opcodes/rx-decode.c

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