Is There A Way To Force NASM To Emit Opcode 0x82 In 8086 Mode

Problem

I'm using NASM as a reference assembler for an 8086 disassembler project I'm working on. To increase test coverage I'm looking for an assembly instruction and/or command line flag that will cause NASM to emit opcode 0x82 when using the directive "CPU 8086".

Background

As can be seen on page 4-31 of the "Intel 8086 Family User's Manual October 1979" opcode 0x82 is described as follows:

Opcode	MODREGR/M	Data	Syntax
0x82	MOD 000 R/M	(DISP-LO),(DISP-HI),DATA-8	ADD REG8/MEM8,IMMED8
0x82	MOD 010 R/M	(DISP-LO),(DISP-HI),DATA-8	ADC REG8/MEM8,IMMED8
0x82	MOD 011 R/M	(DISP-LO),(DISP-HI),DATA-8	SBB REG8/MEM8,IMMED8
0x82	MOD 101 R/M	(DISP-LO),(DISP-HI),DATA-8	SUB REG8/MEM8,IMMED8
0x82	MOD 111 R/M	(DISP-LO),(DISP-HI),DATA-8	CMP REG8/MEM8,IMMED8

However, NASM seems to prefer opcode 0x80 which has the same syntax. Opcode 0x80 is described on page 4-30

Opcode	MODREGR/M	Data	Syntax
0x80	MOD 000 R/M	(DISP-LO),(DISP-HI),DATA-8	ADD REG8/MEM8,IMMED8
0x80	MOD 001 R/M	(DISP-LO),(DISP-HI),DATA-8	OR REG8/MEM8,IMMED8
0x80	MOD 010 R/M	(DISP-LO),(DISP-HI),DATA-8	ADC REG8/MEM8,IMMED8
0x80	MOD 011 R/M	(DISP-LO),(DISP-HI),DATA-8	SBB REG8/MEM8,IMMED8
0x80	MOD 100 R/M	(DISP-LO),(DISP-HI),DATA-8	AND REG8/MEM8,IMMED8
0x80	MOD 101 R/M	(DISP-LO),(DISP-HI),DATA-8	SUB REG8/MEM8,IMMED8
0x80	MOD 110 R/M	(DISP-LO),(DISP-HI),DATA-8	XOR REG8/MEM8,IMMED8
0x80	MOD 111 R/M	(DISP-LO),(DISP-HI),DATA-8	CMP REG8/MEM8,IMMED8

Though I'm not familiar with NASM's codebase there does seem to be some evidence that NASM supports opcode 0x82 as can be seen here: https://github.com/netwide-assembler/nasm/blob/07245bc57431180c6e10dc630d06a7785bd660a9/x86/insns.dat#L116C1-L117C1

My guess is that when searching for a syntax match for an eligible line of assembly NASM finds opcode 0x80 before opcode 0x82. However, given the age of the NASM project I would be surprised if there was a dead code branch so I'm hopeful there is a way to force NASM to emit opcode 0x82.

I have tried the following to no avail:

