// https://github.com/herumi/xbyak/pull/202
sal(rax, r8,   1);
sar(rax, r9,   4);
shl(rax, rdi,  8);
shr(rax, rsi, 12);
rcl(rax, r10, 16);
rcr(rax, r11, 20);
rol(rax, r14, 24);
ror(rax, r15, 28);
sal(rcx, qword[r8],  32);
sar(rcx, qword[r9],  36);
sal(rcx, qword[rdi], 40);
sar(rcx, qword[rsi], 44);
rcl(rcx, qword[r10], 48);
rcr(rcx, qword[r11], 52);
rol(rcx, qword[r14], 56);
ror(rcx, qword[r15], 60);

imul(rax, rdx, r10);
imul(rcx, r15, qword[rdi]);

pushp(rax);
pushp(r8);
pushp(r16);
pushp(r24);
pushp(r31);
popp(rax);
popp(r8);
popp(r16);
popp(r24);
popp(r31);

// lss/lfs/lgs with EGPR (REX2)
lss(r30, ptr[r29]);
lss(r8d, ptr[r24]);
lfs(eax, ptr[r16]);
lfs(r16d, ptr[rax]);
lfs(r16w, ptr[rax]);
lfs(r16, ptr[rax]);
lfs(r31d, ptr[r16+r17*8+0x40]);
lgs(r20d, ptr[r21]);
lgs(ax, ptr[r18+r19]);

// ---- moved from test/apx.cpp (simple encoding tests) ----
// reg_rm
adc(r17, ptr [rax]);
adc(ptr [r18], rdx);
adc(r30, rcx);
add(r17, ptr [rax]);
add(ptr [r18], rdx);
add(r30, rcx);
and_(r17, ptr [rax]);
and_(ptr [r18], rdx);
and_(r30, rcx);
cmp(r17, ptr [rax]);
cmp(ptr [r18], rdx);
cmp(r30, rcx);
or_(r17, ptr [rax]);
or_(ptr [r18], rdx);
or_(r30, rcx);
sbb(r17, ptr [rax]);
sbb(ptr [r18], rdx);
sbb(r30, rcx);
sub(r17, ptr [rax]);
sub(ptr [r18], rdx);
sub(r30, rcx);
xor_(r17, ptr [rax]);
xor_(ptr [r18], rdx);
xor_(r30, rcx);
add(r30, ptr [rbx+rcx*4]);
add(rax, ptr [r30+rcx*4]);
add(rax, ptr [rbx+r30*4]);

// reg64
adc(r30, rax);
adc(r30, rcx);
adc(r30, rdx);
adc(r30, rbx);
adc(r30, rsp);
adc(r30, rbp);
adc(r30, rsi);
adc(r30, rdi);
adc(r30, r8);
adc(r30, r9);
adc(r30, r10);
adc(r30, r11);
adc(r30, r12);
adc(r30, r13);
adc(r30, r14);
adc(r30, r15);
adc(r30, r16);
adc(r30, r17);
adc(r30, r18);
adc(r30, r19);
adc(r30, r20);
adc(r30, r21);
adc(r30, r22);
adc(r30, r23);
adc(r30, r24);
adc(r30, r25);
adc(r30, r26);
adc(r30, r27);
adc(r30, r28);
adc(r30, r29);
adc(r30, r30);
adc(r30, r31);
adc(rax, r30);
adc(rcx, r30);
adc(rdx, r30);
adc(rbx, r30);
adc(rsp, r30);
adc(rbp, r30);
adc(rsi, r30);
adc(rdi, r30);
adc(r8, r30);
adc(r9, r30);
adc(r10, r30);
adc(r11, r30);
adc(r12, r30);
adc(r13, r30);
adc(r14, r30);
adc(r15, r30);
adc(r16, r30);
adc(r17, r30);
adc(r18, r30);
adc(r19, r30);
adc(r20, r30);
adc(r21, r30);
adc(r22, r30);
adc(r23, r30);
adc(r24, r30);
adc(r25, r30);
adc(r26, r30);
adc(r27, r30);
adc(r28, r30);
adc(r29, r30);
adc(r30, r30);
adc(r31, r30);

// reg32
adc(r30d, eax);
adc(r30d, ecx);
adc(r30d, edx);
adc(r30d, ebx);
adc(r30d, esp);
adc(r30d, ebp);
adc(r30d, esi);
adc(r30d, edi);
adc(r30d, r8d);
adc(r30d, r9d);
adc(r30d, r10d);
adc(r30d, r11d);
adc(r30d, r12d);
adc(r30d, r13d);
adc(r30d, r14d);
adc(r30d, r15d);
adc(r30d, r16d);
adc(r30d, r17d);
adc(r30d, r18d);
adc(r30d, r19d);
adc(r30d, r20d);
adc(r30d, r21d);
adc(r30d, r22d);
adc(r30d, r23d);
adc(r30d, r24d);
adc(r30d, r25d);
adc(r30d, r26d);
adc(r30d, r27d);
adc(r30d, r28d);
adc(r30d, r29d);
adc(r30d, r30d);
adc(r30d, r31d);
adc(eax, r29d);
adc(ecx, r29d);
adc(edx, r29d);
adc(ebx, r29d);
adc(esp, r29d);
adc(ebp, r29d);
adc(esi, r29d);
adc(edi, r29d);
adc(r8d, r29d);
adc(r9d, r29d);
adc(r10d, r29d);
adc(r11d, r29d);
adc(r12d, r29d);
adc(r13d, r29d);
adc(r14d, r29d);
adc(r15d, r29d);
adc(r16d, r29d);
adc(r17d, r29d);
adc(r18d, r29d);
adc(r19d, r29d);
adc(r20d, r29d);
adc(r21d, r29d);
adc(r22d, r29d);
adc(r23d, r29d);
adc(r24d, r29d);
adc(r25d, r29d);
adc(r26d, r29d);
adc(r27d, r29d);
adc(r28d, r29d);
adc(r29d, r29d);
adc(r30d, r29d);
adc(r31d, r29d);

