# RUN: llvm-mc -triple x86_64 -disassemble %s | FileCheck %s --check-prefix=ATT
# RUN: llvm-mc -triple x86_64 -disassemble -output-asm-variant=1 %s | FileCheck %s --check-prefix=INTEL

# ATT:   ctestbb {dfv=of} $123, 123(%r8,%rax,4)
# INTEL: ctestb {dfv=of} byte ptr [r8 + 4*rax + 123], 123
0x62,0xd4,0x44,0x02,0xf6,0x44,0x80,0x7b,0x7b

# ATT:   ctestbw {dfv=of} $1234, 123(%r8,%rax,4)
# INTEL: ctestb {dfv=of} word ptr [r8 + 4*rax + 123], 1234
0x62,0xd4,0x45,0x02,0xf7,0x44,0x80,0x7b,0xd2,0x04

# ATT:   ctestbl {dfv=of} $123456, 123(%r8,%rax,4)
# INTEL: ctestb {dfv=of} dword ptr [r8 + 4*rax + 123], 123456
0x62,0xd4,0x44,0x02,0xf7,0x44,0x80,0x7b,0x40,0xe2,0x01,0x00

# ATT:   ctestbq {dfv=of} $123456, 123(%r8,%rax,4)
# INTEL: ctestb {dfv=of} qword ptr [r8 + 4*rax + 123], 123456
0x62,0xd4,0xc4,0x02,0xf7,0x44,0x80,0x7b,0x40,0xe2,0x01,0x00

# ATT:   ctestbb {dfv=of} %bl, 123(%r8,%rax,4)
# INTEL: ctestb {dfv=of} byte ptr [r8 + 4*rax + 123], bl
0x62,0xd4,0x44,0x02,0x84,0x5c,0x80,0x7b

# ATT:   ctestbw {dfv=of} %dx, 123(%r8,%rax,4)
# INTEL: ctestb {dfv=of} word ptr [r8 + 4*rax + 123], dx
0x62,0xd4,0x45,0x02,0x85,0x54,0x80,0x7b

# ATT:   ctestbl {dfv=of} %ecx, 123(%r8,%rax,4)
# INTEL: ctestb {dfv=of} dword ptr [r8 + 4*rax + 123], ecx
0x62,0xd4,0x44,0x02,0x85,0x4c,0x80,0x7b

# ATT:   ctestbq {dfv=of} %r9, 123(%r8,%rax,4)
# INTEL: ctestb {dfv=of} qword ptr [r8 + 4*rax + 123], r9
0x62,0x54,0xc4,0x02,0x85,0x4c,0x80,0x7b

# ATT:   ctestbb {dfv=of} $123, %bl
# INTEL: ctestb {dfv=of} bl, 123
0x62,0xf4,0x44,0x02,0xf6,0xc3,0x7b

# ATT:   ctestbw {dfv=of} $1234, %dx
# INTEL: ctestb {dfv=of} dx, 1234
0x62,0xf4,0x45,0x02,0xf7,0xc2,0xd2,0x04

# ATT:   ctestbl {dfv=of} $123456, %ecx
# INTEL: ctestb {dfv=of} ecx, 123456
0x62,0xf4,0x44,0x02,0xf7,0xc1,0x40,0xe2,0x01,0x00

# ATT:   ctestbq {dfv=of} $123456, %r9
# INTEL: ctestb {dfv=of} r9, 123456
0x62,0xd4,0xc4,0x02,0xf7,0xc1,0x40,0xe2,0x01,0x00

# ATT:   ctestbb {dfv=of} %bl, %dl
# INTEL: ctestb {dfv=of} dl, bl
0x62,0xf4,0x44,0x02,0x84,0xda

# ATT:   ctestbw {dfv=of} %dx, %ax
# INTEL: ctestb {dfv=of} ax, dx
0x62,0xf4,0x45,0x02,0x85,0xd0

# ATT:   ctestbl {dfv=of} %ecx, %edx
# INTEL: ctestb {dfv=of} edx, ecx
0x62,0xf4,0x44,0x02,0x85,0xca

# ATT:   ctestbq {dfv=of} %r9, %r15
# INTEL: ctestb {dfv=of} r15, r9
0x62,0x54,0xc4,0x02,0x85,0xcf

# ATT:   ctestbeb {dfv=of} $123, 123(%r8,%rax,4)
# INTEL: ctestbe {dfv=of} byte ptr [r8 + 4*rax + 123], 123
0x62,0xd4,0x44,0x06,0xf6,0x44,0x80,0x7b,0x7b

# ATT:   ctestbew {dfv=of} $1234, 123(%r8,%rax,4)
# INTEL: ctestbe {dfv=of} word ptr [r8 + 4*rax + 123], 1234
0x62,0xd4,0x45,0x06,0xf7,0x44,0x80,0x7b,0xd2,0x04

# ATT:   ctestbel {dfv=of} $123456, 123(%r8,%rax,4)
# INTEL: ctestbe {dfv=of} dword ptr [r8 + 4*rax + 123], 123456
0x62,0xd4,0x44,0x06,0xf7,0x44,0x80,0x7b,0x40,0xe2,0x01,0x00

# ATT:   ctestbeq {dfv=of} $123456, 123(%r8,%rax,4)
# INTEL: ctestbe {dfv=of} qword ptr [r8 + 4*rax + 123], 123456
0x62,0xd4,0xc4,0x06,0xf7,0x44,0x80,0x7b,0x40,0xe2,0x01,0x00

# ATT:   ctestbeb {dfv=of} %bl, 123(%r8,%rax,4)
# INTEL: ctestbe {dfv=of} byte ptr [r8 + 4*rax + 123], bl
0x62,0xd4,0x44,0x06,0x84,0x5c,0x80,0x7b

# ATT:   ctestbew {dfv=of} %dx, 123(%r8,%rax,4)
# INTEL: ctestbe {dfv=of} word ptr [r8 + 4*rax + 123], dx
0x62,0xd4,0x45,0x06,0x85,0x54,0x80,0x7b

# ATT:   ctestbel {dfv=of} %ecx, 123(%r8,%rax,4)
# INTEL: ctestbe {dfv=of} dword ptr [r8 + 4*rax + 123], ecx
0x62,0xd4,0x44,0x06,0x85,0x4c,0x80,0x7b

# ATT:   ctestbeq {dfv=of} %r9, 123(%r8,%rax,4)
# INTEL: ctestbe {dfv=of} qword ptr [r8 + 4*rax + 123], r9
0x62,0x54,0xc4,0x06,0x85,0x4c,0x80,0x7b

# ATT:   ctestbeb {dfv=of} $123, %bl
# INTEL: ctestbe {dfv=of} bl, 123
0x62,0xf4,0x44,0x06,0xf6,0xc3,0x7b

# ATT:   ctestbew {dfv=of} $1234, %dx
# INTEL: ctestbe {dfv=of} dx, 1234
0x62,0xf4,0x45,0x06,0xf7,0xc2,0xd2,0x04

# ATT:   ctestbel {dfv=of} $123456, %ecx
# INTEL: ctestbe {dfv=of} ecx, 123456
0x62,0xf4,0x44,0x06,0xf7,0xc1,0x40,0xe2,0x01,0x00

# ATT:   ctestbeq {dfv=of} $123456, %r9
# INTEL: ctestbe {dfv=of} r9, 123456
0x62,0xd4,0xc4,0x06,0xf7,0xc1,0x40,0xe2,0x01,0x00

# ATT:   ctestbeb {dfv=of} %bl, %dl
# INTEL: ctestbe {dfv=of} dl, bl
0x62,0xf4,0x44,0x06,0x84,0xda

# ATT:   ctestbew {dfv=of} %dx, %ax
# INTEL: ctestbe {dfv=of} ax, dx
0x62,0xf4,0x45,0x06,0x85,0xd0

# ATT:   ctestbel {dfv=of} %ecx, %edx
# INTEL: ctestbe {dfv=of} edx, ecx
0x62,0xf4,0x44,0x06,0x85,0xca

