# Check 64bit HLE instructions

	.allow_index_reg
	.text
_start:


# Tests for op imm32 rax

# Tests for op imm8 regb/m8
	xacquire lock adcb $100,(%rcx)
	lock xacquire adcb $100,(%rcx)
	xrelease lock adcb $100,(%rcx)
	lock xrelease adcb $100,(%rcx)
	.byte 0xf0; .byte 0xf2; adcb $100,(%rcx)
	.byte 0xf0; .byte 0xf3; adcb $100,(%rcx)
	xacquire lock addb $100,(%rcx)
	lock xacquire addb $100,(%rcx)
	xrelease lock addb $100,(%rcx)
	lock xrelease addb $100,(%rcx)
	.byte 0xf0; .byte 0xf2; addb $100,(%rcx)
	.byte 0xf0; .byte 0xf3; addb $100,(%rcx)
	xacquire lock andb $100,(%rcx)
	lock xacquire andb $100,(%rcx)
	xrelease lock andb $100,(%rcx)
	lock xrelease andb $100,(%rcx)
	.byte 0xf0; .byte 0xf2; andb $100,(%rcx)
	.byte 0xf0; .byte 0xf3; andb $100,(%rcx)
	xrelease movb $100,(%rcx)
	xacquire lock orb $100,(%rcx)
	lock xacquire orb $100,(%rcx)
	xrelease lock orb $100,(%rcx)
	lock xrelease orb $100,(%rcx)
	.byte 0xf0; .byte 0xf2; orb $100,(%rcx)
	.byte 0xf0; .byte 0xf3; orb $100,(%rcx)
	xacquire lock sbbb $100,(%rcx)
	lock xacquire sbbb $100,(%rcx)
	xrelease lock sbbb $100,(%rcx)
	lock xrelease sbbb $100,(%rcx)
	.byte 0xf0; .byte 0xf2; sbbb $100,(%rcx)
	.byte 0xf0; .byte 0xf3; sbbb $100,(%rcx)
	xacquire lock subb $100,(%rcx)
	lock xacquire subb $100,(%rcx)
	xrelease lock subb $100,(%rcx)
	lock xrelease subb $100,(%rcx)
	.byte 0xf0; .byte 0xf2; subb $100,(%rcx)
	.byte 0xf0; .byte 0xf3; subb $100,(%rcx)
	xacquire lock xorb $100,(%rcx)
	lock xacquire xorb $100,(%rcx)
	xrelease lock xorb $100,(%rcx)
	lock xrelease xorb $100,(%rcx)
	.byte 0xf0; .byte 0xf2; xorb $100,(%rcx)
	.byte 0xf0; .byte 0xf3; xorb $100,(%rcx)

# Tests for op imm16 regs/m16
	xacquire lock adcw $1000,(%rcx)
	lock xacquire adcw $1000,(%rcx)
	xrelease lock adcw $1000,(%rcx)
	lock xrelease adcw $1000,(%rcx)
	.byte 0xf0; .byte 0xf2; adcw $1000,(%rcx)
	.byte 0xf0; .byte 0xf3; adcw $1000,(%rcx)
	xacquire lock addw $1000,(%rcx)
	lock xacquire addw $1000,(%rcx)
	xrelease lock addw $1000,(%rcx)
	lock xrelease addw $1000,(%rcx)
	.byte 0xf0; .byte 0xf2; addw $1000,(%rcx)
	.byte 0xf0; .byte 0xf3; addw $1000,(%rcx)
	xacquire lock andw $1000,(%rcx)
	lock xacquire andw $1000,(%rcx)
	xrelease lock andw $1000,(%rcx)
	lock xrelease andw $1000,(%rcx)
	.byte 0xf0; .byte 0xf2; andw $1000,(%rcx)
	.byte 0xf0; .byte 0xf3; andw $1000,(%rcx)
	xrelease movw $1000,(%rcx)
	xacquire lock orw $1000,(%rcx)
	lock xacquire orw $1000,(%rcx)
	xrelease lock orw $1000,(%rcx)
	lock xrelease orw $1000,(%rcx)
	.byte 0xf0; .byte 0xf2; orw $1000,(%rcx)
	.byte 0xf0; .byte 0xf3; orw $1000,(%rcx)
	xacquire lock sbbw $1000,(%rcx)
	lock xacquire sbbw $1000,(%rcx)
	xrelease lock sbbw $1000,(%rcx)
	lock xrelease sbbw $1000,(%rcx)
	.byte 0xf0; .byte 0xf2; sbbw $1000,(%rcx)
	.byte 0xf0; .byte 0xf3; sbbw $1000,(%rcx)
	xacquire lock subw $1000,(%rcx)
	lock xacquire subw $1000,(%rcx)
	xrelease lock subw $1000,(%rcx)
	lock xrelease subw $1000,(%rcx)
	.byte 0xf0; .byte 0xf2; subw $1000,(%rcx)
	.byte 0xf0; .byte 0xf3; subw $1000,(%rcx)
	xacquire lock xorw $1000,(%rcx)
	lock xacquire xorw $1000,(%rcx)
	xrelease lock xorw $1000,(%rcx)
	lock xrelease xorw $1000,(%rcx)
	.byte 0xf0; .byte 0xf2; xorw $1000,(%rcx)
	.byte 0xf0; .byte 0xf3; xorw $1000,(%rcx)

# Tests for op imm32 regl/m32
	xacquire lock adcl $10000000,(%rcx)
	lock xacquire adcl $10000000,(%rcx)
	xrelease lock adcl $10000000,(%rcx)
	lock xrelease adcl $10000000,(%rcx)
	.byte 0xf0; .byte 0xf2; adcl $10000000,(%rcx)
	.byte 0xf0; .byte 0xf3; adcl $10000000,(%rcx)
	xacquire lock addl $10000000,(%rcx)
	lock xacquire addl $10000000,(%rcx)
	xrelease lock addl $10000000,(%rcx)
	lock xrelease addl $10000000,(%rcx)
	.byte 0xf0; .byte 0xf2; addl $10000000,(%rcx)
	.byte 0xf0; .byte 0xf3; addl $10000000,(%rcx)
	xacquire lock andl $10000000,(%rcx)
	lock xacquire andl $10000000,(%rcx)
	xrelease lock andl $10000000,(%rcx)
	lock xrelease andl $10000000,(%rcx)
	.byte 0xf0; .byte 0xf2; andl $10000000,(%rcx)
	.byte 0xf0; .byte 0xf3; andl $10000000,(%rcx)
	xrelease movl $10000000,(%rcx)
	xacquire lock orl $10000000,(%rcx)
	lock xacquire orl $10000000,(%rcx)
	xrelease lock orl $10000000,(%rcx)
	lock xrelease orl $10000000,(%rcx)
	.byte 0xf0; .byte 0xf2; orl $10000000,(%rcx)
	.byte 0xf0; .byte 0xf3; orl $10000000,(%rcx)
	xacquire lock sbbl $10000000,(%rcx)
	lock xacquire sbbl $10000000,(%rcx)
	xrelease lock sbbl $10000000,(%rcx)
	lock xrelease sbbl $10000000,(%rcx)
	.byte 0xf0; .byte 0xf2; sbbl $10000000,(%rcx)
	.byte 0xf0; .byte 0xf3; sbbl $10000000,(%rcx)
	xacquire lock subl $10000000,(%rcx)
	lock xacquire subl $10000000,(%rcx)
	xrelease lock subl $10000000,(%rcx)
	lock xrelease subl $10000000,(%rcx)
	.byte 0xf0; .byte 0xf2; subl $10000000,(%rcx)
	.byte 0xf0; .byte 0xf3; subl $10000000,(%rcx)
	xacquire lock xorl $10000000,(%rcx)
	lock xacquire xorl $10000000,(%rcx)
	xrelease lock xorl $10000000,(%rcx)
	lock xrelease xorl $10000000,(%rcx)
	.byte 0xf0; .byte 0xf2; xorl $10000000,(%rcx)
	.byte 0xf0; .byte 0xf3; xorl $10000000,(%rcx)

# Tests for op imm32 regq/m64
	xacquire lock adcq $10000000,(%rcx)
	lock xacquire adcq $10000000,(%rcx)
	xrelease lock adcq $10000000,(%rcx)
	lock xrelease adcq $10000000,(%rcx)
	.byte 0xf0; .byte 0xf2; adcq $10000000,(%rcx)
	.byte 0xf0; .byte 0xf3; adcq $10000000,(%rcx)
	xacquire lock addq $10000000,(%rcx)
	lock xacquire addq $10000000,(%rcx)
	xrelease lock addq $10000000,(%rcx)
	lock xrelease addq $10000000,(%rcx)
	.byte 0xf0; .byte 0xf2; addq $10000000,(%rcx)
	.byte 0xf0; .byte 0xf3; addq $10000000,(%rcx)
	xacquire lock andq $10000000,(%rcx)
	lock xacquire andq $10000000,(%rcx)
	xrelease lock andq $10000000,(%rcx)
	lock xrelease andq $10000000,(%rcx)
	.byte 0xf0; .byte 0xf2; andq $10000000,(%rcx)
	.byte 0xf0; .byte 0xf3; andq $10000000,(%rcx)
	xrelease movq $10000000,(%rcx)
	xacquire lock orq $10000000,(%rcx)
	lock xacquire orq $10000000,(%rcx)
	xrelease lock orq $10000000,(%rcx)
	lock xrelease orq $10000000,(%rcx)
	.byte 0xf0; .byte 0xf2; orq $10000000,(%rcx)
	.byte 0xf0; .byte 0xf3; orq $10000000,(%rcx)
	xacquire lock sbbq $10000000,(%rcx)
	lock xacquire sbbq $10000000,(%rcx)
	xrelease lock sbbq $10000000,(%rcx)
	lock xrelease sbbq $10000000,(%rcx)
	.byte 0xf0; .byte 0xf2; sbbq $10000000,(%rcx)
	.byte 0xf0; .byte 0xf3; sbbq $10000000,(%rcx)
	xacquire lock subq $10000000,(%rcx)
	lock xacquire subq $10000000,(%rcx)
	xrelease lock subq $10000000,(%rcx)
	lock xrelease subq $10000000,(%rcx)
	.byte 0xf0; .byte 0xf2; subq $10000000,(%rcx)
	.byte 0xf0; .byte 0xf3; subq $10000000,(%rcx)
	xacquire lock xorq $10000000,(%rcx)
	lock xacquire xorq $10000000,(%rcx)
	xrelease lock xorq $10000000,(%rcx)
	lock xrelease xorq $10000000,(%rcx)
	.byte 0xf0; .byte 0xf2; xorq $10000000,(%rcx)
	.byte 0xf0; .byte 0xf3; xorq $10000000,(%rcx)

# Tests for op imm8 regs/m16
	xacquire lock adcw $100,(%rcx)
	lock xacquire adcw $100,(%rcx)
	xrelease lock adcw $100,(%rcx)
	lock xrelease adcw $100,(%rcx)
	.byte 0xf0; .byte 0xf2; adcw $100,(%rcx)
	.byte 0xf0; .byte 0xf3; adcw $100,(%rcx)
	xacquire lock addw $100,(%rcx)
	lock xacquire addw $100,(%rcx)
	xrelease lock addw $100,(%rcx)
	lock xrelease addw $100,(%rcx)
	.byte 0xf0; .byte 0xf2; addw $100,(%rcx)
	.byte 0xf0; .byte 0xf3; addw $100,(%rcx)
	xacquire lock andw $100,(%rcx)
	lock xacquire andw $100,(%rcx)
	xrelease lock andw $100,(%rcx)
	lock xrelease andw $100,(%rcx)
	.byte 0xf0; .byte 0xf2; andw $100,(%rcx)
	.byte 0xf0; .byte 0xf3; andw $100,(%rcx)
	xacquire lock btcw $100,(%rcx)
	lock xacquire btcw $100,(%rcx)
	xrelease lock btcw $100,(%rcx)
	lock xrelease btcw $100,(%rcx)
	.byte 0xf0; .byte 0xf2; btcw $100,(%rcx)
	.byte 0xf0; .byte 0xf3; btcw $100,(%rcx)
	xacquire lock btrw $100,(%rcx)
	lock xacquire btrw $100,(%rcx)
	xrelease lock btrw $100,(%rcx)
	lock xrelease btrw $100,(%rcx)
	.byte 0xf0; .byte 0xf2; btrw $100,(%rcx)
	.byte 0xf0; .byte 0xf3; btrw $100,(%rcx)
	xacquire lock btsw $100,(%rcx)
	lock xacquire btsw $100,(%rcx)
	xrelease lock btsw $100,(%rcx)
	lock xrelease btsw $100,(%rcx)
	.byte 0xf0; .byte 0xf2; btsw $100,(%rcx)
	.byte 0xf0; .byte 0xf3; btsw $100,(%rcx)
	xrelease movw $100,(%rcx)
	xacquire lock orw $100,(%rcx)
	lock xacquire orw $100,(%rcx)
	xrelease lock orw $100,(%rcx)
	lock xrelease orw $100,(%rcx)
	.byte 0xf0; .byte 0xf2; orw $100,(%rcx)
	.byte 0xf0; .byte 0xf3; orw $100,(%rcx)
	xacquire lock sbbw $100,(%rcx)
	lock xacquire sbbw $100,(%rcx)
	xrelease lock sbbw $100,(%rcx)
	lock xrelease sbbw $100,(%rcx)
	.byte 0xf0; .byte 0xf2; sbbw $100,(%rcx)
	.byte 0xf0; .byte 0xf3; sbbw $100,(%rcx)
	xacquire lock subw $100,(%rcx)
	lock xacquire subw $100,(%rcx)
	xrelease lock subw $100,(%rcx)
	lock xrelease subw $100,(%rcx)
	.byte 0xf0; .byte 0xf2; subw $100,(%rcx)
	.byte 0xf0; .byte 0xf3; subw $100,(%rcx)
	xacquire lock xorw $100,(%rcx)
	lock xacquire xorw $100,(%rcx)
	xrelease lock xorw $100,(%rcx)
	lock xrelease xorw $100,(%rcx)
	.byte 0xf0; .byte 0xf2; xorw $100,(%rcx)
	.byte 0xf0; .byte 0xf3; xorw $100,(%rcx)

