/src/binutils-gdb/opcodes/rl78-decode.c

Line	Count	Source
1		/* DO NOT EDIT! -- buffer-read-only: t -- vi:set ro: */
2		#line 1 "rl78-decode.opc"
3		/* -- c -- */
4		/* Copyright (C) 2012-2026 Free Software Foundation, Inc.
5		Contributed by Red Hat.
6		Written by DJ Delorie.
7
8		This file is part of the GNU opcodes library.
9
10		This library is free software; you can redistribute it and/or modify
11		it under the terms of the GNU General Public License as published by
12		the Free Software Foundation; either version 3, or (at your option)
13		any later version.
14
15		It is distributed in the hope that it will be useful, but WITHOUT
16		ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
17		or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
18		License for more details.
19
20		You should have received a copy of the GNU General Public License
21		along with this program; if not, write to the Free Software
22		Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
23		MA 02110-1301, USA. */
24
25		#include "sysdep.h"
26		#include <stdio.h>
27		#include <stdlib.h>
28		#include <string.h>
29		#include "bfd.h"
30		#include "opintl.h"
31		#include "opcode/rl78.h"
32
33		static int trace = 0;
34
35		typedef struct
36		{
37		RL78_Opcode_Decoded * rl78;
38		int (* getbyte)(void *);
39		void * ptr;
40		unsigned char * op;
41		} LocalData;
42
43	5.92M	#define ID(x) rl78->id = RLO_##x, rl78->lineno = __LINE__
44	7.92M	#define OP(n,t,r,a) (rl78->op[n].type = t, \
45	7.92M	rl78->op[n].reg = r, \
46	7.92M	rl78->op[n].addend = a )
47		#define OPX(n,t,r1,r2,a) \
48	14.9k	(rl78->op[n].type = t, \
49	14.9k	rl78->op[n].reg = r1, \
50	14.9k	rl78->op[n].reg2 = r2, \
51	14.9k	rl78->op[n].addend = a )
52
53	1.32M	#define W() rl78->size = RL78_Word
54
55		#define AU ATTRIBUTE_UNUSED
56
57	10.3M	#define OP_BUF_LEN 20
58	10.3M	#define GETBYTE() (ld->rl78->n_bytes < (OP_BUF_LEN - 1) ? ld->op [ld->rl78->n_bytes++] = ld->getbyte (ld->ptr): 0)
59	3.21M	#define B ((unsigned long) GETBYTE())
60
61	6.63M	#define SYNTAX(x) rl78->syntax = x
62
63		#define UNSUPPORTED() \
64	8.74k	rl78->syntax = "unknown"
65
66		#define RB(x) ((x)+RL78_Reg_X)
67		#define RW(x) ((x)+RL78_Reg_AX)
68
69	366k	#define Fz rl78->flags = RL78_PSW_Z
70	264k	#define Fza rl78->flags = RL78_PSW_Z \| RL78_PSW_AC
71	2.33k	#define Fzc rl78->flags = RL78_PSW_Z \| RL78_PSW_CY
72	1.05M	#define Fzac rl78->flags = RL78_PSW_Z \| RL78_PSW_AC \| RL78_PSW_CY
73		#define Fa rl78->flags = RL78_PSW_AC
74		#define Fc rl78->flags = RL78_PSW_CY
75		#define Fac rl78->flags = RL78_PSW_AC \| RL78_PSW_CY
76
77	33.2k	#define IMMU(bytes) immediate (bytes, 0, ld)
78		#define IMMS(bytes) immediate (bytes, 1, ld)
79
80		static int
81		immediate (int bytes, int sign_extend, LocalData * ld)
82	2.36M	{
83	2.36M	unsigned long i = 0;
84
85	2.36M	switch (bytes)
86	2.36M	{
87	1.53M	case 1:
88	1.53M	i \|= B;
89	1.53M	if (sign_extend && (i & 0x80))
90	35.6k	i -= 0x100;
91	1.53M	break;
92	806k	case 2:
93	806k	i \|= B;
94	806k	i \|= B << 8;
95	806k	if (sign_extend && (i & 0x8000))
96	17.6k	i -= 0x10000;
97	806k	break;
98	23.1k	case 3:
99	23.1k	i \|= B;
100	23.1k	i \|= B << 8;
101	23.1k	i \|= B << 16;
102	23.1k	if (sign_extend && (i & 0x800000))
103	0	i -= 0x1000000;
104	23.1k	break;
105	0	default:
106	0	opcodes_error_handler
107		/* xgettext:c-format */
108	0	(_("internal error: immediate() called with invalid byte count %d"),
109	0	bytes);
110	0	abort();
111	2.36M	}
112	2.36M	return i;
113	2.36M	}
114
115	162k	#define DC(c) OP (0, RL78_Operand_Immediate, 0, c)
116	1.93M	#define DR(r) OP (0, RL78_Operand_Register, RL78_Reg_##r, 0)
117	761k	#define DRB(r) OP (0, RL78_Operand_Register, RB(r), 0)
118	352k	#define DRW(r) OP (0, RL78_Operand_Register, RW(r), 0)
119	727k	#define DM(r,a) OP (0, RL78_Operand_Indirect, RL78_Reg_##r, a)
120	872	#define DM2(r1,r2,a) OPX (0, RL78_Operand_Indirect, RL78_Reg_##r1, RL78_Reg_##r2, a)
121	706k	#define DE() rl78->op[0].use_es = 1
122	197k	#define DB(b) set_bit (rl78->op, b)
123	74.9k	#define DCY() DR(PSW); DB(0)
124	82.2k	#define DPUSH() OP (0, RL78_Operand_PreDec, RL78_Reg_SP, 0);
125
126	1.40M	#define SC(c) OP (1, RL78_Operand_Immediate, 0, c)
127	697k	#define SR(r) OP (1, RL78_Operand_Register, RL78_Reg_##r, 0)
128	183k	#define SRB(r) OP (1, RL78_Operand_Register, RB(r), 0)
129	430k	#define SRW(r) OP (1, RL78_Operand_Register, RW(r), 0)
130	1.11M	#define SM(r,a) OP (1, RL78_Operand_Indirect, RL78_Reg_##r, a)
131	14.0k	#define SM2(r1,r2,a) OPX (1, RL78_Operand_Indirect, RL78_Reg_##r1, RL78_Reg_##r2, a)
132	706k	#define SE() rl78->op[1].use_es = 1
133	169k	#define SB(b) set_bit (rl78->op+1, b)
134	71.3k	#define SCY() SR(PSW); SB(0)
135	68.6k	#define COND(c) rl78->op[1].condition = RL78_Condition_##c
136	66.1k	#define SPOP() OP (1, RL78_Operand_PostInc, RL78_Reg_SP, 0);
137
138		static void
139		set_bit (RL78_Opcode_Operand *op, int bit)
140	366k	{
141	366k	op->bit_number = bit;
142	366k	switch (op->type) {
143	182k	case RL78_Operand_Register:
144	182k	op->type = RL78_Operand_Bit;
145	182k	break;
146	184k	case RL78_Operand_Indirect:
147	184k	op->type = RL78_Operand_BitIndirect;
148	184k	break;
149	0	default:
150	0	break;
151	366k	}
152	366k	}
153
154		static int
155		saddr (int x)
156	553k	{
157	553k	if (x < 0x20)
158	143k	return 0xfff00 + x;
159	409k	return 0xffe00 + x;
160	553k	}
161
162		static int
163		sfr (int x)
164	117k	{
165	117k	return 0xfff00 + x;
166	117k	}
167
168		#define SADDR saddr (IMMU (1))
169	21.1k	#define SFR sfr (IMMU (1))
170
171		int
172		rl78_decode_opcode (unsigned long pc AU,
173		RL78_Opcode_Decoded * rl78,
174		int (* getbyte)(void *),
175		void * ptr,
176		RL78_Dis_Isa isa)
177	5.93M	{
178	5.93M	LocalData lds, * ld = &lds;
179	5.93M	unsigned char op_buf[OP_BUF_LEN] = {0};
180	5.93M	unsigned char *op = op_buf;
181	5.93M	int op0, op1;
182
183	5.93M	lds.rl78 = rl78;
184	5.93M	lds.getbyte = getbyte;
185	5.93M	lds.ptr = ptr;
186	5.93M	lds.op = op;
187
188	5.93M	memset (rl78, 0, sizeof (*rl78));
189
190	6.64M	start_again:
191
192		/* Byte registers, not including A. */
193		/* Word registers, not including AX. */
194
195		/----------------------------------------------------------------------/
196		/* ES: prefix */
197
198	6.64M	GETBYTE ();
199	6.64M	switch (op[0] & 0xff)
200	6.64M	{
201	1.28M	case 0x00:
202	1.28M	{
203		/** 0000 0000 nop */
204	1.28M	if (trace)
205	0	{
206	0	printf ("\033[33m%s\033[0m %02x\n",
207	0	"/** 0000 0000 nop */",
208	0	op[0]);
209	0	}
210	1.28M	SYNTAX("nop");
211	1.28M	#line 917 "rl78-decode.opc"
212	1.28M	ID(nop);
213
214		/----------------------------------------------------------------------/
215
216	1.28M	}
217	1.28M	break;
218	71.2k	case 0x01:
219	99.8k	case 0x03:
220	120k	case 0x05:
221	140k	case 0x07:
222	140k	{
223		/** 0000 0rw1 addw %0, %1 */
224	140k	#line 280 "rl78-decode.opc"
225	140k	int rw AU = (op[0] >> 1) & 0x03;
226	140k	if (trace)
227	0	{
228	0	printf ("\033[33m%s\033[0m %02x\n",
229	0	"/** 0000 0rw1 addw %0, %1 */",
230	0	op[0]);
231	0	printf (" rw = 0x%x\n", rw);
232	0	}
233	140k	SYNTAX("addw %0, %1");
234	140k	#line 280 "rl78-decode.opc"
235	140k	ID(add); W(); DR(AX); SRW(rw); Fzac;
236
237	140k	}
238	140k	break;
239	35.0k	case 0x02:
240	35.0k	{
241		/** 0000 0010 addw %0, %e!1 */
242	35.0k	if (trace)
243	0	{
244	0	printf ("\033[33m%s\033[0m %02x\n",
245	0	"/** 0000 0010 addw %0, %e!1 */",
246	0	op[0]);
247	0	}
248	35.0k	SYNTAX("addw %0, %e!1");
249	35.0k	#line 271 "rl78-decode.opc"
250	35.0k	ID(add); W(); DR(AX); SM(None, IMMU(2)); Fzac;
251
252	35.0k	}
253	35.0k	break;
254	24.9k	case 0x04:
255	24.9k	{
256		/** 0000 0100 addw %0, #%1 */
257	24.9k	if (trace)
258	0	{
259	0	printf ("\033[33m%s\033[0m %02x\n",
260	0	"/** 0000 0100 addw %0, #%1 */",
261	0	op[0]);
262	0	}
263	24.9k	SYNTAX("addw %0, #%1");
264	24.9k	#line 277 "rl78-decode.opc"
265	24.9k	ID(add); W(); DR(AX); SC(IMMU(2)); Fzac;
266
267	24.9k	}
268	24.9k	break;
269	22.7k	case 0x06:
270	22.7k	{
271		/** 0000 0110 addw %0, %1 */
272	22.7k	if (trace)
273	0	{
274	0	printf ("\033[33m%s\033[0m %02x\n",
275	0	"/** 0000 0110 addw %0, %1 */",
276	0	op[0]);
277	0	}
278	22.7k	SYNTAX("addw %0, %1");
279	22.7k	#line 283 "rl78-decode.opc"
280	22.7k	ID(add); W(); DR(AX); SM(None, SADDR); Fzac;
281
282	22.7k	}
283	22.7k	break;
284	21.5k	case 0x08:
285	21.5k	{
286		/** 0000 1000 xch a, x */
287	21.5k	if (trace)
288	0	{
289	0	printf ("\033[33m%s\033[0m %02x\n",
290	0	"/** 0000 1000 xch a, x */",
291	0	op[0]);
292	0	}
293	21.5k	SYNTAX("xch a, x");
294	21.5k	#line 1240 "rl78-decode.opc"
295	21.5k	ID(xch); DR(A); SR(X);
296
297		/----------------------------------------------------------------------/
298
299	21.5k	}
300	21.5k	break;
301	18.8k	case 0x09:
302	18.8k	{
303		/** 0000 1001 mov %0, %e1 */
304	18.8k	if (trace)
305	0	{
306	0	printf ("\033[33m%s\033[0m %02x\n",
307	0	"/** 0000 1001 mov %0, %e1 */",
308	0	op[0]);
309	0	}
310	18.8k	SYNTAX("mov %0, %e1");
311	18.8k	#line 684 "rl78-decode.opc"
312	18.8k	ID(mov); DR(A); SM(B, IMMU(2));
313
314	18.8k	}
315	18.8k	break;
316	13.4k	case 0x0a:
317	13.4k	{
318		/** 0000 1010 add %0, #%1 */
319	13.4k	if (trace)
320	0	{
321	0	printf ("\033[33m%s\033[0m %02x\n",
322	0	"/** 0000 1010 add %0, #%1 */",
323	0	op[0]);
324	0	}
325	13.4k	SYNTAX("add %0, #%1");
326	13.4k	#line 234 "rl78-decode.opc"
327	13.4k	ID(add); DM(None, SADDR); SC(IMMU(1)); Fzac;
328
329		/----------------------------------------------------------------------/
330
331	13.4k	}
332	13.4k	break;
333	13.2k	case 0x0b:
334	13.2k	{
335		/** 0000 1011 add %0, %1 */
336	13.2k	if (trace)
337	0	{
338	0	printf ("\033[33m%s\033[0m %02x\n",
339	0	"/** 0000 1011 add %0, %1 */",
340	0	op[0]);
341	0	}
342	13.2k	SYNTAX("add %0, %1");
343	13.2k	#line 228 "rl78-decode.opc"
344	13.2k	ID(add); DR(A); SM(None, SADDR); Fzac;
345
346	13.2k	}
347	13.2k	break;
348	14.0k	case 0x0c:
349	14.0k	{
350		/** 0000 1100 add %0, #%1 */
351	14.0k	if (trace)
352	0	{
353	0	printf ("\033[33m%s\033[0m %02x\n",
354	0	"/** 0000 1100 add %0, #%1 */",
355	0	op[0]);
356	0	}
357	14.0k	SYNTAX("add %0, #%1");
358	14.0k	#line 222 "rl78-decode.opc"
359	14.0k	ID(add); DR(A); SC(IMMU(1)); Fzac;
360
361	14.0k	}
362	14.0k	break;
363	21.3k	case 0x0d:
364	21.3k	{
365		/** 0000 1101 add %0, %e1 */
366	21.3k	if (trace)
367	0	{
368	0	printf ("\033[33m%s\033[0m %02x\n",
369	0	"/** 0000 1101 add %0, %e1 */",
370	0	op[0]);
371	0	}
372	21.3k	SYNTAX("add %0, %e1");
373	21.3k	#line 210 "rl78-decode.opc"
374	21.3k	ID(add); DR(A); SM(HL, 0); Fzac;
375
376	21.3k	}
377	21.3k	break;
378	20.2k	case 0x0e:
379	20.2k	{
380		/** 0000 1110 add %0, %ea1 */
381	20.2k	if (trace)
382	0	{
383	0	printf ("\033[33m%s\033[0m %02x\n",
384	0	"/** 0000 1110 add %0, %ea1 */",
385	0	op[0]);
386	0	}
387	20.2k	SYNTAX("add %0, %ea1");
388	20.2k	#line 216 "rl78-decode.opc"
389	20.2k	ID(add); DR(A); SM(HL, IMMU(1)); Fzac;
390
391	20.2k	}
392	20.2k	break;
393	18.6k	case 0x0f:
394	18.6k	{
395		/** 0000 1111 add %0, %e!1 */
396	18.6k	if (trace)
397	0	{
398	0	printf ("\033[33m%s\033[0m %02x\n",
399	0	"/** 0000 1111 add %0, %e!1 */",
400	0	op[0]);
401	0	}
402	18.6k	SYNTAX("add %0, %e!1");
403	18.6k	#line 207 "rl78-decode.opc"
404	18.6k	ID(add); DR(A); SM(None, IMMU(2)); Fzac;
405
406	18.6k	}
407	18.6k	break;
408	34.0k	case 0x10:
409	34.0k	{
410		/** 0001 0000 addw %0, #%1 */
411	34.0k	if (trace)
412	0	{
413	0	printf ("\033[33m%s\033[0m %02x\n",
414	0	"/** 0001 0000 addw %0, #%1 */",
415	0	op[0]);
416	0	}
417	34.0k	SYNTAX("addw %0, #%1");
418	34.0k	#line 286 "rl78-decode.opc"
419	34.0k	ID(add); W(); DR(SP); SC(IMMU(1)); Fzac;
420
421		/----------------------------------------------------------------------/
422
423	34.0k	}
424	34.0k	break;
425	706k	case 0x11:
426	706k	{
427		/** 0001 0001 es: */
428	706k	if (trace)
429	0	{
430	0	printf ("\033[33m%s\033[0m %02x\n",
431	0	"/** 0001 0001 es: */",
432	0	op[0]);
433	0	}
434	706k	SYNTAX("es:");
435	706k	#line 199 "rl78-decode.opc"
436	706k	DE(); SE();
437	706k	op ++;
438	706k	pc ++;
439	706k	goto start_again;
440
441		/----------------------------------------------------------------------/
442
443	120k	}
444	0	break;
445	12.0k	case 0x12:
446	23.5k	case 0x14:
447	36.4k	case 0x16:
448	36.4k	{
449		/** 0001 0ra0 movw %0, %1 */
450	36.4k	#line 865 "rl78-decode.opc"
451	36.4k	int ra AU = (op[0] >> 1) & 0x03;
452	36.4k	if (trace)
453	0	{
454	0	printf ("\033[33m%s\033[0m %02x\n",
455	0	"/** 0001 0ra0 movw %0, %1 */",
456	0	op[0]);
457	0	printf (" ra = 0x%x\n", ra);
458	0	}
459	36.4k	SYNTAX("movw %0, %1");
460	36.4k	#line 865 "rl78-decode.opc"
461	36.4k	ID(mov); W(); DRW(ra); SR(AX);
462
463	36.4k	}
464	36.4k	break;
465	16.6k	case 0x13:
466	30.7k	case 0x15:
467	41.1k	case 0x17:
468	41.1k	{
469		/** 0001 0ra1 movw %0, %1 */
470	41.1k	#line 862 "rl78-decode.opc"
471	41.1k	int ra AU = (op[0] >> 1) & 0x03;
472	41.1k	if (trace)
473	0	{
474	0	printf ("\033[33m%s\033[0m %02x\n",
475	0	"/** 0001 0ra1 movw %0, %1 */",
476	0	op[0]);
477	0	printf (" ra = 0x%x\n", ra);
478	0	}
479	41.1k	SYNTAX("movw %0, %1");
480	41.1k	#line 862 "rl78-decode.opc"
481	41.1k	ID(mov); W(); DR(AX); SRW(ra);
482
483	41.1k	}
484	41.1k	break;
485	9.32k	case 0x18:
486	9.32k	{
487		/** 0001 1000 mov %e0, %1 */
488	9.32k	if (trace)
489	0	{
490	0	printf ("\033[33m%s\033[0m %02x\n",
491	0	"/** 0001 1000 mov %e0, %1 */",
492	0	op[0]);
493	0	}
494	9.32k	SYNTAX("mov %e0, %1");
495	9.32k	#line 735 "rl78-decode.opc"
496	9.32k	ID(mov); DM(B, IMMU(2)); SR(A);
497
498	9.32k	}
499	9.32k	break;
500	10.7k	case 0x19:
501	10.7k	{
502		/** 0001 1001 mov %e0, #%1 */
503	10.7k	if (trace)
504	0	{
505	0	printf ("\033[33m%s\033[0m %02x\n",
506	0	"/** 0001 1001 mov %e0, #%1 */",
507	0	op[0]);
508	0	}
509	10.7k	SYNTAX("mov %e0, #%1");
510	10.7k	#line 732 "rl78-decode.opc"
511	10.7k	ID(mov); DM(B, IMMU(2)); SC(IMMU(1));
512
513	10.7k	}
514	10.7k	break;
515	9.02k	case 0x1a:
516	9.02k	{
517		/** 0001 1010 addc %0, #%1 */
518	9.02k	if (trace)
519	0	{
520	0	printf ("\033[33m%s\033[0m %02x\n",
521	0	"/** 0001 1010 addc %0, #%1 */",
522	0	op[0]);
523	0	}
524	9.02k	SYNTAX("addc %0, #%1");
525	9.02k	#line 266 "rl78-decode.opc"
526	9.02k	ID(addc); DM(None, SADDR); SC(IMMU(1)); Fzac;
527
528		/----------------------------------------------------------------------/
529
530	9.02k	}
531	9.02k	break;
532	12.5k	case 0x1b:
533	12.5k	{
534		/** 0001 1011 addc %0, %1 */
535	12.5k	if (trace)
536	0	{
537	0	printf ("\033[33m%s\033[0m %02x\n",
538	0	"/** 0001 1011 addc %0, %1 */",
539	0	op[0]);
540	0	}
541	12.5k	SYNTAX("addc %0, %1");
542	12.5k	#line 263 "rl78-decode.opc"
543	12.5k	ID(addc); DR(A); SM(None, SADDR); Fzac;
544
545	12.5k	}
546	12.5k	break;
547	14.2k	case 0x1c:
548	14.2k	{
549		/** 0001 1100 addc %0, #%1 */
550	14.2k	if (trace)
551	0	{
552	0	printf ("\033[33m%s\033[0m %02x\n",
553	0	"/** 0001 1100 addc %0, #%1 */",
554	0	op[0]);
555	0	}
556	14.2k	SYNTAX("addc %0, #%1");
557	14.2k	#line 254 "rl78-decode.opc"
558	14.2k	ID(addc); DR(A); SC(IMMU(1)); Fzac;
559
560	14.2k	}
561	14.2k	break;
562	13.5k	case 0x1d:
563	13.5k	{
564		/** 0001 1101 addc %0, %e1 */
565	13.5k	if (trace)
566	0	{
567	0	printf ("\033[33m%s\033[0m %02x\n",
568	0	"/** 0001 1101 addc %0, %e1 */",
569	0	op[0]);
570	0	}
571	13.5k	SYNTAX("addc %0, %e1");
572	13.5k	#line 242 "rl78-decode.opc"
573	13.5k	ID(addc); DR(A); SM(HL, 0); Fzac;
574
575	13.5k	}
576	13.5k	break;
577	26.8k	case 0x1e:
578	26.8k	{
579		/** 0001 1110 addc %0, %ea1 */
580	26.8k	if (trace)
581	0	{
582	0	printf ("\033[33m%s\033[0m %02x\n",
583	0	"/** 0001 1110 addc %0, %ea1 */",
584	0	op[0]);
585	0	}
586	26.8k	SYNTAX("addc %0, %ea1");
587	26.8k	#line 251 "rl78-decode.opc"
588	26.8k	ID(addc); DR(A); SM(HL, IMMU(1)); Fzac;
589
590	26.8k	}
591	26.8k	break;
592	10.7k	case 0x1f:
593	10.7k	{
594		/** 0001 1111 addc %0, %e!1 */
595	10.7k	if (trace)
596	0	{
597	0	printf ("\033[33m%s\033[0m %02x\n",
598	0	"/** 0001 1111 addc %0, %e!1 */",
599	0	op[0]);
600	0	}
601	10.7k	SYNTAX("addc %0, %e!1");
602	10.7k	#line 239 "rl78-decode.opc"
603	10.7k	ID(addc); DR(A); SM(None, IMMU(2)); Fzac;
604
605	10.7k	}
606	10.7k	break;
607	34.9k	case 0x20:
608	34.9k	{
609		/** 0010 0000 subw %0, #%1 */
610	34.9k	if (trace)
611	0	{
612	0	printf ("\033[33m%s\033[0m %02x\n",
613	0	"/** 0010 0000 subw %0, #%1 */",
614	0	op[0]);
615	0	}
616	34.9k	SYNTAX("subw %0, #%1");
617	34.9k	#line 1204 "rl78-decode.opc"
618	34.9k	ID(sub); W(); DR(SP); SC(IMMU(1)); Fzac;
619
620		/----------------------------------------------------------------------/
621
622	34.9k	}
623	34.9k	break;
624	20.1k	case 0x21:
625	33.5k	case 0x23:
626	50.4k	case 0x25:
627	67.1k	case 0x27:
628	67.1k	{
629		/** 0010 0rw1 subw %0, %1 */
630	67.1k	#line 1198 "rl78-decode.opc"
631	67.1k	int rw AU = (op[0] >> 1) & 0x03;
632	67.1k	if (trace)
633	0	{
634	0	printf ("\033[33m%s\033[0m %02x\n",
635	0	"/** 0010 0rw1 subw %0, %1 */",
636	0	op[0]);
637	0	printf (" rw = 0x%x\n", rw);
638	0	}
639	67.1k	SYNTAX("subw %0, %1");
640	67.1k	#line 1198 "rl78-decode.opc"
641	67.1k	ID(sub); W(); DR(AX); SRW(rw); Fzac;
642
643	67.1k	}
644	67.1k	break;
645	7.91k	case 0x22:
646	7.91k	{
647		/** 0010 0010 subw %0, %e!1 */
648	7.91k	if (trace)
649	0	{
650	0	printf ("\033[33m%s\033[0m %02x\n",
651	0	"/** 0010 0010 subw %0, %e!1 */",
652	0	op[0]);
653	0	}
654	7.91k	SYNTAX("subw %0, %e!1");
655	7.91k	#line 1189 "rl78-decode.opc"
656	7.91k	ID(sub); W(); DR(AX); SM(None, IMMU(2)); Fzac;
657
658	7.91k	}
659	7.91k	break;
660	12.3k	case 0x24:
661	12.3k	{
662		/** 0010 0100 subw %0, #%1 */
663	12.3k	if (trace)
664	0	{
665	0	printf ("\033[33m%s\033[0m %02x\n",
666	0	"/** 0010 0100 subw %0, #%1 */",
667	0	op[0]);
668	0	}
669	12.3k	SYNTAX("subw %0, #%1");
670	12.3k	#line 1195 "rl78-decode.opc"
671	12.3k	ID(sub); W(); DR(AX); SC(IMMU(2)); Fzac;
672
673	12.3k	}
674	12.3k	break;
675	11.0k	case 0x26:
676	11.0k	{
677		/** 0010 0110 subw %0, %1 */
678	11.0k	if (trace)
679	0	{
680	0	printf ("\033[33m%s\033[0m %02x\n",
681	0	"/** 0010 0110 subw %0, %1 */",
682	0	op[0]);
683	0	}
684	11.0k	SYNTAX("subw %0, %1");
685	11.0k	#line 1201 "rl78-decode.opc"
686	11.0k	ID(sub); W(); DR(AX); SM(None, SADDR); Fzac;
687
688	11.0k	}
689	11.0k	break;
690	14.3k	case 0x28:
691	14.3k	{
692		/** 0010 1000 mov %e0, %1 */
693	14.3k	if (trace)
694	0	{
695	0	printf ("\033[33m%s\033[0m %02x\n",
696	0	"/** 0010 1000 mov %e0, %1 */",
697	0	op[0]);
698	0	}
699	14.3k	SYNTAX("mov %e0, %1");
700	14.3k	#line 747 "rl78-decode.opc"
701	14.3k	ID(mov); DM(C, IMMU(2)); SR(A);
702
703	14.3k	}
704	14.3k	break;
705	9.52k	case 0x29:
706	9.52k	{
707		/** 0010 1001 mov %0, %e1 */
708	9.52k	if (trace)
709	0	{
710	0	printf ("\033[33m%s\033[0m %02x\n",
711	0	"/** 0010 1001 mov %0, %e1 */",
712	0	op[0]);
713	0	}
714	9.52k	SYNTAX("mov %0, %e1");
715	9.52k	#line 690 "rl78-decode.opc"
716	9.52k	ID(mov); DR(A); SM(C, IMMU(2));
717
718	9.52k	}
719	9.52k	break;
720	11.3k	case 0x2a:
721	11.3k	{
722		/** 0010 1010 sub %0, #%1 */
723	11.3k	if (trace)
724	0	{
725	0	printf ("\033[33m%s\033[0m %02x\n",
726	0	"/** 0010 1010 sub %0, #%1 */",
727	0	op[0]);
728	0	}
729	11.3k	SYNTAX("sub %0, #%1");
730	11.3k	#line 1152 "rl78-decode.opc"
731	11.3k	ID(sub); DM(None, SADDR); SC(IMMU(1)); Fzac;
732
733		/----------------------------------------------------------------------/
734
735	11.3k	}
736	11.3k	break;
737	17.3k	case 0x2b:
738	17.3k	{
739		/** 0010 1011 sub %0, %1 */
740	17.3k	if (trace)
741	0	{
742	0	printf ("\033[33m%s\033[0m %02x\n",
743	0	"/** 0010 1011 sub %0, %1 */",
744	0	op[0]);
745	0	}
746	17.3k	SYNTAX("sub %0, %1");
747	17.3k	#line 1146 "rl78-decode.opc"
748	17.3k	ID(sub); DR(A); SM(None, SADDR); Fzac;
749
750	17.3k	}
751	17.3k	break;
752	11.8k	case 0x2c:
753	11.8k	{
754		/** 0010 1100 sub %0, #%1 */
755	11.8k	if (trace)
756	0	{
757	0	printf ("\033[33m%s\033[0m %02x\n",
758	0	"/** 0010 1100 sub %0, #%1 */",
759	0	op[0]);
760	0	}
761	11.8k	SYNTAX("sub %0, #%1");
762	11.8k	#line 1140 "rl78-decode.opc"
763	11.8k	ID(sub); DR(A); SC(IMMU(1)); Fzac;
764
765	11.8k	}
766	11.8k	break;
767	12.5k	case 0x2d:
768	12.5k	{
769		/** 0010 1101 sub %0, %e1 */
770	12.5k	if (trace)
771	0	{
772	0	printf ("\033[33m%s\033[0m %02x\n",
773	0	"/** 0010 1101 sub %0, %e1 */",
774	0	op[0]);
775	0	}
776	12.5k	SYNTAX("sub %0, %e1");
777	12.5k	#line 1128 "rl78-decode.opc"
778	12.5k	ID(sub); DR(A); SM(HL, 0); Fzac;
779
780	12.5k	}
781	12.5k	break;
782	21.8k	case 0x2e:
783	21.8k	{
784		/** 0010 1110 sub %0, %ea1 */
785	21.8k	if (trace)
786	0	{
787	0	printf ("\033[33m%s\033[0m %02x\n",
788	0	"/** 0010 1110 sub %0, %ea1 */",
789	0	op[0]);
790	0	}
791	21.8k	SYNTAX("sub %0, %ea1");
792	21.8k	#line 1134 "rl78-decode.opc"
793	21.8k	ID(sub); DR(A); SM(HL, IMMU(1)); Fzac;
794
795	21.8k	}
796	21.8k	break;
797	12.2k	case 0x2f:
798	12.2k	{
799		/** 0010 1111 sub %0, %e!1 */
800	12.2k	if (trace)
801	0	{
802	0	printf ("\033[33m%s\033[0m %02x\n",
803	0	"/** 0010 1111 sub %0, %e!1 */",
804	0	op[0]);
805	0	}
806	12.2k	SYNTAX("sub %0, %e!1");
807	12.2k	#line 1125 "rl78-decode.opc"
808	12.2k	ID(sub); DR(A); SM(None, IMMU(2)); Fzac;
809
810	12.2k	}
811	12.2k	break;
812	27.0k	case 0x30:
813	51.9k	case 0x32:
814	69.0k	case 0x34:
815	81.1k	case 0x36:
816	81.1k	{
817		/** 0011 0rg0 movw %0, #%1 */
818	81.1k	#line 859 "rl78-decode.opc"
819	81.1k	int rg AU = (op[0] >> 1) & 0x03;
820	81.1k	if (trace)
821	0	{
822	0	printf ("\033[33m%s\033[0m %02x\n",
823	0	"/** 0011 0rg0 movw %0, #%1 */",
824	0	op[0]);
825	0	printf (" rg = 0x%x\n", rg);
826	0	}
827	81.1k	SYNTAX("movw %0, #%1");
828	81.1k	#line 859 "rl78-decode.opc"
829	81.1k	ID(mov); W(); DRW(rg); SC(IMMU(2));
830
831	81.1k	}
832	81.1k	break;
833	40.8k	case 0x31:
834	40.8k	GETBYTE ();
835	40.8k	switch (op[1] & 0x8f)
836	40.8k	{
837	3.18k	case 0x00:
838	3.18k	{
839		/** 0011 0001 0bit 0000 btclr %s1, $%a0 */
840	3.18k	#line 422 "rl78-decode.opc"
841	3.18k	int bit AU = (op[1] >> 4) & 0x07;
842	3.18k	if (trace)
843	0	{
844	0	printf ("\033[33m%s\033[0m %02x %02x\n",
845	0	"/** 0011 0001 0bit 0000 btclr %s1, $%a0 */",
846	0	op[0], op[1]);
847	0	printf (" bit = 0x%x\n", bit);
848	0	}
849	3.18k	SYNTAX("btclr %s1, $%a0");
850	3.18k	#line 422 "rl78-decode.opc"
851	3.18k	ID(branch_cond_clear); SM(None, SADDR); SB(bit); DC(pc+IMMS(1)+4); COND(T);
852
853		/----------------------------------------------------------------------/
854
855	3.18k	}
856	3.18k	break;
857	7.77k	case 0x01:
858	7.77k	{
859		/** 0011 0001 0bit 0001 btclr %1, $%a0 */
860	7.77k	#line 416 "rl78-decode.opc"
861	7.77k	int bit AU = (op[1] >> 4) & 0x07;
862	7.77k	if (trace)
863	0	{
864	0	printf ("\033[33m%s\033[0m %02x %02x\n",
865	0	"/** 0011 0001 0bit 0001 btclr %1, $%a0 */",
866	0	op[0], op[1]);
867	0	printf (" bit = 0x%x\n", bit);
868	0	}
869	7.77k	SYNTAX("btclr %1, $%a0");
870	7.77k	#line 416 "rl78-decode.opc"
871	7.77k	ID(branch_cond_clear); DC(pc+IMMS(1)+3); SR(A); SB(bit); COND(T);
872
873	7.77k	}
874	7.77k	break;
875	3.08k	case 0x02:
876	3.08k	{
877		/** 0011 0001 0bit 0010 bt %s1, $%a0 */
878	3.08k	#line 408 "rl78-decode.opc"
879	3.08k	int bit AU = (op[1] >> 4) & 0x07;
880	3.08k	if (trace)
881	0	{
882	0	printf ("\033[33m%s\033[0m %02x %02x\n",
883	0	"/** 0011 0001 0bit 0010 bt %s1, $%a0 */",
884	0	op[0], op[1]);
885	0	printf (" bit = 0x%x\n", bit);
886	0	}
887	3.08k	SYNTAX("bt %s1, $%a0");
888	3.08k	#line 408 "rl78-decode.opc"
889	3.08k	ID(branch_cond); SM(None, SADDR); SB(bit); DC(pc+IMMS(1)+4); COND(T);
890
891		/----------------------------------------------------------------------/
892
893	3.08k	}
894	3.08k	break;
895	963	case 0x03:
896	963	{
897		/** 0011 0001 0bit 0011 bt %1, $%a0 */
898	963	#line 402 "rl78-decode.opc"
899	963	int bit AU = (op[1] >> 4) & 0x07;
900	963	if (trace)
901	0	{
902	0	printf ("\033[33m%s\033[0m %02x %02x\n",
903	0	"/** 0011 0001 0bit 0011 bt %1, $%a0 */",
904	0	op[0], op[1]);
905	0	printf (" bit = 0x%x\n", bit);
906	0	}
907	963	SYNTAX("bt %1, $%a0");
908	963	#line 402 "rl78-decode.opc"
909	963	ID(branch_cond); DC(pc+IMMS(1)+3); SR(A); SB(bit); COND(T);
910
911	963	}
912	963	break;
913	2.14k	case 0x04:
914	2.14k	{
915		/** 0011 0001 0bit 0100 bf %s1, $%a0 */
916	2.14k	#line 369 "rl78-decode.opc"
917	2.14k	int bit AU = (op[1] >> 4) & 0x07;
918	2.14k	if (trace)
919	0	{
920	0	printf ("\033[33m%s\033[0m %02x %02x\n",
921	0	"/** 0011 0001 0bit 0100 bf %s1, $%a0 */",
922	0	op[0], op[1]);
923	0	printf (" bit = 0x%x\n", bit);
924	0	}
925	2.14k	SYNTAX("bf %s1, $%a0");
926	2.14k	#line 369 "rl78-decode.opc"
927	2.14k	ID(branch_cond); SM(None, SADDR); SB(bit); DC(pc+IMMS(1)+4); COND(F);
928
929		/----------------------------------------------------------------------/
930
931	2.14k	}
932	2.14k	break;
933	1.72k	case 0x05:
934	1.72k	{
935		/** 0011 0001 0bit 0101 bf %1, $%a0 */
936	1.72k	#line 363 "rl78-decode.opc"
937	1.72k	int bit AU = (op[1] >> 4) & 0x07;
938	1.72k	if (trace)
939	0	{
940	0	printf ("\033[33m%s\033[0m %02x %02x\n",
941	0	"/** 0011 0001 0bit 0101 bf %1, $%a0 */",
942	0	op[0], op[1]);
943	0	printf (" bit = 0x%x\n", bit);
944	0	}
945	1.72k	SYNTAX("bf %1, $%a0");
946	1.72k	#line 363 "rl78-decode.opc"
947	1.72k	ID(branch_cond); DC(pc+IMMS(1)+3); SR(A); SB(bit); COND(F);
948
949	1.72k	}
950	1.72k	break;
951	1.72k	case 0x07:
952	1.72k	{
953		/** 0011 0001 0cnt 0111 shl %0, %1 */
954	1.72k	#line 1081 "rl78-decode.opc"
955	1.72k	int cnt AU = (op[1] >> 4) & 0x07;
956	1.72k	if (trace)
957	0	{
958	0	printf ("\033[33m%s\033[0m %02x %02x\n",
959	0	"/** 0011 0001 0cnt 0111 shl %0, %1 */",
960	0	op[0], op[1]);
961	0	printf (" cnt = 0x%x\n", cnt);
962	0	}
963	1.72k	SYNTAX("shl %0, %1");
964	1.72k	#line 1081 "rl78-decode.opc"
965	1.72k	ID(shl); DR(C); SC(cnt);
966
967	1.72k	}
968	1.72k	break;
969	2.14k	case 0x08:
970	2.14k	{
971		/** 0011 0001 0cnt 1000 shl %0, %1 */
972	2.14k	#line 1078 "rl78-decode.opc"
973	2.14k	int cnt AU = (op[1] >> 4) & 0x07;
974	2.14k	if (trace)
975	0	{
976	0	printf ("\033[33m%s\033[0m %02x %02x\n",
977	0	"/** 0011 0001 0cnt 1000 shl %0, %1 */",
978	0	op[0], op[1]);
979	0	printf (" cnt = 0x%x\n", cnt);
980	0	}
981	2.14k	SYNTAX("shl %0, %1");
982	2.14k	#line 1078 "rl78-decode.opc"
983	2.14k	ID(shl); DR(B); SC(cnt);
984
985	2.14k	}
986	2.14k	break;
987	653	case 0x09:
988	653	{
989		/** 0011 0001 0cnt 1001 shl %0, %1 */
990	653	#line 1075 "rl78-decode.opc"
991	653	int cnt AU = (op[1] >> 4) & 0x07;
992	653	if (trace)
993	0	{
994	0	printf ("\033[33m%s\033[0m %02x %02x\n",
995	0	"/** 0011 0001 0cnt 1001 shl %0, %1 */",
996	0	op[0], op[1]);
997	0	printf (" cnt = 0x%x\n", cnt);
998	0	}
999	653	SYNTAX("shl %0, %1");
1000	653	#line 1075 "rl78-decode.opc"
1001	653	ID(shl); DR(A); SC(cnt);
1002
1003	653	}
1004	653	break;
1005	311	case 0x0a:
1006	311	{
1007		/** 0011 0001 0cnt 1010 shr %0, %1 */
1008	311	#line 1092 "rl78-decode.opc"
1009	311	int cnt AU = (op[1] >> 4) & 0x07;
1010	311	if (trace)
1011	0	{
1012	0	printf ("\033[33m%s\033[0m %02x %02x\n",
1013	0	"/** 0011 0001 0cnt 1010 shr %0, %1 */",
1014	0	op[0], op[1]);
1015	0	printf (" cnt = 0x%x\n", cnt);
1016	0	}
1017	311	SYNTAX("shr %0, %1");
1018	311	#line 1092 "rl78-decode.opc"
1019	311	ID(shr); DR(A); SC(cnt);
1020
1021	311	}
1022	311	break;
1023	1.22k	case 0x0b:
1024	1.22k	{
1025		/** 0011 0001 0cnt 1011 sar %0, %1 */
1026	1.22k	#line 1039 "rl78-decode.opc"
1027	1.22k	int cnt AU = (op[1] >> 4) & 0x07;
1028	1.22k	if (trace)
1029	0	{
1030	0	printf ("\033[33m%s\033[0m %02x %02x\n",
1031	0	"/** 0011 0001 0cnt 1011 sar %0, %1 */",
1032	0	op[0], op[1]);
1033	0	printf (" cnt = 0x%x\n", cnt);
1034	0	}
1035	1.22k	SYNTAX("sar %0, %1");
1036	1.22k	#line 1039 "rl78-decode.opc"
1037	1.22k	ID(sar); DR(A); SC(cnt);
1038
1039	1.22k	}
1040	1.22k	break;
1041	511	case 0x0c:
1042	991	case 0x8c:
1043	991	{
1044		/** 0011 0001 wcnt 1100 shlw %0, %1 */
1045	991	#line 1087 "rl78-decode.opc"
1046	991	int wcnt AU = (op[1] >> 4) & 0x0f;
1047	991	if (trace)
1048	0	{
1049	0	printf ("\033[33m%s\033[0m %02x %02x\n",
1050	0	"/** 0011 0001 wcnt 1100 shlw %0, %1 */",
1051	0	op[0], op[1]);
1052	0	printf (" wcnt = 0x%x\n", wcnt);
1053	0	}
1054	991	SYNTAX("shlw %0, %1");
1055	991	#line 1087 "rl78-decode.opc"
1056	991	ID(shl); W(); DR(BC); SC(wcnt);
1057
1058		/----------------------------------------------------------------------/
1059
1060	991	}
1061	991	break;
1062	572	case 0x0d:
1063	966	case 0x8d:
1064	966	{
1065		/** 0011 0001 wcnt 1101 shlw %0, %1 */
1066	966	#line 1084 "rl78-decode.opc"
1067	966	int wcnt AU = (op[1] >> 4) & 0x0f;
1068	966	if (trace)
1069	0	{
1070	0	printf ("\033[33m%s\033[0m %02x %02x\n",
1071	0	"/** 0011 0001 wcnt 1101 shlw %0, %1 */",
1072	0	op[0], op[1]);
1073	0	printf (" wcnt = 0x%x\n", wcnt);
1074	0	}
1075	966	SYNTAX("shlw %0, %1");
1076	966	#line 1084 "rl78-decode.opc"
1077	966	ID(shl); W(); DR(AX); SC(wcnt);
1078
1079	966	}
1080	966	break;
1081	520	case 0x0e:
1082	1.05k	case 0x8e:
1083	1.05k	{
1084		/** 0011 0001 wcnt 1110 shrw %0, %1 */
1085	1.05k	#line 1095 "rl78-decode.opc"
1086	1.05k	int wcnt AU = (op[1] >> 4) & 0x0f;
1087	1.05k	if (trace)
1088	0	{
1089	0	printf ("\033[33m%s\033[0m %02x %02x\n",
1090	0	"/** 0011 0001 wcnt 1110 shrw %0, %1 */",
1091	0	op[0], op[1]);
1092	0	printf (" wcnt = 0x%x\n", wcnt);
1093	0	}
1094	1.05k	SYNTAX("shrw %0, %1");
1095	1.05k	#line 1095 "rl78-decode.opc"
1096	1.05k	ID(shr); W(); DR(AX); SC(wcnt);
1097
1098		/----------------------------------------------------------------------/
1099
1100	1.05k	}
1101	1.05k	break;
1102	605	case 0x0f:
1103	2.18k	case 0x8f:
1104	2.18k	{
1105		/** 0011 0001 wcnt 1111 sarw %0, %1 */
1106	2.18k	#line 1042 "rl78-decode.opc"
1107	2.18k	int wcnt AU = (op[1] >> 4) & 0x0f;
1108	2.18k	if (trace)
1109	0	{
1110	0	printf ("\033[33m%s\033[0m %02x %02x\n",
1111	0	"/** 0011 0001 wcnt 1111 sarw %0, %1 */",
1112	0	op[0], op[1]);
1113	0	printf (" wcnt = 0x%x\n", wcnt);
1114	0	}
1115	2.18k	SYNTAX("sarw %0, %1");
1116	2.18k	#line 1042 "rl78-decode.opc"
1117	2.18k	ID(sar); W(); DR(AX); SC(wcnt);
1118
1119		/----------------------------------------------------------------------/
1120
1121	2.18k	}
1122	2.18k	break;
1123	1.36k	case 0x80:
1124	1.36k	{
1125		/** 0011 0001 1bit 0000 btclr %s1, $%a0 */
1126	1.36k	#line 419 "rl78-decode.opc"
1127	1.36k	int bit AU = (op[1] >> 4) & 0x07;
1128	1.36k	if (trace)
1129	0	{
1130	0	printf ("\033[33m%s\033[0m %02x %02x\n",
1131	0	"/** 0011 0001 1bit 0000 btclr %s1, $%a0 */",
1132	0	op[0], op[1]);
1133	0	printf (" bit = 0x%x\n", bit);
1134	0	}
1135	1.36k	SYNTAX("btclr %s1, $%a0");
1136	1.36k	#line 419 "rl78-decode.opc"
1137	1.36k	ID(branch_cond_clear); SM(None, SFR); SB(bit); DC(pc+IMMS(1)+4); COND(T);
1138
1139	1.36k	}
1140	1.36k	break;
1141	589	case 0x81:
1142	589	{
1143		/** 0011 0001 1bit 0001 btclr %e1, $%a0 */
1144	589	#line 413 "rl78-decode.opc"
1145	589	int bit AU = (op[1] >> 4) & 0x07;
1146	589	if (trace)
1147	0	{
1148	0	printf ("\033[33m%s\033[0m %02x %02x\n",
1149	0	"/** 0011 0001 1bit 0001 btclr %e1, $%a0 */",
1150	0	op[0], op[1]);
1151	0	printf (" bit = 0x%x\n", bit);
1152	0	}
1153	589	SYNTAX("btclr %e1, $%a0");
1154	589	#line 413 "rl78-decode.opc"
1155	589	ID(branch_cond_clear); DC(pc+IMMS(1)+3); SM(HL,0); SB(bit); COND(T);
1156
1157	589	}
1158	589	break;
1159	1.63k	case 0x82:
1160	1.63k	{
1161		/** 0011 0001 1bit 0010 bt %s1, $%a0 */
1162	1.63k	#line 405 "rl78-decode.opc"
1163	1.63k	int bit AU = (op[1] >> 4) & 0x07;
1164	1.63k	if (trace)
1165	0	{
1166	0	printf ("\033[33m%s\033[0m %02x %02x\n",
1167	0	"/** 0011 0001 1bit 0010 bt %s1, $%a0 */",
1168	0	op[0], op[1]);
1169	0	printf (" bit = 0x%x\n", bit);
1170	0	}
1171	1.63k	SYNTAX("bt %s1, $%a0");
1172	1.63k	#line 405 "rl78-decode.opc"
1173	1.63k	ID(branch_cond); SM(None, SFR); SB(bit); DC(pc+IMMS(1)+4); COND(T);
1174
1175	1.63k	}
1176	1.63k	break;
1177	422	case 0x83:
1178	422	{
1179		/** 0011 0001 1bit 0011 bt %e1, $%a0 */
1180	422	#line 399 "rl78-decode.opc"
1181	422	int bit AU = (op[1] >> 4) & 0x07;
1182	422	if (trace)
1183	0	{
1184	0	printf ("\033[33m%s\033[0m %02x %02x\n",
1185	0	"/** 0011 0001 1bit 0011 bt %e1, $%a0 */",
1186	0	op[0], op[1]);
1187	0	printf (" bit = 0x%x\n", bit);
1188	0	}
1189	422	SYNTAX("bt %e1, $%a0");
1190	422	#line 399 "rl78-decode.opc"
1191	422	ID(branch_cond); DC(pc+IMMS(1)+3); SM(HL,0); SB(bit); COND(T);
1192
1193	422	}
1194	422	break;
1195	1.12k	case 0x84:
1196	1.12k	{
1197		/** 0011 0001 1bit 0100 bf %s1, $%a0 */
1198	1.12k	#line 366 "rl78-decode.opc"
1199	1.12k	int bit AU = (op[1] >> 4) & 0x07;
1200	1.12k	if (trace)
1201	0	{
1202	0	printf ("\033[33m%s\033[0m %02x %02x\n",
1203	0	"/** 0011 0001 1bit 0100 bf %s1, $%a0 */",
1204	0	op[0], op[1]);
1205	0	printf (" bit = 0x%x\n", bit);
1206	0	}
1207	1.12k	SYNTAX("bf %s1, $%a0");
1208	1.12k	#line 366 "rl78-decode.opc"
1209	1.12k	ID(branch_cond); SM(None, SFR); SB(bit); DC(pc+IMMS(1)+4); COND(F);
1210
1211	1.12k	}
1212	1.12k	break;
1213	927	case 0x85:
1214	927	{
1215		/** 0011 0001 1bit 0101 bf %e1, $%a0 */
1216	927	#line 360 "rl78-decode.opc"
1217	927	int bit AU = (op[1] >> 4) & 0x07;
1218	927	if (trace)
1219	0	{
1220	0	printf ("\033[33m%s\033[0m %02x %02x\n",
1221	0	"/** 0011 0001 1bit 0101 bf %e1, $%a0 */",
1222	0	op[0], op[1]);
1223	0	printf (" bit = 0x%x\n", bit);
1224	0	}
1225	927	SYNTAX("bf %e1, $%a0");
1226	927	#line 360 "rl78-decode.opc"
1227	927	ID(branch_cond); DC(pc+IMMS(1)+3); SM(HL,0); SB(bit); COND(F);
1228
1229	927	}
1230	927	break;
1231	4.59k	default: UNSUPPORTED(); break;
1232	40.8k	}
1233	40.7k	break;
1234	40.7k	case 0x33:
1235	38.1k	case 0x35:
1236	62.2k	case 0x37:
1237	62.2k	{
1238		/** 0011 0ra1 xchw %0, %1 */
1239	62.2k	#line 1245 "rl78-decode.opc"
1240	62.2k	int ra AU = (op[0] >> 1) & 0x03;
1241	62.2k	if (trace)
1242	0	{
1243	0	printf ("\033[33m%s\033[0m %02x\n",
1244	0	"/** 0011 0ra1 xchw %0, %1 */",
1245	0	op[0]);
1246	0	printf (" ra = 0x%x\n", ra);
1247	0	}
1248	62.2k	SYNTAX("xchw %0, %1");
1249	62.2k	#line 1245 "rl78-decode.opc"
1250	62.2k	ID(xch); W(); DR(AX); SRW(ra);
1251
1252		/----------------------------------------------------------------------/
1253
1254	62.2k	}
1255	62.2k	break;
1256	13.8k	case 0x38:
1257	13.8k	{
1258		/** 0011 1000 mov %e0, #%1 */
1259	13.8k	if (trace)
1260	0	{
1261	0	printf ("\033[33m%s\033[0m %02x\n",
1262	0	"/** 0011 1000 mov %e0, #%1 */",
1263	0	op[0]);
1264	0	}
1265	13.8k	SYNTAX("mov %e0, #%1");
1266	13.8k	#line 744 "rl78-decode.opc"
1267	13.8k	ID(mov); DM(C, IMMU(2)); SC(IMMU(1));
1268
1269	13.8k	}
1270	13.8k	break;
1271	11.7k	case 0x39:
1272	11.7k	{
1273		/** 0011 1001 mov %e0, #%1 */
1274	11.7k	if (trace)
1275	0	{
1276	0	printf ("\033[33m%s\033[0m %02x\n",
1277	0	"/** 0011 1001 mov %e0, #%1 */",
1278	0	op[0]);
1279	0	}
1280	11.7k	SYNTAX("mov %e0, #%1");
1281	11.7k	#line 738 "rl78-decode.opc"
1282	11.7k	ID(mov); DM(BC, IMMU(2)); SC(IMMU(1));
1283
1284	11.7k	}
1285	11.7k	break;
1286	16.8k	case 0x3a:
1287	16.8k	{
1288		/** 0011 1010 subc %0, #%1 */
1289	16.8k	if (trace)
1290	0	{
1291	0	printf ("\033[33m%s\033[0m %02x\n",
1292	0	"/** 0011 1010 subc %0, #%1 */",
1293	0	op[0]);
1294	0	}
1295	16.8k	SYNTAX("subc %0, #%1");
1296	16.8k	#line 1184 "rl78-decode.opc"
1297	16.8k	ID(subc); DM(None, SADDR); SC(IMMU(1)); Fzac;
1298
1299		/----------------------------------------------------------------------/
1300
1301	16.8k	}
1302	16.8k	break;
1303	15.0k	case 0x3b:
1304	15.0k	{
1305		/** 0011 1011 subc %0, %1 */
1306	15.0k	if (trace)
1307	0	{
1308	0	printf ("\033[33m%s\033[0m %02x\n",
1309	0	"/** 0011 1011 subc %0, %1 */",
1310	0	op[0]);
1311	0	}
1312	15.0k	SYNTAX("subc %0, %1");
1313	15.0k	#line 1181 "rl78-decode.opc"
1314	15.0k	ID(subc); DR(A); SM(None, SADDR); Fzac;
1315
1316	15.0k	}
1317	15.0k	break;
1318	14.6k	case 0x3c:
1319	14.6k	{
1320		/** 0011 1100 subc %0, #%1 */
1321	14.6k	if (trace)
1322	0	{
1323	0	printf ("\033[33m%s\033[0m %02x\n",
1324	0	"/** 0011 1100 subc %0, #%1 */",
1325	0	op[0]);
1326	0	}
1327	14.6k	SYNTAX("subc %0, #%1");
1328	14.6k	#line 1172 "rl78-decode.opc"
1329	14.6k	ID(subc); DR(A); SC(IMMU(1)); Fzac;
1330
1331	14.6k	}
1332	14.6k	break;
1333	16.4k	case 0x3d:
1334	16.4k	{
1335		/** 0011 1101 subc %0, %e1 */
1336	16.4k	if (trace)
1337	0	{
1338	0	printf ("\033[33m%s\033[0m %02x\n",
1339	0	"/** 0011 1101 subc %0, %e1 */",
1340	0	op[0]);
1341	0	}
1342	16.4k	SYNTAX("subc %0, %e1");
1343	16.4k	#line 1160 "rl78-decode.opc"
1344	16.4k	ID(subc); DR(A); SM(HL, 0); Fzac;
1345
1346	16.4k	}
1347	16.4k	break;
1348	12.1k	case 0x3e:
1349	12.1k	{
1350		/** 0011 1110 subc %0, %ea1 */
1351	12.1k	if (trace)
1352	0	{
1353	0	printf ("\033[33m%s\033[0m %02x\n",
1354	0	"/** 0011 1110 subc %0, %ea1 */",
1355	0	op[0]);
1356	0	}
1357	12.1k	SYNTAX("subc %0, %ea1");
1358	12.1k	#line 1169 "rl78-decode.opc"
1359	12.1k	ID(subc); DR(A); SM(HL, IMMU(1)); Fzac;
1360
1361	12.1k	}
1362	12.1k	break;
1363	10.8k	case 0x3f:
1364	10.8k	{
1365		/** 0011 1111 subc %0, %e!1 */
1366	10.8k	if (trace)
1367	0	{
1368	0	printf ("\033[33m%s\033[0m %02x\n",
1369	0	"/** 0011 1111 subc %0, %e!1 */",
1370	0	op[0]);
1371	0	}
1372	10.8k	SYNTAX("subc %0, %e!1");
1373	10.8k	#line 1157 "rl78-decode.opc"
1374	10.8k	ID(subc); DR(A); SM(None, IMMU(2)); Fzac;
1375
1376	10.8k	}
1377	10.8k	break;
1378	23.3k	case 0x40:
1379	23.3k	{
1380		/** 0100 0000 cmp %e!0, #%1 */
1381	23.3k	if (trace)
1382	0	{
1383	0	printf ("\033[33m%s\033[0m %02x\n",
1384	0	"/** 0100 0000 cmp %e!0, #%1 */",
1385	0	op[0]);
1386	0	}
1387	23.3k	SYNTAX("cmp %e!0, #%1");
1388	23.3k	#line 486 "rl78-decode.opc"
1389	23.3k	ID(cmp); DM(None, IMMU(2)); SC(IMMU(1)); Fzac;
1390
1391	23.3k	}
1392	23.3k	break;
1393	19.2k	case 0x41:
1394	19.2k	{
1395		/** 0100 0001 mov %0, #%1 */
1396	19.2k	if (trace)
1397	0	{
1398	0	printf ("\033[33m%s\033[0m %02x\n",
1399	0	"/** 0100 0001 mov %0, #%1 */",
1400	0	op[0]);
1401	0	}
1402	19.2k	SYNTAX("mov %0, #%1");
1403	19.2k	#line 723 "rl78-decode.opc"
1404	19.2k	ID(mov); DR(ES); SC(IMMU(1));
1405
1406	19.2k	}
1407	19.2k	break;
1408	14.1k	case 0x42:
1409	14.1k	{
1410		/** 0100 0010 cmpw %0, %e!1 */
1411	14.1k	if (trace)
1412	0	{
1413	0	printf ("\033[33m%s\033[0m %02x\n",
1414	0	"/** 0100 0010 cmpw %0, %e!1 */",
1415	0	op[0]);
1416	0	}
1417	14.1k	SYNTAX("cmpw %0, %e!1");
1418	14.1k	#line 537 "rl78-decode.opc"
1419	14.1k	ID(cmp); W(); DR(AX); SM(None, IMMU(2)); Fzac;
1420
1421	14.1k	}
1422	14.1k	break;
1423	9.79k	case 0x43:
1424	25.5k	case 0x45:
1425	37.5k	case 0x47:
1426	37.5k	{
1427		/** 0100 0ra1 cmpw %0, %1 */
1428	37.5k	#line 546 "rl78-decode.opc"
1429	37.5k	int ra AU = (op[0] >> 1) & 0x03;
1430	37.5k	if (trace)
1431	0	{
1432	0	printf ("\033[33m%s\033[0m %02x\n",
1433	0	"/** 0100 0ra1 cmpw %0, %1 */",
1434	0	op[0]);
1435	0	printf (" ra = 0x%x\n", ra);
1436	0	}
1437	37.5k	SYNTAX("cmpw %0, %1");
1438	37.5k	#line 546 "rl78-decode.opc"
1439	37.5k	ID(cmp); W(); DR(AX); SRW(ra); Fzac;
1440
1441	37.5k	}
1442	37.5k	break;
1443	14.3k	case 0x44:
1444	14.3k	{
1445		/** 0100 0100 cmpw %0, #%1 */
1446	14.3k	if (trace)
1447	0	{
1448	0	printf ("\033[33m%s\033[0m %02x\n",
1449	0	"/** 0100 0100 cmpw %0, #%1 */",
1450	0	op[0]);
1451	0	}
1452	14.3k	SYNTAX("cmpw %0, #%1");
1453	14.3k	#line 543 "rl78-decode.opc"
1454	14.3k	ID(cmp); W(); DR(AX); SC(IMMU(2)); Fzac;
1455
1456	14.3k	}
1457	14.3k	break;
1458	11.1k	case 0x46:
1459	11.1k	{
1460		/** 0100 0110 cmpw %0, %1 */
1461	11.1k	if (trace)
1462	0	{
1463	0	printf ("\033[33m%s\033[0m %02x\n",
1464	0	"/** 0100 0110 cmpw %0, %1 */",
1465	0	op[0]);
1466	0	}
1467	11.1k	SYNTAX("cmpw %0, %1");
1468	11.1k	#line 549 "rl78-decode.opc"
1469	11.1k	ID(cmp); W(); DR(AX); SM(None, SADDR); Fzac;
1470
1471		/----------------------------------------------------------------------/
1472
1473	11.1k	}
1474	11.1k	break;
1475	12.8k	case 0x48:
1476	12.8k	{
1477		/** 0100 1000 mov %e0, %1 */
1478	12.8k	if (trace)
1479	0	{
1480	0	printf ("\033[33m%s\033[0m %02x\n",
1481	0	"/** 0100 1000 mov %e0, %1 */",
1482	0	op[0]);
1483	0	}
1484	12.8k	SYNTAX("mov %e0, %1");
1485	12.8k	#line 741 "rl78-decode.opc"
1486	12.8k	ID(mov); DM(BC, IMMU(2)); SR(A);
1487
1488	12.8k	}
1489	12.8k	break;
1490	10.3k	case 0x49:
1491	10.3k	{
1492		/** 0100 1001 mov %0, %e1 */
1493	10.3k	if (trace)
1494	0	{
1495	0	printf ("\033[33m%s\033[0m %02x\n",
1496	0	"/** 0100 1001 mov %0, %e1 */",
1497	0	op[0]);
1498	0	}
1499	10.3k	SYNTAX("mov %0, %e1");
1500	10.3k	#line 687 "rl78-decode.opc"
1501	10.3k	ID(mov); DR(A); SM(BC, IMMU(2));
1502
1503	10.3k	}
1504	10.3k	break;
1505	12.4k	case 0x4a:
1506	12.4k	{
1507		/** 0100 1010 cmp %0, #%1 */
1508	12.4k	if (trace)
1509	0	{
1510	0	printf ("\033[33m%s\033[0m %02x\n",
1511	0	"/** 0100 1010 cmp %0, #%1 */",
1512	0	op[0]);
1513	0	}
1514	12.4k	SYNTAX("cmp %0, #%1");
1515	12.4k	#line 489 "rl78-decode.opc"
1516	12.4k	ID(cmp); DM(None, SADDR); SC(IMMU(1)); Fzac;
1517
1518	12.4k	}
1519	12.4k	break;
1520	9.26k	case 0x4b:
1521	9.26k	{
1522		/** 0100 1011 cmp %0, %1 */
1523	9.26k	if (trace)
1524	0	{
1525	0	printf ("\033[33m%s\033[0m %02x\n",
1526	0	"/** 0100 1011 cmp %0, %1 */",
1527	0	op[0]);
1528	0	}
1529	9.26k	SYNTAX("cmp %0, %1");
1530	9.26k	#line 516 "rl78-decode.opc"
1531	9.26k	ID(cmp); DR(A); SM(None, SADDR); Fzac;
1532
1533		/----------------------------------------------------------------------/
1534
1535	9.26k	}
1536	9.26k	break;
1537	14.7k	case 0x4c:
1538	14.7k	{
1539		/** 0100 1100 cmp %0, #%1 */
1540	14.7k	if (trace)
1541	0	{
1542	0	printf ("\033[33m%s\033[0m %02x\n",
1543	0	"/** 0100 1100 cmp %0, #%1 */",
1544	0	op[0]);
1545	0	}
1546	14.7k	SYNTAX("cmp %0, #%1");
1547	14.7k	#line 507 "rl78-decode.opc"
1548	14.7k	ID(cmp); DR(A); SC(IMMU(1)); Fzac;
1549
1550	14.7k	}
1551	14.7k	break;
1552	14.9k	case 0x4d:
1553	14.9k	{
1554		/** 0100 1101 cmp %0, %e1 */
1555	14.9k	if (trace)
1556	0	{
1557	0	printf ("\033[33m%s\033[0m %02x\n",
1558	0	"/** 0100 1101 cmp %0, %e1 */",
1559	0	op[0]);
1560	0	}
1561	14.9k	SYNTAX("cmp %0, %e1");
1562	14.9k	#line 495 "rl78-decode.opc"
1563	14.9k	ID(cmp); DR(A); SM(HL, 0); Fzac;
1564
1565	14.9k	}
1566	14.9k	break;
1567	13.3k	case 0x4e:
1568	13.3k	{
1569		/** 0100 1110 cmp %0, %ea1 */
1570	13.3k	if (trace)
1571	0	{
1572	0	printf ("\033[33m%s\033[0m %02x\n",
1573	0	"/** 0100 1110 cmp %0, %ea1 */",
1574	0	op[0]);
1575	0	}
1576	13.3k	SYNTAX("cmp %0, %ea1");
1577	13.3k	#line 504 "rl78-decode.opc"
1578	13.3k	ID(cmp); DR(A); SM(HL, IMMU(1)); Fzac;
1579
1580	13.3k	}
1581	13.3k	break;
1582	14.7k	case 0x4f:
1583	14.7k	{
1584		/** 0100 1111 cmp %0, %e!1 */
1585	14.7k	if (trace)
1586	0	{
1587	0	printf ("\033[33m%s\033[0m %02x\n",
1588	0	"/** 0100 1111 cmp %0, %e!1 */",
1589	0	op[0]);
1590	0	}
1591	14.7k	SYNTAX("cmp %0, %e!1");
1592	14.7k	#line 492 "rl78-decode.opc"
1593	14.7k	ID(cmp); DR(A); SM(None, IMMU(2)); Fzac;
1594
1595	14.7k	}
1596	14.7k	break;
1597	15.6k	case 0x50:
1598	25.7k	case 0x51:
1599	35.3k	case 0x52:
1600	43.7k	case 0x53:
1601	54.7k	case 0x54:
1602	66.8k	case 0x55:
1603	80.1k	case 0x56:
1604	88.9k	case 0x57:
1605	88.9k	{
1606		/** 0101 0reg mov %0, #%1 */
1607	88.9k	#line 675 "rl78-decode.opc"
1608	88.9k	int reg AU = op[0] & 0x07;
1609	88.9k	if (trace)
1610	0	{
1611	0	printf ("\033[33m%s\033[0m %02x\n",
1612	0	"/** 0101 0reg mov %0, #%1 */",
1613	0	op[0]);
1614	0	printf (" reg = 0x%x\n", reg);
1615	0	}
1616	88.9k	SYNTAX("mov %0, #%1");
1617	88.9k	#line 675 "rl78-decode.opc"
1618	88.9k	ID(mov); DRB(reg); SC(IMMU(1));
1619
1620	88.9k	}
1621	88.9k	break;
1622	7.17k	case 0x58:
1623	7.17k	{
1624		/** 0101 1000 movw %e0, %1 */
1625	7.17k	if (trace)
1626	0	{
1627	0	printf ("\033[33m%s\033[0m %02x\n",
1628	0	"/** 0101 1000 movw %e0, %1 */",
1629	0	op[0]);
1630	0	}
1631	7.17k	SYNTAX("movw %e0, %1");
1632	7.17k	#line 877 "rl78-decode.opc"
1633	7.17k	ID(mov); W(); DM(B, IMMU(2)); SR(AX);
1634
1635	7.17k	}
1636	7.17k	break;
1637	9.61k	case 0x59:
1638	9.61k	{
1639		/** 0101 1001 movw %0, %e1 */
1640	9.61k	if (trace)
1641	0	{
1642	0	printf ("\033[33m%s\033[0m %02x\n",
1643	0	"/** 0101 1001 movw %0, %e1 */",
1644	0	op[0]);
1645	0	}
1646	9.61k	SYNTAX("movw %0, %e1");
1647	9.61k	#line 868 "rl78-decode.opc"
1648	9.61k	ID(mov); W(); DR(AX); SM(B, IMMU(2));
1649
1650	9.61k	}
1651	9.61k	break;
1652	7.38k	case 0x5a:
1653	7.38k	{
1654		/** 0101 1010 and %0, #%1 */
1655	7.38k	if (trace)
1656	0	{
1657	0	printf ("\033[33m%s\033[0m %02x\n",
1658	0	"/** 0101 1010 and %0, #%1 */",
1659	0	op[0]);
1660	0	}
1661	7.38k	SYNTAX("and %0, #%1");
1662	7.38k	#line 318 "rl78-decode.opc"
1663	7.38k	ID(and); DM(None, SADDR); SC(IMMU(1)); Fz;
1664
1665		/----------------------------------------------------------------------/
1666
1667	7.38k	}
1668	7.38k	break;
1669	18.0k	case 0x5b:
1670	18.0k	{
1671		/** 0101 1011 and %0, %1 */
1672	18.0k	if (trace)
1673	0	{
1674	0	printf ("\033[33m%s\033[0m %02x\n",
1675	0	"/** 0101 1011 and %0, %1 */",
1676	0	op[0]);
1677	0	}
1678	18.0k	SYNTAX("and %0, %1");
1679	18.0k	#line 315 "rl78-decode.opc"
1680	18.0k	ID(and); DR(A); SM(None, SADDR); Fz;
1681
1682	18.0k	}
1683	18.0k	break;
1684	7.97k	case 0x5c:
1685	7.97k	{
1686		/** 0101 1100 and %0, #%1 */
1687	7.97k	if (trace)
1688	0	{
1689	0	printf ("\033[33m%s\033[0m %02x\n",
1690	0	"/** 0101 1100 and %0, #%1 */",
1691	0	op[0]);
1692	0	}
1693	7.97k	SYNTAX("and %0, #%1");
1694	7.97k	#line 306 "rl78-decode.opc"
1695	7.97k	ID(and); DR(A); SC(IMMU(1)); Fz;
1696
1697	7.97k	}
1698	7.97k	break;
1699	9.70k	case 0x5d:
1700	9.70k	{
1701		/** 0101 1101 and %0, %e1 */
1702	9.70k	if (trace)
1703	0	{
1704	0	printf ("\033[33m%s\033[0m %02x\n",
1705	0	"/** 0101 1101 and %0, %e1 */",
1706	0	op[0]);
1707	0	}
1708	9.70k	SYNTAX("and %0, %e1");
1709	9.70k	#line 294 "rl78-decode.opc"
1710	9.70k	ID(and); DR(A); SM(HL, 0); Fz;
1711
1712	9.70k	}
1713	9.70k	break;
1714	8.51k	case 0x5e:
1715	8.51k	{
1716		/** 0101 1110 and %0, %ea1 */
1717	8.51k	if (trace)
1718	0	{
1719	0	printf ("\033[33m%s\033[0m %02x\n",
1720	0	"/** 0101 1110 and %0, %ea1 */",
1721	0	op[0]);
1722	0	}
1723	8.51k	SYNTAX("and %0, %ea1");
1724	8.51k	#line 300 "rl78-decode.opc"
1725	8.51k	ID(and); DR(A); SM(HL, IMMU(1)); Fz;
1726
1727	8.51k	}
1728	8.51k	break;
1729	14.0k	case 0x5f:
1730	14.0k	{
1731		/** 0101 1111 and %0, %e!1 */
1732	14.0k	if (trace)
1733	0	{
1734	0	printf ("\033[33m%s\033[0m %02x\n",
1735	0	"/** 0101 1111 and %0, %e!1 */",
1736	0	op[0]);
1737	0	}
1738	14.0k	SYNTAX("and %0, %e!1");
1739	14.0k	#line 291 "rl78-decode.opc"
1740	14.0k	ID(and); DR(A); SM(None, IMMU(2)); Fz;
1741
1742	14.0k	}
1743	14.0k	break;
1744	15.3k	case 0x60:
1745	41.8k	case 0x62:
1746	60.4k	case 0x63:
1747	91.3k	case 0x64:
1748	112k	case 0x65:
1749	127k	case 0x66:
1750	145k	case 0x67:
1751	145k	{
1752		/** 0110 0rba mov %0, %1 */
1753	145k	#line 678 "rl78-decode.opc"
1754	145k	int rba AU = op[0] & 0x07;
1755	145k	if (trace)
1756	0	{
1757	0	printf ("\033[33m%s\033[0m %02x\n",
1758	0	"/** 0110 0rba mov %0, %1 */",
1759	0	op[0]);
1760	0	printf (" rba = 0x%x\n", rba);
1761	0	}
1762	145k	SYNTAX("mov %0, %1");
1763	145k	#line 678 "rl78-decode.opc"
1764	145k	ID(mov); DR(A); SRB(rba);
1765
1766	145k	}
1767	145k	break;
1768	211k	case 0x61:
1769	211k	GETBYTE ();
1770	211k	switch (op[1] & 0xff)
1771	211k	{
1772	5.55k	case 0x00:
1773	6.13k	case 0x01:
1774	6.78k	case 0x02:
1775	7.21k	case 0x03:
1776	7.70k	case 0x04:
1777	8.00k	case 0x05:
1778	8.67k	case 0x06:
1779	9.04k	case 0x07:
1780	9.04k	{
1781		/** 0110 0001 0000 0reg add %0, %1 */
1782	9.04k	#line 231 "rl78-decode.opc"
1783	9.04k	int reg AU = op[1] & 0x07;
1784	9.04k	if (trace)
1785	0	{
1786	0	printf ("\033[33m%s\033[0m %02x %02x\n",
1787	0	"/** 0110 0001 0000 0reg add %0, %1 */",
1788	0	op[0], op[1]);
1789	0	printf (" reg = 0x%x\n", reg);
1790	0	}
1791	9.04k	SYNTAX("add %0, %1");
1792	9.04k	#line 231 "rl78-decode.opc"
1793	9.04k	ID(add); DRB(reg); SR(A); Fzac;
1794
1795	9.04k	}
1796	9.04k	break;
1797	785	case 0x08:
1798	1.54k	case 0x0a:
1799	1.87k	case 0x0b:
1800	2.04k	case 0x0c:
1801	2.40k	case 0x0d:
1802	2.99k	case 0x0e:
1803	3.61k	case 0x0f:
1804	3.61k	{
1805		/** 0110 0001 0000 1rba add %0, %1 */
1806	3.61k	#line 225 "rl78-decode.opc"
1807	3.61k	int rba AU = op[1] & 0x07;
1808	3.61k	if (trace)
1809	0	{
1810	0	printf ("\033[33m%s\033[0m %02x %02x\n",
1811	0	"/** 0110 0001 0000 1rba add %0, %1 */",
1812	0	op[0], op[1]);
1813	0	printf (" rba = 0x%x\n", rba);
1814	0	}
1815	3.61k	SYNTAX("add %0, %1");
1816	3.61k	#line 225 "rl78-decode.opc"
1817	3.61k	ID(add); DR(A); SRB(rba); Fzac;
1818
1819	3.61k	}
1820	3.61k	break;
1821	894	case 0x09:
1822	894	{
1823		/** 0110 0001 0000 1001 addw %0, %ea1 */
1824	894	if (trace)
1825	0	{
1826	0	printf ("\033[33m%s\033[0m %02x %02x\n",
1827	0	"/** 0110 0001 0000 1001 addw %0, %ea1 */",
1828	0	op[0], op[1]);
1829	0	}
1830	894	SYNTAX("addw %0, %ea1");
1831	894	#line 274 "rl78-decode.opc"
1832	894	ID(add); W(); DR(AX); SM(HL, IMMU(1)); Fzac;
1833
1834	894	}
1835	894	break;
1836	694	case 0x10:
1837	2.07k	case 0x11:
1838	2.40k	case 0x12:
1839	2.68k	case 0x13:
1840	2.85k	case 0x14:
1841	3.81k	case 0x15:
1842	4.68k	case 0x16:
1843	5.43k	case 0x17:
1844	5.43k	{
1845		/** 0110 0001 0001 0reg addc %0, %1 */
1846	5.43k	#line 260 "rl78-decode.opc"
1847	5.43k	int reg AU = op[1] & 0x07;
1848	5.43k	if (trace)
1849	0	{
1850	0	printf ("\033[33m%s\033[0m %02x %02x\n",
1851	0	"/** 0110 0001 0001 0reg addc %0, %1 */",
1852	0	op[0], op[1]);
1853	0	printf (" reg = 0x%x\n", reg);
1854	0	}
1855	5.43k	SYNTAX("addc %0, %1");
1856	5.43k	#line 260 "rl78-decode.opc"
1857	5.43k	ID(addc); DRB(reg); SR(A); Fzac;
1858
1859	5.43k	}
1860	5.43k	break;
1861	353	case 0x18:
1862	507	case 0x1a:
1863	1.71k	case 0x1b:
1864	1.86k	case 0x1c:
1865	2.20k	case 0x1d:
1866	3.68k	case 0x1e:
1867	4.21k	case 0x1f:
1868	4.21k	{
1869		/** 0110 0001 0001 1rba addc %0, %1 */
1870	4.21k	#line 257 "rl78-decode.opc"
1871	4.21k	int rba AU = op[1] & 0x07;
1872	4.21k	if (trace)
1873	0	{
1874	0	printf ("\033[33m%s\033[0m %02x %02x\n",
1875	0	"/** 0110 0001 0001 1rba addc %0, %1 */",
1876	0	op[0], op[1]);
1877	0	printf (" rba = 0x%x\n", rba);
1878	0	}
1879	4.21k	SYNTAX("addc %0, %1");
1880	4.21k	#line 257 "rl78-decode.opc"
1881	4.21k	ID(addc); DR(A); SRB(rba); Fzac;
1882
1883	4.21k	}
1884	4.21k	break;
1885	347	case 0x20:
1886	531	case 0x21:
1887	647	case 0x22:
1888	918	case 0x23:
1889	1.13k	case 0x24:
1890	1.31k	case 0x25:
1891	2.37k	case 0x26:
1892	2.88k	case 0x27:
1893	2.88k	{
1894		/** 0110 0001 0010 0reg sub %0, %1 */
1895	2.88k	#line 1149 "rl78-decode.opc"
1896	2.88k	int reg AU = op[1] & 0x07;
1897	2.88k	if (trace)
1898	0	{
1899	0	printf ("\033[33m%s\033[0m %02x %02x\n",
1900	0	"/** 0110 0001 0010 0reg sub %0, %1 */",
1901	0	op[0], op[1]);
1902	0	printf (" reg = 0x%x\n", reg);
1903	0	}
1904	2.88k	SYNTAX("sub %0, %1");
1905	2.88k	#line 1149 "rl78-decode.opc"
1906	2.88k	ID(sub); DRB(reg); SR(A); Fzac;
1907
1908	2.88k	}
1909	2.88k	break;
1910	150	case 0x28:
1911	363	case 0x2a:
1912	1.23k	case 0x2b:
1913	1.78k	case 0x2c:
1914	2.13k	case 0x2d:
1915	2.75k	case 0x2e:
1916	2.94k	case 0x2f:
1917	2.94k	{
1918		/** 0110 0001 0010 1rba sub %0, %1 */
1919	2.94k	#line 1143 "rl78-decode.opc"
1920	2.94k	int rba AU = op[1] & 0x07;
1921	2.94k	if (trace)
1922	0	{
1923	0	printf ("\033[33m%s\033[0m %02x %02x\n",
1924	0	"/** 0110 0001 0010 1rba sub %0, %1 */",
1925	0	op[0], op[1]);
1926	0	printf (" rba = 0x%x\n", rba);
1927	0	}
1928	2.94k	SYNTAX("sub %0, %1");
1929	2.94k	#line 1143 "rl78-decode.opc"
1930	2.94k	ID(sub); DR(A); SRB(rba); Fzac;
1931
1932	2.94k	}
1933	2.94k	break;
1934	1.13k	case 0x29:
1935	1.13k	{
1936		/** 0110 0001 0010 1001 subw %0, %ea1 */
1937	1.13k	if (trace)
1938	0	{
1939	0	printf ("\033[33m%s\033[0m %02x %02x\n",
1940	0	"/** 0110 0001 0010 1001 subw %0, %ea1 */",
1941	0	op[0], op[1]);
1942	0	}
1943	1.13k	SYNTAX("subw %0, %ea1");
1944	1.13k	#line 1192 "rl78-decode.opc"
1945	1.13k	ID(sub); W(); DR(AX); SM(HL, IMMU(1)); Fzac;
1946
1947	1.13k	}
1948	1.13k	break;
1949	473	case 0x30:
1950	749	case 0x31:
1951	932	case 0x32:
1952	1.38k	case 0x33:
1953	1.55k	case 0x34:
1954	1.77k	case 0x35:
1955	2.22k	case 0x36:
1956	2.44k	case 0x37:
1957	2.44k	{
1958		/** 0110 0001 0011 0reg subc %0, %1 */
1959	2.44k	#line 1178 "rl78-decode.opc"
1960	2.44k	int reg AU = op[1] & 0x07;
1961	2.44k	if (trace)
1962	0	{
1963	0	printf ("\033[33m%s\033[0m %02x %02x\n",
1964	0	"/** 0110 0001 0011 0reg subc %0, %1 */",
1965	0	op[0], op[1]);
1966	0	printf (" reg = 0x%x\n", reg);
1967	0	}
1968	2.44k	SYNTAX("subc %0, %1");
1969	2.44k	#line 1178 "rl78-decode.opc"
1970	2.44k	ID(subc); DRB(reg); SR(A); Fzac;
1971
1972	2.44k	}
1973	2.44k	break;
1974	259	case 0x38:
1975	761	case 0x3a:
1976	3.08k	case 0x3b:
1977	3.80k	case 0x3c:
1978	4.14k	case 0x3d:
1979	4.57k	case 0x3e:
1980	4.95k	case 0x3f:
1981	4.95k	{
1982		/** 0110 0001 0011 1rba subc %0, %1 */
1983	4.95k	#line 1175 "rl78-decode.opc"
1984	4.95k	int rba AU = op[1] & 0x07;
1985	4.95k	if (trace)
1986	0	{
1987	0	printf ("\033[33m%s\033[0m %02x %02x\n",
1988	0	"/** 0110 0001 0011 1rba subc %0, %1 */",
1989	0	op[0], op[1]);
1990	0	printf (" rba = 0x%x\n", rba);
1991	0	}
1992	4.95k	SYNTAX("subc %0, %1");
1993	4.95k	#line 1175 "rl78-decode.opc"
1994	4.95k	ID(subc); DR(A); SRB(rba); Fzac;
1995
1996	4.95k	}
1997	4.95k	break;
1998	1.60k	case 0x40:
1999	2.25k	case 0x41:
2000	2.53k	case 0x42:
2001	2.71k	case 0x43:
2002	3.11k	case 0x44:
2003	3.51k	case 0x45:
2004	4.07k	case 0x46:
2005	4.93k	case 0x47:
2006	4.93k	{
2007		/** 0110 0001 0100 0reg cmp %0, %1 */
2008	4.93k	#line 513 "rl78-decode.opc"
2009	4.93k	int reg AU = op[1] & 0x07;
2010	4.93k	if (trace)
2011	0	{
2012	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2013	0	"/** 0110 0001 0100 0reg cmp %0, %1 */",
2014	0	op[0], op[1]);
2015	0	printf (" reg = 0x%x\n", reg);
2016	0	}
2017	4.93k	SYNTAX("cmp %0, %1");
2018	4.93k	#line 513 "rl78-decode.opc"
2019	4.93k	ID(cmp); DRB(reg); SR(A); Fzac;
2020
2021	4.93k	}
2022	4.93k	break;
2023	235	case 0x48:
2024	379	case 0x4a:
2025	955	case 0x4b:
2026	3.07k	case 0x4c:
2027	3.20k	case 0x4d:
2028	3.44k	case 0x4e:
2029	4.10k	case 0x4f:
2030	4.10k	{
2031		/** 0110 0001 0100 1rba cmp %0, %1 */
2032	4.10k	#line 510 "rl78-decode.opc"
2033	4.10k	int rba AU = op[1] & 0x07;
2034	4.10k	if (trace)
2035	0	{
2036	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2037	0	"/** 0110 0001 0100 1rba cmp %0, %1 */",
2038	0	op[0], op[1]);
2039	0	printf (" rba = 0x%x\n", rba);
2040	0	}
2041	4.10k	SYNTAX("cmp %0, %1");
2042	4.10k	#line 510 "rl78-decode.opc"
2043	4.10k	ID(cmp); DR(A); SRB(rba); Fzac;
2044
2045	4.10k	}
2046	4.10k	break;
2047	317	case 0x49:
2048	317	{
2049		/** 0110 0001 0100 1001 cmpw %0, %ea1 */
2050	317	if (trace)
2051	0	{
2052	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2053	0	"/** 0110 0001 0100 1001 cmpw %0, %ea1 */",
2054	0	op[0], op[1]);
2055	0	}
2056	317	SYNTAX("cmpw %0, %ea1");
2057	317	#line 540 "rl78-decode.opc"
2058	317	ID(cmp); W(); DR(AX); SM(HL, IMMU(1)); Fzac;
2059
2060	317	}
2061	317	break;
2062	1.16k	case 0x50:
2063	1.85k	case 0x51:
2064	1.97k	case 0x52:
2065	2.15k	case 0x53:
2066	2.42k	case 0x54:
2067	3.09k	case 0x55:
2068	3.30k	case 0x56:
2069	3.57k	case 0x57:
2070	3.57k	{
2071		/** 0110 0001 0101 0reg and %0, %1 */
2072	3.57k	#line 312 "rl78-decode.opc"
2073	3.57k	int reg AU = op[1] & 0x07;
2074	3.57k	if (trace)
2075	0	{
2076	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2077	0	"/** 0110 0001 0101 0reg and %0, %1 */",
2078	0	op[0], op[1]);
2079	0	printf (" reg = 0x%x\n", reg);
2080	0	}
2081	3.57k	SYNTAX("and %0, %1");
2082	3.57k	#line 312 "rl78-decode.opc"
2083	3.57k	ID(and); DRB(reg); SR(A); Fz;
2084
2085	3.57k	}
2086	3.57k	break;
2087	435	case 0x58:
2088	798	case 0x5a:
2089	1.27k	case 0x5b:
2090	1.41k	case 0x5c:
2091	1.65k	case 0x5d:
2092	2.31k	case 0x5e:
2093	2.69k	case 0x5f:
2094	2.69k	{
2095		/** 0110 0001 0101 1rba and %0, %1 */
2096	2.69k	#line 309 "rl78-decode.opc"
2097	2.69k	int rba AU = op[1] & 0x07;
2098	2.69k	if (trace)
2099	0	{
2100	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2101	0	"/** 0110 0001 0101 1rba and %0, %1 */",
2102	0	op[0], op[1]);
2103	0	printf (" rba = 0x%x\n", rba);
2104	0	}
2105	2.69k	SYNTAX("and %0, %1");
2106	2.69k	#line 309 "rl78-decode.opc"
2107	2.69k	ID(and); DR(A); SRB(rba); Fz;
2108
2109	2.69k	}
2110	2.69k	break;
2111	230	case 0x59:
2112	230	{
2113		/** 0110 0001 0101 1001 inc %ea0 */
2114	230	if (trace)
2115	0	{
2116	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2117	0	"/** 0110 0001 0101 1001 inc %ea0 */",
2118	0	op[0], op[1]);
2119	0	}
2120	230	SYNTAX("inc %ea0");
2121	230	#line 590 "rl78-decode.opc"
2122	230	ID(add); DM(HL, IMMU(1)); SC(1); Fza;
2123
2124	230	}
2125	230	break;
2126	1.58k	case 0x60:
2127	63.5k	case 0x61:
2128	65.6k	case 0x62:
2129	67.0k	case 0x63:
2130	69.2k	case 0x64:
2131	69.8k	case 0x65:
2132	70.3k	case 0x66:
2133	70.5k	case 0x67:
2134	70.5k	{
2135		/** 0110 0001 0110 0reg or %0, %1 */
2136	70.5k	#line 967 "rl78-decode.opc"
2137	70.5k	int reg AU = op[1] & 0x07;
2138	70.5k	if (trace)
2139	0	{
2140	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2141	0	"/** 0110 0001 0110 0reg or %0, %1 */",
2142	0	op[0], op[1]);
2143	0	printf (" reg = 0x%x\n", reg);
2144	0	}
2145	70.5k	SYNTAX("or %0, %1");
2146	70.5k	#line 967 "rl78-decode.opc"
2147	70.5k	ID(or); DRB(reg); SR(A); Fz;
2148
2149	70.5k	}
2150	70.5k	break;
2151	220	case 0x68:
2152	1.20k	case 0x6a:
2153	1.76k	case 0x6b:
2154	4.02k	case 0x6c:
2155	5.32k	case 0x6d:
2156	6.69k	case 0x6e:
2157	7.82k	case 0x6f:
2158	7.82k	{
2159		/** 0110 0001 0110 1rba or %0, %1 */
2160	7.82k	#line 964 "rl78-decode.opc"
2161	7.82k	int rba AU = op[1] & 0x07;
2162	7.82k	if (trace)
2163	0	{
2164	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2165	0	"/** 0110 0001 0110 1rba or %0, %1 */",
2166	0	op[0], op[1]);
2167	0	printf (" rba = 0x%x\n", rba);
2168	0	}
2169	7.82k	SYNTAX("or %0, %1");
2170	7.82k	#line 964 "rl78-decode.opc"
2171	7.82k	ID(or); DR(A); SRB(rba); Fz;
2172
2173	7.82k	}
2174	7.82k	break;
2175	1.03k	case 0x69:
2176	1.03k	{
2177		/** 0110 0001 0110 1001 dec %ea0 */
2178	1.03k	if (trace)
2179	0	{
2180	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2181	0	"/** 0110 0001 0110 1001 dec %ea0 */",
2182	0	op[0], op[1]);
2183	0	}
2184	1.03k	SYNTAX("dec %ea0");
2185	1.03k	#line 557 "rl78-decode.opc"
2186	1.03k	ID(sub); DM(HL, IMMU(1)); SC(1); Fza;
2187
2188	1.03k	}
2189	1.03k	break;
2190	501	case 0x70:
2191	2.30k	case 0x71:
2192	3.44k	case 0x72:
2193	4.32k	case 0x73:
2194	5.98k	case 0x74:
2195	7.06k	case 0x75:
2196	7.28k	case 0x76:
2197	7.62k	case 0x77:
2198	7.62k	{
2199		/** 0110 0001 0111 0reg xor %0, %1 */
2200	7.62k	#line 1271 "rl78-decode.opc"
2201	7.62k	int reg AU = op[1] & 0x07;
2202	7.62k	if (trace)
2203	0	{
2204	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2205	0	"/** 0110 0001 0111 0reg xor %0, %1 */",
2206	0	op[0], op[1]);
2207	0	printf (" reg = 0x%x\n", reg);
2208	0	}
2209	7.62k	SYNTAX("xor %0, %1");
2210	7.62k	#line 1271 "rl78-decode.opc"
2211	7.62k	ID(xor); DRB(reg); SR(A); Fz;
2212
2213	7.62k	}
2214	7.62k	break;
2215	813	case 0x78:
2216	1.43k	case 0x7a:
2217	1.80k	case 0x7b:
2218	2.09k	case 0x7c:
2219	2.39k	case 0x7d:
2220	3.93k	case 0x7e:
2221	4.92k	case 0x7f:
2222	4.92k	{
2223		/** 0110 0001 0111 1rba xor %0, %1 */
2224	4.92k	#line 1268 "rl78-decode.opc"
2225	4.92k	int rba AU = op[1] & 0x07;
2226	4.92k	if (trace)
2227	0	{
2228	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2229	0	"/** 0110 0001 0111 1rba xor %0, %1 */",
2230	0	op[0], op[1]);
2231	0	printf (" rba = 0x%x\n", rba);
2232	0	}
2233	4.92k	SYNTAX("xor %0, %1");
2234	4.92k	#line 1268 "rl78-decode.opc"
2235	4.92k	ID(xor); DR(A); SRB(rba); Fz;
2236
2237	4.92k	}
2238	4.92k	break;
2239	652	case 0x79:
2240	652	{
2241		/** 0110 0001 0111 1001 incw %ea0 */
2242	652	if (trace)
2243	0	{
2244	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2245	0	"/** 0110 0001 0111 1001 incw %ea0 */",
2246	0	op[0], op[1]);
2247	0	}
2248	652	SYNTAX("incw %ea0");
2249	652	#line 604 "rl78-decode.opc"
2250	652	ID(add); W(); DM(HL, IMMU(1)); SC(1);
2251
2252	652	}
2253	652	break;
2254	1.42k	case 0x80:
2255	2.68k	case 0x81:
2256	2.68k	{
2257		/** 0110 0001 1000 000 add %0, %e1 */
2258	2.68k	if (trace)
2259	0	{
2260	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2261	0	"/** 0110 0001 1000 000 add %0, %e1 */",
2262	0	op[0], op[1]);
2263	0	}
2264	2.68k	SYNTAX("add %0, %e1");
2265	2.68k	#line 213 "rl78-decode.opc"
2266	2.68k	ID(add); DR(A); SM2(HL, B, 0); Fzac;
2267
2268	2.68k	}
2269	2.68k	break;
2270	217	case 0x82:
2271	217	{
2272		/** 0110 0001 1000 0010 add %0, %e1 */
2273	217	if (trace)
2274	0	{
2275	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2276	0	"/** 0110 0001 1000 0010 add %0, %e1 */",
2277	0	op[0], op[1]);
2278	0	}
2279	217	SYNTAX("add %0, %e1");
2280	217	#line 219 "rl78-decode.opc"
2281	217	ID(add); DR(A); SM2(HL, C, 0); Fzac;
2282
2283	217	}
2284	217	break;
2285	809	case 0x84:
2286	1.25k	case 0x85:
2287	1.87k	case 0x86:
2288	2.24k	case 0x87:
2289	2.64k	case 0x94:
2290	3.37k	case 0x95:
2291	3.62k	case 0x96:
2292	3.74k	case 0x97:
2293	5.43k	case 0xa4:
2294	5.82k	case 0xa5:
2295	5.95k	case 0xa6:
2296	6.40k	case 0xa7:
2297	6.57k	case 0xb4:
2298	6.77k	case 0xb5:
2299	7.55k	case 0xb6:
2300	8.72k	case 0xb7:
2301	9.60k	case 0xc4:
2302	10.2k	case 0xc5:
2303	11.0k	case 0xc6:
2304	11.4k	case 0xc7:
2305	11.9k	case 0xd4:
2306	12.1k	case 0xd5:
2307	12.3k	case 0xd6:
2308	12.7k	case 0xd7:
2309	13.0k	case 0xe4:
2310	13.4k	case 0xe5:
2311	13.8k	case 0xe6:
2312	14.1k	case 0xe7:
2313	14.7k	case 0xf4:
2314	19.1k	case 0xf5:
2315	19.3k	case 0xf6:
2316	19.7k	case 0xf7:
2317	19.7k	{
2318		/** 0110 0001 1nnn 01mm callt [%x0] */
2319	19.7k	#line 439 "rl78-decode.opc"
2320	19.7k	int nnn AU = (op[1] >> 4) & 0x07;
2321	19.7k	#line 439 "rl78-decode.opc"
2322	19.7k	int mm AU = op[1] & 0x03;
2323	19.7k	if (trace)
2324	0	{
2325	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2326	0	"/** 0110 0001 1nnn 01mm callt [%x0] */",
2327	0	op[0], op[1]);
2328	0	printf (" nnn = 0x%x,", nnn);
2329	0	printf (" mm = 0x%x\n", mm);
2330	0	}
2331	19.7k	SYNTAX("callt [%x0]");
2332	19.7k	#line 439 "rl78-decode.opc"
2333	19.7k	ID(call); DM(None, 0x80 + mm16 + nnn2);
2334
2335		/----------------------------------------------------------------------/
2336
2337	19.7k	}
2338	19.7k	break;
2339	728	case 0x88:
2340	872	case 0x8a:
2341	1.47k	case 0x8b:
2342	1.55k	case 0x8c:
2343	1.88k	case 0x8d:
2344	2.16k	case 0x8e:
2345	2.49k	case 0x8f:
2346	2.49k	{
2347		/** 0110 0001 1000 1reg xch %0, %1 */
2348	2.49k	#line 1230 "rl78-decode.opc"
2349	2.49k	int reg AU = op[1] & 0x07;
2350	2.49k	if (trace)
2351	0	{
2352	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2353	0	"/** 0110 0001 1000 1reg xch %0, %1 */",
2354	0	op[0], op[1]);
2355	0	printf (" reg = 0x%x\n", reg);
2356	0	}
2357	2.49k	SYNTAX("xch %0, %1");
2358	2.49k	#line 1230 "rl78-decode.opc"
2359		/* Note: DECW uses reg == X, so this must follow DECW */
2360	2.49k	ID(xch); DR(A); SRB(reg);
2361
2362	2.49k	}
2363	2.49k	break;
2364	485	case 0x89:
2365	485	{
2366		/** 0110 0001 1000 1001 decw %ea0 */
2367	485	if (trace)
2368	0	{
2369	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2370	0	"/** 0110 0001 1000 1001 decw %ea0 */",
2371	0	op[0], op[1]);
2372	0	}
2373	485	SYNTAX("decw %ea0");
2374	485	#line 571 "rl78-decode.opc"
2375	485	ID(sub); W(); DM(HL, IMMU(1)); SC(1);
2376
2377	485	}
2378	485	break;
2379	988	case 0x90:
2380	988	{
2381		/** 0110 0001 1001 0000 addc %0, %e1 */
2382	988	if (trace)
2383	0	{
2384	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2385	0	"/** 0110 0001 1001 0000 addc %0, %e1 */",
2386	0	op[0], op[1]);
2387	0	}
2388	988	SYNTAX("addc %0, %e1");
2389	988	#line 245 "rl78-decode.opc"
2390	988	ID(addc); DR(A); SM2(HL, B, 0); Fzac;
2391
2392	988	}
2393	988	break;
2394	584	case 0x92:
2395	584	{
2396		/** 0110 0001 1001 0010 addc %0, %e1 */
2397	584	if (trace)
2398	0	{
2399	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2400	0	"/** 0110 0001 1001 0010 addc %0, %e1 */",
2401	0	op[0], op[1]);
2402	0	}
2403	584	SYNTAX("addc %0, %e1");
2404	584	#line 248 "rl78-decode.opc"
2405	584	ID(addc); DR(A); SM2(HL, C, 0); Fzac;
2406
2407	584	}
2408	584	break;
2409	438	case 0xa0:
2410	694	case 0xa1:
2411	694	{
2412		/** 0110 0001 1010 000 sub %0, %e1 */
2413	694	if (trace)
2414	0	{
2415	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2416	0	"/** 0110 0001 1010 000 sub %0, %e1 */",
2417	0	op[0], op[1]);
2418	0	}
2419	694	SYNTAX("sub %0, %e1");
2420	694	#line 1131 "rl78-decode.opc"
2421	694	ID(sub); DR(A); SM2(HL, B, 0); Fzac;
2422
2423	694	}
2424	694	break;
2425	833	case 0xa2:
2426	833	{
2427		/** 0110 0001 1010 0010 sub %0, %e1 */
2428	833	if (trace)
2429	0	{
2430	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2431	0	"/** 0110 0001 1010 0010 sub %0, %e1 */",
2432	0	op[0], op[1]);
2433	0	}
2434	833	SYNTAX("sub %0, %e1");
2435	833	#line 1137 "rl78-decode.opc"
2436	833	ID(sub); DR(A); SM2(HL, C, 0); Fzac;
2437
2438	833	}
2439	833	break;
2440	490	case 0xa8:
2441	490	{
2442		/** 0110 0001 1010 1000 xch %0, %1 */
2443	490	if (trace)
2444	0	{
2445	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2446	0	"/** 0110 0001 1010 1000 xch %0, %1 */",
2447	0	op[0], op[1]);
2448	0	}
2449	490	SYNTAX("xch %0, %1");
2450	490	#line 1234 "rl78-decode.opc"
2451	490	ID(xch); DR(A); SM(None, SADDR);
2452
2453	490	}
2454	490	break;
2455	408	case 0xa9:
2456	408	{
2457		/** 0110 0001 1010 1001 xch %0, %e1 */
2458	408	if (trace)
2459	0	{
2460	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2461	0	"/** 0110 0001 1010 1001 xch %0, %e1 */",
2462	0	op[0], op[1]);
2463	0	}
2464	408	SYNTAX("xch %0, %e1");
2465	408	#line 1227 "rl78-decode.opc"
2466	408	ID(xch); DR(A); SM2(HL, C, 0);
2467
2468	408	}
2469	408	break;
2470	2.23k	case 0xaa:
2471	2.23k	{
2472		/** 0110 0001 1010 1010 xch %0, %e!1 */
2473	2.23k	if (trace)
2474	0	{
2475	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2476	0	"/** 0110 0001 1010 1010 xch %0, %e!1 */",
2477	0	op[0], op[1]);
2478	0	}
2479	2.23k	SYNTAX("xch %0, %e!1");
2480	2.23k	#line 1209 "rl78-decode.opc"
2481	2.23k	ID(xch); DR(A); SM(None, IMMU(2));
2482
2483	2.23k	}
2484	2.23k	break;
2485	215	case 0xab:
2486	215	{
2487		/** 0110 0001 1010 1011 xch %0, %s1 */
2488	215	if (trace)
2489	0	{
2490	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2491	0	"/** 0110 0001 1010 1011 xch %0, %s1 */",
2492	0	op[0], op[1]);
2493	0	}
2494	215	SYNTAX("xch %0, %s1");
2495	215	#line 1237 "rl78-decode.opc"
2496	215	ID(xch); DR(A); SM(None, SFR);
2497
2498	215	}
2499	215	break;
2500	465	case 0xac:
2501	465	{
2502		/** 0110 0001 1010 1100 xch %0, %e1 */
2503	465	if (trace)
2504	0	{
2505	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2506	0	"/** 0110 0001 1010 1100 xch %0, %e1 */",
2507	0	op[0], op[1]);
2508	0	}
2509	465	SYNTAX("xch %0, %e1");
2510	465	#line 1218 "rl78-decode.opc"
2511	465	ID(xch); DR(A); SM(HL, 0);
2512
2513	465	}
2514	465	break;
2515	940	case 0xad:
2516	940	{
2517		/** 0110 0001 1010 1101 xch %0, %ea1 */
2518	940	if (trace)
2519	0	{
2520	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2521	0	"/** 0110 0001 1010 1101 xch %0, %ea1 */",
2522	0	op[0], op[1]);
2523	0	}
2524	940	SYNTAX("xch %0, %ea1");
2525	940	#line 1224 "rl78-decode.opc"
2526	940	ID(xch); DR(A); SM(HL, IMMU(1));
2527
2528	940	}
2529	940	break;
2530	124	case 0xae:
2531	124	{
2532		/** 0110 0001 1010 1110 xch %0, %e1 */
2533	124	if (trace)
2534	0	{
2535	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2536	0	"/** 0110 0001 1010 1110 xch %0, %e1 */",
2537	0	op[0], op[1]);
2538	0	}
2539	124	SYNTAX("xch %0, %e1");
2540	124	#line 1212 "rl78-decode.opc"
2541	124	ID(xch); DR(A); SM(DE, 0);
2542
2543	124	}
2544	124	break;
2545	305	case 0xaf:
2546	305	{
2547		/** 0110 0001 1010 1111 xch %0, %ea1 */
2548	305	if (trace)
2549	0	{
2550	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2551	0	"/** 0110 0001 1010 1111 xch %0, %ea1 */",
2552	0	op[0], op[1]);
2553	0	}
2554	305	SYNTAX("xch %0, %ea1");
2555	305	#line 1215 "rl78-decode.opc"
2556	305	ID(xch); DR(A); SM(DE, IMMU(1));
2557
2558	305	}
2559	305	break;
2560	180	case 0xb0:
2561	180	{
2562		/** 0110 0001 1011 0000 subc %0, %e1 */
2563	180	if (trace)
2564	0	{
2565	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2566	0	"/** 0110 0001 1011 0000 subc %0, %e1 */",
2567	0	op[0], op[1]);
2568	0	}
2569	180	SYNTAX("subc %0, %e1");
2570	180	#line 1163 "rl78-decode.opc"
2571	180	ID(subc); DR(A); SM2(HL, B, 0); Fzac;
2572
2573	180	}
2574	180	break;
2575	828	case 0xb2:
2576	828	{
2577		/** 0110 0001 1011 0010 subc %0, %e1 */
2578	828	if (trace)
2579	0	{
2580	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2581	0	"/** 0110 0001 1011 0010 subc %0, %e1 */",
2582	0	op[0], op[1]);
2583	0	}
2584	828	SYNTAX("subc %0, %e1");
2585	828	#line 1166 "rl78-decode.opc"
2586	828	ID(subc); DR(A); SM2(HL, C, 0); Fzac;
2587
2588	828	}
2589	828	break;
2590	362	case 0xb8:
2591	362	{
2592		/** 0110 0001 1011 1000 mov %0, %1 */
2593	362	if (trace)
2594	0	{
2595	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2596	0	"/** 0110 0001 1011 1000 mov %0, %1 */",
2597	0	op[0], op[1]);
2598	0	}
2599	362	SYNTAX("mov %0, %1");
2600	362	#line 729 "rl78-decode.opc"
2601	362	ID(mov); DR(ES); SM(None, SADDR);
2602
2603	362	}
2604	362	break;
2605	160	case 0xb9:
2606	160	{
2607		/** 0110 0001 1011 1001 xch %0, %e1 */
2608	160	if (trace)
2609	0	{
2610	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2611	0	"/** 0110 0001 1011 1001 xch %0, %e1 */",
2612	0	op[0], op[1]);
2613	0	}
2614	160	SYNTAX("xch %0, %e1");
2615	160	#line 1221 "rl78-decode.opc"
2616	160	ID(xch); DR(A); SM2(HL, B, 0);
2617
2618	160	}
2619	160	break;
2620	535	case 0xc0:
2621	535	{
2622		/** 0110 0001 1100 0000 cmp %0, %e1 */
2623	535	if (trace)
2624	0	{
2625	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2626	0	"/** 0110 0001 1100 0000 cmp %0, %e1 */",
2627	0	op[0], op[1]);
2628	0	}
2629	535	SYNTAX("cmp %0, %e1");
2630	535	#line 498 "rl78-decode.opc"
2631	535	ID(cmp); DR(A); SM2(HL, B, 0); Fzac;
2632
2633	535	}
2634	535	break;
2635	2.26k	case 0xc2:
2636	2.26k	{
2637		/** 0110 0001 1100 0010 cmp %0, %e1 */
2638	2.26k	if (trace)
2639	0	{
2640	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2641	0	"/** 0110 0001 1100 0010 cmp %0, %e1 */",
2642	0	op[0], op[1]);
2643	0	}
2644	2.26k	SYNTAX("cmp %0, %e1");
2645	2.26k	#line 501 "rl78-decode.opc"
2646	2.26k	ID(cmp); DR(A); SM2(HL, C, 0); Fzac;
2647
2648	2.26k	}
2649	2.26k	break;
2650	5.46k	case 0xc3:
2651	5.46k	{
2652		/** 0110 0001 1100 0011 bh $%a0 */
2653	5.46k	if (trace)
2654	0	{
2655	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2656	0	"/** 0110 0001 1100 0011 bh $%a0 */",
2657	0	op[0], op[1]);
2658	0	}
2659	5.46k	SYNTAX("bh $%a0");
2660	5.46k	#line 346 "rl78-decode.opc"
2661	5.46k	ID(branch_cond); DC(pc+IMMS(1)+3); SR(None); COND(H);
2662
2663	5.46k	}
2664	5.46k	break;
2665	83	case 0xc8:
2666	83	{
2667		/** 0110 0001 1100 1000 sk%c1 */
2668	83	if (trace)
2669	0	{
2670	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2671	0	"/** 0110 0001 1100 1000 sk%c1 */",
2672	0	op[0], op[1]);
2673	0	}
2674	83	SYNTAX("sk%c1");
2675	83	#line 1100 "rl78-decode.opc"
2676	83	ID(skip); COND(C);
2677
2678	83	}
2679	83	break;
2680	213	case 0xc9:
2681	213	{
2682		/** 0110 0001 1100 1001 mov %0, %e1 */
2683	213	if (trace)
2684	0	{
2685	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2686	0	"/** 0110 0001 1100 1001 mov %0, %e1 */",
2687	0	op[0], op[1]);
2688	0	}
2689	213	SYNTAX("mov %0, %e1");
2690	213	#line 666 "rl78-decode.opc"
2691	213	ID(mov); DR(A); SM2(HL, B, 0);
2692
2693	213	}
2694	213	break;
2695	445	case 0xca:
2696	950	case 0xda:
2697	1.13k	case 0xea:
2698	1.37k	case 0xfa:
2699	1.37k	{
2700		/** 0110 0001 11rg 1010 call %0 */
2701	1.37k	#line 436 "rl78-decode.opc"
2702	1.37k	int rg AU = (op[1] >> 4) & 0x03;
2703	1.37k	if (trace)
2704	0	{
2705	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2706	0	"/** 0110 0001 11rg 1010 call %0 */",
2707	0	op[0], op[1]);
2708	0	printf (" rg = 0x%x\n", rg);
2709	0	}
2710	1.37k	SYNTAX("call %0");
2711	1.37k	#line 436 "rl78-decode.opc"
2712	1.37k	ID(call); DRW(rg);
2713
2714	1.37k	}
2715	1.37k	break;
2716	143	case 0xcb:
2717	143	{
2718		/** 0110 0001 1100 1011 br ax */
2719	143	if (trace)
2720	0	{
2721	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2722	0	"/** 0110 0001 1100 1011 br ax */",
2723	0	op[0], op[1]);
2724	0	}
2725	143	SYNTAX("br ax");
2726	143	#line 386 "rl78-decode.opc"
2727	143	ID(branch); DR(AX);
2728
2729		/----------------------------------------------------------------------/
2730
2731	143	}
2732	143	break;
2733	174	case 0xcc:
2734	174	{
2735		/** 0110 0001 1100 1100 brk */
2736	174	if (trace)
2737	0	{
2738	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2739	0	"/** 0110 0001 1100 1100 brk */",
2740	0	op[0], op[1]);
2741	0	}
2742	174	SYNTAX("brk");
2743	174	#line 394 "rl78-decode.opc"
2744	174	ID(break);
2745
2746		/----------------------------------------------------------------------/
2747
2748	174	}
2749	174	break;
2750	106	case 0xcd:
2751	106	{
2752		/** 0110 0001 1100 1101 pop %s0 */
2753	106	if (trace)
2754	0	{
2755	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2756	0	"/** 0110 0001 1100 1101 pop %s0 */",
2757	0	op[0], op[1]);
2758	0	}
2759	106	SYNTAX("pop %s0");
2760	106	#line 995 "rl78-decode.opc"
2761	106	ID(mov); W(); DR(PSW); SPOP();
2762
2763		/----------------------------------------------------------------------/
2764
2765	106	}
2766	106	break;
2767	2.33k	case 0xce:
2768	2.33k	{
2769		/** 0110 0001 1100 1110 movs %ea0, %1 */
2770	2.33k	if (trace)
2771	0	{
2772	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2773	0	"/** 0110 0001 1100 1110 movs %ea0, %1 */",
2774	0	op[0], op[1]);
2775	0	}
2776	2.33k	SYNTAX("movs %ea0, %1");
2777	2.33k	#line 817 "rl78-decode.opc"
2778	2.33k	ID(mov); DM(HL, IMMU(1)); SR(X); Fzc;
2779
2780		/----------------------------------------------------------------------/
2781
2782	2.33k	}
2783	2.33k	break;
2784	298	case 0xcf:
2785	586	case 0xdf:
2786	801	case 0xef:
2787	3.52k	case 0xff:
2788	3.52k	{
2789		/** 0110 0001 11rb 1111 sel rb%1 */
2790	3.52k	#line 1047 "rl78-decode.opc"
2791	3.52k	int rb AU = (op[1] >> 4) & 0x03;
2792	3.52k	if (trace)
2793	0	{
2794	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2795	0	"/** 0110 0001 11rb 1111 sel rb%1 */",
2796	0	op[0], op[1]);
2797	0	printf (" rb = 0x%x\n", rb);
2798	0	}
2799	3.52k	SYNTAX("sel rb%1");
2800	3.52k	#line 1047 "rl78-decode.opc"
2801	3.52k	ID(sel); SC(rb);
2802
2803		/----------------------------------------------------------------------/
2804
2805	3.52k	}
2806	3.52k	break;
2807	897	case 0xd0:
2808	897	{
2809		/** 0110 0001 1101 0000 and %0, %e1 */
2810	897	if (trace)
2811	0	{
2812	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2813	0	"/** 0110 0001 1101 0000 and %0, %e1 */",
2814	0	op[0], op[1]);
2815	0	}
2816	897	SYNTAX("and %0, %e1");
2817	897	#line 297 "rl78-decode.opc"
2818	897	ID(and); DR(A); SM2(HL, B, 0); Fz;
2819
2820	897	}
2821	897	break;
2822	290	case 0xd2:
2823	290	{
2824		/** 0110 0001 1101 0010 and %0, %e1 */
2825	290	if (trace)
2826	0	{
2827	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2828	0	"/** 0110 0001 1101 0010 and %0, %e1 */",
2829	0	op[0], op[1]);
2830	0	}
2831	290	SYNTAX("and %0, %e1");
2832	290	#line 303 "rl78-decode.opc"
2833	290	ID(and); DR(A); SM2(HL, C, 0); Fz;
2834
2835	290	}
2836	290	break;
2837	265	case 0xd3:
2838	265	{
2839		/** 0110 0001 1101 0011 bnh $%a0 */
2840	265	if (trace)
2841	0	{
2842	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2843	0	"/** 0110 0001 1101 0011 bnh $%a0 */",
2844	0	op[0], op[1]);
2845	0	}
2846	265	SYNTAX("bnh $%a0");
2847	265	#line 349 "rl78-decode.opc"
2848	265	ID(branch_cond); DC(pc+IMMS(1)+3); SR(None); COND(NH);
2849
2850	265	}
2851	265	break;
2852	290	case 0xd8:
2853	290	{
2854		/** 0110 0001 1101 1000 sk%c1 */
2855	290	if (trace)
2856	0	{
2857	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2858	0	"/** 0110 0001 1101 1000 sk%c1 */",
2859	0	op[0], op[1]);
2860	0	}
2861	290	SYNTAX("sk%c1");
2862	290	#line 1106 "rl78-decode.opc"
2863	290	ID(skip); COND(NC);
2864
2865	290	}
2866	290	break;
2867	395	case 0xd9:
2868	395	{
2869		/** 0110 0001 1101 1001 mov %e0, %1 */
2870	395	if (trace)
2871	0	{
2872	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2873	0	"/** 0110 0001 1101 1001 mov %e0, %1 */",
2874	0	op[0], op[1]);
2875	0	}
2876	395	SYNTAX("mov %e0, %1");
2877	395	#line 633 "rl78-decode.opc"
2878	395	ID(mov); DM2(HL, B, 0); SR(A);
2879
2880	395	}
2881	395	break;
2882	639	case 0xdb:
2883	639	{
2884		/** 0110 0001 1101 1011 ror %0, %1 */
2885	639	if (trace)
2886	0	{
2887	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2888	0	"/** 0110 0001 1101 1011 ror %0, %1 */",
2889	0	op[0], op[1]);
2890	0	}
2891	639	SYNTAX("ror %0, %1");
2892	639	#line 1028 "rl78-decode.opc"
2893	639	ID(ror); DR(A); SC(1);
2894
2895	639	}
2896	639	break;
2897	208	case 0xdc:
2898	208	{
2899		/** 0110 0001 1101 1100 rolc %0, %1 */
2900	208	if (trace)
2901	0	{
2902	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2903	0	"/** 0110 0001 1101 1100 rolc %0, %1 */",
2904	0	op[0], op[1]);
2905	0	}
2906	208	SYNTAX("rolc %0, %1");
2907	208	#line 1022 "rl78-decode.opc"
2908	208	ID(rolc); DR(A); SC(1);
2909
2910	208	}
2911	208	break;
2912	300	case 0xdd:
2913	300	{
2914		/** 0110 0001 1101 1101 push %s1 */
2915	300	if (trace)
2916	0	{
2917	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2918	0	"/** 0110 0001 1101 1101 push %s1 */",
2919	0	op[0], op[1]);
2920	0	}
2921	300	SYNTAX("push %s1");
2922	300	#line 1003 "rl78-decode.opc"
2923	300	ID(mov); W(); DPUSH(); SR(PSW);
2924
2925		/----------------------------------------------------------------------/
2926
2927	300	}
2928	300	break;
2929	247	case 0xde:
2930	247	{
2931		/** 0110 0001 1101 1110 cmps %0, %ea1 */
2932	247	if (trace)
2933	0	{
2934	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2935	0	"/** 0110 0001 1101 1110 cmps %0, %ea1 */",
2936	0	op[0], op[1]);
2937	0	}
2938	247	SYNTAX("cmps %0, %ea1");
2939	247	#line 532 "rl78-decode.opc"
2940	247	ID(cmp); DR(X); SM(HL, IMMU(1)); Fzac;
2941
2942		/----------------------------------------------------------------------/
2943
2944	247	}
2945	247	break;
2946	149	case 0xe0:
2947	149	{
2948		/** 0110 0001 1110 0000 or %0, %e1 */
2949	149	if (trace)
2950	0	{
2951	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2952	0	"/** 0110 0001 1110 0000 or %0, %e1 */",
2953	0	op[0], op[1]);
2954	0	}
2955	149	SYNTAX("or %0, %e1");
2956	149	#line 952 "rl78-decode.opc"
2957	149	ID(or); DR(A); SM2(HL, B, 0); Fz;
2958
2959	149	}
2960	149	break;
2961	390	case 0xe2:
2962	390	{
2963		/** 0110 0001 1110 0010 or %0, %e1 */
2964	390	if (trace)
2965	0	{
2966	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2967	0	"/** 0110 0001 1110 0010 or %0, %e1 */",
2968	0	op[0], op[1]);
2969	0	}
2970	390	SYNTAX("or %0, %e1");
2971	390	#line 958 "rl78-decode.opc"
2972	390	ID(or); DR(A); SM2(HL, C, 0); Fz;
2973
2974	390	}
2975	390	break;
2976	1.78k	case 0xe3:
2977	1.78k	{
2978		/** 0110 0001 1110 0011 sk%c1 */
2979	1.78k	if (trace)
2980	0	{
2981	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2982	0	"/** 0110 0001 1110 0011 sk%c1 */",
2983	0	op[0], op[1]);
2984	0	}
2985	1.78k	SYNTAX("sk%c1");
2986	1.78k	#line 1103 "rl78-decode.opc"
2987	1.78k	ID(skip); COND(H);
2988
2989	1.78k	}
2990	1.78k	break;
2991	217	case 0xe8:
2992	217	{
2993		/** 0110 0001 1110 1000 sk%c1 */
2994	217	if (trace)
2995	0	{
2996	0	printf ("\033[33m%s\033[0m %02x %02x\n",
2997	0	"/** 0110 0001 1110 1000 sk%c1 */",
2998	0	op[0], op[1]);
2999	0	}
3000	217	SYNTAX("sk%c1");
3001	217	#line 1115 "rl78-decode.opc"
3002	217	ID(skip); COND(Z);
3003
3004		/----------------------------------------------------------------------/
3005
3006	217	}
3007	217	break;
3008	622	case 0xe9:
3009	622	{
3010		/** 0110 0001 1110 1001 mov %0, %e1 */
3011	622	if (trace)
3012	0	{
3013	0	printf ("\033[33m%s\033[0m %02x %02x\n",
3014	0	"/** 0110 0001 1110 1001 mov %0, %e1 */",
3015	0	op[0], op[1]);
3016	0	}
3017	622	SYNTAX("mov %0, %e1");
3018	622	#line 669 "rl78-decode.opc"
3019	622	ID(mov); DR(A); SM2(HL, C, 0);
3020
3021	622	}
3022	622	break;
3023	460	case 0xeb:
3024	460	{
3025		/** 0110 0001 1110 1011 rol %0, %1 */
3026	460	if (trace)
3027	0	{
3028	0	printf ("\033[33m%s\033[0m %02x %02x\n",
3029	0	"/** 0110 0001 1110 1011 rol %0, %1 */",
3030	0	op[0], op[1]);
3031	0	}
3032	460	SYNTAX("rol %0, %1");
3033	460	#line 1019 "rl78-decode.opc"
3034	460	ID(rol); DR(A); SC(1);
3035
3036	460	}
3037	460	break;
3038	185	case 0xec:
3039	185	{
3040		/** 0110 0001 1110 1100 retb */
3041	185	if (trace)
3042	0	{
3043	0	printf ("\033[33m%s\033[0m %02x %02x\n",
3044	0	"/** 0110 0001 1110 1100 retb */",
3045	0	op[0], op[1]);
3046	0	}
3047	185	SYNTAX("retb");
3048	185	#line 1014 "rl78-decode.opc"
3049	185	ID(reti);
3050
3051		/----------------------------------------------------------------------/
3052
3053	185	}
3054	185	break;
3055	292	case 0xed:
3056	292	{
3057		/** 0110 0001 1110 1101 halt */
3058	292	if (trace)
3059	0	{
3060	0	printf ("\033[33m%s\033[0m %02x %02x\n",
3061	0	"/** 0110 0001 1110 1101 halt */",
3062	0	op[0], op[1]);
3063	0	}
3064	292	SYNTAX("halt");
3065	292	#line 582 "rl78-decode.opc"
3066	292	ID(halt);
3067
3068		/----------------------------------------------------------------------/
3069
3070	292	}
3071	292	break;
3072	592	case 0xee:
3073	985	case 0xfe:
3074	985	{
3075		/** 0110 0001 111r 1110 rolwc %0, %1 */
3076	985	#line 1025 "rl78-decode.opc"
3077	985	int r AU = (op[1] >> 4) & 0x01;
3078	985	if (trace)
3079	0	{
3080	0	printf ("\033[33m%s\033[0m %02x %02x\n",
3081	0	"/** 0110 0001 111r 1110 rolwc %0, %1 */",
3082	0	op[0], op[1]);
3083	0	printf (" r = 0x%x\n", r);
3084	0	}
3085	985	SYNTAX("rolwc %0, %1");
3086	985	#line 1025 "rl78-decode.opc"
3087	985	ID(rolc); W(); DRW(r); SC(1);
3088
3089	985	}
3090	985	break;
3091	880	case 0xf0:
3092	880	{
3093		/** 0110 0001 1111 0000 xor %0, %e1 */
3094	880	if (trace)
3095	0	{
3096	0	printf ("\033[33m%s\033[0m %02x %02x\n",
3097	0	"/** 0110 0001 1111 0000 xor %0, %e1 */",
3098	0	op[0], op[1]);
3099	0	}
3100	880	SYNTAX("xor %0, %e1");
3101	880	#line 1256 "rl78-decode.opc"
3102	880	ID(xor); DR(A); SM2(HL, B, 0); Fz;
3103
3104	880	}
3105	880	break;
3106	213	case 0xf2:
3107	213	{
3108		/** 0110 0001 1111 0010 xor %0, %e1 */
3109	213	if (trace)
3110	0	{
3111	0	printf ("\033[33m%s\033[0m %02x %02x\n",
3112	0	"/** 0110 0001 1111 0010 xor %0, %e1 */",
3113	0	op[0], op[1]);
3114	0	}
3115	213	SYNTAX("xor %0, %e1");
3116	213	#line 1262 "rl78-decode.opc"
3117	213	ID(xor); DR(A); SM2(HL, C, 0); Fz;
3118
3119	213	}
3120	213	break;
3121	473	case 0xf3:
3122	473	{
3123		/** 0110 0001 1111 0011 sk%c1 */
3124	473	if (trace)
3125	0	{
3126	0	printf ("\033[33m%s\033[0m %02x %02x\n",
3127	0	"/** 0110 0001 1111 0011 sk%c1 */",
3128	0	op[0], op[1]);
3129	0	}
3130	473	SYNTAX("sk%c1");
3131	473	#line 1109 "rl78-decode.opc"
3132	473	ID(skip); COND(NH);
3133
3134	473	}
3135	473	break;
3136	186	case 0xf8:
3137	186	{
3138		/** 0110 0001 1111 1000 sk%c1 */
3139	186	if (trace)
3140	0	{
3141	0	printf ("\033[33m%s\033[0m %02x %02x\n",
3142	0	"/** 0110 0001 1111 1000 sk%c1 */",
3143	0	op[0], op[1]);
3144	0	}
3145	186	SYNTAX("sk%c1");
3146	186	#line 1112 "rl78-decode.opc"
3147	186	ID(skip); COND(NZ);
3148
3149	186	}
3150	186	break;
3151	477	case 0xf9:
3152	477	{
3153		/** 0110 0001 1111 1001 mov %e0, %1 */
3154	477	if (trace)
3155	0	{
3156	0	printf ("\033[33m%s\033[0m %02x %02x\n",
3157	0	"/** 0110 0001 1111 1001 mov %e0, %1 */",
3158	0	op[0], op[1]);
3159	0	}
3160	477	SYNTAX("mov %e0, %1");
3161	477	#line 642 "rl78-decode.opc"
3162	477	ID(mov); DM2(HL, C, 0); SR(A);
3163
3164	477	}
3165	477	break;
3166	279	case 0xfb:
3167	279	{
3168		/** 0110 0001 1111 1011 rorc %0, %1 */
3169	279	if (trace)
3170	0	{
3171	0	printf ("\033[33m%s\033[0m %02x %02x\n",
3172	0	"/** 0110 0001 1111 1011 rorc %0, %1 */",
3173	0	op[0], op[1]);
3174	0	}
3175	279	SYNTAX("rorc %0, %1");
3176	279	#line 1031 "rl78-decode.opc"
3177	279	ID(rorc); DR(A); SC(1);
3178
3179		/----------------------------------------------------------------------/
3180
3181		/* Note that the branch insns need to be listed before the shift
3182		ones, as "shift count of zero" means "branch insn" */
3183
3184	279	}
3185	279	break;
3186	383	case 0xfc:
3187	383	{
3188		/** 0110 0001 1111 1100 reti */
3189	383	if (trace)
3190	0	{
3191	0	printf ("\033[33m%s\033[0m %02x %02x\n",
3192	0	"/** 0110 0001 1111 1100 reti */",
3193	0	op[0], op[1]);
3194	0	}
3195	383	SYNTAX("reti");
3196	383	#line 1011 "rl78-decode.opc"
3197	383	ID(reti);
3198
3199	383	}
3200	383	break;
3201	668	case 0xfd:
3202	668	{
3203		/** 0110 0001 1111 1101 stop */
3204	668	if (trace)
3205	0	{
3206	0	printf ("\033[33m%s\033[0m %02x %02x\n",
3207	0	"/** 0110 0001 1111 1101 stop */",
3208	0	op[0], op[1]);
3209	0	}
3210	668	SYNTAX("stop");
3211	668	#line 1120 "rl78-decode.opc"
3212	668	ID(stop);
3213
3214		/----------------------------------------------------------------------/
3215
3216	668	}
3217	668	break;
3218	1.83k	default: UNSUPPORTED(); break;
3219	211k	}
3220	211k	break;
3221	211k	case 0x68:
3222	19.8k	{
3223		/** 0110 1000 movw %e0, %1 */
3224	19.8k	if (trace)
3225	0	{
3226	0	printf ("\033[33m%s\033[0m %02x\n",
3227	0	"/** 0110 1000 movw %e0, %1 */",
3228	0	op[0]);
3229	0	}
3230	19.8k	SYNTAX("movw %e0, %1");
3231	19.8k	#line 880 "rl78-decode.opc"
3232	19.8k	ID(mov); W(); DM(C, IMMU(2)); SR(AX);
3233
3234	19.8k	}
3235	19.8k	break;
3236	27.3k	case 0x69:
3237	27.3k	{
3238		/** 0110 1001 movw %0, %e1 */
3239	27.3k	if (trace)
3240	0	{
3241	0	printf ("\033[33m%s\033[0m %02x\n",
3242	0	"/** 0110 1001 movw %0, %e1 */",
3243	0	op[0]);
3244	0	}
3245	27.3k	SYNTAX("movw %0, %e1");
3246	27.3k	#line 871 "rl78-decode.opc"
3247	27.3k	ID(mov); W(); DR(AX); SM(C, IMMU(2));
3248
3249	27.3k	}
3250	27.3k	break;
3251	12.6k	case 0x6a:
3252	12.6k	{
3253		/** 0110 1010 or %0, #%1 */
3254	12.6k	if (trace)
3255	0	{
3256	0	printf ("\033[33m%s\033[0m %02x\n",
3257	0	"/** 0110 1010 or %0, #%1 */",
3258	0	op[0]);
3259	0	}
3260	12.6k	SYNTAX("or %0, #%1");
3261	12.6k	#line 973 "rl78-decode.opc"
3262	12.6k	ID(or); DM(None, SADDR); SC(IMMU(1)); Fz;
3263
3264		/----------------------------------------------------------------------/
3265
3266	12.6k	}
3267	12.6k	break;
3268	8.96k	case 0x6b:
3269	8.96k	{
3270		/** 0110 1011 or %0, %1 */
3271	8.96k	if (trace)
3272	0	{
3273	0	printf ("\033[33m%s\033[0m %02x\n",
3274	0	"/** 0110 1011 or %0, %1 */",
3275	0	op[0]);
3276	0	}
3277	8.96k	SYNTAX("or %0, %1");
3278	8.96k	#line 970 "rl78-decode.opc"
3279	8.96k	ID(or); DR(A); SM(None, SADDR); Fz;
3280
3281	8.96k	}
3282	8.96k	break;
3283	20.7k	case 0x6c:
3284	20.7k	{
3285		/** 0110 1100 or %0, #%1 */
3286	20.7k	if (trace)
3287	0	{
3288	0	printf ("\033[33m%s\033[0m %02x\n",
3289	0	"/** 0110 1100 or %0, #%1 */",
3290	0	op[0]);
3291	0	}
3292	20.7k	SYNTAX("or %0, #%1");
3293	20.7k	#line 961 "rl78-decode.opc"
3294	20.7k	ID(or); DR(A); SC(IMMU(1)); Fz;
3295
3296	20.7k	}
3297	20.7k	break;
3298	18.2k	case 0x6d:
3299	18.2k	{
3300		/** 0110 1101 or %0, %e1 */
3301	18.2k	if (trace)
3302	0	{
3303	0	printf ("\033[33m%s\033[0m %02x\n",
3304	0	"/** 0110 1101 or %0, %e1 */",
3305	0	op[0]);
3306	0	}
3307	18.2k	SYNTAX("or %0, %e1");
3308	18.2k	#line 949 "rl78-decode.opc"
3309	18.2k	ID(or); DR(A); SM(HL, 0); Fz;
3310
3311	18.2k	}
3312	18.2k	break;
3313	27.7k	case 0x6e:
3314	27.7k	{
3315		/** 0110 1110 or %0, %ea1 */
3316	27.7k	if (trace)
3317	0	{
3318	0	printf ("\033[33m%s\033[0m %02x\n",
3319	0	"/** 0110 1110 or %0, %ea1 */",
3320	0	op[0]);
3321	0	}
3322	27.7k	SYNTAX("or %0, %ea1");
3323	27.7k	#line 955 "rl78-decode.opc"
3324	27.7k	ID(or); DR(A); SM(HL, IMMU(1)); Fz;
3325
3326	27.7k	}
3327	27.7k	break;
3328	22.1k	case 0x6f:
3329	22.1k	{
3330		/** 0110 1111 or %0, %e!1 */
3331	22.1k	if (trace)
3332	0	{
3333	0	printf ("\033[33m%s\033[0m %02x\n",
3334	0	"/** 0110 1111 or %0, %e!1 */",
3335	0	op[0]);
3336	0	}
3337	22.1k	SYNTAX("or %0, %e!1");
3338	22.1k	#line 946 "rl78-decode.opc"
3339	22.1k	ID(or); DR(A); SM(None, IMMU(2)); Fz;
3340
3341	22.1k	}
3342	22.1k	break;
3343	25.5k	case 0x70:
3344	51.5k	case 0x72:
3345	88.3k	case 0x73:
3346	118k	case 0x74:
3347	136k	case 0x75:
3348	151k	case 0x76:
3349	165k	case 0x77:
3350	165k	{
3351		/** 0111 0rba mov %0, %1 */
3352	165k	#line 702 "rl78-decode.opc"
3353	165k	int rba AU = op[0] & 0x07;
3354	165k	if (trace)
3355	0	{
3356	0	printf ("\033[33m%s\033[0m %02x\n",
3357	0	"/** 0111 0rba mov %0, %1 */",
3358	0	op[0]);
3359	0	printf (" rba = 0x%x\n", rba);
3360	0	}
3361	165k	SYNTAX("mov %0, %1");
3362	165k	#line 702 "rl78-decode.opc"
3363	165k	ID(mov); DRB(rba); SR(A);
3364
3365	165k	}
3366	165k	break;
3367	199k	case 0x71:
3368	199k	GETBYTE ();
3369	199k	switch (op[1] & 0xff)
3370	199k	{
3371	5.65k	case 0x00:
3372	7.60k	case 0x10:
3373	8.47k	case 0x20:
3374	9.90k	case 0x30:
3375	10.6k	case 0x40:
3376	11.6k	case 0x50:
3377	12.0k	case 0x60:
3378	12.5k	case 0x70:
3379	12.5k	{
3380		/** 0111 0001 0bit 0000 set1 %e!0 */
3381	12.5k	#line 1052 "rl78-decode.opc"
3382	12.5k	int bit AU = (op[1] >> 4) & 0x07;
3383	12.5k	if (trace)
3384	0	{
3385	0	printf ("\033[33m%s\033[0m %02x %02x\n",
3386	0	"/** 0111 0001 0bit 0000 set1 %e!0 */",
3387	0	op[0], op[1]);
3388	0	printf (" bit = 0x%x\n", bit);
3389	0	}
3390	12.5k	SYNTAX("set1 %e!0");
3391	12.5k	#line 1052 "rl78-decode.opc"
3392	12.5k	ID(mov); DM(None, IMMU(2)); DB(bit); SC(1);
3393
3394	12.5k	}
3395	12.5k	break;
3396	1.20k	case 0x01:
3397	7.27k	case 0x11:
3398	7.59k	case 0x21:
3399	8.86k	case 0x31:
3400	9.04k	case 0x41:
3401	11.0k	case 0x51:
3402	12.1k	case 0x61:
3403	57.7k	case 0x71:
3404	57.7k	{
3405		/** 0111 0001 0bit 0001 mov1 %0, cy */
3406	57.7k	#line 809 "rl78-decode.opc"
3407	57.7k	int bit AU = (op[1] >> 4) & 0x07;
3408	57.7k	if (trace)
3409	0	{
3410	0	printf ("\033[33m%s\033[0m %02x %02x\n",
3411	0	"/** 0111 0001 0bit 0001 mov1 %0, cy */",
3412	0	op[0], op[1]);
3413	0	printf (" bit = 0x%x\n", bit);
3414	0	}
3415	57.7k	SYNTAX("mov1 %0, cy");
3416	57.7k	#line 809 "rl78-decode.opc"
3417	57.7k	ID(mov); DM(None, SADDR); DB(bit); SCY();
3418
3419	57.7k	}
3420	57.7k	break;
3421	637	case 0x02:
3422	841	case 0x12:
3423	922	case 0x22:
3424	1.39k	case 0x32:
3425	2.13k	case 0x42:
3426	2.72k	case 0x52:
3427	4.87k	case 0x62:
3428	5.68k	case 0x72:
3429	5.68k	{
3430		/** 0111 0001 0bit 0010 set1 %0 */
3431	5.68k	#line 1070 "rl78-decode.opc"
3432	5.68k	int bit AU = (op[1] >> 4) & 0x07;
3433	5.68k	if (trace)
3434	0	{
3435	0	printf ("\033[33m%s\033[0m %02x %02x\n",
3436	0	"/** 0111 0001 0bit 0010 set1 %0 */",
3437	0	op[0], op[1]);
3438	0	printf (" bit = 0x%x\n", bit);
3439	0	}
3440	5.68k	SYNTAX("set1 %0");
3441	5.68k	#line 1070 "rl78-decode.opc"
3442	5.68k	ID(mov); DM(None, SADDR); DB(bit); SC(1);
3443
3444		/----------------------------------------------------------------------/
3445
3446	5.68k	}
3447	5.68k	break;
3448	755	case 0x03:
3449	1.30k	case 0x13:
3450	1.49k	case 0x23:
3451	3.84k	case 0x33:
3452	4.39k	case 0x43:
3453	4.63k	case 0x53:
3454	5.21k	case 0x63:
3455	5.83k	case 0x73:
3456	5.83k	{
3457		/** 0111 0001 0bit 0011 clr1 %0 */
3458	5.83k	#line 462 "rl78-decode.opc"
3459	5.83k	int bit AU = (op[1] >> 4) & 0x07;
3460	5.83k	if (trace)
3461	0	{
3462	0	printf ("\033[33m%s\033[0m %02x %02x\n",
3463	0	"/** 0111 0001 0bit 0011 clr1 %0 */",
3464	0	op[0], op[1]);
3465	0	printf (" bit = 0x%x\n", bit);
3466	0	}
3467	5.83k	SYNTAX("clr1 %0");
3468	5.83k	#line 462 "rl78-decode.opc"
3469	5.83k	ID(mov); DM(None, SADDR); DB(bit); SC(0);
3470
3471		/----------------------------------------------------------------------/
3472
3473	5.83k	}
3474	5.83k	break;
3475	414	case 0x04:
3476	532	case 0x14:
3477	702	case 0x24:
3478	1.54k	case 0x34:
3479	2.12k	case 0x44:
3480	2.28k	case 0x54:
3481	2.46k	case 0x64:
3482	3.23k	case 0x74:
3483	3.23k	{
3484		/** 0111 0001 0bit 0100 mov1 cy, %1 */
3485	3.23k	#line 803 "rl78-decode.opc"
3486	3.23k	int bit AU = (op[1] >> 4) & 0x07;
3487	3.23k	if (trace)
3488	0	{
3489	0	printf ("\033[33m%s\033[0m %02x %02x\n",
3490	0	"/** 0111 0001 0bit 0100 mov1 cy, %1 */",
3491	0	op[0], op[1]);
3492	0	printf (" bit = 0x%x\n", bit);
3493	0	}
3494	3.23k	SYNTAX("mov1 cy, %1");
3495	3.23k	#line 803 "rl78-decode.opc"
3496	3.23k	ID(mov); DCY(); SM(None, SADDR); SB(bit);
3497
3498	3.23k	}
3499	3.23k	break;
3500	271	case 0x05:
3501	570	case 0x15:
3502	874	case 0x25:
3503	1.24k	case 0x35:
3504	1.72k	case 0x45:
3505	1.98k	case 0x55:
3506	2.62k	case 0x65:
3507	4.09k	case 0x75:
3508	4.09k	{
3509		/** 0111 0001 0bit 0101 and1 cy, %s1 */
3510	4.09k	#line 332 "rl78-decode.opc"
3511	4.09k	int bit AU = (op[1] >> 4) & 0x07;
3512	4.09k	if (trace)
3513	0	{
3514	0	printf ("\033[33m%s\033[0m %02x %02x\n",
3515	0	"/** 0111 0001 0bit 0101 and1 cy, %s1 */",
3516	0	op[0], op[1]);
3517	0	printf (" bit = 0x%x\n", bit);
3518	0	}
3519	4.09k	SYNTAX("and1 cy, %s1");
3520	4.09k	#line 332 "rl78-decode.opc"
3521	4.09k	ID(and); DCY(); SM(None, SADDR); SB(bit);
3522
3523		/----------------------------------------------------------------------/
3524
3525		/* Note that the branch insns need to be listed before the shift
3526		ones, as "shift count of zero" means "branch insn" */
3527
3528	4.09k	}
3529	4.09k	break;
3530	121	case 0x06:
3531	694	case 0x16:
3532	1.22k	case 0x26:
3533	2.13k	case 0x36:
3534	2.37k	case 0x46:
3535	3.22k	case 0x56:
3536	3.53k	case 0x66:
3537	3.62k	case 0x76:
3538	3.62k	{
3539		/** 0111 0001 0bit 0110 or1 cy, %s1 */
3540	3.62k	#line 987 "rl78-decode.opc"
3541	3.62k	int bit AU = (op[1] >> 4) & 0x07;
3542	3.62k	if (trace)
3543	0	{
3544	0	printf ("\033[33m%s\033[0m %02x %02x\n",
3545	0	"/** 0111 0001 0bit 0110 or1 cy, %s1 */",
3546	0	op[0], op[1]);
3547	0	printf (" bit = 0x%x\n", bit);
3548	0	}
3549	3.62k	SYNTAX("or1 cy, %s1");
3550	3.62k	#line 987 "rl78-decode.opc"
3551	3.62k	ID(or); DCY(); SM(None, SADDR); SB(bit);
3552
3553		/----------------------------------------------------------------------/
3554
3555	3.62k	}
3556	3.62k	break;
3557	635	case 0x07:
3558	739	case 0x17:
3559	1.79k	case 0x27:
3560	1.89k	case 0x37:
3561	2.21k	case 0x47:
3562	2.28k	case 0x57:
3563	3.27k	case 0x67:
3564	3.60k	case 0x77:
3565	3.60k	{
3566		/** 0111 0001 0bit 0111 xor1 cy, %s1 */
3567	3.60k	#line 1291 "rl78-decode.opc"
3568	3.60k	int bit AU = (op[1] >> 4) & 0x07;
3569	3.60k	if (trace)
3570	0	{
3571	0	printf ("\033[33m%s\033[0m %02x %02x\n",
3572	0	"/** 0111 0001 0bit 0111 xor1 cy, %s1 */",
3573	0	op[0], op[1]);
3574	0	printf (" bit = 0x%x\n", bit);
3575	0	}
3576	3.60k	SYNTAX("xor1 cy, %s1");
3577	3.60k	#line 1291 "rl78-decode.opc"
3578	3.60k	ID(xor); DCY(); SM(None, SADDR); SB(bit);
3579
3580		/----------------------------------------------------------------------/
3581
3582	3.60k	}
3583	3.60k	break;
3584	293	case 0x08:
3585	631	case 0x18:
3586	2.95k	case 0x28:
3587	3.05k	case 0x38:
3588	3.74k	case 0x48:
3589	3.88k	case 0x58:
3590	4.42k	case 0x68:
3591	4.63k	case 0x78:
3592	4.63k	{
3593		/** 0111 0001 0bit 1000 clr1 %e!0 */
3594	4.63k	#line 444 "rl78-decode.opc"
3595	4.63k	int bit AU = (op[1] >> 4) & 0x07;
3596	4.63k	if (trace)
3597	0	{
3598	0	printf ("\033[33m%s\033[0m %02x %02x\n",
3599	0	"/** 0111 0001 0bit 1000 clr1 %e!0 */",
3600	0	op[0], op[1]);
3601	0	printf (" bit = 0x%x\n", bit);
3602	0	}
3603	4.63k	SYNTAX("clr1 %e!0");
3604	4.63k	#line 444 "rl78-decode.opc"
3605	4.63k	ID(mov); DM(None, IMMU(2)); DB(bit); SC(0);
3606
3607	4.63k	}
3608	4.63k	break;
3609	1.18k	case 0x09:
3610	2.16k	case 0x19:
3611	2.41k	case 0x29:
3612	2.77k	case 0x39:
3613	4.37k	case 0x49:
3614	4.85k	case 0x59:
3615	5.21k	case 0x69:
3616	6.82k	case 0x79:
3617	6.82k	{
3618		/** 0111 0001 0bit 1001 mov1 %s0, cy */
3619	6.82k	#line 812 "rl78-decode.opc"
3620	6.82k	int bit AU = (op[1] >> 4) & 0x07;
3621	6.82k	if (trace)
3622	0	{
3623	0	printf ("\033[33m%s\033[0m %02x %02x\n",
3624	0	"/** 0111 0001 0bit 1001 mov1 %s0, cy */",
3625	0	op[0], op[1]);
3626	0	printf (" bit = 0x%x\n", bit);
3627	0	}
3628	6.82k	SYNTAX("mov1 %s0, cy");
3629	6.82k	#line 812 "rl78-decode.opc"
3630	6.82k	ID(mov); DM(None, SFR); DB(bit); SCY();
3631
3632		/----------------------------------------------------------------------/
3633
3634	6.82k	}
3635	6.82k	break;
3636	124	case 0x0a:
3637	1.72k	case 0x1a:
3638	2.44k	case 0x2a:
3639	2.77k	case 0x3a:
3640	3.12k	case 0x4a:
3641	3.40k	case 0x5a:
3642	4.07k	case 0x6a:
3643	5.05k	case 0x7a:
3644	5.05k	{
3645		/** 0111 0001 0bit 1010 set1 %s0 */
3646	5.05k	#line 1064 "rl78-decode.opc"
3647	5.05k	int bit AU = (op[1] >> 4) & 0x07;
3648	5.05k	if (trace)
3649	0	{
3650	0	printf ("\033[33m%s\033[0m %02x %02x\n",
3651	0	"/** 0111 0001 0bit 1010 set1 %s0 */",
3652	0	op[0], op[1]);
3653	0	printf (" bit = 0x%x\n", bit);
3654	0	}
3655	5.05k	SYNTAX("set1 %s0");
3656	5.05k	#line 1064 "rl78-decode.opc"
3657	5.05k	op0 = SFR;
3658	5.05k	ID(mov); DM(None, op0); DB(bit); SC(1);
3659	5.05k	if (op0 == RL78_SFR_PSW && bit == 7)
3660	293	rl78->syntax = "ei";
3661
3662	5.05k	}
3663	5.05k	break;
3664	480	case 0x0b:
3665	735	case 0x1b:
3666	1.06k	case 0x2b:
3667	1.68k	case 0x3b:
3668	2.60k	case 0x4b:
3669	2.72k	case 0x5b:
3670	2.85k	case 0x6b:
3671	4.01k	case 0x7b:
3672	4.01k	{
3673		/** 0111 0001 0bit 1011 clr1 %s0 */
3674	4.01k	#line 456 "rl78-decode.opc"
3675	4.01k	int bit AU = (op[1] >> 4) & 0x07;
3676	4.01k	if (trace)
3677	0	{
3678	0	printf ("\033[33m%s\033[0m %02x %02x\n",
3679	0	"/** 0111 0001 0bit 1011 clr1 %s0 */",
3680	0	op[0], op[1]);
3681	0	printf (" bit = 0x%x\n", bit);
3682	0	}
3683	4.01k	SYNTAX("clr1 %s0");
3684	4.01k	#line 456 "rl78-decode.opc"
3685	4.01k	op0 = SFR;
3686	4.01k	ID(mov); DM(None, op0); DB(bit); SC(0);
3687	4.01k	if (op0 == RL78_SFR_PSW && bit == 7)
3688	89	rl78->syntax = "di";
3689
3690	4.01k	}
3691	4.01k	break;
3692	808	case 0x0c:
3693	1.66k	case 0x1c:
3694	2.21k	case 0x2c:
3695	2.33k	case 0x3c:
3696	4.60k	case 0x4c:
3697	5.04k	case 0x5c:
3698	6.03k	case 0x6c:
3699	6.85k	case 0x7c:
3700	6.85k	{
3701		/** 0111 0001 0bit 1100 mov1 cy, %s1 */
3702	6.85k	#line 806 "rl78-decode.opc"
3703	6.85k	int bit AU = (op[1] >> 4) & 0x07;
3704	6.85k	if (trace)
3705	0	{
3706	0	printf ("\033[33m%s\033[0m %02x %02x\n",
3707	0	"/** 0111 0001 0bit 1100 mov1 cy, %s1 */",
3708	0	op[0], op[1]);
3709	0	printf (" bit = 0x%x\n", bit);
3710	0	}
3711	6.85k	SYNTAX("mov1 cy, %s1");
3712	6.85k	#line 806 "rl78-decode.opc"
3713	6.85k	ID(mov); DCY(); SM(None, SFR); SB(bit);
3714
3715	6.85k	}
3716	6.85k	break;
3717	187	case 0x0d:
3718	1.11k	case 0x1d:
3719	1.51k	case 0x2d:
3720	2.24k	case 0x3d:
3721	2.50k	case 0x4d:
3722	3.02k	case 0x5d:
3723	4.44k	case 0x6d:
3724	5.29k	case 0x7d:
3725	5.29k	{
3726		/** 0111 0001 0bit 1101 and1 cy, %s1 */
3727	5.29k	#line 329 "rl78-decode.opc"
3728	5.29k	int bit AU = (op[1] >> 4) & 0x07;
3729	5.29k	if (trace)
3730	0	{
3731	0	printf ("\033[33m%s\033[0m %02x %02x\n",
3732	0	"/** 0111 0001 0bit 1101 and1 cy, %s1 */",
3733	0	op[0], op[1]);
3734	0	printf (" bit = 0x%x\n", bit);
3735	0	}
3736	5.29k	SYNTAX("and1 cy, %s1");
3737	5.29k	#line 329 "rl78-decode.opc"
3738	5.29k	ID(and); DCY(); SM(None, SFR); SB(bit);
3739
3740	5.29k	}
3741	5.29k	break;
3742	87	case 0x0e:
3743	1.89k	case 0x1e:
3744	4.22k	case 0x2e:
3745	4.41k	case 0x3e:
3746	5.25k	case 0x4e:
3747	5.42k	case 0x5e:
3748	5.84k	case 0x6e:
3749	6.20k	case 0x7e:
3750	6.20k	{
3751		/** 0111 0001 0bit 1110 or1 cy, %s1 */
3752	6.20k	#line 984 "rl78-decode.opc"
3753	6.20k	int bit AU = (op[1] >> 4) & 0x07;
3754	6.20k	if (trace)
3755	0	{
3756	0	printf ("\033[33m%s\033[0m %02x %02x\n",
3757	0	"/** 0111 0001 0bit 1110 or1 cy, %s1 */",
3758	0	op[0], op[1]);
3759	0	printf (" bit = 0x%x\n", bit);
3760	0	}
3761	6.20k	SYNTAX("or1 cy, %s1");
3762	6.20k	#line 984 "rl78-decode.opc"
3763	6.20k	ID(or); DCY(); SM(None, SFR); SB(bit);
3764
3765	6.20k	}
3766	6.20k	break;
3767	997	case 0x0f:
3768	1.10k	case 0x1f:
3769	1.36k	case 0x2f:
3770	1.66k	case 0x3f:
3771	1.89k	case 0x4f:
3772	2.83k	case 0x5f:
3773	3.48k	case 0x6f:
3774	3.93k	case 0x7f:
3775	3.93k	{
3776		/** 0111 0001 0bit 1111 xor1 cy, %s1 */
3777	3.93k	#line 1288 "rl78-decode.opc"
3778	3.93k	int bit AU = (op[1] >> 4) & 0x07;
3779	3.93k	if (trace)
3780	0	{
3781	0	printf ("\033[33m%s\033[0m %02x %02x\n",
3782	0	"/** 0111 0001 0bit 1111 xor1 cy, %s1 */",
3783	0	op[0], op[1]);
3784	0	printf (" bit = 0x%x\n", bit);
3785	0	}
3786	3.93k	SYNTAX("xor1 cy, %s1");
3787	3.93k	#line 1288 "rl78-decode.opc"
3788	3.93k	ID(xor); DCY(); SM(None, SFR); SB(bit);
3789
3790	3.93k	}
3791	3.93k	break;
3792	870	case 0x80:
3793	870	{
3794		/** 0111 0001 1000 0000 set1 cy */
3795	870	if (trace)
3796	0	{
3797	0	printf ("\033[33m%s\033[0m %02x %02x\n",
3798	0	"/** 0111 0001 1000 0000 set1 cy */",
3799	0	op[0], op[1]);
3800	0	}
3801	870	SYNTAX("set1 cy");
3802	870	#line 1061 "rl78-decode.opc"
3803	870	ID(mov); DCY(); SC(1);
3804
3805	870	}
3806	870	break;
3807	743	case 0x81:
3808	1.15k	case 0x91:
3809	1.30k	case 0xa1:
3810	1.61k	case 0xb1:
3811	1.71k	case 0xc1:
3812	1.97k	case 0xd1:
3813	2.55k	case 0xe1:
3814	3.54k	case 0xf1:
3815	3.54k	{
3816		/** 0111 0001 1bit 0001 mov1 %e0, cy */
3817	3.54k	#line 791 "rl78-decode.opc"
3818	3.54k	int bit AU = (op[1] >> 4) & 0x07;
3819	3.54k	if (trace)
3820	0	{
3821	0	printf ("\033[33m%s\033[0m %02x %02x\n",
3822	0	"/** 0111 0001 1bit 0001 mov1 %e0, cy */",
3823	0	op[0], op[1]);
3824	0	printf (" bit = 0x%x\n", bit);
3825	0	}
3826	3.54k	SYNTAX("mov1 %e0, cy");
3827	3.54k	#line 791 "rl78-decode.opc"
3828	3.54k	ID(mov); DM(HL, 0); DB(bit); SCY();
3829
3830	3.54k	}
3831	3.54k	break;
3832	265	case 0x82:
3833	436	case 0x92:
3834	921	case 0xa2:
3835	1.32k	case 0xb2:
3836	1.42k	case 0xc2:
3837	1.87k	case 0xd2:
3838	1.98k	case 0xe2:
3839	2.93k	case 0xf2:
3840	2.93k	{
3841		/** 0111 0001 1bit 0010 set1 %e0 */
3842	2.93k	#line 1055 "rl78-decode.opc"
3843	2.93k	int bit AU = (op[1] >> 4) & 0x07;
3844	2.93k	if (trace)
3845	0	{
3846	0	printf ("\033[33m%s\033[0m %02x %02x\n",
3847	0	"/** 0111 0001 1bit 0010 set1 %e0 */",
3848	0	op[0], op[1]);
3849	0	printf (" bit = 0x%x\n", bit);
3850	0	}
3851	2.93k	SYNTAX("set1 %e0");
3852	2.93k	#line 1055 "rl78-decode.opc"
3853	2.93k	ID(mov); DM(HL, 0); DB(bit); SC(1);
3854
3855	2.93k	}
3856	2.93k	break;
3857	118	case 0x83:
3858	280	case 0x93:
3859	439	case 0xa3:
3860	2.32k	case 0xb3:
3861	2.58k	case 0xc3:
3862	2.70k	case 0xd3:
3863	2.80k	case 0xe3:
3864	3.46k	case 0xf3:
3865	3.46k	{
3866		/** 0111 0001 1bit 0011 clr1 %e0 */
3867	3.46k	#line 447 "rl78-decode.opc"
3868	3.46k	int bit AU = (op[1] >> 4) & 0x07;
3869	3.46k	if (trace)
3870	0	{
3871	0	printf ("\033[33m%s\033[0m %02x %02x\n",
3872	0	"/** 0111 0001 1bit 0011 clr1 %e0 */",
3873	0	op[0], op[1]);
3874	0	printf (" bit = 0x%x\n", bit);
3875	0	}
3876	3.46k	SYNTAX("clr1 %e0");
3877	3.46k	#line 447 "rl78-decode.opc"
3878	3.46k	ID(mov); DM(HL, 0); DB(bit); SC(0);
3879
3880	3.46k	}
3881	3.46k	break;
3882	430	case 0x84:
3883	1.52k	case 0x94:
3884	1.61k	case 0xa4:
3885	4.45k	case 0xb4:
3886	4.96k	case 0xc4:
3887	5.64k	case 0xd4:
3888	6.02k	case 0xe4:
3889	7.08k	case 0xf4:
3890	7.08k	{
3891		/** 0111 0001 1bit 0100 mov1 cy, %e1 */
3892	7.08k	#line 797 "rl78-decode.opc"
3893	7.08k	int bit AU = (op[1] >> 4) & 0x07;
3894	7.08k	if (trace)
3895	0	{
3896	0	printf ("\033[33m%s\033[0m %02x %02x\n",
3897	0	"/** 0111 0001 1bit 0100 mov1 cy, %e1 */",
3898	0	op[0], op[1]);
3899	0	printf (" bit = 0x%x\n", bit);
3900	0	}
3901	7.08k	SYNTAX("mov1 cy, %e1");
3902	7.08k	#line 797 "rl78-decode.opc"
3903	7.08k	ID(mov); DCY(); SM(HL, 0); SB(bit);
3904
3905	7.08k	}
3906	7.08k	break;
3907	1.36k	case 0x85:
3908	1.66k	case 0x95:
3909	2.70k	case 0xa5:
3910	3.27k	case 0xb5:
3911	3.46k	case 0xc5:
3912	3.94k	case 0xd5:
3913	4.46k	case 0xe5:
3914	4.56k	case 0xf5:
3915	4.56k	{
3916		/** 0111 0001 1bit 0101 and1 cy, %e1 */
3917	4.56k	#line 323 "rl78-decode.opc"
3918	4.56k	int bit AU = (op[1] >> 4) & 0x07;
3919	4.56k	if (trace)
3920	0	{
3921	0	printf ("\033[33m%s\033[0m %02x %02x\n",
3922	0	"/** 0111 0001 1bit 0101 and1 cy, %e1 */",
3923	0	op[0], op[1]);
3924	0	printf (" bit = 0x%x\n", bit);
3925	0	}
3926	4.56k	SYNTAX("and1 cy, %e1");
3927	4.56k	#line 323 "rl78-decode.opc"
3928	4.56k	ID(and); DCY(); SM(HL, 0); SB(bit);
3929
3930	4.56k	}
3931	4.56k	break;
3932	159	case 0x86:
3933	571	case 0x96:
3934	1.34k	case 0xa6:
3935	1.53k	case 0xb6:
3936	1.92k	case 0xc6:
3937	2.08k	case 0xd6:
3938	2.28k	case 0xe6:
3939	3.48k	case 0xf6:
3940	3.48k	{
3941		/** 0111 0001 1bit 0110 or1 cy, %e1 */
3942	3.48k	#line 978 "rl78-decode.opc"
3943	3.48k	int bit AU = (op[1] >> 4) & 0x07;
3944	3.48k	if (trace)
3945	0	{
3946	0	printf ("\033[33m%s\033[0m %02x %02x\n",
3947	0	"/** 0111 0001 1bit 0110 or1 cy, %e1 */",
3948	0	op[0], op[1]);
3949	0	printf (" bit = 0x%x\n", bit);
3950	0	}
3951	3.48k	SYNTAX("or1 cy, %e1");
3952	3.48k	#line 978 "rl78-decode.opc"
3953	3.48k	ID(or); DCY(); SM(HL, 0); SB(bit);
3954
3955	3.48k	}
3956	3.48k	break;
3957	729	case 0x87:
3958	1.25k	case 0x97:
3959	2.59k	case 0xa7:
3960	2.66k	case 0xb7:
3961	3.54k	case 0xc7:
3962	3.83k	case 0xd7:
3963	5.00k	case 0xe7:
3964	5.35k	case 0xf7:
3965	5.35k	{
3966		/** 0111 0001 1bit 0111 xor1 cy, %e1 */
3967	5.35k	#line 1282 "rl78-decode.opc"
3968	5.35k	int bit AU = (op[1] >> 4) & 0x07;
3969	5.35k	if (trace)
3970	0	{
3971	0	printf ("\033[33m%s\033[0m %02x %02x\n",
3972	0	"/** 0111 0001 1bit 0111 xor1 cy, %e1 */",
3973	0	op[0], op[1]);
3974	0	printf (" bit = 0x%x\n", bit);
3975	0	}
3976	5.35k	SYNTAX("xor1 cy, %e1");
3977	5.35k	#line 1282 "rl78-decode.opc"
3978	5.35k	ID(xor); DCY(); SM(HL, 0); SB(bit);
3979
3980	5.35k	}
3981	5.35k	break;
3982	460	case 0x88:
3983	460	{
3984		/** 0111 0001 1000 1000 clr1 cy */
3985	460	if (trace)
3986	0	{
3987	0	printf ("\033[33m%s\033[0m %02x %02x\n",
3988	0	"/** 0111 0001 1000 1000 clr1 cy */",
3989	0	op[0], op[1]);
3990	0	}
3991	460	SYNTAX("clr1 cy");
3992	460	#line 453 "rl78-decode.opc"
3993	460	ID(mov); DCY(); SC(0);
3994
3995	460	}
3996	460	break;
3997	524	case 0x89:
3998	1.18k	case 0x99:
3999	1.43k	case 0xa9:
4000	1.78k	case 0xb9:
4001	1.89k	case 0xc9:
4002	2.53k	case 0xd9:
4003	2.74k	case 0xe9:
4004	3.21k	case 0xf9:
4005	3.21k	{
4006		/** 0111 0001 1bit 1001 mov1 %e0, cy */
4007	3.21k	#line 794 "rl78-decode.opc"
4008	3.21k	int bit AU = (op[1] >> 4) & 0x07;
4009	3.21k	if (trace)
4010	0	{
4011	0	printf ("\033[33m%s\033[0m %02x %02x\n",
4012	0	"/** 0111 0001 1bit 1001 mov1 %e0, cy */",
4013	0	op[0], op[1]);
4014	0	printf (" bit = 0x%x\n", bit);
4015	0	}
4016	3.21k	SYNTAX("mov1 %e0, cy");
4017	3.21k	#line 794 "rl78-decode.opc"
4018	3.21k	ID(mov); DR(A); DB(bit); SCY();
4019
4020	3.21k	}
4021	3.21k	break;
4022	1.06k	case 0x8a:
4023	1.17k	case 0x9a:
4024	1.61k	case 0xaa:
4025	2.06k	case 0xba:
4026	2.21k	case 0xca:
4027	2.49k	case 0xda:
4028	2.69k	case 0xea:
4029	3.06k	case 0xfa:
4030	3.06k	{
4031		/** 0111 0001 1bit 1010 set1 %0 */
4032	3.06k	#line 1058 "rl78-decode.opc"
4033	3.06k	int bit AU = (op[1] >> 4) & 0x07;
4034	3.06k	if (trace)
4035	0	{
4036	0	printf ("\033[33m%s\033[0m %02x %02x\n",
4037	0	"/** 0111 0001 1bit 1010 set1 %0 */",
4038	0	op[0], op[1]);
4039	0	printf (" bit = 0x%x\n", bit);
4040	0	}
4041	3.06k	SYNTAX("set1 %0");
4042	3.06k	#line 1058 "rl78-decode.opc"
4043	3.06k	ID(mov); DR(A); DB(bit); SC(1);
4044
4045	3.06k	}
4046	3.06k	break;
4047	1.02k	case 0x8b:
4048	1.36k	case 0x9b:
4049	1.50k	case 0xab:
4050	1.70k	case 0xbb:
4051	1.81k	case 0xcb:
4052	2.20k	case 0xdb:
4053	2.39k	case 0xeb:
4054	3.65k	case 0xfb:
4055	3.65k	{
4056		/** 0111 0001 1bit 1011 clr1 %0 */
4057	3.65k	#line 450 "rl78-decode.opc"
4058	3.65k	int bit AU = (op[1] >> 4) & 0x07;
4059	3.65k	if (trace)
4060	0	{
4061	0	printf ("\033[33m%s\033[0m %02x %02x\n",
4062	0	"/** 0111 0001 1bit 1011 clr1 %0 */",
4063	0	op[0], op[1]);
4064	0	printf (" bit = 0x%x\n", bit);
4065	0	}
4066	3.65k	SYNTAX("clr1 %0");
4067	3.65k	#line 450 "rl78-decode.opc"
4068	3.65k	ID(mov); DR(A); DB(bit); SC(0);
4069
4070	3.65k	}
4071	3.65k	break;
4072	461	case 0x8c:
4073	614	case 0x9c:
4074	1.12k	case 0xac:
4075	1.50k	case 0xbc:
4076	1.69k	case 0xcc:
4077	2.05k	case 0xdc:
4078	2.17k	case 0xec:
4079	2.36k	case 0xfc:
4080	2.36k	{
4081		/** 0111 0001 1bit 1100 mov1 cy, %e1 */
4082	2.36k	#line 800 "rl78-decode.opc"
4083	2.36k	int bit AU = (op[1] >> 4) & 0x07;
4084	2.36k	if (trace)
4085	0	{
4086	0	printf ("\033[33m%s\033[0m %02x %02x\n",
4087	0	"/** 0111 0001 1bit 1100 mov1 cy, %e1 */",
4088	0	op[0], op[1]);
4089	0	printf (" bit = 0x%x\n", bit);
4090	0	}
4091	2.36k	SYNTAX("mov1 cy, %e1");
4092	2.36k	#line 800 "rl78-decode.opc"
4093	2.36k	ID(mov); DCY(); SR(A); SB(bit);
4094
4095	2.36k	}
4096	2.36k	break;
4097	677	case 0x8d:
4098	1.19k	case 0x9d:
4099	1.37k	case 0xad:
4100	1.50k	case 0xbd:
4101	2.10k	case 0xcd:
4102	2.39k	case 0xdd:
4103	3.41k	case 0xed:
4104	4.09k	case 0xfd:
4105	4.09k	{
4106		/** 0111 0001 1bit 1101 and1 cy, %1 */
4107	4.09k	#line 326 "rl78-decode.opc"
4108	4.09k	int bit AU = (op[1] >> 4) & 0x07;
4109	4.09k	if (trace)
4110	0	{
4111	0	printf ("\033[33m%s\033[0m %02x %02x\n",
4112	0	"/** 0111 0001 1bit 1101 and1 cy, %1 */",
4113	0	op[0], op[1]);
4114	0	printf (" bit = 0x%x\n", bit);
4115	0	}
4116	4.09k	SYNTAX("and1 cy, %1");
4117	4.09k	#line 326 "rl78-decode.opc"
4118	4.09k	ID(and); DCY(); SR(A); SB(bit);
4119
4120	4.09k	}
4121	4.09k	break;
4122	1.21k	case 0x8e:
4123	1.45k	case 0x9e:
4124	1.51k	case 0xae:
4125	1.79k	case 0xbe:
4126	2.21k	case 0xce:
4127	2.77k	case 0xde:
4128	3.33k	case 0xee:
4129	4.17k	case 0xfe:
4130	4.17k	{
4131		/** 0111 0001 1bit 1110 or1 cy, %1 */
4132	4.17k	#line 981 "rl78-decode.opc"
4133	4.17k	int bit AU = (op[1] >> 4) & 0x07;
4134	4.17k	if (trace)
4135	0	{
4136	0	printf ("\033[33m%s\033[0m %02x %02x\n",
4137	0	"/** 0111 0001 1bit 1110 or1 cy, %1 */",
4138	0	op[0], op[1]);
4139	0	printf (" bit = 0x%x\n", bit);
4140	0	}
4141	4.17k	SYNTAX("or1 cy, %1");
4142	4.17k	#line 981 "rl78-decode.opc"
4143	4.17k	ID(or); DCY(); SR(A); SB(bit);
4144
4145	4.17k	}
4146	4.17k	break;
4147	1.31k	case 0x8f:
4148	1.87k	case 0x9f:
4149	2.22k	case 0xaf:
4150	2.32k	case 0xbf:
4151	2.52k	case 0xcf:
4152	2.64k	case 0xdf:
4153	3.20k	case 0xef:
4154	5.03k	case 0xff:
4155	5.03k	{
4156		/** 0111 0001 1bit 1111 xor1 cy, %1 */
4157	5.03k	#line 1285 "rl78-decode.opc"
4158	5.03k	int bit AU = (op[1] >> 4) & 0x07;
4159	5.03k	if (trace)
4160	0	{
4161	0	printf ("\033[33m%s\033[0m %02x %02x\n",
4162	0	"/** 0111 0001 1bit 1111 xor1 cy, %1 */",
4163	0	op[0], op[1]);
4164	0	printf (" bit = 0x%x\n", bit);
4165	0	}
4166	5.03k	SYNTAX("xor1 cy, %1");
4167	5.03k	#line 1285 "rl78-decode.opc"
4168	5.03k	ID(xor); DCY(); SR(A); SB(bit);
4169
4170	5.03k	}
4171	5.03k	break;
4172	566	case 0xc0:
4173	566	{
4174		/** 0111 0001 1100 0000 not1 cy */
4175	566	if (trace)
4176	0	{
4177	0	printf ("\033[33m%s\033[0m %02x %02x\n",
4178	0	"/** 0111 0001 1100 0000 not1 cy */",
4179	0	op[0], op[1]);
4180	0	}
4181	566	SYNTAX("not1 cy");
4182	566	#line 922 "rl78-decode.opc"
4183	566	ID(xor); DCY(); SC(1);
4184
4185		/----------------------------------------------------------------------/
4186
4187	566	}
4188	566	break;
4189	2.31k	default: UNSUPPORTED(); break;
4190	199k	}
4191	199k	break;
4192	199k	case 0x78:
4193	12.6k	{
4194		/** 0111 1000 movw %e0, %1 */
4195	12.6k	if (trace)
4196	0	{
4197	0	printf ("\033[33m%s\033[0m %02x\n",
4198	0	"/** 0111 1000 movw %e0, %1 */",
4199	0	op[0]);
4200	0	}
4201	12.6k	SYNTAX("movw %e0, %1");
4202	12.6k	#line 883 "rl78-decode.opc"
4203	12.6k	ID(mov); W(); DM(BC, IMMU(2)); SR(AX);
4204
4205	12.6k	}
4206	12.6k	break;
4207	10.4k	case 0x79:
4208	10.4k	{
4209		/** 0111 1001 movw %0, %e1 */
4210	10.4k	if (trace)
4211	0	{
4212	0	printf ("\033[33m%s\033[0m %02x\n",
4213	0	"/** 0111 1001 movw %0, %e1 */",
4214	0	op[0]);
4215	0	}
4216	10.4k	SYNTAX("movw %0, %e1");
4217	10.4k	#line 874 "rl78-decode.opc"
4218	10.4k	ID(mov); W(); DR(AX); SM(BC, IMMU(2));
4219
4220	10.4k	}
4221	10.4k	break;
4222	15.4k	case 0x7a:
4223	15.4k	{
4224		/** 0111 1010 xor %0, #%1 */
4225	15.4k	if (trace)
4226	0	{
4227	0	printf ("\033[33m%s\033[0m %02x\n",
4228	0	"/** 0111 1010 xor %0, #%1 */",
4229	0	op[0]);
4230	0	}
4231	15.4k	SYNTAX("xor %0, #%1");
4232	15.4k	#line 1277 "rl78-decode.opc"
4233	15.4k	ID(xor); DM(None, SADDR); SC(IMMU(1)); Fz;
4234
4235		/----------------------------------------------------------------------/
4236
4237	15.4k	}
4238	15.4k	break;
4239	9.98k	case 0x7b:
4240	9.98k	{
4241		/** 0111 1011 xor %0, %1 */
4242	9.98k	if (trace)
4243	0	{
4244	0	printf ("\033[33m%s\033[0m %02x\n",
4245	0	"/** 0111 1011 xor %0, %1 */",
4246	0	op[0]);
4247	0	}
4248	9.98k	SYNTAX("xor %0, %1");
4249	9.98k	#line 1274 "rl78-decode.opc"
4250	9.98k	ID(xor); DR(A); SM(None, SADDR); Fz;
4251
4252	9.98k	}
4253	9.98k	break;
4254	18.3k	case 0x7c:
4255	18.3k	{
4256		/** 0111 1100 xor %0, #%1 */
4257	18.3k	if (trace)
4258	0	{
4259	0	printf ("\033[33m%s\033[0m %02x\n",
4260	0	"/** 0111 1100 xor %0, #%1 */",
4261	0	op[0]);
4262	0	}
4263	18.3k	SYNTAX("xor %0, #%1");
4264	18.3k	#line 1265 "rl78-decode.opc"
4265	18.3k	ID(xor); DR(A); SC(IMMU(1)); Fz;
4266
4267	18.3k	}
4268	18.3k	break;
4269	11.8k	case 0x7d:
4270	11.8k	{
4271		/** 0111 1101 xor %0, %e1 */
4272	11.8k	if (trace)
4273	0	{
4274	0	printf ("\033[33m%s\033[0m %02x\n",
4275	0	"/** 0111 1101 xor %0, %e1 */",
4276	0	op[0]);
4277	0	}
4278	11.8k	SYNTAX("xor %0, %e1");
4279	11.8k	#line 1253 "rl78-decode.opc"
4280	11.8k	ID(xor); DR(A); SM(HL, 0); Fz;
4281
4282	11.8k	}
4283	11.8k	break;
4284	11.0k	case 0x7e:
4285	11.0k	{
4286		/** 0111 1110 xor %0, %ea1 */
4287	11.0k	if (trace)
4288	0	{
4289	0	printf ("\033[33m%s\033[0m %02x\n",
4290	0	"/** 0111 1110 xor %0, %ea1 */",
4291	0	op[0]);
4292	0	}
4293	11.0k	SYNTAX("xor %0, %ea1");
4294	11.0k	#line 1259 "rl78-decode.opc"
4295	11.0k	ID(xor); DR(A); SM(HL, IMMU(1)); Fz;
4296
4297	11.0k	}
4298	11.0k	break;
4299	23.1k	case 0x7f:
4300	23.1k	{
4301		/** 0111 1111 xor %0, %e!1 */
4302	23.1k	if (trace)
4303	0	{
4304	0	printf ("\033[33m%s\033[0m %02x\n",
4305	0	"/** 0111 1111 xor %0, %e!1 */",
4306	0	op[0]);
4307	0	}
4308	23.1k	SYNTAX("xor %0, %e!1");
4309	23.1k	#line 1250 "rl78-decode.opc"
4310	23.1k	ID(xor); DR(A); SM(None, IMMU(2)); Fz;
4311
4312	23.1k	}
4313	23.1k	break;
4314	32.3k	case 0x80:
4315	49.2k	case 0x81:
4316	59.5k	case 0x82:
4317	68.7k	case 0x83:
4318	79.8k	case 0x84:
4319	94.7k	case 0x85:
4320	104k	case 0x86:
4321	114k	case 0x87:
4322	114k	{
4323		/** 1000 0reg inc %0 */
4324	114k	#line 593 "rl78-decode.opc"
4325	114k	int reg AU = op[0] & 0x07;
4326	114k	if (trace)
4327	0	{
4328	0	printf ("\033[33m%s\033[0m %02x\n",
4329	0	"/** 1000 0reg inc %0 */",
4330	0	op[0]);
4331	0	printf (" reg = 0x%x\n", reg);
4332	0	}
4333	114k	SYNTAX("inc %0");
4334	114k	#line 593 "rl78-decode.opc"
4335	114k	ID(add); DRB(reg); SC(1); Fza;
4336
4337	114k	}
4338	114k	break;
4339	11.2k	case 0x88:
4340	11.2k	{
4341		/** 1000 1000 mov %0, %ea1 */
4342	11.2k	if (trace)
4343	0	{
4344	0	printf ("\033[33m%s\033[0m %02x\n",
4345	0	"/** 1000 1000 mov %0, %ea1 */",
4346	0	op[0]);
4347	0	}
4348	11.2k	SYNTAX("mov %0, %ea1");
4349	11.2k	#line 672 "rl78-decode.opc"
4350	11.2k	ID(mov); DR(A); SM(SP, IMMU(1));
4351
4352	11.2k	}
4353	11.2k	break;
4354	23.6k	case 0x89:
4355	23.6k	{
4356		/** 1000 1001 mov %0, %e1 */
4357	23.6k	if (trace)
4358	0	{
4359	0	printf ("\033[33m%s\033[0m %02x\n",
4360	0	"/** 1000 1001 mov %0, %e1 */",
4361	0	op[0]);
4362	0	}
4363	23.6k	SYNTAX("mov %0, %e1");
4364	23.6k	#line 654 "rl78-decode.opc"
4365	23.6k	ID(mov); DR(A); SM(DE, 0);
4366
4367	23.6k	}
4368	23.6k	break;
4369	9.37k	case 0x8a:
4370	9.37k	{
4371		/** 1000 1010 mov %0, %ea1 */
4372	9.37k	if (trace)
4373	0	{
4374	0	printf ("\033[33m%s\033[0m %02x\n",
4375	0	"/** 1000 1010 mov %0, %ea1 */",
4376	0	op[0]);
4377	0	}
4378	9.37k	SYNTAX("mov %0, %ea1");
4379	9.37k	#line 657 "rl78-decode.opc"
4380	9.37k	ID(mov); DR(A); SM(DE, IMMU(1));
4381
4382	9.37k	}
4383	9.37k	break;
4384	14.6k	case 0x8b:
4385	14.6k	{
4386		/** 1000 1011 mov %0, %e1 */
4387	14.6k	if (trace)
4388	0	{
4389	0	printf ("\033[33m%s\033[0m %02x\n",
4390	0	"/** 1000 1011 mov %0, %e1 */",
4391	0	op[0]);
4392	0	}
4393	14.6k	SYNTAX("mov %0, %e1");
4394	14.6k	#line 660 "rl78-decode.opc"
4395	14.6k	ID(mov); DR(A); SM(HL, 0);
4396
4397	14.6k	}
4398	14.6k	break;
4399	7.06k	case 0x8c:
4400	7.06k	{
4401		/** 1000 1100 mov %0, %ea1 */
4402	7.06k	if (trace)
4403	0	{
4404	0	printf ("\033[33m%s\033[0m %02x\n",
4405	0	"/** 1000 1100 mov %0, %ea1 */",
4406	0	op[0]);
4407	0	}
4408	7.06k	SYNTAX("mov %0, %ea1");
4409	7.06k	#line 663 "rl78-decode.opc"
4410	7.06k	ID(mov); DR(A); SM(HL, IMMU(1));
4411
4412	7.06k	}
4413	7.06k	break;
4414	12.8k	case 0x8d:
4415	12.8k	{
4416		/** 1000 1101 mov %0, %1 */
4417	12.8k	if (trace)
4418	0	{
4419	0	printf ("\033[33m%s\033[0m %02x\n",
4420	0	"/** 1000 1101 mov %0, %1 */",
4421	0	op[0]);
4422	0	}
4423	12.8k	SYNTAX("mov %0, %1");
4424	12.8k	#line 696 "rl78-decode.opc"
4425	12.8k	ID(mov); DR(A); SM(None, SADDR);
4426
4427	12.8k	}
4428	12.8k	break;
4429	22.0k	case 0x8e:
4430	22.0k	{
4431		/** 1000 1110 mov %0, %s1 */
4432	22.0k	if (trace)
4433	0	{
4434	0	printf ("\033[33m%s\033[0m %02x\n",
4435	0	"/** 1000 1110 mov %0, %s1 */",
4436	0	op[0]);
4437	0	}
4438	22.0k	SYNTAX("mov %0, %s1");
4439	22.0k	#line 693 "rl78-decode.opc"
4440	22.0k	ID(mov); DR(A); SM(None, SFR);
4441
4442	22.0k	}
4443	22.0k	break;
4444	9.72k	case 0x8f:
4445	9.72k	{
4446		/** 1000 1111 mov %0, %e!1 */
4447	9.72k	if (trace)
4448	0	{
4449	0	printf ("\033[33m%s\033[0m %02x\n",
4450	0	"/** 1000 1111 mov %0, %e!1 */",
4451	0	op[0]);
4452	0	}
4453	9.72k	SYNTAX("mov %0, %e!1");
4454	9.72k	#line 651 "rl78-decode.opc"
4455	9.72k	ID(mov); DR(A); SM(None, IMMU(2));
4456
4457	9.72k	}
4458	9.72k	break;
4459	16.6k	case 0x90:
4460	38.9k	case 0x91:
4461	47.4k	case 0x92:
4462	60.0k	case 0x93:
4463	68.6k	case 0x94:
4464	82.8k	case 0x95:
4465	93.7k	case 0x96:
4466	104k	case 0x97:
4467	104k	{
4468		/** 1001 0reg dec %0 */
4469	104k	#line 560 "rl78-decode.opc"
4470	104k	int reg AU = op[0] & 0x07;
4471	104k	if (trace)
4472	0	{
4473	0	printf ("\033[33m%s\033[0m %02x\n",
4474	0	"/** 1001 0reg dec %0 */",
4475	0	op[0]);
4476	0	printf (" reg = 0x%x\n", reg);
4477	0	}
4478	104k	SYNTAX("dec %0");
4479	104k	#line 560 "rl78-decode.opc"
4480	104k	ID(sub); DRB(reg); SC(1); Fza;
4481
4482	104k	}
4483	104k	break;
4484	11.5k	case 0x98:
4485	11.5k	{
4486		/** 1001 1000 mov %a0, %1 */
4487	11.5k	if (trace)
4488	0	{
4489	0	printf ("\033[33m%s\033[0m %02x\n",
4490	0	"/** 1001 1000 mov %a0, %1 */",
4491	0	op[0]);
4492	0	}
4493	11.5k	SYNTAX("mov %a0, %1");
4494	11.5k	#line 648 "rl78-decode.opc"
4495	11.5k	ID(mov); DM(SP, IMMU(1)); SR(A);
4496
4497	11.5k	}
4498	11.5k	break;
4499	10.6k	case 0x99:
4500	10.6k	{
4501		/** 1001 1001 mov %e0, %1 */
4502	10.6k	if (trace)
4503	0	{
4504	0	printf ("\033[33m%s\033[0m %02x\n",
4505	0	"/** 1001 1001 mov %e0, %1 */",
4506	0	op[0]);
4507	0	}
4508	10.6k	SYNTAX("mov %e0, %1");
4509	10.6k	#line 621 "rl78-decode.opc"
4510	10.6k	ID(mov); DM(DE, 0); SR(A);
4511
4512	10.6k	}
4513	10.6k	break;
4514	6.76k	case 0x9a:
4515	6.76k	{
4516		/** 1001 1010 mov %ea0, %1 */
4517	6.76k	if (trace)
4518	0	{
4519	0	printf ("\033[33m%s\033[0m %02x\n",
4520	0	"/** 1001 1010 mov %ea0, %1 */",
4521	0	op[0]);
4522	0	}
4523	6.76k	SYNTAX("mov %ea0, %1");
4524	6.76k	#line 627 "rl78-decode.opc"
4525	6.76k	ID(mov); DM(DE, IMMU(1)); SR(A);
4526
4527	6.76k	}
4528	6.76k	break;
4529	11.1k	case 0x9b:
4530	11.1k	{
4531		/** 1001 1011 mov %e0, %1 */
4532	11.1k	if (trace)
4533	0	{
4534	0	printf ("\033[33m%s\033[0m %02x\n",
4535	0	"/** 1001 1011 mov %e0, %1 */",
4536	0	op[0]);
4537	0	}
4538	11.1k	SYNTAX("mov %e0, %1");
4539	11.1k	#line 630 "rl78-decode.opc"
4540	11.1k	ID(mov); DM(HL, 0); SR(A);
4541
4542	11.1k	}
4543	11.1k	break;
4544	14.5k	case 0x9c:
4545	14.5k	{
4546		/** 1001 1100 mov %ea0, %1 */
4547	14.5k	if (trace)
4548	0	{
4549	0	printf ("\033[33m%s\033[0m %02x\n",
4550	0	"/** 1001 1100 mov %ea0, %1 */",
4551	0	op[0]);
4552	0	}
4553	14.5k	SYNTAX("mov %ea0, %1");
4554	14.5k	#line 639 "rl78-decode.opc"
4555	14.5k	ID(mov); DM(HL, IMMU(1)); SR(A);
4556
4557	14.5k	}
4558	14.5k	break;
4559	11.1k	case 0x9d:
4560	11.1k	{
4561		/** 1001 1101 mov %0, %1 */
4562	11.1k	if (trace)
4563	0	{
4564	0	printf ("\033[33m%s\033[0m %02x\n",
4565	0	"/** 1001 1101 mov %0, %1 */",
4566	0	op[0]);
4567	0	}
4568	11.1k	SYNTAX("mov %0, %1");
4569	11.1k	#line 753 "rl78-decode.opc"
4570	11.1k	ID(mov); DM(None, SADDR); SR(A);
4571
4572	11.1k	}
4573	11.1k	break;
4574	10.7k	case 0x9e:
4575	10.7k	{
4576		/** 1001 1110 mov %s0, %1 */
4577	10.7k	if (trace)
4578	0	{
4579	0	printf ("\033[33m%s\033[0m %02x\n",
4580	0	"/** 1001 1110 mov %s0, %1 */",
4581	0	op[0]);
4582	0	}
4583	10.7k	SYNTAX("mov %s0, %1");
4584	10.7k	#line 786 "rl78-decode.opc"
4585	10.7k	ID(mov); DM(None, SFR); SR(A);
4586
4587		/----------------------------------------------------------------------/
4588
4589	10.7k	}
4590	10.7k	break;
4591	9.70k	case 0x9f:
4592	9.70k	{
4593		/** 1001 1111 mov %e!0, %1 */
4594	9.70k	if (trace)
4595	0	{
4596	0	printf ("\033[33m%s\033[0m %02x\n",
4597	0	"/** 1001 1111 mov %e!0, %1 */",
4598	0	op[0]);
4599	0	}
4600	9.70k	SYNTAX("mov %e!0, %1");
4601	9.70k	#line 618 "rl78-decode.opc"
4602	9.70k	ID(mov); DM(None, IMMU(2)); SR(A);
4603
4604	9.70k	}
4605	9.70k	break;
4606	16.1k	case 0xa0:
4607	16.1k	{
4608		/** 1010 0000 inc %e!0 */
4609	16.1k	if (trace)
4610	0	{
4611	0	printf ("\033[33m%s\033[0m %02x\n",
4612	0	"/** 1010 0000 inc %e!0 */",
4613	0	op[0]);
4614	0	}
4615	16.1k	SYNTAX("inc %e!0");
4616	16.1k	#line 587 "rl78-decode.opc"
4617	16.1k	ID(add); DM(None, IMMU(2)); SC(1); Fza;
4618
4619	16.1k	}
4620	16.1k	break;
4621	12.2k	case 0xa1:
4622	29.9k	case 0xa3:
4623	41.8k	case 0xa5:
4624	52.5k	case 0xa7:
4625	52.5k	{
4626		/** 1010 0rg1 incw %0 */
4627	52.5k	#line 607 "rl78-decode.opc"
4628	52.5k	int rg AU = (op[0] >> 1) & 0x03;
4629	52.5k	if (trace)
4630	0	{
4631	0	printf ("\033[33m%s\033[0m %02x\n",
4632	0	"/** 1010 0rg1 incw %0 */",
4633	0	op[0]);
4634	0	printf (" rg = 0x%x\n", rg);
4635	0	}
4636	52.5k	SYNTAX("incw %0");
4637	52.5k	#line 607 "rl78-decode.opc"
4638	52.5k	ID(add); W(); DRW(rg); SC(1);
4639
4640	52.5k	}
4641	52.5k	break;
4642	10.9k	case 0xa2:
4643	10.9k	{
4644		/** 1010 0010 incw %e!0 */
4645	10.9k	if (trace)
4646	0	{
4647	0	printf ("\033[33m%s\033[0m %02x\n",
4648	0	"/** 1010 0010 incw %e!0 */",
4649	0	op[0]);
4650	0	}
4651	10.9k	SYNTAX("incw %e!0");
4652	10.9k	#line 601 "rl78-decode.opc"
4653	10.9k	ID(add); W(); DM(None, IMMU(2)); SC(1);
4654
4655	10.9k	}
4656	10.9k	break;
4657	10.9k	case 0xa4:
4658	10.9k	{
4659		/** 1010 0100 inc %0 */
4660	10.9k	if (trace)
4661	0	{
4662	0	printf ("\033[33m%s\033[0m %02x\n",
4663	0	"/** 1010 0100 inc %0 */",
4664	0	op[0]);
4665	0	}
4666	10.9k	SYNTAX("inc %0");
4667	10.9k	#line 596 "rl78-decode.opc"
4668	10.9k	ID(add); DM(None, SADDR); SC(1); Fza;
4669
4670		/----------------------------------------------------------------------/
4671
4672	10.9k	}
4673	10.9k	break;
4674	9.43k	case 0xa6:
4675	9.43k	{
4676		/** 1010 0110 incw %0 */
4677	9.43k	if (trace)
4678	0	{
4679	0	printf ("\033[33m%s\033[0m %02x\n",
4680	0	"/** 1010 0110 incw %0 */",
4681	0	op[0]);
4682	0	}
4683	9.43k	SYNTAX("incw %0");
4684	9.43k	#line 610 "rl78-decode.opc"
4685	9.43k	ID(add); W(); DM(None, SADDR); SC(1);
4686
4687		/----------------------------------------------------------------------/
4688
4689	9.43k	}
4690	9.43k	break;
4691	9.73k	case 0xa8:
4692	9.73k	{
4693		/** 1010 1000 movw %0, %a1 */
4694	9.73k	if (trace)
4695	0	{
4696	0	printf ("\033[33m%s\033[0m %02x\n",
4697	0	"/** 1010 1000 movw %0, %a1 */",
4698	0	op[0]);
4699	0	}
4700	9.73k	SYNTAX("movw %0, %a1");
4701	9.73k	#line 856 "rl78-decode.opc"
4702	9.73k	ID(mov); W(); DR(AX); SM(SP, IMMU(1));
4703
4704	9.73k	}
4705	9.73k	break;
4706	35.9k	case 0xa9:
4707	35.9k	{
4708		/** 1010 1001 movw %0, %e1 */
4709	35.9k	if (trace)
4710	0	{
4711	0	printf ("\033[33m%s\033[0m %02x\n",
4712	0	"/** 1010 1001 movw %0, %e1 */",
4713	0	op[0]);
4714	0	}
4715	35.9k	SYNTAX("movw %0, %e1");
4716	35.9k	#line 844 "rl78-decode.opc"
4717	35.9k	ID(mov); W(); DR(AX); SM(DE, 0);
4718
4719	35.9k	}
4720	35.9k	break;
4721	8.76k	case 0xaa:
4722	8.76k	{
4723		/** 1010 1010 movw %0, %ea1 */
4724	8.76k	if (trace)
4725	0	{
4726	0	printf ("\033[33m%s\033[0m %02x\n",
4727	0	"/** 1010 1010 movw %0, %ea1 */",
4728	0	op[0]);
4729	0	}
4730	8.76k	SYNTAX("movw %0, %ea1");
4731	8.76k	#line 847 "rl78-decode.opc"
4732	8.76k	ID(mov); W(); DR(AX); SM(DE, IMMU(1));
4733
4734	8.76k	}
4735	8.76k	break;
4736	11.1k	case 0xab:
4737	11.1k	{
4738		/** 1010 1011 movw %0, %e1 */
4739	11.1k	if (trace)
4740	0	{
4741	0	printf ("\033[33m%s\033[0m %02x\n",
4742	0	"/** 1010 1011 movw %0, %e1 */",
4743	0	op[0]);
4744	0	}
4745	11.1k	SYNTAX("movw %0, %e1");
4746	11.1k	#line 850 "rl78-decode.opc"
4747	11.1k	ID(mov); W(); DR(AX); SM(HL, 0);
4748
4749	11.1k	}
4750	11.1k	break;
4751	5.21k	case 0xac:
4752	5.21k	{
4753		/** 1010 1100 movw %0, %ea1 */
4754	5.21k	if (trace)
4755	0	{
4756	0	printf ("\033[33m%s\033[0m %02x\n",
4757	0	"/** 1010 1100 movw %0, %ea1 */",
4758	0	op[0]);
4759	0	}
4760	5.21k	SYNTAX("movw %0, %ea1");
4761	5.21k	#line 853 "rl78-decode.opc"
4762	5.21k	ID(mov); W(); DR(AX); SM(HL, IMMU(1));
4763
4764	5.21k	}
4765	5.21k	break;
4766	6.51k	case 0xad:
4767	6.51k	{
4768		/** 1010 1101 movw %0, %1 */
4769	6.51k	if (trace)
4770	0	{
4771	0	printf ("\033[33m%s\033[0m %02x\n",
4772	0	"/** 1010 1101 movw %0, %1 */",
4773	0	op[0]);
4774	0	}
4775	6.51k	SYNTAX("movw %0, %1");
4776	6.51k	#line 886 "rl78-decode.opc"
4777	6.51k	ID(mov); W(); DR(AX); SM(None, SADDR);
4778
4779	6.51k	}
4780	6.51k	break;
4781	12.6k	case 0xae:
4782	12.6k	{
4783		/** 1010 1110 movw %0, %s1 */
4784	12.6k	if (trace)
4785	0	{
4786	0	printf ("\033[33m%s\033[0m %02x\n",
4787	0	"/** 1010 1110 movw %0, %s1 */",
4788	0	op[0]);
4789	0	}
4790	12.6k	SYNTAX("movw %0, %s1");
4791	12.6k	#line 889 "rl78-decode.opc"
4792	12.6k	ID(mov); W(); DR(AX); SM(None, SFR);
4793
4794	12.6k	}
4795	12.6k	break;
4796	20.2k	case 0xaf:
4797	20.2k	{
4798		/** 1010 1111 movw %0, %e!1 */
4799	20.2k	if (trace)
4800	0	{
4801	0	printf ("\033[33m%s\033[0m %02x\n",
4802	0	"/** 1010 1111 movw %0, %e!1 */",
4803	0	op[0]);
4804	0	}
4805	20.2k	SYNTAX("movw %0, %e!1");
4806	20.2k	#line 840 "rl78-decode.opc"
4807	20.2k	ID(mov); W(); DR(AX); SM(None, IMMU(2));
4808
4809
4810	20.2k	}
4811	20.2k	break;
4812	6.47k	case 0xb0:
4813	6.47k	{
4814		/** 1011 0000 dec %e!0 */
4815	6.47k	if (trace)
4816	0	{
4817	0	printf ("\033[33m%s\033[0m %02x\n",
4818	0	"/** 1011 0000 dec %e!0 */",
4819	0	op[0]);
4820	0	}
4821	6.47k	SYNTAX("dec %e!0");
4822	6.47k	#line 554 "rl78-decode.opc"
4823	6.47k	ID(sub); DM(None, IMMU(2)); SC(1); Fza;
4824
4825	6.47k	}
4826	6.47k	break;
4827	6.71k	case 0xb1:
4828	16.4k	case 0xb3:
4829	29.8k	case 0xb5:
4830	40.8k	case 0xb7:
4831	40.8k	{
4832		/** 1011 0rg1 decw %0 */
4833	40.8k	#line 574 "rl78-decode.opc"
4834	40.8k	int rg AU = (op[0] >> 1) & 0x03;
4835	40.8k	if (trace)
4836	0	{
4837	0	printf ("\033[33m%s\033[0m %02x\n",
4838	0	"/** 1011 0rg1 decw %0 */",
4839	0	op[0]);
4840	0	printf (" rg = 0x%x\n", rg);
4841	0	}
4842	40.8k	SYNTAX("decw %0");
4843	40.8k	#line 574 "rl78-decode.opc"
4844	40.8k	ID(sub); W(); DRW(rg); SC(1);
4845
4846	40.8k	}
4847	40.8k	break;
4848	6.23k	case 0xb2:
4849	6.23k	{
4850		/** 1011 0010 decw %e!0 */
4851	6.23k	if (trace)
4852	0	{
4853	0	printf ("\033[33m%s\033[0m %02x\n",
4854	0	"/** 1011 0010 decw %e!0 */",
4855	0	op[0]);
4856	0	}
4857	6.23k	SYNTAX("decw %e!0");
4858	6.23k	#line 568 "rl78-decode.opc"
4859	6.23k	ID(sub); W(); DM(None, IMMU(2)); SC(1);
4860
4861	6.23k	}
4862	6.23k	break;
4863	10.9k	case 0xb4:
4864	10.9k	{
4865		/** 1011 0100 dec %0 */
4866	10.9k	if (trace)
4867	0	{
4868	0	printf ("\033[33m%s\033[0m %02x\n",
4869	0	"/** 1011 0100 dec %0 */",
4870	0	op[0]);
4871	0	}
4872	10.9k	SYNTAX("dec %0");
4873	10.9k	#line 563 "rl78-decode.opc"
4874	10.9k	ID(sub); DM(None, SADDR); SC(1); Fza;
4875
4876		/----------------------------------------------------------------------/
4877
4878	10.9k	}
4879	10.9k	break;
4880	8.47k	case 0xb6:
4881	8.47k	{
4882		/** 1011 0110 decw %0 */
4883	8.47k	if (trace)
4884	0	{
4885	0	printf ("\033[33m%s\033[0m %02x\n",
4886	0	"/** 1011 0110 decw %0 */",
4887	0	op[0]);
4888	0	}
4889	8.47k	SYNTAX("decw %0");
4890	8.47k	#line 577 "rl78-decode.opc"
4891	8.47k	ID(sub); W(); DM(None, SADDR); SC(1);
4892
4893		/----------------------------------------------------------------------/
4894
4895	8.47k	}
4896	8.47k	break;
4897	7.93k	case 0xb8:
4898	7.93k	{
4899		/** 1011 1000 movw %a0, %1 */
4900	7.93k	if (trace)
4901	0	{
4902	0	printf ("\033[33m%s\033[0m %02x\n",
4903	0	"/** 1011 1000 movw %a0, %1 */",
4904	0	op[0]);
4905	0	}
4906	7.93k	SYNTAX("movw %a0, %1");
4907	7.93k	#line 837 "rl78-decode.opc"
4908	7.93k	ID(mov); W(); DM(SP, IMMU(1)); SR(AX);
4909
4910	7.93k	}
4911	7.93k	break;
4912	9.48k	case 0xb9:
4913	9.48k	{
4914		/** 1011 1001 movw %e0, %1 */
4915	9.48k	if (trace)
4916	0	{
4917	0	printf ("\033[33m%s\033[0m %02x\n",
4918	0	"/** 1011 1001 movw %e0, %1 */",
4919	0	op[0]);
4920	0	}
4921	9.48k	SYNTAX("movw %e0, %1");
4922	9.48k	#line 825 "rl78-decode.opc"
4923	9.48k	ID(mov); W(); DM(DE, 0); SR(AX);
4924
4925	9.48k	}
4926	9.48k	break;
4927	7.36k	case 0xba:
4928	7.36k	{
4929		/** 1011 1010 movw %ea0, %1 */
4930	7.36k	if (trace)
4931	0	{
4932	0	printf ("\033[33m%s\033[0m %02x\n",
4933	0	"/** 1011 1010 movw %ea0, %1 */",
4934	0	op[0]);
4935	0	}
4936	7.36k	SYNTAX("movw %ea0, %1");
4937	7.36k	#line 828 "rl78-decode.opc"
4938	7.36k	ID(mov); W(); DM(DE, IMMU(1)); SR(AX);
4939
4940	7.36k	}
4941	7.36k	break;
4942	6.85k	case 0xbb:
4943	6.85k	{
4944		/** 1011 1011 movw %e0, %1 */
4945	6.85k	if (trace)
4946	0	{
4947	0	printf ("\033[33m%s\033[0m %02x\n",
4948	0	"/** 1011 1011 movw %e0, %1 */",
4949	0	op[0]);
4950	0	}
4951	6.85k	SYNTAX("movw %e0, %1");
4952	6.85k	#line 831 "rl78-decode.opc"
4953	6.85k	ID(mov); W(); DM(HL, 0); SR(AX);
4954
4955	6.85k	}
4956	6.85k	break;
4957	5.34k	case 0xbc:
4958	5.34k	{
4959		/** 1011 1100 movw %ea0, %1 */
4960	5.34k	if (trace)
4961	0	{
4962	0	printf ("\033[33m%s\033[0m %02x\n",
4963	0	"/** 1011 1100 movw %ea0, %1 */",
4964	0	op[0]);
4965	0	}
4966	5.34k	SYNTAX("movw %ea0, %1");
4967	5.34k	#line 834 "rl78-decode.opc"
4968	5.34k	ID(mov); W(); DM(HL, IMMU(1)); SR(AX);
4969
4970	5.34k	}
4971	5.34k	break;
4972	7.51k	case 0xbd:
4973	7.51k	{
4974		/** 1011 1101 movw %0, %1 */
4975	7.51k	if (trace)
4976	0	{
4977	0	printf ("\033[33m%s\033[0m %02x\n",
4978	0	"/** 1011 1101 movw %0, %1 */",
4979	0	op[0]);
4980	0	}
4981	7.51k	SYNTAX("movw %0, %1");
4982	7.51k	#line 901 "rl78-decode.opc"
4983	7.51k	ID(mov); W(); DM(None, SADDR); SR(AX);
4984
4985	7.51k	}
4986	7.51k	break;
4987	11.3k	case 0xbe:
4988	11.3k	{
4989		/** 1011 1110 movw %s0, %1 */
4990	11.3k	if (trace)
4991	0	{
4992	0	printf ("\033[33m%s\033[0m %02x\n",
4993	0	"/** 1011 1110 movw %s0, %1 */",
4994	0	op[0]);
4995	0	}
4996	11.3k	SYNTAX("movw %s0, %1");
4997	11.3k	#line 907 "rl78-decode.opc"
4998	11.3k	ID(mov); W(); DM(None, SFR); SR(AX);
4999
5000		/----------------------------------------------------------------------/
5001
5002	11.3k	}
5003	11.3k	break;
5004	8.28k	case 0xbf:
5005	8.28k	{
5006		/** 1011 1111 movw %e!0, %1 */
5007	8.28k	if (trace)
5008	0	{
5009	0	printf ("\033[33m%s\033[0m %02x\n",
5010	0	"/** 1011 1111 movw %e!0, %1 */",
5011	0	op[0]);
5012	0	}
5013	8.28k	SYNTAX("movw %e!0, %1");
5014	8.28k	#line 822 "rl78-decode.opc"
5015	8.28k	ID(mov); W(); DM(None, IMMU(2)); SR(AX);
5016
5017	8.28k	}
5018	8.28k	break;
5019	22.8k	case 0xc0:
5020	35.2k	case 0xc2:
5021	51.6k	case 0xc4:
5022	66.0k	case 0xc6:
5023	66.0k	{
5024		/** 1100 0rg0 pop %0 */
5025	66.0k	#line 992 "rl78-decode.opc"
5026	66.0k	int rg AU = (op[0] >> 1) & 0x03;
5027	66.0k	if (trace)
5028	0	{
5029	0	printf ("\033[33m%s\033[0m %02x\n",
5030	0	"/** 1100 0rg0 pop %0 */",
5031	0	op[0]);
5032	0	printf (" rg = 0x%x\n", rg);
5033	0	}
5034	66.0k	SYNTAX("pop %0");
5035	66.0k	#line 992 "rl78-decode.opc"
5036	66.0k	ID(mov); W(); DRW(rg); SPOP();
5037
5038	66.0k	}
5039	66.0k	break;
5040	25.8k	case 0xc1:
5041	46.5k	case 0xc3:
5042	59.0k	case 0xc5:
5043	81.9k	case 0xc7:
5044	81.9k	{
5045		/** 1100 0rg1 push %1 */
5046	81.9k	#line 1000 "rl78-decode.opc"
5047	81.9k	int rg AU = (op[0] >> 1) & 0x03;
5048	81.9k	if (trace)
5049	0	{
5050	0	printf ("\033[33m%s\033[0m %02x\n",
5051	0	"/** 1100 0rg1 push %1 */",
5052	0	op[0]);
5053	0	printf (" rg = 0x%x\n", rg);
5054	0	}
5055	81.9k	SYNTAX("push %1");
5056	81.9k	#line 1000 "rl78-decode.opc"
5057	81.9k	ID(mov); W(); DPUSH(); SRW(rg);
5058
5059	81.9k	}
5060	81.9k	break;
5061	7.23k	case 0xc8:
5062	7.23k	{
5063		/** 1100 1000 mov %a0, #%1 */
5064	7.23k	if (trace)
5065	0	{
5066	0	printf ("\033[33m%s\033[0m %02x\n",
5067	0	"/** 1100 1000 mov %a0, #%1 */",
5068	0	op[0]);
5069	0	}
5070	7.23k	SYNTAX("mov %a0, #%1");
5071	7.23k	#line 645 "rl78-decode.opc"
5072	7.23k	ID(mov); DM(SP, IMMU(1)); SC(IMMU(1));
5073
5074	7.23k	}
5075	7.23k	break;
5076	8.26k	case 0xc9:
5077	8.26k	{
5078		/** 1100 1001 movw %0, #%1 */
5079	8.26k	if (trace)
5080	0	{
5081	0	printf ("\033[33m%s\033[0m %02x\n",
5082	0	"/** 1100 1001 movw %0, #%1 */",
5083	0	op[0]);
5084	0	}
5085	8.26k	SYNTAX("movw %0, #%1");
5086	8.26k	#line 898 "rl78-decode.opc"
5087	8.26k	ID(mov); W(); DM(None, SADDR); SC(IMMU(2));
5088
5089	8.26k	}
5090	8.26k	break;
5091	6.79k	case 0xca:
5092	6.79k	{
5093		/** 1100 1010 mov %ea0, #%1 */
5094	6.79k	if (trace)
5095	0	{
5096	0	printf ("\033[33m%s\033[0m %02x\n",
5097	0	"/** 1100 1010 mov %ea0, #%1 */",
5098	0	op[0]);
5099	0	}
5100	6.79k	SYNTAX("mov %ea0, #%1");
5101	6.79k	#line 624 "rl78-decode.opc"
5102	6.79k	ID(mov); DM(DE, IMMU(1)); SC(IMMU(1));
5103
5104	6.79k	}
5105	6.79k	break;
5106	5.85k	case 0xcb:
5107	5.85k	{
5108		/** 1100 1011 movw %s0, #%1 */
5109	5.85k	if (trace)
5110	0	{
5111	0	printf ("\033[33m%s\033[0m %02x\n",
5112	0	"/** 1100 1011 movw %s0, #%1 */",
5113	0	op[0]);
5114	0	}
5115	5.85k	SYNTAX("movw %s0, #%1");
5116	5.85k	#line 904 "rl78-decode.opc"
5117	5.85k	ID(mov); W(); DM(None, SFR); SC(IMMU(2));
5118
5119	5.85k	}
5120	5.85k	break;
5121	10.7k	case 0xcc:
5122	10.7k	{
5123		/** 1100 1100 mov %ea0, #%1 */
5124	10.7k	if (trace)
5125	0	{
5126	0	printf ("\033[33m%s\033[0m %02x\n",
5127	0	"/** 1100 1100 mov %ea0, #%1 */",
5128	0	op[0]);
5129	0	}
5130	10.7k	SYNTAX("mov %ea0, #%1");
5131	10.7k	#line 636 "rl78-decode.opc"
5132	10.7k	ID(mov); DM(HL, IMMU(1)); SC(IMMU(1));
5133
5134	10.7k	}
5135	10.7k	break;
5136	11.0k	case 0xcd:
5137	11.0k	{
5138		/** 1100 1101 mov %0, #%1 */
5139	11.0k	if (trace)
5140	0	{
5141	0	printf ("\033[33m%s\033[0m %02x\n",
5142	0	"/** 1100 1101 mov %0, #%1 */",
5143	0	op[0]);
5144	0	}
5145	11.0k	SYNTAX("mov %0, #%1");
5146	11.0k	#line 750 "rl78-decode.opc"
5147	11.0k	ID(mov); DM(None, SADDR); SC(IMMU(1));
5148
5149	11.0k	}
5150	11.0k	break;
5151	12.0k	case 0xce:
5152	12.0k	{
5153		/** 1100 1110 mov %s0, #%1 */
5154	12.0k	if (trace)
5155	0	{
5156	0	printf ("\033[33m%s\033[0m %02x\n",
5157	0	"/** 1100 1110 mov %s0, #%1 */",
5158	0	op[0]);
5159	0	}
5160	12.0k	SYNTAX("mov %s0, #%1");
5161	12.0k	#line 756 "rl78-decode.opc"
5162	12.0k	op0 = SFR;
5163	12.0k	op1 = IMMU(1);
5164	12.0k	ID(mov); DM(None, op0); SC(op1);
5165	12.0k	if (op0 == 0xffffb && isa == RL78_ISA_G14)
5166	0	switch (op1)
5167	0	{
5168	0	case 0x01:
5169	0	rl78->syntax = "mulhu"; ID(mulhu);
5170	0	break;
5171	0	case 0x02:
5172	0	rl78->syntax = "mulh"; ID(mulh);
5173	0	break;
5174	0	case 0x03:
5175	0	rl78->syntax = "divhu"; ID(divhu);
5176	0	break;
5177	0	case 0x04:
5178	0	rl78->syntax = "divwu <old-encoding>"; ID(divwu);
5179	0	break;
5180	0	case 0x05:
5181	0	rl78->syntax = "machu"; ID(machu);
5182	0	break;
5183	0	case 0x06:
5184	0	rl78->syntax = "mach"; ID(mach);
5185	0	break;
5186	0	case 0x0b:
5187	0	rl78->syntax = "divwu"; ID(divwu);
5188	0	break;
5189	0	}
5190
5191	12.0k	}
5192	12.0k	break;
5193	12.0k	case 0xcf:
5194	7.01k	{
5195		/** 1100 1111 mov %e!0, #%1 */
5196	7.01k	if (trace)
5197	0	{
5198	0	printf ("\033[33m%s\033[0m %02x\n",
5199	0	"/** 1100 1111 mov %e!0, #%1 */",
5200	0	op[0]);
5201	0	}
5202	7.01k	SYNTAX("mov %e!0, #%1");
5203	7.01k	#line 615 "rl78-decode.opc"
5204	7.01k	ID(mov); DM(None, IMMU(2)); SC(IMMU(1));
5205
5206	7.01k	}
5207	7.01k	break;
5208	10.6k	case 0xd0:
5209	26.9k	case 0xd1:
5210	45.9k	case 0xd2:
5211	53.9k	case 0xd3:
5212	53.9k	{
5213		/** 1101 00rg cmp0 %0 */
5214	53.9k	#line 524 "rl78-decode.opc"
5215	53.9k	int rg AU = op[0] & 0x03;
5216	53.9k	if (trace)
5217	0	{
5218	0	printf ("\033[33m%s\033[0m %02x\n",
5219	0	"/** 1101 00rg cmp0 %0 */",
5220	0	op[0]);
5221	0	printf (" rg = 0x%x\n", rg);
5222	0	}
5223	53.9k	SYNTAX("cmp0 %0");
5224	53.9k	#line 524 "rl78-decode.opc"
5225	53.9k	ID(cmp); DRB(rg); SC(0); Fzac;
5226
5227	53.9k	}
5228	53.9k	break;
5229	6.77k	case 0xd4:
5230	6.77k	{
5231		/** 1101 0100 cmp0 %0 */
5232	6.77k	if (trace)
5233	0	{
5234	0	printf ("\033[33m%s\033[0m %02x\n",
5235	0	"/** 1101 0100 cmp0 %0 */",
5236	0	op[0]);
5237	0	}
5238	6.77k	SYNTAX("cmp0 %0");
5239	6.77k	#line 527 "rl78-decode.opc"
5240	6.77k	ID(cmp); DM(None, SADDR); SC(0); Fzac;
5241
5242		/----------------------------------------------------------------------/
5243
5244	6.77k	}
5245	6.77k	break;
5246	9.19k	case 0xd5:
5247	9.19k	{
5248		/** 1101 0101 cmp0 %e!0 */
5249	9.19k	if (trace)
5250	0	{
5251	0	printf ("\033[33m%s\033[0m %02x\n",
5252	0	"/** 1101 0101 cmp0 %e!0 */",
5253	0	op[0]);
5254	0	}
5255	9.19k	SYNTAX("cmp0 %e!0");
5256	9.19k	#line 521 "rl78-decode.opc"
5257	9.19k	ID(cmp); DM(None, IMMU(2)); SC(0); Fzac;
5258
5259	9.19k	}
5260	9.19k	break;
5261	9.03k	case 0xd6:
5262	9.03k	{
5263		/** 1101 0110 mulu x */
5264	9.03k	if (trace)
5265	0	{
5266	0	printf ("\033[33m%s\033[0m %02x\n",
5267	0	"/** 1101 0110 mulu x */",
5268	0	op[0]);
5269	0	}
5270	9.03k	SYNTAX("mulu x");
5271	9.03k	#line 912 "rl78-decode.opc"
5272	9.03k	ID(mulu);
5273
5274		/----------------------------------------------------------------------/
5275
5276	9.03k	}
5277	9.03k	break;
5278	14.2k	case 0xd7:
5279	14.2k	{
5280		/** 1101 0111 ret */
5281	14.2k	if (trace)
5282	0	{
5283	0	printf ("\033[33m%s\033[0m %02x\n",
5284	0	"/** 1101 0111 ret */",
5285	0	op[0]);
5286	0	}
5287	14.2k	SYNTAX("ret");
5288	14.2k	#line 1008 "rl78-decode.opc"
5289	14.2k	ID(ret);
5290
5291	14.2k	}
5292	14.2k	break;
5293	7.71k	case 0xd8:
5294	7.71k	{
5295		/** 1101 1000 mov %0, %1 */
5296	7.71k	if (trace)
5297	0	{
5298	0	printf ("\033[33m%s\033[0m %02x\n",
5299	0	"/** 1101 1000 mov %0, %1 */",
5300	0	op[0]);
5301	0	}
5302	7.71k	SYNTAX("mov %0, %1");
5303	7.71k	#line 717 "rl78-decode.opc"
5304	7.71k	ID(mov); DR(X); SM(None, SADDR);
5305
5306	7.71k	}
5307	7.71k	break;
5308	5.66k	case 0xd9:
5309	5.66k	{
5310		/** 1101 1001 mov %0, %e!1 */
5311	5.66k	if (trace)
5312	0	{
5313	0	printf ("\033[33m%s\033[0m %02x\n",
5314	0	"/** 1101 1001 mov %0, %e!1 */",
5315	0	op[0]);
5316	0	}
5317	5.66k	SYNTAX("mov %0, %e!1");
5318	5.66k	#line 714 "rl78-decode.opc"
5319	5.66k	ID(mov); DR(X); SM(None, IMMU(2));
5320
5321	5.66k	}
5322	5.66k	break;
5323	17.1k	case 0xda:
5324	30.6k	case 0xea:
5325	47.3k	case 0xfa:
5326	47.3k	{
5327		/** 11ra 1010 movw %0, %1 */
5328	47.3k	#line 895 "rl78-decode.opc"
5329	47.3k	int ra AU = (op[0] >> 4) & 0x03;
5330	47.3k	if (trace)
5331	0	{
5332	0	printf ("\033[33m%s\033[0m %02x\n",
5333	0	"/** 11ra 1010 movw %0, %1 */",
5334	0	op[0]);
5335	0	printf (" ra = 0x%x\n", ra);
5336	0	}
5337	47.3k	SYNTAX("movw %0, %1");
5338	47.3k	#line 895 "rl78-decode.opc"
5339	47.3k	ID(mov); W(); DRW(ra); SM(None, SADDR);
5340
5341	47.3k	}
5342	47.3k	break;
5343	5.50k	case 0xdb:
5344	15.1k	case 0xeb:
5345	26.1k	case 0xfb:
5346	26.1k	{
5347		/** 11ra 1011 movw %0, %es!1 */
5348	26.1k	#line 892 "rl78-decode.opc"
5349	26.1k	int ra AU = (op[0] >> 4) & 0x03;
5350	26.1k	if (trace)
5351	0	{
5352	0	printf ("\033[33m%s\033[0m %02x\n",
5353	0	"/** 11ra 1011 movw %0, %es!1 */",
5354	0	op[0]);
5355	0	printf (" ra = 0x%x\n", ra);
5356	0	}
5357	26.1k	SYNTAX("movw %0, %es!1");
5358	26.1k	#line 892 "rl78-decode.opc"
5359	26.1k	ID(mov); W(); DRW(ra); SM(None, IMMU(2));
5360
5361	26.1k	}
5362	26.1k	break;
5363	8.94k	case 0xdc:
5364	8.94k	{
5365		/** 1101 1100 bc $%a0 */
5366	8.94k	if (trace)
5367	0	{
5368	0	printf ("\033[33m%s\033[0m %02x\n",
5369	0	"/** 1101 1100 bc $%a0 */",
5370	0	op[0]);
5371	0	}
5372	8.94k	SYNTAX("bc $%a0");
5373	8.94k	#line 340 "rl78-decode.opc"
5374	8.94k	ID(branch_cond); DC(pc+IMMS(1)+2); SR(None); COND(C);
5375
5376	8.94k	}
5377	8.94k	break;
5378	7.11k	case 0xdd:
5379	7.11k	{
5380		/** 1101 1101 bz $%a0 */
5381	7.11k	if (trace)
5382	0	{
5383	0	printf ("\033[33m%s\033[0m %02x\n",
5384	0	"/** 1101 1101 bz $%a0 */",
5385	0	op[0]);
5386	0	}
5387	7.11k	SYNTAX("bz $%a0");
5388	7.11k	#line 352 "rl78-decode.opc"
5389	7.11k	ID(branch_cond); DC(pc+IMMS(1)+2); SR(None); COND(Z);
5390
5391	7.11k	}
5392	7.11k	break;
5393	8.73k	case 0xde:
5394	8.73k	{
5395		/** 1101 1110 bnc $%a0 */
5396	8.73k	if (trace)
5397	0	{
5398	0	printf ("\033[33m%s\033[0m %02x\n",
5399	0	"/** 1101 1110 bnc $%a0 */",
5400	0	op[0]);
5401	0	}
5402	8.73k	SYNTAX("bnc $%a0");
5403	8.73k	#line 343 "rl78-decode.opc"
5404	8.73k	ID(branch_cond); DC(pc+IMMS(1)+2); SR(None); COND(NC);
5405
5406	8.73k	}
5407	8.73k	break;
5408	10.1k	case 0xdf:
5409	10.1k	{
5410		/** 1101 1111 bnz $%a0 */
5411	10.1k	if (trace)
5412	0	{
5413	0	printf ("\033[33m%s\033[0m %02x\n",
5414	0	"/** 1101 1111 bnz $%a0 */",
5415	0	op[0]);
5416	0	}
5417	10.1k	SYNTAX("bnz $%a0");
5418	10.1k	#line 355 "rl78-decode.opc"
5419	10.1k	ID(branch_cond); DC(pc+IMMS(1)+2); SR(None); COND(NZ);
5420
5421		/----------------------------------------------------------------------/
5422
5423	10.1k	}
5424	10.1k	break;
5425	17.3k	case 0xe0:
5426	34.6k	case 0xe1:
5427	49.8k	case 0xe2:
5428	62.0k	case 0xe3:
5429	62.0k	{
5430		/** 1110 00rg oneb %0 */
5431	62.0k	#line 930 "rl78-decode.opc"
5432	62.0k	int rg AU = op[0] & 0x03;
5433	62.0k	if (trace)
5434	0	{
5435	0	printf ("\033[33m%s\033[0m %02x\n",
5436	0	"/** 1110 00rg oneb %0 */",
5437	0	op[0]);
5438	0	printf (" rg = 0x%x\n", rg);
5439	0	}
5440	62.0k	SYNTAX("oneb %0");
5441	62.0k	#line 930 "rl78-decode.opc"
5442	62.0k	ID(mov); DRB(rg); SC(1);
5443
5444	62.0k	}
5445	62.0k	break;
5446	10.5k	case 0xe4:
5447	10.5k	{
5448		/** 1110 0100 oneb %0 */
5449	10.5k	if (trace)
5450	0	{
5451	0	printf ("\033[33m%s\033[0m %02x\n",
5452	0	"/** 1110 0100 oneb %0 */",
5453	0	op[0]);
5454	0	}
5455	10.5k	SYNTAX("oneb %0");
5456	10.5k	#line 933 "rl78-decode.opc"
5457	10.5k	ID(mov); DM(None, SADDR); SC(1);
5458
5459		/----------------------------------------------------------------------/
5460
5461	10.5k	}
5462	10.5k	break;
5463	8.24k	case 0xe5:
5464	8.24k	{
5465		/** 1110 0101 oneb %e!0 */
5466	8.24k	if (trace)
5467	0	{
5468	0	printf ("\033[33m%s\033[0m %02x\n",
5469	0	"/** 1110 0101 oneb %e!0 */",
5470	0	op[0]);
5471	0	}
5472	8.24k	SYNTAX("oneb %e!0");
5473	8.24k	#line 927 "rl78-decode.opc"
5474	8.24k	ID(mov); DM(None, IMMU(2)); SC(1);
5475
5476	8.24k	}
5477	8.24k	break;
5478	8.63k	case 0xe6:
5479	8.63k	{
5480		/** 1110 0110 onew %0 */
5481	8.63k	if (trace)
5482	0	{
5483	0	printf ("\033[33m%s\033[0m %02x\n",
5484	0	"/** 1110 0110 onew %0 */",
5485	0	op[0]);
5486	0	}
5487	8.63k	SYNTAX("onew %0");
5488	8.63k	#line 938 "rl78-decode.opc"
5489	8.63k	ID(mov); DR(AX); SC(1);
5490
5491	8.63k	}
5492	8.63k	break;
5493	11.4k	case 0xe7:
5494	11.4k	{
5495		/** 1110 0111 onew %0 */
5496	11.4k	if (trace)
5497	0	{
5498	0	printf ("\033[33m%s\033[0m %02x\n",
5499	0	"/** 1110 0111 onew %0 */",
5500	0	op[0]);
5501	0	}
5502	11.4k	SYNTAX("onew %0");
5503	11.4k	#line 941 "rl78-decode.opc"
5504	11.4k	ID(mov); DR(BC); SC(1);
5505
5506		/----------------------------------------------------------------------/
5507
5508	11.4k	}
5509	11.4k	break;
5510	14.9k	case 0xe8:
5511	14.9k	{
5512		/** 1110 1000 mov %0, %1 */
5513	14.9k	if (trace)
5514	0	{
5515	0	printf ("\033[33m%s\033[0m %02x\n",
5516	0	"/** 1110 1000 mov %0, %1 */",
5517	0	op[0]);
5518	0	}
5519	14.9k	SYNTAX("mov %0, %1");
5520	14.9k	#line 705 "rl78-decode.opc"
5521	14.9k	ID(mov); DR(B); SM(None, SADDR);
5522
5523	14.9k	}
5524	14.9k	break;
5525	7.10k	case 0xe9:
5526	7.10k	{
5527		/** 1110 1001 mov %0, %e!1 */
5528	7.10k	if (trace)
5529	0	{
5530	0	printf ("\033[33m%s\033[0m %02x\n",
5531	0	"/** 1110 1001 mov %0, %e!1 */",
5532	0	op[0]);
5533	0	}
5534	7.10k	SYNTAX("mov %0, %e!1");
5535	7.10k	#line 699 "rl78-decode.opc"
5536	7.10k	ID(mov); DR(B); SM(None, IMMU(2));
5537
5538	7.10k	}
5539	7.10k	break;
5540	8.02k	case 0xec:
5541	8.02k	{
5542		/** 1110 1100 br !%!a0 */
5543	8.02k	if (trace)
5544	0	{
5545	0	printf ("\033[33m%s\033[0m %02x\n",
5546	0	"/** 1110 1100 br !%!a0 */",
5547	0	op[0]);
5548	0	}
5549	8.02k	SYNTAX("br !%!a0");
5550	8.02k	#line 374 "rl78-decode.opc"
5551	8.02k	ID(branch); DC(IMMU(3));
5552
5553	8.02k	}
5554	8.02k	break;
5555	7.84k	case 0xed:
5556	7.84k	{
5557		/** 1110 1101 br %!a0 */
5558	7.84k	if (trace)
5559	0	{
5560	0	printf ("\033[33m%s\033[0m %02x\n",
5561	0	"/** 1110 1101 br %!a0 */",
5562	0	op[0]);
5563	0	}
5564	7.84k	SYNTAX("br %!a0");
5565	7.84k	#line 377 "rl78-decode.opc"
5566	7.84k	ID(branch); DC(IMMU(2));
5567
5568	7.84k	}
5569	7.84k	break;
5570	15.4k	case 0xee:
5571	15.4k	{
5572		/** 1110 1110 br $%!a0 */
5573	15.4k	if (trace)
5574	0	{
5575	0	printf ("\033[33m%s\033[0m %02x\n",
5576	0	"/** 1110 1110 br $%!a0 */",
5577	0	op[0]);
5578	0	}
5579	15.4k	SYNTAX("br $%!a0");
5580	15.4k	#line 380 "rl78-decode.opc"
5581	15.4k	ID(branch); DC(pc+IMMS(2)+3);
5582
5583	15.4k	}
5584	15.4k	break;
5585	13.6k	case 0xef:
5586	13.6k	{
5587		/** 1110 1111 br $%a0 */
5588	13.6k	if (trace)
5589	0	{
5590	0	printf ("\033[33m%s\033[0m %02x\n",
5591	0	"/** 1110 1111 br $%a0 */",
5592	0	op[0]);
5593	0	}
5594	13.6k	SYNTAX("br $%a0");
5595	13.6k	#line 383 "rl78-decode.opc"
5596	13.6k	ID(branch); DC(pc+IMMS(1)+2);
5597
5598	13.6k	}
5599	13.6k	break;
5600	13.6k	case 0xf0:
5601	29.3k	case 0xf1:
5602	46.3k	case 0xf2:
5603	66.4k	case 0xf3:
5604	66.4k	{
5605		/** 1111 00rg clrb %0 */
5606	66.4k	#line 470 "rl78-decode.opc"
5607	66.4k	int rg AU = op[0] & 0x03;
5608	66.4k	if (trace)
5609	0	{
5610	0	printf ("\033[33m%s\033[0m %02x\n",
5611	0	"/** 1111 00rg clrb %0 */",
5612	0	op[0]);
5613	0	printf (" rg = 0x%x\n", rg);
5614	0	}
5615	66.4k	SYNTAX("clrb %0");
5616	66.4k	#line 470 "rl78-decode.opc"
5617	66.4k	ID(mov); DRB(rg); SC(0);
5618
5619	66.4k	}
5620	66.4k	break;
5621	13.3k	case 0xf4:
5622	13.3k	{
5623		/** 1111 0100 clrb %0 */
5624	13.3k	if (trace)
5625	0	{
5626	0	printf ("\033[33m%s\033[0m %02x\n",
5627	0	"/** 1111 0100 clrb %0 */",
5628	0	op[0]);
5629	0	}
5630	13.3k	SYNTAX("clrb %0");
5631	13.3k	#line 473 "rl78-decode.opc"
5632	13.3k	ID(mov); DM(None, SADDR); SC(0);
5633
5634		/----------------------------------------------------------------------/
5635
5636	13.3k	}
5637	13.3k	break;
5638	8.99k	case 0xf5:
5639	8.99k	{
5640		/** 1111 0101 clrb %e!0 */
5641	8.99k	if (trace)
5642	0	{
5643	0	printf ("\033[33m%s\033[0m %02x\n",
5644	0	"/** 1111 0101 clrb %e!0 */",
5645	0	op[0]);
5646	0	}
5647	8.99k	SYNTAX("clrb %e!0");
5648	8.99k	#line 467 "rl78-decode.opc"
5649	8.99k	ID(mov); DM(None, IMMU(2)); SC(0);
5650
5651	8.99k	}
5652	8.99k	break;
5653	10.0k	case 0xf6:
5654	10.0k	{
5655		/** 1111 0110 clrw %0 */
5656	10.0k	if (trace)
5657	0	{
5658	0	printf ("\033[33m%s\033[0m %02x\n",
5659	0	"/** 1111 0110 clrw %0 */",
5660	0	op[0]);
5661	0	}
5662	10.0k	SYNTAX("clrw %0");
5663	10.0k	#line 478 "rl78-decode.opc"
5664	10.0k	ID(mov); DR(AX); SC(0);
5665
5666	10.0k	}
5667	10.0k	break;
5668	15.6k	case 0xf7:
5669	15.6k	{
5670		/** 1111 0111 clrw %0 */
5671	15.6k	if (trace)
5672	0	{
5673	0	printf ("\033[33m%s\033[0m %02x\n",
5674	0	"/** 1111 0111 clrw %0 */",
5675	0	op[0]);
5676	0	}
5677	15.6k	SYNTAX("clrw %0");
5678	15.6k	#line 481 "rl78-decode.opc"
5679	15.6k	ID(mov); DR(BC); SC(0);
5680
5681		/----------------------------------------------------------------------/
5682
5683	15.6k	}
5684	15.6k	break;
5685	14.4k	case 0xf8:
5686	14.4k	{
5687		/** 1111 1000 mov %0, %1 */
5688	14.4k	if (trace)
5689	0	{
5690	0	printf ("\033[33m%s\033[0m %02x\n",
5691	0	"/** 1111 1000 mov %0, %1 */",
5692	0	op[0]);
5693	0	}
5694	14.4k	SYNTAX("mov %0, %1");
5695	14.4k	#line 711 "rl78-decode.opc"
5696	14.4k	ID(mov); DR(C); SM(None, SADDR);
5697
5698	14.4k	}
5699	14.4k	break;
5700	13.4k	case 0xf9:
5701	13.4k	{
5702		/** 1111 1001 mov %0, %e!1 */
5703	13.4k	if (trace)
5704	0	{
5705	0	printf ("\033[33m%s\033[0m %02x\n",
5706	0	"/** 1111 1001 mov %0, %e!1 */",
5707	0	op[0]);
5708	0	}
5709	13.4k	SYNTAX("mov %0, %e!1");
5710	13.4k	#line 708 "rl78-decode.opc"
5711	13.4k	ID(mov); DR(C); SM(None, IMMU(2));
5712
5713	13.4k	}
5714	13.4k	break;
5715	15.1k	case 0xfc:
5716	15.1k	{
5717		/** 1111 1100 call !%!a0 */
5718	15.1k	if (trace)
5719	0	{
5720	0	printf ("\033[33m%s\033[0m %02x\n",
5721	0	"/** 1111 1100 call !%!a0 */",
5722	0	op[0]);
5723	0	}
5724	15.1k	SYNTAX("call !%!a0");
5725	15.1k	#line 427 "rl78-decode.opc"
5726	15.1k	ID(call); DC(IMMU(3));
5727
5728	15.1k	}
5729	15.1k	break;
5730	18.1k	case 0xfd:
5731	18.1k	{
5732		/** 1111 1101 call %!a0 */
5733	18.1k	if (trace)
5734	0	{
5735	0	printf ("\033[33m%s\033[0m %02x\n",
5736	0	"/** 1111 1101 call %!a0 */",
5737	0	op[0]);
5738	0	}
5739	18.1k	SYNTAX("call %!a0");
5740	18.1k	#line 430 "rl78-decode.opc"
5741	18.1k	ID(call); DC(IMMU(2));
5742
5743	18.1k	}
5744	18.1k	break;
5745	18.9k	case 0xfe:
5746	18.9k	{
5747		/** 1111 1110 call $%!a0 */
5748	18.9k	if (trace)
5749	0	{
5750	0	printf ("\033[33m%s\033[0m %02x\n",
5751	0	"/** 1111 1110 call $%!a0 */",
5752	0	op[0]);
5753	0	}
5754	18.9k	SYNTAX("call $%!a0");
5755	18.9k	#line 433 "rl78-decode.opc"
5756	18.9k	ID(call); DC(pc+IMMS(2)+3);
5757
5758	18.9k	}
5759	18.9k	break;
5760	581k	case 0xff:
5761	581k	{
5762		/** 1111 1111 brk1 */
5763	581k	if (trace)
5764	0	{
5765	0	printf ("\033[33m%s\033[0m %02x\n",
5766	0	"/** 1111 1111 brk1 */",
5767	0	op[0]);
5768	0	}
5769	581k	SYNTAX("brk1");
5770	581k	#line 391 "rl78-decode.opc"
5771	581k	ID(break);
5772
5773	581k	}
5774	581k	break;
5775	6.64M	}
5776	5.93M	#line 1296 "rl78-decode.opc"
5777
5778	5.93M	return rl78->n_bytes;
5779	6.64M	}

Coverage Report

Created: 2026-07-25 10:20