# ATT:   ctestbeq {dfv=of} %r9, %r15
# INTEL: ctestbe {dfv=of} r15, r9
0x62,0x54,0xc4,0x06,0x85,0xcf

# ATT:   ctestfb {dfv=of} $123, 123(%r8,%rax,4)
# INTEL: ctestf {dfv=of} byte ptr [r8 + 4*rax + 123], 123
0x62,0xd4,0x44,0x0b,0xf6,0x44,0x80,0x7b,0x7b

# ATT:   ctestfw {dfv=of} $1234, 123(%r8,%rax,4)
# INTEL: ctestf {dfv=of} word ptr [r8 + 4*rax + 123], 1234
0x62,0xd4,0x45,0x0b,0xf7,0x44,0x80,0x7b,0xd2,0x04

# ATT:   ctestfl {dfv=of} $123456, 123(%r8,%rax,4)
# INTEL: ctestf {dfv=of} dword ptr [r8 + 4*rax + 123], 123456
0x62,0xd4,0x44,0x0b,0xf7,0x44,0x80,0x7b,0x40,0xe2,0x01,0x00

# ATT:   ctestfq {dfv=of} $123456, 123(%r8,%rax,4)
# INTEL: ctestf {dfv=of} qword ptr [r8 + 4*rax + 123], 123456
0x62,0xd4,0xc4,0x0b,0xf7,0x44,0x80,0x7b,0x40,0xe2,0x01,0x00

# ATT:   ctestfb {dfv=of} %bl, 123(%r8,%rax,4)
# INTEL: ctestf {dfv=of} byte ptr [r8 + 4*rax + 123], bl
0x62,0xd4,0x44,0x0b,0x84,0x5c,0x80,0x7b

# ATT:   ctestfw {dfv=of} %dx, 123(%r8,%rax,4)
# INTEL: ctestf {dfv=of} word ptr [r8 + 4*rax + 123], dx
0x62,0xd4,0x45,0x0b,0x85,0x54,0x80,0x7b

# ATT:   ctestfl {dfv=of} %ecx, 123(%r8,%rax,4)
# INTEL: ctestf {dfv=of} dword ptr [r8 + 4*rax + 123], ecx
0x62,0xd4,0x44,0x0b,0x85,0x4c,0x80,0x7b

# ATT:   ctestfq {dfv=of} %r9, 123(%r8,%rax,4)
# INTEL: ctestf {dfv=of} qword ptr [r8 + 4*rax + 123], r9
0x62,0x54,0xc4,0x0b,0x85,0x4c,0x80,0x7b

# ATT:   ctestfb {dfv=of} $123, %bl
# INTEL: ctestf {dfv=of} bl, 123
0x62,0xf4,0x44,0x0b,0xf6,0xc3,0x7b

# ATT:   ctestfw {dfv=of} $1234, %dx
# INTEL: ctestf {dfv=of} dx, 1234
0x62,0xf4,0x45,0x0b,0xf7,0xc2,0xd2,0x04

# ATT:   ctestfl {dfv=of} $123456, %ecx
# INTEL: ctestf {dfv=of} ecx, 123456
0x62,0xf4,0x44,0x0b,0xf7,0xc1,0x40,0xe2,0x01,0x00

# ATT:   ctestfq {dfv=of} $123456, %r9
# INTEL: ctestf {dfv=of} r9, 123456
0x62,0xd4,0xc4,0x0b,0xf7,0xc1,0x40,0xe2,0x01,0x00

# ATT:   ctestfb {dfv=of} %bl, %dl
# INTEL: ctestf {dfv=of} dl, bl
0x62,0xf4,0x44,0x0b,0x84,0xda

# ATT:   ctestfw {dfv=of} %dx, %ax
# INTEL: ctestf {dfv=of} ax, dx
0x62,0xf4,0x45,0x0b,0x85,0xd0

# ATT:   ctestfl {dfv=of} %ecx, %edx
# INTEL: ctestf {dfv=of} edx, ecx
0x62,0xf4,0x44,0x0b,0x85,0xca

# ATT:   ctestfq {dfv=of} %r9, %r15
# INTEL: ctestf {dfv=of} r15, r9
0x62,0x54,0xc4,0x0b,0x85,0xcf

# ATT:   ctestlb {dfv=of} $123, 123(%r8,%rax,4)
# INTEL: ctestl {dfv=of} byte ptr [r8 + 4*rax + 123], 123
0x62,0xd4,0x44,0x0c,0xf6,0x44,0x80,0x7b,0x7b

# ATT:   ctestlw {dfv=of} $1234, 123(%r8,%rax,4)
# INTEL: ctestl {dfv=of} word ptr [r8 + 4*rax + 123], 1234
0x62,0xd4,0x45,0x0c,0xf7,0x44,0x80,0x7b,0xd2,0x04

# ATT:   ctestll {dfv=of} $123456, 123(%r8,%rax,4)
# INTEL: ctestl {dfv=of} dword ptr [r8 + 4*rax + 123], 123456
0x62,0xd4,0x44,0x0c,0xf7,0x44,0x80,0x7b,0x40,0xe2,0x01,0x00

# ATT:   ctestlq {dfv=of} $123456, 123(%r8,%rax,4)
# INTEL: ctestl {dfv=of} qword ptr [r8 + 4*rax + 123], 123456
0x62,0xd4,0xc4,0x0c,0xf7,0x44,0x80,0x7b,0x40,0xe2,0x01,0x00

# ATT:   ctestlb {dfv=of} %bl, 123(%r8,%rax,4)
# INTEL: ctestl {dfv=of} byte ptr [r8 + 4*rax + 123], bl
0x62,0xd4,0x44,0x0c,0x84,0x5c,0x80,0x7b

# ATT:   ctestlw {dfv=of} %dx, 123(%r8,%rax,4)
# INTEL: ctestl {dfv=of} word ptr [r8 + 4*rax + 123], dx
0x62,0xd4,0x45,0x0c,0x85,0x54,0x80,0x7b

# ATT:   ctestll {dfv=of} %ecx, 123(%r8,%rax,4)
# INTEL: ctestl {dfv=of} dword ptr [r8 + 4*rax + 123], ecx
0x62,0xd4,0x44,0x0c,0x85,0x4c,0x80,0x7b

# ATT:   ctestlq {dfv=of} %r9, 123(%r8,%rax,4)
# INTEL: ctestl {dfv=of} qword ptr [r8 + 4*rax + 123], r9
0x62,0x54,0xc4,0x0c,0x85,0x4c,0x80,0x7b

# ATT:   ctestlb {dfv=of} $123, %bl
# INTEL: ctestl {dfv=of} bl, 123
0x62,0xf4,0x44,0x0c,0xf6,0xc3,0x7b

# ATT:   ctestlw {dfv=of} $1234, %dx
# INTEL: ctestl {dfv=of} dx, 1234
0x62,0xf4,0x45,0x0c,0xf7,0xc2,0xd2,0x04

# ATT:   ctestll {dfv=of} $123456, %ecx
# INTEL: ctestl {dfv=of} ecx, 123456
0x62,0xf4,0x44,0x0c,0xf7,0xc1,0x40,0xe2,0x01,0x00

# ATT:   ctestlq {dfv=of} $123456, %r9
# INTEL: ctestl {dfv=of} r9, 123456
0x62,0xd4,0xc4,0x0c,0xf7,0xc1,0x40,0xe2,0x01,0x00

# ATT:   ctestlb {dfv=of} %bl, %dl
# INTEL: ctestl {dfv=of} dl, bl
0x62,0xf4,0x44,0x0c,0x84,0xda

# ATT:   ctestlw {dfv=of} %dx, %ax
# INTEL: ctestl {dfv=of} ax, dx
0x62,0xf4,0x45,0x0c,0x85,0xd0

# ATT:   ctestll {dfv=of} %ecx, %edx
# INTEL: ctestl {dfv=of} edx, ecx
0x62,0xf4,0x44,0x0c,0x85,0xca