# Tests for op imm8 regl/m32
	xacquire lock adcl $100,(%rcx)
	lock xacquire adcl $100,(%rcx)
	xrelease lock adcl $100,(%rcx)
	lock xrelease adcl $100,(%rcx)
	.byte 0xf0; .byte 0xf2; adcl $100,(%rcx)
	.byte 0xf0; .byte 0xf3; adcl $100,(%rcx)
	xacquire lock addl $100,(%rcx)
	lock xacquire addl $100,(%rcx)
	xrelease lock addl $100,(%rcx)
	lock xrelease addl $100,(%rcx)
	.byte 0xf0; .byte 0xf2; addl $100,(%rcx)
	.byte 0xf0; .byte 0xf3; addl $100,(%rcx)
	xacquire lock andl $100,(%rcx)
	lock xacquire andl $100,(%rcx)
	xrelease lock andl $100,(%rcx)
	lock xrelease andl $100,(%rcx)
	.byte 0xf0; .byte 0xf2; andl $100,(%rcx)
	.byte 0xf0; .byte 0xf3; andl $100,(%rcx)
	xacquire lock btcl $100,(%rcx)
	lock xacquire btcl $100,(%rcx)
	xrelease lock btcl $100,(%rcx)
	lock xrelease btcl $100,(%rcx)
	.byte 0xf0; .byte 0xf2; btcl $100,(%rcx)
	.byte 0xf0; .byte 0xf3; btcl $100,(%rcx)
	xacquire lock btrl $100,(%rcx)
	lock xacquire btrl $100,(%rcx)
	xrelease lock btrl $100,(%rcx)
	lock xrelease btrl $100,(%rcx)
	.byte 0xf0; .byte 0xf2; btrl $100,(%rcx)
	.byte 0xf0; .byte 0xf3; btrl $100,(%rcx)
	xacquire lock btsl $100,(%rcx)
	lock xacquire btsl $100,(%rcx)
	xrelease lock btsl $100,(%rcx)
	lock xrelease btsl $100,(%rcx)
	.byte 0xf0; .byte 0xf2; btsl $100,(%rcx)
	.byte 0xf0; .byte 0xf3; btsl $100,(%rcx)
	xrelease movl $100,(%rcx)
	xacquire lock orl $100,(%rcx)
	lock xacquire orl $100,(%rcx)
	xrelease lock orl $100,(%rcx)
	lock xrelease orl $100,(%rcx)
	.byte 0xf0; .byte 0xf2; orl $100,(%rcx)
	.byte 0xf0; .byte 0xf3; orl $100,(%rcx)
	xacquire lock sbbl $100,(%rcx)
	lock xacquire sbbl $100,(%rcx)
	xrelease lock sbbl $100,(%rcx)
	lock xrelease sbbl $100,(%rcx)
	.byte 0xf0; .byte 0xf2; sbbl $100,(%rcx)
	.byte 0xf0; .byte 0xf3; sbbl $100,(%rcx)
	xacquire lock subl $100,(%rcx)
	lock xacquire subl $100,(%rcx)
	xrelease lock subl $100,(%rcx)
	lock xrelease subl $100,(%rcx)
	.byte 0xf0; .byte 0xf2; subl $100,(%rcx)
	.byte 0xf0; .byte 0xf3; subl $100,(%rcx)
	xacquire lock xorl $100,(%rcx)
	lock xacquire xorl $100,(%rcx)
	xrelease lock xorl $100,(%rcx)
	lock xrelease xorl $100,(%rcx)
	.byte 0xf0; .byte 0xf2; xorl $100,(%rcx)
	.byte 0xf0; .byte 0xf3; xorl $100,(%rcx)

# Tests for op imm8 regq/m64
	xacquire lock adcq $100,(%rcx)
	lock xacquire adcq $100,(%rcx)
	xrelease lock adcq $100,(%rcx)
	lock xrelease adcq $100,(%rcx)
	.byte 0xf0; .byte 0xf2; adcq $100,(%rcx)
	.byte 0xf0; .byte 0xf3; adcq $100,(%rcx)
	xacquire lock addq $100,(%rcx)
	lock xacquire addq $100,(%rcx)
	xrelease lock addq $100,(%rcx)
	lock xrelease addq $100,(%rcx)
	.byte 0xf0; .byte 0xf2; addq $100,(%rcx)
	.byte 0xf0; .byte 0xf3; addq $100,(%rcx)
	xacquire lock andq $100,(%rcx)
	lock xacquire andq $100,(%rcx)
	xrelease lock andq $100,(%rcx)
	lock xrelease andq $100,(%rcx)
	.byte 0xf0; .byte 0xf2; andq $100,(%rcx)
	.byte 0xf0; .byte 0xf3; andq $100,(%rcx)
	xacquire lock btcq $100,(%rcx)
	lock xacquire btcq $100,(%rcx)
	xrelease lock btcq $100,(%rcx)
	lock xrelease btcq $100,(%rcx)
	.byte 0xf0; .byte 0xf2; btcq $100,(%rcx)
	.byte 0xf0; .byte 0xf3; btcq $100,(%rcx)
	xacquire lock btrq $100,(%rcx)
	lock xacquire btrq $100,(%rcx)
	xrelease lock btrq $100,(%rcx)
	lock xrelease btrq $100,(%rcx)
	.byte 0xf0; .byte 0xf2; btrq $100,(%rcx)
	.byte 0xf0; .byte 0xf3; btrq $100,(%rcx)
	xacquire lock btsq $100,(%rcx)
	lock xacquire btsq $100,(%rcx)
	xrelease lock btsq $100,(%rcx)
	lock xrelease btsq $100,(%rcx)
	.byte 0xf0; .byte 0xf2; btsq $100,(%rcx)
	.byte 0xf0; .byte 0xf3; btsq $100,(%rcx)
	xrelease movq $100,(%rcx)
	xacquire lock orq $100,(%rcx)
	lock xacquire orq $100,(%rcx)
	xrelease lock orq $100,(%rcx)
	lock xrelease orq $100,(%rcx)
	.byte 0xf0; .byte 0xf2; orq $100,(%rcx)
	.byte 0xf0; .byte 0xf3; orq $100,(%rcx)
	xacquire lock sbbq $100,(%rcx)
	lock xacquire sbbq $100,(%rcx)
	xrelease lock sbbq $100,(%rcx)
	lock xrelease sbbq $100,(%rcx)
	.byte 0xf0; .byte 0xf2; sbbq $100,(%rcx)
	.byte 0xf0; .byte 0xf3; sbbq $100,(%rcx)
	xacquire lock subq $100,(%rcx)
	lock xacquire subq $100,(%rcx)
	xrelease lock subq $100,(%rcx)
	lock xrelease subq $100,(%rcx)
	.byte 0xf0; .byte 0xf2; subq $100,(%rcx)
	.byte 0xf0; .byte 0xf3; subq $100,(%rcx)
	xacquire lock xorq $100,(%rcx)
	lock xacquire xorq $100,(%rcx)
	xrelease lock xorq $100,(%rcx)
	lock xrelease xorq $100,(%rcx)
	.byte 0xf0; .byte 0xf2; xorq $100,(%rcx)
	.byte 0xf0; .byte 0xf3; xorq $100,(%rcx)

# Tests for op imm8 regb/m8
	xacquire lock adcb $100,(%rcx)
	lock xacquire adcb $100,(%rcx)
	xrelease lock adcb $100,(%rcx)
	lock xrelease adcb $100,(%rcx)
	.byte 0xf0; .byte 0xf2; adcb $100,(%rcx)
	.byte 0xf0; .byte 0xf3; adcb $100,(%rcx)
	xacquire lock addb $100,(%rcx)
	lock xacquire addb $100,(%rcx)
	xrelease lock addb $100,(%rcx)
	lock xrelease addb $100,(%rcx)
	.byte 0xf0; .byte 0xf2; addb $100,(%rcx)
	.byte 0xf0; .byte 0xf3; addb $100,(%rcx)
	xacquire lock andb $100,(%rcx)
	lock xacquire andb $100,(%rcx)
	xrelease lock andb $100,(%rcx)
	lock xrelease andb $100,(%rcx)
	.byte 0xf0; .byte 0xf2; andb $100,(%rcx)
	.byte 0xf0; .byte 0xf3; andb $100,(%rcx)
	xrelease movb $100,(%rcx)
	xacquire lock orb $100,(%rcx)
	lock xacquire orb $100,(%rcx)
	xrelease lock orb $100,(%rcx)
	lock xrelease orb $100,(%rcx)
	.byte 0xf0; .byte 0xf2; orb $100,(%rcx)
	.byte 0xf0; .byte 0xf3; orb $100,(%rcx)
	xacquire lock sbbb $100,(%rcx)
	lock xacquire sbbb $100,(%rcx)
	xrelease lock sbbb $100,(%rcx)
	lock xrelease sbbb $100,(%rcx)
	.byte 0xf0; .byte 0xf2; sbbb $100,(%rcx)
	.byte 0xf0; .byte 0xf3; sbbb $100,(%rcx)
	xacquire lock subb $100,(%rcx)
	lock xacquire subb $100,(%rcx)
	xrelease lock subb $100,(%rcx)
	lock xrelease subb $100,(%rcx)
	.byte 0xf0; .byte 0xf2; subb $100,(%rcx)
	.byte 0xf0; .byte 0xf3; subb $100,(%rcx)
	xacquire lock xorb $100,(%rcx)
	lock xacquire xorb $100,(%rcx)
	xrelease lock xorb $100,(%rcx)
	lock xrelease xorb $100,(%rcx)
	.byte 0xf0; .byte 0xf2; xorb $100,(%rcx)
	.byte 0xf0; .byte 0xf3; xorb $100,(%rcx)

# Tests for op regb regb/m8
# Tests for op regb/m8 regb
	xacquire lock adcb %al,(%rcx)
	lock xacquire adcb %al,(%rcx)
	xrelease lock adcb %al,(%rcx)
	lock xrelease adcb %al,(%rcx)
	.byte 0xf0; .byte 0xf2; adcb %al,(%rcx)
	.byte 0xf0; .byte 0xf3; adcb %al,(%rcx)
	xacquire lock addb %al,(%rcx)
	lock xacquire addb %al,(%rcx)
	xrelease lock addb %al,(%rcx)
	lock xrelease addb %al,(%rcx)
	.byte 0xf0; .byte 0xf2; addb %al,(%rcx)
	.byte 0xf0; .byte 0xf3; addb %al,(%rcx)
	xacquire lock andb %al,(%rcx)
	lock xacquire andb %al,(%rcx)
	xrelease lock andb %al,(%rcx)
	lock xrelease andb %al,(%rcx)
	.byte 0xf0; .byte 0xf2; andb %al,(%rcx)
	.byte 0xf0; .byte 0xf3; andb %al,(%rcx)
	xrelease movb %al,(%rcx)
	xacquire lock orb %al,(%rcx)
	lock xacquire orb %al,(%rcx)
	xrelease lock orb %al,(%rcx)
	lock xrelease orb %al,(%rcx)
	.byte 0xf0; .byte 0xf2; orb %al,(%rcx)
	.byte 0xf0; .byte 0xf3; orb %al,(%rcx)
	xacquire lock sbbb %al,(%rcx)
	lock xacquire sbbb %al,(%rcx)
	xrelease lock sbbb %al,(%rcx)
	lock xrelease sbbb %al,(%rcx)
	.byte 0xf0; .byte 0xf2; sbbb %al,(%rcx)
	.byte 0xf0; .byte 0xf3; sbbb %al,(%rcx)
	xacquire lock subb %al,(%rcx)
	lock xacquire subb %al,(%rcx)
	xrelease lock subb %al,(%rcx)
	lock xrelease subb %al,(%rcx)
	.byte 0xf0; .byte 0xf2; subb %al,(%rcx)
	.byte 0xf0; .byte 0xf3; subb %al,(%rcx)
	xacquire lock xchgb %al,(%rcx)
	lock xacquire xchgb %al,(%rcx)
	xacquire xchgb %al,(%rcx)
	xrelease lock xchgb %al,(%rcx)
	lock xrelease xchgb %al,(%rcx)
	xrelease xchgb %al,(%rcx)
	.byte 0xf0; .byte 0xf2; xchgb %al,(%rcx)
	.byte 0xf0; .byte 0xf3; xchgb %al,(%rcx)
	xacquire lock xorb %al,(%rcx)
	lock xacquire xorb %al,(%rcx)
	xrelease lock xorb %al,(%rcx)
	lock xrelease xorb %al,(%rcx)
	.byte 0xf0; .byte 0xf2; xorb %al,(%rcx)
	.byte 0xf0; .byte 0xf3; xorb %al,(%rcx)

