ALAB│!┐'Æ ▄  Assembler Laboratory Copyright (c) 1994,1995 by Kurt I. Groenbech  ▄
 ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
!Welcome to Assembler Laboratory! ┘
Alab is a program developed for assembler programmers, due to the lack of good IDE's which are so extremely good to have in the proccess of writing the source code, assemble it, linking the object file(s), and running the executable program. I began to develop this program long before I even knew there was other programs out there which do/look almost the same. I first started this project because I think this process should be totally uneccessary during development: O
 % Write the source code in your favorite editor.
 % Save the file and exit the editor.
 % Assemble the file from the command line.
 % Return to editor if errors reported
 % Link the object file(s) to an executable program
 % Run the program.
 % Reboot the machine if it crashes
 % Return to the editor to make further modifications.
å
In Assembler Laboratory you have several standalone choices which makes this process uneccessary. Read the documentation (ALAB.DOC). ,
I have also included a program called 'Unhang' which actually can prevent your machine from hanging in many cases. Just run 'unhang.com' before you begin programming and if the machine hangs when you run your program, just press Ctrl+Shift+Backspace and Unhang will hopefully return to Asm Lab/DOS. í
NBNB! Unhang really is a shitty little program. I had no time to program it better, and no time to make it a TSR. It's just a little handy thing in many cases. p
I will perhaps continue to extend this program, due to the fact that I have many ideas to this IDE, and it very much depends on how much response I get from you people out there. I am very anxious to see have the world welcomes it. I would be very happy if you could send me your suggestions on changes/additions to this program! See 'ALAB.DOC' on how to contact me. '
 ■■■■■■■■■■■■ HELP CONTENTS ■■■■■■■■■■■
   ┌───────────────────────┐
   │ Editor Commands       └────────────┐
   │ ┌──────────────────────────────────────┐
   │ │ Error highlighting │                 │
   │ │ Ascii Table(!read) │                 │
   │ │ Opcode help        │                 │
   │ │                    │                 │
   │ │ Sorry, no time for │ further help! :(│
   └─│                    │                 │
     │                    │                 │
     └──────────────────────────────────────┘
KÑ	╙
'"
 Assembler Laboratory Help Index
╩
Sorry :( Some shouted for an Index, but I have not had the time (..;). What should I have put here then? Everything is pretty much selfexplanatory... If you wonder about something, check out the docs. 'i
 ┌────────────────────────────────────┐
 │ ▄ Editor Commands                  │
 │ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀                 │
 │    Block commands                  │
 │    Cursor-movement commands        │
 │    Insert & Delete commands        │
 │    Miscellaneous commands          │
 │                                    │
 └────────────────────────────────────┘
Ç¿╨°'C
 ▄ Block Commands
 ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
 ══════════════════════╤══════════════════════
  Mark block begin     │ Ctrl-K B
  Copy block           │ Ctrl-K K
  Cut block            │ Ctrl-K Y
  Paste block          │ Ctrl-K C
  Hide block           │ Ctrl-K H
  Comment block        │ Ctrl-K G
  Uncomment block      │ Ctrl-K U
'α
 ▄ Cursor Movement Commands
 ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
 ═════════════════╤══════════════════════
  Character left  │ Ctrl-S or Left arrow
  Character right │ Ctrl-D or Right arrow
  Word left       │ Ctrl-A or Ctrl-Left arrow
  Word right      │ Ctrl-F or Ctrl-Right arrow
  Line up         │ Ctrl-E or Up arrow
  Line down       │ Ctrl-X or Down arrow
  Scroll up       │ Ctrl-W
  Scroll down     │ Ctrl-Z
  Page up         │ Ctrl-R or PgUp
  Page down       │ Ctrl-C or PgDn
'f
 ▄ Insert & Delete Commands
 ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
 ══════════════════════╤══════════════════════
  Insert mode on/off   │ Ctrl-V or Ins
  Insert line          │ Ctrl-N
  Delete line          │ Ctrl-Y
  Delete to end of line│ Ctrl-Q Y
  Delete character left│ Ctrl-H or Backspace
  Delete character     │ Ctrl-G or Del
  Delete word right    │ Ctrl-T
'╔
 ▄ Miscellaneous Editor Commands
 ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
 ══════════════════════╤══════════════════════
  Menu bar             │ F10
  Save and edit        │ Ctrl-K S or F2 (default)
  New file             │ Shift-F8 (default)
  Close active window  │ Alt-F3 (default)
                       │
  Tab                  │ Tab
  Floating Tab         │ Shift+Tab
  Auto indent on/off   │ Ctrl-O
  Undo                 │ Ctrl-U
                       │
  Find                 │ Ctrl-Q F
  Find & replace       │ Ctrl-Q A
  Open include file    │ Ctrl-Q I Automatically opens include file specified
                       │          on cursor line
  Repeat last find     │ Ctrl-L
  Abort operation      │ Esc
'.
 ▄ Error Highlighting
 ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
▒
 Every time one file is assembled, if there are errors an error window
 pops up. Here you can scroll through the errors and press <SPACE> to
 jump directly to the right error.
' 
 ▄ Ascii Table
 ▀▀▀▀▀▀▀▀▀▀▀▀▀▀
M
 Just one thing here. You can use these keycombinations in the Ascii Table:
╗
 Ctrl+Alt+C   - Put the character into the editor behind.
 Ctrl+Alt+D   - Put the decimal value into the editor behind.
 Ctrl+Alt+G   - Put the hexadecimal value into the editor behind.
' 
 ▄ Opcode help
 ▀▀▀▀▀▀▀▀▀▀▀▀▀▀
O
You can use SHIFT+up/down/right/left to move about in the online opcode help. 'H ▄ ≡ (System) menu  (Alt-Spacebar)
 ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
\The System menu appears on the far left of the menu bar and is represented by the ≡ symbol. ' ▄ ≡ | About
 ▀▀▀▀▀▀▀▀▀▀▀▀
}When you choose the About command from the ≡ (System) menu, a dialog box appears, showing copyright and version information. G
To close the box, press Esc, Space, or Enter, or click the OK button. ' ▄ ≡ | Refresh
 ▀▀▀▀▀▀▀▀▀▀▀▀▀▀
5The Refresh Display command restores the IDE screen. H
This is handy if your program has accidentally overwritten the screen. '$ ▄ File  (Alt-F)
 ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
ÄThe File menu offers choices for opening and loading existing files, creating new files, shelling to DOS, saving files, and exiting SmartAsm. â
 Open               New               Save
 Save As            Change Dir        Print
 DOS command        DOS shell         Exit
	╡╚┌α≤
	1' ▄ File|Open
 ▀▀▀▀▀▀▀▀▀▀▀▀
èThe Open command displays the Open a File dialog box. In this dialog box, you select the program file you wish to open in an Edit window. ' ▄ File|New
 ▀▀▀▀▀▀▀▀▀▀▀
ñNew opens a new edit window with the default name 'NONAMExx.ASM' (the xx stands for a number between 01 and 99) and automatically makes the new Edit window active. é
These NONAME files are uses as a temporary edit buffer; Assembler Laboratory prompts you to name a NONAME file when you save it. ' ▄ File|Save
 ▀▀▀▀▀▀▀▀▀▀▀▀
JThe Save command saves the file that's in the active edit window to disk. ╚
If the file has a default name (such as NONAME01.ASM), Assembler Laboratory opens the Save File As dialog box so you can rename the file and save it in a different directory or on a different drive. ╜'' ▄ File|Save As...
 ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
»Save As opens up the Save File As dialog box, where you can save the file in the active Edit window under a different name, in a different directory, or on a different drive. \
You can enter the new filename, including the drive and directory, and click or choose OK. A
All windows containing this file are updated with the new name. '- ▄ File|Change dir...
 ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
nFile|Change dir brings up the Change Directory dialog box, where you can specify a directory to make current. b
The current directory is the one Assembler Laboratory uses to save files, and to look for files. '- ▄ File|Print file...
 ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
AThe Print command prints the contents of the active Edit window. 
To print selected text (rather than the window's entire contents), copy the selected text to the clipboard. Then go to the clipboard (from the Edit menu) and choose File|Save as.... Then type in PRN/LPT1/LPT2/LPT3.. depending on what port your printer is on. '- ▄ File|DOS command..
 ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
⌐The DOS command lets you type in a doscommand in a window and then select OK or Cancel. Assembler Laboratory then executes that command via the improved exec procedure. '% ▄ File|DOS shell
 ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
~With the DOS Shell command, you can leave Assembler Laboratory temporarily to perform a DOS command or enter another program. S
To return to Assembler Laboratory, type EXIT at the DOS prompt, then press Enter. ' ▄ File|Exit
 ▀▀▀▀▀▀▀▀▀▀▀▀
]The Exit command exits Assembler Laboratory, removes it from memory, and returns you to DOS. o
If you've modified a source file without saving it, Assembler Laboratory prompts you to do so before exiting. '$ ▄ Edit  (Alt-E)
 ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
èThe Edit menu provides commands to cut, copy and paste text in windows. It also provides other commands assotiated with the edit windows. D
You can also open a Clipboard window to view or edit its contents. ' ▄ Edit|Undo
 ▀▀▀▀▀▀▀▀▀▀▀
0Undos the last changes made in the Edit window. ' ▄ Edit|Cut
 ▀▀▀▀▀▀▀▀▀▀
cThe Cut command removes the selected text from your document and places the text in the Clipboard. ╧
You can choose Edit|Paste to paste the cut text into any another document (or somewhere else in the same document). The text remains selected in the Clipboard so you can paste it as many times as you want. æ' ▄ Edit|Copy
 ▀▀▀▀▀▀▀▀▀▀▀
¬The Copy command leaves the selected text intact, but places an exact copy of it in the Clipboard. To paste the copied text into any another document, choose Edit|Paste. ╛' ▄ Edit|Paste
 ▀▀▀▀▀▀▀▀▀▀▀
oThe Paste command inserts the selected text from the Clipboard into the current window at the cursor position. '. ▄ Edit|Show Clipboard
 ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
¡The Show Clipboard command opens the Clipboard, which stores the text you cut and copy from other windows. Any text you cut or copy is appended at the end of the Clipboard. b
The currently selected (highlighted) Clipboard text is the text Alab uses when you choose Paste. 7' ▄ Edit|Clear
 ▀▀▀▀▀▀▀▀▀▀▀▀
TThe Clear command removes the selected text but does not put it into the Clipboard. '& ▄ Edit|Repeat Key
 ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
The Repeat Key command lets you repeat any key X number of times. First you specify how many times the key shall be repeated, and the you get back into the editor. The first key you then press, is repeated the specified number of times. (fine for lines ext.) ', ▄ Edit|Block Comment
 ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
»When you choose the Block Comment command, Alab places a comment delimiter (';') on the first column of all the lines in the selected text, which then comments out the block. H
Block Uncomment is quite the opposit (removes the comment delimiters). '< ▄ Edit|Expand tabs to spaces
 ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
SThis command scans through the source code and replaces all the tabs with 1 space. '@ ▄ Edit|Compress tabs to spaces
 ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
Ö
This command scans through the source code and replaces a block of 8 spaces with a tab character instead. NB! THIS FUNCTION DOES NOT WORK PROPERLY YET! '' ▄ Search  (Alt-S)
 ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
The Search menu provides commands to search for text in the current Edit window, or you can jump directly to a specified line. %
You can choose from these commands: ;
 Find           Replace
 Search again   Go to line number
$╬%▌&µ'⌡' ▄ Search|Find
 ▀▀▀▀▀▀▀▀▀▀▀▀▀
bThe Find command displays the Find dialog box, where you type in the text you want to search for. v
You can set several options in this dialog box that affect the search. (Ctrl-Q F gives a shortcut to the dialog box) '$ ▄ Search|Replace
 ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
ìThe Replace command displays the Replace dialog box, where you type in the text you want to search for and text you want to replace it with. '. ▄ Search|Search again
 ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
CThe Search Again command repeats the last Find or Replace command. '> ▄ Search|Go to line number...
 ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
}The Go To Line Number command displays the Go To Line Number dialog box, which prompts for the line number you want to find. '* ▄ Assemble|Assemble
 ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
W
If there is NO project open, this happens: ------------------------------------------ m
The current sourcefile is assembled, and an .OBJ-file is generated in the same directory as the sourcefile. U
If there IS a project open, this happens: ----------------------------------------- 
Excactly the same as above. 
 
'	" ▄ Assemble|Link
 ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
W
If there is NO project open, this happens: ------------------------------------------ ç
The linker is invoked with the current sourcefile as the main file (it will be the name of the .exe or .com file), and the files in Options|Linker/Object file(s) and Options|Linker/Library file(s) are linked with the object file generated from the current sourcefile. ( so, you do not have to specify the objectfile generated from the current sourcefile in Options|Linker/Object file(s)! ) U
If there IS a project open, this happens: ----------------------------------------- M
The name of the .EXE/.COM-file will be the same as the name of the project. b
Alab goes through all the files specified in the Project Manager window, and if if the file is a ╧
 OBJ-file: Adds it to the parameters to pass to the linker.
 LIB-file: Adds it to the parameters to pass to the linker.
 ASM-file:
 Checks wether the file is modified. If not (and an .OBJ-file exists), the
╝OBJ-file is added to the parameters to pass to the linker. If the ASM-file is modified, then it is assembled, and the .OBJ-file generated is added to the parameters to pass to the linker. N
Then the parameters is passed to the linker, and an executable is generated. '" ▄ Assemble|Make
 ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
', ▄ Assemble|Build all
 ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
'( ▄ Project  (Alt-P)
 ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