# ATT:   ctestlq {dfv=of} %r9, %r15
# INTEL: ctestl {dfv=of} r15, r9
0x62,0x54,0xc4,0x0c,0x85,0xcf

# ATT:   ctestleb {dfv=of} $123, 123(%r8,%rax,4)
# INTEL: ctestle {dfv=of} byte ptr [r8 + 4*rax + 123], 123
0x62,0xd4,0x44,0x0e,0xf6,0x44,0x80,0x7b,0x7b

# ATT:   ctestlew {dfv=of} $1234, 123(%r8,%rax,4)
# INTEL: ctestle {dfv=of} word ptr [r8 + 4*rax + 123], 1234
0x62,0xd4,0x45,0x0e,0xf7,0x44,0x80,0x7b,0xd2,0x04

# ATT:   ctestlel {dfv=of} $123456, 123(%r8,%rax,4)
# INTEL: ctestle {dfv=of} dword ptr [r8 + 4*rax + 123], 123456
0x62,0xd4,0x44,0x0e,0xf7,0x44,0x80,0x7b,0x40,0xe2,0x01,0x00

# ATT:   ctestleq {dfv=of} $123456, 123(%r8,%rax,4)
# INTEL: ctestle {dfv=of} qword ptr [r8 + 4*rax + 123], 123456
0x62,0xd4,0xc4,0x0e,0xf7,0x44,0x80,0x7b,0x40,0xe2,0x01,0x00

# ATT:   ctestleb {dfv=of} %bl, 123(%r8,%rax,4)
# INTEL: ctestle {dfv=of} byte ptr [r8 + 4*rax + 123], bl
0x62,0xd4,0x44,0x0e,0x84,0x5c,0x80,0x7b

# ATT:   ctestlew {dfv=of} %dx, 123(%r8,%rax,4)
# INTEL: ctestle {dfv=of} word ptr [r8 + 4*rax + 123], dx
0x62,0xd4,0x45,0x0e,0x85,0x54,0x80,0x7b

# ATT:   ctestlel {dfv=of} %ecx, 123(%r8,%rax,4)
# INTEL: ctestle {dfv=of} dword ptr [r8 + 4*rax + 123], ecx
0x62,0xd4,0x44,0x0e,0x85,0x4c,0x80,0x7b

# ATT:   ctestleq {dfv=of} %r9, 123(%r8,%rax,4)
# INTEL: ctestle {dfv=of} qword ptr [r8 + 4*rax + 123], r9
0x62,0x54,0xc4,0x0e,0x85,0x4c,0x80,0x7b

# ATT:   ctestleb {dfv=of} $123, %bl
# INTEL: ctestle {dfv=of} bl, 123
0x62,0xf4,0x44,0x0e,0xf6,0xc3,0x7b

# ATT:   ctestlew {dfv=of} $1234, %dx
# INTEL: ctestle {dfv=of} dx, 1234
0x62,0xf4,0x45,0x0e,0xf7,0xc2,0xd2,0x04

# ATT:   ctestlel {dfv=of} $123456, %ecx
# INTEL: ctestle {dfv=of} ecx, 123456
0x62,0xf4,0x44,0x0e,0xf7,0xc1,0x40,0xe2,0x01,0x00

# ATT:   ctestleq {dfv=of} $123456, %r9
# INTEL: ctestle {dfv=of} r9, 123456
0x62,0xd4,0xc4,0x0e,0xf7,0xc1,0x40,0xe2,0x01,0x00

# ATT:   ctestleb {dfv=of} %bl, %dl
# INTEL: ctestle {dfv=of} dl, bl
0x62,0xf4,0x44,0x0e,0x84,0xda

# ATT:   ctestlew {dfv=of} %dx, %ax
# INTEL: ctestle {dfv=of} ax, dx
0x62,0xf4,0x45,0x0e,0x85,0xd0

# ATT:   ctestlel {dfv=of} %ecx, %edx
# INTEL: ctestle {dfv=of} edx, ecx
0x62,0xf4,0x44,0x0e,0x85,0xca

# ATT:   ctestleq {dfv=of} %r9, %r15
# INTEL: ctestle {dfv=of} r15, r9
0x62,0x54,0xc4,0x0e,0x85,0xcf

# ATT:   ctestaeb {dfv=of} $123, 123(%r8,%rax,4)
# INTEL: ctestae {dfv=of} byte ptr [r8 + 4*rax + 123], 123
0x62,0xd4,0x44,0x03,0xf6,0x44,0x80,0x7b,0x7b

# ATT:   ctestaew {dfv=of} $1234, 123(%r8,%rax,4)
# INTEL: ctestae {dfv=of} word ptr [r8 + 4*rax + 123], 1234
0x62,0xd4,0x45,0x03,0xf7,0x44,0x80,0x7b,0xd2,0x04

# ATT:   ctestael {dfv=of} $123456, 123(%r8,%rax,4)
# INTEL: ctestae {dfv=of} dword ptr [r8 + 4*rax + 123], 123456
0x62,0xd4,0x44,0x03,0xf7,0x44,0x80,0x7b,0x40,0xe2,0x01,0x00

# ATT:   ctestaeq {dfv=of} $123456, 123(%r8,%rax,4)
# INTEL: ctestae {dfv=of} qword ptr [r8 + 4*rax + 123], 123456
0x62,0xd4,0xc4,0x03,0xf7,0x44,0x80,0x7b,0x40,0xe2,0x01,0x00

# ATT:   ctestaeb {dfv=of} %bl, 123(%r8,%rax,4)
# INTEL: ctestae {dfv=of} byte ptr [r8 + 4*rax + 123], bl
0x62,0xd4,0x44,0x03,0x84,0x5c,0x80,0x7b

# ATT:   ctestaew {dfv=of} %dx, 123(%r8,%rax,4)
# INTEL: ctestae {dfv=of} word ptr [r8 + 4*rax + 123], dx
0x62,0xd4,0x45,0x03,0x85,0x54,0x80,0x7b

# ATT:   ctestael {dfv=of} %ecx, 123(%r8,%rax,4)
# INTEL: ctestae {dfv=of} dword ptr [r8 + 4*rax + 123], ecx
0x62,0xd4,0x44,0x03,0x85,0x4c,0x80,0x7b

# ATT:   ctestaeq {dfv=of} %r9, 123(%r8,%rax,4)
# INTEL: ctestae {dfv=of} qword ptr [r8 + 4*rax + 123], r9
0x62,0x54,0xc4,0x03,0x85,0x4c,0x80,0x7b

# ATT:   ctestaeb {dfv=of} $123, %bl
# INTEL: ctestae {dfv=of} bl, 123
0x62,0xf4,0x44,0x03,0xf6,0xc3,0x7b

# ATT:   ctestaew {dfv=of} $1234, %dx
# INTEL: ctestae {dfv=of} dx, 1234
0x62,0xf4,0x45,0x03,0xf7,0xc2,0xd2,0x04

# ATT:   ctestael {dfv=of} $123456, %ecx
# INTEL: ctestae {dfv=of} ecx, 123456
0x62,0xf4,0x44,0x03,0xf7,0xc1,0x40,0xe2,0x01,0x00

# ATT:   ctestaeq {dfv=of} $123456, %r9
# INTEL: ctestae {dfv=of} r9, 123456
0x62,0xd4,0xc4,0x03,0xf7,0xc1,0x40,0xe2,0x01,0x00

# ATT:   ctestaeb {dfv=of} %bl, %dl
# INTEL: ctestae {dfv=of} dl, bl
0x62,0xf4,0x44,0x03,0x84,0xda

# ATT:   ctestaew {dfv=of} %dx, %ax
# INTEL: ctestae {dfv=of} ax, dx
0x62,0xf4,0x45,0x03,0x85,0xd0

# ATT:   ctestael {dfv=of} %ecx, %edx
# INTEL: ctestae {dfv=of} edx, ecx
0x62,0xf4,0x44,0x03,0x85,0xca