# Tests for op regs regs/m16
# Tests for op regs/m16 regs
	xacquire lock adcw %ax,(%rcx)
	lock xacquire adcw %ax,(%rcx)
	xrelease lock adcw %ax,(%rcx)
	lock xrelease adcw %ax,(%rcx)
	.byte 0xf0; .byte 0xf2; adcw %ax,(%rcx)
	.byte 0xf0; .byte 0xf3; adcw %ax,(%rcx)
	xacquire lock addw %ax,(%rcx)
	lock xacquire addw %ax,(%rcx)
	xrelease lock addw %ax,(%rcx)
	lock xrelease addw %ax,(%rcx)
	.byte 0xf0; .byte 0xf2; addw %ax,(%rcx)
	.byte 0xf0; .byte 0xf3; addw %ax,(%rcx)
	xacquire lock andw %ax,(%rcx)
	lock xacquire andw %ax,(%rcx)
	xrelease lock andw %ax,(%rcx)
	lock xrelease andw %ax,(%rcx)
	.byte 0xf0; .byte 0xf2; andw %ax,(%rcx)
	.byte 0xf0; .byte 0xf3; andw %ax,(%rcx)
	xrelease movw %ax,(%rcx)
	xacquire lock orw %ax,(%rcx)
	lock xacquire orw %ax,(%rcx)
	xrelease lock orw %ax,(%rcx)
	lock xrelease orw %ax,(%rcx)
	.byte 0xf0; .byte 0xf2; orw %ax,(%rcx)
	.byte 0xf0; .byte 0xf3; orw %ax,(%rcx)
	xacquire lock sbbw %ax,(%rcx)
	lock xacquire sbbw %ax,(%rcx)
	xrelease lock sbbw %ax,(%rcx)
	lock xrelease sbbw %ax,(%rcx)
	.byte 0xf0; .byte 0xf2; sbbw %ax,(%rcx)
	.byte 0xf0; .byte 0xf3; sbbw %ax,(%rcx)
	xacquire lock subw %ax,(%rcx)
	lock xacquire subw %ax,(%rcx)
	xrelease lock subw %ax,(%rcx)
	lock xrelease subw %ax,(%rcx)
	.byte 0xf0; .byte 0xf2; subw %ax,(%rcx)
	.byte 0xf0; .byte 0xf3; subw %ax,(%rcx)
	xacquire lock xchgw %ax,(%rcx)
	lock xacquire xchgw %ax,(%rcx)
	xacquire xchgw %ax,(%rcx)
	xrelease lock xchgw %ax,(%rcx)
	lock xrelease xchgw %ax,(%rcx)
	xrelease xchgw %ax,(%rcx)
	.byte 0xf0; .byte 0xf2; xchgw %ax,(%rcx)
	.byte 0xf0; .byte 0xf3; xchgw %ax,(%rcx)
	xacquire lock xorw %ax,(%rcx)
	lock xacquire xorw %ax,(%rcx)
	xrelease lock xorw %ax,(%rcx)
	lock xrelease xorw %ax,(%rcx)
	.byte 0xf0; .byte 0xf2; xorw %ax,(%rcx)
	.byte 0xf0; .byte 0xf3; xorw %ax,(%rcx)

# Tests for op regl regl/m32
# Tests for op regl/m32 regl
	xacquire lock adcl %eax,(%rcx)
	lock xacquire adcl %eax,(%rcx)
	xrelease lock adcl %eax,(%rcx)
	lock xrelease adcl %eax,(%rcx)
	.byte 0xf0; .byte 0xf2; adcl %eax,(%rcx)
	.byte 0xf0; .byte 0xf3; adcl %eax,(%rcx)
	xacquire lock addl %eax,(%rcx)
	lock xacquire addl %eax,(%rcx)
	xrelease lock addl %eax,(%rcx)
	lock xrelease addl %eax,(%rcx)
	.byte 0xf0; .byte 0xf2; addl %eax,(%rcx)
	.byte 0xf0; .byte 0xf3; addl %eax,(%rcx)
	xacquire lock andl %eax,(%rcx)
	lock xacquire andl %eax,(%rcx)
	xrelease lock andl %eax,(%rcx)
	lock xrelease andl %eax,(%rcx)
	.byte 0xf0; .byte 0xf2; andl %eax,(%rcx)
	.byte 0xf0; .byte 0xf3; andl %eax,(%rcx)
	xrelease movl %eax,(%rcx)
	xacquire lock orl %eax,(%rcx)
	lock xacquire orl %eax,(%rcx)
	xrelease lock orl %eax,(%rcx)
	lock xrelease orl %eax,(%rcx)
	.byte 0xf0; .byte 0xf2; orl %eax,(%rcx)
	.byte 0xf0; .byte 0xf3; orl %eax,(%rcx)
	xacquire lock sbbl %eax,(%rcx)
	lock xacquire sbbl %eax,(%rcx)
	xrelease lock sbbl %eax,(%rcx)
	lock xrelease sbbl %eax,(%rcx)
	.byte 0xf0; .byte 0xf2; sbbl %eax,(%rcx)
	.byte 0xf0; .byte 0xf3; sbbl %eax,(%rcx)
	xacquire lock subl %eax,(%rcx)
	lock xacquire subl %eax,(%rcx)
	xrelease lock subl %eax,(%rcx)
	lock xrelease subl %eax,(%rcx)
	.byte 0xf0; .byte 0xf2; subl %eax,(%rcx)
	.byte 0xf0; .byte 0xf3; subl %eax,(%rcx)
	xacquire lock xchgl %eax,(%rcx)
	lock xacquire xchgl %eax,(%rcx)
	xacquire xchgl %eax,(%rcx)
	xrelease lock xchgl %eax,(%rcx)
	lock xrelease xchgl %eax,(%rcx)
	xrelease xchgl %eax,(%rcx)
	.byte 0xf0; .byte 0xf2; xchgl %eax,(%rcx)
	.byte 0xf0; .byte 0xf3; xchgl %eax,(%rcx)
	xacquire lock xorl %eax,(%rcx)
	lock xacquire xorl %eax,(%rcx)
	xrelease lock xorl %eax,(%rcx)
	lock xrelease xorl %eax,(%rcx)
	.byte 0xf0; .byte 0xf2; xorl %eax,(%rcx)
	.byte 0xf0; .byte 0xf3; xorl %eax,(%rcx)

# Tests for op regq regq/m64
# Tests for op regq/m64 regq
	xacquire lock adcq %rax,(%rcx)
	lock xacquire adcq %rax,(%rcx)
	xrelease lock adcq %rax,(%rcx)
	lock xrelease adcq %rax,(%rcx)
	.byte 0xf0; .byte 0xf2; adcq %rax,(%rcx)
	.byte 0xf0; .byte 0xf3; adcq %rax,(%rcx)
	xacquire lock addq %rax,(%rcx)
	lock xacquire addq %rax,(%rcx)
	xrelease lock addq %rax,(%rcx)
	lock xrelease addq %rax,(%rcx)
	.byte 0xf0; .byte 0xf2; addq %rax,(%rcx)
	.byte 0xf0; .byte 0xf3; addq %rax,(%rcx)
	xacquire lock andq %rax,(%rcx)
	lock xacquire andq %rax,(%rcx)
	xrelease lock andq %rax,(%rcx)
	lock xrelease andq %rax,(%rcx)
	.byte 0xf0; .byte 0xf2; andq %rax,(%rcx)
	.byte 0xf0; .byte 0xf3; andq %rax,(%rcx)
	xrelease movq %rax,(%rcx)
	xacquire lock orq %rax,(%rcx)
	lock xacquire orq %rax,(%rcx)
	xrelease lock orq %rax,(%rcx)
	lock xrelease orq %rax,(%rcx)
	.byte 0xf0; .byte 0xf2; orq %rax,(%rcx)
	.byte 0xf0; .byte 0xf3; orq %rax,(%rcx)
	xacquire lock sbbq %rax,(%rcx)
	lock xacquire sbbq %rax,(%rcx)
	xrelease lock sbbq %rax,(%rcx)
	lock xrelease sbbq %rax,(%rcx)
	.byte 0xf0; .byte 0xf2; sbbq %rax,(%rcx)
	.byte 0xf0; .byte 0xf3; sbbq %rax,(%rcx)
	xacquire lock subq %rax,(%rcx)
	lock xacquire subq %rax,(%rcx)
	xrelease lock subq %rax,(%rcx)
	lock xrelease subq %rax,(%rcx)
	.byte 0xf0; .byte 0xf2; subq %rax,(%rcx)
	.byte 0xf0; .byte 0xf3; subq %rax,(%rcx)
	xacquire lock xchgq %rax,(%rcx)
	lock xacquire xchgq %rax,(%rcx)
	xacquire xchgq %rax,(%rcx)
	xrelease lock xchgq %rax,(%rcx)
	lock xrelease xchgq %rax,(%rcx)
	xrelease xchgq %rax,(%rcx)
	.byte 0xf0; .byte 0xf2; xchgq %rax,(%rcx)
	.byte 0xf0; .byte 0xf3; xchgq %rax,(%rcx)
	xacquire lock xorq %rax,(%rcx)
	lock xacquire xorq %rax,(%rcx)
	xrelease lock xorq %rax,(%rcx)
	lock xrelease xorq %rax,(%rcx)
	.byte 0xf0; .byte 0xf2; xorq %rax,(%rcx)
	.byte 0xf0; .byte 0xf3; xorq %rax,(%rcx)

# Tests for op regs, regs/m16
	xacquire lock btcw %ax,(%rcx)
	lock xacquire btcw %ax,(%rcx)
	xrelease lock btcw %ax,(%rcx)
	lock xrelease btcw %ax,(%rcx)
	.byte 0xf0; .byte 0xf2; btcw %ax,(%rcx)
	.byte 0xf0; .byte 0xf3; btcw %ax,(%rcx)
	xacquire lock btrw %ax,(%rcx)
	lock xacquire btrw %ax,(%rcx)
	xrelease lock btrw %ax,(%rcx)
	lock xrelease btrw %ax,(%rcx)
	.byte 0xf0; .byte 0xf2; btrw %ax,(%rcx)
	.byte 0xf0; .byte 0xf3; btrw %ax,(%rcx)
	xacquire lock btsw %ax,(%rcx)
	lock xacquire btsw %ax,(%rcx)
	xrelease lock btsw %ax,(%rcx)
	lock xrelease btsw %ax,(%rcx)
	.byte 0xf0; .byte 0xf2; btsw %ax,(%rcx)
	.byte 0xf0; .byte 0xf3; btsw %ax,(%rcx)
	xacquire lock cmpxchgw %ax,(%rcx)
	lock xacquire cmpxchgw %ax,(%rcx)
	xrelease lock cmpxchgw %ax,(%rcx)
	lock xrelease cmpxchgw %ax,(%rcx)
	.byte 0xf0; .byte 0xf2; cmpxchgw %ax,(%rcx)
	.byte 0xf0; .byte 0xf3; cmpxchgw %ax,(%rcx)
	xacquire lock xaddw %ax,(%rcx)
	lock xacquire xaddw %ax,(%rcx)
	xrelease lock xaddw %ax,(%rcx)
	lock xrelease xaddw %ax,(%rcx)
	.byte 0xf0; .byte 0xf2; xaddw %ax,(%rcx)
	.byte 0xf0; .byte 0xf3; xaddw %ax,(%rcx)