// reg16
adc(r30w, ax);
adc(r30w, cx);
adc(r30w, dx);
adc(r30w, bx);
adc(r30w, sp);
adc(r30w, bp);
adc(r30w, si);
adc(r30w, di);
adc(r30w, r8w);
adc(r30w, r9w);
adc(r30w, r10w);
adc(r30w, r11w);
adc(r30w, r12w);
adc(r30w, r13w);
adc(r30w, r14w);
adc(r30w, r15w);
adc(r30w, r16w);
adc(r30w, r17w);
adc(r30w, r18w);
adc(r30w, r19w);
adc(r30w, r20w);
adc(r30w, r21w);
adc(r30w, r22w);
adc(r30w, r23w);
adc(r30w, r24w);
adc(r30w, r25w);
adc(r30w, r26w);
adc(r30w, r27w);
adc(r30w, r28w);
adc(r30w, r29w);
adc(r30w, r30w);
adc(r30w, r31w);
adc(ax, r29w);
adc(cx, r29w);
adc(dx, r29w);
adc(bx, r29w);
adc(sp, r29w);
adc(bp, r29w);
adc(si, r29w);
adc(di, r29w);
adc(r8w, r29w);
adc(r9w, r29w);
adc(r10w, r29w);
adc(r11w, r29w);
adc(r12w, r29w);
adc(r13w, r29w);
adc(r14w, r29w);
adc(r15w, r29w);
adc(r16w, r29w);
adc(r17w, r29w);
adc(r18w, r29w);
adc(r19w, r29w);
adc(r20w, r29w);
adc(r21w, r29w);
adc(r22w, r29w);
adc(r23w, r29w);
adc(r24w, r29w);
adc(r25w, r29w);
adc(r26w, r29w);
adc(r27w, r29w);
adc(r28w, r29w);
adc(r29w, r29w);
adc(r30w, r29w);
adc(r31w, r29w);

// reg8
adc(r17b, al);
adc(r17b, cl);
adc(r17b, dl);
adc(r17b, bl);
adc(r17b, spl);
adc(r17b, bpl);
adc(r17b, sil);
adc(r17b, dil);
adc(r17b, r8b);
adc(r17b, r9b);
adc(r17b, r10b);
adc(r17b, r11b);
adc(r17b, r12b);
adc(r17b, r13b);
adc(r17b, r14b);
adc(r17b, r15b);
adc(r17b, r16b);
adc(r17b, r17b);
adc(r17b, r18b);
adc(r17b, r19b);
adc(r17b, r20b);
adc(r17b, r21b);
adc(r17b, r22b);
adc(r17b, r23b);
adc(r17b, r24b);
adc(r17b, r25b);
adc(r17b, r26b);
adc(r17b, r27b);
adc(r17b, r28b);
adc(r17b, r29b);
adc(r17b, r30b);
adc(r17b, r31b);
adc(al, r20b);
adc(cl, r20b);
adc(dl, r20b);
adc(bl, r20b);
adc(spl, r20b);
adc(bpl, r20b);
adc(sil, r20b);
adc(dil, r20b);
adc(r8b, r20b);
adc(r9b, r20b);
adc(r10b, r20b);
adc(r11b, r20b);
adc(r12b, r20b);
adc(r13b, r20b);
adc(r14b, r20b);
adc(r15b, r20b);
adc(r16b, r20b);
adc(r17b, r20b);
adc(r18b, r20b);
adc(r19b, r20b);
adc(r20b, r20b);
adc(r21b, r20b);
adc(r22b, r20b);
adc(r23b, r20b);
adc(r24b, r20b);
adc(r25b, r20b);
adc(r26b, r20b);
adc(r27b, r20b);
adc(r28b, r20b);
adc(r29b, r20b);
adc(r30b, r20b);
adc(r31b, r20b);