# ATT:   ctestaeq {dfv=of} %r9, %r15
# INTEL: ctestae {dfv=of} r15, r9
0x62,0x54,0xc4,0x03,0x85,0xcf

# ATT:   ctestab {dfv=of} $123, 123(%r8,%rax,4)
# INTEL: ctesta {dfv=of} byte ptr [r8 + 4*rax + 123], 123
0x62,0xd4,0x44,0x07,0xf6,0x44,0x80,0x7b,0x7b

# ATT:   ctestaw {dfv=of} $1234, 123(%r8,%rax,4)
# INTEL: ctesta {dfv=of} word ptr [r8 + 4*rax + 123], 1234
0x62,0xd4,0x45,0x07,0xf7,0x44,0x80,0x7b,0xd2,0x04

# ATT:   ctestal {dfv=of} $123456, 123(%r8,%rax,4)
# INTEL: ctesta {dfv=of} dword ptr [r8 + 4*rax + 123], 123456
0x62,0xd4,0x44,0x07,0xf7,0x44,0x80,0x7b,0x40,0xe2,0x01,0x00

# ATT:   ctestaq {dfv=of} $123456, 123(%r8,%rax,4)
# INTEL: ctesta {dfv=of} qword ptr [r8 + 4*rax + 123], 123456
0x62,0xd4,0xc4,0x07,0xf7,0x44,0x80,0x7b,0x40,0xe2,0x01,0x00

# ATT:   ctestab {dfv=of} %bl, 123(%r8,%rax,4)
# INTEL: ctesta {dfv=of} byte ptr [r8 + 4*rax + 123], bl
0x62,0xd4,0x44,0x07,0x84,0x5c,0x80,0x7b

# ATT:   ctestaw {dfv=of} %dx, 123(%r8,%rax,4)
# INTEL: ctesta {dfv=of} word ptr [r8 + 4*rax + 123], dx
0x62,0xd4,0x45,0x07,0x85,0x54,0x80,0x7b

# ATT:   ctestal {dfv=of} %ecx, 123(%r8,%rax,4)
# INTEL: ctesta {dfv=of} dword ptr [r8 + 4*rax + 123], ecx
0x62,0xd4,0x44,0x07,0x85,0x4c,0x80,0x7b

# ATT:   ctestaq {dfv=of} %r9, 123(%r8,%rax,4)
# INTEL: ctesta {dfv=of} qword ptr [r8 + 4*rax + 123], r9
0x62,0x54,0xc4,0x07,0x85,0x4c,0x80,0x7b

# ATT:   ctestab {dfv=of} $123, %bl
# INTEL: ctesta {dfv=of} bl, 123
0x62,0xf4,0x44,0x07,0xf6,0xc3,0x7b

# ATT:   ctestaw {dfv=of} $1234, %dx
# INTEL: ctesta {dfv=of} dx, 1234
0x62,0xf4,0x45,0x07,0xf7,0xc2,0xd2,0x04

# ATT:   ctestal {dfv=of} $123456, %ecx
# INTEL: ctesta {dfv=of} ecx, 123456
0x62,0xf4,0x44,0x07,0xf7,0xc1,0x40,0xe2,0x01,0x00

# ATT:   ctestaq {dfv=of} $123456, %r9
# INTEL: ctesta {dfv=of} r9, 123456
0x62,0xd4,0xc4,0x07,0xf7,0xc1,0x40,0xe2,0x01,0x00

# ATT:   ctestab {dfv=of} %bl, %dl
# INTEL: ctesta {dfv=of} dl, bl
0x62,0xf4,0x44,0x07,0x84,0xda

# ATT:   ctestaw {dfv=of} %dx, %ax
# INTEL: ctesta {dfv=of} ax, dx
0x62,0xf4,0x45,0x07,0x85,0xd0

# ATT:   ctestal {dfv=of} %ecx, %edx
# INTEL: ctesta {dfv=of} edx, ecx
0x62,0xf4,0x44,0x07,0x85,0xca

# ATT:   ctestaq {dfv=of} %r9, %r15
# INTEL: ctesta {dfv=of} r15, r9
0x62,0x54,0xc4,0x07,0x85,0xcf

# ATT:   ctestgeb {dfv=of} $123, 123(%r8,%rax,4)
# INTEL: ctestge {dfv=of} byte ptr [r8 + 4*rax + 123], 123
0x62,0xd4,0x44,0x0d,0xf6,0x44,0x80,0x7b,0x7b

# ATT:   ctestgew {dfv=of} $1234, 123(%r8,%rax,4)
# INTEL: ctestge {dfv=of} word ptr [r8 + 4*rax + 123], 1234
0x62,0xd4,0x45,0x0d,0xf7,0x44,0x80,0x7b,0xd2,0x04

# ATT:   ctestgel {dfv=of} $123456, 123(%r8,%rax,4)
# INTEL: ctestge {dfv=of} dword ptr [r8 + 4*rax + 123], 123456
0x62,0xd4,0x44,0x0d,0xf7,0x44,0x80,0x7b,0x40,0xe2,0x01,0x00

# ATT:   ctestgeq {dfv=of} $123456, 123(%r8,%rax,4)
# INTEL: ctestge {dfv=of} qword ptr [r8 + 4*rax + 123], 123456
0x62,0xd4,0xc4,0x0d,0xf7,0x44,0x80,0x7b,0x40,0xe2,0x01,0x00

# ATT:   ctestgeb {dfv=of} %bl, 123(%r8,%rax,4)
# INTEL: ctestge {dfv=of} byte ptr [r8 + 4*rax + 123], bl
0x62,0xd4,0x44,0x0d,0x84,0x5c,0x80,0x7b

# ATT:   ctestgew {dfv=of} %dx, 123(%r8,%rax,4)
# INTEL: ctestge {dfv=of} word ptr [r8 + 4*rax + 123], dx
0x62,0xd4,0x45,0x0d,0x85,0x54,0x80,0x7b

# ATT:   ctestgel {dfv=of} %ecx, 123(%r8,%rax,4)
# INTEL: ctestge {dfv=of} dword ptr [r8 + 4*rax + 123], ecx
0x62,0xd4,0x44,0x0d,0x85,0x4c,0x80,0x7b

# ATT:   ctestgeq {dfv=of} %r9, 123(%r8,%rax,4)
# INTEL: ctestge {dfv=of} qword ptr [r8 + 4*rax + 123], r9
0x62,0x54,0xc4,0x0d,0x85,0x4c,0x80,0x7b

# ATT:   ctestgeb {dfv=of} $123, %bl
# INTEL: ctestge {dfv=of} bl, 123
0x62,0xf4,0x44,0x0d,0xf6,0xc3,0x7b

# ATT:   ctestgew {dfv=of} $1234, %dx
# INTEL: ctestge {dfv=of} dx, 1234
0x62,0xf4,0x45,0x0d,0xf7,0xc2,0xd2,0x04

# ATT:   ctestgel {dfv=of} $123456, %ecx
# INTEL: ctestge {dfv=of} ecx, 123456
0x62,0xf4,0x44,0x0d,0xf7,0xc1,0x40,0xe2,0x01,0x00

# ATT:   ctestgeq {dfv=of} $123456, %r9
# INTEL: ctestge {dfv=of} r9, 123456
0x62,0xd4,0xc4,0x0d,0xf7,0xc1,0x40,0xe2,0x01,0x00

# ATT:   ctestgeb {dfv=of} %bl, %dl
# INTEL: ctestge {dfv=of} dl, bl
0x62,0xf4,0x44,0x0d,0x84,0xda

# ATT:   ctestgew {dfv=of} %dx, %ax
# INTEL: ctestge {dfv=of} ax, dx
0x62,0xf4,0x45,0x0d,0x85,0xd0

# ATT:   ctestgel {dfv=of} %ecx, %edx
# INTEL: ctestge {dfv=of} edx, ecx
0x62,0xf4,0x44,0x0d,0x85,0xca

