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 976 "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 979 "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 982 "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 949 "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 949 "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 900 "rx-decode.opc"
4917                 int b AU = op[0] & 0x01;
4918 #line 900 "rx-decode.opc"
4919                 int ittt AU = (op[1] >> 4) & 0x0f;
4920 #line 900 "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 900 "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 910 "rx-decode.opc"
4958                 int b AU = op[0] & 0x01;
4959 #line 910 "rx-decode.opc"
4960                 int ittt AU = (op[1] >> 4) & 0x0f;
4961 #line 910 "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 910 "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 920 "rx-decode.opc"
4999                 int b AU = op[0] & 0x01;
5000 #line 920 "rx-decode.opc"
5001                 int ittt AU = (op[1] >> 4) & 0x0f;
5002 #line 920 "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 920 "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 955 "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 955 "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 952 "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 952 "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 970 "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 973 "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 985 "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 946 "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 946 "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 943 "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 943 "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 (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 904 "rx-decode.opc"
6822                 int sd AU = op[0] & 0x03;
6823 #line 904 "rx-decode.opc"
6824                 int rdst AU = (op[1] >> 4) & 0x0f;
6825 #line 904 "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 904 "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 914 "rx-decode.opc"
6890                 int sd AU = op[0] & 0x03;
6891 #line 914 "rx-decode.opc"
6892                 int rdst AU = (op[1] >> 4) & 0x0f;
6893 #line 914 "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 914 "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
7821                     }
7822                   break;
7823               }
7824             break;
7825           case 0x61:
7826               GETBYTE ();
7827               switch (op[2] & 0x00)
7828               {
7829                 case 0x00:
7830                   goto op_semantics_57;
7831                   break;
7832               }
7833             break;
7834           case 0x62:
7835               GETBYTE ();
7836               switch (op[2] & 0x00)
7837               {
7838                 case 0x00:
7839                   goto op_semantics_57;
7840                   break;
7841               }
7842             break;
7843           case 0x63:
7844               GETBYTE ();
7845               switch (op[2] & 0x00)
7846               {
7847                 case 0x00:
7848                   goto op_semantics_57;
7849                   break;
7850               }
7851             break;
7852           case 0x64:
7853               GETBYTE ();
7854               switch (op[2] & 0x00)
7855               {
7856                 case 0x00:
7857                   op_semantics_58:
7858                     {
7859                       /** 1111 1100 0110 01sd rdst rsrc bclr    %1, %0%S0 */
7860 #line 907 "rx-decode.opc"
7861                       int sd AU = op[1] & 0x03;
7862 #line 907 "rx-decode.opc"
7863                       int rdst AU = (op[2] >> 4) & 0x0f;
7864 #line 907 "rx-decode.opc"
7865                       int rsrc AU = op[2] & 0x0f;
7866                       if (trace)
7867                         {
7868                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7869                                  "/** 1111 1100 0110 01sd rdst rsrc     bclr    %1, %0%S0 */",
7870                                  op[0], op[1], op[2]);
7871                           printf ("  sd = 0x%x,", sd);
7872                           printf ("  rdst = 0x%x,", rdst);
7873                           printf ("  rsrc = 0x%x\n", rsrc);
7874                         }
7875                       SYNTAX("bclr      %1, %0%S0");
7876 #line 907 "rx-decode.opc"
7877                       ID(bclr); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____;
7878
7879                     }
7880                   break;
7881               }
7882             break;
7883           case 0x65:
7884               GETBYTE ();
7885               switch (op[2] & 0x00)
7886               {
7887                 case 0x00:
7888                   goto op_semantics_58;
7889                   break;
7890               }
7891             break;
7892           case 0x66:
7893               GETBYTE ();
7894               switch (op[2] & 0x00)
7895               {
7896                 case 0x00:
7897                   goto op_semantics_58;
7898                   break;
7899               }
7900             break;
7901           case 0x67:
7902               GETBYTE ();
7903               switch (op[2] & 0x00)
7904               {
7905                 case 0x00:
7906                   goto op_semantics_58;
7907                   break;
7908               }
7909             break;
7910           case 0x68:
7911               GETBYTE ();
7912               switch (op[2] & 0x00)
7913               {
7914                 case 0x00:
7915                   op_semantics_59:
7916                     {
7917                       /** 1111 1100 0110 10sd rdst rsrc btst    %2, %1%S1 */
7918 #line 917 "rx-decode.opc"
7919                       int sd AU = op[1] & 0x03;
7920 #line 917 "rx-decode.opc"
7921                       int rdst AU = (op[2] >> 4) & 0x0f;
7922 #line 917 "rx-decode.opc"
7923                       int rsrc AU = op[2] & 0x0f;
7924                       if (trace)
7925                         {
7926                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7927                                  "/** 1111 1100 0110 10sd rdst rsrc     btst    %2, %1%S1 */",
7928                                  op[0], op[1], op[2]);
7929                           printf ("  sd = 0x%x,", sd);
7930                           printf ("  rdst = 0x%x,", rdst);
7931                           printf ("  rsrc = 0x%x\n", rsrc);
7932                         }
7933                       SYNTAX("btst      %2, %1%S1");
7934 #line 917 "rx-decode.opc"
7935                       ID(btst); BWL(BSIZE); S2R(rsrc); SD(sd, rdst, BSIZE); F___ZC;
7936
7937                     }
7938                   break;
7939               }
7940             break;
7941           case 0x69:
7942               GETBYTE ();
7943               switch (op[2] & 0x00)
7944               {
7945                 case 0x00:
7946                   goto op_semantics_59;
7947                   break;
7948               }
7949             break;
7950           case 0x6a:
7951               GETBYTE ();
7952               switch (op[2] & 0x00)
7953               {
7954                 case 0x00:
7955                   goto op_semantics_59;
7956                   break;
7957               }
7958             break;
7959           case 0x6b:
7960               GETBYTE ();
7961               switch (op[2] & 0x00)
7962               {
7963                 case 0x00:
7964                   goto op_semantics_59;
7965                   break;
7966               }
7967             break;
7968           case 0x6c:
7969               GETBYTE ();
7970               switch (op[2] & 0x00)
7971               {
7972                 case 0x00:
7973                   op_semantics_60:
7974                     {
7975                       /** 1111 1100 0110 11sd rdst rsrc bnot    %1, %0%S0 */
7976 #line 927 "rx-decode.opc"
7977                       int sd AU = op[1] & 0x03;
7978 #line 927 "rx-decode.opc"
7979                       int rdst AU = (op[2] >> 4) & 0x0f;
7980 #line 927 "rx-decode.opc"
7981                       int rsrc AU = op[2] & 0x0f;
7982                       if (trace)
7983                         {
7984                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
7985                                  "/** 1111 1100 0110 11sd rdst rsrc     bnot    %1, %0%S0 */",
7986                                  op[0], op[1], op[2]);
7987                           printf ("  sd = 0x%x,", sd);
7988                           printf ("  rdst = 0x%x,", rdst);
7989                           printf ("  rsrc = 0x%x\n", rsrc);
7990                         }
7991                       SYNTAX("bnot      %1, %0%S0");
7992 #line 927 "rx-decode.opc"
7993                       ID(bnot); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE);
7994
7995                     }
7996                   break;
7997               }
7998             break;
7999           case 0x6d:
8000               GETBYTE ();
8001               switch (op[2] & 0x00)
8002               {
8003                 case 0x00:
8004                   goto op_semantics_60;
8005                   break;
8006               }
8007             break;
8008           case 0x6e:
8009               GETBYTE ();
8010               switch (op[2] & 0x00)
8011               {
8012                 case 0x00:
8013                   goto op_semantics_60;
8014                   break;
8015               }
8016             break;
8017           case 0x6f:
8018               GETBYTE ();
8019               switch (op[2] & 0x00)
8020               {
8021                 case 0x00:
8022                   goto op_semantics_60;
8023                   break;
8024               }
8025             break;
8026           case 0x80:
8027               GETBYTE ();
8028               switch (op[2] & 0x00)
8029               {
8030                 case 0x00:
8031                   op_semantics_61:
8032                     {
8033                       /** 1111 1100 1000 00sd rsrc rdst fsub    %1%S1, %0 */
8034 #line 864 "rx-decode.opc"
8035                       int sd AU = op[1] & 0x03;
8036 #line 864 "rx-decode.opc"
8037                       int rsrc AU = (op[2] >> 4) & 0x0f;
8038 #line 864 "rx-decode.opc"
8039                       int rdst AU = op[2] & 0x0f;
8040                       if (trace)
8041                         {
8042                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8043                                  "/** 1111 1100 1000 00sd rsrc rdst     fsub    %1%S1, %0 */",
8044                                  op[0], op[1], op[2]);
8045                           printf ("  sd = 0x%x,", sd);
8046                           printf ("  rsrc = 0x%x,", rsrc);
8047                           printf ("  rdst = 0x%x\n", rdst);
8048                         }
8049                       SYNTAX("fsub      %1%S1, %0");
8050 #line 864 "rx-decode.opc"
8051                       ID(fsub); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8052
8053                     }
8054                   break;
8055               }
8056             break;
8057           case 0x81:
8058               GETBYTE ();
8059               switch (op[2] & 0x00)
8060               {
8061                 case 0x00:
8062                   goto op_semantics_61;
8063                   break;
8064               }
8065             break;
8066           case 0x82:
8067               GETBYTE ();
8068               switch (op[2] & 0x00)
8069               {
8070                 case 0x00:
8071                   goto op_semantics_61;
8072                   break;
8073               }
8074             break;
8075           case 0x83:
8076               GETBYTE ();
8077               switch (op[2] & 0x00)
8078               {
8079                 case 0x00:
8080                   goto op_semantics_61;
8081                   break;
8082               }
8083             break;
8084           case 0x84:
8085               GETBYTE ();
8086               switch (op[2] & 0x00)
8087               {
8088                 case 0x00:
8089                   op_semantics_62:
8090                     {
8091                       /** 1111 1100 1000 01sd rsrc rdst fcmp    %1%S1, %0 */
8092 #line 858 "rx-decode.opc"
8093                       int sd AU = op[1] & 0x03;
8094 #line 858 "rx-decode.opc"
8095                       int rsrc AU = (op[2] >> 4) & 0x0f;
8096 #line 858 "rx-decode.opc"
8097                       int rdst AU = op[2] & 0x0f;
8098                       if (trace)
8099                         {
8100                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8101                                  "/** 1111 1100 1000 01sd rsrc rdst     fcmp    %1%S1, %0 */",
8102                                  op[0], op[1], op[2]);
8103                           printf ("  sd = 0x%x,", sd);
8104                           printf ("  rsrc = 0x%x,", rsrc);
8105                           printf ("  rdst = 0x%x\n", rdst);
8106                         }
8107                       SYNTAX("fcmp      %1%S1, %0");
8108 #line 858 "rx-decode.opc"
8109                       ID(fcmp); DR(rdst); SD(sd, rsrc, LSIZE); F_OSZ_;
8110
8111                     }
8112                   break;
8113               }
8114             break;
8115           case 0x85:
8116               GETBYTE ();
8117               switch (op[2] & 0x00)
8118               {
8119                 case 0x00:
8120                   goto op_semantics_62;
8121                   break;
8122               }
8123             break;
8124           case 0x86:
8125               GETBYTE ();
8126               switch (op[2] & 0x00)
8127               {
8128                 case 0x00:
8129                   goto op_semantics_62;
8130                   break;
8131               }
8132             break;
8133           case 0x87:
8134               GETBYTE ();
8135               switch (op[2] & 0x00)
8136               {
8137                 case 0x00:
8138                   goto op_semantics_62;
8139                   break;
8140               }
8141             break;
8142           case 0x88:
8143               GETBYTE ();
8144               switch (op[2] & 0x00)
8145               {
8146                 case 0x00:
8147                   op_semantics_63:
8148                     {
8149                       /** 1111 1100 1000 10sd rsrc rdst fadd    %1%S1, %0 */
8150 #line 852 "rx-decode.opc"
8151                       int sd AU = op[1] & 0x03;
8152 #line 852 "rx-decode.opc"
8153                       int rsrc AU = (op[2] >> 4) & 0x0f;
8154 #line 852 "rx-decode.opc"
8155                       int rdst AU = op[2] & 0x0f;
8156                       if (trace)
8157                         {
8158                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8159                                  "/** 1111 1100 1000 10sd rsrc rdst     fadd    %1%S1, %0 */",
8160                                  op[0], op[1], op[2]);
8161                           printf ("  sd = 0x%x,", sd);
8162                           printf ("  rsrc = 0x%x,", rsrc);
8163                           printf ("  rdst = 0x%x\n", rdst);
8164                         }
8165                       SYNTAX("fadd      %1%S1, %0");
8166 #line 852 "rx-decode.opc"
8167                       ID(fadd); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8168
8169                     }
8170                   break;
8171               }
8172             break;
8173           case 0x89:
8174               GETBYTE ();
8175               switch (op[2] & 0x00)
8176               {
8177                 case 0x00:
8178                   goto op_semantics_63;
8179                   break;
8180               }
8181             break;
8182           case 0x8a:
8183               GETBYTE ();
8184               switch (op[2] & 0x00)
8185               {
8186                 case 0x00:
8187                   goto op_semantics_63;
8188                   break;
8189               }
8190             break;
8191           case 0x8b:
8192               GETBYTE ();
8193               switch (op[2] & 0x00)
8194               {
8195                 case 0x00:
8196                   goto op_semantics_63;
8197                   break;
8198               }
8199             break;
8200           case 0x8c:
8201               GETBYTE ();
8202               switch (op[2] & 0x00)
8203               {
8204                 case 0x00:
8205                   op_semantics_64:
8206                     {
8207                       /** 1111 1100 1000 11sd rsrc rdst fmul    %1%S1, %0 */
8208 #line 873 "rx-decode.opc"
8209                       int sd AU = op[1] & 0x03;
8210 #line 873 "rx-decode.opc"
8211                       int rsrc AU = (op[2] >> 4) & 0x0f;
8212 #line 873 "rx-decode.opc"
8213                       int rdst AU = op[2] & 0x0f;
8214                       if (trace)
8215                         {
8216                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8217                                  "/** 1111 1100 1000 11sd rsrc rdst     fmul    %1%S1, %0 */",
8218                                  op[0], op[1], op[2]);
8219                           printf ("  sd = 0x%x,", sd);
8220                           printf ("  rsrc = 0x%x,", rsrc);
8221                           printf ("  rdst = 0x%x\n", rdst);
8222                         }
8223                       SYNTAX("fmul      %1%S1, %0");
8224 #line 873 "rx-decode.opc"
8225                       ID(fmul); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8226
8227                     }
8228                   break;
8229               }
8230             break;
8231           case 0x8d:
8232               GETBYTE ();
8233               switch (op[2] & 0x00)
8234               {
8235                 case 0x00:
8236                   goto op_semantics_64;
8237                   break;
8238               }
8239             break;
8240           case 0x8e:
8241               GETBYTE ();
8242               switch (op[2] & 0x00)
8243               {
8244                 case 0x00:
8245                   goto op_semantics_64;
8246                   break;
8247               }
8248             break;
8249           case 0x8f:
8250               GETBYTE ();
8251               switch (op[2] & 0x00)
8252               {
8253                 case 0x00:
8254                   goto op_semantics_64;
8255                   break;
8256               }
8257             break;
8258           case 0x90:
8259               GETBYTE ();
8260               switch (op[2] & 0x00)
8261               {
8262                 case 0x00:
8263                   op_semantics_65:
8264                     {
8265                       /** 1111 1100 1001 00sd rsrc rdst fdiv    %1%S1, %0 */
8266 #line 879 "rx-decode.opc"
8267                       int sd AU = op[1] & 0x03;
8268 #line 879 "rx-decode.opc"
8269                       int rsrc AU = (op[2] >> 4) & 0x0f;
8270 #line 879 "rx-decode.opc"
8271                       int rdst AU = op[2] & 0x0f;
8272                       if (trace)
8273                         {
8274                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8275                                  "/** 1111 1100 1001 00sd rsrc rdst     fdiv    %1%S1, %0 */",
8276                                  op[0], op[1], op[2]);
8277                           printf ("  sd = 0x%x,", sd);
8278                           printf ("  rsrc = 0x%x,", rsrc);
8279                           printf ("  rdst = 0x%x\n", rdst);
8280                         }
8281                       SYNTAX("fdiv      %1%S1, %0");
8282 #line 879 "rx-decode.opc"
8283                       ID(fdiv); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8284
8285                     }
8286                   break;
8287               }
8288             break;
8289           case 0x91:
8290               GETBYTE ();
8291               switch (op[2] & 0x00)
8292               {
8293                 case 0x00:
8294                   goto op_semantics_65;
8295                   break;
8296               }
8297             break;
8298           case 0x92:
8299               GETBYTE ();
8300               switch (op[2] & 0x00)
8301               {
8302                 case 0x00:
8303                   goto op_semantics_65;
8304                   break;
8305               }
8306             break;
8307           case 0x93:
8308               GETBYTE ();
8309               switch (op[2] & 0x00)
8310               {
8311                 case 0x00:
8312                   goto op_semantics_65;
8313                   break;
8314               }
8315             break;
8316           case 0x94:
8317               GETBYTE ();
8318               switch (op[2] & 0x00)
8319               {
8320                 case 0x00:
8321                   op_semantics_66:
8322                     {
8323                       /** 1111 1100 1001 01sd rsrc rdst ftoi    %1%S1, %0 */
8324 #line 867 "rx-decode.opc"
8325                       int sd AU = op[1] & 0x03;
8326 #line 867 "rx-decode.opc"
8327                       int rsrc AU = (op[2] >> 4) & 0x0f;
8328 #line 867 "rx-decode.opc"
8329                       int rdst AU = op[2] & 0x0f;
8330                       if (trace)
8331                         {
8332                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8333                                  "/** 1111 1100 1001 01sd rsrc rdst     ftoi    %1%S1, %0 */",
8334                                  op[0], op[1], op[2]);
8335                           printf ("  sd = 0x%x,", sd);
8336                           printf ("  rsrc = 0x%x,", rsrc);
8337                           printf ("  rdst = 0x%x\n", rdst);
8338                         }
8339                       SYNTAX("ftoi      %1%S1, %0");
8340 #line 867 "rx-decode.opc"
8341                       ID(ftoi); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8342
8343                     }
8344                   break;
8345               }
8346             break;
8347           case 0x95:
8348               GETBYTE ();
8349               switch (op[2] & 0x00)
8350               {
8351                 case 0x00:
8352                   goto op_semantics_66;
8353                   break;
8354               }
8355             break;
8356           case 0x96:
8357               GETBYTE ();
8358               switch (op[2] & 0x00)
8359               {
8360                 case 0x00:
8361                   goto op_semantics_66;
8362                   break;
8363               }
8364             break;
8365           case 0x97:
8366               GETBYTE ();
8367               switch (op[2] & 0x00)
8368               {
8369                 case 0x00:
8370                   goto op_semantics_66;
8371                   break;
8372               }
8373             break;
8374           case 0x98:
8375               GETBYTE ();
8376               switch (op[2] & 0x00)
8377               {
8378                 case 0x00:
8379                   op_semantics_67:
8380                     {
8381                       /** 1111 1100 1001 10sd rsrc rdst round   %1%S1, %0 */
8382 #line 882 "rx-decode.opc"
8383                       int sd AU = op[1] & 0x03;
8384 #line 882 "rx-decode.opc"
8385                       int rsrc AU = (op[2] >> 4) & 0x0f;
8386 #line 882 "rx-decode.opc"
8387                       int rdst AU = op[2] & 0x0f;
8388                       if (trace)
8389                         {
8390                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8391                                  "/** 1111 1100 1001 10sd rsrc rdst     round   %1%S1, %0 */",
8392                                  op[0], op[1], op[2]);
8393                           printf ("  sd = 0x%x,", sd);
8394                           printf ("  rsrc = 0x%x,", rsrc);
8395                           printf ("  rdst = 0x%x\n", rdst);
8396                         }
8397                       SYNTAX("round     %1%S1, %0");
8398 #line 882 "rx-decode.opc"
8399                       ID(round); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8400
8401                     }
8402                   break;
8403               }
8404             break;
8405           case 0x99:
8406               GETBYTE ();
8407               switch (op[2] & 0x00)
8408               {
8409                 case 0x00:
8410                   goto op_semantics_67;
8411                   break;
8412               }
8413             break;
8414           case 0x9a:
8415               GETBYTE ();
8416               switch (op[2] & 0x00)
8417               {
8418                 case 0x00:
8419                   goto op_semantics_67;
8420                   break;
8421               }
8422             break;
8423           case 0x9b:
8424               GETBYTE ();
8425               switch (op[2] & 0x00)
8426               {
8427                 case 0x00:
8428                   goto op_semantics_67;
8429                   break;
8430               }
8431             break;
8432           case 0xd0:
8433               GETBYTE ();
8434               switch (op[2] & 0x00)
8435               {
8436                 case 0x00:
8437                   op_semantics_68:
8438                     {
8439                       /** 1111 1100 1101 sz sd rdst cond        sc%1%s  %0 */
8440 #line 991 "rx-decode.opc"
8441                       int sz AU = (op[1] >> 2) & 0x03;
8442 #line 991 "rx-decode.opc"
8443                       int sd AU = op[1] & 0x03;
8444 #line 991 "rx-decode.opc"
8445                       int rdst AU = (op[2] >> 4) & 0x0f;
8446 #line 991 "rx-decode.opc"
8447                       int cond AU = op[2] & 0x0f;
8448                       if (trace)
8449                         {
8450                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8451                                  "/** 1111 1100 1101 sz sd rdst cond    sc%1%s  %0 */",
8452                                  op[0], op[1], op[2]);
8453                           printf ("  sz = 0x%x,", sz);
8454                           printf ("  sd = 0x%x,", sd);
8455                           printf ("  rdst = 0x%x,", rdst);
8456                           printf ("  cond = 0x%x\n", cond);
8457                         }
8458                       SYNTAX("sc%1%s    %0");
8459 #line 991 "rx-decode.opc"
8460                       ID(sccnd); BWL(sz); DD (sd, rdst, sz); Scc(cond);
8461
8462                     }
8463                   break;
8464               }
8465             break;
8466           case 0xd1:
8467               GETBYTE ();
8468               switch (op[2] & 0x00)
8469               {
8470                 case 0x00:
8471                   goto op_semantics_68;
8472                   break;
8473               }
8474             break;
8475           case 0xd2:
8476               GETBYTE ();
8477               switch (op[2] & 0x00)
8478               {
8479                 case 0x00:
8480                   goto op_semantics_68;
8481                   break;
8482               }
8483             break;
8484           case 0xd3:
8485               GETBYTE ();
8486               switch (op[2] & 0x00)
8487               {
8488                 case 0x00:
8489                   goto op_semantics_68;
8490                   break;
8491               }
8492             break;
8493           case 0xd4:
8494               GETBYTE ();
8495               switch (op[2] & 0x00)
8496               {
8497                 case 0x00:
8498                   goto op_semantics_68;
8499                   break;
8500               }
8501             break;
8502           case 0xd5:
8503               GETBYTE ();
8504               switch (op[2] & 0x00)
8505               {
8506                 case 0x00:
8507                   goto op_semantics_68;
8508                   break;
8509               }
8510             break;
8511           case 0xd6:
8512               GETBYTE ();
8513               switch (op[2] & 0x00)
8514               {
8515                 case 0x00:
8516                   goto op_semantics_68;
8517                   break;
8518               }
8519             break;
8520           case 0xd7:
8521               GETBYTE ();
8522               switch (op[2] & 0x00)
8523               {
8524                 case 0x00:
8525                   goto op_semantics_68;
8526                   break;
8527               }
8528             break;
8529           case 0xd8:
8530               GETBYTE ();
8531               switch (op[2] & 0x00)
8532               {
8533                 case 0x00:
8534                   goto op_semantics_68;
8535                   break;
8536               }
8537             break;
8538           case 0xd9:
8539               GETBYTE ();
8540               switch (op[2] & 0x00)
8541               {
8542                 case 0x00:
8543                   goto op_semantics_68;
8544                   break;
8545               }
8546             break;
8547           case 0xda:
8548               GETBYTE ();
8549               switch (op[2] & 0x00)
8550               {
8551                 case 0x00:
8552                   goto op_semantics_68;
8553                   break;
8554               }
8555             break;
8556           case 0xdb:
8557               GETBYTE ();
8558               switch (op[2] & 0x00)
8559               {
8560                 case 0x00:
8561                   goto op_semantics_68;
8562                   break;
8563               }
8564             break;
8565           case 0xe0:
8566               GETBYTE ();
8567               switch (op[2] & 0x0f)
8568               {
8569                 case 0x00:
8570                 case 0x01:
8571                 case 0x02:
8572                 case 0x03:
8573                 case 0x04:
8574                 case 0x05:
8575                 case 0x06:
8576                 case 0x07:
8577                 case 0x08:
8578                 case 0x09:
8579                 case 0x0a:
8580                 case 0x0b:
8581                 case 0x0c:
8582                 case 0x0d:
8583                 case 0x0e:
8584                   op_semantics_69:
8585                     {
8586                       /** 1111 1100 111bit sd rdst cond bm%2    #%1, %0%S0 */
8587 #line 934 "rx-decode.opc"
8588                       int bit AU = (op[1] >> 2) & 0x07;
8589 #line 934 "rx-decode.opc"
8590                       int sd AU = op[1] & 0x03;
8591 #line 934 "rx-decode.opc"
8592                       int rdst AU = (op[2] >> 4) & 0x0f;
8593 #line 934 "rx-decode.opc"
8594                       int cond AU = op[2] & 0x0f;
8595                       if (trace)
8596                         {
8597                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8598                                  "/** 1111 1100 111bit sd rdst cond     bm%2    #%1, %0%S0 */",
8599                                  op[0], op[1], op[2]);
8600                           printf ("  bit = 0x%x,", bit);
8601                           printf ("  sd = 0x%x,", sd);
8602                           printf ("  rdst = 0x%x,", rdst);
8603                           printf ("  cond = 0x%x\n", cond);
8604                         }
8605                       SYNTAX("bm%2      #%1, %0%S0");
8606 #line 934 "rx-decode.opc"
8607                       ID(bmcc); BWL(BSIZE); S2cc(cond); SC(bit); DD(sd, rdst, BSIZE);
8608
8609                     }
8610                   break;
8611                 case 0x0f:
8612                   op_semantics_70:
8613                     {
8614                       /** 1111 1100 111bit sd rdst 1111 bnot    #%1, %0%S0 */
8615 #line 924 "rx-decode.opc"
8616                       int bit AU = (op[1] >> 2) & 0x07;
8617 #line 924 "rx-decode.opc"
8618                       int sd AU = op[1] & 0x03;
8619 #line 924 "rx-decode.opc"
8620                       int rdst AU = (op[2] >> 4) & 0x0f;
8621                       if (trace)
8622                         {
8623                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
8624                                  "/** 1111 1100 111bit sd rdst 1111     bnot    #%1, %0%S0 */",
8625                                  op[0], op[1], op[2]);
8626                           printf ("  bit = 0x%x,", bit);
8627                           printf ("  sd = 0x%x,", sd);
8628                           printf ("  rdst = 0x%x\n", rdst);
8629                         }
8630                       SYNTAX("bnot      #%1, %0%S0");
8631 #line 924 "rx-decode.opc"
8632                       ID(bnot); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE);
8633
8634                     }
8635                   break;
8636               }
8637             break;
8638           case 0xe1:
8639               GETBYTE ();
8640               switch (op[2] & 0x0f)
8641               {
8642                 case 0x00:
8643                 case 0x01:
8644                 case 0x02:
8645                 case 0x03:
8646                 case 0x04:
8647                 case 0x05:
8648                 case 0x06:
8649                 case 0x07:
8650                 case 0x08:
8651                 case 0x09:
8652                 case 0x0a:
8653                 case 0x0b:
8654                 case 0x0c:
8655                 case 0x0d:
8656                 case 0x0e:
8657                   goto op_semantics_69;
8658                   break;
8659                 case 0x0f:
8660                   goto op_semantics_70;
8661                   break;
8662               }
8663             break;
8664           case 0xe2:
8665               GETBYTE ();
8666               switch (op[2] & 0x0f)
8667               {
8668                 case 0x00:
8669                 case 0x01:
8670                 case 0x02:
8671                 case 0x03:
8672                 case 0x04:
8673                 case 0x05:
8674                 case 0x06:
8675                 case 0x07:
8676                 case 0x08:
8677                 case 0x09:
8678                 case 0x0a:
8679                 case 0x0b:
8680                 case 0x0c:
8681                 case 0x0d:
8682                 case 0x0e:
8683                   goto op_semantics_69;
8684                   break;
8685                 case 0x0f:
8686                   goto op_semantics_70;
8687                   break;
8688               }
8689             break;
8690           case 0xe3:
8691               GETBYTE ();
8692               switch (op[2] & 0x0f)
8693               {
8694                 case 0x00:
8695                 case 0x01:
8696                 case 0x02:
8697                 case 0x03:
8698                 case 0x04:
8699                 case 0x05:
8700                 case 0x06:
8701                 case 0x07:
8702                 case 0x08:
8703                 case 0x09:
8704                 case 0x0a:
8705                 case 0x0b:
8706                 case 0x0c:
8707                 case 0x0d:
8708                 case 0x0e:
8709                   goto op_semantics_69;
8710                   break;
8711                 case 0x0f:
8712                   goto op_semantics_70;
8713                   break;
8714               }
8715             break;
8716           case 0xe4:
8717               GETBYTE ();
8718               switch (op[2] & 0x0f)
8719               {
8720                 case 0x00:
8721                 case 0x01:
8722                 case 0x02:
8723                 case 0x03:
8724                 case 0x04:
8725                 case 0x05:
8726                 case 0x06:
8727                 case 0x07:
8728                 case 0x08:
8729                 case 0x09:
8730                 case 0x0a:
8731                 case 0x0b:
8732                 case 0x0c:
8733                 case 0x0d:
8734                 case 0x0e:
8735                   goto op_semantics_69;
8736                   break;
8737                 case 0x0f:
8738                   goto op_semantics_70;
8739                   break;
8740               }
8741             break;
8742           case 0xe5:
8743               GETBYTE ();
8744               switch (op[2] & 0x0f)
8745               {
8746                 case 0x00:
8747                 case 0x01:
8748                 case 0x02:
8749                 case 0x03:
8750                 case 0x04:
8751                 case 0x05:
8752                 case 0x06:
8753                 case 0x07:
8754                 case 0x08:
8755                 case 0x09:
8756                 case 0x0a:
8757                 case 0x0b:
8758                 case 0x0c:
8759                 case 0x0d:
8760                 case 0x0e:
8761                   goto op_semantics_69;
8762                   break;
8763                 case 0x0f:
8764                   goto op_semantics_70;
8765                   break;
8766               }
8767             break;
8768           case 0xe6:
8769               GETBYTE ();
8770               switch (op[2] & 0x0f)
8771               {
8772                 case 0x00:
8773                 case 0x01:
8774                 case 0x02:
8775                 case 0x03:
8776                 case 0x04:
8777                 case 0x05:
8778                 case 0x06:
8779                 case 0x07:
8780                 case 0x08:
8781                 case 0x09:
8782                 case 0x0a:
8783                 case 0x0b:
8784                 case 0x0c:
8785                 case 0x0d:
8786                 case 0x0e:
8787                   goto op_semantics_69;
8788                   break;
8789                 case 0x0f:
8790                   goto op_semantics_70;
8791                   break;
8792               }
8793             break;
8794           case 0xe7:
8795               GETBYTE ();
8796               switch (op[2] & 0x0f)
8797               {
8798                 case 0x00:
8799                 case 0x01:
8800                 case 0x02:
8801                 case 0x03:
8802                 case 0x04:
8803                 case 0x05:
8804                 case 0x06:
8805                 case 0x07:
8806                 case 0x08:
8807                 case 0x09:
8808                 case 0x0a:
8809                 case 0x0b:
8810                 case 0x0c:
8811                 case 0x0d:
8812                 case 0x0e:
8813                   goto op_semantics_69;
8814                   break;
8815                 case 0x0f:
8816                   goto op_semantics_70;
8817                   break;
8818               }
8819             break;
8820           case 0xe8:
8821               GETBYTE ();
8822               switch (op[2] & 0x0f)
8823               {
8824                 case 0x00:
8825                 case 0x01:
8826                 case 0x02:
8827                 case 0x03:
8828                 case 0x04:
8829                 case 0x05:
8830                 case 0x06:
8831                 case 0x07:
8832                 case 0x08:
8833                 case 0x09:
8834                 case 0x0a:
8835                 case 0x0b:
8836                 case 0x0c:
8837                 case 0x0d:
8838                 case 0x0e:
8839                   goto op_semantics_69;
8840                   break;
8841                 case 0x0f:
8842                   goto op_semantics_70;
8843                   break;
8844               }
8845             break;
8846           case 0xe9:
8847               GETBYTE ();
8848               switch (op[2] & 0x0f)
8849               {
8850                 case 0x00:
8851                 case 0x01:
8852                 case 0x02:
8853                 case 0x03:
8854                 case 0x04:
8855                 case 0x05:
8856                 case 0x06:
8857                 case 0x07:
8858                 case 0x08:
8859                 case 0x09:
8860                 case 0x0a:
8861                 case 0x0b:
8862                 case 0x0c:
8863                 case 0x0d:
8864                 case 0x0e:
8865                   goto op_semantics_69;
8866                   break;
8867                 case 0x0f:
8868                   goto op_semantics_70;
8869                   break;
8870               }
8871             break;
8872           case 0xea:
8873               GETBYTE ();
8874               switch (op[2] & 0x0f)
8875               {
8876                 case 0x00:
8877                 case 0x01:
8878                 case 0x02:
8879                 case 0x03:
8880                 case 0x04:
8881                 case 0x05:
8882                 case 0x06:
8883                 case 0x07:
8884                 case 0x08:
8885                 case 0x09:
8886                 case 0x0a:
8887                 case 0x0b:
8888                 case 0x0c:
8889                 case 0x0d:
8890                 case 0x0e:
8891                   goto op_semantics_69;
8892                   break;
8893                 case 0x0f:
8894                   goto op_semantics_70;
8895                   break;
8896               }
8897             break;
8898           case 0xeb:
8899               GETBYTE ();
8900               switch (op[2] & 0x0f)
8901               {
8902                 case 0x00:
8903                 case 0x01:
8904                 case 0x02:
8905                 case 0x03:
8906                 case 0x04:
8907                 case 0x05:
8908                 case 0x06:
8909                 case 0x07:
8910                 case 0x08:
8911                 case 0x09:
8912                 case 0x0a:
8913                 case 0x0b:
8914                 case 0x0c:
8915                 case 0x0d:
8916                 case 0x0e:
8917                   goto op_semantics_69;
8918                   break;
8919                 case 0x0f:
8920                   goto op_semantics_70;
8921                   break;
8922               }
8923             break;
8924           case 0xec:
8925               GETBYTE ();
8926               switch (op[2] & 0x0f)
8927               {
8928                 case 0x00:
8929                 case 0x01:
8930                 case 0x02:
8931                 case 0x03:
8932                 case 0x04:
8933                 case 0x05:
8934                 case 0x06:
8935                 case 0x07:
8936                 case 0x08:
8937                 case 0x09:
8938                 case 0x0a:
8939                 case 0x0b:
8940                 case 0x0c:
8941                 case 0x0d:
8942                 case 0x0e:
8943                   goto op_semantics_69;
8944                   break;
8945                 case 0x0f:
8946                   goto op_semantics_70;
8947                   break;
8948               }
8949             break;
8950           case 0xed:
8951               GETBYTE ();
8952               switch (op[2] & 0x0f)
8953               {
8954                 case 0x00:
8955                 case 0x01:
8956                 case 0x02:
8957                 case 0x03:
8958                 case 0x04:
8959                 case 0x05:
8960                 case 0x06:
8961                 case 0x07:
8962                 case 0x08:
8963                 case 0x09:
8964                 case 0x0a:
8965                 case 0x0b:
8966                 case 0x0c:
8967                 case 0x0d:
8968                 case 0x0e:
8969                   goto op_semantics_69;
8970                   break;
8971                 case 0x0f:
8972                   goto op_semantics_70;
8973                   break;
8974               }
8975             break;
8976           case 0xee:
8977               GETBYTE ();
8978               switch (op[2] & 0x0f)
8979               {
8980                 case 0x00:
8981                 case 0x01:
8982                 case 0x02:
8983                 case 0x03:
8984                 case 0x04:
8985                 case 0x05:
8986                 case 0x06:
8987                 case 0x07:
8988                 case 0x08:
8989                 case 0x09:
8990                 case 0x0a:
8991                 case 0x0b:
8992                 case 0x0c:
8993                 case 0x0d:
8994                 case 0x0e:
8995                   goto op_semantics_69;
8996                   break;
8997                 case 0x0f:
8998                   goto op_semantics_70;
8999                   break;
9000               }
9001             break;
9002           case 0xef:
9003               GETBYTE ();
9004               switch (op[2] & 0x0f)
9005               {
9006                 case 0x00:
9007                 case 0x01:
9008                 case 0x02:
9009                 case 0x03:
9010                 case 0x04:
9011                 case 0x05:
9012                 case 0x06:
9013                 case 0x07:
9014                 case 0x08:
9015                 case 0x09:
9016                 case 0x0a:
9017                 case 0x0b:
9018                 case 0x0c:
9019                 case 0x0d:
9020                 case 0x0e:
9021                   goto op_semantics_69;
9022                   break;
9023                 case 0x0f:
9024                   goto op_semantics_70;
9025                   break;
9026               }
9027             break;
9028           case 0xf0:
9029               GETBYTE ();
9030               switch (op[2] & 0x0f)
9031               {
9032                 case 0x00:
9033                 case 0x01:
9034                 case 0x02:
9035                 case 0x03:
9036                 case 0x04:
9037                 case 0x05:
9038                 case 0x06:
9039                 case 0x07:
9040                 case 0x08:
9041                 case 0x09:
9042                 case 0x0a:
9043                 case 0x0b:
9044                 case 0x0c:
9045                 case 0x0d:
9046                 case 0x0e:
9047                   goto op_semantics_69;
9048                   break;
9049                 case 0x0f:
9050                   goto op_semantics_70;
9051                   break;
9052               }
9053             break;
9054           case 0xf1:
9055               GETBYTE ();
9056               switch (op[2] & 0x0f)
9057               {
9058                 case 0x00:
9059                 case 0x01:
9060                 case 0x02:
9061                 case 0x03:
9062                 case 0x04:
9063                 case 0x05:
9064                 case 0x06:
9065                 case 0x07:
9066                 case 0x08:
9067                 case 0x09:
9068                 case 0x0a:
9069                 case 0x0b:
9070                 case 0x0c:
9071                 case 0x0d:
9072                 case 0x0e:
9073                   goto op_semantics_69;
9074                   break;
9075                 case 0x0f:
9076                   goto op_semantics_70;
9077                   break;
9078               }
9079             break;
9080           case 0xf2:
9081               GETBYTE ();
9082               switch (op[2] & 0x0f)
9083               {
9084                 case 0x00:
9085                 case 0x01:
9086                 case 0x02:
9087                 case 0x03:
9088                 case 0x04:
9089                 case 0x05:
9090                 case 0x06:
9091                 case 0x07:
9092                 case 0x08:
9093                 case 0x09:
9094                 case 0x0a:
9095                 case 0x0b:
9096                 case 0x0c:
9097                 case 0x0d:
9098                 case 0x0e:
9099                   goto op_semantics_69;
9100                   break;
9101                 case 0x0f:
9102                   goto op_semantics_70;
9103                   break;
9104               }
9105             break;
9106           case 0xf3:
9107               GETBYTE ();
9108               switch (op[2] & 0x0f)
9109               {
9110                 case 0x00:
9111                 case 0x01:
9112                 case 0x02:
9113                 case 0x03:
9114                 case 0x04:
9115                 case 0x05:
9116                 case 0x06:
9117                 case 0x07:
9118                 case 0x08:
9119                 case 0x09:
9120                 case 0x0a:
9121                 case 0x0b:
9122                 case 0x0c:
9123                 case 0x0d:
9124                 case 0x0e:
9125                   goto op_semantics_69;
9126                   break;
9127                 case 0x0f:
9128                   goto op_semantics_70;
9129                   break;
9130               }
9131             break;
9132           case 0xf4:
9133               GETBYTE ();
9134               switch (op[2] & 0x0f)
9135               {
9136                 case 0x00:
9137                 case 0x01:
9138                 case 0x02:
9139                 case 0x03:
9140                 case 0x04:
9141                 case 0x05:
9142                 case 0x06:
9143                 case 0x07:
9144                 case 0x08:
9145                 case 0x09:
9146                 case 0x0a:
9147                 case 0x0b:
9148                 case 0x0c:
9149                 case 0x0d:
9150                 case 0x0e:
9151                   goto op_semantics_69;
9152                   break;
9153                 case 0x0f:
9154                   goto op_semantics_70;
9155                   break;
9156               }
9157             break;
9158           case 0xf5:
9159               GETBYTE ();
9160               switch (op[2] & 0x0f)
9161               {
9162                 case 0x00:
9163                 case 0x01:
9164                 case 0x02:
9165                 case 0x03:
9166                 case 0x04:
9167                 case 0x05:
9168                 case 0x06:
9169                 case 0x07:
9170                 case 0x08:
9171                 case 0x09:
9172                 case 0x0a:
9173                 case 0x0b:
9174                 case 0x0c:
9175                 case 0x0d:
9176                 case 0x0e:
9177                   goto op_semantics_69;
9178                   break;
9179                 case 0x0f:
9180                   goto op_semantics_70;
9181                   break;
9182               }
9183             break;
9184           case 0xf6:
9185               GETBYTE ();
9186               switch (op[2] & 0x0f)
9187               {
9188                 case 0x00:
9189                 case 0x01:
9190                 case 0x02:
9191                 case 0x03:
9192                 case 0x04:
9193                 case 0x05:
9194                 case 0x06:
9195                 case 0x07:
9196                 case 0x08:
9197                 case 0x09:
9198                 case 0x0a:
9199                 case 0x0b:
9200                 case 0x0c:
9201                 case 0x0d:
9202                 case 0x0e:
9203                   goto op_semantics_69;
9204                   break;
9205                 case 0x0f:
9206                   goto op_semantics_70;
9207                   break;
9208               }
9209             break;
9210           case 0xf7:
9211               GETBYTE ();
9212               switch (op[2] & 0x0f)
9213               {
9214                 case 0x00:
9215                 case 0x01:
9216                 case 0x02:
9217                 case 0x03:
9218                 case 0x04:
9219                 case 0x05:
9220                 case 0x06:
9221                 case 0x07:
9222                 case 0x08:
9223                 case 0x09:
9224                 case 0x0a:
9225                 case 0x0b:
9226                 case 0x0c:
9227                 case 0x0d:
9228                 case 0x0e:
9229                   goto op_semantics_69;
9230                   break;
9231                 case 0x0f:
9232                   goto op_semantics_70;
9233                   break;
9234               }
9235             break;
9236           case 0xf8:
9237               GETBYTE ();
9238               switch (op[2] & 0x0f)
9239               {
9240                 case 0x00:
9241                 case 0x01:
9242                 case 0x02:
9243                 case 0x03:
9244                 case 0x04:
9245                 case 0x05:
9246                 case 0x06:
9247                 case 0x07:
9248                 case 0x08:
9249                 case 0x09:
9250                 case 0x0a:
9251                 case 0x0b:
9252                 case 0x0c:
9253                 case 0x0d:
9254                 case 0x0e:
9255                   goto op_semantics_69;
9256                   break;
9257                 case 0x0f:
9258                   goto op_semantics_70;
9259                   break;
9260               }
9261             break;
9262           case 0xf9:
9263               GETBYTE ();
9264               switch (op[2] & 0x0f)
9265               {
9266                 case 0x00:
9267                 case 0x01:
9268                 case 0x02:
9269                 case 0x03:
9270                 case 0x04:
9271                 case 0x05:
9272                 case 0x06:
9273                 case 0x07:
9274                 case 0x08:
9275                 case 0x09:
9276                 case 0x0a:
9277                 case 0x0b:
9278                 case 0x0c:
9279                 case 0x0d:
9280                 case 0x0e:
9281                   goto op_semantics_69;
9282                   break;
9283                 case 0x0f:
9284                   goto op_semantics_70;
9285                   break;
9286               }
9287             break;
9288           case 0xfa:
9289               GETBYTE ();
9290               switch (op[2] & 0x0f)
9291               {
9292                 case 0x00:
9293                 case 0x01:
9294                 case 0x02:
9295                 case 0x03:
9296                 case 0x04:
9297                 case 0x05:
9298                 case 0x06:
9299                 case 0x07:
9300                 case 0x08:
9301                 case 0x09:
9302                 case 0x0a:
9303                 case 0x0b:
9304                 case 0x0c:
9305                 case 0x0d:
9306                 case 0x0e:
9307                   goto op_semantics_69;
9308                   break;
9309                 case 0x0f:
9310                   goto op_semantics_70;
9311                   break;
9312               }
9313             break;
9314           case 0xfb:
9315               GETBYTE ();
9316               switch (op[2] & 0x0f)
9317               {
9318                 case 0x00:
9319                 case 0x01:
9320                 case 0x02:
9321                 case 0x03:
9322                 case 0x04:
9323                 case 0x05:
9324                 case 0x06:
9325                 case 0x07:
9326                 case 0x08:
9327                 case 0x09:
9328                 case 0x0a:
9329                 case 0x0b:
9330                 case 0x0c:
9331                 case 0x0d:
9332                 case 0x0e:
9333                   goto op_semantics_69;
9334                   break;
9335                 case 0x0f:
9336                   goto op_semantics_70;
9337                   break;
9338               }
9339             break;
9340           case 0xfc:
9341               GETBYTE ();
9342               switch (op[2] & 0x0f)
9343               {
9344                 case 0x00:
9345                 case 0x01:
9346                 case 0x02:
9347                 case 0x03:
9348                 case 0x04:
9349                 case 0x05:
9350                 case 0x06:
9351                 case 0x07:
9352                 case 0x08:
9353                 case 0x09:
9354                 case 0x0a:
9355                 case 0x0b:
9356                 case 0x0c:
9357                 case 0x0d:
9358                 case 0x0e:
9359                   goto op_semantics_69;
9360                   break;
9361                 case 0x0f:
9362                   goto op_semantics_70;
9363                   break;
9364               }
9365             break;
9366           case 0xfd:
9367               GETBYTE ();
9368               switch (op[2] & 0x0f)
9369               {
9370                 case 0x00:
9371                 case 0x01:
9372                 case 0x02:
9373                 case 0x03:
9374                 case 0x04:
9375                 case 0x05:
9376                 case 0x06:
9377                 case 0x07:
9378                 case 0x08:
9379                 case 0x09:
9380                 case 0x0a:
9381                 case 0x0b:
9382                 case 0x0c:
9383                 case 0x0d:
9384                 case 0x0e:
9385                   goto op_semantics_69;
9386                   break;
9387                 case 0x0f:
9388                   goto op_semantics_70;
9389                   break;
9390               }
9391             break;
9392           case 0xfe:
9393               GETBYTE ();
9394               switch (op[2] & 0x0f)
9395               {
9396                 case 0x00:
9397                 case 0x01:
9398                 case 0x02:
9399                 case 0x03:
9400                 case 0x04:
9401                 case 0x05:
9402                 case 0x06:
9403                 case 0x07:
9404                 case 0x08:
9405                 case 0x09:
9406                 case 0x0a:
9407                 case 0x0b:
9408                 case 0x0c:
9409                 case 0x0d:
9410                 case 0x0e:
9411                   goto op_semantics_69;
9412                   break;
9413                 case 0x0f:
9414                   goto op_semantics_70;
9415                   break;
9416               }
9417             break;
9418           case 0xff:
9419               GETBYTE ();
9420               switch (op[2] & 0x0f)
9421               {
9422                 case 0x00:
9423                 case 0x01:
9424                 case 0x02:
9425                 case 0x03:
9426                 case 0x04:
9427                 case 0x05:
9428                 case 0x06:
9429                 case 0x07:
9430                 case 0x08:
9431                 case 0x09:
9432                 case 0x0a:
9433                 case 0x0b:
9434                 case 0x0c:
9435                 case 0x0d:
9436                 case 0x0e:
9437                   goto op_semantics_69;
9438                   break;
9439                 case 0x0f:
9440                   goto op_semantics_70;
9441                   break;
9442               }
9443             break;
9444           default: UNSUPPORTED(); break;
9445         }
9446       break;
9447     case 0xfd:
9448         GETBYTE ();
9449         switch (op[1] & 0xff)
9450         {
9451           case 0x00:
9452               GETBYTE ();
9453               switch (op[2] & 0x00)
9454               {
9455                 case 0x00:
9456                     {
9457                       /** 1111 1101 0000 0000 srca srcb mulhi   %1, %2 */
9458 #line 807 "rx-decode.opc"
9459                       int srca AU = (op[2] >> 4) & 0x0f;
9460 #line 807 "rx-decode.opc"
9461                       int srcb AU = op[2] & 0x0f;
9462                       if (trace)
9463                         {
9464                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9465                                  "/** 1111 1101 0000 0000 srca srcb     mulhi   %1, %2 */",
9466                                  op[0], op[1], op[2]);
9467                           printf ("  srca = 0x%x,", srca);
9468                           printf ("  srcb = 0x%x\n", srcb);
9469                         }
9470                       SYNTAX("mulhi     %1, %2");
9471 #line 807 "rx-decode.opc"
9472                       ID(mulhi); SR(srca); S2R(srcb); F_____;
9473
9474                     }
9475                   break;
9476               }
9477             break;
9478           case 0x01:
9479               GETBYTE ();
9480               switch (op[2] & 0x00)
9481               {
9482                 case 0x00:
9483                     {
9484                       /** 1111 1101 0000 0001 srca srcb mullo   %1, %2 */
9485 #line 810 "rx-decode.opc"
9486                       int srca AU = (op[2] >> 4) & 0x0f;
9487 #line 810 "rx-decode.opc"
9488                       int srcb AU = op[2] & 0x0f;
9489                       if (trace)
9490                         {
9491                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9492                                  "/** 1111 1101 0000 0001 srca srcb     mullo   %1, %2 */",
9493                                  op[0], op[1], op[2]);
9494                           printf ("  srca = 0x%x,", srca);
9495                           printf ("  srcb = 0x%x\n", srcb);
9496                         }
9497                       SYNTAX("mullo     %1, %2");
9498 #line 810 "rx-decode.opc"
9499                       ID(mullo); SR(srca); S2R(srcb); F_____;
9500
9501                     }
9502                   break;
9503               }
9504             break;
9505           case 0x04:
9506               GETBYTE ();
9507               switch (op[2] & 0x00)
9508               {
9509                 case 0x00:
9510                     {
9511                       /** 1111 1101 0000 0100 srca srcb machi   %1, %2 */
9512 #line 813 "rx-decode.opc"
9513                       int srca AU = (op[2] >> 4) & 0x0f;
9514 #line 813 "rx-decode.opc"
9515                       int srcb AU = op[2] & 0x0f;
9516                       if (trace)
9517                         {
9518                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9519                                  "/** 1111 1101 0000 0100 srca srcb     machi   %1, %2 */",
9520                                  op[0], op[1], op[2]);
9521                           printf ("  srca = 0x%x,", srca);
9522                           printf ("  srcb = 0x%x\n", srcb);
9523                         }
9524                       SYNTAX("machi     %1, %2");
9525 #line 813 "rx-decode.opc"
9526                       ID(machi); SR(srca); S2R(srcb); F_____;
9527
9528                     }
9529                   break;
9530               }
9531             break;
9532           case 0x05:
9533               GETBYTE ();
9534               switch (op[2] & 0x00)
9535               {
9536                 case 0x00:
9537                     {
9538                       /** 1111 1101 0000 0101 srca srcb maclo   %1, %2 */
9539 #line 816 "rx-decode.opc"
9540                       int srca AU = (op[2] >> 4) & 0x0f;
9541 #line 816 "rx-decode.opc"
9542                       int srcb AU = op[2] & 0x0f;
9543                       if (trace)
9544                         {
9545                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9546                                  "/** 1111 1101 0000 0101 srca srcb     maclo   %1, %2 */",
9547                                  op[0], op[1], op[2]);
9548                           printf ("  srca = 0x%x,", srca);
9549                           printf ("  srcb = 0x%x\n", srcb);
9550                         }
9551                       SYNTAX("maclo     %1, %2");
9552 #line 816 "rx-decode.opc"
9553                       ID(maclo); SR(srca); S2R(srcb); F_____;
9554
9555                     }
9556                   break;
9557               }
9558             break;
9559           case 0x17:
9560               GETBYTE ();
9561               switch (op[2] & 0xf0)
9562               {
9563                 case 0x00:
9564                     {
9565                       /** 1111 1101 0001 0111 0000 rsrc mvtachi %1 */
9566 #line 819 "rx-decode.opc"
9567                       int rsrc AU = op[2] & 0x0f;
9568                       if (trace)
9569                         {
9570                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9571                                  "/** 1111 1101 0001 0111 0000 rsrc     mvtachi %1 */",
9572                                  op[0], op[1], op[2]);
9573                           printf ("  rsrc = 0x%x\n", rsrc);
9574                         }
9575                       SYNTAX("mvtachi   %1");
9576 #line 819 "rx-decode.opc"
9577                       ID(mvtachi); SR(rsrc); F_____;
9578
9579                     }
9580                   break;
9581                 case 0x10:
9582                     {
9583                       /** 1111 1101 0001 0111 0001 rsrc mvtaclo %1 */
9584 #line 822 "rx-decode.opc"
9585                       int rsrc AU = op[2] & 0x0f;
9586                       if (trace)
9587                         {
9588                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9589                                  "/** 1111 1101 0001 0111 0001 rsrc     mvtaclo %1 */",
9590                                  op[0], op[1], op[2]);
9591                           printf ("  rsrc = 0x%x\n", rsrc);
9592                         }
9593                       SYNTAX("mvtaclo   %1");
9594 #line 822 "rx-decode.opc"
9595                       ID(mvtaclo); SR(rsrc); F_____;
9596
9597                     }
9598                   break;
9599                 default: UNSUPPORTED(); break;
9600               }
9601             break;
9602           case 0x18:
9603               GETBYTE ();
9604               switch (op[2] & 0xef)
9605               {
9606                 case 0x00:
9607                     {
9608                       /** 1111 1101 0001 1000 000i 0000 racw    #%1 */
9609 #line 834 "rx-decode.opc"
9610                       int i AU = (op[2] >> 4) & 0x01;
9611                       if (trace)
9612                         {
9613                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9614                                  "/** 1111 1101 0001 1000 000i 0000     racw    #%1 */",
9615                                  op[0], op[1], op[2]);
9616                           printf ("  i = 0x%x\n", i);
9617                         }
9618                       SYNTAX("racw      #%1");
9619 #line 834 "rx-decode.opc"
9620                       ID(racw); SC(i+1); F_____;
9621
9622                     /*----------------------------------------------------------------------*/
9623                     /* SAT                                                                      */
9624
9625                     }
9626                   break;
9627                 default: UNSUPPORTED(); break;
9628               }
9629             break;
9630           case 0x1f:
9631               GETBYTE ();
9632               switch (op[2] & 0xf0)
9633               {
9634                 case 0x00:
9635                     {
9636                       /** 1111 1101 0001 1111 0000 rdst mvfachi %0 */
9637 #line 825 "rx-decode.opc"
9638                       int rdst AU = op[2] & 0x0f;
9639                       if (trace)
9640                         {
9641                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9642                                  "/** 1111 1101 0001 1111 0000 rdst     mvfachi %0 */",
9643                                  op[0], op[1], op[2]);
9644                           printf ("  rdst = 0x%x\n", rdst);
9645                         }
9646                       SYNTAX("mvfachi   %0");
9647 #line 825 "rx-decode.opc"
9648                       ID(mvfachi); DR(rdst); F_____;
9649
9650                     }
9651                   break;
9652                 case 0x10:
9653                     {
9654                       /** 1111 1101 0001 1111 0001 rdst mvfaclo %0 */
9655 #line 831 "rx-decode.opc"
9656                       int rdst AU = op[2] & 0x0f;
9657                       if (trace)
9658                         {
9659                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9660                                  "/** 1111 1101 0001 1111 0001 rdst     mvfaclo %0 */",
9661                                  op[0], op[1], op[2]);
9662                           printf ("  rdst = 0x%x\n", rdst);
9663                         }
9664                       SYNTAX("mvfaclo   %0");
9665 #line 831 "rx-decode.opc"
9666                       ID(mvfaclo); DR(rdst); F_____;
9667
9668                     }
9669                   break;
9670                 case 0x20:
9671                     {
9672                       /** 1111 1101 0001 1111 0010 rdst mvfacmi %0 */
9673 #line 828 "rx-decode.opc"
9674                       int rdst AU = op[2] & 0x0f;
9675                       if (trace)
9676                         {
9677                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9678                                  "/** 1111 1101 0001 1111 0010 rdst     mvfacmi %0 */",
9679                                  op[0], op[1], op[2]);
9680                           printf ("  rdst = 0x%x\n", rdst);
9681                         }
9682                       SYNTAX("mvfacmi   %0");
9683 #line 828 "rx-decode.opc"
9684                       ID(mvfacmi); DR(rdst); F_____;
9685
9686                     }
9687                   break;
9688                 default: UNSUPPORTED(); break;
9689               }
9690             break;
9691           case 0x20:
9692               GETBYTE ();
9693               switch (op[2] & 0x00)
9694               {
9695                 case 0x00:
9696                   op_semantics_71:
9697                     {
9698                       /** 1111 1101 0010 0p sz rdst rsrc        mov%s   %1, %0 */
9699 #line 341 "rx-decode.opc"
9700                       int p AU = (op[1] >> 2) & 0x01;
9701 #line 341 "rx-decode.opc"
9702                       int sz AU = op[1] & 0x03;
9703 #line 341 "rx-decode.opc"
9704                       int rdst AU = (op[2] >> 4) & 0x0f;
9705 #line 341 "rx-decode.opc"
9706                       int rsrc AU = op[2] & 0x0f;
9707                       if (trace)
9708                         {
9709                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9710                                  "/** 1111 1101 0010 0p sz rdst rsrc    mov%s   %1, %0 */",
9711                                  op[0], op[1], op[2]);
9712                           printf ("  p = 0x%x,", p);
9713                           printf ("  sz = 0x%x,", sz);
9714                           printf ("  rdst = 0x%x,", rdst);
9715                           printf ("  rsrc = 0x%x\n", rsrc);
9716                         }
9717                       SYNTAX("mov%s     %1, %0");
9718 #line 341 "rx-decode.opc"
9719                       ID(mov); sBWL (sz); SR(rsrc); F_____;
9720                       OP(0, p ? RX_Operand_Predec : RX_Operand_Postinc, rdst, 0);
9721
9722                     }
9723                   break;
9724               }
9725             break;
9726           case 0x21:
9727               GETBYTE ();
9728               switch (op[2] & 0x00)
9729               {
9730                 case 0x00:
9731                   goto op_semantics_71;
9732                   break;
9733               }
9734             break;
9735           case 0x22:
9736               GETBYTE ();
9737               switch (op[2] & 0x00)
9738               {
9739                 case 0x00:
9740                   goto op_semantics_71;
9741                   break;
9742               }
9743             break;
9744           case 0x24:
9745               GETBYTE ();
9746               switch (op[2] & 0x00)
9747               {
9748                 case 0x00:
9749                   goto op_semantics_71;
9750                   break;
9751               }
9752             break;
9753           case 0x25:
9754               GETBYTE ();
9755               switch (op[2] & 0x00)
9756               {
9757                 case 0x00:
9758                   goto op_semantics_71;
9759                   break;
9760               }
9761             break;
9762           case 0x26:
9763               GETBYTE ();
9764               switch (op[2] & 0x00)
9765               {
9766                 case 0x00:
9767                   goto op_semantics_71;
9768                   break;
9769               }
9770             break;
9771           case 0x28:
9772               GETBYTE ();
9773               switch (op[2] & 0x00)
9774               {
9775                 case 0x00:
9776                   op_semantics_72:
9777                     {
9778                       /** 1111 1101 0010 1p sz rsrc rdst        mov%s   %1, %0 */
9779 #line 345 "rx-decode.opc"
9780                       int p AU = (op[1] >> 2) & 0x01;
9781 #line 345 "rx-decode.opc"
9782                       int sz AU = op[1] & 0x03;
9783 #line 345 "rx-decode.opc"
9784                       int rsrc AU = (op[2] >> 4) & 0x0f;
9785 #line 345 "rx-decode.opc"
9786                       int rdst AU = op[2] & 0x0f;
9787                       if (trace)
9788                         {
9789                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9790                                  "/** 1111 1101 0010 1p sz rsrc rdst    mov%s   %1, %0 */",
9791                                  op[0], op[1], op[2]);
9792                           printf ("  p = 0x%x,", p);
9793                           printf ("  sz = 0x%x,", sz);
9794                           printf ("  rsrc = 0x%x,", rsrc);
9795                           printf ("  rdst = 0x%x\n", rdst);
9796                         }
9797                       SYNTAX("mov%s     %1, %0");
9798 #line 345 "rx-decode.opc"
9799                       ID(mov); sBWL (sz); DR(rdst); F_____;
9800                       OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
9801
9802                     }
9803                   break;
9804               }
9805             break;
9806           case 0x29:
9807               GETBYTE ();
9808               switch (op[2] & 0x00)
9809               {
9810                 case 0x00:
9811                   goto op_semantics_72;
9812                   break;
9813               }
9814             break;
9815           case 0x2a:
9816               GETBYTE ();
9817               switch (op[2] & 0x00)
9818               {
9819                 case 0x00:
9820                   goto op_semantics_72;
9821                   break;
9822               }
9823             break;
9824           case 0x2c:
9825               GETBYTE ();
9826               switch (op[2] & 0x00)
9827               {
9828                 case 0x00:
9829                   goto op_semantics_72;
9830                   break;
9831               }
9832             break;
9833           case 0x2d:
9834               GETBYTE ();
9835               switch (op[2] & 0x00)
9836               {
9837                 case 0x00:
9838                   goto op_semantics_72;
9839                   break;
9840               }
9841             break;
9842           case 0x2e:
9843               GETBYTE ();
9844               switch (op[2] & 0x00)
9845               {
9846                 case 0x00:
9847                   goto op_semantics_72;
9848                   break;
9849               }
9850             break;
9851           case 0x38:
9852               GETBYTE ();
9853               switch (op[2] & 0x00)
9854               {
9855                 case 0x00:
9856                   op_semantics_73:
9857                     {
9858                       /** 1111 1101 0011 1p sz rsrc rdst        movu%s  %1, %0 */
9859 #line 355 "rx-decode.opc"
9860                       int p AU = (op[1] >> 2) & 0x01;
9861 #line 355 "rx-decode.opc"
9862                       int sz AU = op[1] & 0x03;
9863 #line 355 "rx-decode.opc"
9864                       int rsrc AU = (op[2] >> 4) & 0x0f;
9865 #line 355 "rx-decode.opc"
9866                       int rdst AU = op[2] & 0x0f;
9867                       if (trace)
9868                         {
9869                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9870                                  "/** 1111 1101 0011 1p sz rsrc rdst    movu%s  %1, %0 */",
9871                                  op[0], op[1], op[2]);
9872                           printf ("  p = 0x%x,", p);
9873                           printf ("  sz = 0x%x,", sz);
9874                           printf ("  rsrc = 0x%x,", rsrc);
9875                           printf ("  rdst = 0x%x\n", rdst);
9876                         }
9877                       SYNTAX("movu%s    %1, %0");
9878 #line 355 "rx-decode.opc"
9879                       ID(mov); uBWL (sz); DR(rdst); F_____;
9880                        OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
9881
9882                     /*----------------------------------------------------------------------*/
9883                     /* PUSH/POP                                                         */
9884
9885                     }
9886                   break;
9887               }
9888             break;
9889           case 0x39:
9890               GETBYTE ();
9891               switch (op[2] & 0x00)
9892               {
9893                 case 0x00:
9894                   goto op_semantics_73;
9895                   break;
9896               }
9897             break;
9898           case 0x3a:
9899               GETBYTE ();
9900               switch (op[2] & 0x00)
9901               {
9902                 case 0x00:
9903                   goto op_semantics_73;
9904                   break;
9905               }
9906             break;
9907           case 0x3c:
9908               GETBYTE ();
9909               switch (op[2] & 0x00)
9910               {
9911                 case 0x00:
9912                   goto op_semantics_73;
9913                   break;
9914               }
9915             break;
9916           case 0x3d:
9917               GETBYTE ();
9918               switch (op[2] & 0x00)
9919               {
9920                 case 0x00:
9921                   goto op_semantics_73;
9922                   break;
9923               }
9924             break;
9925           case 0x3e:
9926               GETBYTE ();
9927               switch (op[2] & 0x00)
9928               {
9929                 case 0x00:
9930                   goto op_semantics_73;
9931                   break;
9932               }
9933             break;
9934           case 0x60:
9935               GETBYTE ();
9936               switch (op[2] & 0x00)
9937               {
9938                 case 0x00:
9939                     {
9940                       /** 1111 1101 0110 0000 rsrc rdst shlr    %2, %0 */
9941 #line 688 "rx-decode.opc"
9942                       int rsrc AU = (op[2] >> 4) & 0x0f;
9943 #line 688 "rx-decode.opc"
9944                       int rdst AU = op[2] & 0x0f;
9945                       if (trace)
9946                         {
9947                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9948                                  "/** 1111 1101 0110 0000 rsrc rdst     shlr    %2, %0 */",
9949                                  op[0], op[1], op[2]);
9950                           printf ("  rsrc = 0x%x,", rsrc);
9951                           printf ("  rdst = 0x%x\n", rdst);
9952                         }
9953                       SYNTAX("shlr      %2, %0");
9954 #line 688 "rx-decode.opc"
9955                       ID(shlr); S2R(rsrc); SR(rdst); DR(rdst); F__SZC;
9956
9957                     }
9958                   break;
9959               }
9960             break;
9961           case 0x61:
9962               GETBYTE ();
9963               switch (op[2] & 0x00)
9964               {
9965                 case 0x00:
9966                     {
9967                       /** 1111 1101 0110 0001 rsrc rdst shar    %2, %0 */
9968 #line 678 "rx-decode.opc"
9969                       int rsrc AU = (op[2] >> 4) & 0x0f;
9970 #line 678 "rx-decode.opc"
9971                       int rdst AU = op[2] & 0x0f;
9972                       if (trace)
9973                         {
9974                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9975                                  "/** 1111 1101 0110 0001 rsrc rdst     shar    %2, %0 */",
9976                                  op[0], op[1], op[2]);
9977                           printf ("  rsrc = 0x%x,", rsrc);
9978                           printf ("  rdst = 0x%x\n", rdst);
9979                         }
9980                       SYNTAX("shar      %2, %0");
9981 #line 678 "rx-decode.opc"
9982                       ID(shar); S2R(rsrc); SR(rdst); DR(rdst); F_0SZC;
9983
9984                     }
9985                   break;
9986               }
9987             break;
9988           case 0x62:
9989               GETBYTE ();
9990               switch (op[2] & 0x00)
9991               {
9992                 case 0x00:
9993                     {
9994                       /** 1111 1101 0110 0010 rsrc rdst shll    %2, %0 */
9995 #line 668 "rx-decode.opc"
9996                       int rsrc AU = (op[2] >> 4) & 0x0f;
9997 #line 668 "rx-decode.opc"
9998                       int rdst AU = op[2] & 0x0f;
9999                       if (trace)
10000                         {
10001                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10002                                  "/** 1111 1101 0110 0010 rsrc rdst     shll    %2, %0 */",
10003                                  op[0], op[1], op[2]);
10004                           printf ("  rsrc = 0x%x,", rsrc);
10005                           printf ("  rdst = 0x%x\n", rdst);
10006                         }
10007                       SYNTAX("shll      %2, %0");
10008 #line 668 "rx-decode.opc"
10009                       ID(shll); S2R(rsrc); SR(rdst); DR(rdst); F_OSZC;
10010
10011                     }
10012                   break;
10013               }
10014             break;
10015           case 0x64:
10016               GETBYTE ();
10017               switch (op[2] & 0x00)
10018               {
10019                 case 0x00:
10020                     {
10021                       /** 1111 1101 0110 0100 rsrc rdst rotr    %1, %0 */
10022 #line 712 "rx-decode.opc"
10023                       int rsrc AU = (op[2] >> 4) & 0x0f;
10024 #line 712 "rx-decode.opc"
10025                       int rdst AU = op[2] & 0x0f;
10026                       if (trace)
10027                         {
10028                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10029                                  "/** 1111 1101 0110 0100 rsrc rdst     rotr    %1, %0 */",
10030                                  op[0], op[1], op[2]);
10031                           printf ("  rsrc = 0x%x,", rsrc);
10032                           printf ("  rdst = 0x%x\n", rdst);
10033                         }
10034                       SYNTAX("rotr      %1, %0");
10035 #line 712 "rx-decode.opc"
10036                       ID(rotr); SR(rsrc); DR(rdst); F__SZC;
10037
10038                     }
10039                   break;
10040               }
10041             break;
10042           case 0x65:
10043               GETBYTE ();
10044               switch (op[2] & 0x00)
10045               {
10046                 case 0x00:
10047                     {
10048                       /** 1111 1101 0110 0101 rsrc rdst revw    %1, %0 */
10049 #line 715 "rx-decode.opc"
10050                       int rsrc AU = (op[2] >> 4) & 0x0f;
10051 #line 715 "rx-decode.opc"
10052                       int rdst AU = op[2] & 0x0f;
10053                       if (trace)
10054                         {
10055                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10056                                  "/** 1111 1101 0110 0101 rsrc rdst     revw    %1, %0 */",
10057                                  op[0], op[1], op[2]);
10058                           printf ("  rsrc = 0x%x,", rsrc);
10059                           printf ("  rdst = 0x%x\n", rdst);
10060                         }
10061                       SYNTAX("revw      %1, %0");
10062 #line 715 "rx-decode.opc"
10063                       ID(revw); SR(rsrc); DR(rdst);
10064
10065                     }
10066                   break;
10067               }
10068             break;
10069           case 0x66:
10070               GETBYTE ();
10071               switch (op[2] & 0x00)
10072               {
10073                 case 0x00:
10074                     {
10075                       /** 1111 1101 0110 0110 rsrc rdst rotl    %1, %0 */
10076 #line 706 "rx-decode.opc"
10077                       int rsrc AU = (op[2] >> 4) & 0x0f;
10078 #line 706 "rx-decode.opc"
10079                       int rdst AU = op[2] & 0x0f;
10080                       if (trace)
10081                         {
10082                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10083                                  "/** 1111 1101 0110 0110 rsrc rdst     rotl    %1, %0 */",
10084                                  op[0], op[1], op[2]);
10085                           printf ("  rsrc = 0x%x,", rsrc);
10086                           printf ("  rdst = 0x%x\n", rdst);
10087                         }
10088                       SYNTAX("rotl      %1, %0");
10089 #line 706 "rx-decode.opc"
10090                       ID(rotl); SR(rsrc); DR(rdst); F__SZC;
10091
10092                     }
10093                   break;
10094               }
10095             break;
10096           case 0x67:
10097               GETBYTE ();
10098               switch (op[2] & 0x00)
10099               {
10100                 case 0x00:
10101                     {
10102                       /** 1111 1101 0110 0111 rsrc rdst revl    %1, %0 */
10103 #line 718 "rx-decode.opc"
10104                       int rsrc AU = (op[2] >> 4) & 0x0f;
10105 #line 718 "rx-decode.opc"
10106                       int rdst AU = op[2] & 0x0f;
10107                       if (trace)
10108                         {
10109                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10110                                  "/** 1111 1101 0110 0111 rsrc rdst     revl    %1, %0 */",
10111                                  op[0], op[1], op[2]);
10112                           printf ("  rsrc = 0x%x,", rsrc);
10113                           printf ("  rdst = 0x%x\n", rdst);
10114                         }
10115                       SYNTAX("revl      %1, %0");
10116 #line 718 "rx-decode.opc"
10117                       ID(revl); SR(rsrc); DR(rdst);
10118
10119                     /*----------------------------------------------------------------------*/
10120                     /* BRANCH                                                           */
10121
10122                     }
10123                   break;
10124               }
10125             break;
10126           case 0x68:
10127               GETBYTE ();
10128               switch (op[2] & 0x00)
10129               {
10130                 case 0x00:
10131                   op_semantics_74:
10132                     {
10133                       /** 1111 1101 0110 100c rsrc rdst mvtc    %1, %0 */
10134 #line 961 "rx-decode.opc"
10135                       int c AU = op[1] & 0x01;
10136 #line 961 "rx-decode.opc"
10137                       int rsrc AU = (op[2] >> 4) & 0x0f;
10138 #line 961 "rx-decode.opc"
10139                       int rdst AU = op[2] & 0x0f;
10140                       if (trace)
10141                         {
10142                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10143                                  "/** 1111 1101 0110 100c rsrc rdst     mvtc    %1, %0 */",
10144                                  op[0], op[1], op[2]);
10145                           printf ("  c = 0x%x,", c);
10146                           printf ("  rsrc = 0x%x,", rsrc);
10147                           printf ("  rdst = 0x%x\n", rdst);
10148                         }
10149                       SYNTAX("mvtc      %1, %0");
10150 #line 961 "rx-decode.opc"
10151                       ID(mov); SR(rsrc); DR(c*16+rdst + 16);
10152
10153                     }
10154                   break;
10155               }
10156             break;
10157           case 0x69:
10158               GETBYTE ();
10159               switch (op[2] & 0x00)
10160               {
10161                 case 0x00:
10162                   goto op_semantics_74;
10163                   break;
10164               }
10165             break;
10166           case 0x6a:
10167               GETBYTE ();
10168               switch (op[2] & 0x00)
10169               {
10170                 case 0x00:
10171                   op_semantics_75:
10172                     {
10173                       /** 1111 1101 0110 101s rsrc rdst mvfc    %1, %0 */
10174 #line 964 "rx-decode.opc"
10175                       int s AU = op[1] & 0x01;
10176 #line 964 "rx-decode.opc"
10177                       int rsrc AU = (op[2] >> 4) & 0x0f;
10178 #line 964 "rx-decode.opc"
10179                       int rdst AU = op[2] & 0x0f;
10180                       if (trace)
10181                         {
10182                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10183                                  "/** 1111 1101 0110 101s rsrc rdst     mvfc    %1, %0 */",
10184                                  op[0], op[1], op[2]);
10185                           printf ("  s = 0x%x,", s);
10186                           printf ("  rsrc = 0x%x,", rsrc);
10187                           printf ("  rdst = 0x%x\n", rdst);
10188                         }
10189                       SYNTAX("mvfc      %1, %0");
10190 #line 964 "rx-decode.opc"
10191                       ID(mov); SR((s*16+rsrc) + 16); DR(rdst);
10192
10193                     /*----------------------------------------------------------------------*/
10194                     /* INTERRUPTS                                                               */
10195
10196                     }
10197                   break;
10198               }
10199             break;
10200           case 0x6b:
10201               GETBYTE ();
10202               switch (op[2] & 0x00)
10203               {
10204                 case 0x00:
10205                   goto op_semantics_75;
10206                   break;
10207               }
10208             break;
10209           case 0x6c:
10210               GETBYTE ();
10211               switch (op[2] & 0x00)
10212               {
10213                 case 0x00:
10214                   op_semantics_76:
10215                     {
10216                       /** 1111 1101 0110 110i mmmm rdst rotr    #%1, %0 */
10217 #line 709 "rx-decode.opc"
10218                       int i AU = op[1] & 0x01;
10219 #line 709 "rx-decode.opc"
10220                       int mmmm AU = (op[2] >> 4) & 0x0f;
10221 #line 709 "rx-decode.opc"
10222                       int rdst AU = op[2] & 0x0f;
10223                       if (trace)
10224                         {
10225                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10226                                  "/** 1111 1101 0110 110i mmmm rdst     rotr    #%1, %0 */",
10227                                  op[0], op[1], op[2]);
10228                           printf ("  i = 0x%x,", i);
10229                           printf ("  mmmm = 0x%x,", mmmm);
10230                           printf ("  rdst = 0x%x\n", rdst);
10231                         }
10232                       SYNTAX("rotr      #%1, %0");
10233 #line 709 "rx-decode.opc"
10234                       ID(rotr); SC(i*16+mmmm); DR(rdst); F__SZC;
10235
10236                     }
10237                   break;
10238               }
10239             break;
10240           case 0x6d:
10241               GETBYTE ();
10242               switch (op[2] & 0x00)
10243               {
10244                 case 0x00:
10245                   goto op_semantics_76;
10246                   break;
10247               }
10248             break;
10249           case 0x6e:
10250               GETBYTE ();
10251               switch (op[2] & 0x00)
10252               {
10253                 case 0x00:
10254                   op_semantics_77:
10255                     {
10256                       /** 1111 1101 0110 111i mmmm rdst rotl    #%1, %0 */
10257 #line 703 "rx-decode.opc"
10258                       int i AU = op[1] & 0x01;
10259 #line 703 "rx-decode.opc"
10260                       int mmmm AU = (op[2] >> 4) & 0x0f;
10261 #line 703 "rx-decode.opc"
10262                       int rdst AU = op[2] & 0x0f;
10263                       if (trace)
10264                         {
10265                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10266                                  "/** 1111 1101 0110 111i mmmm rdst     rotl    #%1, %0 */",
10267                                  op[0], op[1], op[2]);
10268                           printf ("  i = 0x%x,", i);
10269                           printf ("  mmmm = 0x%x,", mmmm);
10270                           printf ("  rdst = 0x%x\n", rdst);
10271                         }
10272                       SYNTAX("rotl      #%1, %0");
10273 #line 703 "rx-decode.opc"
10274                       ID(rotl); SC(i*16+mmmm); DR(rdst); F__SZC;
10275
10276                     }
10277                   break;
10278               }
10279             break;
10280           case 0x6f:
10281               GETBYTE ();
10282               switch (op[2] & 0x00)
10283               {
10284                 case 0x00:
10285                   goto op_semantics_77;
10286                   break;
10287               }
10288             break;
10289           case 0x70:
10290               GETBYTE ();
10291               switch (op[2] & 0xf0)
10292               {
10293                 case 0x20:
10294                   op_semantics_78:
10295                     {
10296                       /** 1111 1101 0111 im00 0010rdst  adc     #%1, %0 */
10297 #line 485 "rx-decode.opc"
10298                       int im AU = (op[1] >> 2) & 0x03;
10299 #line 485 "rx-decode.opc"
10300                       int rdst AU = op[2] & 0x0f;
10301                       if (trace)
10302                         {
10303                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10304                                  "/** 1111 1101 0111 im00 0010rdst      adc     #%1, %0 */",
10305                                  op[0], op[1], op[2]);
10306                           printf ("  im = 0x%x,", im);
10307                           printf ("  rdst = 0x%x\n", rdst);
10308                         }
10309                       SYNTAX("adc       #%1, %0");
10310 #line 485 "rx-decode.opc"
10311                       ID(adc); SC(IMMex(im)); DR(rdst); F_OSZC;
10312
10313                     }
10314                   break;
10315                 case 0x40:
10316                   op_semantics_79:
10317                     {
10318                       /** 1111 1101 0111 im00 0100rdst  max     #%1, %0 */
10319 #line 567 "rx-decode.opc"
10320                       int im AU = (op[1] >> 2) & 0x03;
10321 #line 567 "rx-decode.opc"
10322                       int rdst AU = op[2] & 0x0f;
10323                       if (trace)
10324                         {
10325                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10326                                  "/** 1111 1101 0111 im00 0100rdst      max     #%1, %0 */",
10327                                  op[0], op[1], op[2]);
10328                           printf ("  im = 0x%x,", im);
10329                           printf ("  rdst = 0x%x\n", rdst);
10330                         }
10331                       SYNTAX("max       #%1, %0");
10332 #line 567 "rx-decode.opc"
10333                       ID(max); DR(rdst); SC(IMMex(im));
10334
10335                     }
10336                   break;
10337                 case 0x50:
10338                   op_semantics_80:
10339                     {
10340                       /** 1111 1101 0111 im00 0101rdst  min     #%1, %0 */
10341 #line 587 "rx-decode.opc"
10342                       int im AU = (op[1] >> 2) & 0x03;
10343 #line 587 "rx-decode.opc"
10344                       int rdst AU = op[2] & 0x0f;
10345                       if (trace)
10346                         {
10347                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10348                                  "/** 1111 1101 0111 im00 0101rdst      min     #%1, %0 */",
10349                                  op[0], op[1], op[2]);
10350                           printf ("  im = 0x%x,", im);
10351                           printf ("  rdst = 0x%x\n", rdst);
10352                         }
10353                       SYNTAX("min       #%1, %0");
10354 #line 587 "rx-decode.opc"
10355                       ID(min); DR(rdst); SC(IMMex(im));
10356
10357                     }
10358                   break;
10359                 case 0x60:
10360                   op_semantics_81:
10361                     {
10362                       /** 1111 1101 0111 im00 0110rdst  emul    #%1, %0 */
10363 #line 617 "rx-decode.opc"
10364                       int im AU = (op[1] >> 2) & 0x03;
10365 #line 617 "rx-decode.opc"
10366                       int rdst AU = op[2] & 0x0f;
10367                       if (trace)
10368                         {
10369                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10370                                  "/** 1111 1101 0111 im00 0110rdst      emul    #%1, %0 */",
10371                                  op[0], op[1], op[2]);
10372                           printf ("  im = 0x%x,", im);
10373                           printf ("  rdst = 0x%x\n", rdst);
10374                         }
10375                       SYNTAX("emul      #%1, %0");
10376 #line 617 "rx-decode.opc"
10377                       ID(emul); DR(rdst); SC(IMMex(im));
10378
10379                     }
10380                   break;
10381                 case 0x70:
10382                   op_semantics_82:
10383                     {
10384                       /** 1111 1101 0111 im00 0111rdst  emulu   #%1, %0 */
10385 #line 629 "rx-decode.opc"
10386                       int im AU = (op[1] >> 2) & 0x03;
10387 #line 629 "rx-decode.opc"
10388                       int rdst AU = op[2] & 0x0f;
10389                       if (trace)
10390                         {
10391                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10392                                  "/** 1111 1101 0111 im00 0111rdst      emulu   #%1, %0 */",
10393                                  op[0], op[1], op[2]);
10394                           printf ("  im = 0x%x,", im);
10395                           printf ("  rdst = 0x%x\n", rdst);
10396                         }
10397                       SYNTAX("emulu     #%1, %0");
10398 #line 629 "rx-decode.opc"
10399                       ID(emulu); DR(rdst); SC(IMMex(im));
10400
10401                     }
10402                   break;
10403                 case 0x80:
10404                   op_semantics_83:
10405                     {
10406                       /** 1111 1101 0111 im00 1000rdst  div     #%1, %0 */
10407 #line 641 "rx-decode.opc"
10408                       int im AU = (op[1] >> 2) & 0x03;
10409 #line 641 "rx-decode.opc"
10410                       int rdst AU = op[2] & 0x0f;
10411                       if (trace)
10412                         {
10413                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10414                                  "/** 1111 1101 0111 im00 1000rdst      div     #%1, %0 */",
10415                                  op[0], op[1], op[2]);
10416                           printf ("  im = 0x%x,", im);
10417                           printf ("  rdst = 0x%x\n", rdst);
10418                         }
10419                       SYNTAX("div       #%1, %0");
10420 #line 641 "rx-decode.opc"
10421                       ID(div); DR(rdst); SC(IMMex(im)); F_O___;
10422
10423                     }
10424                   break;
10425                 case 0x90:
10426                   op_semantics_84:
10427                     {
10428                       /** 1111 1101 0111 im00 1001rdst  divu    #%1, %0 */
10429 #line 653 "rx-decode.opc"
10430                       int im AU = (op[1] >> 2) & 0x03;
10431 #line 653 "rx-decode.opc"
10432                       int rdst AU = op[2] & 0x0f;
10433                       if (trace)
10434                         {
10435                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10436                                  "/** 1111 1101 0111 im00 1001rdst      divu    #%1, %0 */",
10437                                  op[0], op[1], op[2]);
10438                           printf ("  im = 0x%x,", im);
10439                           printf ("  rdst = 0x%x\n", rdst);
10440                         }
10441                       SYNTAX("divu      #%1, %0");
10442 #line 653 "rx-decode.opc"
10443                       ID(divu); DR(rdst); SC(IMMex(im)); F_O___;
10444
10445                     }
10446                   break;
10447                 case 0xc0:
10448                   op_semantics_85:
10449                     {
10450                       /** 1111 1101 0111 im00 1100rdst  tst     #%1, %2 */
10451 #line 464 "rx-decode.opc"
10452                       int im AU = (op[1] >> 2) & 0x03;
10453 #line 464 "rx-decode.opc"
10454                       int rdst AU = op[2] & 0x0f;
10455                       if (trace)
10456                         {
10457                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10458                                  "/** 1111 1101 0111 im00 1100rdst      tst     #%1, %2 */",
10459                                  op[0], op[1], op[2]);
10460                           printf ("  im = 0x%x,", im);
10461                           printf ("  rdst = 0x%x\n", rdst);
10462                         }
10463                       SYNTAX("tst       #%1, %2");
10464 #line 464 "rx-decode.opc"
10465                       ID(and); SC(IMMex(im)); S2R(rdst); F__SZ_;
10466
10467                     }
10468                   break;
10469                 case 0xd0:
10470                   op_semantics_86:
10471                     {
10472                       /** 1111 1101 0111 im00 1101rdst  xor     #%1, %0 */
10473 #line 443 "rx-decode.opc"
10474                       int im AU = (op[1] >> 2) & 0x03;
10475 #line 443 "rx-decode.opc"
10476                       int rdst AU = op[2] & 0x0f;
10477                       if (trace)
10478                         {
10479                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10480                                  "/** 1111 1101 0111 im00 1101rdst      xor     #%1, %0 */",
10481                                  op[0], op[1], op[2]);
10482                           printf ("  im = 0x%x,", im);
10483                           printf ("  rdst = 0x%x\n", rdst);
10484                         }
10485                       SYNTAX("xor       #%1, %0");
10486 #line 443 "rx-decode.opc"
10487                       ID(xor); SC(IMMex(im)); DR(rdst); F__SZ_;
10488
10489                     }
10490                   break;
10491                 case 0xe0:
10492                   op_semantics_87:
10493                     {
10494                       /** 1111 1101 0111 im00 1110rdst  stz     #%1, %0 */
10495 #line 389 "rx-decode.opc"
10496                       int im AU = (op[1] >> 2) & 0x03;
10497 #line 389 "rx-decode.opc"
10498                       int rdst AU = op[2] & 0x0f;
10499                       if (trace)
10500                         {
10501                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10502                                  "/** 1111 1101 0111 im00 1110rdst      stz     #%1, %0 */",
10503                                  op[0], op[1], op[2]);
10504                           printf ("  im = 0x%x,", im);
10505                           printf ("  rdst = 0x%x\n", rdst);
10506                         }
10507                       SYNTAX("stz       #%1, %0");
10508 #line 389 "rx-decode.opc"
10509                       ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_z);
10510
10511                     }
10512                   break;
10513                 case 0xf0:
10514                   op_semantics_88:
10515                     {
10516                       /** 1111 1101 0111 im00 1111rdst  stnz    #%1, %0 */
10517 #line 392 "rx-decode.opc"
10518                       int im AU = (op[1] >> 2) & 0x03;
10519 #line 392 "rx-decode.opc"
10520                       int rdst AU = op[2] & 0x0f;
10521                       if (trace)
10522                         {
10523                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10524                                  "/** 1111 1101 0111 im00 1111rdst      stnz    #%1, %0 */",
10525                                  op[0], op[1], op[2]);
10526                           printf ("  im = 0x%x,", im);
10527                           printf ("  rdst = 0x%x\n", rdst);
10528                         }
10529                       SYNTAX("stnz      #%1, %0");
10530 #line 392 "rx-decode.opc"
10531                       ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_nz);
10532
10533                     /*----------------------------------------------------------------------*/
10534                     /* RTSD                                                                     */
10535
10536                     }
10537                   break;
10538                 default: UNSUPPORTED(); break;
10539               }
10540             break;
10541           case 0x72:
10542               GETBYTE ();
10543               switch (op[2] & 0xf0)
10544               {
10545                 case 0x00:
10546                     {
10547                       /** 1111 1101 0111 0010 0000 rdst fsub    #%1, %0 */
10548 #line 861 "rx-decode.opc"
10549                       int rdst AU = op[2] & 0x0f;
10550                       if (trace)
10551                         {
10552                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10553                                  "/** 1111 1101 0111 0010 0000 rdst     fsub    #%1, %0 */",
10554                                  op[0], op[1], op[2]);
10555                           printf ("  rdst = 0x%x\n", rdst);
10556                         }
10557                       SYNTAX("fsub      #%1, %0");
10558 #line 861 "rx-decode.opc"
10559                       ID(fsub); DR(rdst); SC(IMM(0)); F__SZ_;
10560
10561                     }
10562                   break;
10563                 case 0x10:
10564                     {
10565                       /** 1111 1101 0111 0010 0001 rdst fcmp    #%1, %0 */
10566 #line 855 "rx-decode.opc"
10567                       int rdst AU = op[2] & 0x0f;
10568                       if (trace)
10569                         {
10570                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10571                                  "/** 1111 1101 0111 0010 0001 rdst     fcmp    #%1, %0 */",
10572                                  op[0], op[1], op[2]);
10573                           printf ("  rdst = 0x%x\n", rdst);
10574                         }
10575                       SYNTAX("fcmp      #%1, %0");
10576 #line 855 "rx-decode.opc"
10577                       ID(fcmp); DR(rdst); SC(IMM(0)); F_OSZ_;
10578
10579                     }
10580                   break;
10581                 case 0x20:
10582                     {
10583                       /** 1111 1101 0111 0010 0010 rdst fadd    #%1, %0 */
10584 #line 849 "rx-decode.opc"
10585                       int rdst AU = op[2] & 0x0f;
10586                       if (trace)
10587                         {
10588                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10589                                  "/** 1111 1101 0111 0010 0010 rdst     fadd    #%1, %0 */",
10590                                  op[0], op[1], op[2]);
10591                           printf ("  rdst = 0x%x\n", rdst);
10592                         }
10593                       SYNTAX("fadd      #%1, %0");
10594 #line 849 "rx-decode.opc"
10595                       ID(fadd); DR(rdst); SC(IMM(0)); F__SZ_;
10596
10597                     }
10598                   break;
10599                 case 0x30:
10600                     {
10601                       /** 1111 1101 0111 0010 0011 rdst fmul    #%1, %0 */
10602 #line 870 "rx-decode.opc"
10603                       int rdst AU = op[2] & 0x0f;
10604                       if (trace)
10605                         {
10606                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10607                                  "/** 1111 1101 0111 0010 0011 rdst     fmul    #%1, %0 */",
10608                                  op[0], op[1], op[2]);
10609                           printf ("  rdst = 0x%x\n", rdst);
10610                         }
10611                       SYNTAX("fmul      #%1, %0");
10612 #line 870 "rx-decode.opc"
10613                       ID(fmul); DR(rdst); SC(IMM(0)); F__SZ_;
10614
10615                     }
10616                   break;
10617                 case 0x40:
10618                     {
10619                       /** 1111 1101 0111 0010 0100 rdst fdiv    #%1, %0 */
10620 #line 876 "rx-decode.opc"
10621                       int rdst AU = op[2] & 0x0f;
10622                       if (trace)
10623                         {
10624                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10625                                  "/** 1111 1101 0111 0010 0100 rdst     fdiv    #%1, %0 */",
10626                                  op[0], op[1], op[2]);
10627                           printf ("  rdst = 0x%x\n", rdst);
10628                         }
10629                       SYNTAX("fdiv      #%1, %0");
10630 #line 876 "rx-decode.opc"
10631                       ID(fdiv); DR(rdst); SC(IMM(0)); F__SZ_;
10632
10633                     }
10634                   break;
10635                 default: UNSUPPORTED(); break;
10636               }
10637             break;
10638           case 0x73:
10639               GETBYTE ();
10640               switch (op[2] & 0xe0)
10641               {
10642                 case 0x00:
10643                   op_semantics_89:
10644                     {
10645                       /** 1111 1101 0111 im11 000crdst  mvtc    #%1, %0 */
10646 #line 958 "rx-decode.opc"
10647                       int im AU = (op[1] >> 2) & 0x03;
10648 #line 958 "rx-decode.opc"
10649                       int crdst AU = op[2] & 0x1f;
10650                       if (trace)
10651                         {
10652                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10653                                  "/** 1111 1101 0111 im11 000crdst      mvtc    #%1, %0 */",
10654                                  op[0], op[1], op[2]);
10655                           printf ("  im = 0x%x,", im);
10656                           printf ("  crdst = 0x%x\n", crdst);
10657                         }
10658                       SYNTAX("mvtc      #%1, %0");
10659 #line 958 "rx-decode.opc"
10660                       ID(mov); SC(IMMex(im)); DR(crdst + 16);
10661
10662                     }
10663                   break;
10664                 default: UNSUPPORTED(); break;
10665               }
10666             break;
10667           case 0x74:
10668               GETBYTE ();
10669               switch (op[2] & 0xf0)
10670               {
10671                 case 0x20:
10672                   goto op_semantics_78;
10673                   break;
10674                 case 0x40:
10675                   goto op_semantics_79;
10676                   break;
10677                 case 0x50:
10678                   goto op_semantics_80;
10679                   break;
10680                 case 0x60:
10681                   goto op_semantics_81;
10682                   break;
10683                 case 0x70:
10684                   goto op_semantics_82;
10685                   break;
10686                 case 0x80:
10687                   goto op_semantics_83;
10688                   break;
10689                 case 0x90:
10690                   goto op_semantics_84;
10691                   break;
10692                 case 0xc0:
10693                   goto op_semantics_85;
10694                   break;
10695                 case 0xd0:
10696                   goto op_semantics_86;
10697                   break;
10698                 case 0xe0:
10699                   goto op_semantics_87;
10700                   break;
10701                 case 0xf0:
10702                   goto op_semantics_88;
10703                   break;
10704                 default: UNSUPPORTED(); break;
10705               }
10706             break;
10707           case 0x77:
10708               GETBYTE ();
10709               switch (op[2] & 0xe0)
10710               {
10711                 case 0x00:
10712                   goto op_semantics_89;
10713                   break;
10714                 default: UNSUPPORTED(); break;
10715               }
10716             break;
10717           case 0x78:
10718               GETBYTE ();
10719               switch (op[2] & 0xf0)
10720               {
10721                 case 0x20:
10722                   goto op_semantics_78;
10723                   break;
10724                 case 0x40:
10725                   goto op_semantics_79;
10726                   break;
10727                 case 0x50:
10728                   goto op_semantics_80;
10729                   break;
10730                 case 0x60:
10731                   goto op_semantics_81;
10732                   break;
10733                 case 0x70:
10734                   goto op_semantics_82;
10735                   break;
10736                 case 0x80:
10737                   goto op_semantics_83;
10738                   break;
10739                 case 0x90:
10740                   goto op_semantics_84;
10741                   break;
10742                 case 0xc0:
10743                   goto op_semantics_85;
10744                   break;
10745                 case 0xd0:
10746                   goto op_semantics_86;
10747                   break;
10748                 case 0xe0:
10749                   goto op_semantics_87;
10750                   break;
10751                 case 0xf0:
10752                   goto op_semantics_88;
10753                   break;
10754                 default: UNSUPPORTED(); break;
10755               }
10756             break;
10757           case 0x7b:
10758               GETBYTE ();
10759               switch (op[2] & 0xe0)
10760               {
10761                 case 0x00:
10762                   goto op_semantics_89;
10763                   break;
10764                 default: UNSUPPORTED(); break;
10765               }
10766             break;
10767           case 0x7c:
10768               GETBYTE ();
10769               switch (op[2] & 0xf0)
10770               {
10771                 case 0x20:
10772                   goto op_semantics_78;
10773                   break;
10774                 case 0x40:
10775                   goto op_semantics_79;
10776                   break;
10777                 case 0x50:
10778                   goto op_semantics_80;
10779                   break;
10780                 case 0x60:
10781                   goto op_semantics_81;
10782                   break;
10783                 case 0x70:
10784                   goto op_semantics_82;
10785                   break;
10786                 case 0x80:
10787                   goto op_semantics_83;
10788                   break;
10789                 case 0x90:
10790                   goto op_semantics_84;
10791                   break;
10792                 case 0xc0:
10793                   goto op_semantics_85;
10794                   break;
10795                 case 0xd0:
10796                   goto op_semantics_86;
10797                   break;
10798                 case 0xe0:
10799                   goto op_semantics_87;
10800                   break;
10801                 case 0xf0:
10802                   goto op_semantics_88;
10803                   break;
10804                 default: UNSUPPORTED(); break;
10805               }
10806             break;
10807           case 0x7f:
10808               GETBYTE ();
10809               switch (op[2] & 0xe0)
10810               {
10811                 case 0x00:
10812                   goto op_semantics_89;
10813                   break;
10814                 default: UNSUPPORTED(); break;
10815               }
10816             break;
10817           case 0x80:
10818               GETBYTE ();
10819               switch (op[2] & 0x00)
10820               {
10821                 case 0x00:
10822                   op_semantics_90:
10823                     {
10824                       /** 1111 1101 100immmm rsrc rdst  shlr    #%2, %1, %0 */
10825 #line 691 "rx-decode.opc"
10826                       int immmm AU = op[1] & 0x1f;
10827 #line 691 "rx-decode.opc"
10828                       int rsrc AU = (op[2] >> 4) & 0x0f;
10829 #line 691 "rx-decode.opc"
10830                       int rdst AU = op[2] & 0x0f;
10831                       if (trace)
10832                         {
10833                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10834                                  "/** 1111 1101 100immmm rsrc rdst      shlr    #%2, %1, %0 */",
10835                                  op[0], op[1], op[2]);
10836                           printf ("  immmm = 0x%x,", immmm);
10837                           printf ("  rsrc = 0x%x,", rsrc);
10838                           printf ("  rdst = 0x%x\n", rdst);
10839                         }
10840                       SYNTAX("shlr      #%2, %1, %0");
10841 #line 691 "rx-decode.opc"
10842                       ID(shlr); S2C(immmm); SR(rsrc); DR(rdst); F__SZC;
10843
10844                     /*----------------------------------------------------------------------*/
10845                     /* ROTATE                                                           */
10846
10847                     }
10848                   break;
10849               }
10850             break;
10851           case 0x81:
10852               GETBYTE ();
10853               switch (op[2] & 0x00)
10854               {
10855                 case 0x00:
10856                   goto op_semantics_90;
10857                   break;
10858               }
10859             break;
10860           case 0x82:
10861               GETBYTE ();
10862               switch (op[2] & 0x00)
10863               {
10864                 case 0x00:
10865                   goto op_semantics_90;
10866                   break;
10867               }
10868             break;
10869           case 0x83:
10870               GETBYTE ();
10871               switch (op[2] & 0x00)
10872               {
10873                 case 0x00:
10874                   goto op_semantics_90;
10875                   break;
10876               }
10877             break;
10878           case 0x84:
10879               GETBYTE ();
10880               switch (op[2] & 0x00)
10881               {
10882                 case 0x00:
10883                   goto op_semantics_90;
10884                   break;
10885               }
10886             break;
10887           case 0x85:
10888               GETBYTE ();
10889               switch (op[2] & 0x00)
10890               {
10891                 case 0x00:
10892                   goto op_semantics_90;
10893                   break;
10894               }
10895             break;
10896           case 0x86:
10897               GETBYTE ();
10898               switch (op[2] & 0x00)
10899               {
10900                 case 0x00:
10901                   goto op_semantics_90;
10902                   break;
10903               }
10904             break;
10905           case 0x87:
10906               GETBYTE ();
10907               switch (op[2] & 0x00)
10908               {
10909                 case 0x00:
10910                   goto op_semantics_90;
10911                   break;
10912               }
10913             break;
10914           case 0x88:
10915               GETBYTE ();
10916               switch (op[2] & 0x00)
10917               {
10918                 case 0x00:
10919                   goto op_semantics_90;
10920                   break;
10921               }
10922             break;
10923           case 0x89:
10924               GETBYTE ();
10925               switch (op[2] & 0x00)
10926               {
10927                 case 0x00:
10928                   goto op_semantics_90;
10929                   break;
10930               }
10931             break;
10932           case 0x8a:
10933               GETBYTE ();
10934               switch (op[2] & 0x00)
10935               {
10936                 case 0x00:
10937                   goto op_semantics_90;
10938                   break;
10939               }
10940             break;
10941           case 0x8b:
10942               GETBYTE ();
10943               switch (op[2] & 0x00)
10944               {
10945                 case 0x00:
10946                   goto op_semantics_90;
10947                   break;
10948               }
10949             break;
10950           case 0x8c:
10951               GETBYTE ();
10952               switch (op[2] & 0x00)
10953               {
10954                 case 0x00:
10955                   goto op_semantics_90;
10956                   break;
10957               }
10958             break;
10959           case 0x8d:
10960               GETBYTE ();
10961               switch (op[2] & 0x00)
10962               {
10963                 case 0x00:
10964                   goto op_semantics_90;
10965                   break;
10966               }
10967             break;
10968           case 0x8e:
10969               GETBYTE ();
10970               switch (op[2] & 0x00)
10971               {
10972                 case 0x00:
10973                   goto op_semantics_90;
10974                   break;
10975               }
10976             break;
10977           case 0x8f:
10978               GETBYTE ();
10979               switch (op[2] & 0x00)
10980               {
10981                 case 0x00:
10982                   goto op_semantics_90;
10983                   break;
10984               }
10985             break;
10986           case 0x90:
10987               GETBYTE ();
10988               switch (op[2] & 0x00)
10989               {
10990                 case 0x00:
10991                   goto op_semantics_90;
10992                   break;
10993               }
10994             break;
10995           case 0x91:
10996               GETBYTE ();
10997               switch (op[2] & 0x00)
10998               {
10999                 case 0x00:
11000                   goto op_semantics_90;
11001                   break;
11002               }
11003             break;
11004           case 0x92:
11005               GETBYTE ();
11006               switch (op[2] & 0x00)
11007               {
11008                 case 0x00:
11009                   goto op_semantics_90;
11010                   break;
11011               }
11012             break;
11013           case 0x93:
11014               GETBYTE ();
11015               switch (op[2] & 0x00)
11016               {
11017                 case 0x00:
11018                   goto op_semantics_90;
11019                   break;
11020               }
11021             break;
11022           case 0x94:
11023               GETBYTE ();
11024               switch (op[2] & 0x00)
11025               {
11026                 case 0x00:
11027                   goto op_semantics_90;
11028                   break;
11029               }
11030             break;
11031           case 0x95:
11032               GETBYTE ();
11033               switch (op[2] & 0x00)
11034               {
11035                 case 0x00:
11036                   goto op_semantics_90;
11037                   break;
11038               }
11039             break;
11040           case 0x96:
11041               GETBYTE ();
11042               switch (op[2] & 0x00)
11043               {
11044                 case 0x00:
11045                   goto op_semantics_90;
11046                   break;
11047               }
11048             break;
11049           case 0x97:
11050               GETBYTE ();
11051               switch (op[2] & 0x00)
11052               {
11053                 case 0x00:
11054                   goto op_semantics_90;
11055                   break;
11056               }
11057             break;
11058           case 0x98:
11059               GETBYTE ();
11060               switch (op[2] & 0x00)
11061               {
11062                 case 0x00:
11063                   goto op_semantics_90;
11064                   break;
11065               }
11066             break;
11067           case 0x99:
11068               GETBYTE ();
11069               switch (op[2] & 0x00)
11070               {
11071                 case 0x00:
11072                   goto op_semantics_90;
11073                   break;
11074               }
11075             break;
11076           case 0x9a:
11077               GETBYTE ();
11078               switch (op[2] & 0x00)
11079               {
11080                 case 0x00:
11081                   goto op_semantics_90;
11082                   break;
11083               }
11084             break;
11085           case 0x9b:
11086               GETBYTE ();
11087               switch (op[2] & 0x00)
11088               {
11089                 case 0x00:
11090                   goto op_semantics_90;
11091                   break;
11092               }
11093             break;
11094           case 0x9c:
11095               GETBYTE ();
11096               switch (op[2] & 0x00)
11097               {
11098                 case 0x00:
11099                   goto op_semantics_90;
11100                   break;
11101               }
11102             break;
11103           case 0x9d:
11104               GETBYTE ();
11105               switch (op[2] & 0x00)
11106               {
11107                 case 0x00:
11108                   goto op_semantics_90;
11109                   break;
11110               }
11111             break;
11112           case 0x9e:
11113               GETBYTE ();
11114               switch (op[2] & 0x00)
11115               {
11116                 case 0x00:
11117                   goto op_semantics_90;
11118                   break;
11119               }
11120             break;
11121           case 0x9f:
11122               GETBYTE ();
11123               switch (op[2] & 0x00)
11124               {
11125                 case 0x00:
11126                   goto op_semantics_90;
11127                   break;
11128               }
11129             break;
11130           case 0xa0:
11131               GETBYTE ();
11132               switch (op[2] & 0x00)
11133               {
11134                 case 0x00:
11135                   op_semantics_91:
11136                     {
11137                       /** 1111 1101 101immmm rsrc rdst  shar    #%2, %1, %0 */
11138 #line 681 "rx-decode.opc"
11139                       int immmm AU = op[1] & 0x1f;
11140 #line 681 "rx-decode.opc"
11141                       int rsrc AU = (op[2] >> 4) & 0x0f;
11142 #line 681 "rx-decode.opc"
11143                       int rdst AU = op[2] & 0x0f;
11144                       if (trace)
11145                         {
11146                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11147                                  "/** 1111 1101 101immmm rsrc rdst      shar    #%2, %1, %0 */",
11148                                  op[0], op[1], op[2]);
11149                           printf ("  immmm = 0x%x,", immmm);
11150                           printf ("  rsrc = 0x%x,", rsrc);
11151                           printf ("  rdst = 0x%x\n", rdst);
11152                         }
11153                       SYNTAX("shar      #%2, %1, %0");
11154 #line 681 "rx-decode.opc"
11155                       ID(shar); S2C(immmm); SR(rsrc); DR(rdst); F_0SZC;
11156
11157
11158                     }
11159                   break;
11160               }
11161             break;
11162           case 0xa1:
11163               GETBYTE ();
11164               switch (op[2] & 0x00)
11165               {
11166                 case 0x00:
11167                   goto op_semantics_91;
11168                   break;
11169               }
11170             break;
11171           case 0xa2:
11172               GETBYTE ();
11173               switch (op[2] & 0x00)
11174               {
11175                 case 0x00:
11176                   goto op_semantics_91;
11177                   break;
11178               }
11179             break;
11180           case 0xa3:
11181               GETBYTE ();
11182               switch (op[2] & 0x00)
11183               {
11184                 case 0x00:
11185                   goto op_semantics_91;
11186                   break;
11187               }
11188             break;
11189           case 0xa4:
11190               GETBYTE ();
11191               switch (op[2] & 0x00)
11192               {
11193                 case 0x00:
11194                   goto op_semantics_91;
11195                   break;
11196               }
11197             break;
11198           case 0xa5:
11199               GETBYTE ();
11200               switch (op[2] & 0x00)
11201               {
11202                 case 0x00:
11203                   goto op_semantics_91;
11204                   break;
11205               }
11206             break;
11207           case 0xa6:
11208               GETBYTE ();
11209               switch (op[2] & 0x00)
11210               {
11211                 case 0x00:
11212                   goto op_semantics_91;
11213                   break;
11214               }
11215             break;
11216           case 0xa7:
11217               GETBYTE ();
11218               switch (op[2] & 0x00)
11219               {
11220                 case 0x00:
11221                   goto op_semantics_91;
11222                   break;
11223               }
11224             break;
11225           case 0xa8:
11226               GETBYTE ();
11227               switch (op[2] & 0x00)
11228               {
11229                 case 0x00:
11230                   goto op_semantics_91;
11231                   break;
11232               }
11233             break;
11234           case 0xa9:
11235               GETBYTE ();
11236               switch (op[2] & 0x00)
11237               {
11238                 case 0x00:
11239                   goto op_semantics_91;
11240                   break;
11241               }
11242             break;
11243           case 0xaa:
11244               GETBYTE ();
11245               switch (op[2] & 0x00)
11246               {
11247                 case 0x00:
11248                   goto op_semantics_91;
11249                   break;
11250               }
11251             break;
11252           case 0xab:
11253               GETBYTE ();
11254               switch (op[2] & 0x00)
11255               {
11256                 case 0x00:
11257                   goto op_semantics_91;
11258                   break;
11259               }
11260             break;
11261           case 0xac:
11262               GETBYTE ();
11263               switch (op[2] & 0x00)
11264               {
11265                 case 0x00:
11266                   goto op_semantics_91;
11267                   break;
11268               }
11269             break;
11270           case 0xad:
11271               GETBYTE ();
11272               switch (op[2] & 0x00)
11273               {
11274                 case 0x00:
11275                   goto op_semantics_91;
11276                   break;
11277               }
11278             break;
11279           case 0xae:
11280               GETBYTE ();
11281               switch (op[2] & 0x00)
11282               {
11283                 case 0x00:
11284                   goto op_semantics_91;
11285                   break;
11286               }
11287             break;
11288           case 0xaf:
11289               GETBYTE ();
11290               switch (op[2] & 0x00)
11291               {
11292                 case 0x00:
11293                   goto op_semantics_91;
11294                   break;
11295               }
11296             break;
11297           case 0xb0:
11298               GETBYTE ();
11299               switch (op[2] & 0x00)
11300               {
11301                 case 0x00:
11302                   goto op_semantics_91;
11303                   break;
11304               }
11305             break;
11306           case 0xb1:
11307               GETBYTE ();
11308               switch (op[2] & 0x00)
11309               {
11310                 case 0x00:
11311                   goto op_semantics_91;
11312                   break;
11313               }
11314             break;
11315           case 0xb2:
11316               GETBYTE ();
11317               switch (op[2] & 0x00)
11318               {
11319                 case 0x00:
11320                   goto op_semantics_91;
11321                   break;
11322               }
11323             break;
11324           case 0xb3:
11325               GETBYTE ();
11326               switch (op[2] & 0x00)
11327               {
11328                 case 0x00:
11329                   goto op_semantics_91;
11330                   break;
11331               }
11332             break;
11333           case 0xb4:
11334               GETBYTE ();
11335               switch (op[2] & 0x00)
11336               {
11337                 case 0x00:
11338                   goto op_semantics_91;
11339                   break;
11340               }
11341             break;
11342           case 0xb5:
11343               GETBYTE ();
11344               switch (op[2] & 0x00)
11345               {
11346                 case 0x00:
11347                   goto op_semantics_91;
11348                   break;
11349               }
11350             break;
11351           case 0xb6:
11352               GETBYTE ();
11353               switch (op[2] & 0x00)
11354               {
11355                 case 0x00:
11356                   goto op_semantics_91;
11357                   break;
11358               }
11359             break;
11360           case 0xb7:
11361               GETBYTE ();
11362               switch (op[2] & 0x00)
11363               {
11364                 case 0x00:
11365                   goto op_semantics_91;
11366                   break;
11367               }
11368             break;
11369           case 0xb8:
11370               GETBYTE ();
11371               switch (op[2] & 0x00)
11372               {
11373                 case 0x00:
11374                   goto op_semantics_91;
11375                   break;
11376               }
11377             break;
11378           case 0xb9:
11379               GETBYTE ();
11380               switch (op[2] & 0x00)
11381               {
11382                 case 0x00:
11383                   goto op_semantics_91;
11384                   break;
11385               }
11386             break;
11387           case 0xba:
11388               GETBYTE ();
11389               switch (op[2] & 0x00)
11390               {
11391                 case 0x00:
11392                   goto op_semantics_91;
11393                   break;
11394               }
11395             break;
11396           case 0xbb:
11397               GETBYTE ();
11398               switch (op[2] & 0x00)
11399               {
11400                 case 0x00:
11401                   goto op_semantics_91;
11402                   break;
11403               }
11404             break;
11405           case 0xbc:
11406               GETBYTE ();
11407               switch (op[2] & 0x00)
11408               {
11409                 case 0x00:
11410                   goto op_semantics_91;
11411                   break;
11412               }
11413             break;
11414           case 0xbd:
11415               GETBYTE ();
11416               switch (op[2] & 0x00)
11417               {
11418                 case 0x00:
11419                   goto op_semantics_91;
11420                   break;
11421               }
11422             break;
11423           case 0xbe:
11424               GETBYTE ();
11425               switch (op[2] & 0x00)
11426               {
11427                 case 0x00:
11428                   goto op_semantics_91;
11429                   break;
11430               }
11431             break;
11432           case 0xbf:
11433               GETBYTE ();
11434               switch (op[2] & 0x00)
11435               {
11436                 case 0x00:
11437                   goto op_semantics_91;
11438                   break;
11439               }
11440             break;
11441           case 0xc0:
11442               GETBYTE ();
11443               switch (op[2] & 0x00)
11444               {
11445                 case 0x00:
11446                   op_semantics_92:
11447                     {
11448                       /** 1111 1101 110immmm rsrc rdst  shll    #%2, %1, %0 */
11449 #line 671 "rx-decode.opc"
11450                       int immmm AU = op[1] & 0x1f;
11451 #line 671 "rx-decode.opc"
11452                       int rsrc AU = (op[2] >> 4) & 0x0f;
11453 #line 671 "rx-decode.opc"
11454                       int rdst AU = op[2] & 0x0f;
11455                       if (trace)
11456                         {
11457                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11458                                  "/** 1111 1101 110immmm rsrc rdst      shll    #%2, %1, %0 */",
11459                                  op[0], op[1], op[2]);
11460                           printf ("  immmm = 0x%x,", immmm);
11461                           printf ("  rsrc = 0x%x,", rsrc);
11462                           printf ("  rdst = 0x%x\n", rdst);
11463                         }
11464                       SYNTAX("shll      #%2, %1, %0");
11465 #line 671 "rx-decode.opc"
11466                       ID(shll); S2C(immmm); SR(rsrc); DR(rdst); F_OSZC;
11467
11468
11469                     }
11470                   break;
11471               }
11472             break;
11473           case 0xc1:
11474               GETBYTE ();
11475               switch (op[2] & 0x00)
11476               {
11477                 case 0x00:
11478                   goto op_semantics_92;
11479                   break;
11480               }
11481             break;
11482           case 0xc2:
11483               GETBYTE ();
11484               switch (op[2] & 0x00)
11485               {
11486                 case 0x00:
11487                   goto op_semantics_92;
11488                   break;
11489               }
11490             break;
11491           case 0xc3:
11492               GETBYTE ();
11493               switch (op[2] & 0x00)
11494               {
11495                 case 0x00:
11496                   goto op_semantics_92;
11497                   break;
11498               }
11499             break;
11500           case 0xc4:
11501               GETBYTE ();
11502               switch (op[2] & 0x00)
11503               {
11504                 case 0x00:
11505                   goto op_semantics_92;
11506                   break;
11507               }
11508             break;
11509           case 0xc5:
11510               GETBYTE ();
11511               switch (op[2] & 0x00)
11512               {
11513                 case 0x00:
11514                   goto op_semantics_92;
11515                   break;
11516               }
11517             break;
11518           case 0xc6:
11519               GETBYTE ();
11520               switch (op[2] & 0x00)
11521               {
11522                 case 0x00:
11523                   goto op_semantics_92;
11524                   break;
11525               }
11526             break;
11527           case 0xc7:
11528               GETBYTE ();
11529               switch (op[2] & 0x00)
11530               {
11531                 case 0x00:
11532                   goto op_semantics_92;
11533                   break;
11534               }
11535             break;
11536           case 0xc8:
11537               GETBYTE ();
11538               switch (op[2] & 0x00)
11539               {
11540                 case 0x00:
11541                   goto op_semantics_92;
11542                   break;
11543               }
11544             break;
11545           case 0xc9:
11546               GETBYTE ();
11547               switch (op[2] & 0x00)
11548               {
11549                 case 0x00:
11550                   goto op_semantics_92;
11551                   break;
11552               }
11553             break;
11554           case 0xca:
11555               GETBYTE ();
11556               switch (op[2] & 0x00)
11557               {
11558                 case 0x00:
11559                   goto op_semantics_92;
11560                   break;
11561               }
11562             break;
11563           case 0xcb:
11564               GETBYTE ();
11565               switch (op[2] & 0x00)
11566               {
11567                 case 0x00:
11568                   goto op_semantics_92;
11569                   break;
11570               }
11571             break;
11572           case 0xcc:
11573               GETBYTE ();
11574               switch (op[2] & 0x00)
11575               {
11576                 case 0x00:
11577                   goto op_semantics_92;
11578                   break;
11579               }
11580             break;
11581           case 0xcd:
11582               GETBYTE ();
11583               switch (op[2] & 0x00)
11584               {
11585                 case 0x00:
11586                   goto op_semantics_92;
11587                   break;
11588               }
11589             break;
11590           case 0xce:
11591               GETBYTE ();
11592               switch (op[2] & 0x00)
11593               {
11594                 case 0x00:
11595                   goto op_semantics_92;
11596                   break;
11597               }
11598             break;
11599           case 0xcf:
11600               GETBYTE ();
11601               switch (op[2] & 0x00)
11602               {
11603                 case 0x00:
11604                   goto op_semantics_92;
11605                   break;
11606               }
11607             break;
11608           case 0xd0:
11609               GETBYTE ();
11610               switch (op[2] & 0x00)
11611               {
11612                 case 0x00:
11613                   goto op_semantics_92;
11614                   break;
11615               }
11616             break;
11617           case 0xd1:
11618               GETBYTE ();
11619               switch (op[2] & 0x00)
11620               {
11621                 case 0x00:
11622                   goto op_semantics_92;
11623                   break;
11624               }
11625             break;
11626           case 0xd2:
11627               GETBYTE ();
11628               switch (op[2] & 0x00)
11629               {
11630                 case 0x00:
11631                   goto op_semantics_92;
11632                   break;
11633               }
11634             break;
11635           case 0xd3:
11636               GETBYTE ();
11637               switch (op[2] & 0x00)
11638               {
11639                 case 0x00:
11640                   goto op_semantics_92;
11641                   break;
11642               }
11643             break;
11644           case 0xd4:
11645               GETBYTE ();
11646               switch (op[2] & 0x00)
11647               {
11648                 case 0x00:
11649                   goto op_semantics_92;
11650                   break;
11651               }
11652             break;
11653           case 0xd5:
11654               GETBYTE ();
11655               switch (op[2] & 0x00)
11656               {
11657                 case 0x00:
11658                   goto op_semantics_92;
11659                   break;
11660               }
11661             break;
11662           case 0xd6:
11663               GETBYTE ();
11664               switch (op[2] & 0x00)
11665               {
11666                 case 0x00:
11667                   goto op_semantics_92;
11668                   break;
11669               }
11670             break;
11671           case 0xd7:
11672               GETBYTE ();
11673               switch (op[2] & 0x00)
11674               {
11675                 case 0x00:
11676                   goto op_semantics_92;
11677                   break;
11678               }
11679             break;
11680           case 0xd8:
11681               GETBYTE ();
11682               switch (op[2] & 0x00)
11683               {
11684                 case 0x00:
11685                   goto op_semantics_92;
11686                   break;
11687               }
11688             break;
11689           case 0xd9:
11690               GETBYTE ();
11691               switch (op[2] & 0x00)
11692               {
11693                 case 0x00:
11694                   goto op_semantics_92;
11695                   break;
11696               }
11697             break;
11698           case 0xda:
11699               GETBYTE ();
11700               switch (op[2] & 0x00)
11701               {
11702                 case 0x00:
11703                   goto op_semantics_92;
11704                   break;
11705               }
11706             break;
11707           case 0xdb:
11708               GETBYTE ();
11709               switch (op[2] & 0x00)
11710               {
11711                 case 0x00:
11712                   goto op_semantics_92;
11713                   break;
11714               }
11715             break;
11716           case 0xdc:
11717               GETBYTE ();
11718               switch (op[2] & 0x00)
11719               {
11720                 case 0x00:
11721                   goto op_semantics_92;
11722                   break;
11723               }
11724             break;
11725           case 0xdd:
11726               GETBYTE ();
11727               switch (op[2] & 0x00)
11728               {
11729                 case 0x00:
11730                   goto op_semantics_92;
11731                   break;
11732               }
11733             break;
11734           case 0xde:
11735               GETBYTE ();
11736               switch (op[2] & 0x00)
11737               {
11738                 case 0x00:
11739                   goto op_semantics_92;
11740                   break;
11741               }
11742             break;
11743           case 0xdf:
11744               GETBYTE ();
11745               switch (op[2] & 0x00)
11746               {
11747                 case 0x00:
11748                   goto op_semantics_92;
11749                   break;
11750               }
11751             break;
11752           case 0xe0:
11753               GETBYTE ();
11754               switch (op[2] & 0xf0)
11755               {
11756                 case 0x00:
11757                 case 0x10:
11758                 case 0x20:
11759                 case 0x30:
11760                 case 0x40:
11761                 case 0x50:
11762                 case 0x60:
11763                 case 0x70:
11764                 case 0x80:
11765                 case 0x90:
11766                 case 0xa0:
11767                 case 0xb0:
11768                 case 0xc0:
11769                 case 0xd0:
11770                 case 0xe0:
11771                   op_semantics_93:
11772                     {
11773                       /** 1111 1101 111 bittt cond rdst bm%2    #%1, %0%S0 */
11774 #line 937 "rx-decode.opc"
11775                       int bittt AU = op[1] & 0x1f;
11776 #line 937 "rx-decode.opc"
11777                       int cond AU = (op[2] >> 4) & 0x0f;
11778 #line 937 "rx-decode.opc"
11779                       int rdst AU = op[2] & 0x0f;
11780                       if (trace)
11781                         {
11782                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11783                                  "/** 1111 1101 111 bittt cond rdst     bm%2    #%1, %0%S0 */",
11784                                  op[0], op[1], op[2]);
11785                           printf ("  bittt = 0x%x,", bittt);
11786                           printf ("  cond = 0x%x,", cond);
11787                           printf ("  rdst = 0x%x\n", rdst);
11788                         }
11789                       SYNTAX("bm%2      #%1, %0%S0");
11790 #line 937 "rx-decode.opc"
11791                       ID(bmcc); BWL(LSIZE); S2cc(cond); SC(bittt); DR(rdst);
11792
11793                     /*----------------------------------------------------------------------*/
11794                     /* CONTROL REGISTERS                                                        */
11795
11796                     }
11797                   break;
11798                 case 0xf0:
11799                   op_semantics_94:
11800                     {
11801                       /** 1111 1101 111bittt 1111 rdst  bnot    #%1, %0 */
11802 #line 930 "rx-decode.opc"
11803                       int bittt AU = op[1] & 0x1f;
11804 #line 930 "rx-decode.opc"
11805                       int rdst AU = op[2] & 0x0f;
11806                       if (trace)
11807                         {
11808                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11809                                  "/** 1111 1101 111bittt 1111 rdst      bnot    #%1, %0 */",
11810                                  op[0], op[1], op[2]);
11811                           printf ("  bittt = 0x%x,", bittt);
11812                           printf ("  rdst = 0x%x\n", rdst);
11813                         }
11814                       SYNTAX("bnot      #%1, %0");
11815 #line 930 "rx-decode.opc"
11816                       ID(bnot); BWL(LSIZE); SC(bittt); DR(rdst);
11817
11818
11819                     }
11820                   break;
11821               }
11822             break;
11823           case 0xe1:
11824               GETBYTE ();
11825               switch (op[2] & 0xf0)
11826               {
11827                 case 0x00:
11828                 case 0x10:
11829                 case 0x20:
11830                 case 0x30:
11831                 case 0x40:
11832                 case 0x50:
11833                 case 0x60:
11834                 case 0x70:
11835                 case 0x80:
11836                 case 0x90:
11837                 case 0xa0:
11838                 case 0xb0:
11839                 case 0xc0:
11840                 case 0xd0:
11841                 case 0xe0:
11842                   goto op_semantics_93;
11843                   break;
11844                 case 0xf0:
11845                   goto op_semantics_94;
11846                   break;
11847               }
11848             break;
11849           case 0xe2:
11850               GETBYTE ();
11851               switch (op[2] & 0xf0)
11852               {
11853                 case 0x00:
11854                 case 0x10:
11855                 case 0x20:
11856                 case 0x30:
11857                 case 0x40:
11858                 case 0x50:
11859                 case 0x60:
11860                 case 0x70:
11861                 case 0x80:
11862                 case 0x90:
11863                 case 0xa0:
11864                 case 0xb0:
11865                 case 0xc0:
11866                 case 0xd0:
11867                 case 0xe0:
11868                   goto op_semantics_93;
11869                   break;
11870                 case 0xf0:
11871                   goto op_semantics_94;
11872                   break;
11873               }
11874             break;
11875           case 0xe3:
11876               GETBYTE ();
11877               switch (op[2] & 0xf0)
11878               {
11879                 case 0x00:
11880                 case 0x10:
11881                 case 0x20:
11882                 case 0x30:
11883                 case 0x40:
11884                 case 0x50:
11885                 case 0x60:
11886                 case 0x70:
11887                 case 0x80:
11888                 case 0x90:
11889                 case 0xa0:
11890                 case 0xb0:
11891                 case 0xc0:
11892                 case 0xd0:
11893                 case 0xe0:
11894                   goto op_semantics_93;
11895                   break;
11896                 case 0xf0:
11897                   goto op_semantics_94;
11898                   break;
11899               }
11900             break;
11901           case 0xe4:
11902               GETBYTE ();
11903               switch (op[2] & 0xf0)
11904               {
11905                 case 0x00:
11906                 case 0x10:
11907                 case 0x20:
11908                 case 0x30:
11909                 case 0x40:
11910                 case 0x50:
11911                 case 0x60:
11912                 case 0x70:
11913                 case 0x80:
11914                 case 0x90:
11915                 case 0xa0:
11916                 case 0xb0:
11917                 case 0xc0:
11918                 case 0xd0:
11919                 case 0xe0:
11920                   goto op_semantics_93;
11921                   break;
11922                 case 0xf0:
11923                   goto op_semantics_94;
11924                   break;
11925               }
11926             break;
11927           case 0xe5:
11928               GETBYTE ();
11929               switch (op[2] & 0xf0)
11930               {
11931                 case 0x00:
11932                 case 0x10:
11933                 case 0x20:
11934                 case 0x30:
11935                 case 0x40:
11936                 case 0x50:
11937                 case 0x60:
11938                 case 0x70:
11939                 case 0x80:
11940                 case 0x90:
11941                 case 0xa0:
11942                 case 0xb0:
11943                 case 0xc0:
11944                 case 0xd0:
11945                 case 0xe0:
11946                   goto op_semantics_93;
11947                   break;
11948                 case 0xf0:
11949                   goto op_semantics_94;
11950                   break;
11951               }
11952             break;
11953           case 0xe6:
11954               GETBYTE ();
11955               switch (op[2] & 0xf0)
11956               {
11957                 case 0x00:
11958                 case 0x10:
11959                 case 0x20:
11960                 case 0x30:
11961                 case 0x40:
11962                 case 0x50:
11963                 case 0x60:
11964                 case 0x70:
11965                 case 0x80:
11966                 case 0x90:
11967                 case 0xa0:
11968                 case 0xb0:
11969                 case 0xc0:
11970                 case 0xd0:
11971                 case 0xe0:
11972                   goto op_semantics_93;
11973                   break;
11974                 case 0xf0:
11975                   goto op_semantics_94;
11976                   break;
11977               }
11978             break;
11979           case 0xe7:
11980               GETBYTE ();
11981               switch (op[2] & 0xf0)
11982               {
11983                 case 0x00:
11984                 case 0x10:
11985                 case 0x20:
11986                 case 0x30:
11987                 case 0x40:
11988                 case 0x50:
11989                 case 0x60:
11990                 case 0x70:
11991                 case 0x80:
11992                 case 0x90:
11993                 case 0xa0:
11994                 case 0xb0:
11995                 case 0xc0:
11996                 case 0xd0:
11997                 case 0xe0:
11998                   goto op_semantics_93;
11999                   break;
12000                 case 0xf0:
12001                   goto op_semantics_94;
12002                   break;
12003               }
12004             break;
12005           case 0xe8:
12006               GETBYTE ();
12007               switch (op[2] & 0xf0)
12008               {
12009                 case 0x00:
12010                 case 0x10:
12011                 case 0x20:
12012                 case 0x30:
12013                 case 0x40:
12014                 case 0x50:
12015                 case 0x60:
12016                 case 0x70:
12017                 case 0x80:
12018                 case 0x90:
12019                 case 0xa0:
12020                 case 0xb0:
12021                 case 0xc0:
12022                 case 0xd0:
12023                 case 0xe0:
12024                   goto op_semantics_93;
12025                   break;
12026                 case 0xf0:
12027                   goto op_semantics_94;
12028                   break;
12029               }
12030             break;
12031           case 0xe9:
12032               GETBYTE ();
12033               switch (op[2] & 0xf0)
12034               {
12035                 case 0x00:
12036                 case 0x10:
12037                 case 0x20:
12038                 case 0x30:
12039                 case 0x40:
12040                 case 0x50:
12041                 case 0x60:
12042                 case 0x70:
12043                 case 0x80:
12044                 case 0x90:
12045                 case 0xa0:
12046                 case 0xb0:
12047                 case 0xc0:
12048                 case 0xd0:
12049                 case 0xe0:
12050                   goto op_semantics_93;
12051                   break;
12052                 case 0xf0:
12053                   goto op_semantics_94;
12054                   break;
12055               }
12056             break;
12057           case 0xea:
12058               GETBYTE ();
12059               switch (op[2] & 0xf0)
12060               {
12061                 case 0x00:
12062                 case 0x10:
12063                 case 0x20:
12064                 case 0x30:
12065                 case 0x40:
12066                 case 0x50:
12067                 case 0x60:
12068                 case 0x70:
12069                 case 0x80:
12070                 case 0x90:
12071                 case 0xa0:
12072                 case 0xb0:
12073                 case 0xc0:
12074                 case 0xd0:
12075                 case 0xe0:
12076                   goto op_semantics_93;
12077                   break;
12078                 case 0xf0:
12079                   goto op_semantics_94;
12080                   break;
12081               }
12082             break;
12083           case 0xeb:
12084               GETBYTE ();
12085               switch (op[2] & 0xf0)
12086               {
12087                 case 0x00:
12088                 case 0x10:
12089                 case 0x20:
12090                 case 0x30:
12091                 case 0x40:
12092                 case 0x50:
12093                 case 0x60:
12094                 case 0x70:
12095                 case 0x80:
12096                 case 0x90:
12097                 case 0xa0:
12098                 case 0xb0:
12099                 case 0xc0:
12100                 case 0xd0:
12101                 case 0xe0:
12102                   goto op_semantics_93;
12103                   break;
12104                 case 0xf0:
12105                   goto op_semantics_94;
12106                   break;
12107               }
12108             break;
12109           case 0xec:
12110               GETBYTE ();
12111               switch (op[2] & 0xf0)
12112               {
12113                 case 0x00:
12114                 case 0x10:
12115                 case 0x20:
12116                 case 0x30:
12117                 case 0x40:
12118                 case 0x50:
12119                 case 0x60:
12120                 case 0x70:
12121                 case 0x80:
12122                 case 0x90:
12123                 case 0xa0:
12124                 case 0xb0:
12125                 case 0xc0:
12126                 case 0xd0:
12127                 case 0xe0:
12128                   goto op_semantics_93;
12129                   break;
12130                 case 0xf0:
12131                   goto op_semantics_94;
12132                   break;
12133               }
12134             break;
12135           case 0xed:
12136               GETBYTE ();
12137               switch (op[2] & 0xf0)
12138               {
12139                 case 0x00:
12140                 case 0x10:
12141                 case 0x20:
12142                 case 0x30:
12143                 case 0x40:
12144                 case 0x50:
12145                 case 0x60:
12146                 case 0x70:
12147                 case 0x80:
12148                 case 0x90:
12149                 case 0xa0:
12150                 case 0xb0:
12151                 case 0xc0:
12152                 case 0xd0:
12153                 case 0xe0:
12154                   goto op_semantics_93;
12155                   break;
12156                 case 0xf0:
12157                   goto op_semantics_94;
12158                   break;
12159               }
12160             break;
12161           case 0xee:
12162               GETBYTE ();
12163               switch (op[2] & 0xf0)
12164               {
12165                 case 0x00:
12166                 case 0x10:
12167                 case 0x20:
12168                 case 0x30:
12169                 case 0x40:
12170                 case 0x50:
12171                 case 0x60:
12172                 case 0x70:
12173                 case 0x80:
12174                 case 0x90:
12175                 case 0xa0:
12176                 case 0xb0:
12177                 case 0xc0:
12178                 case 0xd0:
12179                 case 0xe0:
12180                   goto op_semantics_93;
12181                   break;
12182                 case 0xf0:
12183                   goto op_semantics_94;
12184                   break;
12185               }
12186             break;
12187           case 0xef:
12188               GETBYTE ();
12189               switch (op[2] & 0xf0)
12190               {
12191                 case 0x00:
12192                 case 0x10:
12193                 case 0x20:
12194                 case 0x30:
12195                 case 0x40:
12196                 case 0x50:
12197                 case 0x60:
12198                 case 0x70:
12199                 case 0x80:
12200                 case 0x90:
12201                 case 0xa0:
12202                 case 0xb0:
12203                 case 0xc0:
12204                 case 0xd0:
12205                 case 0xe0:
12206                   goto op_semantics_93;
12207                   break;
12208                 case 0xf0:
12209                   goto op_semantics_94;
12210                   break;
12211               }
12212             break;
12213           case 0xf0:
12214               GETBYTE ();
12215               switch (op[2] & 0xf0)
12216               {
12217                 case 0x00:
12218                 case 0x10:
12219                 case 0x20:
12220                 case 0x30:
12221                 case 0x40:
12222                 case 0x50:
12223                 case 0x60:
12224                 case 0x70:
12225                 case 0x80:
12226                 case 0x90:
12227                 case 0xa0:
12228                 case 0xb0:
12229                 case 0xc0:
12230                 case 0xd0:
12231                 case 0xe0:
12232                   goto op_semantics_93;
12233                   break;
12234                 case 0xf0:
12235                   goto op_semantics_94;
12236                   break;
12237               }
12238             break;
12239           case 0xf1:
12240               GETBYTE ();
12241               switch (op[2] & 0xf0)
12242               {
12243                 case 0x00:
12244                 case 0x10:
12245                 case 0x20:
12246                 case 0x30:
12247                 case 0x40:
12248                 case 0x50:
12249                 case 0x60:
12250                 case 0x70:
12251                 case 0x80:
12252                 case 0x90:
12253                 case 0xa0:
12254                 case 0xb0:
12255                 case 0xc0:
12256                 case 0xd0:
12257                 case 0xe0:
12258                   goto op_semantics_93;
12259                   break;
12260                 case 0xf0:
12261                   goto op_semantics_94;
12262                   break;
12263               }
12264             break;
12265           case 0xf2:
12266               GETBYTE ();
12267               switch (op[2] & 0xf0)
12268               {
12269                 case 0x00:
12270                 case 0x10:
12271                 case 0x20:
12272                 case 0x30:
12273                 case 0x40:
12274                 case 0x50:
12275                 case 0x60:
12276                 case 0x70:
12277                 case 0x80:
12278                 case 0x90:
12279                 case 0xa0:
12280                 case 0xb0:
12281                 case 0xc0:
12282                 case 0xd0:
12283                 case 0xe0:
12284                   goto op_semantics_93;
12285                   break;
12286                 case 0xf0:
12287                   goto op_semantics_94;
12288                   break;
12289               }
12290             break;
12291           case 0xf3:
12292               GETBYTE ();
12293               switch (op[2] & 0xf0)
12294               {
12295                 case 0x00:
12296                 case 0x10:
12297                 case 0x20:
12298                 case 0x30:
12299                 case 0x40:
12300                 case 0x50:
12301                 case 0x60:
12302                 case 0x70:
12303                 case 0x80:
12304                 case 0x90:
12305                 case 0xa0:
12306                 case 0xb0:
12307                 case 0xc0:
12308                 case 0xd0:
12309                 case 0xe0:
12310                   goto op_semantics_93;
12311                   break;
12312                 case 0xf0:
12313                   goto op_semantics_94;
12314                   break;
12315               }
12316             break;
12317           case 0xf4:
12318               GETBYTE ();
12319               switch (op[2] & 0xf0)
12320               {
12321                 case 0x00:
12322                 case 0x10:
12323                 case 0x20:
12324                 case 0x30:
12325                 case 0x40:
12326                 case 0x50:
12327                 case 0x60:
12328                 case 0x70:
12329                 case 0x80:
12330                 case 0x90:
12331                 case 0xa0:
12332                 case 0xb0:
12333                 case 0xc0:
12334                 case 0xd0:
12335                 case 0xe0:
12336                   goto op_semantics_93;
12337                   break;
12338                 case 0xf0:
12339                   goto op_semantics_94;
12340                   break;
12341               }
12342             break;
12343           case 0xf5:
12344               GETBYTE ();
12345               switch (op[2] & 0xf0)
12346               {
12347                 case 0x00:
12348                 case 0x10:
12349                 case 0x20:
12350                 case 0x30:
12351                 case 0x40:
12352                 case 0x50:
12353                 case 0x60:
12354                 case 0x70:
12355                 case 0x80:
12356                 case 0x90:
12357                 case 0xa0:
12358                 case 0xb0:
12359                 case 0xc0:
12360                 case 0xd0:
12361                 case 0xe0:
12362                   goto op_semantics_93;
12363                   break;
12364                 case 0xf0:
12365                   goto op_semantics_94;
12366                   break;
12367               }
12368             break;
12369           case 0xf6:
12370               GETBYTE ();
12371               switch (op[2] & 0xf0)
12372               {
12373                 case 0x00:
12374                 case 0x10:
12375                 case 0x20:
12376                 case 0x30:
12377                 case 0x40:
12378                 case 0x50:
12379                 case 0x60:
12380                 case 0x70:
12381                 case 0x80:
12382                 case 0x90:
12383                 case 0xa0:
12384                 case 0xb0:
12385                 case 0xc0:
12386                 case 0xd0:
12387                 case 0xe0:
12388                   goto op_semantics_93;
12389                   break;
12390                 case 0xf0:
12391                   goto op_semantics_94;
12392                   break;
12393               }
12394             break;
12395           case 0xf7:
12396               GETBYTE ();
12397               switch (op[2] & 0xf0)
12398               {
12399                 case 0x00:
12400                 case 0x10:
12401                 case 0x20:
12402                 case 0x30:
12403                 case 0x40:
12404                 case 0x50:
12405                 case 0x60:
12406                 case 0x70:
12407                 case 0x80:
12408                 case 0x90:
12409                 case 0xa0:
12410                 case 0xb0:
12411                 case 0xc0:
12412                 case 0xd0:
12413                 case 0xe0:
12414                   goto op_semantics_93;
12415                   break;
12416                 case 0xf0:
12417                   goto op_semantics_94;
12418                   break;
12419               }
12420             break;
12421           case 0xf8:
12422               GETBYTE ();
12423               switch (op[2] & 0xf0)
12424               {
12425                 case 0x00:
12426                 case 0x10:
12427                 case 0x20:
12428                 case 0x30:
12429                 case 0x40:
12430                 case 0x50:
12431                 case 0x60:
12432                 case 0x70:
12433                 case 0x80:
12434                 case 0x90:
12435                 case 0xa0:
12436                 case 0xb0:
12437                 case 0xc0:
12438                 case 0xd0:
12439                 case 0xe0:
12440                   goto op_semantics_93;
12441                   break;
12442                 case 0xf0:
12443                   goto op_semantics_94;
12444                   break;
12445               }
12446             break;
12447           case 0xf9:
12448               GETBYTE ();
12449               switch (op[2] & 0xf0)
12450               {
12451                 case 0x00:
12452                 case 0x10:
12453                 case 0x20:
12454                 case 0x30:
12455                 case 0x40:
12456                 case 0x50:
12457                 case 0x60:
12458                 case 0x70:
12459                 case 0x80:
12460                 case 0x90:
12461                 case 0xa0:
12462                 case 0xb0:
12463                 case 0xc0:
12464                 case 0xd0:
12465                 case 0xe0:
12466                   goto op_semantics_93;
12467                   break;
12468                 case 0xf0:
12469                   goto op_semantics_94;
12470                   break;
12471               }
12472             break;
12473           case 0xfa:
12474               GETBYTE ();
12475               switch (op[2] & 0xf0)
12476               {
12477                 case 0x00:
12478                 case 0x10:
12479                 case 0x20:
12480                 case 0x30:
12481                 case 0x40:
12482                 case 0x50:
12483                 case 0x60:
12484                 case 0x70:
12485                 case 0x80:
12486                 case 0x90:
12487                 case 0xa0:
12488                 case 0xb0:
12489                 case 0xc0:
12490                 case 0xd0:
12491                 case 0xe0:
12492                   goto op_semantics_93;
12493                   break;
12494                 case 0xf0:
12495                   goto op_semantics_94;
12496                   break;
12497               }
12498             break;
12499           case 0xfb:
12500               GETBYTE ();
12501               switch (op[2] & 0xf0)
12502               {
12503                 case 0x00:
12504                 case 0x10:
12505                 case 0x20:
12506                 case 0x30:
12507                 case 0x40:
12508                 case 0x50:
12509                 case 0x60:
12510                 case 0x70:
12511                 case 0x80:
12512                 case 0x90:
12513                 case 0xa0:
12514                 case 0xb0:
12515                 case 0xc0:
12516                 case 0xd0:
12517                 case 0xe0:
12518                   goto op_semantics_93;
12519                   break;
12520                 case 0xf0:
12521                   goto op_semantics_94;
12522                   break;
12523               }
12524             break;
12525           case 0xfc:
12526               GETBYTE ();
12527               switch (op[2] & 0xf0)
12528               {
12529                 case 0x00:
12530                 case 0x10:
12531                 case 0x20:
12532                 case 0x30:
12533                 case 0x40:
12534                 case 0x50:
12535                 case 0x60:
12536                 case 0x70:
12537                 case 0x80:
12538                 case 0x90:
12539                 case 0xa0:
12540                 case 0xb0:
12541                 case 0xc0:
12542                 case 0xd0:
12543                 case 0xe0:
12544                   goto op_semantics_93;
12545                   break;
12546                 case 0xf0:
12547                   goto op_semantics_94;
12548                   break;
12549               }
12550             break;
12551           case 0xfd:
12552               GETBYTE ();
12553               switch (op[2] & 0xf0)
12554               {
12555                 case 0x00:
12556                 case 0x10:
12557                 case 0x20:
12558                 case 0x30:
12559                 case 0x40:
12560                 case 0x50:
12561                 case 0x60:
12562                 case 0x70:
12563                 case 0x80:
12564                 case 0x90:
12565                 case 0xa0:
12566                 case 0xb0:
12567                 case 0xc0:
12568                 case 0xd0:
12569                 case 0xe0:
12570                   goto op_semantics_93;
12571                   break;
12572                 case 0xf0:
12573                   goto op_semantics_94;
12574                   break;
12575               }
12576             break;
12577           case 0xfe:
12578               GETBYTE ();
12579               switch (op[2] & 0xf0)
12580               {
12581                 case 0x00:
12582                 case 0x10:
12583                 case 0x20:
12584                 case 0x30:
12585                 case 0x40:
12586                 case 0x50:
12587                 case 0x60:
12588                 case 0x70:
12589                 case 0x80:
12590                 case 0x90:
12591                 case 0xa0:
12592                 case 0xb0:
12593                 case 0xc0:
12594                 case 0xd0:
12595                 case 0xe0:
12596                   goto op_semantics_93;
12597                   break;
12598                 case 0xf0:
12599                   goto op_semantics_94;
12600                   break;
12601               }
12602             break;
12603           case 0xff:
12604               GETBYTE ();
12605               switch (op[2] & 0xf0)
12606               {
12607                 case 0x00:
12608                 case 0x10:
12609                 case 0x20:
12610                 case 0x30:
12611                 case 0x40:
12612                 case 0x50:
12613                 case 0x60:
12614                 case 0x70:
12615                 case 0x80:
12616                 case 0x90:
12617                 case 0xa0:
12618                 case 0xb0:
12619                 case 0xc0:
12620                 case 0xd0:
12621                 case 0xe0:
12622                   goto op_semantics_93;
12623                   break;
12624                 case 0xf0:
12625                   goto op_semantics_94;
12626                   break;
12627               }
12628             break;
12629           default: UNSUPPORTED(); break;
12630         }
12631       break;
12632     case 0xfe:
12633         GETBYTE ();
12634         switch (op[1] & 0xff)
12635         {
12636           case 0x00:
12637               GETBYTE ();
12638               switch (op[2] & 0x00)
12639               {
12640                 case 0x00:
12641                   op_semantics_95:
12642                     {
12643                       /** 1111 1110 00sz isrc bsrc rdst mov%s   %0, [%1, %2] */
12644 #line 335 "rx-decode.opc"
12645                       int sz AU = (op[1] >> 4) & 0x03;
12646 #line 335 "rx-decode.opc"
12647                       int isrc AU = op[1] & 0x0f;
12648 #line 335 "rx-decode.opc"
12649                       int bsrc AU = (op[2] >> 4) & 0x0f;
12650 #line 335 "rx-decode.opc"
12651                       int rdst AU = op[2] & 0x0f;
12652                       if (trace)
12653                         {
12654                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12655                                  "/** 1111 1110 00sz isrc bsrc rdst     mov%s   %0, [%1, %2] */",
12656                                  op[0], op[1], op[2]);
12657                           printf ("  sz = 0x%x,", sz);
12658                           printf ("  isrc = 0x%x,", isrc);
12659                           printf ("  bsrc = 0x%x,", bsrc);
12660                           printf ("  rdst = 0x%x\n", rdst);
12661                         }
12662                       SYNTAX("mov%s     %0, [%1, %2]");
12663 #line 335 "rx-decode.opc"
12664                       ID(movbir); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
12665
12666                     }
12667                   break;
12668               }
12669             break;
12670           case 0x01:
12671               GETBYTE ();
12672               switch (op[2] & 0x00)
12673               {
12674                 case 0x00:
12675                   goto op_semantics_95;
12676                   break;
12677               }
12678             break;
12679           case 0x02:
12680               GETBYTE ();
12681               switch (op[2] & 0x00)
12682               {
12683                 case 0x00:
12684                   goto op_semantics_95;
12685                   break;
12686               }
12687             break;
12688           case 0x03:
12689               GETBYTE ();
12690               switch (op[2] & 0x00)
12691               {
12692                 case 0x00:
12693                   goto op_semantics_95;
12694                   break;
12695               }
12696             break;
12697           case 0x04:
12698               GETBYTE ();
12699               switch (op[2] & 0x00)
12700               {
12701                 case 0x00:
12702                   goto op_semantics_95;
12703                   break;
12704               }
12705             break;
12706           case 0x05:
12707               GETBYTE ();
12708               switch (op[2] & 0x00)
12709               {
12710                 case 0x00:
12711                   goto op_semantics_95;
12712                   break;
12713               }
12714             break;
12715           case 0x06:
12716               GETBYTE ();
12717               switch (op[2] & 0x00)
12718               {
12719                 case 0x00:
12720                   goto op_semantics_95;
12721                   break;
12722               }
12723             break;
12724           case 0x07:
12725               GETBYTE ();
12726               switch (op[2] & 0x00)
12727               {
12728                 case 0x00:
12729                   goto op_semantics_95;
12730                   break;
12731               }
12732             break;
12733           case 0x08:
12734               GETBYTE ();
12735               switch (op[2] & 0x00)
12736               {
12737                 case 0x00:
12738                   goto op_semantics_95;
12739                   break;
12740               }
12741             break;
12742           case 0x09:
12743               GETBYTE ();
12744               switch (op[2] & 0x00)
12745               {
12746                 case 0x00:
12747                   goto op_semantics_95;
12748                   break;
12749               }
12750             break;
12751           case 0x0a:
12752               GETBYTE ();
12753               switch (op[2] & 0x00)
12754               {
12755                 case 0x00:
12756                   goto op_semantics_95;
12757                   break;
12758               }
12759             break;
12760           case 0x0b:
12761               GETBYTE ();
12762               switch (op[2] & 0x00)
12763               {
12764                 case 0x00:
12765                   goto op_semantics_95;
12766                   break;
12767               }
12768             break;
12769           case 0x0c:
12770               GETBYTE ();
12771               switch (op[2] & 0x00)
12772               {
12773                 case 0x00:
12774                   goto op_semantics_95;
12775                   break;
12776               }
12777             break;
12778           case 0x0d:
12779               GETBYTE ();
12780               switch (op[2] & 0x00)
12781               {
12782                 case 0x00:
12783                   goto op_semantics_95;
12784                   break;
12785               }
12786             break;
12787           case 0x0e:
12788               GETBYTE ();
12789               switch (op[2] & 0x00)
12790               {
12791                 case 0x00:
12792                   goto op_semantics_95;
12793                   break;
12794               }
12795             break;
12796           case 0x0f:
12797               GETBYTE ();
12798               switch (op[2] & 0x00)
12799               {
12800                 case 0x00:
12801                   goto op_semantics_95;
12802                   break;
12803               }
12804             break;
12805           case 0x10:
12806               GETBYTE ();
12807               switch (op[2] & 0x00)
12808               {
12809                 case 0x00:
12810                   goto op_semantics_95;
12811                   break;
12812               }
12813             break;
12814           case 0x11:
12815               GETBYTE ();
12816               switch (op[2] & 0x00)
12817               {
12818                 case 0x00:
12819                   goto op_semantics_95;
12820                   break;
12821               }
12822             break;
12823           case 0x12:
12824               GETBYTE ();
12825               switch (op[2] & 0x00)
12826               {
12827                 case 0x00:
12828                   goto op_semantics_95;
12829                   break;
12830               }
12831             break;
12832           case 0x13:
12833               GETBYTE ();
12834               switch (op[2] & 0x00)
12835               {
12836                 case 0x00:
12837                   goto op_semantics_95;
12838                   break;
12839               }
12840             break;
12841           case 0x14:
12842               GETBYTE ();
12843               switch (op[2] & 0x00)
12844               {
12845                 case 0x00:
12846                   goto op_semantics_95;
12847                   break;
12848               }
12849             break;
12850           case 0x15:
12851               GETBYTE ();
12852               switch (op[2] & 0x00)
12853               {
12854                 case 0x00:
12855                   goto op_semantics_95;
12856                   break;
12857               }
12858             break;
12859           case 0x16:
12860               GETBYTE ();
12861               switch (op[2] & 0x00)
12862               {
12863                 case 0x00:
12864                   goto op_semantics_95;
12865                   break;
12866               }
12867             break;
12868           case 0x17:
12869               GETBYTE ();
12870               switch (op[2] & 0x00)
12871               {
12872                 case 0x00:
12873                   goto op_semantics_95;
12874                   break;
12875               }
12876             break;
12877           case 0x18:
12878               GETBYTE ();
12879               switch (op[2] & 0x00)
12880               {
12881                 case 0x00:
12882                   goto op_semantics_95;
12883                   break;
12884               }
12885             break;
12886           case 0x19:
12887               GETBYTE ();
12888               switch (op[2] & 0x00)
12889               {
12890                 case 0x00:
12891                   goto op_semantics_95;
12892                   break;
12893               }
12894             break;
12895           case 0x1a:
12896               GETBYTE ();
12897               switch (op[2] & 0x00)
12898               {
12899                 case 0x00:
12900                   goto op_semantics_95;
12901                   break;
12902               }
12903             break;
12904           case 0x1b:
12905               GETBYTE ();
12906               switch (op[2] & 0x00)
12907               {
12908                 case 0x00:
12909                   goto op_semantics_95;
12910                   break;
12911               }
12912             break;
12913           case 0x1c:
12914               GETBYTE ();
12915               switch (op[2] & 0x00)
12916               {
12917                 case 0x00:
12918                   goto op_semantics_95;
12919                   break;
12920               }
12921             break;
12922           case 0x1d:
12923               GETBYTE ();
12924               switch (op[2] & 0x00)
12925               {
12926                 case 0x00:
12927                   goto op_semantics_95;
12928                   break;
12929               }
12930             break;
12931           case 0x1e:
12932               GETBYTE ();
12933               switch (op[2] & 0x00)
12934               {
12935                 case 0x00:
12936                   goto op_semantics_95;
12937                   break;
12938               }
12939             break;
12940           case 0x1f:
12941               GETBYTE ();
12942               switch (op[2] & 0x00)
12943               {
12944                 case 0x00:
12945                   goto op_semantics_95;
12946                   break;
12947               }
12948             break;
12949           case 0x20:
12950               GETBYTE ();
12951               switch (op[2] & 0x00)
12952               {
12953                 case 0x00:
12954                   goto op_semantics_95;
12955                   break;
12956               }
12957             break;
12958           case 0x21:
12959               GETBYTE ();
12960               switch (op[2] & 0x00)
12961               {
12962                 case 0x00:
12963                   goto op_semantics_95;
12964                   break;
12965               }
12966             break;
12967           case 0x22:
12968               GETBYTE ();
12969               switch (op[2] & 0x00)
12970               {
12971                 case 0x00:
12972                   goto op_semantics_95;
12973                   break;
12974               }
12975             break;
12976           case 0x23:
12977               GETBYTE ();
12978               switch (op[2] & 0x00)
12979               {
12980                 case 0x00:
12981                   goto op_semantics_95;
12982                   break;
12983               }
12984             break;
12985           case 0x24:
12986               GETBYTE ();
12987               switch (op[2] & 0x00)
12988               {
12989                 case 0x00:
12990                   goto op_semantics_95;
12991                   break;
12992               }
12993             break;
12994           case 0x25:
12995               GETBYTE ();
12996               switch (op[2] & 0x00)
12997               {
12998                 case 0x00:
12999                   goto op_semantics_95;
13000                   break;
13001               }
13002             break;
13003           case 0x26:
13004               GETBYTE ();
13005               switch (op[2] & 0x00)
13006               {
13007                 case 0x00:
13008                   goto op_semantics_95;
13009                   break;
13010               }
13011             break;
13012           case 0x27:
13013               GETBYTE ();
13014               switch (op[2] & 0x00)
13015               {
13016                 case 0x00:
13017                   goto op_semantics_95;
13018                   break;
13019               }
13020             break;
13021           case 0x28:
13022               GETBYTE ();
13023               switch (op[2] & 0x00)
13024               {
13025                 case 0x00:
13026                   goto op_semantics_95;
13027                   break;
13028               }
13029             break;
13030           case 0x29:
13031               GETBYTE ();
13032               switch (op[2] & 0x00)
13033               {
13034                 case 0x00:
13035                   goto op_semantics_95;
13036                   break;
13037               }
13038             break;
13039           case 0x2a:
13040               GETBYTE ();
13041               switch (op[2] & 0x00)
13042               {
13043                 case 0x00:
13044                   goto op_semantics_95;
13045                   break;
13046               }
13047             break;
13048           case 0x2b:
13049               GETBYTE ();
13050               switch (op[2] & 0x00)
13051               {
13052                 case 0x00:
13053                   goto op_semantics_95;
13054                   break;
13055               }
13056             break;
13057           case 0x2c:
13058               GETBYTE ();
13059               switch (op[2] & 0x00)
13060               {
13061                 case 0x00:
13062                   goto op_semantics_95;
13063                   break;
13064               }
13065             break;
13066           case 0x2d:
13067               GETBYTE ();
13068               switch (op[2] & 0x00)
13069               {
13070                 case 0x00:
13071                   goto op_semantics_95;
13072                   break;
13073               }
13074             break;
13075           case 0x2e:
13076               GETBYTE ();
13077               switch (op[2] & 0x00)
13078               {
13079                 case 0x00:
13080                   goto op_semantics_95;
13081                   break;
13082               }
13083             break;
13084           case 0x2f:
13085               GETBYTE ();
13086               switch (op[2] & 0x00)
13087               {
13088                 case 0x00:
13089                   goto op_semantics_95;
13090                   break;
13091               }
13092             break;
13093           case 0x40:
13094               GETBYTE ();
13095               switch (op[2] & 0x00)
13096               {
13097                 case 0x00:
13098                   op_semantics_96:
13099                     {
13100                       /** 1111 1110 01sz isrc bsrc rdst mov%s   [%1, %2], %0 */
13101 #line 332 "rx-decode.opc"
13102                       int sz AU = (op[1] >> 4) & 0x03;
13103 #line 332 "rx-decode.opc"
13104                       int isrc AU = op[1] & 0x0f;
13105 #line 332 "rx-decode.opc"
13106                       int bsrc AU = (op[2] >> 4) & 0x0f;
13107 #line 332 "rx-decode.opc"
13108                       int rdst AU = op[2] & 0x0f;
13109                       if (trace)
13110                         {
13111                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13112                                  "/** 1111 1110 01sz isrc bsrc rdst     mov%s   [%1, %2], %0 */",
13113                                  op[0], op[1], op[2]);
13114                           printf ("  sz = 0x%x,", sz);
13115                           printf ("  isrc = 0x%x,", isrc);
13116                           printf ("  bsrc = 0x%x,", bsrc);
13117                           printf ("  rdst = 0x%x\n", rdst);
13118                         }
13119                       SYNTAX("mov%s     [%1, %2], %0");
13120 #line 332 "rx-decode.opc"
13121                       ID(movbi); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
13122
13123                     }
13124                   break;
13125               }
13126             break;
13127           case 0x41:
13128               GETBYTE ();
13129               switch (op[2] & 0x00)
13130               {
13131                 case 0x00:
13132                   goto op_semantics_96;
13133                   break;
13134               }
13135             break;
13136           case 0x42:
13137               GETBYTE ();
13138               switch (op[2] & 0x00)
13139               {
13140                 case 0x00:
13141                   goto op_semantics_96;
13142                   break;
13143               }
13144             break;
13145           case 0x43:
13146               GETBYTE ();
13147               switch (op[2] & 0x00)
13148               {
13149                 case 0x00:
13150                   goto op_semantics_96;
13151                   break;
13152               }
13153             break;
13154           case 0x44:
13155               GETBYTE ();
13156               switch (op[2] & 0x00)
13157               {
13158                 case 0x00:
13159                   goto op_semantics_96;
13160                   break;
13161               }
13162             break;
13163           case 0x45:
13164               GETBYTE ();
13165               switch (op[2] & 0x00)
13166               {
13167                 case 0x00:
13168                   goto op_semantics_96;
13169                   break;
13170               }
13171             break;
13172           case 0x46:
13173               GETBYTE ();
13174               switch (op[2] & 0x00)
13175               {
13176                 case 0x00:
13177                   goto op_semantics_96;
13178                   break;
13179               }
13180             break;
13181           case 0x47:
13182               GETBYTE ();
13183               switch (op[2] & 0x00)
13184               {
13185                 case 0x00:
13186                   goto op_semantics_96;
13187                   break;
13188               }
13189             break;
13190           case 0x48:
13191               GETBYTE ();
13192               switch (op[2] & 0x00)
13193               {
13194                 case 0x00:
13195                   goto op_semantics_96;
13196                   break;
13197               }
13198             break;
13199           case 0x49:
13200               GETBYTE ();
13201               switch (op[2] & 0x00)
13202               {
13203                 case 0x00:
13204                   goto op_semantics_96;
13205                   break;
13206               }
13207             break;
13208           case 0x4a:
13209               GETBYTE ();
13210               switch (op[2] & 0x00)
13211               {
13212                 case 0x00:
13213                   goto op_semantics_96;
13214                   break;
13215               }
13216             break;
13217           case 0x4b:
13218               GETBYTE ();
13219               switch (op[2] & 0x00)
13220               {
13221                 case 0x00:
13222                   goto op_semantics_96;
13223                   break;
13224               }
13225             break;
13226           case 0x4c:
13227               GETBYTE ();
13228               switch (op[2] & 0x00)
13229               {
13230                 case 0x00:
13231                   goto op_semantics_96;
13232                   break;
13233               }
13234             break;
13235           case 0x4d:
13236               GETBYTE ();
13237               switch (op[2] & 0x00)
13238               {
13239                 case 0x00:
13240                   goto op_semantics_96;
13241                   break;
13242               }
13243             break;
13244           case 0x4e:
13245               GETBYTE ();
13246               switch (op[2] & 0x00)
13247               {
13248                 case 0x00:
13249                   goto op_semantics_96;
13250                   break;
13251               }
13252             break;
13253           case 0x4f:
13254               GETBYTE ();
13255               switch (op[2] & 0x00)
13256               {
13257                 case 0x00:
13258                   goto op_semantics_96;
13259                   break;
13260               }
13261             break;
13262           case 0x50:
13263               GETBYTE ();
13264               switch (op[2] & 0x00)
13265               {
13266                 case 0x00:
13267                   goto op_semantics_96;
13268                   break;
13269               }
13270             break;
13271           case 0x51:
13272               GETBYTE ();
13273               switch (op[2] & 0x00)
13274               {
13275                 case 0x00:
13276                   goto op_semantics_96;
13277                   break;
13278               }
13279             break;
13280           case 0x52:
13281               GETBYTE ();
13282               switch (op[2] & 0x00)
13283               {
13284                 case 0x00:
13285                   goto op_semantics_96;
13286                   break;
13287               }
13288             break;
13289           case 0x53:
13290               GETBYTE ();
13291               switch (op[2] & 0x00)
13292               {
13293                 case 0x00:
13294                   goto op_semantics_96;
13295                   break;
13296               }
13297             break;
13298           case 0x54:
13299               GETBYTE ();
13300               switch (op[2] & 0x00)
13301               {
13302                 case 0x00:
13303                   goto op_semantics_96;
13304                   break;
13305               }
13306             break;
13307           case 0x55:
13308               GETBYTE ();
13309               switch (op[2] & 0x00)
13310               {
13311                 case 0x00:
13312                   goto op_semantics_96;
13313                   break;
13314               }
13315             break;
13316           case 0x56:
13317               GETBYTE ();
13318               switch (op[2] & 0x00)
13319               {
13320                 case 0x00:
13321                   goto op_semantics_96;
13322                   break;
13323               }
13324             break;
13325           case 0x57:
13326               GETBYTE ();
13327               switch (op[2] & 0x00)
13328               {
13329                 case 0x00:
13330                   goto op_semantics_96;
13331                   break;
13332               }
13333             break;
13334           case 0x58:
13335               GETBYTE ();
13336               switch (op[2] & 0x00)
13337               {
13338                 case 0x00:
13339                   goto op_semantics_96;
13340                   break;
13341               }
13342             break;
13343           case 0x59:
13344               GETBYTE ();
13345               switch (op[2] & 0x00)
13346               {
13347                 case 0x00:
13348                   goto op_semantics_96;
13349                   break;
13350               }
13351             break;
13352           case 0x5a:
13353               GETBYTE ();
13354               switch (op[2] & 0x00)
13355               {
13356                 case 0x00:
13357                   goto op_semantics_96;
13358                   break;
13359               }
13360             break;
13361           case 0x5b:
13362               GETBYTE ();
13363               switch (op[2] & 0x00)
13364               {
13365                 case 0x00:
13366                   goto op_semantics_96;
13367                   break;
13368               }
13369             break;
13370           case 0x5c:
13371               GETBYTE ();
13372               switch (op[2] & 0x00)
13373               {
13374                 case 0x00:
13375                   goto op_semantics_96;
13376                   break;
13377               }
13378             break;
13379           case 0x5d:
13380               GETBYTE ();
13381               switch (op[2] & 0x00)
13382               {
13383                 case 0x00:
13384                   goto op_semantics_96;
13385                   break;
13386               }
13387             break;
13388           case 0x5e:
13389               GETBYTE ();
13390               switch (op[2] & 0x00)
13391               {
13392                 case 0x00:
13393                   goto op_semantics_96;
13394                   break;
13395               }
13396             break;
13397           case 0x5f:
13398               GETBYTE ();
13399               switch (op[2] & 0x00)
13400               {
13401                 case 0x00:
13402                   goto op_semantics_96;
13403                   break;
13404               }
13405             break;
13406           case 0x60:
13407               GETBYTE ();
13408               switch (op[2] & 0x00)
13409               {
13410                 case 0x00:
13411                   goto op_semantics_96;
13412                   break;
13413               }
13414             break;
13415           case 0x61:
13416               GETBYTE ();
13417               switch (op[2] & 0x00)
13418               {
13419                 case 0x00:
13420                   goto op_semantics_96;
13421                   break;
13422               }
13423             break;
13424           case 0x62:
13425               GETBYTE ();
13426               switch (op[2] & 0x00)
13427               {
13428                 case 0x00:
13429                   goto op_semantics_96;
13430                   break;
13431               }
13432             break;
13433           case 0x63:
13434               GETBYTE ();
13435               switch (op[2] & 0x00)
13436               {
13437                 case 0x00:
13438                   goto op_semantics_96;
13439                   break;
13440               }
13441             break;
13442           case 0x64:
13443               GETBYTE ();
13444               switch (op[2] & 0x00)
13445               {
13446                 case 0x00:
13447                   goto op_semantics_96;
13448                   break;
13449               }
13450             break;
13451           case 0x65:
13452               GETBYTE ();
13453               switch (op[2] & 0x00)
13454               {
13455                 case 0x00:
13456                   goto op_semantics_96;
13457                   break;
13458               }
13459             break;
13460           case 0x66:
13461               GETBYTE ();
13462               switch (op[2] & 0x00)
13463               {
13464                 case 0x00:
13465                   goto op_semantics_96;
13466                   break;
13467               }
13468             break;
13469           case 0x67:
13470               GETBYTE ();
13471               switch (op[2] & 0x00)
13472               {
13473                 case 0x00:
13474                   goto op_semantics_96;
13475                   break;
13476               }
13477             break;
13478           case 0x68:
13479               GETBYTE ();
13480               switch (op[2] & 0x00)
13481               {
13482                 case 0x00:
13483                   goto op_semantics_96;
13484                   break;
13485               }
13486             break;
13487           case 0x69:
13488               GETBYTE ();
13489               switch (op[2] & 0x00)
13490               {
13491                 case 0x00:
13492                   goto op_semantics_96;
13493                   break;
13494               }
13495             break;
13496           case 0x6a:
13497               GETBYTE ();
13498               switch (op[2] & 0x00)
13499               {
13500                 case 0x00:
13501                   goto op_semantics_96;
13502                   break;
13503               }
13504             break;
13505           case 0x6b:
13506               GETBYTE ();
13507               switch (op[2] & 0x00)
13508               {
13509                 case 0x00:
13510                   goto op_semantics_96;
13511                   break;
13512               }
13513             break;
13514           case 0x6c:
13515               GETBYTE ();
13516               switch (op[2] & 0x00)
13517               {
13518                 case 0x00:
13519                   goto op_semantics_96;
13520                   break;
13521               }
13522             break;
13523           case 0x6d:
13524               GETBYTE ();
13525               switch (op[2] & 0x00)
13526               {
13527                 case 0x00:
13528                   goto op_semantics_96;
13529                   break;
13530               }
13531             break;
13532           case 0x6e:
13533               GETBYTE ();
13534               switch (op[2] & 0x00)
13535               {
13536                 case 0x00:
13537                   goto op_semantics_96;
13538                   break;
13539               }
13540             break;
13541           case 0x6f:
13542               GETBYTE ();
13543               switch (op[2] & 0x00)
13544               {
13545                 case 0x00:
13546                   goto op_semantics_96;
13547                   break;
13548               }
13549             break;
13550           case 0xc0:
13551               GETBYTE ();
13552               switch (op[2] & 0x00)
13553               {
13554                 case 0x00:
13555                   op_semantics_97:
13556                     {
13557                       /** 1111 1110 11sz isrc bsrc rdst movu%s  [%1, %2], %0 */
13558 #line 338 "rx-decode.opc"
13559                       int sz AU = (op[1] >> 4) & 0x03;
13560 #line 338 "rx-decode.opc"
13561                       int isrc AU = op[1] & 0x0f;
13562 #line 338 "rx-decode.opc"
13563                       int bsrc AU = (op[2] >> 4) & 0x0f;
13564 #line 338 "rx-decode.opc"
13565                       int rdst AU = op[2] & 0x0f;
13566                       if (trace)
13567                         {
13568                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13569                                  "/** 1111 1110 11sz isrc bsrc rdst     movu%s  [%1, %2], %0 */",
13570                                  op[0], op[1], op[2]);
13571                           printf ("  sz = 0x%x,", sz);
13572                           printf ("  isrc = 0x%x,", isrc);
13573                           printf ("  bsrc = 0x%x,", bsrc);
13574                           printf ("  rdst = 0x%x\n", rdst);
13575                         }
13576                       SYNTAX("movu%s    [%1, %2], %0");
13577 #line 338 "rx-decode.opc"
13578                       ID(movbi); uBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
13579
13580                     }
13581                   break;
13582               }
13583             break;
13584           case 0xc1:
13585               GETBYTE ();
13586               switch (op[2] & 0x00)
13587               {
13588                 case 0x00:
13589                   goto op_semantics_97;
13590                   break;
13591               }
13592             break;
13593           case 0xc2:
13594               GETBYTE ();
13595               switch (op[2] & 0x00)
13596               {
13597                 case 0x00:
13598                   goto op_semantics_97;
13599                   break;
13600               }
13601             break;
13602           case 0xc3:
13603               GETBYTE ();
13604               switch (op[2] & 0x00)
13605               {
13606                 case 0x00:
13607                   goto op_semantics_97;
13608                   break;
13609               }
13610             break;
13611           case 0xc4:
13612               GETBYTE ();
13613               switch (op[2] & 0x00)
13614               {
13615                 case 0x00:
13616                   goto op_semantics_97;
13617                   break;
13618               }
13619             break;
13620           case 0xc5:
13621               GETBYTE ();
13622               switch (op[2] & 0x00)
13623               {
13624                 case 0x00:
13625                   goto op_semantics_97;
13626                   break;
13627               }
13628             break;
13629           case 0xc6:
13630               GETBYTE ();
13631               switch (op[2] & 0x00)
13632               {
13633                 case 0x00:
13634                   goto op_semantics_97;
13635                   break;
13636               }
13637             break;
13638           case 0xc7:
13639               GETBYTE ();
13640               switch (op[2] & 0x00)
13641               {
13642                 case 0x00:
13643                   goto op_semantics_97;
13644                   break;
13645               }
13646             break;
13647           case 0xc8:
13648               GETBYTE ();
13649               switch (op[2] & 0x00)
13650               {
13651                 case 0x00:
13652                   goto op_semantics_97;
13653                   break;
13654               }
13655             break;
13656           case 0xc9:
13657               GETBYTE ();
13658               switch (op[2] & 0x00)
13659               {
13660                 case 0x00:
13661                   goto op_semantics_97;
13662                   break;
13663               }
13664             break;
13665           case 0xca:
13666               GETBYTE ();
13667               switch (op[2] & 0x00)
13668               {
13669                 case 0x00:
13670                   goto op_semantics_97;
13671                   break;
13672               }
13673             break;
13674           case 0xcb:
13675               GETBYTE ();
13676               switch (op[2] & 0x00)
13677               {
13678                 case 0x00:
13679                   goto op_semantics_97;
13680                   break;
13681               }
13682             break;
13683           case 0xcc:
13684               GETBYTE ();
13685               switch (op[2] & 0x00)
13686               {
13687                 case 0x00:
13688                   goto op_semantics_97;
13689                   break;
13690               }
13691             break;
13692           case 0xcd:
13693               GETBYTE ();
13694               switch (op[2] & 0x00)
13695               {
13696                 case 0x00:
13697                   goto op_semantics_97;
13698                   break;
13699               }
13700             break;
13701           case 0xce:
13702               GETBYTE ();
13703               switch (op[2] & 0x00)
13704               {
13705                 case 0x00:
13706                   goto op_semantics_97;
13707                   break;
13708               }
13709             break;
13710           case 0xcf:
13711               GETBYTE ();
13712               switch (op[2] & 0x00)
13713               {
13714                 case 0x00:
13715                   goto op_semantics_97;
13716                   break;
13717               }
13718             break;
13719           case 0xd0:
13720               GETBYTE ();
13721               switch (op[2] & 0x00)
13722               {
13723                 case 0x00:
13724                   goto op_semantics_97;
13725                   break;
13726               }
13727             break;
13728           case 0xd1:
13729               GETBYTE ();
13730               switch (op[2] & 0x00)
13731               {
13732                 case 0x00:
13733                   goto op_semantics_97;
13734                   break;
13735               }
13736             break;
13737           case 0xd2:
13738               GETBYTE ();
13739               switch (op[2] & 0x00)
13740               {
13741                 case 0x00:
13742                   goto op_semantics_97;
13743                   break;
13744               }
13745             break;
13746           case 0xd3:
13747               GETBYTE ();
13748               switch (op[2] & 0x00)
13749               {
13750                 case 0x00:
13751                   goto op_semantics_97;
13752                   break;
13753               }
13754             break;
13755           case 0xd4:
13756               GETBYTE ();
13757               switch (op[2] & 0x00)
13758               {
13759                 case 0x00:
13760                   goto op_semantics_97;
13761                   break;
13762               }
13763             break;
13764           case 0xd5:
13765               GETBYTE ();
13766               switch (op[2] & 0x00)
13767               {
13768                 case 0x00:
13769                   goto op_semantics_97;
13770                   break;
13771               }
13772             break;
13773           case 0xd6:
13774               GETBYTE ();
13775               switch (op[2] & 0x00)
13776               {
13777                 case 0x00:
13778                   goto op_semantics_97;
13779                   break;
13780               }
13781             break;
13782           case 0xd7:
13783               GETBYTE ();
13784               switch (op[2] & 0x00)
13785               {
13786                 case 0x00:
13787                   goto op_semantics_97;
13788                   break;
13789               }
13790             break;
13791           case 0xd8:
13792               GETBYTE ();
13793               switch (op[2] & 0x00)
13794               {
13795                 case 0x00:
13796                   goto op_semantics_97;
13797                   break;
13798               }
13799             break;
13800           case 0xd9:
13801               GETBYTE ();
13802               switch (op[2] & 0x00)
13803               {
13804                 case 0x00:
13805                   goto op_semantics_97;
13806                   break;
13807               }
13808             break;
13809           case 0xda:
13810               GETBYTE ();
13811               switch (op[2] & 0x00)
13812               {
13813                 case 0x00:
13814                   goto op_semantics_97;
13815                   break;
13816               }
13817             break;
13818           case 0xdb:
13819               GETBYTE ();
13820               switch (op[2] & 0x00)
13821               {
13822                 case 0x00:
13823                   goto op_semantics_97;
13824                   break;
13825               }
13826             break;
13827           case 0xdc:
13828               GETBYTE ();
13829               switch (op[2] & 0x00)
13830               {
13831                 case 0x00:
13832                   goto op_semantics_97;
13833                   break;
13834               }
13835             break;
13836           case 0xdd:
13837               GETBYTE ();
13838               switch (op[2] & 0x00)
13839               {
13840                 case 0x00:
13841                   goto op_semantics_97;
13842                   break;
13843               }
13844             break;
13845           case 0xde:
13846               GETBYTE ();
13847               switch (op[2] & 0x00)
13848               {
13849                 case 0x00:
13850                   goto op_semantics_97;
13851                   break;
13852               }
13853             break;
13854           case 0xdf:
13855               GETBYTE ();
13856               switch (op[2] & 0x00)
13857               {
13858                 case 0x00:
13859                   goto op_semantics_97;
13860                   break;
13861               }
13862             break;
13863           case 0xe0:
13864               GETBYTE ();
13865               switch (op[2] & 0x00)
13866               {
13867                 case 0x00:
13868                   goto op_semantics_97;
13869                   break;
13870               }
13871             break;
13872           case 0xe1:
13873               GETBYTE ();
13874               switch (op[2] & 0x00)
13875               {
13876                 case 0x00:
13877                   goto op_semantics_97;
13878                   break;
13879               }
13880             break;
13881           case 0xe2:
13882               GETBYTE ();
13883               switch (op[2] & 0x00)
13884               {
13885                 case 0x00:
13886                   goto op_semantics_97;
13887                   break;
13888               }
13889             break;
13890           case 0xe3:
13891               GETBYTE ();
13892               switch (op[2] & 0x00)
13893               {
13894                 case 0x00:
13895                   goto op_semantics_97;
13896                   break;
13897               }
13898             break;
13899           case 0xe4:
13900               GETBYTE ();
13901               switch (op[2] & 0x00)
13902               {
13903                 case 0x00:
13904                   goto op_semantics_97;
13905                   break;
13906               }
13907             break;
13908           case 0xe5:
13909               GETBYTE ();
13910               switch (op[2] & 0x00)
13911               {
13912                 case 0x00:
13913                   goto op_semantics_97;
13914                   break;
13915               }
13916             break;
13917           case 0xe6:
13918               GETBYTE ();
13919               switch (op[2] & 0x00)
13920               {
13921                 case 0x00:
13922                   goto op_semantics_97;
13923                   break;
13924               }
13925             break;
13926           case 0xe7:
13927               GETBYTE ();
13928               switch (op[2] & 0x00)
13929               {
13930                 case 0x00:
13931                   goto op_semantics_97;
13932                   break;
13933               }
13934             break;
13935           case 0xe8:
13936               GETBYTE ();
13937               switch (op[2] & 0x00)
13938               {
13939                 case 0x00:
13940                   goto op_semantics_97;
13941                   break;
13942               }
13943             break;
13944           case 0xe9:
13945               GETBYTE ();
13946               switch (op[2] & 0x00)
13947               {
13948                 case 0x00:
13949                   goto op_semantics_97;
13950                   break;
13951               }
13952             break;
13953           case 0xea:
13954               GETBYTE ();
13955               switch (op[2] & 0x00)
13956               {
13957                 case 0x00:
13958                   goto op_semantics_97;
13959                   break;
13960               }
13961             break;
13962           case 0xeb:
13963               GETBYTE ();
13964               switch (op[2] & 0x00)
13965               {
13966                 case 0x00:
13967                   goto op_semantics_97;
13968                   break;
13969               }
13970             break;
13971           case 0xec:
13972               GETBYTE ();
13973               switch (op[2] & 0x00)
13974               {
13975                 case 0x00:
13976                   goto op_semantics_97;
13977                   break;
13978               }
13979             break;
13980           case 0xed:
13981               GETBYTE ();
13982               switch (op[2] & 0x00)
13983               {
13984                 case 0x00:
13985                   goto op_semantics_97;
13986                   break;
13987               }
13988             break;
13989           case 0xee:
13990               GETBYTE ();
13991               switch (op[2] & 0x00)
13992               {
13993                 case 0x00:
13994                   goto op_semantics_97;
13995                   break;
13996               }
13997             break;
13998           case 0xef:
13999               GETBYTE ();
14000               switch (op[2] & 0x00)
14001               {
14002                 case 0x00:
14003                   goto op_semantics_97;
14004                   break;
14005               }
14006             break;
14007           default: UNSUPPORTED(); break;
14008         }
14009       break;
14010     case 0xff:
14011         GETBYTE ();
14012         switch (op[1] & 0xff)
14013         {
14014           case 0x00:
14015               GETBYTE ();
14016               switch (op[2] & 0x00)
14017               {
14018                 case 0x00:
14019                   op_semantics_98:
14020                     {
14021                       /** 1111 1111 0000 rdst srca srcb sub     %2, %1, %0 */
14022 #line 542 "rx-decode.opc"
14023                       int rdst AU = op[1] & 0x0f;
14024 #line 542 "rx-decode.opc"
14025                       int srca AU = (op[2] >> 4) & 0x0f;
14026 #line 542 "rx-decode.opc"
14027                       int srcb AU = op[2] & 0x0f;
14028                       if (trace)
14029                         {
14030                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
14031                                  "/** 1111 1111 0000 rdst srca srcb     sub     %2, %1, %0 */",
14032                                  op[0], op[1], op[2]);
14033                           printf ("  rdst = 0x%x,", rdst);
14034                           printf ("  srca = 0x%x,", srca);
14035                           printf ("  srcb = 0x%x\n", srcb);
14036                         }
14037                       SYNTAX("sub       %2, %1, %0");
14038 #line 542 "rx-decode.opc"
14039                       ID(sub); DR(rdst); SR(srcb); S2R(srca); F_OSZC;
14040
14041                     /*----------------------------------------------------------------------*/
14042                     /* SBB                                                                      */
14043
14044                     }
14045                   break;
14046               }
14047             break;
14048           case 0x01:
14049               GETBYTE ();
14050               switch (op[2] & 0x00)
14051               {
14052                 case 0x00:
14053                   goto op_semantics_98;
14054                   break;
14055               }
14056             break;
14057           case 0x02:
14058               GETBYTE ();
14059               switch (op[2] & 0x00)
14060               {
14061                 case 0x00:
14062                   goto op_semantics_98;
14063                   break;
14064               }
14065             break;
14066           case 0x03:
14067               GETBYTE ();
14068               switch (op[2] & 0x00)
14069               {
14070                 case 0x00:
14071                   goto op_semantics_98;
14072                   break;
14073               }
14074             break;
14075           case 0x04:
14076               GETBYTE ();
14077               switch (op[2] & 0x00)
14078               {
14079                 case 0x00:
14080                   goto op_semantics_98;
14081                   break;
14082               }
14083             break;
14084           case 0x05:
14085               GETBYTE ();
14086               switch (op[2] & 0x00)
14087               {
14088                 case 0x00:
14089                   goto op_semantics_98;
14090                   break;
14091               }
14092             break;
14093           case 0x06:
14094               GETBYTE ();
14095               switch (op[2] & 0x00)
14096               {
14097                 case 0x00:
14098                   goto op_semantics_98;
14099                   break;
14100               }
14101             break;
14102           case 0x07:
14103               GETBYTE ();
14104               switch (op[2] & 0x00)
14105               {
14106                 case 0x00:
14107                   goto op_semantics_98;
14108                   break;
14109               }
14110             break;
14111           case 0x08:
14112               GETBYTE ();
14113               switch (op[2] & 0x00)
14114               {
14115                 case 0x00:
14116                   goto op_semantics_98;
14117                   break;
14118               }
14119             break;
14120           case 0x09:
14121               GETBYTE ();
14122               switch (op[2] & 0x00)
14123               {
14124                 case 0x00:
14125                   goto op_semantics_98;
14126                   break;
14127               }
14128             break;
14129           case 0x0a:
14130               GETBYTE ();
14131               switch (op[2] & 0x00)
14132               {
14133                 case 0x00:
14134                   goto op_semantics_98;
14135                   break;
14136               }
14137             break;
14138           case 0x0b:
14139               GETBYTE ();
14140               switch (op[2] & 0x00)
14141               {
14142                 case 0x00:
14143                   goto op_semantics_98;
14144                   break;
14145               }
14146             break;
14147           case 0x0c:
14148               GETBYTE ();
14149               switch (op[2] & 0x00)
14150               {
14151                 case 0x00:
14152                   goto op_semantics_98;
14153                   break;
14154               }
14155             break;
14156           case 0x0d:
14157               GETBYTE ();
14158               switch (op[2] & 0x00)
14159               {
14160                 case 0x00:
14161                   goto op_semantics_98;
14162                   break;
14163               }
14164             break;
14165           case 0x0e:
14166               GETBYTE ();
14167               switch (op[2] & 0x00)
14168               {
14169                 case 0x00:
14170                   goto op_semantics_98;
14171                   break;
14172               }
14173             break;
14174           case 0x0f:
14175               GETBYTE ();
14176               switch (op[2] & 0x00)
14177               {
14178                 case 0x00:
14179                   goto op_semantics_98;
14180                   break;
14181               }
14182             break;
14183           case 0x20:
14184               GETBYTE ();
14185               switch (op[2] & 0x00)
14186               {
14187                 case 0x00:
14188                   op_semantics_99:
14189                     {
14190                       /** 1111 1111 0010 rdst srca srcb add     %2, %1, %0 */
14191 #line 509 "rx-decode.opc"
14192                       int rdst AU = op[1] & 0x0f;
14193 #line 509 "rx-decode.opc"
14194                       int srca AU = (op[2] >> 4) & 0x0f;
14195 #line 509 "rx-decode.opc"
14196                       int srcb AU = op[2] & 0x0f;
14197                       if (trace)
14198                         {
14199                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
14200                                  "/** 1111 1111 0010 rdst srca srcb     add     %2, %1, %0 */",
14201                                  op[0], op[1], op[2]);
14202                           printf ("  rdst = 0x%x,", rdst);
14203                           printf ("  srca = 0x%x,", srca);
14204                           printf ("  srcb = 0x%x\n", srcb);
14205                         }
14206                       SYNTAX("add       %2, %1, %0");
14207 #line 509 "rx-decode.opc"
14208                       ID(add); DR(rdst); SR(srcb); S2R(srca); F_OSZC;
14209
14210                     /*----------------------------------------------------------------------*/
14211                     /* CMP                                                                      */
14212
14213                     }
14214                   break;
14215               }
14216             break;
14217           case 0x21:
14218               GETBYTE ();
14219               switch (op[2] & 0x00)
14220               {
14221                 case 0x00:
14222                   goto op_semantics_99;
14223                   break;
14224               }
14225             break;
14226           case 0x22:
14227               GETBYTE ();
14228               switch (op[2] & 0x00)
14229               {
14230                 case 0x00:
14231                   goto op_semantics_99;
14232                   break;
14233               }
14234             break;
14235           case 0x23:
14236               GETBYTE ();
14237               switch (op[2] & 0x00)
14238               {
14239                 case 0x00:
14240                   goto op_semantics_99;
14241                   break;
14242               }
14243             break;
14244           case 0x24:
14245               GETBYTE ();
14246               switch (op[2] & 0x00)
14247               {
14248                 case 0x00:
14249                   goto op_semantics_99;
14250                   break;
14251               }
14252             break;
14253           case 0x25:
14254               GETBYTE ();
14255               switch (op[2] & 0x00)
14256               {
14257                 case 0x00:
14258                   goto op_semantics_99;
14259                   break;
14260               }
14261             break;
14262           case 0x26:
14263               GETBYTE ();
14264               switch (op[2] & 0x00)
14265               {
14266                 case 0x00:
14267                   goto op_semantics_99;
14268                   break;
14269               }
14270             break;
14271           case 0x27:
14272               GETBYTE ();
14273               switch (op[2] & 0x00)
14274               {
14275                 case 0x00:
14276                   goto op_semantics_99;
14277                   break;
14278               }
14279             break;
14280           case 0x28:
14281               GETBYTE ();
14282               switch (op[2] & 0x00)
14283               {
14284                 case 0x00:
14285                   goto op_semantics_99;
14286                   break;
14287               }
14288             break;
14289           case 0x29:
14290               GETBYTE ();
14291               switch (op[2] & 0x00)
14292               {
14293                 case 0x00:
14294                   goto op_semantics_99;
14295                   break;
14296               }
14297             break;
14298           case 0x2a:
14299               GETBYTE ();
14300               switch (op[2] & 0x00)
14301               {
14302                 case 0x00:
14303                   goto op_semantics_99;
14304                   break;
14305               }
14306             break;
14307           case 0x2b:
14308               GETBYTE ();
14309               switch (op[2] & 0x00)
14310               {
14311                 case 0x00:
14312                   goto op_semantics_99;
14313                   break;
14314               }
14315             break;
14316           case 0x2c:
14317               GETBYTE ();
14318               switch (op[2] & 0x00)
14319               {
14320                 case 0x00:
14321                   goto op_semantics_99;
14322                   break;
14323               }
14324             break;
14325           case 0x2d:
14326               GETBYTE ();
14327               switch (op[2] & 0x00)
14328               {
14329                 case 0x00:
14330                   goto op_semantics_99;
14331                   break;
14332               }
14333             break;
14334           case 0x2e:
14335               GETBYTE ();
14336               switch (op[2] & 0x00)
14337               {
14338                 case 0x00:
14339                   goto op_semantics_99;
14340                   break;
14341               }
14342             break;
14343           case 0x2f:
14344               GETBYTE ();
14345               switch (op[2] & 0x00)
14346               {
14347                 case 0x00:
14348                   goto op_semantics_99;
14349                   break;
14350               }
14351             break;
14352           case 0x30:
14353               GETBYTE ();
14354               switch (op[2] & 0x00)
14355               {
14356                 case 0x00:
14357                   op_semantics_100:
14358                     {
14359                       /** 1111 1111 0011 rdst srca srcb mul     %2, %1, %0 */
14360 #line 611 "rx-decode.opc"
14361                       int rdst AU = op[1] & 0x0f;
14362 #line 611 "rx-decode.opc"
14363                       int srca AU = (op[2] >> 4) & 0x0f;
14364 #line 611 "rx-decode.opc"
14365                       int srcb AU = op[2] & 0x0f;
14366                       if (trace)
14367                         {
14368                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
14369                                  "/** 1111 1111 0011 rdst srca srcb     mul     %2, %1, %0 */",
14370                                  op[0], op[1], op[2]);
14371                           printf ("  rdst = 0x%x,", rdst);
14372                           printf ("  srca = 0x%x,", srca);
14373                           printf ("  srcb = 0x%x\n", srcb);
14374                         }
14375                       SYNTAX("mul       %2, %1, %0");
14376 #line 611 "rx-decode.opc"
14377                       ID(mul); DR(rdst); SR(srcb); S2R(srca); F_____;
14378
14379                     /*----------------------------------------------------------------------*/
14380                     /* EMUL                                                                     */
14381
14382                     }
14383                   break;
14384               }
14385             break;
14386           case 0x31:
14387               GETBYTE ();
14388               switch (op[2] & 0x00)
14389               {
14390                 case 0x00:
14391                   goto op_semantics_100;
14392                   break;
14393               }
14394             break;
14395           case 0x32:
14396               GETBYTE ();
14397               switch (op[2] & 0x00)
14398               {
14399                 case 0x00:
14400                   goto op_semantics_100;
14401                   break;
14402               }
14403             break;
14404           case 0x33:
14405               GETBYTE ();
14406               switch (op[2] & 0x00)
14407               {
14408                 case 0x00:
14409                   goto op_semantics_100;
14410                   break;
14411               }
14412             break;
14413           case 0x34:
14414               GETBYTE ();
14415               switch (op[2] & 0x00)
14416               {
14417                 case 0x00:
14418                   goto op_semantics_100;
14419                   break;
14420               }
14421             break;
14422           case 0x35:
14423               GETBYTE ();
14424               switch (op[2] & 0x00)
14425               {
14426                 case 0x00:
14427                   goto op_semantics_100;
14428                   break;
14429               }
14430             break;
14431           case 0x36:
14432               GETBYTE ();
14433               switch (op[2] & 0x00)
14434               {
14435                 case 0x00:
14436                   goto op_semantics_100;
14437                   break;
14438               }
14439             break;
14440           case 0x37:
14441               GETBYTE ();
14442               switch (op[2] & 0x00)
14443               {
14444                 case 0x00:
14445                   goto op_semantics_100;
14446                   break;
14447               }
14448             break;
14449           case 0x38:
14450               GETBYTE ();
14451               switch (op[2] & 0x00)
14452               {
14453                 case 0x00:
14454                   goto op_semantics_100;
14455                   break;
14456               }
14457             break;
14458           case 0x39:
14459               GETBYTE ();
14460               switch (op[2] & 0x00)
14461               {
14462                 case 0x00:
14463                   goto op_semantics_100;
14464                   break;
14465               }
14466             break;
14467           case 0x3a:
14468               GETBYTE ();
14469               switch (op[2] & 0x00)
14470               {
14471                 case 0x00:
14472                   goto op_semantics_100;
14473                   break;
14474               }
14475             break;
14476           case 0x3b:
14477               GETBYTE ();
14478               switch (op[2] & 0x00)
14479               {
14480                 case 0x00:
14481                   goto op_semantics_100;
14482                   break;
14483               }
14484             break;
14485           case 0x3c:
14486               GETBYTE ();
14487               switch (op[2] & 0x00)
14488               {
14489                 case 0x00:
14490                   goto op_semantics_100;
14491                   break;
14492               }
14493             break;
14494           case 0x3d:
14495               GETBYTE ();
14496               switch (op[2] & 0x00)
14497               {
14498                 case 0x00:
14499                   goto op_semantics_100;
14500                   break;
14501               }
14502             break;
14503           case 0x3e:
14504               GETBYTE ();
14505               switch (op[2] & 0x00)
14506               {
14507                 case 0x00:
14508                   goto op_semantics_100;
14509                   break;
14510               }
14511             break;
14512           case 0x3f:
14513               GETBYTE ();
14514               switch (op[2] & 0x00)
14515               {
14516                 case 0x00:
14517                   goto op_semantics_100;
14518                   break;
14519               }
14520             break;
14521           case 0x40:
14522               GETBYTE ();
14523               switch (op[2] & 0x00)
14524               {
14525                 case 0x00:
14526                   op_semantics_101:
14527                     {
14528                       /** 1111 1111 0100 rdst srca srcb and     %2, %1, %0 */
14529 #line 419 "rx-decode.opc"
14530                       int rdst AU = op[1] & 0x0f;
14531 #line 419 "rx-decode.opc"
14532                       int srca AU = (op[2] >> 4) & 0x0f;
14533 #line 419 "rx-decode.opc"
14534                       int srcb AU = op[2] & 0x0f;
14535                       if (trace)
14536                         {
14537                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
14538                                  "/** 1111 1111 0100 rdst srca srcb     and     %2, %1, %0 */",
14539                                  op[0], op[1], op[2]);
14540                           printf ("  rdst = 0x%x,", rdst);
14541                           printf ("  srca = 0x%x,", srca);
14542                           printf ("  srcb = 0x%x\n", srcb);
14543                         }
14544                       SYNTAX("and       %2, %1, %0");
14545 #line 419 "rx-decode.opc"
14546                       ID(and); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
14547
14548                     /*----------------------------------------------------------------------*/
14549                     /* OR                                                                       */
14550
14551                     }
14552                   break;
14553               }
14554             break;
14555           case 0x41:
14556               GETBYTE ();
14557               switch (op[2] & 0x00)
14558               {
14559                 case 0x00:
14560                   goto op_semantics_101;
14561                   break;
14562               }
14563             break;
14564           case 0x42:
14565               GETBYTE ();
14566               switch (op[2] & 0x00)
14567               {
14568                 case 0x00:
14569                   goto op_semantics_101;
14570                   break;
14571               }
14572             break;
14573           case 0x43:
14574               GETBYTE ();
14575               switch (op[2] & 0x00)
14576               {
14577                 case 0x00:
14578                   goto op_semantics_101;
14579                   break;
14580               }
14581             break;
14582           case 0x44:
14583               GETBYTE ();
14584               switch (op[2] & 0x00)
14585               {
14586                 case 0x00:
14587                   goto op_semantics_101;
14588                   break;
14589               }
14590             break;
14591           case 0x45:
14592               GETBYTE ();
14593               switch (op[2] & 0x00)
14594               {
14595                 case 0x00:
14596                   goto op_semantics_101;
14597                   break;
14598               }
14599             break;
14600           case 0x46:
14601               GETBYTE ();
14602               switch (op[2] & 0x00)
14603               {
14604                 case 0x00:
14605                   goto op_semantics_101;
14606                   break;
14607               }
14608             break;
14609           case 0x47:
14610               GETBYTE ();
14611               switch (op[2] & 0x00)
14612               {
14613                 case 0x00:
14614                   goto op_semantics_101;
14615                   break;
14616               }
14617             break;
14618           case 0x48:
14619               GETBYTE ();
14620               switch (op[2] & 0x00)
14621               {
14622                 case 0x00:
14623                   goto op_semantics_101;
14624                   break;
14625               }
14626             break;
14627           case 0x49:
14628               GETBYTE ();
14629               switch (op[2] & 0x00)
14630               {
14631                 case 0x00:
14632                   goto op_semantics_101;
14633                   break;
14634               }
14635             break;
14636           case 0x4a:
14637               GETBYTE ();
14638               switch (op[2] & 0x00)
14639               {
14640                 case 0x00:
14641                   goto op_semantics_101;
14642                   break;
14643               }
14644             break;
14645           case 0x4b:
14646               GETBYTE ();
14647               switch (op[2] & 0x00)
14648               {
14649                 case 0x00:
14650                   goto op_semantics_101;
14651                   break;
14652               }
14653             break;
14654           case 0x4c:
14655               GETBYTE ();
14656               switch (op[2] & 0x00)
14657               {
14658                 case 0x00:
14659                   goto op_semantics_101;
14660                   break;
14661               }
14662             break;
14663           case 0x4d:
14664               GETBYTE ();
14665               switch (op[2] & 0x00)
14666               {
14667                 case 0x00:
14668                   goto op_semantics_101;
14669                   break;
14670               }
14671             break;
14672           case 0x4e:
14673               GETBYTE ();
14674               switch (op[2] & 0x00)
14675               {
14676                 case 0x00:
14677                   goto op_semantics_101;
14678                   break;
14679               }
14680             break;
14681           case 0x4f:
14682               GETBYTE ();
14683               switch (op[2] & 0x00)
14684               {
14685                 case 0x00:
14686                   goto op_semantics_101;
14687                   break;
14688               }
14689             break;
14690           case 0x50:
14691               GETBYTE ();
14692               switch (op[2] & 0x00)
14693               {
14694                 case 0x00:
14695                   op_semantics_102:
14696                     {
14697                       /** 1111 1111 0101 rdst srca srcb or      %2, %1, %0 */
14698 #line 437 "rx-decode.opc"
14699                       int rdst AU = op[1] & 0x0f;
14700 #line 437 "rx-decode.opc"
14701                       int srca AU = (op[2] >> 4) & 0x0f;
14702 #line 437 "rx-decode.opc"
14703                       int srcb AU = op[2] & 0x0f;
14704                       if (trace)
14705                         {
14706                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
14707                                  "/** 1111 1111 0101 rdst srca srcb     or      %2, %1, %0 */",
14708                                  op[0], op[1], op[2]);
14709                           printf ("  rdst = 0x%x,", rdst);
14710                           printf ("  srca = 0x%x,", srca);
14711                           printf ("  srcb = 0x%x\n", srcb);
14712                         }
14713                       SYNTAX("or        %2, %1, %0");
14714 #line 437 "rx-decode.opc"
14715                       ID(or); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
14716
14717                     /*----------------------------------------------------------------------*/
14718                     /* XOR                                                                      */
14719
14720                     }
14721                   break;
14722               }
14723             break;
14724           case 0x51:
14725               GETBYTE ();
14726               switch (op[2] & 0x00)
14727               {
14728                 case 0x00:
14729                   goto op_semantics_102;
14730                   break;
14731               }
14732             break;
14733           case 0x52:
14734               GETBYTE ();
14735               switch (op[2] & 0x00)
14736               {
14737                 case 0x00:
14738                   goto op_semantics_102;
14739                   break;
14740               }
14741             break;
14742           case 0x53:
14743               GETBYTE ();
14744               switch (op[2] & 0x00)
14745               {
14746                 case 0x00:
14747                   goto op_semantics_102;
14748                   break;
14749               }
14750             break;
14751           case 0x54:
14752               GETBYTE ();
14753               switch (op[2] & 0x00)
14754               {
14755                 case 0x00:
14756                   goto op_semantics_102;
14757                   break;
14758               }
14759             break;
14760           case 0x55:
14761               GETBYTE ();
14762               switch (op[2] & 0x00)
14763               {
14764                 case 0x00:
14765                   goto op_semantics_102;
14766                   break;
14767               }
14768             break;
14769           case 0x56:
14770               GETBYTE ();
14771               switch (op[2] & 0x00)
14772               {
14773                 case 0x00:
14774                   goto op_semantics_102;
14775                   break;
14776               }
14777             break;
14778           case 0x57:
14779               GETBYTE ();
14780               switch (op[2] & 0x00)
14781               {
14782                 case 0x00:
14783                   goto op_semantics_102;
14784                   break;
14785               }
14786             break;
14787           case 0x58:
14788               GETBYTE ();
14789               switch (op[2] & 0x00)
14790               {
14791                 case 0x00:
14792                   goto op_semantics_102;
14793                   break;
14794               }
14795             break;
14796           case 0x59:
14797               GETBYTE ();
14798               switch (op[2] & 0x00)
14799               {
14800                 case 0x00:
14801                   goto op_semantics_102;
14802                   break;
14803               }
14804             break;
14805           case 0x5a:
14806               GETBYTE ();
14807               switch (op[2] & 0x00)
14808               {
14809                 case 0x00:
14810                   goto op_semantics_102;
14811                   break;
14812               }
14813             break;
14814           case 0x5b:
14815               GETBYTE ();
14816               switch (op[2] & 0x00)
14817               {
14818                 case 0x00:
14819                   goto op_semantics_102;
14820                   break;
14821               }
14822             break;
14823           case 0x5c:
14824               GETBYTE ();
14825               switch (op[2] & 0x00)
14826               {
14827                 case 0x00:
14828                   goto op_semantics_102;
14829                   break;
14830               }
14831             break;
14832           case 0x5d:
14833               GETBYTE ();
14834               switch (op[2] & 0x00)
14835               {
14836                 case 0x00:
14837                   goto op_semantics_102;
14838                   break;
14839               }
14840             break;
14841           case 0x5e:
14842               GETBYTE ();
14843               switch (op[2] & 0x00)
14844               {
14845                 case 0x00:
14846                   goto op_semantics_102;
14847                   break;
14848               }
14849             break;
14850           case 0x5f:
14851               GETBYTE ();
14852               switch (op[2] & 0x00)
14853               {
14854                 case 0x00:
14855                   goto op_semantics_102;
14856                   break;
14857               }
14858             break;
14859           default: UNSUPPORTED(); break;
14860         }
14861       break;
14862     default: UNSUPPORTED(); break;
14863   }
14864 #line 994 "rx-decode.opc"
14865
14866   return rx->n_bytes;
14867 }