// rm
adc(r16, ptr [r17+0x40]);
adc(ptr [r17+0x40], r16);
adc(r16d, ptr [r17+0x40]);
adc(ptr [r17+0x40], r16d);
adc(r16w, ptr [r17+0x40]);
adc(ptr [r17+0x40], r16w);
adc(r16b, ptr [r17+0x40]);
adc(ptr [r17+0x40], r16b);
adc(r16, ptr [r18*4+0x40]);
adc(ptr [r18*4+0x40], r16);
adc(r16d, ptr [r18*4+0x40]);
adc(ptr [r18*4+0x40], r16d);
adc(r16w, ptr [r18*4+0x40]);
adc(ptr [r18*4+0x40], r16w);
adc(r16b, ptr [r18*4+0x40]);
adc(ptr [r18*4+0x40], r16b);
adc(r16, ptr [r17+r18*4+0x40]);
adc(ptr [r17+r18*4+0x40], r16);
adc(r16d, ptr [r17+r18*4+0x40]);
adc(ptr [r17+r18*4+0x40], r16d);
adc(r16w, ptr [r17+r18*4+0x40]);
adc(ptr [r17+r18*4+0x40], r16w);
adc(r16b, ptr [r17+r18*4+0x40]);
adc(ptr [r17+r18*4+0x40], r16b);

// r3
adc(r20b, r21b, r23b);
adc(r20w, r21w, r23w);
adc(r20d, r21d, r23d);
adc(r20, r21, r23);

// rm3
adc(rax, r18, ptr [rbx+rcx*4+0x123]);
adc(rax, ptr [rbx+rcx*4+0x123], r20);
adc(rax, ptr [r30], r29);
adc(r11, r13, ptr [r10]);
adc(r11, r13, ptr [r10*4]);
adc(r11, ptr [r10*8], r9);

// rm3_2
adc(r20b, r21b, r23b);
adc(r20w, r21w, r23w);
adc(r20d, r21d, r23d);
adc(r20, r21, r23);
adc(r20b, ptr [rax+rcx*4+0x7fffffff], 0x12);
adc(r20w, ptr [rax+rcx*4+0x7fffffff], 0x1234);
adc(r20d, ptr [rax+rcx*4+0x7fffffff], 0x12345678);
adc(r20, ptr [rax+rcx*4+0x7fffffff], 0x12345678);
adc(r20b, al, 0x12);
adc(r20w, ax, 0x1234);
adc(r20d, eax, 0x12345678);
adc(r20, rax, 0x12345678);

// adcx_adox
adcx(rax, r30);
adcx(ecx, r20d);
adcx(ecx, ptr [r31+r29*4]);
adcx(r20d, ptr [rax]);
adcx(r16, ptr [r31+r29*4]);
adcx(r17, ptr [rax]);
adcx(rax, rcx, rdx);
adox(rax, r30);
adox(ecx, r20d);
adox(ecx, ptr [r31+r29*4]);
adox(r20d, ptr [rax]);
adox(r16, ptr [r31+r29*4]);
adox(r17, ptr [rax]);
adox(rax, rcx, rdx);

// r3_2
add(rax, rcx, rdx);
adc(rax, rcx, rdx);
and_(rax, rcx, rdx);
or_(rax, rcx, rdx);
sbb(rax, rcx, rdx);
sub(rax, rcx, rdx);
xor_(rax, rcx, rdx);
add(r30, ptr [r20], r9);
adc(r30, ptr [r20], r9);
and_(r30, ptr [r20], r9);
or_(r30, ptr [r20], r9);
sbb(r30, ptr [r20], r9);
sub(r30, ptr [r20], r9);
xor_(r30, ptr [r20], r9);

// andn_etc
andn(r29, r30, r31);
andn(eax, ecx, r17d);
andn(r29, r30, ptr [r31+r20*4]);
mulx(eax, ecx, r17d);
mulx(r29, r30, r31);
mulx(r29, r30, ptr [r31+r20*4]);
pdep(eax, ecx, r17d);
pdep(r29, r30, r31);
pdep(r29, r30, ptr [r31+r20*4]);
pext(eax, ecx, r17d);
pext(r29, r30, r31);
pext(r29, r30, ptr [r31+r20*4]);

// bextr_etc
bextr(r29, r30, r31);
bextr(eax, ecx, r17d);
bextr(r29, ptr [r31+r20*4], r30);
bzhi(r29, r30, r31);
bzhi(eax, ecx, r17d);
bzhi(r29, ptr [r31+r20*4], r30);
sarx(r29, r30, r31);
sarx(eax, ecx, r17d);
sarx(r29, ptr [r31+r20*4], r30);
shlx(r29, r30, r31);
shlx(eax, ecx, r17d);
shlx(r29, ptr [r31+r20*4], r30);
shrx(r29, r30, r31);
shrx(eax, ecx, r17d);
shrx(r29, ptr [r31+r20*4], r30);
blsi(r30, r31);
blsi(ecx, r17d);
blsi(r30, ptr [r31+r20*4]);
blsmsk(r30, r31);
blsmsk(ecx, r17d);
blsmsk(r30, ptr [r31+r20*4]);
blsr(r30, r31);
blsr(ecx, r17d);
blsr(r30, ptr [r31+r20*4]);
rorx(r30, r31, 3);
rorx(ecx, r17d, 5);
rorx(r30, ptr [r31+r20*4], 4);