# ATT:   ctestgeq {dfv=of} %r9, %r15
# INTEL: ctestge {dfv=of} r15, r9
0x62,0x54,0xc4,0x0d,0x85,0xcf

# ATT:   ctestgb {dfv=of} $123, 123(%r8,%rax,4)
# INTEL: ctestg {dfv=of} byte ptr [r8 + 4*rax + 123], 123
0x62,0xd4,0x44,0x0f,0xf6,0x44,0x80,0x7b,0x7b

# ATT:   ctestgw {dfv=of} $1234, 123(%r8,%rax,4)
# INTEL: ctestg {dfv=of} word ptr [r8 + 4*rax + 123], 1234
0x62,0xd4,0x45,0x0f,0xf7,0x44,0x80,0x7b,0xd2,0x04

# ATT:   ctestgl {dfv=of} $123456, 123(%r8,%rax,4)
# INTEL: ctestg {dfv=of} dword ptr [r8 + 4*rax + 123], 123456
0x62,0xd4,0x44,0x0f,0xf7,0x44,0x80,0x7b,0x40,0xe2,0x01,0x00

# ATT:   ctestgq {dfv=of} $123456, 123(%r8,%rax,4)
# INTEL: ctestg {dfv=of} qword ptr [r8 + 4*rax + 123], 123456
0x62,0xd4,0xc4,0x0f,0xf7,0x44,0x80,0x7b,0x40,0xe2,0x01,0x00

# ATT:   ctestgb {dfv=of} %bl, 123(%r8,%rax,4)
# INTEL: ctestg {dfv=of} byte ptr [r8 + 4*rax + 123], bl
0x62,0xd4,0x44,0x0f,0x84,0x5c,0x80,0x7b

# ATT:   ctestgw {dfv=of} %dx, 123(%r8,%rax,4)
# INTEL: ctestg {dfv=of} word ptr [r8 + 4*rax + 123], dx
0x62,0xd4,0x45,0x0f,0x85,0x54,0x80,0x7b

# ATT:   ctestgl {dfv=of} %ecx, 123(%r8,%rax,4)
# INTEL: ctestg {dfv=of} dword ptr [r8 + 4*rax + 123], ecx
0x62,0xd4,0x44,0x0f,0x85,0x4c,0x80,0x7b

# ATT:   ctestgq {dfv=of} %r9, 123(%r8,%rax,4)
# INTEL: ctestg {dfv=of} qword ptr [r8 + 4*rax + 123], r9
0x62,0x54,0xc4,0x0f,0x85,0x4c,0x80,0x7b

# ATT:   ctestgb {dfv=of} $123, %bl
# INTEL: ctestg {dfv=of} bl, 123
0x62,0xf4,0x44,0x0f,0xf6,0xc3,0x7b

# ATT:   ctestgw {dfv=of} $1234, %dx
# INTEL: ctestg {dfv=of} dx, 1234
0x62,0xf4,0x45,0x0f,0xf7,0xc2,0xd2,0x04

# ATT:   ctestgl {dfv=of} $123456, %ecx
# INTEL: ctestg {dfv=of} ecx, 123456
0x62,0xf4,0x44,0x0f,0xf7,0xc1,0x40,0xe2,0x01,0x00

# ATT:   ctestgq {dfv=of} $123456, %r9
# INTEL: ctestg {dfv=of} r9, 123456
0x62,0xd4,0xc4,0x0f,0xf7,0xc1,0x40,0xe2,0x01,0x00

# ATT:   ctestgb {dfv=of} %bl, %dl
# INTEL: ctestg {dfv=of} dl, bl
0x62,0xf4,0x44,0x0f,0x84,0xda

# ATT:   ctestgw {dfv=of} %dx, %ax
# INTEL: ctestg {dfv=of} ax, dx
0x62,0xf4,0x45,0x0f,0x85,0xd0

# ATT:   ctestgl {dfv=of} %ecx, %edx
# INTEL: ctestg {dfv=of} edx, ecx
0x62,0xf4,0x44,0x0f,0x85,0xca

# ATT:   ctestgq {dfv=of} %r9, %r15
# INTEL: ctestg {dfv=of} r15, r9
0x62,0x54,0xc4,0x0f,0x85,0xcf

# ATT:   ctestnob {dfv=of} $123, 123(%r8,%rax,4)
# INTEL: ctestno {dfv=of} byte ptr [r8 + 4*rax + 123], 123
0x62,0xd4,0x44,0x01,0xf6,0x44,0x80,0x7b,0x7b

# ATT:   ctestnow {dfv=of} $1234, 123(%r8,%rax,4)
# INTEL: ctestno {dfv=of} word ptr [r8 + 4*rax + 123], 1234
0x62,0xd4,0x45,0x01,0xf7,0x44,0x80,0x7b,0xd2,0x04

# ATT:   ctestnol {dfv=of} $123456, 123(%r8,%rax,4)
# INTEL: ctestno {dfv=of} dword ptr [r8 + 4*rax + 123], 123456
0x62,0xd4,0x44,0x01,0xf7,0x44,0x80,0x7b,0x40,0xe2,0x01,0x00

# ATT:   ctestnoq {dfv=of} $123456, 123(%r8,%rax,4)
# INTEL: ctestno {dfv=of} qword ptr [r8 + 4*rax + 123], 123456
0x62,0xd4,0xc4,0x01,0xf7,0x44,0x80,0x7b,0x40,0xe2,0x01,0x00

# ATT:   ctestnob {dfv=of} %bl, 123(%r8,%rax,4)
# INTEL: ctestno {dfv=of} byte ptr [r8 + 4*rax + 123], bl
0x62,0xd4,0x44,0x01,0x84,0x5c,0x80,0x7b

# ATT:   ctestnow {dfv=of} %dx, 123(%r8,%rax,4)
# INTEL: ctestno {dfv=of} word ptr [r8 + 4*rax + 123], dx
0x62,0xd4,0x45,0x01,0x85,0x54,0x80,0x7b

# ATT:   ctestnol {dfv=of} %ecx, 123(%r8,%rax,4)
# INTEL: ctestno {dfv=of} dword ptr [r8 + 4*rax + 123], ecx
0x62,0xd4,0x44,0x01,0x85,0x4c,0x80,0x7b

# ATT:   ctestnoq {dfv=of} %r9, 123(%r8,%rax,4)
# INTEL: ctestno {dfv=of} qword ptr [r8 + 4*rax + 123], r9
0x62,0x54,0xc4,0x01,0x85,0x4c,0x80,0x7b

# ATT:   ctestnob {dfv=of} $123, %bl
# INTEL: ctestno {dfv=of} bl, 123
0x62,0xf4,0x44,0x01,0xf6,0xc3,0x7b

# ATT:   ctestnow {dfv=of} $1234, %dx
# INTEL: ctestno {dfv=of} dx, 1234
0x62,0xf4,0x45,0x01,0xf7,0xc2,0xd2,0x04

# ATT:   ctestnol {dfv=of} $123456, %ecx
# INTEL: ctestno {dfv=of} ecx, 123456
0x62,0xf4,0x44,0x01,0xf7,0xc1,0x40,0xe2,0x01,0x00

# ATT:   ctestnoq {dfv=of} $123456, %r9
# INTEL: ctestno {dfv=of} r9, 123456
0x62,0xd4,0xc4,0x01,0xf7,0xc1,0x40,0xe2,0x01,0x00

# ATT:   ctestnob {dfv=of} %bl, %dl
# INTEL: ctestno {dfv=of} dl, bl
0x62,0xf4,0x44,0x01,0x84,0xda

# ATT:   ctestnow {dfv=of} %dx, %ax
# INTEL: ctestno {dfv=of} ax, dx
0x62,0xf4,0x45,0x01,0x85,0xd0

# ATT:   ctestnol {dfv=of} %ecx, %edx
# INTEL: ctestno {dfv=of} edx, ecx
0x62,0xf4,0x44,0x01,0x85,0xca