# Tests for op regl regl/m32
	xacquire lock btcl %eax,(%rcx)
	lock xacquire btcl %eax,(%rcx)
	xrelease lock btcl %eax,(%rcx)
	lock xrelease btcl %eax,(%rcx)
	.byte 0xf0; .byte 0xf2; btcl %eax,(%rcx)
	.byte 0xf0; .byte 0xf3; btcl %eax,(%rcx)
	xacquire lock btrl %eax,(%rcx)
	lock xacquire btrl %eax,(%rcx)
	xrelease lock btrl %eax,(%rcx)
	lock xrelease btrl %eax,(%rcx)
	.byte 0xf0; .byte 0xf2; btrl %eax,(%rcx)
	.byte 0xf0; .byte 0xf3; btrl %eax,(%rcx)
	xacquire lock btsl %eax,(%rcx)
	lock xacquire btsl %eax,(%rcx)
	xrelease lock btsl %eax,(%rcx)
	lock xrelease btsl %eax,(%rcx)
	.byte 0xf0; .byte 0xf2; btsl %eax,(%rcx)
	.byte 0xf0; .byte 0xf3; btsl %eax,(%rcx)
	xacquire lock cmpxchgl %eax,(%rcx)
	lock xacquire cmpxchgl %eax,(%rcx)
	xrelease lock cmpxchgl %eax,(%rcx)
	lock xrelease cmpxchgl %eax,(%rcx)
	.byte 0xf0; .byte 0xf2; cmpxchgl %eax,(%rcx)
	.byte 0xf0; .byte 0xf3; cmpxchgl %eax,(%rcx)
	xacquire lock xaddl %eax,(%rcx)
	lock xacquire xaddl %eax,(%rcx)
	xrelease lock xaddl %eax,(%rcx)
	lock xrelease xaddl %eax,(%rcx)
	.byte 0xf0; .byte 0xf2; xaddl %eax,(%rcx)
	.byte 0xf0; .byte 0xf3; xaddl %eax,(%rcx)

# Tests for op regq regq/m64
	xacquire lock btcq %rax,(%rcx)
	lock xacquire btcq %rax,(%rcx)
	xrelease lock btcq %rax,(%rcx)
	lock xrelease btcq %rax,(%rcx)
	.byte 0xf0; .byte 0xf2; btcq %rax,(%rcx)
	.byte 0xf0; .byte 0xf3; btcq %rax,(%rcx)
	xacquire lock btrq %rax,(%rcx)
	lock xacquire btrq %rax,(%rcx)
	xrelease lock btrq %rax,(%rcx)
	lock xrelease btrq %rax,(%rcx)
	.byte 0xf0; .byte 0xf2; btrq %rax,(%rcx)
	.byte 0xf0; .byte 0xf3; btrq %rax,(%rcx)
	xacquire lock btsq %rax,(%rcx)
	lock xacquire btsq %rax,(%rcx)
	xrelease lock btsq %rax,(%rcx)
	lock xrelease btsq %rax,(%rcx)
	.byte 0xf0; .byte 0xf2; btsq %rax,(%rcx)
	.byte 0xf0; .byte 0xf3; btsq %rax,(%rcx)
	xacquire lock cmpxchgq %rax,(%rcx)
	lock xacquire cmpxchgq %rax,(%rcx)
	xrelease lock cmpxchgq %rax,(%rcx)
	lock xrelease cmpxchgq %rax,(%rcx)
	.byte 0xf0; .byte 0xf2; cmpxchgq %rax,(%rcx)
	.byte 0xf0; .byte 0xf3; cmpxchgq %rax,(%rcx)
	xacquire lock xaddq %rax,(%rcx)
	lock xacquire xaddq %rax,(%rcx)
	xrelease lock xaddq %rax,(%rcx)
	lock xrelease xaddq %rax,(%rcx)
	.byte 0xf0; .byte 0xf2; xaddq %rax,(%rcx)
	.byte 0xf0; .byte 0xf3; xaddq %rax,(%rcx)

# Tests for op regb/m8
	xacquire lock decb (%rcx)
	lock xacquire decb (%rcx)
	xrelease lock decb (%rcx)
	lock xrelease decb (%rcx)
	.byte 0xf0; .byte 0xf2; decb (%rcx)
	.byte 0xf0; .byte 0xf3; decb (%rcx)
	xacquire lock incb (%rcx)
	lock xacquire incb (%rcx)
	xrelease lock incb (%rcx)
	lock xrelease incb (%rcx)
	.byte 0xf0; .byte 0xf2; incb (%rcx)
	.byte 0xf0; .byte 0xf3; incb (%rcx)
	xacquire lock negb (%rcx)
	lock xacquire negb (%rcx)
	xrelease lock negb (%rcx)
	lock xrelease negb (%rcx)
	.byte 0xf0; .byte 0xf2; negb (%rcx)
	.byte 0xf0; .byte 0xf3; negb (%rcx)
	xacquire lock notb (%rcx)
	lock xacquire notb (%rcx)
	xrelease lock notb (%rcx)
	lock xrelease notb (%rcx)
	.byte 0xf0; .byte 0xf2; notb (%rcx)
	.byte 0xf0; .byte 0xf3; notb (%rcx)

# Tests for op regs/m16
	xacquire lock decw (%rcx)
	lock xacquire decw (%rcx)
	xrelease lock decw (%rcx)
	lock xrelease decw (%rcx)
	.byte 0xf0; .byte 0xf2; decw (%rcx)
	.byte 0xf0; .byte 0xf3; decw (%rcx)
	xacquire lock incw (%rcx)
	lock xacquire incw (%rcx)
	xrelease lock incw (%rcx)
	lock xrelease incw (%rcx)
	.byte 0xf0; .byte 0xf2; incw (%rcx)
	.byte 0xf0; .byte 0xf3; incw (%rcx)
	xacquire lock negw (%rcx)
	lock xacquire negw (%rcx)
	xrelease lock negw (%rcx)
	lock xrelease negw (%rcx)
	.byte 0xf0; .byte 0xf2; negw (%rcx)
	.byte 0xf0; .byte 0xf3; negw (%rcx)
	xacquire lock notw (%rcx)
	lock xacquire notw (%rcx)
	xrelease lock notw (%rcx)
	lock xrelease notw (%rcx)
	.byte 0xf0; .byte 0xf2; notw (%rcx)
	.byte 0xf0; .byte 0xf3; notw (%rcx)

# Tests for op regl/m32
	xacquire lock decl (%rcx)
	lock xacquire decl (%rcx)
	xrelease lock decl (%rcx)
	lock xrelease decl (%rcx)
	.byte 0xf0; .byte 0xf2; decl (%rcx)
	.byte 0xf0; .byte 0xf3; decl (%rcx)
	xacquire lock incl (%rcx)
	lock xacquire incl (%rcx)
	xrelease lock incl (%rcx)
	lock xrelease incl (%rcx)
	.byte 0xf0; .byte 0xf2; incl (%rcx)
	.byte 0xf0; .byte 0xf3; incl (%rcx)
	xacquire lock negl (%rcx)
	lock xacquire negl (%rcx)
	xrelease lock negl (%rcx)
	lock xrelease negl (%rcx)
	.byte 0xf0; .byte 0xf2; negl (%rcx)
	.byte 0xf0; .byte 0xf3; negl (%rcx)
	xacquire lock notl (%rcx)
	lock xacquire notl (%rcx)
	xrelease lock notl (%rcx)
	lock xrelease notl (%rcx)
	.byte 0xf0; .byte 0xf2; notl (%rcx)
	.byte 0xf0; .byte 0xf3; notl (%rcx)

# Tests for op regq/m64
	xacquire lock decq (%rcx)
	lock xacquire decq (%rcx)
	xrelease lock decq (%rcx)
	lock xrelease decq (%rcx)
	.byte 0xf0; .byte 0xf2; decq (%rcx)
	.byte 0xf0; .byte 0xf3; decq (%rcx)
	xacquire lock incq (%rcx)
	lock xacquire incq (%rcx)
	xrelease lock incq (%rcx)
	lock xrelease incq (%rcx)
	.byte 0xf0; .byte 0xf2; incq (%rcx)
	.byte 0xf0; .byte 0xf3; incq (%rcx)
	xacquire lock negq (%rcx)
	lock xacquire negq (%rcx)
	xrelease lock negq (%rcx)
	lock xrelease negq (%rcx)
	.byte 0xf0; .byte 0xf2; negq (%rcx)
	.byte 0xf0; .byte 0xf3; negq (%rcx)
	xacquire lock notq (%rcx)
	lock xacquire notq (%rcx)
	xrelease lock notq (%rcx)
	lock xrelease notq (%rcx)
	.byte 0xf0; .byte 0xf2; notq (%rcx)
	.byte 0xf0; .byte 0xf3; notq (%rcx)

# Tests for op m64
	xacquire lock cmpxchg8bq (%rcx)
	lock xacquire cmpxchg8bq (%rcx)
	xrelease lock cmpxchg8bq (%rcx)
	lock xrelease cmpxchg8bq (%rcx)
	.byte 0xf0; .byte 0xf2; cmpxchg8bq (%rcx)
	.byte 0xf0; .byte 0xf3; cmpxchg8bq (%rcx)

# Tests for op regb, regb/m8
	xacquire lock cmpxchgb %cl,(%rcx)
	lock xacquire cmpxchgb %cl,(%rcx)
	xrelease lock cmpxchgb %cl,(%rcx)
	lock xrelease cmpxchgb %cl,(%rcx)
	.byte 0xf0; .byte 0xf2; cmpxchgb %cl,(%rcx)
	.byte 0xf0; .byte 0xf3; cmpxchgb %cl,(%rcx)
	xacquire lock xaddb %cl,(%rcx)
	lock xacquire xaddb %cl,(%rcx)
	xrelease lock xaddb %cl,(%rcx)
	lock xrelease xaddb %cl,(%rcx)
	.byte 0xf0; .byte 0xf2; xaddb %cl,(%rcx)
	.byte 0xf0; .byte 0xf3; xaddb %cl,(%rcx)

	.intel_syntax noprefix


# Tests for op imm32 rax

# Tests for op imm8 regb/m8
	xacquire lock adc BYTE PTR [rcx],100
	lock xacquire adc BYTE PTR [rcx],100
	xrelease lock adc BYTE PTR [rcx],100
	lock xrelease adc BYTE PTR [rcx],100
	.byte 0xf0; .byte 0xf2; adc BYTE PTR [rcx],100
	.byte 0xf0; .byte 0xf3; adc BYTE PTR [rcx],100
	xacquire lock add BYTE PTR [rcx],100
	lock xacquire add BYTE PTR [rcx],100
	xrelease lock add BYTE PTR [rcx],100
	lock xrelease add BYTE PTR [rcx],100
	.byte 0xf0; .byte 0xf2; add BYTE PTR [rcx],100
	.byte 0xf0; .byte 0xf3; add BYTE PTR [rcx],100
	xacquire lock and BYTE PTR [rcx],100
	lock xacquire and BYTE PTR [rcx],100
	xrelease lock and BYTE PTR [rcx],100
	lock xrelease and BYTE PTR [rcx],100
	.byte 0xf0; .byte 0xf2; and BYTE PTR [rcx],100
	.byte 0xf0; .byte 0xf3; and BYTE PTR [rcx],100
	xrelease mov BYTE PTR [rcx],100
	xacquire lock or BYTE PTR [rcx],100
	lock xacquire or BYTE PTR [rcx],100
	xrelease lock or BYTE PTR [rcx],100
	lock xrelease or BYTE PTR [rcx],100
	.byte 0xf0; .byte 0xf2; or BYTE PTR [rcx],100
	.byte 0xf0; .byte 0xf3; or BYTE PTR [rcx],100
	xacquire lock sbb BYTE PTR [rcx],100
	lock xacquire sbb BYTE PTR [rcx],100
	xrelease lock sbb BYTE PTR [rcx],100
	lock xrelease sbb BYTE PTR [rcx],100
	.byte 0xf0; .byte 0xf2; sbb BYTE PTR [rcx],100
	.byte 0xf0; .byte 0xf3; sbb BYTE PTR [rcx],100
	xacquire lock sub BYTE PTR [rcx],100
	lock xacquire sub BYTE PTR [rcx],100
	xrelease lock sub BYTE PTR [rcx],100
	lock xrelease sub BYTE PTR [rcx],100
	.byte 0xf0; .byte 0xf2; sub BYTE PTR [rcx],100
	.byte 0xf0; .byte 0xf3; sub BYTE PTR [rcx],100
	xacquire lock xor BYTE PTR [rcx],100
	lock xacquire xor BYTE PTR [rcx],100
	xrelease lock xor BYTE PTR [rcx],100
	lock xrelease xor BYTE PTR [rcx],100
	.byte 0xf0; .byte 0xf2; xor BYTE PTR [rcx],100
	.byte 0xf0; .byte 0xf3; xor BYTE PTR [rcx],100