// bit
adc(r20b, r21b, r22b);
adc(r20w, r21w, r22w);
adc(r20d, r21d, r22d);
adc(r20, r21, r22);
adc(r20b, r21b);
adc(r20w, r21w);
adc(r20d, r21d);
adc(r20, r21);
adc(r20b, r21b, 0x3);
adc(r20w, r21w, 0x3);
adc(r20d, r21d, 0x3);
adc(r20, r21, 0x3);
adc(r20b, 0x3);
adc(r20w, 0x3);
adc(r20d, 0x3);
adc(r20, 0x3);
add(r20b, r21b, r22b);
add(r20w, r21w, r22w);
add(r20d, r21d, r22d);
add(r20, r21, r22);
add(r20b, r21b);
add(r20w, r21w);
add(r20d, r21d);
add(r20, r21);
add(r20b, r21b, 0x3);
add(r20w, r21w, 0x3);
add(r20d, r21d, 0x3);
add(r20, r21, 0x3);
add(r20b, 0x3);
add(r20w, 0x3);
add(r20d, 0x3);
add(r20, 0x3);

// inc_dec
inc(r30b);
inc(r30w);
inc(r30d);
inc(r30);
inc(r30b, r31b);
inc(r30w, r31w);
inc(r30d, r31d);
inc(r30, r31);
inc(r30, ptr [r31]);
dec(r30b);
dec(r30w);
dec(r30d);
dec(r30);
dec(r30b, r31b);
dec(r30w, r31w);
dec(r30d, r31d);
dec(r30, r31);
dec(r30, ptr [r31]);

// div_op1
div(r20b);
div(r20d);
div(r20w);
div(r20);
div(byte [r20+r30*1]);
div(word [r20+r30*1]);
div(dword [r20+r30*1]);
div(qword [r20+r30*1]);
idiv(r20b);
idiv(r20d);
idiv(r20w);
idiv(r20);
idiv(byte [r20+r30*1]);
idiv(word [r20+r30*1]);
idiv(dword [r20+r30*1]);
idiv(qword [r20+r30*1]);
imul(r20b);
imul(r20d);
imul(r20w);
imul(r20);
imul(byte [r20+r30*1]);
imul(word [r20+r30*1]);
imul(dword [r20+r30*1]);
imul(qword [r20+r30*1]);
mul(r20b);
mul(r20d);
mul(r20w);
mul(r20);
mul(byte [r20+r30*1]);
mul(word [r20+r30*1]);
mul(dword [r20+r30*1]);
mul(qword [r20+r30*1]);
neg(r20b);
neg(r20d);
neg(r20w);
neg(r20);
neg(byte [r20+r30*1]);
neg(word [r20+r30*1]);
neg(dword [r20+r30*1]);
neg(qword [r20+r30*1]);
not_(r20b);
not_(r20d);
not_(r20w);
not_(r20);
not_(byte [r20+r30*1]);
not_(word [r20+r30*1]);
not_(dword [r20+r30*1]);
not_(qword [r20+r30*1]);

// imul_2op
imul(r30w, ax);
imul(r30d, eax);
imul(r30, rax);
imul(rcx, ptr [r30]);
neg(r30b, al);
neg(r30w, ax);
neg(r30d, eax);
neg(r30, rax);
neg(rcx, ptr [r30]);
not_(r30b, al);
not_(r30w, ax);
not_(r30d, eax);
not_(r30, rax);
not_(rcx, ptr [r30]);

// imul_zu
imul(r30w, ax, 0x1234);
imul(r30d, eax, 0x12345678);
imul(r30, rax, 0x12345678);
imul(rcx, ptr [r30], 0x12345678);

// lzcnt
lzcnt(r16w, r17w);
lzcnt(r16d, r17d);
lzcnt(r16, r17);
lzcnt(rax, ptr [r18]);
tzcnt(r16w, r17w);
tzcnt(r16d, r17d);
tzcnt(r16, r17);
tzcnt(rax, ptr [r18]);
popcnt(r16w, r17w);
popcnt(r16d, r17d);
popcnt(r16, r17);
popcnt(rax, ptr [r18]);

// shld
shld(r16, rcx, cl);
shld(r16, rcx, 0x9);
shld(r20, r16, rcx, cl);
shld(r20, r16, rcx, 0x9);
shld(r20, ptr [r21], rcx, 0x9);
shrd(r16, rcx, cl);
shrd(r16, rcx, 0x9);
shrd(r20, r16, rcx, cl);
shrd(r20, r16, rcx, 0x9);
shrd(r20, ptr [r21], rcx, 0x9);

// base
lea(r30, ptr[r20+r21]);
add(r30, r20);
add(r30, ptr[r20]);
cmp(r30, ptr[r20]);

// mov_misc
movdir64b(r16, ptr [r20+r21*8+0x4]);
movdiri(ptr [r20+r21*8+0x4], r16);
movbe(ptr [r16], r30w);
movbe(ptr [r16], r30d);
movbe(ptr [r16], r30);
movbe(r30w, ptr [r16]);
movbe(r30d, ptr [r16]);
movbe(r30, ptr [r16]);
crc32(r30d, r8b);
crc32(r30d, r8w);
crc32(r30d, r8d);
crc32(r30, r8b);
crc32(r30, r8);
jmpabs(0x12345678aabbccdd);
cmpbexadd(ptr [r20+r30*8], r21, r22);
cmpbexadd(ptr [r20+r30*8], r21d, r22d);
cmovb(r8, r9, r10);
cmovb(r8d, r9d, r10d);
setb(r31b);
setb(ptr [r30]);
bswap(eax);
bswap(r8d);
bswap(r16d);
bswap(rcx);
bswap(r9);
bswap(r17);