fThe Project Menu lets you create/maintain a project file. A project file is a file which holds all information about a program (project). In the project file you have a list of all .asm, .obj and .lib files which is to be included in the project. Se Link, Make and Build All for further information about what happens when you link, make or build a project. )#*)+2	': ▄ Tools|Procedure Worksheet
 ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
▒Procedure Worksheet is a completely new tool in assembly IDE's. You get a window with a complete procedure overview. You then can go to a procedure and press one of these keys: +
 Ctrl-Space    Jump directly to procedure
'2 ▄ Tools|Macro Worksheet
 ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
1The same as Procedure Worksheet, but for macros. -?'0 ▄ Tools|Heuristic Scan
 ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
╧Have you ever experienced this : You have gone through the program a thousand times, but everything seems alright. But the program still keeps hanging/bugging when you run it?? After xxx number of minutes/hours of stepping through the program you find for example that the only error is a bitchy little 'ret' who's missing in one of the procedures. After you fix it, the whole program works just fine! Well, here is where heuristic scan comes in handy. Heuristic scan assumes that you have compiled the program and that the assembler reported no errors. Then heuristic scan scans through the source-code for little bugs such as missing ret's, the DS-register doesn't point to data register when accessing data, and so forth. "Wow! Cool! Now I just have to press the shortcut key for heuristic scan (or go via the menu), and heuristic scan will find most of the little shitty bugs for me!" (the error output file for heuristic scan is 'heuristi.err' in the Asm Lab directory) '≈ AAA          AAD          AAM         AAS         ADC         ADD
 AND          ARPL         BOUND       BSF         BSR         BSWAP
 BT           BTC          BTR         BTS         CALL        CBW
 CDQ          CLC          CLD         CLI         CLTS        CMC
 CMP          CMPS         CMPXCHG     CWD         CWDE        DAA
 DAS          DEC          DIV         ENTER       ESC         HLT
 IDIV         IMUL         IN          INC         INS         INT
 INTO         INVD         INVLPG      IRET_IRETD  Jxx         JCXZ_JECXZ
 JMP          LAHF         LAR         LDS         LEA         LEAVE
 LES          LFS          LGDT        LIDT        LGS         LLDT
 LMSW         LOCK         LODS        LOOP        LOOPE_LOOPZ LOOPNZ_LOOPNE
8
 LSL          LSS          LTR         MOV         MOVS        MOVSX
 MOVZX        MUL          NEG         NOP         NOT         OR
 OUT          OUTS         POP         POPA_POPAD  POPF_POPFD  PUSH
 PUSHA_PUSHAD PUSHF_PUSHFD RCL         RCR         REP         REPE_REPZ
 REPNE_REPNZ  RET_RETF     ROL         ROR         SAHF        SAL_SHL
 SAR          SBB          SCAS        SETAE_SETNB SETB_SETNAE SETBE_SETNA
 SETE_SETZ    SETNE_SETNZ  SETL_SETNGE SETGE_SETNL SETLE_SETNG SETG_SETNLE
 SETS         SETNS        SETC        SETNC       SETO        SETNO
 SETP_SETPE   SETNP_SETPO  SGDT        SIDT        SHL         SHR
 SHLD_SHRD    SLDT         SMSW        STC         STD         STI
 STOS         STR          SUB         TEST        VERR        VERW
 WAIT_FWAIT   WBINVD       XCHG        XLAT_XLATB  XOR