# Tests for op imm16 regs/m16
	xacquire lock adc WORD PTR [rcx],1000
	lock xacquire adc WORD PTR [rcx],1000
	xrelease lock adc WORD PTR [rcx],1000
	lock xrelease adc WORD PTR [rcx],1000
	.byte 0xf0; .byte 0xf2; adc WORD PTR [rcx],1000
	.byte 0xf0; .byte 0xf3; adc WORD PTR [rcx],1000
	xacquire lock add WORD PTR [rcx],1000
	lock xacquire add WORD PTR [rcx],1000
	xrelease lock add WORD PTR [rcx],1000
	lock xrelease add WORD PTR [rcx],1000
	.byte 0xf0; .byte 0xf2; add WORD PTR [rcx],1000
	.byte 0xf0; .byte 0xf3; add WORD PTR [rcx],1000
	xacquire lock and WORD PTR [rcx],1000
	lock xacquire and WORD PTR [rcx],1000
	xrelease lock and WORD PTR [rcx],1000
	lock xrelease and WORD PTR [rcx],1000
	.byte 0xf0; .byte 0xf2; and WORD PTR [rcx],1000
	.byte 0xf0; .byte 0xf3; and WORD PTR [rcx],1000
	xrelease mov WORD PTR [rcx],1000
	xacquire lock or WORD PTR [rcx],1000
	lock xacquire or WORD PTR [rcx],1000
	xrelease lock or WORD PTR [rcx],1000
	lock xrelease or WORD PTR [rcx],1000
	.byte 0xf0; .byte 0xf2; or WORD PTR [rcx],1000
	.byte 0xf0; .byte 0xf3; or WORD PTR [rcx],1000
	xacquire lock sbb WORD PTR [rcx],1000
	lock xacquire sbb WORD PTR [rcx],1000
	xrelease lock sbb WORD PTR [rcx],1000
	lock xrelease sbb WORD PTR [rcx],1000
	.byte 0xf0; .byte 0xf2; sbb WORD PTR [rcx],1000
	.byte 0xf0; .byte 0xf3; sbb WORD PTR [rcx],1000
	xacquire lock sub WORD PTR [rcx],1000
	lock xacquire sub WORD PTR [rcx],1000
	xrelease lock sub WORD PTR [rcx],1000
	lock xrelease sub WORD PTR [rcx],1000
	.byte 0xf0; .byte 0xf2; sub WORD PTR [rcx],1000
	.byte 0xf0; .byte 0xf3; sub WORD PTR [rcx],1000
	xacquire lock xor WORD PTR [rcx],1000
	lock xacquire xor WORD PTR [rcx],1000
	xrelease lock xor WORD PTR [rcx],1000
	lock xrelease xor WORD PTR [rcx],1000
	.byte 0xf0; .byte 0xf2; xor WORD PTR [rcx],1000
	.byte 0xf0; .byte 0xf3; xor WORD PTR [rcx],1000

# Tests for op imm32 regl/m32
	xacquire lock adc DWORD PTR [rcx],10000000
	lock xacquire adc DWORD PTR [rcx],10000000
	xrelease lock adc DWORD PTR [rcx],10000000
	lock xrelease adc DWORD PTR [rcx],10000000
	.byte 0xf0; .byte 0xf2; adc DWORD PTR [rcx],10000000
	.byte 0xf0; .byte 0xf3; adc DWORD PTR [rcx],10000000
	xacquire lock add DWORD PTR [rcx],10000000
	lock xacquire add DWORD PTR [rcx],10000000
	xrelease lock add DWORD PTR [rcx],10000000
	lock xrelease add DWORD PTR [rcx],10000000
	.byte 0xf0; .byte 0xf2; add DWORD PTR [rcx],10000000
	.byte 0xf0; .byte 0xf3; add DWORD PTR [rcx],10000000
	xacquire lock and DWORD PTR [rcx],10000000
	lock xacquire and DWORD PTR [rcx],10000000
	xrelease lock and DWORD PTR [rcx],10000000
	lock xrelease and DWORD PTR [rcx],10000000
	.byte 0xf0; .byte 0xf2; and DWORD PTR [rcx],10000000
	.byte 0xf0; .byte 0xf3; and DWORD PTR [rcx],10000000
	xrelease mov DWORD PTR [rcx],10000000
	xacquire lock or DWORD PTR [rcx],10000000
	lock xacquire or DWORD PTR [rcx],10000000
	xrelease lock or DWORD PTR [rcx],10000000
	lock xrelease or DWORD PTR [rcx],10000000
	.byte 0xf0; .byte 0xf2; or DWORD PTR [rcx],10000000
	.byte 0xf0; .byte 0xf3; or DWORD PTR [rcx],10000000
	xacquire lock sbb DWORD PTR [rcx],10000000
	lock xacquire sbb DWORD PTR [rcx],10000000
	xrelease lock sbb DWORD PTR [rcx],10000000
	lock xrelease sbb DWORD PTR [rcx],10000000
	.byte 0xf0; .byte 0xf2; sbb DWORD PTR [rcx],10000000
	.byte 0xf0; .byte 0xf3; sbb DWORD PTR [rcx],10000000
	xacquire lock sub DWORD PTR [rcx],10000000
	lock xacquire sub DWORD PTR [rcx],10000000
	xrelease lock sub DWORD PTR [rcx],10000000
	lock xrelease sub DWORD PTR [rcx],10000000
	.byte 0xf0; .byte 0xf2; sub DWORD PTR [rcx],10000000
	.byte 0xf0; .byte 0xf3; sub DWORD PTR [rcx],10000000
	xacquire lock xor DWORD PTR [rcx],10000000
	lock xacquire xor DWORD PTR [rcx],10000000
	xrelease lock xor DWORD PTR [rcx],10000000
	lock xrelease xor DWORD PTR [rcx],10000000
	.byte 0xf0; .byte 0xf2; xor DWORD PTR [rcx],10000000
	.byte 0xf0; .byte 0xf3; xor DWORD PTR [rcx],10000000

# Tests for op imm32 regq/m64
	xacquire lock adc QWORD PTR [rcx],10000000
	lock xacquire adc QWORD PTR [rcx],10000000
	xrelease lock adc QWORD PTR [rcx],10000000
	lock xrelease adc QWORD PTR [rcx],10000000
	.byte 0xf0; .byte 0xf2; adc QWORD PTR [rcx],10000000
	.byte 0xf0; .byte 0xf3; adc QWORD PTR [rcx],10000000
	xacquire lock add QWORD PTR [rcx],10000000
	lock xacquire add QWORD PTR [rcx],10000000
	xrelease lock add QWORD PTR [rcx],10000000
	lock xrelease add QWORD PTR [rcx],10000000
	.byte 0xf0; .byte 0xf2; add QWORD PTR [rcx],10000000
	.byte 0xf0; .byte 0xf3; add QWORD PTR [rcx],10000000
	xacquire lock and QWORD PTR [rcx],10000000
	lock xacquire and QWORD PTR [rcx],10000000
	xrelease lock and QWORD PTR [rcx],10000000
	lock xrelease and QWORD PTR [rcx],10000000
	.byte 0xf0; .byte 0xf2; and QWORD PTR [rcx],10000000
	.byte 0xf0; .byte 0xf3; and QWORD PTR [rcx],10000000
	xrelease mov QWORD PTR [rcx],10000000
	xacquire lock or QWORD PTR [rcx],10000000
	lock xacquire or QWORD PTR [rcx],10000000
	xrelease lock or QWORD PTR [rcx],10000000
	lock xrelease or QWORD PTR [rcx],10000000
	.byte 0xf0; .byte 0xf2; or QWORD PTR [rcx],10000000
	.byte 0xf0; .byte 0xf3; or QWORD PTR [rcx],10000000
	xacquire lock sbb QWORD PTR [rcx],10000000
	lock xacquire sbb QWORD PTR [rcx],10000000
	xrelease lock sbb QWORD PTR [rcx],10000000
	lock xrelease sbb QWORD PTR [rcx],10000000
	.byte 0xf0; .byte 0xf2; sbb QWORD PTR [rcx],10000000
	.byte 0xf0; .byte 0xf3; sbb QWORD PTR [rcx],10000000
	xacquire lock sub QWORD PTR [rcx],10000000
	lock xacquire sub QWORD PTR [rcx],10000000
	xrelease lock sub QWORD PTR [rcx],10000000
	lock xrelease sub QWORD PTR [rcx],10000000
	.byte 0xf0; .byte 0xf2; sub QWORD PTR [rcx],10000000
	.byte 0xf0; .byte 0xf3; sub QWORD PTR [rcx],10000000
	xacquire lock xor QWORD PTR [rcx],10000000
	lock xacquire xor QWORD PTR [rcx],10000000
	xrelease lock xor QWORD PTR [rcx],10000000
	lock xrelease xor QWORD PTR [rcx],10000000
	.byte 0xf0; .byte 0xf2; xor QWORD PTR [rcx],10000000
	.byte 0xf0; .byte 0xf3; xor QWORD PTR [rcx],10000000

# Tests for op imm8 regs/m16
	xacquire lock adc WORD PTR [rcx],100
	lock xacquire adc WORD PTR [rcx],100
	xrelease lock adc WORD PTR [rcx],100
	lock xrelease adc WORD PTR [rcx],100
	.byte 0xf0; .byte 0xf2; adc WORD PTR [rcx],100
	.byte 0xf0; .byte 0xf3; adc WORD PTR [rcx],100
	xacquire lock add WORD PTR [rcx],100
	lock xacquire add WORD PTR [rcx],100
	xrelease lock add WORD PTR [rcx],100
	lock xrelease add WORD PTR [rcx],100
	.byte 0xf0; .byte 0xf2; add WORD PTR [rcx],100
	.byte 0xf0; .byte 0xf3; add WORD PTR [rcx],100
	xacquire lock and WORD PTR [rcx],100
	lock xacquire and WORD PTR [rcx],100
	xrelease lock and WORD PTR [rcx],100
	lock xrelease and WORD PTR [rcx],100
	.byte 0xf0; .byte 0xf2; and WORD PTR [rcx],100
	.byte 0xf0; .byte 0xf3; and WORD PTR [rcx],100
	xacquire lock btc WORD PTR [rcx],100
	lock xacquire btc WORD PTR [rcx],100
	xrelease lock btc WORD PTR [rcx],100
	lock xrelease btc WORD PTR [rcx],100
	.byte 0xf0; .byte 0xf2; btc WORD PTR [rcx],100
	.byte 0xf0; .byte 0xf3; btc WORD PTR [rcx],100
	xacquire lock btr WORD PTR [rcx],100
	lock xacquire btr WORD PTR [rcx],100
	xrelease lock btr WORD PTR [rcx],100
	lock xrelease btr WORD PTR [rcx],100
	.byte 0xf0; .byte 0xf2; btr WORD PTR [rcx],100
	.byte 0xf0; .byte 0xf3; btr WORD PTR [rcx],100
	xacquire lock bts WORD PTR [rcx],100
	lock xacquire bts WORD PTR [rcx],100
	xrelease lock bts WORD PTR [rcx],100
	lock xrelease bts WORD PTR [rcx],100
	.byte 0xf0; .byte 0xf2; bts WORD PTR [rcx],100
	.byte 0xf0; .byte 0xf3; bts WORD PTR [rcx],100
	xrelease mov WORD PTR [rcx],100
	xacquire lock or WORD PTR [rcx],100
	lock xacquire or WORD PTR [rcx],100
	xrelease lock or WORD PTR [rcx],100
	lock xrelease or WORD PTR [rcx],100
	.byte 0xf0; .byte 0xf2; or WORD PTR [rcx],100
	.byte 0xf0; .byte 0xf3; or WORD PTR [rcx],100
	xacquire lock sbb WORD PTR [rcx],100
	lock xacquire sbb WORD PTR [rcx],100
	xrelease lock sbb WORD PTR [rcx],100
	lock xrelease sbb WORD PTR [rcx],100
	.byte 0xf0; .byte 0xf2; sbb WORD PTR [rcx],100
	.byte 0xf0; .byte 0xf3; sbb WORD PTR [rcx],100
	xacquire lock sub WORD PTR [rcx],100
	lock xacquire sub WORD PTR [rcx],100
	xrelease lock sub WORD PTR [rcx],100
	lock xrelease sub WORD PTR [rcx],100
	.byte 0xf0; .byte 0xf2; sub WORD PTR [rcx],100
	.byte 0xf0; .byte 0xf3; sub WORD PTR [rcx],100
	xacquire lock xor WORD PTR [rcx],100
	lock xacquire xor WORD PTR [rcx],100
	xrelease lock xor WORD PTR [rcx],100
	lock xrelease xor WORD PTR [rcx],100
	.byte 0xf0; .byte 0xf2; xor WORD PTR [rcx],100
	.byte 0xf0; .byte 0xf3; xor WORD PTR [rcx],100