// shift_2op
shl(r16b, cl);
shl(r16w, cl);
shl(r16d, cl);
shl(r16, cl);
shl(r16b, 0x3);
shl(r16w, 0x5);
shl(r16d, 0x7);
shl(r16, 0x9);
shl(byte [r30], 0x3);
shl(word [r30], 0x5);
shl(dword [r30], 0x7);
shl(qword [r30], 0x9);
shr(r16b, cl);
shr(r16w, cl);
shr(r16d, cl);
shr(r16, cl);
shr(r16b, 0x3);
shr(r16w, 0x5);
shr(r16d, 0x7);
shr(r16, 0x9);
shr(byte [r30], 0x3);
shr(word [r30], 0x5);
shr(dword [r30], 0x7);
shr(qword [r30], 0x9);
sar(r16b, cl);
sar(r16w, cl);
sar(r16d, cl);
sar(r16, cl);
sar(r16b, 0x3);
sar(r16w, 0x5);
sar(r16d, 0x7);
sar(r16, 0x9);
sar(byte [r30], 0x3);
sar(word [r30], 0x5);
sar(dword [r30], 0x7);
sar(qword [r30], 0x9);
ror(r16b, cl);
ror(r16w, cl);
ror(r16d, cl);
ror(r16, cl);
ror(r16b, 0x3);
ror(r16w, 0x5);
ror(r16d, 0x7);
ror(r16, 0x9);
ror(byte [r30], 0x3);
ror(word [r30], 0x5);
ror(dword [r30], 0x7);
ror(qword [r30], 0x9);
rol(r16b, cl);
rol(r16w, cl);
rol(r16d, cl);
rol(r16, cl);
rol(r16b, 0x3);
rol(r16w, 0x5);
rol(r16d, 0x7);
rol(r16, 0x9);
rol(byte [r30], 0x3);
rol(word [r30], 0x5);
rol(dword [r30], 0x7);
rol(qword [r30], 0x9);
rcl(r16b, cl);
rcl(r16w, cl);
rcl(r16d, cl);
rcl(r16, cl);
rcl(r16b, 0x3);
rcl(r16w, 0x5);
rcl(r16d, 0x7);
rcl(r16, 0x9);
rcl(byte [r30], 0x3);
rcl(word [r30], 0x5);
rcl(dword [r30], 0x7);
rcl(qword [r30], 0x9);
rcr(r16b, cl);
rcr(r16w, cl);
rcr(r16d, cl);
rcr(r16, cl);
rcr(r16b, 0x3);
rcr(r16w, 0x5);
rcr(r16d, 0x7);
rcr(r16, 0x9);
rcr(byte [r30], 0x3);
rcr(word [r30], 0x5);
rcr(dword [r30], 0x7);
rcr(qword [r30], 0x9);

