OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.3/] [opcodes/] [z8k-opc.h] - Blame information for rev 1777

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 1181 sfurman 
                        /* THIS FILE IS AUTOMAGICALLY GENERATED, DON'T EDIT IT */
2 
#define ARG_MASK 0x0f
3 
#define ARG_SRC 0x01
4 
#define ARG_DST 0x02
5 
#define ARG_RS 0x01
6 
#define ARG_RD 0x02
7 
#define ARG_RA 0x03
8 
#define ARG_RB 0x04
9 
#define ARG_RR 0x05
10 
#define ARG_RX 0x06
11 
#define ARG_IMM4 0x01
12 
#define ARG_IMM8 0x02
13 
#define ARG_IMM16 0x03
14 
#define ARG_IMM32 0x04
15 
#define ARG_IMMN 0x05
16 
#define ARG_IMMNMINUS1 0x05
17 
#define ARG_IMM_1 0x06
18 
#define ARG_IMM_2 0x07
19 
#define ARG_DISP16 0x08
20 
#define ARG_NIM8 0x09
21 
#define ARG_IMM2 0x0a
22 
#define ARG_IMM1OR2 0x0b
23 
#define ARG_DISP12 0x0b
24 
#define ARG_NIM4 0x0c
25 
#define ARG_DISP8 0x0c
26 
#define ARG_IMM4M1 0x0d
27 
#define CLASS_MASK 0x1fff0
28 
#define CLASS_X 0x10
29 
#define CLASS_BA 0x20
30 
#define CLASS_DA 0x30
31 
#define CLASS_BX 0x40
32 
#define CLASS_DISP 0x50
33 
#define CLASS_IMM 0x60
34 
#define CLASS_CC 0x70
35 
#define CLASS_CTRL 0x80
36 
#define CLASS_IGNORE 0x90
37 
#define CLASS_ADDRESS 0xd0
38 
#define CLASS_0CCC 0xe0
39 
#define CLASS_1CCC 0xf0
40 
#define CLASS_0DISP7 0x100
41 
#define CLASS_1DISP7 0x200
42 
#define CLASS_01II 0x300
43 
#define CLASS_00II 0x400
44 
#define CLASS_BIT 0x500
45 
#define CLASS_FLAGS 0x600
46 
#define CLASS_IR 0x700
47 
#define CLASS_DISP8 0x800
48 
#define CLASS_BIT_1OR2 0x900
49 
#define CLASS_REG 0x7000
50 
#define CLASS_REG_BYTE 0x2000
51 
#define CLASS_REG_WORD 0x3000
52 
#define CLASS_REG_QUAD 0x4000
53 
#define CLASS_REG_LONG 0x5000
54 
#define CLASS_REGN0 0x8000
55 
#define CLASS_PR 0x10000
56 
#define OPC_adc 0
57 
#define OPC_adcb 1
58 
#define OPC_add 2
59 
#define OPC_addb 3
60 
#define OPC_addl 4
61 
#define OPC_and 5
62 
#define OPC_andb 6
63 
#define OPC_bit 7
64 
#define OPC_bitb 8
65 
#define OPC_call 9
66 
#define OPC_calr 10
67 
#define OPC_clr 11
68 
#define OPC_clrb 12
69 
#define OPC_com 13
70 
#define OPC_comb 14
71 
#define OPC_comflg 15
72 
#define OPC_cp 16
73 
#define OPC_cpb 17
74 
#define OPC_cpd 18
75 
#define OPC_cpdb 19
76 
#define OPC_cpdr 20
77 
#define OPC_cpdrb 21
78 
#define OPC_cpi 22
79 
#define OPC_cpib 23
80 
#define OPC_cpir 24
81 
#define OPC_cpirb 25
82 
#define OPC_cpl 26
83 
#define OPC_cpsd 27
84 
#define OPC_cpsdb 28
85 
#define OPC_cpsdr 29
86 
#define OPC_cpsdrb 30
87 
#define OPC_cpsi 31
88 
#define OPC_cpsib 32
89 
#define OPC_cpsir 33
90 
#define OPC_cpsirb 34
91 
#define OPC_dab 35
92 
#define OPC_dbjnz 36
93 
#define OPC_dec 37
94 
#define OPC_decb 38
95 
#define OPC_di 39
96 
#define OPC_div 40
97 
#define OPC_divl 41
98 
#define OPC_djnz 42
99 
#define OPC_ei 43
100 
#define OPC_ex 44
101 
#define OPC_exb 45
102 
#define OPC_exts 46
103 
#define OPC_extsb 47
104 
#define OPC_extsl 48
105 
#define OPC_halt 49
106 
#define OPC_in 50
107 
#define OPC_inb 51
108 
#define OPC_inc 52
109 
#define OPC_incb 53
110 
#define OPC_ind 54
111 
#define OPC_indb 55
112 
#define OPC_inib 56
113 
#define OPC_inibr 57
114 
#define OPC_iret 58
115 
#define OPC_jp 59
116 
#define OPC_jr 60
117 
#define OPC_ld 61
118 
#define OPC_lda 62
119 
#define OPC_ldar 63
120 
#define OPC_ldb 64
121 
#define OPC_ldctl 65
122 
#define OPC_ldir 66
123 
#define OPC_ldirb 67
124 
#define OPC_ldk 68
125 
#define OPC_ldl 69
126 
#define OPC_ldm 70
127 
#define OPC_ldps 71
128 
#define OPC_ldr 72
129 
#define OPC_ldrb 73
130 
#define OPC_ldrl 74
131 
#define OPC_mbit 75
132 
#define OPC_mreq 76
133 
#define OPC_mres 77
134 
#define OPC_mset 78
135 
#define OPC_mult 79
136 
#define OPC_multl 80
137 
#define OPC_neg 81
138 
#define OPC_negb 82
139 
#define OPC_nop 83
140 
#define OPC_or 84
141 
#define OPC_orb 85
142 
#define OPC_out 86
143 
#define OPC_outb 87
144 
#define OPC_outd 88
145 
#define OPC_outdb 89
146 
#define OPC_outib 90
147 
#define OPC_outibr 91
148 
#define OPC_pop 92
149 
#define OPC_popl 93
150 
#define OPC_push 94
151 
#define OPC_pushl 95
152 
#define OPC_res 96
153 
#define OPC_resb 97
154 
#define OPC_resflg 98
155 
#define OPC_ret 99
156 
#define OPC_rl 100
157 
#define OPC_rlb 101
158 
#define OPC_rlc 102
159 
#define OPC_rlcb 103
160 
#define OPC_rldb 104
161 
#define OPC_rr 105
162 
#define OPC_rrb 106
163 
#define OPC_rrc 107
164 
#define OPC_rrcb 108
165 
#define OPC_rrdb 109
166 
#define OPC_sbc 110
167 
#define OPC_sbcb 111
168 
#define OPC_sda 112
169 
#define OPC_sdab 113
170 
#define OPC_sdal 114
171 
#define OPC_sdl 115
172 
#define OPC_sdlb 116
173 
#define OPC_sdll 117
174 
#define OPC_set 118
175 
#define OPC_setb 119
176 
#define OPC_setflg 120
177 
#define OPC_sinb 121
178 
#define OPC_sind 122
179 
#define OPC_sindb 123
180 
#define OPC_sinib 124
181 
#define OPC_sinibr 125
182 
#define OPC_sla 126
183 
#define OPC_slab 127
184 
#define OPC_slal 128
185 
#define OPC_sll 129
186 
#define OPC_sllb 130
187 
#define OPC_slll 131
188 
#define OPC_sout 132
189 
#define OPC_soutb 133
190 
#define OPC_soutd 134
191 
#define OPC_soutdb 135
192 
#define OPC_soutib 136
193 
#define OPC_soutibr 137
194 
#define OPC_sra 138
195 
#define OPC_srab 139
196 
#define OPC_sral 140
197 
#define OPC_srl 141
198 
#define OPC_srlb 142
199 
#define OPC_srll 143
200 
#define OPC_sub 144
201 
#define OPC_subb 145
202 
#define OPC_subl 146
203 
#define OPC_tcc 147
204 
#define OPC_tccb 148
205 
#define OPC_test 149
206 
#define OPC_testb 150
207 
#define OPC_testl 151
208 
#define OPC_trdb 152
209 
#define OPC_trdrb 153
210 
#define OPC_trib 154
211 
#define OPC_trirb 155
212 
#define OPC_trtdrb 156
213 
#define OPC_trtib 157
214 
#define OPC_trtirb 158
215 
#define OPC_trtrb 159
216 
#define OPC_tset 160
217 
#define OPC_tsetb 161
218 
#define OPC_xor 162
219 
#define OPC_xorb 163
220 
#define OPC_ldd  164
221 
#define OPC_lddb  165
222 
#define OPC_lddr  166
223 
#define OPC_lddrb 167
224 
#define OPC_ldi  168
225 
#define OPC_ldib 169
226 
#define OPC_sc   170
227 
#define OPC_bpt   171
228 
#define OPC_ext0e 172
229 
#define OPC_ext0f 172
230 
#define OPC_ext8e 172
231 
#define OPC_ext8f 172
232 
#define OPC_rsvd36 172
233 
#define OPC_rsvd38 172
234 
#define OPC_rsvd78 172
235 
#define OPC_rsvd7e 172
236 
#define OPC_rsvd9d 172
237 
#define OPC_rsvd9f 172
238 
#define OPC_rsvdb9 172
239 
#define OPC_rsvdbf 172
240 
#define OPC_outi 173
241 
#define OPC_ldctlb 174
242 
#define OPC_sin 175
243 
#define OPC_trtdb 176
244 
typedef struct {
245 
#ifdef NICENAMES
246 
char *nicename;
247 
int type;
248 
int cycles;
249 
int flags;
250 
#endif
251 
char *name;
252 
unsigned char opcode;
253 
void (*func) PARAMS ((void));
254 
unsigned int arg_info[4];
255 
unsigned int byte_info[10];
256 
int noperands;
257 
int length;
258 
int idx;
259 
} opcode_entry_type;
260 
#ifdef DEFINE_TABLE
261 
opcode_entry_type z8k_table[] = {
262 
 
263 
 
264 
/* 1011 0101 ssss dddd *** adc rd,rs */
265 
{
266 
#ifdef NICENAMES
267 
"adc rd,rs",16,5,
268 
0x3c,
269 
#endif
270 
"adc",OPC_adc,0,{CLASS_REG_WORD+(ARG_RD),CLASS_REG_WORD+(ARG_RS),},
271 
        {CLASS_BIT+0xb,CLASS_BIT+5,CLASS_REG+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,0},
272 
 
273 
 
274 
/* 1011 0100 ssss dddd *** adcb rbd,rbs */
275 
{
276 
#ifdef NICENAMES
277 
"adcb rbd,rbs",8,5,
278 
0x3f,
279 
#endif
280 
"adcb",OPC_adcb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_REG_BYTE+(ARG_RS),},
281 
        {CLASS_BIT+0xb,CLASS_BIT+4,CLASS_REG+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,1},
282 
 
283 
 
284 
/* 0000 0001 ssN0 dddd *** add rd,@rs */
285 
{
286 
#ifdef NICENAMES
287 
"add rd,@rs",16,7,
288 
0x3c,
289 
#endif
290 
"add",OPC_add,0,{CLASS_REG_WORD+(ARG_RD),CLASS_IR+(ARG_RS),},
291 
        {CLASS_BIT+0,CLASS_BIT+1,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,2},
292 
 
293 
 
294 
/* 0100 0001 0000 dddd address_src *** add rd,address_src */
295 
{
296 
#ifdef NICENAMES
297 
"add rd,address_src",16,9,
298 
0x3c,
299 
#endif
300 
"add",OPC_add,0,{CLASS_REG_WORD+(ARG_RD),CLASS_DA+(ARG_SRC),},
301 
        {CLASS_BIT+4,CLASS_BIT+1,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,3},
302 
 
303 
 
304 
/* 0100 0001 ssN0 dddd address_src *** add rd,address_src(rs) */
305 
{
306 
#ifdef NICENAMES
307 
"add rd,address_src(rs)",16,10,
308 
0x3c,
309 
#endif
310 
"add",OPC_add,0,{CLASS_REG_WORD+(ARG_RD),CLASS_X+(ARG_RS),},
311 
        {CLASS_BIT+4,CLASS_BIT+1,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,4},
312 
 
313 
 
314 
/* 0000 0001 0000 dddd imm16 *** add rd,imm16 */
315 
{
316 
#ifdef NICENAMES
317 
"add rd,imm16",16,7,
318 
0x3c,
319 
#endif
320 
"add",OPC_add,0,{CLASS_REG_WORD+(ARG_RD),CLASS_IMM+(ARG_IMM16),},
321 
        {CLASS_BIT+0,CLASS_BIT+1,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_IMM+(ARG_IMM16),0,0,0,0,},2,4,5},
322 
 
323 
 
324 
/* 1000 0001 ssss dddd *** add rd,rs */
325 
{
326 
#ifdef NICENAMES
327 
"add rd,rs",16,4,
328 
0x3c,
329 
#endif
330 
"add",OPC_add,0,{CLASS_REG_WORD+(ARG_RD),CLASS_REG_WORD+(ARG_RS),},
331 
        {CLASS_BIT+8,CLASS_BIT+1,CLASS_REG+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,6},
332 
 
333 
 
334 
/* 0000 0000 ssN0 dddd *** addb rbd,@rs */
335 
{
336 
#ifdef NICENAMES
337 
"addb rbd,@rs",8,7,
338 
0x3f,
339 
#endif
340 
"addb",OPC_addb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_IR+(ARG_RS),},
341 
        {CLASS_BIT+0,CLASS_BIT+0,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,7},
342 
 
343 
 
344 
/* 0100 0000 0000 dddd address_src *** addb rbd,address_src */
345 
{
346 
#ifdef NICENAMES
347 
"addb rbd,address_src",8,9,
348 
0x3f,
349 
#endif
350 
"addb",OPC_addb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_DA+(ARG_SRC),},
351 
        {CLASS_BIT+4,CLASS_BIT+0,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,8},
352 
 
353 
 
354 
/* 0100 0000 ssN0 dddd address_src *** addb rbd,address_src(rs) */
355 
{
356 
#ifdef NICENAMES
357 
"addb rbd,address_src(rs)",8,10,
358 
0x3f,
359 
#endif
360 
"addb",OPC_addb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_X+(ARG_RS),},
361 
        {CLASS_BIT+4,CLASS_BIT+0,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,9},
362 
 
363 
 
364 
/* 0000 0000 0000 dddd imm8 imm8 *** addb rbd,imm8 */
365 
{
366 
#ifdef NICENAMES
367 
"addb rbd,imm8",8,7,
368 
0x3f,
369 
#endif
370 
"addb",OPC_addb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_IMM+(ARG_IMM8),},
371 
        {CLASS_BIT+0,CLASS_BIT+0,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_IMM+(ARG_IMM8),CLASS_IMM+(ARG_IMM8),0,0,0,},2,4,10},
372 
 
373 
 
374 
/* 1000 0000 ssss dddd *** addb rbd,rbs */
375 
{
376 
#ifdef NICENAMES
377 
"addb rbd,rbs",8,4,
378 
0x3f,
379 
#endif
380 
"addb",OPC_addb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_REG_BYTE+(ARG_RS),},
381 
        {CLASS_BIT+8,CLASS_BIT+0,CLASS_REG+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,11},
382 
 
383 
 
384 
/* 0001 0110 ssN0 dddd *** addl rrd,@rs */
385 
{
386 
#ifdef NICENAMES
387 
"addl rrd,@rs",32,14,
388 
0x3c,
389 
#endif
390 
"addl",OPC_addl,0,{CLASS_REG_LONG+(ARG_RD),CLASS_IR+(ARG_RS),},
391 
        {CLASS_BIT+1,CLASS_BIT+6,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,12},
392 
 
393 
 
394 
/* 0101 0110 0000 dddd address_src *** addl rrd,address_src */
395 
{
396 
#ifdef NICENAMES
397 
"addl rrd,address_src",32,15,
398 
0x3c,
399 
#endif
400 
"addl",OPC_addl,0,{CLASS_REG_LONG+(ARG_RD),CLASS_DA+(ARG_SRC),},
401 
        {CLASS_BIT+5,CLASS_BIT+6,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,13},
402 
 
403 
 
404 
/* 0101 0110 ssN0 dddd address_src *** addl rrd,address_src(rs) */
405 
{
406 
#ifdef NICENAMES
407 
"addl rrd,address_src(rs)",32,16,
408 
0x3c,
409 
#endif
410 
"addl",OPC_addl,0,{CLASS_REG_LONG+(ARG_RD),CLASS_X+(ARG_RS),},
411 
        {CLASS_BIT+5,CLASS_BIT+6,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,14},
412 
 
413 
 
414 
/* 0001 0110 0000 dddd imm32 *** addl rrd,imm32 */
415 
{
416 
#ifdef NICENAMES
417 
"addl rrd,imm32",32,14,
418 
0x3c,
419 
#endif
420 
"addl",OPC_addl,0,{CLASS_REG_LONG+(ARG_RD),CLASS_IMM+(ARG_IMM32),},
421 
        {CLASS_BIT+1,CLASS_BIT+6,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_IMM+(ARG_IMM32),0,0,0,0,},2,6,15},
422 
 
423 
 
424 
/* 1001 0110 ssss dddd *** addl rrd,rrs */
425 
{
426 
#ifdef NICENAMES
427 
"addl rrd,rrs",32,8,
428 
0x3c,
429 
#endif
430 
"addl",OPC_addl,0,{CLASS_REG_LONG+(ARG_RD),CLASS_REG_LONG+(ARG_RS),},
431 
        {CLASS_BIT+9,CLASS_BIT+6,CLASS_REG+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,16},
432 
 
433 
 
434 
/* 0000 0111 ssN0 dddd *** and rd,@rs */
435 
{
436 
#ifdef NICENAMES
437 
"and rd,@rs",16,7,
438 
0x18,
439 
#endif
440 
"and",OPC_and,0,{CLASS_REG_WORD+(ARG_RD),CLASS_IR+(ARG_RS),},
441 
        {CLASS_BIT+0,CLASS_BIT+7,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,17},
442 
 
443 
 
444 
/* 0100 0111 0000 dddd address_src *** and rd,address_src */
445 
{
446 
#ifdef NICENAMES
447 
"and rd,address_src",16,9,
448 
0x18,
449 
#endif
450 
"and",OPC_and,0,{CLASS_REG_WORD+(ARG_RD),CLASS_DA+(ARG_SRC),},
451 
        {CLASS_BIT+4,CLASS_BIT+7,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,18},
452 
 
453 
 
454 
/* 0100 0111 ssN0 dddd address_src *** and rd,address_src(rs) */
455 
{
456 
#ifdef NICENAMES
457 
"and rd,address_src(rs)",16,10,
458 
0x18,
459 
#endif
460 
"and",OPC_and,0,{CLASS_REG_WORD+(ARG_RD),CLASS_X+(ARG_RS),},
461 
        {CLASS_BIT+4,CLASS_BIT+7,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,19},
462 
 
463 
 
464 
/* 0000 0111 0000 dddd imm16 *** and rd,imm16 */
465 
{
466 
#ifdef NICENAMES
467 
"and rd,imm16",16,7,
468 
0x18,
469 
#endif
470 
"and",OPC_and,0,{CLASS_REG_WORD+(ARG_RD),CLASS_IMM+(ARG_IMM16),},
471 
        {CLASS_BIT+0,CLASS_BIT+7,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_IMM+(ARG_IMM16),0,0,0,0,},2,4,20},
472 
 
473 
 
474 
/* 1000 0111 ssss dddd *** and rd,rs */
475 
{
476 
#ifdef NICENAMES
477 
"and rd,rs",16,4,
478 
0x18,
479 
#endif
480 
"and",OPC_and,0,{CLASS_REG_WORD+(ARG_RD),CLASS_REG_WORD+(ARG_RS),},
481 
        {CLASS_BIT+8,CLASS_BIT+7,CLASS_REG+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,21},
482 
 
483 
 
484 
/* 0000 0110 ssN0 dddd *** andb rbd,@rs */
485 
{
486 
#ifdef NICENAMES
487 
"andb rbd,@rs",8,7,
488 
0x1c,
489 
#endif
490 
"andb",OPC_andb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_IR+(ARG_RS),},
491 
        {CLASS_BIT+0,CLASS_BIT+6,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,22},
492 
 
493 
 
494 
/* 0100 0110 0000 dddd address_src *** andb rbd,address_src */
495 
{
496 
#ifdef NICENAMES
497 
"andb rbd,address_src",8,9,
498 
0x1c,
499 
#endif
500 
"andb",OPC_andb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_DA+(ARG_SRC),},
501 
        {CLASS_BIT+4,CLASS_BIT+6,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,23},
502 
 
503 
 
504 
/* 0100 0110 ssN0 dddd address_src *** andb rbd,address_src(rs) */
505 
{
506 
#ifdef NICENAMES
507 
"andb rbd,address_src(rs)",8,10,
508 
0x1c,
509 
#endif
510 
"andb",OPC_andb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_X+(ARG_RS),},
511 
        {CLASS_BIT+4,CLASS_BIT+6,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,24},
512 
 
513 
 
514 
/* 0000 0110 0000 dddd imm8 imm8 *** andb rbd,imm8 */
515 
{
516 
#ifdef NICENAMES
517 
"andb rbd,imm8",8,7,
518 
0x1c,
519 
#endif
520 
"andb",OPC_andb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_IMM+(ARG_IMM8),},
521 
        {CLASS_BIT+0,CLASS_BIT+6,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_IMM+(ARG_IMM8),CLASS_IMM+(ARG_IMM8),0,0,0,},2,4,25},
522 
 
523 
 
524 
/* 1000 0110 ssss dddd *** andb rbd,rbs */
525 
{
526 
#ifdef NICENAMES
527 
"andb rbd,rbs",8,4,
528 
0x1c,
529 
#endif
530 
"andb",OPC_andb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_REG_BYTE+(ARG_RS),},
531 
        {CLASS_BIT+8,CLASS_BIT+6,CLASS_REG+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,26},
532 
 
533 
 
534 
/* 0010 0111 ddN0 imm4 *** bit @rd,imm4 */
535 
{
536 
#ifdef NICENAMES
537 
"bit @rd,imm4",16,8,
538 
0x10,
539 
#endif
540 
"bit",OPC_bit,0,{CLASS_IR+(ARG_RD),CLASS_IMM +(ARG_IMM4),},
541 
        {CLASS_BIT+2,CLASS_BIT+7,CLASS_REGN0+(ARG_RD),CLASS_IMM+(ARG_IMM4),0,0,0,0,0,},2,2,27},
542 
 
543 
 
544 
/* 0110 0111 ddN0 imm4 address_dst *** bit address_dst(rd),imm4 */
545 
{
546 
#ifdef NICENAMES
547 
"bit address_dst(rd),imm4",16,11,
548 
0x10,
549 
#endif
550 
"bit",OPC_bit,0,{CLASS_X+(ARG_RD),CLASS_IMM +(ARG_IMM4),},
551 
        {CLASS_BIT+6,CLASS_BIT+7,CLASS_REGN0+(ARG_RD),CLASS_IMM+(ARG_IMM4),CLASS_ADDRESS+(ARG_DST),0,0,0,0,},2,4,28},
552 
 
553 
 
554 
/* 0110 0111 0000 imm4 address_dst *** bit address_dst,imm4 */
555 
{
556 
#ifdef NICENAMES
557 
"bit address_dst,imm4",16,10,
558 
0x10,
559 
#endif
560 
"bit",OPC_bit,0,{CLASS_DA+(ARG_DST),CLASS_IMM +(ARG_IMM4),},
561 
        {CLASS_BIT+6,CLASS_BIT+7,CLASS_BIT+0,CLASS_IMM+(ARG_IMM4),CLASS_ADDRESS+(ARG_DST),0,0,0,0,},2,4,29},
562 
 
563 
 
564 
/* 1010 0111 dddd imm4 *** bit rd,imm4 */
565 
{
566 
#ifdef NICENAMES
567 
"bit rd,imm4",16,4,
568 
0x10,
569 
#endif
570 
"bit",OPC_bit,0,{CLASS_REG_WORD+(ARG_RD),CLASS_IMM +(ARG_IMM4),},
571 
        {CLASS_BIT+0xa,CLASS_BIT+7,CLASS_REG+(ARG_RD),CLASS_IMM+(ARG_IMM4),0,0,0,0,0,},2,2,30},
572 
 
573 
 
574 
/* 0010 0111 0000 ssss 0000 dddd 0000 0000 *** bit rd,rs */
575 
{
576 
#ifdef NICENAMES
577 
"bit rd,rs",16,10,
578 
0x10,
579 
#endif
580 
"bit",OPC_bit,0,{CLASS_REG_WORD+(ARG_RD),CLASS_REG_WORD+(ARG_RS),},
581 
        {CLASS_BIT+2,CLASS_BIT+7,CLASS_BIT+0,CLASS_REG+(ARG_RS),CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_BIT+0,CLASS_BIT+0,0,},2,4,31},
582 
 
583 
 
584 
/* 0010 0110 ddN0 imm4 *** bitb @rd,imm4 */
585 
{
586 
#ifdef NICENAMES
587 
"bitb @rd,imm4",8,8,
588 
0x10,
589 
#endif
590 
"bitb",OPC_bitb,0,{CLASS_IR+(ARG_RD),CLASS_IMM +(ARG_IMM4),},
591 
        {CLASS_BIT+2,CLASS_BIT+6,CLASS_REGN0+(ARG_RD),CLASS_IMM+(ARG_IMM4),0,0,0,0,0,},2,2,32},
592 
 
593 
 
594 
/* 0110 0110 ddN0 imm4 address_dst *** bitb address_dst(rd),imm4 */
595 
{
596 
#ifdef NICENAMES
597 
"bitb address_dst(rd),imm4",8,11,
598 
0x10,
599 
#endif
600 
"bitb",OPC_bitb,0,{CLASS_X+(ARG_RD),CLASS_IMM +(ARG_IMM4),},
601 
        {CLASS_BIT+6,CLASS_BIT+6,CLASS_REGN0+(ARG_RD),CLASS_IMM+(ARG_IMM4),CLASS_ADDRESS+(ARG_DST),0,0,0,0,},2,4,33},
602 
 
603 
 
604 
/* 0110 0110 0000 imm4 address_dst *** bitb address_dst,imm4 */
605 
{
606 
#ifdef NICENAMES
607 
"bitb address_dst,imm4",8,10,
608 
0x10,
609 
#endif
610 
"bitb",OPC_bitb,0,{CLASS_DA+(ARG_DST),CLASS_IMM +(ARG_IMM4),},
611 
        {CLASS_BIT+6,CLASS_BIT+6,CLASS_BIT+0,CLASS_IMM+(ARG_IMM4),CLASS_ADDRESS+(ARG_DST),0,0,0,0,},2,4,34},
612 
 
613 
 
614 
/* 1010 0110 dddd imm4 *** bitb rbd,imm4 */
615 
{
616 
#ifdef NICENAMES
617 
"bitb rbd,imm4",8,4,
618 
0x10,
619 
#endif
620 
"bitb",OPC_bitb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_IMM +(ARG_IMM4),},
621 
        {CLASS_BIT+0xa,CLASS_BIT+6,CLASS_REG+(ARG_RD),CLASS_IMM+(ARG_IMM4),0,0,0,0,0,},2,2,35},
622 
 
623 
 
624 
/* 0010 0110 0000 ssss 0000 dddd 0000 0000 *** bitb rbd,rs */
625 
{
626 
#ifdef NICENAMES
627 
"bitb rbd,rs",8,10,
628 
0x10,
629 
#endif
630 
"bitb",OPC_bitb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_REG_WORD+(ARG_RS),},
631 
        {CLASS_BIT+2,CLASS_BIT+6,CLASS_BIT+0,CLASS_REG+(ARG_RS),CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_BIT+0,CLASS_BIT+0,0,},2,4,36},
632 
 
633 
 
634 
/* 0011 0110 0000 0000 *** bpt */
635 
{
636 
#ifdef NICENAMES
637 
"bpt",8,2,
638 
0x00,
639 
#endif
640 
"bpt",OPC_bpt,0,{0},
641 
        {CLASS_BIT+3,CLASS_BIT+6,CLASS_BIT+0,CLASS_BIT+0,0,0,0,0,0,},0,2,37},
642 
 
643 
 
644 
/* 0001 1111 ddN0 0000 *** call @rd */
645 
{
646 
#ifdef NICENAMES
647 
"call @rd",32,10,
648 
0x00,
649 
#endif
650 
"call",OPC_call,0,{CLASS_IR+(ARG_RD),},
651 
        {CLASS_BIT+1,CLASS_BIT+0xf,CLASS_REGN0+(ARG_RD),CLASS_BIT+0,0,0,0,0,0,},1,2,38},
652 
 
653 
 
654 
/* 0101 1111 0000 0000 address_dst *** call address_dst */
655 
{
656 
#ifdef NICENAMES
657 
"call address_dst",32,12,
658 
0x00,
659 
#endif
660 
"call",OPC_call,0,{CLASS_DA+(ARG_DST),},
661 
        {CLASS_BIT+5,CLASS_BIT+0xf,CLASS_BIT+0,CLASS_BIT+0,CLASS_ADDRESS+(ARG_DST),0,0,0,0,},1,4,39},
662 
 
663 
 
664 
/* 0101 1111 ddN0 0000 address_dst *** call address_dst(rd) */
665 
{
666 
#ifdef NICENAMES
667 
"call address_dst(rd)",32,13,
668 
0x00,
669 
#endif
670 
"call",OPC_call,0,{CLASS_X+(ARG_RD),},
671 
        {CLASS_BIT+5,CLASS_BIT+0xf,CLASS_REGN0+(ARG_RD),CLASS_BIT+0,CLASS_ADDRESS+(ARG_DST),0,0,0,0,},1,4,40},
672 
 
673 
 
674 
/* 1101 disp12 *** calr disp12 */
675 
{
676 
#ifdef NICENAMES
677 
"calr disp12",16,10,
678 
0x00,
679 
#endif
680 
"calr",OPC_calr,0,{CLASS_DISP,},
681 
        {CLASS_BIT+0xd,CLASS_DISP+(ARG_DISP12),0,0,0,0,0,0,0,},1,2,41},
682 
 
683 
 
684 
/* 0000 1101 ddN0 1000 *** clr @rd */
685 
{
686 
#ifdef NICENAMES
687 
"clr @rd",16,8,
688 
0x00,
689 
#endif
690 
"clr",OPC_clr,0,{CLASS_IR+(ARG_RD),},
691 
        {CLASS_BIT+0,CLASS_BIT+0xd,CLASS_REGN0+(ARG_RD),CLASS_BIT+8,0,0,0,0,0,},1,2,42},
692 
 
693 
 
694 
/* 0100 1101 0000 1000 address_dst *** clr address_dst */
695 
{
696 
#ifdef NICENAMES
697 
"clr address_dst",16,11,
698 
0x00,
699 
#endif
700 
"clr",OPC_clr,0,{CLASS_DA+(ARG_DST),},
701 
        {CLASS_BIT+4,CLASS_BIT+0xd,CLASS_BIT+0,CLASS_BIT+8,CLASS_ADDRESS+(ARG_DST),0,0,0,0,},1,4,43},
702 
 
703 
 
704 
/* 0100 1101 ddN0 1000 address_dst *** clr address_dst(rd) */
705 
{
706 
#ifdef NICENAMES
707 
"clr address_dst(rd)",16,12,
708 
0x00,
709 
#endif
710 
"clr",OPC_clr,0,{CLASS_X+(ARG_RD),},
711 
        {CLASS_BIT+4,CLASS_BIT+0xd,CLASS_REGN0+(ARG_RD),CLASS_BIT+8,CLASS_ADDRESS+(ARG_DST),0,0,0,0,},1,4,44},
712 
 
713 
 
714 
/* 1000 1101 dddd 1000 *** clr rd */
715 
{
716 
#ifdef NICENAMES
717 
"clr rd",16,7,
718 
0x00,
719 
#endif
720 
"clr",OPC_clr,0,{CLASS_REG_WORD+(ARG_RD),},
721 
        {CLASS_BIT+8,CLASS_BIT+0xd,CLASS_REG+(ARG_RD),CLASS_BIT+8,0,0,0,0,0,},1,2,45},
722 
 
723 
 
724 
/* 0000 1100 ddN0 1000 *** clrb @rd */
725 
{
726 
#ifdef NICENAMES
727 
"clrb @rd",8,8,
728 
0x00,
729 
#endif
730 
"clrb",OPC_clrb,0,{CLASS_IR+(ARG_RD),},
731 
        {CLASS_BIT+0,CLASS_BIT+0xc,CLASS_REGN0+(ARG_RD),CLASS_BIT+8,0,0,0,0,0,},1,2,46},
732 
 
733 
 
734 
/* 0100 1100 0000 1000 address_dst *** clrb address_dst */
735 
{
736 
#ifdef NICENAMES
737 
"clrb address_dst",8,11,
738 
0x00,
739 
#endif
740 
"clrb",OPC_clrb,0,{CLASS_DA+(ARG_DST),},
741 
        {CLASS_BIT+4,CLASS_BIT+0xc,CLASS_BIT+0,CLASS_BIT+8,CLASS_ADDRESS+(ARG_DST),0,0,0,0,},1,4,47},
742 
 
743 
 
744 
/* 0100 1100 ddN0 1000 address_dst *** clrb address_dst(rd) */
745 
{
746 
#ifdef NICENAMES
747 
"clrb address_dst(rd)",8,12,
748 
0x00,
749 
#endif
750 
"clrb",OPC_clrb,0,{CLASS_X+(ARG_RD),},
751 
        {CLASS_BIT+4,CLASS_BIT+0xc,CLASS_REGN0+(ARG_RD),CLASS_BIT+8,CLASS_ADDRESS+(ARG_DST),0,0,0,0,},1,4,48},
752 
 
753 
 
754 
/* 1000 1100 dddd 1000 *** clrb rbd */
755 
{
756 
#ifdef NICENAMES
757 
"clrb rbd",8,7,
758 
0x00,
759 
#endif
760 
"clrb",OPC_clrb,0,{CLASS_REG_BYTE+(ARG_RD),},
761 
        {CLASS_BIT+8,CLASS_BIT+0xc,CLASS_REG+(ARG_RD),CLASS_BIT+8,0,0,0,0,0,},1,2,49},
762 
 
763 
 
764 
/* 0000 1101 ddN0 0000 *** com @rd */
765 
{
766 
#ifdef NICENAMES
767 
"com @rd",16,12,
768 
0x18,
769 
#endif
770 
"com",OPC_com,0,{CLASS_IR+(ARG_RD),},
771 
        {CLASS_BIT+0,CLASS_BIT+0xd,CLASS_REGN0+(ARG_RD),CLASS_BIT+0,0,0,0,0,0,},1,2,50},
772 
 
773 
 
774 
/* 0100 1101 0000 0000 address_dst *** com address_dst */
775 
{
776 
#ifdef NICENAMES
777 
"com address_dst",16,15,
778 
0x18,
779 
#endif
780 
"com",OPC_com,0,{CLASS_DA+(ARG_DST),},
781 
        {CLASS_BIT+4,CLASS_BIT+0xd,CLASS_BIT+0,CLASS_BIT+0,CLASS_ADDRESS+(ARG_DST),0,0,0,0,},1,4,51},
782 
 
783 
 
784 
/* 0100 1101 ddN0 0000 address_dst *** com address_dst(rd) */
785 
{
786 
#ifdef NICENAMES
787 
"com address_dst(rd)",16,16,
788 
0x18,
789 
#endif
790 
"com",OPC_com,0,{CLASS_X+(ARG_RD),},
791 
        {CLASS_BIT+4,CLASS_BIT+0xd,CLASS_REGN0+(ARG_RD),CLASS_BIT+0,CLASS_ADDRESS+(ARG_DST),0,0,0,0,},1,4,52},
792 
 
793 
 
794 
/* 1000 1101 dddd 0000 *** com rd */
795 
{
796 
#ifdef NICENAMES
797 
"com rd",16,7,
798 
0x18,
799 
#endif
800 
"com",OPC_com,0,{CLASS_REG_WORD+(ARG_RD),},
801 
        {CLASS_BIT+8,CLASS_BIT+0xd,CLASS_REG+(ARG_RD),CLASS_BIT+0,0,0,0,0,0,},1,2,53},
802 
 
803 
 
804 
/* 0000 1100 ddN0 0000 *** comb @rd */
805 
{
806 
#ifdef NICENAMES
807 
"comb @rd",8,12,
808 
0x1c,
809 
#endif
810 
"comb",OPC_comb,0,{CLASS_IR+(ARG_RD),},
811 
        {CLASS_BIT+0,CLASS_BIT+0xc,CLASS_REGN0+(ARG_RD),CLASS_BIT+0,0,0,0,0,0,},1,2,54},
812 
 
813 
 
814 
/* 0100 1100 0000 0000 address_dst *** comb address_dst */
815 
{
816 
#ifdef NICENAMES
817 
"comb address_dst",8,15,
818 
0x1c,
819 
#endif
820 
"comb",OPC_comb,0,{CLASS_DA+(ARG_DST),},
821 
        {CLASS_BIT+4,CLASS_BIT+0xc,CLASS_BIT+0,CLASS_BIT+0,CLASS_ADDRESS+(ARG_DST),0,0,0,0,},1,4,55},
822 
 
823 
 
824 
/* 0100 1100 ddN0 0000 address_dst *** comb address_dst(rd) */
825 
{
826 
#ifdef NICENAMES
827 
"comb address_dst(rd)",8,16,
828 
0x1c,
829 
#endif
830 
"comb",OPC_comb,0,{CLASS_X+(ARG_RD),},
831 
        {CLASS_BIT+4,CLASS_BIT+0xc,CLASS_REGN0+(ARG_RD),CLASS_BIT+0,CLASS_ADDRESS+(ARG_DST),0,0,0,0,},1,4,56},
832 
 
833 
 
834 
/* 1000 1100 dddd 0000 *** comb rbd */
835 
{
836 
#ifdef NICENAMES
837 
"comb rbd",8,7,
838 
0x1c,
839 
#endif
840 
"comb",OPC_comb,0,{CLASS_REG_BYTE+(ARG_RD),},
841 
        {CLASS_BIT+8,CLASS_BIT+0xc,CLASS_REG+(ARG_RD),CLASS_BIT+0,0,0,0,0,0,},1,2,57},
842 
 
843 
 
844 
/* 1000 1101 flags 0101 *** comflg flags */
845 
{
846 
#ifdef NICENAMES
847 
"comflg flags",16,7,
848 
0x3c,
849 
#endif
850 
"comflg",OPC_comflg,0,{CLASS_FLAGS,},
851 
        {CLASS_BIT+8,CLASS_BIT+0xd,CLASS_FLAGS,CLASS_BIT+5,0,0,0,0,0,},1,2,58},
852 
 
853 
 
854 
/* 0000 1101 ddN0 0001 imm16 *** cp @rd,imm16 */
855 
{
856 
#ifdef NICENAMES
857 
"cp @rd,imm16",16,11,
858 
0x3c,
859 
#endif
860 
"cp",OPC_cp,0,{CLASS_IR+(ARG_RD),CLASS_IMM+(ARG_IMM16),},
861 
        {CLASS_BIT+0,CLASS_BIT+0xd,CLASS_REGN0+(ARG_RD),CLASS_BIT+1,CLASS_IMM+(ARG_IMM16),0,0,0,0,},2,4,59},
862 
 
863 
 
864 
/* 0100 1101 ddN0 0001 address_dst imm16 *** cp address_dst(rd),imm16 */
865 
{
866 
#ifdef NICENAMES
867 
"cp address_dst(rd),imm16",16,15,
868 
0x3c,
869 
#endif
870 
"cp",OPC_cp,0,{CLASS_X+(ARG_RD),CLASS_IMM+(ARG_IMM16),},
871 
        {CLASS_BIT+4,CLASS_BIT+0xd,CLASS_REGN0+(ARG_RD),CLASS_BIT+1,CLASS_ADDRESS+(ARG_DST),CLASS_IMM+(ARG_IMM16),0,0,0,},2,6,60},
872 
 
873 
 
874 
/* 0100 1101 0000 0001 address_dst imm16 *** cp address_dst,imm16 */
875 
{
876 
#ifdef NICENAMES
877 
"cp address_dst,imm16",16,14,
878 
0x3c,
879 
#endif
880 
"cp",OPC_cp,0,{CLASS_DA+(ARG_DST),CLASS_IMM+(ARG_IMM16),},
881 
        {CLASS_BIT+4,CLASS_BIT+0xd,CLASS_BIT+0,CLASS_BIT+1,CLASS_ADDRESS+(ARG_DST),CLASS_IMM+(ARG_IMM16),0,0,0,},2,6,61},
882 
 
883 
 
884 
/* 0000 1011 ssN0 dddd *** cp rd,@rs */
885 
{
886 
#ifdef NICENAMES
887 
"cp rd,@rs",16,7,
888 
0x3c,
889 
#endif
890 
"cp",OPC_cp,0,{CLASS_REG_WORD+(ARG_RD),CLASS_IR+(ARG_RS),},
891 
        {CLASS_BIT+0,CLASS_BIT+0xb,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,62},
892 
 
893 
 
894 
/* 0100 1011 0000 dddd address_src *** cp rd,address_src */
895 
{
896 
#ifdef NICENAMES
897 
"cp rd,address_src",16,9,
898 
0x3c,
899 
#endif
900 
"cp",OPC_cp,0,{CLASS_REG_WORD+(ARG_RD),CLASS_DA+(ARG_SRC),},
901 
        {CLASS_BIT+4,CLASS_BIT+0xb,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,63},
902 
 
903 
 
904 
/* 0100 1011 ssN0 dddd address_src *** cp rd,address_src(rs) */
905 
{
906 
#ifdef NICENAMES
907 
"cp rd,address_src(rs)",16,10,
908 
0x3c,
909 
#endif
910 
"cp",OPC_cp,0,{CLASS_REG_WORD+(ARG_RD),CLASS_X+(ARG_RS),},
911 
        {CLASS_BIT+4,CLASS_BIT+0xb,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,64},
912 
 
913 
 
914 
/* 0000 1011 0000 dddd imm16 *** cp rd,imm16 */
915 
{
916 
#ifdef NICENAMES
917 
"cp rd,imm16",16,7,
918 
0x3c,
919 
#endif
920 
"cp",OPC_cp,0,{CLASS_REG_WORD+(ARG_RD),CLASS_IMM+(ARG_IMM16),},
921 
        {CLASS_BIT+0,CLASS_BIT+0xb,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_IMM+(ARG_IMM16),0,0,0,0,},2,4,65},
922 
 
923 
 
924 
/* 1000 1011 ssss dddd *** cp rd,rs */
925 
{
926 
#ifdef NICENAMES
927 
"cp rd,rs",16,4,
928 
0x3c,
929 
#endif
930 
"cp",OPC_cp,0,{CLASS_REG_WORD+(ARG_RD),CLASS_REG_WORD+(ARG_RS),},
931 
        {CLASS_BIT+8,CLASS_BIT+0xb,CLASS_REG+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,66},
932 
 
933 
 
934 
/* 0000 1100 ddN0 0001 imm8 imm8 *** cpb @rd,imm8 */
935 
{
936 
#ifdef NICENAMES
937 
"cpb @rd,imm8",8,11,
938 
0x3c,
939 
#endif
940 
"cpb",OPC_cpb,0,{CLASS_IR+(ARG_RD),CLASS_IMM+(ARG_IMM8),},
941 
        {CLASS_BIT+0,CLASS_BIT+0xc,CLASS_REGN0+(ARG_RD),CLASS_BIT+1,CLASS_IMM+(ARG_IMM8),CLASS_IMM+(ARG_IMM8),0,0,0,},2,4,67},
942 
 
943 
 
944 
/* 0100 1100 ddN0 0001 address_dst imm8 imm8 *** cpb address_dst(rd),imm8 */
945 
{
946 
#ifdef NICENAMES
947 
"cpb address_dst(rd),imm8",8,15,
948 
0x3c,
949 
#endif
950 
"cpb",OPC_cpb,0,{CLASS_X+(ARG_RD),CLASS_IMM+(ARG_IMM8),},
951 
        {CLASS_BIT+4,CLASS_BIT+0xc,CLASS_REGN0+(ARG_RD),CLASS_BIT+1,CLASS_ADDRESS+(ARG_DST),CLASS_IMM+(ARG_IMM8),CLASS_IMM+(ARG_IMM8),0,0,},2,6,68},
952 
 
953 
 
954 
/* 0100 1100 0000 0001 address_dst imm8 imm8 *** cpb address_dst,imm8 */
955 
{
956 
#ifdef NICENAMES
957 
"cpb address_dst,imm8",8,14,
958 
0x3c,
959 
#endif
960 
"cpb",OPC_cpb,0,{CLASS_DA+(ARG_DST),CLASS_IMM+(ARG_IMM8),},
961 
        {CLASS_BIT+4,CLASS_BIT+0xc,CLASS_BIT+0,CLASS_BIT+1,CLASS_ADDRESS+(ARG_DST),CLASS_IMM+(ARG_IMM8),CLASS_IMM+(ARG_IMM8),0,0,},2,6,69},
962 
 
963 
 
964 
/* 0000 1010 ssN0 dddd *** cpb rbd,@rs */
965 
{
966 
#ifdef NICENAMES
967 
"cpb rbd,@rs",8,7,
968 
0x3c,
969 
#endif
970 
"cpb",OPC_cpb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_IR+(ARG_RS),},
971 
        {CLASS_BIT+0,CLASS_BIT+0xa,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,70},
972 
 
973 
 
974 
/* 0100 1010 0000 dddd address_src *** cpb rbd,address_src */
975 
{
976 
#ifdef NICENAMES
977 
"cpb rbd,address_src",8,9,
978 
0x3c,
979 
#endif
980 
"cpb",OPC_cpb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_DA+(ARG_SRC),},
981 
        {CLASS_BIT+4,CLASS_BIT+0xa,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,71},
982 
 
983 
 
984 
/* 0100 1010 ssN0 dddd address_src *** cpb rbd,address_src(rs) */
985 
{
986 
#ifdef NICENAMES
987 
"cpb rbd,address_src(rs)",8,10,
988 
0x3c,
989 
#endif
990 
"cpb",OPC_cpb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_X+(ARG_RS),},
991 
        {CLASS_BIT+4,CLASS_BIT+0xa,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,72},
992 
 
993 
 
994 
/* 0000 1010 0000 dddd imm8 imm8 *** cpb rbd,imm8 */
995 
{
996 
#ifdef NICENAMES
997 
"cpb rbd,imm8",8,7,
998 
0x3c,
999 
#endif
1000 
"cpb",OPC_cpb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_IMM+(ARG_IMM8),},
1001 
        {CLASS_BIT+0,CLASS_BIT+0xa,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_IMM+(ARG_IMM8),CLASS_IMM+(ARG_IMM8),0,0,0,},2,4,73},
1002 
 
1003 
 
1004 
/* 1000 1010 ssss dddd *** cpb rbd,rbs */
1005 
{
1006 
#ifdef NICENAMES
1007 
"cpb rbd,rbs",8,4,
1008 
0x3c,
1009 
#endif
1010 
"cpb",OPC_cpb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_REG_BYTE+(ARG_RS),},
1011 
        {CLASS_BIT+8,CLASS_BIT+0xa,CLASS_REG+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,74},
1012 
 
1013 
 
1014 
/* 1011 1011 ssN0 1000 0000 rrrr dddd cccc *** cpd rd,@rs,rr,cc */
1015 
{
1016 
#ifdef NICENAMES
1017 
"cpd rd,@rs,rr,cc",16,11,
1018 
0x3c,
1019 
#endif
1020 
"cpd",OPC_cpd,0,{CLASS_REG_WORD+(ARG_RD),CLASS_IR+(ARG_RS),CLASS_REG_WORD+(ARG_RR),CLASS_CC,},
1021 
        {CLASS_BIT+0xb,CLASS_BIT+0xb,CLASS_REGN0+(ARG_RS),CLASS_BIT+8,CLASS_BIT+0,CLASS_REG+(ARG_RR),CLASS_REG+(ARG_RD),CLASS_CC,0,},4,4,75},
1022 
 
1023 
 
1024 
/* 1011 1010 ssN0 1000 0000 rrrr dddd cccc *** cpdb rbd,@rs,rr,cc */
1025 
{
1026 
#ifdef NICENAMES
1027 
"cpdb rbd,@rs,rr,cc",8,11,
1028 
0x3c,
1029 
#endif
1030 
"cpdb",OPC_cpdb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_IR+(ARG_RS),CLASS_REG_WORD+(ARG_RR),CLASS_CC,},
1031 
        {CLASS_BIT+0xb,CLASS_BIT+0xa,CLASS_REGN0+(ARG_RS),CLASS_BIT+8,CLASS_BIT+0,CLASS_REG+(ARG_RR),CLASS_REG+(ARG_RD),CLASS_CC,0,},4,4,76},
1032 
 
1033 
 
1034 
/* 1011 1011 ssN0 1100 0000 rrrr dddd cccc *** cpdr rd,@rs,rr,cc */
1035 
{
1036 
#ifdef NICENAMES
1037 
"cpdr rd,@rs,rr,cc",16,11,
1038 
0x3c,
1039 
#endif
1040 
"cpdr",OPC_cpdr,0,{CLASS_REG_WORD+(ARG_RD),CLASS_IR+(ARG_RS),CLASS_REG_WORD+(ARG_RR),CLASS_CC,},
1041 
        {CLASS_BIT+0xb,CLASS_BIT+0xb,CLASS_REGN0+(ARG_RS),CLASS_BIT+0xc,CLASS_BIT+0,CLASS_REG+(ARG_RR),CLASS_REG+(ARG_RD),CLASS_CC,0,},4,4,77},
1042 
 
1043 
 
1044 
/* 1011 1010 ssN0 1100 0000 rrrr dddd cccc *** cpdrb rbd,@rs,rr,cc */
1045 
{
1046 
#ifdef NICENAMES
1047 
"cpdrb rbd,@rs,rr,cc",8,11,
1048 
0x3c,
1049 
#endif
1050 
"cpdrb",OPC_cpdrb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_IR+(ARG_RS),CLASS_REG_WORD+(ARG_RR),CLASS_CC,},
1051 
        {CLASS_BIT+0xb,CLASS_BIT+0xa,CLASS_REGN0+(ARG_RS),CLASS_BIT+0xc,CLASS_BIT+0,CLASS_REG+(ARG_RR),CLASS_REG+(ARG_RD),CLASS_CC,0,},4,4,78},
1052 
 
1053 
 
1054 
/* 1011 1011 ssN0 0000 0000 rrrr dddd cccc *** cpi rd,@rs,rr,cc */
1055 
{
1056 
#ifdef NICENAMES
1057 
"cpi rd,@rs,rr,cc",16,11,
1058 
0x3c,
1059 
#endif
1060 
"cpi",OPC_cpi,0,{CLASS_REG_WORD+(ARG_RD),CLASS_IR+(ARG_RS),CLASS_REG_WORD+(ARG_RR),CLASS_CC,},
1061 
        {CLASS_BIT+0xb,CLASS_BIT+0xb,CLASS_REGN0+(ARG_RS),CLASS_BIT+0,CLASS_BIT+0,CLASS_REG+(ARG_RR),CLASS_REG+(ARG_RD),CLASS_CC,0,},4,4,79},
1062 
 
1063 
 
1064 
/* 1011 1010 ssN0 0000 0000 rrrr dddd cccc *** cpib rbd,@rs,rr,cc */
1065 
{
1066 
#ifdef NICENAMES
1067 
"cpib rbd,@rs,rr,cc",8,11,
1068 
0x3c,
1069 
#endif
1070 
"cpib",OPC_cpib,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_IR+(ARG_RS),CLASS_REG_WORD+(ARG_RR),CLASS_CC,},
1071 
        {CLASS_BIT+0xb,CLASS_BIT+0xa,CLASS_REGN0+(ARG_RS),CLASS_BIT+0,CLASS_BIT+0,CLASS_REG+(ARG_RR),CLASS_REG+(ARG_RD),CLASS_CC,0,},4,4,80},
1072 
 
1073 
 
1074 
/* 1011 1011 ssN0 0100 0000 rrrr dddd cccc *** cpir rd,@rs,rr,cc */
1075 
{
1076 
#ifdef NICENAMES
1077 
"cpir rd,@rs,rr,cc",16,11,
1078 
0x3c,
1079 
#endif
1080 
"cpir",OPC_cpir,0,{CLASS_REG_WORD+(ARG_RD),CLASS_IR+(ARG_RS),CLASS_REG_WORD+(ARG_RR),CLASS_CC,},
1081 
        {CLASS_BIT+0xb,CLASS_BIT+0xb,CLASS_REGN0+(ARG_RS),CLASS_BIT+4,CLASS_BIT+0,CLASS_REG+(ARG_RR),CLASS_REG+(ARG_RD),CLASS_CC,0,},4,4,81},
1082 
 
1083 
 
1084 
/* 1011 1010 ssN0 0100 0000 rrrr dddd cccc *** cpirb rbd,@rs,rr,cc */
1085 
{
1086 
#ifdef NICENAMES
1087 
"cpirb rbd,@rs,rr,cc",8,11,
1088 
0x3c,
1089 
#endif
1090 
"cpirb",OPC_cpirb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_IR+(ARG_RS),CLASS_REG_WORD+(ARG_RR),CLASS_CC,},
1091 
        {CLASS_BIT+0xb,CLASS_BIT+0xa,CLASS_REGN0+(ARG_RS),CLASS_BIT+4,CLASS_BIT+0,CLASS_REG+(ARG_RR),CLASS_REG+(ARG_RD),CLASS_CC,0,},4,4,82},
1092 
 
1093 
 
1094 
/* 0001 0000 ssN0 dddd *** cpl rrd,@rs */
1095 
{
1096 
#ifdef NICENAMES
1097 
"cpl rrd,@rs",32,14,
1098 
0x3c,
1099 
#endif
1100 
"cpl",OPC_cpl,0,{CLASS_REG_LONG+(ARG_RD),CLASS_IR+(ARG_RS),},
1101 
        {CLASS_BIT+1,CLASS_BIT+0,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,83},
1102 
 
1103 
 
1104 
/* 0101 0000 0000 dddd address_src *** cpl rrd,address_src */
1105 
{
1106 
#ifdef NICENAMES
1107 
"cpl rrd,address_src",32,15,
1108 
0x3c,
1109 
#endif
1110 
"cpl",OPC_cpl,0,{CLASS_REG_LONG+(ARG_RD),CLASS_DA+(ARG_SRC),},
1111 
        {CLASS_BIT+5,CLASS_BIT+0,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,84},
1112 
 
1113 
 
1114 
/* 0101 0000 ssN0 dddd address_src *** cpl rrd,address_src(rs) */
1115 
{
1116 
#ifdef NICENAMES
1117 
"cpl rrd,address_src(rs)",32,16,
1118 
0x3c,
1119 
#endif
1120 
"cpl",OPC_cpl,0,{CLASS_REG_LONG+(ARG_RD),CLASS_X+(ARG_RS),},
1121 
        {CLASS_BIT+5,CLASS_BIT+0,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,85},
1122 
 
1123 
 
1124 
/* 0001 0000 0000 dddd imm32 *** cpl rrd,imm32 */
1125 
{
1126 
#ifdef NICENAMES
1127 
"cpl rrd,imm32",32,14,
1128 
0x3c,
1129 
#endif
1130 
"cpl",OPC_cpl,0,{CLASS_REG_LONG+(ARG_RD),CLASS_IMM+(ARG_IMM32),},
1131 
        {CLASS_BIT+1,CLASS_BIT+0,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_IMM+(ARG_IMM32),0,0,0,0,},2,6,86},
1132 
 
1133 
 
1134 
/* 1001 0000 ssss dddd *** cpl rrd,rrs */
1135 
{
1136 
#ifdef NICENAMES
1137 
"cpl rrd,rrs",32,8,
1138 
0x3c,
1139 
#endif
1140 
"cpl",OPC_cpl,0,{CLASS_REG_LONG+(ARG_RD),CLASS_REG_LONG+(ARG_RS),},
1141 
        {CLASS_BIT+9,CLASS_BIT+0,CLASS_REG+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,87},
1142 
 
1143 
 
1144 
/* 1011 1011 ssN0 1010 0000 rrrr ddN0 cccc *** cpsd @rd,@rs,rr,cc */
1145 
{
1146 
#ifdef NICENAMES
1147 
"cpsd @rd,@rs,rr,cc",16,11,
1148 
0x3c,
1149 
#endif
1150 
"cpsd",OPC_cpsd,0,{CLASS_IR+(ARG_RD),CLASS_IR+(ARG_RS),CLASS_REG_WORD+(ARG_RR),CLASS_CC,},
1151 
        {CLASS_BIT+0xb,CLASS_BIT+0xb,CLASS_REGN0+(ARG_RS),CLASS_BIT+0xa,CLASS_BIT+0,CLASS_REG+(ARG_RR),CLASS_REGN0+(ARG_RD),CLASS_CC,0,},4,4,88},
1152 
 
1153 
 
1154 
/* 1011 1010 ssN0 1010 0000 rrrr ddN0 cccc *** cpsdb @rd,@rs,rr,cc */
1155 
{
1156 
#ifdef NICENAMES
1157 
"cpsdb @rd,@rs,rr,cc",8,11,
1158 
0x3c,
1159 
#endif
1160 
"cpsdb",OPC_cpsdb,0,{CLASS_IR+(ARG_RD),CLASS_IR+(ARG_RS),CLASS_REG_WORD+(ARG_RR),CLASS_CC,},
1161 
        {CLASS_BIT+0xb,CLASS_BIT+0xa,CLASS_REGN0+(ARG_RS),CLASS_BIT+0xa,CLASS_BIT+0,CLASS_REG+(ARG_RR),CLASS_REGN0+(ARG_RD),CLASS_CC,0,},4,4,89},
1162 
 
1163 
 
1164 
/* 1011 1011 ssN0 1110 0000 rrrr ddN0 cccc *** cpsdr @rd,@rs,rr,cc */
1165 
{
1166 
#ifdef NICENAMES
1167 
"cpsdr @rd,@rs,rr,cc",16,11,
1168 
0x3c,
1169 
#endif
1170 
"cpsdr",OPC_cpsdr,0,{CLASS_IR+(ARG_RD),CLASS_IR+(ARG_RS),CLASS_REG_WORD+(ARG_RR),CLASS_CC,},
1171 
        {CLASS_BIT+0xb,CLASS_BIT+0xb,CLASS_REGN0+(ARG_RS),CLASS_BIT+0xe,CLASS_BIT+0,CLASS_REG+(ARG_RR),CLASS_REGN0+(ARG_RD),CLASS_CC,0,},4,4,90},
1172 
 
1173 
 
1174 
/* 1011 1010 ssN0 1110 0000 rrrr ddN0 cccc *** cpsdrb @rd,@rs,rr,cc */
1175 
{
1176 
#ifdef NICENAMES
1177 
"cpsdrb @rd,@rs,rr,cc",8,11,
1178 
0x3c,
1179 
#endif
1180 
"cpsdrb",OPC_cpsdrb,0,{CLASS_IR+(ARG_RD),CLASS_IR+(ARG_RS),CLASS_REG_WORD+(ARG_RR),CLASS_CC,},
1181 
        {CLASS_BIT+0xb,CLASS_BIT+0xa,CLASS_REGN0+(ARG_RS),CLASS_BIT+0xe,CLASS_BIT+0,CLASS_REG+(ARG_RR),CLASS_REGN0+(ARG_RD),CLASS_CC,0,},4,4,91},
1182 
 
1183 
 
1184 
/* 1011 1011 ssN0 0010 0000 rrrr ddN0 cccc *** cpsi @rd,@rs,rr,cc */
1185 
{
1186 
#ifdef NICENAMES
1187 
"cpsi @rd,@rs,rr,cc",16,11,
1188 
0x3c,
1189 
#endif
1190 
"cpsi",OPC_cpsi,0,{CLASS_IR+(ARG_RD),CLASS_IR+(ARG_RS),CLASS_REG_WORD+(ARG_RR),CLASS_CC,},
1191 
        {CLASS_BIT+0xb,CLASS_BIT+0xb,CLASS_REGN0+(ARG_RS),CLASS_BIT+2,CLASS_BIT+0,CLASS_REG+(ARG_RR),CLASS_REGN0+(ARG_RD),CLASS_CC,0,},4,4,92},
1192 
 
1193 
 
1194 
/* 1011 1010 ssN0 0010 0000 rrrr ddN0 cccc *** cpsib @rd,@rs,rr,cc */
1195 
{
1196 
#ifdef NICENAMES
1197 
"cpsib @rd,@rs,rr,cc",8,11,
1198 
0x3c,
1199 
#endif
1200 
"cpsib",OPC_cpsib,0,{CLASS_IR+(ARG_RD),CLASS_IR+(ARG_RS),CLASS_REG_WORD+(ARG_RR),CLASS_CC,},
1201 
        {CLASS_BIT+0xb,CLASS_BIT+0xa,CLASS_REGN0+(ARG_RS),CLASS_BIT+2,CLASS_BIT+0,CLASS_REG+(ARG_RR),CLASS_REGN0+(ARG_RD),CLASS_CC,0,},4,4,93},
1202 
 
1203 
 
1204 
/* 1011 1011 ssN0 0110 0000 rrrr ddN0 cccc *** cpsir @rd,@rs,rr,cc */
1205 
{
1206 
#ifdef NICENAMES
1207 
"cpsir @rd,@rs,rr,cc",16,11,
1208 
0x3c,
1209 
#endif
1210 
"cpsir",OPC_cpsir,0,{CLASS_IR+(ARG_RD),CLASS_IR+(ARG_RS),CLASS_REG_WORD+(ARG_RR),CLASS_CC,},
1211 
        {CLASS_BIT+0xb,CLASS_BIT+0xb,CLASS_REGN0+(ARG_RS),CLASS_BIT+6,CLASS_BIT+0,CLASS_REG+(ARG_RR),CLASS_REGN0+(ARG_RD),CLASS_CC,0,},4,4,94},
1212 
 
1213 
 
1214 
/* 1011 1010 ssN0 0110 0000 rrrr ddN0 cccc *** cpsirb @rd,@rs,rr,cc */
1215 
{
1216 
#ifdef NICENAMES
1217 
"cpsirb @rd,@rs,rr,cc",8,11,
1218 
0x3c,
1219 
#endif
1220 
"cpsirb",OPC_cpsirb,0,{CLASS_IR+(ARG_RD),CLASS_IR+(ARG_RS),CLASS_REG_WORD+(ARG_RR),CLASS_CC,},
1221 
        {CLASS_BIT+0xb,CLASS_BIT+0xa,CLASS_REGN0+(ARG_RS),CLASS_BIT+6,CLASS_BIT+0,CLASS_REG+(ARG_RR),CLASS_REGN0+(ARG_RD),CLASS_CC,0,},4,4,95},
1222 
 
1223 
 
1224 
/* 1011 0000 dddd 0000 *** dab rbd */
1225 
{
1226 
#ifdef NICENAMES
1227 
"dab rbd",8,5,
1228 
0x38,
1229 
#endif
1230 
"dab",OPC_dab,0,{CLASS_REG_BYTE+(ARG_RD),},
1231 
        {CLASS_BIT+0xb,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_BIT+0,0,0,0,0,0,},1,2,96},
1232 
 
1233 
 
1234 
/* 1111 dddd 0disp7 *** dbjnz rbd,disp7 */
1235 
{
1236 
#ifdef NICENAMES
1237 
"dbjnz rbd,disp7",16,11,
1238 
0x00,
1239 
#endif
1240 
"dbjnz",OPC_dbjnz,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_DISP,},
1241 
        {CLASS_BIT+0xf,CLASS_REG+(ARG_RD),CLASS_0DISP7,0,0,0,0,0,0,},2,2,97},
1242 
 
1243 
 
1244 
/* 0010 1011 ddN0 imm4m1 *** dec @rd,imm4m1 */
1245 
{
1246 
#ifdef NICENAMES
1247 
"dec @rd,imm4m1",16,11,
1248 
0x1c,
1249 
#endif
1250 
"dec",OPC_dec,0,{CLASS_IR+(ARG_RD),CLASS_IMM +(ARG_IMM4M1),},
1251 
        {CLASS_BIT+2,CLASS_BIT+0xb,CLASS_REGN0+(ARG_RD),CLASS_IMM+(ARG_IMM4M1),0,0,0,0,0,},2,2,98},
1252 
 
1253 
 
1254 
/* 0110 1011 ddN0 imm4m1 address_dst *** dec address_dst(rd),imm4m1 */
1255 
{
1256 
#ifdef NICENAMES
1257 
"dec address_dst(rd),imm4m1",16,14,
1258 
0x1c,
1259 
#endif
1260 
"dec",OPC_dec,0,{CLASS_X+(ARG_RD),CLASS_IMM +(ARG_IMM4M1),},
1261 
        {CLASS_BIT+6,CLASS_BIT+0xb,CLASS_REGN0+(ARG_RD),CLASS_IMM+(ARG_IMM4M1),CLASS_ADDRESS+(ARG_DST),0,0,0,0,},2,4,99},
1262 
 
1263 
 
1264 
/* 0110 1011 0000 imm4m1 address_dst *** dec address_dst,imm4m1 */
1265 
{
1266 
#ifdef NICENAMES
1267 
"dec address_dst,imm4m1",16,13,
1268 
0x1c,
1269 
#endif
1270 
"dec",OPC_dec,0,{CLASS_DA+(ARG_DST),CLASS_IMM +(ARG_IMM4M1),},
1271 
        {CLASS_BIT+6,CLASS_BIT+0xb,CLASS_BIT+0,CLASS_IMM+(ARG_IMM4M1),CLASS_ADDRESS+(ARG_DST),0,0,0,0,},2,4,100},
1272 
 
1273 
 
1274 
/* 1010 1011 dddd imm4m1 *** dec rd,imm4m1 */
1275 
{
1276 
#ifdef NICENAMES
1277 
"dec rd,imm4m1",16,4,
1278 
0x1c,
1279 
#endif
1280 
"dec",OPC_dec,0,{CLASS_REG_WORD+(ARG_RD),CLASS_IMM +(ARG_IMM4M1),},
1281 
        {CLASS_BIT+0xa,CLASS_BIT+0xb,CLASS_REG+(ARG_RD),CLASS_IMM+(ARG_IMM4M1),0,0,0,0,0,},2,2,101},
1282 
 
1283 
 
1284 
/* 0010 1010 ddN0 imm4m1 *** decb @rd,imm4m1 */
1285 
{
1286 
#ifdef NICENAMES
1287 
"decb @rd,imm4m1",8,11,
1288 
0x1c,
1289 
#endif
1290 
"decb",OPC_decb,0,{CLASS_IR+(ARG_RD),CLASS_IMM +(ARG_IMM4M1),},
1291 
        {CLASS_BIT+2,CLASS_BIT+0xa,CLASS_REGN0+(ARG_RD),CLASS_IMM+(ARG_IMM4M1),0,0,0,0,0,},2,2,102},
1292 
 
1293 
 
1294 
/* 0110 1010 ddN0 imm4m1 address_dst *** decb address_dst(rd),imm4m1 */
1295 
{
1296 
#ifdef NICENAMES
1297 
"decb address_dst(rd),imm4m1",8,14,
1298 
0x1c,
1299 
#endif
1300 
"decb",OPC_decb,0,{CLASS_X+(ARG_RD),CLASS_IMM +(ARG_IMM4M1),},
1301 
        {CLASS_BIT+6,CLASS_BIT+0xa,CLASS_REGN0+(ARG_RD),CLASS_IMM+(ARG_IMM4M1),CLASS_ADDRESS+(ARG_DST),0,0,0,0,},2,4,103},
1302 
 
1303 
 
1304 
/* 0110 1010 0000 imm4m1 address_dst *** decb address_dst,imm4m1 */
1305 
{
1306 
#ifdef NICENAMES
1307 
"decb address_dst,imm4m1",8,13,
1308 
0x1c,
1309 
#endif
1310 
"decb",OPC_decb,0,{CLASS_DA+(ARG_DST),CLASS_IMM +(ARG_IMM4M1),},
1311 
        {CLASS_BIT+6,CLASS_BIT+0xa,CLASS_BIT+0,CLASS_IMM+(ARG_IMM4M1),CLASS_ADDRESS+(ARG_DST),0,0,0,0,},2,4,104},
1312 
 
1313 
 
1314 
/* 1010 1010 dddd imm4m1 *** decb rbd,imm4m1 */
1315 
{
1316 
#ifdef NICENAMES
1317 
"decb rbd,imm4m1",8,4,
1318 
0x1c,
1319 
#endif
1320 
"decb",OPC_decb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_IMM +(ARG_IMM4M1),},
1321 
        {CLASS_BIT+0xa,CLASS_BIT+0xa,CLASS_REG+(ARG_RD),CLASS_IMM+(ARG_IMM4M1),0,0,0,0,0,},2,2,105},
1322 
 
1323 
 
1324 
/* 0111 1100 0000 00ii *** di i2 */
1325 
{
1326 
#ifdef NICENAMES
1327 
"di i2",16,7,
1328 
0x00,
1329 
#endif
1330 
"di",OPC_di,0,{CLASS_IMM+(ARG_IMM2),},
1331 
        {CLASS_BIT+7,CLASS_BIT+0xc,CLASS_BIT+0,CLASS_00II,0,0,0,0,0,},1,2,106},
1332 
 
1333 
 
1334 
/* 0001 1011 ssN0 dddd *** div rrd,@rs */
1335 
{
1336 
#ifdef NICENAMES
1337 
"div rrd,@rs",16,107,
1338 
0x3c,
1339 
#endif
1340 
"div",OPC_div,0,{CLASS_REG_LONG+(ARG_RD),CLASS_IR+(ARG_RS),},
1341 
        {CLASS_BIT+1,CLASS_BIT+0xb,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,107},
1342 
 
1343 
 
1344 
/* 0101 1011 0000 dddd address_src *** div rrd,address_src */
1345 
{
1346 
#ifdef NICENAMES
1347 
"div rrd,address_src",16,107,
1348 
0x3c,
1349 
#endif
1350 
"div",OPC_div,0,{CLASS_REG_LONG+(ARG_RD),CLASS_DA+(ARG_SRC),},
1351 
        {CLASS_BIT+5,CLASS_BIT+0xb,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,108},
1352 
 
1353 
 
1354 
/* 0101 1011 ssN0 dddd address_src *** div rrd,address_src(rs) */
1355 
{
1356 
#ifdef NICENAMES
1357 
"div rrd,address_src(rs)",16,107,
1358 
0x3c,
1359 
#endif
1360 
"div",OPC_div,0,{CLASS_REG_LONG+(ARG_RD),CLASS_X+(ARG_RS),},
1361 
        {CLASS_BIT+5,CLASS_BIT+0xb,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,109},
1362 
 
1363 
 
1364 
/* 0001 1011 0000 dddd imm16 *** div rrd,imm16 */
1365 
{
1366 
#ifdef NICENAMES
1367 
"div rrd,imm16",16,107,
1368 
0x3c,
1369 
#endif
1370 
"div",OPC_div,0,{CLASS_REG_LONG+(ARG_RD),CLASS_IMM+(ARG_IMM16),},
1371 
        {CLASS_BIT+1,CLASS_BIT+0xb,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_IMM+(ARG_IMM16),0,0,0,0,},2,4,110},
1372 
 
1373 
 
1374 
/* 1001 1011 ssss dddd *** div rrd,rs */
1375 
{
1376 
#ifdef NICENAMES
1377 
"div rrd,rs",16,107,
1378 
0x3c,
1379 
#endif
1380 
"div",OPC_div,0,{CLASS_REG_LONG+(ARG_RD),CLASS_REG_WORD+(ARG_RS),},
1381 
        {CLASS_BIT+9,CLASS_BIT+0xb,CLASS_REG+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,111},
1382 
 
1383 
 
1384 
/* 0001 1010 ssN0 dddd *** divl rqd,@rs */
1385 
{
1386 
#ifdef NICENAMES
1387 
"divl rqd,@rs",32,744,
1388 
0x3c,
1389 
#endif
1390 
"divl",OPC_divl,0,{CLASS_REG_QUAD+(ARG_RD),CLASS_IR+(ARG_RS),},
1391 
        {CLASS_BIT+1,CLASS_BIT+0xa,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,112},
1392 
 
1393 
 
1394 
/* 0101 1010 0000 dddd address_src *** divl rqd,address_src */
1395 
{
1396 
#ifdef NICENAMES
1397 
"divl rqd,address_src",32,745,
1398 
0x3c,
1399 
#endif
1400 
"divl",OPC_divl,0,{CLASS_REG_QUAD+(ARG_RD),CLASS_DA+(ARG_SRC),},
1401 
        {CLASS_BIT+5,CLASS_BIT+0xa,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,113},
1402 
 
1403 
 
1404 
/* 0101 1010 ssN0 dddd address_src *** divl rqd,address_src(rs) */
1405 
{
1406 
#ifdef NICENAMES
1407 
"divl rqd,address_src(rs)",32,746,
1408 
0x3c,
1409 
#endif
1410 
"divl",OPC_divl,0,{CLASS_REG_QUAD+(ARG_RD),CLASS_X+(ARG_RS),},
1411 
        {CLASS_BIT+5,CLASS_BIT+0xa,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,114},
1412 
 
1413 
 
1414 
/* 0001 1010 0000 dddd imm32 *** divl rqd,imm32 */
1415 
{
1416 
#ifdef NICENAMES
1417 
"divl rqd,imm32",32,744,
1418 
0x3c,
1419 
#endif
1420 
"divl",OPC_divl,0,{CLASS_REG_QUAD+(ARG_RD),CLASS_IMM+(ARG_IMM32),},
1421 
        {CLASS_BIT+1,CLASS_BIT+0xa,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_IMM+(ARG_IMM32),0,0,0,0,},2,6,115},
1422 
 
1423 
 
1424 
/* 1001 1010 ssss dddd *** divl rqd,rrs */
1425 
{
1426 
#ifdef NICENAMES
1427 
"divl rqd,rrs",32,744,
1428 
0x3c,
1429 
#endif
1430 
"divl",OPC_divl,0,{CLASS_REG_QUAD+(ARG_RD),CLASS_REG_LONG+(ARG_RS),},
1431 
        {CLASS_BIT+9,CLASS_BIT+0xa,CLASS_REG+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,116},
1432 
 
1433 
 
1434 
/* 1111 dddd 1disp7 *** djnz rd,disp7 */
1435 
{
1436 
#ifdef NICENAMES
1437 
"djnz rd,disp7",16,11,
1438 
0x00,
1439 
#endif
1440 
"djnz",OPC_djnz,0,{CLASS_REG_WORD+(ARG_RD),CLASS_DISP,},
1441 
        {CLASS_BIT+0xf,CLASS_REG+(ARG_RD),CLASS_1DISP7,0,0,0,0,0,0,},2,2,117},
1442 
 
1443 
 
1444 
/* 0111 1100 0000 01ii *** ei i2 */
1445 
{
1446 
#ifdef NICENAMES
1447 
"ei i2",16,7,
1448 
0x00,
1449 
#endif
1450 
"ei",OPC_ei,0,{CLASS_IMM+(ARG_IMM2),},
1451 
        {CLASS_BIT+7,CLASS_BIT+0xc,CLASS_BIT+0,CLASS_01II,0,0,0,0,0,},1,2,118},
1452 
 
1453 
 
1454 
/* 0010 1101 ssN0 dddd *** ex rd,@rs */
1455 
{
1456 
#ifdef NICENAMES
1457 
"ex rd,@rs",16,12,
1458 
0x00,
1459 
#endif
1460 
"ex",OPC_ex,0,{CLASS_REG_WORD+(ARG_RD),CLASS_IR+(ARG_RS),},
1461 
        {CLASS_BIT+2,CLASS_BIT+0xd,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,119},
1462 
 
1463 
 
1464 
/* 0110 1101 0000 dddd address_src *** ex rd,address_src */
1465 
{
1466 
#ifdef NICENAMES
1467 
"ex rd,address_src",16,15,
1468 
0x00,
1469 
#endif
1470 
"ex",OPC_ex,0,{CLASS_REG_WORD+(ARG_RD),CLASS_DA+(ARG_SRC),},
1471 
        {CLASS_BIT+6,CLASS_BIT+0xd,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,120},
1472 
 
1473 
 
1474 
/* 0110 1101 ssN0 dddd address_src *** ex rd,address_src(rs) */
1475 
{
1476 
#ifdef NICENAMES
1477 
"ex rd,address_src(rs)",16,16,
1478 
0x00,
1479 
#endif
1480 
"ex",OPC_ex,0,{CLASS_REG_WORD+(ARG_RD),CLASS_X+(ARG_RS),},
1481 
        {CLASS_BIT+6,CLASS_BIT+0xd,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,121},
1482 
 
1483 
 
1484 
/* 1010 1101 ssss dddd *** ex rd,rs */
1485 
{
1486 
#ifdef NICENAMES
1487 
"ex rd,rs",16,6,
1488 
0x00,
1489 
#endif
1490 
"ex",OPC_ex,0,{CLASS_REG_WORD+(ARG_RD),CLASS_REG_WORD+(ARG_RS),},
1491 
        {CLASS_BIT+0xa,CLASS_BIT+0xd,CLASS_REG+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,122},
1492 
 
1493 
 
1494 
/* 0010 1100 ssN0 dddd *** exb rbd,@rs */
1495 
{
1496 
#ifdef NICENAMES
1497 
"exb rbd,@rs",8,12,
1498 
0x00,
1499 
#endif
1500 
"exb",OPC_exb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_IR+(ARG_RS),},
1501 
        {CLASS_BIT+2,CLASS_BIT+0xc,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,123},
1502 
 
1503 
 
1504 
/* 0110 1100 0000 dddd address_src *** exb rbd,address_src */
1505 
{
1506 
#ifdef NICENAMES
1507 
"exb rbd,address_src",8,15,
1508 
0x00,
1509 
#endif
1510 
"exb",OPC_exb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_DA+(ARG_SRC),},
1511 
        {CLASS_BIT+6,CLASS_BIT+0xc,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,124},
1512 
 
1513 
 
1514 
/* 0110 1100 ssN0 dddd address_src *** exb rbd,address_src(rs) */
1515 
{
1516 
#ifdef NICENAMES
1517 
"exb rbd,address_src(rs)",8,16,
1518 
0x00,
1519 
#endif
1520 
"exb",OPC_exb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_X+(ARG_RS),},
1521 
        {CLASS_BIT+6,CLASS_BIT+0xc,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,125},
1522 
 
1523 
 
1524 
/* 1010 1100 ssss dddd *** exb rbd,rbs */
1525 
{
1526 
#ifdef NICENAMES
1527 
"exb rbd,rbs",8,6,
1528 
0x00,
1529 
#endif
1530 
"exb",OPC_exb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_REG_BYTE+(ARG_RS),},
1531 
        {CLASS_BIT+0xa,CLASS_BIT+0xc,CLASS_REG+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,126},
1532 
 
1533 
 
1534 
/* 0000 1110 imm8 *** ext0e imm8 */
1535 
{
1536 
#ifdef NICENAMES
1537 
"ext0e imm8",8,10,
1538 
0x00,
1539 
#endif
1540 
"ext0e",OPC_ext0e,0,{CLASS_IMM+(ARG_IMM8),},
1541 
        {CLASS_BIT+0,CLASS_BIT+0xe,CLASS_IMM+(ARG_IMM8),0,0,0,0,0,0,},1,2,127},
1542 
 
1543 
 
1544 
/* 0000 1111 imm8 *** ext0f imm8 */
1545 
{
1546 
#ifdef NICENAMES
1547 
"ext0f imm8",8,10,
1548 
0x00,
1549 
#endif
1550 
"ext0f",OPC_ext0f,0,{CLASS_IMM+(ARG_IMM8),},
1551 
        {CLASS_BIT+0,CLASS_BIT+0xf,CLASS_IMM+(ARG_IMM8),0,0,0,0,0,0,},1,2,128},
1552 
 
1553 
 
1554 
/* 1000 1110 imm8 *** ext8e imm8 */
1555 
{
1556 
#ifdef NICENAMES
1557 
"ext8e imm8",8,10,
1558 
0x00,
1559 
#endif
1560 
"ext8e",OPC_ext8e,0,{CLASS_IMM+(ARG_IMM8),},
1561 
        {CLASS_BIT+8,CLASS_BIT+0xe,CLASS_IMM+(ARG_IMM8),0,0,0,0,0,0,},1,2,129},
1562 
 
1563 
 
1564 
/* 1000 1111 imm8 *** ext8f imm8 */
1565 
{
1566 
#ifdef NICENAMES
1567 
"ext8f imm8",8,10,
1568 
0x00,
1569 
#endif
1570 
"ext8f",OPC_ext8f,0,{CLASS_IMM+(ARG_IMM8),},
1571 
        {CLASS_BIT+8,CLASS_BIT+0xf,CLASS_IMM+(ARG_IMM8),0,0,0,0,0,0,},1,2,130},
1572 
 
1573 
 
1574 
/* 1011 0001 dddd 1010 *** exts rrd */
1575 
{
1576 
#ifdef NICENAMES
1577 
"exts rrd",16,11,
1578 
0x00,
1579 
#endif
1580 
"exts",OPC_exts,0,{CLASS_REG_LONG+(ARG_RD),},
1581 
        {CLASS_BIT+0xb,CLASS_BIT+1,CLASS_REG+(ARG_RD),CLASS_BIT+0xa,0,0,0,0,0,},1,2,131},
1582 
 
1583 
 
1584 
/* 1011 0001 dddd 0000 *** extsb rd */
1585 
{
1586 
#ifdef NICENAMES
1587 
"extsb rd",8,11,
1588 
0x00,
1589 
#endif
1590 
"extsb",OPC_extsb,0,{CLASS_REG_WORD+(ARG_RD),},
1591 
        {CLASS_BIT+0xb,CLASS_BIT+1,CLASS_REG+(ARG_RD),CLASS_BIT+0,0,0,0,0,0,},1,2,132},
1592 
 
1593 
 
1594 
/* 1011 0001 dddd 0111 *** extsl rqd */
1595 
{
1596 
#ifdef NICENAMES
1597 
"extsl rqd",32,11,
1598 
0x00,
1599 
#endif
1600 
"extsl",OPC_extsl,0,{CLASS_REG_QUAD+(ARG_RD),},
1601 
        {CLASS_BIT+0xb,CLASS_BIT+1,CLASS_REG+(ARG_RD),CLASS_BIT+7,0,0,0,0,0,},1,2,133},
1602 
 
1603 
 
1604 
/* 0111 1010 0000 0000 *** halt */
1605 
{
1606 
#ifdef NICENAMES
1607 
"halt",16,8,
1608 
0x00,
1609 
#endif
1610 
"halt",OPC_halt,0,{0},
1611 
        {CLASS_BIT+7,CLASS_BIT+0xa,CLASS_BIT+0,CLASS_BIT+0,0,0,0,0,0,},0,2,134},
1612 
 
1613 
 
1614 
/* 0011 1101 ssN0 dddd *** in rd,@rs */
1615 
{
1616 
#ifdef NICENAMES
1617 
"in rd,@rs",16,10,
1618 
0x00,
1619 
#endif
1620 
"in",OPC_in,0,{CLASS_REG_WORD+(ARG_RD),CLASS_IR+(ARG_RS),},
1621 
        {CLASS_BIT+3,CLASS_BIT+0xd,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,135},
1622 
 
1623 
 
1624 
/* 0011 1011 dddd 0100 imm16 *** in rd,imm16 */
1625 
{
1626 
#ifdef NICENAMES
1627 
"in rd,imm16",16,12,
1628 
0x00,
1629 
#endif
1630 
"in",OPC_in,0,{CLASS_REG_WORD+(ARG_RD),CLASS_IMM+(ARG_IMM16),},
1631 
        {CLASS_BIT+3,CLASS_BIT+0xb,CLASS_REG+(ARG_RD),CLASS_BIT+4,CLASS_IMM+(ARG_IMM16),0,0,0,0,},2,4,136},
1632 
 
1633 
 
1634 
/* 0011 1100 ssN0 dddd *** inb rbd,@rs */
1635 
{
1636 
#ifdef NICENAMES
1637 
"inb rbd,@rs",8,12,
1638 
0x00,
1639 
#endif
1640 
"inb",OPC_inb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_IR+(ARG_RS),},
1641 
        {CLASS_BIT+3,CLASS_BIT+0xc,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,137},
1642 
 
1643 
 
1644 
/* 0011 1010 dddd 0100 imm16 *** inb rbd,imm16 */
1645 
{
1646 
#ifdef NICENAMES
1647 
"inb rbd,imm16",8,10,
1648 
0x00,
1649 
#endif
1650 
"inb",OPC_inb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_IMM+(ARG_IMM16),},
1651 
        {CLASS_BIT+3,CLASS_BIT+0xa,CLASS_REG+(ARG_RD),CLASS_BIT+4,CLASS_IMM+(ARG_IMM16),0,0,0,0,},2,4,138},
1652 
 
1653 
 
1654 
/* 0010 1001 ddN0 imm4m1 *** inc @rd,imm4m1 */
1655 
{
1656 
#ifdef NICENAMES
1657 
"inc @rd,imm4m1",16,11,
1658 
0x1c,
1659 
#endif
1660 
"inc",OPC_inc,0,{CLASS_IR+(ARG_RD),CLASS_IMM +(ARG_IMM4M1),},
1661 
        {CLASS_BIT+2,CLASS_BIT+9,CLASS_REGN0+(ARG_RD),CLASS_IMM+(ARG_IMM4M1),0,0,0,0,0,},2,2,139},
1662 
 
1663 
 
1664 
/* 0110 1001 ddN0 imm4m1 address_dst *** inc address_dst(rd),imm4m1 */
1665 
{
1666 
#ifdef NICENAMES
1667 
"inc address_dst(rd),imm4m1",16,14,
1668 
0x1c,
1669 
#endif
1670 
"inc",OPC_inc,0,{CLASS_X+(ARG_RD),CLASS_IMM +(ARG_IMM4M1),},
1671 
        {CLASS_BIT+6,CLASS_BIT+9,CLASS_REGN0+(ARG_RD),CLASS_IMM+(ARG_IMM4M1),CLASS_ADDRESS+(ARG_DST),0,0,0,0,},2,4,140},
1672 
 
1673 
 
1674 
/* 0110 1001 0000 imm4m1 address_dst *** inc address_dst,imm4m1 */
1675 
{
1676 
#ifdef NICENAMES
1677 
"inc address_dst,imm4m1",16,13,
1678 
0x1c,
1679 
#endif
1680 
"inc",OPC_inc,0,{CLASS_DA+(ARG_DST),CLASS_IMM +(ARG_IMM4M1),},
1681 
        {CLASS_BIT+6,CLASS_BIT+9,CLASS_BIT+0,CLASS_IMM+(ARG_IMM4M1),CLASS_ADDRESS+(ARG_DST),0,0,0,0,},2,4,141},
1682 
 
1683 
 
1684 
/* 1010 1001 dddd imm4m1 *** inc rd,imm4m1 */
1685 
{
1686 
#ifdef NICENAMES
1687 
"inc rd,imm4m1",16,4,
1688 
0x1c,
1689 
#endif
1690 
"inc",OPC_inc,0,{CLASS_REG_WORD+(ARG_RD),CLASS_IMM +(ARG_IMM4M1),},
1691 
        {CLASS_BIT+0xa,CLASS_BIT+9,CLASS_REG+(ARG_RD),CLASS_IMM+(ARG_IMM4M1),0,0,0,0,0,},2,2,142},
1692 
 
1693 
 
1694 
/* 0010 1000 ddN0 imm4m1 *** incb @rd,imm4m1 */
1695 
{
1696 
#ifdef NICENAMES
1697 
"incb @rd,imm4m1",8,11,
1698 
0x1c,
1699 
#endif
1700 
"incb",OPC_incb,0,{CLASS_IR+(ARG_RD),CLASS_IMM +(ARG_IMM4M1),},
1701 
        {CLASS_BIT+2,CLASS_BIT+8,CLASS_REGN0+(ARG_RD),CLASS_IMM+(ARG_IMM4M1),0,0,0,0,0,},2,2,143},
1702 
 
1703 
 
1704 
/* 0110 1000 ddN0 imm4m1 address_dst *** incb address_dst(rd),imm4m1 */
1705 
{
1706 
#ifdef NICENAMES
1707 
"incb address_dst(rd),imm4m1",8,14,
1708 
0x1c,
1709 
#endif
1710 
"incb",OPC_incb,0,{CLASS_X+(ARG_RD),CLASS_IMM +(ARG_IMM4M1),},
1711 
        {CLASS_BIT+6,CLASS_BIT+8,CLASS_REGN0+(ARG_RD),CLASS_IMM+(ARG_IMM4M1),CLASS_ADDRESS+(ARG_DST),0,0,0,0,},2,4,144},
1712 
 
1713 
 
1714 
/* 0110 1000 0000 imm4m1 address_dst *** incb address_dst,imm4m1 */
1715 
{
1716 
#ifdef NICENAMES
1717 
"incb address_dst,imm4m1",8,13,
1718 
0x1c,
1719 
#endif
1720 
"incb",OPC_incb,0,{CLASS_DA+(ARG_DST),CLASS_IMM +(ARG_IMM4M1),},
1721 
        {CLASS_BIT+6,CLASS_BIT+8,CLASS_BIT+0,CLASS_IMM+(ARG_IMM4M1),CLASS_ADDRESS+(ARG_DST),0,0,0,0,},2,4,145},
1722 
 
1723 
 
1724 
/* 1010 1000 dddd imm4m1 *** incb rbd,imm4m1 */
1725 
{
1726 
#ifdef NICENAMES
1727 
"incb rbd,imm4m1",8,4,
1728 
0x1c,
1729 
#endif
1730 
"incb",OPC_incb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_IMM +(ARG_IMM4M1),},
1731 
        {CLASS_BIT+0xa,CLASS_BIT+8,CLASS_REG+(ARG_RD),CLASS_IMM+(ARG_IMM4M1),0,0,0,0,0,},2,2,146},
1732 
 
1733 
 
1734 
/* 0011 1011 ssN0 1000 0000 aaaa ddN0 1000 *** ind @rd,@rs,ra */
1735 
{
1736 
#ifdef NICENAMES
1737 
"ind @rd,@rs,ra",16,21,
1738 
0x04,
1739 
#endif
1740 
"ind",OPC_ind,0,{CLASS_IR+(ARG_RD),CLASS_IR+(ARG_RS),CLASS_REG_WORD+(ARG_RA),},
1741 
        {CLASS_BIT+3,CLASS_BIT+0xb,CLASS_REGN0+(ARG_RS),CLASS_BIT+8,CLASS_BIT+0,CLASS_REG+(ARG_RA),CLASS_REGN0+(ARG_RD),CLASS_BIT+8,0,},3,4,147},
1742 
 
1743 
 
1744 
/* 0011 1010 ssN0 1000 0000 aaaa ddN0 1000 *** indb @rd,@rs,rba */
1745 
{
1746 
#ifdef NICENAMES
1747 
"indb @rd,@rs,rba",8,21,
1748 
0x04,
1749 
#endif
1750 
"indb",OPC_indb,0,{CLASS_IR+(ARG_RD),CLASS_IR+(ARG_RS),CLASS_REG_BYTE+(ARG_RA),},
1751 
        {CLASS_BIT+3,CLASS_BIT+0xa,CLASS_REGN0+(ARG_RS),CLASS_BIT+8,CLASS_BIT+0,CLASS_REG+(ARG_RA),CLASS_REGN0+(ARG_RD),CLASS_BIT+8,0,},3,4,148},
1752 
 
1753 
 
1754 
/* 0011 1010 ssN0 0000 0000 aaaa ddN0 1000 *** inib @rd,@rs,ra */
1755 
{
1756 
#ifdef NICENAMES
1757 
"inib @rd,@rs,ra",8,21,
1758 
0x04,
1759 
#endif
1760 
"inib",OPC_inib,0,{CLASS_IR+(ARG_RD),CLASS_IR+(ARG_RS),CLASS_REG_WORD+(ARG_RA),},
1761 
        {CLASS_BIT+3,CLASS_BIT+0xa,CLASS_REGN0+(ARG_RS),CLASS_BIT+0,CLASS_BIT+0,CLASS_REG+(ARG_RA),CLASS_REGN0+(ARG_RD),CLASS_BIT+8,0,},3,4,149},
1762 
 
1763 
 
1764 
/* 0011 1010 ssN0 0000 0000 aaaa ddN0 0000 *** inibr @rd,@rs,ra */
1765 
{
1766 
#ifdef NICENAMES
1767 
"inibr @rd,@rs,ra",16,21,
1768 
0x04,
1769 
#endif
1770 
"inibr",OPC_inibr,0,{CLASS_IR+(ARG_RD),CLASS_IR+(ARG_RS),CLASS_REG_WORD+(ARG_RA),},
1771 
        {CLASS_BIT+3,CLASS_BIT+0xa,CLASS_REGN0+(ARG_RS),CLASS_BIT+0,CLASS_BIT+0,CLASS_REG+(ARG_RA),CLASS_REGN0+(ARG_RD),CLASS_BIT+0,0,},3,4,150},
1772 
 
1773 
 
1774 
/* 0111 1011 0000 0000 *** iret */
1775 
{
1776 
#ifdef NICENAMES
1777 
"iret",16,13,
1778 
0x3f,
1779 
#endif
1780 
"iret",OPC_iret,0,{0},
1781 
        {CLASS_BIT+7,CLASS_BIT+0xb,CLASS_BIT+0,CLASS_BIT+0,0,0,0,0,0,},0,2,151},
1782 
 
1783 
 
1784 
/* 0001 1110 ddN0 cccc *** jp cc,@rd */
1785 
{
1786 
#ifdef NICENAMES
1787 
"jp cc,@rd",16,10,
1788 
0x00,
1789 
#endif
1790 
"jp",OPC_jp,0,{CLASS_CC,CLASS_IR+(ARG_RD),},
1791 
        {CLASS_BIT+1,CLASS_BIT+0xe,CLASS_REGN0+(ARG_RD),CLASS_CC,0,0,0,0,0,},2,2,152},
1792 
 
1793 
 
1794 
/* 0101 1110 0000 cccc address_dst *** jp cc,address_dst */
1795 
{
1796 
#ifdef NICENAMES
1797 
"jp cc,address_dst",16,7,
1798 
0x00,
1799 
#endif
1800 
"jp",OPC_jp,0,{CLASS_CC,CLASS_DA+(ARG_DST),},
1801 
        {CLASS_BIT+5,CLASS_BIT+0xe,CLASS_BIT+0,CLASS_CC,CLASS_ADDRESS+(ARG_DST),0,0,0,0,},2,4,153},
1802 
 
1803 
 
1804 
/* 0101 1110 ddN0 cccc address_dst *** jp cc,address_dst(rd) */
1805 
{
1806 
#ifdef NICENAMES
1807 
"jp cc,address_dst(rd)",16,8,
1808 
0x00,
1809 
#endif
1810 
"jp",OPC_jp,0,{CLASS_CC,CLASS_X+(ARG_RD),},
1811 
        {CLASS_BIT+5,CLASS_BIT+0xe,CLASS_REGN0+(ARG_RD),CLASS_CC,CLASS_ADDRESS+(ARG_DST),0,0,0,0,},2,4,154},
1812 
 
1813 
 
1814 
/* 1110 cccc disp8 *** jr cc,disp8 */
1815 
{
1816 
#ifdef NICENAMES
1817 
"jr cc,disp8",16,6,
1818 
0x00,
1819 
#endif
1820 
"jr",OPC_jr,0,{CLASS_CC,CLASS_DISP,},
1821 
        {CLASS_BIT+0xe,CLASS_CC,CLASS_DISP8,0,0,0,0,0,0,},2,2,155},
1822 
 
1823 
 
1824 
/* 0000 1101 ddN0 0101 imm16 *** ld @rd,imm16 */
1825 
{
1826 
#ifdef NICENAMES
1827 
"ld @rd,imm16",16,7,
1828 
0x00,
1829 
#endif
1830 
"ld",OPC_ld,0,{CLASS_IR+(ARG_RD),CLASS_IMM+(ARG_IMM16),},
1831 
        {CLASS_BIT+0,CLASS_BIT+0xd,CLASS_REGN0+(ARG_RD),CLASS_BIT+5,CLASS_IMM+(ARG_IMM16),0,0,0,0,},2,4,156},
1832 
 
1833 
 
1834 
/* 0010 1111 ddN0 ssss *** ld @rd,rs */
1835 
{
1836 
#ifdef NICENAMES
1837 
"ld @rd,rs",16,8,
1838 
0x00,
1839 
#endif
1840 
"ld",OPC_ld,0,{CLASS_IR+(ARG_RD),CLASS_REG_WORD+(ARG_RS),},
1841 
        {CLASS_BIT+2,CLASS_BIT+0xf,CLASS_REGN0+(ARG_RD),CLASS_REG+(ARG_RS),0,0,0,0,0,},2,2,157},
1842 
 
1843 
 
1844 
/* 0100 1101 ddN0 0101 address_dst imm16 *** ld address_dst(rd),imm16 */
1845 
{
1846 
#ifdef NICENAMES
1847 
"ld address_dst(rd),imm16",16,15,
1848 
0x00,
1849 
#endif
1850 
"ld",OPC_ld,0,{CLASS_X+(ARG_RD),CLASS_IMM+(ARG_IMM16),},
1851 
        {CLASS_BIT+4,CLASS_BIT+0xd,CLASS_REGN0+(ARG_RD),CLASS_BIT+5,CLASS_ADDRESS+(ARG_DST),CLASS_IMM+(ARG_IMM16),0,0,0,},2,6,158},
1852 
 
1853 
 
1854 
/* 0110 1111 ddN0 ssss address_dst *** ld address_dst(rd),rs */
1855 
{
1856 
#ifdef NICENAMES
1857 
"ld address_dst(rd),rs",16,12,
1858 
0x00,
1859 
#endif
1860 
"ld",OPC_ld,0,{CLASS_X+(ARG_RD),CLASS_REG_WORD+(ARG_RS),},
1861 
        {CLASS_BIT+6,CLASS_BIT+0xf,CLASS_REGN0+(ARG_RD),CLASS_REG+(ARG_RS),CLASS_ADDRESS+(ARG_DST),0,0,0,0,},2,4,159},
1862 
 
1863 
 
1864 
/* 0100 1101 0000 0101 address_dst imm16 *** ld address_dst,imm16 */
1865 
{
1866 
#ifdef NICENAMES
1867 
"ld address_dst,imm16",16,14,
1868 
0x00,
1869 
#endif
1870 
"ld",OPC_ld,0,{CLASS_DA+(ARG_DST),CLASS_IMM+(ARG_IMM16),},
1871 
        {CLASS_BIT+4,CLASS_BIT+0xd,CLASS_BIT+0,CLASS_BIT+5,CLASS_ADDRESS+(ARG_DST),CLASS_IMM+(ARG_IMM16),0,0,0,},2,6,160},
1872 
 
1873 
 
1874 
/* 0110 1111 0000 ssss address_dst *** ld address_dst,rs */
1875 
{
1876 
#ifdef NICENAMES
1877 
"ld address_dst,rs",16,11,
1878 
0x00,
1879 
#endif
1880 
"ld",OPC_ld,0,{CLASS_DA+(ARG_DST),CLASS_REG_WORD+(ARG_RS),},
1881 
        {CLASS_BIT+6,CLASS_BIT+0xf,CLASS_BIT+0,CLASS_REG+(ARG_RS),CLASS_ADDRESS+(ARG_DST),0,0,0,0,},2,4,161},
1882 
 
1883 
 
1884 
/* 0011 0011 ddN0 ssss imm16 *** ld rd(imm16),rs */
1885 
{
1886 
#ifdef NICENAMES
1887 
"ld rd(imm16),rs",16,14,
1888 
0x00,
1889 
#endif
1890 
"ld",OPC_ld,0,{CLASS_BA+(ARG_RD),CLASS_REG_WORD+(ARG_RS),},
1891 
        {CLASS_BIT+3,CLASS_BIT+3,CLASS_REGN0+(ARG_RD),CLASS_REG+(ARG_RS),CLASS_IMM+(ARG_IMM16),0,0,0,0,},2,4,162},
1892 
 
1893 
 
1894 
/* 0111 0011 ddN0 ssss 0000 xxxx 0000 0000 *** ld rd(rx),rs */
1895 
{
1896 
#ifdef NICENAMES
1897 
"ld rd(rx),rs",16,14,
1898 
0x00,
1899 
#endif
1900 
"ld",OPC_ld,0,{CLASS_BX+(ARG_RD),CLASS_REG_WORD+(ARG_RS),},
1901 
        {CLASS_BIT+7,CLASS_BIT+3,CLASS_REGN0+(ARG_RD),CLASS_REG+(ARG_RS),CLASS_BIT+0,CLASS_REG+(ARG_RX),CLASS_BIT+0,CLASS_BIT+0,0,},2,4,163},
1902 
 
1903 
 
1904 
/* 0010 0001 ssN0 dddd *** ld rd,@rs */
1905 
{
1906 
#ifdef NICENAMES
1907 
"ld rd,@rs",16,7,
1908 
0x00,
1909 
#endif
1910 
"ld",OPC_ld,0,{CLASS_REG_WORD+(ARG_RD),CLASS_IR+(ARG_RS),},
1911 
        {CLASS_BIT+2,CLASS_BIT+1,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,164},
1912 
 
1913 
 
1914 
/* 0110 0001 0000 dddd address_src *** ld rd,address_src */
1915 
{
1916 
#ifdef NICENAMES
1917 
"ld rd,address_src",16,9,
1918 
0x00,
1919 
#endif
1920 
"ld",OPC_ld,0,{CLASS_REG_WORD+(ARG_RD),CLASS_DA+(ARG_SRC),},
1921 
        {CLASS_BIT+6,CLASS_BIT+1,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,165},
1922 
 
1923 
 
1924 
/* 0110 0001 ssN0 dddd address_src *** ld rd,address_src(rs) */
1925 
{
1926 
#ifdef NICENAMES
1927 
"ld rd,address_src(rs)",16,10,
1928 
0x00,
1929 
#endif
1930 
"ld",OPC_ld,0,{CLASS_REG_WORD+(ARG_RD),CLASS_X+(ARG_RS),},
1931 
        {CLASS_BIT+6,CLASS_BIT+1,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,166},
1932 
 
1933 
 
1934 
/* 0010 0001 0000 dddd imm16 *** ld rd,imm16 */
1935 
{
1936 
#ifdef NICENAMES
1937 
"ld rd,imm16",16,7,
1938 
0x00,
1939 
#endif
1940 
"ld",OPC_ld,0,{CLASS_REG_WORD+(ARG_RD),CLASS_IMM+(ARG_IMM16),},
1941 
        {CLASS_BIT+2,CLASS_BIT+1,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_IMM+(ARG_IMM16),0,0,0,0,},2,4,167},
1942 
 
1943 
 
1944 
/* 1010 0001 ssss dddd *** ld rd,rs */
1945 
{
1946 
#ifdef NICENAMES
1947 
"ld rd,rs",16,3,
1948 
0x00,
1949 
#endif
1950 
"ld",OPC_ld,0,{CLASS_REG_WORD+(ARG_RD),CLASS_REG_WORD+(ARG_RS),},
1951 
        {CLASS_BIT+0xa,CLASS_BIT+1,CLASS_REG+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,168},
1952 
 
1953 
 
1954 
/* 0011 0001 ssN0 dddd imm16 *** ld rd,rs(imm16) */
1955 
{
1956 
#ifdef NICENAMES
1957 
"ld rd,rs(imm16)",16,14,
1958 
0x00,
1959 
#endif
1960 
"ld",OPC_ld,0,{CLASS_REG_WORD+(ARG_RD),CLASS_BA+(ARG_RS),},
1961 
        {CLASS_BIT+3,CLASS_BIT+1,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),CLASS_IMM+(ARG_IMM16),0,0,0,0,},2,4,169},
1962 
 
1963 
 
1964 
/* 0111 0001 ssN0 dddd 0000 xxxx 0000 0000 *** ld rd,rs(rx) */
1965 
{
1966 
#ifdef NICENAMES
1967 
"ld rd,rs(rx)",16,14,
1968 
0x00,
1969 
#endif
1970 
"ld",OPC_ld,0,{CLASS_REG_WORD+(ARG_RD),CLASS_BX+(ARG_RS),},
1971 
        {CLASS_BIT+7,CLASS_BIT+1,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),CLASS_BIT+0,CLASS_REG+(ARG_RX),CLASS_BIT+0,CLASS_BIT+0,0,},2,4,170},
1972 
 
1973 
 
1974 
/* 0111 0110 0000 dddd address_src *** lda prd,address_src */
1975 
{
1976 
#ifdef NICENAMES
1977 
"lda prd,address_src",16,12,
1978 
0x00,
1979 
#endif
1980 
"lda",OPC_lda,0,{CLASS_PR+(ARG_RD),CLASS_DA+(ARG_SRC),},
1981 
        {CLASS_BIT+7,CLASS_BIT+6,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,171},
1982 
 
1983 
 
1984 
/* 0111 0110 ssN0 dddd address_src *** lda prd,address_src(rs) */
1985 
{
1986 
#ifdef NICENAMES
1987 
"lda prd,address_src(rs)",16,13,
1988 
0x00,
1989 
#endif
1990 
"lda",OPC_lda,0,{CLASS_PR+(ARG_RD),CLASS_X+(ARG_RS),},
1991 
        {CLASS_BIT+7,CLASS_BIT+6,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,172},
1992 
 
1993 
 
1994 
/* 0011 0100 ssN0 dddd imm16 *** lda prd,rs(imm16) */
1995 
{
1996 
#ifdef NICENAMES
1997 
"lda prd,rs(imm16)",16,15,
1998 
0x00,
1999 
#endif
2000 
"lda",OPC_lda,0,{CLASS_PR+(ARG_RD),CLASS_BA+(ARG_RS),},
2001 
        {CLASS_BIT+3,CLASS_BIT+4,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),CLASS_IMM+(ARG_IMM16),0,0,0,0,},2,4,173},
2002 
 
2003 
 
2004 
/* 0111 0100 ssN0 dddd 0000 xxxx 0000 0000 *** lda prd,rs(rx) */
2005 
{
2006 
#ifdef NICENAMES
2007 
"lda prd,rs(rx)",16,15,
2008 
0x00,
2009 
#endif
2010 
"lda",OPC_lda,0,{CLASS_PR+(ARG_RD),CLASS_BX+(ARG_RS),},
2011 
        {CLASS_BIT+7,CLASS_BIT+4,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),CLASS_BIT+0,CLASS_REG+(ARG_RX),CLASS_BIT+0,CLASS_BIT+0,0,},2,4,174},
2012 
 
2013 
 
2014 
/* 0011 0100 0000 dddd disp16 *** ldar prd,disp16 */
2015 
{
2016 
#ifdef NICENAMES
2017 
"ldar prd,disp16",16,15,
2018 
0x00,
2019 
#endif
2020 
"ldar",OPC_ldar,0,{CLASS_PR+(ARG_RD),CLASS_DISP,},
2021 
        {CLASS_BIT+3,CLASS_BIT+4,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_DISP+(ARG_DISP16),0,0,0,0,},2,4,175},
2022 
 
2023 
 
2024 
/* 0000 1100 ddN0 0101 imm8 imm8 *** ldb @rd,imm8 */
2025 
{
2026 
#ifdef NICENAMES
2027 
"ldb @rd,imm8",8,7,
2028 
0x00,
2029 
#endif
2030 
"ldb",OPC_ldb,0,{CLASS_IR+(ARG_RD),CLASS_IMM+(ARG_IMM8),},
2031 
        {CLASS_BIT+0,CLASS_BIT+0xc,CLASS_REGN0+(ARG_RD),CLASS_BIT+5,CLASS_IMM+(ARG_IMM8),CLASS_IMM+(ARG_IMM8),0,0,0,},2,4,176},
2032 
 
2033 
 
2034 
/* 0010 1110 ddN0 ssss *** ldb @rd,rbs */
2035 
{
2036 
#ifdef NICENAMES
2037 
"ldb @rd,rbs",8,8,
2038 
0x00,
2039 
#endif
2040 
"ldb",OPC_ldb,0,{CLASS_IR+(ARG_RD),CLASS_REG_BYTE+(ARG_RS),},
2041 
        {CLASS_BIT+2,CLASS_BIT+0xe,CLASS_REGN0+(ARG_RD),CLASS_REG+(ARG_RS),0,0,0,0,0,},2,2,177},
2042 
 
2043 
 
2044 
/* 0100 1100 ddN0 0101 address_dst imm8 imm8 *** ldb address_dst(rd),imm8 */
2045 
{
2046 
#ifdef NICENAMES
2047 
"ldb address_dst(rd),imm8",8,15,
2048 
0x00,
2049 
#endif
2050 
"ldb",OPC_ldb,0,{CLASS_X+(ARG_RD),CLASS_IMM+(ARG_IMM8),},
2051 
        {CLASS_BIT+4,CLASS_BIT+0xc,CLASS_REGN0+(ARG_RD),CLASS_BIT+5,CLASS_ADDRESS+(ARG_DST),CLASS_IMM+(ARG_IMM8),CLASS_IMM+(ARG_IMM8),0,0,},2,6,178},
2052 
 
2053 
 
2054 
/* 0110 1110 ddN0 ssss address_dst *** ldb address_dst(rd),rbs */
2055 
{
2056 
#ifdef NICENAMES
2057 
"ldb address_dst(rd),rbs",8,12,
2058 
0x00,
2059 
#endif
2060 
"ldb",OPC_ldb,0,{CLASS_X+(ARG_RD),CLASS_REG_BYTE+(ARG_RS),},
2061 
        {CLASS_BIT+6,CLASS_BIT+0xe,CLASS_REGN0+(ARG_RD),CLASS_REG+(ARG_RS),CLASS_ADDRESS+(ARG_DST),0,0,0,0,},2,4,179},
2062 
 
2063 
 
2064 
/* 0100 1100 0000 0101 address_dst imm8 imm8 *** ldb address_dst,imm8 */
2065 
{
2066 
#ifdef NICENAMES
2067 
"ldb address_dst,imm8",8,14,
2068 
0x00,
2069 
#endif
2070 
"ldb",OPC_ldb,0,{CLASS_DA+(ARG_DST),CLASS_IMM+(ARG_IMM8),},
2071 
        {CLASS_BIT+4,CLASS_BIT+0xc,CLASS_BIT+0,CLASS_BIT+5,CLASS_ADDRESS+(ARG_DST),CLASS_IMM+(ARG_IMM8),CLASS_IMM+(ARG_IMM8),0,0,},2,6,180},
2072 
 
2073 
 
2074 
/* 0110 1110 0000 ssss address_dst *** ldb address_dst,rbs */
2075 
{
2076 
#ifdef NICENAMES
2077 
"ldb address_dst,rbs",8,11,
2078 
0x00,
2079 
#endif
2080 
"ldb",OPC_ldb,0,{CLASS_DA+(ARG_DST),CLASS_REG_BYTE+(ARG_RS),},
2081 
        {CLASS_BIT+6,CLASS_BIT+0xe,CLASS_BIT+0,CLASS_REG+(ARG_RS),CLASS_ADDRESS+(ARG_DST),0,0,0,0,},2,4,181},
2082 
 
2083 
 
2084 
/* 0010 0000 ssN0 dddd *** ldb rbd,@rs */
2085 
{
2086 
#ifdef NICENAMES
2087 
"ldb rbd,@rs",8,7,
2088 
0x00,
2089 
#endif
2090 
"ldb",OPC_ldb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_IR+(ARG_RS),},
2091 
        {CLASS_BIT+2,CLASS_BIT+0,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,182},
2092 
 
2093 
 
2094 
/* 0110 0000 0000 dddd address_src *** ldb rbd,address_src */
2095 
{
2096 
#ifdef NICENAMES
2097 
"ldb rbd,address_src",8,9,
2098 
0x00,
2099 
#endif
2100 
"ldb",OPC_ldb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_DA+(ARG_SRC),},
2101 
        {CLASS_BIT+6,CLASS_BIT+0,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,183},
2102 
 
2103 
 
2104 
/* 0110 0000 ssN0 dddd address_src *** ldb rbd,address_src(rs) */
2105 
{
2106 
#ifdef NICENAMES
2107 
"ldb rbd,address_src(rs)",8,10,
2108 
0x00,
2109 
#endif
2110 
"ldb",OPC_ldb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_X+(ARG_RS),},
2111 
        {CLASS_BIT+6,CLASS_BIT+0,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,184},
2112 
 
2113 
 
2114 
/* 1100 dddd imm8 *** ldb rbd,imm8 */
2115 
{
2116 
#ifdef NICENAMES
2117 
"ldb rbd,imm8",8,5,
2118 
0x00,
2119 
#endif
2120 
"ldb",OPC_ldb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_IMM+(ARG_IMM8),},
2121 
        {CLASS_BIT+0xc,CLASS_REG+(ARG_RD),CLASS_IMM+(ARG_IMM8),0,0,0,0,0,0,},2,2,185},
2122 
 
2123 
 
2124 
/* 1010 0000 ssss dddd *** ldb rbd,rbs */
2125 
{
2126 
#ifdef NICENAMES
2127 
"ldb rbd,rbs",8,3,
2128 
0x00,
2129 
#endif
2130 
"ldb",OPC_ldb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_REG_BYTE+(ARG_RS),},
2131 
        {CLASS_BIT+0xa,CLASS_BIT+0,CLASS_REG+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,186},
2132 
 
2133 
 
2134 
/* 0011 0000 ssN0 dddd imm16 *** ldb rbd,rs(imm16) */
2135 
{
2136 
#ifdef NICENAMES
2137 
"ldb rbd,rs(imm16)",8,14,
2138 
0x00,
2139 
#endif
2140 
"ldb",OPC_ldb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_BA+(ARG_RS),},
2141 
        {CLASS_BIT+3,CLASS_BIT+0,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),CLASS_IMM+(ARG_IMM16),0,0,0,0,},2,4,187},
2142 
 
2143 
 
2144 
/* 0111 0000 ssN0 dddd 0000 xxxx 0000 0000 *** ldb rbd,rs(rx) */
2145 
{
2146 
#ifdef NICENAMES
2147 
"ldb rbd,rs(rx)",8,14,
2148 
0x00,
2149 
#endif
2150 
"ldb",OPC_ldb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_BX+(ARG_RS),},
2151 
        {CLASS_BIT+7,CLASS_BIT+0,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),CLASS_BIT+0,CLASS_REG+(ARG_RX),CLASS_BIT+0,CLASS_BIT+0,0,},2,4,188},
2152 
 
2153 
 
2154 
/* 0011 0010 ddN0 ssss imm16 *** ldb rd(imm16),rbs */
2155 
{
2156 
#ifdef NICENAMES
2157 
"ldb rd(imm16),rbs",8,14,
2158 
0x00,
2159 
#endif
2160 
"ldb",OPC_ldb,0,{CLASS_BA+(ARG_RD),CLASS_REG_BYTE+(ARG_RS),},
2161 
        {CLASS_BIT+3,CLASS_BIT+2,CLASS_REGN0+(ARG_RD),CLASS_REG+(ARG_RS),CLASS_IMM+(ARG_IMM16),0,0,0,0,},2,4,189},
2162 
 
2163 
 
2164 
/* 0111 0010 ddN0 ssss 0000 xxxx 0000 0000 *** ldb rd(rx),rbs */
2165 
{
2166 
#ifdef NICENAMES
2167 
"ldb rd(rx),rbs",8,14,
2168 
0x00,
2169 
#endif
2170 
"ldb",OPC_ldb,0,{CLASS_BX+(ARG_RD),CLASS_REG_BYTE+(ARG_RS),},
2171 
        {CLASS_BIT+7,CLASS_BIT+2,CLASS_REGN0+(ARG_RD),CLASS_REG+(ARG_RS),CLASS_BIT+0,CLASS_REG+(ARG_RX),CLASS_BIT+0,CLASS_BIT+0,0,},2,4,190},
2172 
 
2173 
 
2174 
/* 0111 1101 ssss 1ccc *** ldctl ctrl,rs */
2175 
{
2176 
#ifdef NICENAMES
2177 
"ldctl ctrl,rs",32,7,
2178 
0x00,
2179 
#endif
2180 
"ldctl",OPC_ldctl,0,{CLASS_CTRL,CLASS_REG_WORD+(ARG_RS),},
2181 
        {CLASS_BIT+7,CLASS_BIT+0xd,CLASS_REG+(ARG_RS),CLASS_1CCC,0,0,0,0,0,},2,2,191},
2182 
 
2183 
 
2184 
/* 0111 1101 dddd 0ccc *** ldctl rd,ctrl */
2185 
{
2186 
#ifdef NICENAMES
2187 
"ldctl rd,ctrl",32,7,
2188 
0x00,
2189 
#endif
2190 
"ldctl",OPC_ldctl,0,{CLASS_REG_WORD+(ARG_RD),CLASS_CTRL,},
2191 
        {CLASS_BIT+7,CLASS_BIT+0xd,CLASS_REG+(ARG_RD),CLASS_0CCC,0,0,0,0,0,},2,2,192},
2192 
 
2193 
 
2194 
/* 1000 1100 ssss 1001 *** ldctlb ctrl,rbs */
2195 
{
2196 
#ifdef NICENAMES
2197 
"ldctlb ctrl,rbs",32,7,
2198 
0x3f,
2199 
#endif
2200 
"ldctlb",OPC_ldctlb,0,{CLASS_CTRL,CLASS_REG_BYTE+(ARG_RS),},
2201 
        {CLASS_BIT+8,CLASS_BIT+0xc,CLASS_REG+(ARG_RS),CLASS_BIT+9,0,0,0,0,0,},2,2,193},
2202 
 
2203 
 
2204 
/* 1000 1100 dddd 0001 *** ldctlb rbd,ctrl */
2205 
{
2206 
#ifdef NICENAMES
2207 
"ldctlb rbd,ctrl",32,7,
2208 
0x00,
2209 
#endif
2210 
"ldctlb",OPC_ldctlb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_CTRL,},
2211 
        {CLASS_BIT+8,CLASS_BIT+0xc,CLASS_REG+(ARG_RD),CLASS_BIT+1,0,0,0,0,0,},2,2,194},
2212 
 
2213 
 
2214 
/* 1011 1011 ssN0 1001 0000 rrrr ddN0 1000 *** ldd @rd,@rs,rr */
2215 
{
2216 
#ifdef NICENAMES
2217 
"ldd @rd,@rs,rr",16,11,
2218 
0x04,
2219 
#endif
2220 
"ldd",OPC_ldd,0,{CLASS_IR+(ARG_RD),CLASS_IR+(ARG_RS),CLASS_REG_WORD+(ARG_RR),},
2221 
        {CLASS_BIT+0xb,CLASS_BIT+0xb,CLASS_REGN0+(ARG_RS),CLASS_BIT+9,CLASS_BIT+0,CLASS_REG+(ARG_RR),CLASS_REGN0+(ARG_RD),CLASS_BIT+8,0,},3,4,195},
2222 
 
2223 
 
2224 
/* 1011 1010 ssN0 1001 0000 rrrr ddN0 1000 *** lddb @rd,@rs,rr */
2225 
{
2226 
#ifdef NICENAMES
2227 
"lddb @rd,@rs,rr",8,11,
2228 
0x04,
2229 
#endif
2230 
"lddb",OPC_lddb,0,{CLASS_IR+(ARG_RD),CLASS_IR+(ARG_RS),CLASS_REG_WORD+(ARG_RR),},
2231 
        {CLASS_BIT+0xb,CLASS_BIT+0xa,CLASS_REGN0+(ARG_RS),CLASS_BIT+9,CLASS_BIT+0,CLASS_REG+(ARG_RR),CLASS_REGN0+(ARG_RD),CLASS_BIT+8,0,},3,4,196},
2232 
 
2233 
 
2234 
/* 1011 1011 ssN0 1001 0000 rrrr ddN0 0000 *** lddr @rd,@rs,rr */
2235 
{
2236 
#ifdef NICENAMES
2237 
"lddr @rd,@rs,rr",16,11,
2238 
0x04,
2239 
#endif
2240 
"lddr",OPC_lddr,0,{CLASS_IR+(ARG_RD),CLASS_IR+(ARG_RS),CLASS_REG_WORD+(ARG_RR),},
2241 
        {CLASS_BIT+0xb,CLASS_BIT+0xb,CLASS_REGN0+(ARG_RS),CLASS_BIT+9,CLASS_BIT+0,CLASS_REG+(ARG_RR),CLASS_REGN0+(ARG_RD),CLASS_BIT+0,0,},3,4,197},
2242 
 
2243 
 
2244 
/* 1011 1010 ssN0 1001 0000 rrrr ddN0 0000 *** lddrb @rd,@rs,rr */
2245 
{
2246 
#ifdef NICENAMES
2247 
"lddrb @rd,@rs,rr",8,11,
2248 
0x04,
2249 
#endif
2250 
"lddrb",OPC_lddrb,0,{CLASS_IR+(ARG_RD),CLASS_IR+(ARG_RS),CLASS_REG_WORD+(ARG_RR),},
2251 
        {CLASS_BIT+0xb,CLASS_BIT+0xa,CLASS_REGN0+(ARG_RS),CLASS_BIT+9,CLASS_BIT+0,CLASS_REG+(ARG_RR),CLASS_REGN0+(ARG_RD),CLASS_BIT+0,0,},3,4,198},
2252 
 
2253 
 
2254 
/* 1011 1011 ssN0 0001 0000 rrrr ddN0 1000 *** ldi @rd,@rs,rr */
2255 
{
2256 
#ifdef NICENAMES
2257 
"ldi @rd,@rs,rr",16,11,
2258 
0x04,
2259 
#endif
2260 
"ldi",OPC_ldi,0,{CLASS_IR+(ARG_RD),CLASS_IR+(ARG_RS),CLASS_REG_WORD+(ARG_RR),},
2261 
        {CLASS_BIT+0xb,CLASS_BIT+0xb,CLASS_REGN0+(ARG_RS),CLASS_BIT+1,CLASS_BIT+0,CLASS_REG+(ARG_RR),CLASS_REGN0+(ARG_RD),CLASS_BIT+8,0,},3,4,199},
2262 
 
2263 
 
2264 
/* 1011 1010 ssN0 0001 0000 rrrr ddN0 1000 *** ldib @rd,@rs,rr */
2265 
{
2266 
#ifdef NICENAMES
2267 
"ldib @rd,@rs,rr",8,11,
2268 
0x04,
2269 
#endif
2270 
"ldib",OPC_ldib,0,{CLASS_IR+(ARG_RD),CLASS_IR+(ARG_RS),CLASS_REG_WORD+(ARG_RR),},
2271 
        {CLASS_BIT+0xb,CLASS_BIT+0xa,CLASS_REGN0+(ARG_RS),CLASS_BIT+1,CLASS_BIT+0,CLASS_REG+(ARG_RR),CLASS_REGN0+(ARG_RD),CLASS_BIT+8,0,},3,4,200},
2272 
 
2273 
 
2274 
/* 1011 1011 ssN0 0001 0000 rrrr ddN0 0000 *** ldir @rd,@rs,rr */
2275 
{
2276 
#ifdef NICENAMES
2277 
"ldir @rd,@rs,rr",16,11,
2278 
0x04,
2279 
#endif
2280 
"ldir",OPC_ldir,0,{CLASS_IR+(ARG_RD),CLASS_IR+(ARG_RS),CLASS_REG_WORD+(ARG_RR),},
2281 
        {CLASS_BIT+0xb,CLASS_BIT+0xb,CLASS_REGN0+(ARG_RS),CLASS_BIT+1,CLASS_BIT+0,CLASS_REG+(ARG_RR),CLASS_REGN0+(ARG_RD),CLASS_BIT+0,0,},3,4,201},
2282 
 
2283 
 
2284 
/* 1011 1010 ssN0 0001 0000 rrrr ddN0 0000 *** ldirb @rd,@rs,rr */
2285 
{
2286 
#ifdef NICENAMES
2287 
"ldirb @rd,@rs,rr",8,11,
2288 
0x04,
2289 
#endif
2290 
"ldirb",OPC_ldirb,0,{CLASS_IR+(ARG_RD),CLASS_IR+(ARG_RS),CLASS_REG_WORD+(ARG_RR),},
2291 
        {CLASS_BIT+0xb,CLASS_BIT+0xa,CLASS_REGN0+(ARG_RS),CLASS_BIT+1,CLASS_BIT+0,CLASS_REG+(ARG_RR),CLASS_REGN0+(ARG_RD),CLASS_BIT+0,0,},3,4,202},
2292 
 
2293 
 
2294 
/* 1011 1101 dddd imm4 *** ldk rd,imm4 */
2295 
{
2296 
#ifdef NICENAMES
2297 
"ldk rd,imm4",16,5,
2298 
0x00,
2299 
#endif
2300 
"ldk",OPC_ldk,0,{CLASS_REG_WORD+(ARG_RD),CLASS_IMM +(ARG_IMM4),},
2301 
        {CLASS_BIT+0xb,CLASS_BIT+0xd,CLASS_REG+(ARG_RD),CLASS_IMM+(ARG_IMM4),0,0,0,0,0,},2,2,203},
2302 
 
2303 
 
2304 
/* 0001 1101 ddN0 ssss *** ldl @rd,rrs */
2305 
{
2306 
#ifdef NICENAMES
2307 
"ldl @rd,rrs",32,11,
2308 
0x00,
2309 
#endif
2310 
"ldl",OPC_ldl,0,{CLASS_IR+(ARG_RD),CLASS_REG_LONG+(ARG_RS),},
2311 
        {CLASS_BIT+1,CLASS_BIT+0xd,CLASS_REGN0+(ARG_RD),CLASS_REG+(ARG_RS),0,0,0,0,0,},2,2,204},
2312 
 
2313 
 
2314 
/* 0101 1101 ddN0 ssss address_dst *** ldl address_dst(rd),rrs */
2315 
{
2316 
#ifdef NICENAMES
2317 
"ldl address_dst(rd),rrs",32,14,
2318 
0x00,
2319 
#endif
2320 
"ldl",OPC_ldl,0,{CLASS_X+(ARG_RD),CLASS_REG_LONG+(ARG_RS),},
2321 
        {CLASS_BIT+5,CLASS_BIT+0xd,CLASS_REGN0+(ARG_RD),CLASS_REG+(ARG_RS),CLASS_ADDRESS+(ARG_DST),0,0,0,0,},2,4,205},
2322 
 
2323 
 
2324 
/* 0101 1101 0000 ssss address_dst *** ldl address_dst,rrs */
2325 
{
2326 
#ifdef NICENAMES
2327 
"ldl address_dst,rrs",32,15,
2328 
0x00,
2329 
#endif
2330 
"ldl",OPC_ldl,0,{CLASS_DA+(ARG_DST),CLASS_REG_LONG+(ARG_RS),},
2331 
        {CLASS_BIT+5,CLASS_BIT+0xd,CLASS_BIT+0,CLASS_REG+(ARG_RS),CLASS_ADDRESS+(ARG_DST),0,0,0,0,},2,4,206},
2332 
 
2333 
 
2334 
/* 0011 0111 ddN0 ssss imm16 *** ldl rd(imm16),rrs */
2335 
{
2336 
#ifdef NICENAMES
2337 
"ldl rd(imm16),rrs",32,17,
2338 
0x00,
2339 
#endif
2340 
"ldl",OPC_ldl,0,{CLASS_BA+(ARG_RD),CLASS_REG_LONG+(ARG_RS),},
2341 
        {CLASS_BIT+3,CLASS_BIT+7,CLASS_REGN0+(ARG_RD),CLASS_REG+(ARG_RS),CLASS_IMM+(ARG_IMM16),0,0,0,0,},2,4,207},
2342 
 
2343 
 
2344 
/* 0111 0111 ddN0 ssss 0000 xxxx 0000 0000 *** ldl rd(rx),rrs */
2345 
{
2346 
#ifdef NICENAMES
2347 
"ldl rd(rx),rrs",32,17,
2348 
0x00,
2349 
#endif
2350 
"ldl",OPC_ldl,0,{CLASS_BX+(ARG_RD),CLASS_REG_LONG+(ARG_RS),},
2351 
        {CLASS_BIT+7,CLASS_BIT+7,CLASS_REGN0+(ARG_RD),CLASS_REG+(ARG_RS),CLASS_BIT+0,CLASS_REG+(ARG_RX),CLASS_BIT+0,CLASS_BIT+0,0,},2,4,208},
2352 
 
2353 
 
2354 
/* 0001 0100 ssN0 dddd *** ldl rrd,@rs */
2355 
{
2356 
#ifdef NICENAMES
2357 
"ldl rrd,@rs",32,11,
2358 
0x00,
2359 
#endif
2360 
"ldl",OPC_ldl,0,{CLASS_REG_LONG+(ARG_RD),CLASS_IR+(ARG_RS),},
2361 
        {CLASS_BIT+1,CLASS_BIT+4,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,209},
2362 
 
2363 
 
2364 
/* 0101 0100 0000 dddd address_src *** ldl rrd,address_src */
2365 
{
2366 
#ifdef NICENAMES
2367 
"ldl rrd,address_src",32,12,
2368 
0x00,
2369 
#endif
2370 
"ldl",OPC_ldl,0,{CLASS_REG_LONG+(ARG_RD),CLASS_DA+(ARG_SRC),},
2371 
        {CLASS_BIT+5,CLASS_BIT+4,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,210},
2372 
 
2373 
 
2374 
/* 0101 0100 ssN0 dddd address_src *** ldl rrd,address_src(rs) */
2375 
{
2376 
#ifdef NICENAMES
2377 
"ldl rrd,address_src(rs)",32,13,
2378 
0x00,
2379 
#endif
2380 
"ldl",OPC_ldl,0,{CLASS_REG_LONG+(ARG_RD),CLASS_X+(ARG_RS),},
2381 
        {CLASS_BIT+5,CLASS_BIT+4,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,211},
2382 
 
2383 
 
2384 
/* 0001 0100 0000 dddd imm32 *** ldl rrd,imm32 */
2385 
{
2386 
#ifdef NICENAMES
2387 
"ldl rrd,imm32",32,11,
2388 
0x00,
2389 
#endif
2390 
"ldl",OPC_ldl,0,{CLASS_REG_LONG+(ARG_RD),CLASS_IMM+(ARG_IMM32),},
2391 
        {CLASS_BIT+1,CLASS_BIT+4,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_IMM+(ARG_IMM32),0,0,0,0,},2,6,212},
2392 
 
2393 
 
2394 
/* 1001 0100 ssss dddd *** ldl rrd,rrs */
2395 
{
2396 
#ifdef NICENAMES
2397 
"ldl rrd,rrs",32,5,
2398 
0x00,
2399 
#endif
2400 
"ldl",OPC_ldl,0,{CLASS_REG_LONG+(ARG_RD),CLASS_REG_LONG+(ARG_RS),},
2401 
        {CLASS_BIT+9,CLASS_BIT+4,CLASS_REG+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,213},
2402 
 
2403 
 
2404 
/* 0011 0101 ssN0 dddd imm16 *** ldl rrd,rs(imm16) */
2405 
{
2406 
#ifdef NICENAMES
2407 
"ldl rrd,rs(imm16)",32,17,
2408 
0x00,
2409 
#endif
2410 
"ldl",OPC_ldl,0,{CLASS_REG_LONG+(ARG_RD),CLASS_BA+(ARG_RS),},
2411 
        {CLASS_BIT+3,CLASS_BIT+5,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),CLASS_IMM+(ARG_IMM16),0,0,0,0,},2,4,214},
2412 
 
2413 
 
2414 
/* 0111 0101 ssN0 dddd 0000 xxxx 0000 0000 *** ldl rrd,rs(rx) */
2415 
{
2416 
#ifdef NICENAMES
2417 
"ldl rrd,rs(rx)",32,17,
2418 
0x00,
2419 
#endif
2420 
"ldl",OPC_ldl,0,{CLASS_REG_LONG+(ARG_RD),CLASS_BX+(ARG_RS),},
2421 
        {CLASS_BIT+7,CLASS_BIT+5,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),CLASS_BIT+0,CLASS_REG+(ARG_RX),CLASS_BIT+0,CLASS_BIT+0,0,},2,4,215},
2422 
 
2423 
 
2424 
/* 0001 1100 ddN0 1001 0000 ssss 0000 imm4m1 *** ldm @rd,rs,n */
2425 
{
2426 
#ifdef NICENAMES
2427 
"ldm @rd,rs,n",16,11,
2428 
0x00,
2429 
#endif
2430 
"ldm",OPC_ldm,0,{CLASS_IR+(ARG_RD),CLASS_REG_WORD+(ARG_RS),CLASS_IMM + (ARG_IMM4M1),},
2431 
        {CLASS_BIT+1,CLASS_BIT+0xc,CLASS_REGN0+(ARG_RD),CLASS_BIT+9,CLASS_BIT+0,CLASS_REG+(ARG_RS),CLASS_BIT+0,CLASS_IMM+(ARG_IMM4M1),0,},3,4,216},
2432 
 
2433 
 
2434 
/* 0101 1100 ddN0 1001 0000 ssss 0000 imm4m1 address_dst *** ldm address_dst(rd),rs,n */
2435 
{
2436 
#ifdef NICENAMES
2437 
"ldm address_dst(rd),rs,n",16,15,
2438 
0x00,
2439 
#endif
2440 
"ldm",OPC_ldm,0,{CLASS_X+(ARG_RD),CLASS_REG_WORD+(ARG_RS),CLASS_IMM + (ARG_IMM4M1),},
2441 
        {CLASS_BIT+5,CLASS_BIT+0xc,CLASS_REGN0+(ARG_RD),CLASS_BIT+9,CLASS_BIT+0,CLASS_REG+(ARG_RS),CLASS_BIT+0,CLASS_IMM+(ARG_IMM4M1),CLASS_ADDRESS+(ARG_DST),},3,6,217},
2442 
 
2443 
 
2444 
/* 0101 1100 0000 1001 0000 ssss 0000 imm4m1 address_dst *** ldm address_dst,rs,n */
2445 
{
2446 
#ifdef NICENAMES
2447 
"ldm address_dst,rs,n",16,14,
2448 
0x00,
2449 
#endif
2450 
"ldm",OPC_ldm,0,{CLASS_DA+(ARG_DST),CLASS_REG_WORD+(ARG_RS),CLASS_IMM + (ARG_IMM4M1),},
2451 
        {CLASS_BIT+5,CLASS_BIT+0xc,CLASS_BIT+0,CLASS_BIT+9,CLASS_BIT+0,CLASS_REG+(ARG_RS),CLASS_BIT+0,CLASS_IMM+(ARG_IMM4M1),CLASS_ADDRESS+(ARG_DST),},3,6,218},
2452 
 
2453 
 
2454 
/* 0001 1100 ssN0 0001 0000 dddd 0000 imm4m1 *** ldm rd,@rs,n */
2455 
{
2456 
#ifdef NICENAMES
2457 
"ldm rd,@rs,n",16,11,
2458 
0x00,
2459 
#endif
2460 
"ldm",OPC_ldm,0,{CLASS_REG_WORD+(ARG_RD),CLASS_IR+(ARG_RS),CLASS_IMM + (ARG_IMM4M1),},
2461 
        {CLASS_BIT+1,CLASS_BIT+0xc,CLASS_REGN0+(ARG_RS),CLASS_BIT+1,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_BIT+0,CLASS_IMM+(ARG_IMM4M1),0,},3,4,219},
2462 
 
2463 
 
2464 
/* 0101 1100 ssN0 0001 0000 dddd 0000 imm4m1 address_src *** ldm rd,address_src(rs),n */
2465 
{
2466 
#ifdef NICENAMES
2467 
"ldm rd,address_src(rs),n",16,15,
2468 
0x00,
2469 
#endif
2470 
"ldm",OPC_ldm,0,{CLASS_REG_WORD+(ARG_RD),CLASS_X+(ARG_RS),CLASS_IMM + (ARG_IMM4M1),},
2471 
        {CLASS_BIT+5,CLASS_BIT+0xc,CLASS_REGN0+(ARG_RS),CLASS_BIT+1,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_BIT+0,CLASS_IMM+(ARG_IMM4M1),CLASS_ADDRESS+(ARG_SRC),},3,6,220},
2472 
 
2473 
 
2474 
/* 0101 1100 0000 0001 0000 dddd 0000 imm4m1 address_src *** ldm rd,address_src,n */
2475 
{
2476 
#ifdef NICENAMES
2477 
"ldm rd,address_src,n",16,14,
2478 
0x00,
2479 
#endif
2480 
"ldm",OPC_ldm,0,{CLASS_REG_WORD+(ARG_RD),CLASS_DA+(ARG_SRC),CLASS_IMM + (ARG_IMM4M1),},
2481 
        {CLASS_BIT+5,CLASS_BIT+0xc,CLASS_BIT+0,CLASS_BIT+1,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_BIT+0,CLASS_IMM+(ARG_IMM4M1),CLASS_ADDRESS+(ARG_SRC),},3,6,221},
2482 
 
2483 
 
2484 
/* 0011 1001 ssN0 0000 *** ldps @rs */
2485 
{
2486 
#ifdef NICENAMES
2487 
"ldps @rs",16,12,
2488 
0x3f,
2489 
#endif
2490 
"ldps",OPC_ldps,0,{CLASS_IR+(ARG_RS),},
2491 
        {CLASS_BIT+3,CLASS_BIT+9,CLASS_REGN0+(ARG_RS),CLASS_BIT+0,0,0,0,0,0,},1,2,222},
2492 
 
2493 
 
2494 
/* 0111 1001 0000 0000 address_src *** ldps address_src */
2495 
{
2496 
#ifdef NICENAMES
2497 
"ldps address_src",16,16,
2498 
0x3f,
2499 
#endif
2500 
"ldps",OPC_ldps,0,{CLASS_DA+(ARG_SRC),},
2501 
        {CLASS_BIT+7,CLASS_BIT+9,CLASS_BIT+0,CLASS_BIT+0,CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},1,4,223},
2502 
 
2503 
 
2504 
/* 0111 1001 ssN0 0000 address_src *** ldps address_src(rs) */
2505 
{
2506 
#ifdef NICENAMES
2507 
"ldps address_src(rs)",16,17,
2508 
0x3f,
2509 
#endif
2510 
"ldps",OPC_ldps,0,{CLASS_X+(ARG_RS),},
2511 
        {CLASS_BIT+7,CLASS_BIT+9,CLASS_REGN0+(ARG_RS),CLASS_BIT+0,CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},1,4,224},
2512 
 
2513 
 
2514 
/* 0011 0011 0000 ssss disp16 *** ldr disp16,rs */
2515 
{
2516 
#ifdef NICENAMES
2517 
"ldr disp16,rs",16,14,
2518 
0x00,
2519 
#endif
2520 
"ldr",OPC_ldr,0,{CLASS_DISP,CLASS_REG_WORD+(ARG_RS),},
2521 
        {CLASS_BIT+3,CLASS_BIT+3,CLASS_BIT+0,CLASS_REG+(ARG_RS),CLASS_DISP+(ARG_DISP16),0,0,0,0,},2,4,225},
2522 
 
2523 
 
2524 
/* 0011 0001 0000 dddd disp16 *** ldr rd,disp16 */
2525 
{
2526 
#ifdef NICENAMES
2527 
"ldr rd,disp16",16,14,
2528 
0x00,
2529 
#endif
2530 
"ldr",OPC_ldr,0,{CLASS_REG_WORD+(ARG_RD),CLASS_DISP,},
2531 
        {CLASS_BIT+3,CLASS_BIT+1,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_DISP+(ARG_DISP16),0,0,0,0,},2,4,226},
2532 
 
2533 
 
2534 
/* 0011 0010 0000 ssss disp16 *** ldrb disp16,rbs */
2535 
{
2536 
#ifdef NICENAMES
2537 
"ldrb disp16,rbs",8,14,
2538 
0x00,
2539 
#endif
2540 
"ldrb",OPC_ldrb,0,{CLASS_DISP,CLASS_REG_BYTE+(ARG_RS),},
2541 
        {CLASS_BIT+3,CLASS_BIT+2,CLASS_BIT+0,CLASS_REG+(ARG_RS),CLASS_DISP+(ARG_DISP16),0,0,0,0,},2,4,227},
2542 
 
2543 
 
2544 
/* 0011 0000 0000 dddd disp16 *** ldrb rbd,disp16 */
2545 
{
2546 
#ifdef NICENAMES
2547 
"ldrb rbd,disp16",8,14,
2548 
0x00,
2549 
#endif
2550 
"ldrb",OPC_ldrb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_DISP,},
2551 
        {CLASS_BIT+3,CLASS_BIT+0,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_DISP+(ARG_DISP16),0,0,0,0,},2,4,228},
2552 
 
2553 
 
2554 
/* 0011 0111 0000 ssss disp16 *** ldrl disp16,rrs */
2555 
{
2556 
#ifdef NICENAMES
2557 
"ldrl disp16,rrs",32,17,
2558 
0x00,
2559 
#endif
2560 
"ldrl",OPC_ldrl,0,{CLASS_DISP,CLASS_REG_LONG+(ARG_RS),},
2561 
        {CLASS_BIT+3,CLASS_BIT+7,CLASS_BIT+0,CLASS_REG+(ARG_RS),CLASS_DISP+(ARG_DISP16),0,0,0,0,},2,4,229},
2562 
 
2563 
 
2564 
/* 0011 0101 0000 dddd disp16 *** ldrl rrd,disp16 */
2565 
{
2566 
#ifdef NICENAMES
2567 
"ldrl rrd,disp16",32,17,
2568 
0x00,
2569 
#endif
2570 
"ldrl",OPC_ldrl,0,{CLASS_REG_LONG+(ARG_RD),CLASS_DISP,},
2571 
        {CLASS_BIT+3,CLASS_BIT+5,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_DISP+(ARG_DISP16),0,0,0,0,},2,4,230},
2572 
 
2573 
 
2574 
/* 0111 1011 0000 1010 *** mbit */
2575 
{
2576 
#ifdef NICENAMES
2577 
"mbit",16,7,
2578 
0x38,
2579 
#endif
2580 
"mbit",OPC_mbit,0,{0},
2581 
        {CLASS_BIT+7,CLASS_BIT+0xb,CLASS_BIT+0,CLASS_BIT+0xa,0,0,0,0,0,},0,2,231},
2582 
 
2583 
 
2584 
/* 0111 1011 dddd 1101 *** mreq rd */
2585 
{
2586 
#ifdef NICENAMES
2587 
"mreq rd",16,12,
2588 
0x18,
2589 
#endif
2590 
"mreq",OPC_mreq,0,{CLASS_REG_WORD+(ARG_RD),},
2591 
        {CLASS_BIT+7,CLASS_BIT+0xb,CLASS_REG+(ARG_RD),CLASS_BIT+0xd,0,0,0,0,0,},1,2,232},
2592 
 
2593 
 
2594 
/* 0111 1011 0000 1001 *** mres */
2595 
{
2596 
#ifdef NICENAMES
2597 
"mres",16,5,
2598 
0x00,
2599 
#endif
2600 
"mres",OPC_mres,0,{0},
2601 
        {CLASS_BIT+7,CLASS_BIT+0xb,CLASS_BIT+0,CLASS_BIT+9,0,0,0,0,0,},0,2,233},
2602 
 
2603 
 
2604 
/* 0111 1011 0000 1000 *** mset */
2605 
{
2606 
#ifdef NICENAMES
2607 
"mset",16,5,
2608 
0x00,
2609 
#endif
2610 
"mset",OPC_mset,0,{0},
2611 
        {CLASS_BIT+7,CLASS_BIT+0xb,CLASS_BIT+0,CLASS_BIT+8,0,0,0,0,0,},0,2,234},
2612 
 
2613 
 
2614 
/* 0001 1001 ssN0 dddd *** mult rrd,@rs */
2615 
{
2616 
#ifdef NICENAMES
2617 
"mult rrd,@rs",16,70,
2618 
0x3c,
2619 
#endif
2620 
"mult",OPC_mult,0,{CLASS_REG_LONG+(ARG_RD),CLASS_IR+(ARG_RS),},
2621 
        {CLASS_BIT+1,CLASS_BIT+9,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,235},
2622 
 
2623 
 
2624 
/* 0101 1001 0000 dddd address_src *** mult rrd,address_src */
2625 
{
2626 
#ifdef NICENAMES
2627 
"mult rrd,address_src",16,70,
2628 
0x3c,
2629 
#endif
2630 
"mult",OPC_mult,0,{CLASS_REG_LONG+(ARG_RD),CLASS_DA+(ARG_SRC),},
2631 
        {CLASS_BIT+5,CLASS_BIT+9,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,236},
2632 
 
2633 
 
2634 
/* 0101 1001 ssN0 dddd address_src *** mult rrd,address_src(rs) */
2635 
{
2636 
#ifdef NICENAMES
2637 
"mult rrd,address_src(rs)",16,70,
2638 
0x3c,
2639 
#endif
2640 
"mult",OPC_mult,0,{CLASS_REG_LONG+(ARG_RD),CLASS_X+(ARG_RS),},
2641 
        {CLASS_BIT+5,CLASS_BIT+9,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,237},
2642 
 
2643 
 
2644 
/* 0001 1001 0000 dddd imm16 *** mult rrd,imm16 */
2645 
{
2646 
#ifdef NICENAMES
2647 
"mult rrd,imm16",16,70,
2648 
0x3c,
2649 
#endif
2650 
"mult",OPC_mult,0,{CLASS_REG_LONG+(ARG_RD),CLASS_IMM+(ARG_IMM16),},
2651 
        {CLASS_BIT+1,CLASS_BIT+9,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_IMM+(ARG_IMM16),0,0,0,0,},2,4,238},
2652 
 
2653 
 
2654 
/* 1001 1001 ssss dddd *** mult rrd,rs */
2655 
{
2656 
#ifdef NICENAMES
2657 
"mult rrd,rs",16,70,
2658 
0x3c,
2659 
#endif
2660 
"mult",OPC_mult,0,{CLASS_REG_LONG+(ARG_RD),CLASS_REG_WORD+(ARG_RS),},
2661 
        {CLASS_BIT+9,CLASS_BIT+9,CLASS_REG+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,239},
2662 
 
2663 
 
2664 
/* 0001 1000 ssN0 dddd *** multl rqd,@rs */
2665 
{
2666 
#ifdef NICENAMES
2667 
"multl rqd,@rs",32,282,
2668 
0x3c,
2669 
#endif
2670 
"multl",OPC_multl,0,{CLASS_REG_QUAD+(ARG_RD),CLASS_IR+(ARG_RS),},
2671 
        {CLASS_BIT+1,CLASS_BIT+8,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,240},
2672 
 
2673 
 
2674 
/* 0101 1000 0000 dddd address_src *** multl rqd,address_src */
2675 
{
2676 
#ifdef NICENAMES
2677 
"multl rqd,address_src",32,282,
2678 
0x3c,
2679 
#endif
2680 
"multl",OPC_multl,0,{CLASS_REG_QUAD+(ARG_RD),CLASS_DA+(ARG_SRC),},
2681 
        {CLASS_BIT+5,CLASS_BIT+8,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,241},
2682 
 
2683 
 
2684 
/* 0101 1000 ssN0 dddd address_src *** multl rqd,address_src(rs) */
2685 
{
2686 
#ifdef NICENAMES
2687 
"multl rqd,address_src(rs)",32,282,
2688 
0x3c,
2689 
#endif
2690 
"multl",OPC_multl,0,{CLASS_REG_QUAD+(ARG_RD),CLASS_X+(ARG_RS),},
2691 
        {CLASS_BIT+5,CLASS_BIT+8,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,242},
2692 
 
2693 
 
2694 
/* 0001 1000 0000 dddd imm32 *** multl rqd,imm32 */
2695 
{
2696 
#ifdef NICENAMES
2697 
"multl rqd,imm32",32,282,
2698 
0x3c,
2699 
#endif
2700 
"multl",OPC_multl,0,{CLASS_REG_QUAD+(ARG_RD),CLASS_IMM+(ARG_IMM32),},
2701 
        {CLASS_BIT+1,CLASS_BIT+8,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_IMM+(ARG_IMM32),0,0,0,0,},2,6,243},
2702 
 
2703 
 
2704 
/* 1001 1000 ssss dddd *** multl rqd,rrs */
2705 
{
2706 
#ifdef NICENAMES
2707 
"multl rqd,rrs",32,282,
2708 
0x3c,
2709 
#endif
2710 
"multl",OPC_multl,0,{CLASS_REG_QUAD+(ARG_RD),CLASS_REG_LONG+(ARG_RS),},
2711 
        {CLASS_BIT+9,CLASS_BIT+8,CLASS_REG+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,244},
2712 
 
2713 
 
2714 
/* 0000 1101 ddN0 0010 *** neg @rd */
2715 
{
2716 
#ifdef NICENAMES
2717 
"neg @rd",16,12,
2718 
0x3c,
2719 
#endif
2720 
"neg",OPC_neg,0,{CLASS_IR+(ARG_RD),},
2721 
        {CLASS_BIT+0,CLASS_BIT+0xd,CLASS_REGN0+(ARG_RD),CLASS_BIT+2,0,0,0,0,0,},1,2,245},
2722 
 
2723 
 
2724 
/* 0100 1101 0000 0010 address_dst *** neg address_dst */
2725 
{
2726 
#ifdef NICENAMES
2727 
"neg address_dst",16,15,
2728 
0x3c,
2729 
#endif
2730 
"neg",OPC_neg,0,{CLASS_DA+(ARG_DST),},
2731 
        {CLASS_BIT+4,CLASS_BIT+0xd,CLASS_BIT+0,CLASS_BIT+2,CLASS_ADDRESS+(ARG_DST),0,0,0,0,},1,4,246},
2732 
 
2733 
 
2734 
/* 0100 1101 ddN0 0010 address_dst *** neg address_dst(rd) */
2735 
{
2736 
#ifdef NICENAMES
2737 
"neg address_dst(rd)",16,16,
2738 
0x3c,
2739 
#endif
2740 
"neg",OPC_neg,0,{CLASS_X+(ARG_RD),},
2741 
        {CLASS_BIT+4,CLASS_BIT+0xd,CLASS_REGN0+(ARG_RD),CLASS_BIT+2,CLASS_ADDRESS+(ARG_DST),0,0,0,0,},1,4,247},
2742 
 
2743 
 
2744 
/* 1000 1101 dddd 0010 *** neg rd */
2745 
{
2746 
#ifdef NICENAMES
2747 
"neg rd",16,7,
2748 
0x3c,
2749 
#endif
2750 
"neg",OPC_neg,0,{CLASS_REG_WORD+(ARG_RD),},
2751 
        {CLASS_BIT+8,CLASS_BIT+0xd,CLASS_REG+(ARG_RD),CLASS_BIT+2,0,0,0,0,0,},1,2,248},
2752 
 
2753 
 
2754 
/* 0000 1100 ddN0 0010 *** negb @rd */
2755 
{
2756 
#ifdef NICENAMES
2757 
"negb @rd",8,12,
2758 
0x3c,
2759 
#endif
2760 
"negb",OPC_negb,0,{CLASS_IR+(ARG_RD),},
2761 
        {CLASS_BIT+0,CLASS_BIT+0xc,CLASS_REGN0+(ARG_RD),CLASS_BIT+2,0,0,0,0,0,},1,2,249},
2762 
 
2763 
 
2764 
/* 0100 1100 0000 0010 address_dst *** negb address_dst */
2765 
{
2766 
#ifdef NICENAMES
2767 
"negb address_dst",8,15,
2768 
0x3c,
2769 
#endif
2770 
"negb",OPC_negb,0,{CLASS_DA+(ARG_DST),},
2771 
        {CLASS_BIT+4,CLASS_BIT+0xc,CLASS_BIT+0,CLASS_BIT+2,CLASS_ADDRESS+(ARG_DST),0,0,0,0,},1,4,250},
2772 
 
2773 
 
2774 
/* 0100 1100 ddN0 0010 address_dst *** negb address_dst(rd) */
2775 
{
2776 
#ifdef NICENAMES
2777 
"negb address_dst(rd)",8,16,
2778 
0x3c,
2779 
#endif
2780 
"negb",OPC_negb,0,{CLASS_X+(ARG_RD),},
2781 
        {CLASS_BIT+4,CLASS_BIT+0xc,CLASS_REGN0+(ARG_RD),CLASS_BIT+2,CLASS_ADDRESS+(ARG_DST),0,0,0,0,},1,4,251},
2782 
 
2783 
 
2784 
/* 1000 1100 dddd 0010 *** negb rbd */
2785 
{
2786 
#ifdef NICENAMES
2787 
"negb rbd",8,7,
2788 
0x3c,
2789 
#endif
2790 
"negb",OPC_negb,0,{CLASS_REG_BYTE+(ARG_RD),},
2791 
        {CLASS_BIT+8,CLASS_BIT+0xc,CLASS_REG+(ARG_RD),CLASS_BIT+2,0,0,0,0,0,},1,2,252},
2792 
 
2793 
 
2794 
/* 1000 1101 0000 0111 *** nop */
2795 
{
2796 
#ifdef NICENAMES
2797 
"nop",16,7,
2798 
0x00,
2799 
#endif
2800 
"nop",OPC_nop,0,{0},
2801 
        {CLASS_BIT+8,CLASS_BIT+0xd,CLASS_BIT+0,CLASS_BIT+7,0,0,0,0,0,},0,2,253},
2802 
 
2803 
 
2804 
/* 0000 0101 ssN0 dddd *** or rd,@rs */
2805 
{
2806 
#ifdef NICENAMES
2807 
"or rd,@rs",16,7,
2808 
0x38,
2809 
#endif
2810 
"or",OPC_or,0,{CLASS_REG_WORD+(ARG_RD),CLASS_IR+(ARG_RS),},
2811 
        {CLASS_BIT+0,CLASS_BIT+5,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,254},
2812 
 
2813 
 
2814 
/* 0100 0101 0000 dddd address_src *** or rd,address_src */
2815 
{
2816 
#ifdef NICENAMES
2817 
"or rd,address_src",16,9,
2818 
0x38,
2819 
#endif
2820 
"or",OPC_or,0,{CLASS_REG_WORD+(ARG_RD),CLASS_DA+(ARG_SRC),},
2821 
        {CLASS_BIT+4,CLASS_BIT+5,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,255},
2822 
 
2823 
 
2824 
/* 0100 0101 ssN0 dddd address_src *** or rd,address_src(rs) */
2825 
{
2826 
#ifdef NICENAMES
2827 
"or rd,address_src(rs)",16,10,
2828 
0x38,
2829 
#endif
2830 
"or",OPC_or,0,{CLASS_REG_WORD+(ARG_RD),CLASS_X+(ARG_RS),},
2831 
        {CLASS_BIT+4,CLASS_BIT+5,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,256},
2832 
 
2833 
 
2834 
/* 0000 0101 0000 dddd imm16 *** or rd,imm16 */
2835 
{
2836 
#ifdef NICENAMES
2837 
"or rd,imm16",16,7,
2838 
0x38,
2839 
#endif
2840 
"or",OPC_or,0,{CLASS_REG_WORD+(ARG_RD),CLASS_IMM+(ARG_IMM16),},
2841 
        {CLASS_BIT+0,CLASS_BIT+5,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_IMM+(ARG_IMM16),0,0,0,0,},2,4,257},
2842 
 
2843 
 
2844 
/* 1000 0101 ssss dddd *** or rd,rs */
2845 
{
2846 
#ifdef NICENAMES
2847 
"or rd,rs",16,4,
2848 
0x38,
2849 
#endif
2850 
"or",OPC_or,0,{CLASS_REG_WORD+(ARG_RD),CLASS_REG_WORD+(ARG_RS),},
2851 
        {CLASS_BIT+8,CLASS_BIT+5,CLASS_REG+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,258},
2852 
 
2853 
 
2854 
/* 0000 0100 ssN0 dddd *** orb rbd,@rs */
2855 
{
2856 
#ifdef NICENAMES
2857 
"orb rbd,@rs",8,7,
2858 
0x3c,
2859 
#endif
2860 
"orb",OPC_orb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_IR+(ARG_RS),},
2861 
        {CLASS_BIT+0,CLASS_BIT+4,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,259},
2862 
 
2863 
 
2864 
/* 0100 0100 0000 dddd address_src *** orb rbd,address_src */
2865 
{
2866 
#ifdef NICENAMES
2867 
"orb rbd,address_src",8,9,
2868 
0x3c,
2869 
#endif
2870 
"orb",OPC_orb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_DA+(ARG_SRC),},
2871 
        {CLASS_BIT+4,CLASS_BIT+4,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,260},
2872 
 
2873 
 
2874 
/* 0100 0100 ssN0 dddd address_src *** orb rbd,address_src(rs) */
2875 
{
2876 
#ifdef NICENAMES
2877 
"orb rbd,address_src(rs)",8,10,
2878 
0x3c,
2879 
#endif
2880 
"orb",OPC_orb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_X+(ARG_RS),},
2881 
        {CLASS_BIT+4,CLASS_BIT+4,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,261},
2882 
 
2883 
 
2884 
/* 0000 0100 0000 dddd imm8 imm8 *** orb rbd,imm8 */
2885 
{
2886 
#ifdef NICENAMES
2887 
"orb rbd,imm8",8,7,
2888 
0x3c,
2889 
#endif
2890 
"orb",OPC_orb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_IMM+(ARG_IMM8),},
2891 
        {CLASS_BIT+0,CLASS_BIT+4,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_IMM+(ARG_IMM8),CLASS_IMM+(ARG_IMM8),0,0,0,},2,4,262},
2892 
 
2893 
 
2894 
/* 1000 0100 ssss dddd *** orb rbd,rbs */
2895 
{
2896 
#ifdef NICENAMES
2897 
"orb rbd,rbs",8,4,
2898 
0x3c,
2899 
#endif
2900 
"orb",OPC_orb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_REG_BYTE+(ARG_RS),},
2901 
        {CLASS_BIT+8,CLASS_BIT+4,CLASS_REG+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,263},
2902 
 
2903 
 
2904 
/* 0011 1111 ddN0 ssss *** out @rd,rs */
2905 
{
2906 
#ifdef NICENAMES
2907 
"out @rd,rs",16,0,
2908 
0x04,
2909 
#endif
2910 
"out",OPC_out,0,{CLASS_IR+(ARG_RD),CLASS_REG_WORD+(ARG_RS),},
2911 
        {CLASS_BIT+3,CLASS_BIT+0xf,CLASS_REGN0+(ARG_RD),CLASS_REG+(ARG_RS),0,0,0,0,0,},2,2,264},
2912 
 
2913 
 
2914 
/* 0011 1011 ssss 0110 imm16 *** out imm16,rs */
2915 
{
2916 
#ifdef NICENAMES
2917 
"out imm16,rs",16,0,
2918 
0x04,
2919 
#endif
2920 
"out",OPC_out,0,{CLASS_IMM+(ARG_IMM16),CLASS_REG_WORD+(ARG_RS),},
2921 
        {CLASS_BIT+3,CLASS_BIT+0xb,CLASS_REG+(ARG_RS),CLASS_BIT+6,CLASS_IMM+(ARG_IMM16),0,0,0,0,},2,4,265},
2922 
 
2923 
 
2924 
/* 0011 1110 ddN0 ssss *** outb @rd,rbs */
2925 
{
2926 
#ifdef NICENAMES
2927 
"outb @rd,rbs",8,0,
2928 
0x04,
2929 
#endif
2930 
"outb",OPC_outb,0,{CLASS_IR+(ARG_RD),CLASS_REG_BYTE+(ARG_RS),},
2931 
        {CLASS_BIT+3,CLASS_BIT+0xe,CLASS_REGN0+(ARG_RD),CLASS_REG+(ARG_RS),0,0,0,0,0,},2,2,266},
2932 
 
2933 
 
2934 
/* 0011 1010 ssss 0110 imm16 *** outb imm16,rbs */
2935 
{
2936 
#ifdef NICENAMES
2937 
"outb imm16,rbs",8,0,
2938 
0x04,
2939 
#endif
2940 
"outb",OPC_outb,0,{CLASS_IMM+(ARG_IMM16),CLASS_REG_BYTE+(ARG_RS),},
2941 
        {CLASS_BIT+3,CLASS_BIT+0xa,CLASS_REG+(ARG_RS),CLASS_BIT+6,CLASS_IMM+(ARG_IMM16),0,0,0,0,},2,4,267},
2942 
 
2943 
 
2944 
/* 0011 1011 ssN0 1010 0000 aaaa ddN0 1000 *** outd @rd,@rs,ra */
2945 
{
2946 
#ifdef NICENAMES
2947 
"outd @rd,@rs,ra",16,0,
2948 
0x04,
2949 
#endif
2950 
"outd",OPC_outd,0,{CLASS_IR+(ARG_RD),CLASS_IR+(ARG_RS),CLASS_REG_WORD+(ARG_RA),},
2951 
        {CLASS_BIT+3,CLASS_BIT+0xb,CLASS_REGN0+(ARG_RS),CLASS_BIT+0xa,CLASS_BIT+0,CLASS_REG+(ARG_RA),CLASS_REGN0+(ARG_RD),CLASS_BIT+8,0,},3,4,268},
2952 
 
2953 
 
2954 
/* 0011 1010 ssN0 1010 0000 aaaa ddN0 1000 *** outdb @rd,@rs,rba */
2955 
{
2956 
#ifdef NICENAMES
2957 
"outdb @rd,@rs,rba",16,0,
2958 
0x04,
2959 
#endif
2960 
"outdb",OPC_outdb,0,{CLASS_IR+(ARG_RD),CLASS_IR+(ARG_RS),CLASS_REG_BYTE+(ARG_RA),},
2961 
        {CLASS_BIT+3,CLASS_BIT+0xa,CLASS_REGN0+(ARG_RS),CLASS_BIT+0xa,CLASS_BIT+0,CLASS_REG+(ARG_RA),CLASS_REGN0+(ARG_RD),CLASS_BIT+8,0,},3,4,269},
2962 
 
2963 
 
2964 
/* 0011 1011 ssN0 0010 0000 aaaa ddN0 1000 *** outi @rd,@rs,ra */
2965 
{
2966 
#ifdef NICENAMES
2967 
"outi @rd,@rs,ra",16,0,
2968 
0x04,
2969 
#endif
2970 
"outi",OPC_outi,0,{CLASS_IR+(ARG_RD),CLASS_IR+(ARG_RS),CLASS_REG_WORD+(ARG_RA),},
2971 
        {CLASS_BIT+3,CLASS_BIT+0xb,CLASS_REGN0+(ARG_RS),CLASS_BIT+2,CLASS_BIT+0,CLASS_REG+(ARG_RA),CLASS_REGN0+(ARG_RD),CLASS_BIT+8,0,},3,4,270},
2972 
 
2973 
 
2974 
/* 0011 1010 ssN0 0010 0000 aaaa ddN0 1000 *** outib @rd,@rs,ra */
2975 
{
2976 
#ifdef NICENAMES
2977 
"outib @rd,@rs,ra",16,0,
2978 
0x04,
2979 
#endif
2980 
"outib",OPC_outib,0,{CLASS_IR+(ARG_RD),CLASS_IR+(ARG_RS),CLASS_REG_WORD+(ARG_RA),},
2981 
        {CLASS_BIT+3,CLASS_BIT+0xa,CLASS_REGN0+(ARG_RS),CLASS_BIT+2,CLASS_BIT+0,CLASS_REG+(ARG_RA),CLASS_REGN0+(ARG_RD),CLASS_BIT+8,0,},3,4,271},
2982 
 
2983 
 
2984 
/* 0011 1010 ssN0 0010 0000 aaaa ddN0 0000 *** outibr @rd,@rs,ra */
2985 
{
2986 
#ifdef NICENAMES
2987 
"outibr @rd,@rs,ra",16,0,
2988 
0x04,
2989 
#endif
2990 
"outibr",OPC_outibr,0,{CLASS_IR+(ARG_RD),CLASS_IR+(ARG_RS),CLASS_REG_WORD+(ARG_RA),},
2991 
        {CLASS_BIT+3,CLASS_BIT+0xa,CLASS_REGN0+(ARG_RS),CLASS_BIT+2,CLASS_BIT+0,CLASS_REG+(ARG_RA),CLASS_REGN0+(ARG_RD),CLASS_BIT+0,0,},3,4,272},
2992 
 
2993 
 
2994 
/* 0001 0111 ssN0 ddN0 *** pop @rd,@rs */
2995 
{
2996 
#ifdef NICENAMES
2997 
"pop @rd,@rs",16,12,
2998 
0x00,
2999 
#endif
3000 
"pop",OPC_pop,0,{CLASS_IR+(ARG_RD),CLASS_IR+(ARG_RS),},
3001 
        {CLASS_BIT+1,CLASS_BIT+7,CLASS_REGN0+(ARG_RS),CLASS_REGN0+(ARG_RD),0,0,0,0,0,},2,2,273},
3002 
 
3003 
 
3004 
/* 0101 0111 ssN0 ddN0 address_dst *** pop address_dst(rd),@rs */
3005 
{
3006 
#ifdef NICENAMES
3007 
"pop address_dst(rd),@rs",16,16,
3008 
0x00,
3009 
#endif
3010 
"pop",OPC_pop,0,{CLASS_X+(ARG_RD),CLASS_IR+(ARG_RS),},
3011 
        {CLASS_BIT+5,CLASS_BIT+7,CLASS_REGN0+(ARG_RS),CLASS_REGN0+(ARG_RD),CLASS_ADDRESS+(ARG_DST),0,0,0,0,},2,4,274},
3012 
 
3013 
 
3014 
/* 0101 0111 ssN0 0000 address_dst *** pop address_dst,@rs */
3015 
{
3016 
#ifdef NICENAMES
3017 
"pop address_dst,@rs",16,16,
3018 
0x00,
3019 
#endif
3020 
"pop",OPC_pop,0,{CLASS_DA+(ARG_DST),CLASS_IR+(ARG_RS),},
3021 
        {CLASS_BIT+5,CLASS_BIT+7,CLASS_REGN0+(ARG_RS),CLASS_BIT+0,CLASS_ADDRESS+(ARG_DST),0,0,0,0,},2,4,275},
3022 
 
3023 
 
3024 
/* 1001 0111 ssN0 dddd *** pop rd,@rs */
3025 
{
3026 
#ifdef NICENAMES
3027 
"pop rd,@rs",16,8,
3028 
0x00,
3029 
#endif
3030 
"pop",OPC_pop,0,{CLASS_REG_WORD+(ARG_RD),CLASS_IR+(ARG_RS),},
3031 
        {CLASS_BIT+9,CLASS_BIT+7,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,276},
3032 
 
3033 
 
3034 
/* 0001 0101 ssN0 ddN0 *** popl @rd,@rs */
3035 
{
3036 
#ifdef NICENAMES
3037 
"popl @rd,@rs",32,19,
3038 
0x00,
3039 
#endif
3040 
"popl",OPC_popl,0,{CLASS_IR+(ARG_RD),CLASS_IR+(ARG_RS),},
3041 
        {CLASS_BIT+1,CLASS_BIT+5,CLASS_REGN0+(ARG_RS),CLASS_REGN0+(ARG_RD),0,0,0,0,0,},2,2,277},
3042 
 
3043 
 
3044 
/* 0101 0101 ssN0 ddN0 address_dst *** popl address_dst(rd),@rs */
3045 
{
3046 
#ifdef NICENAMES
3047 
"popl address_dst(rd),@rs",32,23,
3048 
0x00,
3049 
#endif
3050 
"popl",OPC_popl,0,{CLASS_X+(ARG_RD),CLASS_IR+(ARG_RS),},
3051 
        {CLASS_BIT+5,CLASS_BIT+5,CLASS_REGN0+(ARG_RS),CLASS_REGN0+(ARG_RD),CLASS_ADDRESS+(ARG_DST),0,0,0,0,},2,4,278},
3052 
 
3053 
 
3054 
/* 0101 0101 ssN0 0000 address_dst *** popl address_dst,@rs */
3055 
{
3056 
#ifdef NICENAMES
3057 
"popl address_dst,@rs",32,23,
3058 
0x00,
3059 
#endif
3060 
"popl",OPC_popl,0,{CLASS_DA+(ARG_DST),CLASS_IR+(ARG_RS),},
3061 
        {CLASS_BIT+5,CLASS_BIT+5,CLASS_REGN0+(ARG_RS),CLASS_BIT+0,CLASS_ADDRESS+(ARG_DST),0,0,0,0,},2,4,279},
3062 
 
3063 
 
3064 
/* 1001 0101 ssN0 dddd *** popl rrd,@rs */
3065 
{
3066 
#ifdef NICENAMES
3067 
"popl rrd,@rs",32,12,
3068 
0x00,
3069 
#endif
3070 
"popl",OPC_popl,0,{CLASS_REG_LONG+(ARG_RD),CLASS_IR+(ARG_RS),},
3071 
        {CLASS_BIT+9,CLASS_BIT+5,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,280},
3072 
 
3073 
 
3074 
/* 0001 0011 ddN0 ssN0 *** push @rd,@rs */
3075 
{
3076 
#ifdef NICENAMES
3077 
"push @rd,@rs",16,13,
3078 
0x00,
3079 
#endif
3080 
"push",OPC_push,0,{CLASS_IR+(ARG_RD),CLASS_IR+(ARG_RS),},
3081 
        {CLASS_BIT+1,CLASS_BIT+3,CLASS_REGN0+(ARG_RD),CLASS_REGN0+(ARG_RS),0,0,0,0,0,},2,2,281},
3082 
 
3083 
 
3084 
/* 0101 0011 ddN0 0000 address_src *** push @rd,address_src */
3085 
{
3086 
#ifdef NICENAMES
3087 
"push @rd,address_src",16,14,
3088 
0x00,
3089 
#endif
3090 
"push",OPC_push,0,{CLASS_IR+(ARG_RD),CLASS_DA+(ARG_SRC),},
3091 
        {CLASS_BIT+5,CLASS_BIT+3,CLASS_REGN0+(ARG_RD),CLASS_BIT+0,CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,282},
3092 
 
3093 
 
3094 
/* 0101 0011 ddN0 ssN0 address_src *** push @rd,address_src(rs) */
3095 
{
3096 
#ifdef NICENAMES
3097 
"push @rd,address_src(rs)",16,14,
3098 
0x00,
3099 
#endif
3100 
"push",OPC_push,0,{CLASS_IR+(ARG_RD),CLASS_X+(ARG_RS),},
3101 
        {CLASS_BIT+5,CLASS_BIT+3,CLASS_REGN0+(ARG_RD),CLASS_REGN0+(ARG_RS),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,283},
3102 
 
3103 
 
3104 
/* 0000 1101 ddN0 1001 imm16 *** push @rd,imm16 */
3105 
{
3106 
#ifdef NICENAMES
3107 
"push @rd,imm16",16,12,
3108 
0x00,
3109 
#endif
3110 
"push",OPC_push,0,{CLASS_IR+(ARG_RD),CLASS_IMM+(ARG_IMM16),},
3111 
        {CLASS_BIT+0,CLASS_BIT+0xd,CLASS_REGN0+(ARG_RD),CLASS_BIT+9,CLASS_IMM+(ARG_IMM16),0,0,0,0,},2,4,284},
3112 
 
3113 
 
3114 
/* 1001 0011 ddN0 ssss *** push @rd,rs */
3115 
{
3116 
#ifdef NICENAMES
3117 
"push @rd,rs",16,9,
3118 
0x00,
3119 
#endif
3120 
"push",OPC_push,0,{CLASS_IR+(ARG_RD),CLASS_REG_WORD+(ARG_RS),},
3121 
        {CLASS_BIT+9,CLASS_BIT+3,CLASS_REGN0+(ARG_RD),CLASS_REG+(ARG_RS),0,0,0,0,0,},2,2,285},
3122 
 
3123 
 
3124 
/* 0001 0001 ddN0 ssN0 *** pushl @rd,@rs */
3125 
{
3126 
#ifdef NICENAMES
3127 
"pushl @rd,@rs",32,20,
3128 
0x00,
3129 
#endif
3130 
"pushl",OPC_pushl,0,{CLASS_IR+(ARG_RD),CLASS_IR+(ARG_RS),},
3131 
        {CLASS_BIT+1,CLASS_BIT+1,CLASS_REGN0+(ARG_RD),CLASS_REGN0+(ARG_RS),0,0,0,0,0,},2,2,286},
3132 
 
3133 
 
3134 
/* 0101 0001 ddN0 0000 address_src *** pushl @rd,address_src */
3135 
{
3136 
#ifdef NICENAMES
3137 
"pushl @rd,address_src",32,21,
3138 
0x00,
3139 
#endif
3140 
"pushl",OPC_pushl,0,{CLASS_IR+(ARG_RD),CLASS_DA+(ARG_SRC),},
3141 
        {CLASS_BIT+5,CLASS_BIT+1,CLASS_REGN0+(ARG_RD),CLASS_BIT+0,CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,287},
3142 
 
3143 
 
3144 
/* 0101 0001 ddN0 ssN0 address_src *** pushl @rd,address_src(rs) */
3145 
{
3146 
#ifdef NICENAMES
3147 
"pushl @rd,address_src(rs)",32,21,
3148 
0x00,
3149 
#endif
3150 
"pushl",OPC_pushl,0,{CLASS_IR+(ARG_RD),CLASS_X+(ARG_RS),},
3151 
        {CLASS_BIT+5,CLASS_BIT+1,CLASS_REGN0+(ARG_RD),CLASS_REGN0+(ARG_RS),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,288},
3152 
 
3153 
 
3154 
/* 1001 0001 ddN0 ssss *** pushl @rd,rrs */
3155 
{
3156 
#ifdef NICENAMES
3157 
"pushl @rd,rrs",32,12,
3158 
0x00,
3159 
#endif
3160 
"pushl",OPC_pushl,0,{CLASS_IR+(ARG_RD),CLASS_REG_LONG+(ARG_RS),},
3161 
        {CLASS_BIT+9,CLASS_BIT+1,CLASS_REGN0+(ARG_RD),CLASS_REG+(ARG_RS),0,0,0,0,0,},2,2,289},
3162 
 
3163 
 
3164 
/* 0010 0011 ddN0 imm4 *** res @rd,imm4 */
3165 
{
3166 
#ifdef NICENAMES
3167 
"res @rd,imm4",16,11,
3168 
0x00,
3169 
#endif
3170 
"res",OPC_res,0,{CLASS_IR+(ARG_RD),CLASS_IMM +(ARG_IMM4),},
3171 
        {CLASS_BIT+2,CLASS_BIT+3,CLASS_REGN0+(ARG_RD),CLASS_IMM+(ARG_IMM4),0,0,0,0,0,},2,2,290},
3172 
 
3173 
 
3174 
/* 0110 0011 ddN0 imm4 address_dst *** res address_dst(rd),imm4 */
3175 
{
3176 
#ifdef NICENAMES
3177 
"res address_dst(rd),imm4",16,14,
3178 
0x00,
3179 
#endif
3180 
"res",OPC_res,0,{CLASS_X+(ARG_RD),CLASS_IMM +(ARG_IMM4),},
3181 
        {CLASS_BIT+6,CLASS_BIT+3,CLASS_REGN0+(ARG_RD),CLASS_IMM+(ARG_IMM4),CLASS_ADDRESS+(ARG_DST),0,0,0,0,},2,4,291},
3182 
 
3183 
 
3184 
/* 0110 0011 0000 imm4 address_dst *** res address_dst,imm4 */
3185 
{
3186 
#ifdef NICENAMES
3187 
"res address_dst,imm4",16,13,
3188 
0x00,
3189 
#endif
3190 
"res",OPC_res,0,{CLASS_DA+(ARG_DST),CLASS_IMM +(ARG_IMM4),},
3191 
        {CLASS_BIT+6,CLASS_BIT+3,CLASS_BIT+0,CLASS_IMM+(ARG_IMM4),CLASS_ADDRESS+(ARG_DST),0,0,0,0,},2,4,292},
3192 
 
3193 
 
3194 
/* 1010 0011 dddd imm4 *** res rd,imm4 */
3195 
{
3196 
#ifdef NICENAMES
3197 
"res rd,imm4",16,4,
3198 
0x00,
3199 
#endif
3200 
"res",OPC_res,0,{CLASS_REG_WORD+(ARG_RD),CLASS_IMM +(ARG_IMM4),},
3201 
        {CLASS_BIT+0xa,CLASS_BIT+3,CLASS_REG+(ARG_RD),CLASS_IMM+(ARG_IMM4),0,0,0,0,0,},2,2,293},
3202 
 
3203 
 
3204 
/* 0010 0011 0000 ssss 0000 dddd 0000 0000 *** res rd,rs */
3205 
{
3206 
#ifdef NICENAMES
3207 
"res rd,rs",16,10,
3208 
0x00,
3209 
#endif
3210 
"res",OPC_res,0,{CLASS_REG_WORD+(ARG_RD),CLASS_REG_WORD+(ARG_RS),},
3211 
        {CLASS_BIT+2,CLASS_BIT+3,CLASS_BIT+0,CLASS_REG+(ARG_RS),CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_BIT+0,CLASS_BIT+0,0,},2,4,294},
3212 
 
3213 
 
3214 
/* 0010 0010 ddN0 imm4 *** resb @rd,imm4 */
3215 
{
3216 
#ifdef NICENAMES
3217 
"resb @rd,imm4",8,11,
3218 
0x00,
3219 
#endif
3220 
"resb",OPC_resb,0,{CLASS_IR+(ARG_RD),CLASS_IMM +(ARG_IMM4),},
3221 
        {CLASS_BIT+2,CLASS_BIT+2,CLASS_REGN0+(ARG_RD),CLASS_IMM+(ARG_IMM4),0,0,0,0,0,},2,2,295},
3222 
 
3223 
 
3224 
/* 0110 0010 ddN0 imm4 address_dst *** resb address_dst(rd),imm4 */
3225 
{
3226 
#ifdef NICENAMES
3227 
"resb address_dst(rd),imm4",8,14,
3228 
0x00,
3229 
#endif
3230 
"resb",OPC_resb,0,{CLASS_X+(ARG_RD),CLASS_IMM +(ARG_IMM4),},
3231 
        {CLASS_BIT+6,CLASS_BIT+2,CLASS_REGN0+(ARG_RD),CLASS_IMM+(ARG_IMM4),CLASS_ADDRESS+(ARG_DST),0,0,0,0,},2,4,296},
3232 
 
3233 
 
3234 
/* 0110 0010 0000 imm4 address_dst *** resb address_dst,imm4 */
3235 
{
3236 
#ifdef NICENAMES
3237 
"resb address_dst,imm4",8,13,
3238 
0x00,
3239 
#endif
3240 
"resb",OPC_resb,0,{CLASS_DA+(ARG_DST),CLASS_IMM +(ARG_IMM4),},
3241 
        {CLASS_BIT+6,CLASS_BIT+2,CLASS_BIT+0,CLASS_IMM+(ARG_IMM4),CLASS_ADDRESS+(ARG_DST),0,0,0,0,},2,4,297},
3242 
 
3243 
 
3244 
/* 1010 0010 dddd imm4 *** resb rbd,imm4 */
3245 
{
3246 
#ifdef NICENAMES
3247 
"resb rbd,imm4",8,4,
3248 
0x00,
3249 
#endif
3250 
"resb",OPC_resb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_IMM +(ARG_IMM4),},
3251 
        {CLASS_BIT+0xa,CLASS_BIT+2,CLASS_REG+(ARG_RD),CLASS_IMM+(ARG_IMM4),0,0,0,0,0,},2,2,298},
3252 
 
3253 
 
3254 
/* 0010 0010 0000 ssss 0000 dddd 0000 0000 *** resb rbd,rs */
3255 
{
3256 
#ifdef NICENAMES
3257 
"resb rbd,rs",8,10,
3258 
0x00,
3259 
#endif
3260 
"resb",OPC_resb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_REG_WORD+(ARG_RS),},
3261 
        {CLASS_BIT+2,CLASS_BIT+2,CLASS_BIT+0,CLASS_REG+(ARG_RS),CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_BIT+0,CLASS_BIT+0,0,},2,4,299},
3262 
 
3263 
 
3264 
/* 1000 1101 flags 0011 *** resflg flags */
3265 
{
3266 
#ifdef NICENAMES
3267 
"resflg flags",16,7,
3268 
0x3c,
3269 
#endif
3270 
"resflg",OPC_resflg,0,{CLASS_FLAGS,},
3271 
        {CLASS_BIT+8,CLASS_BIT+0xd,CLASS_FLAGS,CLASS_BIT+3,0,0,0,0,0,},1,2,300},
3272 
 
3273 
 
3274 
/* 1001 1110 0000 cccc *** ret cc */
3275 
{
3276 
#ifdef NICENAMES
3277 
"ret cc",16,10,
3278 
0x00,
3279 
#endif
3280 
"ret",OPC_ret,0,{CLASS_CC,},
3281 
        {CLASS_BIT+9,CLASS_BIT+0xe,CLASS_BIT+0,CLASS_CC,0,0,0,0,0,},1,2,301},
3282 
 
3283 
 
3284 
/* 1011 0011 dddd 00I0 *** rl rd,imm1or2 */
3285 
{
3286 
#ifdef NICENAMES
3287 
"rl rd,imm1or2",16,6,
3288 
0x3c,
3289 
#endif
3290 
"rl",OPC_rl,0,{CLASS_REG_WORD+(ARG_RD),CLASS_IMM+(ARG_IMM1OR2),},
3291 
        {CLASS_BIT+0xb,CLASS_BIT+3,CLASS_REG+(ARG_RD),CLASS_BIT_1OR2+0,0,0,0,0,0,},2,2,302},
3292 
 
3293 
 
3294 
/* 1011 0010 dddd 00I0 *** rlb rbd,imm1or2 */
3295 
{
3296 
#ifdef NICENAMES
3297 
"rlb rbd,imm1or2",8,6,
3298 
0x3c,
3299 
#endif
3300 
"rlb",OPC_rlb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_IMM+(ARG_IMM1OR2),},
3301 
        {CLASS_BIT+0xb,CLASS_BIT+2,CLASS_REG+(ARG_RD),CLASS_BIT_1OR2+0,0,0,0,0,0,},2,2,303},
3302 
 
3303 
 
3304 
/* 1011 0011 dddd 10I0 *** rlc rd,imm1or2 */
3305 
{
3306 
#ifdef NICENAMES
3307 
"rlc rd,imm1or2",16,6,
3308 
0x3c,
3309 
#endif
3310 
"rlc",OPC_rlc,0,{CLASS_REG_WORD+(ARG_RD),CLASS_IMM+(ARG_IMM1OR2),},
3311 
        {CLASS_BIT+0xb,CLASS_BIT+3,CLASS_REG+(ARG_RD),CLASS_BIT_1OR2+8,0,0,0,0,0,},2,2,304},
3312 
 
3313 
 
3314 
/* 1011 0010 dddd 10I0 *** rlcb rbd,imm1or2 */
3315 
{
3316 
#ifdef NICENAMES
3317 
"rlcb rbd,imm1or2",8,9,
3318 
0x10,
3319 
#endif
3320 
"rlcb",OPC_rlcb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_IMM+(ARG_IMM1OR2),},
3321 
        {CLASS_BIT+0xb,CLASS_BIT+2,CLASS_REG+(ARG_RD),CLASS_BIT_1OR2+8,0,0,0,0,0,},2,2,305},
3322 
 
3323 
 
3324 
/* 1011 1110 aaaa bbbb *** rldb rbb,rba */
3325 
{
3326 
#ifdef NICENAMES
3327 
"rldb rbb,rba",8,9,
3328 
0x10,
3329 
#endif
3330 
"rldb",OPC_rldb,0,{CLASS_REG_BYTE+(ARG_RB),CLASS_REG_BYTE+(ARG_RA),},
3331 
        {CLASS_BIT+0xb,CLASS_BIT+0xe,CLASS_REG+(ARG_RA),CLASS_REG+(ARG_RB),0,0,0,0,0,},2,2,306},
3332 
 
3333 
 
3334 
/* 1011 0011 dddd 01I0 *** rr rd,imm1or2 */
3335 
{
3336 
#ifdef NICENAMES
3337 
"rr rd,imm1or2",16,6,
3338 
0x3c,
3339 
#endif
3340 
"rr",OPC_rr,0,{CLASS_REG_WORD+(ARG_RD),CLASS_IMM+(ARG_IMM1OR2),},
3341 
        {CLASS_BIT+0xb,CLASS_BIT+3,CLASS_REG+(ARG_RD),CLASS_BIT_1OR2+4,0,0,0,0,0,},2,2,307},
3342 
 
3343 
 
3344 
/* 1011 0010 dddd 01I0 *** rrb rbd,imm1or2 */
3345 
{
3346 
#ifdef NICENAMES
3347 
"rrb rbd,imm1or2",8,6,
3348 
0x3c,
3349 
#endif
3350 
"rrb",OPC_rrb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_IMM+(ARG_IMM1OR2),},
3351 
        {CLASS_BIT+0xb,CLASS_BIT+2,CLASS_REG+(ARG_RD),CLASS_BIT_1OR2+4,0,0,0,0,0,},2,2,308},
3352 
 
3353 
 
3354 
/* 1011 0011 dddd 11I0 *** rrc rd,imm1or2 */
3355 
{
3356 
#ifdef NICENAMES
3357 
"rrc rd,imm1or2",16,6,
3358 
0x3c,
3359 
#endif
3360 
"rrc",OPC_rrc,0,{CLASS_REG_WORD+(ARG_RD),CLASS_IMM+(ARG_IMM1OR2),},
3361 
        {CLASS_BIT+0xb,CLASS_BIT+3,CLASS_REG+(ARG_RD),CLASS_BIT_1OR2+0xc,0,0,0,0,0,},2,2,309},
3362 
 
3363 
 
3364 
/* 1011 0010 dddd 11I0 *** rrcb rbd,imm1or2 */
3365 
{
3366 
#ifdef NICENAMES
3367 
"rrcb rbd,imm1or2",8,9,
3368 
0x10,
3369 
#endif
3370 
"rrcb",OPC_rrcb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_IMM+(ARG_IMM1OR2),},
3371 
        {CLASS_BIT+0xb,CLASS_BIT+2,CLASS_REG+(ARG_RD),CLASS_BIT_1OR2+0xc,0,0,0,0,0,},2,2,310},
3372 
 
3373 
 
3374 
/* 1011 1100 aaaa bbbb *** rrdb rbb,rba */
3375 
{
3376 
#ifdef NICENAMES
3377 
"rrdb rbb,rba",8,9,
3378 
0x10,
3379 
#endif
3380 
"rrdb",OPC_rrdb,0,{CLASS_REG_BYTE+(ARG_RB),CLASS_REG_BYTE+(ARG_RA),},
3381 
        {CLASS_BIT+0xb,CLASS_BIT+0xc,CLASS_REG+(ARG_RA),CLASS_REG+(ARG_RB),0,0,0,0,0,},2,2,311},
3382 
 
3383 
 
3384 
/* 0011 0110 imm8 *** rsvd36 */
3385 
{
3386 
#ifdef NICENAMES
3387 
"rsvd36",8,10,
3388 
0x00,
3389 
#endif
3390 
"rsvd36",OPC_rsvd36,0,{0},
3391 
        {CLASS_BIT+3,CLASS_BIT+6,CLASS_IMM+(ARG_IMM8),0,0,0,0,0,0,},0,2,312},
3392 
 
3393 
 
3394 
/* 0011 1000 imm8 *** rsvd38 */
3395 
{
3396 
#ifdef NICENAMES
3397 
"rsvd38",8,10,
3398 
0x00,
3399 
#endif
3400 
"rsvd38",OPC_rsvd38,0,{0},
3401 
        {CLASS_BIT+3,CLASS_BIT+8,CLASS_IMM+(ARG_IMM8),0,0,0,0,0,0,},0,2,313},
3402 
 
3403 
 
3404 
/* 0111 1000 imm8 *** rsvd78 */
3405 
{
3406 
#ifdef NICENAMES
3407 
"rsvd78",8,10,
3408 
0x00,
3409 
#endif
3410 
"rsvd78",OPC_rsvd78,0,{0},
3411 
        {CLASS_BIT+7,CLASS_BIT+8,CLASS_IMM+(ARG_IMM8),0,0,0,0,0,0,},0,2,314},
3412 
 
3413 
 
3414 
/* 0111 1110 imm8 *** rsvd7e */
3415 
{
3416 
#ifdef NICENAMES
3417 
"rsvd7e",8,10,
3418 
0x00,
3419 
#endif
3420 
"rsvd7e",OPC_rsvd7e,0,{0},
3421 
        {CLASS_BIT+7,CLASS_BIT+0xe,CLASS_IMM+(ARG_IMM8),0,0,0,0,0,0,},0,2,315},
3422 
 
3423 
 
3424 
/* 1001 1101 imm8 *** rsvd9d */
3425 
{
3426 
#ifdef NICENAMES
3427 
"rsvd9d",8,10,
3428 
0x00,
3429 
#endif
3430 
"rsvd9d",OPC_rsvd9d,0,{0},
3431 
        {CLASS_BIT+9,CLASS_BIT+0xd,CLASS_IMM+(ARG_IMM8),0,0,0,0,0,0,},0,2,316},
3432 
 
3433 
 
3434 
/* 1001 1111 imm8 *** rsvd9f */
3435 
{
3436 
#ifdef NICENAMES
3437 
"rsvd9f",8,10,
3438 
0x00,
3439 
#endif
3440 
"rsvd9f",OPC_rsvd9f,0,{0},
3441 
        {CLASS_BIT+9,CLASS_BIT+0xf,CLASS_IMM+(ARG_IMM8),0,0,0,0,0,0,},0,2,317},
3442 
 
3443 
 
3444 
/* 1011 1001 imm8 *** rsvdb9 */
3445 
{
3446 
#ifdef NICENAMES
3447 
"rsvdb9",8,10,
3448 
0x00,
3449 
#endif
3450 
"rsvdb9",OPC_rsvdb9,0,{0},
3451 
        {CLASS_BIT+0xb,CLASS_BIT+9,CLASS_IMM+(ARG_IMM8),0,0,0,0,0,0,},0,2,318},
3452 
 
3453 
 
3454 
/* 1011 1111 imm8 *** rsvdbf */
3455 
{
3456 
#ifdef NICENAMES
3457 
"rsvdbf",8,10,
3458 
0x00,
3459 
#endif
3460 
"rsvdbf",OPC_rsvdbf,0,{0},
3461 
        {CLASS_BIT+0xb,CLASS_BIT+0xf,CLASS_IMM+(ARG_IMM8),0,0,0,0,0,0,},0,2,319},
3462 
 
3463 
 
3464 
/* 1011 0111 ssss dddd *** sbc rd,rs */
3465 
{
3466 
#ifdef NICENAMES
3467 
"sbc rd,rs",16,5,
3468 
0x3c,
3469 
#endif
3470 
"sbc",OPC_sbc,0,{CLASS_REG_WORD+(ARG_RD),CLASS_REG_WORD+(ARG_RS),},
3471 
        {CLASS_BIT+0xb,CLASS_BIT+7,CLASS_REG+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,320},
3472 
 
3473 
 
3474 
/* 1011 0110 ssss dddd *** sbcb rbd,rbs */
3475 
{
3476 
#ifdef NICENAMES
3477 
"sbcb rbd,rbs",8,5,
3478 
0x3f,
3479 
#endif
3480 
"sbcb",OPC_sbcb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_REG_BYTE+(ARG_RS),},
3481 
        {CLASS_BIT+0xb,CLASS_BIT+6,CLASS_REG+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,321},
3482 
 
3483 
 
3484 
/* 0111 1111 imm8 *** sc imm8 */
3485 
{
3486 
#ifdef NICENAMES
3487 
"sc imm8",8,33,
3488 
0x3f,
3489 
#endif
3490 
"sc",OPC_sc,0,{CLASS_IMM+(ARG_IMM8),},
3491 
        {CLASS_BIT+7,CLASS_BIT+0xf,CLASS_IMM+(ARG_IMM8),0,0,0,0,0,0,},1,2,322},
3492 
 
3493 
 
3494 
/* 1011 0011 dddd 1011 0000 ssss 0000 0000 *** sda rd,rs */
3495 
{
3496 
#ifdef NICENAMES
3497 
"sda rd,rs",16,15,
3498 
0x3c,
3499 
#endif
3500 
"sda",OPC_sda,0,{CLASS_REG_WORD+(ARG_RD),CLASS_REG_WORD+(ARG_RS),},
3501 
        {CLASS_BIT+0xb,CLASS_BIT+3,CLASS_REG+(ARG_RD),CLASS_BIT+0xb,CLASS_BIT+0,CLASS_REG+(ARG_RS),CLASS_BIT+0,CLASS_BIT+0,0,},2,4,323},
3502 
 
3503 
 
3504 
/* 1011 0010 dddd 1011 0000 ssss 0000 0000 *** sdab rbd,rs */
3505 
{
3506 
#ifdef NICENAMES
3507 
"sdab rbd,rs",8,15,
3508 
0x3c,
3509 
#endif
3510 
"sdab",OPC_sdab,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_REG_WORD+(ARG_RS),},
3511 
        {CLASS_BIT+0xb,CLASS_BIT+2,CLASS_REG+(ARG_RD),CLASS_BIT+0xb,CLASS_BIT+0,CLASS_REG+(ARG_RS),CLASS_BIT+0,CLASS_BIT+0,0,},2,4,324},
3512 
 
3513 
 
3514 
/* 1011 0011 dddd 1111 0000 ssss 0000 0000 *** sdal rrd,rs */
3515 
{
3516 
#ifdef NICENAMES
3517 
"sdal rrd,rs",32,15,
3518 
0x3c,
3519 
#endif
3520 
"sdal",OPC_sdal,0,{CLASS_REG_LONG+(ARG_RD),CLASS_REG_WORD+(ARG_RS),},
3521 
        {CLASS_BIT+0xb,CLASS_BIT+3,CLASS_REG+(ARG_RD),CLASS_BIT+0xf,CLASS_BIT+0,CLASS_REG+(ARG_RS),CLASS_BIT+0,CLASS_BIT+0,0,},2,4,325},
3522 
 
3523 
 
3524 
/* 1011 0011 dddd 0011 0000 ssss 0000 0000 *** sdl rd,rs */
3525 
{
3526 
#ifdef NICENAMES
3527 
"sdl rd,rs",16,15,
3528 
0x38,
3529 
#endif
3530 
"sdl",OPC_sdl,0,{CLASS_REG_WORD+(ARG_RD),CLASS_REG_WORD+(ARG_RS),},
3531 
        {CLASS_BIT+0xb,CLASS_BIT+3,CLASS_REG+(ARG_RD),CLASS_BIT+3,CLASS_BIT+0,CLASS_REG+(ARG_RS),CLASS_BIT+0,CLASS_BIT+0,0,},2,4,326},
3532 
 
3533 
 
3534 
/* 1011 0010 dddd 0011 0000 ssss 0000 0000 *** sdlb rbd,rs */
3535 
{
3536 
#ifdef NICENAMES
3537 
"sdlb rbd,rs",8,15,
3538 
0x38,
3539 
#endif
3540 
"sdlb",OPC_sdlb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_REG_WORD+(ARG_RS),},
3541 
        {CLASS_BIT+0xb,CLASS_BIT+2,CLASS_REG+(ARG_RD),CLASS_BIT+3,CLASS_BIT+0,CLASS_REG+(ARG_RS),CLASS_BIT+0,CLASS_BIT+0,0,},2,4,327},
3542 
 
3543 
 
3544 
/* 1011 0011 dddd 0111 0000 ssss 0000 0000 *** sdll rrd,rs */
3545 
{
3546 
#ifdef NICENAMES
3547 
"sdll rrd,rs",32,15,
3548 
0x38,
3549 
#endif
3550 
"sdll",OPC_sdll,0,{CLASS_REG_LONG+(ARG_RD),CLASS_REG_WORD+(ARG_RS),},
3551 
        {CLASS_BIT+0xb,CLASS_BIT+3,CLASS_REG+(ARG_RD),CLASS_BIT+7,CLASS_BIT+0,CLASS_REG+(ARG_RS),CLASS_BIT+0,CLASS_BIT+0,0,},2,4,328},
3552 
 
3553 
 
3554 
/* 0010 0101 ddN0 imm4 *** set @rd,imm4 */
3555 
{
3556 
#ifdef NICENAMES
3557 
"set @rd,imm4",16,11,
3558 
0x00,
3559 
#endif
3560 
"set",OPC_set,0,{CLASS_IR+(ARG_RD),CLASS_IMM +(ARG_IMM4),},
3561 
        {CLASS_BIT+2,CLASS_BIT+5,CLASS_REGN0+(ARG_RD),CLASS_IMM+(ARG_IMM4),0,0,0,0,0,},2,2,329},
3562 
 
3563 
 
3564 
/* 0110 0101 ddN0 imm4 address_dst *** set address_dst(rd),imm4 */
3565 
{
3566 
#ifdef NICENAMES
3567 
"set address_dst(rd),imm4",16,14,
3568 
0x00,
3569 
#endif
3570 
"set",OPC_set,0,{CLASS_X+(ARG_RD),CLASS_IMM +(ARG_IMM4),},
3571 
        {CLASS_BIT+6,CLASS_BIT+5,CLASS_REGN0+(ARG_RD),CLASS_IMM+(ARG_IMM4),CLASS_ADDRESS+(ARG_DST),0,0,0,0,},2,4,330},
3572 
 
3573 
 
3574 
/* 0110 0101 0000 imm4 address_dst *** set address_dst,imm4 */
3575 
{
3576 
#ifdef NICENAMES
3577 
"set address_dst,imm4",16,13,
3578 
0x00,
3579 
#endif
3580 
"set",OPC_set,0,{CLASS_DA+(ARG_DST),CLASS_IMM +(ARG_IMM4),},
3581 
        {CLASS_BIT+6,CLASS_BIT+5,CLASS_BIT+0,CLASS_IMM+(ARG_IMM4),CLASS_ADDRESS+(ARG_DST),0,0,0,0,},2,4,331},
3582 
 
3583 
 
3584 
/* 1010 0101 dddd imm4 *** set rd,imm4 */
3585 
{
3586 
#ifdef NICENAMES
3587 
"set rd,imm4",16,4,
3588 
0x00,
3589 
#endif
3590 
"set",OPC_set,0,{CLASS_REG_WORD+(ARG_RD),CLASS_IMM +(ARG_IMM4),},
3591 
        {CLASS_BIT+0xa,CLASS_BIT+5,CLASS_REG+(ARG_RD),CLASS_IMM+(ARG_IMM4),0,0,0,0,0,},2,2,332},
3592 
 
3593 
 
3594 
/* 0010 0101 0000 ssss 0000 dddd 0000 0000 *** set rd,rs */
3595 
{
3596 
#ifdef NICENAMES
3597 
"set rd,rs",16,10,
3598 
0x00,
3599 
#endif
3600 
"set",OPC_set,0,{CLASS_REG_WORD+(ARG_RD),CLASS_REG_WORD+(ARG_RS),},
3601 
        {CLASS_BIT+2,CLASS_BIT+5,CLASS_BIT+0,CLASS_REG+(ARG_RS),CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_BIT+0,CLASS_BIT+0,0,},2,4,333},
3602 
 
3603 
 
3604 
/* 0010 0100 ddN0 imm4 *** setb @rd,imm4 */
3605 
{
3606 
#ifdef NICENAMES
3607 
"setb @rd,imm4",8,11,
3608 
0x00,
3609 
#endif
3610 
"setb",OPC_setb,0,{CLASS_IR+(ARG_RD),CLASS_IMM +(ARG_IMM4),},
3611 
        {CLASS_BIT+2,CLASS_BIT+4,CLASS_REGN0+(ARG_RD),CLASS_IMM+(ARG_IMM4),0,0,0,0,0,},2,2,334},
3612 
 
3613 
 
3614 
/* 0110 0100 ddN0 imm4 address_dst *** setb address_dst(rd),imm4 */
3615 
{
3616 
#ifdef NICENAMES
3617 
"setb address_dst(rd),imm4",8,14,
3618 
0x00,
3619 
#endif
3620 
"setb",OPC_setb,0,{CLASS_X+(ARG_RD),CLASS_IMM +(ARG_IMM4),},
3621 
        {CLASS_BIT+6,CLASS_BIT+4,CLASS_REGN0+(ARG_RD),CLASS_IMM+(ARG_IMM4),CLASS_ADDRESS+(ARG_DST),0,0,0,0,},2,4,335},
3622 
 
3623 
 
3624 
/* 0110 0100 0000 imm4 address_dst *** setb address_dst,imm4 */
3625 
{
3626 
#ifdef NICENAMES
3627 
"setb address_dst,imm4",8,13,
3628 
0x00,
3629 
#endif
3630 
"setb",OPC_setb,0,{CLASS_DA+(ARG_DST),CLASS_IMM +(ARG_IMM4),},
3631 
        {CLASS_BIT+6,CLASS_BIT+4,CLASS_BIT+0,CLASS_IMM+(ARG_IMM4),CLASS_ADDRESS+(ARG_DST),0,0,0,0,},2,4,336},
3632 
 
3633 
 
3634 
/* 1010 0100 dddd imm4 *** setb rbd,imm4 */
3635 
{
3636 
#ifdef NICENAMES
3637 
"setb rbd,imm4",8,4,
3638 
0x00,
3639 
#endif
3640 
"setb",OPC_setb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_IMM +(ARG_IMM4),},
3641 
        {CLASS_BIT+0xa,CLASS_BIT+4,CLASS_REG+(ARG_RD),CLASS_IMM+(ARG_IMM4),0,0,0,0,0,},2,2,337},
3642 
 
3643 
 
3644 
/* 0010 0100 0000 ssss 0000 dddd 0000 0000 *** setb rbd,rs */
3645 
{
3646 
#ifdef NICENAMES
3647 
"setb rbd,rs",8,10,
3648 
0x00,
3649 
#endif
3650 
"setb",OPC_setb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_REG_WORD+(ARG_RS),},
3651 
        {CLASS_BIT+2,CLASS_BIT+4,CLASS_BIT+0,CLASS_REG+(ARG_RS),CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_BIT+0,CLASS_BIT+0,0,},2,4,338},
3652 
 
3653 
 
3654 
/* 1000 1101 flags 0001 *** setflg flags */
3655 
{
3656 
#ifdef NICENAMES
3657 
"setflg flags",16,7,
3658 
0x3c,
3659 
#endif
3660 
"setflg",OPC_setflg,0,{CLASS_FLAGS,},
3661 
        {CLASS_BIT+8,CLASS_BIT+0xd,CLASS_FLAGS,CLASS_BIT+1,0,0,0,0,0,},1,2,339},
3662 
 
3663 
 
3664 
/* 0011 1011 dddd 0101 imm16 *** sin rd,imm16 */
3665 
{
3666 
#ifdef NICENAMES
3667 
"sin rd,imm16",8,0,
3668 
0x00,
3669 
#endif
3670 
"sin",OPC_sin,0,{CLASS_REG_WORD+(ARG_RD),CLASS_IMM+(ARG_IMM16),},
3671 
        {CLASS_BIT+3,CLASS_BIT+0xb,CLASS_REG+(ARG_RD),CLASS_BIT+5,CLASS_IMM+(ARG_IMM16),0,0,0,0,},2,4,340},
3672 
 
3673 
 
3674 
/* 0011 1010 dddd 0101 imm16 *** sinb rbd,imm16 */
3675 
{
3676 
#ifdef NICENAMES
3677 
"sinb rbd,imm16",8,0,
3678 
0x00,
3679 
#endif
3680 
"sinb",OPC_sinb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_IMM+(ARG_IMM16),},
3681 
        {CLASS_BIT+3,CLASS_BIT+0xa,CLASS_REG+(ARG_RD),CLASS_BIT+5,CLASS_IMM+(ARG_IMM16),0,0,0,0,},2,4,341},
3682 
 
3683 
 
3684 
/* 0011 1011 ssN0 1000 0001 aaaa ddN0 1000 *** sind @rd,@rs,ra */
3685 
{
3686 
#ifdef NICENAMES
3687 
"sind @rd,@rs,ra",16,0,
3688 
0x00,
3689 
#endif
3690 
"sind",OPC_sind,0,{CLASS_IR+(ARG_RD),CLASS_IR+(ARG_RS),CLASS_REG_WORD+(ARG_RA),},
3691 
        {CLASS_BIT+3,CLASS_BIT+0xb,CLASS_REGN0+(ARG_RS),CLASS_BIT+8,CLASS_BIT+1,CLASS_REG+(ARG_RA),CLASS_REGN0+(ARG_RD),CLASS_BIT+8,0,},3,4,342},
3692 
 
3693 
 
3694 
/* 0011 1010 ssN0 1000 0001 aaaa ddN0 1000 *** sindb @rd,@rs,rba */
3695 
{
3696 
#ifdef NICENAMES
3697 
"sindb @rd,@rs,rba",8,0,
3698 
0x00,
3699 
#endif
3700 
"sindb",OPC_sindb,0,{CLASS_IR+(ARG_RD),CLASS_IR+(ARG_RS),CLASS_REG_BYTE+(ARG_RA),},
3701 
        {CLASS_BIT+3,CLASS_BIT+0xa,CLASS_REGN0+(ARG_RS),CLASS_BIT+8,CLASS_BIT+1,CLASS_REG+(ARG_RA),CLASS_REGN0+(ARG_RD),CLASS_BIT+8,0,},3,4,343},
3702 
 
3703 
 
3704 
/* 0011 1010 ssN0 0001 0000 aaaa ddN0 1000 *** sinib @rd,@rs,ra */
3705 
{
3706 
#ifdef NICENAMES
3707 
"sinib @rd,@rs,ra",8,0,
3708 
0x00,
3709 
#endif
3710 
"sinib",OPC_sinib,0,{CLASS_IR+(ARG_RD),CLASS_IR+(ARG_RS),CLASS_REG_WORD+(ARG_RA),},
3711 
        {CLASS_BIT+3,CLASS_BIT+0xa,CLASS_REGN0+(ARG_RS),CLASS_BIT+1,CLASS_BIT+0,CLASS_REG+(ARG_RA),CLASS_REGN0+(ARG_RD),CLASS_BIT+8,0,},3,4,344},
3712 
 
3713 
 
3714 
/* 0011 1010 ssN0 0001 0000 aaaa ddN0 0000 *** sinibr @rd,@rs,ra */
3715 
{
3716 
#ifdef NICENAMES
3717 
"sinibr @rd,@rs,ra",16,0,
3718 
0x00,
3719 
#endif
3720 
"sinibr",OPC_sinibr,0,{CLASS_IR+(ARG_RD),CLASS_IR+(ARG_RS),CLASS_REG_WORD+(ARG_RA),},
3721 
        {CLASS_BIT+3,CLASS_BIT+0xa,CLASS_REGN0+(ARG_RS),CLASS_BIT+1,CLASS_BIT+0,CLASS_REG+(ARG_RA),CLASS_REGN0+(ARG_RD),CLASS_BIT+0,0,},3,4,345},
3722 
 
3723 
 
3724 
/* 1011 0011 dddd 1001 0000 0000 imm8 *** sla rd,imm8 */
3725 
{
3726 
#ifdef NICENAMES
3727 
"sla rd,imm8",16,13,
3728 
0x3c,
3729 
#endif
3730 
"sla",OPC_sla,0,{CLASS_REG_WORD+(ARG_RD),CLASS_IMM+(ARG_IMM8),},
3731 
        {CLASS_BIT+0xb,CLASS_BIT+3,CLASS_REG+(ARG_RD),CLASS_BIT+9,CLASS_BIT+0,CLASS_BIT+0,CLASS_IMM+(ARG_IMM8),0,0,},2,4,346},
3732 
 
3733 
 
3734 
/* 1011 0010 dddd 1001 iiii iiii 0000 imm4 *** slab rbd,imm4 */
3735 
{
3736 
#ifdef NICENAMES
3737 
"slab rbd,imm4",8,13,
3738 
0x3c,
3739 
#endif
3740 
"slab",OPC_slab,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_IMM +(ARG_IMM4),},
3741 
        {CLASS_BIT+0xb,CLASS_BIT+2,CLASS_REG+(ARG_RD),CLASS_BIT+9,CLASS_IGNORE,CLASS_IGNORE,CLASS_BIT+0,CLASS_IMM+(ARG_IMM4),0,},2,4,347},
3742 
 
3743 
 
3744 
/* 1011 0011 dddd 1101 0000 0000 imm8 *** slal rrd,imm8 */
3745 
{
3746 
#ifdef NICENAMES
3747 
"slal rrd,imm8",32,13,
3748 
0x3c,
3749 
#endif
3750 
"slal",OPC_slal,0,{CLASS_REG_LONG+(ARG_RD),CLASS_IMM+(ARG_IMM8),},
3751 
        {CLASS_BIT+0xb,CLASS_BIT+3,CLASS_REG+(ARG_RD),CLASS_BIT+0xd,CLASS_BIT+0,CLASS_BIT+0,CLASS_IMM+(ARG_IMM8),0,0,},2,4,348},
3752 
 
3753 
 
3754 
/* 1011 0011 dddd 0001 0000 0000 imm8 *** sll rd,imm8 */
3755 
{
3756 
#ifdef NICENAMES
3757 
"sll rd,imm8",16,13,
3758 
0x38,
3759 
#endif
3760 
"sll",OPC_sll,0,{CLASS_REG_WORD+(ARG_RD),CLASS_IMM+(ARG_IMM8),},
3761 
        {CLASS_BIT+0xb,CLASS_BIT+3,CLASS_REG+(ARG_RD),CLASS_BIT+1,CLASS_BIT+0,CLASS_BIT+0,CLASS_IMM+(ARG_IMM8),0,0,},2,4,349},
3762 
 
3763 
 
3764 
/* 1011 0010 dddd 0001 iiii iiii 0000 imm4 *** sllb rbd,imm4 */
3765 
{
3766 
#ifdef NICENAMES
3767 
"sllb rbd,imm4",8,13,
3768 
0x38,
3769 
#endif
3770 
"sllb",OPC_sllb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_IMM +(ARG_IMM4),},
3771 
        {CLASS_BIT+0xb,CLASS_BIT+2,CLASS_REG+(ARG_RD),CLASS_BIT+1,CLASS_IGNORE,CLASS_IGNORE,CLASS_BIT+0,CLASS_IMM+(ARG_IMM4),0,},2,4,350},
3772 
 
3773 
 
3774 
/* 1011 0011 dddd 0101 0000 0000 imm8 *** slll rrd,imm8 */
3775 
{
3776 
#ifdef NICENAMES
3777 
"slll rrd,imm8",32,13,
3778 
0x38,
3779 
#endif
3780 
"slll",OPC_slll,0,{CLASS_REG_LONG+(ARG_RD),CLASS_IMM+(ARG_IMM8),},
3781 
        {CLASS_BIT+0xb,CLASS_BIT+3,CLASS_REG+(ARG_RD),CLASS_BIT+5,CLASS_BIT+0,CLASS_BIT+0,CLASS_IMM+(ARG_IMM8),0,0,},2,4,351},
3782 
 
3783 
 
3784 
/* 0011 1011 ssss 0111 imm16 *** sout imm16,rs */
3785 
{
3786 
#ifdef NICENAMES
3787 
"sout imm16,rs",16,0,
3788 
0x00,
3789 
#endif
3790 
"sout",OPC_sout,0,{CLASS_IMM+(ARG_IMM16),CLASS_REG_WORD+(ARG_RS),},
3791 
        {CLASS_BIT+3,CLASS_BIT+0xb,CLASS_REG+(ARG_RS),CLASS_BIT+7,CLASS_IMM+(ARG_IMM16),0,0,0,0,},2,4,352},
3792 
 
3793 
 
3794 
/* 0011 1010 ssss 0111 imm16 *** soutb imm16,rbs */
3795 
{
3796 
#ifdef NICENAMES
3797 
"soutb imm16,rbs",8,0,
3798 
0x00,
3799 
#endif
3800 
"soutb",OPC_soutb,0,{CLASS_IMM+(ARG_IMM16),CLASS_REG_BYTE+(ARG_RS),},
3801 
        {CLASS_BIT+3,CLASS_BIT+0xa,CLASS_REG+(ARG_RS),CLASS_BIT+7,CLASS_IMM+(ARG_IMM16),0,0,0,0,},2,4,353},
3802 
 
3803 
 
3804 
/* 0011 1011 ssN0 1011 0000 aaaa ddN0 1000 *** soutd @rd,@rs,ra */
3805 
{
3806 
#ifdef NICENAMES
3807 
"soutd @rd,@rs,ra",16,0,
3808 
0x00,
3809 
#endif
3810 
"soutd",OPC_soutd,0,{CLASS_IR+(ARG_RD),CLASS_IR+(ARG_RS),CLASS_REG_WORD+(ARG_RA),},
3811 
        {CLASS_BIT+3,CLASS_BIT+0xb,CLASS_REGN0+(ARG_RS),CLASS_BIT+0xb,CLASS_BIT+0,CLASS_REG+(ARG_RA),CLASS_REGN0+(ARG_RD),CLASS_BIT+8,0,},3,4,354},
3812 
 
3813 
 
3814 
/* 0011 1010 ssN0 1011 0000 aaaa ddN0 1000 *** soutdb @rd,@rs,rba */
3815 
{
3816 
#ifdef NICENAMES
3817 
"soutdb @rd,@rs,rba",8,0,
3818 
0x00,
3819 
#endif
3820 
"soutdb",OPC_soutdb,0,{CLASS_IR+(ARG_RD),CLASS_IR+(ARG_RS),CLASS_REG_BYTE+(ARG_RA),},
3821 
        {CLASS_BIT+3,CLASS_BIT+0xa,CLASS_REGN0+(ARG_RS),CLASS_BIT+0xb,CLASS_BIT+0,CLASS_REG+(ARG_RA),CLASS_REGN0+(ARG_RD),CLASS_BIT+8,0,},3,4,355},
3822 
 
3823 
 
3824 
/* 0011 1010 ssN0 0011 0000 aaaa ddN0 1000 *** soutib @rd,@rs,ra */
3825 
{
3826 
#ifdef NICENAMES
3827 
"soutib @rd,@rs,ra",8,0,
3828 
0x00,
3829 
#endif
3830 
"soutib",OPC_soutib,0,{CLASS_IR+(ARG_RD),CLASS_IR+(ARG_RS),CLASS_REG_WORD+(ARG_RA),},
3831 
        {CLASS_BIT+3,CLASS_BIT+0xa,CLASS_REGN0+(ARG_RS),CLASS_BIT+3,CLASS_BIT+0,CLASS_REG+(ARG_RA),CLASS_REGN0+(ARG_RD),CLASS_BIT+8,0,},3,4,356},
3832 
 
3833 
 
3834 
/* 0011 1010 ssN0 0011 0000 aaaa ddN0 0000 *** soutibr @rd,@rs,ra */
3835 
{
3836 
#ifdef NICENAMES
3837 
"soutibr @rd,@rs,ra",16,0,
3838 
0x00,
3839 
#endif
3840 
"soutibr",OPC_soutibr,0,{CLASS_IR+(ARG_RD),CLASS_IR+(ARG_RS),CLASS_REG_WORD+(ARG_RA),},
3841 
        {CLASS_BIT+3,CLASS_BIT+0xa,CLASS_REGN0+(ARG_RS),CLASS_BIT+3,CLASS_BIT+0,CLASS_REG+(ARG_RA),CLASS_REGN0+(ARG_RD),CLASS_BIT+0,0,},3,4,357},
3842 
 
3843 
 
3844 
/* 1011 0011 dddd 1001 1111 1111 nim8 *** sra rd,imm8 */
3845 
{
3846 
#ifdef NICENAMES
3847 
"sra rd,imm8",16,13,
3848 
0x3c,
3849 
#endif
3850 
"sra",OPC_sra,0,{CLASS_REG_WORD+(ARG_RD),CLASS_IMM+(ARG_IMM8),},
3851 
        {CLASS_BIT+0xb,CLASS_BIT+3,CLASS_REG+(ARG_RD),CLASS_BIT+9,CLASS_BIT+0xf,CLASS_BIT+0xf,CLASS_IMM+(ARG_NIM8),0,0,},2,4,358},
3852 
 
3853 
 
3854 
/* 1011 0010 dddd 1001 iiii iiii 1111 nim4 *** srab rbd,imm4 */
3855 
{
3856 
#ifdef NICENAMES
3857 
"srab rbd,imm4",8,13,
3858 
0x3c,
3859 
#endif
3860 
"srab",OPC_srab,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_IMM +(ARG_IMM4),},
3861 
        {CLASS_BIT+0xb,CLASS_BIT+2,CLASS_REG+(ARG_RD),CLASS_BIT+9,CLASS_IGNORE,CLASS_IGNORE,CLASS_BIT+0xf,CLASS_IMM+(ARG_NIM4),0,},2,4,359},
3862 
 
3863 
 
3864 
/* 1011 0011 dddd 1101 1111 1111 nim8 *** sral rrd,imm8 */
3865 
{
3866 
#ifdef NICENAMES
3867 
"sral rrd,imm8",32,13,
3868 
0x3c,
3869 
#endif
3870 
"sral",OPC_sral,0,{CLASS_REG_LONG+(ARG_RD),CLASS_IMM+(ARG_IMM8),},
3871 
        {CLASS_BIT+0xb,CLASS_BIT+3,CLASS_REG+(ARG_RD),CLASS_BIT+0xd,CLASS_BIT+0xf,CLASS_BIT+0xf,CLASS_IMM+(ARG_NIM8),0,0,},2,4,360},
3872 
 
3873 
 
3874 
/* 1011 0011 dddd 0001 1111 1111 nim8 *** srl rd,imm8 */
3875 
{
3876 
#ifdef NICENAMES
3877 
"srl rd,imm8",16,13,
3878 
0x3c,
3879 
#endif
3880 
"srl",OPC_srl,0,{CLASS_REG_WORD+(ARG_RD),CLASS_IMM+(ARG_IMM8),},
3881 
        {CLASS_BIT+0xb,CLASS_BIT+3,CLASS_REG+(ARG_RD),CLASS_BIT+1,CLASS_BIT+0xf,CLASS_BIT+0xf,CLASS_IMM+(ARG_NIM8),0,0,},2,4,361},
3882 
 
3883 
 
3884 
/* 1011 0010 dddd 0001 iiii iiii 1111 nim4 *** srlb rbd,imm4 */
3885 
{
3886 
#ifdef NICENAMES
3887 
"srlb rbd,imm4",8,13,
3888 
0x3c,
3889 
#endif
3890 
"srlb",OPC_srlb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_IMM +(ARG_IMM4),},
3891 
        {CLASS_BIT+0xb,CLASS_BIT+2,CLASS_REG+(ARG_RD),CLASS_BIT+1,CLASS_IGNORE,CLASS_IGNORE,CLASS_BIT+0xf,CLASS_IMM+(ARG_NIM4),0,},2,4,362},
3892 
 
3893 
 
3894 
/* 1011 0011 dddd 0101 1111 1111 nim8 *** srll rrd,imm8 */
3895 
{
3896 
#ifdef NICENAMES
3897 
"srll rrd,imm8",32,13,
3898 
0x3c,
3899 
#endif
3900 
"srll",OPC_srll,0,{CLASS_REG_LONG+(ARG_RD),CLASS_IMM+(ARG_IMM8),},
3901 
        {CLASS_BIT+0xb,CLASS_BIT+3,CLASS_REG+(ARG_RD),CLASS_BIT+5,CLASS_BIT+0xf,CLASS_BIT+0xf,CLASS_IMM+(ARG_NIM8),0,0,},2,4,363},
3902 
 
3903 
 
3904 
/* 0000 0011 ssN0 dddd *** sub rd,@rs */
3905 
{
3906 
#ifdef NICENAMES
3907 
"sub rd,@rs",16,7,
3908 
0x3c,
3909 
#endif
3910 
"sub",OPC_sub,0,{CLASS_REG_WORD+(ARG_RD),CLASS_IR+(ARG_RS),},
3911 
        {CLASS_BIT+0,CLASS_BIT+3,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,364},
3912 
 
3913 
 
3914 
/* 0100 0011 0000 dddd address_src *** sub rd,address_src */
3915 
{
3916 
#ifdef NICENAMES
3917 
"sub rd,address_src",16,9,
3918 
0x3c,
3919 
#endif
3920 
"sub",OPC_sub,0,{CLASS_REG_WORD+(ARG_RD),CLASS_DA+(ARG_SRC),},
3921 
        {CLASS_BIT+4,CLASS_BIT+3,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,365},
3922 
 
3923 
 
3924 
/* 0100 0011 ssN0 dddd address_src *** sub rd,address_src(rs) */
3925 
{
3926 
#ifdef NICENAMES
3927 
"sub rd,address_src(rs)",16,10,
3928 
0x3c,
3929 
#endif
3930 
"sub",OPC_sub,0,{CLASS_REG_WORD+(ARG_RD),CLASS_X+(ARG_RS),},
3931 
        {CLASS_BIT+4,CLASS_BIT+3,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,366},
3932 
 
3933 
 
3934 
/* 0000 0011 0000 dddd imm16 *** sub rd,imm16 */
3935 
{
3936 
#ifdef NICENAMES
3937 
"sub rd,imm16",16,7,
3938 
0x3c,
3939 
#endif
3940 
"sub",OPC_sub,0,{CLASS_REG_WORD+(ARG_RD),CLASS_IMM+(ARG_IMM16),},
3941 
        {CLASS_BIT+0,CLASS_BIT+3,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_IMM+(ARG_IMM16),0,0,0,0,},2,4,367},
3942 
 
3943 
 
3944 
/* 1000 0011 ssss dddd *** sub rd,rs */
3945 
{
3946 
#ifdef NICENAMES
3947 
"sub rd,rs",16,4,
3948 
0x3c,
3949 
#endif
3950 
"sub",OPC_sub,0,{CLASS_REG_WORD+(ARG_RD),CLASS_REG_WORD+(ARG_RS),},
3951 
        {CLASS_BIT+8,CLASS_BIT+3,CLASS_REG+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,368},
3952 
 
3953 
 
3954 
/* 0000 0010 ssN0 dddd *** subb rbd,@rs */
3955 
{
3956 
#ifdef NICENAMES
3957 
"subb rbd,@rs",8,7,
3958 
0x3f,
3959 
#endif
3960 
"subb",OPC_subb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_IR+(ARG_RS),},
3961 
        {CLASS_BIT+0,CLASS_BIT+2,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,369},
3962 
 
3963 
 
3964 
/* 0100 0010 0000 dddd address_src *** subb rbd,address_src */
3965 
{
3966 
#ifdef NICENAMES
3967 
"subb rbd,address_src",8,9,
3968 
0x3f,
3969 
#endif
3970 
"subb",OPC_subb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_DA+(ARG_SRC),},
3971 
        {CLASS_BIT+4,CLASS_BIT+2,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,370},
3972 
 
3973 
 
3974 
/* 0100 0010 ssN0 dddd address_src *** subb rbd,address_src(rs) */
3975 
{
3976 
#ifdef NICENAMES
3977 
"subb rbd,address_src(rs)",8,10,
3978 
0x3f,
3979 
#endif
3980 
"subb",OPC_subb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_X+(ARG_RS),},
3981 
        {CLASS_BIT+4,CLASS_BIT+2,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,371},
3982 
 
3983 
 
3984 
/* 0000 0010 0000 dddd imm8 imm8 *** subb rbd,imm8 */
3985 
{
3986 
#ifdef NICENAMES
3987 
"subb rbd,imm8",8,7,
3988 
0x3f,
3989 
#endif
3990 
"subb",OPC_subb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_IMM+(ARG_IMM8),},
3991 
        {CLASS_BIT+0,CLASS_BIT+2,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_IMM+(ARG_IMM8),CLASS_IMM+(ARG_IMM8),0,0,0,},2,4,372},
3992 
 
3993 
 
3994 
/* 1000 0010 ssss dddd *** subb rbd,rbs */
3995 
{
3996 
#ifdef NICENAMES
3997 
"subb rbd,rbs",8,4,
3998 
0x3f,
3999 
#endif
4000 
"subb",OPC_subb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_REG_BYTE+(ARG_RS),},
4001 
        {CLASS_BIT+8,CLASS_BIT+2,CLASS_REG+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,373},
4002 
 
4003 
 
4004 
/* 0001 0010 ssN0 dddd *** subl rrd,@rs */
4005 
{
4006 
#ifdef NICENAMES
4007 
"subl rrd,@rs",32,14,
4008 
0x3c,
4009 
#endif
4010 
"subl",OPC_subl,0,{CLASS_REG_LONG+(ARG_RD),CLASS_IR+(ARG_RS),},
4011 
        {CLASS_BIT+1,CLASS_BIT+2,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,374},
4012 
 
4013 
 
4014 
/* 0101 0010 0000 dddd address_src *** subl rrd,address_src */
4015 
{
4016 
#ifdef NICENAMES
4017 
"subl rrd,address_src",32,15,
4018 
0x3c,
4019 
#endif
4020 
"subl",OPC_subl,0,{CLASS_REG_LONG+(ARG_RD),CLASS_DA+(ARG_SRC),},
4021 
        {CLASS_BIT+5,CLASS_BIT+2,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,375},
4022 
 
4023 
 
4024 
/* 0101 0010 ssN0 dddd address_src *** subl rrd,address_src(rs) */
4025 
{
4026 
#ifdef NICENAMES
4027 
"subl rrd,address_src(rs)",32,16,
4028 
0x3c,
4029 
#endif
4030 
"subl",OPC_subl,0,{CLASS_REG_LONG+(ARG_RD),CLASS_X+(ARG_RS),},
4031 
        {CLASS_BIT+5,CLASS_BIT+2,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,376},
4032 
 
4033 
 
4034 
/* 0001 0010 0000 dddd imm32 *** subl rrd,imm32 */
4035 
{
4036 
#ifdef NICENAMES
4037 
"subl rrd,imm32",32,14,
4038 
0x3c,
4039 
#endif
4040 
"subl",OPC_subl,0,{CLASS_REG_LONG+(ARG_RD),CLASS_IMM+(ARG_IMM32),},
4041 
        {CLASS_BIT+1,CLASS_BIT+2,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_IMM+(ARG_IMM32),0,0,0,0,},2,6,377},
4042 
 
4043 
 
4044 
/* 1001 0010 ssss dddd *** subl rrd,rrs */
4045 
{
4046 
#ifdef NICENAMES
4047 
"subl rrd,rrs",32,8,
4048 
0x3c,
4049 
#endif
4050 
"subl",OPC_subl,0,{CLASS_REG_LONG+(ARG_RD),CLASS_REG_LONG+(ARG_RS),},
4051 
        {CLASS_BIT+9,CLASS_BIT+2,CLASS_REG+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,378},
4052 
 
4053 
 
4054 
/* 1010 1111 dddd cccc *** tcc cc,rd */
4055 
{
4056 
#ifdef NICENAMES
4057 
"tcc cc,rd",16,5,
4058 
0x00,
4059 
#endif
4060 
"tcc",OPC_tcc,0,{CLASS_CC,CLASS_REG_WORD+(ARG_RD),},
4061 
        {CLASS_BIT+0xa,CLASS_BIT+0xf,CLASS_REG+(ARG_RD),CLASS_CC,0,0,0,0,0,},2,2,379},
4062 
 
4063 
 
4064 
/* 1010 1110 dddd cccc *** tccb cc,rbd */
4065 
{
4066 
#ifdef NICENAMES
4067 
"tccb cc,rbd",8,5,
4068 
0x00,
4069 
#endif
4070 
"tccb",OPC_tccb,0,{CLASS_CC,CLASS_REG_BYTE+(ARG_RD),},
4071 
        {CLASS_BIT+0xa,CLASS_BIT+0xe,CLASS_REG+(ARG_RD),CLASS_CC,0,0,0,0,0,},2,2,380},
4072 
 
4073 
 
4074 
/* 0000 1101 ddN0 0100 *** test @rd */
4075 
{
4076 
#ifdef NICENAMES
4077 
"test @rd",16,8,
4078 
0x18,
4079 
#endif
4080 
"test",OPC_test,0,{CLASS_IR+(ARG_RD),},
4081 
        {CLASS_BIT+0,CLASS_BIT+0xd,CLASS_REGN0+(ARG_RD),CLASS_BIT+4,0,0,0,0,0,},1,2,381},
4082 
 
4083 
 
4084 
/* 0100 1101 0000 0100 address_dst *** test address_dst */
4085 
{
4086 
#ifdef NICENAMES
4087 
"test address_dst",16,11,
4088 
0x00,
4089 
#endif
4090 
"test",OPC_test,0,{CLASS_DA+(ARG_DST),},
4091 
        {CLASS_BIT+4,CLASS_BIT+0xd,CLASS_BIT+0,CLASS_BIT+4,CLASS_ADDRESS+(ARG_DST),0,0,0,0,},1,4,382},
4092 
 
4093 
 
4094 
/* 0100 1101 ddN0 0100 address_dst *** test address_dst(rd) */
4095 
{
4096 
#ifdef NICENAMES
4097 
"test address_dst(rd)",16,12,
4098 
0x00,
4099 
#endif
4100 
"test",OPC_test,0,{CLASS_X+(ARG_RD),},
4101 
        {CLASS_BIT+4,CLASS_BIT+0xd,CLASS_REGN0+(ARG_RD),CLASS_BIT+4,CLASS_ADDRESS+(ARG_DST),0,0,0,0,},1,4,383},
4102 
 
4103 
 
4104 
/* 1000 1101 dddd 0100 *** test rd */
4105 
{
4106 
#ifdef NICENAMES
4107 
"test rd",16,7,
4108 
0x00,
4109 
#endif
4110 
"test",OPC_test,0,{CLASS_REG_WORD+(ARG_RD),},
4111 
        {CLASS_BIT+8,CLASS_BIT+0xd,CLASS_REG+(ARG_RD),CLASS_BIT+4,0,0,0,0,0,},1,2,384},
4112 
 
4113 
 
4114 
/* 0000 1100 ddN0 0100 *** testb @rd */
4115 
{
4116 
#ifdef NICENAMES
4117 
"testb @rd",8,8,
4118 
0x1c,
4119 
#endif
4120 
"testb",OPC_testb,0,{CLASS_IR+(ARG_RD),},
4121 
        {CLASS_BIT+0,CLASS_BIT+0xc,CLASS_REGN0+(ARG_RD),CLASS_BIT+4,0,0,0,0,0,},1,2,385},
4122 
 
4123 
 
4124 
/* 0100 1100 0000 0100 address_dst *** testb address_dst */
4125 
{
4126 
#ifdef NICENAMES
4127 
"testb address_dst",8,11,
4128 
0x1c,
4129 
#endif
4130 
"testb",OPC_testb,0,{CLASS_DA+(ARG_DST),},
4131 
        {CLASS_BIT+4,CLASS_BIT+0xc,CLASS_BIT+0,CLASS_BIT+4,CLASS_ADDRESS+(ARG_DST),0,0,0,0,},1,4,386},
4132 
 
4133 
 
4134 
/* 0100 1100 ddN0 0100 address_dst *** testb address_dst(rd) */
4135 
{
4136 
#ifdef NICENAMES
4137 
"testb address_dst(rd)",8,12,
4138 
0x1c,
4139 
#endif
4140 
"testb",OPC_testb,0,{CLASS_X+(ARG_RD),},
4141 
        {CLASS_BIT+4,CLASS_BIT+0xc,CLASS_REGN0+(ARG_RD),CLASS_BIT+4,CLASS_ADDRESS+(ARG_DST),0,0,0,0,},1,4,387},
4142 
 
4143 
 
4144 
/* 1000 1100 dddd 0100 *** testb rbd */
4145 
{
4146 
#ifdef NICENAMES
4147 
"testb rbd",8,7,
4148 
0x1c,
4149 
#endif
4150 
"testb",OPC_testb,0,{CLASS_REG_BYTE+(ARG_RD),},
4151 
        {CLASS_BIT+8,CLASS_BIT+0xc,CLASS_REG+(ARG_RD),CLASS_BIT+4,0,0,0,0,0,},1,2,388},
4152 
 
4153 
 
4154 
/* 0001 1100 ddN0 1000 *** testl @rd */
4155 
{
4156 
#ifdef NICENAMES
4157 
"testl @rd",32,13,
4158 
0x18,
4159 
#endif
4160 
"testl",OPC_testl,0,{CLASS_IR+(ARG_RD),},
4161 
        {CLASS_BIT+1,CLASS_BIT+0xc,CLASS_REGN0+(ARG_RD),CLASS_BIT+8,0,0,0,0,0,},1,2,389},
4162 
 
4163 
 
4164 
/* 0101 1100 0000 1000 address_dst *** testl address_dst */
4165 
{
4166 
#ifdef NICENAMES
4167 
"testl address_dst",32,16,
4168 
0x18,
4169 
#endif
4170 
"testl",OPC_testl,0,{CLASS_DA+(ARG_DST),},
4171 
        {CLASS_BIT+5,CLASS_BIT+0xc,CLASS_BIT+0,CLASS_BIT+8,CLASS_ADDRESS+(ARG_DST),0,0,0,0,},1,4,390},
4172 
 
4173 
 
4174 
/* 0101 1100 ddN0 1000 address_dst *** testl address_dst(rd) */
4175 
{
4176 
#ifdef NICENAMES
4177 
"testl address_dst(rd)",32,17,
4178 
0x18,
4179 
#endif
4180 
"testl",OPC_testl,0,{CLASS_X+(ARG_RD),},
4181 
        {CLASS_BIT+5,CLASS_BIT+0xc,CLASS_REGN0+(ARG_RD),CLASS_BIT+8,CLASS_ADDRESS+(ARG_DST),0,0,0,0,},1,4,391},
4182 
 
4183 
 
4184 
/* 1001 1100 dddd 1000 *** testl rrd */
4185 
{
4186 
#ifdef NICENAMES
4187 
"testl rrd",32,13,
4188 
0x18,
4189 
#endif
4190 
"testl",OPC_testl,0,{CLASS_REG_LONG+(ARG_RD),},
4191 
        {CLASS_BIT+9,CLASS_BIT+0xc,CLASS_REG+(ARG_RD),CLASS_BIT+8,0,0,0,0,0,},1,2,392},
4192 
 
4193 
 
4194 
/* 1011 1000 ddN0 1000 0000 aaaa ssN0 0000 *** trdb @rd,@rs,rba */
4195 
{
4196 
#ifdef NICENAMES
4197 
"trdb @rd,@rs,rba",8,25,
4198 
0x1c,
4199 
#endif
4200 
"trdb",OPC_trdb,0,{CLASS_IR+(ARG_RD),CLASS_IR+(ARG_RS),CLASS_REG_BYTE+(ARG_RA),},
4201 
        {CLASS_BIT+0xb,CLASS_BIT+8,CLASS_REGN0+(ARG_RD),CLASS_BIT+8,CLASS_BIT+0,CLASS_REG+(ARG_RA),CLASS_REGN0+(ARG_RS),CLASS_BIT+0,0,},3,4,393},
4202 
 
4203 
 
4204 
/* 1011 1000 ddN0 1100 0000 aaaa ssN0 0000 *** trdrb @rd,@rs,rba */
4205 
{
4206 
#ifdef NICENAMES
4207 
"trdrb @rd,@rs,rba",8,25,
4208 
0x1c,
4209 
#endif
4210 
"trdrb",OPC_trdrb,0,{CLASS_IR+(ARG_RD),CLASS_IR+(ARG_RS),CLASS_REG_BYTE+(ARG_RA),},
4211 
        {CLASS_BIT+0xb,CLASS_BIT+8,CLASS_REGN0+(ARG_RD),CLASS_BIT+0xc,CLASS_BIT+0,CLASS_REG+(ARG_RA),CLASS_REGN0+(ARG_RS),CLASS_BIT+0,0,},3,4,394},
4212 
 
4213 
 
4214 
/* 1011 1000 ddN0 0000 0000 rrrr ssN0 0000 *** trib @rd,@rs,rbr */
4215 
{
4216 
#ifdef NICENAMES
4217 
"trib @rd,@rs,rbr",8,25,
4218 
0x1c,
4219 
#endif
4220 
"trib",OPC_trib,0,{CLASS_IR+(ARG_RD),CLASS_IR+(ARG_RS),CLASS_REG_BYTE+(ARG_RR),},
4221 
        {CLASS_BIT+0xb,CLASS_BIT+8,CLASS_REGN0+(ARG_RD),CLASS_BIT+0,CLASS_BIT+0,CLASS_REG+(ARG_RR),CLASS_REGN0+(ARG_RS),CLASS_BIT+0,0,},3,4,395},
4222 
 
4223 
 
4224 
/* 1011 1000 ddN0 0100 0000 rrrr ssN0 0000 *** trirb @rd,@rs,rbr */
4225 
{
4226 
#ifdef NICENAMES
4227 
"trirb @rd,@rs,rbr",8,25,
4228 
0x1c,
4229 
#endif
4230 
"trirb",OPC_trirb,0,{CLASS_IR+(ARG_RD),CLASS_IR+(ARG_RS),CLASS_REG_BYTE+(ARG_RR),},
4231 
        {CLASS_BIT+0xb,CLASS_BIT+8,CLASS_REGN0+(ARG_RD),CLASS_BIT+4,CLASS_BIT+0,CLASS_REG+(ARG_RR),CLASS_REGN0+(ARG_RS),CLASS_BIT+0,0,},3,4,396},
4232 
 
4233 
 
4234 
/* 1011 1000 aaN0 1010 0000 rrrr bbN0 0000 *** trtdb @ra,@rb,rbr */
4235 
{
4236 
#ifdef NICENAMES
4237 
"trtdb @ra,@rb,rbr",8,25,
4238 
0x1c,
4239 
#endif
4240 
"trtdb",OPC_trtdb,0,{CLASS_IR+(ARG_RA),CLASS_IR+(ARG_RB),CLASS_REG_BYTE+(ARG_RR),},
4241 
        {CLASS_BIT+0xb,CLASS_BIT+8,CLASS_REGN0+(ARG_RA),CLASS_BIT+0xa,CLASS_BIT+0,CLASS_REG+(ARG_RR),CLASS_REGN0+(ARG_RB),CLASS_BIT+0,0,},3,4,397},
4242 
 
4243 
 
4244 
/* 1011 1000 aaN0 1110 0000 rrrr bbN0 1110 *** trtdrb @ra,@rb,rbr */
4245 
{
4246 
#ifdef NICENAMES
4247 
"trtdrb @ra,@rb,rbr",8,25,
4248 
0x1c,
4249 
#endif
4250 
"trtdrb",OPC_trtdrb,0,{CLASS_IR+(ARG_RA),CLASS_IR+(ARG_RB),CLASS_REG_BYTE+(ARG_RR),},
4251 
        {CLASS_BIT+0xb,CLASS_BIT+8,CLASS_REGN0+(ARG_RA),CLASS_BIT+0xe,CLASS_BIT+0,CLASS_REG+(ARG_RR),CLASS_REGN0+(ARG_RB),CLASS_BIT+0xe,0,},3,4,398},
4252 
 
4253 
 
4254 
/* 1011 1000 aaN0 0010 0000 rrrr bbN0 0000 *** trtib @ra,@rb,rbr */
4255 
{
4256 
#ifdef NICENAMES
4257 
"trtib @ra,@rb,rbr",8,25,
4258 
0x1c,
4259 
#endif
4260 
"trtib",OPC_trtib,0,{CLASS_IR+(ARG_RA),CLASS_IR+(ARG_RB),CLASS_REG_BYTE+(ARG_RR),},
4261 
        {CLASS_BIT+0xb,CLASS_BIT+8,CLASS_REGN0+(ARG_RA),CLASS_BIT+2,CLASS_BIT+0,CLASS_REG+(ARG_RR),CLASS_REGN0+(ARG_RB),CLASS_BIT+0,0,},3,4,399},
4262 
 
4263 
 
4264 
/* 1011 1000 aaN0 0110 0000 rrrr bbN0 1110 *** trtirb @ra,@rb,rbr */
4265 
{
4266 
#ifdef NICENAMES
4267 
"trtirb @ra,@rb,rbr",8,25,
4268 
0x1c,
4269 
#endif
4270 
"trtirb",OPC_trtirb,0,{CLASS_IR+(ARG_RA),CLASS_IR+(ARG_RB),CLASS_REG_BYTE+(ARG_RR),},
4271 
        {CLASS_BIT+0xb,CLASS_BIT+8,CLASS_REGN0+(ARG_RA),CLASS_BIT+6,CLASS_BIT+0,CLASS_REG+(ARG_RR),CLASS_REGN0+(ARG_RB),CLASS_BIT+0xe,0,},3,4,400},
4272 
 
4273 
 
4274 
/* 1011 1000 aaN0 1010 0000 rrrr bbN0 0000 *** trtrb @ra,@rb,rbr */
4275 
{
4276 
#ifdef NICENAMES
4277 
"trtrb @ra,@rb,rbr",8,25,
4278 
0x1c,
4279 
#endif
4280 
"trtrb",OPC_trtrb,0,{CLASS_IR+(ARG_RA),CLASS_IR+(ARG_RB),CLASS_REG_BYTE+(ARG_RR),},
4281 
        {CLASS_BIT+0xb,CLASS_BIT+8,CLASS_REGN0+(ARG_RA),CLASS_BIT+0xa,CLASS_BIT+0,CLASS_REG+(ARG_RR),CLASS_REGN0+(ARG_RB),CLASS_BIT+0,0,},3,4,401},
4282 
 
4283 
 
4284 
/* 0000 1101 ddN0 0110 *** tset @rd */
4285 
{
4286 
#ifdef NICENAMES
4287 
"tset @rd",16,11,
4288 
0x08,
4289 
#endif
4290 
"tset",OPC_tset,0,{CLASS_IR+(ARG_RD),},
4291 
        {CLASS_BIT+0,CLASS_BIT+0xd,CLASS_REGN0+(ARG_RD),CLASS_BIT+6,0,0,0,0,0,},1,2,402},
4292 
 
4293 
 
4294 
/* 0100 1101 0000 0110 address_dst *** tset address_dst */
4295 
{
4296 
#ifdef NICENAMES
4297 
"tset address_dst",16,14,
4298 
0x08,
4299 
#endif
4300 
"tset",OPC_tset,0,{CLASS_DA+(ARG_DST),},
4301 
        {CLASS_BIT+4,CLASS_BIT+0xd,CLASS_BIT+0,CLASS_BIT+6,CLASS_ADDRESS+(ARG_DST),0,0,0,0,},1,4,403},
4302 
 
4303 
 
4304 
/* 0100 1101 ddN0 0110 address_dst *** tset address_dst(rd) */
4305 
{
4306 
#ifdef NICENAMES
4307 
"tset address_dst(rd)",16,15,
4308 
0x08,
4309 
#endif
4310 
"tset",OPC_tset,0,{CLASS_X+(ARG_RD),},
4311 
        {CLASS_BIT+4,CLASS_BIT+0xd,CLASS_REGN0+(ARG_RD),CLASS_BIT+6,CLASS_ADDRESS+(ARG_DST),0,0,0,0,},1,4,404},
4312 
 
4313 
 
4314 
/* 1000 1101 dddd 0110 *** tset rd */
4315 
{
4316 
#ifdef NICENAMES
4317 
"tset rd",16,7,
4318 
0x08,
4319 
#endif
4320 
"tset",OPC_tset,0,{CLASS_REG_WORD+(ARG_RD),},
4321 
        {CLASS_BIT+8,CLASS_BIT+0xd,CLASS_REG+(ARG_RD),CLASS_BIT+6,0,0,0,0,0,},1,2,405},
4322 
 
4323 
 
4324 
/* 0000 1100 ddN0 0110 *** tsetb @rd */
4325 
{
4326 
#ifdef NICENAMES
4327 
"tsetb @rd",8,11,
4328 
0x08,
4329 
#endif
4330 
"tsetb",OPC_tsetb,0,{CLASS_IR+(ARG_RD),},
4331 
        {CLASS_BIT+0,CLASS_BIT+0xc,CLASS_REGN0+(ARG_RD),CLASS_BIT+6,0,0,0,0,0,},1,2,406},
4332 
 
4333 
 
4334 
/* 0100 1100 0000 0110 address_dst *** tsetb address_dst */
4335 
{
4336 
#ifdef NICENAMES
4337 
"tsetb address_dst",8,14,
4338 
0x08,
4339 
#endif
4340 
"tsetb",OPC_tsetb,0,{CLASS_DA+(ARG_DST),},
4341 
        {CLASS_BIT+4,CLASS_BIT+0xc,CLASS_BIT+0,CLASS_BIT+6,CLASS_ADDRESS+(ARG_DST),0,0,0,0,},1,4,407},
4342 
 
4343 
 
4344 
/* 0100 1100 ddN0 0110 address_dst *** tsetb address_dst(rd) */
4345 
{
4346 
#ifdef NICENAMES
4347 
"tsetb address_dst(rd)",8,15,
4348 
0x08,
4349 
#endif
4350 
"tsetb",OPC_tsetb,0,{CLASS_X+(ARG_RD),},
4351 
        {CLASS_BIT+4,CLASS_BIT+0xc,CLASS_REGN0+(ARG_RD),CLASS_BIT+6,CLASS_ADDRESS+(ARG_DST),0,0,0,0,},1,4,408},
4352 
 
4353 
 
4354 
/* 1000 1100 dddd 0110 *** tsetb rbd */
4355 
{
4356 
#ifdef NICENAMES
4357 
"tsetb rbd",8,7,
4358 
0x08,
4359 
#endif
4360 
"tsetb",OPC_tsetb,0,{CLASS_REG_BYTE+(ARG_RD),},
4361 
        {CLASS_BIT+8,CLASS_BIT+0xc,CLASS_REG+(ARG_RD),CLASS_BIT+6,0,0,0,0,0,},1,2,409},
4362 
 
4363 
 
4364 
/* 0000 1001 ssN0 dddd *** xor rd,@rs */
4365 
{
4366 
#ifdef NICENAMES
4367 
"xor rd,@rs",16,7,
4368 
0x18,
4369 
#endif
4370 
"xor",OPC_xor,0,{CLASS_REG_WORD+(ARG_RD),CLASS_IR+(ARG_RS),},
4371 
        {CLASS_BIT+0,CLASS_BIT+9,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,410},
4372 
 
4373 
 
4374 
/* 0100 1001 0000 dddd address_src *** xor rd,address_src */
4375 
{
4376 
#ifdef NICENAMES
4377 
"xor rd,address_src",16,9,
4378 
0x18,
4379 
#endif
4380 
"xor",OPC_xor,0,{CLASS_REG_WORD+(ARG_RD),CLASS_DA+(ARG_SRC),},
4381 
        {CLASS_BIT+4,CLASS_BIT+9,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,411},
4382 
 
4383 
 
4384 
/* 0100 1001 ssN0 dddd address_src *** xor rd,address_src(rs) */
4385 
{
4386 
#ifdef NICENAMES
4387 
"xor rd,address_src(rs)",16,10,
4388 
0x18,
4389 
#endif
4390 
"xor",OPC_xor,0,{CLASS_REG_WORD+(ARG_RD),CLASS_X+(ARG_RS),},
4391 
        {CLASS_BIT+4,CLASS_BIT+9,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,412},
4392 
 
4393 
 
4394 
/* 0000 1001 0000 dddd imm16 *** xor rd,imm16 */
4395 
{
4396 
#ifdef NICENAMES
4397 
"xor rd,imm16",16,7,
4398 
0x18,
4399 
#endif
4400 
"xor",OPC_xor,0,{CLASS_REG_WORD+(ARG_RD),CLASS_IMM+(ARG_IMM16),},
4401 
        {CLASS_BIT+0,CLASS_BIT+9,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_IMM+(ARG_IMM16),0,0,0,0,},2,4,413},
4402 
 
4403 
 
4404 
/* 1000 1001 ssss dddd *** xor rd,rs */
4405 
{
4406 
#ifdef NICENAMES
4407 
"xor rd,rs",16,4,
4408 
0x18,
4409 
#endif
4410 
"xor",OPC_xor,0,{CLASS_REG_WORD+(ARG_RD),CLASS_REG_WORD+(ARG_RS),},
4411 
        {CLASS_BIT+8,CLASS_BIT+9,CLASS_REG+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,414},
4412 
 
4413 
 
4414 
/* 0000 1000 ssN0 dddd *** xorb rbd,@rs */
4415 
{
4416 
#ifdef NICENAMES
4417 
"xorb rbd,@rs",8,7,
4418 
0x1c,
4419 
#endif
4420 
"xorb",OPC_xorb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_IR+(ARG_RS),},
4421 
        {CLASS_BIT+0,CLASS_BIT+8,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,415},
4422 
 
4423 
 
4424 
/* 0100 1000 0000 dddd address_src *** xorb rbd,address_src */
4425 
{
4426 
#ifdef NICENAMES
4427 
"xorb rbd,address_src",8,9,
4428 
0x1c,
4429 
#endif
4430 
"xorb",OPC_xorb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_DA+(ARG_SRC),},
4431 
        {CLASS_BIT+4,CLASS_BIT+8,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,416},
4432 
 
4433 
 
4434 
/* 0100 1000 ssN0 dddd address_src *** xorb rbd,address_src(rs) */
4435 
{
4436 
#ifdef NICENAMES
4437 
"xorb rbd,address_src(rs)",8,10,
4438 
0x1c,
4439 
#endif
4440 
"xorb",OPC_xorb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_X+(ARG_RS),},
4441 
        {CLASS_BIT+4,CLASS_BIT+8,CLASS_REGN0+(ARG_RS),CLASS_REG+(ARG_RD),CLASS_ADDRESS+(ARG_SRC),0,0,0,0,},2,4,417},
4442 
 
4443 
 
4444 
/* 0000 1000 0000 dddd imm8 imm8 *** xorb rbd,imm8 */
4445 
{
4446 
#ifdef NICENAMES
4447 
"xorb rbd,imm8",8,7,
4448 
0x1c,
4449 
#endif
4450 
"xorb",OPC_xorb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_IMM+(ARG_IMM8),},
4451 
        {CLASS_BIT+0,CLASS_BIT+8,CLASS_BIT+0,CLASS_REG+(ARG_RD),CLASS_IMM+(ARG_IMM8),CLASS_IMM+(ARG_IMM8),0,0,0,},2,4,418},
4452 
 
4453 
 
4454 
/* 1000 1000 ssss dddd *** xorb rbd,rbs */
4455 
{
4456 
#ifdef NICENAMES
4457 
"xorb rbd,rbs",8,4,
4458 
0x1c,
4459 
#endif
4460 
"xorb",OPC_xorb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_REG_BYTE+(ARG_RS),},
4461 
        {CLASS_BIT+8,CLASS_BIT+8,CLASS_REG+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,419},
4462 
 
4463 
 
4464 
/* 1000 1000 ssss dddd *** xorb rbd,rbs */
4465 
{
4466 
#ifdef NICENAMES
4467 
"xorb rbd,rbs",8,4,
4468 
0x01,
4469 
#endif
4470 
"xorb",OPC_xorb,0,{CLASS_REG_BYTE+(ARG_RD),CLASS_REG_BYTE+(ARG_RS),},
4471 
        {CLASS_BIT+8,CLASS_BIT+8,CLASS_REG+(ARG_RS),CLASS_REG+(ARG_RD),0,0,0,0,0,},2,2,420},
4472 
 
4473 
/* end marker */
4474 
{
4475 
#ifdef NICENAMES
4476 
NULL,0,0,
4477 
0,
4478 
#endif
4479 
NULL,0,0,{0,0,0,0},{0,0,0,0,0,0,0,0,0,0},0,0,0}
4480 
};
4481 
#endif

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.