# Tests for op imm8 regl/m32
	xacquire lock adc DWORD PTR [rcx],100
	lock xacquire adc DWORD PTR [rcx],100
	xrelease lock adc DWORD PTR [rcx],100
	lock xrelease adc DWORD PTR [rcx],100
	.byte 0xf0; .byte 0xf2; adc DWORD PTR [rcx],100
	.byte 0xf0; .byte 0xf3; adc DWORD PTR [rcx],100
	xacquire lock add DWORD PTR [rcx],100
	lock xacquire add DWORD PTR [rcx],100
	xrelease lock add DWORD PTR [rcx],100
	lock xrelease add DWORD PTR [rcx],100
	.byte 0xf0; .byte 0xf2; add DWORD PTR [rcx],100
	.byte 0xf0; .byte 0xf3; add DWORD PTR [rcx],100
	xacquire lock and DWORD PTR [rcx],100
	lock xacquire and DWORD PTR [rcx],100
	xrelease lock and DWORD PTR [rcx],100
	lock xrelease and DWORD PTR [rcx],100
	.byte 0xf0; .byte 0xf2; and DWORD PTR [rcx],100
	.byte 0xf0; .byte 0xf3; and DWORD PTR [rcx],100
	xacquire lock btc DWORD PTR [rcx],100
	lock xacquire btc DWORD PTR [rcx],100
	xrelease lock btc DWORD PTR [rcx],100
	lock xrelease btc DWORD PTR [rcx],100
	.byte 0xf0; .byte 0xf2; btc DWORD PTR [rcx],100
	.byte 0xf0; .byte 0xf3; btc DWORD PTR [rcx],100
	xacquire lock btr DWORD PTR [rcx],100
	lock xacquire btr DWORD PTR [rcx],100
	xrelease lock btr DWORD PTR [rcx],100
	lock xrelease btr DWORD PTR [rcx],100
	.byte 0xf0; .byte 0xf2; btr DWORD PTR [rcx],100
	.byte 0xf0; .byte 0xf3; btr DWORD PTR [rcx],100
	xacquire lock bts DWORD PTR [rcx],100
	lock xacquire bts DWORD PTR [rcx],100
	xrelease lock bts DWORD PTR [rcx],100
	lock xrelease bts DWORD PTR [rcx],100
	.byte 0xf0; .byte 0xf2; bts DWORD PTR [rcx],100
	.byte 0xf0; .byte 0xf3; bts DWORD PTR [rcx],100
	xrelease mov DWORD PTR [rcx],100
	xacquire lock or DWORD PTR [rcx],100
	lock xacquire or DWORD PTR [rcx],100
	xrelease lock or DWORD PTR [rcx],100
	lock xrelease or DWORD PTR [rcx],100
	.byte 0xf0; .byte 0xf2; or DWORD PTR [rcx],100
	.byte 0xf0; .byte 0xf3; or DWORD PTR [rcx],100
	xacquire lock sbb DWORD PTR [rcx],100
	lock xacquire sbb DWORD PTR [rcx],100
	xrelease lock sbb DWORD PTR [rcx],100
	lock xrelease sbb DWORD PTR [rcx],100
	.byte 0xf0; .byte 0xf2; sbb DWORD PTR [rcx],100
	.byte 0xf0; .byte 0xf3; sbb DWORD PTR [rcx],100
	xacquire lock sub DWORD PTR [rcx],100
	lock xacquire sub DWORD PTR [rcx],100
	xrelease lock sub DWORD PTR [rcx],100
	lock xrelease sub DWORD PTR [rcx],100
	.byte 0xf0; .byte 0xf2; sub DWORD PTR [rcx],100
	.byte 0xf0; .byte 0xf3; sub DWORD PTR [rcx],100
	xacquire lock xor DWORD PTR [rcx],100
	lock xacquire xor DWORD PTR [rcx],100
	xrelease lock xor DWORD PTR [rcx],100
	lock xrelease xor DWORD PTR [rcx],100
	.byte 0xf0; .byte 0xf2; xor DWORD PTR [rcx],100
	.byte 0xf0; .byte 0xf3; xor DWORD PTR [rcx],100

# Tests for op imm8 regq/m64
	xacquire lock adc QWORD PTR [rcx],100
	lock xacquire adc QWORD PTR [rcx],100
	xrelease lock adc QWORD PTR [rcx],100
	lock xrelease adc QWORD PTR [rcx],100
	.byte 0xf0; .byte 0xf2; adc QWORD PTR [rcx],100
	.byte 0xf0; .byte 0xf3; adc QWORD PTR [rcx],100
	xacquire lock add QWORD PTR [rcx],100
	lock xacquire add QWORD PTR [rcx],100
	xrelease lock add QWORD PTR [rcx],100
	lock xrelease add QWORD PTR [rcx],100
	.byte 0xf0; .byte 0xf2; add QWORD PTR [rcx],100
	.byte 0xf0; .byte 0xf3; add QWORD PTR [rcx],100
	xacquire lock and QWORD PTR [rcx],100
	lock xacquire and QWORD PTR [rcx],100
	xrelease lock and QWORD PTR [rcx],100
	lock xrelease and QWORD PTR [rcx],100
	.byte 0xf0; .byte 0xf2; and QWORD PTR [rcx],100
	.byte 0xf0; .byte 0xf3; and QWORD PTR [rcx],100
	xacquire lock btc QWORD PTR [rcx],100
	lock xacquire btc QWORD PTR [rcx],100
	xrelease lock btc QWORD PTR [rcx],100
	lock xrelease btc QWORD PTR [rcx],100
	.byte 0xf0; .byte 0xf2; btc QWORD PTR [rcx],100
	.byte 0xf0; .byte 0xf3; btc QWORD PTR [rcx],100
	xacquire lock btr QWORD PTR [rcx],100
	lock xacquire btr QWORD PTR [rcx],100
	xrelease lock btr QWORD PTR [rcx],100
	lock xrelease btr QWORD PTR [rcx],100
	.byte 0xf0; .byte 0xf2; btr QWORD PTR [rcx],100
	.byte 0xf0; .byte 0xf3; btr QWORD PTR [rcx],100
	xacquire lock bts QWORD PTR [rcx],100
	lock xacquire bts QWORD PTR [rcx],100
	xrelease lock bts QWORD PTR [rcx],100
	lock xrelease bts QWORD PTR [rcx],100
	.byte 0xf0; .byte 0xf2; bts QWORD PTR [rcx],100
	.byte 0xf0; .byte 0xf3; bts QWORD PTR [rcx],100
	xrelease mov QWORD PTR [rcx],100
	xacquire lock or QWORD PTR [rcx],100
	lock xacquire or QWORD PTR [rcx],100
	xrelease lock or QWORD PTR [rcx],100
	lock xrelease or QWORD PTR [rcx],100
	.byte 0xf0; .byte 0xf2; or QWORD PTR [rcx],100
	.byte 0xf0; .byte 0xf3; or QWORD PTR [rcx],100
	xacquire lock sbb QWORD PTR [rcx],100
	lock xacquire sbb QWORD PTR [rcx],100
	xrelease lock sbb QWORD PTR [rcx],100
	lock xrelease sbb QWORD PTR [rcx],100
	.byte 0xf0; .byte 0xf2; sbb QWORD PTR [rcx],100
	.byte 0xf0; .byte 0xf3; sbb QWORD PTR [rcx],100
	xacquire lock sub QWORD PTR [rcx],100
	lock xacquire sub QWORD PTR [rcx],100
	xrelease lock sub QWORD PTR [rcx],100
	lock xrelease sub QWORD PTR [rcx],100
	.byte 0xf0; .byte 0xf2; sub QWORD PTR [rcx],100
	.byte 0xf0; .byte 0xf3; sub QWORD PTR [rcx],100
	xacquire lock xor QWORD PTR [rcx],100
	lock xacquire xor QWORD PTR [rcx],100
	xrelease lock xor QWORD PTR [rcx],100
	lock xrelease xor QWORD PTR [rcx],100
	.byte 0xf0; .byte 0xf2; xor QWORD PTR [rcx],100
	.byte 0xf0; .byte 0xf3; xor QWORD PTR [rcx],100

# Tests for op imm8 regb/m8
	xacquire lock adc BYTE PTR [rcx],100
	lock xacquire adc BYTE PTR [rcx],100
	xrelease lock adc BYTE PTR [rcx],100
	lock xrelease adc BYTE PTR [rcx],100
	.byte 0xf0; .byte 0xf2; adc BYTE PTR [rcx],100
	.byte 0xf0; .byte 0xf3; adc BYTE PTR [rcx],100
	xacquire lock add BYTE PTR [rcx],100
	lock xacquire add BYTE PTR [rcx],100
	xrelease lock add BYTE PTR [rcx],100
	lock xrelease add BYTE PTR [rcx],100
	.byte 0xf0; .byte 0xf2; add BYTE PTR [rcx],100
	.byte 0xf0; .byte 0xf3; add BYTE PTR [rcx],100
	xacquire lock and BYTE PTR [rcx],100
	lock xacquire and BYTE PTR [rcx],100
	xrelease lock and BYTE PTR [rcx],100
	lock xrelease and BYTE PTR [rcx],100
	.byte 0xf0; .byte 0xf2; and BYTE PTR [rcx],100
	.byte 0xf0; .byte 0xf3; and BYTE PTR [rcx],100
	xrelease mov BYTE PTR [rcx],100
	xacquire lock or BYTE PTR [rcx],100
	lock xacquire or BYTE PTR [rcx],100
	xrelease lock or BYTE PTR [rcx],100
	lock xrelease or BYTE PTR [rcx],100
	.byte 0xf0; .byte 0xf2; or BYTE PTR [rcx],100
	.byte 0xf0; .byte 0xf3; or BYTE PTR [rcx],100
	xacquire lock sbb BYTE PTR [rcx],100
	lock xacquire sbb BYTE PTR [rcx],100
	xrelease lock sbb BYTE PTR [rcx],100
	lock xrelease sbb BYTE PTR [rcx],100
	.byte 0xf0; .byte 0xf2; sbb BYTE PTR [rcx],100
	.byte 0xf0; .byte 0xf3; sbb BYTE PTR [rcx],100
	xacquire lock sub BYTE PTR [rcx],100
	lock xacquire sub BYTE PTR [rcx],100
	xrelease lock sub BYTE PTR [rcx],100
	lock xrelease sub BYTE PTR [rcx],100
	.byte 0xf0; .byte 0xf2; sub BYTE PTR [rcx],100
	.byte 0xf0; .byte 0xf3; sub BYTE PTR [rcx],100
	xacquire lock xor BYTE PTR [rcx],100
	lock xacquire xor BYTE PTR [rcx],100
	xrelease lock xor BYTE PTR [rcx],100
	lock xrelease xor BYTE PTR [rcx],100
	.byte 0xf0; .byte 0xf2; xor BYTE PTR [rcx],100
	.byte 0xf0; .byte 0xf3; xor BYTE PTR [rcx],100

# Tests for op regb regb/m8
# Tests for op regb/m8 regb
	xacquire lock adc BYTE PTR [rcx],al
	lock xacquire adc BYTE PTR [rcx],al
	xrelease lock adc BYTE PTR [rcx],al
	lock xrelease adc BYTE PTR [rcx],al
	.byte 0xf0; .byte 0xf2; adc BYTE PTR [rcx],al
	.byte 0xf0; .byte 0xf3; adc BYTE PTR [rcx],al
	xacquire lock add BYTE PTR [rcx],al
	lock xacquire add BYTE PTR [rcx],al
	xrelease lock add BYTE PTR [rcx],al
	lock xrelease add BYTE PTR [rcx],al
	.byte 0xf0; .byte 0xf2; add BYTE PTR [rcx],al
	.byte 0xf0; .byte 0xf3; add BYTE PTR [rcx],al
	xacquire lock and BYTE PTR [rcx],al
	lock xacquire and BYTE PTR [rcx],al
	xrelease lock and BYTE PTR [rcx],al
	lock xrelease and BYTE PTR [rcx],al
	.byte 0xf0; .byte 0xf2; and BYTE PTR [rcx],al
	.byte 0xf0; .byte 0xf3; and BYTE PTR [rcx],al
	xrelease mov BYTE PTR [rcx],al
	xacquire lock or BYTE PTR [rcx],al
	lock xacquire or BYTE PTR [rcx],al
	xrelease lock or BYTE PTR [rcx],al
	lock xrelease or BYTE PTR [rcx],al
	.byte 0xf0; .byte 0xf2; or BYTE PTR [rcx],al
	.byte 0xf0; .byte 0xf3; or BYTE PTR [rcx],al
	xacquire lock sbb BYTE PTR [rcx],al
	lock xacquire sbb BYTE PTR [rcx],al
	xrelease lock sbb BYTE PTR [rcx],al
	lock xrelease sbb BYTE PTR [rcx],al
	.byte 0xf0; .byte 0xf2; sbb BYTE PTR [rcx],al
	.byte 0xf0; .byte 0xf3; sbb BYTE PTR [rcx],al
	xacquire lock sub BYTE PTR [rcx],al
	lock xacquire sub BYTE PTR [rcx],al
	xrelease lock sub BYTE PTR [rcx],al
	lock xrelease sub BYTE PTR [rcx],al
	.byte 0xf0; .byte 0xf2; sub BYTE PTR [rcx],al
	.byte 0xf0; .byte 0xf3; sub BYTE PTR [rcx],al
	xacquire lock xchg BYTE PTR [rcx],al
	lock xacquire xchg BYTE PTR [rcx],al
	xacquire xchg BYTE PTR [rcx],al
	xrelease lock xchg BYTE PTR [rcx],al
	lock xrelease xchg BYTE PTR [rcx],al
	xrelease xchg BYTE PTR [rcx],al
	.byte 0xf0; .byte 0xf2; xchg BYTE PTR [rcx],al
	.byte 0xf0; .byte 0xf3; xchg BYTE PTR [rcx],al
	xacquire lock xor BYTE PTR [rcx],al
	lock xacquire xor BYTE PTR [rcx],al
	xrelease lock xor BYTE PTR [rcx],al
	lock xrelease xor BYTE PTR [rcx],al
	.byte 0xf0; .byte 0xf2; xor BYTE PTR [rcx],al
	.byte 0xf0; .byte 0xf3; xor BYTE PTR [rcx],al

