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

Subversion Repositories or1k

[/] [or1k/] [tags/] [start/] [gdb-5.0/] [opcodes/] [z8k-opc.h] - Blame information for rev 1778

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

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

powered by: WebSVN 2.1.0

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