; 8088 mneumonic list for MAX assembler (with one correct usage)   
 
 AAA            ; ascii adjust for addition      
 AAD            ; ascii adjust for division
 AAM            ; ascii adjust for multiplication
 AAS            ; ascii adjust for subtraction
 ADC    ax,bx      ; add with carry 
 ADCBY  mem,2      ;  "   "     "   (bytes)     
 ADCWO [bx+si+1],2 ;  "   "     "   (words)
 ADD    ax,bx      ; add   
 ADDBY [bx+si+1],2 ;  "  (bytes)
 ADDWO  mem,2      ;  "  (words)
 AND    ax,bx      ; logical AND
 ANDBY  mem,2      ;    "     "  (bytes)
 ANDWO [bx+si+1],2 ;    "     "  (words)
 CALL   label      ; call procedures (subroutines)
 CALLFAR label     ; call far
 CBW    ; convert byte to word (AL to AX)
 CLC    ; clear carry flag
 CLD    ; clear direction Flag
 CLI    ; clear interrupt enable flag
 CMC    ; complement carry flag
 CMP    ax,bx      ; compare
 CMPBY [bx+si+1],2 ;    "    (bytes)
 CMPWO  mem,2      ;    "    (words)
 CMPSB  ; compare string bytes (DS:[SI] - ES:[DI], inc or dec SI & DI)
 CMPSW  ; compare string words                  "
 CWD    ; convert word to double word (AX to DX:AX)
 DAA    ; decimal adjust for addition
 DAS    ; decimal adjust for subtraction
 DEC    ax       ; decriment (subtract 1)
 DECBY  mem      ;     "     (bytes)
 DECWO [bx+si+1] ;     "     (words)
 DIV    bl       ; divide unsigned number in AX or DX:AX. see below
 DIVBY [bx+si+1] ;   "       "        "   "  AX. results in AL. remainder in AH (bytes)
 DIVWO  bx       ;   "       "        "   "  DX:AX.  "   "  AX.     "     "  DX (words)
 ESC    01,[bx]  ; used with math coprocessor
 HLT             ; halt until hardware interrupt occurs       
 IDIV   bx        ; divide signed number in AX or DX:AX. see below
 IDIVBY  mem      ;   "      "       "   "  AX. results in AL. remainder in AH (bytes)        
 IDIVWO [bx+si+1] ;   "      "       "   "  DX:AX.  "   "  AX.     "     "  DX         
 IMUL   bl        ; multiply signed number by AL or AX. see below
 IMULBY [bx+si+1] ;    "       "       "   "  AL. results in AX 
 IMULWO bx        ;    "       "       "   "  AX.    "    "  DX:AX
 IN     al,dx    ; input from a port
 INC    bh       ; increment (add 1)
 INCBY  mem      ;     "     (bytes)
 INCWO [bx+si+1] ;     "     (words)
 INT    21h     ; interrupt
 INTO           ; interrupt if overflow
 IRET           ; interrupt return