# Tests for op regs regs/m16
# Tests for op regs/m16 regs
	xacquire lock adc WORD PTR [rcx],ax
	lock xacquire adc WORD PTR [rcx],ax
	xrelease lock adc WORD PTR [rcx],ax
	lock xrelease adc WORD PTR [rcx],ax
	.byte 0xf0; .byte 0xf2; adc WORD PTR [rcx],ax
	.byte 0xf0; .byte 0xf3; adc WORD PTR [rcx],ax
	xacquire lock add WORD PTR [rcx],ax
	lock xacquire add WORD PTR [rcx],ax
	xrelease lock add WORD PTR [rcx],ax
	lock xrelease add WORD PTR [rcx],ax
	.byte 0xf0; .byte 0xf2; add WORD PTR [rcx],ax
	.byte 0xf0; .byte 0xf3; add WORD PTR [rcx],ax
	xacquire lock and WORD PTR [rcx],ax
	lock xacquire and WORD PTR [rcx],ax
	xrelease lock and WORD PTR [rcx],ax
	lock xrelease and WORD PTR [rcx],ax
	.byte 0xf0; .byte 0xf2; and WORD PTR [rcx],ax
	.byte 0xf0; .byte 0xf3; and WORD PTR [rcx],ax
	xrelease mov WORD PTR [rcx],ax
	xacquire lock or WORD PTR [rcx],ax
	lock xacquire or WORD PTR [rcx],ax
	xrelease lock or WORD PTR [rcx],ax
	lock xrelease or WORD PTR [rcx],ax
	.byte 0xf0; .byte 0xf2; or WORD PTR [rcx],ax
	.byte 0xf0; .byte 0xf3; or WORD PTR [rcx],ax
	xacquire lock sbb WORD PTR [rcx],ax
	lock xacquire sbb WORD PTR [rcx],ax
	xrelease lock sbb WORD PTR [rcx],ax
	lock xrelease sbb WORD PTR [rcx],ax
	.byte 0xf0; .byte 0xf2; sbb WORD PTR [rcx],ax
	.byte 0xf0; .byte 0xf3; sbb WORD PTR [rcx],ax
	xacquire lock sub WORD PTR [rcx],ax
	lock xacquire sub WORD PTR [rcx],ax
	xrelease lock sub WORD PTR [rcx],ax
	lock xrelease sub WORD PTR [rcx],ax
	.byte 0xf0; .byte 0xf2; sub WORD PTR [rcx],ax
	.byte 0xf0; .byte 0xf3; sub WORD PTR [rcx],ax
	xacquire lock xchg WORD PTR [rcx],ax
	lock xacquire xchg WORD PTR [rcx],ax
	xacquire xchg WORD PTR [rcx],ax
	xrelease lock xchg WORD PTR [rcx],ax
	lock xrelease xchg WORD PTR [rcx],ax
	xrelease xchg WORD PTR [rcx],ax
	.byte 0xf0; .byte 0xf2; xchg WORD PTR [rcx],ax
	.byte 0xf0; .byte 0xf3; xchg WORD PTR [rcx],ax
	xacquire lock xor WORD PTR [rcx],ax
	lock xacquire xor WORD PTR [rcx],ax
	xrelease lock xor WORD PTR [rcx],ax
	lock xrelease xor WORD PTR [rcx],ax
	.byte 0xf0; .byte 0xf2; xor WORD PTR [rcx],ax
	.byte 0xf0; .byte 0xf3; xor WORD PTR [rcx],ax

# Tests for op regl regl/m32
# Tests for op regl/m32 regl
	xacquire lock adc DWORD PTR [rcx],eax
	lock xacquire adc DWORD PTR [rcx],eax
	xrelease lock adc DWORD PTR [rcx],eax
	lock xrelease adc DWORD PTR [rcx],eax
	.byte 0xf0; .byte 0xf2; adc DWORD PTR [rcx],eax
	.byte 0xf0; .byte 0xf3; adc DWORD PTR [rcx],eax
	xacquire lock add DWORD PTR [rcx],eax
	lock xacquire add DWORD PTR [rcx],eax
	xrelease lock add DWORD PTR [rcx],eax
	lock xrelease add DWORD PTR [rcx],eax
	.byte 0xf0; .byte 0xf2; add DWORD PTR [rcx],eax
	.byte 0xf0; .byte 0xf3; add DWORD PTR [rcx],eax
	xacquire lock and DWORD PTR [rcx],eax
	lock xacquire and DWORD PTR [rcx],eax
	xrelease lock and DWORD PTR [rcx],eax
	lock xrelease and DWORD PTR [rcx],eax
	.byte 0xf0; .byte 0xf2; and DWORD PTR [rcx],eax
	.byte 0xf0; .byte 0xf3; and DWORD PTR [rcx],eax
	xrelease mov DWORD PTR [rcx],eax
	xacquire lock or DWORD PTR [rcx],eax
	lock xacquire or DWORD PTR [rcx],eax
	xrelease lock or DWORD PTR [rcx],eax
	lock xrelease or DWORD PTR [rcx],eax
	.byte 0xf0; .byte 0xf2; or DWORD PTR [rcx],eax
	.byte 0xf0; .byte 0xf3; or DWORD PTR [rcx],eax
	xacquire lock sbb DWORD PTR [rcx],eax
	lock xacquire sbb DWORD PTR [rcx],eax
	xrelease lock sbb DWORD PTR [rcx],eax
	lock xrelease sbb DWORD PTR [rcx],eax
	.byte 0xf0; .byte 0xf2; sbb DWORD PTR [rcx],eax
	.byte 0xf0; .byte 0xf3; sbb DWORD PTR [rcx],eax
	xacquire lock sub DWORD PTR [rcx],eax
	lock xacquire sub DWORD PTR [rcx],eax
	xrelease lock sub DWORD PTR [rcx],eax
	lock xrelease sub DWORD PTR [rcx],eax
	.byte 0xf0; .byte 0xf2; sub DWORD PTR [rcx],eax
	.byte 0xf0; .byte 0xf3; sub DWORD PTR [rcx],eax
	xacquire lock xchg DWORD PTR [rcx],eax
	lock xacquire xchg DWORD PTR [rcx],eax
	xacquire xchg DWORD PTR [rcx],eax
	xrelease lock xchg DWORD PTR [rcx],eax
	lock xrelease xchg DWORD PTR [rcx],eax
	xrelease xchg DWORD PTR [rcx],eax
	.byte 0xf0; .byte 0xf2; xchg DWORD PTR [rcx],eax
	.byte 0xf0; .byte 0xf3; xchg DWORD PTR [rcx],eax
	xacquire lock xor DWORD PTR [rcx],eax
	lock xacquire xor DWORD PTR [rcx],eax
	xrelease lock xor DWORD PTR [rcx],eax
	lock xrelease xor DWORD PTR [rcx],eax
	.byte 0xf0; .byte 0xf2; xor DWORD PTR [rcx],eax
	.byte 0xf0; .byte 0xf3; xor DWORD PTR [rcx],eax

# Tests for op regq regq/m64
# Tests for op regq/m64 regq
	xacquire lock adc QWORD PTR [rcx],rax
	lock xacquire adc QWORD PTR [rcx],rax
	xrelease lock adc QWORD PTR [rcx],rax
	lock xrelease adc QWORD PTR [rcx],rax
	.byte 0xf0; .byte 0xf2; adc QWORD PTR [rcx],rax
	.byte 0xf0; .byte 0xf3; adc QWORD PTR [rcx],rax
	xacquire lock add QWORD PTR [rcx],rax
	lock xacquire add QWORD PTR [rcx],rax
	xrelease lock add QWORD PTR [rcx],rax
	lock xrelease add QWORD PTR [rcx],rax
	.byte 0xf0; .byte 0xf2; add QWORD PTR [rcx],rax
	.byte 0xf0; .byte 0xf3; add QWORD PTR [rcx],rax
	xacquire lock and QWORD PTR [rcx],rax
	lock xacquire and QWORD PTR [rcx],rax
	xrelease lock and QWORD PTR [rcx],rax
	lock xrelease and QWORD PTR [rcx],rax
	.byte 0xf0; .byte 0xf2; and QWORD PTR [rcx],rax
	.byte 0xf0; .byte 0xf3; and QWORD PTR [rcx],rax
	xrelease mov QWORD PTR [rcx],rax
	xacquire lock or QWORD PTR [rcx],rax
	lock xacquire or QWORD PTR [rcx],rax
	xrelease lock or QWORD PTR [rcx],rax
	lock xrelease or QWORD PTR [rcx],rax
	.byte 0xf0; .byte 0xf2; or QWORD PTR [rcx],rax
	.byte 0xf0; .byte 0xf3; or QWORD PTR [rcx],rax
	xacquire lock sbb QWORD PTR [rcx],rax
	lock xacquire sbb QWORD PTR [rcx],rax
	xrelease lock sbb QWORD PTR [rcx],rax
	lock xrelease sbb QWORD PTR [rcx],rax
	.byte 0xf0; .byte 0xf2; sbb QWORD PTR [rcx],rax
	.byte 0xf0; .byte 0xf3; sbb QWORD PTR [rcx],rax
	xacquire lock sub QWORD PTR [rcx],rax
	lock xacquire sub QWORD PTR [rcx],rax
	xrelease lock sub QWORD PTR [rcx],rax
	lock xrelease sub QWORD PTR [rcx],rax
	.byte 0xf0; .byte 0xf2; sub QWORD PTR [rcx],rax
	.byte 0xf0; .byte 0xf3; sub QWORD PTR [rcx],rax
	xacquire lock xchg QWORD PTR [rcx],rax
	lock xacquire xchg QWORD PTR [rcx],rax
	xacquire xchg QWORD PTR [rcx],rax
	xrelease lock xchg QWORD PTR [rcx],rax
	lock xrelease xchg QWORD PTR [rcx],rax
	xrelease xchg QWORD PTR [rcx],rax
	.byte 0xf0; .byte 0xf2; xchg QWORD PTR [rcx],rax
	.byte 0xf0; .byte 0xf3; xchg QWORD PTR [rcx],rax
	xacquire lock xor QWORD PTR [rcx],rax
	lock xacquire xor QWORD PTR [rcx],rax
	xrelease lock xor QWORD PTR [rcx],rax
	lock xrelease xor QWORD PTR [rcx],rax
	.byte 0xf0; .byte 0xf2; xor QWORD PTR [rcx],rax
	.byte 0xf0; .byte 0xf3; xor QWORD PTR [rcx],rax

# Tests for op regs, regs/m16
	xacquire lock btc WORD PTR [rcx],ax
	lock xacquire btc WORD PTR [rcx],ax
	xrelease lock btc WORD PTR [rcx],ax
	lock xrelease btc WORD PTR [rcx],ax
	.byte 0xf0; .byte 0xf2; btc WORD PTR [rcx],ax
	.byte 0xf0; .byte 0xf3; btc WORD PTR [rcx],ax
	xacquire lock btr WORD PTR [rcx],ax
	lock xacquire btr WORD PTR [rcx],ax
	xrelease lock btr WORD PTR [rcx],ax
	lock xrelease btr WORD PTR [rcx],ax
	.byte 0xf0; .byte 0xf2; btr WORD PTR [rcx],ax
	.byte 0xf0; .byte 0xf3; btr WORD PTR [rcx],ax
	xacquire lock bts WORD PTR [rcx],ax
	lock xacquire bts WORD PTR [rcx],ax
	xrelease lock bts WORD PTR [rcx],ax
	lock xrelease bts WORD PTR [rcx],ax
	.byte 0xf0; .byte 0xf2; bts WORD PTR [rcx],ax
	.byte 0xf0; .byte 0xf3; bts WORD PTR [rcx],ax
	xacquire lock cmpxchg WORD PTR [rcx],ax
	lock xacquire cmpxchg WORD PTR [rcx],ax
	xrelease lock cmpxchg WORD PTR [rcx],ax
	lock xrelease cmpxchg WORD PTR [rcx],ax
	.byte 0xf0; .byte 0xf2; cmpxchg WORD PTR [rcx],ax
	.byte 0xf0; .byte 0xf3; cmpxchg WORD PTR [rcx],ax
	xacquire lock xadd WORD PTR [rcx],ax
	lock xacquire xadd WORD PTR [rcx],ax
	xrelease lock xadd WORD PTR [rcx],ax
	lock xrelease xadd WORD PTR [rcx],ax
	.byte 0xf0; .byte 0xf2; xadd WORD PTR [rcx],ax
	.byte 0xf0; .byte 0xf3; xadd WORD PTR [rcx],ax

