opcodes/rx-decode.c

   1 #line 1 "rx-decode.opc"
   2 /* -*- c -*- */
   3 /* Copyright 2012 Free Software Foundation, Inc.
   4    Contributed by Red Hat.
   5    Written by DJ Delorie.
   6
   7    This file is part of the GNU opcodes library.
   8
   9    This library is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3, or (at your option)
  12    any later version.
  13
  14    It is distributed in the hope that it will be useful, but WITHOUT
  15    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  16    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  17    License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  22    MA 02110-1301, USA.  */
  23
  24 #include "sysdep.h"
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include "ansidecl.h"
  29 #include "opcode/rx.h"
  30
  31 #define RX_OPCODE_BIG_ENDIAN 0
  32
  33 typedef struct
  34 {
  35   RX_Opcode_Decoded * rx;
  36   int (* getbyte)(void *);
  37   void * ptr;
  38   unsigned char * op;
  39 } LocalData;
  40
  41 static int trace = 0;
  42
  43 #define BSIZE 0
  44 #define WSIZE 1
  45 #define LSIZE 2
  46
  47 /* These are for when the upper bits are "don't care" or "undefined".  */
  48 static int bwl[] =
  49 {
  50   RX_Byte,
  51   RX_Word,
  52   RX_Long
  53 };
  54
  55 static int sbwl[] =
  56 {
  57   RX_SByte,
  58   RX_SWord,
  59   RX_Long
  60 };
  61
  62 static int ubwl[] =
  63 {
  64   RX_UByte,
  65   RX_UWord,
  66   RX_Long
  67 };
  68
  69 static int memex[] =
  70 {
  71   RX_SByte,
  72   RX_SWord,
  73   RX_Long,
  74   RX_UWord
  75 };
  76
  77 #define ID(x) rx->id = RXO_##x
  78 #define OP(n,t,r,a) (rx->op[n].type = t, \
  79                      rx->op[n].reg = r,      \
  80                      rx->op[n].addend = a )
  81 #define OPs(n,t,r,a,s) (OP (n,t,r,a), \
  82                         rx->op[n].size = s )
  83
  84 /* This is for the BWL and BW bitfields.  */
  85 static int SCALE[] = { 1, 2, 4 };
  86 /* This is for the prefix size enum.  */
  87 static int PSCALE[] = { 4, 1, 1, 1, 2, 2, 2, 3, 4 };
  88
  89 static int flagmap[] = {0, 1, 2, 3, 0, 0, 0, 0,
  90                        16, 17, 0, 0, 0, 0, 0, 0 };
  91
  92 static int dsp3map[] = { 8, 9, 10, 3, 4, 5, 6, 7 };
  93
  94 /*
  95  *C     a constant (immediate) c
  96  *R     A register
  97  *I     Register indirect, no offset
  98  *Is    Register indirect, with offset
  99  *D     standard displacement: type (r,[r],dsp8,dsp16 code), register, BWL code
 100  *P     standard displacement: type (r,[r]), reg, assumes UByte
 101  *Pm    memex displacement: type (r,[r]), reg, memex code
 102  *cc    condition code.  */
 103
 104 #define DC(c)       OP (0, RX_Operand_Immediate, 0, c)
 105 #define DR(r)       OP (0, RX_Operand_Register,  r, 0)
 106 #define DI(r,a)     OP (0, RX_Operand_Indirect,  r, a)
 107 #define DIs(r,a,s)  OP (0, RX_Operand_Indirect,  r, (a) * SCALE[s])
 108 #define DD(t,r,s)   rx_disp (0, t, r, bwl[s], ld);
 109 #define DF(r)       OP (0, RX_Operand_Flag,  flagmap[r], 0)
 110
 111 #define SC(i)       OP (1, RX_Operand_Immediate, 0, i)
 112 #define SR(r)       OP (1, RX_Operand_Register,  r, 0)
 113 #define SRR(r)      OP (1, RX_Operand_TwoReg,  r, 0)
 114 #define SI(r,a)     OP (1, RX_Operand_Indirect,  r, a)
 115 #define SIs(r,a,s)  OP (1, RX_Operand_Indirect,  r, (a) * SCALE[s])
 116 #define SD(t,r,s)   rx_disp (1, t, r, bwl[s], ld);
 117 #define SP(t,r)     rx_disp (1, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 1);
 118 #define SPm(t,r,m)  rx_disp (1, t, r, memex[m], ld); rx->op[1].size = memex[m];
 119 #define Scc(cc)     OP (1, RX_Operand_Condition,  cc, 0)
 120
 121 #define S2C(i)      OP (2, RX_Operand_Immediate, 0, i)
 122 #define S2R(r)      OP (2, RX_Operand_Register,  r, 0)
 123 #define S2I(r,a)    OP (2, RX_Operand_Indirect,  r, a)
 124 #define S2Is(r,a,s) OP (2, RX_Operand_Indirect,  r, (a) * SCALE[s])
 125 #define S2D(t,r,s)  rx_disp (2, t, r, bwl[s], ld);
 126 #define S2P(t,r)    rx_disp (2, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 2);
 127 #define S2Pm(t,r,m) rx_disp (2, t, r, memex[m], ld); rx->op[2].size = memex[m];
 128 #define S2cc(cc)    OP (2, RX_Operand_Condition,  cc, 0)
 129
 130 #define BWL(sz)     rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = bwl[sz]
 131 #define sBWL(sz)    rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = sbwl[sz]
 132 #define uBWL(sz)    rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = ubwl[sz]
 133 #define P(t, n)     rx->op[n].size = (t!=3) ? RX_UByte : RX_Long;
 134
 135 #define F(f) store_flags(rx, f)
 136
 137 #define AU ATTRIBUTE_UNUSED
 138 #define GETBYTE() (ld->op [ld->rx->n_bytes++] = ld->getbyte (ld->ptr))
 139
 140 #define SYNTAX(x) rx->syntax = x
 141
 142 #define UNSUPPORTED() \
 143   rx->syntax = "*unknown*"
 144
 145 #define IMM(sf)   immediate (sf, 0, ld)
 146 #define IMMex(sf) immediate (sf, 1, ld)
 147
 148 static int
 149 immediate (int sfield, int ex, LocalData * ld)
 150 {
 151   unsigned long i = 0, j;
 152
 153   switch (sfield)
 154     {
 155 #define B ((unsigned long) GETBYTE())
 156     case 0:
 157 #if RX_OPCODE_BIG_ENDIAN
 158       i  = B;
 159       if (ex && (i & 0x80))
 160         i -= 0x100;
 161       i <<= 24;
 162       i |= B << 16;
 163       i |= B << 8;
 164       i |= B;
 165 #else
 166       i = B;
 167       i |= B << 8;
 168       i |= B << 16;
 169       j = B;
 170       if (ex && (j & 0x80))
 171         j -= 0x100;
 172       i |= j << 24;
 173 #endif
 174       break;
 175     case 3:
 176 #if RX_OPCODE_BIG_ENDIAN
 177       i  = B << 16;
 178       i |= B << 8;
 179       i |= B;
 180 #else
 181       i  = B;
 182       i |= B << 8;
 183       i |= B << 16;
 184 #endif
 185       if (ex && (i & 0x800000))
 186         i -= 0x1000000;
 187       break;
 188     case 2:
 189 #if RX_OPCODE_BIG_ENDIAN
 190       i |= B << 8;
 191       i |= B;
 192 #else
 193       i |= B;
 194       i |= B << 8;
 195 #endif
 196       if (ex && (i & 0x8000))
 197         i -= 0x10000;
 198       break;
 199     case 1:
 200       i |= B;
 201       if (ex && (i & 0x80))
 202         i -= 0x100;
 203       break;
 204     default:
 205       abort();
 206     }
 207   return i;
 208 }
 209
 210 static void
 211 rx_disp (int n, int type, int reg, int size, LocalData * ld)
 212 {
 213   int disp;
 214
 215   ld->rx->op[n].reg = reg;
 216   switch (type)
 217     {
 218     case 3:
 219       ld->rx->op[n].type = RX_Operand_Register;
 220       break;
 221     case 0:
 222       ld->rx->op[n].type = RX_Operand_Indirect;
 223       ld->rx->op[n].addend = 0;
 224       break;
 225     case 1:
 226       ld->rx->op[n].type = RX_Operand_Indirect;
 227       disp = GETBYTE ();
 228       ld->rx->op[n].addend = disp * PSCALE[size];
 229       break;
 230     case 2:
 231       ld->rx->op[n].type = RX_Operand_Indirect;
 232       disp = GETBYTE ();
 233 #if RX_OPCODE_BIG_ENDIAN
 234       disp = disp * 256 + GETBYTE ();
 235 #else
 236       disp = disp + GETBYTE () * 256;
 237 #endif
 238       ld->rx->op[n].addend = disp * PSCALE[size];
 239       break;
 240     default:
 241       abort ();
 242     }
 243 }
 244
 245 #define xO 8
 246 #define xS 4
 247 #define xZ 2
 248 #define xC 1
 249
 250 #define F_____
 251 #define F___ZC rx->flags_0 = rx->flags_s = xZ|xC;
 252 #define F__SZ_ rx->flags_0 = rx->flags_s = xS|xZ;
 253 #define F__SZC rx->flags_0 = rx->flags_s = xS|xZ|xC;
 254 #define F_0SZC rx->flags_0 = xO|xS|xZ|xC; rx->flags_s = xS|xZ|xC;
 255 #define F_O___ rx->flags_0 = rx->flags_s = xO;
 256 #define F_OS__ rx->flags_0 = rx->flags_s = xO|xS;
 257 #define F_OSZ_ rx->flags_0 = rx->flags_s = xO|xS|xZ;
 258 #define F_OSZC rx->flags_0 = rx->flags_s = xO|xS|xZ|xC;
 259
 260 int
 261 rx_decode_opcode (unsigned long pc AU,
 262                   RX_Opcode_Decoded * rx,
 263                   int (* getbyte)(void *),
 264                   void * ptr)
 265 {
 266   LocalData lds, * ld = &lds;
 267   unsigned char op[20] = {0};
 268
 269   lds.rx = rx;
 270   lds.getbyte = getbyte;
 271   lds.ptr = ptr;
 272   lds.op = op;
 273
 274   memset (rx, 0, sizeof (*rx));
 275   BWL(LSIZE);
 276
 277
 278 /*----------------------------------------------------------------------*/
 279 /* MOV                                                                  */
 280
 281   GETBYTE ();
 282   switch (op[0] & 0xff)
 283   {
 284     case 0x00:
 285         {
 286           /** 0000 0000                 brk */
 287           if (trace)
 288             {
 289               printf ("\033[33m%s\033[0m  %02x\n",
 290                      "/** 0000 0000                     brk */",
 291                      op[0]);
 292             }
 293           SYNTAX("brk");
 294 #line 984 "rx-decode.opc"
 295           ID(brk);
 296
 297         }
 298       break;
 299     case 0x01:
 300         {
 301           /** 0000 0001                 dbt */
 302           if (trace)
 303             {
 304               printf ("\033[33m%s\033[0m  %02x\n",
 305                      "/** 0000 0001                     dbt */",
 306                      op[0]);
 307             }
 308           SYNTAX("dbt");
 309 #line 987 "rx-decode.opc"
 310           ID(dbt);
 311
 312         }
 313       break;
 314     case 0x02:
 315         {
 316           /** 0000 0010                 rts */
 317           if (trace)
 318             {
 319               printf ("\033[33m%s\033[0m  %02x\n",
 320                      "/** 0000 0010                     rts */",
 321                      op[0]);
 322             }
 323           SYNTAX("rts");
 324 #line 765 "rx-decode.opc"
 325           ID(rts);
 326
 327         /*----------------------------------------------------------------------*/
 328         /* NOP                                                          */
 329
 330         }
 331       break;
 332     case 0x03:
 333         {
 334           /** 0000 0011                 nop */
 335           if (trace)
 336             {
 337               printf ("\033[33m%s\033[0m  %02x\n",
 338                      "/** 0000 0011                     nop */",
 339                      op[0]);
 340             }
 341           SYNTAX("nop");
 342 #line 771 "rx-decode.opc"
 343           ID(nop);
 344
 345         /*----------------------------------------------------------------------*/
 346         /* STRING FUNCTIONS                                                     */
 347
 348         }
 349       break;
 350     case 0x04:
 351         {
 352           /** 0000 0100                 bra.a   %a0 */
 353           if (trace)
 354             {
 355               printf ("\033[33m%s\033[0m  %02x\n",
 356                      "/** 0000 0100                     bra.a   %a0 */",
 357                      op[0]);
 358             }
 359           SYNTAX("bra.a %a0");
 360 #line 743 "rx-decode.opc"
 361           ID(branch); DC(pc + IMMex(3));
 362
 363         }
 364       break;
 365     case 0x05:
 366         {
 367           /** 0000 0101                 bsr.a   %a0 */
 368           if (trace)
 369             {
 370               printf ("\033[33m%s\033[0m  %02x\n",
 371                      "/** 0000 0101                     bsr.a   %a0 */",
 372                      op[0]);
 373             }
 374           SYNTAX("bsr.a %a0");
 375 #line 759 "rx-decode.opc"
 376           ID(jsr); DC(pc + IMMex(3));
 377
 378         }
 379       break;
 380     case 0x06:
 381         GETBYTE ();
 382         switch (op[1] & 0xff)
 383         {
 384           case 0x00:
 385               GETBYTE ();
 386               switch (op[2] & 0x00)
 387               {
 388                 case 0x00:
 389                   op_semantics_1:
 390                     {
 391                       /** 0000 0110 mx00 00ss rsrc rdst                 sub     %2%S2, %1 */
 392 #line 539 "rx-decode.opc"
 393                       int mx AU = (op[1] >> 6) & 0x03;
 394 #line 539 "rx-decode.opc"
 395                       int ss AU = op[1] & 0x03;
 396 #line 539 "rx-decode.opc"
 397                       int rsrc AU = (op[2] >> 4) & 0x0f;
 398 #line 539 "rx-decode.opc"
 399                       int rdst AU = op[2] & 0x0f;
 400                       if (trace)
 401                         {
 402                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
 403                                  "/** 0000 0110 mx00 00ss rsrc rdst                     sub     %2%S2, %1 */",
 404                                  op[0], op[1], op[2]);
 405                           printf ("  mx = 0x%x,", mx);
 406                           printf ("  ss = 0x%x,", ss);
 407                           printf ("  rsrc = 0x%x,", rsrc);
 408                           printf ("  rdst = 0x%x\n", rdst);
 409                         }
 410                       SYNTAX("sub       %2%S2, %1");
 411 #line 539 "rx-decode.opc"
 412                       ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); DR(rdst); F_OSZC;
 413
 414                     }
 415                   break;
 416               }
 417             break;
 418           case 0x01:
 419               GETBYTE ();
 420               switch (op[2] & 0x00)
 421               {
 422                 case 0x00:
 423                   goto op_semantics_1;
 424                   break;
 425               }
 426             break;
 427           case 0x02:
 428               GETBYTE ();
 429               switch (op[2] & 0x00)
 430               {
 431                 case 0x00:
 432                   goto op_semantics_1;
 433                   break;
 434               }
 435             break;
 436           case 0x03:
 437               GETBYTE ();
 438               switch (op[2] & 0x00)
 439               {
 440                 case 0x00:
 441                   goto op_semantics_1;
 442                   break;
 443               }
 444             break;
 445           case 0x04:
 446               GETBYTE ();
 447               switch (op[2] & 0x00)
 448               {
 449                 case 0x00:
 450                   op_semantics_2:
 451                     {
 452                       /** 0000 0110 mx00 01ss rsrc rdst         cmp     %2%S2, %1 */
 453 #line 527 "rx-decode.opc"
 454                       int mx AU = (op[1] >> 6) & 0x03;
 455 #line 527 "rx-decode.opc"
 456                       int ss AU = op[1] & 0x03;
 457 #line 527 "rx-decode.opc"
 458                       int rsrc AU = (op[2] >> 4) & 0x0f;
 459 #line 527 "rx-decode.opc"
 460                       int rdst AU = op[2] & 0x0f;
 461                       if (trace)
 462                         {
 463                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
 464                                  "/** 0000 0110 mx00 01ss rsrc rdst             cmp     %2%S2, %1 */",
 465                                  op[0], op[1], op[2]);
 466                           printf ("  mx = 0x%x,", mx);
 467                           printf ("  ss = 0x%x,", ss);
 468                           printf ("  rsrc = 0x%x,", rsrc);
 469                           printf ("  rdst = 0x%x\n", rdst);
 470                         }
 471                       SYNTAX("cmp       %2%S2, %1");
 472 #line 527 "rx-decode.opc"
 473                       ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); F_OSZC;
 474
 475                     /*----------------------------------------------------------------------*/
 476                     /* SUB                                                                      */
 477
 478                     }
 479                   break;
 480               }
 481             break;
 482           case 0x05:
 483               GETBYTE ();
 484               switch (op[2] & 0x00)
 485               {
 486                 case 0x00:
 487                   goto op_semantics_2;
 488                   break;
 489               }
 490             break;
 491           case 0x06:
 492               GETBYTE ();
 493               switch (op[2] & 0x00)
 494               {
 495                 case 0x00:
 496                   goto op_semantics_2;
 497                   break;
 498               }
 499             break;
 500           case 0x07:
 501               GETBYTE ();
 502               switch (op[2] & 0x00)
 503               {
 504                 case 0x00:
 505                   goto op_semantics_2;
 506                   break;
 507               }
 508             break;
 509           case 0x08:
 510               GETBYTE ();
 511               switch (op[2] & 0x00)
 512               {
 513                 case 0x00:
 514                   op_semantics_3:
 515                     {
 516                       /** 0000 0110 mx00 10ss rsrc rdst add     %1%S1, %0 */
 517 #line 503 "rx-decode.opc"
 518                       int mx AU = (op[1] >> 6) & 0x03;
 519 #line 503 "rx-decode.opc"
 520                       int ss AU = op[1] & 0x03;
 521 #line 503 "rx-decode.opc"
 522                       int rsrc AU = (op[2] >> 4) & 0x0f;
 523 #line 503 "rx-decode.opc"
 524                       int rdst AU = op[2] & 0x0f;
 525                       if (trace)
 526                         {
 527                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
 528                                  "/** 0000 0110 mx00 10ss rsrc rdst     add     %1%S1, %0 */",
 529                                  op[0], op[1], op[2]);
 530                           printf ("  mx = 0x%x,", mx);
 531                           printf ("  ss = 0x%x,", ss);
 532                           printf ("  rsrc = 0x%x,", rsrc);
 533                           printf ("  rdst = 0x%x\n", rdst);
 534                         }
 535                       SYNTAX("add       %1%S1, %0");
 536 #line 503 "rx-decode.opc"
 537                       ID(add); SPm(ss, rsrc, mx); DR(rdst); F_OSZC;
 538
 539                     }
 540                   break;
 541               }
 542             break;
 543           case 0x09:
 544               GETBYTE ();
 545               switch (op[2] & 0x00)
 546               {
 547                 case 0x00:
 548                   goto op_semantics_3;
 549                   break;
 550               }
 551             break;
 552           case 0x0a:
 553               GETBYTE ();
 554               switch (op[2] & 0x00)
 555               {
 556                 case 0x00:
 557                   goto op_semantics_3;
 558                   break;
 559               }
 560             break;
 561           case 0x0b:
 562               GETBYTE ();
 563               switch (op[2] & 0x00)
 564               {
 565                 case 0x00:
 566                   goto op_semantics_3;
 567                   break;
 568               }
 569             break;
 570           case 0x0c:
 571               GETBYTE ();
 572               switch (op[2] & 0x00)
 573               {
 574                 case 0x00:
 575                   op_semantics_4:
 576                     {
 577                       /** 0000 0110 mx00 11ss rsrc rdst mul     %1%S1, %0 */
 578 #line 608 "rx-decode.opc"
 579                       int mx AU = (op[1] >> 6) & 0x03;
 580 #line 608 "rx-decode.opc"
 581                       int ss AU = op[1] & 0x03;
 582 #line 608 "rx-decode.opc"
 583                       int rsrc AU = (op[2] >> 4) & 0x0f;
 584 #line 608 "rx-decode.opc"
 585                       int rdst AU = op[2] & 0x0f;
 586                       if (trace)
 587                         {
 588                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
 589                                  "/** 0000 0110 mx00 11ss rsrc rdst     mul     %1%S1, %0 */",
 590                                  op[0], op[1], op[2]);
 591                           printf ("  mx = 0x%x,", mx);
 592                           printf ("  ss = 0x%x,", ss);
 593                           printf ("  rsrc = 0x%x,", rsrc);
 594                           printf ("  rdst = 0x%x\n", rdst);
 595                         }
 596                       SYNTAX("mul       %1%S1, %0");
 597 #line 608 "rx-decode.opc"
 598                       ID(mul); SPm(ss, rsrc, mx); DR(rdst); F_____;
 599
 600                     }
 601                   break;
 602               }
 603             break;
 604           case 0x0d:
 605               GETBYTE ();
 606               switch (op[2] & 0x00)
 607               {
 608                 case 0x00:
 609                   goto op_semantics_4;
 610                   break;
 611               }
 612             break;
 613           case 0x0e:
 614               GETBYTE ();
 615               switch (op[2] & 0x00)
 616               {
 617                 case 0x00:
 618                   goto op_semantics_4;
 619                   break;
 620               }
 621             break;
 622           case 0x0f:
 623               GETBYTE ();
 624               switch (op[2] & 0x00)
 625               {
 626                 case 0x00:
 627                   goto op_semantics_4;
 628                   break;
 629               }
 630             break;
 631           case 0x10:
 632               GETBYTE ();
 633               switch (op[2] & 0x00)
 634               {
 635                 case 0x00:
 636                   op_semantics_5:
 637                     {
 638                       /** 0000 0110 mx01 00ss rsrc rdst and     %1%S1, %0 */
 639 #line 416 "rx-decode.opc"
 640                       int mx AU = (op[1] >> 6) & 0x03;
 641 #line 416 "rx-decode.opc"
 642                       int ss AU = op[1] & 0x03;
 643 #line 416 "rx-decode.opc"
 644                       int rsrc AU = (op[2] >> 4) & 0x0f;
 645 #line 416 "rx-decode.opc"
 646                       int rdst AU = op[2] & 0x0f;
 647                       if (trace)
 648                         {
 649                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
 650                                  "/** 0000 0110 mx01 00ss rsrc rdst     and     %1%S1, %0 */",
 651                                  op[0], op[1], op[2]);
 652                           printf ("  mx = 0x%x,", mx);
 653                           printf ("  ss = 0x%x,", ss);
 654                           printf ("  rsrc = 0x%x,", rsrc);
 655                           printf ("  rdst = 0x%x\n", rdst);
 656                         }
 657                       SYNTAX("and       %1%S1, %0");
 658 #line 416 "rx-decode.opc"
 659                       ID(and); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
 660
 661                     }
 662                   break;
 663               }
 664             break;
 665           case 0x11:
 666               GETBYTE ();
 667               switch (op[2] & 0x00)
 668               {
 669                 case 0x00:
 670                   goto op_semantics_5;
 671                   break;
 672               }
 673             break;
 674           case 0x12:
 675               GETBYTE ();
 676               switch (op[2] & 0x00)
 677               {
 678                 case 0x00:
 679                   goto op_semantics_5;
 680                   break;
 681               }
 682             break;
 683           case 0x13:
 684               GETBYTE ();
 685               switch (op[2] & 0x00)
 686               {
 687                 case 0x00:
 688                   goto op_semantics_5;
 689                   break;
 690               }
 691             break;
 692           case 0x14:
 693               GETBYTE ();
 694               switch (op[2] & 0x00)
 695               {
 696                 case 0x00:
 697                   op_semantics_6:
 698                     {
 699                       /** 0000 0110 mx01 01ss rsrc rdst                 or      %1%S1, %0 */
 700 #line 434 "rx-decode.opc"
 701                       int mx AU = (op[1] >> 6) & 0x03;
 702 #line 434 "rx-decode.opc"
 703                       int ss AU = op[1] & 0x03;
 704 #line 434 "rx-decode.opc"
 705                       int rsrc AU = (op[2] >> 4) & 0x0f;
 706 #line 434 "rx-decode.opc"
 707                       int rdst AU = op[2] & 0x0f;
 708                       if (trace)
 709                         {
 710                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
 711                                  "/** 0000 0110 mx01 01ss rsrc rdst                     or      %1%S1, %0 */",
 712                                  op[0], op[1], op[2]);
 713                           printf ("  mx = 0x%x,", mx);
 714                           printf ("  ss = 0x%x,", ss);
 715                           printf ("  rsrc = 0x%x,", rsrc);
 716                           printf ("  rdst = 0x%x\n", rdst);
 717                         }
 718                       SYNTAX("or        %1%S1, %0");
 719 #line 434 "rx-decode.opc"
 720                       ID(or); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
 721
 722                     }
 723                   break;
 724               }
 725             break;
 726           case 0x15:
 727               GETBYTE ();
 728               switch (op[2] & 0x00)
 729               {
 730                 case 0x00:
 731                   goto op_semantics_6;
 732                   break;
 733               }
 734             break;
 735           case 0x16:
 736               GETBYTE ();
 737               switch (op[2] & 0x00)
 738               {
 739                 case 0x00:
 740                   goto op_semantics_6;
 741                   break;
 742               }
 743             break;
 744           case 0x17:
 745               GETBYTE ();
 746               switch (op[2] & 0x00)
 747               {
 748                 case 0x00:
 749                   goto op_semantics_6;
 750                   break;
 751               }
 752             break;
 753           case 0x20:
 754               GETBYTE ();
 755               switch (op[2] & 0xff)
 756               {
 757                 case 0x00:
 758                     GETBYTE ();
 759                     switch (op[3] & 0x00)
 760                     {
 761                       case 0x00:
 762                         op_semantics_7:
 763                           {
 764                             /** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb     %1%S1, %0 */
 765 #line 552 "rx-decode.opc"
 766                             int mx AU = (op[1] >> 6) & 0x03;
 767 #line 552 "rx-decode.opc"
 768                             int sp AU = op[1] & 0x03;
 769 #line 552 "rx-decode.opc"
 770                             int rsrc AU = (op[3] >> 4) & 0x0f;
 771 #line 552 "rx-decode.opc"
 772                             int rdst AU = op[3] & 0x0f;
 773                             if (trace)
 774                               {
 775                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
 776                                        "/** 0000 0110 mx10 00sp 0000 0000 rsrc rdst     sbb     %1%S1, %0 */",
 777                                        op[0], op[1], op[2], op[3]);
 778                                 printf ("  mx = 0x%x,", mx);
 779                                 printf ("  sp = 0x%x,", sp);
 780                                 printf ("  rsrc = 0x%x,", rsrc);
 781                                 printf ("  rdst = 0x%x\n", rdst);
 782                               }
 783                             SYNTAX("sbb %1%S1, %0");
 784 #line 552 "rx-decode.opc"
 785                             ID(sbb); SPm(sp, rsrc, mx); DR(rdst); F_OSZC;
 786
 787                           /*----------------------------------------------------------------------*/
 788                           /* ABS                                                                        */
 789
 790                           }
 791                         break;
 792                     }
 793                   break;
 794                 case 0x04:
 795                     GETBYTE ();
 796                     switch (op[3] & 0x00)
 797                     {
 798                       case 0x00:
 799                         op_semantics_8:
 800                           {
 801                             /** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max     %1%S1, %0 */
 802 #line 581 "rx-decode.opc"
 803                             int mx AU = (op[1] >> 6) & 0x03;
 804 #line 581 "rx-decode.opc"
 805                             int ss AU = op[1] & 0x03;
 806 #line 581 "rx-decode.opc"
 807                             int rsrc AU = (op[3] >> 4) & 0x0f;
 808 #line 581 "rx-decode.opc"
 809                             int rdst AU = op[3] & 0x0f;
 810                             if (trace)
 811                               {
 812                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
 813                                        "/** 0000 0110 mx10 00ss 0000 0100 rsrc rdst     max     %1%S1, %0 */",
 814                                        op[0], op[1], op[2], op[3]);
 815                                 printf ("  mx = 0x%x,", mx);
 816                                 printf ("  ss = 0x%x,", ss);
 817                                 printf ("  rsrc = 0x%x,", rsrc);
 818                                 printf ("  rdst = 0x%x\n", rdst);
 819                               }
 820                             SYNTAX("max %1%S1, %0");
 821 #line 581 "rx-decode.opc"
 822                             ID(max); SPm(ss, rsrc, mx); DR(rdst);
 823
 824                           /*----------------------------------------------------------------------*/
 825                           /* MIN                                                                        */
 826
 827                           }
 828                         break;
 829                     }
 830                   break;
 831                 case 0x05:
 832                     GETBYTE ();
 833                     switch (op[3] & 0x00)
 834                     {
 835                       case 0x00:
 836                         op_semantics_9:
 837                           {
 838                             /** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min     %1%S1, %0 */
 839 #line 593 "rx-decode.opc"
 840                             int mx AU = (op[1] >> 6) & 0x03;
 841 #line 593 "rx-decode.opc"
 842                             int ss AU = op[1] & 0x03;
 843 #line 593 "rx-decode.opc"
 844                             int rsrc AU = (op[3] >> 4) & 0x0f;
 845 #line 593 "rx-decode.opc"
 846                             int rdst AU = op[3] & 0x0f;
 847                             if (trace)
 848                               {
 849                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
 850                                        "/** 0000 0110 mx10 00ss 0000 0101 rsrc rdst     min     %1%S1, %0 */",
 851                                        op[0], op[1], op[2], op[3]);
 852                                 printf ("  mx = 0x%x,", mx);
 853                                 printf ("  ss = 0x%x,", ss);
 854                                 printf ("  rsrc = 0x%x,", rsrc);
 855                                 printf ("  rdst = 0x%x\n", rdst);
 856                               }
 857                             SYNTAX("min %1%S1, %0");
 858 #line 593 "rx-decode.opc"
 859                             ID(min); SPm(ss, rsrc, mx); DR(rdst);
 860
 861                           /*----------------------------------------------------------------------*/
 862                           /* MUL                                                                        */
 863
 864                           }
 865                         break;
 866                     }
 867                   break;
 868                 case 0x06:
 869                     GETBYTE ();
 870                     switch (op[3] & 0x00)
 871                     {
 872                       case 0x00:
 873                         op_semantics_10:
 874                           {
 875                             /** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul    %1%S1, %0 */
 876 #line 623 "rx-decode.opc"
 877                             int mx AU = (op[1] >> 6) & 0x03;
 878 #line 623 "rx-decode.opc"
 879                             int ss AU = op[1] & 0x03;
 880 #line 623 "rx-decode.opc"
 881                             int rsrc AU = (op[3] >> 4) & 0x0f;
 882 #line 623 "rx-decode.opc"
 883                             int rdst AU = op[3] & 0x0f;
 884                             if (trace)
 885                               {
 886                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
 887                                        "/** 0000 0110 mx10 00ss 0000 0110 rsrc rdst     emul    %1%S1, %0 */",
 888                                        op[0], op[1], op[2], op[3]);
 889                                 printf ("  mx = 0x%x,", mx);
 890                                 printf ("  ss = 0x%x,", ss);
 891                                 printf ("  rsrc = 0x%x,", rsrc);
 892                                 printf ("  rdst = 0x%x\n", rdst);
 893                               }
 894                             SYNTAX("emul        %1%S1, %0");
 895 #line 623 "rx-decode.opc"
 896                             ID(emul); SPm(ss, rsrc, mx); DR(rdst);
 897
 898                           /*----------------------------------------------------------------------*/
 899                           /* EMULU                                                                      */
 900
 901                           }
 902                         break;
 903                     }
 904                   break;
 905                 case 0x07:
 906                     GETBYTE ();
 907                     switch (op[3] & 0x00)
 908                     {
 909                       case 0x00:
 910                         op_semantics_11:
 911                           {
 912                             /** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu   %1%S1, %0 */
 913 #line 635 "rx-decode.opc"
 914                             int mx AU = (op[1] >> 6) & 0x03;
 915 #line 635 "rx-decode.opc"
 916                             int ss AU = op[1] & 0x03;
 917 #line 635 "rx-decode.opc"
 918                             int rsrc AU = (op[3] >> 4) & 0x0f;
 919 #line 635 "rx-decode.opc"
 920                             int rdst AU = op[3] & 0x0f;
 921                             if (trace)
 922                               {
 923                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
 924                                        "/** 0000 0110 mx10 00ss 0000 0111 rsrc rdst     emulu   %1%S1, %0 */",
 925                                        op[0], op[1], op[2], op[3]);
 926                                 printf ("  mx = 0x%x,", mx);
 927                                 printf ("  ss = 0x%x,", ss);
 928                                 printf ("  rsrc = 0x%x,", rsrc);
 929                                 printf ("  rdst = 0x%x\n", rdst);
 930                               }
 931                             SYNTAX("emulu       %1%S1, %0");
 932 #line 635 "rx-decode.opc"
 933                             ID(emulu); SPm(ss, rsrc, mx); DR(rdst);
 934
 935                           /*----------------------------------------------------------------------*/
 936                           /* DIV                                                                        */
 937
 938                           }
 939                         break;
 940                     }
 941                   break;
 942                 case 0x08:
 943                     GETBYTE ();
 944                     switch (op[3] & 0x00)
 945                     {
 946                       case 0x00:
 947                         op_semantics_12:
 948                           {
 949                             /** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div     %1%S1, %0 */
 950 #line 647 "rx-decode.opc"
 951                             int mx AU = (op[1] >> 6) & 0x03;
 952 #line 647 "rx-decode.opc"
 953                             int ss AU = op[1] & 0x03;
 954 #line 647 "rx-decode.opc"
 955                             int rsrc AU = (op[3] >> 4) & 0x0f;
 956 #line 647 "rx-decode.opc"
 957                             int rdst AU = op[3] & 0x0f;
 958                             if (trace)
 959                               {
 960                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
 961                                        "/** 0000 0110 mx10 00ss 0000 1000 rsrc rdst     div     %1%S1, %0 */",
 962                                        op[0], op[1], op[2], op[3]);
 963                                 printf ("  mx = 0x%x,", mx);
 964                                 printf ("  ss = 0x%x,", ss);
 965                                 printf ("  rsrc = 0x%x,", rsrc);
 966                                 printf ("  rdst = 0x%x\n", rdst);
 967                               }
 968                             SYNTAX("div %1%S1, %0");
 969 #line 647 "rx-decode.opc"
 970                             ID(div); SPm(ss, rsrc, mx); DR(rdst); F_O___;
 971
 972                           /*----------------------------------------------------------------------*/
 973                           /* DIVU                                                                       */
 974
 975                           }
 976                         break;
 977                     }
 978                   break;
 979                 case 0x09:
 980                     GETBYTE ();
 981                     switch (op[3] & 0x00)
 982                     {
 983                       case 0x00:
 984                         op_semantics_13:
 985                           {
 986                             /** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu    %1%S1, %0 */
 987 #line 659 "rx-decode.opc"
 988                             int mx AU = (op[1] >> 6) & 0x03;
 989 #line 659 "rx-decode.opc"
 990                             int ss AU = op[1] & 0x03;
 991 #line 659 "rx-decode.opc"
 992                             int rsrc AU = (op[3] >> 4) & 0x0f;
 993 #line 659 "rx-decode.opc"
 994                             int rdst AU = op[3] & 0x0f;
 995                             if (trace)
 996                               {
 997                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
 998                                        "/** 0000 0110 mx10 00ss 0000 1001 rsrc rdst     divu    %1%S1, %0 */",
 999                                        op[0], op[1], op[2], op[3]);
1000                                 printf ("  mx = 0x%x,", mx);
1001                                 printf ("  ss = 0x%x,", ss);
1002                                 printf ("  rsrc = 0x%x,", rsrc);
1003                                 printf ("  rdst = 0x%x\n", rdst);
1004                               }
1005                             SYNTAX("divu        %1%S1, %0");
1006 #line 659 "rx-decode.opc"
1007                             ID(divu); SPm(ss, rsrc, mx); DR(rdst); F_O___;
1008
1009                           /*----------------------------------------------------------------------*/
1010                           /* SHIFT                                                              */
1011
1012                           }
1013                         break;
1014                     }
1015                   break;
1016                 case 0x0c:
1017                     GETBYTE ();
1018                     switch (op[3] & 0x00)
1019                     {
1020                       case 0x00:
1021                         op_semantics_14:
1022                           {
1023                             /** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst     %1%S1, %2 */
1024 #line 470 "rx-decode.opc"
1025                             int mx AU = (op[1] >> 6) & 0x03;
1026 #line 470 "rx-decode.opc"
1027                             int ss AU = op[1] & 0x03;
1028 #line 470 "rx-decode.opc"
1029                             int rsrc AU = (op[3] >> 4) & 0x0f;
1030 #line 470 "rx-decode.opc"
1031                             int rdst AU = op[3] & 0x0f;
1032                             if (trace)
1033                               {
1034                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1035                                        "/** 0000 0110 mx10 00ss 0000 1100 rsrc rdst     tst     %1%S1, %2 */",
1036                                        op[0], op[1], op[2], op[3]);
1037                                 printf ("  mx = 0x%x,", mx);
1038                                 printf ("  ss = 0x%x,", ss);
1039                                 printf ("  rsrc = 0x%x,", rsrc);
1040                                 printf ("  rdst = 0x%x\n", rdst);
1041                               }
1042                             SYNTAX("tst %1%S1, %2");
1043 #line 470 "rx-decode.opc"
1044                             ID(and); SPm(ss, rsrc, mx); S2R(rdst); F__SZ_;
1045
1046                           /*----------------------------------------------------------------------*/
1047                           /* NEG                                                                        */
1048
1049                           }
1050                         break;
1051                     }
1052                   break;
1053                 case 0x0d:
1054                     GETBYTE ();
1055                     switch (op[3] & 0x00)
1056                     {
1057                       case 0x00:
1058                         op_semantics_15:
1059                           {
1060                             /** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor     %1%S1, %0 */
1061 #line 449 "rx-decode.opc"
1062                             int mx AU = (op[1] >> 6) & 0x03;
1063 #line 449 "rx-decode.opc"
1064                             int ss AU = op[1] & 0x03;
1065 #line 449 "rx-decode.opc"
1066                             int rsrc AU = (op[3] >> 4) & 0x0f;
1067 #line 449 "rx-decode.opc"
1068                             int rdst AU = op[3] & 0x0f;
1069                             if (trace)
1070                               {
1071                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1072                                        "/** 0000 0110 mx10 00ss 0000 1101 rsrc rdst     xor     %1%S1, %0 */",
1073                                        op[0], op[1], op[2], op[3]);
1074                                 printf ("  mx = 0x%x,", mx);
1075                                 printf ("  ss = 0x%x,", ss);
1076                                 printf ("  rsrc = 0x%x,", rsrc);
1077                                 printf ("  rdst = 0x%x\n", rdst);
1078                               }
1079                             SYNTAX("xor %1%S1, %0");
1080 #line 449 "rx-decode.opc"
1081                             ID(xor); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
1082
1083                           /*----------------------------------------------------------------------*/
1084                           /* NOT                                                                        */
1085
1086                           }
1087                         break;
1088                     }
1089                   break;
1090                 case 0x10:
1091                     GETBYTE ();
1092                     switch (op[3] & 0x00)
1093                     {
1094                       case 0x00:
1095                         op_semantics_16:
1096                           {
1097                             /** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg    %1%S1, %0 */
1098 #line 383 "rx-decode.opc"
1099                             int mx AU = (op[1] >> 6) & 0x03;
1100 #line 383 "rx-decode.opc"
1101                             int ss AU = op[1] & 0x03;
1102 #line 383 "rx-decode.opc"
1103                             int rsrc AU = (op[3] >> 4) & 0x0f;
1104 #line 383 "rx-decode.opc"
1105                             int rdst AU = op[3] & 0x0f;
1106                             if (trace)
1107                               {
1108                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1109                                        "/** 0000 0110 mx10 00ss 0001 0000 rsrc rdst     xchg    %1%S1, %0 */",
1110                                        op[0], op[1], op[2], op[3]);
1111                                 printf ("  mx = 0x%x,", mx);
1112                                 printf ("  ss = 0x%x,", ss);
1113                                 printf ("  rsrc = 0x%x,", rsrc);
1114                                 printf ("  rdst = 0x%x\n", rdst);
1115                               }
1116                             SYNTAX("xchg        %1%S1, %0");
1117 #line 383 "rx-decode.opc"
1118                             ID(xchg); DR(rdst); SPm(ss, rsrc, mx);
1119
1120                           /*----------------------------------------------------------------------*/
1121                           /* STZ/STNZ                                                           */
1122
1123                           }
1124                         break;
1125                     }
1126                   break;
1127                 case 0x11:
1128                     GETBYTE ();
1129                     switch (op[3] & 0x00)
1130                     {
1131                       case 0x00:
1132                         op_semantics_17:
1133                           {
1134                             /** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof    %1%S1, %0 */
1135 #line 888 "rx-decode.opc"
1136                             int mx AU = (op[1] >> 6) & 0x03;
1137 #line 888 "rx-decode.opc"
1138                             int sd AU = op[1] & 0x03;
1139 #line 888 "rx-decode.opc"
1140                             int rsrc AU = (op[3] >> 4) & 0x0f;
1141 #line 888 "rx-decode.opc"
1142                             int rdst AU = op[3] & 0x0f;
1143                             if (trace)
1144                               {
1145                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1146                                        "/** 0000 0110 mx10 00sd 0001 0001 rsrc rdst     itof    %1%S1, %0 */",
1147                                        op[0], op[1], op[2], op[3]);
1148                                 printf ("  mx = 0x%x,", mx);
1149                                 printf ("  sd = 0x%x,", sd);
1150                                 printf ("  rsrc = 0x%x,", rsrc);
1151                                 printf ("  rdst = 0x%x\n", rdst);
1152                               }
1153                             SYNTAX("itof        %1%S1, %0");
1154 #line 888 "rx-decode.opc"
1155                             ID(itof); DR (rdst); SPm(sd, rsrc, mx); F__SZ_;
1156
1157                           /*----------------------------------------------------------------------*/
1158                           /* BIT OPS                                                            */
1159
1160                           }
1161                         break;
1162                     }
1163                   break;
1164                 default: UNSUPPORTED(); break;
1165               }
1166             break;
1167           case 0x21:
1168               GETBYTE ();
1169               switch (op[2] & 0xff)
1170               {
1171                 case 0x00:
1172                     GETBYTE ();
1173                     switch (op[3] & 0x00)
1174                     {
1175                       case 0x00:
1176                         goto op_semantics_7;
1177                         break;
1178                     }
1179                   break;
1180                 case 0x04:
1181                     GETBYTE ();
1182                     switch (op[3] & 0x00)
1183                     {
1184                       case 0x00:
1185                         goto op_semantics_8;
1186                         break;
1187                     }
1188                   break;
1189                 case 0x05:
1190                     GETBYTE ();
1191                     switch (op[3] & 0x00)
1192                     {
1193                       case 0x00:
1194                         goto op_semantics_9;
1195                         break;
1196                     }
1197                   break;
1198                 case 0x06:
1199                     GETBYTE ();
1200                     switch (op[3] & 0x00)
1201                     {
1202                       case 0x00:
1203                         goto op_semantics_10;
1204                         break;
1205                     }
1206                   break;
1207                 case 0x07:
1208                     GETBYTE ();
1209                     switch (op[3] & 0x00)
1210                     {
1211                       case 0x00:
1212                         goto op_semantics_11;
1213                         break;
1214                     }
1215                   break;
1216                 case 0x08:
1217                     GETBYTE ();
1218                     switch (op[3] & 0x00)
1219                     {
1220                       case 0x00:
1221                         goto op_semantics_12;
1222                         break;
1223                     }
1224                   break;
1225                 case 0x09:
1226                     GETBYTE ();
1227                     switch (op[3] & 0x00)
1228                     {
1229                       case 0x00:
1230                         goto op_semantics_13;
1231                         break;
1232                     }
1233                   break;
1234                 case 0x0c:
1235                     GETBYTE ();
1236                     switch (op[3] & 0x00)
1237                     {
1238                       case 0x00:
1239                         goto op_semantics_14;
1240                         break;
1241                     }
1242                   break;
1243                 case 0x0d:
1244                     GETBYTE ();
1245                     switch (op[3] & 0x00)
1246                     {
1247                       case 0x00:
1248                         goto op_semantics_15;
1249                         break;
1250                     }
1251                   break;
1252                 case 0x10:
1253                     GETBYTE ();
1254                     switch (op[3] & 0x00)
1255                     {
1256                       case 0x00:
1257                         goto op_semantics_16;
1258                         break;
1259                     }
1260                   break;
1261                 case 0x11:
1262                     GETBYTE ();
1263                     switch (op[3] & 0x00)
1264                     {
1265                       case 0x00:
1266                         goto op_semantics_17;
1267                         break;
1268                     }
1269                   break;
1270                 default: UNSUPPORTED(); break;
1271               }
1272             break;
1273           case 0x22:
1274               GETBYTE ();
1275               switch (op[2] & 0xff)
1276               {
1277                 case 0x00:
1278                     GETBYTE ();
1279                     switch (op[3] & 0x00)
1280                     {
1281                       case 0x00:
1282                         goto op_semantics_7;
1283                         break;
1284                     }
1285                   break;
1286                 case 0x04:
1287                     GETBYTE ();
1288                     switch (op[3] & 0x00)
1289                     {
1290                       case 0x00:
1291                         goto op_semantics_8;
1292                         break;
1293                     }
1294                   break;
1295                 case 0x05:
1296                     GETBYTE ();
1297                     switch (op[3] & 0x00)
1298                     {
1299                       case 0x00:
1300                         goto op_semantics_9;
1301                         break;
1302                     }
1303                   break;
1304                 case 0x06:
1305                     GETBYTE ();
1306                     switch (op[3] & 0x00)
1307                     {
1308                       case 0x00:
1309                         goto op_semantics_10;
1310                         break;
1311                     }
1312                   break;
1313                 case 0x07:
1314                     GETBYTE ();
1315                     switch (op[3] & 0x00)
1316                     {
1317                       case 0x00:
1318                         goto op_semantics_11;
1319                         break;
1320                     }
1321                   break;
1322                 case 0x08:
1323                     GETBYTE ();
1324                     switch (op[3] & 0x00)
1325                     {
1326                       case 0x00:
1327                         goto op_semantics_12;
1328                         break;
1329                     }
1330                   break;
1331                 case 0x09:
1332                     GETBYTE ();
1333                     switch (op[3] & 0x00)
1334                     {
1335                       case 0x00:
1336                         goto op_semantics_13;
1337                         break;
1338                     }
1339                   break;
1340                 case 0x0c:
1341                     GETBYTE ();
1342                     switch (op[3] & 0x00)
1343                     {
1344                       case 0x00:
1345                         goto op_semantics_14;
1346                         break;
1347                     }
1348                   break;
1349                 case 0x0d:
1350                     GETBYTE ();
1351                     switch (op[3] & 0x00)
1352                     {
1353                       case 0x00:
1354                         goto op_semantics_15;
1355                         break;
1356                     }
1357                   break;
1358                 case 0x10:
1359                     GETBYTE ();
1360                     switch (op[3] & 0x00)
1361                     {
1362                       case 0x00:
1363                         goto op_semantics_16;
1364                         break;
1365                     }
1366                   break;
1367                 case 0x11:
1368                     GETBYTE ();
1369                     switch (op[3] & 0x00)
1370                     {
1371                       case 0x00:
1372                         goto op_semantics_17;
1373                         break;
1374                     }
1375                   break;
1376                 default: UNSUPPORTED(); break;
1377               }
1378             break;
1379           case 0x23:
1380               GETBYTE ();
1381               switch (op[2] & 0xff)
1382               {
1383                 case 0x00:
1384                     GETBYTE ();
1385                     switch (op[3] & 0x00)
1386                     {
1387                       case 0x00:
1388                         goto op_semantics_7;
1389                         break;
1390                     }
1391                   break;
1392                 case 0x04:
1393                     GETBYTE ();
1394                     switch (op[3] & 0x00)
1395                     {
1396                       case 0x00:
1397                         goto op_semantics_8;
1398                         break;
1399                     }
1400                   break;
1401                 case 0x05:
1402                     GETBYTE ();
1403                     switch (op[3] & 0x00)
1404                     {
1405                       case 0x00:
1406                         goto op_semantics_9;
1407                         break;
1408                     }
1409                   break;
1410                 case 0x06:
1411                     GETBYTE ();
1412                     switch (op[3] & 0x00)
1413                     {
1414                       case 0x00:
1415                         goto op_semantics_10;
1416                         break;
1417                     }
1418                   break;
1419                 case 0x07:
1420                     GETBYTE ();
1421                     switch (op[3] & 0x00)
1422                     {
1423                       case 0x00:
1424                         goto op_semantics_11;
1425                         break;
1426                     }
1427                   break;
1428                 case 0x08:
1429                     GETBYTE ();
1430                     switch (op[3] & 0x00)
1431                     {
1432                       case 0x00:
1433                         goto op_semantics_12;
1434                         break;
1435                     }
1436                   break;
1437                 case 0x09:
1438                     GETBYTE ();
1439                     switch (op[3] & 0x00)
1440                     {
1441                       case 0x00:
1442                         goto op_semantics_13;
1443                         break;
1444                     }
1445                   break;
1446                 case 0x0c:
1447                     GETBYTE ();
1448                     switch (op[3] & 0x00)
1449                     {
1450                       case 0x00:
1451                         goto op_semantics_14;
1452                         break;
1453                     }
1454                   break;
1455                 case 0x0d:
1456                     GETBYTE ();
1457                     switch (op[3] & 0x00)
1458                     {
1459                       case 0x00:
1460                         goto op_semantics_15;
1461                         break;
1462                     }
1463                   break;
1464                 case 0x10:
1465                     GETBYTE ();
1466                     switch (op[3] & 0x00)
1467                     {
1468                       case 0x00:
1469                         goto op_semantics_16;
1470                         break;
1471                     }
1472                   break;
1473                 case 0x11:
1474                     GETBYTE ();
1475                     switch (op[3] & 0x00)
1476                     {
1477                       case 0x00:
1478                         goto op_semantics_17;
1479                         break;
1480                     }
1481                   break;
1482                 default: UNSUPPORTED(); break;
1483               }
1484             break;
1485           case 0x40:
1486               GETBYTE ();
1487               switch (op[2] & 0x00)
1488               {
1489                 case 0x00:
1490                   goto op_semantics_1;
1491                   break;
1492               }
1493             break;
1494           case 0x41:
1495               GETBYTE ();
1496               switch (op[2] & 0x00)
1497               {
1498                 case 0x00:
1499                   goto op_semantics_1;
1500                   break;
1501               }
1502             break;
1503           case 0x42:
1504               GETBYTE ();
1505               switch (op[2] & 0x00)
1506               {
1507                 case 0x00:
1508                   goto op_semantics_1;
1509                   break;
1510               }
1511             break;
1512           case 0x43:
1513               GETBYTE ();
1514               switch (op[2] & 0x00)
1515               {
1516                 case 0x00:
1517                   goto op_semantics_1;
1518                   break;
1519               }
1520             break;
1521           case 0x44:
1522               GETBYTE ();
1523               switch (op[2] & 0x00)
1524               {
1525                 case 0x00:
1526                   goto op_semantics_2;
1527                   break;
1528               }
1529             break;
1530           case 0x45:
1531               GETBYTE ();
1532               switch (op[2] & 0x00)
1533               {
1534                 case 0x00:
1535                   goto op_semantics_2;
1536                   break;
1537               }
1538             break;
1539           case 0x46:
1540               GETBYTE ();
1541               switch (op[2] & 0x00)
1542               {
1543                 case 0x00:
1544                   goto op_semantics_2;
1545                   break;
1546               }
1547             break;
1548           case 0x47:
1549               GETBYTE ();
1550               switch (op[2] & 0x00)
1551               {
1552                 case 0x00:
1553                   goto op_semantics_2;
1554                   break;
1555               }
1556             break;
1557           case 0x48:
1558               GETBYTE ();
1559               switch (op[2] & 0x00)
1560               {
1561                 case 0x00:
1562                   goto op_semantics_3;
1563                   break;
1564               }
1565             break;
1566           case 0x49:
1567               GETBYTE ();
1568               switch (op[2] & 0x00)
1569               {
1570                 case 0x00:
1571                   goto op_semantics_3;
1572                   break;
1573               }
1574             break;
1575           case 0x4a:
1576               GETBYTE ();
1577               switch (op[2] & 0x00)
1578               {
1579                 case 0x00:
1580                   goto op_semantics_3;
1581                   break;
1582               }
1583             break;
1584           case 0x4b:
1585               GETBYTE ();
1586               switch (op[2] & 0x00)
1587               {
1588                 case 0x00:
1589                   goto op_semantics_3;
1590                   break;
1591               }
1592             break;
1593           case 0x4c:
1594               GETBYTE ();
1595               switch (op[2] & 0x00)
1596               {
1597                 case 0x00:
1598                   goto op_semantics_4;
1599                   break;
1600               }
1601             break;
1602           case 0x4d:
1603               GETBYTE ();
1604               switch (op[2] & 0x00)
1605               {
1606                 case 0x00:
1607                   goto op_semantics_4;
1608                   break;
1609               }
1610             break;
1611           case 0x4e:
1612               GETBYTE ();
1613               switch (op[2] & 0x00)
1614               {
1615                 case 0x00:
1616                   goto op_semantics_4;
1617                   break;
1618               }
1619             break;
1620           case 0x4f:
1621               GETBYTE ();
1622               switch (op[2] & 0x00)
1623               {
1624                 case 0x00:
1625                   goto op_semantics_4;
1626                   break;
1627               }
1628             break;
1629           case 0x50:
1630               GETBYTE ();
1631               switch (op[2] & 0x00)
1632               {
1633                 case 0x00:
1634                   goto op_semantics_5;
1635                   break;
1636               }
1637             break;
1638           case 0x51:
1639               GETBYTE ();
1640               switch (op[2] & 0x00)
1641               {
1642                 case 0x00:
1643                   goto op_semantics_5;
1644                   break;
1645               }
1646             break;
1647           case 0x52:
1648               GETBYTE ();
1649               switch (op[2] & 0x00)
1650               {
1651                 case 0x00:
1652                   goto op_semantics_5;
1653                   break;
1654               }
1655             break;
1656           case 0x53:
1657               GETBYTE ();
1658               switch (op[2] & 0x00)
1659               {
1660                 case 0x00:
1661                   goto op_semantics_5;
1662                   break;
1663               }
1664             break;
1665           case 0x54:
1666               GETBYTE ();
1667               switch (op[2] & 0x00)
1668               {
1669                 case 0x00:
1670                   goto op_semantics_6;
1671                   break;
1672               }
1673             break;
1674           case 0x55:
1675               GETBYTE ();
1676               switch (op[2] & 0x00)
1677               {
1678                 case 0x00:
1679                   goto op_semantics_6;
1680                   break;
1681               }
1682             break;
1683           case 0x56:
1684               GETBYTE ();
1685               switch (op[2] & 0x00)
1686               {
1687                 case 0x00:
1688                   goto op_semantics_6;
1689                   break;
1690               }
1691             break;
1692           case 0x57:
1693               GETBYTE ();
1694               switch (op[2] & 0x00)
1695               {
1696                 case 0x00:
1697                   goto op_semantics_6;
1698                   break;
1699               }
1700             break;
1701           case 0x60:
1702               GETBYTE ();
1703               switch (op[2] & 0xff)
1704               {
1705                 case 0x00:
1706                     GETBYTE ();
1707                     switch (op[3] & 0x00)
1708                     {
1709                       case 0x00:
1710                         goto op_semantics_7;
1711                         break;
1712                     }
1713                   break;
1714                 case 0x04:
1715                     GETBYTE ();
1716                     switch (op[3] & 0x00)
1717                     {
1718                       case 0x00:
1719                         goto op_semantics_8;
1720                         break;
1721                     }
1722                   break;
1723                 case 0x05:
1724                     GETBYTE ();
1725                     switch (op[3] & 0x00)
1726                     {
1727                       case 0x00:
1728                         goto op_semantics_9;
1729                         break;
1730                     }
1731                   break;
1732                 case 0x06:
1733                     GETBYTE ();
1734                     switch (op[3] & 0x00)
1735                     {
1736                       case 0x00:
1737                         goto op_semantics_10;
1738                         break;
1739                     }
1740                   break;
1741                 case 0x07:
1742                     GETBYTE ();
1743                     switch (op[3] & 0x00)
1744                     {
1745                       case 0x00:
1746                         goto op_semantics_11;
1747                         break;
1748                     }
1749                   break;
1750                 case 0x08:
1751                     GETBYTE ();
1752                     switch (op[3] & 0x00)
1753                     {
1754                       case 0x00:
1755                         goto op_semantics_12;
1756                         break;
1757                     }
1758                   break;
1759                 case 0x09:
1760                     GETBYTE ();
1761                     switch (op[3] & 0x00)
1762                     {
1763                       case 0x00:
1764                         goto op_semantics_13;
1765                         break;
1766                     }
1767                   break;
1768                 case 0x0c:
1769                     GETBYTE ();
1770                     switch (op[3] & 0x00)
1771                     {
1772                       case 0x00:
1773                         goto op_semantics_14;
1774                         break;
1775                     }
1776                   break;
1777                 case 0x0d:
1778                     GETBYTE ();
1779                     switch (op[3] & 0x00)
1780                     {
1781                       case 0x00:
1782                         goto op_semantics_15;
1783                         break;
1784                     }
1785                   break;
1786                 case 0x10:
1787                     GETBYTE ();
1788                     switch (op[3] & 0x00)
1789                     {
1790                       case 0x00:
1791                         goto op_semantics_16;
1792                         break;
1793                     }
1794                   break;
1795                 case 0x11:
1796                     GETBYTE ();
1797                     switch (op[3] & 0x00)
1798                     {
1799                       case 0x00:
1800                         goto op_semantics_17;
1801                         break;
1802                     }
1803                   break;
1804                 default: UNSUPPORTED(); break;
1805               }
1806             break;
1807           case 0x61:
1808               GETBYTE ();
1809               switch (op[2] & 0xff)
1810               {
1811                 case 0x00:
1812                     GETBYTE ();
1813                     switch (op[3] & 0x00)
1814                     {
1815                       case 0x00:
1816                         goto op_semantics_7;
1817                         break;
1818                     }
1819                   break;
1820                 case 0x04:
1821                     GETBYTE ();
1822                     switch (op[3] & 0x00)
1823                     {
1824                       case 0x00:
1825                         goto op_semantics_8;
1826                         break;
1827                     }
1828                   break;
1829                 case 0x05:
1830                     GETBYTE ();
1831                     switch (op[3] & 0x00)
1832                     {
1833                       case 0x00:
1834                         goto op_semantics_9;
1835                         break;
1836                     }
1837                   break;
1838                 case 0x06:
1839                     GETBYTE ();
1840                     switch (op[3] & 0x00)
1841                     {
1842                       case 0x00:
1843                         goto op_semantics_10;
1844                         break;
1845                     }
1846                   break;
1847                 case 0x07:
1848                     GETBYTE ();
1849                     switch (op[3] & 0x00)
1850                     {
1851                       case 0x00:
1852                         goto op_semantics_11;
1853                         break;
1854                     }
1855                   break;
1856                 case 0x08:
1857                     GETBYTE ();
1858                     switch (op[3] & 0x00)
1859                     {
1860                       case 0x00:
1861                         goto op_semantics_12;
1862                         break;
1863                     }
1864                   break;
1865                 case 0x09:
1866                     GETBYTE ();
1867                     switch (op[3] & 0x00)
1868                     {
1869                       case 0x00:
1870                         goto op_semantics_13;
1871                         break;
1872                     }
1873                   break;
1874                 case 0x0c:
1875                     GETBYTE ();
1876                     switch (op[3] & 0x00)
1877                     {
1878                       case 0x00:
1879                         goto op_semantics_14;
1880                         break;
1881                     }
1882                   break;
1883                 case 0x0d:
1884                     GETBYTE ();
1885                     switch (op[3] & 0x00)
1886                     {
1887                       case 0x00:
1888                         goto op_semantics_15;
1889                         break;
1890                     }
1891                   break;
1892                 case 0x10:
1893                     GETBYTE ();
1894                     switch (op[3] & 0x00)
1895                     {
1896                       case 0x00:
1897                         goto op_semantics_16;
1898                         break;
1899                     }
1900                   break;
1901                 case 0x11:
1902                     GETBYTE ();
1903                     switch (op[3] & 0x00)
1904                     {
1905                       case 0x00:
1906                         goto op_semantics_17;
1907                         break;
1908                     }
1909                   break;
1910                 default: UNSUPPORTED(); break;
1911               }
1912             break;
1913           case 0x62:
1914               GETBYTE ();
1915               switch (op[2] & 0xff)
1916               {
1917                 case 0x00:
1918                     GETBYTE ();
1919                     switch (op[3] & 0x00)
1920                     {
1921                       case 0x00:
1922                         goto op_semantics_7;
1923                         break;
1924                     }
1925                   break;
1926                 case 0x04:
1927                     GETBYTE ();
1928                     switch (op[3] & 0x00)
1929                     {
1930                       case 0x00:
1931                         goto op_semantics_8;
1932                         break;
1933                     }
1934                   break;
1935                 case 0x05:
1936                     GETBYTE ();
1937                     switch (op[3] & 0x00)
1938                     {
1939                       case 0x00:
1940                         goto op_semantics_9;
1941                         break;
1942                     }
1943                   break;
1944                 case 0x06:
1945                     GETBYTE ();
1946                     switch (op[3] & 0x00)
1947                     {
1948                       case 0x00:
1949                         goto op_semantics_10;
1950                         break;
1951                     }
1952                   break;
1953                 case 0x07:
1954                     GETBYTE ();
1955                     switch (op[3] & 0x00)
1956                     {
1957                       case 0x00:
1958                         goto op_semantics_11;
1959                         break;
1960                     }
1961                   break;
1962                 case 0x08:
1963                     GETBYTE ();
1964                     switch (op[3] & 0x00)
1965                     {
1966                       case 0x00:
1967                         goto op_semantics_12;
1968                         break;
1969                     }
1970                   break;
1971                 case 0x09:
1972                     GETBYTE ();
1973                     switch (op[3] & 0x00)
1974                     {
1975                       case 0x00:
1976                         goto op_semantics_13;
1977                         break;
1978                     }
1979                   break;
1980                 case 0x0c:
1981                     GETBYTE ();
1982                     switch (op[3] & 0x00)
1983                     {
1984                       case 0x00:
1985                         goto op_semantics_14;
1986                         break;
1987                     }
1988                   break;
1989                 case 0x0d:
1990                     GETBYTE ();
1991                     switch (op[3] & 0x00)
1992                     {
1993                       case 0x00:
1994                         goto op_semantics_15;
1995                         break;
1996                     }
1997                   break;
1998                 case 0x10:
1999                     GETBYTE ();
2000                     switch (op[3] & 0x00)
2001                     {
2002                       case 0x00:
2003                         goto op_semantics_16;
2004                         break;
2005                     }
2006                   break;
2007                 case 0x11:
2008                     GETBYTE ();
2009                     switch (op[3] & 0x00)
2010                     {
2011                       case 0x00:
2012                         goto op_semantics_17;
2013                         break;
2014                     }
2015                   break;
2016                 default: UNSUPPORTED(); break;
2017               }
2018             break;
2019           case 0x63:
2020               GETBYTE ();
2021               switch (op[2] & 0xff)
2022               {
2023                 case 0x00:
2024                     GETBYTE ();
2025                     switch (op[3] & 0x00)
2026                     {
2027                       case 0x00:
2028                         goto op_semantics_7;
2029                         break;
2030                     }
2031                   break;
2032                 case 0x04:
2033                     GETBYTE ();
2034                     switch (op[3] & 0x00)
2035                     {
2036                       case 0x00:
2037                         goto op_semantics_8;
2038                         break;
2039                     }
2040                   break;
2041                 case 0x05:
2042                     GETBYTE ();
2043                     switch (op[3] & 0x00)
2044                     {
2045                       case 0x00:
2046                         goto op_semantics_9;
2047                         break;
2048                     }
2049                   break;
2050                 case 0x06:
2051                     GETBYTE ();
2052                     switch (op[3] & 0x00)
2053                     {
2054                       case 0x00:
2055                         goto op_semantics_10;
2056                         break;
2057                     }
2058                   break;
2059                 case 0x07:
2060                     GETBYTE ();
2061                     switch (op[3] & 0x00)
2062                     {
2063                       case 0x00:
2064                         goto op_semantics_11;
2065                         break;
2066                     }
2067                   break;
2068                 case 0x08:
2069                     GETBYTE ();
2070                     switch (op[3] & 0x00)
2071                     {
2072                       case 0x00:
2073                         goto op_semantics_12;
2074                         break;
2075                     }
2076                   break;
2077                 case 0x09:
2078                     GETBYTE ();
2079                     switch (op[3] & 0x00)
2080                     {
2081                       case 0x00:
2082                         goto op_semantics_13;
2083                         break;
2084                     }
2085                   break;
2086                 case 0x0c:
2087                     GETBYTE ();
2088                     switch (op[3] & 0x00)
2089                     {
2090                       case 0x00:
2091                         goto op_semantics_14;
2092                         break;
2093                     }
2094                   break;
2095                 case 0x0d:
2096                     GETBYTE ();
2097                     switch (op[3] & 0x00)
2098                     {
2099                       case 0x00:
2100                         goto op_semantics_15;
2101                         break;
2102                     }
2103                   break;
2104                 case 0x10:
2105                     GETBYTE ();
2106                     switch (op[3] & 0x00)
2107                     {
2108                       case 0x00:
2109                         goto op_semantics_16;
2110                         break;
2111                     }
2112                   break;
2113                 case 0x11:
2114                     GETBYTE ();
2115                     switch (op[3] & 0x00)
2116                     {
2117                       case 0x00:
2118                         goto op_semantics_17;
2119                         break;
2120                     }
2121                   break;
2122                 default: UNSUPPORTED(); break;
2123               }
2124             break;
2125           case 0x80:
2126               GETBYTE ();
2127               switch (op[2] & 0x00)
2128               {
2129                 case 0x00:
2130                   goto op_semantics_1;
2131                   break;
2132               }
2133             break;
2134           case 0x81:
2135               GETBYTE ();
2136               switch (op[2] & 0x00)
2137               {
2138                 case 0x00:
2139                   goto op_semantics_1;
2140                   break;
2141               }
2142             break;
2143           case 0x82:
2144               GETBYTE ();
2145               switch (op[2] & 0x00)
2146               {
2147                 case 0x00:
2148                   goto op_semantics_1;
2149                   break;
2150               }
2151             break;
2152           case 0x83:
2153               GETBYTE ();
2154               switch (op[2] & 0x00)
2155               {
2156                 case 0x00:
2157                   goto op_semantics_1;
2158                   break;
2159               }
2160             break;
2161           case 0x84:
2162               GETBYTE ();
2163               switch (op[2] & 0x00)
2164               {
2165                 case 0x00:
2166                   goto op_semantics_2;
2167                   break;
2168               }
2169             break;
2170           case 0x85:
2171               GETBYTE ();
2172               switch (op[2] & 0x00)
2173               {
2174                 case 0x00:
2175                   goto op_semantics_2;
2176                   break;
2177               }
2178             break;
2179           case 0x86:
2180               GETBYTE ();
2181               switch (op[2] & 0x00)
2182               {
2183                 case 0x00:
2184                   goto op_semantics_2;
2185                   break;
2186               }
2187             break;
2188           case 0x87:
2189               GETBYTE ();
2190               switch (op[2] & 0x00)
2191               {
2192                 case 0x00:
2193                   goto op_semantics_2;
2194                   break;
2195               }
2196             break;
2197           case 0x88:
2198               GETBYTE ();
2199               switch (op[2] & 0x00)
2200               {
2201                 case 0x00:
2202                   goto op_semantics_3;
2203                   break;
2204               }
2205             break;
2206           case 0x89:
2207               GETBYTE ();
2208               switch (op[2] & 0x00)
2209               {
2210                 case 0x00:
2211                   goto op_semantics_3;
2212                   break;
2213               }
2214             break;
2215           case 0x8a:
2216               GETBYTE ();
2217               switch (op[2] & 0x00)
2218               {
2219                 case 0x00:
2220                   goto op_semantics_3;
2221                   break;
2222               }
2223             break;
2224           case 0x8b:
2225               GETBYTE ();
2226               switch (op[2] & 0x00)
2227               {
2228                 case 0x00:
2229                   goto op_semantics_3;
2230                   break;
2231               }
2232             break;
2233           case 0x8c:
2234               GETBYTE ();
2235               switch (op[2] & 0x00)
2236               {
2237                 case 0x00:
2238                   goto op_semantics_4;
2239                   break;
2240               }
2241             break;
2242           case 0x8d:
2243               GETBYTE ();
2244               switch (op[2] & 0x00)
2245               {
2246                 case 0x00:
2247                   goto op_semantics_4;
2248                   break;
2249               }
2250             break;
2251           case 0x8e:
2252               GETBYTE ();
2253               switch (op[2] & 0x00)
2254               {
2255                 case 0x00:
2256                   goto op_semantics_4;
2257                   break;
2258               }
2259             break;
2260           case 0x8f:
2261               GETBYTE ();
2262               switch (op[2] & 0x00)
2263               {
2264                 case 0x00:
2265                   goto op_semantics_4;
2266                   break;
2267               }
2268             break;
2269           case 0x90:
2270               GETBYTE ();
2271               switch (op[2] & 0x00)
2272               {
2273                 case 0x00:
2274                   goto op_semantics_5;
2275                   break;
2276               }
2277             break;
2278           case 0x91:
2279               GETBYTE ();
2280               switch (op[2] & 0x00)
2281               {
2282                 case 0x00:
2283                   goto op_semantics_5;
2284                   break;
2285               }
2286             break;
2287           case 0x92:
2288               GETBYTE ();
2289               switch (op[2] & 0x00)
2290               {
2291                 case 0x00:
2292                   goto op_semantics_5;
2293                   break;
2294               }
2295             break;
2296           case 0x93:
2297               GETBYTE ();
2298               switch (op[2] & 0x00)
2299               {
2300                 case 0x00:
2301                   goto op_semantics_5;
2302                   break;
2303               }
2304             break;
2305           case 0x94:
2306               GETBYTE ();
2307               switch (op[2] & 0x00)
2308               {
2309                 case 0x00:
2310                   goto op_semantics_6;
2311                   break;
2312               }
2313             break;
2314           case 0x95:
2315               GETBYTE ();
2316               switch (op[2] & 0x00)
2317               {
2318                 case 0x00:
2319                   goto op_semantics_6;
2320                   break;
2321               }
2322             break;
2323           case 0x96:
2324               GETBYTE ();
2325               switch (op[2] & 0x00)
2326               {
2327                 case 0x00:
2328                   goto op_semantics_6;
2329                   break;
2330               }
2331             break;
2332           case 0x97:
2333               GETBYTE ();
2334               switch (op[2] & 0x00)
2335               {
2336                 case 0x00:
2337                   goto op_semantics_6;
2338                   break;
2339               }
2340             break;
2341           case 0xa0:
2342               GETBYTE ();
2343               switch (op[2] & 0xff)
2344               {
2345                 case 0x00:
2346                     GETBYTE ();
2347                     switch (op[3] & 0x00)
2348                     {
2349                       case 0x00:
2350                         goto op_semantics_7;
2351                         break;
2352                     }
2353                   break;
2354                 case 0x02:
2355                     GETBYTE ();
2356                     switch (op[3] & 0x00)
2357                     {
2358                       case 0x00:
2359                         op_semantics_18:
2360                           {
2361                             /** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc     %1%S1, %0 */
2362 #line 491 "rx-decode.opc"
2363                             int ss AU = op[1] & 0x03;
2364 #line 491 "rx-decode.opc"
2365                             int rsrc AU = (op[3] >> 4) & 0x0f;
2366 #line 491 "rx-decode.opc"
2367                             int rdst AU = op[3] & 0x0f;
2368                             if (trace)
2369                               {
2370                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
2371                                        "/** 0000 0110 1010 00ss 0000 0010 rsrc rdst     adc     %1%S1, %0 */",
2372                                        op[0], op[1], op[2], op[3]);
2373                                 printf ("  ss = 0x%x,", ss);
2374                                 printf ("  rsrc = 0x%x,", rsrc);
2375                                 printf ("  rdst = 0x%x\n", rdst);
2376                               }
2377                             SYNTAX("adc %1%S1, %0");
2378 #line 491 "rx-decode.opc"
2379                             ID(adc); SPm(ss, rsrc, 2); DR(rdst); F_OSZC;
2380
2381                           /*----------------------------------------------------------------------*/
2382                           /* ADD                                                                        */
2383
2384                           }
2385                         break;
2386                     }
2387                   break;
2388                 case 0x04:
2389                     GETBYTE ();
2390                     switch (op[3] & 0x00)
2391                     {
2392                       case 0x00:
2393                         goto op_semantics_8;
2394                         break;
2395                     }
2396                   break;
2397                 case 0x05:
2398                     GETBYTE ();
2399                     switch (op[3] & 0x00)
2400                     {
2401                       case 0x00:
2402                         goto op_semantics_9;
2403                         break;
2404                     }
2405                   break;
2406                 case 0x06:
2407                     GETBYTE ();
2408                     switch (op[3] & 0x00)
2409                     {
2410                       case 0x00:
2411                         goto op_semantics_10;
2412                         break;
2413                     }
2414                   break;
2415                 case 0x07:
2416                     GETBYTE ();
2417                     switch (op[3] & 0x00)
2418                     {
2419                       case 0x00:
2420                         goto op_semantics_11;
2421                         break;
2422                     }
2423                   break;
2424                 case 0x08:
2425                     GETBYTE ();
2426                     switch (op[3] & 0x00)
2427                     {
2428                       case 0x00:
2429                         goto op_semantics_12;
2430                         break;
2431                     }
2432                   break;
2433                 case 0x09:
2434                     GETBYTE ();
2435                     switch (op[3] & 0x00)
2436                     {
2437                       case 0x00:
2438                         goto op_semantics_13;
2439                         break;
2440                     }
2441                   break;
2442                 case 0x0c:
2443                     GETBYTE ();
2444                     switch (op[3] & 0x00)
2445                     {
2446                       case 0x00:
2447                         goto op_semantics_14;
2448                         break;
2449                     }
2450                   break;
2451                 case 0x0d:
2452                     GETBYTE ();
2453                     switch (op[3] & 0x00)
2454                     {
2455                       case 0x00:
2456                         goto op_semantics_15;
2457                         break;
2458                     }
2459                   break;
2460                 case 0x10:
2461                     GETBYTE ();
2462                     switch (op[3] & 0x00)
2463                     {
2464                       case 0x00:
2465                         goto op_semantics_16;
2466                         break;
2467                     }
2468                   break;
2469                 case 0x11:
2470                     GETBYTE ();
2471                     switch (op[3] & 0x00)
2472                     {
2473                       case 0x00:
2474                         goto op_semantics_17;
2475                         break;
2476                     }
2477                   break;
2478                 default: UNSUPPORTED(); break;
2479               }
2480             break;
2481           case 0xa1:
2482               GETBYTE ();
2483               switch (op[2] & 0xff)
2484               {
2485                 case 0x00:
2486                     GETBYTE ();
2487                     switch (op[3] & 0x00)
2488                     {
2489                       case 0x00:
2490                         goto op_semantics_7;
2491                         break;
2492                     }
2493                   break;
2494                 case 0x02:
2495                     GETBYTE ();
2496                     switch (op[3] & 0x00)
2497                     {
2498                       case 0x00:
2499                         goto op_semantics_18;
2500                         break;
2501                     }
2502                   break;
2503                 case 0x04:
2504                     GETBYTE ();
2505                     switch (op[3] & 0x00)
2506                     {
2507                       case 0x00:
2508                         goto op_semantics_8;
2509                         break;
2510                     }
2511                   break;
2512                 case 0x05:
2513                     GETBYTE ();
2514                     switch (op[3] & 0x00)
2515                     {
2516                       case 0x00:
2517                         goto op_semantics_9;
2518                         break;
2519                     }
2520                   break;
2521                 case 0x06:
2522                     GETBYTE ();
2523                     switch (op[3] & 0x00)
2524                     {
2525                       case 0x00:
2526                         goto op_semantics_10;
2527                         break;
2528                     }
2529                   break;
2530                 case 0x07:
2531                     GETBYTE ();
2532                     switch (op[3] & 0x00)
2533                     {
2534                       case 0x00:
2535                         goto op_semantics_11;
2536                         break;
2537                     }
2538                   break;
2539                 case 0x08:
2540                     GETBYTE ();
2541                     switch (op[3] & 0x00)
2542                     {
2543                       case 0x00:
2544                         goto op_semantics_12;
2545                         break;
2546                     }
2547                   break;
2548                 case 0x09:
2549                     GETBYTE ();
2550                     switch (op[3] & 0x00)
2551                     {
2552                       case 0x00:
2553                         goto op_semantics_13;
2554                         break;
2555                     }
2556                   break;
2557                 case 0x0c:
2558                     GETBYTE ();
2559                     switch (op[3] & 0x00)
2560                     {
2561                       case 0x00:
2562                         goto op_semantics_14;
2563                         break;
2564                     }
2565                   break;
2566                 case 0x0d:
2567                     GETBYTE ();
2568                     switch (op[3] & 0x00)
2569                     {
2570                       case 0x00:
2571                         goto op_semantics_15;
2572                         break;
2573                     }
2574                   break;
2575                 case 0x10:
2576                     GETBYTE ();
2577                     switch (op[3] & 0x00)
2578                     {
2579                       case 0x00:
2580                         goto op_semantics_16;
2581                         break;
2582                     }
2583                   break;
2584                 case 0x11:
2585                     GETBYTE ();
2586                     switch (op[3] & 0x00)
2587                     {
2588                       case 0x00:
2589                         goto op_semantics_17;
2590                         break;
2591                     }
2592                   break;
2593                 default: UNSUPPORTED(); break;
2594               }
2595             break;
2596           case 0xa2:
2597               GETBYTE ();
2598               switch (op[2] & 0xff)
2599               {
2600                 case 0x00:
2601                     GETBYTE ();
2602                     switch (op[3] & 0x00)
2603                     {
2604                       case 0x00:
2605                         goto op_semantics_7;
2606                         break;
2607                     }
2608                   break;
2609                 case 0x02:
2610                     GETBYTE ();
2611                     switch (op[3] & 0x00)
2612                     {
2613                       case 0x00:
2614                         goto op_semantics_18;
2615                         break;
2616                     }
2617                   break;
2618                 case 0x04:
2619                     GETBYTE ();
2620                     switch (op[3] & 0x00)
2621                     {
2622                       case 0x00:
2623                         goto op_semantics_8;
2624                         break;
2625                     }
2626                   break;
2627                 case 0x05:
2628                     GETBYTE ();
2629                     switch (op[3] & 0x00)
2630                     {
2631                       case 0x00:
2632                         goto op_semantics_9;
2633                         break;
2634                     }
2635                   break;
2636                 case 0x06:
2637                     GETBYTE ();
2638                     switch (op[3] & 0x00)
2639                     {
2640                       case 0x00:
2641                         goto op_semantics_10;
2642                         break;
2643                     }
2644                   break;
2645                 case 0x07:
2646                     GETBYTE ();
2647                     switch (op[3] & 0x00)
2648                     {
2649                       case 0x00:
2650                         goto op_semantics_11;
2651                         break;
2652                     }
2653                   break;
2654                 case 0x08:
2655                     GETBYTE ();
2656                     switch (op[3] & 0x00)
2657                     {
2658                       case 0x00:
2659                         goto op_semantics_12;
2660                         break;
2661                     }
2662                   break;
2663                 case 0x09:
2664                     GETBYTE ();
2665                     switch (op[3] & 0x00)
2666                     {
2667                       case 0x00:
2668                         goto op_semantics_13;
2669                         break;
2670                     }
2671                   break;
2672                 case 0x0c:
2673                     GETBYTE ();
2674                     switch (op[3] & 0x00)
2675                     {
2676                       case 0x00:
2677                         goto op_semantics_14;
2678                         break;
2679                     }
2680                   break;
2681                 case 0x0d:
2682                     GETBYTE ();
2683                     switch (op[3] & 0x00)
2684                     {
2685                       case 0x00:
2686                         goto op_semantics_15;
2687                         break;
2688                     }
2689                   break;
2690                 case 0x10:
2691                     GETBYTE ();
2692                     switch (op[3] & 0x00)
2693                     {
2694                       case 0x00:
2695                         goto op_semantics_16;
2696                         break;
2697                     }
2698                   break;
2699                 case 0x11:
2700                     GETBYTE ();
2701                     switch (op[3] & 0x00)
2702                     {
2703                       case 0x00:
2704                         goto op_semantics_17;
2705                         break;
2706                     }
2707                   break;
2708                 default: UNSUPPORTED(); break;
2709               }
2710             break;
2711           case 0xa3:
2712               GETBYTE ();
2713               switch (op[2] & 0xff)
2714               {
2715                 case 0x00:
2716                     GETBYTE ();
2717                     switch (op[3] & 0x00)
2718                     {
2719                       case 0x00:
2720                         goto op_semantics_7;
2721                         break;
2722                     }
2723                   break;
2724                 case 0x02:
2725                     GETBYTE ();
2726                     switch (op[3] & 0x00)
2727                     {
2728                       case 0x00:
2729                         goto op_semantics_18;
2730                         break;
2731                     }
2732                   break;
2733                 case 0x04:
2734                     GETBYTE ();
2735                     switch (op[3] & 0x00)
2736                     {
2737                       case 0x00:
2738                         goto op_semantics_8;
2739                         break;
2740                     }
2741                   break;
2742                 case 0x05:
2743                     GETBYTE ();
2744                     switch (op[3] & 0x00)
2745                     {
2746                       case 0x00:
2747                         goto op_semantics_9;
2748                         break;
2749                     }
2750                   break;
2751                 case 0x06:
2752                     GETBYTE ();
2753                     switch (op[3] & 0x00)
2754                     {
2755                       case 0x00:
2756                         goto op_semantics_10;
2757                         break;
2758                     }
2759                   break;
2760                 case 0x07:
2761                     GETBYTE ();
2762                     switch (op[3] & 0x00)
2763                     {
2764                       case 0x00:
2765                         goto op_semantics_11;
2766                         break;
2767                     }
2768                   break;
2769                 case 0x08:
2770                     GETBYTE ();
2771                     switch (op[3] & 0x00)
2772                     {
2773                       case 0x00:
2774                         goto op_semantics_12;
2775                         break;
2776                     }
2777                   break;
2778                 case 0x09:
2779                     GETBYTE ();
2780                     switch (op[3] & 0x00)
2781                     {
2782                       case 0x00:
2783                         goto op_semantics_13;
2784                         break;
2785                     }
2786                   break;
2787                 case 0x0c:
2788                     GETBYTE ();
2789                     switch (op[3] & 0x00)
2790                     {
2791                       case 0x00:
2792                         goto op_semantics_14;
2793                         break;
2794                     }
2795                   break;
2796                 case 0x0d:
2797                     GETBYTE ();
2798                     switch (op[3] & 0x00)
2799                     {
2800                       case 0x00:
2801                         goto op_semantics_15;
2802                         break;
2803                     }
2804                   break;
2805                 case 0x10:
2806                     GETBYTE ();
2807                     switch (op[3] & 0x00)
2808                     {
2809                       case 0x00:
2810                         goto op_semantics_16;
2811                         break;
2812                     }
2813                   break;
2814                 case 0x11:
2815                     GETBYTE ();
2816                     switch (op[3] & 0x00)
2817                     {
2818                       case 0x00:
2819                         goto op_semantics_17;
2820                         break;
2821                     }
2822                   break;
2823                 default: UNSUPPORTED(); break;
2824               }
2825             break;
2826           case 0xc0:
2827               GETBYTE ();
2828               switch (op[2] & 0x00)
2829               {
2830                 case 0x00:
2831                   goto op_semantics_1;
2832                   break;
2833               }
2834             break;
2835           case 0xc1:
2836               GETBYTE ();
2837               switch (op[2] & 0x00)
2838               {
2839                 case 0x00:
2840                   goto op_semantics_1;
2841                   break;
2842               }
2843             break;
2844           case 0xc2:
2845               GETBYTE ();
2846               switch (op[2] & 0x00)
2847               {
2848                 case 0x00:
2849                   goto op_semantics_1;
2850                   break;
2851               }
2852             break;
2853           case 0xc3:
2854               GETBYTE ();
2855               switch (op[2] & 0x00)
2856               {
2857                 case 0x00:
2858                   goto op_semantics_1;
2859                   break;
2860               }
2861             break;
2862           case 0xc4:
2863               GETBYTE ();
2864               switch (op[2] & 0x00)
2865               {
2866                 case 0x00:
2867                   goto op_semantics_2;
2868                   break;
2869               }
2870             break;
2871           case 0xc5:
2872               GETBYTE ();
2873               switch (op[2] & 0x00)
2874               {
2875                 case 0x00:
2876                   goto op_semantics_2;
2877                   break;
2878               }
2879             break;
2880           case 0xc6:
2881               GETBYTE ();
2882               switch (op[2] & 0x00)
2883               {
2884                 case 0x00:
2885                   goto op_semantics_2;
2886                   break;
2887               }
2888             break;
2889           case 0xc7:
2890               GETBYTE ();
2891               switch (op[2] & 0x00)
2892               {
2893                 case 0x00:
2894                   goto op_semantics_2;
2895                   break;
2896               }
2897             break;
2898           case 0xc8:
2899               GETBYTE ();
2900               switch (op[2] & 0x00)
2901               {
2902                 case 0x00:
2903                   goto op_semantics_3;
2904                   break;
2905               }
2906             break;
2907           case 0xc9:
2908               GETBYTE ();
2909               switch (op[2] & 0x00)
2910               {
2911                 case 0x00:
2912                   goto op_semantics_3;
2913                   break;
2914               }
2915             break;
2916           case 0xca:
2917               GETBYTE ();
2918               switch (op[2] & 0x00)
2919               {
2920                 case 0x00:
2921                   goto op_semantics_3;
2922                   break;
2923               }
2924             break;
2925           case 0xcb:
2926               GETBYTE ();
2927               switch (op[2] & 0x00)
2928               {
2929                 case 0x00:
2930                   goto op_semantics_3;
2931                   break;
2932               }
2933             break;
2934           case 0xcc:
2935               GETBYTE ();
2936               switch (op[2] & 0x00)
2937               {
2938                 case 0x00:
2939                   goto op_semantics_4;
2940                   break;
2941               }
2942             break;
2943           case 0xcd:
2944               GETBYTE ();
2945               switch (op[2] & 0x00)
2946               {
2947                 case 0x00:
2948                   goto op_semantics_4;
2949                   break;
2950               }
2951             break;
2952           case 0xce:
2953               GETBYTE ();
2954               switch (op[2] & 0x00)
2955               {
2956                 case 0x00:
2957                   goto op_semantics_4;
2958                   break;
2959               }
2960             break;
2961           case 0xcf:
2962               GETBYTE ();
2963               switch (op[2] & 0x00)
2964               {
2965                 case 0x00:
2966                   goto op_semantics_4;
2967                   break;
2968               }
2969             break;
2970           case 0xd0:
2971               GETBYTE ();
2972               switch (op[2] & 0x00)
2973               {
2974                 case 0x00:
2975                   goto op_semantics_5;
2976                   break;
2977               }
2978             break;
2979           case 0xd1:
2980               GETBYTE ();
2981               switch (op[2] & 0x00)
2982               {
2983                 case 0x00:
2984                   goto op_semantics_5;
2985                   break;
2986               }
2987             break;
2988           case 0xd2:
2989               GETBYTE ();
2990               switch (op[2] & 0x00)
2991               {
2992                 case 0x00:
2993                   goto op_semantics_5;
2994                   break;
2995               }
2996             break;
2997           case 0xd3:
2998               GETBYTE ();
2999               switch (op[2] & 0x00)
3000               {
3001                 case 0x00:
3002                   goto op_semantics_5;
3003                   break;
3004               }
3005             break;
3006           case 0xd4:
3007               GETBYTE ();
3008               switch (op[2] & 0x00)
3009               {
3010                 case 0x00:
3011                   goto op_semantics_6;
3012                   break;
3013               }
3014             break;
3015           case 0xd5:
3016               GETBYTE ();
3017               switch (op[2] & 0x00)
3018               {
3019                 case 0x00:
3020                   goto op_semantics_6;
3021                   break;
3022               }
3023             break;
3024           case 0xd6:
3025               GETBYTE ();
3026               switch (op[2] & 0x00)
3027               {
3028                 case 0x00:
3029                   goto op_semantics_6;
3030                   break;
3031               }
3032             break;
3033           case 0xd7:
3034               GETBYTE ();
3035               switch (op[2] & 0x00)
3036               {
3037                 case 0x00:
3038                   goto op_semantics_6;
3039                   break;
3040               }
3041             break;
3042           case 0xe0:
3043               GETBYTE ();
3044               switch (op[2] & 0xff)
3045               {
3046                 case 0x00:
3047                     GETBYTE ();
3048                     switch (op[3] & 0x00)
3049                     {
3050                       case 0x00:
3051                         goto op_semantics_7;
3052                         break;
3053                     }
3054                   break;
3055                 case 0x04:
3056                     GETBYTE ();
3057                     switch (op[3] & 0x00)
3058                     {
3059                       case 0x00:
3060                         goto op_semantics_8;
3061                         break;
3062                     }
3063                   break;
3064                 case 0x05:
3065                     GETBYTE ();
3066                     switch (op[3] & 0x00)
3067                     {
3068                       case 0x00:
3069                         goto op_semantics_9;
3070                         break;
3071                     }
3072                   break;
3073                 case 0x06:
3074                     GETBYTE ();
3075                     switch (op[3] & 0x00)
3076                     {
3077                       case 0x00:
3078                         goto op_semantics_10;
3079                         break;
3080                     }
3081                   break;
3082                 case 0x07:
3083                     GETBYTE ();
3084                     switch (op[3] & 0x00)
3085                     {
3086                       case 0x00:
3087                         goto op_semantics_11;
3088                         break;
3089                     }
3090                   break;
3091                 case 0x08:
3092                     GETBYTE ();
3093                     switch (op[3] & 0x00)
3094                     {
3095                       case 0x00:
3096                         goto op_semantics_12;
3097                         break;
3098                     }
3099                   break;
3100                 case 0x09:
3101                     GETBYTE ();
3102                     switch (op[3] & 0x00)
3103                     {
3104                       case 0x00:
3105                         goto op_semantics_13;
3106                         break;
3107                     }
3108                   break;
3109                 case 0x0c:
3110                     GETBYTE ();
3111                     switch (op[3] & 0x00)
3112                     {
3113                       case 0x00:
3114                         goto op_semantics_14;
3115                         break;
3116                     }
3117                   break;
3118                 case 0x0d:
3119                     GETBYTE ();
3120                     switch (op[3] & 0x00)
3121                     {
3122                       case 0x00:
3123                         goto op_semantics_15;
3124                         break;
3125                     }
3126                   break;
3127                 case 0x10:
3128                     GETBYTE ();
3129                     switch (op[3] & 0x00)
3130                     {
3131                       case 0x00:
3132                         goto op_semantics_16;
3133                         break;
3134                     }
3135                   break;
3136                 case 0x11:
3137                     GETBYTE ();
3138                     switch (op[3] & 0x00)
3139                     {
3140                       case 0x00:
3141                         goto op_semantics_17;
3142                         break;
3143                     }
3144                   break;
3145                 default: UNSUPPORTED(); break;
3146               }
3147             break;
3148           case 0xe1:
3149               GETBYTE ();
3150               switch (op[2] & 0xff)
3151               {
3152                 case 0x00:
3153                     GETBYTE ();
3154                     switch (op[3] & 0x00)
3155                     {
3156                       case 0x00:
3157                         goto op_semantics_7;
3158                         break;
3159                     }
3160                   break;
3161                 case 0x04:
3162                     GETBYTE ();
3163                     switch (op[3] & 0x00)
3164                     {
3165                       case 0x00:
3166                         goto op_semantics_8;
3167                         break;
3168                     }
3169                   break;
3170                 case 0x05:
3171                     GETBYTE ();
3172                     switch (op[3] & 0x00)
3173                     {
3174                       case 0x00:
3175                         goto op_semantics_9;
3176                         break;
3177                     }
3178                   break;
3179                 case 0x06:
3180                     GETBYTE ();
3181                     switch (op[3] & 0x00)
3182                     {
3183                       case 0x00:
3184                         goto op_semantics_10;
3185                         break;
3186                     }
3187                   break;
3188                 case 0x07:
3189                     GETBYTE ();
3190                     switch (op[3] & 0x00)
3191                     {
3192                       case 0x00:
3193                         goto op_semantics_11;
3194                         break;
3195                     }
3196                   break;
3197                 case 0x08:
3198                     GETBYTE ();
3199                     switch (op[3] & 0x00)
3200                     {
3201                       case 0x00:
3202                         goto op_semantics_12;
3203                         break;
3204                     }
3205                   break;
3206                 case 0x09:
3207                     GETBYTE ();
3208                     switch (op[3] & 0x00)
3209                     {
3210                       case 0x00:
3211                         goto op_semantics_13;
3212                         break;
3213                     }
3214                   break;
3215                 case 0x0c:
3216                     GETBYTE ();
3217                     switch (op[3] & 0x00)
3218                     {
3219                       case 0x00:
3220                         goto op_semantics_14;
3221                         break;
3222                     }
3223                   break;
3224                 case 0x0d:
3225                     GETBYTE ();
3226                     switch (op[3] & 0x00)
3227                     {
3228                       case 0x00:
3229                         goto op_semantics_15;
3230                         break;
3231                     }
3232                   break;
3233                 case 0x10:
3234                     GETBYTE ();
3235                     switch (op[3] & 0x00)
3236                     {
3237                       case 0x00:
3238                         goto op_semantics_16;
3239                         break;
3240                     }
3241                   break;
3242                 case 0x11:
3243                     GETBYTE ();
3244                     switch (op[3] & 0x00)
3245                     {
3246                       case 0x00:
3247                         goto op_semantics_17;
3248                         break;
3249                     }
3250                   break;
3251                 default: UNSUPPORTED(); break;
3252               }
3253             break;
3254           case 0xe2:
3255               GETBYTE ();
3256               switch (op[2] & 0xff)
3257               {
3258                 case 0x00:
3259                     GETBYTE ();
3260                     switch (op[3] & 0x00)
3261                     {
3262                       case 0x00:
3263                         goto op_semantics_7;
3264                         break;
3265                     }
3266                   break;
3267                 case 0x04:
3268                     GETBYTE ();
3269                     switch (op[3] & 0x00)
3270                     {
3271                       case 0x00:
3272                         goto op_semantics_8;
3273                         break;
3274                     }
3275                   break;
3276                 case 0x05:
3277                     GETBYTE ();
3278                     switch (op[3] & 0x00)
3279                     {
3280                       case 0x00:
3281                         goto op_semantics_9;
3282                         break;
3283                     }
3284                   break;
3285                 case 0x06:
3286                     GETBYTE ();
3287                     switch (op[3] & 0x00)
3288                     {
3289                       case 0x00:
3290                         goto op_semantics_10;
3291                         break;
3292                     }
3293                   break;
3294                 case 0x07:
3295                     GETBYTE ();
3296                     switch (op[3] & 0x00)
3297                     {
3298                       case 0x00:
3299                         goto op_semantics_11;
3300                         break;
3301                     }
3302                   break;
3303                 case 0x08:
3304                     GETBYTE ();
3305                     switch (op[3] & 0x00)
3306                     {
3307                       case 0x00:
3308                         goto op_semantics_12;
3309                         break;
3310                     }
3311                   break;
3312                 case 0x09:
3313                     GETBYTE ();
3314                     switch (op[3] & 0x00)
3315                     {
3316                       case 0x00:
3317                         goto op_semantics_13;
3318                         break;
3319                     }
3320                   break;
3321                 case 0x0c:
3322                     GETBYTE ();
3323                     switch (op[3] & 0x00)
3324                     {
3325                       case 0x00:
3326                         goto op_semantics_14;
3327                         break;
3328                     }
3329                   break;
3330                 case 0x0d:
3331                     GETBYTE ();
3332                     switch (op[3] & 0x00)
3333                     {
3334                       case 0x00:
3335                         goto op_semantics_15;
3336                         break;
3337                     }
3338                   break;
3339                 case 0x10:
3340                     GETBYTE ();
3341                     switch (op[3] & 0x00)
3342                     {
3343                       case 0x00:
3344                         goto op_semantics_16;
3345                         break;
3346                     }
3347                   break;
3348                 case 0x11:
3349                     GETBYTE ();
3350                     switch (op[3] & 0x00)
3351                     {
3352                       case 0x00:
3353                         goto op_semantics_17;
3354                         break;
3355                     }
3356                   break;
3357                 default: UNSUPPORTED(); break;
3358               }
3359             break;
3360           case 0xe3:
3361               GETBYTE ();
3362               switch (op[2] & 0xff)
3363               {
3364                 case 0x00:
3365                     GETBYTE ();
3366                     switch (op[3] & 0x00)
3367                     {
3368                       case 0x00:
3369                         goto op_semantics_7;
3370                         break;
3371                     }
3372                   break;
3373                 case 0x04:
3374                     GETBYTE ();
3375                     switch (op[3] & 0x00)
3376                     {
3377                       case 0x00:
3378                         goto op_semantics_8;
3379                         break;
3380                     }
3381                   break;
3382                 case 0x05:
3383                     GETBYTE ();
3384                     switch (op[3] & 0x00)
3385                     {
3386                       case 0x00:
3387                         goto op_semantics_9;
3388                         break;
3389                     }
3390                   break;
3391                 case 0x06:
3392                     GETBYTE ();
3393                     switch (op[3] & 0x00)
3394                     {
3395                       case 0x00:
3396                         goto op_semantics_10;
3397                         break;
3398                     }
3399                   break;
3400                 case 0x07:
3401                     GETBYTE ();
3402                     switch (op[3] & 0x00)
3403                     {
3404                       case 0x00:
3405                         goto op_semantics_11;
3406                         break;
3407                     }
3408                   break;
3409                 case 0x08:
3410                     GETBYTE ();
3411                     switch (op[3] & 0x00)
3412                     {
3413                       case 0x00:
3414                         goto op_semantics_12;
3415                         break;
3416                     }
3417                   break;
3418                 case 0x09:
3419                     GETBYTE ();
3420                     switch (op[3] & 0x00)
3421                     {
3422                       case 0x00:
3423                         goto op_semantics_13;
3424                         break;
3425                     }
3426                   break;
3427                 case 0x0c:
3428                     GETBYTE ();
3429                     switch (op[3] & 0x00)
3430                     {
3431                       case 0x00:
3432                         goto op_semantics_14;
3433                         break;
3434                     }
3435                   break;
3436                 case 0x0d:
3437                     GETBYTE ();
3438                     switch (op[3] & 0x00)
3439                     {
3440                       case 0x00:
3441                         goto op_semantics_15;
3442                         break;
3443                     }
3444                   break;
3445                 case 0x10:
3446                     GETBYTE ();
3447                     switch (op[3] & 0x00)
3448                     {
3449                       case 0x00:
3450                         goto op_semantics_16;
3451                         break;
3452                     }
3453                   break;
3454                 case 0x11:
3455                     GETBYTE ();
3456                     switch (op[3] & 0x00)
3457                     {
3458                       case 0x00:
3459                         goto op_semantics_17;
3460                         break;
3461                     }
3462                   break;
3463                 default: UNSUPPORTED(); break;
3464               }
3465             break;
3466           default: UNSUPPORTED(); break;
3467         }
3468       break;
3469     case 0x08:
3470     case 0x09:
3471     case 0x0a:
3472     case 0x0b:
3473     case 0x0c:
3474     case 0x0d:
3475     case 0x0e:
3476     case 0x0f:
3477         {
3478           /** 0000 1dsp                 bra.s   %a0 */
3479 #line 734 "rx-decode.opc"
3480           int dsp AU = op[0] & 0x07;
3481           if (trace)
3482             {
3483               printf ("\033[33m%s\033[0m  %02x\n",
3484                      "/** 0000 1dsp                     bra.s   %a0 */",
3485                      op[0]);
3486               printf ("  dsp = 0x%x\n", dsp);
3487             }
3488           SYNTAX("bra.s %a0");
3489 #line 734 "rx-decode.opc"
3490           ID(branch); DC(pc + dsp3map[dsp]);
3491
3492         }
3493       break;
3494     case 0x10:
3495     case 0x11:
3496     case 0x12:
3497     case 0x13:
3498     case 0x14:
3499     case 0x15:
3500     case 0x16:
3501     case 0x17:
3502     case 0x18:
3503     case 0x19:
3504     case 0x1a:
3505     case 0x1b:
3506     case 0x1c:
3507     case 0x1d:
3508     case 0x1e:
3509     case 0x1f:
3510         {
3511           /** 0001 n dsp                        b%1.s   %a0 */
3512 #line 724 "rx-decode.opc"
3513           int n AU = (op[0] >> 3) & 0x01;
3514 #line 724 "rx-decode.opc"
3515           int dsp AU = op[0] & 0x07;
3516           if (trace)
3517             {
3518               printf ("\033[33m%s\033[0m  %02x\n",
3519                      "/** 0001 n dsp                    b%1.s   %a0 */",
3520                      op[0]);
3521               printf ("  n = 0x%x,", n);
3522               printf ("  dsp = 0x%x\n", dsp);
3523             }
3524           SYNTAX("b%1.s %a0");
3525 #line 724 "rx-decode.opc"
3526           ID(branch); Scc(n); DC(pc + dsp3map[dsp]);
3527
3528         }
3529       break;
3530     case 0x20:
3531     case 0x21:
3532     case 0x22:
3533     case 0x23:
3534     case 0x24:
3535     case 0x25:
3536     case 0x26:
3537     case 0x27:
3538     case 0x28:
3539     case 0x29:
3540     case 0x2a:
3541     case 0x2b:
3542     case 0x2c:
3543     case 0x2d:
3544     case 0x2f:
3545         {
3546           /** 0010 cond                 b%1.b   %a0 */
3547 #line 727 "rx-decode.opc"
3548           int cond AU = op[0] & 0x0f;
3549           if (trace)
3550             {
3551               printf ("\033[33m%s\033[0m  %02x\n",
3552                      "/** 0010 cond                     b%1.b   %a0 */",
3553                      op[0]);
3554               printf ("  cond = 0x%x\n", cond);
3555             }
3556           SYNTAX("b%1.b %a0");
3557 #line 727 "rx-decode.opc"
3558           ID(branch); Scc(cond); DC(pc + IMMex (1));
3559
3560         }
3561       break;
3562     case 0x2e:
3563         {
3564           /** 0010 1110                 bra.b   %a0 */
3565           if (trace)
3566             {
3567               printf ("\033[33m%s\033[0m  %02x\n",
3568                      "/** 0010 1110                     bra.b   %a0 */",
3569                      op[0]);
3570             }
3571           SYNTAX("bra.b %a0");
3572 #line 737 "rx-decode.opc"
3573           ID(branch); DC(pc + IMMex(1));
3574
3575         }
3576       break;
3577     case 0x38:
3578         {
3579           /** 0011 1000                 bra.w   %a0 */
3580           if (trace)
3581             {
3582               printf ("\033[33m%s\033[0m  %02x\n",
3583                      "/** 0011 1000                     bra.w   %a0 */",
3584                      op[0]);
3585             }
3586           SYNTAX("bra.w %a0");
3587 #line 740 "rx-decode.opc"
3588           ID(branch); DC(pc + IMMex(2));
3589
3590         }
3591       break;
3592     case 0x39:
3593         {
3594           /** 0011 1001                 bsr.w   %a0 */
3595           if (trace)
3596             {
3597               printf ("\033[33m%s\033[0m  %02x\n",
3598                      "/** 0011 1001                     bsr.w   %a0 */",
3599                      op[0]);
3600             }
3601           SYNTAX("bsr.w %a0");
3602 #line 756 "rx-decode.opc"
3603           ID(jsr); DC(pc + IMMex(2));
3604
3605         }
3606       break;
3607     case 0x3a:
3608     case 0x3b:
3609         {
3610           /** 0011 101c                 b%1.w   %a0 */
3611 #line 730 "rx-decode.opc"
3612           int c AU = op[0] & 0x01;
3613           if (trace)
3614             {
3615               printf ("\033[33m%s\033[0m  %02x\n",
3616                      "/** 0011 101c                     b%1.w   %a0 */",
3617                      op[0]);
3618               printf ("  c = 0x%x\n", c);
3619             }
3620           SYNTAX("b%1.w %a0");
3621 #line 730 "rx-decode.opc"
3622           ID(branch); Scc(c); DC(pc + IMMex (2));
3623
3624
3625         }
3626       break;
3627     case 0x3c:
3628         GETBYTE ();
3629         switch (op[1] & 0x00)
3630         {
3631           case 0x00:
3632             op_semantics_19:
3633               {
3634                 /** 0011 11sz d dst sppp                mov%s   #%1, %0 */
3635 #line 304 "rx-decode.opc"
3636                 int sz AU = op[0] & 0x03;
3637 #line 304 "rx-decode.opc"
3638                 int d AU = (op[1] >> 7) & 0x01;
3639 #line 304 "rx-decode.opc"
3640                 int dst AU = (op[1] >> 4) & 0x07;
3641 #line 304 "rx-decode.opc"
3642                 int sppp AU = op[1] & 0x0f;
3643                 if (trace)
3644                   {
3645                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3646                            "/** 0011 11sz d dst sppp            mov%s   #%1, %0 */",
3647                            op[0], op[1]);
3648                     printf ("  sz = 0x%x,", sz);
3649                     printf ("  d = 0x%x,", d);
3650                     printf ("  dst = 0x%x,", dst);
3651                     printf ("  sppp = 0x%x\n", sppp);
3652                   }
3653                 SYNTAX("mov%s   #%1, %0");
3654 #line 304 "rx-decode.opc"
3655                 ID(mov); sBWL (sz); DIs(dst, d*16+sppp, sz); SC(IMM(1)); F_____;
3656
3657               }
3658             break;
3659         }
3660       break;
3661     case 0x3d:
3662         GETBYTE ();
3663         switch (op[1] & 0x00)
3664         {
3665           case 0x00:
3666             goto op_semantics_19;
3667             break;
3668         }
3669       break;
3670     case 0x3e:
3671         GETBYTE ();
3672         switch (op[1] & 0x00)
3673         {
3674           case 0x00:
3675             goto op_semantics_19;
3676             break;
3677         }
3678       break;
3679     case 0x3f:
3680         GETBYTE ();
3681         switch (op[1] & 0x00)
3682         {
3683           case 0x00:
3684               {
3685                 /** 0011 1111 rega regb         rtsd    #%1, %2-%0 */
3686 #line 401 "rx-decode.opc"
3687                 int rega AU = (op[1] >> 4) & 0x0f;
3688 #line 401 "rx-decode.opc"
3689                 int regb AU = op[1] & 0x0f;
3690                 if (trace)
3691                   {
3692                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3693                            "/** 0011 1111 rega regb             rtsd    #%1, %2-%0 */",
3694                            op[0], op[1]);
3695                     printf ("  rega = 0x%x,", rega);
3696                     printf ("  regb = 0x%x\n", regb);
3697                   }
3698                 SYNTAX("rtsd    #%1, %2-%0");
3699 #line 401 "rx-decode.opc"
3700                 ID(rtsd); SC(IMM(1) * 4); S2R(rega); DR(regb);
3701
3702               /*----------------------------------------------------------------------*/
3703               /* AND                                                                    */
3704
3705               }
3706             break;
3707         }
3708       break;
3709     case 0x40:
3710         GETBYTE ();
3711         switch (op[1] & 0x00)
3712         {
3713           case 0x00:
3714             op_semantics_20:
3715               {
3716                 /** 0100 00ss rsrc rdst                 sub     %2%S2, %1 */
3717 #line 536 "rx-decode.opc"
3718                 int ss AU = op[0] & 0x03;
3719 #line 536 "rx-decode.opc"
3720                 int rsrc AU = (op[1] >> 4) & 0x0f;
3721 #line 536 "rx-decode.opc"
3722                 int rdst AU = op[1] & 0x0f;
3723                 if (trace)
3724                   {
3725                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3726                            "/** 0100 00ss rsrc rdst                     sub     %2%S2, %1 */",
3727                            op[0], op[1]);
3728                     printf ("  ss = 0x%x,", ss);
3729                     printf ("  rsrc = 0x%x,", rsrc);
3730                     printf ("  rdst = 0x%x\n", rdst);
3731                   }
3732                 SYNTAX("sub     %2%S2, %1");
3733 #line 536 "rx-decode.opc"
3734                 ID(sub); S2P(ss, rsrc); SR(rdst); DR(rdst); F_OSZC;
3735
3736               }
3737             break;
3738         }
3739       break;
3740     case 0x41:
3741         GETBYTE ();
3742         switch (op[1] & 0x00)
3743         {
3744           case 0x00:
3745             goto op_semantics_20;
3746             break;
3747         }
3748       break;
3749     case 0x42:
3750         GETBYTE ();
3751         switch (op[1] & 0x00)
3752         {
3753           case 0x00:
3754             goto op_semantics_20;
3755             break;
3756         }
3757       break;
3758     case 0x43:
3759         GETBYTE ();
3760         switch (op[1] & 0x00)
3761         {
3762           case 0x00:
3763             goto op_semantics_20;
3764             break;
3765         }
3766       break;
3767     case 0x44:
3768         GETBYTE ();
3769         switch (op[1] & 0x00)
3770         {
3771           case 0x00:
3772             op_semantics_21:
3773               {
3774                 /** 0100 01ss rsrc rdst         cmp     %2%S2, %1 */
3775 #line 524 "rx-decode.opc"
3776                 int ss AU = op[0] & 0x03;
3777 #line 524 "rx-decode.opc"
3778                 int rsrc AU = (op[1] >> 4) & 0x0f;
3779 #line 524 "rx-decode.opc"
3780                 int rdst AU = op[1] & 0x0f;
3781                 if (trace)
3782                   {
3783                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3784                            "/** 0100 01ss rsrc rdst             cmp     %2%S2, %1 */",
3785                            op[0], op[1]);
3786                     printf ("  ss = 0x%x,", ss);
3787                     printf ("  rsrc = 0x%x,", rsrc);
3788                     printf ("  rdst = 0x%x\n", rdst);
3789                   }
3790                 SYNTAX("cmp     %2%S2, %1");
3791 #line 524 "rx-decode.opc"
3792                 ID(sub); S2P(ss, rsrc); SR(rdst); F_OSZC;
3793
3794               }
3795             break;
3796         }
3797       break;
3798     case 0x45:
3799         GETBYTE ();
3800         switch (op[1] & 0x00)
3801         {
3802           case 0x00:
3803             goto op_semantics_21;
3804             break;
3805         }
3806       break;
3807     case 0x46:
3808         GETBYTE ();
3809         switch (op[1] & 0x00)
3810         {
3811           case 0x00:
3812             goto op_semantics_21;
3813             break;
3814         }
3815       break;
3816     case 0x47:
3817         GETBYTE ();
3818         switch (op[1] & 0x00)
3819         {
3820           case 0x00:
3821             goto op_semantics_21;
3822             break;
3823         }
3824       break;
3825     case 0x48:
3826         GETBYTE ();
3827         switch (op[1] & 0x00)
3828         {
3829           case 0x00:
3830             op_semantics_22:
3831               {
3832                 /** 0100 10ss rsrc rdst                 add     %1%S1, %0 */
3833 #line 500 "rx-decode.opc"
3834                 int ss AU = op[0] & 0x03;
3835 #line 500 "rx-decode.opc"
3836                 int rsrc AU = (op[1] >> 4) & 0x0f;
3837 #line 500 "rx-decode.opc"
3838                 int rdst AU = op[1] & 0x0f;
3839                 if (trace)
3840                   {
3841                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3842                            "/** 0100 10ss rsrc rdst                     add     %1%S1, %0 */",
3843                            op[0], op[1]);
3844                     printf ("  ss = 0x%x,", ss);
3845                     printf ("  rsrc = 0x%x,", rsrc);
3846                     printf ("  rdst = 0x%x\n", rdst);
3847                   }
3848                 SYNTAX("add     %1%S1, %0");
3849 #line 500 "rx-decode.opc"
3850                 ID(add); SP(ss, rsrc); DR(rdst); F_OSZC;
3851
3852               }
3853             break;
3854         }
3855       break;
3856     case 0x49:
3857         GETBYTE ();
3858         switch (op[1] & 0x00)
3859         {
3860           case 0x00:
3861             goto op_semantics_22;
3862             break;
3863         }
3864       break;
3865     case 0x4a:
3866         GETBYTE ();
3867         switch (op[1] & 0x00)
3868         {
3869           case 0x00:
3870             goto op_semantics_22;
3871             break;
3872         }
3873       break;
3874     case 0x4b:
3875         GETBYTE ();
3876         switch (op[1] & 0x00)
3877         {
3878           case 0x00:
3879             goto op_semantics_22;
3880             break;
3881         }
3882       break;
3883     case 0x4c:
3884         GETBYTE ();
3885         switch (op[1] & 0x00)
3886         {
3887           case 0x00:
3888             op_semantics_23:
3889               {
3890                 /** 0100 11ss rsrc rdst                 mul     %1%S1, %0 */
3891 #line 605 "rx-decode.opc"
3892                 int ss AU = op[0] & 0x03;
3893 #line 605 "rx-decode.opc"
3894                 int rsrc AU = (op[1] >> 4) & 0x0f;
3895 #line 605 "rx-decode.opc"
3896                 int rdst AU = op[1] & 0x0f;
3897                 if (trace)
3898                   {
3899                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3900                            "/** 0100 11ss rsrc rdst                     mul     %1%S1, %0 */",
3901                            op[0], op[1]);
3902                     printf ("  ss = 0x%x,", ss);
3903                     printf ("  rsrc = 0x%x,", rsrc);
3904                     printf ("  rdst = 0x%x\n", rdst);
3905                   }
3906                 SYNTAX("mul     %1%S1, %0");
3907 #line 605 "rx-decode.opc"
3908                 ID(mul); SP(ss, rsrc); DR(rdst); F_____;
3909
3910               }
3911             break;
3912         }
3913       break;
3914     case 0x4d:
3915         GETBYTE ();
3916         switch (op[1] & 0x00)
3917         {
3918           case 0x00:
3919             goto op_semantics_23;
3920             break;
3921         }
3922       break;
3923     case 0x4e:
3924         GETBYTE ();
3925         switch (op[1] & 0x00)
3926         {
3927           case 0x00:
3928             goto op_semantics_23;
3929             break;
3930         }
3931       break;
3932     case 0x4f:
3933         GETBYTE ();
3934         switch (op[1] & 0x00)
3935         {
3936           case 0x00:
3937             goto op_semantics_23;
3938             break;
3939         }
3940       break;
3941     case 0x50:
3942         GETBYTE ();
3943         switch (op[1] & 0x00)
3944         {
3945           case 0x00:
3946             op_semantics_24:
3947               {
3948                 /** 0101 00ss rsrc rdst                 and     %1%S1, %0 */
3949 #line 413 "rx-decode.opc"
3950                 int ss AU = op[0] & 0x03;
3951 #line 413 "rx-decode.opc"
3952                 int rsrc AU = (op[1] >> 4) & 0x0f;
3953 #line 413 "rx-decode.opc"
3954                 int rdst AU = op[1] & 0x0f;
3955                 if (trace)
3956                   {
3957                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3958                            "/** 0101 00ss rsrc rdst                     and     %1%S1, %0 */",
3959                            op[0], op[1]);
3960                     printf ("  ss = 0x%x,", ss);
3961                     printf ("  rsrc = 0x%x,", rsrc);
3962                     printf ("  rdst = 0x%x\n", rdst);
3963                   }
3964                 SYNTAX("and     %1%S1, %0");
3965 #line 413 "rx-decode.opc"
3966                 ID(and); SP(ss, rsrc); DR(rdst); F__SZ_;
3967
3968               }
3969             break;
3970         }
3971       break;
3972     case 0x51:
3973         GETBYTE ();
3974         switch (op[1] & 0x00)
3975         {
3976           case 0x00:
3977             goto op_semantics_24;
3978             break;
3979         }
3980       break;
3981     case 0x52:
3982         GETBYTE ();
3983         switch (op[1] & 0x00)
3984         {
3985           case 0x00:
3986             goto op_semantics_24;
3987             break;
3988         }
3989       break;
3990     case 0x53:
3991         GETBYTE ();
3992         switch (op[1] & 0x00)
3993         {
3994           case 0x00:
3995             goto op_semantics_24;
3996             break;
3997         }
3998       break;
3999     case 0x54:
4000         GETBYTE ();
4001         switch (op[1] & 0x00)
4002         {
4003           case 0x00:
4004             op_semantics_25:
4005               {
4006                 /** 0101 01ss rsrc rdst                 or      %1%S1, %0 */
4007 #line 431 "rx-decode.opc"
4008                 int ss AU = op[0] & 0x03;
4009 #line 431 "rx-decode.opc"
4010                 int rsrc AU = (op[1] >> 4) & 0x0f;
4011 #line 431 "rx-decode.opc"
4012                 int rdst AU = op[1] & 0x0f;
4013                 if (trace)
4014                   {
4015                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4016                            "/** 0101 01ss rsrc rdst                     or      %1%S1, %0 */",
4017                            op[0], op[1]);
4018                     printf ("  ss = 0x%x,", ss);
4019                     printf ("  rsrc = 0x%x,", rsrc);
4020                     printf ("  rdst = 0x%x\n", rdst);
4021                   }
4022                 SYNTAX("or      %1%S1, %0");
4023 #line 431 "rx-decode.opc"
4024                 ID(or); SP(ss, rsrc); DR(rdst); F__SZ_;
4025
4026               }
4027             break;
4028         }
4029       break;
4030     case 0x55:
4031         GETBYTE ();
4032         switch (op[1] & 0x00)
4033         {
4034           case 0x00:
4035             goto op_semantics_25;
4036             break;
4037         }
4038       break;
4039     case 0x56:
4040         GETBYTE ();
4041         switch (op[1] & 0x00)
4042         {
4043           case 0x00:
4044             goto op_semantics_25;
4045             break;
4046         }
4047       break;
4048     case 0x57:
4049         GETBYTE ();
4050         switch (op[1] & 0x00)
4051         {
4052           case 0x00:
4053             goto op_semantics_25;
4054             break;
4055         }
4056       break;
4057     case 0x58:
4058         GETBYTE ();
4059         switch (op[1] & 0x00)
4060         {
4061           case 0x00:
4062             op_semantics_26:
4063               {
4064                 /** 0101 1 s ss rsrc rdst       movu%s  %1, %0 */
4065 #line 352 "rx-decode.opc"
4066                 int s AU = (op[0] >> 2) & 0x01;
4067 #line 352 "rx-decode.opc"
4068                 int ss AU = op[0] & 0x03;
4069 #line 352 "rx-decode.opc"
4070                 int rsrc AU = (op[1] >> 4) & 0x0f;
4071 #line 352 "rx-decode.opc"
4072                 int rdst AU = op[1] & 0x0f;
4073                 if (trace)
4074                   {
4075                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4076                            "/** 0101 1 s ss rsrc rdst   movu%s  %1, %0 */",
4077                            op[0], op[1]);
4078                     printf ("  s = 0x%x,", s);
4079                     printf ("  ss = 0x%x,", ss);
4080                     printf ("  rsrc = 0x%x,", rsrc);
4081                     printf ("  rdst = 0x%x\n", rdst);
4082                   }
4083                 SYNTAX("movu%s  %1, %0");
4084 #line 352 "rx-decode.opc"
4085                 ID(mov); uBWL(s); SD(ss, rsrc, s); DR(rdst); F_____;
4086
4087               }
4088             break;
4089         }
4090       break;
4091     case 0x59:
4092         GETBYTE ();
4093         switch (op[1] & 0x00)
4094         {
4095           case 0x00:
4096             goto op_semantics_26;
4097             break;
4098         }
4099       break;
4100     case 0x5a:
4101         GETBYTE ();
4102         switch (op[1] & 0x00)
4103         {
4104           case 0x00:
4105             goto op_semantics_26;
4106             break;
4107         }
4108       break;
4109     case 0x5b:
4110         GETBYTE ();
4111         switch (op[1] & 0x00)
4112         {
4113           case 0x00:
4114             goto op_semantics_26;
4115             break;
4116         }
4117       break;
4118     case 0x5c:
4119         GETBYTE ();
4120         switch (op[1] & 0x00)
4121         {
4122           case 0x00:
4123             goto op_semantics_26;
4124             break;
4125         }
4126       break;
4127     case 0x5d:
4128         GETBYTE ();
4129         switch (op[1] & 0x00)
4130         {
4131           case 0x00:
4132             goto op_semantics_26;
4133             break;
4134         }
4135       break;
4136     case 0x5e:
4137         GETBYTE ();
4138         switch (op[1] & 0x00)
4139         {
4140           case 0x00:
4141             goto op_semantics_26;
4142             break;
4143         }
4144       break;
4145     case 0x5f:
4146         GETBYTE ();
4147         switch (op[1] & 0x00)
4148         {
4149           case 0x00:
4150             goto op_semantics_26;
4151             break;
4152         }
4153       break;
4154     case 0x60:
4155         GETBYTE ();
4156         switch (op[1] & 0x00)
4157         {
4158           case 0x00:
4159               {
4160                 /** 0110 0000 immm rdst                 sub     #%2, %0 */
4161 #line 533 "rx-decode.opc"
4162                 int immm AU = (op[1] >> 4) & 0x0f;
4163 #line 533 "rx-decode.opc"
4164                 int rdst AU = op[1] & 0x0f;
4165                 if (trace)
4166                   {
4167                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4168                            "/** 0110 0000 immm rdst                     sub     #%2, %0 */",
4169                            op[0], op[1]);
4170                     printf ("  immm = 0x%x,", immm);
4171                     printf ("  rdst = 0x%x\n", rdst);
4172                   }
4173                 SYNTAX("sub     #%2, %0");
4174 #line 533 "rx-decode.opc"
4175                 ID(sub); S2C(immm); SR(rdst); DR(rdst); F_OSZC;
4176
4177               }
4178             break;
4179         }
4180       break;
4181     case 0x61:
4182         GETBYTE ();
4183         switch (op[1] & 0x00)
4184         {
4185           case 0x00:
4186               {
4187                 /** 0110 0001 immm rdst                 cmp     #%2, %1 */
4188 #line 515 "rx-decode.opc"
4189                 int immm AU = (op[1] >> 4) & 0x0f;
4190 #line 515 "rx-decode.opc"
4191                 int rdst AU = op[1] & 0x0f;
4192                 if (trace)
4193                   {
4194                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4195                            "/** 0110 0001 immm rdst                     cmp     #%2, %1 */",
4196                            op[0], op[1]);
4197                     printf ("  immm = 0x%x,", immm);
4198                     printf ("  rdst = 0x%x\n", rdst);
4199                   }
4200                 SYNTAX("cmp     #%2, %1");
4201 #line 515 "rx-decode.opc"
4202                 ID(sub); S2C(immm); SR(rdst); F_OSZC;
4203
4204               }
4205             break;
4206         }
4207       break;
4208     case 0x62:
4209         GETBYTE ();
4210         switch (op[1] & 0x00)
4211         {
4212           case 0x00:
4213               {
4214                 /** 0110 0010 immm rdst                 add     #%1, %0 */
4215 #line 497 "rx-decode.opc"
4216                 int immm AU = (op[1] >> 4) & 0x0f;
4217 #line 497 "rx-decode.opc"
4218                 int rdst AU = op[1] & 0x0f;
4219                 if (trace)
4220                   {
4221                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4222                            "/** 0110 0010 immm rdst                     add     #%1, %0 */",
4223                            op[0], op[1]);
4224                     printf ("  immm = 0x%x,", immm);
4225                     printf ("  rdst = 0x%x\n", rdst);
4226                   }
4227                 SYNTAX("add     #%1, %0");
4228 #line 497 "rx-decode.opc"
4229                 ID(add); SC(immm); DR(rdst); F_OSZC;
4230
4231               }
4232             break;
4233         }
4234       break;
4235     case 0x63:
4236         GETBYTE ();
4237         switch (op[1] & 0x00)
4238         {
4239           case 0x00:
4240               {
4241                 /** 0110 0011 immm rdst                 mul     #%1, %0 */
4242 #line 599 "rx-decode.opc"
4243                 int immm AU = (op[1] >> 4) & 0x0f;
4244 #line 599 "rx-decode.opc"
4245                 int rdst AU = op[1] & 0x0f;
4246                 if (trace)
4247                   {
4248                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4249                            "/** 0110 0011 immm rdst                     mul     #%1, %0 */",
4250                            op[0], op[1]);
4251                     printf ("  immm = 0x%x,", immm);
4252                     printf ("  rdst = 0x%x\n", rdst);
4253                   }
4254                 SYNTAX("mul     #%1, %0");
4255 #line 599 "rx-decode.opc"
4256                 ID(mul); DR(rdst); SC(immm); F_____;
4257
4258               }
4259             break;
4260         }
4261       break;
4262     case 0x64:
4263         GETBYTE ();
4264         switch (op[1] & 0x00)
4265         {
4266           case 0x00:
4267               {
4268                 /** 0110 0100 immm rdst                 and     #%1, %0 */
4269 #line 407 "rx-decode.opc"
4270                 int immm AU = (op[1] >> 4) & 0x0f;
4271 #line 407 "rx-decode.opc"
4272                 int rdst AU = op[1] & 0x0f;
4273                 if (trace)
4274                   {
4275                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4276                            "/** 0110 0100 immm rdst                     and     #%1, %0 */",
4277                            op[0], op[1]);
4278                     printf ("  immm = 0x%x,", immm);
4279                     printf ("  rdst = 0x%x\n", rdst);
4280                   }
4281                 SYNTAX("and     #%1, %0");
4282 #line 407 "rx-decode.opc"
4283                 ID(and); SC(immm); DR(rdst); F__SZ_;
4284
4285               }
4286             break;
4287         }
4288       break;
4289     case 0x65:
4290         GETBYTE ();
4291         switch (op[1] & 0x00)
4292         {
4293           case 0x00:
4294               {
4295                 /** 0110 0101 immm rdst                 or      #%1, %0 */
4296 #line 425 "rx-decode.opc"
4297                 int immm AU = (op[1] >> 4) & 0x0f;
4298 #line 425 "rx-decode.opc"
4299                 int rdst AU = op[1] & 0x0f;
4300                 if (trace)
4301                   {
4302                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4303                            "/** 0110 0101 immm rdst                     or      #%1, %0 */",
4304                            op[0], op[1]);
4305                     printf ("  immm = 0x%x,", immm);
4306                     printf ("  rdst = 0x%x\n", rdst);
4307                   }
4308                 SYNTAX("or      #%1, %0");
4309 #line 425 "rx-decode.opc"
4310                 ID(or); SC(immm); DR(rdst); F__SZ_;
4311
4312               }
4313             break;
4314         }
4315       break;
4316     case 0x66:
4317         GETBYTE ();
4318         switch (op[1] & 0x00)
4319         {
4320           case 0x00:
4321               {
4322                 /** 0110 0110 immm rdst         mov%s   #%1, %0 */
4323 #line 301 "rx-decode.opc"
4324                 int immm AU = (op[1] >> 4) & 0x0f;
4325 #line 301 "rx-decode.opc"
4326                 int rdst AU = op[1] & 0x0f;
4327                 if (trace)
4328                   {
4329                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4330                            "/** 0110 0110 immm rdst             mov%s   #%1, %0 */",
4331                            op[0], op[1]);
4332                     printf ("  immm = 0x%x,", immm);
4333                     printf ("  rdst = 0x%x\n", rdst);
4334                   }
4335                 SYNTAX("mov%s   #%1, %0");
4336 #line 301 "rx-decode.opc"
4337                 ID(mov); DR(rdst); SC(immm); F_____;
4338
4339               }
4340             break;
4341         }
4342       break;
4343     case 0x67:
4344         {
4345           /** 0110 0111                 rtsd    #%1 */
4346           if (trace)
4347             {
4348               printf ("\033[33m%s\033[0m  %02x\n",
4349                      "/** 0110 0111                     rtsd    #%1 */",
4350                      op[0]);
4351             }
4352           SYNTAX("rtsd  #%1");
4353 #line 398 "rx-decode.opc"
4354           ID(rtsd); SC(IMM(1) * 4);
4355
4356         }
4357       break;
4358     case 0x68:
4359         GETBYTE ();
4360         switch (op[1] & 0x00)
4361         {
4362           case 0x00:
4363             op_semantics_27:
4364               {
4365                 /** 0110 100i mmmm rdst                 shlr    #%2, %0 */
4366 #line 685 "rx-decode.opc"
4367                 int i AU = op[0] & 0x01;
4368 #line 685 "rx-decode.opc"
4369                 int mmmm AU = (op[1] >> 4) & 0x0f;
4370 #line 685 "rx-decode.opc"
4371                 int rdst AU = op[1] & 0x0f;
4372                 if (trace)
4373                   {
4374                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4375                            "/** 0110 100i mmmm rdst                     shlr    #%2, %0 */",
4376                            op[0], op[1]);
4377                     printf ("  i = 0x%x,", i);
4378                     printf ("  mmmm = 0x%x,", mmmm);
4379                     printf ("  rdst = 0x%x\n", rdst);
4380                   }
4381                 SYNTAX("shlr    #%2, %0");
4382 #line 685 "rx-decode.opc"
4383                 ID(shlr); S2C(i*16+mmmm); SR(rdst); DR(rdst); F__SZC;
4384
4385               }
4386             break;
4387         }
4388       break;
4389     case 0x69:
4390         GETBYTE ();
4391         switch (op[1] & 0x00)
4392         {
4393           case 0x00:
4394             goto op_semantics_27;
4395             break;
4396         }
4397       break;
4398     case 0x6a:
4399         GETBYTE ();
4400         switch (op[1] & 0x00)
4401         {
4402           case 0x00:
4403             op_semantics_28:
4404               {
4405                 /** 0110 101i mmmm rdst                 shar    #%2, %0 */
4406 #line 675 "rx-decode.opc"
4407                 int i AU = op[0] & 0x01;
4408 #line 675 "rx-decode.opc"
4409                 int mmmm AU = (op[1] >> 4) & 0x0f;
4410 #line 675 "rx-decode.opc"
4411                 int rdst AU = op[1] & 0x0f;
4412                 if (trace)
4413                   {
4414                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4415                            "/** 0110 101i mmmm rdst                     shar    #%2, %0 */",
4416                            op[0], op[1]);
4417                     printf ("  i = 0x%x,", i);
4418                     printf ("  mmmm = 0x%x,", mmmm);
4419                     printf ("  rdst = 0x%x\n", rdst);
4420                   }
4421                 SYNTAX("shar    #%2, %0");
4422 #line 675 "rx-decode.opc"
4423                 ID(shar); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_0SZC;
4424
4425               }
4426             break;
4427         }
4428       break;
4429     case 0x6b:
4430         GETBYTE ();
4431         switch (op[1] & 0x00)
4432         {
4433           case 0x00:
4434             goto op_semantics_28;
4435             break;
4436         }
4437       break;
4438     case 0x6c:
4439         GETBYTE ();
4440         switch (op[1] & 0x00)
4441         {
4442           case 0x00:
4443             op_semantics_29:
4444               {
4445                 /** 0110 110i mmmm rdst                 shll    #%2, %0 */
4446 #line 665 "rx-decode.opc"
4447                 int i AU = op[0] & 0x01;
4448 #line 665 "rx-decode.opc"
4449                 int mmmm AU = (op[1] >> 4) & 0x0f;
4450 #line 665 "rx-decode.opc"
4451                 int rdst AU = op[1] & 0x0f;
4452                 if (trace)
4453                   {
4454                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4455                            "/** 0110 110i mmmm rdst                     shll    #%2, %0 */",
4456                            op[0], op[1]);
4457                     printf ("  i = 0x%x,", i);
4458                     printf ("  mmmm = 0x%x,", mmmm);
4459                     printf ("  rdst = 0x%x\n", rdst);
4460                   }
4461                 SYNTAX("shll    #%2, %0");
4462 #line 665 "rx-decode.opc"
4463                 ID(shll); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_OSZC;
4464
4465               }
4466             break;
4467         }
4468       break;
4469     case 0x6d:
4470         GETBYTE ();
4471         switch (op[1] & 0x00)
4472         {
4473           case 0x00:
4474             goto op_semantics_29;
4475             break;
4476         }
4477       break;
4478     case 0x6e:
4479         GETBYTE ();
4480         switch (op[1] & 0x00)
4481         {
4482           case 0x00:
4483               {
4484                 /** 0110 1110 dsta dstb         pushm   %1-%2 */
4485 #line 365 "rx-decode.opc"
4486                 int dsta AU = (op[1] >> 4) & 0x0f;
4487 #line 365 "rx-decode.opc"
4488                 int dstb AU = op[1] & 0x0f;
4489                 if (trace)
4490                   {
4491                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4492                            "/** 0110 1110 dsta dstb             pushm   %1-%2 */",
4493                            op[0], op[1]);
4494                     printf ("  dsta = 0x%x,", dsta);
4495                     printf ("  dstb = 0x%x\n", dstb);
4496                   }
4497                 SYNTAX("pushm   %1-%2");
4498 #line 365 "rx-decode.opc"
4499                 ID(pushm); SR(dsta); S2R(dstb); F_____;
4500
4501               }
4502             break;
4503         }
4504       break;
4505     case 0x6f:
4506         GETBYTE ();
4507         switch (op[1] & 0x00)
4508         {
4509           case 0x00:
4510               {
4511                 /** 0110 1111 dsta dstb         popm    %1-%2 */
4512 #line 362 "rx-decode.opc"
4513                 int dsta AU = (op[1] >> 4) & 0x0f;
4514 #line 362 "rx-decode.opc"
4515                 int dstb AU = op[1] & 0x0f;
4516                 if (trace)
4517                   {
4518                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4519                            "/** 0110 1111 dsta dstb             popm    %1-%2 */",
4520                            op[0], op[1]);
4521                     printf ("  dsta = 0x%x,", dsta);
4522                     printf ("  dstb = 0x%x\n", dstb);
4523                   }
4524                 SYNTAX("popm    %1-%2");
4525 #line 362 "rx-decode.opc"
4526                 ID(popm); SR(dsta); S2R(dstb); F_____;
4527
4528               }
4529             break;
4530         }
4531       break;
4532     case 0x70:
4533         GETBYTE ();
4534         switch (op[1] & 0x00)
4535         {
4536           case 0x00:
4537             op_semantics_30:
4538               {
4539                 /** 0111 00im rsrc rdst                 add     #%1, %2, %0 */
4540 #line 506 "rx-decode.opc"
4541                 int im AU = op[0] & 0x03;
4542 #line 506 "rx-decode.opc"
4543                 int rsrc AU = (op[1] >> 4) & 0x0f;
4544 #line 506 "rx-decode.opc"
4545                 int rdst AU = op[1] & 0x0f;
4546                 if (trace)
4547                   {
4548                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4549                            "/** 0111 00im rsrc rdst                     add     #%1, %2, %0 */",
4550                            op[0], op[1]);
4551                     printf ("  im = 0x%x,", im);
4552                     printf ("  rsrc = 0x%x,", rsrc);
4553                     printf ("  rdst = 0x%x\n", rdst);
4554                   }
4555                 SYNTAX("add     #%1, %2, %0");
4556 #line 506 "rx-decode.opc"
4557                 ID(add); SC(IMMex(im)); S2R(rsrc); DR(rdst); F_OSZC;
4558
4559               }
4560             break;
4561         }
4562       break;
4563     case 0x71:
4564         GETBYTE ();
4565         switch (op[1] & 0x00)
4566         {
4567           case 0x00:
4568             goto op_semantics_30;
4569             break;
4570         }
4571       break;
4572     case 0x72:
4573         GETBYTE ();
4574         switch (op[1] & 0x00)
4575         {
4576           case 0x00:
4577             goto op_semantics_30;
4578             break;
4579         }
4580       break;
4581     case 0x73:
4582         GETBYTE ();
4583         switch (op[1] & 0x00)
4584         {
4585           case 0x00:
4586             goto op_semantics_30;
4587             break;
4588         }
4589       break;
4590     case 0x74:
4591         GETBYTE ();
4592         switch (op[1] & 0xf0)
4593         {
4594           case 0x00:
4595             op_semantics_31:
4596               {
4597                 /** 0111 01im 0000 rsrc         cmp     #%2, %1%S1 */
4598 #line 518 "rx-decode.opc"
4599                 int im AU = op[0] & 0x03;
4600 #line 518 "rx-decode.opc"
4601                 int rsrc AU = op[1] & 0x0f;
4602                 if (trace)
4603                   {
4604                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4605                            "/** 0111 01im 0000 rsrc             cmp     #%2, %1%S1 */",
4606                            op[0], op[1]);
4607                     printf ("  im = 0x%x,", im);
4608                     printf ("  rsrc = 0x%x\n", rsrc);
4609                   }
4610                 SYNTAX("cmp     #%2, %1%S1");
4611 #line 518 "rx-decode.opc"
4612                 ID(sub); SR(rsrc); S2C(IMMex(im)); F_OSZC;
4613
4614               }
4615             break;
4616           case 0x10:
4617             op_semantics_32:
4618               {
4619                 /** 0111 01im 0001rdst                  mul     #%1, %0 */
4620 #line 602 "rx-decode.opc"
4621                 int im AU = op[0] & 0x03;
4622 #line 602 "rx-decode.opc"
4623                 int rdst AU = op[1] & 0x0f;
4624                 if (trace)
4625                   {
4626                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4627                            "/** 0111 01im 0001rdst                      mul     #%1, %0 */",
4628                            op[0], op[1]);
4629                     printf ("  im = 0x%x,", im);
4630                     printf ("  rdst = 0x%x\n", rdst);
4631                   }
4632                 SYNTAX("mul     #%1, %0");
4633 #line 602 "rx-decode.opc"
4634                 ID(mul); DR(rdst); SC(IMMex(im)); F_____;
4635
4636               }
4637             break;
4638           case 0x20:
4639             op_semantics_33:
4640               {
4641                 /** 0111 01im 0010 rdst                 and     #%1, %0 */
4642 #line 410 "rx-decode.opc"
4643                 int im AU = op[0] & 0x03;
4644 #line 410 "rx-decode.opc"
4645                 int rdst AU = op[1] & 0x0f;
4646                 if (trace)
4647                   {
4648                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4649                            "/** 0111 01im 0010 rdst                     and     #%1, %0 */",
4650                            op[0], op[1]);
4651                     printf ("  im = 0x%x,", im);
4652                     printf ("  rdst = 0x%x\n", rdst);
4653                   }
4654                 SYNTAX("and     #%1, %0");
4655 #line 410 "rx-decode.opc"
4656                 ID(and); SC(IMMex(im)); DR(rdst); F__SZ_;
4657
4658               }
4659             break;
4660           case 0x30:
4661             op_semantics_34:
4662               {
4663                 /** 0111 01im 0011 rdst                 or      #%1, %0 */
4664 #line 428 "rx-decode.opc"
4665                 int im AU = op[0] & 0x03;
4666 #line 428 "rx-decode.opc"
4667                 int rdst AU = op[1] & 0x0f;
4668                 if (trace)
4669                   {
4670                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4671                            "/** 0111 01im 0011 rdst                     or      #%1, %0 */",
4672                            op[0], op[1]);
4673                     printf ("  im = 0x%x,", im);
4674                     printf ("  rdst = 0x%x\n", rdst);
4675                   }
4676                 SYNTAX("or      #%1, %0");
4677 #line 428 "rx-decode.opc"
4678                 ID(or); SC(IMMex(im)); DR(rdst); F__SZ_;
4679
4680               }
4681             break;
4682           default: UNSUPPORTED(); break;
4683         }
4684       break;
4685     case 0x75:
4686         GETBYTE ();
4687         switch (op[1] & 0xff)
4688         {
4689           case 0x00:
4690           case 0x01:
4691           case 0x02:
4692           case 0x03:
4693           case 0x04:
4694           case 0x05:
4695           case 0x06:
4696           case 0x07:
4697           case 0x08:
4698           case 0x09:
4699           case 0x0a:
4700           case 0x0b:
4701           case 0x0c:
4702           case 0x0d:
4703           case 0x0e:
4704           case 0x0f:
4705             goto op_semantics_31;
4706             break;
4707           case 0x10:
4708           case 0x11:
4709           case 0x12:
4710           case 0x13:
4711           case 0x14:
4712           case 0x15:
4713           case 0x16:
4714           case 0x17:
4715           case 0x18:
4716           case 0x19:
4717           case 0x1a:
4718           case 0x1b:
4719           case 0x1c:
4720           case 0x1d:
4721           case 0x1e:
4722           case 0x1f:
4723             goto op_semantics_32;
4724             break;
4725           case 0x20:
4726           case 0x21:
4727           case 0x22:
4728           case 0x23:
4729           case 0x24:
4730           case 0x25:
4731           case 0x26:
4732           case 0x27:
4733           case 0x28:
4734           case 0x29:
4735           case 0x2a:
4736           case 0x2b:
4737           case 0x2c:
4738           case 0x2d:
4739           case 0x2e:
4740           case 0x2f:
4741             goto op_semantics_33;
4742             break;
4743           case 0x30:
4744           case 0x31:
4745           case 0x32:
4746           case 0x33:
4747           case 0x34:
4748           case 0x35:
4749           case 0x36:
4750           case 0x37:
4751           case 0x38:
4752           case 0x39:
4753           case 0x3a:
4754           case 0x3b:
4755           case 0x3c:
4756           case 0x3d:
4757           case 0x3e:
4758           case 0x3f:
4759             goto op_semantics_34;
4760             break;
4761           case 0x40:
4762           case 0x41:
4763           case 0x42:
4764           case 0x43:
4765           case 0x44:
4766           case 0x45:
4767           case 0x46:
4768           case 0x47:
4769           case 0x48:
4770           case 0x49:
4771           case 0x4a:
4772           case 0x4b:
4773           case 0x4c:
4774           case 0x4d:
4775           case 0x4e:
4776           case 0x4f:
4777               {
4778                 /** 0111 0101 0100 rdst         mov%s   #%1, %0 */
4779 #line 282 "rx-decode.opc"
4780                 int rdst AU = op[1] & 0x0f;
4781                 if (trace)
4782                   {
4783                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4784                            "/** 0111 0101 0100 rdst             mov%s   #%1, %0 */",
4785                            op[0], op[1]);
4786                     printf ("  rdst = 0x%x\n", rdst);
4787                   }
4788                 SYNTAX("mov%s   #%1, %0");
4789 #line 282 "rx-decode.opc"
4790                 ID(mov); DR(rdst); SC(IMM (1)); F_____;
4791
4792               }
4793             break;
4794           case 0x50:
4795           case 0x51:
4796           case 0x52:
4797           case 0x53:
4798           case 0x54:
4799           case 0x55:
4800           case 0x56:
4801           case 0x57:
4802           case 0x58:
4803           case 0x59:
4804           case 0x5a:
4805           case 0x5b:
4806           case 0x5c:
4807           case 0x5d:
4808           case 0x5e:
4809           case 0x5f:
4810               {
4811                 /** 0111 0101 0101 rsrc                 cmp     #%2, %1 */
4812 #line 521 "rx-decode.opc"
4813                 int rsrc AU = op[1] & 0x0f;
4814                 if (trace)
4815                   {
4816                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4817                            "/** 0111 0101 0101 rsrc                     cmp     #%2, %1 */",
4818                            op[0], op[1]);
4819                     printf ("  rsrc = 0x%x\n", rsrc);
4820                   }
4821                 SYNTAX("cmp     #%2, %1");
4822 #line 521 "rx-decode.opc"
4823                 ID(sub); SR(rsrc); S2C(IMM(1)); F_OSZC;
4824
4825               }
4826             break;
4827           case 0x60:
4828               {
4829                 /** 0111 0101 0110 0000         int #%1 */
4830                 if (trace)
4831                   {
4832                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4833                            "/** 0111 0101 0110 0000             int #%1 */",
4834                            op[0], op[1]);
4835                   }
4836                 SYNTAX("int #%1");
4837 #line 990 "rx-decode.opc"
4838                 ID(int); SC(IMM(1));
4839
4840               }
4841             break;
4842           case 0x70:
4843               GETBYTE ();
4844               switch (op[2] & 0xf0)
4845               {
4846                 case 0x00:
4847                     {
4848                       /** 0111 0101 0111 0000 0000 immm mvtipl  #%1 */
4849 #line 957 "rx-decode.opc"
4850                       int immm AU = op[2] & 0x0f;
4851                       if (trace)
4852                         {
4853                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
4854                                  "/** 0111 0101 0111 0000 0000 immm     mvtipl  #%1 */",
4855                                  op[0], op[1], op[2]);
4856                           printf ("  immm = 0x%x\n", immm);
4857                         }
4858                       SYNTAX("mvtipl    #%1");
4859 #line 957 "rx-decode.opc"
4860                       ID(mvtipl); SC(immm);
4861
4862                     }
4863                   break;
4864                 default: UNSUPPORTED(); break;
4865               }
4866             break;
4867           default: UNSUPPORTED(); break;
4868         }
4869       break;
4870     case 0x76:
4871         GETBYTE ();
4872         switch (op[1] & 0xf0)
4873         {
4874           case 0x00:
4875             goto op_semantics_31;
4876             break;
4877           case 0x10:
4878             goto op_semantics_32;
4879             break;
4880           case 0x20:
4881             goto op_semantics_33;
4882             break;
4883           case 0x30:
4884             goto op_semantics_34;
4885             break;
4886           default: UNSUPPORTED(); break;
4887         }
4888       break;
4889     case 0x77:
4890         GETBYTE ();
4891         switch (op[1] & 0xf0)
4892         {
4893           case 0x00:
4894             goto op_semantics_31;
4895             break;
4896           case 0x10:
4897             goto op_semantics_32;
4898             break;
4899           case 0x20:
4900             goto op_semantics_33;
4901             break;
4902           case 0x30:
4903             goto op_semantics_34;
4904             break;
4905           default: UNSUPPORTED(); break;
4906         }
4907       break;
4908     case 0x78:
4909         GETBYTE ();
4910         switch (op[1] & 0x00)
4911         {
4912           case 0x00:
4913             op_semantics_35:
4914               {
4915                 /** 0111 100b ittt rdst                 bset    #%1, %0 */
4916 #line 902 "rx-decode.opc"
4917                 int b AU = op[0] & 0x01;
4918 #line 902 "rx-decode.opc"
4919                 int ittt AU = (op[1] >> 4) & 0x0f;
4920 #line 902 "rx-decode.opc"
4921                 int rdst AU = op[1] & 0x0f;
4922                 if (trace)
4923                   {
4924                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4925                            "/** 0111 100b ittt rdst                     bset    #%1, %0 */",
4926                            op[0], op[1]);
4927                     printf ("  b = 0x%x,", b);
4928                     printf ("  ittt = 0x%x,", ittt);
4929                     printf ("  rdst = 0x%x\n", rdst);
4930                   }
4931                 SYNTAX("bset    #%1, %0");
4932 #line 902 "rx-decode.opc"
4933                 ID(bset); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____;
4934
4935
4936               }
4937             break;
4938         }
4939       break;
4940     case 0x79:
4941         GETBYTE ();
4942         switch (op[1] & 0x00)
4943         {
4944           case 0x00:
4945             goto op_semantics_35;
4946             break;
4947         }
4948       break;
4949     case 0x7a:
4950         GETBYTE ();
4951         switch (op[1] & 0x00)
4952         {
4953           case 0x00:
4954             op_semantics_36:
4955               {
4956                 /** 0111 101b ittt rdst                 bclr    #%1, %0 */
4957 #line 914 "rx-decode.opc"
4958                 int b AU = op[0] & 0x01;
4959 #line 914 "rx-decode.opc"
4960                 int ittt AU = (op[1] >> 4) & 0x0f;
4961 #line 914 "rx-decode.opc"
4962                 int rdst AU = op[1] & 0x0f;
4963                 if (trace)
4964                   {
4965                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4966                            "/** 0111 101b ittt rdst                     bclr    #%1, %0 */",
4967                            op[0], op[1]);
4968                     printf ("  b = 0x%x,", b);
4969                     printf ("  ittt = 0x%x,", ittt);
4970                     printf ("  rdst = 0x%x\n", rdst);
4971                   }
4972                 SYNTAX("bclr    #%1, %0");
4973 #line 914 "rx-decode.opc"
4974                 ID(bclr); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____;
4975
4976
4977               }
4978             break;
4979         }
4980       break;
4981     case 0x7b:
4982         GETBYTE ();
4983         switch (op[1] & 0x00)
4984         {
4985           case 0x00:
4986             goto op_semantics_36;
4987             break;
4988         }
4989       break;
4990     case 0x7c:
4991         GETBYTE ();
4992         switch (op[1] & 0x00)
4993         {
4994           case 0x00:
4995             op_semantics_37:
4996               {
4997                 /** 0111 110b ittt rdst                 btst    #%2, %1 */
4998 #line 926 "rx-decode.opc"
4999                 int b AU = op[0] & 0x01;
5000 #line 926 "rx-decode.opc"
5001                 int ittt AU = (op[1] >> 4) & 0x0f;
5002 #line 926 "rx-decode.opc"
5003                 int rdst AU = op[1] & 0x0f;
5004                 if (trace)
5005                   {
5006                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5007                            "/** 0111 110b ittt rdst                     btst    #%2, %1 */",
5008                            op[0], op[1]);
5009                     printf ("  b = 0x%x,", b);
5010                     printf ("  ittt = 0x%x,", ittt);
5011                     printf ("  rdst = 0x%x\n", rdst);
5012                   }
5013                 SYNTAX("btst    #%2, %1");
5014 #line 926 "rx-decode.opc"
5015                 ID(btst); BWL(LSIZE); S2C(b*16+ittt); SR(rdst); F___ZC;
5016
5017
5018               }
5019             break;
5020         }
5021       break;
5022     case 0x7d:
5023         GETBYTE ();
5024         switch (op[1] & 0x00)
5025         {
5026           case 0x00:
5027             goto op_semantics_37;
5028             break;
5029         }
5030       break;
5031     case 0x7e:
5032         GETBYTE ();
5033         switch (op[1] & 0xf0)
5034         {
5035           case 0x00:
5036               {
5037                 /** 0111 1110 0000 rdst                 not     %0 */
5038 #line 455 "rx-decode.opc"
5039                 int rdst AU = op[1] & 0x0f;
5040                 if (trace)
5041                   {
5042                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5043                            "/** 0111 1110 0000 rdst                     not     %0 */",
5044                            op[0], op[1]);
5045                     printf ("  rdst = 0x%x\n", rdst);
5046                   }
5047                 SYNTAX("not     %0");
5048 #line 455 "rx-decode.opc"
5049                 ID(xor); DR(rdst); SR(rdst); S2C(~0); F__SZ_;
5050
5051               }
5052             break;
5053           case 0x10:
5054               {
5055                 /** 0111 1110 0001 rdst                 neg     %0 */
5056 #line 476 "rx-decode.opc"
5057                 int rdst AU = op[1] & 0x0f;
5058                 if (trace)
5059                   {
5060                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5061                            "/** 0111 1110 0001 rdst                     neg     %0 */",
5062                            op[0], op[1]);
5063                     printf ("  rdst = 0x%x\n", rdst);
5064                   }
5065                 SYNTAX("neg     %0");
5066 #line 476 "rx-decode.opc"
5067                 ID(sub); DR(rdst); SC(0); S2R(rdst); F_OSZC;
5068
5069               }
5070             break;
5071           case 0x20:
5072               {
5073                 /** 0111 1110 0010 rdst                 abs     %0 */
5074 #line 558 "rx-decode.opc"
5075                 int rdst AU = op[1] & 0x0f;
5076                 if (trace)
5077                   {
5078                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5079                            "/** 0111 1110 0010 rdst                     abs     %0 */",
5080                            op[0], op[1]);
5081                     printf ("  rdst = 0x%x\n", rdst);
5082                   }
5083                 SYNTAX("abs     %0");
5084 #line 558 "rx-decode.opc"
5085                 ID(abs); DR(rdst); SR(rdst); F_OSZ_;
5086
5087               }
5088             break;
5089           case 0x30:
5090               {
5091                 /** 0111 1110 0011 rdst         sat     %0 */
5092 #line 840 "rx-decode.opc"
5093                 int rdst AU = op[1] & 0x0f;
5094                 if (trace)
5095                   {
5096                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5097                            "/** 0111 1110 0011 rdst             sat     %0 */",
5098                            op[0], op[1]);
5099                     printf ("  rdst = 0x%x\n", rdst);
5100                   }
5101                 SYNTAX("sat     %0");
5102 #line 840 "rx-decode.opc"
5103                 ID(sat); DR (rdst);
5104
5105               }
5106             break;
5107           case 0x40:
5108               {
5109                 /** 0111 1110 0100 rdst                 rorc    %0 */
5110 #line 700 "rx-decode.opc"
5111                 int rdst AU = op[1] & 0x0f;
5112                 if (trace)
5113                   {
5114                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5115                            "/** 0111 1110 0100 rdst                     rorc    %0 */",
5116                            op[0], op[1]);
5117                     printf ("  rdst = 0x%x\n", rdst);
5118                   }
5119                 SYNTAX("rorc    %0");
5120 #line 700 "rx-decode.opc"
5121                 ID(rorc); DR(rdst); F__SZC;
5122
5123               }
5124             break;
5125           case 0x50:
5126               {
5127                 /** 0111 1110 0101 rdst                 rolc    %0 */
5128 #line 697 "rx-decode.opc"
5129                 int rdst AU = op[1] & 0x0f;
5130                 if (trace)
5131                   {
5132                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5133                            "/** 0111 1110 0101 rdst                     rolc    %0 */",
5134                            op[0], op[1]);
5135                     printf ("  rdst = 0x%x\n", rdst);
5136                   }
5137                 SYNTAX("rolc    %0");
5138 #line 697 "rx-decode.opc"
5139                 ID(rolc); DR(rdst); F__SZC;
5140
5141               }
5142             break;
5143           case 0x80:
5144           case 0x90:
5145           case 0xa0:
5146               {
5147                 /** 0111 1110 10sz rsrc         push%s  %1 */
5148 #line 371 "rx-decode.opc"
5149                 int sz AU = (op[1] >> 4) & 0x03;
5150 #line 371 "rx-decode.opc"
5151                 int rsrc AU = op[1] & 0x0f;
5152                 if (trace)
5153                   {
5154                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5155                            "/** 0111 1110 10sz rsrc             push%s  %1 */",
5156                            op[0], op[1]);
5157                     printf ("  sz = 0x%x,", sz);
5158                     printf ("  rsrc = 0x%x\n", rsrc);
5159                   }
5160                 SYNTAX("push%s  %1");
5161 #line 371 "rx-decode.opc"
5162                 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SR(rsrc); F_____;
5163
5164               }
5165             break;
5166           case 0xb0:
5167               {
5168                 /** 0111 1110 1011 rdst         pop     %0 */
5169 #line 368 "rx-decode.opc"
5170                 int rdst AU = op[1] & 0x0f;
5171                 if (trace)
5172                   {
5173                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5174                            "/** 0111 1110 1011 rdst             pop     %0 */",
5175                            op[0], op[1]);
5176                     printf ("  rdst = 0x%x\n", rdst);
5177                   }
5178                 SYNTAX("pop     %0");
5179 #line 368 "rx-decode.opc"
5180                 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(rdst); F_____;
5181
5182               }
5183             break;
5184           case 0xc0:
5185           case 0xd0:
5186               {
5187                 /** 0111 1110 110 crsrc                 pushc   %1 */
5188 #line 963 "rx-decode.opc"
5189                 int crsrc AU = op[1] & 0x1f;
5190                 if (trace)
5191                   {
5192                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5193                            "/** 0111 1110 110 crsrc                     pushc   %1 */",
5194                            op[0], op[1]);
5195                     printf ("  crsrc = 0x%x\n", crsrc);
5196                   }
5197                 SYNTAX("pushc   %1");
5198 #line 963 "rx-decode.opc"
5199                 ID(mov); OP(0, RX_Operand_Predec, 0, 0); SR(crsrc + 16);
5200
5201               }
5202             break;
5203           case 0xe0:
5204           case 0xf0:
5205               {
5206                 /** 0111 1110 111 crdst                 popc    %0 */
5207 #line 960 "rx-decode.opc"
5208                 int crdst AU = op[1] & 0x1f;
5209                 if (trace)
5210                   {
5211                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5212                            "/** 0111 1110 111 crdst                     popc    %0 */",
5213                            op[0], op[1]);
5214                     printf ("  crdst = 0x%x\n", crdst);
5215                   }
5216                 SYNTAX("popc    %0");
5217 #line 960 "rx-decode.opc"
5218                 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(crdst + 16);
5219
5220               }
5221             break;
5222           default: UNSUPPORTED(); break;
5223         }
5224       break;
5225     case 0x7f:
5226         GETBYTE ();
5227         switch (op[1] & 0xff)
5228         {
5229           case 0x00:
5230           case 0x01:
5231           case 0x02:
5232           case 0x03:
5233           case 0x04:
5234           case 0x05:
5235           case 0x06:
5236           case 0x07:
5237           case 0x08:
5238           case 0x09:
5239           case 0x0a:
5240           case 0x0b:
5241           case 0x0c:
5242           case 0x0d:
5243           case 0x0e:
5244           case 0x0f:
5245               {
5246                 /** 0111 1111 0000 rsrc         jmp     %0 */
5247 #line 750 "rx-decode.opc"
5248                 int rsrc AU = op[1] & 0x0f;
5249                 if (trace)
5250                   {
5251                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5252                            "/** 0111 1111 0000 rsrc             jmp     %0 */",
5253                            op[0], op[1]);
5254                     printf ("  rsrc = 0x%x\n", rsrc);
5255                   }
5256                 SYNTAX("jmp     %0");
5257 #line 750 "rx-decode.opc"
5258                 ID(branch); DR(rsrc);
5259
5260               }
5261             break;
5262           case 0x10:
5263           case 0x11:
5264           case 0x12:
5265           case 0x13:
5266           case 0x14:
5267           case 0x15:
5268           case 0x16:
5269           case 0x17:
5270           case 0x18:
5271           case 0x19:
5272           case 0x1a:
5273           case 0x1b:
5274           case 0x1c:
5275           case 0x1d:
5276           case 0x1e:
5277           case 0x1f:
5278               {
5279                 /** 0111 1111 0001 rsrc         jsr     %0 */
5280 #line 753 "rx-decode.opc"
5281                 int rsrc AU = op[1] & 0x0f;
5282                 if (trace)
5283                   {
5284                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5285                            "/** 0111 1111 0001 rsrc             jsr     %0 */",
5286                            op[0], op[1]);
5287                     printf ("  rsrc = 0x%x\n", rsrc);
5288                   }
5289                 SYNTAX("jsr     %0");
5290 #line 753 "rx-decode.opc"
5291                 ID(jsr); DR(rsrc);
5292
5293               }
5294             break;
5295           case 0x40:
5296           case 0x41:
5297           case 0x42:
5298           case 0x43:
5299           case 0x44:
5300           case 0x45:
5301           case 0x46:
5302           case 0x47:
5303           case 0x48:
5304           case 0x49:
5305           case 0x4a:
5306           case 0x4b:
5307           case 0x4c:
5308           case 0x4d:
5309           case 0x4e:
5310           case 0x4f:
5311               {
5312                 /** 0111 1111 0100 rsrc         bra.l   %0 */
5313 #line 746 "rx-decode.opc"
5314                 int rsrc AU = op[1] & 0x0f;
5315                 if (trace)
5316                   {
5317                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5318                            "/** 0111 1111 0100 rsrc             bra.l   %0 */",
5319                            op[0], op[1]);
5320                     printf ("  rsrc = 0x%x\n", rsrc);
5321                   }
5322                 SYNTAX("bra.l   %0");
5323 #line 746 "rx-decode.opc"
5324                 ID(branchrel); DR(rsrc);
5325
5326
5327               }
5328             break;
5329           case 0x50:
5330           case 0x51:
5331           case 0x52:
5332           case 0x53:
5333           case 0x54:
5334           case 0x55:
5335           case 0x56:
5336           case 0x57:
5337           case 0x58:
5338           case 0x59:
5339           case 0x5a:
5340           case 0x5b:
5341           case 0x5c:
5342           case 0x5d:
5343           case 0x5e:
5344           case 0x5f:
5345               {
5346                 /** 0111 1111 0101 rsrc         bsr.l   %0 */
5347 #line 762 "rx-decode.opc"
5348                 int rsrc AU = op[1] & 0x0f;
5349                 if (trace)
5350                   {
5351                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5352                            "/** 0111 1111 0101 rsrc             bsr.l   %0 */",
5353                            op[0], op[1]);
5354                     printf ("  rsrc = 0x%x\n", rsrc);
5355                   }
5356                 SYNTAX("bsr.l   %0");
5357 #line 762 "rx-decode.opc"
5358                 ID(jsrrel); DR(rsrc);
5359
5360               }
5361             break;
5362           case 0x80:
5363           case 0x81:
5364           case 0x82:
5365               {
5366                 /** 0111 1111 1000 00sz         suntil%s */
5367 #line 786 "rx-decode.opc"
5368                 int sz AU = op[1] & 0x03;
5369                 if (trace)
5370                   {
5371                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5372                            "/** 0111 1111 1000 00sz             suntil%s */",
5373                            op[0], op[1]);
5374                     printf ("  sz = 0x%x\n", sz);
5375                   }
5376                 SYNTAX("suntil%s");
5377 #line 786 "rx-decode.opc"
5378                 ID(suntil); BWL(sz); F___ZC;
5379
5380               }
5381             break;
5382           case 0x83:
5383               {
5384                 /** 0111 1111 1000 0011         scmpu */
5385                 if (trace)
5386                   {
5387                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5388                            "/** 0111 1111 1000 0011             scmpu */",
5389                            op[0], op[1]);
5390                   }
5391                 SYNTAX("scmpu");
5392 #line 777 "rx-decode.opc"
5393                 ID(scmpu); F___ZC;
5394
5395               }
5396             break;
5397           case 0x84:
5398           case 0x85:
5399           case 0x86:
5400               {
5401                 /** 0111 1111 1000 01sz         swhile%s */
5402 #line 789 "rx-decode.opc"
5403                 int sz AU = op[1] & 0x03;
5404                 if (trace)
5405                   {
5406                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5407                            "/** 0111 1111 1000 01sz             swhile%s */",
5408                            op[0], op[1]);
5409                     printf ("  sz = 0x%x\n", sz);
5410                   }
5411                 SYNTAX("swhile%s");
5412 #line 789 "rx-decode.opc"
5413                 ID(swhile); BWL(sz); F___ZC;
5414
5415               }
5416             break;
5417           case 0x87:
5418               {
5419                 /** 0111 1111 1000 0111         smovu */
5420                 if (trace)
5421                   {
5422                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5423                            "/** 0111 1111 1000 0111             smovu */",
5424                            op[0], op[1]);
5425                   }
5426                 SYNTAX("smovu");
5427 #line 780 "rx-decode.opc"
5428                 ID(smovu);
5429
5430               }
5431             break;
5432           case 0x88:
5433           case 0x89:
5434           case 0x8a:
5435               {
5436                 /** 0111 1111 1000 10sz         sstr%s */
5437 #line 795 "rx-decode.opc"
5438                 int sz AU = op[1] & 0x03;
5439                 if (trace)
5440                   {
5441                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5442                            "/** 0111 1111 1000 10sz             sstr%s */",
5443                            op[0], op[1]);
5444                     printf ("  sz = 0x%x\n", sz);
5445                   }
5446                 SYNTAX("sstr%s");
5447 #line 795 "rx-decode.opc"
5448                 ID(sstr); BWL(sz);
5449
5450               /*----------------------------------------------------------------------*/
5451               /* RMPA                                                                   */
5452
5453               }
5454             break;
5455           case 0x8b:
5456               {
5457                 /** 0111 1111 1000 1011         smovb */
5458                 if (trace)
5459                   {
5460                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5461                            "/** 0111 1111 1000 1011             smovb */",
5462                            op[0], op[1]);
5463                   }
5464                 SYNTAX("smovb");
5465 #line 783 "rx-decode.opc"
5466                 ID(smovb);
5467
5468               }
5469             break;
5470           case 0x8c:
5471           case 0x8d:
5472           case 0x8e:
5473               {
5474                 /** 0111 1111 1000 11sz         rmpa%s */
5475 #line 801 "rx-decode.opc"
5476                 int sz AU = op[1] & 0x03;
5477                 if (trace)
5478                   {
5479                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5480                            "/** 0111 1111 1000 11sz             rmpa%s */",
5481                            op[0], op[1]);
5482                     printf ("  sz = 0x%x\n", sz);
5483                   }
5484                 SYNTAX("rmpa%s");
5485 #line 801 "rx-decode.opc"
5486                 ID(rmpa); BWL(sz); F_OS__;
5487
5488               /*----------------------------------------------------------------------*/
5489               /* HI/LO stuff                                                            */
5490
5491               }
5492             break;
5493           case 0x8f:
5494               {
5495                 /** 0111 1111 1000 1111         smovf */
5496                 if (trace)
5497                   {
5498                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5499                            "/** 0111 1111 1000 1111             smovf */",
5500                            op[0], op[1]);
5501                   }
5502                 SYNTAX("smovf");
5503 #line 792 "rx-decode.opc"
5504                 ID(smovf);
5505
5506               }
5507             break;
5508           case 0x93:
5509               {
5510                 /** 0111 1111 1001 0011         satr */
5511                 if (trace)
5512                   {
5513                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5514                            "/** 0111 1111 1001 0011             satr */",
5515                            op[0], op[1]);
5516                   }
5517                 SYNTAX("satr");
5518 #line 843 "rx-decode.opc"
5519                 ID(satr);
5520
5521               /*----------------------------------------------------------------------*/
5522               /* FLOAT                                                          */
5523
5524               }
5525             break;
5526           case 0x94:
5527               {
5528                 /** 0111 1111 1001 0100         rtfi */
5529                 if (trace)
5530                   {
5531                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5532                            "/** 0111 1111 1001 0100             rtfi */",
5533                            op[0], op[1]);
5534                   }
5535                 SYNTAX("rtfi");
5536 #line 978 "rx-decode.opc"
5537                 ID(rtfi);
5538
5539               }
5540             break;
5541           case 0x95:
5542               {
5543                 /** 0111 1111 1001 0101         rte */
5544                 if (trace)
5545                   {
5546                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5547                            "/** 0111 1111 1001 0101             rte */",
5548                            op[0], op[1]);
5549                   }
5550                 SYNTAX("rte");
5551 #line 981 "rx-decode.opc"
5552                 ID(rte);
5553
5554               }
5555             break;
5556           case 0x96:
5557               {
5558                 /** 0111 1111 1001 0110         wait */
5559                 if (trace)
5560                   {
5561                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5562                            "/** 0111 1111 1001 0110             wait */",
5563                            op[0], op[1]);
5564                   }
5565                 SYNTAX("wait");
5566 #line 993 "rx-decode.opc"
5567                 ID(wait);
5568
5569               /*----------------------------------------------------------------------*/
5570               /* SCcnd                                                          */
5571
5572               }
5573             break;
5574           case 0xa0:
5575           case 0xa1:
5576           case 0xa2:
5577           case 0xa3:
5578           case 0xa4:
5579           case 0xa5:
5580           case 0xa6:
5581           case 0xa7:
5582           case 0xa8:
5583           case 0xa9:
5584           case 0xaa:
5585           case 0xab:
5586           case 0xac:
5587           case 0xad:
5588           case 0xae:
5589           case 0xaf:
5590               {
5591                 /** 0111 1111 1010 rdst                 setpsw  %0 */
5592 #line 954 "rx-decode.opc"
5593                 int rdst AU = op[1] & 0x0f;
5594                 if (trace)
5595                   {
5596                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5597                            "/** 0111 1111 1010 rdst                     setpsw  %0 */",
5598                            op[0], op[1]);
5599                     printf ("  rdst = 0x%x\n", rdst);
5600                   }
5601                 SYNTAX("setpsw  %0");
5602 #line 954 "rx-decode.opc"
5603                 ID(setpsw); DF(rdst);
5604
5605               }
5606             break;
5607           case 0xb0:
5608           case 0xb1:
5609           case 0xb2:
5610           case 0xb3:
5611           case 0xb4:
5612           case 0xb5:
5613           case 0xb6:
5614           case 0xb7:
5615           case 0xb8:
5616           case 0xb9:
5617           case 0xba:
5618           case 0xbb:
5619           case 0xbc:
5620           case 0xbd:
5621           case 0xbe:
5622           case 0xbf:
5623               {
5624                 /** 0111 1111 1011 rdst                 clrpsw  %0 */
5625 #line 951 "rx-decode.opc"
5626                 int rdst AU = op[1] & 0x0f;
5627                 if (trace)
5628                   {
5629                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5630                            "/** 0111 1111 1011 rdst                     clrpsw  %0 */",
5631                            op[0], op[1]);
5632                     printf ("  rdst = 0x%x\n", rdst);
5633                   }
5634                 SYNTAX("clrpsw  %0");
5635 #line 951 "rx-decode.opc"
5636                 ID(clrpsw); DF(rdst);
5637
5638               }
5639             break;
5640           default: UNSUPPORTED(); break;
5641         }
5642       break;
5643     case 0x80:
5644         GETBYTE ();
5645         switch (op[1] & 0x00)
5646         {
5647           case 0x00:
5648             op_semantics_38:
5649               {
5650                 /** 10sz 0dsp a dst b src       mov%s   %1, %0 */
5651 #line 329 "rx-decode.opc"
5652                 int sz AU = (op[0] >> 4) & 0x03;
5653 #line 329 "rx-decode.opc"
5654                 int dsp AU = op[0] & 0x07;
5655 #line 329 "rx-decode.opc"
5656                 int a AU = (op[1] >> 7) & 0x01;
5657 #line 329 "rx-decode.opc"
5658                 int dst AU = (op[1] >> 4) & 0x07;
5659 #line 329 "rx-decode.opc"
5660                 int b AU = (op[1] >> 3) & 0x01;
5661 #line 329 "rx-decode.opc"
5662                 int src AU = op[1] & 0x07;
5663                 if (trace)
5664                   {
5665                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5666                            "/** 10sz 0dsp a dst b src   mov%s   %1, %0 */",
5667                            op[0], op[1]);
5668                     printf ("  sz = 0x%x,", sz);
5669                     printf ("  dsp = 0x%x,", dsp);
5670                     printf ("  a = 0x%x,", a);
5671                     printf ("  dst = 0x%x,", dst);
5672                     printf ("  b = 0x%x,", b);
5673                     printf ("  src = 0x%x\n", src);
5674                   }
5675                 SYNTAX("mov%s   %1, %0");
5676 #line 329 "rx-decode.opc"
5677                 ID(mov); sBWL(sz); DIs(dst, dsp*4+a*2+b, sz); SR(src); F_____;
5678
5679               }
5680             break;
5681         }
5682       break;
5683     case 0x81:
5684         GETBYTE ();
5685         switch (op[1] & 0x00)
5686         {
5687           case 0x00:
5688             goto op_semantics_38;
5689             break;
5690         }
5691       break;
5692     case 0x82:
5693         GETBYTE ();
5694         switch (op[1] & 0x00)
5695         {
5696           case 0x00:
5697             goto op_semantics_38;
5698             break;
5699         }
5700       break;
5701     case 0x83:
5702         GETBYTE ();
5703         switch (op[1] & 0x00)
5704         {
5705           case 0x00:
5706             goto op_semantics_38;
5707             break;
5708         }
5709       break;
5710     case 0x84:
5711         GETBYTE ();
5712         switch (op[1] & 0x00)
5713         {
5714           case 0x00:
5715             goto op_semantics_38;
5716             break;
5717         }
5718       break;
5719     case 0x85:
5720         GETBYTE ();
5721         switch (op[1] & 0x00)
5722         {
5723           case 0x00:
5724             goto op_semantics_38;
5725             break;
5726         }
5727       break;
5728     case 0x86:
5729         GETBYTE ();
5730         switch (op[1] & 0x00)
5731         {
5732           case 0x00:
5733             goto op_semantics_38;
5734             break;
5735         }
5736       break;
5737     case 0x87:
5738         GETBYTE ();
5739         switch (op[1] & 0x00)
5740         {
5741           case 0x00:
5742             goto op_semantics_38;
5743             break;
5744         }
5745       break;
5746     case 0x88:
5747         GETBYTE ();
5748         switch (op[1] & 0x00)
5749         {
5750           case 0x00:
5751             op_semantics_39:
5752               {
5753                 /** 10sz 1dsp a src b dst       mov%s   %1, %0 */
5754 #line 326 "rx-decode.opc"
5755                 int sz AU = (op[0] >> 4) & 0x03;
5756 #line 326 "rx-decode.opc"
5757                 int dsp AU = op[0] & 0x07;
5758 #line 326 "rx-decode.opc"
5759                 int a AU = (op[1] >> 7) & 0x01;
5760 #line 326 "rx-decode.opc"
5761                 int src AU = (op[1] >> 4) & 0x07;
5762 #line 326 "rx-decode.opc"
5763                 int b AU = (op[1] >> 3) & 0x01;
5764 #line 326 "rx-decode.opc"
5765                 int dst AU = op[1] & 0x07;
5766                 if (trace)
5767                   {
5768                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5769                            "/** 10sz 1dsp a src b dst   mov%s   %1, %0 */",
5770                            op[0], op[1]);
5771                     printf ("  sz = 0x%x,", sz);
5772                     printf ("  dsp = 0x%x,", dsp);
5773                     printf ("  a = 0x%x,", a);
5774                     printf ("  src = 0x%x,", src);
5775                     printf ("  b = 0x%x,", b);
5776                     printf ("  dst = 0x%x\n", dst);
5777                   }
5778                 SYNTAX("mov%s   %1, %0");
5779 #line 326 "rx-decode.opc"
5780                 ID(mov); sBWL(sz); DR(dst); SIs(src, dsp*4+a*2+b, sz); F_____;
5781
5782               }
5783             break;
5784         }
5785       break;
5786     case 0x89:
5787         GETBYTE ();
5788         switch (op[1] & 0x00)
5789         {
5790           case 0x00:
5791             goto op_semantics_39;
5792             break;
5793         }
5794       break;
5795     case 0x8a:
5796         GETBYTE ();
5797         switch (op[1] & 0x00)
5798         {
5799           case 0x00:
5800             goto op_semantics_39;
5801             break;
5802         }
5803       break;
5804     case 0x8b:
5805         GETBYTE ();
5806         switch (op[1] & 0x00)
5807         {
5808           case 0x00:
5809             goto op_semantics_39;
5810             break;
5811         }
5812       break;
5813     case 0x8c:
5814         GETBYTE ();
5815         switch (op[1] & 0x00)
5816         {
5817           case 0x00:
5818             goto op_semantics_39;
5819             break;
5820         }
5821       break;
5822     case 0x8d:
5823         GETBYTE ();
5824         switch (op[1] & 0x00)
5825         {
5826           case 0x00:
5827             goto op_semantics_39;
5828             break;
5829         }
5830       break;
5831     case 0x8e:
5832         GETBYTE ();
5833         switch (op[1] & 0x00)
5834         {
5835           case 0x00:
5836             goto op_semantics_39;
5837             break;
5838         }
5839       break;
5840     case 0x8f:
5841         GETBYTE ();
5842         switch (op[1] & 0x00)
5843         {
5844           case 0x00:
5845             goto op_semantics_39;
5846             break;
5847         }
5848       break;
5849     case 0x90:
5850         GETBYTE ();
5851         switch (op[1] & 0x00)
5852         {
5853           case 0x00:
5854             goto op_semantics_38;
5855             break;
5856         }
5857       break;
5858     case 0x91:
5859         GETBYTE ();
5860         switch (op[1] & 0x00)
5861         {
5862           case 0x00:
5863             goto op_semantics_38;
5864             break;
5865         }
5866       break;
5867     case 0x92:
5868         GETBYTE ();
5869         switch (op[1] & 0x00)
5870         {
5871           case 0x00:
5872             goto op_semantics_38;
5873             break;
5874         }
5875       break;
5876     case 0x93:
5877         GETBYTE ();
5878         switch (op[1] & 0x00)
5879         {
5880           case 0x00:
5881             goto op_semantics_38;
5882             break;
5883         }
5884       break;
5885     case 0x94:
5886         GETBYTE ();
5887         switch (op[1] & 0x00)
5888         {
5889           case 0x00:
5890             goto op_semantics_38;
5891             break;
5892         }
5893       break;
5894     case 0x95:
5895         GETBYTE ();
5896         switch (op[1] & 0x00)
5897         {
5898           case 0x00:
5899             goto op_semantics_38;
5900             break;
5901         }
5902       break;
5903     case 0x96:
5904         GETBYTE ();
5905         switch (op[1] & 0x00)
5906         {
5907           case 0x00:
5908             goto op_semantics_38;
5909             break;
5910         }
5911       break;
5912     case 0x97:
5913         GETBYTE ();
5914         switch (op[1] & 0x00)
5915         {
5916           case 0x00:
5917             goto op_semantics_38;
5918             break;
5919         }
5920       break;
5921     case 0x98:
5922         GETBYTE ();
5923         switch (op[1] & 0x00)
5924         {
5925           case 0x00:
5926             goto op_semantics_39;
5927             break;
5928         }
5929       break;
5930     case 0x99:
5931         GETBYTE ();
5932         switch (op[1] & 0x00)
5933         {
5934           case 0x00:
5935             goto op_semantics_39;
5936             break;
5937         }
5938       break;
5939     case 0x9a:
5940         GETBYTE ();
5941         switch (op[1] & 0x00)
5942         {
5943           case 0x00:
5944             goto op_semantics_39;
5945             break;
5946         }
5947       break;
5948     case 0x9b:
5949         GETBYTE ();
5950         switch (op[1] & 0x00)
5951         {
5952           case 0x00:
5953             goto op_semantics_39;
5954             break;
5955         }
5956       break;
5957     case 0x9c:
5958         GETBYTE ();
5959         switch (op[1] & 0x00)
5960         {
5961           case 0x00:
5962             goto op_semantics_39;
5963             break;
5964         }
5965       break;
5966     case 0x9d:
5967         GETBYTE ();
5968         switch (op[1] & 0x00)
5969         {
5970           case 0x00:
5971             goto op_semantics_39;
5972             break;
5973         }
5974       break;
5975     case 0x9e:
5976         GETBYTE ();
5977         switch (op[1] & 0x00)
5978         {
5979           case 0x00:
5980             goto op_semantics_39;
5981             break;
5982         }
5983       break;
5984     case 0x9f:
5985         GETBYTE ();
5986         switch (op[1] & 0x00)
5987         {
5988           case 0x00:
5989             goto op_semantics_39;
5990             break;
5991         }
5992       break;
5993     case 0xa0:
5994         GETBYTE ();
5995         switch (op[1] & 0x00)
5996         {
5997           case 0x00:
5998             goto op_semantics_38;
5999             break;
6000         }
6001       break;
6002     case 0xa1:
6003         GETBYTE ();
6004         switch (op[1] & 0x00)
6005         {
6006           case 0x00:
6007             goto op_semantics_38;
6008             break;
6009         }
6010       break;
6011     case 0xa2:
6012         GETBYTE ();
6013         switch (op[1] & 0x00)
6014         {
6015           case 0x00:
6016             goto op_semantics_38;
6017             break;
6018         }
6019       break;
6020     case 0xa3:
6021         GETBYTE ();
6022         switch (op[1] & 0x00)
6023         {
6024           case 0x00:
6025             goto op_semantics_38;
6026             break;
6027         }
6028       break;
6029     case 0xa4:
6030         GETBYTE ();
6031         switch (op[1] & 0x00)
6032         {
6033           case 0x00:
6034             goto op_semantics_38;
6035             break;
6036         }
6037       break;
6038     case 0xa5:
6039         GETBYTE ();
6040         switch (op[1] & 0x00)
6041         {
6042           case 0x00:
6043             goto op_semantics_38;
6044             break;
6045         }
6046       break;
6047     case 0xa6:
6048         GETBYTE ();
6049         switch (op[1] & 0x00)
6050         {
6051           case 0x00:
6052             goto op_semantics_38;
6053             break;
6054         }
6055       break;
6056     case 0xa7:
6057         GETBYTE ();
6058         switch (op[1] & 0x00)
6059         {
6060           case 0x00:
6061             goto op_semantics_38;
6062             break;
6063         }
6064       break;
6065     case 0xa8:
6066         GETBYTE ();
6067         switch (op[1] & 0x00)
6068         {
6069           case 0x00:
6070             goto op_semantics_39;
6071             break;
6072         }
6073       break;
6074     case 0xa9:
6075         GETBYTE ();
6076         switch (op[1] & 0x00)
6077         {
6078           case 0x00:
6079             goto op_semantics_39;
6080             break;
6081         }
6082       break;
6083     case 0xaa:
6084         GETBYTE ();
6085         switch (op[1] & 0x00)
6086         {
6087           case 0x00:
6088             goto op_semantics_39;
6089             break;
6090         }
6091       break;
6092     case 0xab:
6093         GETBYTE ();
6094         switch (op[1] & 0x00)
6095         {
6096           case 0x00:
6097             goto op_semantics_39;
6098             break;
6099         }
6100       break;
6101     case 0xac:
6102         GETBYTE ();
6103         switch (op[1] & 0x00)
6104         {
6105           case 0x00:
6106             goto op_semantics_39;
6107             break;
6108         }
6109       break;
6110     case 0xad:
6111         GETBYTE ();
6112         switch (op[1] & 0x00)
6113         {
6114           case 0x00:
6115             goto op_semantics_39;
6116             break;
6117         }
6118       break;
6119     case 0xae:
6120         GETBYTE ();
6121         switch (op[1] & 0x00)
6122         {
6123           case 0x00:
6124             goto op_semantics_39;
6125             break;
6126         }
6127       break;
6128     case 0xaf:
6129         GETBYTE ();
6130         switch (op[1] & 0x00)
6131         {
6132           case 0x00:
6133             goto op_semantics_39;
6134             break;
6135         }
6136       break;
6137     case 0xb0:
6138         GETBYTE ();
6139         switch (op[1] & 0x00)
6140         {
6141           case 0x00:
6142             op_semantics_40:
6143               {
6144                 /** 1011 w dsp a src b dst      movu%s  %1, %0 */
6145 #line 349 "rx-decode.opc"
6146                 int w AU = (op[0] >> 3) & 0x01;
6147 #line 349 "rx-decode.opc"
6148                 int dsp AU = op[0] & 0x07;
6149 #line 349 "rx-decode.opc"
6150                 int a AU = (op[1] >> 7) & 0x01;
6151 #line 349 "rx-decode.opc"
6152                 int src AU = (op[1] >> 4) & 0x07;
6153 #line 349 "rx-decode.opc"
6154                 int b AU = (op[1] >> 3) & 0x01;
6155 #line 349 "rx-decode.opc"
6156                 int dst AU = op[1] & 0x07;
6157                 if (trace)
6158                   {
6159                     printf ("\033[33m%s\033[0m  %02x %02x\n",
6160                            "/** 1011 w dsp a src b dst  movu%s  %1, %0 */",
6161                            op[0], op[1]);
6162                     printf ("  w = 0x%x,", w);
6163                     printf ("  dsp = 0x%x,", dsp);
6164                     printf ("  a = 0x%x,", a);
6165                     printf ("  src = 0x%x,", src);
6166                     printf ("  b = 0x%x,", b);
6167                     printf ("  dst = 0x%x\n", dst);
6168                   }
6169                 SYNTAX("movu%s  %1, %0");
6170 #line 349 "rx-decode.opc"
6171                 ID(mov); uBWL(w); DR(dst); SIs(src, dsp*4+a*2+b, w); F_____;
6172
6173               }
6174             break;
6175         }
6176       break;
6177     case 0xb1:
6178         GETBYTE ();
6179         switch (op[1] & 0x00)
6180         {
6181           case 0x00:
6182             goto op_semantics_40;
6183             break;
6184         }
6185       break;
6186     case 0xb2:
6187         GETBYTE ();
6188         switch (op[1] & 0x00)
6189         {
6190           case 0x00:
6191             goto op_semantics_40;
6192             break;
6193         }
6194       break;
6195     case 0xb3:
6196         GETBYTE ();
6197         switch (op[1] & 0x00)
6198         {
6199           case 0x00:
6200             goto op_semantics_40;
6201             break;
6202         }
6203       break;
6204     case 0xb4:
6205         GETBYTE ();
6206         switch (op[1] & 0x00)
6207         {
6208           case 0x00:
6209             goto op_semantics_40;
6210             break;
6211         }
6212       break;
6213     case 0xb5:
6214         GETBYTE ();
6215         switch (op[1] & 0x00)
6216         {
6217           case 0x00:
6218             goto op_semantics_40;
6219             break;
6220         }
6221       break;
6222     case 0xb6:
6223         GETBYTE ();
6224         switch (op[1] & 0x00)
6225         {
6226           case 0x00:
6227             goto op_semantics_40;
6228             break;
6229         }
6230       break;
6231     case 0xb7:
6232         GETBYTE ();
6233         switch (op[1] & 0x00)
6234         {
6235           case 0x00:
6236             goto op_semantics_40;
6237             break;
6238         }
6239       break;
6240     case 0xb8:
6241         GETBYTE ();
6242         switch (op[1] & 0x00)
6243         {
6244           case 0x00:
6245             goto op_semantics_40;
6246             break;
6247         }
6248       break;
6249     case 0xb9:
6250         GETBYTE ();
6251         switch (op[1] & 0x00)
6252         {
6253           case 0x00:
6254             goto op_semantics_40;
6255             break;
6256         }
6257       break;
6258     case 0xba:
6259         GETBYTE ();
6260         switch (op[1] & 0x00)
6261         {
6262           case 0x00:
6263             goto op_semantics_40;
6264             break;
6265         }
6266       break;
6267     case 0xbb:
6268         GETBYTE ();
6269         switch (op[1] & 0x00)
6270         {
6271           case 0x00:
6272             goto op_semantics_40;
6273             break;
6274         }
6275       break;
6276     case 0xbc:
6277         GETBYTE ();
6278         switch (op[1] & 0x00)
6279         {
6280           case 0x00:
6281             goto op_semantics_40;
6282             break;
6283         }
6284       break;
6285     case 0xbd:
6286         GETBYTE ();
6287         switch (op[1] & 0x00)
6288         {
6289           case 0x00:
6290             goto op_semantics_40;
6291             break;
6292         }
6293       break;
6294     case 0xbe:
6295         GETBYTE ();
6296         switch (op[1] & 0x00)
6297         {
6298           case 0x00:
6299             goto op_semantics_40;
6300             break;
6301         }
6302       break;
6303     case 0xbf:
6304         GETBYTE ();
6305         switch (op[1] & 0x00)
6306         {
6307           case 0x00:
6308             goto op_semantics_40;
6309             break;
6310         }
6311       break;
6312     case 0xc0:
6313         GETBYTE ();
6314         switch (op[1] & 0x00)
6315         {
6316           case 0x00:
6317             op_semantics_41:
6318               {
6319                 /** 11sz sd ss rsrc rdst        mov%s   %1, %0 */
6320 #line 307 "rx-decode.opc"
6321                 int sz AU = (op[0] >> 4) & 0x03;
6322 #line 307 "rx-decode.opc"
6323                 int sd AU = (op[0] >> 2) & 0x03;
6324 #line 307 "rx-decode.opc"
6325                 int ss AU = op[0] & 0x03;
6326 #line 307 "rx-decode.opc"
6327                 int rsrc AU = (op[1] >> 4) & 0x0f;
6328 #line 307 "rx-decode.opc"
6329                 int rdst AU = op[1] & 0x0f;
6330                 if (trace)
6331                   {
6332                     printf ("\033[33m%s\033[0m  %02x %02x\n",
6333                            "/** 11sz sd ss rsrc rdst    mov%s   %1, %0 */",
6334                            op[0], op[1]);
6335                     printf ("  sz = 0x%x,", sz);
6336                     printf ("  sd = 0x%x,", sd);
6337                     printf ("  ss = 0x%x,", ss);
6338                     printf ("  rsrc = 0x%x,", rsrc);
6339                     printf ("  rdst = 0x%x\n", rdst);
6340                   }
6341                 SYNTAX("mov%s   %1, %0");
6342 #line 307 "rx-decode.opc"
6343                 if (sd == 3 && ss == 3 && sz == 2 && rsrc == 0 && rdst == 0)
6344                   {
6345                     ID(nop2);
6346                     rx->syntax = "nop";
6347                   }
6348                 else
6349                   {
6350                     ID(mov); sBWL(sz); F_____;
6351                     if ((ss == 3) && (sd != 3))
6352                 {
6353                   SD(ss, rdst, sz); DD(sd, rsrc, sz);
6354                 }
6355                     else
6356                 {
6357                   SD(ss, rsrc, sz); DD(sd, rdst, sz);
6358                 }
6359                   }
6360
6361               }
6362             break;
6363         }
6364       break;
6365     case 0xc1:
6366         GETBYTE ();
6367         switch (op[1] & 0x00)
6368         {
6369           case 0x00:
6370             goto op_semantics_41;
6371             break;
6372         }
6373       break;
6374     case 0xc2:
6375         GETBYTE ();
6376         switch (op[1] & 0x00)
6377         {
6378           case 0x00:
6379             goto op_semantics_41;
6380             break;
6381         }
6382       break;
6383     case 0xc3:
6384         GETBYTE ();
6385         switch (op[1] & 0x00)
6386         {
6387           case 0x00:
6388             goto op_semantics_41;
6389             break;
6390         }
6391       break;
6392     case 0xc4:
6393         GETBYTE ();
6394         switch (op[1] & 0x00)
6395         {
6396           case 0x00:
6397             goto op_semantics_41;
6398             break;
6399         }
6400       break;
6401     case 0xc5:
6402         GETBYTE ();
6403         switch (op[1] & 0x00)
6404         {
6405           case 0x00:
6406             goto op_semantics_41;
6407             break;
6408         }
6409       break;
6410     case 0xc6:
6411         GETBYTE ();
6412         switch (op[1] & 0x00)
6413         {
6414           case 0x00:
6415             goto op_semantics_41;
6416             break;
6417         }
6418       break;
6419     case 0xc7:
6420         GETBYTE ();
6421         switch (op[1] & 0x00)
6422         {
6423           case 0x00:
6424             goto op_semantics_41;
6425             break;
6426         }
6427       break;
6428     case 0xc8:
6429         GETBYTE ();
6430         switch (op[1] & 0x00)
6431         {
6432           case 0x00:
6433             goto op_semantics_41;
6434             break;
6435         }
6436       break;
6437     case 0xc9:
6438         GETBYTE ();
6439         switch (op[1] & 0x00)
6440         {
6441           case 0x00:
6442             goto op_semantics_41;
6443             break;
6444         }
6445       break;
6446     case 0xca:
6447         GETBYTE ();
6448         switch (op[1] & 0x00)
6449         {
6450           case 0x00:
6451             goto op_semantics_41;
6452             break;
6453         }
6454       break;
6455     case 0xcb:
6456         GETBYTE ();
6457         switch (op[1] & 0x00)
6458         {
6459           case 0x00:
6460             goto op_semantics_41;
6461             break;
6462         }
6463       break;
6464     case 0xcc:
6465         GETBYTE ();
6466         switch (op[1] & 0x00)
6467         {
6468           case 0x00:
6469             goto op_semantics_41;
6470             break;
6471         }
6472       break;
6473     case 0xcd:
6474         GETBYTE ();
6475         switch (op[1] & 0x00)
6476         {
6477           case 0x00:
6478             goto op_semantics_41;
6479             break;
6480         }
6481       break;
6482     case 0xce:
6483         GETBYTE ();
6484         switch (op[1] & 0x00)
6485         {
6486           case 0x00:
6487             goto op_semantics_41;
6488             break;
6489         }
6490       break;
6491     case 0xcf:
6492         GETBYTE ();
6493         switch (op[1] & 0x00)
6494         {
6495           case 0x00:
6496             goto op_semantics_41;
6497             break;
6498         }
6499       break;
6500     case 0xd0:
6501         GETBYTE ();
6502         switch (op[1] & 0x00)
6503         {
6504           case 0x00:
6505             goto op_semantics_41;
6506             break;
6507         }
6508       break;
6509     case 0xd1:
6510         GETBYTE ();
6511         switch (op[1] & 0x00)
6512         {
6513           case 0x00:
6514             goto op_semantics_41;
6515             break;
6516         }
6517       break;
6518     case 0xd2:
6519         GETBYTE ();
6520         switch (op[1] & 0x00)
6521         {
6522           case 0x00:
6523             goto op_semantics_41;
6524             break;
6525         }
6526       break;
6527     case 0xd3:
6528         GETBYTE ();
6529         switch (op[1] & 0x00)
6530         {
6531           case 0x00:
6532             goto op_semantics_41;
6533             break;
6534         }
6535       break;
6536     case 0xd4:
6537         GETBYTE ();
6538         switch (op[1] & 0x00)
6539         {
6540           case 0x00:
6541             goto op_semantics_41;
6542             break;
6543         }
6544       break;
6545     case 0xd5:
6546         GETBYTE ();
6547         switch (op[1] & 0x00)
6548         {
6549           case 0x00:
6550             goto op_semantics_41;
6551             break;
6552         }
6553       break;
6554     case 0xd6:
6555         GETBYTE ();
6556         switch (op[1] & 0x00)
6557         {
6558           case 0x00:
6559             goto op_semantics_41;
6560             break;
6561         }
6562       break;
6563     case 0xd7:
6564         GETBYTE ();
6565         switch (op[1] & 0x00)
6566         {
6567           case 0x00:
6568             goto op_semantics_41;
6569             break;
6570         }
6571       break;
6572     case 0xd8:
6573         GETBYTE ();
6574         switch (op[1] & 0x00)
6575         {
6576           case 0x00:
6577             goto op_semantics_41;
6578             break;
6579         }
6580       break;
6581     case 0xd9:
6582         GETBYTE ();
6583         switch (op[1] & 0x00)
6584         {
6585           case 0x00:
6586             goto op_semantics_41;
6587             break;
6588         }
6589       break;
6590     case 0xda:
6591         GETBYTE ();
6592         switch (op[1] & 0x00)
6593         {
6594           case 0x00:
6595             goto op_semantics_41;
6596             break;
6597         }
6598       break;
6599     case 0xdb:
6600         GETBYTE ();
6601         switch (op[1] & 0x00)
6602         {
6603           case 0x00:
6604             goto op_semantics_41;
6605             break;
6606         }
6607       break;
6608     case 0xdc:
6609         GETBYTE ();
6610         switch (op[1] & 0x00)
6611         {
6612           case 0x00:
6613             goto op_semantics_41;
6614             break;
6615         }
6616       break;
6617     case 0xdd:
6618         GETBYTE ();
6619         switch (op[1] & 0x00)
6620         {
6621           case 0x00:
6622             goto op_semantics_41;
6623             break;
6624         }
6625       break;
6626     case 0xde:
6627         GETBYTE ();
6628         switch (op[1] & 0x00)
6629         {
6630           case 0x00:
6631             goto op_semantics_41;
6632             break;
6633         }
6634       break;
6635     case 0xdf:
6636         GETBYTE ();
6637         switch (op[1] & 0x00)
6638         {
6639           case 0x00:
6640             goto op_semantics_41;
6641             break;
6642         }
6643       break;
6644     case 0xe0:
6645         GETBYTE ();
6646         switch (op[1] & 0x00)
6647         {
6648           case 0x00:
6649             goto op_semantics_41;
6650             break;
6651         }
6652       break;
6653     case 0xe1:
6654         GETBYTE ();
6655         switch (op[1] & 0x00)
6656         {
6657           case 0x00:
6658             goto op_semantics_41;
6659             break;
6660         }
6661       break;
6662     case 0xe2:
6663         GETBYTE ();
6664         switch (op[1] & 0x00)
6665         {
6666           case 0x00:
6667             goto op_semantics_41;
6668             break;
6669         }
6670       break;
6671     case 0xe3:
6672         GETBYTE ();
6673         switch (op[1] & 0x00)
6674         {
6675           case 0x00:
6676             goto op_semantics_41;
6677             break;
6678         }
6679       break;
6680     case 0xe4:
6681         GETBYTE ();
6682         switch (op[1] & 0x00)
6683         {
6684           case 0x00:
6685             goto op_semantics_41;
6686             break;
6687         }
6688       break;
6689     case 0xe5:
6690         GETBYTE ();
6691         switch (op[1] & 0x00)
6692         {
6693           case 0x00:
6694             goto op_semantics_41;
6695             break;
6696         }
6697       break;
6698     case 0xe6:
6699         GETBYTE ();
6700         switch (op[1] & 0x00)
6701         {
6702           case 0x00:
6703             goto op_semantics_41;
6704             break;
6705         }
6706       break;
6707     case 0xe7:
6708         GETBYTE ();
6709         switch (op[1] & 0x00)
6710         {
6711           case 0x00:
6712             goto op_semantics_41;
6713             break;
6714         }
6715       break;
6716     case 0xe8:
6717         GETBYTE ();
6718         switch (op[1] & 0x00)
6719         {
6720           case 0x00:
6721             goto op_semantics_41;
6722             break;
6723         }
6724       break;
6725     case 0xe9:
6726         GETBYTE ();
6727         switch (op[1] & 0x00)
6728         {
6729           case 0x00:
6730             goto op_semantics_41;
6731             break;
6732         }
6733       break;
6734     case 0xea:
6735         GETBYTE ();
6736         switch (op[1] & 0x00)
6737         {
6738           case 0x00:
6739             goto op_semantics_41;
6740             break;
6741         }
6742       break;
6743     case 0xeb:
6744         GETBYTE ();
6745         switch (op[1] & 0x00)
6746         {
6747           case 0x00:
6748             goto op_semantics_41;
6749             break;
6750         }
6751       break;
6752     case 0xec:
6753         GETBYTE ();
6754         switch (op[1] & 0x00)
6755         {
6756           case 0x00:
6757             goto op_semantics_41;
6758             break;
6759         }
6760       break;
6761     case 0xed:
6762         GETBYTE ();
6763         switch (op[1] & 0x00)
6764         {
6765           case 0x00:
6766             goto op_semantics_41;
6767             break;
6768         }
6769       break;
6770     case 0xee:
6771         GETBYTE ();
6772         switch (op[1] & 0x00)
6773         {
6774           case 0x00:
6775             goto op_semantics_41;
6776             break;
6777         }
6778       break;
6779     case 0xef:
6780         GETBYTE ();
6781         switch (op[1] & 0x00)
6782         {
6783           case 0x00:
6784             goto op_semantics_41;
6785             break;
6786         }
6787       break;
6788     case 0xf0:
6789         GETBYTE ();
6790         switch (op[1] & 0x08)
6791         {
6792           case 0x00:
6793             op_semantics_42:
6794               {
6795                 /** 1111 00sd rdst 0bit                 bset    #%1, %0%S0 */
6796 #line 894 "rx-decode.opc"
6797                 int sd AU = op[0] & 0x03;
6798 #line 894 "rx-decode.opc"
6799                 int rdst AU = (op[1] >> 4) & 0x0f;
6800 #line 894 "rx-decode.opc"
6801                 int bit AU = op[1] & 0x07;
6802                 if (trace)
6803                   {
6804                     printf ("\033[33m%s\033[0m  %02x %02x\n",
6805                            "/** 1111 00sd rdst 0bit                     bset    #%1, %0%S0 */",
6806                            op[0], op[1]);
6807                     printf ("  sd = 0x%x,", sd);
6808                     printf ("  rdst = 0x%x,", rdst);
6809                     printf ("  bit = 0x%x\n", bit);
6810                   }
6811                 SYNTAX("bset    #%1, %0%S0");
6812 #line 894 "rx-decode.opc"
6813                 ID(bset); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____;
6814
6815               }
6816             break;
6817           case 0x08:
6818             op_semantics_43:
6819               {
6820                 /** 1111 00sd rdst 1bit                 bclr    #%1, %0%S0 */
6821 #line 906 "rx-decode.opc"
6822                 int sd AU = op[0] & 0x03;
6823 #line 906 "rx-decode.opc"
6824                 int rdst AU = (op[1] >> 4) & 0x0f;
6825 #line 906 "rx-decode.opc"
6826                 int bit AU = op[1] & 0x07;
6827                 if (trace)
6828                   {
6829                     printf ("\033[33m%s\033[0m  %02x %02x\n",
6830                            "/** 1111 00sd rdst 1bit                     bclr    #%1, %0%S0 */",
6831                            op[0], op[1]);
6832                     printf ("  sd = 0x%x,", sd);
6833                     printf ("  rdst = 0x%x,", rdst);
6834                     printf ("  bit = 0x%x\n", bit);
6835                   }
6836                 SYNTAX("bclr    #%1, %0%S0");
6837 #line 906 "rx-decode.opc"
6838                 ID(bclr); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____;
6839
6840               }
6841             break;
6842         }
6843       break;
6844     case 0xf1:
6845         GETBYTE ();
6846         switch (op[1] & 0x08)
6847         {
6848           case 0x00:
6849             goto op_semantics_42;
6850             break;
6851           case 0x08:
6852             goto op_semantics_43;
6853             break;
6854         }
6855       break;
6856     case 0xf2:
6857         GETBYTE ();
6858         switch (op[1] & 0x08)
6859         {
6860           case 0x00:
6861             goto op_semantics_42;
6862             break;
6863           case 0x08:
6864             goto op_semantics_43;
6865             break;
6866         }
6867       break;
6868     case 0xf3:
6869         GETBYTE ();
6870         switch (op[1] & 0x08)
6871         {
6872           case 0x00:
6873             goto op_semantics_42;
6874             break;
6875           case 0x08:
6876             goto op_semantics_43;
6877             break;
6878         }
6879       break;
6880     case 0xf4:
6881         GETBYTE ();
6882         switch (op[1] & 0x0c)
6883         {
6884           case 0x00:
6885           case 0x04:
6886             op_semantics_44:
6887               {
6888                 /** 1111 01sd rdst 0bit                 btst    #%2, %1%S1 */
6889 #line 918 "rx-decode.opc"
6890                 int sd AU = op[0] & 0x03;
6891 #line 918 "rx-decode.opc"
6892                 int rdst AU = (op[1] >> 4) & 0x0f;
6893 #line 918 "rx-decode.opc"
6894                 int bit AU = op[1] & 0x07;
6895                 if (trace)
6896                   {
6897                     printf ("\033[33m%s\033[0m  %02x %02x\n",
6898                            "/** 1111 01sd rdst 0bit                     btst    #%2, %1%S1 */",
6899                            op[0], op[1]);
6900                     printf ("  sd = 0x%x,", sd);
6901                     printf ("  rdst = 0x%x,", rdst);
6902                     printf ("  bit = 0x%x\n", bit);
6903                   }
6904                 SYNTAX("btst    #%2, %1%S1");
6905 #line 918 "rx-decode.opc"
6906                 ID(btst); BWL(BSIZE); S2C(bit); SD(sd, rdst, BSIZE); F___ZC;
6907
6908               }
6909             break;
6910           case 0x08:
6911             op_semantics_45:
6912               {
6913                 /** 1111 01ss rsrc 10sz         push%s  %1 */
6914 #line 374 "rx-decode.opc"
6915                 int ss AU = op[0] & 0x03;
6916 #line 374 "rx-decode.opc"
6917                 int rsrc AU = (op[1] >> 4) & 0x0f;
6918 #line 374 "rx-decode.opc"
6919                 int sz AU = op[1] & 0x03;
6920                 if (trace)
6921                   {
6922                     printf ("\033[33m%s\033[0m  %02x %02x\n",
6923                            "/** 1111 01ss rsrc 10sz             push%s  %1 */",
6924                            op[0], op[1]);
6925                     printf ("  ss = 0x%x,", ss);
6926                     printf ("  rsrc = 0x%x,", rsrc);
6927                     printf ("  sz = 0x%x\n", sz);
6928                   }
6929                 SYNTAX("push%s  %1");
6930 #line 374 "rx-decode.opc"
6931                 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SD(ss, rsrc, sz); F_____;
6932
6933               /*----------------------------------------------------------------------*/
6934               /* XCHG                                                                   */
6935
6936               }
6937             break;
6938           default: UNSUPPORTED(); break;
6939         }
6940       break;
6941     case 0xf5:
6942         GETBYTE ();
6943         switch (op[1] & 0x0c)
6944         {
6945           case 0x00:
6946           case 0x04:
6947             goto op_semantics_44;
6948             break;
6949           case 0x08:
6950             goto op_semantics_45;
6951             break;
6952           default: UNSUPPORTED(); break;
6953         }
6954       break;
6955     case 0xf6:
6956         GETBYTE ();
6957         switch (op[1] & 0x0c)
6958         {
6959           case 0x00:
6960           case 0x04:
6961             goto op_semantics_44;
6962             break;
6963           case 0x08:
6964             goto op_semantics_45;
6965             break;
6966           default: UNSUPPORTED(); break;
6967         }
6968       break;
6969     case 0xf7:
6970         GETBYTE ();
6971         switch (op[1] & 0x0c)
6972         {
6973           case 0x00:
6974           case 0x04:
6975             goto op_semantics_44;
6976             break;
6977           case 0x08:
6978             goto op_semantics_45;
6979             break;
6980           default: UNSUPPORTED(); break;
6981         }
6982       break;
6983     case 0xf8:
6984         GETBYTE ();
6985         switch (op[1] & 0x00)
6986         {
6987           case 0x00:
6988             op_semantics_46:
6989               {
6990                 /** 1111 10sd rdst im sz        mov%s   #%1, %0 */
6991 #line 285 "rx-decode.opc"
6992                 int sd AU = op[0] & 0x03;
6993 #line 285 "rx-decode.opc"
6994                 int rdst AU = (op[1] >> 4) & 0x0f;
6995 #line 285 "rx-decode.opc"
6996                 int im AU = (op[1] >> 2) & 0x03;
6997 #line 285 "rx-decode.opc"
6998                 int sz AU = op[1] & 0x03;
6999                 if (trace)
7000                   {
7001                     printf ("\033[33m%s\033[0m  %02x %02x\n",
7002                            "/** 1111 10sd rdst im sz    mov%s   #%1, %0 */",
7003                            op[0], op[1]);
7004                     printf ("  sd = 0x%x,", sd);
7005                     printf ("  rdst = 0x%x,", rdst);
7006                     printf ("  im = 0x%x,", im);
7007                     printf ("  sz = 0x%x\n", sz);
7008                   }
7009                 SYNTAX("mov%s   #%1, %0");
7010 #line 285 "rx-decode.opc"
7011                 ID(mov); DD(sd, rdst, sz);
7012                 if ((im == 1 && sz == 0)
7013                     || (im == 2 && sz == 1)
7014                     || (im == 0 && sz == 2))
7015                   {
7016                     BWL (sz);
7017                     SC(IMM(im));
7018                   }
7019                 else
7020                   {
7021                     sBWL (sz);
7022                     SC(IMMex(im));
7023                   }
7024                  F_____;
7025
7026               }
7027             break;
7028         }
7029       break;
7030     case 0xf9:
7031         GETBYTE ();
7032         switch (op[1] & 0x00)
7033         {
7034           case 0x00:
7035             goto op_semantics_46;
7036             break;
7037         }
7038       break;
7039     case 0xfa:
7040         GETBYTE ();
7041         switch (op[1] & 0x00)
7042         {
7043           case 0x00:
7044             goto op_semantics_46;
7045             break;
7046         }
7047       break;
7048     case 0xfb:
7049         GETBYTE ();
7050         switch (op[1] & 0x00)
7051         {
7052           case 0x00:
7053             goto op_semantics_46;
7054             break;
7055         }
7056       break;
7057     case 0xfc:
7058         GETBYTE ();
7059         switch (op[1] & 0xff)
7060         {
7061           case 0x03:
7062               GETBYTE ();
7063               switch (op[2] & 0x00)
7064               {
7065                 case 0x00:
7066                     {
7067                       /** 1111 1100 0000 0011 rsrc rdst sbb     %1, %0 */
7068 #line 548 "rx-decode.opc"
7069                       int rsrc AU = (op[2] >> 4) & 0x0f;
7070 #line 548 "rx-decode.opc"
7071                       int rdst AU = op[2] & 0x0f;
7072                       if (trace)
7073                         {
7074                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7075                                  "/** 1111 1100 0000 0011 rsrc rdst     sbb     %1, %0 */",
7076                                  op[0], op[1], op[2]);
7077                           printf ("  rsrc = 0x%x,", rsrc);
7078                           printf ("  rdst = 0x%x\n", rdst);
7079                         }
7080                       SYNTAX("sbb       %1, %0");
7081 #line 548 "rx-decode.opc"
7082                       ID(sbb); SR (rsrc); DR(rdst); F_OSZC;
7083
7084                       /* FIXME: only supports .L */
7085                     }
7086                   break;
7087               }
7088             break;
7089           case 0x07:
7090               GETBYTE ();
7091               switch (op[2] & 0x00)
7092               {
7093                 case 0x00:
7094                     {
7095                       /** 1111 1100 0000 0111 rsrc rdst neg     %2, %0 */
7096 #line 479 "rx-decode.opc"
7097                       int rsrc AU = (op[2] >> 4) & 0x0f;
7098 #line 479 "rx-decode.opc"
7099                       int rdst AU = op[2] & 0x0f;
7100                       if (trace)
7101                         {
7102                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7103                                  "/** 1111 1100 0000 0111 rsrc rdst     neg     %2, %0 */",
7104                                  op[0], op[1], op[2]);
7105                           printf ("  rsrc = 0x%x,", rsrc);
7106                           printf ("  rdst = 0x%x\n", rdst);
7107                         }
7108                       SYNTAX("neg       %2, %0");
7109 #line 479 "rx-decode.opc"
7110                       ID(sub); DR(rdst); SC(0); S2R(rsrc); F_OSZC;
7111
7112                     /*----------------------------------------------------------------------*/
7113                     /* ADC                                                                      */
7114
7115                     }
7116                   break;
7117               }
7118             break;
7119           case 0x0b:
7120               GETBYTE ();
7121               switch (op[2] & 0x00)
7122               {
7123                 case 0x00:
7124                     {
7125                       /** 1111 1100 0000 1011 rsrc rdst adc     %1, %0 */
7126 #line 488 "rx-decode.opc"
7127                       int rsrc AU = (op[2] >> 4) & 0x0f;
7128 #line 488 "rx-decode.opc"
7129                       int rdst AU = op[2] & 0x0f;
7130                       if (trace)
7131                         {
7132                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7133                                  "/** 1111 1100 0000 1011 rsrc rdst     adc     %1, %0 */",
7134                                  op[0], op[1], op[2]);
7135                           printf ("  rsrc = 0x%x,", rsrc);
7136                           printf ("  rdst = 0x%x\n", rdst);
7137                         }
7138                       SYNTAX("adc       %1, %0");
7139 #line 488 "rx-decode.opc"
7140                       ID(adc); SR(rsrc); DR(rdst); F_OSZC;
7141
7142                     }
7143                   break;
7144               }
7145             break;
7146           case 0x0f:
7147               GETBYTE ();
7148               switch (op[2] & 0x00)
7149               {
7150                 case 0x00:
7151                     {
7152                       /** 1111 1100 0000 1111 rsrc rdst abs     %1, %0 */
7153 #line 561 "rx-decode.opc"
7154                       int rsrc AU = (op[2] >> 4) & 0x0f;
7155 #line 561 "rx-decode.opc"
7156                       int rdst AU = op[2] & 0x0f;
7157                       if (trace)
7158                         {
7159                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7160                                  "/** 1111 1100 0000 1111 rsrc rdst     abs     %1, %0 */",
7161                                  op[0], op[1], op[2]);
7162                           printf ("  rsrc = 0x%x,", rsrc);
7163                           printf ("  rdst = 0x%x\n", rdst);
7164                         }
7165                       SYNTAX("abs       %1, %0");
7166 #line 561 "rx-decode.opc"
7167                       ID(abs); DR(rdst); SR(rsrc); F_OSZ_;
7168
7169                     /*----------------------------------------------------------------------*/
7170                     /* MAX                                                                      */
7171
7172                     }
7173                   break;
7174               }
7175             break;
7176           case 0x10:
7177               GETBYTE ();
7178               switch (op[2] & 0x00)
7179               {
7180                 case 0x00:
7181                   op_semantics_47:
7182                     {
7183                       /** 1111 1100 0001 00ss rsrc rdst max     %1%S1, %0 */
7184 #line 570 "rx-decode.opc"
7185                       int ss AU = op[1] & 0x03;
7186 #line 570 "rx-decode.opc"
7187                       int rsrc AU = (op[2] >> 4) & 0x0f;
7188 #line 570 "rx-decode.opc"
7189                       int rdst AU = op[2] & 0x0f;
7190                       if (trace)
7191                         {
7192                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7193                                  "/** 1111 1100 0001 00ss rsrc rdst     max     %1%S1, %0 */",
7194                                  op[0], op[1], op[2]);
7195                           printf ("  ss = 0x%x,", ss);
7196                           printf ("  rsrc = 0x%x,", rsrc);
7197                           printf ("  rdst = 0x%x\n", rdst);
7198                         }
7199                       SYNTAX("max       %1%S1, %0");
7200 #line 570 "rx-decode.opc"
7201                       if (ss == 3 && rsrc == 0 && rdst == 0)
7202                         {
7203                           ID(nop3);
7204                           rx->syntax = "nop";
7205                         }
7206                       else
7207                         {
7208                           ID(max); SP(ss, rsrc); DR(rdst);
7209                         }
7210
7211                     }
7212                   break;
7213               }
7214             break;
7215           case 0x11:
7216               GETBYTE ();
7217               switch (op[2] & 0x00)
7218               {
7219                 case 0x00:
7220                   goto op_semantics_47;
7221                   break;
7222               }
7223             break;
7224           case 0x12:
7225               GETBYTE ();
7226               switch (op[2] & 0x00)
7227               {
7228                 case 0x00:
7229                   goto op_semantics_47;
7230                   break;
7231               }
7232             break;
7233           case 0x13:
7234               GETBYTE ();
7235               switch (op[2] & 0x00)
7236               {
7237                 case 0x00:
7238                   goto op_semantics_47;
7239                   break;
7240               }
7241             break;
7242           case 0x14:
7243               GETBYTE ();
7244               switch (op[2] & 0x00)
7245               {
7246                 case 0x00:
7247                   op_semantics_48:
7248                     {
7249                       /** 1111 1100 0001 01ss rsrc rdst min     %1%S1, %0 */
7250 #line 590 "rx-decode.opc"
7251                       int ss AU = op[1] & 0x03;
7252 #line 590 "rx-decode.opc"
7253                       int rsrc AU = (op[2] >> 4) & 0x0f;
7254 #line 590 "rx-decode.opc"
7255                       int rdst AU = op[2] & 0x0f;
7256                       if (trace)
7257                         {
7258                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7259                                  "/** 1111 1100 0001 01ss rsrc rdst     min     %1%S1, %0 */",
7260                                  op[0], op[1], op[2]);
7261                           printf ("  ss = 0x%x,", ss);
7262                           printf ("  rsrc = 0x%x,", rsrc);
7263                           printf ("  rdst = 0x%x\n", rdst);
7264                         }
7265                       SYNTAX("min       %1%S1, %0");
7266 #line 590 "rx-decode.opc"
7267                       ID(min); SP(ss, rsrc); DR(rdst);
7268
7269                     }
7270                   break;
7271               }
7272             break;
7273           case 0x15:
7274               GETBYTE ();
7275               switch (op[2] & 0x00)
7276               {
7277                 case 0x00:
7278                   goto op_semantics_48;
7279                   break;
7280               }
7281             break;
7282           case 0x16:
7283               GETBYTE ();
7284               switch (op[2] & 0x00)
7285               {
7286                 case 0x00:
7287                   goto op_semantics_48;
7288                   break;
7289               }
7290             break;
7291           case 0x17:
7292               GETBYTE ();
7293               switch (op[2] & 0x00)
7294               {
7295                 case 0x00:
7296                   goto op_semantics_48;
7297                   break;
7298               }
7299             break;
7300           case 0x18:
7301               GETBYTE ();
7302               switch (op[2] & 0x00)
7303               {
7304                 case 0x00:
7305                   op_semantics_49:
7306                     {
7307                       /** 1111 1100 0001 10ss rsrc rdst emul    %1%S1, %0 */
7308 #line 620 "rx-decode.opc"
7309                       int ss AU = op[1] & 0x03;
7310 #line 620 "rx-decode.opc"
7311                       int rsrc AU = (op[2] >> 4) & 0x0f;
7312 #line 620 "rx-decode.opc"
7313                       int rdst AU = op[2] & 0x0f;
7314                       if (trace)
7315                         {
7316                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7317                                  "/** 1111 1100 0001 10ss rsrc rdst     emul    %1%S1, %0 */",
7318                                  op[0], op[1], op[2]);
7319                           printf ("  ss = 0x%x,", ss);
7320                           printf ("  rsrc = 0x%x,", rsrc);
7321                           printf ("  rdst = 0x%x\n", rdst);
7322                         }
7323                       SYNTAX("emul      %1%S1, %0");
7324 #line 620 "rx-decode.opc"
7325                       ID(emul); SP(ss, rsrc); DR(rdst);
7326
7327                     }
7328                   break;
7329               }
7330             break;
7331           case 0x19:
7332               GETBYTE ();
7333               switch (op[2] & 0x00)
7334               {
7335                 case 0x00:
7336                   goto op_semantics_49;
7337                   break;
7338               }
7339             break;
7340           case 0x1a:
7341               GETBYTE ();
7342               switch (op[2] & 0x00)
7343               {
7344                 case 0x00:
7345                   goto op_semantics_49;
7346                   break;
7347               }
7348             break;
7349           case 0x1b:
7350               GETBYTE ();
7351               switch (op[2] & 0x00)
7352               {
7353                 case 0x00:
7354                   goto op_semantics_49;
7355                   break;
7356               }
7357             break;
7358           case 0x1c:
7359               GETBYTE ();
7360               switch (op[2] & 0x00)
7361               {
7362                 case 0x00:
7363                   op_semantics_50:
7364                     {
7365                       /** 1111 1100 0001 11ss rsrc rdst emulu   %1%S1, %0 */
7366 #line 632 "rx-decode.opc"
7367                       int ss AU = op[1] & 0x03;
7368 #line 632 "rx-decode.opc"
7369                       int rsrc AU = (op[2] >> 4) & 0x0f;
7370 #line 632 "rx-decode.opc"
7371                       int rdst AU = op[2] & 0x0f;
7372                       if (trace)
7373                         {
7374                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7375                                  "/** 1111 1100 0001 11ss rsrc rdst     emulu   %1%S1, %0 */",
7376                                  op[0], op[1], op[2]);
7377                           printf ("  ss = 0x%x,", ss);
7378                           printf ("  rsrc = 0x%x,", rsrc);
7379                           printf ("  rdst = 0x%x\n", rdst);
7380                         }
7381                       SYNTAX("emulu     %1%S1, %0");
7382 #line 632 "rx-decode.opc"
7383                       ID(emulu); SP(ss, rsrc); DR(rdst);
7384
7385                     }
7386                   break;
7387               }
7388             break;
7389           case 0x1d:
7390               GETBYTE ();
7391               switch (op[2] & 0x00)
7392               {
7393                 case 0x00:
7394                   goto op_semantics_50;
7395                   break;
7396               }
7397             break;
7398           case 0x1e:
7399               GETBYTE ();
7400               switch (op[2] & 0x00)
7401               {
7402                 case 0x00:
7403                   goto op_semantics_50;
7404                   break;
7405               }
7406             break;
7407           case 0x1f:
7408               GETBYTE ();
7409               switch (op[2] & 0x00)
7410               {
7411                 case 0x00:
7412                   goto op_semantics_50;
7413                   break;
7414               }
7415             break;
7416           case 0x20:
7417               GETBYTE ();
7418               switch (op[2] & 0x00)
7419               {
7420                 case 0x00:
7421                   op_semantics_51:
7422                     {
7423                       /** 1111 1100 0010 00ss rsrc rdst div     %1%S1, %0 */
7424 #line 644 "rx-decode.opc"
7425                       int ss AU = op[1] & 0x03;
7426 #line 644 "rx-decode.opc"
7427                       int rsrc AU = (op[2] >> 4) & 0x0f;
7428 #line 644 "rx-decode.opc"
7429                       int rdst AU = op[2] & 0x0f;
7430                       if (trace)
7431                         {
7432                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7433                                  "/** 1111 1100 0010 00ss rsrc rdst     div     %1%S1, %0 */",
7434                                  op[0], op[1], op[2]);
7435                           printf ("  ss = 0x%x,", ss);
7436                           printf ("  rsrc = 0x%x,", rsrc);
7437                           printf ("  rdst = 0x%x\n", rdst);
7438                         }
7439                       SYNTAX("div       %1%S1, %0");
7440 #line 644 "rx-decode.opc"
7441                       ID(div); SP(ss, rsrc); DR(rdst); F_O___;
7442
7443                     }
7444                   break;
7445               }
7446             break;
7447           case 0x21:
7448               GETBYTE ();
7449               switch (op[2] & 0x00)
7450               {
7451                 case 0x00:
7452                   goto op_semantics_51;
7453                   break;
7454               }
7455             break;
7456           case 0x22:
7457               GETBYTE ();
7458               switch (op[2] & 0x00)
7459               {
7460                 case 0x00:
7461                   goto op_semantics_51;
7462                   break;
7463               }
7464             break;
7465           case 0x23:
7466               GETBYTE ();
7467               switch (op[2] & 0x00)
7468               {
7469                 case 0x00:
7470                   goto op_semantics_51;
7471                   break;
7472               }
7473             break;
7474           case 0x24:
7475               GETBYTE ();
7476               switch (op[2] & 0x00)
7477               {
7478                 case 0x00:
7479                   op_semantics_52:
7480                     {
7481                       /** 1111 1100 0010 01ss rsrc rdst divu    %1%S1, %0 */
7482 #line 656 "rx-decode.opc"
7483                       int ss AU = op[1] & 0x03;
7484 #line 656 "rx-decode.opc"
7485                       int rsrc AU = (op[2] >> 4) & 0x0f;
7486 #line 656 "rx-decode.opc"
7487                       int rdst AU = op[2] & 0x0f;
7488                       if (trace)
7489                         {
7490                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7491                                  "/** 1111 1100 0010 01ss rsrc rdst     divu    %1%S1, %0 */",
7492                                  op[0], op[1], op[2]);
7493                           printf ("  ss = 0x%x,", ss);
7494                           printf ("  rsrc = 0x%x,", rsrc);
7495                           printf ("  rdst = 0x%x\n", rdst);
7496                         }
7497                       SYNTAX("divu      %1%S1, %0");
7498 #line 656 "rx-decode.opc"
7499                       ID(divu); SP(ss, rsrc); DR(rdst); F_O___;
7500
7501                     }
7502                   break;
7503               }
7504             break;
7505           case 0x25:
7506               GETBYTE ();
7507               switch (op[2] & 0x00)
7508               {
7509                 case 0x00:
7510                   goto op_semantics_52;
7511                   break;
7512               }
7513             break;
7514           case 0x26:
7515               GETBYTE ();
7516               switch (op[2] & 0x00)
7517               {
7518                 case 0x00:
7519                   goto op_semantics_52;
7520                   break;
7521               }
7522             break;
7523           case 0x27:
7524               GETBYTE ();
7525               switch (op[2] & 0x00)
7526               {
7527                 case 0x00:
7528                   goto op_semantics_52;
7529                   break;
7530               }
7531             break;
7532           case 0x30:
7533               GETBYTE ();
7534               switch (op[2] & 0x00)
7535               {
7536                 case 0x00:
7537                   op_semantics_53:
7538                     {
7539                       /** 1111 1100 0011 00ss rsrc rdst tst     %1%S1, %2 */
7540 #line 467 "rx-decode.opc"
7541                       int ss AU = op[1] & 0x03;
7542 #line 467 "rx-decode.opc"
7543                       int rsrc AU = (op[2] >> 4) & 0x0f;
7544 #line 467 "rx-decode.opc"
7545                       int rdst AU = op[2] & 0x0f;
7546                       if (trace)
7547                         {
7548                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7549                                  "/** 1111 1100 0011 00ss rsrc rdst     tst     %1%S1, %2 */",
7550                                  op[0], op[1], op[2]);
7551                           printf ("  ss = 0x%x,", ss);
7552                           printf ("  rsrc = 0x%x,", rsrc);
7553                           printf ("  rdst = 0x%x\n", rdst);
7554                         }
7555                       SYNTAX("tst       %1%S1, %2");
7556 #line 467 "rx-decode.opc"
7557                       ID(and); SP(ss, rsrc); S2R(rdst); F__SZ_;
7558
7559                     }
7560                   break;
7561               }
7562             break;
7563           case 0x31:
7564               GETBYTE ();
7565               switch (op[2] & 0x00)
7566               {
7567                 case 0x00:
7568                   goto op_semantics_53;
7569                   break;
7570               }
7571             break;
7572           case 0x32:
7573               GETBYTE ();
7574               switch (op[2] & 0x00)
7575               {
7576                 case 0x00:
7577                   goto op_semantics_53;
7578                   break;
7579               }
7580             break;
7581           case 0x33:
7582               GETBYTE ();
7583               switch (op[2] & 0x00)
7584               {
7585                 case 0x00:
7586                   goto op_semantics_53;
7587                   break;
7588               }
7589             break;
7590           case 0x34:
7591               GETBYTE ();
7592               switch (op[2] & 0x00)
7593               {
7594                 case 0x00:
7595                   op_semantics_54:
7596                     {
7597                       /** 1111 1100 0011 01ss rsrc rdst xor     %1%S1, %0 */
7598 #line 446 "rx-decode.opc"
7599                       int ss AU = op[1] & 0x03;
7600 #line 446 "rx-decode.opc"
7601                       int rsrc AU = (op[2] >> 4) & 0x0f;
7602 #line 446 "rx-decode.opc"
7603                       int rdst AU = op[2] & 0x0f;
7604                       if (trace)
7605                         {
7606                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7607                                  "/** 1111 1100 0011 01ss rsrc rdst     xor     %1%S1, %0 */",
7608                                  op[0], op[1], op[2]);
7609                           printf ("  ss = 0x%x,", ss);
7610                           printf ("  rsrc = 0x%x,", rsrc);
7611                           printf ("  rdst = 0x%x\n", rdst);
7612                         }
7613                       SYNTAX("xor       %1%S1, %0");
7614 #line 446 "rx-decode.opc"
7615                       ID(xor); SP(ss, rsrc); DR(rdst); F__SZ_;
7616
7617                     }
7618                   break;
7619               }
7620             break;
7621           case 0x35:
7622               GETBYTE ();
7623               switch (op[2] & 0x00)
7624               {
7625                 case 0x00:
7626                   goto op_semantics_54;
7627                   break;
7628               }
7629             break;
7630           case 0x36:
7631               GETBYTE ();
7632               switch (op[2] & 0x00)
7633               {
7634                 case 0x00:
7635                   goto op_semantics_54;
7636                   break;
7637               }
7638             break;
7639           case 0x37:
7640               GETBYTE ();
7641               switch (op[2] & 0x00)
7642               {
7643                 case 0x00:
7644                   goto op_semantics_54;
7645                   break;
7646               }
7647             break;
7648           case 0x3b:
7649               GETBYTE ();
7650               switch (op[2] & 0x00)
7651               {
7652                 case 0x00:
7653                     {
7654                       /** 1111 1100 0011 1011 rsrc rdst not     %1, %0 */
7655 #line 458 "rx-decode.opc"
7656                       int rsrc AU = (op[2] >> 4) & 0x0f;
7657 #line 458 "rx-decode.opc"
7658                       int rdst AU = op[2] & 0x0f;
7659                       if (trace)
7660                         {
7661                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7662                                  "/** 1111 1100 0011 1011 rsrc rdst     not     %1, %0 */",
7663                                  op[0], op[1], op[2]);
7664                           printf ("  rsrc = 0x%x,", rsrc);
7665                           printf ("  rdst = 0x%x\n", rdst);
7666                         }
7667                       SYNTAX("not       %1, %0");
7668 #line 458 "rx-decode.opc"
7669                       ID(xor); DR(rdst); SR(rsrc); S2C(~0); F__SZ_;
7670
7671                     /*----------------------------------------------------------------------*/
7672                     /* TST                                                                      */
7673
7674                     }
7675                   break;
7676               }
7677             break;
7678           case 0x40:
7679               GETBYTE ();
7680               switch (op[2] & 0x00)
7681               {
7682                 case 0x00:
7683                   op_semantics_55:
7684                     {
7685                       /** 1111 1100 0100 00ss rsrc rdst xchg    %1%S1, %0 */
7686 #line 380 "rx-decode.opc"
7687                       int ss AU = op[1] & 0x03;
7688 #line 380 "rx-decode.opc"
7689                       int rsrc AU = (op[2] >> 4) & 0x0f;
7690 #line 380 "rx-decode.opc"
7691                       int rdst AU = op[2] & 0x0f;
7692                       if (trace)
7693                         {
7694                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7695                                  "/** 1111 1100 0100 00ss rsrc rdst     xchg    %1%S1, %0 */",
7696                                  op[0], op[1], op[2]);
7697                           printf ("  ss = 0x%x,", ss);
7698                           printf ("  rsrc = 0x%x,", rsrc);
7699                           printf ("  rdst = 0x%x\n", rdst);
7700                         }
7701                       SYNTAX("xchg      %1%S1, %0");
7702 #line 380 "rx-decode.opc"
7703                       ID(xchg); DR(rdst); SP(ss, rsrc);
7704
7705                     }
7706                   break;
7707               }
7708             break;
7709           case 0x41:
7710               GETBYTE ();
7711               switch (op[2] & 0x00)
7712               {
7713                 case 0x00:
7714                   goto op_semantics_55;
7715                   break;
7716               }
7717             break;
7718           case 0x42:
7719               GETBYTE ();
7720               switch (op[2] & 0x00)
7721               {
7722                 case 0x00:
7723                   goto op_semantics_55;
7724                   break;
7725               }
7726             break;
7727           case 0x43:
7728               GETBYTE ();
7729               switch (op[2] & 0x00)
7730               {
7731                 case 0x00:
7732                   goto op_semantics_55;
7733                   break;
7734               }
7735             break;
7736           case 0x44:
7737               GETBYTE ();
7738               switch (op[2] & 0x00)
7739               {
7740                 case 0x00:
7741                   op_semantics_56:
7742                     {
7743                       /** 1111 1100 0100 01sd rsrc rdst itof    %1%S1, %0 */
7744 #line 885 "rx-decode.opc"
7745                       int sd AU = op[1] & 0x03;
7746 #line 885 "rx-decode.opc"
7747                       int rsrc AU = (op[2] >> 4) & 0x0f;
7748 #line 885 "rx-decode.opc"
7749                       int rdst AU = op[2] & 0x0f;
7750                       if (trace)
7751                         {
7752                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7753                                  "/** 1111 1100 0100 01sd rsrc rdst     itof    %1%S1, %0 */",
7754                                  op[0], op[1], op[2]);
7755                           printf ("  sd = 0x%x,", sd);
7756                           printf ("  rsrc = 0x%x,", rsrc);
7757                           printf ("  rdst = 0x%x\n", rdst);
7758                         }
7759                       SYNTAX("itof      %1%S1, %0");
7760 #line 885 "rx-decode.opc"
7761                       ID(itof); DR (rdst); SP(sd, rsrc); F__SZ_;
7762
7763                     }
7764                   break;
7765               }
7766             break;
7767           case 0x45:
7768               GETBYTE ();
7769               switch (op[2] & 0x00)
7770               {
7771                 case 0x00:
7772                   goto op_semantics_56;
7773                   break;
7774               }
7775             break;
7776           case 0x46:
7777               GETBYTE ();
7778               switch (op[2] & 0x00)
7779               {
7780                 case 0x00:
7781                   goto op_semantics_56;
7782                   break;
7783               }
7784             break;
7785           case 0x47:
7786               GETBYTE ();
7787               switch (op[2] & 0x00)
7788               {
7789                 case 0x00:
7790                   goto op_semantics_56;
7791                   break;
7792               }
7793             break;
7794           case 0x60:
7795               GETBYTE ();
7796               switch (op[2] & 0x00)
7797               {
7798                 case 0x00:
7799                   op_semantics_57:
7800                     {
7801                       /** 1111 1100 0110 00sd rdst rsrc bset    %1, %0%S0 */
7802 #line 897 "rx-decode.opc"
7803                       int sd AU = op[1] & 0x03;
7804 #line 897 "rx-decode.opc"
7805                       int rdst AU = (op[2] >> 4) & 0x0f;
7806 #line 897 "rx-decode.opc"
7807                       int rsrc AU = op[2] & 0x0f;
7808                       if (trace)
7809                         {
7810                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7811                                  "/** 1111 1100 0110 00sd rdst rsrc     bset    %1, %0%S0 */",
7812                                  op[0], op[1], op[2]);
7813                           printf ("  sd = 0x%x,", sd);
7814                           printf ("  rdst = 0x%x,", rdst);
7815                           printf ("  rsrc = 0x%x\n", rsrc);
7816                         }
7817                       SYNTAX("bset      %1, %0%S0");
7818 #line 897 "rx-decode.opc"
7819                       ID(bset); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____;
7820                       if (sd == 3) /* bset reg,reg */
7821                         BWL(LSIZE);
7822
7823                     }
7824                   break;
7825               }
7826             break;
7827           case 0x61:
7828               GETBYTE ();
7829               switch (op[2] & 0x00)
7830               {
7831                 case 0x00:
7832                   goto op_semantics_57;
7833                   break;
7834               }
7835             break;
7836           case 0x62:
7837               GETBYTE ();
7838               switch (op[2] & 0x00)
7839               {
7840                 case 0x00:
7841                   goto op_semantics_57;
7842                   break;
7843               }
7844             break;
7845           case 0x63:
7846               GETBYTE ();
7847               switch (op[2] & 0x00)
7848               {
7849                 case 0x00:
7850                   goto op_semantics_57;
7851                   break;
7852               }
7853             break;
7854           case 0x64:
7855               GETBYTE ();
7856               switch (op[2] & 0x00)
7857               {
7858                 case 0x00:
7859                   op_semantics_58:
7860                     {
7861                       /** 1111 1100 0110 01sd rdst rsrc bclr    %1, %0%S0 */
7862 #line 909 "rx-decode.opc"
7863                       int sd AU = op[1] & 0x03;
7864 #line 909 "rx-decode.opc"
7865                       int rdst AU = (op[2] >> 4) & 0x0f;
7866 #line 909 "rx-decode.opc"
7867                       int rsrc AU = op[2] & 0x0f;
7868                       if (trace)
7869                         {
7870                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7871                                  "/** 1111 1100 0110 01sd rdst rsrc     bclr    %1, %0%S0 */",
7872                                  op[0], op[1], op[2]);
7873                           printf ("  sd = 0x%x,", sd);
7874                           printf ("  rdst = 0x%x,", rdst);
7875                           printf ("  rsrc = 0x%x\n", rsrc);
7876                         }
7877                       SYNTAX("bclr      %1, %0%S0");
7878 #line 909 "rx-decode.opc"
7879                       ID(bclr); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____;
7880                       if (sd == 3) /* bset reg,reg */
7881                         BWL(LSIZE);
7882
7883                     }
7884                   break;
7885               }
7886             break;
7887           case 0x65:
7888               GETBYTE ();
7889               switch (op[2] & 0x00)
7890               {
7891                 case 0x00:
7892                   goto op_semantics_58;
7893                   break;
7894               }
7895             break;
7896           case 0x66:
7897               GETBYTE ();
7898               switch (op[2] & 0x00)
7899               {
7900                 case 0x00:
7901                   goto op_semantics_58;
7902                   break;
7903               }
7904             break;
7905           case 0x67:
7906               GETBYTE ();
7907               switch (op[2] & 0x00)
7908               {
7909                 case 0x00:
7910                   goto op_semantics_58;
7911                   break;
7912               }
7913             break;
7914           case 0x68:
7915               GETBYTE ();
7916               switch (op[2] & 0x00)
7917               {
7918                 case 0x00:
7919                   op_semantics_59:
7920                     {
7921                       /** 1111 1100 0110 10sd rdst rsrc btst    %2, %1%S1 */
7922 #line 921 "rx-decode.opc"
7923                       int sd AU = op[1] & 0x03;
7924 #line 921 "rx-decode.opc"
7925                       int rdst AU = (op[2] >> 4) & 0x0f;
7926 #line 921 "rx-decode.opc"
7927                       int rsrc AU = op[2] & 0x0f;
7928                       if (trace)
7929                         {
7930                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7931                                  "/** 1111 1100 0110 10sd rdst rsrc     btst    %2, %1%S1 */",
7932                                  op[0], op[1], op[2]);
7933                           printf ("  sd = 0x%x,", sd);
7934                           printf ("  rdst = 0x%x,", rdst);
7935                           printf ("  rsrc = 0x%x\n", rsrc);
7936                         }
7937                       SYNTAX("btst      %2, %1%S1");
7938 #line 921 "rx-decode.opc"
7939                       ID(btst); BWL(BSIZE); S2R(rsrc); SD(sd, rdst, BSIZE); F___ZC;
7940                       if (sd == 3) /* bset reg,reg */
7941                         BWL(LSIZE);
7942
7943                     }
7944                   break;
7945               }
7946             break;
7947           case 0x69:
7948               GETBYTE ();
7949               switch (op[2] & 0x00)
7950               {
7951                 case 0x00:
7952                   goto op_semantics_59;
7953                   break;
7954               }
7955             break;
7956           case 0x6a:
7957               GETBYTE ();
7958               switch (op[2] & 0x00)
7959               {
7960                 case 0x00:
7961                   goto op_semantics_59;
7962                   break;
7963               }
7964             break;
7965           case 0x6b:
7966               GETBYTE ();
7967               switch (op[2] & 0x00)
7968               {
7969                 case 0x00:
7970                   goto op_semantics_59;
7971                   break;
7972               }
7973             break;
7974           case 0x6c:
7975               GETBYTE ();
7976               switch (op[2] & 0x00)
7977               {
7978                 case 0x00:
7979                   op_semantics_60:
7980                     {
7981                       /** 1111 1100 0110 11sd rdst rsrc bnot    %1, %0%S0 */
7982 #line 933 "rx-decode.opc"
7983                       int sd AU = op[1] & 0x03;
7984 #line 933 "rx-decode.opc"
7985                       int rdst AU = (op[2] >> 4) & 0x0f;
7986 #line 933 "rx-decode.opc"
7987                       int rsrc AU = op[2] & 0x0f;
7988                       if (trace)
7989                         {
7990                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7991                                  "/** 1111 1100 0110 11sd rdst rsrc     bnot    %1, %0%S0 */",
7992                                  op[0], op[1], op[2]);
7993                           printf ("  sd = 0x%x,", sd);
7994                           printf ("  rdst = 0x%x,", rdst);
7995                           printf ("  rsrc = 0x%x\n", rsrc);
7996                         }
7997                       SYNTAX("bnot      %1, %0%S0");
7998 #line 933 "rx-decode.opc"
7999                       ID(bnot); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE);
8000                       if (sd == 3) /* bset reg,reg */
8001                         BWL(LSIZE);
8002
8003                     }
8004                   break;
8005               }
8006             break;
8007           case 0x6d:
8008               GETBYTE ();
8009               switch (op[2] & 0x00)
8010               {
8011                 case 0x00:
8012                   goto op_semantics_60;
8013                   break;
8014               }
8015             break;
8016           case 0x6e:
8017               GETBYTE ();
8018               switch (op[2] & 0x00)
8019               {
8020                 case 0x00:
8021                   goto op_semantics_60;
8022                   break;
8023               }
8024             break;
8025           case 0x6f:
8026               GETBYTE ();
8027               switch (op[2] & 0x00)
8028               {
8029                 case 0x00:
8030                   goto op_semantics_60;
8031                   break;
8032               }
8033             break;
8034           case 0x80:
8035               GETBYTE ();
8036               switch (op[2] & 0x00)
8037               {
8038                 case 0x00:
8039                   op_semantics_61:
8040                     {
8041                       /** 1111 1100 1000 00sd rsrc rdst fsub    %1%S1, %0 */
8042 #line 864 "rx-decode.opc"
8043                       int sd AU = op[1] & 0x03;
8044 #line 864 "rx-decode.opc"
8045                       int rsrc AU = (op[2] >> 4) & 0x0f;
8046 #line 864 "rx-decode.opc"
8047                       int rdst AU = op[2] & 0x0f;
8048                       if (trace)
8049                         {
8050                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8051                                  "/** 1111 1100 1000 00sd rsrc rdst     fsub    %1%S1, %0 */",
8052                                  op[0], op[1], op[2]);
8053                           printf ("  sd = 0x%x,", sd);
8054                           printf ("  rsrc = 0x%x,", rsrc);
8055                           printf ("  rdst = 0x%x\n", rdst);
8056                         }
8057                       SYNTAX("fsub      %1%S1, %0");
8058 #line 864 "rx-decode.opc"
8059                       ID(fsub); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8060
8061                     }
8062                   break;
8063               }
8064             break;
8065           case 0x81:
8066               GETBYTE ();
8067               switch (op[2] & 0x00)
8068               {
8069                 case 0x00:
8070                   goto op_semantics_61;
8071                   break;
8072               }
8073             break;
8074           case 0x82:
8075               GETBYTE ();
8076               switch (op[2] & 0x00)
8077               {
8078                 case 0x00:
8079                   goto op_semantics_61;
8080                   break;
8081               }
8082             break;
8083           case 0x83:
8084               GETBYTE ();
8085               switch (op[2] & 0x00)
8086               {
8087                 case 0x00:
8088                   goto op_semantics_61;
8089                   break;
8090               }
8091             break;
8092           case 0x84:
8093               GETBYTE ();
8094               switch (op[2] & 0x00)
8095               {
8096                 case 0x00:
8097                   op_semantics_62:
8098                     {
8099                       /** 1111 1100 1000 01sd rsrc rdst fcmp    %1%S1, %0 */
8100 #line 858 "rx-decode.opc"
8101                       int sd AU = op[1] & 0x03;
8102 #line 858 "rx-decode.opc"
8103                       int rsrc AU = (op[2] >> 4) & 0x0f;
8104 #line 858 "rx-decode.opc"
8105                       int rdst AU = op[2] & 0x0f;
8106                       if (trace)
8107                         {
8108                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8109                                  "/** 1111 1100 1000 01sd rsrc rdst     fcmp    %1%S1, %0 */",
8110                                  op[0], op[1], op[2]);
8111                           printf ("  sd = 0x%x,", sd);
8112                           printf ("  rsrc = 0x%x,", rsrc);
8113                           printf ("  rdst = 0x%x\n", rdst);
8114                         }
8115                       SYNTAX("fcmp      %1%S1, %0");
8116 #line 858 "rx-decode.opc"
8117                       ID(fcmp); DR(rdst); SD(sd, rsrc, LSIZE); F_OSZ_;
8118
8119                     }
8120                   break;
8121               }
8122             break;
8123           case 0x85:
8124               GETBYTE ();
8125               switch (op[2] & 0x00)
8126               {
8127                 case 0x00:
8128                   goto op_semantics_62;
8129                   break;
8130               }
8131             break;
8132           case 0x86:
8133               GETBYTE ();
8134               switch (op[2] & 0x00)
8135               {
8136                 case 0x00:
8137                   goto op_semantics_62;
8138                   break;
8139               }
8140             break;
8141           case 0x87:
8142               GETBYTE ();
8143               switch (op[2] & 0x00)
8144               {
8145                 case 0x00:
8146                   goto op_semantics_62;
8147                   break;
8148               }
8149             break;
8150           case 0x88:
8151               GETBYTE ();
8152               switch (op[2] & 0x00)
8153               {
8154                 case 0x00:
8155                   op_semantics_63:
8156                     {
8157                       /** 1111 1100 1000 10sd rsrc rdst fadd    %1%S1, %0 */
8158 #line 852 "rx-decode.opc"
8159                       int sd AU = op[1] & 0x03;
8160 #line 852 "rx-decode.opc"
8161                       int rsrc AU = (op[2] >> 4) & 0x0f;
8162 #line 852 "rx-decode.opc"
8163                       int rdst AU = op[2] & 0x0f;
8164                       if (trace)
8165                         {
8166                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8167                                  "/** 1111 1100 1000 10sd rsrc rdst     fadd    %1%S1, %0 */",
8168                                  op[0], op[1], op[2]);
8169                           printf ("  sd = 0x%x,", sd);
8170                           printf ("  rsrc = 0x%x,", rsrc);
8171                           printf ("  rdst = 0x%x\n", rdst);
8172                         }
8173                       SYNTAX("fadd      %1%S1, %0");
8174 #line 852 "rx-decode.opc"
8175                       ID(fadd); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8176
8177                     }
8178                   break;
8179               }
8180             break;
8181           case 0x89:
8182               GETBYTE ();
8183               switch (op[2] & 0x00)
8184               {
8185                 case 0x00:
8186                   goto op_semantics_63;
8187                   break;
8188               }
8189             break;
8190           case 0x8a:
8191               GETBYTE ();
8192               switch (op[2] & 0x00)
8193               {
8194                 case 0x00:
8195                   goto op_semantics_63;
8196                   break;
8197               }
8198             break;
8199           case 0x8b:
8200               GETBYTE ();
8201               switch (op[2] & 0x00)
8202               {
8203                 case 0x00:
8204                   goto op_semantics_63;
8205                   break;
8206               }
8207             break;
8208           case 0x8c:
8209               GETBYTE ();
8210               switch (op[2] & 0x00)
8211               {
8212                 case 0x00:
8213                   op_semantics_64:
8214                     {
8215                       /** 1111 1100 1000 11sd rsrc rdst fmul    %1%S1, %0 */
8216 #line 873 "rx-decode.opc"
8217                       int sd AU = op[1] & 0x03;
8218 #line 873 "rx-decode.opc"
8219                       int rsrc AU = (op[2] >> 4) & 0x0f;
8220 #line 873 "rx-decode.opc"
8221                       int rdst AU = op[2] & 0x0f;
8222                       if (trace)
8223                         {
8224                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8225                                  "/** 1111 1100 1000 11sd rsrc rdst     fmul    %1%S1, %0 */",
8226                                  op[0], op[1], op[2]);
8227                           printf ("  sd = 0x%x,", sd);
8228                           printf ("  rsrc = 0x%x,", rsrc);
8229                           printf ("  rdst = 0x%x\n", rdst);
8230                         }
8231                       SYNTAX("fmul      %1%S1, %0");
8232 #line 873 "rx-decode.opc"
8233                       ID(fmul); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8234
8235                     }
8236                   break;
8237               }
8238             break;
8239           case 0x8d:
8240               GETBYTE ();
8241               switch (op[2] & 0x00)
8242               {
8243                 case 0x00:
8244                   goto op_semantics_64;
8245                   break;
8246               }
8247             break;
8248           case 0x8e:
8249               GETBYTE ();
8250               switch (op[2] & 0x00)
8251               {
8252                 case 0x00:
8253                   goto op_semantics_64;
8254                   break;
8255               }
8256             break;
8257           case 0x8f:
8258               GETBYTE ();
8259               switch (op[2] & 0x00)
8260               {
8261                 case 0x00:
8262                   goto op_semantics_64;
8263                   break;
8264               }
8265             break;
8266           case 0x90:
8267               GETBYTE ();
8268               switch (op[2] & 0x00)
8269               {
8270                 case 0x00:
8271                   op_semantics_65:
8272                     {
8273                       /** 1111 1100 1001 00sd rsrc rdst fdiv    %1%S1, %0 */
8274 #line 879 "rx-decode.opc"
8275                       int sd AU = op[1] & 0x03;
8276 #line 879 "rx-decode.opc"
8277                       int rsrc AU = (op[2] >> 4) & 0x0f;
8278 #line 879 "rx-decode.opc"
8279                       int rdst AU = op[2] & 0x0f;
8280                       if (trace)
8281                         {
8282                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8283                                  "/** 1111 1100 1001 00sd rsrc rdst     fdiv    %1%S1, %0 */",
8284                                  op[0], op[1], op[2]);
8285                           printf ("  sd = 0x%x,", sd);
8286                           printf ("  rsrc = 0x%x,", rsrc);
8287                           printf ("  rdst = 0x%x\n", rdst);
8288                         }
8289                       SYNTAX("fdiv      %1%S1, %0");
8290 #line 879 "rx-decode.opc"
8291                       ID(fdiv); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8292
8293                     }
8294                   break;
8295               }
8296             break;
8297           case 0x91:
8298               GETBYTE ();
8299               switch (op[2] & 0x00)
8300               {
8301                 case 0x00:
8302                   goto op_semantics_65;
8303                   break;
8304               }
8305             break;
8306           case 0x92:
8307               GETBYTE ();
8308               switch (op[2] & 0x00)
8309               {
8310                 case 0x00:
8311                   goto op_semantics_65;
8312                   break;
8313               }
8314             break;
8315           case 0x93:
8316               GETBYTE ();
8317               switch (op[2] & 0x00)
8318               {
8319                 case 0x00:
8320                   goto op_semantics_65;
8321                   break;
8322               }
8323             break;
8324           case 0x94:
8325               GETBYTE ();
8326               switch (op[2] & 0x00)
8327               {
8328                 case 0x00:
8329                   op_semantics_66:
8330                     {
8331                       /** 1111 1100 1001 01sd rsrc rdst ftoi    %1%S1, %0 */
8332 #line 867 "rx-decode.opc"
8333                       int sd AU = op[1] & 0x03;
8334 #line 867 "rx-decode.opc"
8335                       int rsrc AU = (op[2] >> 4) & 0x0f;
8336 #line 867 "rx-decode.opc"
8337                       int rdst AU = op[2] & 0x0f;
8338                       if (trace)
8339                         {
8340                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8341                                  "/** 1111 1100 1001 01sd rsrc rdst     ftoi    %1%S1, %0 */",
8342                                  op[0], op[1], op[2]);
8343                           printf ("  sd = 0x%x,", sd);
8344                           printf ("  rsrc = 0x%x,", rsrc);
8345                           printf ("  rdst = 0x%x\n", rdst);
8346                         }
8347                       SYNTAX("ftoi      %1%S1, %0");
8348 #line 867 "rx-decode.opc"
8349                       ID(ftoi); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8350
8351                     }
8352                   break;
8353               }
8354             break;
8355           case 0x95:
8356               GETBYTE ();
8357               switch (op[2] & 0x00)
8358               {
8359                 case 0x00:
8360                   goto op_semantics_66;
8361                   break;
8362               }
8363             break;
8364           case 0x96:
8365               GETBYTE ();
8366               switch (op[2] & 0x00)
8367               {
8368                 case 0x00:
8369                   goto op_semantics_66;
8370                   break;
8371               }
8372             break;
8373           case 0x97:
8374               GETBYTE ();
8375               switch (op[2] & 0x00)
8376               {
8377                 case 0x00:
8378                   goto op_semantics_66;
8379                   break;
8380               }
8381             break;
8382           case 0x98:
8383               GETBYTE ();
8384               switch (op[2] & 0x00)
8385               {
8386                 case 0x00:
8387                   op_semantics_67:
8388                     {
8389                       /** 1111 1100 1001 10sd rsrc rdst round   %1%S1, %0 */
8390 #line 882 "rx-decode.opc"
8391                       int sd AU = op[1] & 0x03;
8392 #line 882 "rx-decode.opc"
8393                       int rsrc AU = (op[2] >> 4) & 0x0f;
8394 #line 882 "rx-decode.opc"
8395                       int rdst AU = op[2] & 0x0f;
8396                       if (trace)
8397                         {
8398                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8399                                  "/** 1111 1100 1001 10sd rsrc rdst     round   %1%S1, %0 */",
8400                                  op[0], op[1], op[2]);
8401                           printf ("  sd = 0x%x,", sd);
8402                           printf ("  rsrc = 0x%x,", rsrc);
8403                           printf ("  rdst = 0x%x\n", rdst);
8404                         }
8405                       SYNTAX("round     %1%S1, %0");
8406 #line 882 "rx-decode.opc"
8407                       ID(round); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8408
8409                     }
8410                   break;
8411               }
8412             break;
8413           case 0x99:
8414               GETBYTE ();
8415               switch (op[2] & 0x00)
8416               {
8417                 case 0x00:
8418                   goto op_semantics_67;
8419                   break;
8420               }
8421             break;
8422           case 0x9a:
8423               GETBYTE ();
8424               switch (op[2] & 0x00)
8425               {
8426                 case 0x00:
8427                   goto op_semantics_67;
8428                   break;
8429               }
8430             break;
8431           case 0x9b:
8432               GETBYTE ();
8433               switch (op[2] & 0x00)
8434               {
8435                 case 0x00:
8436                   goto op_semantics_67;
8437                   break;
8438               }
8439             break;
8440           case 0xd0:
8441               GETBYTE ();
8442               switch (op[2] & 0x00)
8443               {
8444                 case 0x00:
8445                   op_semantics_68:
8446                     {
8447                       /** 1111 1100 1101 sz sd rdst cond        sc%1%s  %0 */
8448 #line 999 "rx-decode.opc"
8449                       int sz AU = (op[1] >> 2) & 0x03;
8450 #line 999 "rx-decode.opc"
8451                       int sd AU = op[1] & 0x03;
8452 #line 999 "rx-decode.opc"
8453                       int rdst AU = (op[2] >> 4) & 0x0f;
8454 #line 999 "rx-decode.opc"
8455                       int cond AU = op[2] & 0x0f;
8456                       if (trace)
8457                         {
8458                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8459                                  "/** 1111 1100 1101 sz sd rdst cond    sc%1%s  %0 */",
8460                                  op[0], op[1], op[2]);
8461                           printf ("  sz = 0x%x,", sz);
8462                           printf ("  sd = 0x%x,", sd);
8463                           printf ("  rdst = 0x%x,", rdst);
8464                           printf ("  cond = 0x%x\n", cond);
8465                         }
8466                       SYNTAX("sc%1%s    %0");
8467 #line 999 "rx-decode.opc"
8468                       ID(sccnd); BWL(sz); DD (sd, rdst, sz); Scc(cond);
8469
8470                     }
8471                   break;
8472               }
8473             break;
8474           case 0xd1:
8475               GETBYTE ();
8476               switch (op[2] & 0x00)
8477               {
8478                 case 0x00:
8479                   goto op_semantics_68;
8480                   break;
8481               }
8482             break;
8483           case 0xd2:
8484               GETBYTE ();
8485               switch (op[2] & 0x00)
8486               {
8487                 case 0x00:
8488                   goto op_semantics_68;
8489                   break;
8490               }
8491             break;
8492           case 0xd3:
8493               GETBYTE ();
8494               switch (op[2] & 0x00)
8495               {
8496                 case 0x00:
8497                   goto op_semantics_68;
8498                   break;
8499               }
8500             break;
8501           case 0xd4:
8502               GETBYTE ();
8503               switch (op[2] & 0x00)
8504               {
8505                 case 0x00:
8506                   goto op_semantics_68;
8507                   break;
8508               }
8509             break;
8510           case 0xd5:
8511               GETBYTE ();
8512               switch (op[2] & 0x00)
8513               {
8514                 case 0x00:
8515                   goto op_semantics_68;
8516                   break;
8517               }
8518             break;
8519           case 0xd6:
8520               GETBYTE ();
8521               switch (op[2] & 0x00)
8522               {
8523                 case 0x00:
8524                   goto op_semantics_68;
8525                   break;
8526               }
8527             break;
8528           case 0xd7:
8529               GETBYTE ();
8530               switch (op[2] & 0x00)
8531               {
8532                 case 0x00:
8533                   goto op_semantics_68;
8534                   break;
8535               }
8536             break;
8537           case 0xd8:
8538               GETBYTE ();
8539               switch (op[2] & 0x00)
8540               {
8541                 case 0x00:
8542                   goto op_semantics_68;
8543                   break;
8544               }
8545             break;
8546           case 0xd9:
8547               GETBYTE ();
8548               switch (op[2] & 0x00)
8549               {
8550                 case 0x00:
8551                   goto op_semantics_68;
8552                   break;
8553               }
8554             break;
8555           case 0xda:
8556               GETBYTE ();
8557               switch (op[2] & 0x00)
8558               {
8559                 case 0x00:
8560                   goto op_semantics_68;
8561                   break;
8562               }
8563             break;
8564           case 0xdb:
8565               GETBYTE ();
8566               switch (op[2] & 0x00)
8567               {
8568                 case 0x00:
8569                   goto op_semantics_68;
8570                   break;
8571               }
8572             break;
8573           case 0xe0:
8574               GETBYTE ();
8575               switch (op[2] & 0x0f)
8576               {
8577                 case 0x00:
8578                 case 0x01:
8579                 case 0x02:
8580                 case 0x03:
8581                 case 0x04:
8582                 case 0x05:
8583                 case 0x06:
8584                 case 0x07:
8585                 case 0x08:
8586                 case 0x09:
8587                 case 0x0a:
8588                 case 0x0b:
8589                 case 0x0c:
8590                 case 0x0d:
8591                 case 0x0e:
8592                   op_semantics_69:
8593                     {
8594                       /** 1111 1100 111bit sd rdst cond bm%2    #%1, %0%S0 */
8595 #line 942 "rx-decode.opc"
8596                       int bit AU = (op[1] >> 2) & 0x07;
8597 #line 942 "rx-decode.opc"
8598                       int sd AU = op[1] & 0x03;
8599 #line 942 "rx-decode.opc"
8600                       int rdst AU = (op[2] >> 4) & 0x0f;
8601 #line 942 "rx-decode.opc"
8602                       int cond AU = op[2] & 0x0f;
8603                       if (trace)
8604                         {
8605                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8606                                  "/** 1111 1100 111bit sd rdst cond     bm%2    #%1, %0%S0 */",
8607                                  op[0], op[1], op[2]);
8608                           printf ("  bit = 0x%x,", bit);
8609                           printf ("  sd = 0x%x,", sd);
8610                           printf ("  rdst = 0x%x,", rdst);
8611                           printf ("  cond = 0x%x\n", cond);
8612                         }
8613                       SYNTAX("bm%2      #%1, %0%S0");
8614 #line 942 "rx-decode.opc"
8615                       ID(bmcc); BWL(BSIZE); S2cc(cond); SC(bit); DD(sd, rdst, BSIZE);
8616
8617                     }
8618                   break;
8619                 case 0x0f:
8620                   op_semantics_70:
8621                     {
8622                       /** 1111 1100 111bit sd rdst 1111 bnot    #%1, %0%S0 */
8623 #line 930 "rx-decode.opc"
8624                       int bit AU = (op[1] >> 2) & 0x07;
8625 #line 930 "rx-decode.opc"
8626                       int sd AU = op[1] & 0x03;
8627 #line 930 "rx-decode.opc"
8628                       int rdst AU = (op[2] >> 4) & 0x0f;
8629                       if (trace)
8630                         {
8631                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8632                                  "/** 1111 1100 111bit sd rdst 1111     bnot    #%1, %0%S0 */",
8633                                  op[0], op[1], op[2]);
8634                           printf ("  bit = 0x%x,", bit);
8635                           printf ("  sd = 0x%x,", sd);
8636                           printf ("  rdst = 0x%x\n", rdst);
8637                         }
8638                       SYNTAX("bnot      #%1, %0%S0");
8639 #line 930 "rx-decode.opc"
8640                       ID(bnot); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE);
8641
8642                     }
8643                   break;
8644               }
8645             break;
8646           case 0xe1:
8647               GETBYTE ();
8648               switch (op[2] & 0x0f)
8649               {
8650                 case 0x00:
8651                 case 0x01:
8652                 case 0x02:
8653                 case 0x03:
8654                 case 0x04:
8655                 case 0x05:
8656                 case 0x06:
8657                 case 0x07:
8658                 case 0x08:
8659                 case 0x09:
8660                 case 0x0a:
8661                 case 0x0b:
8662                 case 0x0c:
8663                 case 0x0d:
8664                 case 0x0e:
8665                   goto op_semantics_69;
8666                   break;
8667                 case 0x0f:
8668                   goto op_semantics_70;
8669                   break;
8670               }
8671             break;
8672           case 0xe2:
8673               GETBYTE ();
8674               switch (op[2] & 0x0f)
8675               {
8676                 case 0x00:
8677                 case 0x01:
8678                 case 0x02:
8679                 case 0x03:
8680                 case 0x04:
8681                 case 0x05:
8682                 case 0x06:
8683                 case 0x07:
8684                 case 0x08:
8685                 case 0x09:
8686                 case 0x0a:
8687                 case 0x0b:
8688                 case 0x0c:
8689                 case 0x0d:
8690                 case 0x0e:
8691                   goto op_semantics_69;
8692                   break;
8693                 case 0x0f:
8694                   goto op_semantics_70;
8695                   break;
8696               }
8697             break;
8698           case 0xe3:
8699               GETBYTE ();
8700               switch (op[2] & 0x0f)
8701               {
8702                 case 0x00:
8703                 case 0x01:
8704                 case 0x02:
8705                 case 0x03:
8706                 case 0x04:
8707                 case 0x05:
8708                 case 0x06:
8709                 case 0x07:
8710                 case 0x08:
8711                 case 0x09:
8712                 case 0x0a:
8713                 case 0x0b:
8714                 case 0x0c:
8715                 case 0x0d:
8716                 case 0x0e:
8717                   goto op_semantics_69;
8718                   break;
8719                 case 0x0f:
8720                   goto op_semantics_70;
8721                   break;
8722               }
8723             break;
8724           case 0xe4:
8725               GETBYTE ();
8726               switch (op[2] & 0x0f)
8727               {
8728                 case 0x00:
8729                 case 0x01:
8730                 case 0x02:
8731                 case 0x03:
8732                 case 0x04:
8733                 case 0x05:
8734                 case 0x06:
8735                 case 0x07:
8736                 case 0x08:
8737                 case 0x09:
8738                 case 0x0a:
8739                 case 0x0b:
8740                 case 0x0c:
8741                 case 0x0d:
8742                 case 0x0e:
8743                   goto op_semantics_69;
8744                   break;
8745                 case 0x0f:
8746                   goto op_semantics_70;
8747                   break;
8748               }
8749             break;
8750           case 0xe5:
8751               GETBYTE ();
8752               switch (op[2] & 0x0f)
8753               {
8754                 case 0x00:
8755                 case 0x01:
8756                 case 0x02:
8757                 case 0x03:
8758                 case 0x04:
8759                 case 0x05:
8760                 case 0x06:
8761                 case 0x07:
8762                 case 0x08:
8763                 case 0x09:
8764                 case 0x0a:
8765                 case 0x0b:
8766                 case 0x0c:
8767                 case 0x0d:
8768                 case 0x0e:
8769                   goto op_semantics_69;
8770                   break;
8771                 case 0x0f:
8772                   goto op_semantics_70;
8773                   break;
8774               }
8775             break;
8776           case 0xe6:
8777               GETBYTE ();
8778               switch (op[2] & 0x0f)
8779               {
8780                 case 0x00:
8781                 case 0x01:
8782                 case 0x02:
8783                 case 0x03:
8784                 case 0x04:
8785                 case 0x05:
8786                 case 0x06:
8787                 case 0x07:
8788                 case 0x08:
8789                 case 0x09:
8790                 case 0x0a:
8791                 case 0x0b:
8792                 case 0x0c:
8793                 case 0x0d:
8794                 case 0x0e:
8795                   goto op_semantics_69;
8796                   break;
8797                 case 0x0f:
8798                   goto op_semantics_70;
8799                   break;
8800               }
8801             break;
8802           case 0xe7:
8803               GETBYTE ();
8804               switch (op[2] & 0x0f)
8805               {
8806                 case 0x00:
8807                 case 0x01:
8808                 case 0x02:
8809                 case 0x03:
8810                 case 0x04:
8811                 case 0x05:
8812                 case 0x06:
8813                 case 0x07:
8814                 case 0x08:
8815                 case 0x09:
8816                 case 0x0a:
8817                 case 0x0b:
8818                 case 0x0c:
8819                 case 0x0d:
8820                 case 0x0e:
8821                   goto op_semantics_69;
8822                   break;
8823                 case 0x0f:
8824                   goto op_semantics_70;
8825                   break;
8826               }
8827             break;
8828           case 0xe8:
8829               GETBYTE ();
8830               switch (op[2] & 0x0f)
8831               {
8832                 case 0x00:
8833                 case 0x01:
8834                 case 0x02:
8835                 case 0x03:
8836                 case 0x04:
8837                 case 0x05:
8838                 case 0x06:
8839                 case 0x07:
8840                 case 0x08:
8841                 case 0x09:
8842                 case 0x0a:
8843                 case 0x0b:
8844                 case 0x0c:
8845                 case 0x0d:
8846                 case 0x0e:
8847                   goto op_semantics_69;
8848                   break;
8849                 case 0x0f:
8850                   goto op_semantics_70;
8851                   break;
8852               }
8853             break;
8854           case 0xe9:
8855               GETBYTE ();
8856               switch (op[2] & 0x0f)
8857               {
8858                 case 0x00:
8859                 case 0x01:
8860                 case 0x02:
8861                 case 0x03:
8862                 case 0x04:
8863                 case 0x05:
8864                 case 0x06:
8865                 case 0x07:
8866                 case 0x08:
8867                 case 0x09:
8868                 case 0x0a:
8869                 case 0x0b:
8870                 case 0x0c:
8871                 case 0x0d:
8872                 case 0x0e:
8873                   goto op_semantics_69;
8874                   break;
8875                 case 0x0f:
8876                   goto op_semantics_70;
8877                   break;
8878               }
8879             break;
8880           case 0xea:
8881               GETBYTE ();
8882               switch (op[2] & 0x0f)
8883               {
8884                 case 0x00:
8885                 case 0x01:
8886                 case 0x02:
8887                 case 0x03:
8888                 case 0x04:
8889                 case 0x05:
8890                 case 0x06:
8891                 case 0x07:
8892                 case 0x08:
8893                 case 0x09:
8894                 case 0x0a:
8895                 case 0x0b:
8896                 case 0x0c:
8897                 case 0x0d:
8898                 case 0x0e:
8899                   goto op_semantics_69;
8900                   break;
8901                 case 0x0f:
8902                   goto op_semantics_70;
8903                   break;
8904               }
8905             break;
8906           case 0xeb:
8907               GETBYTE ();
8908               switch (op[2] & 0x0f)
8909               {
8910                 case 0x00:
8911                 case 0x01:
8912                 case 0x02:
8913                 case 0x03:
8914                 case 0x04:
8915                 case 0x05:
8916                 case 0x06:
8917                 case 0x07:
8918                 case 0x08:
8919                 case 0x09:
8920                 case 0x0a:
8921                 case 0x0b:
8922                 case 0x0c:
8923                 case 0x0d:
8924                 case 0x0e:
8925                   goto op_semantics_69;
8926                   break;
8927                 case 0x0f:
8928                   goto op_semantics_70;
8929                   break;
8930               }
8931             break;
8932           case 0xec:
8933               GETBYTE ();
8934               switch (op[2] & 0x0f)
8935               {
8936                 case 0x00:
8937                 case 0x01:
8938                 case 0x02:
8939                 case 0x03:
8940                 case 0x04:
8941                 case 0x05:
8942                 case 0x06:
8943                 case 0x07:
8944                 case 0x08:
8945                 case 0x09:
8946                 case 0x0a:
8947                 case 0x0b:
8948                 case 0x0c:
8949                 case 0x0d:
8950                 case 0x0e:
8951                   goto op_semantics_69;
8952                   break;
8953                 case 0x0f:
8954                   goto op_semantics_70;
8955                   break;
8956               }
8957             break;
8958           case 0xed:
8959               GETBYTE ();
8960               switch (op[2] & 0x0f)
8961               {
8962                 case 0x00:
8963                 case 0x01:
8964                 case 0x02:
8965                 case 0x03:
8966                 case 0x04:
8967                 case 0x05:
8968                 case 0x06:
8969                 case 0x07:
8970                 case 0x08:
8971                 case 0x09:
8972                 case 0x0a:
8973                 case 0x0b:
8974                 case 0x0c:
8975                 case 0x0d:
8976                 case 0x0e:
8977                   goto op_semantics_69;
8978                   break;
8979                 case 0x0f:
8980                   goto op_semantics_70;
8981                   break;
8982               }
8983             break;
8984           case 0xee:
8985               GETBYTE ();
8986               switch (op[2] & 0x0f)
8987               {
8988                 case 0x00:
8989                 case 0x01:
8990                 case 0x02:
8991                 case 0x03:
8992                 case 0x04:
8993                 case 0x05:
8994                 case 0x06:
8995                 case 0x07:
8996                 case 0x08:
8997                 case 0x09:
8998                 case 0x0a:
8999                 case 0x0b:
9000                 case 0x0c:
9001                 case 0x0d:
9002                 case 0x0e:
9003                   goto op_semantics_69;
9004                   break;
9005                 case 0x0f:
9006                   goto op_semantics_70;
9007                   break;
9008               }
9009             break;
9010           case 0xef:
9011               GETBYTE ();
9012               switch (op[2] & 0x0f)
9013               {
9014                 case 0x00:
9015                 case 0x01:
9016                 case 0x02:
9017                 case 0x03:
9018                 case 0x04:
9019                 case 0x05:
9020                 case 0x06:
9021                 case 0x07:
9022                 case 0x08:
9023                 case 0x09:
9024                 case 0x0a:
9025                 case 0x0b:
9026                 case 0x0c:
9027                 case 0x0d:
9028                 case 0x0e:
9029                   goto op_semantics_69;
9030                   break;
9031                 case 0x0f:
9032                   goto op_semantics_70;
9033                   break;
9034               }
9035             break;
9036           case 0xf0:
9037               GETBYTE ();
9038               switch (op[2] & 0x0f)
9039               {
9040                 case 0x00:
9041                 case 0x01:
9042                 case 0x02:
9043                 case 0x03:
9044                 case 0x04:
9045                 case 0x05:
9046                 case 0x06:
9047                 case 0x07:
9048                 case 0x08:
9049                 case 0x09:
9050                 case 0x0a:
9051                 case 0x0b:
9052                 case 0x0c:
9053                 case 0x0d:
9054                 case 0x0e:
9055                   goto op_semantics_69;
9056                   break;
9057                 case 0x0f:
9058                   goto op_semantics_70;
9059                   break;
9060               }
9061             break;
9062           case 0xf1:
9063               GETBYTE ();
9064               switch (op[2] & 0x0f)
9065               {
9066                 case 0x00:
9067                 case 0x01:
9068                 case 0x02:
9069                 case 0x03:
9070                 case 0x04:
9071                 case 0x05:
9072                 case 0x06:
9073                 case 0x07:
9074                 case 0x08:
9075                 case 0x09:
9076                 case 0x0a:
9077                 case 0x0b:
9078                 case 0x0c:
9079                 case 0x0d:
9080                 case 0x0e:
9081                   goto op_semantics_69;
9082                   break;
9083                 case 0x0f:
9084                   goto op_semantics_70;
9085                   break;
9086               }
9087             break;
9088           case 0xf2:
9089               GETBYTE ();
9090               switch (op[2] & 0x0f)
9091               {
9092                 case 0x00:
9093                 case 0x01:
9094                 case 0x02:
9095                 case 0x03:
9096                 case 0x04:
9097                 case 0x05:
9098                 case 0x06:
9099                 case 0x07:
9100                 case 0x08:
9101                 case 0x09:
9102                 case 0x0a:
9103                 case 0x0b:
9104                 case 0x0c:
9105                 case 0x0d:
9106                 case 0x0e:
9107                   goto op_semantics_69;
9108                   break;
9109                 case 0x0f:
9110                   goto op_semantics_70;
9111                   break;
9112               }
9113             break;
9114           case 0xf3:
9115               GETBYTE ();
9116               switch (op[2] & 0x0f)
9117               {
9118                 case 0x00:
9119                 case 0x01:
9120                 case 0x02:
9121                 case 0x03:
9122                 case 0x04:
9123                 case 0x05:
9124                 case 0x06:
9125                 case 0x07:
9126                 case 0x08:
9127                 case 0x09:
9128                 case 0x0a:
9129                 case 0x0b:
9130                 case 0x0c:
9131                 case 0x0d:
9132                 case 0x0e:
9133                   goto op_semantics_69;
9134                   break;
9135                 case 0x0f:
9136                   goto op_semantics_70;
9137                   break;
9138               }
9139             break;
9140           case 0xf4:
9141               GETBYTE ();
9142               switch (op[2] & 0x0f)
9143               {
9144                 case 0x00:
9145                 case 0x01:
9146                 case 0x02:
9147                 case 0x03:
9148                 case 0x04:
9149                 case 0x05:
9150                 case 0x06:
9151                 case 0x07:
9152                 case 0x08:
9153                 case 0x09:
9154                 case 0x0a:
9155                 case 0x0b:
9156                 case 0x0c:
9157                 case 0x0d:
9158                 case 0x0e:
9159                   goto op_semantics_69;
9160                   break;
9161                 case 0x0f:
9162                   goto op_semantics_70;
9163                   break;
9164               }
9165             break;
9166           case 0xf5:
9167               GETBYTE ();
9168               switch (op[2] & 0x0f)
9169               {
9170                 case 0x00:
9171                 case 0x01:
9172                 case 0x02:
9173                 case 0x03:
9174                 case 0x04:
9175                 case 0x05:
9176                 case 0x06:
9177                 case 0x07:
9178                 case 0x08:
9179                 case 0x09:
9180                 case 0x0a:
9181                 case 0x0b:
9182                 case 0x0c:
9183                 case 0x0d:
9184                 case 0x0e:
9185                   goto op_semantics_69;
9186                   break;
9187                 case 0x0f:
9188                   goto op_semantics_70;
9189                   break;
9190               }
9191             break;
9192           case 0xf6:
9193               GETBYTE ();
9194               switch (op[2] & 0x0f)
9195               {
9196                 case 0x00:
9197                 case 0x01:
9198                 case 0x02:
9199                 case 0x03:
9200                 case 0x04:
9201                 case 0x05:
9202                 case 0x06:
9203                 case 0x07:
9204                 case 0x08:
9205                 case 0x09:
9206                 case 0x0a:
9207                 case 0x0b:
9208                 case 0x0c:
9209                 case 0x0d:
9210                 case 0x0e:
9211                   goto op_semantics_69;
9212                   break;
9213                 case 0x0f:
9214                   goto op_semantics_70;
9215                   break;
9216               }
9217             break;
9218           case 0xf7:
9219               GETBYTE ();
9220               switch (op[2] & 0x0f)
9221               {
9222                 case 0x00:
9223                 case 0x01:
9224                 case 0x02:
9225                 case 0x03:
9226                 case 0x04:
9227                 case 0x05:
9228                 case 0x06:
9229                 case 0x07:
9230                 case 0x08:
9231                 case 0x09:
9232                 case 0x0a:
9233                 case 0x0b:
9234                 case 0x0c:
9235                 case 0x0d:
9236                 case 0x0e:
9237                   goto op_semantics_69;
9238                   break;
9239                 case 0x0f:
9240                   goto op_semantics_70;
9241                   break;
9242               }
9243             break;
9244           case 0xf8:
9245               GETBYTE ();
9246               switch (op[2] & 0x0f)
9247               {
9248                 case 0x00:
9249                 case 0x01:
9250                 case 0x02:
9251                 case 0x03:
9252                 case 0x04:
9253                 case 0x05:
9254                 case 0x06:
9255                 case 0x07:
9256                 case 0x08:
9257                 case 0x09:
9258                 case 0x0a:
9259                 case 0x0b:
9260                 case 0x0c:
9261                 case 0x0d:
9262                 case 0x0e:
9263                   goto op_semantics_69;
9264                   break;
9265                 case 0x0f:
9266                   goto op_semantics_70;
9267                   break;
9268               }
9269             break;
9270           case 0xf9:
9271               GETBYTE ();
9272               switch (op[2] & 0x0f)
9273               {
9274                 case 0x00:
9275                 case 0x01:
9276                 case 0x02:
9277                 case 0x03:
9278                 case 0x04:
9279                 case 0x05:
9280                 case 0x06:
9281                 case 0x07:
9282                 case 0x08:
9283                 case 0x09:
9284                 case 0x0a:
9285                 case 0x0b:
9286                 case 0x0c:
9287                 case 0x0d:
9288                 case 0x0e:
9289                   goto op_semantics_69;
9290                   break;
9291                 case 0x0f:
9292                   goto op_semantics_70;
9293                   break;
9294               }
9295             break;
9296           case 0xfa:
9297               GETBYTE ();
9298               switch (op[2] & 0x0f)
9299               {
9300                 case 0x00:
9301                 case 0x01:
9302                 case 0x02:
9303                 case 0x03:
9304                 case 0x04:
9305                 case 0x05:
9306                 case 0x06:
9307                 case 0x07:
9308                 case 0x08:
9309                 case 0x09:
9310                 case 0x0a:
9311                 case 0x0b:
9312                 case 0x0c:
9313                 case 0x0d:
9314                 case 0x0e:
9315                   goto op_semantics_69;
9316                   break;
9317                 case 0x0f:
9318                   goto op_semantics_70;
9319                   break;
9320               }
9321             break;
9322           case 0xfb:
9323               GETBYTE ();
9324               switch (op[2] & 0x0f)
9325               {
9326                 case 0x00:
9327                 case 0x01:
9328                 case 0x02:
9329                 case 0x03:
9330                 case 0x04:
9331                 case 0x05:
9332                 case 0x06:
9333                 case 0x07:
9334                 case 0x08:
9335                 case 0x09:
9336                 case 0x0a:
9337                 case 0x0b:
9338                 case 0x0c:
9339                 case 0x0d:
9340                 case 0x0e:
9341                   goto op_semantics_69;
9342                   break;
9343                 case 0x0f:
9344                   goto op_semantics_70;
9345                   break;
9346               }
9347             break;
9348           case 0xfc:
9349               GETBYTE ();
9350               switch (op[2] & 0x0f)
9351               {
9352                 case 0x00:
9353                 case 0x01:
9354                 case 0x02:
9355                 case 0x03:
9356                 case 0x04:
9357                 case 0x05:
9358                 case 0x06:
9359                 case 0x07:
9360                 case 0x08:
9361                 case 0x09:
9362                 case 0x0a:
9363                 case 0x0b:
9364                 case 0x0c:
9365                 case 0x0d:
9366                 case 0x0e:
9367                   goto op_semantics_69;
9368                   break;
9369                 case 0x0f:
9370                   goto op_semantics_70;
9371                   break;
9372               }
9373             break;
9374           case 0xfd:
9375               GETBYTE ();
9376               switch (op[2] & 0x0f)
9377               {
9378                 case 0x00:
9379                 case 0x01:
9380                 case 0x02:
9381                 case 0x03:
9382                 case 0x04:
9383                 case 0x05:
9384                 case 0x06:
9385                 case 0x07:
9386                 case 0x08:
9387                 case 0x09:
9388                 case 0x0a:
9389                 case 0x0b:
9390                 case 0x0c:
9391                 case 0x0d:
9392                 case 0x0e:
9393                   goto op_semantics_69;
9394                   break;
9395                 case 0x0f:
9396                   goto op_semantics_70;
9397                   break;
9398               }
9399             break;
9400           case 0xfe:
9401               GETBYTE ();
9402               switch (op[2] & 0x0f)
9403               {
9404                 case 0x00:
9405                 case 0x01:
9406                 case 0x02:
9407                 case 0x03:
9408                 case 0x04:
9409                 case 0x05:
9410                 case 0x06:
9411                 case 0x07:
9412                 case 0x08:
9413                 case 0x09:
9414                 case 0x0a:
9415                 case 0x0b:
9416                 case 0x0c:
9417                 case 0x0d:
9418                 case 0x0e:
9419                   goto op_semantics_69;
9420                   break;
9421                 case 0x0f:
9422                   goto op_semantics_70;
9423                   break;
9424               }
9425             break;
9426           case 0xff:
9427               GETBYTE ();
9428               switch (op[2] & 0x0f)
9429               {
9430                 case 0x00:
9431                 case 0x01:
9432                 case 0x02:
9433                 case 0x03:
9434                 case 0x04:
9435                 case 0x05:
9436                 case 0x06:
9437                 case 0x07:
9438                 case 0x08:
9439                 case 0x09:
9440                 case 0x0a:
9441                 case 0x0b:
9442                 case 0x0c:
9443                 case 0x0d:
9444                 case 0x0e:
9445                   goto op_semantics_69;
9446                   break;
9447                 case 0x0f:
9448                   goto op_semantics_70;
9449                   break;
9450               }
9451             break;
9452           default: UNSUPPORTED(); break;
9453         }
9454       break;
9455     case 0xfd:
9456         GETBYTE ();
9457         switch (op[1] & 0xff)
9458         {
9459           case 0x00:
9460               GETBYTE ();
9461               switch (op[2] & 0x00)
9462               {
9463                 case 0x00:
9464                     {
9465                       /** 1111 1101 0000 0000 srca srcb mulhi   %1, %2 */
9466 #line 807 "rx-decode.opc"
9467                       int srca AU = (op[2] >> 4) & 0x0f;
9468 #line 807 "rx-decode.opc"
9469                       int srcb AU = op[2] & 0x0f;
9470                       if (trace)
9471                         {
9472                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9473                                  "/** 1111 1101 0000 0000 srca srcb     mulhi   %1, %2 */",
9474                                  op[0], op[1], op[2]);
9475                           printf ("  srca = 0x%x,", srca);
9476                           printf ("  srcb = 0x%x\n", srcb);
9477                         }
9478                       SYNTAX("mulhi     %1, %2");
9479 #line 807 "rx-decode.opc"
9480                       ID(mulhi); SR(srca); S2R(srcb); F_____;
9481
9482                     }
9483                   break;
9484               }
9485             break;
9486           case 0x01:
9487               GETBYTE ();
9488               switch (op[2] & 0x00)
9489               {
9490                 case 0x00:
9491                     {
9492                       /** 1111 1101 0000 0001 srca srcb mullo   %1, %2 */
9493 #line 810 "rx-decode.opc"
9494                       int srca AU = (op[2] >> 4) & 0x0f;
9495 #line 810 "rx-decode.opc"
9496                       int srcb AU = op[2] & 0x0f;
9497                       if (trace)
9498                         {
9499                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9500                                  "/** 1111 1101 0000 0001 srca srcb     mullo   %1, %2 */",
9501                                  op[0], op[1], op[2]);
9502                           printf ("  srca = 0x%x,", srca);
9503                           printf ("  srcb = 0x%x\n", srcb);
9504                         }
9505                       SYNTAX("mullo     %1, %2");
9506 #line 810 "rx-decode.opc"
9507                       ID(mullo); SR(srca); S2R(srcb); F_____;
9508
9509                     }
9510                   break;
9511               }
9512             break;
9513           case 0x04:
9514               GETBYTE ();
9515               switch (op[2] & 0x00)
9516               {
9517                 case 0x00:
9518                     {
9519                       /** 1111 1101 0000 0100 srca srcb machi   %1, %2 */
9520 #line 813 "rx-decode.opc"
9521                       int srca AU = (op[2] >> 4) & 0x0f;
9522 #line 813 "rx-decode.opc"
9523                       int srcb AU = op[2] & 0x0f;
9524                       if (trace)
9525                         {
9526                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9527                                  "/** 1111 1101 0000 0100 srca srcb     machi   %1, %2 */",
9528                                  op[0], op[1], op[2]);
9529                           printf ("  srca = 0x%x,", srca);
9530                           printf ("  srcb = 0x%x\n", srcb);
9531                         }
9532                       SYNTAX("machi     %1, %2");
9533 #line 813 "rx-decode.opc"
9534                       ID(machi); SR(srca); S2R(srcb); F_____;
9535
9536                     }
9537                   break;
9538               }
9539             break;
9540           case 0x05:
9541               GETBYTE ();
9542               switch (op[2] & 0x00)
9543               {
9544                 case 0x00:
9545                     {
9546                       /** 1111 1101 0000 0101 srca srcb maclo   %1, %2 */
9547 #line 816 "rx-decode.opc"
9548                       int srca AU = (op[2] >> 4) & 0x0f;
9549 #line 816 "rx-decode.opc"
9550                       int srcb AU = op[2] & 0x0f;
9551                       if (trace)
9552                         {
9553                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9554                                  "/** 1111 1101 0000 0101 srca srcb     maclo   %1, %2 */",
9555                                  op[0], op[1], op[2]);
9556                           printf ("  srca = 0x%x,", srca);
9557                           printf ("  srcb = 0x%x\n", srcb);
9558                         }
9559                       SYNTAX("maclo     %1, %2");
9560 #line 816 "rx-decode.opc"
9561                       ID(maclo); SR(srca); S2R(srcb); F_____;
9562
9563                     }
9564                   break;
9565               }
9566             break;
9567           case 0x17:
9568               GETBYTE ();
9569               switch (op[2] & 0xf0)
9570               {
9571                 case 0x00:
9572                     {
9573                       /** 1111 1101 0001 0111 0000 rsrc mvtachi %1 */
9574 #line 819 "rx-decode.opc"
9575                       int rsrc AU = op[2] & 0x0f;
9576                       if (trace)
9577                         {
9578                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9579                                  "/** 1111 1101 0001 0111 0000 rsrc     mvtachi %1 */",
9580                                  op[0], op[1], op[2]);
9581                           printf ("  rsrc = 0x%x\n", rsrc);
9582                         }
9583                       SYNTAX("mvtachi   %1");
9584 #line 819 "rx-decode.opc"
9585                       ID(mvtachi); SR(rsrc); F_____;
9586
9587                     }
9588                   break;
9589                 case 0x10:
9590                     {
9591                       /** 1111 1101 0001 0111 0001 rsrc mvtaclo %1 */
9592 #line 822 "rx-decode.opc"
9593                       int rsrc AU = op[2] & 0x0f;
9594                       if (trace)
9595                         {
9596                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9597                                  "/** 1111 1101 0001 0111 0001 rsrc     mvtaclo %1 */",
9598                                  op[0], op[1], op[2]);
9599                           printf ("  rsrc = 0x%x\n", rsrc);
9600                         }
9601                       SYNTAX("mvtaclo   %1");
9602 #line 822 "rx-decode.opc"
9603                       ID(mvtaclo); SR(rsrc); F_____;
9604
9605                     }
9606                   break;
9607                 default: UNSUPPORTED(); break;
9608               }
9609             break;
9610           case 0x18:
9611               GETBYTE ();
9612               switch (op[2] & 0xef)
9613               {
9614                 case 0x00:
9615                     {
9616                       /** 1111 1101 0001 1000 000i 0000 racw    #%1 */
9617 #line 834 "rx-decode.opc"
9618                       int i AU = (op[2] >> 4) & 0x01;
9619                       if (trace)
9620                         {
9621                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9622                                  "/** 1111 1101 0001 1000 000i 0000     racw    #%1 */",
9623                                  op[0], op[1], op[2]);
9624                           printf ("  i = 0x%x\n", i);
9625                         }
9626                       SYNTAX("racw      #%1");
9627 #line 834 "rx-decode.opc"
9628                       ID(racw); SC(i+1); F_____;
9629
9630                     /*----------------------------------------------------------------------*/
9631                     /* SAT                                                                      */
9632
9633                     }
9634                   break;
9635                 default: UNSUPPORTED(); break;
9636               }
9637             break;
9638           case 0x1f:
9639               GETBYTE ();
9640               switch (op[2] & 0xf0)
9641               {
9642                 case 0x00:
9643                     {
9644                       /** 1111 1101 0001 1111 0000 rdst mvfachi %0 */
9645 #line 825 "rx-decode.opc"
9646                       int rdst AU = op[2] & 0x0f;
9647                       if (trace)
9648                         {
9649                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9650                                  "/** 1111 1101 0001 1111 0000 rdst     mvfachi %0 */",
9651                                  op[0], op[1], op[2]);
9652                           printf ("  rdst = 0x%x\n", rdst);
9653                         }
9654                       SYNTAX("mvfachi   %0");
9655 #line 825 "rx-decode.opc"
9656                       ID(mvfachi); DR(rdst); F_____;
9657
9658                     }
9659                   break;
9660                 case 0x10:
9661                     {
9662                       /** 1111 1101 0001 1111 0001 rdst mvfaclo %0 */
9663 #line 831 "rx-decode.opc"
9664                       int rdst AU = op[2] & 0x0f;
9665                       if (trace)
9666                         {
9667                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9668                                  "/** 1111 1101 0001 1111 0001 rdst     mvfaclo %0 */",
9669                                  op[0], op[1], op[2]);
9670                           printf ("  rdst = 0x%x\n", rdst);
9671                         }
9672                       SYNTAX("mvfaclo   %0");
9673 #line 831 "rx-decode.opc"
9674                       ID(mvfaclo); DR(rdst); F_____;
9675
9676                     }
9677                   break;
9678                 case 0x20:
9679                     {
9680                       /** 1111 1101 0001 1111 0010 rdst mvfacmi %0 */
9681 #line 828 "rx-decode.opc"
9682                       int rdst AU = op[2] & 0x0f;
9683                       if (trace)
9684                         {
9685                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9686                                  "/** 1111 1101 0001 1111 0010 rdst     mvfacmi %0 */",
9687                                  op[0], op[1], op[2]);
9688                           printf ("  rdst = 0x%x\n", rdst);
9689                         }
9690                       SYNTAX("mvfacmi   %0");
9691 #line 828 "rx-decode.opc"
9692                       ID(mvfacmi); DR(rdst); F_____;
9693
9694                     }
9695                   break;
9696                 default: UNSUPPORTED(); break;
9697               }
9698             break;
9699           case 0x20:
9700               GETBYTE ();
9701               switch (op[2] & 0x00)
9702               {
9703                 case 0x00:
9704                   op_semantics_71:
9705                     {
9706                       /** 1111 1101 0010 0p sz rdst rsrc        mov%s   %1, %0 */
9707 #line 341 "rx-decode.opc"
9708                       int p AU = (op[1] >> 2) & 0x01;
9709 #line 341 "rx-decode.opc"
9710                       int sz AU = op[1] & 0x03;
9711 #line 341 "rx-decode.opc"
9712                       int rdst AU = (op[2] >> 4) & 0x0f;
9713 #line 341 "rx-decode.opc"
9714                       int rsrc AU = op[2] & 0x0f;
9715                       if (trace)
9716                         {
9717                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9718                                  "/** 1111 1101 0010 0p sz rdst rsrc    mov%s   %1, %0 */",
9719                                  op[0], op[1], op[2]);
9720                           printf ("  p = 0x%x,", p);
9721                           printf ("  sz = 0x%x,", sz);
9722                           printf ("  rdst = 0x%x,", rdst);
9723                           printf ("  rsrc = 0x%x\n", rsrc);
9724                         }
9725                       SYNTAX("mov%s     %1, %0");
9726 #line 341 "rx-decode.opc"
9727                       ID(mov); sBWL (sz); SR(rsrc); F_____;
9728                       OP(0, p ? RX_Operand_Predec : RX_Operand_Postinc, rdst, 0);
9729
9730                     }
9731                   break;
9732               }
9733             break;
9734           case 0x21:
9735               GETBYTE ();
9736               switch (op[2] & 0x00)
9737               {
9738                 case 0x00:
9739                   goto op_semantics_71;
9740                   break;
9741               }
9742             break;
9743           case 0x22:
9744               GETBYTE ();
9745               switch (op[2] & 0x00)
9746               {
9747                 case 0x00:
9748                   goto op_semantics_71;
9749                   break;
9750               }
9751             break;
9752           case 0x24:
9753               GETBYTE ();
9754               switch (op[2] & 0x00)
9755               {
9756                 case 0x00:
9757                   goto op_semantics_71;
9758                   break;
9759               }
9760             break;
9761           case 0x25:
9762               GETBYTE ();
9763               switch (op[2] & 0x00)
9764               {
9765                 case 0x00:
9766                   goto op_semantics_71;
9767                   break;
9768               }
9769             break;
9770           case 0x26:
9771               GETBYTE ();
9772               switch (op[2] & 0x00)
9773               {
9774                 case 0x00:
9775                   goto op_semantics_71;
9776                   break;
9777               }
9778             break;
9779           case 0x28:
9780               GETBYTE ();
9781               switch (op[2] & 0x00)
9782               {
9783                 case 0x00:
9784                   op_semantics_72:
9785                     {
9786                       /** 1111 1101 0010 1p sz rsrc rdst        mov%s   %1, %0 */
9787 #line 345 "rx-decode.opc"
9788                       int p AU = (op[1] >> 2) & 0x01;
9789 #line 345 "rx-decode.opc"
9790                       int sz AU = op[1] & 0x03;
9791 #line 345 "rx-decode.opc"
9792                       int rsrc AU = (op[2] >> 4) & 0x0f;
9793 #line 345 "rx-decode.opc"
9794                       int rdst AU = op[2] & 0x0f;
9795                       if (trace)
9796                         {
9797                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9798                                  "/** 1111 1101 0010 1p sz rsrc rdst    mov%s   %1, %0 */",
9799                                  op[0], op[1], op[2]);
9800                           printf ("  p = 0x%x,", p);
9801                           printf ("  sz = 0x%x,", sz);
9802                           printf ("  rsrc = 0x%x,", rsrc);
9803                           printf ("  rdst = 0x%x\n", rdst);
9804                         }
9805                       SYNTAX("mov%s     %1, %0");
9806 #line 345 "rx-decode.opc"
9807                       ID(mov); sBWL (sz); DR(rdst); F_____;
9808                       OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
9809
9810                     }
9811                   break;
9812               }
9813             break;
9814           case 0x29:
9815               GETBYTE ();
9816               switch (op[2] & 0x00)
9817               {
9818                 case 0x00:
9819                   goto op_semantics_72;
9820                   break;
9821               }
9822             break;
9823           case 0x2a:
9824               GETBYTE ();
9825               switch (op[2] & 0x00)
9826               {
9827                 case 0x00:
9828                   goto op_semantics_72;
9829                   break;
9830               }
9831             break;
9832           case 0x2c:
9833               GETBYTE ();
9834               switch (op[2] & 0x00)
9835               {
9836                 case 0x00:
9837                   goto op_semantics_72;
9838                   break;
9839               }
9840             break;
9841           case 0x2d:
9842               GETBYTE ();
9843               switch (op[2] & 0x00)
9844               {
9845                 case 0x00:
9846                   goto op_semantics_72;
9847                   break;
9848               }
9849             break;
9850           case 0x2e:
9851               GETBYTE ();
9852               switch (op[2] & 0x00)
9853               {
9854                 case 0x00:
9855                   goto op_semantics_72;
9856                   break;
9857               }
9858             break;
9859           case 0x38:
9860               GETBYTE ();
9861               switch (op[2] & 0x00)
9862               {
9863                 case 0x00:
9864                   op_semantics_73:
9865                     {
9866                       /** 1111 1101 0011 1p sz rsrc rdst        movu%s  %1, %0 */
9867 #line 355 "rx-decode.opc"
9868                       int p AU = (op[1] >> 2) & 0x01;
9869 #line 355 "rx-decode.opc"
9870                       int sz AU = op[1] & 0x03;
9871 #line 355 "rx-decode.opc"
9872                       int rsrc AU = (op[2] >> 4) & 0x0f;
9873 #line 355 "rx-decode.opc"
9874                       int rdst AU = op[2] & 0x0f;
9875                       if (trace)
9876                         {
9877                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9878                                  "/** 1111 1101 0011 1p sz rsrc rdst    movu%s  %1, %0 */",
9879                                  op[0], op[1], op[2]);
9880                           printf ("  p = 0x%x,", p);
9881                           printf ("  sz = 0x%x,", sz);
9882                           printf ("  rsrc = 0x%x,", rsrc);
9883                           printf ("  rdst = 0x%x\n", rdst);
9884                         }
9885                       SYNTAX("movu%s    %1, %0");
9886 #line 355 "rx-decode.opc"
9887                       ID(mov); uBWL (sz); DR(rdst); F_____;
9888                        OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
9889
9890                     /*----------------------------------------------------------------------*/
9891                     /* PUSH/POP                                                         */
9892
9893                     }
9894                   break;
9895               }
9896             break;
9897           case 0x39:
9898               GETBYTE ();
9899               switch (op[2] & 0x00)
9900               {
9901                 case 0x00:
9902                   goto op_semantics_73;
9903                   break;
9904               }
9905             break;
9906           case 0x3a:
9907               GETBYTE ();
9908               switch (op[2] & 0x00)
9909               {
9910                 case 0x00:
9911                   goto op_semantics_73;
9912                   break;
9913               }
9914             break;
9915           case 0x3c:
9916               GETBYTE ();
9917               switch (op[2] & 0x00)
9918               {
9919                 case 0x00:
9920                   goto op_semantics_73;
9921                   break;
9922               }
9923             break;
9924           case 0x3d:
9925               GETBYTE ();
9926               switch (op[2] & 0x00)
9927               {
9928                 case 0x00:
9929                   goto op_semantics_73;
9930                   break;
9931               }
9932             break;
9933           case 0x3e:
9934               GETBYTE ();
9935               switch (op[2] & 0x00)
9936               {
9937                 case 0x00:
9938                   goto op_semantics_73;
9939                   break;
9940               }
9941             break;
9942           case 0x60:
9943               GETBYTE ();
9944               switch (op[2] & 0x00)
9945               {
9946                 case 0x00:
9947                     {
9948                       /** 1111 1101 0110 0000 rsrc rdst shlr    %2, %0 */
9949 #line 688 "rx-decode.opc"
9950                       int rsrc AU = (op[2] >> 4) & 0x0f;
9951 #line 688 "rx-decode.opc"
9952                       int rdst AU = op[2] & 0x0f;
9953                       if (trace)
9954                         {
9955                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9956                                  "/** 1111 1101 0110 0000 rsrc rdst     shlr    %2, %0 */",
9957                                  op[0], op[1], op[2]);
9958                           printf ("  rsrc = 0x%x,", rsrc);
9959                           printf ("  rdst = 0x%x\n", rdst);
9960                         }
9961                       SYNTAX("shlr      %2, %0");
9962 #line 688 "rx-decode.opc"
9963                       ID(shlr); S2R(rsrc); SR(rdst); DR(rdst); F__SZC;
9964
9965                     }
9966                   break;
9967               }
9968             break;
9969           case 0x61:
9970               GETBYTE ();
9971               switch (op[2] & 0x00)
9972               {
9973                 case 0x00:
9974                     {
9975                       /** 1111 1101 0110 0001 rsrc rdst shar    %2, %0 */
9976 #line 678 "rx-decode.opc"
9977                       int rsrc AU = (op[2] >> 4) & 0x0f;
9978 #line 678 "rx-decode.opc"
9979                       int rdst AU = op[2] & 0x0f;
9980                       if (trace)
9981                         {
9982                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9983                                  "/** 1111 1101 0110 0001 rsrc rdst     shar    %2, %0 */",
9984                                  op[0], op[1], op[2]);
9985                           printf ("  rsrc = 0x%x,", rsrc);
9986                           printf ("  rdst = 0x%x\n", rdst);
9987                         }
9988                       SYNTAX("shar      %2, %0");
9989 #line 678 "rx-decode.opc"
9990                       ID(shar); S2R(rsrc); SR(rdst); DR(rdst); F_0SZC;
9991
9992                     }
9993                   break;
9994               }
9995             break;
9996           case 0x62:
9997               GETBYTE ();
9998               switch (op[2] & 0x00)
9999               {
10000                 case 0x00:
10001                     {
10002                       /** 1111 1101 0110 0010 rsrc rdst shll    %2, %0 */
10003 #line 668 "rx-decode.opc"
10004                       int rsrc AU = (op[2] >> 4) & 0x0f;
10005 #line 668 "rx-decode.opc"
10006                       int rdst AU = op[2] & 0x0f;
10007                       if (trace)
10008                         {
10009                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10010                                  "/** 1111 1101 0110 0010 rsrc rdst     shll    %2, %0 */",
10011                                  op[0], op[1], op[2]);
10012                           printf ("  rsrc = 0x%x,", rsrc);
10013                           printf ("  rdst = 0x%x\n", rdst);
10014                         }
10015                       SYNTAX("shll      %2, %0");
10016 #line 668 "rx-decode.opc"
10017                       ID(shll); S2R(rsrc); SR(rdst); DR(rdst); F_OSZC;
10018
10019                     }
10020                   break;
10021               }
10022             break;
10023           case 0x64:
10024               GETBYTE ();
10025               switch (op[2] & 0x00)
10026               {
10027                 case 0x00:
10028                     {
10029                       /** 1111 1101 0110 0100 rsrc rdst rotr    %1, %0 */
10030 #line 712 "rx-decode.opc"
10031                       int rsrc AU = (op[2] >> 4) & 0x0f;
10032 #line 712 "rx-decode.opc"
10033                       int rdst AU = op[2] & 0x0f;
10034                       if (trace)
10035                         {
10036                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10037                                  "/** 1111 1101 0110 0100 rsrc rdst     rotr    %1, %0 */",
10038                                  op[0], op[1], op[2]);
10039                           printf ("  rsrc = 0x%x,", rsrc);
10040                           printf ("  rdst = 0x%x\n", rdst);
10041                         }
10042                       SYNTAX("rotr      %1, %0");
10043 #line 712 "rx-decode.opc"
10044                       ID(rotr); SR(rsrc); DR(rdst); F__SZC;
10045
10046                     }
10047                   break;
10048               }
10049             break;
10050           case 0x65:
10051               GETBYTE ();
10052               switch (op[2] & 0x00)
10053               {
10054                 case 0x00:
10055                     {
10056                       /** 1111 1101 0110 0101 rsrc rdst revw    %1, %0 */
10057 #line 715 "rx-decode.opc"
10058                       int rsrc AU = (op[2] >> 4) & 0x0f;
10059 #line 715 "rx-decode.opc"
10060                       int rdst AU = op[2] & 0x0f;
10061                       if (trace)
10062                         {
10063                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10064                                  "/** 1111 1101 0110 0101 rsrc rdst     revw    %1, %0 */",
10065                                  op[0], op[1], op[2]);
10066                           printf ("  rsrc = 0x%x,", rsrc);
10067                           printf ("  rdst = 0x%x\n", rdst);
10068                         }
10069                       SYNTAX("revw      %1, %0");
10070 #line 715 "rx-decode.opc"
10071                       ID(revw); SR(rsrc); DR(rdst);
10072
10073                     }
10074                   break;
10075               }
10076             break;
10077           case 0x66:
10078               GETBYTE ();
10079               switch (op[2] & 0x00)
10080               {
10081                 case 0x00:
10082                     {
10083                       /** 1111 1101 0110 0110 rsrc rdst rotl    %1, %0 */
10084 #line 706 "rx-decode.opc"
10085                       int rsrc AU = (op[2] >> 4) & 0x0f;
10086 #line 706 "rx-decode.opc"
10087                       int rdst AU = op[2] & 0x0f;
10088                       if (trace)
10089                         {
10090                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10091                                  "/** 1111 1101 0110 0110 rsrc rdst     rotl    %1, %0 */",
10092                                  op[0], op[1], op[2]);
10093                           printf ("  rsrc = 0x%x,", rsrc);
10094                           printf ("  rdst = 0x%x\n", rdst);
10095                         }
10096                       SYNTAX("rotl      %1, %0");
10097 #line 706 "rx-decode.opc"
10098                       ID(rotl); SR(rsrc); DR(rdst); F__SZC;
10099
10100                     }
10101                   break;
10102               }
10103             break;
10104           case 0x67:
10105               GETBYTE ();
10106               switch (op[2] & 0x00)
10107               {
10108                 case 0x00:
10109                     {
10110                       /** 1111 1101 0110 0111 rsrc rdst revl    %1, %0 */
10111 #line 718 "rx-decode.opc"
10112                       int rsrc AU = (op[2] >> 4) & 0x0f;
10113 #line 718 "rx-decode.opc"
10114                       int rdst AU = op[2] & 0x0f;
10115                       if (trace)
10116                         {
10117                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10118                                  "/** 1111 1101 0110 0111 rsrc rdst     revl    %1, %0 */",
10119                                  op[0], op[1], op[2]);
10120                           printf ("  rsrc = 0x%x,", rsrc);
10121                           printf ("  rdst = 0x%x\n", rdst);
10122                         }
10123                       SYNTAX("revl      %1, %0");
10124 #line 718 "rx-decode.opc"
10125                       ID(revl); SR(rsrc); DR(rdst);
10126
10127                     /*----------------------------------------------------------------------*/
10128                     /* BRANCH                                                           */
10129
10130                     }
10131                   break;
10132               }
10133             break;
10134           case 0x68:
10135               GETBYTE ();
10136               switch (op[2] & 0x00)
10137               {
10138                 case 0x00:
10139                   op_semantics_74:
10140                     {
10141                       /** 1111 1101 0110 100c rsrc rdst mvtc    %1, %0 */
10142 #line 969 "rx-decode.opc"
10143                       int c AU = op[1] & 0x01;
10144 #line 969 "rx-decode.opc"
10145                       int rsrc AU = (op[2] >> 4) & 0x0f;
10146 #line 969 "rx-decode.opc"
10147                       int rdst AU = op[2] & 0x0f;
10148                       if (trace)
10149                         {
10150                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10151                                  "/** 1111 1101 0110 100c rsrc rdst     mvtc    %1, %0 */",
10152                                  op[0], op[1], op[2]);
10153                           printf ("  c = 0x%x,", c);
10154                           printf ("  rsrc = 0x%x,", rsrc);
10155                           printf ("  rdst = 0x%x\n", rdst);
10156                         }
10157                       SYNTAX("mvtc      %1, %0");
10158 #line 969 "rx-decode.opc"
10159                       ID(mov); SR(rsrc); DR(c*16+rdst + 16);
10160
10161                     }
10162                   break;
10163               }
10164             break;
10165           case 0x69:
10166               GETBYTE ();
10167               switch (op[2] & 0x00)
10168               {
10169                 case 0x00:
10170                   goto op_semantics_74;
10171                   break;
10172               }
10173             break;
10174           case 0x6a:
10175               GETBYTE ();
10176               switch (op[2] & 0x00)
10177               {
10178                 case 0x00:
10179                   op_semantics_75:
10180                     {
10181                       /** 1111 1101 0110 101s rsrc rdst mvfc    %1, %0 */
10182 #line 972 "rx-decode.opc"
10183                       int s AU = op[1] & 0x01;
10184 #line 972 "rx-decode.opc"
10185                       int rsrc AU = (op[2] >> 4) & 0x0f;
10186 #line 972 "rx-decode.opc"
10187                       int rdst AU = op[2] & 0x0f;
10188                       if (trace)
10189                         {
10190                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10191                                  "/** 1111 1101 0110 101s rsrc rdst     mvfc    %1, %0 */",
10192                                  op[0], op[1], op[2]);
10193                           printf ("  s = 0x%x,", s);
10194                           printf ("  rsrc = 0x%x,", rsrc);
10195                           printf ("  rdst = 0x%x\n", rdst);
10196                         }
10197                       SYNTAX("mvfc      %1, %0");
10198 #line 972 "rx-decode.opc"
10199                       ID(mov); SR((s*16+rsrc) + 16); DR(rdst);
10200
10201                     /*----------------------------------------------------------------------*/
10202                     /* INTERRUPTS                                                               */
10203
10204                     }
10205                   break;
10206               }
10207             break;
10208           case 0x6b:
10209               GETBYTE ();
10210               switch (op[2] & 0x00)
10211               {
10212                 case 0x00:
10213                   goto op_semantics_75;
10214                   break;
10215               }
10216             break;
10217           case 0x6c:
10218               GETBYTE ();
10219               switch (op[2] & 0x00)
10220               {
10221                 case 0x00:
10222                   op_semantics_76:
10223                     {
10224                       /** 1111 1101 0110 110i mmmm rdst rotr    #%1, %0 */
10225 #line 709 "rx-decode.opc"
10226                       int i AU = op[1] & 0x01;
10227 #line 709 "rx-decode.opc"
10228                       int mmmm AU = (op[2] >> 4) & 0x0f;
10229 #line 709 "rx-decode.opc"
10230                       int rdst AU = op[2] & 0x0f;
10231                       if (trace)
10232                         {
10233                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10234                                  "/** 1111 1101 0110 110i mmmm rdst     rotr    #%1, %0 */",
10235                                  op[0], op[1], op[2]);
10236                           printf ("  i = 0x%x,", i);
10237                           printf ("  mmmm = 0x%x,", mmmm);
10238                           printf ("  rdst = 0x%x\n", rdst);
10239                         }
10240                       SYNTAX("rotr      #%1, %0");
10241 #line 709 "rx-decode.opc"
10242                       ID(rotr); SC(i*16+mmmm); DR(rdst); F__SZC;
10243
10244                     }
10245                   break;
10246               }
10247             break;
10248           case 0x6d:
10249               GETBYTE ();
10250               switch (op[2] & 0x00)
10251               {
10252                 case 0x00:
10253                   goto op_semantics_76;
10254                   break;
10255               }
10256             break;
10257           case 0x6e:
10258               GETBYTE ();
10259               switch (op[2] & 0x00)
10260               {
10261                 case 0x00:
10262                   op_semantics_77:
10263                     {
10264                       /** 1111 1101 0110 111i mmmm rdst rotl    #%1, %0 */
10265 #line 703 "rx-decode.opc"
10266                       int i AU = op[1] & 0x01;
10267 #line 703 "rx-decode.opc"
10268                       int mmmm AU = (op[2] >> 4) & 0x0f;
10269 #line 703 "rx-decode.opc"
10270                       int rdst AU = op[2] & 0x0f;
10271                       if (trace)
10272                         {
10273                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10274                                  "/** 1111 1101 0110 111i mmmm rdst     rotl    #%1, %0 */",
10275                                  op[0], op[1], op[2]);
10276                           printf ("  i = 0x%x,", i);
10277                           printf ("  mmmm = 0x%x,", mmmm);
10278                           printf ("  rdst = 0x%x\n", rdst);
10279                         }
10280                       SYNTAX("rotl      #%1, %0");
10281 #line 703 "rx-decode.opc"
10282                       ID(rotl); SC(i*16+mmmm); DR(rdst); F__SZC;
10283
10284                     }
10285                   break;
10286               }
10287             break;
10288           case 0x6f:
10289               GETBYTE ();
10290               switch (op[2] & 0x00)
10291               {
10292                 case 0x00:
10293                   goto op_semantics_77;
10294                   break;
10295               }
10296             break;
10297           case 0x70:
10298               GETBYTE ();
10299               switch (op[2] & 0xf0)
10300               {
10301                 case 0x20:
10302                   op_semantics_78:
10303                     {
10304                       /** 1111 1101 0111 im00 0010rdst  adc     #%1, %0 */
10305 #line 485 "rx-decode.opc"
10306                       int im AU = (op[1] >> 2) & 0x03;
10307 #line 485 "rx-decode.opc"
10308                       int rdst AU = op[2] & 0x0f;
10309                       if (trace)
10310                         {
10311                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10312                                  "/** 1111 1101 0111 im00 0010rdst      adc     #%1, %0 */",
10313                                  op[0], op[1], op[2]);
10314                           printf ("  im = 0x%x,", im);
10315                           printf ("  rdst = 0x%x\n", rdst);
10316                         }
10317                       SYNTAX("adc       #%1, %0");
10318 #line 485 "rx-decode.opc"
10319                       ID(adc); SC(IMMex(im)); DR(rdst); F_OSZC;
10320
10321                     }
10322                   break;
10323                 case 0x40:
10324                   op_semantics_79:
10325                     {
10326                       /** 1111 1101 0111 im00 0100rdst  max     #%1, %0 */
10327 #line 567 "rx-decode.opc"
10328                       int im AU = (op[1] >> 2) & 0x03;
10329 #line 567 "rx-decode.opc"
10330                       int rdst AU = op[2] & 0x0f;
10331                       if (trace)
10332                         {
10333                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10334                                  "/** 1111 1101 0111 im00 0100rdst      max     #%1, %0 */",
10335                                  op[0], op[1], op[2]);
10336                           printf ("  im = 0x%x,", im);
10337                           printf ("  rdst = 0x%x\n", rdst);
10338                         }
10339                       SYNTAX("max       #%1, %0");
10340 #line 567 "rx-decode.opc"
10341                       ID(max); DR(rdst); SC(IMMex(im));
10342
10343                     }
10344                   break;
10345                 case 0x50:
10346                   op_semantics_80:
10347                     {
10348                       /** 1111 1101 0111 im00 0101rdst  min     #%1, %0 */
10349 #line 587 "rx-decode.opc"
10350                       int im AU = (op[1] >> 2) & 0x03;
10351 #line 587 "rx-decode.opc"
10352                       int rdst AU = op[2] & 0x0f;
10353                       if (trace)
10354                         {
10355                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10356                                  "/** 1111 1101 0111 im00 0101rdst      min     #%1, %0 */",
10357                                  op[0], op[1], op[2]);
10358                           printf ("  im = 0x%x,", im);
10359                           printf ("  rdst = 0x%x\n", rdst);
10360                         }
10361                       SYNTAX("min       #%1, %0");
10362 #line 587 "rx-decode.opc"
10363                       ID(min); DR(rdst); SC(IMMex(im));
10364
10365                     }
10366                   break;
10367                 case 0x60:
10368                   op_semantics_81:
10369                     {
10370                       /** 1111 1101 0111 im00 0110rdst  emul    #%1, %0 */
10371 #line 617 "rx-decode.opc"
10372                       int im AU = (op[1] >> 2) & 0x03;
10373 #line 617 "rx-decode.opc"
10374                       int rdst AU = op[2] & 0x0f;
10375                       if (trace)
10376                         {
10377                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10378                                  "/** 1111 1101 0111 im00 0110rdst      emul    #%1, %0 */",
10379                                  op[0], op[1], op[2]);
10380                           printf ("  im = 0x%x,", im);
10381                           printf ("  rdst = 0x%x\n", rdst);
10382                         }
10383                       SYNTAX("emul      #%1, %0");
10384 #line 617 "rx-decode.opc"
10385                       ID(emul); DR(rdst); SC(IMMex(im));
10386
10387                     }
10388                   break;
10389                 case 0x70:
10390                   op_semantics_82:
10391                     {
10392                       /** 1111 1101 0111 im00 0111rdst  emulu   #%1, %0 */
10393 #line 629 "rx-decode.opc"
10394                       int im AU = (op[1] >> 2) & 0x03;
10395 #line 629 "rx-decode.opc"
10396                       int rdst AU = op[2] & 0x0f;
10397                       if (trace)
10398                         {
10399                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10400                                  "/** 1111 1101 0111 im00 0111rdst      emulu   #%1, %0 */",
10401                                  op[0], op[1], op[2]);
10402                           printf ("  im = 0x%x,", im);
10403                           printf ("  rdst = 0x%x\n", rdst);
10404                         }
10405                       SYNTAX("emulu     #%1, %0");
10406 #line 629 "rx-decode.opc"
10407                       ID(emulu); DR(rdst); SC(IMMex(im));
10408
10409                     }
10410                   break;
10411                 case 0x80:
10412                   op_semantics_83:
10413                     {
10414                       /** 1111 1101 0111 im00 1000rdst  div     #%1, %0 */
10415 #line 641 "rx-decode.opc"
10416                       int im AU = (op[1] >> 2) & 0x03;
10417 #line 641 "rx-decode.opc"
10418                       int rdst AU = op[2] & 0x0f;
10419                       if (trace)
10420                         {
10421                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10422                                  "/** 1111 1101 0111 im00 1000rdst      div     #%1, %0 */",
10423                                  op[0], op[1], op[2]);
10424                           printf ("  im = 0x%x,", im);
10425                           printf ("  rdst = 0x%x\n", rdst);
10426                         }
10427                       SYNTAX("div       #%1, %0");
10428 #line 641 "rx-decode.opc"
10429                       ID(div); DR(rdst); SC(IMMex(im)); F_O___;
10430
10431                     }
10432                   break;
10433                 case 0x90:
10434                   op_semantics_84:
10435                     {
10436                       /** 1111 1101 0111 im00 1001rdst  divu    #%1, %0 */
10437 #line 653 "rx-decode.opc"
10438                       int im AU = (op[1] >> 2) & 0x03;
10439 #line 653 "rx-decode.opc"
10440                       int rdst AU = op[2] & 0x0f;
10441                       if (trace)
10442                         {
10443                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10444                                  "/** 1111 1101 0111 im00 1001rdst      divu    #%1, %0 */",
10445                                  op[0], op[1], op[2]);
10446                           printf ("  im = 0x%x,", im);
10447                           printf ("  rdst = 0x%x\n", rdst);
10448                         }
10449                       SYNTAX("divu      #%1, %0");
10450 #line 653 "rx-decode.opc"
10451                       ID(divu); DR(rdst); SC(IMMex(im)); F_O___;
10452
10453                     }
10454                   break;
10455                 case 0xc0:
10456                   op_semantics_85:
10457                     {
10458                       /** 1111 1101 0111 im00 1100rdst  tst     #%1, %2 */
10459 #line 464 "rx-decode.opc"
10460                       int im AU = (op[1] >> 2) & 0x03;
10461 #line 464 "rx-decode.opc"
10462                       int rdst AU = op[2] & 0x0f;
10463                       if (trace)
10464                         {
10465                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10466                                  "/** 1111 1101 0111 im00 1100rdst      tst     #%1, %2 */",
10467                                  op[0], op[1], op[2]);
10468                           printf ("  im = 0x%x,", im);
10469                           printf ("  rdst = 0x%x\n", rdst);
10470                         }
10471                       SYNTAX("tst       #%1, %2");
10472 #line 464 "rx-decode.opc"
10473                       ID(and); SC(IMMex(im)); S2R(rdst); F__SZ_;
10474
10475                     }
10476                   break;
10477                 case 0xd0:
10478                   op_semantics_86:
10479                     {
10480                       /** 1111 1101 0111 im00 1101rdst  xor     #%1, %0 */
10481 #line 443 "rx-decode.opc"
10482                       int im AU = (op[1] >> 2) & 0x03;
10483 #line 443 "rx-decode.opc"
10484                       int rdst AU = op[2] & 0x0f;
10485                       if (trace)
10486                         {
10487                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10488                                  "/** 1111 1101 0111 im00 1101rdst      xor     #%1, %0 */",
10489                                  op[0], op[1], op[2]);
10490                           printf ("  im = 0x%x,", im);
10491                           printf ("  rdst = 0x%x\n", rdst);
10492                         }
10493                       SYNTAX("xor       #%1, %0");
10494 #line 443 "rx-decode.opc"
10495                       ID(xor); SC(IMMex(im)); DR(rdst); F__SZ_;
10496
10497                     }
10498                   break;
10499                 case 0xe0:
10500                   op_semantics_87:
10501                     {
10502                       /** 1111 1101 0111 im00 1110rdst  stz     #%1, %0 */
10503 #line 389 "rx-decode.opc"
10504                       int im AU = (op[1] >> 2) & 0x03;
10505 #line 389 "rx-decode.opc"
10506                       int rdst AU = op[2] & 0x0f;
10507                       if (trace)
10508                         {
10509                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10510                                  "/** 1111 1101 0111 im00 1110rdst      stz     #%1, %0 */",
10511                                  op[0], op[1], op[2]);
10512                           printf ("  im = 0x%x,", im);
10513                           printf ("  rdst = 0x%x\n", rdst);
10514                         }
10515                       SYNTAX("stz       #%1, %0");
10516 #line 389 "rx-decode.opc"
10517                       ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_z);
10518
10519                     }
10520                   break;
10521                 case 0xf0:
10522                   op_semantics_88:
10523                     {
10524                       /** 1111 1101 0111 im00 1111rdst  stnz    #%1, %0 */
10525 #line 392 "rx-decode.opc"
10526                       int im AU = (op[1] >> 2) & 0x03;
10527 #line 392 "rx-decode.opc"
10528                       int rdst AU = op[2] & 0x0f;
10529                       if (trace)
10530                         {
10531                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10532                                  "/** 1111 1101 0111 im00 1111rdst      stnz    #%1, %0 */",
10533                                  op[0], op[1], op[2]);
10534                           printf ("  im = 0x%x,", im);
10535                           printf ("  rdst = 0x%x\n", rdst);
10536                         }
10537                       SYNTAX("stnz      #%1, %0");
10538 #line 392 "rx-decode.opc"
10539                       ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_nz);
10540
10541                     /*----------------------------------------------------------------------*/
10542                     /* RTSD                                                                     */
10543
10544                     }
10545                   break;
10546                 default: UNSUPPORTED(); break;
10547               }
10548             break;
10549           case 0x72:
10550               GETBYTE ();
10551               switch (op[2] & 0xf0)
10552               {
10553                 case 0x00:
10554                     {
10555                       /** 1111 1101 0111 0010 0000 rdst fsub    #%1, %0 */
10556 #line 861 "rx-decode.opc"
10557                       int rdst AU = op[2] & 0x0f;
10558                       if (trace)
10559                         {
10560                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10561                                  "/** 1111 1101 0111 0010 0000 rdst     fsub    #%1, %0 */",
10562                                  op[0], op[1], op[2]);
10563                           printf ("  rdst = 0x%x\n", rdst);
10564                         }
10565                       SYNTAX("fsub      #%1, %0");
10566 #line 861 "rx-decode.opc"
10567                       ID(fsub); DR(rdst); SC(IMM(0)); F__SZ_;
10568
10569                     }
10570                   break;
10571                 case 0x10:
10572                     {
10573                       /** 1111 1101 0111 0010 0001 rdst fcmp    #%1, %0 */
10574 #line 855 "rx-decode.opc"
10575                       int rdst AU = op[2] & 0x0f;
10576                       if (trace)
10577                         {
10578                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10579                                  "/** 1111 1101 0111 0010 0001 rdst     fcmp    #%1, %0 */",
10580                                  op[0], op[1], op[2]);
10581                           printf ("  rdst = 0x%x\n", rdst);
10582                         }
10583                       SYNTAX("fcmp      #%1, %0");
10584 #line 855 "rx-decode.opc"
10585                       ID(fcmp); DR(rdst); SC(IMM(0)); F_OSZ_;
10586
10587                     }
10588                   break;
10589                 case 0x20:
10590                     {
10591                       /** 1111 1101 0111 0010 0010 rdst fadd    #%1, %0 */
10592 #line 849 "rx-decode.opc"
10593                       int rdst AU = op[2] & 0x0f;
10594                       if (trace)
10595                         {
10596                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10597                                  "/** 1111 1101 0111 0010 0010 rdst     fadd    #%1, %0 */",
10598                                  op[0], op[1], op[2]);
10599                           printf ("  rdst = 0x%x\n", rdst);
10600                         }
10601                       SYNTAX("fadd      #%1, %0");
10602 #line 849 "rx-decode.opc"
10603                       ID(fadd); DR(rdst); SC(IMM(0)); F__SZ_;
10604
10605                     }
10606                   break;
10607                 case 0x30:
10608                     {
10609                       /** 1111 1101 0111 0010 0011 rdst fmul    #%1, %0 */
10610 #line 870 "rx-decode.opc"
10611                       int rdst AU = op[2] & 0x0f;
10612                       if (trace)
10613                         {
10614                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10615                                  "/** 1111 1101 0111 0010 0011 rdst     fmul    #%1, %0 */",
10616                                  op[0], op[1], op[2]);
10617                           printf ("  rdst = 0x%x\n", rdst);
10618                         }
10619                       SYNTAX("fmul      #%1, %0");
10620 #line 870 "rx-decode.opc"
10621                       ID(fmul); DR(rdst); SC(IMM(0)); F__SZ_;
10622
10623                     }
10624                   break;
10625                 case 0x40:
10626                     {
10627                       /** 1111 1101 0111 0010 0100 rdst fdiv    #%1, %0 */
10628 #line 876 "rx-decode.opc"
10629                       int rdst AU = op[2] & 0x0f;
10630                       if (trace)
10631                         {
10632                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10633                                  "/** 1111 1101 0111 0010 0100 rdst     fdiv    #%1, %0 */",
10634                                  op[0], op[1], op[2]);
10635                           printf ("  rdst = 0x%x\n", rdst);
10636                         }
10637                       SYNTAX("fdiv      #%1, %0");
10638 #line 876 "rx-decode.opc"
10639                       ID(fdiv); DR(rdst); SC(IMM(0)); F__SZ_;
10640
10641                     }
10642                   break;
10643                 default: UNSUPPORTED(); break;
10644               }
10645             break;
10646           case 0x73:
10647               GETBYTE ();
10648               switch (op[2] & 0xe0)
10649               {
10650                 case 0x00:
10651                   op_semantics_89:
10652                     {
10653                       /** 1111 1101 0111 im11 000crdst  mvtc    #%1, %0 */
10654 #line 966 "rx-decode.opc"
10655                       int im AU = (op[1] >> 2) & 0x03;
10656 #line 966 "rx-decode.opc"
10657                       int crdst AU = op[2] & 0x1f;
10658                       if (trace)
10659                         {
10660                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10661                                  "/** 1111 1101 0111 im11 000crdst      mvtc    #%1, %0 */",
10662                                  op[0], op[1], op[2]);
10663                           printf ("  im = 0x%x,", im);
10664                           printf ("  crdst = 0x%x\n", crdst);
10665                         }
10666                       SYNTAX("mvtc      #%1, %0");
10667 #line 966 "rx-decode.opc"
10668                       ID(mov); SC(IMMex(im)); DR(crdst + 16);
10669
10670                     }
10671                   break;
10672                 default: UNSUPPORTED(); break;
10673               }
10674             break;
10675           case 0x74:
10676               GETBYTE ();
10677               switch (op[2] & 0xf0)
10678               {
10679                 case 0x20:
10680                   goto op_semantics_78;
10681                   break;
10682                 case 0x40:
10683                   goto op_semantics_79;
10684                   break;
10685                 case 0x50:
10686                   goto op_semantics_80;
10687                   break;
10688                 case 0x60:
10689                   goto op_semantics_81;
10690                   break;
10691                 case 0x70:
10692                   goto op_semantics_82;
10693                   break;
10694                 case 0x80:
10695                   goto op_semantics_83;
10696                   break;
10697                 case 0x90:
10698                   goto op_semantics_84;
10699                   break;
10700                 case 0xc0:
10701                   goto op_semantics_85;
10702                   break;
10703                 case 0xd0:
10704                   goto op_semantics_86;
10705                   break;
10706                 case 0xe0:
10707                   goto op_semantics_87;
10708                   break;
10709                 case 0xf0:
10710                   goto op_semantics_88;
10711                   break;
10712                 default: UNSUPPORTED(); break;
10713               }
10714             break;
10715           case 0x77:
10716               GETBYTE ();
10717               switch (op[2] & 0xe0)
10718               {
10719                 case 0x00:
10720                   goto op_semantics_89;
10721                   break;
10722                 default: UNSUPPORTED(); break;
10723               }
10724             break;
10725           case 0x78:
10726               GETBYTE ();
10727               switch (op[2] & 0xf0)
10728               {
10729                 case 0x20:
10730                   goto op_semantics_78;
10731                   break;
10732                 case 0x40:
10733                   goto op_semantics_79;
10734                   break;
10735                 case 0x50:
10736                   goto op_semantics_80;
10737                   break;
10738                 case 0x60:
10739                   goto op_semantics_81;
10740                   break;
10741                 case 0x70:
10742                   goto op_semantics_82;
10743                   break;
10744                 case 0x80:
10745                   goto op_semantics_83;
10746                   break;
10747                 case 0x90:
10748                   goto op_semantics_84;
10749                   break;
10750                 case 0xc0:
10751                   goto op_semantics_85;
10752                   break;
10753                 case 0xd0:
10754                   goto op_semantics_86;
10755                   break;
10756                 case 0xe0:
10757                   goto op_semantics_87;
10758                   break;
10759                 case 0xf0:
10760                   goto op_semantics_88;
10761                   break;
10762                 default: UNSUPPORTED(); break;
10763               }
10764             break;
10765           case 0x7b:
10766               GETBYTE ();
10767               switch (op[2] & 0xe0)
10768               {
10769                 case 0x00:
10770                   goto op_semantics_89;
10771                   break;
10772                 default: UNSUPPORTED(); break;
10773               }
10774             break;
10775           case 0x7c:
10776               GETBYTE ();
10777               switch (op[2] & 0xf0)
10778               {
10779                 case 0x20:
10780                   goto op_semantics_78;
10781                   break;
10782                 case 0x40:
10783                   goto op_semantics_79;
10784                   break;
10785                 case 0x50:
10786                   goto op_semantics_80;
10787                   break;
10788                 case 0x60:
10789                   goto op_semantics_81;
10790                   break;
10791                 case 0x70:
10792                   goto op_semantics_82;
10793                   break;
10794                 case 0x80:
10795                   goto op_semantics_83;
10796                   break;
10797                 case 0x90:
10798                   goto op_semantics_84;
10799                   break;
10800                 case 0xc0:
10801                   goto op_semantics_85;
10802                   break;
10803                 case 0xd0:
10804                   goto op_semantics_86;
10805                   break;
10806                 case 0xe0:
10807                   goto op_semantics_87;
10808                   break;
10809                 case 0xf0:
10810                   goto op_semantics_88;
10811                   break;
10812                 default: UNSUPPORTED(); break;
10813               }
10814             break;
10815           case 0x7f:
10816               GETBYTE ();
10817               switch (op[2] & 0xe0)
10818               {
10819                 case 0x00:
10820                   goto op_semantics_89;
10821                   break;
10822                 default: UNSUPPORTED(); break;
10823               }
10824             break;
10825           case 0x80:
10826               GETBYTE ();
10827               switch (op[2] & 0x00)
10828               {
10829                 case 0x00:
10830                   op_semantics_90:
10831                     {
10832                       /** 1111 1101 100immmm rsrc rdst  shlr    #%2, %1, %0 */
10833 #line 691 "rx-decode.opc"
10834                       int immmm AU = op[1] & 0x1f;
10835 #line 691 "rx-decode.opc"
10836                       int rsrc AU = (op[2] >> 4) & 0x0f;
10837 #line 691 "rx-decode.opc"
10838                       int rdst AU = op[2] & 0x0f;
10839                       if (trace)
10840                         {
10841                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10842                                  "/** 1111 1101 100immmm rsrc rdst      shlr    #%2, %1, %0 */",
10843                                  op[0], op[1], op[2]);
10844                           printf ("  immmm = 0x%x,", immmm);
10845                           printf ("  rsrc = 0x%x,", rsrc);
10846                           printf ("  rdst = 0x%x\n", rdst);
10847                         }
10848                       SYNTAX("shlr      #%2, %1, %0");
10849 #line 691 "rx-decode.opc"
10850                       ID(shlr); S2C(immmm); SR(rsrc); DR(rdst); F__SZC;
10851
10852                     /*----------------------------------------------------------------------*/
10853                     /* ROTATE                                                           */
10854
10855                     }
10856                   break;
10857               }
10858             break;
10859           case 0x81:
10860               GETBYTE ();
10861               switch (op[2] & 0x00)
10862               {
10863                 case 0x00:
10864                   goto op_semantics_90;
10865                   break;
10866               }
10867             break;
10868           case 0x82:
10869               GETBYTE ();
10870               switch (op[2] & 0x00)
10871               {
10872                 case 0x00:
10873                   goto op_semantics_90;
10874                   break;
10875               }
10876             break;
10877           case 0x83:
10878               GETBYTE ();
10879               switch (op[2] & 0x00)
10880               {
10881                 case 0x00:
10882                   goto op_semantics_90;
10883                   break;
10884               }
10885             break;
10886           case 0x84:
10887               GETBYTE ();
10888               switch (op[2] & 0x00)
10889               {
10890                 case 0x00:
10891                   goto op_semantics_90;
10892                   break;
10893               }
10894             break;
10895           case 0x85:
10896               GETBYTE ();
10897               switch (op[2] & 0x00)
10898               {
10899                 case 0x00:
10900                   goto op_semantics_90;
10901                   break;
10902               }
10903             break;
10904           case 0x86:
10905               GETBYTE ();
10906               switch (op[2] & 0x00)
10907               {
10908                 case 0x00:
10909                   goto op_semantics_90;
10910                   break;
10911               }
10912             break;
10913           case 0x87:
10914               GETBYTE ();
10915               switch (op[2] & 0x00)
10916               {
10917                 case 0x00:
10918                   goto op_semantics_90;
10919                   break;
10920               }
10921             break;
10922           case 0x88:
10923               GETBYTE ();
10924               switch (op[2] & 0x00)
10925               {
10926                 case 0x00:
10927                   goto op_semantics_90;
10928                   break;
10929               }
10930             break;
10931           case 0x89:
10932               GETBYTE ();
10933               switch (op[2] & 0x00)
10934               {
10935                 case 0x00:
10936                   goto op_semantics_90;
10937                   break;
10938               }
10939             break;
10940           case 0x8a:
10941               GETBYTE ();
10942               switch (op[2] & 0x00)
10943               {
10944                 case 0x00:
10945                   goto op_semantics_90;
10946                   break;
10947               }
10948             break;
10949           case 0x8b:
10950               GETBYTE ();
10951               switch (op[2] & 0x00)
10952               {
10953                 case 0x00:
10954                   goto op_semantics_90;
10955                   break;
10956               }
10957             break;
10958           case 0x8c:
10959               GETBYTE ();
10960               switch (op[2] & 0x00)
10961               {
10962                 case 0x00:
10963                   goto op_semantics_90;
10964                   break;
10965               }
10966             break;
10967           case 0x8d:
10968               GETBYTE ();
10969               switch (op[2] & 0x00)
10970               {
10971                 case 0x00:
10972                   goto op_semantics_90;
10973                   break;
10974               }
10975             break;
10976           case 0x8e:
10977               GETBYTE ();
10978               switch (op[2] & 0x00)
10979               {
10980                 case 0x00:
10981                   goto op_semantics_90;
10982                   break;
10983               }
10984             break;
10985           case 0x8f:
10986               GETBYTE ();
10987               switch (op[2] & 0x00)
10988               {
10989                 case 0x00:
10990                   goto op_semantics_90;
10991                   break;
10992               }
10993             break;
10994           case 0x90:
10995               GETBYTE ();
10996               switch (op[2] & 0x00)
10997               {
10998                 case 0x00:
10999                   goto op_semantics_90;
11000                   break;
11001               }
11002             break;
11003           case 0x91:
11004               GETBYTE ();
11005               switch (op[2] & 0x00)
11006               {
11007                 case 0x00:
11008                   goto op_semantics_90;
11009                   break;
11010               }
11011             break;
11012           case 0x92:
11013               GETBYTE ();
11014               switch (op[2] & 0x00)
11015               {
11016                 case 0x00:
11017                   goto op_semantics_90;
11018                   break;
11019               }
11020             break;
11021           case 0x93:
11022               GETBYTE ();
11023               switch (op[2] & 0x00)
11024               {
11025                 case 0x00:
11026                   goto op_semantics_90;
11027                   break;
11028               }
11029             break;
11030           case 0x94:
11031               GETBYTE ();
11032               switch (op[2] & 0x00)
11033               {
11034                 case 0x00:
11035                   goto op_semantics_90;
11036                   break;
11037               }
11038             break;
11039           case 0x95:
11040               GETBYTE ();
11041               switch (op[2] & 0x00)
11042               {
11043                 case 0x00:
11044                   goto op_semantics_90;
11045                   break;
11046               }
11047             break;
11048           case 0x96:
11049               GETBYTE ();
11050               switch (op[2] & 0x00)
11051               {
11052                 case 0x00:
11053                   goto op_semantics_90;
11054                   break;
11055               }
11056             break;
11057           case 0x97:
11058               GETBYTE ();
11059               switch (op[2] & 0x00)
11060               {
11061                 case 0x00:
11062                   goto op_semantics_90;
11063                   break;
11064               }
11065             break;
11066           case 0x98:
11067               GETBYTE ();
11068               switch (op[2] & 0x00)
11069               {
11070                 case 0x00:
11071                   goto op_semantics_90;
11072                   break;
11073               }
11074             break;
11075           case 0x99:
11076               GETBYTE ();
11077               switch (op[2] & 0x00)
11078               {
11079                 case 0x00:
11080                   goto op_semantics_90;
11081                   break;
11082               }
11083             break;
11084           case 0x9a:
11085               GETBYTE ();
11086               switch (op[2] & 0x00)
11087               {
11088                 case 0x00:
11089                   goto op_semantics_90;
11090                   break;
11091               }
11092             break;
11093           case 0x9b:
11094               GETBYTE ();
11095               switch (op[2] & 0x00)
11096               {
11097                 case 0x00:
11098                   goto op_semantics_90;
11099                   break;
11100               }
11101             break;
11102           case 0x9c:
11103               GETBYTE ();
11104               switch (op[2] & 0x00)
11105               {
11106                 case 0x00:
11107                   goto op_semantics_90;
11108                   break;
11109               }
11110             break;
11111           case 0x9d:
11112               GETBYTE ();
11113               switch (op[2] & 0x00)
11114               {
11115                 case 0x00:
11116                   goto op_semantics_90;
11117                   break;
11118               }
11119             break;
11120           case 0x9e:
11121               GETBYTE ();
11122               switch (op[2] & 0x00)
11123               {
11124                 case 0x00:
11125                   goto op_semantics_90;
11126                   break;
11127               }
11128             break;
11129           case 0x9f:
11130               GETBYTE ();
11131               switch (op[2] & 0x00)
11132               {
11133                 case 0x00:
11134                   goto op_semantics_90;
11135                   break;
11136               }
11137             break;
11138           case 0xa0:
11139               GETBYTE ();
11140               switch (op[2] & 0x00)
11141               {
11142                 case 0x00:
11143                   op_semantics_91:
11144                     {
11145                       /** 1111 1101 101immmm rsrc rdst  shar    #%2, %1, %0 */
11146 #line 681 "rx-decode.opc"
11147                       int immmm AU = op[1] & 0x1f;
11148 #line 681 "rx-decode.opc"
11149                       int rsrc AU = (op[2] >> 4) & 0x0f;
11150 #line 681 "rx-decode.opc"
11151                       int rdst AU = op[2] & 0x0f;
11152                       if (trace)
11153                         {
11154                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11155                                  "/** 1111 1101 101immmm rsrc rdst      shar    #%2, %1, %0 */",
11156                                  op[0], op[1], op[2]);
11157                           printf ("  immmm = 0x%x,", immmm);
11158                           printf ("  rsrc = 0x%x,", rsrc);
11159                           printf ("  rdst = 0x%x\n", rdst);
11160                         }
11161                       SYNTAX("shar      #%2, %1, %0");
11162 #line 681 "rx-decode.opc"
11163                       ID(shar); S2C(immmm); SR(rsrc); DR(rdst); F_0SZC;
11164
11165
11166                     }
11167                   break;
11168               }
11169             break;
11170           case 0xa1:
11171               GETBYTE ();
11172               switch (op[2] & 0x00)
11173               {
11174                 case 0x00:
11175                   goto op_semantics_91;
11176                   break;
11177               }
11178             break;
11179           case 0xa2:
11180               GETBYTE ();
11181               switch (op[2] & 0x00)
11182               {
11183                 case 0x00:
11184                   goto op_semantics_91;
11185                   break;
11186               }
11187             break;
11188           case 0xa3:
11189               GETBYTE ();
11190               switch (op[2] & 0x00)
11191               {
11192                 case 0x00:
11193                   goto op_semantics_91;
11194                   break;
11195               }
11196             break;
11197           case 0xa4:
11198               GETBYTE ();
11199               switch (op[2] & 0x00)
11200               {
11201                 case 0x00:
11202                   goto op_semantics_91;
11203                   break;
11204               }
11205             break;
11206           case 0xa5:
11207               GETBYTE ();
11208               switch (op[2] & 0x00)
11209               {
11210                 case 0x00:
11211                   goto op_semantics_91;
11212                   break;
11213               }
11214             break;
11215           case 0xa6:
11216               GETBYTE ();
11217               switch (op[2] & 0x00)
11218               {
11219                 case 0x00:
11220                   goto op_semantics_91;
11221                   break;
11222               }
11223             break;
11224           case 0xa7:
11225               GETBYTE ();
11226               switch (op[2] & 0x00)
11227               {
11228                 case 0x00:
11229                   goto op_semantics_91;
11230                   break;
11231               }
11232             break;
11233           case 0xa8:
11234               GETBYTE ();
11235               switch (op[2] & 0x00)
11236               {
11237                 case 0x00:
11238                   goto op_semantics_91;
11239                   break;
11240               }
11241             break;
11242           case 0xa9:
11243               GETBYTE ();
11244               switch (op[2] & 0x00)
11245               {
11246                 case 0x00:
11247                   goto op_semantics_91;
11248                   break;
11249               }
11250             break;
11251           case 0xaa:
11252               GETBYTE ();
11253               switch (op[2] & 0x00)
11254               {
11255                 case 0x00:
11256                   goto op_semantics_91;
11257                   break;
11258               }
11259             break;
11260           case 0xab:
11261               GETBYTE ();
11262               switch (op[2] & 0x00)
11263               {
11264                 case 0x00:
11265                   goto op_semantics_91;
11266                   break;
11267               }
11268             break;
11269           case 0xac:
11270               GETBYTE ();
11271               switch (op[2] & 0x00)
11272               {
11273                 case 0x00:
11274                   goto op_semantics_91;
11275                   break;
11276               }
11277             break;
11278           case 0xad:
11279               GETBYTE ();
11280               switch (op[2] & 0x00)
11281               {
11282                 case 0x00:
11283                   goto op_semantics_91;
11284                   break;
11285               }
11286             break;
11287           case 0xae:
11288               GETBYTE ();
11289               switch (op[2] & 0x00)
11290               {
11291                 case 0x00:
11292                   goto op_semantics_91;
11293                   break;
11294               }
11295             break;
11296           case 0xaf:
11297               GETBYTE ();
11298               switch (op[2] & 0x00)
11299               {
11300                 case 0x00:
11301                   goto op_semantics_91;
11302                   break;
11303               }
11304             break;
11305           case 0xb0:
11306               GETBYTE ();
11307               switch (op[2] & 0x00)
11308               {
11309                 case 0x00:
11310                   goto op_semantics_91;
11311                   break;
11312               }
11313             break;
11314           case 0xb1:
11315               GETBYTE ();
11316               switch (op[2] & 0x00)
11317               {
11318                 case 0x00:
11319                   goto op_semantics_91;
11320                   break;
11321               }
11322             break;
11323           case 0xb2:
11324               GETBYTE ();
11325               switch (op[2] & 0x00)
11326               {
11327                 case 0x00:
11328                   goto op_semantics_91;
11329                   break;
11330               }
11331             break;
11332           case 0xb3:
11333               GETBYTE ();
11334               switch (op[2] & 0x00)
11335               {
11336                 case 0x00:
11337                   goto op_semantics_91;
11338                   break;
11339               }
11340             break;
11341           case 0xb4:
11342               GETBYTE ();
11343               switch (op[2] & 0x00)
11344               {
11345                 case 0x00:
11346                   goto op_semantics_91;
11347                   break;
11348               }
11349             break;
11350           case 0xb5:
11351               GETBYTE ();
11352               switch (op[2] & 0x00)
11353               {
11354                 case 0x00:
11355                   goto op_semantics_91;
11356                   break;
11357               }
11358             break;
11359           case 0xb6:
11360               GETBYTE ();
11361               switch (op[2] & 0x00)
11362               {
11363                 case 0x00:
11364                   goto op_semantics_91;
11365                   break;
11366               }
11367             break;
11368           case 0xb7:
11369               GETBYTE ();
11370               switch (op[2] & 0x00)
11371               {
11372                 case 0x00:
11373                   goto op_semantics_91;
11374                   break;
11375               }
11376             break;
11377           case 0xb8:
11378               GETBYTE ();
11379               switch (op[2] & 0x00)
11380               {
11381                 case 0x00:
11382                   goto op_semantics_91;
11383                   break;
11384               }
11385             break;
11386           case 0xb9:
11387               GETBYTE ();
11388               switch (op[2] & 0x00)
11389               {
11390                 case 0x00:
11391                   goto op_semantics_91;
11392                   break;
11393               }
11394             break;
11395           case 0xba:
11396               GETBYTE ();
11397               switch (op[2] & 0x00)
11398               {
11399                 case 0x00:
11400                   goto op_semantics_91;
11401                   break;
11402               }
11403             break;
11404           case 0xbb:
11405               GETBYTE ();
11406               switch (op[2] & 0x00)
11407               {
11408                 case 0x00:
11409                   goto op_semantics_91;
11410                   break;
11411               }
11412             break;
11413           case 0xbc:
11414               GETBYTE ();
11415               switch (op[2] & 0x00)
11416               {
11417                 case 0x00:
11418                   goto op_semantics_91;
11419                   break;
11420               }
11421             break;
11422           case 0xbd:
11423               GETBYTE ();
11424               switch (op[2] & 0x00)
11425               {
11426                 case 0x00:
11427                   goto op_semantics_91;
11428                   break;
11429               }
11430             break;
11431           case 0xbe:
11432               GETBYTE ();
11433               switch (op[2] & 0x00)
11434               {
11435                 case 0x00:
11436                   goto op_semantics_91;
11437                   break;
11438               }
11439             break;
11440           case 0xbf:
11441               GETBYTE ();
11442               switch (op[2] & 0x00)
11443               {
11444                 case 0x00:
11445                   goto op_semantics_91;
11446                   break;
11447               }
11448             break;
11449           case 0xc0:
11450               GETBYTE ();
11451               switch (op[2] & 0x00)
11452               {
11453                 case 0x00:
11454                   op_semantics_92:
11455                     {
11456                       /** 1111 1101 110immmm rsrc rdst  shll    #%2, %1, %0 */
11457 #line 671 "rx-decode.opc"
11458                       int immmm AU = op[1] & 0x1f;
11459 #line 671 "rx-decode.opc"
11460                       int rsrc AU = (op[2] >> 4) & 0x0f;
11461 #line 671 "rx-decode.opc"
11462                       int rdst AU = op[2] & 0x0f;
11463                       if (trace)
11464                         {
11465                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11466                                  "/** 1111 1101 110immmm rsrc rdst      shll    #%2, %1, %0 */",
11467                                  op[0], op[1], op[2]);
11468                           printf ("  immmm = 0x%x,", immmm);
11469                           printf ("  rsrc = 0x%x,", rsrc);
11470                           printf ("  rdst = 0x%x\n", rdst);
11471                         }
11472                       SYNTAX("shll      #%2, %1, %0");
11473 #line 671 "rx-decode.opc"
11474                       ID(shll); S2C(immmm); SR(rsrc); DR(rdst); F_OSZC;
11475
11476
11477                     }
11478                   break;
11479               }
11480             break;
11481           case 0xc1:
11482               GETBYTE ();
11483               switch (op[2] & 0x00)
11484               {
11485                 case 0x00:
11486                   goto op_semantics_92;
11487                   break;
11488               }
11489             break;
11490           case 0xc2:
11491               GETBYTE ();
11492               switch (op[2] & 0x00)
11493               {
11494                 case 0x00:
11495                   goto op_semantics_92;
11496                   break;
11497               }
11498             break;
11499           case 0xc3:
11500               GETBYTE ();
11501               switch (op[2] & 0x00)
11502               {
11503                 case 0x00:
11504                   goto op_semantics_92;
11505                   break;
11506               }
11507             break;
11508           case 0xc4:
11509               GETBYTE ();
11510               switch (op[2] & 0x00)
11511               {
11512                 case 0x00:
11513                   goto op_semantics_92;
11514                   break;
11515               }
11516             break;
11517           case 0xc5:
11518               GETBYTE ();
11519               switch (op[2] & 0x00)
11520               {
11521                 case 0x00:
11522                   goto op_semantics_92;
11523                   break;
11524               }
11525             break;
11526           case 0xc6:
11527               GETBYTE ();
11528               switch (op[2] & 0x00)
11529               {
11530                 case 0x00:
11531                   goto op_semantics_92;
11532                   break;
11533               }
11534             break;
11535           case 0xc7:
11536               GETBYTE ();
11537               switch (op[2] & 0x00)
11538               {
11539                 case 0x00:
11540                   goto op_semantics_92;
11541                   break;
11542               }
11543             break;
11544           case 0xc8:
11545               GETBYTE ();
11546               switch (op[2] & 0x00)
11547               {
11548                 case 0x00:
11549                   goto op_semantics_92;
11550                   break;
11551               }
11552             break;
11553           case 0xc9:
11554               GETBYTE ();
11555               switch (op[2] & 0x00)
11556               {
11557                 case 0x00:
11558                   goto op_semantics_92;
11559                   break;
11560               }
11561             break;
11562           case 0xca:
11563               GETBYTE ();
11564               switch (op[2] & 0x00)
11565               {
11566                 case 0x00:
11567                   goto op_semantics_92;
11568                   break;
11569               }
11570             break;
11571           case 0xcb:
11572               GETBYTE ();
11573               switch (op[2] & 0x00)
11574               {
11575                 case 0x00:
11576                   goto op_semantics_92;
11577                   break;
11578               }
11579             break;
11580           case 0xcc:
11581               GETBYTE ();
11582               switch (op[2] & 0x00)
11583               {
11584                 case 0x00:
11585                   goto op_semantics_92;
11586                   break;
11587               }
11588             break;
11589           case 0xcd:
11590               GETBYTE ();
11591               switch (op[2] & 0x00)
11592               {
11593                 case 0x00:
11594                   goto op_semantics_92;
11595                   break;
11596               }
11597             break;
11598           case 0xce:
11599               GETBYTE ();
11600               switch (op[2] & 0x00)
11601               {
11602                 case 0x00:
11603                   goto op_semantics_92;
11604                   break;
11605               }
11606             break;
11607           case 0xcf:
11608               GETBYTE ();
11609               switch (op[2] & 0x00)
11610               {
11611                 case 0x00:
11612                   goto op_semantics_92;
11613                   break;
11614               }
11615             break;
11616           case 0xd0:
11617               GETBYTE ();
11618               switch (op[2] & 0x00)
11619               {
11620                 case 0x00:
11621                   goto op_semantics_92;
11622                   break;
11623               }
11624             break;
11625           case 0xd1:
11626               GETBYTE ();
11627               switch (op[2] & 0x00)
11628               {
11629                 case 0x00:
11630                   goto op_semantics_92;
11631                   break;
11632               }
11633             break;
11634           case 0xd2:
11635               GETBYTE ();
11636               switch (op[2] & 0x00)
11637               {
11638                 case 0x00:
11639                   goto op_semantics_92;
11640                   break;
11641               }
11642             break;
11643           case 0xd3:
11644               GETBYTE ();
11645               switch (op[2] & 0x00)
11646               {
11647                 case 0x00:
11648                   goto op_semantics_92;
11649                   break;
11650               }
11651             break;
11652           case 0xd4:
11653               GETBYTE ();
11654               switch (op[2] & 0x00)
11655               {
11656                 case 0x00:
11657                   goto op_semantics_92;
11658                   break;
11659               }
11660             break;
11661           case 0xd5:
11662               GETBYTE ();
11663               switch (op[2] & 0x00)
11664               {
11665                 case 0x00:
11666                   goto op_semantics_92;
11667                   break;
11668               }
11669             break;
11670           case 0xd6:
11671               GETBYTE ();
11672               switch (op[2] & 0x00)
11673               {
11674                 case 0x00:
11675                   goto op_semantics_92;
11676                   break;
11677               }
11678             break;
11679           case 0xd7:
11680               GETBYTE ();
11681               switch (op[2] & 0x00)
11682               {
11683                 case 0x00:
11684                   goto op_semantics_92;
11685                   break;
11686               }
11687             break;
11688           case 0xd8:
11689               GETBYTE ();
11690               switch (op[2] & 0x00)
11691               {
11692                 case 0x00:
11693                   goto op_semantics_92;
11694                   break;
11695               }
11696             break;
11697           case 0xd9:
11698               GETBYTE ();
11699               switch (op[2] & 0x00)
11700               {
11701                 case 0x00:
11702                   goto op_semantics_92;
11703                   break;
11704               }
11705             break;
11706           case 0xda:
11707               GETBYTE ();
11708               switch (op[2] & 0x00)
11709               {
11710                 case 0x00:
11711                   goto op_semantics_92;
11712                   break;
11713               }
11714             break;
11715           case 0xdb:
11716               GETBYTE ();
11717               switch (op[2] & 0x00)
11718               {
11719                 case 0x00:
11720                   goto op_semantics_92;
11721                   break;
11722               }
11723             break;
11724           case 0xdc:
11725               GETBYTE ();
11726               switch (op[2] & 0x00)
11727               {
11728                 case 0x00:
11729                   goto op_semantics_92;
11730                   break;
11731               }
11732             break;
11733           case 0xdd:
11734               GETBYTE ();
11735               switch (op[2] & 0x00)
11736               {
11737                 case 0x00:
11738                   goto op_semantics_92;
11739                   break;
11740               }
11741             break;
11742           case 0xde:
11743               GETBYTE ();
11744               switch (op[2] & 0x00)
11745               {
11746                 case 0x00:
11747                   goto op_semantics_92;
11748                   break;
11749               }
11750             break;
11751           case 0xdf:
11752               GETBYTE ();
11753               switch (op[2] & 0x00)
11754               {
11755                 case 0x00:
11756                   goto op_semantics_92;
11757                   break;
11758               }
11759             break;
11760           case 0xe0:
11761               GETBYTE ();
11762               switch (op[2] & 0xf0)
11763               {
11764                 case 0x00:
11765                 case 0x10:
11766                 case 0x20:
11767                 case 0x30:
11768                 case 0x40:
11769                 case 0x50:
11770                 case 0x60:
11771                 case 0x70:
11772                 case 0x80:
11773                 case 0x90:
11774                 case 0xa0:
11775                 case 0xb0:
11776                 case 0xc0:
11777                 case 0xd0:
11778                 case 0xe0:
11779                   op_semantics_93:
11780                     {
11781                       /** 1111 1101 111 bittt cond rdst bm%2    #%1, %0%S0 */
11782 #line 945 "rx-decode.opc"
11783                       int bittt AU = op[1] & 0x1f;
11784 #line 945 "rx-decode.opc"
11785                       int cond AU = (op[2] >> 4) & 0x0f;
11786 #line 945 "rx-decode.opc"
11787                       int rdst AU = op[2] & 0x0f;
11788                       if (trace)
11789                         {
11790                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11791                                  "/** 1111 1101 111 bittt cond rdst     bm%2    #%1, %0%S0 */",
11792                                  op[0], op[1], op[2]);
11793                           printf ("  bittt = 0x%x,", bittt);
11794                           printf ("  cond = 0x%x,", cond);
11795                           printf ("  rdst = 0x%x\n", rdst);
11796                         }
11797                       SYNTAX("bm%2      #%1, %0%S0");
11798 #line 945 "rx-decode.opc"
11799                       ID(bmcc); BWL(LSIZE); S2cc(cond); SC(bittt); DR(rdst);
11800
11801                     /*----------------------------------------------------------------------*/
11802                     /* CONTROL REGISTERS                                                        */
11803
11804                     }
11805                   break;
11806                 case 0xf0:
11807                   op_semantics_94:
11808                     {
11809                       /** 1111 1101 111bittt 1111 rdst  bnot    #%1, %0 */
11810 #line 938 "rx-decode.opc"
11811                       int bittt AU = op[1] & 0x1f;
11812 #line 938 "rx-decode.opc"
11813                       int rdst AU = op[2] & 0x0f;
11814                       if (trace)
11815                         {
11816                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11817                                  "/** 1111 1101 111bittt 1111 rdst      bnot    #%1, %0 */",
11818                                  op[0], op[1], op[2]);
11819                           printf ("  bittt = 0x%x,", bittt);
11820                           printf ("  rdst = 0x%x\n", rdst);
11821                         }
11822                       SYNTAX("bnot      #%1, %0");
11823 #line 938 "rx-decode.opc"
11824                       ID(bnot); BWL(LSIZE); SC(bittt); DR(rdst);
11825
11826
11827                     }
11828                   break;
11829               }
11830             break;
11831           case 0xe1:
11832               GETBYTE ();
11833               switch (op[2] & 0xf0)
11834               {
11835                 case 0x00:
11836                 case 0x10:
11837                 case 0x20:
11838                 case 0x30:
11839                 case 0x40:
11840                 case 0x50:
11841                 case 0x60:
11842                 case 0x70:
11843                 case 0x80:
11844                 case 0x90:
11845                 case 0xa0:
11846                 case 0xb0:
11847                 case 0xc0:
11848                 case 0xd0:
11849                 case 0xe0:
11850                   goto op_semantics_93;
11851                   break;
11852                 case 0xf0:
11853                   goto op_semantics_94;
11854                   break;
11855               }
11856             break;
11857           case 0xe2:
11858               GETBYTE ();
11859               switch (op[2] & 0xf0)
11860               {
11861                 case 0x00:
11862                 case 0x10:
11863                 case 0x20:
11864                 case 0x30:
11865                 case 0x40:
11866                 case 0x50:
11867                 case 0x60:
11868                 case 0x70:
11869                 case 0x80:
11870                 case 0x90:
11871                 case 0xa0:
11872                 case 0xb0:
11873                 case 0xc0:
11874                 case 0xd0:
11875                 case 0xe0:
11876                   goto op_semantics_93;
11877                   break;
11878                 case 0xf0:
11879                   goto op_semantics_94;
11880                   break;
11881               }
11882             break;
11883           case 0xe3:
11884               GETBYTE ();
11885               switch (op[2] & 0xf0)
11886               {
11887                 case 0x00:
11888                 case 0x10:
11889                 case 0x20:
11890                 case 0x30:
11891                 case 0x40:
11892                 case 0x50:
11893                 case 0x60:
11894                 case 0x70:
11895                 case 0x80:
11896                 case 0x90:
11897                 case 0xa0:
11898                 case 0xb0:
11899                 case 0xc0:
11900                 case 0xd0:
11901                 case 0xe0:
11902                   goto op_semantics_93;
11903                   break;
11904                 case 0xf0:
11905                   goto op_semantics_94;
11906                   break;
11907               }
11908             break;
11909           case 0xe4:
11910               GETBYTE ();
11911               switch (op[2] & 0xf0)
11912               {
11913                 case 0x00:
11914                 case 0x10:
11915                 case 0x20:
11916                 case 0x30:
11917                 case 0x40:
11918                 case 0x50:
11919                 case 0x60:
11920                 case 0x70:
11921                 case 0x80:
11922                 case 0x90:
11923                 case 0xa0:
11924                 case 0xb0:
11925                 case 0xc0:
11926                 case 0xd0:
11927                 case 0xe0:
11928                   goto op_semantics_93;
11929                   break;
11930                 case 0xf0:
11931                   goto op_semantics_94;
11932                   break;
11933               }
11934             break;
11935           case 0xe5:
11936               GETBYTE ();
11937               switch (op[2] & 0xf0)
11938               {
11939                 case 0x00:
11940                 case 0x10:
11941                 case 0x20:
11942                 case 0x30:
11943                 case 0x40:
11944                 case 0x50:
11945                 case 0x60:
11946                 case 0x70:
11947                 case 0x80:
11948                 case 0x90:
11949                 case 0xa0:
11950                 case 0xb0:
11951                 case 0xc0:
11952                 case 0xd0:
11953                 case 0xe0:
11954                   goto op_semantics_93;
11955                   break;
11956                 case 0xf0:
11957                   goto op_semantics_94;
11958                   break;
11959               }
11960             break;
11961           case 0xe6:
11962               GETBYTE ();
11963               switch (op[2] & 0xf0)
11964               {
11965                 case 0x00:
11966                 case 0x10:
11967                 case 0x20:
11968                 case 0x30:
11969                 case 0x40:
11970                 case 0x50:
11971                 case 0x60:
11972                 case 0x70:
11973                 case 0x80:
11974                 case 0x90:
11975                 case 0xa0:
11976                 case 0xb0:
11977                 case 0xc0:
11978                 case 0xd0:
11979                 case 0xe0:
11980                   goto op_semantics_93;
11981                   break;
11982                 case 0xf0:
11983                   goto op_semantics_94;
11984                   break;
11985               }
11986             break;
11987           case 0xe7:
11988               GETBYTE ();
11989               switch (op[2] & 0xf0)
11990               {
11991                 case 0x00:
11992                 case 0x10:
11993                 case 0x20:
11994                 case 0x30:
11995                 case 0x40:
11996                 case 0x50:
11997                 case 0x60:
11998                 case 0x70:
11999                 case 0x80:
12000                 case 0x90:
12001                 case 0xa0:
12002                 case 0xb0:
12003                 case 0xc0:
12004                 case 0xd0:
12005                 case 0xe0:
12006                   goto op_semantics_93;
12007                   break;
12008                 case 0xf0:
12009                   goto op_semantics_94;
12010                   break;
12011               }
12012             break;
12013           case 0xe8:
12014               GETBYTE ();
12015               switch (op[2] & 0xf0)
12016               {
12017                 case 0x00:
12018                 case 0x10:
12019                 case 0x20:
12020                 case 0x30:
12021                 case 0x40:
12022                 case 0x50:
12023                 case 0x60:
12024                 case 0x70:
12025                 case 0x80:
12026                 case 0x90:
12027                 case 0xa0:
12028                 case 0xb0:
12029                 case 0xc0:
12030                 case 0xd0:
12031                 case 0xe0:
12032                   goto op_semantics_93;
12033                   break;
12034                 case 0xf0:
12035                   goto op_semantics_94;
12036                   break;
12037               }
12038             break;
12039           case 0xe9:
12040               GETBYTE ();
12041               switch (op[2] & 0xf0)
12042               {
12043                 case 0x00:
12044                 case 0x10:
12045                 case 0x20:
12046                 case 0x30:
12047                 case 0x40:
12048                 case 0x50:
12049                 case 0x60:
12050                 case 0x70:
12051                 case 0x80:
12052                 case 0x90:
12053                 case 0xa0:
12054                 case 0xb0:
12055                 case 0xc0:
12056                 case 0xd0:
12057                 case 0xe0:
12058                   goto op_semantics_93;
12059                   break;
12060                 case 0xf0:
12061                   goto op_semantics_94;
12062                   break;
12063               }
12064             break;
12065           case 0xea:
12066               GETBYTE ();
12067               switch (op[2] & 0xf0)
12068               {
12069                 case 0x00:
12070                 case 0x10:
12071                 case 0x20:
12072                 case 0x30:
12073                 case 0x40:
12074                 case 0x50:
12075                 case 0x60:
12076                 case 0x70:
12077                 case 0x80:
12078                 case 0x90:
12079                 case 0xa0:
12080                 case 0xb0:
12081                 case 0xc0:
12082                 case 0xd0:
12083                 case 0xe0:
12084                   goto op_semantics_93;
12085                   break;
12086                 case 0xf0:
12087                   goto op_semantics_94;
12088                   break;
12089               }
12090             break;
12091           case 0xeb:
12092               GETBYTE ();
12093               switch (op[2] & 0xf0)
12094               {
12095                 case 0x00:
12096                 case 0x10:
12097                 case 0x20:
12098                 case 0x30:
12099                 case 0x40:
12100                 case 0x50:
12101                 case 0x60:
12102                 case 0x70:
12103                 case 0x80:
12104                 case 0x90:
12105                 case 0xa0:
12106                 case 0xb0:
12107                 case 0xc0:
12108                 case 0xd0:
12109                 case 0xe0:
12110                   goto op_semantics_93;
12111                   break;
12112                 case 0xf0:
12113                   goto op_semantics_94;
12114                   break;
12115               }
12116             break;
12117           case 0xec:
12118               GETBYTE ();
12119               switch (op[2] & 0xf0)
12120               {
12121                 case 0x00:
12122                 case 0x10:
12123                 case 0x20:
12124                 case 0x30:
12125                 case 0x40:
12126                 case 0x50:
12127                 case 0x60:
12128                 case 0x70:
12129                 case 0x80:
12130                 case 0x90:
12131                 case 0xa0:
12132                 case 0xb0:
12133                 case 0xc0:
12134                 case 0xd0:
12135                 case 0xe0:
12136                   goto op_semantics_93;
12137                   break;
12138                 case 0xf0:
12139                   goto op_semantics_94;
12140                   break;
12141               }
12142             break;
12143           case 0xed:
12144               GETBYTE ();
12145               switch (op[2] & 0xf0)
12146               {
12147                 case 0x00:
12148                 case 0x10:
12149                 case 0x20:
12150                 case 0x30:
12151                 case 0x40:
12152                 case 0x50:
12153                 case 0x60:
12154                 case 0x70:
12155                 case 0x80:
12156                 case 0x90:
12157                 case 0xa0:
12158                 case 0xb0:
12159                 case 0xc0:
12160                 case 0xd0:
12161                 case 0xe0:
12162                   goto op_semantics_93;
12163                   break;
12164                 case 0xf0:
12165                   goto op_semantics_94;
12166                   break;
12167               }
12168             break;
12169           case 0xee:
12170               GETBYTE ();
12171               switch (op[2] & 0xf0)
12172               {
12173                 case 0x00:
12174                 case 0x10:
12175                 case 0x20:
12176                 case 0x30:
12177                 case 0x40:
12178                 case 0x50:
12179                 case 0x60:
12180                 case 0x70:
12181                 case 0x80:
12182                 case 0x90:
12183                 case 0xa0:
12184                 case 0xb0:
12185                 case 0xc0:
12186                 case 0xd0:
12187                 case 0xe0:
12188                   goto op_semantics_93;
12189                   break;
12190                 case 0xf0:
12191                   goto op_semantics_94;
12192                   break;
12193               }
12194             break;
12195           case 0xef:
12196               GETBYTE ();
12197               switch (op[2] & 0xf0)
12198               {
12199                 case 0x00:
12200                 case 0x10:
12201                 case 0x20:
12202                 case 0x30:
12203                 case 0x40:
12204                 case 0x50:
12205                 case 0x60:
12206                 case 0x70:
12207                 case 0x80:
12208                 case 0x90:
12209                 case 0xa0:
12210                 case 0xb0:
12211                 case 0xc0:
12212                 case 0xd0:
12213                 case 0xe0:
12214                   goto op_semantics_93;
12215                   break;
12216                 case 0xf0:
12217                   goto op_semantics_94;
12218                   break;
12219               }
12220             break;
12221           case 0xf0:
12222               GETBYTE ();
12223               switch (op[2] & 0xf0)
12224               {
12225                 case 0x00:
12226                 case 0x10:
12227                 case 0x20:
12228                 case 0x30:
12229                 case 0x40:
12230                 case 0x50:
12231                 case 0x60:
12232                 case 0x70:
12233                 case 0x80:
12234                 case 0x90:
12235                 case 0xa0:
12236                 case 0xb0:
12237                 case 0xc0:
12238                 case 0xd0:
12239                 case 0xe0:
12240                   goto op_semantics_93;
12241                   break;
12242                 case 0xf0:
12243                   goto op_semantics_94;
12244                   break;
12245               }
12246             break;
12247           case 0xf1:
12248               GETBYTE ();
12249               switch (op[2] & 0xf0)
12250               {
12251                 case 0x00:
12252                 case 0x10:
12253                 case 0x20:
12254                 case 0x30:
12255                 case 0x40:
12256                 case 0x50:
12257                 case 0x60:
12258                 case 0x70:
12259                 case 0x80:
12260                 case 0x90:
12261                 case 0xa0:
12262                 case 0xb0:
12263                 case 0xc0:
12264                 case 0xd0:
12265                 case 0xe0:
12266                   goto op_semantics_93;
12267                   break;
12268                 case 0xf0:
12269                   goto op_semantics_94;
12270                   break;
12271               }
12272             break;
12273           case 0xf2:
12274               GETBYTE ();
12275               switch (op[2] & 0xf0)
12276               {
12277                 case 0x00:
12278                 case 0x10:
12279                 case 0x20:
12280                 case 0x30:
12281                 case 0x40:
12282                 case 0x50:
12283                 case 0x60:
12284                 case 0x70:
12285                 case 0x80:
12286                 case 0x90:
12287                 case 0xa0:
12288                 case 0xb0:
12289                 case 0xc0:
12290                 case 0xd0:
12291                 case 0xe0:
12292                   goto op_semantics_93;
12293                   break;
12294                 case 0xf0:
12295                   goto op_semantics_94;
12296                   break;
12297               }
12298             break;
12299           case 0xf3:
12300               GETBYTE ();
12301               switch (op[2] & 0xf0)
12302               {
12303                 case 0x00:
12304                 case 0x10:
12305                 case 0x20:
12306                 case 0x30:
12307                 case 0x40:
12308                 case 0x50:
12309                 case 0x60:
12310                 case 0x70:
12311                 case 0x80:
12312                 case 0x90:
12313                 case 0xa0:
12314                 case 0xb0:
12315                 case 0xc0:
12316                 case 0xd0:
12317                 case 0xe0:
12318                   goto op_semantics_93;
12319                   break;
12320                 case 0xf0:
12321                   goto op_semantics_94;
12322                   break;
12323               }
12324             break;
12325           case 0xf4:
12326               GETBYTE ();
12327               switch (op[2] & 0xf0)
12328               {
12329                 case 0x00:
12330                 case 0x10:
12331                 case 0x20:
12332                 case 0x30:
12333                 case 0x40:
12334                 case 0x50:
12335                 case 0x60:
12336                 case 0x70:
12337                 case 0x80:
12338                 case 0x90:
12339                 case 0xa0:
12340                 case 0xb0:
12341                 case 0xc0:
12342                 case 0xd0:
12343                 case 0xe0:
12344                   goto op_semantics_93;
12345                   break;
12346                 case 0xf0:
12347                   goto op_semantics_94;
12348                   break;
12349               }
12350             break;
12351           case 0xf5:
12352               GETBYTE ();
12353               switch (op[2] & 0xf0)
12354               {
12355                 case 0x00:
12356                 case 0x10:
12357                 case 0x20:
12358                 case 0x30:
12359                 case 0x40:
12360                 case 0x50:
12361                 case 0x60:
12362                 case 0x70:
12363                 case 0x80:
12364                 case 0x90:
12365                 case 0xa0:
12366                 case 0xb0:
12367                 case 0xc0:
12368                 case 0xd0:
12369                 case 0xe0:
12370                   goto op_semantics_93;
12371                   break;
12372                 case 0xf0:
12373                   goto op_semantics_94;
12374                   break;
12375               }
12376             break;
12377           case 0xf6:
12378               GETBYTE ();
12379               switch (op[2] & 0xf0)
12380               {
12381                 case 0x00:
12382                 case 0x10:
12383                 case 0x20:
12384                 case 0x30:
12385                 case 0x40:
12386                 case 0x50:
12387                 case 0x60:
12388                 case 0x70:
12389                 case 0x80:
12390                 case 0x90:
12391                 case 0xa0:
12392                 case 0xb0:
12393                 case 0xc0:
12394                 case 0xd0:
12395                 case 0xe0:
12396                   goto op_semantics_93;
12397                   break;
12398                 case 0xf0:
12399                   goto op_semantics_94;
12400                   break;
12401               }
12402             break;
12403           case 0xf7:
12404               GETBYTE ();
12405               switch (op[2] & 0xf0)
12406               {
12407                 case 0x00:
12408                 case 0x10:
12409                 case 0x20:
12410                 case 0x30:
12411                 case 0x40:
12412                 case 0x50:
12413                 case 0x60:
12414                 case 0x70:
12415                 case 0x80:
12416                 case 0x90:
12417                 case 0xa0:
12418                 case 0xb0:
12419                 case 0xc0:
12420                 case 0xd0:
12421                 case 0xe0:
12422                   goto op_semantics_93;
12423                   break;
12424                 case 0xf0:
12425                   goto op_semantics_94;
12426                   break;
12427               }
12428             break;
12429           case 0xf8:
12430               GETBYTE ();
12431               switch (op[2] & 0xf0)
12432               {
12433                 case 0x00:
12434                 case 0x10:
12435                 case 0x20:
12436                 case 0x30:
12437                 case 0x40:
12438                 case 0x50:
12439                 case 0x60:
12440                 case 0x70:
12441                 case 0x80:
12442                 case 0x90:
12443                 case 0xa0:
12444                 case 0xb0:
12445                 case 0xc0:
12446                 case 0xd0:
12447                 case 0xe0:
12448                   goto op_semantics_93;
12449                   break;
12450                 case 0xf0:
12451                   goto op_semantics_94;
12452                   break;
12453               }
12454             break;
12455           case 0xf9:
12456               GETBYTE ();
12457               switch (op[2] & 0xf0)
12458               {
12459                 case 0x00:
12460                 case 0x10:
12461                 case 0x20:
12462                 case 0x30:
12463                 case 0x40:
12464                 case 0x50:
12465                 case 0x60:
12466                 case 0x70:
12467                 case 0x80:
12468                 case 0x90:
12469                 case 0xa0:
12470                 case 0xb0:
12471                 case 0xc0:
12472                 case 0xd0:
12473                 case 0xe0:
12474                   goto op_semantics_93;
12475                   break;
12476                 case 0xf0:
12477                   goto op_semantics_94;
12478                   break;
12479               }
12480             break;
12481           case 0xfa:
12482               GETBYTE ();
12483               switch (op[2] & 0xf0)
12484               {
12485                 case 0x00:
12486                 case 0x10:
12487                 case 0x20:
12488                 case 0x30:
12489                 case 0x40:
12490                 case 0x50:
12491                 case 0x60:
12492                 case 0x70:
12493                 case 0x80:
12494                 case 0x90:
12495                 case 0xa0:
12496                 case 0xb0:
12497                 case 0xc0:
12498                 case 0xd0:
12499                 case 0xe0:
12500                   goto op_semantics_93;
12501                   break;
12502                 case 0xf0:
12503                   goto op_semantics_94;
12504                   break;
12505               }
12506             break;
12507           case 0xfb:
12508               GETBYTE ();
12509               switch (op[2] & 0xf0)
12510               {
12511                 case 0x00:
12512                 case 0x10:
12513                 case 0x20:
12514                 case 0x30:
12515                 case 0x40:
12516                 case 0x50:
12517                 case 0x60:
12518                 case 0x70:
12519                 case 0x80:
12520                 case 0x90:
12521                 case 0xa0:
12522                 case 0xb0:
12523                 case 0xc0:
12524                 case 0xd0:
12525                 case 0xe0:
12526                   goto op_semantics_93;
12527                   break;
12528                 case 0xf0:
12529                   goto op_semantics_94;
12530                   break;
12531               }
12532             break;
12533           case 0xfc:
12534               GETBYTE ();
12535               switch (op[2] & 0xf0)
12536               {
12537                 case 0x00:
12538                 case 0x10:
12539                 case 0x20:
12540                 case 0x30:
12541                 case 0x40:
12542                 case 0x50:
12543                 case 0x60:
12544                 case 0x70:
12545                 case 0x80:
12546                 case 0x90:
12547                 case 0xa0:
12548                 case 0xb0:
12549                 case 0xc0:
12550                 case 0xd0:
12551                 case 0xe0:
12552                   goto op_semantics_93;
12553                   break;
12554                 case 0xf0:
12555                   goto op_semantics_94;
12556                   break;
12557               }
12558             break;
12559           case 0xfd:
12560               GETBYTE ();
12561               switch (op[2] & 0xf0)
12562               {
12563                 case 0x00:
12564                 case 0x10:
12565                 case 0x20:
12566                 case 0x30:
12567                 case 0x40:
12568                 case 0x50:
12569                 case 0x60:
12570                 case 0x70:
12571                 case 0x80:
12572                 case 0x90:
12573                 case 0xa0:
12574                 case 0xb0:
12575                 case 0xc0:
12576                 case 0xd0:
12577                 case 0xe0:
12578                   goto op_semantics_93;
12579                   break;
12580                 case 0xf0:
12581                   goto op_semantics_94;
12582                   break;
12583               }
12584             break;
12585           case 0xfe:
12586               GETBYTE ();
12587               switch (op[2] & 0xf0)
12588               {
12589                 case 0x00:
12590                 case 0x10:
12591                 case 0x20:
12592                 case 0x30:
12593                 case 0x40:
12594                 case 0x50:
12595                 case 0x60:
12596                 case 0x70:
12597                 case 0x80:
12598                 case 0x90:
12599                 case 0xa0:
12600                 case 0xb0:
12601                 case 0xc0:
12602                 case 0xd0:
12603                 case 0xe0:
12604                   goto op_semantics_93;
12605                   break;
12606                 case 0xf0:
12607                   goto op_semantics_94;
12608                   break;
12609               }
12610             break;
12611           case 0xff:
12612               GETBYTE ();
12613               switch (op[2] & 0xf0)
12614               {
12615                 case 0x00:
12616                 case 0x10:
12617                 case 0x20:
12618                 case 0x30:
12619                 case 0x40:
12620                 case 0x50:
12621                 case 0x60:
12622                 case 0x70:
12623                 case 0x80:
12624                 case 0x90:
12625                 case 0xa0:
12626                 case 0xb0:
12627                 case 0xc0:
12628                 case 0xd0:
12629                 case 0xe0:
12630                   goto op_semantics_93;
12631                   break;
12632                 case 0xf0:
12633                   goto op_semantics_94;
12634                   break;
12635               }
12636             break;
12637           default: UNSUPPORTED(); break;
12638         }
12639       break;
12640     case 0xfe:
12641         GETBYTE ();
12642         switch (op[1] & 0xff)
12643         {
12644           case 0x00:
12645               GETBYTE ();
12646               switch (op[2] & 0x00)
12647               {
12648                 case 0x00:
12649                   op_semantics_95:
12650                     {
12651                       /** 1111 1110 00sz isrc bsrc rdst mov%s   %0, [%1, %2] */
12652 #line 335 "rx-decode.opc"
12653                       int sz AU = (op[1] >> 4) & 0x03;
12654 #line 335 "rx-decode.opc"
12655                       int isrc AU = op[1] & 0x0f;
12656 #line 335 "rx-decode.opc"
12657                       int bsrc AU = (op[2] >> 4) & 0x0f;
12658 #line 335 "rx-decode.opc"
12659                       int rdst AU = op[2] & 0x0f;
12660                       if (trace)
12661                         {
12662                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12663                                  "/** 1111 1110 00sz isrc bsrc rdst     mov%s   %0, [%1, %2] */",
12664                                  op[0], op[1], op[2]);
12665                           printf ("  sz = 0x%x,", sz);
12666                           printf ("  isrc = 0x%x,", isrc);
12667                           printf ("  bsrc = 0x%x,", bsrc);
12668                           printf ("  rdst = 0x%x\n", rdst);
12669                         }
12670                       SYNTAX("mov%s     %0, [%1, %2]");
12671 #line 335 "rx-decode.opc"
12672                       ID(movbir); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
12673
12674                     }
12675                   break;
12676               }
12677             break;
12678           case 0x01:
12679               GETBYTE ();
12680               switch (op[2] & 0x00)
12681               {
12682                 case 0x00:
12683                   goto op_semantics_95;
12684                   break;
12685               }
12686             break;
12687           case 0x02:
12688               GETBYTE ();
12689               switch (op[2] & 0x00)
12690               {
12691                 case 0x00:
12692                   goto op_semantics_95;
12693                   break;
12694               }
12695             break;
12696           case 0x03:
12697               GETBYTE ();
12698               switch (op[2] & 0x00)
12699               {
12700                 case 0x00:
12701                   goto op_semantics_95;
12702                   break;
12703               }
12704             break;
12705           case 0x04:
12706               GETBYTE ();
12707               switch (op[2] & 0x00)
12708               {
12709                 case 0x00:
12710                   goto op_semantics_95;
12711                   break;
12712               }
12713             break;
12714           case 0x05:
12715               GETBYTE ();
12716               switch (op[2] & 0x00)
12717               {
12718                 case 0x00:
12719                   goto op_semantics_95;
12720                   break;
12721               }
12722             break;
12723           case 0x06:
12724               GETBYTE ();
12725               switch (op[2] & 0x00)
12726               {
12727                 case 0x00:
12728                   goto op_semantics_95;
12729                   break;
12730               }
12731             break;
12732           case 0x07:
12733               GETBYTE ();
12734               switch (op[2] & 0x00)
12735               {
12736                 case 0x00:
12737                   goto op_semantics_95;
12738                   break;
12739               }
12740             break;
12741           case 0x08:
12742               GETBYTE ();
12743               switch (op[2] & 0x00)
12744               {
12745                 case 0x00:
12746                   goto op_semantics_95;
12747                   break;
12748               }
12749             break;
12750           case 0x09:
12751               GETBYTE ();
12752               switch (op[2] & 0x00)
12753               {
12754                 case 0x00:
12755                   goto op_semantics_95;
12756                   break;
12757               }
12758             break;
12759           case 0x0a:
12760               GETBYTE ();
12761               switch (op[2] & 0x00)
12762               {
12763                 case 0x00:
12764                   goto op_semantics_95;
12765                   break;
12766               }
12767             break;
12768           case 0x0b:
12769               GETBYTE ();
12770               switch (op[2] & 0x00)
12771               {
12772                 case 0x00:
12773                   goto op_semantics_95;
12774                   break;
12775               }
12776             break;
12777           case 0x0c:
12778               GETBYTE ();
12779               switch (op[2] & 0x00)
12780               {
12781                 case 0x00:
12782                   goto op_semantics_95;
12783                   break;
12784               }
12785             break;
12786           case 0x0d:
12787               GETBYTE ();
12788               switch (op[2] & 0x00)
12789               {
12790                 case 0x00:
12791                   goto op_semantics_95;
12792                   break;
12793               }
12794             break;
12795           case 0x0e:
12796               GETBYTE ();
12797               switch (op[2] & 0x00)
12798               {
12799                 case 0x00:
12800                   goto op_semantics_95;
12801                   break;
12802               }
12803             break;
12804           case 0x0f:
12805               GETBYTE ();
12806               switch (op[2] & 0x00)
12807               {
12808                 case 0x00:
12809                   goto op_semantics_95;
12810                   break;
12811               }
12812             break;
12813           case 0x10:
12814               GETBYTE ();
12815               switch (op[2] & 0x00)
12816               {
12817                 case 0x00:
12818                   goto op_semantics_95;
12819                   break;
12820               }
12821             break;
12822           case 0x11:
12823               GETBYTE ();
12824               switch (op[2] & 0x00)
12825               {
12826                 case 0x00:
12827                   goto op_semantics_95;
12828                   break;
12829               }
12830             break;
12831           case 0x12:
12832               GETBYTE ();
12833               switch (op[2] & 0x00)
12834               {
12835                 case 0x00:
12836                   goto op_semantics_95;
12837                   break;
12838               }
12839             break;
12840           case 0x13:
12841               GETBYTE ();
12842               switch (op[2] & 0x00)
12843               {
12844                 case 0x00:
12845                   goto op_semantics_95;
12846                   break;
12847               }
12848             break;
12849           case 0x14:
12850               GETBYTE ();
12851               switch (op[2] & 0x00)
12852               {
12853                 case 0x00:
12854                   goto op_semantics_95;
12855                   break;
12856               }
12857             break;
12858           case 0x15:
12859               GETBYTE ();
12860               switch (op[2] & 0x00)
12861               {
12862                 case 0x00:
12863                   goto op_semantics_95;
12864                   break;
12865               }
12866             break;
12867           case 0x16:
12868               GETBYTE ();
12869               switch (op[2] & 0x00)
12870               {
12871                 case 0x00:
12872                   goto op_semantics_95;
12873                   break;
12874               }
12875             break;
12876           case 0x17:
12877               GETBYTE ();
12878               switch (op[2] & 0x00)
12879               {
12880                 case 0x00:
12881                   goto op_semantics_95;
12882                   break;
12883               }
12884             break;
12885           case 0x18:
12886               GETBYTE ();
12887               switch (op[2] & 0x00)
12888               {
12889                 case 0x00:
12890                   goto op_semantics_95;
12891                   break;
12892               }
12893             break;
12894           case 0x19:
12895               GETBYTE ();
12896               switch (op[2] & 0x00)
12897               {
12898                 case 0x00:
12899                   goto op_semantics_95;
12900                   break;
12901               }
12902             break;
12903           case 0x1a:
12904               GETBYTE ();
12905               switch (op[2] & 0x00)
12906               {
12907                 case 0x00:
12908                   goto op_semantics_95;
12909                   break;
12910               }
12911             break;
12912           case 0x1b:
12913               GETBYTE ();
12914               switch (op[2] & 0x00)
12915               {
12916                 case 0x00:
12917                   goto op_semantics_95;
12918                   break;
12919               }
12920             break;
12921           case 0x1c:
12922               GETBYTE ();
12923               switch (op[2] & 0x00)
12924               {
12925                 case 0x00:
12926                   goto op_semantics_95;
12927                   break;
12928               }
12929             break;
12930           case 0x1d:
12931               GETBYTE ();
12932               switch (op[2] & 0x00)
12933               {
12934                 case 0x00:
12935                   goto op_semantics_95;
12936                   break;
12937               }
12938             break;
12939           case 0x1e:
12940               GETBYTE ();
12941               switch (op[2] & 0x00)
12942               {
12943                 case 0x00:
12944                   goto op_semantics_95;
12945                   break;
12946               }
12947             break;
12948           case 0x1f:
12949               GETBYTE ();
12950               switch (op[2] & 0x00)
12951               {
12952                 case 0x00:
12953                   goto op_semantics_95;
12954                   break;
12955               }
12956             break;
12957           case 0x20:
12958               GETBYTE ();
12959               switch (op[2] & 0x00)
12960               {
12961                 case 0x00:
12962                   goto op_semantics_95;
12963                   break;
12964               }
12965             break;
12966           case 0x21:
12967               GETBYTE ();
12968               switch (op[2] & 0x00)
12969               {
12970                 case 0x00:
12971                   goto op_semantics_95;
12972                   break;
12973               }
12974             break;
12975           case 0x22:
12976               GETBYTE ();
12977               switch (op[2] & 0x00)
12978               {
12979                 case 0x00:
12980                   goto op_semantics_95;
12981                   break;
12982               }
12983             break;
12984           case 0x23:
12985               GETBYTE ();
12986               switch (op[2] & 0x00)
12987               {
12988                 case 0x00:
12989                   goto op_semantics_95;
12990                   break;
12991               }
12992             break;
12993           case 0x24:
12994               GETBYTE ();
12995               switch (op[2] & 0x00)
12996               {
12997                 case 0x00:
12998                   goto op_semantics_95;
12999                   break;
13000               }
13001             break;
13002           case 0x25:
13003               GETBYTE ();
13004               switch (op[2] & 0x00)
13005               {
13006                 case 0x00:
13007                   goto op_semantics_95;
13008                   break;
13009               }
13010             break;
13011           case 0x26:
13012               GETBYTE ();
13013               switch (op[2] & 0x00)
13014               {
13015                 case 0x00:
13016                   goto op_semantics_95;
13017                   break;
13018               }
13019             break;
13020           case 0x27:
13021               GETBYTE ();
13022               switch (op[2] & 0x00)
13023               {
13024                 case 0x00:
13025                   goto op_semantics_95;
13026                   break;
13027               }
13028             break;
13029           case 0x28:
13030               GETBYTE ();
13031               switch (op[2] & 0x00)
13032               {
13033                 case 0x00:
13034                   goto op_semantics_95;
13035                   break;
13036               }
13037             break;
13038           case 0x29:
13039               GETBYTE ();
13040               switch (op[2] & 0x00)
13041               {
13042                 case 0x00:
13043                   goto op_semantics_95;
13044                   break;
13045               }
13046             break;
13047           case 0x2a:
13048               GETBYTE ();
13049               switch (op[2] & 0x00)
13050               {
13051                 case 0x00:
13052                   goto op_semantics_95;
13053                   break;
13054               }
13055             break;
13056           case 0x2b:
13057               GETBYTE ();
13058               switch (op[2] & 0x00)
13059               {
13060                 case 0x00:
13061                   goto op_semantics_95;
13062                   break;
13063               }
13064             break;
13065           case 0x2c:
13066               GETBYTE ();
13067               switch (op[2] & 0x00)
13068               {
13069                 case 0x00:
13070                   goto op_semantics_95;
13071                   break;
13072               }
13073             break;
13074           case 0x2d:
13075               GETBYTE ();
13076               switch (op[2] & 0x00)
13077               {
13078                 case 0x00:
13079                   goto op_semantics_95;
13080                   break;
13081               }
13082             break;
13083           case 0x2e:
13084               GETBYTE ();
13085               switch (op[2] & 0x00)
13086               {
13087                 case 0x00:
13088                   goto op_semantics_95;
13089                   break;
13090               }
13091             break;
13092           case 0x2f:
13093               GETBYTE ();
13094               switch (op[2] & 0x00)
13095               {
13096                 case 0x00:
13097                   goto op_semantics_95;
13098                   break;
13099               }
13100             break;
13101           case 0x40:
13102               GETBYTE ();
13103               switch (op[2] & 0x00)
13104               {
13105                 case 0x00:
13106                   op_semantics_96:
13107                     {
13108                       /** 1111 1110 01sz isrc bsrc rdst mov%s   [%1, %2], %0 */
13109 #line 332 "rx-decode.opc"
13110                       int sz AU = (op[1] >> 4) & 0x03;
13111 #line 332 "rx-decode.opc"
13112                       int isrc AU = op[1] & 0x0f;
13113 #line 332 "rx-decode.opc"
13114                       int bsrc AU = (op[2] >> 4) & 0x0f;
13115 #line 332 "rx-decode.opc"
13116                       int rdst AU = op[2] & 0x0f;
13117                       if (trace)
13118                         {
13119                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13120                                  "/** 1111 1110 01sz isrc bsrc rdst     mov%s   [%1, %2], %0 */",
13121                                  op[0], op[1], op[2]);
13122                           printf ("  sz = 0x%x,", sz);
13123                           printf ("  isrc = 0x%x,", isrc);
13124                           printf ("  bsrc = 0x%x,", bsrc);
13125                           printf ("  rdst = 0x%x\n", rdst);
13126                         }
13127                       SYNTAX("mov%s     [%1, %2], %0");
13128 #line 332 "rx-decode.opc"
13129                       ID(movbi); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
13130
13131                     }
13132                   break;
13133               }
13134             break;
13135           case 0x41:
13136               GETBYTE ();
13137               switch (op[2] & 0x00)
13138               {
13139                 case 0x00:
13140                   goto op_semantics_96;
13141                   break;
13142               }
13143             break;
13144           case 0x42:
13145               GETBYTE ();
13146               switch (op[2] & 0x00)
13147               {
13148                 case 0x00:
13149                   goto op_semantics_96;
13150                   break;
13151               }
13152             break;
13153           case 0x43:
13154               GETBYTE ();
13155               switch (op[2] & 0x00)
13156               {
13157                 case 0x00:
13158                   goto op_semantics_96;
13159                   break;
13160               }
13161             break;
13162           case 0x44:
13163               GETBYTE ();
13164               switch (op[2] & 0x00)
13165               {
13166                 case 0x00:
13167                   goto op_semantics_96;
13168                   break;
13169               }
13170             break;
13171           case 0x45:
13172               GETBYTE ();
13173               switch (op[2] & 0x00)
13174               {
13175                 case 0x00:
13176                   goto op_semantics_96;
13177                   break;
13178               }
13179             break;
13180           case 0x46:
13181               GETBYTE ();
13182               switch (op[2] & 0x00)
13183               {
13184                 case 0x00:
13185                   goto op_semantics_96;
13186                   break;
13187               }
13188             break;
13189           case 0x47:
13190               GETBYTE ();
13191               switch (op[2] & 0x00)
13192               {
13193                 case 0x00:
13194                   goto op_semantics_96;
13195                   break;
13196               }
13197             break;
13198           case 0x48:
13199               GETBYTE ();
13200               switch (op[2] & 0x00)
13201               {
13202                 case 0x00:
13203                   goto op_semantics_96;
13204                   break;
13205               }
13206             break;
13207           case 0x49:
13208               GETBYTE ();
13209               switch (op[2] & 0x00)
13210               {
13211                 case 0x00:
13212                   goto op_semantics_96;
13213                   break;
13214               }
13215             break;
13216           case 0x4a:
13217               GETBYTE ();
13218               switch (op[2] & 0x00)
13219               {
13220                 case 0x00:
13221                   goto op_semantics_96;
13222                   break;
13223               }
13224             break;
13225           case 0x4b:
13226               GETBYTE ();
13227               switch (op[2] & 0x00)
13228               {
13229                 case 0x00:
13230                   goto op_semantics_96;
13231                   break;
13232               }
13233             break;
13234           case 0x4c:
13235               GETBYTE ();
13236               switch (op[2] & 0x00)
13237               {
13238                 case 0x00:
13239                   goto op_semantics_96;
13240                   break;
13241               }
13242             break;
13243           case 0x4d:
13244               GETBYTE ();
13245               switch (op[2] & 0x00)
13246               {
13247                 case 0x00:
13248                   goto op_semantics_96;
13249                   break;
13250               }
13251             break;
13252           case 0x4e:
13253               GETBYTE ();
13254               switch (op[2] & 0x00)
13255               {
13256                 case 0x00:
13257                   goto op_semantics_96;
13258                   break;
13259               }
13260             break;
13261           case 0x4f:
13262               GETBYTE ();
13263               switch (op[2] & 0x00)
13264               {
13265                 case 0x00:
13266                   goto op_semantics_96;
13267                   break;
13268               }
13269             break;
13270           case 0x50:
13271               GETBYTE ();
13272               switch (op[2] & 0x00)
13273               {
13274                 case 0x00:
13275                   goto op_semantics_96;
13276                   break;
13277               }
13278             break;
13279           case 0x51:
13280               GETBYTE ();
13281               switch (op[2] & 0x00)
13282               {
13283                 case 0x00:
13284                   goto op_semantics_96;
13285                   break;
13286               }
13287             break;
13288           case 0x52:
13289               GETBYTE ();
13290               switch (op[2] & 0x00)
13291               {
13292                 case 0x00:
13293                   goto op_semantics_96;
13294                   break;
13295               }
13296             break;
13297           case 0x53:
13298               GETBYTE ();
13299               switch (op[2] & 0x00)
13300               {
13301                 case 0x00:
13302                   goto op_semantics_96;
13303                   break;
13304               }
13305             break;
13306           case 0x54:
13307               GETBYTE ();
13308               switch (op[2] & 0x00)
13309               {
13310                 case 0x00:
13311                   goto op_semantics_96;
13312                   break;
13313               }
13314             break;
13315           case 0x55:
13316               GETBYTE ();
13317               switch (op[2] & 0x00)
13318               {
13319                 case 0x00:
13320                   goto op_semantics_96;
13321                   break;
13322               }
13323             break;
13324           case 0x56:
13325               GETBYTE ();
13326               switch (op[2] & 0x00)
13327               {
13328                 case 0x00:
13329                   goto op_semantics_96;
13330                   break;
13331               }
13332             break;
13333           case 0x57:
13334               GETBYTE ();
13335               switch (op[2] & 0x00)
13336               {
13337                 case 0x00:
13338                   goto op_semantics_96;
13339                   break;
13340               }
13341             break;
13342           case 0x58:
13343               GETBYTE ();
13344               switch (op[2] & 0x00)
13345               {
13346                 case 0x00:
13347                   goto op_semantics_96;
13348                   break;
13349               }
13350             break;
13351           case 0x59:
13352               GETBYTE ();
13353               switch (op[2] & 0x00)
13354               {
13355                 case 0x00:
13356                   goto op_semantics_96;
13357                   break;
13358               }
13359             break;
13360           case 0x5a:
13361               GETBYTE ();
13362               switch (op[2] & 0x00)
13363               {
13364                 case 0x00:
13365                   goto op_semantics_96;
13366                   break;
13367               }
13368             break;
13369           case 0x5b:
13370               GETBYTE ();
13371               switch (op[2] & 0x00)
13372               {
13373                 case 0x00:
13374                   goto op_semantics_96;
13375                   break;
13376               }
13377             break;
13378           case 0x5c:
13379               GETBYTE ();
13380               switch (op[2] & 0x00)
13381               {
13382                 case 0x00:
13383                   goto op_semantics_96;
13384                   break;
13385               }
13386             break;
13387           case 0x5d:
13388               GETBYTE ();
13389               switch (op[2] & 0x00)
13390               {
13391                 case 0x00:
13392                   goto op_semantics_96;
13393                   break;
13394               }
13395             break;
13396           case 0x5e:
13397               GETBYTE ();
13398               switch (op[2] & 0x00)
13399               {
13400                 case 0x00:
13401                   goto op_semantics_96;
13402                   break;
13403               }
13404             break;
13405           case 0x5f:
13406               GETBYTE ();
13407               switch (op[2] & 0x00)
13408               {
13409                 case 0x00:
13410                   goto op_semantics_96;
13411                   break;
13412               }
13413             break;
13414           case 0x60:
13415               GETBYTE ();
13416               switch (op[2] & 0x00)
13417               {
13418                 case 0x00:
13419                   goto op_semantics_96;
13420                   break;
13421               }
13422             break;
13423           case 0x61:
13424               GETBYTE ();
13425               switch (op[2] & 0x00)
13426               {
13427                 case 0x00:
13428                   goto op_semantics_96;
13429                   break;
13430               }
13431             break;
13432           case 0x62:
13433               GETBYTE ();
13434               switch (op[2] & 0x00)
13435               {
13436                 case 0x00:
13437                   goto op_semantics_96;
13438                   break;
13439               }
13440             break;
13441           case 0x63:
13442               GETBYTE ();
13443               switch (op[2] & 0x00)
13444               {
13445                 case 0x00:
13446                   goto op_semantics_96;
13447                   break;
13448               }
13449             break;
13450           case 0x64:
13451               GETBYTE ();
13452               switch (op[2] & 0x00)
13453               {
13454                 case 0x00:
13455                   goto op_semantics_96;
13456                   break;
13457               }
13458             break;
13459           case 0x65:
13460               GETBYTE ();
13461               switch (op[2] & 0x00)
13462               {
13463                 case 0x00:
13464                   goto op_semantics_96;
13465                   break;
13466               }
13467             break;
13468           case 0x66:
13469               GETBYTE ();
13470               switch (op[2] & 0x00)
13471               {
13472                 case 0x00:
13473                   goto op_semantics_96;
13474                   break;
13475               }
13476             break;
13477           case 0x67:
13478               GETBYTE ();
13479               switch (op[2] & 0x00)
13480               {
13481                 case 0x00:
13482                   goto op_semantics_96;
13483                   break;
13484               }
13485             break;
13486           case 0x68:
13487               GETBYTE ();
13488               switch (op[2] & 0x00)
13489               {
13490                 case 0x00:
13491                   goto op_semantics_96;
13492                   break;
13493               }
13494             break;
13495           case 0x69:
13496               GETBYTE ();
13497               switch (op[2] & 0x00)
13498               {
13499                 case 0x00:
13500                   goto op_semantics_96;
13501                   break;
13502               }
13503             break;
13504           case 0x6a:
13505               GETBYTE ();
13506               switch (op[2] & 0x00)
13507               {
13508                 case 0x00:
13509                   goto op_semantics_96;
13510                   break;
13511               }
13512             break;
13513           case 0x6b:
13514               GETBYTE ();
13515               switch (op[2] & 0x00)
13516               {
13517                 case 0x00:
13518                   goto op_semantics_96;
13519                   break;
13520               }
13521             break;
13522           case 0x6c:
13523               GETBYTE ();
13524               switch (op[2] & 0x00)
13525               {
13526                 case 0x00:
13527                   goto op_semantics_96;
13528                   break;
13529               }
13530             break;
13531           case 0x6d:
13532               GETBYTE ();
13533               switch (op[2] & 0x00)
13534               {
13535                 case 0x00:
13536                   goto op_semantics_96;
13537                   break;
13538               }
13539             break;
13540           case 0x6e:
13541               GETBYTE ();
13542               switch (op[2] & 0x00)
13543               {
13544                 case 0x00:
13545                   goto op_semantics_96;
13546                   break;
13547               }
13548             break;
13549           case 0x6f:
13550               GETBYTE ();
13551               switch (op[2] & 0x00)
13552               {
13553                 case 0x00:
13554                   goto op_semantics_96;
13555                   break;
13556               }
13557             break;
13558           case 0xc0:
13559               GETBYTE ();
13560               switch (op[2] & 0x00)
13561               {
13562                 case 0x00:
13563                   op_semantics_97:
13564                     {
13565                       /** 1111 1110 11sz isrc bsrc rdst movu%s  [%1, %2], %0 */
13566 #line 338 "rx-decode.opc"
13567                       int sz AU = (op[1] >> 4) & 0x03;
13568 #line 338 "rx-decode.opc"
13569                       int isrc AU = op[1] & 0x0f;
13570 #line 338 "rx-decode.opc"
13571                       int bsrc AU = (op[2] >> 4) & 0x0f;
13572 #line 338 "rx-decode.opc"
13573                       int rdst AU = op[2] & 0x0f;
13574                       if (trace)
13575                         {
13576                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13577                                  "/** 1111 1110 11sz isrc bsrc rdst     movu%s  [%1, %2], %0 */",
13578                                  op[0], op[1], op[2]);
13579                           printf ("  sz = 0x%x,", sz);
13580                           printf ("  isrc = 0x%x,", isrc);
13581                           printf ("  bsrc = 0x%x,", bsrc);
13582                           printf ("  rdst = 0x%x\n", rdst);
13583                         }
13584                       SYNTAX("movu%s    [%1, %2], %0");
13585 #line 338 "rx-decode.opc"
13586                       ID(movbi); uBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
13587
13588                     }
13589                   break;
13590               }
13591             break;
13592           case 0xc1:
13593               GETBYTE ();
13594               switch (op[2] & 0x00)
13595               {
13596                 case 0x00:
13597                   goto op_semantics_97;
13598                   break;
13599               }
13600             break;
13601           case 0xc2:
13602               GETBYTE ();
13603               switch (op[2] & 0x00)
13604               {
13605                 case 0x00:
13606                   goto op_semantics_97;
13607                   break;
13608               }
13609             break;
13610           case 0xc3:
13611               GETBYTE ();
13612               switch (op[2] & 0x00)
13613               {
13614                 case 0x00:
13615                   goto op_semantics_97;
13616                   break;
13617               }
13618             break;
13619           case 0xc4:
13620               GETBYTE ();
13621               switch (op[2] & 0x00)
13622               {
13623                 case 0x00:
13624                   goto op_semantics_97;
13625                   break;
13626               }
13627             break;
13628           case 0xc5:
13629               GETBYTE ();
13630               switch (op[2] & 0x00)
13631               {
13632                 case 0x00:
13633                   goto op_semantics_97;
13634                   break;
13635               }
13636             break;
13637           case 0xc6:
13638               GETBYTE ();
13639               switch (op[2] & 0x00)
13640               {
13641                 case 0x00:
13642                   goto op_semantics_97;
13643                   break;
13644               }
13645             break;
13646           case 0xc7:
13647               GETBYTE ();
13648               switch (op[2] & 0x00)
13649               {
13650                 case 0x00:
13651                   goto op_semantics_97;
13652                   break;
13653               }
13654             break;
13655           case 0xc8:
13656               GETBYTE ();
13657               switch (op[2] & 0x00)
13658               {
13659                 case 0x00:
13660                   goto op_semantics_97;
13661                   break;
13662               }
13663             break;
13664           case 0xc9:
13665               GETBYTE ();
13666               switch (op[2] & 0x00)
13667               {
13668                 case 0x00:
13669                   goto op_semantics_97;
13670                   break;
13671               }
13672             break;
13673           case 0xca:
13674               GETBYTE ();
13675               switch (op[2] & 0x00)
13676               {
13677                 case 0x00:
13678                   goto op_semantics_97;
13679                   break;
13680               }
13681             break;
13682           case 0xcb:
13683               GETBYTE ();
13684               switch (op[2] & 0x00)
13685               {
13686                 case 0x00:
13687                   goto op_semantics_97;
13688                   break;
13689               }
13690             break;
13691           case 0xcc:
13692               GETBYTE ();
13693               switch (op[2] & 0x00)
13694               {
13695                 case 0x00:
13696                   goto op_semantics_97;
13697                   break;
13698               }
13699             break;
13700           case 0xcd:
13701               GETBYTE ();
13702               switch (op[2] & 0x00)
13703               {
13704                 case 0x00:
13705                   goto op_semantics_97;
13706                   break;
13707               }
13708             break;
13709           case 0xce:
13710               GETBYTE ();
13711               switch (op[2] & 0x00)
13712               {
13713                 case 0x00:
13714                   goto op_semantics_97;
13715                   break;
13716               }
13717             break;
13718           case 0xcf:
13719               GETBYTE ();
13720               switch (op[2] & 0x00)
13721               {
13722                 case 0x00:
13723                   goto op_semantics_97;
13724                   break;
13725               }
13726             break;
13727           case 0xd0:
13728               GETBYTE ();
13729               switch (op[2] & 0x00)
13730               {
13731                 case 0x00:
13732                   goto op_semantics_97;
13733                   break;
13734               }
13735             break;
13736           case 0xd1:
13737               GETBYTE ();
13738               switch (op[2] & 0x00)
13739               {
13740                 case 0x00:
13741                   goto op_semantics_97;
13742                   break;
13743               }
13744             break;
13745           case 0xd2:
13746               GETBYTE ();
13747               switch (op[2] & 0x00)
13748               {
13749                 case 0x00:
13750                   goto op_semantics_97;
13751                   break;
13752               }
13753             break;
13754           case 0xd3:
13755               GETBYTE ();
13756               switch (op[2] & 0x00)
13757               {
13758                 case 0x00:
13759                   goto op_semantics_97;
13760                   break;
13761               }
13762             break;
13763           case 0xd4:
13764               GETBYTE ();
13765               switch (op[2] & 0x00)
13766               {
13767                 case 0x00:
13768                   goto op_semantics_97;
13769                   break;
13770               }
13771             break;
13772           case 0xd5:
13773               GETBYTE ();
13774               switch (op[2] & 0x00)
13775               {
13776                 case 0x00:
13777                   goto op_semantics_97;
13778                   break;
13779               }
13780             break;
13781           case 0xd6:
13782               GETBYTE ();
13783               switch (op[2] & 0x00)
13784               {
13785                 case 0x00:
13786                   goto op_semantics_97;
13787                   break;
13788               }
13789             break;
13790           case 0xd7:
13791               GETBYTE ();
13792               switch (op[2] & 0x00)
13793               {
13794                 case 0x00:
13795                   goto op_semantics_97;
13796                   break;
13797               }
13798             break;
13799           case 0xd8:
13800               GETBYTE ();
13801               switch (op[2] & 0x00)
13802               {
13803                 case 0x00:
13804                   goto op_semantics_97;
13805                   break;
13806               }
13807             break;
13808           case 0xd9:
13809               GETBYTE ();
13810               switch (op[2] & 0x00)
13811               {
13812                 case 0x00:
13813                   goto op_semantics_97;
13814                   break;
13815               }
13816             break;
13817           case 0xda:
13818               GETBYTE ();
13819               switch (op[2] & 0x00)
13820               {
13821                 case 0x00:
13822                   goto op_semantics_97;
13823                   break;
13824               }
13825             break;
13826           case 0xdb:
13827               GETBYTE ();
13828               switch (op[2] & 0x00)
13829               {
13830                 case 0x00:
13831                   goto op_semantics_97;
13832                   break;
13833               }
13834             break;
13835           case 0xdc:
13836               GETBYTE ();
13837               switch (op[2] & 0x00)
13838               {
13839                 case 0x00:
13840                   goto op_semantics_97;
13841                   break;
13842               }
13843             break;
13844           case 0xdd:
13845               GETBYTE ();
13846               switch (op[2] & 0x00)
13847               {
13848                 case 0x00:
13849                   goto op_semantics_97;
13850                   break;
13851               }
13852             break;
13853           case 0xde:
13854               GETBYTE ();
13855               switch (op[2] & 0x00)
13856               {
13857                 case 0x00:
13858                   goto op_semantics_97;
13859                   break;
13860               }
13861             break;
13862           case 0xdf:
13863               GETBYTE ();
13864               switch (op[2] & 0x00)
13865               {
13866                 case 0x00:
13867                   goto op_semantics_97;
13868                   break;
13869               }
13870             break;
13871           case 0xe0:
13872               GETBYTE ();
13873               switch (op[2] & 0x00)
13874               {
13875                 case 0x00:
13876                   goto op_semantics_97;
13877                   break;
13878               }
13879             break;
13880           case 0xe1:
13881               GETBYTE ();
13882               switch (op[2] & 0x00)
13883               {
13884                 case 0x00:
13885                   goto op_semantics_97;
13886                   break;
13887               }
13888             break;
13889           case 0xe2:
13890               GETBYTE ();
13891               switch (op[2] & 0x00)
13892               {
13893                 case 0x00:
13894                   goto op_semantics_97;
13895                   break;
13896               }
13897             break;
13898           case 0xe3:
13899               GETBYTE ();
13900               switch (op[2] & 0x00)
13901               {
13902                 case 0x00:
13903                   goto op_semantics_97;
13904                   break;
13905               }
13906             break;
13907           case 0xe4:
13908               GETBYTE ();
13909               switch (op[2] & 0x00)
13910               {
13911                 case 0x00:
13912                   goto op_semantics_97;
13913                   break;
13914               }
13915             break;
13916           case 0xe5:
13917               GETBYTE ();
13918               switch (op[2] & 0x00)
13919               {
13920                 case 0x00:
13921                   goto op_semantics_97;
13922                   break;
13923               }
13924             break;
13925           case 0xe6:
13926               GETBYTE ();
13927               switch (op[2] & 0x00)
13928               {
13929                 case 0x00:
13930                   goto op_semantics_97;
13931                   break;
13932               }
13933             break;
13934           case 0xe7:
13935               GETBYTE ();
13936               switch (op[2] & 0x00)
13937               {
13938                 case 0x00:
13939                   goto op_semantics_97;
13940                   break;
13941               }
13942             break;
13943           case 0xe8:
13944               GETBYTE ();
13945               switch (op[2] & 0x00)
13946               {
13947                 case 0x00:
13948                   goto op_semantics_97;
13949                   break;
13950               }
13951             break;
13952           case 0xe9:
13953               GETBYTE ();
13954               switch (op[2] & 0x00)
13955               {
13956                 case 0x00:
13957                   goto op_semantics_97;
13958                   break;
13959               }
13960             break;
13961           case 0xea:
13962               GETBYTE ();
13963               switch (op[2] & 0x00)
13964               {
13965                 case 0x00:
13966                   goto op_semantics_97;
13967                   break;
13968               }
13969             break;
13970           case 0xeb:
13971               GETBYTE ();
13972               switch (op[2] & 0x00)
13973               {
13974                 case 0x00:
13975                   goto op_semantics_97;
13976                   break;
13977               }
13978             break;
13979           case 0xec:
13980               GETBYTE ();
13981               switch (op[2] & 0x00)
13982               {
13983                 case 0x00:
13984                   goto op_semantics_97;
13985                   break;
13986               }
13987             break;
13988           case 0xed:
13989               GETBYTE ();
13990               switch (op[2] & 0x00)
13991               {
13992                 case 0x00:
13993                   goto op_semantics_97;
13994                   break;
13995               }
13996             break;
13997           case 0xee:
13998               GETBYTE ();
13999               switch (op[2] & 0x00)
14000               {
14001                 case 0x00:
14002                   goto op_semantics_97;
14003                   break;
14004               }
14005             break;
14006           case 0xef:
14007               GETBYTE ();
14008               switch (op[2] & 0x00)
14009               {
14010                 case 0x00:
14011                   goto op_semantics_97;
14012                   break;
14013               }
14014             break;
14015           default: UNSUPPORTED(); break;
14016         }
14017       break;
14018     case 0xff:
14019         GETBYTE ();
14020         switch (op[1] & 0xff)
14021         {
14022           case 0x00:
14023               GETBYTE ();
14024               switch (op[2] & 0x00)
14025               {
14026                 case 0x00:
14027                   op_semantics_98:
14028                     {
14029                       /** 1111 1111 0000 rdst srca srcb sub     %2, %1, %0 */
14030 #line 542 "rx-decode.opc"
14031                       int rdst AU = op[1] & 0x0f;
14032 #line 542 "rx-decode.opc"
14033                       int srca AU = (op[2] >> 4) & 0x0f;
14034 #line 542 "rx-decode.opc"
14035                       int srcb AU = op[2] & 0x0f;
14036                       if (trace)
14037                         {
14038                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
14039                                  "/** 1111 1111 0000 rdst srca srcb     sub     %2, %1, %0 */",
14040                                  op[0], op[1], op[2]);
14041                           printf ("  rdst = 0x%x,", rdst);
14042                           printf ("  srca = 0x%x,", srca);
14043                           printf ("  srcb = 0x%x\n", srcb);
14044                         }
14045                       SYNTAX("sub       %2, %1, %0");
14046 #line 542 "rx-decode.opc"
14047                       ID(sub); DR(rdst); SR(srcb); S2R(srca); F_OSZC;
14048
14049                     /*----------------------------------------------------------------------*/
14050                     /* SBB                                                                      */
14051
14052                     }
14053                   break;
14054               }
14055             break;
14056           case 0x01:
14057               GETBYTE ();
14058               switch (op[2] & 0x00)
14059               {
14060                 case 0x00:
14061                   goto op_semantics_98;
14062                   break;
14063               }
14064             break;
14065           case 0x02:
14066               GETBYTE ();
14067               switch (op[2] & 0x00)
14068               {
14069                 case 0x00:
14070                   goto op_semantics_98;
14071                   break;
14072               }
14073             break;
14074           case 0x03:
14075               GETBYTE ();
14076               switch (op[2] & 0x00)
14077               {
14078                 case 0x00:
14079                   goto op_semantics_98;
14080                   break;
14081               }
14082             break;
14083           case 0x04:
14084               GETBYTE ();
14085               switch (op[2] & 0x00)
14086               {
14087                 case 0x00:
14088                   goto op_semantics_98;
14089                   break;
14090               }
14091             break;
14092           case 0x05:
14093               GETBYTE ();
14094               switch (op[2] & 0x00)
14095               {
14096                 case 0x00:
14097                   goto op_semantics_98;
14098                   break;
14099               }
14100             break;
14101           case 0x06:
14102               GETBYTE ();
14103               switch (op[2] & 0x00)
14104               {
14105                 case 0x00:
14106                   goto op_semantics_98;
14107                   break;
14108               }
14109             break;
14110           case 0x07:
14111               GETBYTE ();
14112               switch (op[2] & 0x00)
14113               {
14114                 case 0x00:
14115                   goto op_semantics_98;
14116                   break;
14117               }
14118             break;
14119           case 0x08:
14120               GETBYTE ();
14121               switch (op[2] & 0x00)
14122               {
14123                 case 0x00:
14124                   goto op_semantics_98;
14125                   break;
14126               }
14127             break;
14128           case 0x09:
14129               GETBYTE ();
14130               switch (op[2] & 0x00)
14131               {
14132                 case 0x00:
14133                   goto op_semantics_98;
14134                   break;
14135               }
14136             break;
14137           case 0x0a:
14138               GETBYTE ();
14139               switch (op[2] & 0x00)
14140               {
14141                 case 0x00:
14142                   goto op_semantics_98;
14143                   break;
14144               }
14145             break;
14146           case 0x0b:
14147               GETBYTE ();
14148               switch (op[2] & 0x00)
14149               {
14150                 case 0x00:
14151                   goto op_semantics_98;
14152                   break;
14153               }
14154             break;
14155           case 0x0c:
14156               GETBYTE ();
14157               switch (op[2] & 0x00)
14158               {
14159                 case 0x00:
14160                   goto op_semantics_98;
14161                   break;
14162               }
14163             break;
14164           case 0x0d:
14165               GETBYTE ();
14166               switch (op[2] & 0x00)
14167               {
14168                 case 0x00:
14169                   goto op_semantics_98;
14170                   break;
14171               }
14172             break;
14173           case 0x0e:
14174               GETBYTE ();
14175               switch (op[2] & 0x00)
14176               {
14177                 case 0x00:
14178                   goto op_semantics_98;
14179                   break;
14180               }
14181             break;
14182           case 0x0f:
14183               GETBYTE ();
14184               switch (op[2] & 0x00)
14185               {
14186                 case 0x00:
14187                   goto op_semantics_98;
14188                   break;
14189               }
14190             break;
14191           case 0x20:
14192               GETBYTE ();
14193               switch (op[2] & 0x00)
14194               {
14195                 case 0x00:
14196                   op_semantics_99:
14197                     {
14198                       /** 1111 1111 0010 rdst srca srcb add     %2, %1, %0 */
14199 #line 509 "rx-decode.opc"
14200                       int rdst AU = op[1] & 0x0f;
14201 #line 509 "rx-decode.opc"
14202                       int srca AU = (op[2] >> 4) & 0x0f;
14203 #line 509 "rx-decode.opc"
14204                       int srcb AU = op[2] & 0x0f;
14205                       if (trace)
14206                         {
14207                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
14208                                  "/** 1111 1111 0010 rdst srca srcb     add     %2, %1, %0 */",
14209                                  op[0], op[1], op[2]);
14210                           printf ("  rdst = 0x%x,", rdst);
14211                           printf ("  srca = 0x%x,", srca);
14212                           printf ("  srcb = 0x%x\n", srcb);
14213                         }
14214                       SYNTAX("add       %2, %1, %0");
14215 #line 509 "rx-decode.opc"
14216                       ID(add); DR(rdst); SR(srcb); S2R(srca); F_OSZC;
14217
14218                     /*----------------------------------------------------------------------*/
14219                     /* CMP                                                                      */
14220
14221                     }
14222                   break;
14223               }
14224             break;
14225           case 0x21:
14226               GETBYTE ();
14227               switch (op[2] & 0x00)
14228               {
14229                 case 0x00:
14230                   goto op_semantics_99;
14231                   break;
14232               }
14233             break;
14234           case 0x22:
14235               GETBYTE ();
14236               switch (op[2] & 0x00)
14237               {
14238                 case 0x00:
14239                   goto op_semantics_99;
14240                   break;
14241               }
14242             break;
14243           case 0x23:
14244               GETBYTE ();
14245               switch (op[2] & 0x00)
14246               {
14247                 case 0x00:
14248                   goto op_semantics_99;
14249                   break;
14250               }
14251             break;
14252           case 0x24:
14253               GETBYTE ();
14254               switch (op[2] & 0x00)
14255               {
14256                 case 0x00:
14257                   goto op_semantics_99;
14258                   break;
14259               }
14260             break;
14261           case 0x25:
14262               GETBYTE ();
14263               switch (op[2] & 0x00)
14264               {
14265                 case 0x00:
14266                   goto op_semantics_99;
14267                   break;
14268               }
14269             break;
14270           case 0x26:
14271               GETBYTE ();
14272               switch (op[2] & 0x00)
14273               {
14274                 case 0x00:
14275                   goto op_semantics_99;
14276                   break;
14277               }
14278             break;
14279           case 0x27:
14280               GETBYTE ();
14281               switch (op[2] & 0x00)
14282               {
14283                 case 0x00:
14284                   goto op_semantics_99;
14285                   break;
14286               }
14287             break;
14288           case 0x28:
14289               GETBYTE ();
14290               switch (op[2] & 0x00)
14291               {
14292                 case 0x00:
14293                   goto op_semantics_99;
14294                   break;
14295               }
14296             break;
14297           case 0x29:
14298               GETBYTE ();
14299               switch (op[2] & 0x00)
14300               {
14301                 case 0x00:
14302                   goto op_semantics_99;
14303                   break;
14304               }
14305             break;
14306           case 0x2a:
14307               GETBYTE ();
14308               switch (op[2] & 0x00)
14309               {
14310                 case 0x00:
14311                   goto op_semantics_99;
14312                   break;
14313               }
14314             break;
14315           case 0x2b:
14316               GETBYTE ();
14317               switch (op[2] & 0x00)
14318               {
14319                 case 0x00:
14320                   goto op_semantics_99;
14321                   break;
14322               }
14323             break;
14324           case 0x2c:
14325               GETBYTE ();
14326               switch (op[2] & 0x00)
14327               {
14328                 case 0x00:
14329                   goto op_semantics_99;
14330                   break;
14331               }
14332             break;
14333           case 0x2d:
14334               GETBYTE ();
14335               switch (op[2] & 0x00)
14336               {
14337                 case 0x00:
14338                   goto op_semantics_99;
14339                   break;
14340               }
14341             break;
14342           case 0x2e:
14343               GETBYTE ();
14344               switch (op[2] & 0x00)
14345               {
14346                 case 0x00:
14347                   goto op_semantics_99;
14348                   break;
14349               }
14350             break;
14351           case 0x2f:
14352               GETBYTE ();
14353               switch (op[2] & 0x00)
14354               {
14355                 case 0x00:
14356                   goto op_semantics_99;
14357                   break;
14358               }
14359             break;
14360           case 0x30:
14361               GETBYTE ();
14362               switch (op[2] & 0x00)
14363               {
14364                 case 0x00:
14365                   op_semantics_100:
14366                     {
14367                       /** 1111 1111 0011 rdst srca srcb mul     %2, %1, %0 */
14368 #line 611 "rx-decode.opc"
14369                       int rdst AU = op[1] & 0x0f;
14370 #line 611 "rx-decode.opc"
14371                       int srca AU = (op[2] >> 4) & 0x0f;
14372 #line 611 "rx-decode.opc"
14373                       int srcb AU = op[2] & 0x0f;
14374                       if (trace)
14375                         {
14376                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
14377                                  "/** 1111 1111 0011 rdst srca srcb     mul     %2, %1, %0 */",
14378                                  op[0], op[1], op[2]);
14379                           printf ("  rdst = 0x%x,", rdst);
14380                           printf ("  srca = 0x%x,", srca);
14381                           printf ("  srcb = 0x%x\n", srcb);
14382                         }
14383                       SYNTAX("mul       %2, %1, %0");
14384 #line 611 "rx-decode.opc"
14385                       ID(mul); DR(rdst); SR(srcb); S2R(srca); F_____;
14386
14387                     /*----------------------------------------------------------------------*/
14388                     /* EMUL                                                                     */
14389
14390                     }
14391                   break;
14392               }
14393             break;
14394           case 0x31:
14395               GETBYTE ();
14396               switch (op[2] & 0x00)
14397               {
14398                 case 0x00:
14399                   goto op_semantics_100;
14400                   break;
14401               }
14402             break;
14403           case 0x32:
14404               GETBYTE ();
14405               switch (op[2] & 0x00)
14406               {
14407                 case 0x00:
14408                   goto op_semantics_100;
14409                   break;
14410               }
14411             break;
14412           case 0x33:
14413               GETBYTE ();
14414               switch (op[2] & 0x00)
14415               {
14416                 case 0x00:
14417                   goto op_semantics_100;
14418                   break;
14419               }
14420             break;
14421           case 0x34:
14422               GETBYTE ();
14423               switch (op[2] & 0x00)
14424               {
14425                 case 0x00:
14426                   goto op_semantics_100;
14427                   break;
14428               }
14429             break;
14430           case 0x35:
14431               GETBYTE ();
14432               switch (op[2] & 0x00)
14433               {
14434                 case 0x00:
14435                   goto op_semantics_100;
14436                   break;
14437               }
14438             break;
14439           case 0x36:
14440               GETBYTE ();
14441               switch (op[2] & 0x00)
14442               {
14443                 case 0x00:
14444                   goto op_semantics_100;
14445                   break;
14446               }
14447             break;
14448           case 0x37:
14449               GETBYTE ();
14450               switch (op[2] & 0x00)
14451               {
14452                 case 0x00:
14453                   goto op_semantics_100;
14454                   break;
14455               }
14456             break;
14457           case 0x38:
14458               GETBYTE ();
14459               switch (op[2] & 0x00)
14460               {
14461                 case 0x00:
14462                   goto op_semantics_100;
14463                   break;
14464               }
14465             break;
14466           case 0x39:
14467               GETBYTE ();
14468               switch (op[2] & 0x00)
14469               {
14470                 case 0x00:
14471                   goto op_semantics_100;
14472                   break;
14473               }
14474             break;
14475           case 0x3a:
14476               GETBYTE ();
14477               switch (op[2] & 0x00)
14478               {
14479                 case 0x00:
14480                   goto op_semantics_100;
14481                   break;
14482               }
14483             break;
14484           case 0x3b:
14485               GETBYTE ();
14486               switch (op[2] & 0x00)
14487               {
14488                 case 0x00:
14489                   goto op_semantics_100;
14490                   break;
14491               }
14492             break;
14493           case 0x3c:
14494               GETBYTE ();
14495               switch (op[2] & 0x00)
14496               {
14497                 case 0x00:
14498                   goto op_semantics_100;
14499                   break;
14500               }
14501             break;
14502           case 0x3d:
14503               GETBYTE ();
14504               switch (op[2] & 0x00)
14505               {
14506                 case 0x00:
14507                   goto op_semantics_100;
14508                   break;
14509               }
14510             break;
14511           case 0x3e:
14512               GETBYTE ();
14513               switch (op[2] & 0x00)
14514               {
14515                 case 0x00:
14516                   goto op_semantics_100;
14517                   break;
14518               }
14519             break;
14520           case 0x3f:
14521               GETBYTE ();
14522               switch (op[2] & 0x00)
14523               {
14524                 case 0x00:
14525                   goto op_semantics_100;
14526                   break;
14527               }
14528             break;
14529           case 0x40:
14530               GETBYTE ();
14531               switch (op[2] & 0x00)
14532               {
14533                 case 0x00:
14534                   op_semantics_101:
14535                     {
14536                       /** 1111 1111 0100 rdst srca srcb and     %2, %1, %0 */
14537 #line 419 "rx-decode.opc"
14538                       int rdst AU = op[1] & 0x0f;
14539 #line 419 "rx-decode.opc"
14540                       int srca AU = (op[2] >> 4) & 0x0f;
14541 #line 419 "rx-decode.opc"
14542                       int srcb AU = op[2] & 0x0f;
14543                       if (trace)
14544                         {
14545                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
14546                                  "/** 1111 1111 0100 rdst srca srcb     and     %2, %1, %0 */",
14547                                  op[0], op[1], op[2]);
14548                           printf ("  rdst = 0x%x,", rdst);
14549                           printf ("  srca = 0x%x,", srca);
14550                           printf ("  srcb = 0x%x\n", srcb);
14551                         }
14552                       SYNTAX("and       %2, %1, %0");
14553 #line 419 "rx-decode.opc"
14554                       ID(and); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
14555
14556                     /*----------------------------------------------------------------------*/
14557                     /* OR                                                                       */
14558
14559                     }
14560                   break;
14561               }
14562             break;
14563           case 0x41:
14564               GETBYTE ();
14565               switch (op[2] & 0x00)
14566               {
14567                 case 0x00:
14568                   goto op_semantics_101;
14569                   break;
14570               }
14571             break;
14572           case 0x42:
14573               GETBYTE ();
14574               switch (op[2] & 0x00)
14575               {
14576                 case 0x00:
14577                   goto op_semantics_101;
14578                   break;
14579               }
14580             break;
14581           case 0x43:
14582               GETBYTE ();
14583               switch (op[2] & 0x00)
14584               {
14585                 case 0x00:
14586                   goto op_semantics_101;
14587                   break;
14588               }
14589             break;
14590           case 0x44:
14591               GETBYTE ();
14592               switch (op[2] & 0x00)
14593               {
14594                 case 0x00:
14595                   goto op_semantics_101;
14596                   break;
14597               }
14598             break;
14599           case 0x45:
14600               GETBYTE ();
14601               switch (op[2] & 0x00)
14602               {
14603                 case 0x00:
14604                   goto op_semantics_101;
14605                   break;
14606               }
14607             break;
14608           case 0x46:
14609               GETBYTE ();
14610               switch (op[2] & 0x00)
14611               {
14612                 case 0x00:
14613                   goto op_semantics_101;
14614                   break;
14615               }
14616             break;
14617           case 0x47:
14618               GETBYTE ();
14619               switch (op[2] & 0x00)
14620               {
14621                 case 0x00:
14622                   goto op_semantics_101;
14623                   break;
14624               }
14625             break;
14626           case 0x48:
14627               GETBYTE ();
14628               switch (op[2] & 0x00)
14629               {
14630                 case 0x00:
14631                   goto op_semantics_101;
14632                   break;
14633               }
14634             break;
14635           case 0x49:
14636               GETBYTE ();
14637               switch (op[2] & 0x00)
14638               {
14639                 case 0x00:
14640                   goto op_semantics_101;
14641                   break;
14642               }
14643             break;
14644           case 0x4a:
14645               GETBYTE ();
14646               switch (op[2] & 0x00)
14647               {
14648                 case 0x00:
14649                   goto op_semantics_101;
14650                   break;
14651               }
14652             break;
14653           case 0x4b:
14654               GETBYTE ();
14655               switch (op[2] & 0x00)
14656               {
14657                 case 0x00:
14658                   goto op_semantics_101;
14659                   break;
14660               }
14661             break;
14662           case 0x4c:
14663               GETBYTE ();
14664               switch (op[2] & 0x00)
14665               {
14666                 case 0x00:
14667                   goto op_semantics_101;
14668                   break;
14669               }
14670             break;
14671           case 0x4d:
14672               GETBYTE ();
14673               switch (op[2] & 0x00)
14674               {
14675                 case 0x00:
14676                   goto op_semantics_101;
14677                   break;
14678               }
14679             break;
14680           case 0x4e:
14681               GETBYTE ();
14682               switch (op[2] & 0x00)
14683               {
14684                 case 0x00:
14685                   goto op_semantics_101;
14686                   break;
14687               }
14688             break;
14689           case 0x4f:
14690               GETBYTE ();
14691               switch (op[2] & 0x00)
14692               {
14693                 case 0x00:
14694                   goto op_semantics_101;
14695                   break;
14696               }
14697             break;
14698           case 0x50:
14699               GETBYTE ();
14700               switch (op[2] & 0x00)
14701               {
14702                 case 0x00:
14703                   op_semantics_102:
14704                     {
14705                       /** 1111 1111 0101 rdst srca srcb or      %2, %1, %0 */
14706 #line 437 "rx-decode.opc"
14707                       int rdst AU = op[1] & 0x0f;
14708 #line 437 "rx-decode.opc"
14709                       int srca AU = (op[2] >> 4) & 0x0f;
14710 #line 437 "rx-decode.opc"
14711                       int srcb AU = op[2] & 0x0f;
14712                       if (trace)
14713                         {
14714                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
14715                                  "/** 1111 1111 0101 rdst srca srcb     or      %2, %1, %0 */",
14716                                  op[0], op[1], op[2]);
14717                           printf ("  rdst = 0x%x,", rdst);
14718                           printf ("  srca = 0x%x,", srca);
14719                           printf ("  srcb = 0x%x\n", srcb);
14720                         }
14721                       SYNTAX("or        %2, %1, %0");
14722 #line 437 "rx-decode.opc"
14723                       ID(or); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
14724
14725                     /*----------------------------------------------------------------------*/
14726                     /* XOR                                                                      */
14727
14728                     }
14729                   break;
14730               }
14731             break;
14732           case 0x51:
14733               GETBYTE ();
14734               switch (op[2] & 0x00)
14735               {
14736                 case 0x00:
14737                   goto op_semantics_102;
14738                   break;
14739               }
14740             break;
14741           case 0x52:
14742               GETBYTE ();
14743               switch (op[2] & 0x00)
14744               {
14745                 case 0x00:
14746                   goto op_semantics_102;
14747                   break;
14748               }
14749             break;
14750           case 0x53:
14751               GETBYTE ();
14752               switch (op[2] & 0x00)
14753               {
14754                 case 0x00:
14755                   goto op_semantics_102;
14756                   break;
14757               }
14758             break;
14759           case 0x54:
14760               GETBYTE ();
14761               switch (op[2] & 0x00)
14762               {
14763                 case 0x00:
14764                   goto op_semantics_102;
14765                   break;
14766               }
14767             break;
14768           case 0x55:
14769               GETBYTE ();
14770               switch (op[2] & 0x00)
14771               {
14772                 case 0x00:
14773                   goto op_semantics_102;
14774                   break;
14775               }
14776             break;
14777           case 0x56:
14778               GETBYTE ();
14779               switch (op[2] & 0x00)
14780               {
14781                 case 0x00:
14782                   goto op_semantics_102;
14783                   break;
14784               }
14785             break;
14786           case 0x57:
14787               GETBYTE ();
14788               switch (op[2] & 0x00)
14789               {
14790                 case 0x00:
14791                   goto op_semantics_102;
14792                   break;
14793               }
14794             break;
14795           case 0x58:
14796               GETBYTE ();
14797               switch (op[2] & 0x00)
14798               {
14799                 case 0x00:
14800                   goto op_semantics_102;
14801                   break;
14802               }
14803             break;
14804           case 0x59:
14805               GETBYTE ();
14806               switch (op[2] & 0x00)
14807               {
14808                 case 0x00:
14809                   goto op_semantics_102;
14810                   break;
14811               }
14812             break;
14813           case 0x5a:
14814               GETBYTE ();
14815               switch (op[2] & 0x00)
14816               {
14817                 case 0x00:
14818                   goto op_semantics_102;
14819                   break;
14820               }
14821             break;
14822           case 0x5b:
14823               GETBYTE ();
14824               switch (op[2] & 0x00)
14825               {
14826                 case 0x00:
14827                   goto op_semantics_102;
14828                   break;
14829               }
14830             break;
14831           case 0x5c:
14832               GETBYTE ();
14833               switch (op[2] & 0x00)
14834               {
14835                 case 0x00:
14836                   goto op_semantics_102;
14837                   break;
14838               }
14839             break;
14840           case 0x5d:
14841               GETBYTE ();
14842               switch (op[2] & 0x00)
14843               {
14844                 case 0x00:
14845                   goto op_semantics_102;
14846                   break;
14847               }
14848             break;
14849           case 0x5e:
14850               GETBYTE ();
14851               switch (op[2] & 0x00)
14852               {
14853                 case 0x00:
14854                   goto op_semantics_102;
14855                   break;
14856               }
14857             break;
14858           case 0x5f:
14859               GETBYTE ();
14860               switch (op[2] & 0x00)
14861               {
14862                 case 0x00:
14863                   goto op_semantics_102;
14864                   break;
14865               }
14866             break;
14867           default: UNSUPPORTED(); break;
14868         }
14869       break;
14870     default: UNSUPPORTED(); break;
14871   }
14872 #line 1002 "rx-decode.opc"
14873
14874   return rx->n_bytes;
14875 }