//! Static, named definitions of instruction opcodes.
/// Empty opcode for use as a default.
pub static EMPTY: = ;
/// Add with carry flag r{16,32,64} to r/m of the same size.
pub static ADC: = ;
/// Add r{16,32,64} to r/m of the same size.
pub static ADD: = ;
/// Add imm{16,32} to r/m{16,32,64}, possibly sign-extended.
pub static ADD_IMM: = ;
/// Add sign-extended imm8 to r/m{16,32,64}.
pub static ADD_IMM8_SIGN_EXTEND: = ;
/// Add packed double-precision floating-point values from xmm2/mem to xmm1 and store result in
/// xmm1 (SSE2).
pub static ADDPD: = ;
/// Add packed single-precision floating-point values from xmm2/mem to xmm1 and store result in
/// xmm1 (SSE).
pub static ADDPS: = ;
/// Add the low double-precision floating-point value from xmm2/mem to xmm1
/// and store the result in xmm1.
pub static ADDSD: = ;
/// Add the low single-precision floating-point value from xmm2/mem to xmm1
/// and store the result in xmm1.
pub static ADDSS: = ;
/// r/m{16,32,64} AND register of the same size (Intel docs have a typo).
pub static AND: = ;
/// imm{16,32} AND r/m{16,32,64}, possibly sign-extended.
pub static AND_IMM: = ;
/// r/m{16,32,64} AND sign-extended imm8.
pub static AND_IMM8_SIGN_EXTEND: = ;
/// Return the bitwise logical AND NOT of packed single-precision floating-point
/// values in xmm1 and xmm2/mem.
pub static ANDNPS: = ;
/// Return the bitwise logical AND of packed single-precision floating-point values
/// in xmm1 and xmm2/mem.
pub static ANDPS: = ;
/// Bit scan forward (stores index of first encountered 1 from the front).
pub static BIT_SCAN_FORWARD: = ;
/// Bit scan reverse (stores index of first encountered 1 from the back).
pub static BIT_SCAN_REVERSE: = ;
/// Call near, relative, displacement relative to next instruction (sign-extended).
pub static CALL_RELATIVE: = ;
/// Move r/m{16,32,64} if overflow (OF=1).
pub static CMOV_OVERFLOW: = ;
/// Compare imm{16,32} with r/m{16,32,64} (sign-extended if 64).
pub static CMP_IMM: = ;
/// Compare imm8 with r/m{16,32,64}.
pub static CMP_IMM8: = ;
/// Compare r{16,32,64} with r/m of the same size.
pub static CMP_REG: = ;
/// Compare packed double-precision floating-point value in xmm2/m32 and xmm1 using bits 2:0 of
/// imm8 as comparison predicate (SSE2).
pub static CMPPD: = ;
/// Compare packed single-precision floating-point value in xmm2/m32 and xmm1 using bits 2:0 of
/// imm8 as comparison predicate (SSE).
pub static CMPPS: = ;
/// Convert scalar double-precision floating-point value to scalar single-precision
/// floating-point value.
pub static CVTSD2SS: = ;
/// Convert doubleword integer to scalar double-precision floating-point value.
pub static CVTSI2SD: = ;
/// Convert doubleword integer to scalar single-precision floating-point value.
pub static CVTSI2SS: = ;
/// Convert scalar single-precision floating-point value to scalar double-precision
/// float-point value.
pub static CVTSS2SD: = ;
/// Convert with truncation scalar double-precision floating-point value to signed
/// integer.
pub static CVTTSD2SI: = ;
/// Convert with truncation scalar single-precision floating-point value to integer.
pub static CVTTSS2SI: = ;
/// Unsigned divide for {16,32,64}-bit.
pub static DIV: = ;
/// Divide packed double-precision floating-point values in xmm1 by packed double-precision
/// floating-point values in xmm2/mem (SSE2).
pub static DIVPD: = ;
/// Divide packed single-precision floating-point values in xmm1 by packed single-precision
/// floating-point values in xmm2/mem (SSE).
pub static DIVPS: = ;
/// Divide low double-precision floating-point value in xmm1 by low double-precision
/// floating-point value in xmm2/m64.
pub static DIVSD: = ;
/// Divide low single-precision floating-point value in xmm1 by low single-precision
/// floating-point value in xmm2/m32.
pub static DIVSS: = ;
/// Signed divide for {16,32,64}-bit.
pub static IDIV: = ;
/// Signed multiply for {16,32,64}-bit, generic registers.
pub static IMUL: = ;
/// Signed multiply for {16,32,64}-bit, storing into RDX:RAX.
pub static IMUL_RDX_RAX: = ;
/// Insert scalar single-precision floating-point value.
pub static INSERTPS: = ;
/// Either:
/// 1. Jump near, absolute indirect, RIP = 64-bit offset from register or memory.
/// 2. Jump far, absolute indirect, address given in m16:64.
pub static JUMP_ABSOLUTE: = ;
/// Jump near, relative, RIP = RIP + 32-bit displacement sign extended to 64 bits.
pub static JUMP_NEAR_RELATIVE: = ;
/// Jump near (rel32) if overflow (OF=1).
pub static JUMP_NEAR_IF_OVERFLOW: = ;
/// Jump short, relative, RIP = RIP + 8-bit displacement sign extended to 64 bits.
pub static JUMP_SHORT: = ;
/// Jump short (rel8) if equal (ZF=1).
pub static JUMP_SHORT_IF_EQUAL: = ;
/// Jump short (rel8) if not equal (ZF=0).
pub static JUMP_SHORT_IF_NOT_EQUAL: = ;
/// Jump short (rel8) if overflow (OF=1).
pub static JUMP_SHORT_IF_OVERFLOW: = ;
/// Store effective address for m in register r{16,32,64}.
pub static LEA: = ;
/// Count the number of leading zero bits.
pub static LZCNT: = ;
/// Return the maximum packed double-precision floating-point values between xmm1 and xmm2/m128
/// (SSE2).
pub static MAXPD: = ;
/// Return the maximum packed single-precision floating-point values between xmm1 and xmm2/m128
/// (SSE).
pub static MAXPS: = ;
/// Return the maximum scalar double-precision floating-point value between
/// xmm2/m64 and xmm1.
pub static MAXSD: = ;
/// Return the maximum scalar single-precision floating-point value between
/// xmm2/m32 and xmm1.
pub static MAXSS: = ;
/// Return the minimum packed double-precision floating-point values between xmm1 and xmm2/m128
/// (SSE2).
pub static MINPD: = ;
/// Return the minimum packed single-precision floating-point values between xmm1 and xmm2/m128
/// (SSE).
pub static MINPS: = ;
/// Return the minimum scalar double-precision floating-point value between
/// xmm2/m64 and xmm1.
pub static MINSD: = ;
/// Return the minimum scalar single-precision floating-point value between
/// xmm2/m32 and xmm1.
pub static MINSS: = ;
/// Move r8 to r/m8.
pub static MOV_BYTE_STORE: = ;
/// Move imm{16,32,64} to same-sized register.
pub static MOV_IMM: = ;
/// Move imm{16,32} to r{16,32,64}, sign-extended if 64-bit target.
pub static MOV_IMM_SIGNEXTEND: = ;
/// Move {r/m16, r/m32, r/m64} to same-sized register.
pub static MOV_LOAD: = ;
/// Move r16 to r/m16.
pub static MOV_STORE_16: = ;
/// Move {r16, r32, r64} to same-sized register or memory.
pub static MOV_STORE: = ;
/// Move aligned packed single-precision floating-point values from x/m to xmm (SSE).
pub static MOVAPS_LOAD: = ;
/// Move doubleword from r/m32 to xmm (SSE2). Quadword with REX prefix.
pub static MOVD_LOAD_XMM: = ;
/// Move doubleword from xmm to r/m32 (SSE2). Quadword with REX prefix.
pub static MOVD_STORE_XMM: = ;
/// Move packed single-precision floating-point values low to high (SSE).
pub static MOVLHPS: = ;
/// Move scalar double-precision floating-point value (from reg/mem to reg).
pub static MOVSD_LOAD: = ;
/// Move scalar double-precision floating-point value (from reg to reg/mem).
pub static MOVSD_STORE: = ;
/// Move scalar single-precision floating-point value (from reg to reg/mem).
pub static MOVSS_STORE: = ;
/// Move scalar single-precision floating-point-value (from reg/mem to reg).
pub static MOVSS_LOAD: = ;
/// Move byte to register with sign-extension.
pub static MOVSX_BYTE: = ;
/// Move word to register with sign-extension.
pub static MOVSX_WORD: = ;
/// Move doubleword to register with sign-extension.
pub static MOVSXD: = ;
/// Move unaligned packed single-precision floating-point from x/m to xmm (SSE).
pub static MOVUPS_LOAD: = ;
/// Move unaligned packed single-precision floating-point value from xmm to x/m (SSE).
pub static MOVUPS_STORE: = ;
/// Move byte to register with zero-extension.
pub static MOVZX_BYTE: = ;
/// Move word to register with zero-extension.
pub static MOVZX_WORD: = ;
/// Unsigned multiply for {16,32,64}-bit.
pub static MUL: = ;
/// Multiply packed double-precision floating-point values from xmm2/mem to xmm1 and store result
/// in xmm1 (SSE2).
pub static MULPD: = ;
/// Multiply packed single-precision floating-point values from xmm2/mem to xmm1 and store result
/// in xmm1 (SSE).
pub static MULPS: = ;
/// Multiply the low double-precision floating-point value in xmm2/m64 by the
/// low double-precision floating-point value in xmm1.
pub static MULSD: = ;
/// Multiply the low single-precision floating-point value in xmm2/m32 by the
/// low single-precision floating-point value in xmm1.
pub static MULSS: = ;
/// Reverse each bit of r/m{16,32,64}.
pub static NOT: = ;
/// r{16,32,64} OR register of same size.
pub static OR: = ;
/// imm{16,32} OR r/m{16,32,64}, possibly sign-extended.
pub static OR_IMM: = ;
/// r/m{16,32,64} OR sign-extended imm8.
pub static OR_IMM8_SIGN_EXTEND: = ;
/// Return the bitwise logical OR of packed single-precision values in xmm and x/m (SSE).
pub static ORPS: = ;
/// Add packed byte integers from xmm2/m128 and xmm1 (SSE2).
pub static PADDB: = ;
/// Add packed doubleword integers from xmm2/m128 and xmm1 (SSE2).
pub static PADDD: = ;
/// Add packed quadword integers from xmm2/m128 and xmm1 (SSE2).
pub static PADDQ: = ;
/// Add packed word integers from xmm2/m128 and xmm1 (SSE2).
pub static PADDW: = ;
/// Add packed signed byte integers from xmm2/m128 and xmm1 saturate the results (SSE).
pub static PADDSB: = ;
/// Add packed signed word integers from xmm2/m128 and xmm1 saturate the results (SSE).
pub static PADDSW: = ;
/// Add packed unsigned byte integers from xmm2/m128 and xmm1 saturate the results (SSE).
pub static PADDUSB: = ;
/// Add packed unsigned word integers from xmm2/m128 and xmm1 saturate the results (SSE).
pub static PADDUSW: = ;
/// Bitwise AND of xmm2/m128 and xmm1 (SSE2).
pub static PAND: = ;
/// Bitwise AND NOT of xmm2/m128 and xmm1 (SSE2).
pub static PANDN: = ;
/// Compare packed data for equal (SSE2).
pub static PCMPEQB: = ;
/// Compare packed data for equal (SSE2).
pub static PCMPEQD: = ;
/// Compare packed data for equal (SSE4.1).
pub static PCMPEQQ: = ;
/// Compare packed data for equal (SSE2).
pub static PCMPEQW: = ;
/// Compare packed signed byte integers for greater than (SSE2).
pub static PCMPGTB: = ;
/// Compare packed signed doubleword integers for greater than (SSE2).
pub static PCMPGTD: = ;
/// Compare packed signed quadword integers for greater than (SSE4.2).
pub static PCMPGTQ: = ;
/// Compare packed signed word integers for greater than (SSE2).
pub static PCMPGTW: = ;
/// Extract doubleword or quadword, depending on REX.W (SSE4.1).
pub static PEXTR: = ;
/// Extract byte (SSE4.1).
pub static PEXTRB: = ;
/// Extract word (SSE4.1). There is a 3-byte SSE2 variant that can also move to m/16.
pub static PEXTRW: = ;
/// Insert doubleword or quadword, depending on REX.W (SSE4.1).
pub static PINSR: = ;
/// Insert byte (SSE4.1).
pub static PINSRB: = ;
/// Insert word (SSE2).
pub static PINSRW: = ;
/// Compare packed signed byte integers in xmm1 and xmm2/m128 and store packed maximum values in
/// xmm1 (SSE4.1).
pub static PMAXSB: = ;
/// Compare packed signed doubleword integers in xmm1 and xmm2/m128 and store packed maximum
/// values in xmm1 (SSE4.1).
pub static PMAXSD: = ;
/// Compare packed signed word integers in xmm1 and xmm2/m128 and store packed maximum values in
/// xmm1 (SSE2).
pub static PMAXSW: = ;
/// Compare packed unsigned byte integers in xmm1 and xmm2/m128 and store packed maximum values in
/// xmm1 (SSE2).
pub static PMAXUB: = ;
/// Compare packed unsigned doubleword integers in xmm1 and xmm2/m128 and store packed maximum
/// values in xmm1 (SSE4.1).
pub static PMAXUD: = ;
/// Compare packed unsigned word integers in xmm1 and xmm2/m128 and store packed maximum values in
/// xmm1 (SSE4.1).
pub static PMAXUW: = ;
/// Compare packed signed byte integers in xmm1 and xmm2/m128 and store packed minimum values in
/// xmm1 (SSE4.1).
pub static PMINSB: = ;
/// Compare packed signed doubleword integers in xmm1 and xmm2/m128 and store packed minimum
/// values in xmm1 (SSE4.1).
pub static PMINSD: = ;
/// Compare packed signed word integers in xmm1 and xmm2/m128 and store packed minimum values in
/// xmm1 (SSE2).
pub static PMINSW: = ;
/// Compare packed unsigned byte integers in xmm1 and xmm2/m128 and store packed minimum values in
/// xmm1 (SSE2).
pub static PMINUB: = ;
/// Compare packed unsigned doubleword integers in xmm1 and xmm2/m128 and store packed minimum
/// values in xmm1 (SSE4.1).
pub static PMINUD: = ;
/// Compare packed unsigned word integers in xmm1 and xmm2/m128 and store packed minimum values in
/// xmm1 (SSE4.1).
pub static PMINUW: = ;
/// Multiply the packed signed word integers in xmm1 and xmm2/m128, and store the low 16 bits of
/// the results in xmm1 (SSE2).
pub static PMULLW: = ;
/// Multiply the packed doubleword signed integers in xmm1 and xmm2/m128 and store the low 32
/// bits of each product in xmm1 (SSE4.1).
pub static PMULLD: = ;
/// Pop top of stack into r{16,32,64}; increment stack pointer.
pub static POP_REG: = ;
/// Returns the count of number of bits set to 1.
pub static POPCNT: = ;
/// Bitwise OR of xmm2/m128 and xmm1 (SSE2).
pub static POR: = ;
/// Shuffle bytes in xmm1 according to contents of xmm2/m128 (SSE3).
pub static PSHUFB: = ;
/// Shuffle the doublewords in xmm2/m128 based on the encoding in imm8 and
/// store the result in xmm1 (SSE2).
pub static PSHUFD: = ;
/// Shift words in xmm1 by imm8; the direction and sign-bit behavior is controlled by the RRR
/// digit used in the ModR/M byte (SSE2).
pub static PS_W_IMM: = ;
/// Shift doublewords in xmm1 by imm8; the direction and sign-bit behavior is controlled by the RRR
/// digit used in the ModR/M byte (SSE2).
pub static PS_D_IMM: = ;
/// Shift quadwords in xmm1 by imm8; the direction and sign-bit behavior is controlled by the RRR
/// digit used in the ModR/M byte (SSE2).
pub static PS_Q_IMM: = ;
/// Shift words in xmm1 left by xmm2/m128 while shifting in 0s (SSE2).
pub static PSLLW: = ;
/// Shift doublewords in xmm1 left by xmm2/m128 while shifting in 0s (SSE2).
pub static PSLLD: = ;
/// Shift quadwords in xmm1 left by xmm2/m128 while shifting in 0s (SSE2).
pub static PSLLQ: = ;
/// Shift words in xmm1 right by xmm2/m128 while shifting in 0s (SSE2).
pub static PSRLW: = ;
/// Shift doublewords in xmm1 right by xmm2/m128 while shifting in 0s (SSE2).
pub static PSRLD: = ;
/// Shift quadwords in xmm1 right by xmm2/m128 while shifting in 0s (SSE2).
pub static PSRLQ: = ;
/// Shift words in xmm1 right by xmm2/m128 while shifting in sign bits (SSE2).
pub static PSRAW: = ;
/// Shift doublewords in xmm1 right by xmm2/m128 while shifting in sign bits (SSE2).
pub static PSRAD: = ;
/// Subtract packed byte integers in xmm2/m128 from packed byte integers in xmm1 (SSE2).
pub static PSUBB: = ;
/// Subtract packed word integers in xmm2/m128 from packed word integers in xmm1 (SSE2).
pub static PSUBW: = ;
/// Subtract packed doubleword integers in xmm2/m128 from doubleword byte integers in xmm1 (SSE2).
pub static PSUBD: = ;
/// Subtract packed quadword integers in xmm2/m128 from xmm1 (SSE2).
pub static PSUBQ: = ;
/// Subtract packed signed byte integers in xmm2/m128 from packed signed byte integers in xmm1
/// and saturate results (SSE2).
pub static PSUBSB: = ;
/// Subtract packed signed word integers in xmm2/m128 from packed signed word integers in xmm1
/// and saturate results (SSE2).
pub static PSUBSW: = ;
/// Subtract packed unsigned byte integers in xmm2/m128 from packed unsigned byte integers in xmm1
/// and saturate results (SSE2).
pub static PSUBUSB: = ;
/// Subtract packed unsigned word integers in xmm2/m128 from packed unsigned word integers in xmm1
/// and saturate results (SSE2).
pub static PSUBUSW: = ;
/// Set ZF if xmm2/m128 AND xmm1 result is all 0s; set CF if xmm2/m128 AND NOT xmm1 result is all
/// 0s (SSE4.1).
pub static PTEST: = ;
/// Push r{16,32,64}.
pub static PUSH_REG: = ;
/// Logical exclusive OR (SSE2).
pub static PXOR: = ;
/// Near return to calling procedure.
pub static RET_NEAR: = ;
/// General rotation opcode. Kind of rotation depends on encoding.
pub static ROTATE_CL: = ;
/// General rotation opcode. Kind of rotation depends on encoding.
pub static ROTATE_IMM8: = ;
/// Round scalar doubl-precision floating-point values.
pub static ROUNDSD: = ;
/// Round scalar single-precision floating-point values.
pub static ROUNDSS: = ;
/// Subtract with borrow r{16,32,64} from r/m of the same size.
pub static SBB: = ;
/// Set byte if overflow (OF=1).
pub static SET_BYTE_IF_OVERFLOW: = ;
/// Compute the square root of the packed double-precision floating-point values and store the
/// result in xmm1 (SSE2).
pub static SQRTPD: = ;
/// Compute the square root of the packed double-precision floating-point values and store the
/// result in xmm1 (SSE).
pub static SQRTPS: = ;
/// Compute square root of scalar double-precision floating-point value.
pub static SQRTSD: = ;
/// Compute square root of scalar single-precision value.
pub static SQRTSS: = ;
/// Subtract r{16,32,64} from r/m of same size.
pub static SUB: = ;
/// Subtract packed double-precision floating-point values in xmm2/mem from xmm1 and store result
/// in xmm1 (SSE2).
pub static SUBPD: = ;
/// Subtract packed single-precision floating-point values in xmm2/mem from xmm1 and store result
/// in xmm1 (SSE).
pub static SUBPS: = ;
/// Subtract the low double-precision floating-point value in xmm2/m64 from xmm1
/// and store the result in xmm1.
pub static SUBSD: = ;
/// Subtract the low single-precision floating-point value in xmm2/m32 from xmm1
/// and store the result in xmm1.
pub static SUBSS: = ;
/// AND r8 with r/m8; set SF, ZF, PF according to result.
pub static TEST_BYTE_REG: = ;
/// AND {r16, r32, r64} with r/m of the same size; set SF, ZF, PF according to result.
pub static TEST_REG: = ;
/// Count the number of trailing zero bits.
pub static TZCNT: = ;
/// Compare low double-precision floating-point values in xmm1 and xmm2/mem64
/// and set the EFLAGS flags accordingly.
pub static UCOMISD: = ;
/// Compare low single-precision floating-point values in xmm1 and xmm2/mem32
/// and set the EFLAGS flags accordingly.
pub static UCOMISS: = ;
/// Raise invalid opcode instruction.
pub static UNDEFINED2: = ;
/// imm{16,32} XOR r/m{16,32,64}, possibly sign-extended.
pub static XOR_IMM: = ;
/// r/m{16,32,64} XOR sign-extended imm8.
pub static XOR_IMM8_SIGN_EXTEND: = ;
/// r/m{16,32,64} XOR register of the same size.
pub static XOR: = ;
/// r/m8 XOR r8.
pub static XORB: = ;
/// Bitwise logical XOR of packed double-precision floating-point values.
pub static XORPD: = ;
/// Bitwise logical XOR of packed single-precision floating-point values.
pub static XORPS: = ;