label:     ; a memory location for instructions to refer to    
 
 JA      label   ; jump if above
 JAE     label   ; jump if above or equal
 JB      label   ; jump if below
 JBE     label   ; jump if below or equal
 JC      label   ; jump if carry
 JCXZ    label   ; jump if CX is zero
 JE      label   ; jump if equal
 JG      label   ; jump if greater than
 JGE     label   ; jump if greater than or equal
 JL      label   ; jump if less than
 JLE     label   ; jump if less than or equal
 JMP     label   ; 2,3 or 5 byte jump (unconditional)
 JMPNEAR label   ; jump near (unconditional)
 JMPFAR  label   ; jump far (unconditional)
 JNA     label   ; jump if not above
 JNAE    label   ; jump if not above or equal
 JNB     label   ; jump if not below
 JNBE    label   ; jump if not below or equal
 JNC     label   ; jump if no carry
 JNE     label   ; jump if not equal
 JNG     label   ; jump if not greater than
 JNGE    label   ; jump if not greater than or equal
 JNL     label   ; jump if not less than
 JNLE    label   ; jump if not less than or equal
 JNO     label   ; jump if not overflow
 JNP     label   ; jump if not parity (odd)
 JNS     label   ; jump if not sign
 JNZ     label   ; jump if not zero
 JO      label   ; jump if overflow
 JP      label   ; jump if parity (even)
 JPE     label   ; jump if parity even
 JPO     label   ; jump if parity odd
 JS      label   ; jump if sign
 JZ      label   ; jump if zero
 LAHF            ; load AH from flags
 LDS    ax,label ; load pointer using DS  
 LEA    ax,label ; load effective address
 LES    ax,label ; load pointer using ES
 LOCK            ; lock out 2nd processor until done (prefix)
 LODSB           ; load string byte (from [SI] to AX, inc or dec SI)
 LODSW           ; load string word               "
 LOOP   label    ; loop to label until CX is zero (no flags used)
 LOOPE  label    ; loop if equal (ZF=1)           "
 LOOPNE label    ; loop if not equal              "
 LOOPNZ label    ; loop if not zero               "
 LOOPZ  label    ; loop if zero (ZF=1)            "
 MOV    al,bl      ; move
 MOVBY  mem,2      ;  "   (byte)
 MOVWO [bx+si+1],2 ;  "   (word)
 MOVSB           ; move string byte (DS:[SI] to ES:[DI], inc or dec SI & DI)
 MOVSW           ; move string word                    "
 MUL    bx       ; multiply unsigned number by AL or AX. see below 
 MULBY [bx+si+1] ;     "       "       "    "  AL. results in AX
 MULWO  mem      ;     "       "       "    "  AX.    "    "  DX:AX
 NEG    ax       ; negate (change sign)
 NEGBY [bx+si+1] ;   "    (bytes)
 NEGWO  mem      ;   "    (words)
 NOP             ; no operation (used as marker when label on separate line)
 NOT    ax       ; reverse each bit
 NOTBY  mem      ;    "     "    "  (bytes)
 NOTWO [bx+si+1] ;    "     "    "  (words)
 OR     ax,bx      ; logical OR
 ORBY   mem,2      ;    "    "  (bytes)
 ORWO  [bx+si+1],2 ;    "    "  (words)
 OUT   dx,al   ; output to a port
 POP   ax      ; pop off the stack
 POPF          ; pop flags
 PUSH  [bp+di] ; push onto the stack
 PUSHF         ; push flags
 RCL    ax,cl       ; rotate through carry left
 RCLBY  mem,1       ;   "       "      "    "   (bytes)
 RCLWO [bx+si+1],cl ;   "       "      "    "   (words)
 RCR    bx,1        ; rotate through carry right
 RCRBY [bx+si+1],cl ;   "       "      "    "   (bytes)
 RCRWO  mem,cl      ;   "       "      "    "   (words)
 REP       ; repeat (prefix for string primitives)
 REPE      ; repeat while equal     "
 REPNE     ; repeat while not equal "
 REPNZ     ; repeat while not zero  "
 REPZ      ; repeat while zero      "
 RET       ; return
 RETF      ; return far
 ROL    ax,cl      ; rotate left
 ROLBY  mem,cl     ;   "     "   (bytes)
 ROLWO [bx+si+1],1 ;   "     "   (words)
 ROR    ax,1        ; rotate right
 RORBY  mem,1       ;   "     "   (bytes)
 RORWO [bx+si+1],cl ;   "     "   (words)
 SAHF              ; store AH into flags
 SAR    bx,cl      ; shift arithmetic right (signed divide by 2, cl times)
 SARBY [bx+si+1],1 ;   "       "       "    (bytes) 
 SARWO  mem,cl     ;   "       "       "    (words)
 SBB    ax,bx      ; subtract with borrow
 SBBBY  mem,2      ;    "       "    "    (bytes)
 SBBWO [bx+si+1],2 ;    "       "    "    (words)
 SCASB    ; scan string byte (compare AL - ES:[DI], inc or dec DI)
 SCASW    ; scan string word (compare AX - ES:[DI], inc or dec DI)
 SHL    ax,cl       ; shift logical or arithmetic left (mul by 2, cl times)
 SHLBY  mem,cl      ;   "      "    "      "       "   (bytes)  
 SHLWO  [bx+si+1],1 ;   "      "    "      "       "   (words) (*2, 1 time)
 SHR    ax,1        ; shift logical right (unsigned divide by 2, one time)
 SHRBY  mem,1       ;   "      "      "   (bytes)
 SHRWO [bx+si+1],cl ;   "      "      "   (words) (uns. divide by 2, cl times)
 STC     ; set carry flag
 STD     ; set direction flag
 STI     ; set interupt enable flag
 STOSB   ; store string byte (from AL to ES:[DI], inc or dec DI)
 STOSW   ; store string word (from AX to ES:[DI], inc or dec DI)                
 SUB    ax,bx      ; subtract
 SUBBY [bx+si+1],2 ;    "     (bytes)
 SUBWO  mem,2      ;    "     (words)
 TEST   ax,bx       ; logical AND for flags only
 TESTBY mem,2       ;    "     "   "    "    "   (bytes)
 TESTWO [bx+si+1],2 ;    "     "   "    "    "   (words)
;WAIT         ; wait until math coprocessor is finished (registered version)
 XCHG  ax,bx  ; exchange
 XLAT         ; translate (set AL to [BX + unsigned AL] )
 XOR    ax,bx      ; Exclusive-OR
 XORBY [bx+si+1],2 ;      "       (bytes)
 XORWO  mem,2      ;      "       (words)

mem DW 0      ; a memory location (variable) for instructions to refer to