# ATT:   ctestnoq {dfv=of} %r9, %r15
# INTEL: ctestno {dfv=of} r15, r9
0x62,0x54,0xc4,0x01,0x85,0xcf

# ATT:   ctestnsb {dfv=of} $123, 123(%r8,%rax,4)
# INTEL: ctestns {dfv=of} byte ptr [r8 + 4*rax + 123], 123
0x62,0xd4,0x44,0x09,0xf6,0x44,0x80,0x7b,0x7b

# ATT:   ctestnsw {dfv=of} $1234, 123(%r8,%rax,4)
# INTEL: ctestns {dfv=of} word ptr [r8 + 4*rax + 123], 1234
0x62,0xd4,0x45,0x09,0xf7,0x44,0x80,0x7b,0xd2,0x04

# ATT:   ctestnsl {dfv=of} $123456, 123(%r8,%rax,4)
# INTEL: ctestns {dfv=of} dword ptr [r8 + 4*rax + 123], 123456
0x62,0xd4,0x44,0x09,0xf7,0x44,0x80,0x7b,0x40,0xe2,0x01,0x00

# ATT:   ctestnsq {dfv=of} $123456, 123(%r8,%rax,4)
# INTEL: ctestns {dfv=of} qword ptr [r8 + 4*rax + 123], 123456
0x62,0xd4,0xc4,0x09,0xf7,0x44,0x80,0x7b,0x40,0xe2,0x01,0x00

# ATT:   ctestnsb {dfv=of} %bl, 123(%r8,%rax,4)
# INTEL: ctestns {dfv=of} byte ptr [r8 + 4*rax + 123], bl
0x62,0xd4,0x44,0x09,0x84,0x5c,0x80,0x7b

# ATT:   ctestnsw {dfv=of} %dx, 123(%r8,%rax,4)
# INTEL: ctestns {dfv=of} word ptr [r8 + 4*rax + 123], dx
0x62,0xd4,0x45,0x09,0x85,0x54,0x80,0x7b

# ATT:   ctestnsl {dfv=of} %ecx, 123(%r8,%rax,4)
# INTEL: ctestns {dfv=of} dword ptr [r8 + 4*rax + 123], ecx
0x62,0xd4,0x44,0x09,0x85,0x4c,0x80,0x7b

# ATT:   ctestnsq {dfv=of} %r9, 123(%r8,%rax,4)
# INTEL: ctestns {dfv=of} qword ptr [r8 + 4*rax + 123], r9
0x62,0x54,0xc4,0x09,0x85,0x4c,0x80,0x7b

# ATT:   ctestnsb {dfv=of} $123, %bl
# INTEL: ctestns {dfv=of} bl, 123
0x62,0xf4,0x44,0x09,0xf6,0xc3,0x7b

# ATT:   ctestnsw {dfv=of} $1234, %dx
# INTEL: ctestns {dfv=of} dx, 1234
0x62,0xf4,0x45,0x09,0xf7,0xc2,0xd2,0x04

# ATT:   ctestnsl {dfv=of} $123456, %ecx
# INTEL: ctestns {dfv=of} ecx, 123456
0x62,0xf4,0x44,0x09,0xf7,0xc1,0x40,0xe2,0x01,0x00

# ATT:   ctestnsq {dfv=of} $123456, %r9
# INTEL: ctestns {dfv=of} r9, 123456
0x62,0xd4,0xc4,0x09,0xf7,0xc1,0x40,0xe2,0x01,0x00

# ATT:   ctestnsb {dfv=of} %bl, %dl
# INTEL: ctestns {dfv=of} dl, bl
0x62,0xf4,0x44,0x09,0x84,0xda

# ATT:   ctestnsw {dfv=of} %dx, %ax
# INTEL: ctestns {dfv=of} ax, dx
0x62,0xf4,0x45,0x09,0x85,0xd0

# ATT:   ctestnsl {dfv=of} %ecx, %edx
# INTEL: ctestns {dfv=of} edx, ecx
0x62,0xf4,0x44,0x09,0x85,0xca

# ATT:   ctestnsq {dfv=of} %r9, %r15
# INTEL: ctestns {dfv=of} r15, r9
0x62,0x54,0xc4,0x09,0x85,0xcf

# ATT:   ctestneb {dfv=of} $123, 123(%r8,%rax,4)
# INTEL: ctestne {dfv=of} byte ptr [r8 + 4*rax + 123], 123
0x62,0xd4,0x44,0x05,0xf6,0x44,0x80,0x7b,0x7b

# ATT:   ctestnew {dfv=of} $1234, 123(%r8,%rax,4)
# INTEL: ctestne {dfv=of} word ptr [r8 + 4*rax + 123], 1234
0x62,0xd4,0x45,0x05,0xf7,0x44,0x80,0x7b,0xd2,0x04

# ATT:   ctestnel {dfv=of} $123456, 123(%r8,%rax,4)
# INTEL: ctestne {dfv=of} dword ptr [r8 + 4*rax + 123], 123456
0x62,0xd4,0x44,0x05,0xf7,0x44,0x80,0x7b,0x40,0xe2,0x01,0x00

# ATT:   ctestneq {dfv=of} $123456, 123(%r8,%rax,4)
# INTEL: ctestne {dfv=of} qword ptr [r8 + 4*rax + 123], 123456
0x62,0xd4,0xc4,0x05,0xf7,0x44,0x80,0x7b,0x40,0xe2,0x01,0x00

# ATT:   ctestneb {dfv=of} %bl, 123(%r8,%rax,4)
# INTEL: ctestne {dfv=of} byte ptr [r8 + 4*rax + 123], bl
0x62,0xd4,0x44,0x05,0x84,0x5c,0x80,0x7b

# ATT:   ctestnew {dfv=of} %dx, 123(%r8,%rax,4)
# INTEL: ctestne {dfv=of} word ptr [r8 + 4*rax + 123], dx
0x62,0xd4,0x45,0x05,0x85,0x54,0x80,0x7b

# ATT:   ctestnel {dfv=of} %ecx, 123(%r8,%rax,4)
# INTEL: ctestne {dfv=of} dword ptr [r8 + 4*rax + 123], ecx
0x62,0xd4,0x44,0x05,0x85,0x4c,0x80,0x7b

# ATT:   ctestneq {dfv=of} %r9, 123(%r8,%rax,4)
# INTEL: ctestne {dfv=of} qword ptr [r8 + 4*rax + 123], r9
0x62,0x54,0xc4,0x05,0x85,0x4c,0x80,0x7b

# ATT:   ctestneb {dfv=of} $123, %bl
# INTEL: ctestne {dfv=of} bl, 123
0x62,0xf4,0x44,0x05,0xf6,0xc3,0x7b

# ATT:   ctestnew {dfv=of} $1234, %dx
# INTEL: ctestne {dfv=of} dx, 1234
0x62,0xf4,0x45,0x05,0xf7,0xc2,0xd2,0x04

# ATT:   ctestnel {dfv=of} $123456, %ecx
# INTEL: ctestne {dfv=of} ecx, 123456
0x62,0xf4,0x44,0x05,0xf7,0xc1,0x40,0xe2,0x01,0x00

# ATT:   ctestneq {dfv=of} $123456, %r9
# INTEL: ctestne {dfv=of} r9, 123456
0x62,0xd4,0xc4,0x05,0xf7,0xc1,0x40,0xe2,0x01,0x00

# ATT:   ctestneb {dfv=of} %bl, %dl
# INTEL: ctestne {dfv=of} dl, bl
0x62,0xf4,0x44,0x05,0x84,0xda

# ATT:   ctestnew {dfv=of} %dx, %ax
# INTEL: ctestne {dfv=of} ax, dx
0x62,0xf4,0x45,0x05,0x85,0xd0

# ATT:   ctestnel {dfv=of} %ecx, %edx
# INTEL: ctestne {dfv=of} edx, ecx
0x62,0xf4,0x44,0x05,0x85,0xca