// shift_3op
rcl(r20b, r16b, cl);
rcl(r20w, r16w, cl);
rcl(r20d, r16d, cl);
rcl(r20, r16, cl);
rcl(r20b, ptr [r16], cl);
rcl(r20w, ptr [r16], cl);
rcl(r20d, ptr [r16], cl);
rcl(r20, ptr [r16], cl);
rcl(r20b, r16b, 0x2);
rcl(r20w, r16w, 0x4);
rcl(r20d, r16d, 0x6);
rcl(r20, r16, 0x8);
rcl(r20b, ptr [r16], 0x2);
rcl(r20w, ptr [r16], 0x4);
rcl(r20d, ptr [r16], 0x6);
rcl(r20, ptr [r16], 0x8);
rcr(r20b, r16b, cl);
rcr(r20w, r16w, cl);
rcr(r20d, r16d, cl);
rcr(r20, r16, cl);
rcr(r20b, ptr [r16], cl);
rcr(r20w, ptr [r16], cl);
rcr(r20d, ptr [r16], cl);
rcr(r20, ptr [r16], cl);
rcr(r20b, r16b, 0x2);
rcr(r20w, r16w, 0x4);
rcr(r20d, r16d, 0x6);
rcr(r20, r16, 0x8);
rcr(r20b, ptr [r16], 0x2);
rcr(r20w, ptr [r16], 0x4);
rcr(r20d, ptr [r16], 0x6);
rcr(r20, ptr [r16], 0x8);
rol(r20b, r16b, cl);
rol(r20w, r16w, cl);
rol(r20d, r16d, cl);
rol(r20, r16, cl);
rol(r20b, ptr [r16], cl);
rol(r20w, ptr [r16], cl);
rol(r20d, ptr [r16], cl);
rol(r20, ptr [r16], cl);
rol(r20b, r16b, 0x2);
rol(r20w, r16w, 0x4);
rol(r20d, r16d, 0x6);
rol(r20, r16, 0x8);
rol(r20b, ptr [r16], 0x2);
rol(r20w, ptr [r16], 0x4);
rol(r20d, ptr [r16], 0x6);
rol(r20, ptr [r16], 0x8);
shl(r20b, r16b, cl);
shl(r20w, r16w, cl);
shl(r20d, r16d, cl);
shl(r20, r16, cl);
shl(r20b, ptr [r16], cl);
shl(r20w, ptr [r16], cl);
shl(r20d, ptr [r16], cl);
shl(r20, ptr [r16], cl);
shl(r20b, r16b, 0x2);
shl(r20w, r16w, 0x4);
shl(r20d, r16d, 0x6);
shl(r20, r16, 0x8);
shl(r20b, ptr [r16], 0x2);
shl(r20w, ptr [r16], 0x4);
shl(r20d, ptr [r16], 0x6);
shl(r20, ptr [r16], 0x8);
shr(r20b, r16b, cl);
shr(r20w, r16w, cl);
shr(r20d, r16d, cl);
shr(r20, r16, cl);
shr(r20b, ptr [r16], cl);
shr(r20w, ptr [r16], cl);
shr(r20d, ptr [r16], cl);
shr(r20, ptr [r16], cl);
shr(r20b, r16b, 0x2);
shr(r20w, r16w, 0x4);
shr(r20d, r16d, 0x6);
shr(r20, r16, 0x8);
shr(r20b, ptr [r16], 0x2);
shr(r20w, ptr [r16], 0x4);
shr(r20d, ptr [r16], 0x6);
shr(r20, ptr [r16], 0x8);
sar(r20b, r16b, cl);
sar(r20w, r16w, cl);
sar(r20d, r16d, cl);
sar(r20, r16, cl);
sar(r20b, ptr [r16], cl);
sar(r20w, ptr [r16], cl);
sar(r20d, ptr [r16], cl);
sar(r20, ptr [r16], cl);
sar(r20b, r16b, 0x2);
sar(r20w, r16w, 0x4);
sar(r20d, r16d, 0x6);
sar(r20, r16, 0x8);
sar(r20b, ptr [r16], 0x2);
sar(r20w, ptr [r16], 0x4);
sar(r20d, ptr [r16], 0x6);
sar(r20, ptr [r16], 0x8);

// push2_pop2
push2(r20, r30);
push2(rax, rcx);
push2p(r20, r30);
push2p(rdx, r8);
pop2(rax, rcx);
pop2(r20, r30);
pop2p(rax, rcx);
pop2p(r20, r30);

// cfcmov
cfcmovb(r30w, r31w);
cfcmovb(r30d, r31d);
cfcmovb(r30, r31);
cfcmovb(ptr [r8+r20*4+0x3], r19w);
cfcmovb(ptr [r8+r20*4+0x3], r19d);
cfcmovb(ptr [r8+r20*4+0x3], r19);
cfcmovb(r30w, ptr [r9]);
cfcmovb(r30d, ptr [r9]);
cfcmovb(r30, ptr [r9]);
cfcmovb(r20w, r30w, r31w);
cfcmovb(r20d, r30d, r31d);
cfcmovb(r20, r30, r31);
cfcmovb(r20w, r30w, ptr [r9]);
cfcmovb(r20d, r30d, ptr [r9]);
cfcmovb(r20, r30, ptr [r9]);
cfcmovo(r20, r21, r22);
cfcmovo(r20, r21, ptr [r22]);
cfcmovno(r20, r21, r22);
cfcmovno(r20, r21, ptr [r22]);
cfcmovb(r20, r21, r22);
cfcmovb(r20, r21, ptr [r22]);
cfcmovnb(r20, r21, r22);
cfcmovnb(r20, r21, ptr [r22]);
cfcmovz(r20, r21, r22);
cfcmovz(r20, r21, ptr [r22]);
cfcmovnz(r20, r21, r22);
cfcmovnz(r20, r21, ptr [r22]);
cfcmovbe(r20, r21, r22);
cfcmovbe(r20, r21, ptr [r22]);
cfcmovnbe(r20, r21, r22);
cfcmovnbe(r20, r21, ptr [r22]);
cfcmovs(r20, r21, r22);
cfcmovs(r20, r21, ptr [r22]);
cfcmovns(r20, r21, r22);
cfcmovns(r20, r21, ptr [r22]);
cfcmovp(r20, r21, r22);
cfcmovp(r20, r21, ptr [r22]);
cfcmovnp(r20, r21, r22);
cfcmovnp(r20, r21, ptr [r22]);
cfcmovl(r20, r21, r22);
cfcmovl(r20, r21, ptr [r22]);
cfcmovnl(r20, r21, r22);
cfcmovnl(r20, r21, ptr [r22]);
cfcmovle(r20, r21, r22);
cfcmovle(r20, r21, ptr [r22]);
cfcmovnle(r20, r21, r22);
cfcmovnle(r20, r21, ptr [r22]);