CPU 8086
ADD byte al, 0
ADD byte al, 127
ADD byte al, 255
ADD byte cl, 0
ADD byte cl, 127
ADD byte cl, 255
ADD byte dl, 0
ADD byte dl, 127
ADD byte dl, 255
ADD byte bl, 0
ADD byte bl, 127
ADD byte bl, 255
ADD byte ah, 0
ADD byte ah, 127
ADD byte ah, 255
ADD byte ch, 0
ADD byte ch, 127
ADD byte ch, 255
ADD byte dh, 0
ADD byte dh, 127
ADD byte dh, 255
ADD byte bh, 0
ADD byte bh, 127
ADD byte bh, 255
ADD byte [bx + si], 0
ADD byte [bx + si], 127
ADD byte [bx + si], 255
ADD byte [bx + di], 0
ADD byte [bx + di], 127
ADD byte [bx + di], 255
ADD byte [bp + si], 0
ADD byte [bp + si], 127
ADD byte [bp + si], 255
ADD byte [bp + di], 0
ADD byte [bp + di], 127
ADD byte [bp + di], 255
ADD byte [127], 0
ADD byte [127], 127
ADD byte [127], 255
ADD byte [1], 0
ADD byte [1], 127
ADD byte [1], 255
ADD byte [0], 0
ADD byte [0], 127
ADD byte [0], 255
ADD byte [-1], 0
ADD byte [-1], 127
ADD byte [-1], 255
ADD byte [-128], 0
ADD byte [-128], 127
ADD byte [-128], 255
ADD byte [bx], 0
ADD byte [bx], 127
ADD byte [bx], 255
ADD byte [bx + si + 127], 0
ADD byte [bx + si + 127], 127
ADD byte [bx + si + 127], 255
ADD byte [bx + si + 1], 0
ADD byte [bx + si + 1], 127
ADD byte [bx + si + 1], 255
ADD byte [bx + si + 0], 0
ADD byte [bx + si + 0], 127
ADD byte [bx + si + 0], 255
ADD byte [bx + si + -1], 0
ADD byte [bx + si + -1], 127
ADD byte [bx + si + -1], 255
ADD byte [bx + si + -128], 0
ADD byte [bx + si + -128], 127
ADD byte [bx + si + -128], 255
ADD byte [bx + di + 127], 0
ADD byte [bx + di + 127], 127
ADD byte [bx + di + 127], 255
ADD byte [bx + di + 1], 0
ADD byte [bx + di + 1], 127
ADD byte [bx + di + 1], 255
ADD byte [bx + di + 0], 0
ADD byte [bx + di + 0], 127
ADD byte [bx + di + 0], 255
ADD byte [bx + di + -1], 0
ADD byte [bx + di + -1], 127
ADD byte [bx + di + -1], 255
ADD byte [bx + di + -128], 0
ADD byte [bx + di + -128], 127
ADD byte [bx + di + -128], 255
ADD byte [bp + si + 127], 0
ADD byte [bp + si + 127], 127
ADD byte [bp + si + 127], 255
ADD byte [bp + si + 1], 0
ADD byte [bp + si + 1], 127
ADD byte [bp + si + 1], 255
ADD byte [bp + si + 0], 0
ADD byte [bp + si + 0], 127
ADD byte [bp + si + 0], 255
ADD byte [bp + si + -1], 0
ADD byte [bp + si + -1], 127
ADD byte [bp + si + -1], 255
ADD byte [bp + si + -128], 0
ADD byte [bp + si + -128], 127
ADD byte [bp + si + -128], 255
ADD byte [bp + di + 127], 0
ADD byte [bp + di + 127], 127
ADD byte [bp + di + 127], 255
ADD byte [bp + di + 1], 0
ADD byte [bp + di + 1], 127
ADD byte [bp + di + 1], 255
ADD byte [bp + di + 0], 0
ADD byte [bp + di + 0], 127
ADD byte [bp + di + 0], 255
ADD byte [bp + di + -1], 0
ADD byte [bp + di + -1], 127
ADD byte [bp + di + -1], 255
ADD byte [bp + di + -128], 0
ADD byte [bp + di + -128], 127
ADD byte [bp + di + -128], 255
ADD byte [bp + 127], 0
ADD byte [bp + 127], 127
ADD byte [bp + 127], 255
ADD byte [bp + 1], 0
ADD byte [bp + 1], 127
ADD byte [bp + 1], 255
ADD byte [bp + 0], 0
ADD byte [bp + 0], 127
ADD byte [bp + 0], 255
ADD byte [bp + -1], 0
ADD byte [bp + -1], 127
ADD byte [bp + -1], 255
ADD byte [bp + -128], 0
ADD byte [bp + -128], 127
ADD byte [bp + -128], 255
ADD byte [bx + 127], 0
ADD byte [bx + 127], 127
ADD byte [bx + 127], 255
ADD byte [bx + 1], 0
ADD byte [bx + 1], 127
ADD byte [bx + 1], 255
ADD byte [bx + 0], 0
ADD byte [bx + 0], 127
ADD byte [bx + 0], 255
ADD byte [bx + -1], 0
ADD byte [bx + -1], 127
ADD byte [bx + -1], 255
ADD byte [bx + -128], 0
ADD byte [bx + -128], 127
ADD byte [bx + -128], 255
ADC byte al, 0
ADC byte al, 127
ADC byte al, 255
ADC byte cl, 0
ADC byte cl, 127
ADC byte cl, 255
ADC byte dl, 0
ADC byte dl, 127
ADC byte dl, 255
ADC byte bl, 0
ADC byte bl, 127
ADC byte bl, 255
ADC byte ah, 0
ADC byte ah, 127
ADC byte ah, 255
ADC byte ch, 0
ADC byte ch, 127
ADC byte ch, 255
ADC byte dh, 0
ADC byte dh, 127
ADC byte dh, 255
ADC byte bh, 0
ADC byte bh, 127
ADC byte bh, 255
ADC byte [bx + si], 0
ADC byte [bx + si], 127
ADC byte [bx + si], 255
ADC byte [bx + di], 0
ADC byte [bx + di], 127
ADC byte [bx + di], 255
ADC byte [bp + si], 0
ADC byte [bp + si], 127
ADC byte [bp + si], 255
ADC byte [bp + di], 0
ADC byte [bp + di], 127
ADC byte [bp + di], 255
ADC byte [127], 0
ADC byte [127], 127
ADC byte [127], 255
ADC byte [1], 0
ADC byte [1], 127
ADC byte [1], 255
ADC byte [0], 0
ADC byte [0], 127
ADC byte [0], 255
ADC byte [-1], 0
ADC byte [-1], 127
ADC byte [-1], 255
ADC byte [-128], 0
ADC byte [-128], 127
ADC byte [-128], 255
ADC byte [bx], 0
ADC byte [bx], 127
ADC byte [bx], 255
ADC byte [bx + si + 127], 0
ADC byte [bx + si + 127], 127
ADC byte [bx + si + 127], 255
ADC byte [bx + si + 1], 0
ADC byte [bx + si + 1], 127
ADC byte [bx + si + 1], 255
ADC byte [bx + si + 0], 0
ADC byte [bx + si + 0], 127
ADC byte [bx + si + 0], 255
ADC byte [bx + si + -1], 0
ADC byte [bx + si + -1], 127
ADC byte [bx + si + -1], 255
ADC byte [bx + si + -128], 0
ADC byte [bx + si + -128], 127
ADC byte [bx + si + -128], 255
ADC byte [bx + di + 127], 0
ADC byte [bx + di + 127], 127
ADC byte [bx + di + 127], 255
ADC byte [bx + di + 1], 0
ADC byte [bx + di + 1], 127
ADC byte [bx + di + 1], 255
ADC byte [bx + di + 0], 0
ADC byte [bx + di + 0], 127
ADC byte [bx + di + 0], 255
ADC byte [bx + di + -1], 0
ADC byte [bx + di + -1], 127
ADC byte [bx + di + -1], 255
ADC byte [bx + di + -128], 0
ADC byte [bx + di + -128], 127
ADC byte [bx + di + -128], 255
ADC byte [bp + si + 127], 0
ADC byte [bp + si + 127], 127
ADC byte [bp + si + 127], 255
ADC byte [bp + si + 1], 0
ADC byte [bp + si + 1], 127
ADC byte [bp + si + 1], 255
ADC byte [bp + si + 0], 0
ADC byte [bp + si + 0], 127
ADC byte [bp + si + 0], 255
ADC byte [bp + si + -1], 0
ADC byte [bp + si + -1], 127
ADC byte [bp + si + -1], 255
ADC byte [bp + si + -128], 0
ADC byte [bp + si + -128], 127
ADC byte [bp + si + -128], 255
ADC byte [bp + di + 127], 0
ADC byte [bp + di + 127], 127
ADC byte [bp + di + 127], 255
ADC byte [bp + di + 1], 0
ADC byte [bp + di + 1], 127
ADC byte [bp + di + 1], 255
ADC byte [bp + di + 0], 0
ADC byte [bp + di + 0], 127
ADC byte [bp + di + 0], 255
ADC byte [bp + di + -1], 0
ADC byte [bp + di + -1], 127
ADC byte [bp + di + -1], 255
ADC byte [bp + di + -128], 0
ADC byte [bp + di + -128], 127
ADC byte [bp + di + -128], 255
ADC byte [bp + 127], 0
ADC byte [bp + 127], 127
ADC byte [bp + 127], 255
ADC byte [bp + 1], 0
ADC byte [bp + 1], 127
ADC byte [bp + 1], 255
ADC byte [bp + 0], 0
ADC byte [bp + 0], 127
ADC byte [bp + 0], 255
ADC byte [bp + -1], 0
ADC byte [bp + -1], 127
ADC byte [bp + -1], 255
ADC byte [bp + -128], 0
ADC byte [bp + -128], 127
ADC byte [bp + -128], 255
ADC byte [bx + 127], 0
ADC byte [bx + 127], 127
ADC byte [bx + 127], 255
ADC byte [bx + 1], 0
ADC byte [bx + 1], 127
ADC byte [bx + 1], 255
ADC byte [bx + 0], 0
ADC byte [bx + 0], 127
ADC byte [bx + 0], 255
ADC byte [bx + -1], 0
ADC byte [bx + -1], 127
ADC byte [bx + -1], 255
ADC byte [bx + -128], 0
ADC byte [bx + -128], 127
ADC byte [bx + -128], 255
SBB byte al, 0
SBB byte al, 127
SBB byte al, 255
SBB byte cl, 0
SBB byte cl, 127
SBB byte cl, 255
SBB byte dl, 0
SBB byte dl, 127
SBB byte dl, 255
SBB byte bl, 0
SBB byte bl, 127
SBB byte bl, 255
SBB byte ah, 0
SBB byte ah, 127
SBB byte ah, 255
SBB byte ch, 0
SBB byte ch, 127
SBB byte ch, 255
SBB byte dh, 0
SBB byte dh, 127
SBB byte dh, 255
SBB byte bh, 0
SBB byte bh, 127
SBB byte bh, 255
SBB byte [bx + si], 0
SBB byte [bx + si], 127
SBB byte [bx + si], 255
SBB byte [bx + di], 0
SBB byte [bx + di], 127
SBB byte [bx + di], 255
SBB byte [bp + si], 0
SBB byte [bp + si], 127
SBB byte [bp + si], 255
SBB byte [bp + di], 0
SBB byte [bp + di], 127
SBB byte [bp + di], 255
SBB byte [127], 0
SBB byte [127], 127
SBB byte [127], 255
SBB byte [1], 0
SBB byte [1], 127
SBB byte [1], 255
SBB byte [0], 0
SBB byte [0], 127
SBB byte [0], 255
SBB byte [-1], 0
SBB byte [-1], 127
SBB byte [-1], 255
SBB byte [-128], 0
SBB byte [-128], 127
SBB byte [-128], 255
SBB byte [bx], 0
SBB byte [bx], 127
SBB byte [bx], 255
SBB byte [bx + si + 127], 0
SBB byte [bx + si + 127], 127
SBB byte [bx + si + 127], 255
SBB byte [bx + si + 1], 0
SBB byte [bx + si + 1], 127
SBB byte [bx + si + 1], 255
SBB byte [bx + si + 0], 0
SBB byte [bx + si + 0], 127
SBB byte [bx + si + 0], 255
SBB byte [bx + si + -1], 0
SBB byte [bx + si + -1], 127
SBB byte [bx + si + -1], 255
SBB byte [bx + si + -128], 0
SBB byte [bx + si + -128], 127
SBB byte [bx + si + -128], 255
SBB byte [bx + di + 127], 0
SBB byte [bx + di + 127], 127
SBB byte [bx + di + 127], 255
SBB byte [bx + di + 1], 0
SBB byte [bx + di + 1], 127
SBB byte [bx + di + 1], 255
SBB byte [bx + di + 0], 0
SBB byte [bx + di + 0], 127
SBB byte [bx + di + 0], 255
SBB byte [bx + di + -1], 0
SBB byte [bx + di + -1], 127
SBB byte [bx + di + -1], 255
SBB byte [bx + di + -128], 0
SBB byte [bx + di + -128], 127
SBB byte [bx + di + -128], 255
SBB byte [bp + si + 127], 0
SBB byte [bp + si + 127], 127
SBB byte [bp + si + 127], 255
SBB byte [bp + si + 1], 0
SBB byte [bp + si + 1], 127
SBB byte [bp + si + 1], 255
SBB byte [bp + si + 0], 0
SBB byte [bp + si + 0], 127
SBB byte [bp + si + 0], 255
SBB byte [bp + si + -1], 0
SBB byte [bp + si + -1], 127
SBB byte [bp + si + -1], 255
SBB byte [bp + si + -128], 0
SBB byte [bp + si + -128], 127
SBB byte [bp + si + -128], 255
SBB byte [bp + di + 127], 0
SBB byte [bp + di + 127], 127
SBB byte [bp + di + 127], 255
SBB byte [bp + di + 1], 0
SBB byte [bp + di + 1], 127
SBB byte [bp + di + 1], 255
SBB byte [bp + di + 0], 0
SBB byte [bp + di + 0], 127
SBB byte [bp + di + 0], 255
SBB byte [bp + di + -1], 0
SBB byte [bp + di + -1], 127
SBB byte [bp + di + -1], 255
SBB byte [bp + di + -128], 0
SBB byte [bp + di + -128], 127
SBB byte [bp + di + -128], 255
SBB byte [bp + 127], 0
SBB byte [bp + 127], 127
SBB byte [bp + 127], 255
SBB byte [bp + 1], 0
SBB byte [bp + 1], 127
SBB byte [bp + 1], 255
SBB byte [bp + 0], 0
SBB byte [bp + 0], 127
SBB byte [bp + 0], 255
SBB byte [bp + -1], 0
SBB byte [bp + -1], 127
SBB byte [bp + -1], 255
SBB byte [bp + -128], 0
SBB byte [bp + -128], 127
SBB byte [bp + -128], 255
SBB byte [bx + 127], 0
SBB byte [bx + 127], 127
SBB byte [bx + 127], 255
SBB byte [bx + 1], 0
SBB byte [bx + 1], 127
SBB byte [bx + 1], 255
SBB byte [bx + 0], 0
SBB byte [bx + 0], 127
SBB byte [bx + 0], 255
SBB byte [bx + -1], 0
SBB byte [bx + -1], 127
SBB byte [bx + -1], 255
SBB byte [bx + -128], 0
SBB byte [bx + -128], 127
SBB byte [bx + -128], 255
SUB byte al, 0
SUB byte al, 127
SUB byte al, 255
SUB byte cl, 0
SUB byte cl, 127
SUB byte cl, 255
SUB byte dl, 0
SUB byte dl, 127
SUB byte dl, 255
SUB byte bl, 0
SUB byte bl, 127
SUB byte bl, 255
SUB byte ah, 0
SUB byte ah, 127
SUB byte ah, 255
SUB byte ch, 0
SUB byte ch, 127
SUB byte ch, 255
SUB byte dh, 0
SUB byte dh, 127
SUB byte dh, 255
SUB byte bh, 0
SUB byte bh, 127
SUB byte bh, 255
SUB byte [bx + si], 0
SUB byte [bx + si], 127
SUB byte [bx + si], 255
SUB byte [bx + di], 0
SUB byte [bx + di], 127
SUB byte [bx + di], 255
SUB byte [bp + si], 0
SUB byte [bp + si], 127
SUB byte [bp + si], 255
SUB byte [bp + di], 0
SUB byte [bp + di], 127
SUB byte [bp + di], 255
SUB byte [127], 0
SUB byte [127], 127
SUB byte [127], 255
SUB byte [1], 0
SUB byte [1], 127
SUB byte [1], 255
SUB byte [0], 0
SUB byte [0], 127
SUB byte [0], 255
SUB byte [-1], 0
SUB byte [-1], 127
SUB byte [-1], 255
SUB byte [-128], 0
SUB byte [-128], 127
SUB byte [-128], 255
SUB byte [bx], 0
SUB byte [bx], 127
SUB byte [bx], 255
SUB byte [bx + si + 127], 0
SUB byte [bx + si + 127], 127
SUB byte [bx + si + 127], 255
SUB byte [bx + si + 1], 0
SUB byte [bx + si + 1], 127
SUB byte [bx + si + 1], 255
SUB byte [bx + si + 0], 0
SUB byte [bx + si + 0], 127
SUB byte [bx + si + 0], 255
SUB byte [bx + si + -1], 0
SUB byte [bx + si + -1], 127
SUB byte [bx + si + -1], 255
SUB byte [bx + si + -128], 0
SUB byte [bx + si + -128], 127
SUB byte [bx + si + -128], 255
SUB byte [bx + di + 127], 0
SUB byte [bx + di + 127], 127
SUB byte [bx + di + 127], 255
SUB byte [bx + di + 1], 0
SUB byte [bx + di + 1], 127
SUB byte [bx + di + 1], 255
SUB byte [bx + di + 0], 0
SUB byte [bx + di + 0], 127
SUB byte [bx + di + 0], 255
SUB byte [bx + di + -1], 0
SUB byte [bx + di + -1], 127
SUB byte [bx + di + -1], 255
SUB byte [bx + di + -128], 0
SUB byte [bx + di + -128], 127
SUB byte [bx + di + -128], 255
SUB byte [bp + si + 127], 0
SUB byte [bp + si + 127], 127
SUB byte [bp + si + 127], 255
SUB byte [bp + si + 1], 0
SUB byte [bp + si + 1], 127
SUB byte [bp + si + 1], 255
SUB byte [bp + si + 0], 0
SUB byte [bp + si + 0], 127
SUB byte [bp + si + 0], 255
SUB byte [bp + si + -1], 0
SUB byte [bp + si + -1], 127
SUB byte [bp + si + -1], 255
SUB byte [bp + si + -128], 0
SUB byte [bp + si + -128], 127
SUB byte [bp + si + -128], 255
SUB byte [bp + di + 127], 0
SUB byte [bp + di + 127], 127
SUB byte [bp + di + 127], 255
SUB byte [bp + di + 1], 0
SUB byte [bp + di + 1], 127
SUB byte [bp + di + 1], 255
SUB byte [bp + di + 0], 0
SUB byte [bp + di + 0], 127
SUB byte [bp + di + 0], 255
SUB byte [bp + di + -1], 0
SUB byte [bp + di + -1], 127
SUB byte [bp + di + -1], 255
SUB byte [bp + di + -128], 0
SUB byte [bp + di + -128], 127
SUB byte [bp + di + -128], 255
SUB byte [bp + 127], 0
SUB byte [bp + 127], 127
SUB byte [bp + 127], 255
SUB byte [bp + 1], 0
SUB byte [bp + 1], 127
SUB byte [bp + 1], 255
SUB byte [bp + 0], 0
SUB byte [bp + 0], 127
SUB byte [bp + 0], 255
SUB byte [bp + -1], 0
SUB byte [bp + -1], 127
SUB byte [bp + -1], 255
SUB byte [bp + -128], 0
SUB byte [bp + -128], 127
SUB byte [bp + -128], 255
SUB byte [bx + 127], 0
SUB byte [bx + 127], 127
SUB byte [bx + 127], 255
SUB byte [bx + 1], 0
SUB byte [bx + 1], 127
SUB byte [bx + 1], 255
SUB byte [bx + 0], 0
SUB byte [bx + 0], 127
SUB byte [bx + 0], 255
SUB byte [bx + -1], 0
SUB byte [bx + -1], 127
SUB byte [bx + -1], 255
SUB byte [bx + -128], 0
SUB byte [bx + -128], 127
SUB byte [bx + -128], 255
CMP byte al, 0
CMP byte al, 127
CMP byte al, 255
CMP byte cl, 0
CMP byte cl, 127
CMP byte cl, 255
CMP byte dl, 0
CMP byte dl, 127
CMP byte dl, 255
CMP byte bl, 0
CMP byte bl, 127
CMP byte bl, 255
CMP byte ah, 0
CMP byte ah, 127
CMP byte ah, 255
CMP byte ch, 0
CMP byte ch, 127
CMP byte ch, 255
CMP byte dh, 0
CMP byte dh, 127
CMP byte dh, 255
CMP byte bh, 0
CMP byte bh, 127
CMP byte bh, 255
CMP byte [bx + si], 0
CMP byte [bx + si], 127
CMP byte [bx + si], 255
CMP byte [bx + di], 0
CMP byte [bx + di], 127
CMP byte [bx + di], 255
CMP byte [bp + si], 0
CMP byte [bp + si], 127
CMP byte [bp + si], 255
CMP byte [bp + di], 0
CMP byte [bp + di], 127
CMP byte [bp + di], 255
CMP byte [127], 0
CMP byte [127], 127
CMP byte [127], 255
CMP byte [1], 0
CMP byte [1], 127
CMP byte [1], 255
CMP byte [0], 0
CMP byte [0], 127
CMP byte [0], 255
CMP byte [-1], 0
CMP byte [-1], 127
CMP byte [-1], 255
CMP byte [-128], 0
CMP byte [-128], 127
CMP byte [-128], 255
CMP byte [bx], 0
CMP byte [bx], 127
CMP byte [bx], 255
CMP byte [bx + si + 127], 0
CMP byte [bx + si + 127], 127
CMP byte [bx + si + 127], 255
CMP byte [bx + si + 1], 0
CMP byte [bx + si + 1], 127
CMP byte [bx + si + 1], 255
CMP byte [bx + si + 0], 0
CMP byte [bx + si + 0], 127
CMP byte [bx + si + 0], 255
CMP byte [bx + si + -1], 0
CMP byte [bx + si + -1], 127
CMP byte [bx + si + -1], 255
CMP byte [bx + si + -128], 0
CMP byte [bx + si + -128], 127
CMP byte [bx + si + -128], 255
CMP byte [bx + di + 127], 0
CMP byte [bx + di + 127], 127
CMP byte [bx + di + 127], 255
CMP byte [bx + di + 1], 0
CMP byte [bx + di + 1], 127
CMP byte [bx + di + 1], 255
CMP byte [bx + di + 0], 0
CMP byte [bx + di + 0], 127
CMP byte [bx + di + 0], 255
CMP byte [bx + di + -1], 0
CMP byte [bx + di + -1], 127
CMP byte [bx + di + -1], 255
CMP byte [bx + di + -128], 0
CMP byte [bx + di + -128], 127
CMP byte [bx + di + -128], 255
CMP byte [bp + si + 127], 0
CMP byte [bp + si + 127], 127
CMP byte [bp + si + 127], 255
CMP byte [bp + si + 1], 0
CMP byte [bp + si + 1], 127
CMP byte [bp + si + 1], 255
CMP byte [bp + si + 0], 0
CMP byte [bp + si + 0], 127
CMP byte [bp + si + 0], 255
CMP byte [bp + si + -1], 0
CMP byte [bp + si + -1], 127
CMP byte [bp + si + -1], 255
CMP byte [bp + si + -128], 0
CMP byte [bp + si + -128], 127
CMP byte [bp + si + -128], 255
CMP byte [bp + di + 127], 0
CMP byte [bp + di + 127], 127
CMP byte [bp + di + 127], 255
CMP byte [bp + di + 1], 0
CMP byte [bp + di + 1], 127
CMP byte [bp + di + 1], 255
CMP byte [bp + di + 0], 0
CMP byte [bp + di + 0], 127
CMP byte [bp + di + 0], 255
CMP byte [bp + di + -1], 0
CMP byte [bp + di + -1], 127
CMP byte [bp + di + -1], 255
CMP byte [bp + di + -128], 0
CMP byte [bp + di + -128], 127
CMP byte [bp + di + -128], 255
CMP byte [bp + 127], 0
CMP byte [bp + 127], 127
CMP byte [bp + 127], 255
CMP byte [bp + 1], 0
CMP byte [bp + 1], 127
CMP byte [bp + 1], 255
CMP byte [bp + 0], 0
CMP byte [bp + 0], 127
CMP byte [bp + 0], 255
CMP byte [bp + -1], 0
CMP byte [bp + -1], 127
CMP byte [bp + -1], 255
CMP byte [bp + -128], 0
CMP byte [bp + -128], 127
CMP byte [bp + -128], 255
CMP byte [bx + 127], 0
CMP byte [bx + 127], 127
CMP byte [bx + 127], 255
CMP byte [bx + 1], 0
CMP byte [bx + 1], 127
CMP byte [bx + 1], 255
CMP byte [bx + 0], 0
CMP byte [bx + 0], 127
CMP byte [bx + 0], 255
CMP byte [bx + -1], 0
CMP byte [bx + -1], 127
CMP byte [bx + -1], 255
CMP byte [bx + -128], 0
CMP byte [bx + -128], 127
CMP byte [bx + -128], 255

Solution

No, it is not possible.

Starting with version 2.10.04 NASM’s disassembler ndisasm became capable of disassembling the 82 opcode.
Bug report 33C2DA filed in 2012 complained that ndisasm could not disassemble the 82 opcode.
In response to that commit EB867FE7 added only data without implementing any logic allowing you to switch between the two.

The 82h opcodes are undocumented aliases for the 80h opcodes, except in 64‐bit mode. We don’t generate them, but let the disassembler handle them correctly.

The commit message pretty clearly states that is (or at least [in 2012] was) not intended to emit 82 opcodes.

Note that as for now the cpu directive only restricts the set of assembled instructions. It does not select any specific opcode in case you were under the impression that it did that.

^{NB: According to bug report 33C4FE 82 00 00 is still disassembled incorrectly.}