ë1234(546@7E8R9_:k;w<â=è>ù?ñ@░A╝B╚C═D┌EτF≤G HIJK*L6MBNNOSP`QmRySàTæUûVúW░X╝Y╚Z╘[┘\µ]≤^ 
_`
a#b0c=dIeUfaghhuiéjÄkÜlªm¼n╣o╞p╥q▐rΩ
s·tuv w,x8y?zL{Y|e}q~}üÇÄü¢éº
â│
ä┐à┼å╥ç▀êδë≈è	ïîì(Ä4Å@ÉLæUÆbôoö{òçûôùá	ÿ¡Ö║Ü╞¢╥£▐¥δ₧°ƒáíó)ú0
ñ=ÑJªVºb¿n⌐s	¬Ç½ì¼Ö¡Ñ«▒»╢░├▒╨▓▄│Φ┤⌠╡·
╢╖╕ 
╣,'! AAA - Ascii Adjust for Addition
K
        Usage:  AAA
        Modifies flags: AF CF (OF,PF,SF,ZF undefined)
e
        Changes contents of AL to valid unpacked decimal.  The high order
        nibble is zeroed.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
=
        none              8     3     4     3             1
'! AAD - Ascii Adjust for Division
K
        Usage:  AAD
        Modifies flags: SF ZF PF (AF,CF,OF undefined)
╧
        Used before dividing unpacked decimal numbers.   Multiplies AH by
        10 and the adds result into AL.  Sets AH to zero.  This instruction
        is also known to have an undocumented behavior.
(
        AL := 10*AH+AL
        AH := 0
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
=
        none              60    14    19    14            2
'' AAM - Ascii Adjust for Multiplication
L

        Usage:  AAM
        Modifies flags: PF SF ZF (AF,CF,OF undefined)
/
        AH := AL / 10
        AL := AL mod 10
$
        Used after multiplication of two unpacked decimal numbers, this
        instruction adjusts an unpacked decimal number.  The high order
        nibble of each byte must be zeroed before using this instruction.
        This instruction is also known to have an undocumented behavior.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
=
        none              83    16    17    15            2
'$ AAS - Ascii Adjust for Subtraction
K
        Usage:  AAS
        Modifies flags: AF CF (OF,PF,SF,ZF undefined)
p
        Corrects result of a previous unpacked decimal subtraction in AL.
        High order nibble is zeroed.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
=
        none              8     3     4     3             1
' ADC - Add With Carry
L
        Usage:  ADC     dest,src
        Modifies flags: AF CF OF SF PF ZF
Ç
        Sums two binary operands placing the result in the destination.
        If CF is set, a 1 is added to the destination.
|
                                Clocks                  Size
        Operands         808x  286   386   486          Bytes
ò
        reg,reg           3     2     2     1             2
        mem,reg         16+EA   7     7     3            2-4  (W88=24+EA)
        reg,mem          9+EA   7     6     2            2-4  (W88=13+EA)
        reg,immed         4     3     2     1            3-4
        mem,immed       17+EA   7     7     3            3-6  (W88=23+EA)
        accum,immed       4     3     2     1            2-3
' ADD - Arithmetic Addition
L
        Usage:  ADD     dest,src
        Modifies flags: AF CF OF PF SF ZF
o
        Adds "src" to "dest" and replacing the original contents of "dest".
        Both operands are binary.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
ò
        reg,reg           3     2     2     1             2
        mem,reg         16+EA   7     7     3            2-4  (W88=24+EA)
        reg,mem          9+EA   7     6     2            2-4  (W88=13+EA)
        reg,immed         4     3     2     1            3-4
        mem,immed       17+EA   7     7     3            3-6  (W88=23+EA)
        accum,immed       4     3     2     1            2-3
' AND - Logical And
X
        Usage:  AND     dest,src
        Modifies flags: CF OF PF SF ZF (AF undefined)
g
        Performs a logical AND of the two operands replacing the destination
        with the result.
|
                                Clocks                  Size
        Operands         808x  286   386   486          Bytes
ò
        reg,reg           3     2     2     1             2
        mem,reg         16+EA   7     7     3            2-4  (W88=24+EA)
        reg,mem          9+EA   7     6     1            2-4  (W88=13+EA)
        reg,immed         4     3     2     1            3-4
        mem,immed       17+EA   7     7     3            3-6  (W88=23+EA)
        accum,immed       4     3     2     1            2-3
'A ARPL - Adjusted Requested Privilege Level of Selector (286+ PM)
[
        Usage:  ARPL    dest,src
        (286+ protected mode)
        Modifies flags: ZF
²
        Compares the RPL bits of "dest" against "src".  If the RPL bits
        of "dest" are less than "src", the destination RPL bits are set
        equal to the source RPL bits and the Zero Flag is set.  Otherwise
        the Zero Flag is cleared.
|
                                Clocks                  Size
        Operands         808x  286   386   486          Bytes
y
        reg,reg           -     10    20    9             2
        mem,reg           -     11    21    9             4
'* BOUND - Array Index Bound Check (80188+)
@
        Usage:  BOUND   src,limit
        Modifies flags: None
@
        Array index in source register is checked against upper and lower
        bounds in memory source.  The first word located at "limit" is
        the lower boundary and the word at "limit+2" is the upper array bound.
        Interrupt 5 occurs if the source value is less than or higher than
        the source.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
y
        reg16,mem32       -   nj=13 nj=10   7             2
        reg32,mem64       -   nj=13 nj=10   7             2

        - nj = no jump taken
' BSF - Bit Scan Forward (386+)
=
        Usage:  BSF     dest,src
        Modifies flags: ZF

        Scans source operand for first bit set.  Sets ZF if a bit is found
        set and loads the destination with an index to first set bit.  Clears
        ZF is no bits are found set.  BSF scans forward across bit pattern
        (0-n) while BSR scans in reverse (n-0).
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
⌠
        reg,reg           -     -   10+3n  6-42           3
        reg,mem           -     -   10+3n  7-43          3-7
        reg32,reg32       -     -   10+3n  6-42          3-7
        reg32,mem32       -     -   10+3n  7-43          3-7
'  BSR - Bit Scan Reverse  (386+)
=
        Usage:  BSR     dest,src
        Modifies flags: ZF

        Scans source operand for first bit set.  Sets ZF if a bit is found
        set and loads the destination with an index to first set bit.  Clears
        ZF is no bits are found set.  BSF scans forward across bit pattern
        (0-n) while BSR scans in reverse (n-0).
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
⌠
        reg,reg           -     -   10+3n  6-103          3
        reg,mem           -     -   10+3n  7-104         3-7
        reg32,reg32       -     -   10+3n  6-103         3-7
        reg32,mem32       -     -   10+3n  7-104         3-7
'  BSWAP - Byte Swap       (486+)
<
        Usage:  BSWAP   reg32
        Modifies flags: none
═
        Changes the byte order of a 32 bit register from big endian to
        little endian or vice versa.   Result left in destination register
        is undefined if the operand is a 16 bit register.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
=
        reg32             -     -     -     1             2
'  BT - Bit Test           (386+)
=
        Usage:  BT      dest,src
        Modifies flags: CF
`
        The destination bit indexed by the source value is copied into the
        Carry Flag.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
⌡
        reg16,immed8      -     -     3     3            4-8
        mem16,immed8      -     -     6     6            4-8
        reg16,reg16       -     -     3     3            3-7
        mem16,reg16       -     -     12    12           3-7
'' BTC - Bit Test with Compliment (386+)
=
        Usage:  BTC     dest,src
        Modifies flags: CF
ä
        The destination bit indexed by the source value is copied into the
        Carry Flag after being complimented (inverted).
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
⌡
        reg16,immed8      -     -     6     6            4-8
        mem16,immed8      -     -     8     8            4-8
        reg16,reg16       -     -     6     6            3-7
        mem16,reg16       -     -     13    13           3-7
'" BTR - Bit Test with Reset (386+)
=
        Usage:  BTR     dest,src
        Modifies flags: CF
ä
        The destination bit indexed by the source value is copied into the
        Carry Flag and then cleared in the destination.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
⌡
        reg16,immed8      -     -     6     6            4-8
        mem16,immed8      -     -     8     8            4-8
        reg16,reg16       -     -     6     6            3-7
        mem16,reg16       -     -     13    13           3-7
'  BTS - Bit Test and Set  (386+)
=
        Usage:  BTS     dest,src
        Modifies flags: CF
Ç
        The destination bit indexed by the source value is copied into the
        Carry Flag and then set in the destination.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
⌡
        reg16,immed8      -     -     6     6            4-8
        mem16,immed8      -     -     8     8            4-8
        reg16,reg16       -     -     6     6            3-7
        mem16,reg16       -     -     13    13           3-7
' CALL - Procedure Call
B
        Usage:  CALL    destination
        Modifies flags: None
┼
        Pushes Instruction Pointer (and Code Segment for far calls) onto
        stack and loads Instruction Pointer with the address of proc-name.
        Code continues with execution at CS:IP.
î
                                                         Clocks
                   Operands                     808x   286     386     486
ò
        rel16 (near, IP relative)                19     7      7+m      3
        rel32 (near, IP relative)                -      -      7+m      3
ò
        reg16 (near, register indirect)          16     7      7+m      5
        reg32 (near, register indirect)          -      -      7+m      5
¥
        mem16 (near, memory indirect)            -     21+EA    11    10+m      5
        mem32 (near, memory indirect)            -      -     10+m      5
Y
        ptr16:16 (far, full ptr supplied)        28     13    17+m      18
        ptr16:32 (far, full ptr supplied)        -      -     17+m      18
        ptr16:16 (far, ptr supplied, prot. mode) -      26    34+m      20
        ptr16:32 (far, ptr supplied, prot. mode) -      -     34+m      20
        m16:16 (far, indirect)                 37+EA    16    22+m      17
        m16:32 (far, indirect)                   -      -     22+m      17
        m16:16 (far, indirect, prot. mode)       -      29    38+m      20
        m16:32 (far, indirect, prot. mode)       -      -     38+m      20
1
        ptr16:16 (task, via TSS or task gate)    -     177     TS     37+TS
        m16:16 (task, via TSS or task gate)      -   180/185  5+TS    37+TS
        m16:32 (task)                            -      -      TS     37+TS
        m16:32 (task)                            -      -     5+TS    37+TS
-
        ptr16:16 (gate, same privilege)          -      41    52+m      35
        ptr16:32 (gate, same privilege)          -      -     52+m      35
        m16:16 (gate, same privilege)            -      44    56+m      35
        m16:32 (gate, same privilege)            -      -     56+m      35
-
        ptr16:16 (gate, more priv, no parm)      -      82    86+m      69
        ptr16:32 (gate, more priv, no parm)      -      -     86+m      69
        m16:16 (gate, more priv, no parm)        -      83    90+m      69
        m16:32 (gate, more priv, no parm)        -      -     90+m      69
1
        ptr16:16 (gate, more priv, x parms)      -    86+4x  94+4x+m  77+4x
        ptr16:32 (gate, more priv, x parms)      -      -    94+4x+m  77+4x
        m16:16 (gate, more priv, x parms)        -    90+4x  98+4x+m  77+4x
        m16:32 (gate, more priv, x parms)        -      -    98+4x+m  77+4x
' CBW - Convert Byte to Word
2
        Usage:  CBW
        Modifies flags: None
i
        Converts byte in AL to word Value in AX by extending sign of AL
        throughout register AH.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
=
        none              2     2     3     3             1
'% CDQ - Convert Double to Quad (386+)
2
        Usage:  CDQ
        Modifies flags: None
à
        Converts signed DWORD in EAX to a signed quad word in EDX:EAX by
        extending the high order bit of EAX throughout EDX
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
=
        none              -     -     2     3             1
' CLC - Clear Carry
0
        Usage:  CLC
        Modifies flags: CF
 
        Clears the Carry Flag.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
=
        none              2     2     2     2             1
' CLD - Clear Direction Flag
0
        Usage:  CLD
        Modifies flags: DF
s
        Clears the Direction Flag causing string instructions to increment
        the SI and DI index registers.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
=
        none              2     2     2     2             1
'& CLI - Clear Interrupt Flag (disable)
0
        Usage:  CLI
        Modifies flags: IF
ì
        Disables the maskable hardware interrupts by clearing the Interrupt
        flag.  NMI's and software interrupts are not inhibited.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
=
        none              2     2     3     5             1
'3 CLTS - Clear Task Switched Flag (286+ privileged)
3
        Usage:  CLTS
        Modifies flags: None
¼
        Clears the Task Switched Flag in the Machine Status Register.  This
        is a privileged operation and is generally used only by operating
        system code.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
=
        none              -     2     5     7             2
' CMC - Complement Carry Flag
0
        Usage:  CMC
        Modifies flags: CF
*
        Toggles (inverts) the Carry Flag
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
=
        none              2     2     2     2             1
' CMP - Compare
L
        Usage:  CMP     dest,src
        Modifies flags: AF CF OF PF SF ZF
û
        Subtracts source from destination and updates the flags but does
        not save result.  Flags can subsequently be checked for conditions.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
ò
        reg,reg           3     2     2     1             2
        mem,reg          9+EA   7     5     2            2-4  (W88=13+EA)
        reg,mem          9+EA   6     6     2            2-4  (W88=13+EA)
        reg,immed         4     3     2     1            3-4
        mem,immed       10+EA   6     5     2            3-6  (W88=14+EA)
        accum,immed       4     3     2     1            2-3
'2 CMPS - Compare String (Byte, Word or Doubleword)
ù
        Usage:  CMPS    dest,src
                CMPSB
                CMPSW
                CMPSD   (386+)
        Modifies flags: AF CF OF PF SF ZF
╚
        Subtracts destination value from source without saving results.
        Updates flags based on the subtraction and  the index registers
        (E)SI and (E)DI are incremented or decremented depending on the
        state of the Direction Flag.  CMPSB inc/decrements the index
        registers by 1, CMPSW inc/decrements by 2, while CMPSD increments
        or decrements by 4.  The REP prefixes can be used to process
        entire data items.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
G
        dest,src          22    8     10    8             1  (W88=30)
'  CMPXCHG - Compare and Exchange
T
        Usage:  CMPXCHG dest,src  (486+)
        Modifies flags: AF CF OF PF SF ZF
º
        Compares the accumulator (8-32 bits) with "dest".  If equal the
        "dest" is loaded with "src", otherwise the accumulator is loaded
        with "dest".
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
y
        reg,reg           -     -     -     6             2
        mem,reg           -     -     -     7             2
:
        - add 3 clocks if the "mem,reg" comparison fails
'" CWD - Convert Word to Doubleword
2
        Usage:  CWD
        Modifies flags: None
t
        Extends sign of word in register AX throughout register DX forming
        a doubleword quantity in DX:AX.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
=
        none              5     2     2     3             1
'3 CWDE - Convert Word to Extended Doubleword (386+)
3
        Usage:  CWDE
        Modifies flags: None
|
        Converts a signed word in AX to a signed doubleword in EAX by
        extending the sign bit of AX throughout EAX.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
=
        none              -     -     3     3             1
'# DAA - Decimal Adjust for Addition
K
        Usage:  DAA
        Modifies flags: AF CF PF SF ZF (OF undefined)
Ä
        Corrects result (in AL) of a previous BCD addition operation.
        Contents of AL are changed to a pair of packed decimal digits.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
=
        none              4     3     4     2             1
'& DAS - Decimal Adjust for Subtraction
K
        Usage:  DAS
        Modifies flags: AF CF PF SF ZF (OF undefined)
æ
        Corrects result (in AL) of a previous BCD subtraction operation.
        Contents of AL are changed to a pair of packed decimal digits.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
=
        none              4     3     4     2             1
' DEC - Decrement
E
        Usage:  DEC     dest
        Modifies flags: AF OF PF SF ZF
B
        Unsigned binary subtraction of one from the destination.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
╢
        reg8              3     2     2     1             2
        mem             15+EA   7     6     3            2-4
        reg16/32          3     2     2     1             1
' DIV - Divide
S
        Usage:  DIV     src
        Modifies flags: (AF,CF,OF,PF,SF,ZF undefined)
V
        Unsigned binary division of accumulator by source.  If the source
        divisor is a byte value then AX is divided by "src" and the quotient
        is placed in AL and the remainder in AH.  If source operand is a word
        value, then DX:AX is divided by "src" and the quotient is stored in AX
        and the remainder in DX.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
~
        reg8             80-90  14    14    16            2
        reg16           144-162 22    22    24            2
        reg32              -    -     38    40            2
        mem8        (86-96)+EA  17    17    16           2-4
        mem16     (150-168)+EA  25    25    24           2-4  (W88=158-176+EA)
        mem32              -    -     41    40           2-4
'$ ENTER - Make Stack Frame  (80188+)
C
        Usage:  ENTER   locals,level
        Modifies flags: None
M
        Modifies stack for entry to procedure for high level language.
        Operand "locals" specifies the amount of storage to be allocated
        on the stack.   "Level" specifies the nesting level of the routine.
        Paired with the LEAVE instruction, this is an efficient method of
        entry and exit to procedures.
î
                                     Clocks                     Size
        Operands         808x    286       386       486        Bytes
═
        immed16,0         -       11       10         14          4
        immed16,1         -       15       12         17          4
        immed16,immed8    -   12+4(n-1) 15+4(n-1)    17+3n        4
' ESC - Escape
@
        Usage:  ESC     immed,src
        Modifies flags: None
ì
        Provides access to the data bus for other resident processors.
        The CPU treats it as a NOP but places memory operand on bus.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
z
        immed,reg         2   9-20    ?                   2
        immed,mem         2   9-20    ?                  2-4
' HLT - Halt CPU
3
        Usage:   HLT
        Modifies flags: None
░
        Halts CPU until RESET line is activated, NMI or maskable interrupt
        received.  The CPU becomes dormant but retains the current CS:IP
        for later restart.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
=
        none              2     2     5     4             1
'  IDIV - Signed Integer Division
S
        Usage:   IDIV   src
        Modifies flags: (AF,CF,OF,PF,SF,ZF undefined)
│
        Signed binary division of accumulator by source.  If source is a
        byte value, AX is divided by "src" and the quotient is stored in
        AL and the remainder in AH.  If source is a word value, DX:AX is
        divided by "src", and the quotient is stored in AL and the
        remainder in DX.
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
{
        reg8          101-112   17    19    19            2
        reg16         165-184   25    27    27            2
        reg32            -      -     43    43            2
        mem8     (107-118)+EA   20    22    20           2-4
        mem16    (171-190)+EA   38    30    28           2-4  (W88=175-194)
        mem32            -      -     46    44           2-4
' IMUL - Signed Multiply
π
        Usage:  IMUL    src
                IMUL    src,immed        (286+)
                IMUL    dest,src,immed8  (286+)
                IMUL    dest,src         (386+)
        Modifies flags: CF OF (AF,PF,SF,ZF undefined)
╬
        Signed multiplication of accumulator by "src" with result placed
        in the accumulator.  If the source operand is a byte value, it
        is multiplied by AL and the result stored in AX.  If the source
        operand is a word value it is multiplied by AX and the result is
        stored in DX:AX.  Other variations of this instruction allow
        specification of source and destination registers as well as a
        third immediate factor.
|
                                  Clocks                Size
        Operands         808x   286   386   486         Bytes
═
        reg8             80-98   13   9-14  13-18         2
        reg16           128-154  21   9-22  13-26         2
        reg32              -     -    9-38  12-42         2
        mem8             86-104  16  12-17  13-18        2-4
        mem16           134-160  24  12-25  13-26        2-4
        mem32              -     -   12-41  13-42        2-4
        reg16,reg16        -     -    9-22  13-26        3-5
        reg32,reg32        -     -    9-38  13-42        3-5
        reg16,mem16        -     -   12-25  13-26        3-5
        reg32,mem32        -     -   12-41  13-42        3-5
        reg16,immed        -     21   9-22  13-26         3
        reg32,immed        -     21   9-38  13-42        3-6
        reg16,reg16,immed  -     2    9-22  13-26        3-6
        reg32,reg32,immed  -     21   9-38  13-42        3-6
        reg16,mem16,immed  -     24  12-25  13-26        3-6
        reg32,mem32,immed  -     24  12-41  13-42        3-6
'# IN - Input Byte or Word From Port
A
        Usage:  IN      accum,port
        Modifies flags: None
Æ
        A byte, word or dword is read from "port" and placed in AL, AX or
        EAX respectively.  If the port number is in the range of 0-255
        it can be specified as an immediate, otherwise the port number
        must be specified in DX.  Valid port ranges on the PC are 0-1024,
        though values through 65535 may be specified and recognized by
        third party vendors and PS/2's.
|
                                 Clocks                 Size
        Operands         808x  286   386    486         Bytes
±
        accum,immed8    10/14   5     12     14           2
        accum,immed8 (PM)            6/26  8/28/27        2
        accum,DX         8/12   5     13     14           1
        accum,DX (PM)                7/27  8/28/27        1
C
        - 386+ protected mode timings depend on privilege levels.
E
          first number is the timing if:    CPL ≤ IOPL
          second number is the timing if:   CPL > IOPL or in VM 86 mode (386)
                                            CPL ≥ IOPL  (486)
          third number is the timing when:    virtual mode on 486 processor
        - 486 virtual mode always requires 27 cycles
' INC - Increment
E
        Usage:  INC     dest
        Modifies flags: AF OF PF SF ZF
:
        Adds one to destination unsigned binary operand.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
 
        reg8              3     2     2     1             2
        reg16             3     2     2     1             1
        reg32             3     2     2     1             1
        mem             15+EA   7     6     3            2-4  (W88=23+EA)
'( INS - Input String from Port  (80188+)
ë
        Usage:  INS     dest,port
                INSB
                INSW
                INSD    (386+)
        Modifies flags: None
k
        Loads data from port to the destination ES:(E)DI  (even if a
        destination operand is supplied).  (E)DI is adjusted by the size
        of the operand and increased if the Direction Flag is cleared and
        decreased if the Direction Flag is set.  For INSB, INSW, INSD no
        operands are allowed and the size is determined by the mnemonic.
|
                                 Clocks                 Size
        Operands         808x  286   386    486         Bytes
±
        dest,port         -     5     15     17           1
        dest,port (PM)    -     5    9/29 10/32/30        1
        none              -     5     15     17           1
        none (PM)         -     5    9/29 10/32/30        1
C
        - 386+ protected mode timings depend on privilege levels.
╣
          first number is the timing if:    CPL ≤ IOPL
          second number is the timing if:   CPL > IOPL
          third number is the timing if:    virtual mode on 486 processor
' INT - Interrupt
;
        Usage:  INT     num
        Modifies flags: TF IF

        Initiates a software interrupt by pushing the flags, clearing the
        Trap and Interrupt Flags, pushing CS followed by IP and loading
        CS:IP with the value found in the interrupt vector table.  Execution
        then begins at the location addressed by the new CS:IP
î
                                               Clocks           Size
            Operands                    808x  286   386   486   Bytes
⌐
 3 (constant)                          52/72  23+m   33    26     2
 3 (prot. mode, same priv.)              -    40+m   59    44     2
 3 (prot. mode, more priv.)              -    78+m   99    71     2
 3 (from VM86 to PL 0)                   -     -    119    82     2
 3 (prot. mode via task gate)            -   167+m   TS  37+TS    2
 immed8                                51/71  23+m   37    30     1
 immed8 (prot. mode, same priv.)         -    40+m   59    44     1
 immed8 (prot. mode, more priv.)         -    78+m   99    71     1
 immed8 (from VM86 to PL 0)              -     -    119    86     1
 immed8 (prot. mode, via task gate)      -   167+m   TS  37+TS    1
' INTO - Interrupt on Overflow
4
        Usage:  INTO
        Modifies flags: IF TF
Ä
        If the Overflow Flag is set this instruction generates an INT 4
        which causes the code addressed by 0000:0010 to be executed.
é
                                          Clocks           Size
        Operands                808x    286   386   486    Bytes
s
        none: jump             53/73   24+m    35    28      1
              no jump            4       3     3     3
        (prot. mode, same priv.) -       -     59    46      1
        (prot. mode, more priv.) -       -     99    73      1
        (from VM86 to PL 0)      -       -    119    84      1
        (prot. mode, via task gate)      -     TS  39+TS     1
'! INVD - Invalidate Cache  (486+)
3
        Usage:  INVD
        Modifies flags: none
░
        Flushes CPU internal cache.  Issues special function bus cycle
        which indicates to flush external caches.   Data in write-back
        external caches is lost.
|
                                  Clocks                Size
        Operands         808x   286   386   486         Bytes
=
        none              -      -     -     4            2
'@ INVLPG - Invalidate Translation Look-Aside Buffer Entry (486+)
5
        Usage:  INVLPG
        Modifies flags: none
╜
        Invalidates a single page table entry in the Translation
        Look-Aside Buffer.  Intel warns that this instruction may be
        implemented differently on future processors.
|
                                  Clocks                Size
        Operands         808x   286   386   486         Bytes
=
        none              -      -     -     12           2
-
        - timing is for TLB entry hit only.
' IRET/IRETD - Interrupt Return
d
        Usage:  IRET
                IRETD  (386+)
        Modifies flags: AF CF DF IF PF SF TF ZF
r
        Returns control to point of interruption by popping IP, CS
        and then the Flags from the stack and continues execution at
        this location.  CPU exception interrupts will return to the
        instruction that cause the exception because the CS:IP placed
        on the stack during the interrupt is the address of the offending
        instruction.
î
                                         Clocks                 Size
            Operands            808x   286   386   486          Bytes
!
    iret                       32/44  17+m    22    15            1
    iret  (prot. mode)           -    31+m    38    15            1
    iret  (to less privilege)    -    55+m    82    36            1
    iret  (different task, NT=1) -   169+m    TS  TS+32           1
    iretd                        -      -   22/38   15            1
    iretd (to less privilege)    -      -     82    36            1
    iretd (to VM86 mode)         -      -     60    15            1
    iretd (different task, NT=1) -      -     TS  TS+32           1
:
    - 386 timings are listed as real-mode/protected-mode
' Jxx - Jump Instructions Table
I
        Mnemonic              Meaning                    Jump Condition
┴
          JA     Jump if Above                         CF=0 and ZF=0
          JAE    Jump if Above or Equal                CF=0
          JB     Jump if Below                         CF=1
          JBE    Jump if Below or Equal                CF=1 or F=1
          JC     Jump if Carry                         CF=1
          JCXZ   Jump if CX Zero                       CX=0
          JE     Jump if Equal                         ZF=1
          JG     Jump if Greater (signed)              ZF=0 and SF=OF
          JGE    Jump if Greater or Equal (signed)     SF=OF
          JL     Jump if Less (signed)                 SF != OF
          JLE    Jump if Less or Equal (signed)        ZF=1 or SF != OF
          JMP    Unconditional Jump                    unconditional
          JNA    Jump if Not Above                     CF=1 or ZF=1
          JNAE   Jump if Not Above or Equal            CF=1
          JNB    Jump if Not Below                     CF=0
σ
          JNBE   Jump if Not Below or Equal            CF=0 and ZF=0
          JNC    Jump if Not Carry                     CF=0
          JNE    Jump if Not Equal                     ZF=0
          JNG    Jump if Not Greater (signed)          ZF=1 or SF != OF
          JNGE   Jump if Not Greater or Equal (signed) SF != OF
          JNL    Jump if Not Less (signed)             SF=OF
          JNLE   Jump if Not Less or Equal (signed)    ZF=0 and SF=OF
          JNO    Jump if Not Overflow (signed)         OF=0
          JNP    Jump if No Parity                     PF=0
          JNS    Jump if Not Signed (signed)           SF=0
          JNZ    Jump if Not Zero                      ZF=0
          JO     Jump if Overflow (signed)             OF=1
          JP     Jump if Parity                        PF=1
          JPE    Jump if Parity Even                   PF=1
          JPO    Jump if Parity Odd                    PF=0
          JS     Jump if Signed (signed)               SF=1
=
          JZ     Jump if Zero                          ZF=1
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
╒
        Jx: jump          16   7+m   7+m    3             2
            no jump        4    3     3     1
        Jx  near-label     -    -    7+m    3             4
            no jump        -    -     3     1

        - It's a good programming practice to organize code so the
          expected case is executed without a jump since the actual
          jump takes longer to execute than falling through the test.
        - see   JCXZ  and  JMP  for their respective timings
'- JCXZ/JECXZ - Jump if Register (E)CX is Zero
b
        Usage:  JCXZ    label
                JECXZ   label  (386+)
        Modifies flags: None
k
        Causes execution to branch to "label" if register CX is zero.  Uses
        unsigned comparision.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
k
        label:  jump      18   8+m   9+m    8             2
                no jump    6    4     5     5
' JMP - Unconditional Jump
=
        Usage:  JMP     target
        Modifies flags: None

        Unconditionally transfers control to "label".  Jumps by default
        are within -32768 to 32767 bytes from the instruction following
        the jump.  NEAR and SHORT jumps cause the IP to be updated while FAR
        jumps cause CS and IP to be updated.
ç
                                                        Clocks
                   Operands                     808x  286    386   486
Ñ
        rel8  (relative)                        15    7+m    7+m    3
        rel16 (relative)                        15    7+m    7+m    3
        rel32 (relative)                         -     -     7+m    3
        reg16 (near, register indirect)         11    7+m    7+m    5
        reg32 (near, register indirect)          -     -     7+m    5
        mem16 (near, mem indirect)             18+EA  11+m  10+m    5
╔
        mem32 (near, mem indirect)             24+EA  15+m  10+m    5
        ptr16:16 (far, dword immed)              -     -    12+m    17
        ptr16:16 (far, PM dword immed)           -     -    27+m    19
        ptr16:16 (call gate, same priv.)         -    38+m  45+m    32
        ptr16:16 (via TSS)                       -   175+m   TS   42+TS
        ptr16:16 (via task gate)                 -   180+m   TS   43+TS
        mem16:16 (far, indirect)                 -     -    43+m    13
        mem16:16 (far, PM indirect)              -     -    31+m    18
        mem16:16 (call gate, same priv.)         -    41+m  49+m    31
        mem16:16 (via TSS)                       -   178+m  5+TS  41+TS

        mem16:16 (via task gate)                 -   183+m  5+TS  42+TS
        ptr16:32 (far, 6 byte immed)             -     -    12+m    13
        ptr16:32 (far, PM 6 byte immed)          -     -    27+m    18
        ptr16:32 (call gate, same priv.)         -     -    45+m    31
        ptr16:32 (via TSS)                       -     -     TS   42+TS
        ptr16:32 (via task state)                -     -     TS   43+TS
        m16:32 (far, address at dword)           -     -    43+m    13
        m16:32 (far, address at dword)           -     -    31+m    18
        m16:32 (call gate, same priv.)           -     -    49+m    31
        m16:32 (via TSS)                         -     -    5+TS  41+TS
        m16:32 (via task state)                  -     -    5+TS  42+TS
'$ LAHF - Load Register AH From Flags
3
        Usage:  LAHF
        Modifies flags: None
à
        Copies bits 0-7 of the flags register into AH.  This includes flags
        AF, CF, PF, SF and ZF other bits are undefined.
'
        AH := SF ZF xx AF xx PF xx CF
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
=
        none              4     2     2     3             1
'+ LAR - Load Access Rights (286+ protected)
=
        Usage:  LAR     dest,src
        Modifies flags: ZF

        The high byte of the of the destination register is overwritten by
        the value of the access rights byte and the low order byte is zeroed
        depending on the selection in the source operand.  The Zero Flag is
        set if the load operation is successful.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
≤
        reg16,reg16       -     14    15    11            3
        reg32,reg32       -     -     15    11            3
        reg16,mem16       -     16    16    11           3-7
        reg32,mem32       -     -     16    11           3-7
' LDS - Load Pointer Using DS
?
        Usage:  LDS     dest,src
        Modifies flags: None
╗
        Loads 32-bit pointer from memory source to destination register
        and DS.  The offset is placed in the destination register and the
        segment is placed in DS.  To use this instruction the word at the
        lower memory address must contain the offset and the word at the
        higher address must contain the segment.  This simplifies the loading
        of far pointers from the stack and the interrupt vector table.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
{
        reg16,mem32     16+EA   7     7     6            2-4
        reg,mem (PM)      -     -     22    12           5-7
' LEA - Load Effective Address
?
        Usage:  LEA     dest,src
        Modifies flags: None
H
        Transfers offset address of "src" to the destination register.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
>
        reg,mem          2+EA   3     2     1            2-4
r
        - the MOV instruction can often save clock cycles when used in
          place of LEA on 8088 processors
'3 LEAVE - Restore Stack for Procedure Exit (80188+)
4
        Usage:  LEAVE
        Modifies flags: None
╝
        Releases the local variables created by the previous ENTER
        instruction by restoring SP and BP to their condition before
        the procedure stack frame was initialized.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
=
        none              -     5     4     5             1
' LES - Load Pointer Using ES
?
        Usage:  LES     dest,src
        Modifies flags: None
╗
        Loads 32-bit pointer from memory source to destination register
        and ES.  The offset is placed in the destination register and the
        segment is placed in ES.  To use this instruction the word at the
        lower memory address must contain the offset and the word at the
        higher address must contain the segment.  This simplifies the loading
        of far pointers from the stack and the interrupt vector table.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
ê
        reg,mem         16+EA   7     7     6            2-4  (W88=24+EA)
        reg,mem (PM)      -     -     22    12           5-7
'$ LFS - Load Pointer Using FS (386+)
?
        Usage:  LFS     dest,src
        Modifies flags: None
╗
        Loads 32-bit pointer from memory source to destination register
        and FS.  The offset is placed in the destination register and the
        segment is placed in FS.  To use this instruction the word at the
        lower memory address must contain the offset and the word at the
        higher address must contain the segment.  This simplifies the loading
        of far pointers from the stack and the interrupt vector table.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
{
        reg,mem           -     -     7     6            5-7
        reg,mem (PM)      -     -     22    12           5-7
'7 LGDT - Load Global Descriptor Table (286+ privileged)
:
        Usage:  LGDT    src
        Modifies flags: None
`
        Loads a value from an operand into the Global Descriptor Table
        (GDT) register.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
=
        mem64             -     11    11    11            5
': LIDT - Load Interrupt Descriptor Table (286+ privileged)
:
        Usage:  LIDT    src
        Modifies flags: None
c
        Loads a value from an operand into the Interrupt Descriptor Table
        (IDT) register.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
=
        mem64             -     12    11    11            5
'$ LGS - Load Pointer Using GS (386+)
?
        Usage:  LGS     dest,src
        Modifies flags: None
╗
        Loads 32-bit pointer from memory source to destination register
        and GS.  The offset is placed in the destination register and the
        segment is placed in GS.  To use this instruction the word at the
        lower memory address must contain the offset and the word at the
        higher address must contain the segment.  This simplifies the loading
        of far pointers from the stack and the interrupt vector table.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
{
        reg,mem           -     -     7     6            5-7
        reg,mem (PM)      -     -     22    12           5-7
'6 LLDT - Load Local Descriptor Table (286+ privileged)
:
        Usage:  LLDT    src
        Modifies flags: None
`
        Loads a value from an operand into the Local Descriptor Table
        Register (LDTR).
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
y
        reg16             -     17    20    11            3
        mem16             -     19    24    11            5
'3 LMSW - Load Machine Status Word (286+ privileged)
:
        Usage:  LMSW    src
        Modifies flags: None
F
        Loads the Machine Status Word (MSW) from data found at "src"
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
y
        reg16             -     3     10    13            3
        mem16             -     6     13    13            5
' LOCK - Lock Bus
W
        Usage:  LOCK
                LOCK: (386+ prefix)
        Modifies flags: None
ä
        This instruction is a prefix that causes the CPU assert bus lock
        signal during the execution of the next instruction.  Used to
        avoid two processors from updating the same data location.  The
        286 always asserts lock during an XCHG with memory operands.  This
        should only be used to lock the bus prior to XCHG, MOV, IN and
        OUT instructions.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
=
        none              2     0     0     1             1
'+ LODS - Load String (Byte, Word or Double)
ä
        Usage:  LODS    src
                LODSB
                LODSW
                LODSD  (386+)
        Modifies flags: None
\
        Transfers string element addressed by DS:SI (even if an operand is
        supplied) to the accumulator.   SI is incremented based on the size
        of the operand or based on the instruction used.  If the Direction
        Flag is set SI is decremented, if the Direction Flag is clear SI
        is incremented.  Use with REP prefixes.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
=
        src             12/16   5     5     5             1
'- LOOP - Decrement CX and Loop if CX Not Zero
<
        Usage:  LOOP    label
        Modifies flags: None
╚
        Decrements CX by 1 and transfers control to "label" if CX is not
        Zero.  The "label" operand must be within -128 or 127 bytes of the
        instruction following the loop instruction
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
k
        label:  jump      18   8+m  11+m    6             2
                no jump    5    4     ?     2
'2 LOOPE/LOOPZ - Loop While Equal / Loop While Zero
Z
        Usage:  LOOPE   label
                LOOPZ   label
        Modifies flags: None

        Decrements CX by 1 (without modifying the flags) and transfers
        control to "label" if CX != 0 and the Zero Flag is set.  The
        "label" operand must be within -128 or 127 bytes of the instruction
        following the loop instruction.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
k
        label:  jump      18   8+m  11+m    9             2
                no jump    5    4     ?     6
'< LOOPNZ/LOOPNE - Loop While Not Zero / Loop While Not Equal
Z
        Usage:  LOOPNZ  label
                LOOPNE  label
        Modifies flags: None

        Decrements CX by 1 (without modifying the flags) and transfers
        control to "label" if CX != 0 and the Zero Flag is clear.  The
        "label" operand must be within -128 or 127 bytes of the instruction
        following the loop instruction.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
k
        label:  jump      19   8+m  11+m    9             2
                no jump    5    4     ?     6
'+ LSL - Load Segment Limit (286+ protected)
=
        Usage:  LSL     dest,src
        Modifies flags: ZF
≥
        Loads the segment limit of a selector into the destination register
        if the selector is valid and visible at the current privilege level.
        If loading is successful the Zero Flag is set, otherwise it is
        cleared.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
±
        reg16,reg16       -     14  20/25   10            3
        reg32,reg32       -     -   20/25   10            3
        reg16,mem16       -     16  21/26   10            5
        reg32,mem32       -     -   21/26   10            5
B
        - 386 times are listed "byte granular" / "page granular"
'$ LSS - Load Pointer Using SS (386+)
?
        Usage:  LSS     dest,src
        Modifies flags: None
╗
        Loads 32-bit pointer from memory source to destination register
        and SS.  The offset is placed in the destination register and the
        segment is placed in SS.  To use this instruction the word at the
        lower memory address must contain the offset and the word at the
        higher address must contain the segment.  This simplifies the loading
        of far pointers from the stack and the interrupt vector table.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
{
        reg,mem           -     -     7     6            5-7
        reg,mem (PM)      -     -     22    12           5-7
', LTR - Load Task Register (286+ privileged)
:
        Usage:  LTR     src
        Modifies flags: None
L
        Loads the current task register with the value specified in "src".
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
y
        reg16             -     17    23    20            3
        mem16             -     19    27    20            5
' MOV - Move Byte or Word
?
        Usage:  MOV     dest,src
        Modifies flags: None


        Copies byte or word from the source operand to the destination
        operand.  If the destination is SS interrupts are disabled except
        on early buggy 808x CPUs.  Some CPUs disable interrupts if the
        destination is any of the segment registers
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
l
        reg,reg           2     2     2     1             2
        mem,reg          9+EA   3     2     1            2-4  (W88=13+EA)
        reg,mem          8+EA   5     4     1            2-4  (W88=12+EA)
        mem,immed       10+EA   3     2     1            3-6  (W88=14+EA)
        reg,immed         4     2     2     1            2-3
        mem,accum         10    3     2     1             3   (W88=14)
        accum,mem         10    5     4     1             3   (W88=14)
        segreg,reg16      2     2     2     3             2
        segreg,mem16     8+EA   5     5     9            2-4  (W88=12+EA)
\
        reg16,segreg      2     2     2     3             2
        mem16,segreg     9+EA   3     2     3            2-4  (W88=13+EA)
        reg32,CR0/CR2/CR3 -     -     6     4
        CR0,reg32         -     -     10    16
        CR2,reg32         -     -     4     4             3
        CR3,reg32         -     -     5     4             3
┼
        reg32,DR0/DR1/DR2/DR3   -     22   10             3
        reg32,DR6/DR7     -     -     22   10             3
        DR0/DR1/DR2/DR3,reg32   -     22   11             3
        DR6/DR7,reg32     -     -     16   11             3
        reg32,TR6/TR7     -     -     12    4             3
        TR6/TR7,reg32     -     -     12    4             3
        reg32,TR3                           3
        TR3,reg32                           6
L
        - when the 386 special registers are used all operands are 32 bits
'# MOVS - Move String (Byte or Word)
ë
        Usage:  MOVS    dest,src
                MOVSB
                MOVSW
                MOVSD  (386+)
        Modifies flags: None
^
        Copies data from addressed by DS:SI (even if operands are given) to
        the location ES:DI destination and updates SI and DI based on the
        size of the operand or instruction used.  SI and DI are incremented
        when the Direction Flag is cleared and decremented when the Direction
        Flag is Set.  Use with REP prefixes.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
H
        dest,src          18    5     7     7             1   (W88=26)
'& MOVSX - Move with Sign Extend (386+)
?
        Usage:  MOVSX   dest,src
        Modifies flags: None
l
        Copies the value of the source operand to the destination register
        with the sign extended.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
z
        reg,reg           -     -     3     3             3
        reg,mem           -     -     6     3            3-7
'& MOVZX - Move with Zero Extend (386+)
?
        Usage:  MOVZX   dest,src
        Modifies flags: None
n
        Copies the value of the source operand to the destination register
        with the zeroes extended.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
z
        reg,reg           -     -     3     3             3
        reg,mem           -     -     6     3            3-7
' MUL - Unsigned Multiply
S
        Usage:  MUL     src
        Modifies flags: CF OF (AF,PF,SF,ZF undefined)

        Unsigned multiply of the accumulator by the source.  If "src" is
        a byte value, then AL is used as the other multiplicand and the
        result is placed in AX.  If "src" is a word value, then AX is
        multiplied by "src" and DX:AX receives the result.  If "src" is
        a double word value, then EAX is multiplied by "src" and EDX:EAX
        receives the result.  The 386+ uses an early out algorithm which
        makes multiplying any size value in EAX as fast as in the 8 or 16
        bit registers.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
m
        reg8            70-77   13   9-14  13-18          2
        reg16          118-113  21   9-22  13-26          2
        reg32             -     -    9-38  13-42         2-4
        mem8        (76-83)+EA  16  12-17  13-18         2-4
        mem16     (124-139)+EA  24  12-25  13-26         2-4
        mem32             -     -   12-21  13-42         2-4
'! NEG - Two's Complement Negation
H
        Usage:  NEG     dest
        Modifies flags: AF CF OF PF SF ZF
j
        Subtracts the destination from 0 and saves the 2s complement of
        "dest" back into "dest".
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
ç
        reg               3     2     2     1             2
        mem             16+EA   7     6     3            2-4  (W88=24+EA)
' NOP - No Operation (90h)
2
        Usage:  NOP
        Modifies flags: None
╔
        This is a do nothing instruction.  It results in occupation of both
        space and time and is most useful for patching code segments.
        (This is the original XCHG AL,AL instruction)
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
=
        none              3     3     3     1             1
'/ NOT - One's Compliment Negation (Logical NOT)
;
        Usage:  NOT     dest
        Modifies flags: None
K
        Inverts the bits of the "dest" operand forming the 1s complement.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
ç
        reg               3     2     2     1             2
        mem             16+EA   7     6     3            2-4  (W88=24+EA)
' OR - Inclusive Logical OR
X
        Usage:  OR      dest,src
        Modifies flags: CF OF PF SF ZF (AF undefined)
¬
        Logical inclusive OR of the two operands returning the result in
        the destination.  Any bit set in either operand will be set in the
        destination.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
┼
        reg,reg           3     2     2     1             2
        mem,reg         16+EA   7     7     3            2-4  (W88=24+EA)
        reg,mem          9+EA   7     6     2            2-4  (W88=13+EA)
        reg,immed         4     3     2     1            3-4
        mem8,immed8     17+EA   7     7     3            3-6
        mem16,immed16   25+EA   7     7     3            3-6
        accum,immed       4     3     2     1            2-3
' OUT - Output Data to Port
A
        Usage:  OUT     port,accum
        Modifies flags: None
┬
        Transfers byte in AL,word in AX or dword in EAX to the specified
        hardware port address.  If the port number is in the range of 0-255
        it can be specified as an immediate.  If greater than 255 then the
        port number must be specified in DX.  Since the PC only decodes 10
        bits of the port address, values over 1023 can only be decoded by
        third party vendor equipment and also map to the port range 0-1023.
|
                                 Clocks                 Size
        Operands         808x  286   386    486         Bytes
±
        immed8,accum    10/14   3     10     16           2
        immed8,accum (PM) -     -    4/24 11/31/29        2
        DX,accum         8/12   3     11     16           1
        DX,accum (PM)     -     -    5/25 10/30/29        1
C
        - 386+ protected mode timings depend on privilege levels.
┐
          first number is the timing when:    CPL ≤ IOPL
          second number is the timing when:   CPL > IOPL
          third number is the timing when:    virtual mode on 486 processor
'( OUTS - Output String to Port  (80188+)
è
        Usage:  OUTS    port,src
                OUTSB
                OUTSW
                OUTSD   (386+)
        Modifies flags: None
╜
        Transfers a byte, word or doubleword from "src" to the hardware
        port specified in DX.  For instructions with no operands the "src"
        is located at DS:SI and SI is incremented or decremented by the
        size of the operand or the size dictated by the instruction format.
        When the Direction Flag is set SI is decremented, when clear, SI is
        incremented.  If the port number is in the range of 0-255 it can
&
        be specified as an immediate.  If greater than 255 then the port
        number must be specified in DX.  Since the PC only decodes 10 bits
        of the port address, values over 1023 can only be decoded by third
        party vendor equipment and also map to the port range 0-1023.
|
                                 Clocks                 Size
        Operands         808x  286   386    486         Bytes
y
        port,src          -     5     14     17           1
        port,src (PM)     -     -    8/28 10/32/30        1
C
        - 386+ protected mode timings depend on privilege levels.
┐
          first number is the timing when:    CPL ≤ IOPL
          second number is the timing when:   CPL > IOPL
          third number is the timing when:    virtual mode on 486 processor
' POP - Pop Word off Stack
;
        Usage:  POP     dest
        Modifies flags: None
╡
        Transfers word at the current stack top (SS:SP) to the destination
        then increments SP by two to point to the new stack top.  CS is not
        a valid destination.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
/
        reg16             8     5     4     4             1
        reg32             4     -     -     4             1
        segreg            8     5     7     3             1
        mem16           17+EA   5     5     6            2-4
        mem32             5     -     -     6            2-4
'5 POPA/POPAD - Pop All Registers onto Stack  (80188+)
Q
        Usage:  POPA
                POPAD  (386+)
        Modifies flags: None

        Pops the top 8 words off the stack into the 8 general purpose 16/32
        bit registers.   Registers are popped in the following order: (E)DI,
        (E)SI, (E)BP, (E)SP, (E)DX, (E)CX and (E)AX.  The (E)SP value popped
        from the stack is actually discarded.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
=
        none              -     19    24    9             1
'" POPF/POPFD - Pop Flags off Stack
V
        Usage:  POPF
                POPFD  (386+)
        Modifies flags: all flags
é
        Pops word/doubleword from stack into the Flags Register and then
        increments SP by 2 (for POPF) or 4 (for POPFD).
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
â
        none             8/12   5     5     9             1  (W88=12)
        none  (PM)        -     -     5     6             1
' PUSH - Push Word onto Stack
h
        Usage:  PUSH    src
                PUSH    immed   (80188+ only)
        Modifies flags: None
¼
        Decrements SP by the size of the operand (two or four, byte values
        are sign extended) and transfers one word from source to the stack
        top (SS:SP).
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
y
        reg16           11/15   3     2     1             1
        reg32             -     -     2     1             1
        mem16           16+EA   5     5     4            2-4  (W88=24+EA)
        mem32             -     -     5     4            2-4
        segreg          10/14   3     2     3             1
        immed             -     3     2     1            2-3
'8 PUSHA/PUSHAD - Push All Registers onto Stack  (80188+)
S
        Usage:  PUSHA
                PUSHAD  (386+)
        Modifies flags: None
┘
        Pushes all general purpose registers onto the stack in the following
        order: (E)AX, (E)CX, (E)DX, (E)BX, (E)SP, (E)BP, (E)SI, (E)DI.  The
        value of SP is the value before the actual push of SP.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
=
        none              -     19    24    11            1
'& PUSHF/PUSHFD - Push Flags onto Stack
S
        Usage:  PUSHF
                PUSHFD  (386+)
        Modifies flags: None
}
        Transfers the Flags Register onto the stack.  PUSHF saves a 16 bit
        value while PUSHFD saves a 32 bit value.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
y
        none            10/14   3     4     4             1
        none  (PM)        -     -     4     3             1
'! RCL - Rotate Through Carry Left
B
        Usage:  RCL     dest,count
        Modifies flags: CF OF
₧
           ┌─┐     ┌───────────────┐
        ┌─■│C│<■──■│7 <────────── 0│<─┐
        │  └─┘     └───────────────┘  │
        └─────────────────────────────┘
╚
        Rotates the bits in the destination to the left "count" times with
        all data pushed out the left side re-entering on the right.  The
        Carry Flag holds the last bit rotated out.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
â
        reg,1             2     2     9     3            2
        mem,1           15+EA   7     10    4           2-4  (W88=23+EA)
        reg,CL           8+4n  5+n    9    8-30          2
        mem,CL        20+EA+4n 8+n    10   9-31         2-4  (W88=28+EA+4n)
        reg,immed8        -    5+n     9   8-30          3
        mem,immed8        -    8+n    10   9-31         3-5
'" RCR - Rotate Through Carry Right
B
        Usage:  RCR     dest,count
        Modifies flags: CF OF
₧
           ┌───────────────┐     ┌─┐
        ┌─>│7 ■─────────> 0│■───>│C│■─┐
        │  └───────────────┘     └─┘  │
        └─────────────────────────────┘
╔
        Rotates the bits in the destination to the right "count" times with
        all data pushed out the right side re-entering on the left.  The
        Carry Flag holds the last bit rotated out.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
à
        reg,1             2     2     9     3            2
        mem,1           15+EA   7     10    4           2-4   (W88=23+EA)
        reg,CL           8+4n  5+n    9    8-30          2
        mem,CL        20+EA+4n 8+n    10   9-31         2-4   (W88=28+EA+4n)
        reg,immed8        -    5+n    9    8-30          3
        mem,immed8        -    8+n    10   9-31         3-5
' REP - Repeat String Operation
2
        Usage:  REP
        Modifies flags: None
Æ
        Repeats execution of string instructions while CX != 0.  After
        each string operation, CX is decremented and the Zero Flag is
        tested.  The combination of a repeat prefix and a segment override
        on CPU's before the 386 may result in errors if an interrupt occurs
        before CX=0.  The following code shows code that is susceptible to
        this and how to avoid it:
Ω
         again:  rep movs  byte ptr ES:[DI],ES:[SI]   ; vulnerable instr.
                     jcxz  next              ; continue if REP successful
                     loop  again             ; interrupt goofed count
         next:
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
=
        none              2     2     2                   1
'( REPE/REPZ - Repeat Equal / Repeat Zero
H
        Usage:  REPE
                REPZ
        Modifies flags: None
Y
        Repeats execution of string instructions while CX != 0 and the Zero
        Flag is set.  CX is decremented and the Zero Flag tested after
        each string operation.   The combination of a repeat prefix and a
        segment override on processors other than the 386 may result in
        errors if an interrupt occurs before CX=0.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
=
        none              2     2     2                   1
'2 REPNE/REPNZ - Repeat Not Equal / Repeat Not Zero
J
        Usage:  REPNE
                REPNZ
        Modifies flags: None
\
        Repeats execution of string instructions while CX != 0 and the Zero
        Flag is clear.   CX is decremented and the Zero Flag tested after
        each string operation.   The combination of a repeat prefix and a
        segment override on processors other than the 386 may result in
        errors if an interrupt occurs before CX=0.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
=
        none              2     2     2                   1
'" RET/RETF - Return From Procedure
{
        Usage:  RET     nBytes
                RETF    nBytes
                RETN    nBytes
        Modifies flags: None

        Transfers control from a procedure back to the instruction address
        saved on the stack.  "n bytes" is an optional number of bytes to
        release.  Far returns pop the IP followed by the CS, while near
        returns pop only the IP register.
|
                                 Clocks                 Size
        Operands         808x  286    386   486         Bytes
ß
        retn            16/20  11+m  10+m    5            1
        retn immed      20/24  11+m  10+m    5            3
        retf            26/34  15+m  18+m    13           1
        retf (PM, same priv.)   -    32+m    18           1
        retf (PM, lesser priv.) -      68    33           1
        retf immed      25/33  15+m  18+m    14           3
        retf immed (PM, same priv.)  32+m    17           1
        retf immed (PM, lesser priv.)  68    33           1
' ROL - Rotate Left
B
        Usage:  ROL     dest,count
        Modifies flags: CF OF
Æ
        ┌─┐     ┌───────────────┐
        │C│<■┬─■│7 <────────── 0│<─┐
        └─┘  │  └───────────────┘  │
             └─────────────────────┘
▄
        Rotates the bits in the destination to the left "count" times with
        all data pushed out the left side re-entering on the right.  The
        Carry Flag will contain the value of the last bit rotated out.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
ë
        reg,1             2     2     3     3             2
        mem,1           15+EA   7     7     4            2-4  (W88=23+EA)
        reg,CL           8+4n  5+n    3     3             2
        mem,CL        20+EA+4n 8+n    7     4            2-4  (W88=28+EA+4n)
        reg,immed8        -    5+n    3     2             3
        mem,immed8        -    8+n    7     4            3-5
' ROR - Rotate Right
B
        Usage:  ROR     dest,count
        Modifies flags: CF OF
É
           ┌───────────────┐     ┌─┐
        ┌─>│7 ■─────────> 0│■─┬─>│C│
        │  └───────────────┘  │  └─┘
        └─────────────────────┘
▌
        Rotates the bits in the destination to the right "count" times with
        all data pushed out the right side re-entering on the left.  The
        Carry Flag will contain the value of the last bit rotated out.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
ë
        reg,1             2     2     3     3             2
        mem,1           15+EA   7     7     4            2-4  (W88=23+EA)
        reg,CL           8+4n  5+n    3     3             2
        mem,CL        20+EA+4n 8+n    7     4            2-4  (W88=28+EA+4n)
        reg,immed8        -    5+n    3     2             3
        mem,immed8        -    8+n    7     4            3-5
'% SAHF - Store AH Register into FLAGS
=
        Usage:  SAHF
        Modifies flags: AF CF PF SF ZF
i
        Transfers bits 0-7 of AH into the Flags Register.  This includes
        AF, CF, PF, SF and ZF.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
=
        none              4     2     3     2             1
'6 SAL/SHL - Shift Arithmetic Left / Shift Logical Left
}
        Usage:  SAL     dest,count
                SHL     dest,count
        Modifies flags: CF OF PF SF ZF (AF undefined)

        ┌─┐     ┌───────────────┐     ┌─┐
        │C│<───■│7 <────────── 0│<───■│0│
        └─┘     └───────────────┘     └─┘
æ
        Shifts the destination left by "count" bits with zeroes shifted
        in on right.  The Carry Flag contains the last bit shifted out.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
â
        reg,1             2     2     3     3            2
        mem,1           15+EA   7     7     4           2-4  (W88=23+EA)
        reg,CL           8+4n  5+n    3     3            2
        mem,CL        20+EA+4n 8+n    7     4           2-4  (W88=28+EA+4n)
        reg,immed8        -    5+n    3     2            3
        mem,immed8        -    8+n    7     4           3-5
' SAR - Shift Arithmetic Right
Z
        Usage:  SAR     dest,count
        Modifies flags: CF OF PF SF ZF (AF undefined)
~
           ┌───────────────┐     ┌─┐
        ┌─■│7 ──────────> 0│───■>│C│
        │  └───────────────┘     └─┘
        └───^
│
        Shifts the destination right by "count" bits with the current sign
        bit replicated in the leftmost bit.  The Carry Flag contains the
        last bit shifted out.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
ë
        reg,1             2     2     3     3             2
        mem,1           15+EA   7     7     4            2-4  (W88=23+EA)
        reg,CL           8+4n  5+n    3     3             2
        mem,CL        20+EA+4n 8+n    7     4            2-4  (W88=28+EA+4n)
        reg,immed8        -    5+n    3     2             3
        mem,immed8        -    8+n    7     4            3-5
'" SBB - Subtract with Borrow/Carry
L
        Usage:  SBB     dest,src
        Modifies flags: AF CF OF PF SF ZF
Ä
        Subtracts the source from the destination, and subtracts 1 extra if
        the Carry Flag is set.   Results are returned in "dest".
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
ò
        reg,reg           3     2     2     1             2
        mem,reg         16+EA   7     6     3            2-4  (W88=24+EA)
        reg,mem          9+EA   7     7     2            2-4  (W88=13+EA)
        reg,immed         4     3     2     1            3-4
        mem,immed       17+EA   7     7     3            3-6  (W88=25+EA)
        accum,immed       4     3     2     1            2-3
'0 SCAS - Scan String  (Byte, Word or Doubleword)
ò
        Usage:  SCAS    string
                SCASB
                SCASW
                SCASD   (386+)
        Modifies flags: AF CF OF PF SF ZF
0
        Compares value at ES:DI (even if operand is specified) from the
        accumulator and sets the flags similar to a subtraction.  DI is
        incremented/decremented based on the instruction format (or
        operand size) and the state of the Direction Flag.  Use with REP
        prefixes.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
G
        string            15    7     7     6             1  (W88=19)
'? SETAE/SETNB - Set if Above or Equal / Set if Not Below (386+)
q
        Usage:  SETAE   dest
                SETNB   dest
        (unsigned, 386+)
        Modifies flags: none
o
        Sets the byte in the operand to 1 if the Carry Flag is clear
        otherwise sets the operand to 0.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
y
        reg8              -     -     4     3             3
        mem8              -     -     5     4             3
'? SETB/SETNAE - Set if Below / Set if Not Above or Equal (386+)
q
        Usage:  SETB    dest
                SETNAE  dest
        (unsigned, 386+)
        Modifies flags: none
m
        Sets the byte in the operand to 1 if the Carry Flag is set
        otherwise sets the operand to 0.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
y
        reg8              -     -     4     3             3
        mem8              -     -     5     4             3
'? SETBE/SETNA - Set if Below or Equal / Set if Not Above (386+)
q
        Usage:  SETBE   dest
                SETNA   dest
        (unsigned, 386+)
        Modifies flags: none

        Sets the byte in the operand to 1 if the Carry Flag or the Zero
        Flag is set, otherwise sets the operand to 0.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
y
        reg8              -     -     4     3             3
        mem8              -     -     5     4             3
'/ SETE/SETZ - Set if Equal / Set if Zero (386+)
X
        Usage:  SETE    dest
                SETZ    dest
        Modifies flags: none
m
        Sets the byte in the operand to 1 if the Zero Flag is set,
        otherwise sets the operand to 0.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
y
        reg8              -     -     4     3             3
        mem8              -     -     5     4             3
'9 SETNE/SETNZ - Set if Not Equal / Set if Not Zero (386+)
X
        Usage:  SETNE   dest
                SETNZ   dest
        Modifies flags: none
o
        Sets the byte in the operand to 1 if the Zero Flag is clear,
        otherwise sets the operand to 0.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
y
        reg8              -     -     4     3             3
        mem8              -     -     5     4             3
'@ SETL/SETNGE - Set if Less / Set if Not Greater or Equal (386+)
o
        Usage:  SETL    dest
                SETNGE  dest
        (signed, 386+)
        Modifies flags: none
ê
        Sets the byte in the operand to 1 if the Sign Flag is not equal
        to the Overflow Flag, otherwise sets the operand to 0.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
y
        reg8              -     -     4     3             3
        mem8              -     -     5     4             3
'@ SETGE/SETNL - Set if Greater or Equal / Set if Not Less (386+)
o
        Usage:  SETGE   dest
                SETNL   dest
        (signed, 386+)
        Modifies flags: none

        Sets the byte in the operand to 1 if the Sign Flag equals the
        Overflow Flag, otherwise sets the operand to 0.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
y
        reg8              -     -     4     3             3
        mem8              -     -     5     4             3
'I SETLE/SETNG - Set if Less or Equal / Set if Not greater or Equal (386+)
o
        Usage:  SETLE   dest
                SETNG   dest
        (signed, 386+)
        Modifies flags: none
⌐
        Sets the byte in the operand to 1 if the Zero Flag is set or the
        Sign Flag is not equal to the Overflow Flag,  otherwise sets the
        operand to 0.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
y
        reg8              -     -     4     3             3
        mem8              -     -     5     4             3
'@ SETG/SETNLE - Set if Greater / Set if Not Less or Equal (386+)
o
        Usage:  SETG    dest
                SETNLE  dest
        (signed, 386+)
        Modifies flags: none
Ñ
        Sets the byte in the operand to 1 if the Zero Flag is clear or the
        Sign Flag equals to the Overflow Flag,  otherwise sets the operand
        to 0.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
y
        reg8              -     -     4     3             3
        mem8              -     -     5     4             3
' SETS - Set if Signed (386+)
;
        Usage:  SETS    dest
        Modifies flags: none
m
        Sets the byte in the operand to 1 if the Sign Flag is set, otherwise
        sets the operand to 0.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
y
        reg8              -     -     4     3             3
        mem8              -     -     5     4             3
'" SETNS - Set if Not Signed (386+)
;
        Usage:  SETNS   dest
        Modifies flags: none
o
        Sets the byte in the operand to 1 if the Sign Flag is clear,
        otherwise sets the operand to 0.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
y
        reg8              -     -     4     3             3
        mem8              -     -     5     4             3
' SETC - Set if Carry (386+)
;
        Usage:  SETC    dest
        Modifies flags: none
n
        Sets the byte in the operand to 1 if the Carry Flag is set,
        otherwise sets the operand to 0.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
y
        reg8              -     -     4     3             3
        mem8              -     -     5     4             3
'! SETNC - Set if Not Carry (386+)
;
        Usage:  SETNC   dest
        Modifies flags: none
p
        Sets the byte in the operand to 1 if the Carry Flag is clear,
        otherwise sets the operand to 0.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
y
        reg8              -     -     4     3             3
        mem8              -     -     5     4             3
' SETO - Set if Overflow (386+)
;
        Usage:  SETO    dest
        Modifies flags: none
q
        Sets the byte in the operand to 1 if the Overflow Flag is set,
        otherwise sets the operand to 0.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
y
        reg8              -     -     4     3             3
        mem8              -     -     5     4             3
'$ SETNO - Set if Not Overflow (386+)
;
        Usage:  SETNO   dest
        Modifies flags: none
s
        Sets the byte in the operand to 1 if the Overflow Flag is clear,
        otherwise sets the operand to 0.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
y
        reg8              -     -     4     3             3
        mem8              -     -     5     4             3
'9 SETP/SETPE - Set if Parity / Set if Parity Even  (386+)
X
        Usage:  SETP    dest
                SETPE   dest
        Modifies flags: none
o
        Sets the byte in the operand to 1 if the Parity Flag is set,
        otherwise sets the operand to 0.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
y
        reg8              -     -     4     3             3
        mem8              -     -     5     4             3
'; SETNP/SETPO - Set if No Parity / Set if Parity Odd (386+)
X
        Usage:  SETNP   dest
                SETPO   dest
        Modifies flags: none
q
        Sets the byte in the operand to 1 if the Parity Flag is clear,
        otherwise sets the operand to 0.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
y
        reg8              -     -     4     3             3
        mem8              -     -     5     4             3
'8 SGDT - Store Global Descriptor Table (286+ privileged)
;
        Usage:  SGDT    dest
        Modifies flags: none
_
        Stores the Global Descriptor Table (GDT) Register into the
        specified operand.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
=
        mem64             -     11    9     10            5
'; SIDT - Store Interrupt Descriptor Table (286+ privileged)
;
        Usage:  SIDT    dest
        Modifies flags: none
b
        Stores the Interrupt Descriptor Table (IDT) Register into the
        specified operand.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
=
        mem64             -     12    9     10            5
' SHL - Shift Logical Left

        See: SAL
' SHR - Shift Logical Right
Z
        Usage:  SHR     dest,count
        Modifies flags: CF OF PF SF ZF (AF undefined)

        ┌─┐     ┌───────────────┐     ┌─┐
        │0│───■>│7 ──────────> 0│───■>│C│
        └─┘     └───────────────┘     └─┘
ò
        Shifts the destination right by "count" bits with zeroes shifted
        in on the left.  The Carry Flag contains the last bit shifted out.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
ï
        reg,1             2     2     3                   2
        mem,1           15+EA   7     7                  2-4   (W88=23+EA)
        reg,CL           8+4n  5+n    3                   2
        mem,CL        20+EA+4n 8+n    7                  2-4   (W88=28+EA+4n)
        reg,immed8        -    5+n    3                   3
        mem,immed8        -    8+n    7                  3-5
'+ SHLD/SHRD - Double Precision Shift (386+)
à
        Usage:  SHLD    dest,src,count
                SHRD    dest,src,count
        Modifies flags: CF PF SF ZF (OF,AF undefined)
a
        SHLD shifts "dest" to the left "count" times and the bit positions
        opened are filled with the most significant bits of "src".  SHRD
        shifts "dest" to the right "count" times and the bit positions
        opened are filled with the least significant bits of the second
        operand.  Only the 5 lower bits of "count" are used.
î
                                        Clocks                  Size
        Operands                808x  286   386   486           Bytes
!
        reg16,reg16,immed8       -     -     3     2              4
        reg32,reg32,immed8       -     -     3     2              4
        mem16,reg16,immed8       -     -     7     3              6
        mem32,reg32,immed8       -     -     7     3              6
        reg16,reg16,CL           -     -     3     3              3
        reg32,reg32,CL           -     -     3     3              3
        mem16,reg16,CL           -     -     7     4              5
        mem32,reg32,CL           -     -     7     4              5
'7 SLDT - Store Local Descriptor Table (286+ privileged)
;
        Usage:  SLDT    dest
        Modifies flags: none
^
        Stores the Local Descriptor Table (LDT) Register into the
        specified operand.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
y
        reg16             -     2     2     2             3
        mem16             -     2     2     3             5
'4 SMSW - Store Machine Status Word (286+ privileged)
;
        Usage:  SMSW    dest
        Modifies flags: none
6
        Store Machine Status Word (MSW) into "dest".
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
y
        reg16             -     2     10    2             3
        mem16             -     3     3     3             5
' STC - Set Carry
0
        Usage:  STC
        Modifies flags: CF
#
        Sets the Carry Flag to 1.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
=
        none              2     2     2     2             1
' STD - Set Direction Flag
0
        Usage:  STD
        Modifies flags: DF
ü
        Sets the Direction Flag to 1 causing string instructions to
        auto-decrement SI and DI instead of auto-increment.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
=
        none              2     2     2     2             1
'/ STI - Set Interrupt Flag  (Enable Interrupts)
0
        Usage:  STI
        Modifies flags: IF

        Sets the Interrupt Flag to 1, which enables recognition of all
        hardware interrupts.  If an interrupt is generated by a hardware
        device, an End of Interrupt (EOI) must also be issued to enable
        other hardware interrupts of the same or lower priority.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
=
        none              2     2     2     5             1
'1 STOS - Store String  (Byte, Word or Doubleword)
}
        Usage:  STOS    dest
                STOSB
                STOSW
                STOSD
        Modifies flags: None

        Stores value in accumulator to location at ES:(E)DI (even if operand
        is given).  (E)DI is incremented/decremented based on the size of
        the operand (or instruction format) and the state of the Direction
        Flag.   Use with REP prefixes.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
G
        dest              11    3     4     5             1  (W88=15)
'- STR - Store Task Register (286+ privileged)
;
        Usage:  STR     dest
        Modifies flags: None
D
        Stores the current Task Register to the specified operand.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
y
        reg16             -     2     2     2             3
        mem16             -     3     2     3             5
' SUB - Subtract
L
        Usage:  SUB     dest,src
        Modifies flags: AF CF OF PF SF ZF
l
        The source is subtracted from the destination and the result is
        stored in the destination.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
ò
        reg,reg           3     2     2     1             2
        mem,reg         16+EA   7     6     3            2-4  (W88=24+EA)
        reg,mem          9+EA   7     7     2            2-4  (W88=13+EA)
        reg,immed         4     3     2     1            3-4
        mem,immed       17+EA   7     7     3            3-6  (W88=25+EA)
        accum,immed       4     3     2     1            2-3
' TEST - Test For Bit Pattern
X
        Usage:  TEST    dest,src
        Modifies flags: CF OF PF SF ZF (AF undefined)
s
        Performs a logical AND of the two operands updating the flags
        register without saving the result.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
ê
        reg,reg           3     2     1     1             2
        reg,mem          9+EA   6     5     1            2-4  (W88=13+EA)
        mem,reg          9+EA   6     5     2            2-4  (W88=13+EA)
        reg,immed         5     3     2     1            3-4
        mem,immed       11+EA   6     5     2            3-6
        accum,immed       4     3     2     1            2-3
'% VERR - Verify Read (286+ protected)
8
        Usage:  VERR    src
        Modifies flags: ZF
╞
        Verifies the specified segment selector is valid and is readable
        at the current privilege level.  If the segment is readable,
        the Zero Flag is set, otherwise it is cleared.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
y
        reg16             -     14    10    11            3
        mem16             -     16    11    11            5
'& VERW - Verify Write (286+ protected)
8
        Usage:  VERW    src
        Modifies flags: ZF
┼
        Verifies the specified segment selector is valid and is ratable
        at the current privilege level.  If the segment is writable,
        the Zero Flag is set, otherwise it is cleared.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
y
        reg16             -     14    15    11            3
        mem16             -     16    16    11            5
' WAIT/FWAIT - Event Wait
I
        Usage:  WAIT
                FWAIT
        Modifies flags: None

        CPU enters wait state until the coprocessor signals it has finished
        its operation.  This instruction is used to prevent the CPU from
        accessing memory that may be temporarily in use by the coprocessor.
        WAIT and FWAIT are identical.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
=
        none              4     3     6+   1-3            1
'1 WBINVD - Write-Back and Invalidate Cache (486+)
5
        Usage:  WBINVD
        Modifies flags: None
û
        Flushes internal cache, then signals the external cache to write
        back current data followed by a signal to flush the external cache.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
=
        none              -     -     -     5             2
' XCHG - Exchange
?
        Usage:  XCHG    dest,src
        Modifies flags: None
7
        Exchanges contents of source and destination.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
I
        reg,reg           4     3     3     3             2
        mem,reg         17+EA   5     5     5            2-4  (W88=25+EA)
        reg,mem         17+EA   5     5     3            2-4  (W88=25+EA)
        accum,reg         3     3     3     3             1
        reg,accum         3     3     3     3             1
' XLAT/XLATB - Translate
k
        Usage:  XLAT    translation-table
                XLATB   (masm 5.x)
        Modifies flags: None
╧
        Replaces the byte in AL with byte from a user table addressed by
        BX.  The original value of AL is the index into the translate table.
        The best way to discripe this is MOV AL,[BX+AL]
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
=
        table offset      11    5     5     4             1
' XOR - Exclusive OR
X
        Usage:  XOR     dest,src
        Modifies flags: CF OF PF SF ZF (AF undefined)
l
        Performs a bitwise exclusive OR of the operands and returns
        the result in the destination.
|
                                 Clocks                 Size
        Operands         808x  286   386   486          Bytes
ò
        reg,reg           3     2     2     1             2
        mem,reg         16+EA   7     6     3            2-4  (W88=24+EA)
        reg,mem          9+EA   7     7     2            2-4  (W88=13+EA)
        reg,immed         4     3     2     1            3-4
        mem,immed       17+EA   7     7     3            3-6  (W88=25+EA)
        accum,immed       4     3     2     1            2-3
''?
          ASCII - EBCDIC - Character Codes and Character Sets
├
                             Extended                 Control
         Dec   Octal    Hex   ASCII    EBCDIC  ASCII   Codes
          0     000     00              NUL     NUL
          1     001     01   blk Face   SOH     SOH     ^A
          2     002     02             STX     STX     ^B
          3     003     03             ETX     ETX     ^C
          4     004     04             PF      EOT     ^D
          5     005     05             HT      ENQ     ^E
          6     006     06             LC      ACK     ^F
          7     007     07             DEL     BEL     ^G
          8     010     08     ...              BS      ^H
          9     011     09     ...              HT      ^I
O
         10     012     0A     ...      SMM     LF      ^J
         11     013     0B             VT      VT      ^K
         12     014     0C             FF      FF      ^L
         13     015     0D     ...      CR      CR      ^M
         14     016     0E             SO      SO      ^N
         15     017     0F             SI      SI      ^O
         16     020     10             DLE     DLE     ^P
         17     021     11             DC1     DC1     ^Q
         18     022     12             DC2     DC2     ^R
         19     023     13             TM      DC3     ^S
O
         20     024     14             RES     DC4     ^T
         21     025     15             NL      NAK     ^U
         22     026     16             BS      SYN     ^V
         23     027     17             IL      ETB     ^W
         24     030     18             CAN     CAN     ^X
         25     031     19             EM      EM      ^Y
         26     032     1A     ...      CC      SUB     ^Z
         27     033     1B             CU1     ESC     ^[
         28     034     1C             IFS     FS      ^\
         29     035     1D             IGS     GS      ^]

         30     036     1E             IRS     RS      ^^
         31     037     1F             IUS     US      ^_
         32     040     20              DS      SP
         33     041     21      !       SOS     !
         34     042     22      "       FS      "
         35     043     23      #               #
         36     044     24      $       BYP     $
         37     045     25      %       LF      %
         38     046     26      &       ETB     &
         39     047     27      '       ESC     '
⌡
         40     050     28      (               (
         41     051     29      )               )
         42     052     2A      *       SM      *
         43     053     2B      +       CU2     +
         44     054     2C      ,               ,
         45     055     2D      -       ENQ     -
         46     056     2E      .       ACK     .
         47     057     2F      /       BEL     /
         48     060     30      0               0
         49     061     31      1               1
⌡
         50     062     32      2       SYN     2
         51     063     33      3               3
         52     064     34      4       PN      4
         53     065     35      5       RS      5
         54     066     36      6       UC      6
         55     067     37      7       EOT     7
         56     070     38      8               8
         57     071     39      9               9
         58     072     3A      :               :
         59     073     3B      ;       CU3     ;
⌡
         60     074     3C      <       DC4     <
         61     075     3D      =       NAK     =
         62     076     3E      >               >
         63     077     3F      ?       SUB     ?
         64     100     40      @       SP      @
         65     101     41      A               A
         66     102     42      B               B
         67     103     43      C               C
         68     104     44      D               D
         69     105     45      E               E
⌡
         70     106     46      F               F
         71     107     47      G               G
         72     110     48      H               H
         73     111     49      I               I
         74     112     4A      J       ¢       J
         75     113     4B      K       .       K
         76     114     4C      L       <       L
         77     115     4D      M       {       M
         78     116     4E      N       +       N
         79     117     4F      O       |       O
⌡
         80     120     50      P       &       P
         81     121     51      Q               Q
         82     122     52      R               R
         83     123     53      S               S
         84     124     54      T               T
         85     125     55      U               U
         86     126     56      V               V
         87     127     57      W               W
         88     130     58      X               X
         89     131     59      Y               Y
⌡
         90     132     5A      Z       !       Z
         91     133     5B      [       $       [
         92     134     5C      \       *       \
         93     135     5D      ]       )       ]
         94     136     5E      ^       ;       ^
         95     137     5F      _       ¬       _
         96     140     60      `               `
         97     141     61      a       /       a
         98     142     62      b               b
         99     143     63      c               c
⌡
        100     144     64      d               d
        101     145     65      e               e
        102     146     66      f               f
        103     147     67      g               g
        104     150     68      h               h
        105     151     69      i               i
        106     152     6A      j               j
        107     153     6B      k       ,       k
        108     154     6C      l       %       l
        109     155     6D      m       _       m
⌡
        110     156     6E      n       >       n
        111     157     6F      o       ?       o
        112     160     70      p               p
        113     161     71      q               q
        114     162     72      r               r
        115     163     73      s               s
        116     164     74      t               t
        117     165     75      u               u
        118     166     76      v               v
        119     167     77      w               w
▐
        120     170     78      x               x
        121     171     79      y               y
        122     172     7A      z       :       z
        123     173     7B      {       #       {
        124     174     7C      |       @       |
        125     175     7D      }       '       }
        126     176     7E      ~~      =       ~~
        127     177     7F             "       
        128     200     80      Ç
        129     201     81      ü       a
ò
        130     202     82      é       b
        131     203     83      â       c
        132     204     84      ä       d
        133     205     85      à       e
        134     206     86      å       f
        135     207     87      ç       g
        136     210     88      ê       h
        137     211     89      ë       i
        138     212     8A      è
        139     213     8B      ï
}
        140     214     8C      î
        141     215     8D      ì
        142     216     8E      Ä
        143     217     8F      Å
        144     220     90      É
        145     221     91      æ       j
        146     222     92      Æ       k
        147     223     93      ô       l
        148     224     94      ö       m
        149     225     95      ò       n
u
        150     226     96      û       o
        151     227     97      ù       p
        152     230     98      ÿ       q
        153     231     99      Ö       r
        154     232     9A      Ü
        155     233     9B      ¢
        156     234     9C      £
        157     235     9D      ¥
        158     236     9E      ₧
        159     237     9F      ƒ
ò
        160     240     A0      á
        161     241     A1      í
        162     242     A2      ó       s
        163     243     A3      ú       t
        164     244     A4      ñ       u
        165     245     A5      Ñ       v
        166     246     A6      ª       w
        167     247     A7      º       x
        168     250     A8      ¿       y
        169     251     A9      ⌐       z
U
        170     252     AA      ¬
        171     253     AB      ½
        172     254     AC      ¼
        173     255     AD      ¡
        174     256     AE      «
        175     257     AF      »
        176     260     B0      ░
        177     261     B1      ▒
        178     262     B2      ▓
        179     263     B3      │
U
        180     264     B4      ┤
        181     265     B5      ╡
        182     266     B6      ╢
        183     267     B7      ╖
        184     270     B8      ╕
        185     271     B9      ╣
        186     272     BA      ║
        187     273     BB      ╗
        188     274     BC      ╝
        189     275     BD      ╜
ì
        190     276     BE      ╛
        191     277     BF      ┐
        192     300     C0      └
        193     301     C1      ┴       A
        194     302     C2      ┬       B
        195     303     C3      ├       C
        196     304     C4      ─       D
        197     305     C5      ┼       E
        198     306     C6      ╞       F
        199     307     C7      ╟       G
m
        200     310     C8      ╚       H
        201     311     C9      ╔       I
        202     312     CA      ╩
        203     313     CB      ╦
        204     314     CC      ╠
        205     315     CD      ═
        206     316     CE      ╬
        207     317     CF      ╧
        208     320     D0      ╨
        209     321     D1      ╤       J
ò
        210     322     D2      ╥       K
        211     323     D3      ╙       L
        212     324     D4      ╘       M
        213     325     D5      ╒       N
        214     326     D6      ╓       O
        215     327     D7      ╫       P
        216     330     D8      ╪       Q
        217     331     D9      ┘       R
        218     332     DA      ┌
        219     333     DB      █
u
        220     334     DC      ▄
        221     335     DD      ▌
        222     336     DE      ▐
        223     337     DF      ▀
        224     340     E0      α
        225     341     E1      ß
        226     342     E2      Γ       S
        227     343     E3      π       T
        228     344     E4      Σ       U
        229     345     E5      σ       V
u
        230     346     E6      µ       W
        231     347     E7      τ       X
        232     350     E8      Φ       Y
        233     351     E9      Θ       Z
        234     352     EA      Ω
        235     353     EB      δ
        236     354     EC      ∞
        237     355     ED      φ
        238     356     EE      ε
        239     357     EF      ∩
Ñ
        240     360     F0      ≡       0
        241     361     F1      ±       1
        242     362     F2      ≥       2
        243     363     F3      ≤       3
        244     364     F4      ⌠       4
        245     365     F5      ⌡       5
        246     366     F6      ÷       6
        247     367     F7      ≈       7
        248     370     F8      °       8
        249     371     F9      ∙       9
╞
        250     372     FA      ·
        251     373     FB      √
        252     374     FC      ⁿ
        253     375     FD      ²
        254     376     FE      ■
        255     377     FF
'.
                             ASCII Key Codes
l
   ─────────────────────────────────────────────────────────────────────
   Key                     Code      SHIFT+code  CTRL+code  ALT+code
   ─────────────────────────────────────────────────────────────────────
   F1                      0;59      0;84        0;94       0;104
   F2                      0;60      0;85        0;95       0;105
   F3                      0;61      0;86        0;96       0;106
   F4                      0;62      0;87        0;97       0;107
   F5                      0;63      0;88        0;98       0;108
   F6                      0;64      0;89        0;99       0;109
   F7                      0;65      0;90        0;100      0;110
   F8                      0;66      0;91        0;101      0;111
   F9                      0;67      0;92        0;102      0;112
   F10                     0;68      0;93        0;103      0;113
à
   F11                     0;133     0;135       0;137      0;139
   F12                     0;134     0;136       0;138      0;140
m
   HOME                    0;71      55          0;119      -
   UP ARROW                0;72      56          (0;141)    -
   PAGE UP                 0;73      57          0;132      -
   LEFT ARROW              0;75      52          0;115      -
   RIGHT ARROW             0;77      54          0;116      -
   END                     0;79      49          0;117      -
   DOWN ARROW              0;80      50          (0;145)    -
   PAGE DOWN               0;81      51          0;118      -
   INSERT                  0;82      48          (0;146)    -
   DELETE                  0;83      46          (0;147)    -
╜
   HOME        (gray key)  (224;71)  (224;71)    (224;119)  (224;151)
   UP ARROW    (gray key)  (224;72)  (224;72)    (224;141)  (224;152)
   PAGE UP     (gray key)  (224;73)  (224;73)    (224;132)  (224;153)
   LEFT ARROW  (gray key)  (224;75)  (224;75)    (224;115)  (224;155)
   RIGHT ARROW (gray key)  (224;77)  (224;77)    (224;116)  (224;157)
   END         (gray key)  (224;79)  (224;79)    (224;117)  (224;159)
   DOWN ARROW  (gray key)  (224;80)  (224;80)    (224;145)  (224;154)
   PAGE DOWN   (gray key)  (224;81)  (224;81)    (224;118)  (224;161)
   INSERT      (gray key)  (224;82)  (224;82)    (224;146)  (224;162)
   DELETE      (gray key)  (224;83)  (224;83)    (224;147)  (224;163)
é
   PRINT SCREEN            -         -           0;114      -
   PAUSE/BREAK             -         -           0;0        -
   BACKSPACE               8         8           127        (0)
   ENTER                   13        -           10         (0;28)
   TAB                     9         0;15        (0;148)    (0;165)
   NULL                    0;3       -           -          -
J
   A                       97        65          1          0;30
   B                       98        66          2          0;48
   C                       99        67          3          0;46
   D                       100       68          4          0;32
   E                       101       69          5          0;18
   F                       102       70          6          0;33
   G                       103       71          7          0;34
   H                       104       72          8          0;35
   I                       105       73          9          0;23
ï
   J                       106       74          10         0;36
   K                       107       75          11         0;37
   L                       108       76          12         0;38
   M                       109       77          13         0;50
   N                       110       78          14         0;49
   O                       111       79          15         0;24
   P                       112       80          16         0;25
   Q                       113       81          17         0;16
   R                       114       82          18         0;19
   S                       115       83          19         0;31
╚
   T                       116       84          20         0;20
   U                       117       85          21         0;22
   V                       118       86          22         0;47
   W                       119       87          23         0;17
   X                       120       88          24         0;45
   Y                       121       89          25         0;21
   Z                       122       90          26         0;44
ò
   0                       48        41          -          0;129
   1                       49        33          -          0;120
   2                       50        64          0          0;121
   3                       51        35          -          0;122
   4                       52        36          -          0;123
   5                       53        37          -          0;124
   6                       54        94          30         0;125
   7                       55        38          -          0;126
   8                       56        42          -          0;127
   9                       57        40          -          0;128
╨
   -                       45        95          31         0;130
   =                       61        43          -          0;131
   [                       91        123         27         0;26
   ]                       93        125         29         0;27
   \                       92        124         28         0;43
   ;                       59        58          -          0;39
   '                       39        34          -          0;40
   ,                       44        60          -          0;51
   .                       46        62          -          0;52
   /                       47        63          -          0;53
   `                       96        126         -          (0;41)
ï
   ENTER (keypad)          13        -           10         (0;166)
   /     (keypad)          47        47          (0;142)    (0;74)
   *     (keypad)          42        (0;144)     (0;78)     -
   -     (keypad)          45        45          (0;149)    (0;164)
   +     (keypad)          43        43          (0;150)    (0;55)
   5     (keypad)          (0;76)    53          (0;143)    -
'
>
               Key       Normal    Shifted   w/Ctrl    w/Alt
c
                A         1E61      1E41      1E01      1E00
                B         3062      3042      3002      3000
                C         2E63      2E42      2E03      2E00
                D         2064      2044      2004      2000
                E         1265      1245      1205      1200
                F         2166      2146      2106      2100
                G         2267      2247      2207      2200
                H         2368      2348      2308      2300
                I         1769      1749      1709      1700
                J         246A      244A      240A      2400
c
                K         256B      254B      250B      2500
                L         266C      264C      260C      2600
                M         326D      324D      320D      3200
                N         316E      314E      310E      3100
                O         186F      184F      180F      1800
                P         1970      1950      1910      1900
                Q         1071      1051      1011      1000
                R         1372      1352      1312      1300
                S         1F73      1F53      1F13      1F00
                T         1474      1454      1414      1400
o
                U         1675      1655      1615      1600
                V         2F76      2F56      2F16      2F00
                W         1177      1157      1117      1100
                X         2D78      2D58      2D18      2D00
                Y         1579      1559      1519      1500
                Z         2C7A      2C5A      2C1A      2C00
>
               Key       Normal    Shifted   w/Ctrl    w/Alt
c
                1         0231      0221                7800
                2         0332      0340      0300      7900
                3         0433      0423                7A00
                4         0534      0524                7B00
                5         0635      0625                7C00
                6         0736      075E      071E      7D00
                7         0837      0826                7E00
                8         0938      092A                7F00
                9         0A39      0A28                8000
                0         0B30      0B29                8100
>
               Key       Normal    Shifted   w/Ctrl    w/Alt
<
                -         0C2D      0C5F      0C1F      8200
                =         0D3D      0D2B                8300
                [         1A5B      1A7B      1A1B      1A00
                ]         1B5D      1B7D      1B1D      1B00
                ;         273B      273A                2700
                '         2827      2822
                `         2960      297E
                \         2B5C      2B7C      2B1C      2600
                ,         332C      333C
                .         342E      343E
                /         352F      353F
>
                Key      Normal    Shifted   w/Ctrl    w/Alt
▌
                F1        3B00      5400      5E00      6800
                F2        3C00      5500      5F00      6900
                F3        3D00      5600      6000      6A00
                F4        3E00      5700      6100      6B00
                F5        3F00      5800      6200      6C00
                F6        4000      5900      6300      6D00
                F7        4100      5A00      6400      6E00
                F8        4200      5B00      6500      6F00
                F9        4300      5C00      6600      7000
                F10       4400      5D00      6700      7100
                F11       8500      8700      8900      8B00
                F12       8600      8800      8A00      8C00
A
                Key         Normal    Shifted   w/Ctrl    w/Alt
∙
                BackSpace    0E08      0E08      0E7F     0E00
                Del          5300      532E      9300     A300
                Down Arrow   5000      5032      9100     A000
                End          4F00      4F31      7500     9F00
                Enter        1C0D      1C0D      1C0A     A600
                Esc          011B      011B      011B     0100
                Home         4700      4737      7700     9700
                Ins          5200      5230      9200     A200
"
                Keypad 5               4C35      8F00
                Keypad *     372A                9600     3700
                Keypad -     4A2D      4A2D      8E00     4A00
                Keypad +     4E2B      4E2B               4E00
                Keypad /     352F      352F      9500     A400
                Left Arrow   4B00      4B34      7300     9B00
                PgDn         5100      5133      7600     A100
                PgUp         4900      4939      8400     9900
                PrtSc                            7200
                Right Arrow  4D00      4D36      7400     9D00
                SpaceBar     3920      3920      3920     3920
                Tab          0F09      0F00      9400     A500
                Up Arrow     4800      4838      8D00     9800
'╛╚≥	Ω
p╝
Ñµ╤â3!╠=ε<} ö!v"{#q$r%╚%&'√'æ(Γ)^*ô+┼,`-E.q/v031░1w2≥3≡89P9∙:<Æ<¥@àI$KXM∩O£QñTáWÿZ;]`c²e⌠g7jÑloqq!|ª}PüÇé┐âƒàΣå√ëdì╞Å\æô╓öªûàÿK£mƒSíú╟ªε¡⌠▓╡┤╣i╛S┴%├U┼I╩╒╫ëα]Γ_σéΦkΩ\∞î∩╢≥U⌠·⌡$∙■·╗ⁿu N{Ö	║Σáx[7 Æ$}&`(-*á-H2≥7╝:%=3?nBáDáFÇJdNRÖT?WU[5_c«dêhNlpo=rftìv╞x─z╬|Gü▓âå▀ç╡ëäïZì/Åæô#ò├ûiÿíÿI£í÷óÑñ╫Ñpº╖⌐G¼²¡δ░∞│╢F╕~║H╝⌐╛╔└╟├═├≥ì