// evex_misc
vmovaps(xmm31, ptr [r30+r26*8+0x40]);
vaddps(zmm30, zmm21, ptr [r20+r30*1]);
vcvtsd2si(r30d, ptr [r17+r31*4]);
vcvtsd2si(eax, ptr [r16+128]);
vcvtsd2si(rax, ptr [r16+128]);
vcvtss2si(eax, ptr [r16+128]);
vcvtss2si(rax, ptr [r16+128]);
vcvttsd2si(eax, ptr [r16+128]);
vcvttsd2si(rax, ptr [r16+128]);
vcvttss2si(eax, ptr [r16+128]);
vcvttss2si(rax, ptr [r16+128]);
test(ptr[r30], r31);
test(byte[r30], 0x12);
call(r20);
call(ptr[r20]);

// kmov
kmovb(k1, ptr [r20]);
kmovb(k2, r21d);
kmovb(ptr [r22], k3);
kmovb(r23d, k4);
kmovw(k1, ptr [r20]);
kmovw(k2, r21d);
kmovw(ptr [r22], k3);
kmovw(r23d, k4);
kmovd(k1, ptr [r20]);
kmovd(k2, r21d);
kmovd(ptr [r22], k3);
kmovd(r23d, k4);
kmovq(k1, ptr [r20]);
kmovq(k2, r21);
kmovq(ptr [r22], k3);
kmovq(r23, k4);

// amx
ldtilecfg(ptr [r30+r29*4+0x12]);
sttilecfg(ptr [r30+r29*4+0x12]);
tileloadd(tmm1, ptr [r30+r29*4+0x12]);
tileloaddt1(tmm3, ptr [r30+r29*4+0x12]);
tilestored(ptr [r30+r29*4+0x12], tmm5);

// aeskl
aesdec128kl(xmm15, ptr[rax+rcx*4+0x12]);
aesdec256kl(xmm15, ptr[rax+rcx*4+0x12]);
aesdecwide128kl(ptr[rax+rcx*4+0x12]);
aesdecwide256kl(ptr[rax+rcx*4+0x12]);
aesenc128kl(xmm15, ptr[rax+rcx*4+0x12]);
aesenc256kl(xmm15, ptr[rax+rcx*4+0x12]);
aesencwide128kl(ptr[rax+rcx*4+0x12]);
aesencwide256kl(ptr[rax+rcx*4+0x12]);

// encodekey
encodekey128(eax, ebx);
encodekey128(eax, r8d);
encodekey128(r8d, ebx);
encodekey256(eax, ebx);
encodekey256(eax, r8d);
encodekey256(r8d, ebx);

// sha
sha1msg1(xmm15, ptr [rax+rcx*4+0x12]);
sha1msg2(xmm15, ptr [rax+rcx*4+0x12]);
sha1nexte(xmm15, ptr [rax+rcx*4+0x12]);
sha256msg1(xmm15, ptr [rax+rcx*4+0x12]);
sha256msg2(xmm15, ptr [rax+rcx*4+0x12]);
sha256rnds2(xmm15, ptr [rax+rcx*4+0x12]);
sha1rnds4(xmm15, ptr [rax+rcx*4+0x12], 0x23);

// 0x0f_rex2
addps(xmm3, ptr [r30+r20*4+0x4]);
movups(xmm5, ptr [r16]);
movq(r31, xmm5);
cvtsd2si(r20, ptr [r30]);
bsr(r20, r30);

// rao_int
aadd(ptr [r16+r31*1], r17d);
aadd(ptr [r16+r31*1], r17);
aand(ptr [r16+r31*1], r17d);
aand(ptr [r16+r31*1], r17);
aor(ptr [r16+r31*1], r17d);
aor(ptr [r16+r31*1], r17);
axor(ptr [r16+r31*1], r17d);
axor(ptr [r16+r31*1], r17);

// ---- T_nf/T_zu tests moved from test/apx.cpp ----
// NF
add(rax, rcx, rdx);
add(rax|T_nf, rcx, rdx);
and_(rax, rcx, rdx);
and_(rax|T_nf, rcx, rdx);
or_(rax, rcx, rdx);
or_(rax|T_nf, rcx, rdx);
sub(rax, rcx, rdx);
sub(rax|T_nf, rcx, rdx);
xor_(rax, rcx, rdx);
xor_(rax|T_nf, rcx, rdx);
add(rax, rcx, 3);
add(rax|T_nf, rcx, 3);
and_(rax, rcx, 3);
and_(rax|T_nf, rcx, 3);
or_(rax, rcx, 3);
or_(rax|T_nf, rcx, 3);
sub(rax, rcx, 3);
sub(rax|T_nf, rcx, 3);
xor_(rax, rcx, 3);
xor_(rax|T_nf, rcx, 3);

// andn_etc
andn(r29|T_nf, r30, r31);

// bextr_etc
bextr(r29|T_nf, r30, r31);
bzhi(r29|T_nf, r30, r31);
blsi(r30|T_nf, r31);
blsmsk(r30|T_nf, r31);
blsr(r30|T_nf, r31);

// inc_dec
inc(r30w|T_nf, r31w);
dec(r30w|T_nf, r31w);

// div_op1
div(r20|T_nf);
div(eax|T_nf);
idiv(r20|T_nf);
idiv(eax|T_nf);
imul(r20|T_nf);
imul(eax|T_nf);
mul(r20|T_nf);
mul(eax|T_nf);
neg(r20|T_nf);
neg(eax|T_nf);