# Tests for op regl regl/m32
	xacquire lock btc DWORD PTR [rcx],eax
	lock xacquire btc DWORD PTR [rcx],eax
	xrelease lock btc DWORD PTR [rcx],eax
	lock xrelease btc DWORD PTR [rcx],eax
	.byte 0xf0; .byte 0xf2; btc DWORD PTR [rcx],eax
	.byte 0xf0; .byte 0xf3; btc DWORD PTR [rcx],eax
	xacquire lock btr DWORD PTR [rcx],eax
	lock xacquire btr DWORD PTR [rcx],eax
	xrelease lock btr DWORD PTR [rcx],eax
	lock xrelease btr DWORD PTR [rcx],eax
	.byte 0xf0; .byte 0xf2; btr DWORD PTR [rcx],eax
	.byte 0xf0; .byte 0xf3; btr DWORD PTR [rcx],eax
	xacquire lock bts DWORD PTR [rcx],eax
	lock xacquire bts DWORD PTR [rcx],eax
	xrelease lock bts DWORD PTR [rcx],eax
	lock xrelease bts DWORD PTR [rcx],eax
	.byte 0xf0; .byte 0xf2; bts DWORD PTR [rcx],eax
	.byte 0xf0; .byte 0xf3; bts DWORD PTR [rcx],eax
	xacquire lock cmpxchg DWORD PTR [rcx],eax
	lock xacquire cmpxchg DWORD PTR [rcx],eax
	xrelease lock cmpxchg DWORD PTR [rcx],eax
	lock xrelease cmpxchg DWORD PTR [rcx],eax
	.byte 0xf0; .byte 0xf2; cmpxchg DWORD PTR [rcx],eax
	.byte 0xf0; .byte 0xf3; cmpxchg DWORD PTR [rcx],eax
	xacquire lock xadd DWORD PTR [rcx],eax
	lock xacquire xadd DWORD PTR [rcx],eax
	xrelease lock xadd DWORD PTR [rcx],eax
	lock xrelease xadd DWORD PTR [rcx],eax
	.byte 0xf0; .byte 0xf2; xadd DWORD PTR [rcx],eax
	.byte 0xf0; .byte 0xf3; xadd DWORD PTR [rcx],eax

# Tests for op regq regq/m64
	xacquire lock btc QWORD PTR [rcx],rax
	lock xacquire btc QWORD PTR [rcx],rax
	xrelease lock btc QWORD PTR [rcx],rax
	lock xrelease btc QWORD PTR [rcx],rax
	.byte 0xf0; .byte 0xf2; btc QWORD PTR [rcx],rax
	.byte 0xf0; .byte 0xf3; btc QWORD PTR [rcx],rax
	xacquire lock btr QWORD PTR [rcx],rax
	lock xacquire btr QWORD PTR [rcx],rax
	xrelease lock btr QWORD PTR [rcx],rax
	lock xrelease btr QWORD PTR [rcx],rax
	.byte 0xf0; .byte 0xf2; btr QWORD PTR [rcx],rax
	.byte 0xf0; .byte 0xf3; btr QWORD PTR [rcx],rax
	xacquire lock bts QWORD PTR [rcx],rax
	lock xacquire bts QWORD PTR [rcx],rax
	xrelease lock bts QWORD PTR [rcx],rax
	lock xrelease bts QWORD PTR [rcx],rax
	.byte 0xf0; .byte 0xf2; bts QWORD PTR [rcx],rax
	.byte 0xf0; .byte 0xf3; bts QWORD PTR [rcx],rax
	xacquire lock cmpxchg QWORD PTR [rcx],rax
	lock xacquire cmpxchg QWORD PTR [rcx],rax
	xrelease lock cmpxchg QWORD PTR [rcx],rax
	lock xrelease cmpxchg QWORD PTR [rcx],rax
	.byte 0xf0; .byte 0xf2; cmpxchg QWORD PTR [rcx],rax
	.byte 0xf0; .byte 0xf3; cmpxchg QWORD PTR [rcx],rax
	xacquire lock xadd QWORD PTR [rcx],rax
	lock xacquire xadd QWORD PTR [rcx],rax
	xrelease lock xadd QWORD PTR [rcx],rax
	lock xrelease xadd QWORD PTR [rcx],rax
	.byte 0xf0; .byte 0xf2; xadd QWORD PTR [rcx],rax
	.byte 0xf0; .byte 0xf3; xadd QWORD PTR [rcx],rax

# Tests for op regb/m8
	xacquire lock dec BYTE PTR [rcx]
	lock xacquire dec BYTE PTR [rcx]
	xrelease lock dec BYTE PTR [rcx]
	lock xrelease dec BYTE PTR [rcx]
	.byte 0xf0; .byte 0xf2; dec BYTE PTR [rcx]
	.byte 0xf0; .byte 0xf3; dec BYTE PTR [rcx]
	xacquire lock inc BYTE PTR [rcx]
	lock xacquire inc BYTE PTR [rcx]
	xrelease lock inc BYTE PTR [rcx]
	lock xrelease inc BYTE PTR [rcx]
	.byte 0xf0; .byte 0xf2; inc BYTE PTR [rcx]
	.byte 0xf0; .byte 0xf3; inc BYTE PTR [rcx]
	xacquire lock neg BYTE PTR [rcx]
	lock xacquire neg BYTE PTR [rcx]
	xrelease lock neg BYTE PTR [rcx]
	lock xrelease neg BYTE PTR [rcx]
	.byte 0xf0; .byte 0xf2; neg BYTE PTR [rcx]
	.byte 0xf0; .byte 0xf3; neg BYTE PTR [rcx]
	xacquire lock not BYTE PTR [rcx]
	lock xacquire not BYTE PTR [rcx]
	xrelease lock not BYTE PTR [rcx]
	lock xrelease not BYTE PTR [rcx]
	.byte 0xf0; .byte 0xf2; not BYTE PTR [rcx]
	.byte 0xf0; .byte 0xf3; not BYTE PTR [rcx]

# Tests for op regs/m16
	xacquire lock dec WORD PTR [rcx]
	lock xacquire dec WORD PTR [rcx]
	xrelease lock dec WORD PTR [rcx]
	lock xrelease dec WORD PTR [rcx]
	.byte 0xf0; .byte 0xf2; dec WORD PTR [rcx]
	.byte 0xf0; .byte 0xf3; dec WORD PTR [rcx]
	xacquire lock inc WORD PTR [rcx]
	lock xacquire inc WORD PTR [rcx]
	xrelease lock inc WORD PTR [rcx]
	lock xrelease inc WORD PTR [rcx]
	.byte 0xf0; .byte 0xf2; inc WORD PTR [rcx]
	.byte 0xf0; .byte 0xf3; inc WORD PTR [rcx]
	xacquire lock neg WORD PTR [rcx]
	lock xacquire neg WORD PTR [rcx]
	xrelease lock neg WORD PTR [rcx]
	lock xrelease neg WORD PTR [rcx]
	.byte 0xf0; .byte 0xf2; neg WORD PTR [rcx]
	.byte 0xf0; .byte 0xf3; neg WORD PTR [rcx]
	xacquire lock not WORD PTR [rcx]
	lock xacquire not WORD PTR [rcx]
	xrelease lock not WORD PTR [rcx]
	lock xrelease not WORD PTR [rcx]
	.byte 0xf0; .byte 0xf2; not WORD PTR [rcx]
	.byte 0xf0; .byte 0xf3; not WORD PTR [rcx]

# Tests for op regl/m32
	xacquire lock dec DWORD PTR [rcx]
	lock xacquire dec DWORD PTR [rcx]
	xrelease lock dec DWORD PTR [rcx]
	lock xrelease dec DWORD PTR [rcx]
	.byte 0xf0; .byte 0xf2; dec DWORD PTR [rcx]
	.byte 0xf0; .byte 0xf3; dec DWORD PTR [rcx]
	xacquire lock inc DWORD PTR [rcx]
	lock xacquire inc DWORD PTR [rcx]
	xrelease lock inc DWORD PTR [rcx]
	lock xrelease inc DWORD PTR [rcx]
	.byte 0xf0; .byte 0xf2; inc DWORD PTR [rcx]
	.byte 0xf0; .byte 0xf3; inc DWORD PTR [rcx]
	xacquire lock neg DWORD PTR [rcx]
	lock xacquire neg DWORD PTR [rcx]
	xrelease lock neg DWORD PTR [rcx]
	lock xrelease neg DWORD PTR [rcx]
	.byte 0xf0; .byte 0xf2; neg DWORD PTR [rcx]
	.byte 0xf0; .byte 0xf3; neg DWORD PTR [rcx]
	xacquire lock not DWORD PTR [rcx]
	lock xacquire not DWORD PTR [rcx]
	xrelease lock not DWORD PTR [rcx]
	lock xrelease not DWORD PTR [rcx]
	.byte 0xf0; .byte 0xf2; not DWORD PTR [rcx]
	.byte 0xf0; .byte 0xf3; not DWORD PTR [rcx]

# Tests for op regq/m64
	xacquire lock dec QWORD PTR [rcx]
	lock xacquire dec QWORD PTR [rcx]
	xrelease lock dec QWORD PTR [rcx]
	lock xrelease dec QWORD PTR [rcx]
	.byte 0xf0; .byte 0xf2; dec QWORD PTR [rcx]
	.byte 0xf0; .byte 0xf3; dec QWORD PTR [rcx]
	xacquire lock inc QWORD PTR [rcx]
	lock xacquire inc QWORD PTR [rcx]
	xrelease lock inc QWORD PTR [rcx]
	lock xrelease inc QWORD PTR [rcx]
	.byte 0xf0; .byte 0xf2; inc QWORD PTR [rcx]
	.byte 0xf0; .byte 0xf3; inc QWORD PTR [rcx]
	xacquire lock neg QWORD PTR [rcx]
	lock xacquire neg QWORD PTR [rcx]
	xrelease lock neg QWORD PTR [rcx]
	lock xrelease neg QWORD PTR [rcx]
	.byte 0xf0; .byte 0xf2; neg QWORD PTR [rcx]
	.byte 0xf0; .byte 0xf3; neg QWORD PTR [rcx]
	xacquire lock not QWORD PTR [rcx]
	lock xacquire not QWORD PTR [rcx]
	xrelease lock not QWORD PTR [rcx]
	lock xrelease not QWORD PTR [rcx]
	.byte 0xf0; .byte 0xf2; not QWORD PTR [rcx]
	.byte 0xf0; .byte 0xf3; not QWORD PTR [rcx]

# Tests for op m64
	xacquire lock cmpxchg8b QWORD PTR [rcx]
	lock xacquire cmpxchg8b QWORD PTR [rcx]
	xrelease lock cmpxchg8b QWORD PTR [rcx]
	lock xrelease cmpxchg8b QWORD PTR [rcx]
	.byte 0xf0; .byte 0xf2; cmpxchg8b QWORD PTR [rcx]
	.byte 0xf0; .byte 0xf3; cmpxchg8b QWORD PTR [rcx]

# Tests for op regb, regb/m8
	xacquire lock cmpxchg BYTE PTR [rcx],cl
	lock xacquire cmpxchg BYTE PTR [rcx],cl
	xrelease lock cmpxchg BYTE PTR [rcx],cl
	lock xrelease cmpxchg BYTE PTR [rcx],cl
	.byte 0xf0; .byte 0xf2; cmpxchg BYTE PTR [rcx],cl
	.byte 0xf0; .byte 0xf3; cmpxchg BYTE PTR [rcx],cl
	xacquire lock xadd BYTE PTR [rcx],cl
	lock xacquire xadd BYTE PTR [rcx],cl
	xrelease lock xadd BYTE PTR [rcx],cl
	lock xrelease xadd BYTE PTR [rcx],cl
	.byte 0xf0; .byte 0xf2; xadd BYTE PTR [rcx],cl
	.byte 0xf0; .byte 0xf3; xadd BYTE PTR [rcx],cl