Integer Math  
ADD  dest,src        add two operands, placing result in dest
dest (src + dest)
ADC  dest,src        add two operands, using carry from previous ADD
dest (src + dest + CF)
INC  dest            add 1 to dest (reg or r/m)
dest (dest+1)

SUB  dest,src        subtract src from dest, leaving result in dest
dest (dest - src)
SBB  dest,src        subtract using borrow (carry flag) from previous SUB
dest ((dest - src) - CF)
DEC  dest            subtract 1 from dest (reg or r/m)
dest (dest - 1)

CMP  dest,src        compare (non-destructive subtract)
flags are set to indicate carry, overflow, etc.

NEG  dest            change sign of an operand
dest (0 - dest);

AAA                  adjust after ASCII addition
AL (AL corrected for ASCII addition)
AAS                  adjust for ASCII subtraction
AL (AL corrected for ASCII subtraction)
AAM                  adjust after ASCII multiply
AH:AL (AH:AL corrected for ASCII multiplication)
AAD                  adjust before ASCII division
AH:AL (AH:AL prepared for division of ASCII codes)

DAA                  adjust after BCD addition
AL (AL corrected for BCD addition)
DAS                  adjust for BCD subtraction
AL (AL corrected for BCD subtraction)

MUL src              multiply AL(AX) by unsigned value src (reg/mem)
AX (AL * src8)
DX:AX (AX * src16)
IMUL src             multiply AL(AX) by signed integer src (reg/mem)
AX (AL * immed8)
DX:AX (AX * immed16)
IMUL reg16,r/m,im16  multiply reg/mem by 16-bit immediate signed value 286+
reg16 (r/m8 * im16)
reg16 (r/m16 * im16)

DIV  src             divide accumulator by unsigned value src (reg/mem)
Division by 0 or result too large causes INT 0.
AL (AX   src8); AH (AX MOD src8)
AX (DX:AX   src16); DX (DX:AX MOD src16)
IDIV src             divide accumulator by unsigned value src (reg/mem)

CBW                  convert byte to word (sign-extend AL into AH)
AH (filled with bit-7 of AL)
CWD                  convert word to dword (sign-extend AX into DX)
DX (filled with bit-15 of AX)

  Bitwise Logic  
AND dest,src         logical AND (mask; reset dest bits which are 0 in src)
dest (dest & src)
TEST dest,src        non-destructive AND (bit test; JZ jumps if no match)
flags (set as for dest & src)

OR   dest,src        inclusive OR (set dest bits which are 1s in src)
dest (dest | src)

XOR  dest,src        exclusive OR (toggle dest bits which are 1s in src)
dest (dest ^ src)

NOT  dest            form 1's complement (toggle every bit in dest)
dest (~dest)

  Shifts and Rotates  
RCL  dest            Rotate dest left through Carry by 1 bit position
dest,CL          ...by CL bit positions
dest,cnt         ...by immediate count bit positions (mod 32)     386+

RCR  dest            Rotate dest right through Carry by 1 bit position
dest,CL          ...by CL bit positions
dest,cnt         ...by immediate count bit positions (mod 32)     386+

ROL  dest            Rotate dest left by 1 bit position
dest,CL          ...by CL bit positions
dest,cnt         ...by immediate count bit positions (mod 32)     386+

ROR  dest            Rotate dest right by 1 bit position
dest,CL          ...by CL bit positions
dest,cnt         ...by immediate count bit positions (mod 32)     386+

SHL/
SAL dest            Shift left by 1 bit position (multiply by 2)
dest,CL          ...by CL bit positions
dest,cnt         ...by immediate count bit positions (mod 32)     386+

SHR  dest            Shift right by 1 position (divide by 2)
dest,CL          ...by CL bit positions
dest,cnt         ...by immediate count bit positions (mod 32)     386+

SAR  dest            Shift arithmetic right (retain high bit) by 1 position
dest,CL          ...by CL bit positions
dest,cnt         ...by immediate count bit positions (mod 32)     386+
                                                                            

Arithmetic and Binary Logic Instructions