// imul_2op
imul(r30|T_nf, rax);
imul(rcx|T_nf, rax);
neg(r30|T_nf, rax);
neg(rcx|T_nf, rax);

// imul_zu
imul(ax|T_zu, cx, 0x1234);
imul(ax|T_nf, cx, 0x1234);
imul(ax|T_zu|T_nf, cx, 0x1234);
imul(r30|T_zu, rax, 0x12345678);
imul(r30|T_nf, rax, 0x12345678);
imul(r30|T_nf|T_zu, rax, 0x12345678);

// lzcnt
lzcnt(r16|T_nf, r17);
lzcnt(rax|T_nf, rcx);
tzcnt(r16|T_nf, r17);
tzcnt(rax|T_nf, rcx);
popcnt(r16|T_nf, r17);
popcnt(rax|T_nf, rcx);

// shld
shld(rax|T_nf, rcx, cl);
shld(r16|T_nf, rcx, 0x9);
shld(r20|T_nf, r16, rcx, cl);
shld(r20|T_nf, r16, rcx, 0x9);
shrd(rax|T_nf, rcx, cl);
shrd(r16|T_nf, rcx, 0x9);
shrd(r20|T_nf, r16, rcx, cl);
shrd(r20|T_nf, r16, rcx, 0x9);

// mov_misc
setb(r31b|T_zu);
setb(r15b|T_zu);

// shift_2op
shl(r16|T_nf, cl);
shr(r16|T_nf, cl);
sar(r16|T_nf, cl);
ror(r16|T_nf, cl);
rol(r16|T_nf, cl);

// ---- ccmp/ctest (dfv) tests moved from test/apx.cpp ----
// ccmp
ccmpb(rax, rbx, 0);
ccmpb(r30b, r31b, 1);
ccmpb(r30w, r31w, 2);
ccmpb(r30d, r31d, 3);
ccmpb(r30, r31, 4);
ccmpb(ptr [r30], r31b, 5);
ccmpb(ptr [r30], r31w, 6);
ccmpb(ptr [r30], r31d, 7);
ccmpb(ptr [r30], r31, 8);
ccmpb(r31b, ptr [r30], 9);
ccmpb(r31w, ptr [r30], 10);
ccmpb(r31d, ptr [r30], 11);
ccmpb(r31, ptr [r30], 12);
ccmpb(r20b, 0x12, 9);
ccmpb(r20w, 0x1234, 9);
ccmpb(r20d, 0x12345678, 9);
ccmpb(r20, 0x12345678, 9);
ccmpb(byte [r20], 0x12, 9);
ccmpb(word [r20], 0x1234, 9);
ccmpb(dword [r20], 0x12345678, 9);
ccmpb(qword [r20], 0x12345678, 9);
ccmpo(rax, rcx, 0);
ccmpno(rax, rcx, 1);
ccmpb(rax, rcx, 2);
ccmpnb(rax, rcx, 3);
ccmpz(rax, rcx, 4);
ccmpnz(rax, rcx, 5);
ccmpbe(rax, rcx, 6);
ccmpnbe(rax, rcx, 7);
ccmps(rax, rcx, 8);
ccmpns(rax, rcx, 9);
ccmpt(rax, rcx, 10);
ccmpf(rax, rcx, 11);
ccmpl(rax, rcx, 12);
ccmpnl(rax, rcx, 13);
ccmple(rax, rcx, 14);
ccmpnle(rax, rcx, 15);

// ctestb
ctestb(r30b, r31b, 0);
ctestb(r30w, r31w, 1);
ctestb(r30d, r31d, 2);
ctestb(r30, r31, 3);
ctestb(ptr [r30], r31b, 4);
ctestb(ptr [r30], r31w, 5);
ctestb(ptr [r30], r31d, 6);
ctestb(ptr [r30], r31, 7);
ctestb(r30b, 0x12, 8);
ctestb(r30w, 0x1234, 9);
ctestb(r30d, 0x12345678, 10);
ctestb(r30, 0x12345678, 11);
ctestb(byte [r30], 0x12, 12);
ctestb(word [r30], 0x1234, 13);
ctestb(dword [r30], 0x12345678, 14);
ctestb(qword [r30], 0x12345678, 15);
ctesto(rax, rcx, 0);
ctestno(rax, rcx, 1);
ctestb(rax, rcx, 2);
ctestnb(rax, rcx, 3);
ctestz(rax, rcx, 4);
ctestnz(rax, rcx, 5);
ctestbe(rax, rcx, 6);
ctestnbe(rax, rcx, 7);
ctests(rax, rcx, 8);
ctestns(rax, rcx, 9);
ctestt(rax, rcx, 10);
ctestf(rax, rcx, 11);
ctestl(rax, rcx, 12);
ctestnl(rax, rcx, 13);
ctestle(rax, rcx, 14);
ctestnle(rax, rcx, 15);

// dfv omitted (dfv=0)
ccmpb(rax, rbx);
ccmpz(r20w, 0x1234);
ctestnle(qword [r30], 0x12345678);