# ATT:   ctestneq {dfv=of} %r9, %r15
# INTEL: ctestne {dfv=of} r15, r9
0x62,0x54,0xc4,0x05,0x85,0xcf

# ATT:   ctestob {dfv=of} $123, 123(%r8,%rax,4)
# INTEL: ctesto {dfv=of} byte ptr [r8 + 4*rax + 123], 123
0x62,0xd4,0x44,0x00,0xf6,0x44,0x80,0x7b,0x7b

# ATT:   ctestow {dfv=of} $1234, 123(%r8,%rax,4)
# INTEL: ctesto {dfv=of} word ptr [r8 + 4*rax + 123], 1234
0x62,0xd4,0x45,0x00,0xf7,0x44,0x80,0x7b,0xd2,0x04

# ATT:   ctestol {dfv=of} $123456, 123(%r8,%rax,4)
# INTEL: ctesto {dfv=of} dword ptr [r8 + 4*rax + 123], 123456
0x62,0xd4,0x44,0x00,0xf7,0x44,0x80,0x7b,0x40,0xe2,0x01,0x00

# ATT:   ctestoq {dfv=of} $123456, 123(%r8,%rax,4)
# INTEL: ctesto {dfv=of} qword ptr [r8 + 4*rax + 123], 123456
0x62,0xd4,0xc4,0x00,0xf7,0x44,0x80,0x7b,0x40,0xe2,0x01,0x00

# ATT:   ctestob {dfv=of} %bl, 123(%r8,%rax,4)
# INTEL: ctesto {dfv=of} byte ptr [r8 + 4*rax + 123], bl
0x62,0xd4,0x44,0x00,0x84,0x5c,0x80,0x7b

# ATT:   ctestow {dfv=of} %dx, 123(%r8,%rax,4)
# INTEL: ctesto {dfv=of} word ptr [r8 + 4*rax + 123], dx
0x62,0xd4,0x45,0x00,0x85,0x54,0x80,0x7b

# ATT:   ctestol {dfv=of} %ecx, 123(%r8,%rax,4)
# INTEL: ctesto {dfv=of} dword ptr [r8 + 4*rax + 123], ecx
0x62,0xd4,0x44,0x00,0x85,0x4c,0x80,0x7b

# ATT:   ctestoq {dfv=of} %r9, 123(%r8,%rax,4)
# INTEL: ctesto {dfv=of} qword ptr [r8 + 4*rax + 123], r9
0x62,0x54,0xc4,0x00,0x85,0x4c,0x80,0x7b

# ATT:   ctestob {dfv=of} $123, %bl
# INTEL: ctesto {dfv=of} bl, 123
0x62,0xf4,0x44,0x00,0xf6,0xc3,0x7b

# ATT:   ctestow {dfv=of} $1234, %dx
# INTEL: ctesto {dfv=of} dx, 1234
0x62,0xf4,0x45,0x00,0xf7,0xc2,0xd2,0x04

# ATT:   ctestol {dfv=of} $123456, %ecx
# INTEL: ctesto {dfv=of} ecx, 123456
0x62,0xf4,0x44,0x00,0xf7,0xc1,0x40,0xe2,0x01,0x00

# ATT:   ctestoq {dfv=of} $123456, %r9
# INTEL: ctesto {dfv=of} r9, 123456
0x62,0xd4,0xc4,0x00,0xf7,0xc1,0x40,0xe2,0x01,0x00

# ATT:   ctestob {dfv=of} %bl, %dl
# INTEL: ctesto {dfv=of} dl, bl
0x62,0xf4,0x44,0x00,0x84,0xda

# ATT:   ctestow {dfv=of} %dx, %ax
# INTEL: ctesto {dfv=of} ax, dx
0x62,0xf4,0x45,0x00,0x85,0xd0

# ATT:   ctestol {dfv=of} %ecx, %edx
# INTEL: ctesto {dfv=of} edx, ecx
0x62,0xf4,0x44,0x00,0x85,0xca

# ATT:   ctestoq {dfv=of} %r9, %r15
# INTEL: ctesto {dfv=of} r15, r9
0x62,0x54,0xc4,0x00,0x85,0xcf

# ATT:   ctestsb {dfv=of} $123, 123(%r8,%rax,4)
# INTEL: ctests {dfv=of} byte ptr [r8 + 4*rax + 123], 123
0x62,0xd4,0x44,0x08,0xf6,0x44,0x80,0x7b,0x7b

# ATT:   ctestsw {dfv=of} $1234, 123(%r8,%rax,4)
# INTEL: ctests {dfv=of} word ptr [r8 + 4*rax + 123], 1234
0x62,0xd4,0x45,0x08,0xf7,0x44,0x80,0x7b,0xd2,0x04

# ATT:   ctestsl {dfv=of} $123456, 123(%r8,%rax,4)
# INTEL: ctests {dfv=of} dword ptr [r8 + 4*rax + 123], 123456
0x62,0xd4,0x44,0x08,0xf7,0x44,0x80,0x7b,0x40,0xe2,0x01,0x00

# ATT:   ctestsq {dfv=of} $123456, 123(%r8,%rax,4)
# INTEL: ctests {dfv=of} qword ptr [r8 + 4*rax + 123], 123456
0x62,0xd4,0xc4,0x08,0xf7,0x44,0x80,0x7b,0x40,0xe2,0x01,0x00

# ATT:   ctestsb {dfv=of} %bl, 123(%r8,%rax,4)
# INTEL: ctests {dfv=of} byte ptr [r8 + 4*rax + 123], bl
0x62,0xd4,0x44,0x08,0x84,0x5c,0x80,0x7b

# ATT:   ctestsw {dfv=of} %dx, 123(%r8,%rax,4)
# INTEL: ctests {dfv=of} word ptr [r8 + 4*rax + 123], dx
0x62,0xd4,0x45,0x08,0x85,0x54,0x80,0x7b

# ATT:   ctestsl {dfv=of} %ecx, 123(%r8,%rax,4)
# INTEL: ctests {dfv=of} dword ptr [r8 + 4*rax + 123], ecx
0x62,0xd4,0x44,0x08,0x85,0x4c,0x80,0x7b

# ATT:   ctestsq {dfv=of} %r9, 123(%r8,%rax,4)
# INTEL: ctests {dfv=of} qword ptr [r8 + 4*rax + 123], r9
0x62,0x54,0xc4,0x08,0x85,0x4c,0x80,0x7b

# ATT:   ctestsb {dfv=of} $123, %bl
# INTEL: ctests {dfv=of} bl, 123
0x62,0xf4,0x44,0x08,0xf6,0xc3,0x7b

# ATT:   ctestsw {dfv=of} $1234, %dx
# INTEL: ctests {dfv=of} dx, 1234
0x62,0xf4,0x45,0x08,0xf7,0xc2,0xd2,0x04

# ATT:   ctestsl {dfv=of} $123456, %ecx
# INTEL: ctests {dfv=of} ecx, 123456
0x62,0xf4,0x44,0x08,0xf7,0xc1,0x40,0xe2,0x01,0x00

# ATT:   ctestsq {dfv=of} $123456, %r9
# INTEL: ctests {dfv=of} r9, 123456
0x62,0xd4,0xc4,0x08,0xf7,0xc1,0x40,0xe2,0x01,0x00

# ATT:   ctestsb {dfv=of} %bl, %dl
# INTEL: ctests {dfv=of} dl, bl
0x62,0xf4,0x44,0x08,0x84,0xda

# ATT:   ctestsw {dfv=of} %dx, %ax
# INTEL: ctests {dfv=of} ax, dx
0x62,0xf4,0x45,0x08,0x85,0xd0

# ATT:   ctestsl {dfv=of} %ecx, %edx
# INTEL: ctests {dfv=of} edx, ecx
0x62,0xf4,0x44,0x08,0x85,0xca

# ATT:   ctestsq {dfv=of} %r9, %r15
# INTEL: ctests {dfv=of} r15, r9
0x62,0x54,0xc4,0x08,0x85,0xcf

# ATT:   ctesttb {dfv=of} $123, 123(%r8,%rax,4)
# INTEL: ctestt {dfv=of} byte ptr [r8 + 4*rax + 123], 123
0x62,0xd4,0x44,0x0a,0xf6,0x44,0x80,0x7b,0x7b

# ATT:   ctesttw {dfv=of} $1234, 123(%r8,%rax,4)
# INTEL: ctestt {dfv=of} word ptr [r8 + 4*rax + 123], 1234
0x62,0xd4,0x45,0x0a,0xf7,0x44,0x80,0x7b,0xd2,0x04

# ATT:   ctesttl {dfv=of} $123456, 123(%r8,%rax,4)
# INTEL: ctestt {dfv=of} dword ptr [r8 + 4*rax + 123], 123456
0x62,0xd4,0x44,0x0a,0xf7,0x44,0x80,0x7b,0x40,0xe2,0x01,0x00

# ATT:   ctesttq {dfv=of} $123456, 123(%r8,%rax,4)
# INTEL: ctestt {dfv=of} qword ptr [r8 + 4*rax + 123], 123456
0x62,0xd4,0xc4,0x0a,0xf7,0x44,0x80,0x7b,0x40,0xe2,0x01,0x00

# ATT:   ctesttb {dfv=of} %bl, 123(%r8,%rax,4)
# INTEL: ctestt {dfv=of} byte ptr [r8 + 4*rax + 123], bl
0x62,0xd4,0x44,0x0a,0x84,0x5c,0x80,0x7b

# ATT:   ctesttw {dfv=of} %dx, 123(%r8,%rax,4)
# INTEL: ctestt {dfv=of} word ptr [r8 + 4*rax + 123], dx
0x62,0xd4,0x45,0x0a,0x85,0x54,0x80,0x7b

# ATT:   ctesttl {dfv=of} %ecx, 123(%r8,%rax,4)
# INTEL: ctestt {dfv=of} dword ptr [r8 + 4*rax + 123], ecx
0x62,0xd4,0x44,0x0a,0x85,0x4c,0x80,0x7b

# ATT:   ctesttq {dfv=of} %r9, 123(%r8,%rax,4)
# INTEL: ctestt {dfv=of} qword ptr [r8 + 4*rax + 123], r9
0x62,0x54,0xc4,0x0a,0x85,0x4c,0x80,0x7b

# ATT:   ctesttb {dfv=of} $123, %bl
# INTEL: ctestt {dfv=of} bl, 123
0x62,0xf4,0x44,0x0a,0xf6,0xc3,0x7b

# ATT:   ctesttw {dfv=of} $1234, %dx
# INTEL: ctestt {dfv=of} dx, 1234
0x62,0xf4,0x45,0x0a,0xf7,0xc2,0xd2,0x04

# ATT:   ctesttl {dfv=of} $123456, %ecx
# INTEL: ctestt {dfv=of} ecx, 123456
0x62,0xf4,0x44,0x0a,0xf7,0xc1,0x40,0xe2,0x01,0x00

# ATT:   ctesttq {dfv=of} $123456, %r9
# INTEL: ctestt {dfv=of} r9, 123456
0x62,0xd4,0xc4,0x0a,0xf7,0xc1,0x40,0xe2,0x01,0x00

# ATT:   ctesttb {dfv=of} %bl, %dl
# INTEL: ctestt {dfv=of} dl, bl
0x62,0xf4,0x44,0x0a,0x84,0xda

# ATT:   ctesttw {dfv=of} %dx, %ax
# INTEL: ctestt {dfv=of} ax, dx
0x62,0xf4,0x45,0x0a,0x85,0xd0

# ATT:   ctesttl {dfv=of} %ecx, %edx
# INTEL: ctestt {dfv=of} edx, ecx
0x62,0xf4,0x44,0x0a,0x85,0xca

# ATT:   ctesttq {dfv=of} %r9, %r15
# INTEL: ctestt {dfv=of} r15, r9
0x62,0x54,0xc4,0x0a,0x85,0xcf

# ATT:   ctesteb {dfv=of} $123, 123(%r8,%rax,4)
# INTEL: cteste {dfv=of} byte ptr [r8 + 4*rax + 123], 123
0x62,0xd4,0x44,0x04,0xf6,0x44,0x80,0x7b,0x7b

# ATT:   ctestew {dfv=of} $1234, 123(%r8,%rax,4)
# INTEL: cteste {dfv=of} word ptr [r8 + 4*rax + 123], 1234
0x62,0xd4,0x45,0x04,0xf7,0x44,0x80,0x7b,0xd2,0x04

# ATT:   ctestel {dfv=of} $123456, 123(%r8,%rax,4)
# INTEL: cteste {dfv=of} dword ptr [r8 + 4*rax + 123], 123456
0x62,0xd4,0x44,0x04,0xf7,0x44,0x80,0x7b,0x40,0xe2,0x01,0x00

# ATT:   ctesteq {dfv=of} $123456, 123(%r8,%rax,4)
# INTEL: cteste {dfv=of} qword ptr [r8 + 4*rax + 123], 123456
0x62,0xd4,0xc4,0x04,0xf7,0x44,0x80,0x7b,0x40,0xe2,0x01,0x00

# ATT:   ctesteb {dfv=of} %bl, 123(%r8,%rax,4)
# INTEL: cteste {dfv=of} byte ptr [r8 + 4*rax + 123], bl
0x62,0xd4,0x44,0x04,0x84,0x5c,0x80,0x7b

# ATT:   ctestew {dfv=of} %dx, 123(%r8,%rax,4)
# INTEL: cteste {dfv=of} word ptr [r8 + 4*rax + 123], dx
0x62,0xd4,0x45,0x04,0x85,0x54,0x80,0x7b

# ATT:   ctestel {dfv=of} %ecx, 123(%r8,%rax,4)
# INTEL: cteste {dfv=of} dword ptr [r8 + 4*rax + 123], ecx
0x62,0xd4,0x44,0x04,0x85,0x4c,0x80,0x7b

# ATT:   ctesteq {dfv=of} %r9, 123(%r8,%rax,4)
# INTEL: cteste {dfv=of} qword ptr [r8 + 4*rax + 123], r9
0x62,0x54,0xc4,0x04,0x85,0x4c,0x80,0x7b

# ATT:   ctesteb {dfv=of} $123, %bl
# INTEL: cteste {dfv=of} bl, 123
0x62,0xf4,0x44,0x04,0xf6,0xc3,0x7b

# ATT:   ctestew {dfv=of} $1234, %dx
# INTEL: cteste {dfv=of} dx, 1234
0x62,0xf4,0x45,0x04,0xf7,0xc2,0xd2,0x04

# ATT:   ctestel {dfv=of} $123456, %ecx
# INTEL: cteste {dfv=of} ecx, 123456
0x62,0xf4,0x44,0x04,0xf7,0xc1,0x40,0xe2,0x01,0x00

# ATT:   ctesteq {dfv=of} $123456, %r9
# INTEL: cteste {dfv=of} r9, 123456
0x62,0xd4,0xc4,0x04,0xf7,0xc1,0x40,0xe2,0x01,0x00

# ATT:   ctesteb {dfv=of} %bl, %dl
# INTEL: cteste {dfv=of} dl, bl
0x62,0xf4,0x44,0x04,0x84,0xda

# ATT:   ctestew {dfv=of} %dx, %ax
# INTEL: cteste {dfv=of} ax, dx
0x62,0xf4,0x45,0x04,0x85,0xd0

# ATT:   ctestel {dfv=of} %ecx, %edx
# INTEL: cteste {dfv=of} edx, ecx
0x62,0xf4,0x44,0x04,0x85,0xca

# ATT:   ctesteq {dfv=of} %r9, %r15
# INTEL: cteste {dfv=of} r15, r9
0x62,0x54,0xc4,0x04,0x85,0xcf