This is nasm.info, produced by makeinfo version 6.0 from nasmdoc.texi.

INFO-DIR-SECTION Programming
START-INFO-DIR-ENTRY
* NASM: (nasm).                The Netwide Assembler for x86.
END-INFO-DIR-ENTRY

This file documents NASM, the Netwide Assembler: an assembler targetting
the Intel x86 series of processors, with portable source.

   Copyright 1996-2016 The NASM Development Team

   This document is redistributable under the license given in the file
"LICENSE" distributed in the NASM archive.


File: nasm.info,  Node: Section 8.5.2,  Next: Section 8.5.3,  Prev: Section 8.5.1,  Up: Section 8.5

8.5.2. Borland Pascal Segment Name Restrictions
-----------------------------------------------

Since Borland Pascal's internal unit file format is completely different
from 'OBJ', it only makes a very sketchy job of actually reading and
understanding the various information contained in a real 'OBJ' file
when it links that in.  Therefore an object file intended to be linked
to a Pascal program must obey a number of restrictions:

   * Procedures and functions must be in a segment whose name is either
     'CODE', 'CSEG', or something ending in '_TEXT'.

   * initialized data must be in a segment whose name is either 'CONST'
     or something ending in '_DATA'.

   * Uninitialized data must be in a segment whose name is either
     'DATA', 'DSEG', or something ending in '_BSS'.

   * Any other segments in the object file are completely ignored.
     'GROUP' directives and segment attributes are also ignored.


File: nasm.info,  Node: Section 8.5.3,  Next: Chapter 9,  Prev: Section 8.5.2,  Up: Section 8.5

8.5.3. Using 'c16.mac' With Pascal Programs
-------------------------------------------

The 'c16.mac' macro package, described in *note Section 8.4.5::, can
also be used to simplify writing functions to be called from Pascal
programs, if you code '%define PASCAL'.  This definition ensures that
functions are far (it implies 'FARCODE'), and also causes procedure
return instructions to be generated with an operand.

   Defining 'PASCAL' does not change the code which calculates the
argument offsets; you must declare your function's arguments in reverse
order.  For example:

     %define PASCAL

     proc    _pascalproc

     %$j     arg 4
     %$i     arg
             mov     ax,[bp + %$i]
             mov     bx,[bp + %$j]
             mov     es,[bp + %$j + 2]
             add     ax,[bx]

     endproc

   This defines the same routine, conceptually, as the example in *note
Section 8.4.5::: it defines a function taking two arguments, an integer
and a pointer to an integer, which returns the sum of the integer and
the contents of the pointer.  The only difference between this code and
the large-model C version is that 'PASCAL' is defined instead of
'FARCODE', and that the arguments are declared in reverse order.


File: nasm.info,  Node: Chapter 9,  Next: Section 9.1,  Prev: Section 8.5.3,  Up: Top

Chapter 9: Writing 32-bit Code (Unix, Win32, DJGPP)
***************************************************

This chapter attempts to cover some of the common issues involved when
writing 32-bit code, to run under Win32 or Unix, or to be linked with C
code generated by a Unix-style C compiler such as DJGPP. It covers how
to write assembly code to interface with 32-bit C routines, and how to
write position-independent code for shared libraries.

   Almost all 32-bit code, and in particular all code running under
'Win32', 'DJGPP' or any of the PC Unix variants, runs in _flat_ memory
model.  This means that the segment registers and paging have already
been set up to give you the same 32-bit 4Gb address space no matter what
segment you work relative to, and that you should ignore all segment
registers completely.  When writing flat-model application code, you
never need to use a segment override or modify any segment register, and
the code-section addresses you pass to 'CALL' and 'JMP' live in the same
address space as the data-section addresses you access your variables by
and the stack-section addresses you access local variables and procedure
parameters by.  Every address is 32 bits long and contains only an
offset part.

* Menu:

* Section 9.1:: Interfacing to 32-bit C Programs
* Section 9.2:: Writing NetBSD/FreeBSD/OpenBSD and Linux/ELF Shared Libraries


File: nasm.info,  Node: Section 9.1,  Next: Section 9.1.1,  Prev: Chapter 9,  Up: Chapter 9

9.1. Interfacing to 32-bit C Programs
=====================================

A lot of the discussion in *note Section 8.4::, about interfacing to
16-bit C programs, still applies when working in 32 bits.  The absence
of memory models or segmentation worries simplifies things a lot.

* Menu:

* Section 9.1.1:: External Symbol Names
* Section 9.1.2:: Function Definitions and Function Calls
* Section 9.1.3:: Accessing Data Items
* Section 9.1.4:: 'c32.mac': Helper Macros for the 32-bit C Interface


File: nasm.info,  Node: Section 9.1.1,  Next: Section 9.1.2,  Prev: Section 9.1,  Up: Section 9.1

9.1.1. External Symbol Names
----------------------------

Most 32-bit C compilers share the convention used by 16-bit compilers,
that the names of all global symbols (functions or data) they define are
formed by prefixing an underscore to the name as it appears in the C
program.  However, not all of them do: the 'ELF' specification states
that C symbols do _not_ have a leading underscore on their
assembly-language names.

   The older Linux 'a.out' C compiler, all 'Win32' compilers, 'DJGPP',
and 'NetBSD' and 'FreeBSD', all use the leading underscore; for these
compilers, the macros 'cextern' and 'cglobal', as given in *note Section
8.4.1::, will still work.  For 'ELF', though, the leading underscore
should not be used.

   See also *note Section 2.1.27::.


File: nasm.info,  Node: Section 9.1.2,  Next: Section 9.1.3,  Prev: Section 9.1.1,  Up: Section 9.1

9.1.2. Function Definitions and Function Calls
----------------------------------------------

The C calling convention in 32-bit programs is as follows.  In the
following description, the words _caller_ and _callee_ are used to
denote the function doing the calling and the function which gets
called.

   * The caller pushes the function's parameters on the stack, one after
     another, in reverse order (right to left, so that the first
     argument specified to the function is pushed last).

   * The caller then executes a near 'CALL' instruction to pass control
     to the callee.

   * The callee receives control, and typically (although this is not
     actually necessary, in functions which do not need to access their
     parameters) starts by saving the value of 'ESP' in 'EBP' so as to
     be able to use 'EBP' as a base pointer to find its parameters on
     the stack.  However, the caller was probably doing this too, so
     part of the calling convention states that 'EBP' must be preserved
     by any C function.  Hence the callee, if it is going to set up
     'EBP' as a frame pointer, must push the previous value first.

   * The callee may then access its parameters relative to 'EBP'.  The
     doubleword at '[EBP]' holds the previous value of 'EBP' as it was
     pushed; the next doubleword, at '[EBP+4]', holds the return
     address, pushed implicitly by 'CALL'.  The parameters start after
     that, at '[EBP+8]'.  The leftmost parameter of the function, since
     it was pushed last, is accessible at this offset from 'EBP'; the
     others follow, at successively greater offsets.  Thus, in a
     function such as 'printf' which takes a variable number of
     parameters, the pushing of the parameters in reverse order means
     that the function knows where to find its first parameter, which
     tells it the number and type of the remaining ones.

   * The callee may also wish to decrease 'ESP' further, so as to
     allocate space on the stack for local variables, which will then be
     accessible at negative offsets from 'EBP'.

   * The callee, if it wishes to return a value to the caller, should
     leave the value in 'AL', 'AX' or 'EAX' depending on the size of the
     value.  Floating-point results are typically returned in 'ST0'.

   * Once the callee has finished processing, it restores 'ESP' from
     'EBP' if it had allocated local stack space, then pops the previous
     value of 'EBP', and returns via 'RET' (equivalently, 'RETN').

   * When the caller regains control from the callee, the function
     parameters are still on the stack, so it typically adds an
     immediate constant to 'ESP' to remove them (instead of executing a
     number of slow 'POP' instructions).  Thus, if a function is
     accidentally called with the wrong number of parameters due to a
     prototype mismatch, the stack will still be returned to a sensible
     state since the caller, which _knows_ how many parameters it
     pushed, does the removing.

   There is an alternative calling convention used by Win32 programs for
Windows API calls, and also for functions called _by_ the Windows API
such as window procedures: they follow what Microsoft calls the
'__stdcall' convention.  This is slightly closer to the Pascal
convention, in that the callee clears the stack by passing a parameter
to the 'RET' instruction.  However, the parameters are still pushed in
right-to-left order.

   Thus, you would define a function in C style in the following way:

     global  _myfunc

     _myfunc:
             push    ebp
             mov     ebp,esp
             sub     esp,0x40        ; 64 bytes of local stack space
             mov     ebx,[ebp+8]     ; first parameter to function

             ; some more code

             leave                   ; mov esp,ebp / pop ebp
             ret

   At the other end of the process, to call a C function from your
assembly code, you would do something like this:

     extern  _printf

             ; and then, further down...

             push    dword [myint]   ; one of my integer variables
             push    dword mystring  ; pointer into my data segment
             call    _printf
             add     esp,byte 8      ; `byte' saves space

             ; then those data items...

     segment _DATA

     myint       dd   1234
     mystring    db   'This number -> %d <- should be 1234',10,0

   This piece of code is the assembly equivalent of the C code

         int myint = 1234;
         printf("This number -> %d <- should be 1234\n", myint);


File: nasm.info,  Node: Section 9.1.3,  Next: Section 9.1.4,  Prev: Section 9.1.2,  Up: Section 9.1

9.1.3. Accessing Data Items
---------------------------

To get at the contents of C variables, or to declare variables which C
can access, you need only declare the names as 'GLOBAL' or 'EXTERN'.
(Again, the names require leading underscores, as stated in *note
Section 9.1.1::.)  Thus, a C variable declared as 'int i' can be
accessed from assembler as

               extern _i
               mov eax,[_i]

   And to declare your own integer variable which C programs can access
as 'extern int j', you do this (making sure you are assembling in the
'_DATA' segment, if necessary):

               global _j
     _j        dd 0

   To access a C array, you need to know the size of the components of
the array.  For example, 'int' variables are four bytes long, so if a C
program declares an array as 'int a[10]', you can access 'a[3]' by
coding 'mov ax,[_a+12]'.  (The byte offset 12 is obtained by multiplying
the desired array index, 3, by the size of the array element, 4.)  The
sizes of the C base types in 32-bit compilers are: 1 for 'char', 2 for
'short', 4 for 'int', 'long' and 'float', and 8 for 'double'.  Pointers,
being 32-bit addresses, are also 4 bytes long.

   To access a C data structure, you need to know the offset from the
base of the structure to the field you are interested in.  You can
either do this by converting the C structure definition into a NASM
structure definition (using 'STRUC'), or by calculating the one offset
and using just that.

   To do either of these, you should read your C compiler's manual to
find out how it organizes data structures.  NASM gives no special
alignment to structure members in its own 'STRUC' macro, so you have to
specify alignment yourself if the C compiler generates it.  Typically,
you might find that a structure like

     struct {
         char c;
         int i;
     } foo;

   might be eight bytes long rather than five, since the 'int' field
would be aligned to a four-byte boundary.  However, this sort of feature
is sometimes a configurable option in the C compiler, either using
command- line options or '#pragma' lines, so you have to find out how
your own compiler does it.


File: nasm.info,  Node: Section 9.1.4,  Next: Section 9.2,  Prev: Section 9.1.3,  Up: Section 9.1

9.1.4. 'c32.mac': Helper Macros for the 32-bit C Interface
----------------------------------------------------------

Included in the NASM archives, in the 'misc' directory, is a file
'c32.mac' of macros.  It defines three macros: 'proc', 'arg' and
'endproc'.  These are intended to be used for C-style procedure
definitions, and they automate a lot of the work involved in keeping
track of the calling convention.

   An example of an assembly function using the macro set is given here:

     proc    _proc32

     %$i     arg
     %$j     arg
             mov     eax,[ebp + %$i]
             mov     ebx,[ebp + %$j]
             add     eax,[ebx]

     endproc

   This defines '_proc32' to be a procedure taking two arguments, the
first ('i') an integer and the second ('j') a pointer to an integer.  It
returns 'i + *j'.

   Note that the 'arg' macro has an 'EQU' as the first line of its
expansion, and since the label before the macro call gets prepended to
the first line of the expanded macro, the 'EQU' works, defining '%$i' to
be an offset from 'BP'.  A context-local variable is used, local to the
context pushed by the 'proc' macro and popped by the 'endproc' macro, so
that the same argument name can be used in later procedures.  Of course,
you don't _have_ to do that.

   'arg' can take an optional parameter, giving the size of the
argument.  If no size is given, 4 is assumed, since it is likely that
many function parameters will be of type 'int' or pointers.


File: nasm.info,  Node: Section 9.2,  Next: Section 9.2.1,  Prev: Section 9.1.4,  Up: Chapter 9

9.2. Writing NetBSD/FreeBSD/OpenBSD and Linux/ELF Shared Libraries
==================================================================

'ELF' replaced the older 'a.out' object file format under Linux because
it contains support for position-independent code (PIC), which makes
writing shared libraries much easier.  NASM supports the 'ELF'
position-independent code features, so you can write Linux 'ELF' shared
libraries in NASM.

   NetBSD, and its close cousins FreeBSD and OpenBSD, take a different
approach by hacking PIC support into the 'a.out' format.  NASM supports
this as the 'aoutb' output format, so you can write BSD shared libraries
in NASM too.

   The operating system loads a PIC shared library by memory-mapping the
library file at an arbitrarily chosen point in the address space of the
running process.  The contents of the library's code section must
therefore not depend on where it is loaded in memory.

   Therefore, you cannot get at your variables by writing code like
this:

             mov     eax,[myvar]             ; WRONG

   Instead, the linker provides an area of memory called the _global
offset table_, or GOT; the GOT is situated at a constant distance from
your library's code, so if you can find out where your library is loaded
(which is typically done using a 'CALL' and 'POP' combination), you can
obtain the address of the GOT, and you can then load the addresses of
your variables out of linker-generated entries in the GOT.

   The _data_ section of a PIC shared library does not have these
restrictions: since the data section is writable, it has to be copied
into memory anyway rather than just paged in from the library file, so
as long as it's being copied it can be relocated too.  So you can put
ordinary types of relocation in the data section without too much worry
(but see *note Section 9.2.4:: for a caveat).

* Menu:

* Section 9.2.1:: Obtaining the Address of the GOT
* Section 9.2.2:: Finding Your Local Data Items
* Section 9.2.3:: Finding External and Common Data Items
* Section 9.2.4:: Exporting Symbols to the Library User
* Section 9.2.5:: Calling Procedures Outside the Library
* Section 9.2.6:: Generating the Library File


File: nasm.info,  Node: Section 9.2.1,  Next: Section 9.2.2,  Prev: Section 9.2,  Up: Section 9.2

9.2.1. Obtaining the Address of the GOT
---------------------------------------

Each code module in your shared library should define the GOT as an
external symbol:

     extern  _GLOBAL_OFFSET_TABLE_   ; in ELF
     extern  __GLOBAL_OFFSET_TABLE_  ; in BSD a.out

   At the beginning of any function in your shared library which plans
to access your data or BSS sections, you must first calculate the
address of the GOT. This is typically done by writing the function in
this form:

     func:   push    ebp
             mov     ebp,esp
             push    ebx
             call    .get_GOT
     .get_GOT:
             pop     ebx
             add     ebx,_GLOBAL_OFFSET_TABLE_+$$-.get_GOT wrt ..gotpc

             ; the function body comes here

             mov     ebx,[ebp-4]
             mov     esp,ebp
             pop     ebp
             ret

   (For BSD, again, the symbol '_GLOBAL_OFFSET_TABLE' requires a second
leading underscore.)

   The first two lines of this function are simply the standard C
prologue to set up a stack frame, and the last three lines are standard
C function epilogue.  The third line, and the fourth to last line, save
and restore the 'EBX' register, because PIC shared libraries use this
register to store the address of the GOT.

   The interesting bit is the 'CALL' instruction and the following two
lines.  The 'CALL' and 'POP' combination obtains the address of the
label '.get_GOT', without having to know in advance where the program
was loaded (since the 'CALL' instruction is encoded relative to the
current position).  The 'ADD' instruction makes use of one of the
special PIC relocation types: GOTPC relocation.  With the 'WRT ..gotpc'
qualifier specified, the symbol referenced (here
'_GLOBAL_OFFSET_TABLE_', the special symbol assigned to the GOT) is
given as an offset from the beginning of the section.  (Actually, 'ELF'
encodes it as the offset from the operand field of the 'ADD'
instruction, but NASM simplifies this deliberately, so you do things the
same way for both 'ELF' and 'BSD'.)  So the instruction then _adds_ the
beginning of the section, to get the real address of the GOT, and
subtracts the value of '.get_GOT' which it knows is in 'EBX'.
Therefore, by the time that instruction has finished, 'EBX' contains the
address of the GOT.

   If you didn't follow that, don't worry: it's never necessary to
obtain the address of the GOT by any other means, so you can put those
three instructions into a macro and safely ignore them:

     %macro  get_GOT 0

             call    %%getgot
       %%getgot:
             pop     ebx
             add     ebx,_GLOBAL_OFFSET_TABLE_+$$-%%getgot wrt ..gotpc

     %endmacro


File: nasm.info,  Node: Section 9.2.2,  Next: Section 9.2.3,  Prev: Section 9.2.1,  Up: Section 9.2

9.2.2. Finding Your Local Data Items
------------------------------------

Having got the GOT, you can then use it to obtain the addresses of your
data items.  Most variables will reside in the sections you have
declared; they can be accessed using the '..gotoff' special 'WRT' type.
The way this works is like this:

             lea     eax,[ebx+myvar wrt ..gotoff]

   The expression 'myvar wrt ..gotoff' is calculated, when the shared
library is linked, to be the offset to the local variable 'myvar' from
the beginning of the GOT. Therefore, adding it to 'EBX' as above will
place the real address of 'myvar' in 'EAX'.

   If you declare variables as 'GLOBAL' without specifying a size for
them, they are shared between code modules in the library, but do not
get exported from the library to the program that loaded it.  They will
still be in your ordinary data and BSS sections, so you can access them
in the same way as local variables, using the above '..gotoff'
mechanism.

   Note that due to a peculiarity of the way BSD 'a.out' format handles
this relocation type, there must be at least one non-local symbol in the
same section as the address you're trying to access.


File: nasm.info,  Node: Section 9.2.3,  Next: Section 9.2.4,  Prev: Section 9.2.2,  Up: Section 9.2

9.2.3. Finding External and Common Data Items
---------------------------------------------

If your library needs to get at an external variable (external to the
_library_, not just to one of the modules within it), you must use the
'..got' type to get at it.  The '..got' type, instead of giving you the
offset from the GOT base to the variable, gives you the offset from the
GOT base to a GOT _entry_ containing the address of the variable.  The
linker will set up this GOT entry when it builds the library, and the
dynamic linker will place the correct address in it at load time.  So to
obtain the address of an external variable 'extvar' in 'EAX', you would
code

             mov     eax,[ebx+extvar wrt ..got]

   This loads the address of 'extvar' out of an entry in the GOT. The
linker, when it builds the shared library, collects together every
relocation of type '..got', and builds the GOT so as to ensure it has
every necessary entry present.

   Common variables must also be accessed in this way.


File: nasm.info,  Node: Section 9.2.4,  Next: Section 9.2.5,  Prev: Section 9.2.3,  Up: Section 9.2

9.2.4. Exporting Symbols to the Library User
--------------------------------------------

If you want to export symbols to the user of the library, you have to
declare whether they are functions or data, and if they are data, you
have to give the size of the data item.  This is because the dynamic
linker has to build procedure linkage table entries for any exported
functions, and also moves exported data items away from the library's
data section in which they were declared.

   So to export a function to users of the library, you must use

     global  func:function           ; declare it as a function

     func:   push    ebp

             ; etc.

   And to export a data item such as an array, you would have to code

     global  array:data array.end-array      ; give the size too

     array:  resd    128
     .end:

   Be careful: If you export a variable to the library user, by
declaring it as 'GLOBAL' and supplying a size, the variable will end up
living in the data section of the main program, rather than in your
library's data section, where you declared it.  So you will have to
access your own global variable with the '..got' mechanism rather than
'..gotoff', as if it were external (which, effectively, it has become).

   Equally, if you need to store the address of an exported global in
one of your data sections, you can't do it by means of the standard sort
of code:

     dataptr:        dd      global_data_item        ; WRONG

   NASM will interpret this code as an ordinary relocation, in which
'global_data_item' is merely an offset from the beginning of the '.data'
section (or whatever); so this reference will end up pointing at your
data section instead of at the exported global which resides elsewhere.

   Instead of the above code, then, you must write

     dataptr:        dd      global_data_item wrt ..sym

   which makes use of the special 'WRT' type '..sym' to instruct NASM to
search the symbol table for a particular symbol at that address, rather
than just relocating by section base.

   Either method will work for functions: referring to one of your
functions by means of

     funcptr:        dd      my_function

   will give the user the address of the code you wrote, whereas

     funcptr:        dd      my_function wrt ..sym

   will give the address of the procedure linkage table for the
function, which is where the calling program will _believe_ the function
lives.  Either address is a valid way to call the function.


File: nasm.info,  Node: Section 9.2.5,  Next: Section 9.2.6,  Prev: Section 9.2.4,  Up: Section 9.2

9.2.5. Calling Procedures Outside the Library
---------------------------------------------

Calling procedures outside your shared library has to be done by means
of a _procedure linkage table_, or PLT. The PLT is placed at a known
offset from where the library is loaded, so the library code can make
calls to the PLT in a position-independent way.  Within the PLT there is
code to jump to offsets contained in the GOT, so function calls to other
shared libraries or to routines in the main program can be transparently
passed off to their real destinations.

   To call an external routine, you must use another special PIC
relocation type, 'WRT ..plt'.  This is much easier than the GOT-based
ones: you simply replace calls such as 'CALL printf' with the
PLT-relative version 'CALL printf WRT ..plt'.


File: nasm.info,  Node: Section 9.2.6,  Next: Chapter 10,  Prev: Section 9.2.5,  Up: Section 9.2

9.2.6. Generating the Library File
----------------------------------

Having written some code modules and assembled them to '.o' files, you
then generate your shared library with a command such as

     ld -shared -o library.so module1.o module2.o       # for ELF
     ld -Bshareable -o library.so module1.o module2.o   # for BSD

   For ELF, if your shared library is going to reside in system
directories such as '/usr/lib' or '/lib', it is usually worth using the
'-soname' flag to the linker, to store the final library file name, with
a version number, into the library:

     ld -shared -soname library.so.1 -o library.so.1.2 *.o

   You would then copy 'library.so.1.2' into the library directory, and
create 'library.so.1' as a symbolic link to it.


File: nasm.info,  Node: Chapter 10,  Next: Section 10.1,  Prev: Section 9.2.6,  Up: Top

Chapter 10: Mixing 16 and 32 Bit Code
*************************************

This chapter tries to cover some of the issues, largely related to
unusual forms of addressing and jump instructions, encountered when
writing operating system code such as protected-mode initialisation
routines, which require code that operates in mixed segment sizes, such
as code in a 16-bit segment trying to modify data in a 32-bit one, or
jumps between different- size segments.

* Menu:

* Section 10.1:: Mixed-Size Jumps
* Section 10.2:: Addressing Between Different-Size Segments
* Section 10.3:: Other Mixed-Size Instructions


File: nasm.info,  Node: Section 10.1,  Next: Section 10.2,  Prev: Chapter 10,  Up: Chapter 10

10.1. Mixed-Size Jumps
======================

The most common form of mixed-size instruction is the one used when
writing a 32-bit OS: having done your setup in 16-bit mode, such as
loading the kernel, you then have to boot it by switching into protected
mode and jumping to the 32-bit kernel start address.  In a fully 32-bit
OS, this tends to be the _only_ mixed-size instruction you need, since
everything before it can be done in pure 16-bit code, and everything
after it can be pure 32-bit.

   This jump must specify a 48-bit far address, since the target segment
is a 32-bit one.  However, it must be assembled in a 16-bit segment, so
just coding, for example,

             jmp     0x1234:0x56789ABC       ; wrong!

   will not work, since the offset part of the address will be truncated
to '0x9ABC' and the jump will be an ordinary 16-bit far one.

   The Linux kernel setup code gets round the inability of 'as86' to
generate the required instruction by coding it manually, using 'DB'
instructions.  NASM can go one better than that, by actually generating
the right instruction itself.  Here's how to do it right:

             jmp     dword 0x1234:0x56789ABC         ; right

   The 'DWORD' prefix (strictly speaking, it should come _after_ the
colon, since it is declaring the _offset_ field to be a doubleword; but
NASM will accept either form, since both are unambiguous) forces the
offset part to be treated as far, in the assumption that you are
deliberately writing a jump from a 16-bit segment to a 32-bit one.

   You can do the reverse operation, jumping from a 32-bit segment to a
16-bit one, by means of the 'WORD' prefix:

             jmp     word 0x8765:0x4321      ; 32 to 16 bit

   If the 'WORD' prefix is specified in 16-bit mode, or the 'DWORD'
prefix in 32-bit mode, they will be ignored, since each is explicitly
forcing NASM into a mode it was in anyway.


File: nasm.info,  Node: Section 10.2,  Next: Section 10.3,  Prev: Section 10.1,  Up: Chapter 10

10.2. Addressing Between Different-Size Segments
================================================

If your OS is mixed 16 and 32-bit, or if you are writing a DOS extender,
you are likely to have to deal with some 16-bit segments and some 32-bit
ones.  At some point, you will probably end up writing code in a 16-bit
segment which has to access data in a 32-bit segment, or vice versa.

   If the data you are trying to access in a 32-bit segment lies within
the first 64K of the segment, you may be able to get away with using an
ordinary 16-bit addressing operation for the purpose; but sooner or
later, you will want to do 32-bit addressing from 16-bit mode.

   The easiest way to do this is to make sure you use a register for the
address, since any effective address containing a 32-bit register is
forced to be a 32-bit address.  So you can do

             mov     eax,offset_into_32_bit_segment_specified_by_fs
             mov     dword [fs:eax],0x11223344

   This is fine, but slightly cumbersome (since it wastes an instruction
and a register) if you already know the precise offset you are aiming
at.  The x86 architecture does allow 32-bit effective addresses to
specify nothing but a 4-byte offset, so why shouldn't NASM be able to
generate the best instruction for the purpose?

   It can.  As in *note Section 10.1::, you need only prefix the address
with the 'DWORD' keyword, and it will be forced to be a 32-bit address:

             mov     dword [fs:dword my_offset],0x11223344

   Also as in *note Section 10.1::, NASM is not fussy about whether the
'DWORD' prefix comes before or after the segment override, so arguably a
nicer-looking way to code the above instruction is

             mov     dword [dword fs:my_offset],0x11223344

   Don't confuse the 'DWORD' prefix _outside_ the square brackets, which
controls the size of the data stored at the address, with the one
'inside' the square brackets which controls the length of the address
itself.  The two can quite easily be different:

             mov     word [dword 0x12345678],0x9ABC

   This moves 16 bits of data to an address specified by a 32-bit
offset.

   You can also specify 'WORD' or 'DWORD' prefixes along with the 'FAR'
prefix to indirect far jumps or calls.  For example:

             call    dword far [fs:word 0x4321]

   This instruction contains an address specified by a 16-bit offset; it
loads a 48-bit far pointer from that (16-bit segment and 32-bit offset),
and calls that address.


File: nasm.info,  Node: Section 10.3,  Next: Chapter 11,  Prev: Section 10.2,  Up: Chapter 10

10.3. Other Mixed-Size Instructions
===================================

The other way you might want to access data might be using the string
instructions ('LODSx', 'STOSx' and so on) or the 'XLATB' instruction.
These instructions, since they take no parameters, might seem to have no
easy way to make them perform 32-bit addressing when assembled in a
16-bit segment.

   This is the purpose of NASM's 'a16', 'a32' and 'a64' prefixes.  If
you are coding 'LODSB' in a 16-bit segment but it is supposed to be
accessing a string in a 32-bit segment, you should load the desired
address into 'ESI' and then code

             a32     lodsb

   The prefix forces the addressing size to 32 bits, meaning that
'LODSB' loads from '[DS:ESI]' instead of '[DS:SI]'.  To access a string
in a 16-bit segment when coding in a 32-bit one, the corresponding 'a16'
prefix can be used.

   The 'a16', 'a32' and 'a64' prefixes can be applied to any instruction
in NASM's instruction table, but most of them can generate all the
useful forms without them.  The prefixes are necessary only for
instructions with implicit addressing: 'CMPSx', 'SCASx', 'LODSx',
'STOSx', 'MOVSx', 'INSx', 'OUTSx', and 'XLATB'.  Also, the various push
and pop instructions ('PUSHA' and 'POPF' as well as the more usual
'PUSH' and 'POP') can accept 'a16', 'a32' or 'a64' prefixes to force a
particular one of 'SP', 'ESP' or 'RSP' to be used as a stack pointer, in
case the stack segment in use is a different size from the code segment.

   'PUSH' and 'POP', when applied to segment registers in 32-bit mode,
also have the slightly odd behaviour that they push and pop 4 bytes at a
time, of which the top two are ignored and the bottom two give the value
of the segment register being manipulated.  To force the 16-bit
behaviour of segment-register push and pop instructions, you can use the
operand-size prefix 'o16':

             o16 push    ss
             o16 push    ds

   This code saves a doubleword of stack space by fitting two segment
registers into the space which would normally be consumed by pushing
one.

   (You can also use the 'o32' prefix to force the 32-bit behaviour when
in 16-bit mode, but this seems less useful.)


File: nasm.info,  Node: Chapter 11,  Next: Section 11.1,  Prev: Section 10.3,  Up: Top

Chapter 11: Writing 64-bit Code (Unix, Win64)
*********************************************

This chapter attempts to cover some of the common issues involved when
writing 64-bit code, to run under Win64 or Unix.  It covers how to write
assembly code to interface with 64-bit C routines, and how to write
position-independent code for shared libraries.

   All 64-bit code uses a flat memory model, since segmentation is not
available in 64-bit mode.  The one exception is the 'FS' and 'GS'
registers, which still add their bases.

   Position independence in 64-bit mode is significantly simpler, since
the processor supports 'RIP'-relative addressing directly; see the 'REL'
keyword (*note Section 3.3::).  On most 64-bit platforms, it is probably
desirable to make that the default, using the directive 'DEFAULT REL'
(*note Section 6.2::).

   64-bit programming is relatively similar to 32-bit programming, but
of course pointers are 64 bits long; additionally, all existing
platforms pass arguments in registers rather than on the stack.
Furthermore, 64-bit platforms use SSE2 by default for floating point.
Please see the ABI documentation for your platform.

   64-bit platforms differ in the sizes of the fundamental datatypes,
not just from 32-bit platforms but from each other.  If a specific size
data type is desired, it is probably best to use the types defined in
the Standard C header '<inttypes.h>'.

   In 64-bit mode, the default instruction size is still 32 bits.  When
loading a value into a 32-bit register (but not an 8- or 16-bit
register), the upper 32 bits of the corresponding 64-bit register are
set to zero.

* Menu:

* Section 11.1:: Register Names in 64-bit Mode
* Section 11.2:: Immediates and Displacements in 64-bit Mode
* Section 11.3:: Interfacing to 64-bit C Programs (Unix)
* Section 11.4:: Interfacing to 64-bit C Programs (Win64)


File: nasm.info,  Node: Section 11.1,  Next: Section 11.2,  Prev: Chapter 11,  Up: Chapter 11

11.1. Register Names in 64-bit Mode
===================================

NASM uses the following names for general-purpose registers in 64-bit
mode, for 8-, 16-, 32- and 64-bit references, respectively:

          AL/AH, CL/CH, DL/DH, BL/BH, SPL, BPL, SIL, DIL, R8B-R15B
          AX, CX, DX, BX, SP, BP, SI, DI, R8W-R15W
          EAX, ECX, EDX, EBX, ESP, EBP, ESI, EDI, R8D-R15D
          RAX, RCX, RDX, RBX, RSP, RBP, RSI, RDI, R8-R15

   This is consistent with the AMD documentation and most other
assemblers.  The Intel documentation, however, uses the names 'R8L-R15L'
for 8-bit references to the higher registers.  It is possible to use
those names by definiting them as macros; similarly, if one wants to use
numeric names for the low 8 registers, define them as macros.  The
standard macro package 'altreg' (see *note Section 5.1::) can be used
for this purpose.


File: nasm.info,  Node: Section 11.2,  Next: Section 11.3,  Prev: Section 11.1,  Up: Chapter 11

11.2. Immediates and Displacements in 64-bit Mode
=================================================

In 64-bit mode, immediates and displacements are generally only 32 bits
wide.  NASM will therefore truncate most displacements and immediates to
32 bits.

   The only instruction which takes a full 64-bit immediate is:

          MOV reg64,imm64

   NASM will produce this instruction whenever the programmer uses 'MOV'
with an immediate into a 64-bit register.  If this is not desirable,
simply specify the equivalent 32-bit register, which will be
automatically zero- extended by the processor, or specify the immediate
as 'DWORD':

          mov rax,foo             ; 64-bit immediate
          mov rax,qword foo       ; (identical)
          mov eax,foo             ; 32-bit immediate, zero-extended
          mov rax,dword foo       ; 32-bit immediate, sign-extended

   The length of these instructions are 10, 5 and 7 bytes, respectively.

   The only instructions which take a full 64-bit _displacement_ is
loading or storing, using 'MOV', 'AL', 'AX', 'EAX' or 'RAX' (but no
other registers) to an absolute 64-bit address.  Since this is a
relatively rarely used instruction (64-bit code generally uses relative
addressing), the programmer has to explicitly declare the displacement
size as 'QWORD':

          default abs

          mov eax,[foo]           ; 32-bit absolute disp, sign-extended
          mov eax,[a32 foo]       ; 32-bit absolute disp, zero-extended
          mov eax,[qword foo]     ; 64-bit absolute disp

          default rel

          mov eax,[foo]           ; 32-bit relative disp
          mov eax,[a32 foo]       ; d:o, address truncated to 32 bits(!)
          mov eax,[qword foo]     ; error
          mov eax,[abs qword foo] ; 64-bit absolute disp

   A sign-extended absolute displacement can access from -2 GB to +2 GB;
a zero-extended absolute displacement can access from 0 to 4 GB.


File: nasm.info,  Node: Section 11.3,  Next: Section 11.4,  Prev: Section 11.2,  Up: Chapter 11

11.3. Interfacing to 64-bit C Programs (Unix)
=============================================

On Unix, the 64-bit ABI is defined by the document:

   'http://www.nasm.us/links/unix64abi'

   Although written for AT&T-syntax assembly, the concepts apply equally
well for NASM-style assembly.  What follows is a simplified summary.

   The first six integer arguments (from the left) are passed in 'RDI',
'RSI', 'RDX', 'RCX', 'R8', and 'R9', in that order.  Additional integer
arguments are passed on the stack.  These registers, plus 'RAX', 'R10'
and 'R11' are destroyed by function calls, and thus are available for
use by the function without saving.

   Integer return values are passed in 'RAX' and 'RDX', in that order.

   Floating point is done using SSE registers, except for 'long double'.
Floating-point arguments are passed in 'XMM0' to 'XMM7'; return is
'XMM0' and 'XMM1'.  'long double' are passed on the stack, and returned
in 'ST0' and 'ST1'.

   All SSE and x87 registers are destroyed by function calls.

   On 64-bit Unix, 'long' is 64 bits.

   Integer and SSE register arguments are counted separately, so for the
case of

          void foo(long a, double b, int c)

   'a' is passed in 'RDI', 'b' in 'XMM0', and 'c' in 'ESI'.


File: nasm.info,  Node: Section 11.4,  Next: Chapter 12,  Prev: Section 11.3,  Up: Chapter 11

11.4. Interfacing to 64-bit C Programs (Win64)
==============================================

The Win64 ABI is described at:

   'http://www.nasm.us/links/win64abi'

   What follows is a simplified summary.

   The first four integer arguments are passed in 'RCX', 'RDX', 'R8' and
'R9', in that order.  Additional integer arguments are passed on the
stack.  These registers, plus 'RAX', 'R10' and 'R11' are destroyed by
function calls, and thus are available for use by the function without
saving.

   Integer return values are passed in 'RAX' only.

   Floating point is done using SSE registers, except for 'long double'.
Floating-point arguments are passed in 'XMM0' to 'XMM3'; return is
'XMM0' only.

   On Win64, 'long' is 32 bits; 'long long' or '_int64' is 64 bits.

   Integer and SSE register arguments are counted together, so for the
case of

          void foo(long long a, double b, int c)

   'a' is passed in 'RCX', 'b' in 'XMM1', and 'c' in 'R8D'.


File: nasm.info,  Node: Chapter 12,  Next: Section 12.1,  Prev: Section 11.4,  Up: Top

Chapter 12: Troubleshooting
***************************

This chapter describes some of the common problems that users have been
known to encounter with NASM, and answers them.  It also gives
instructions for reporting bugs in NASM if you find a difficulty that
isn't listed here.

* Menu:

* Section 12.1:: Common Problems
* Section 12.2:: Bugs


File: nasm.info,  Node: Section 12.1,  Next: Section 12.1.1,  Prev: Chapter 12,  Up: Chapter 12

12.1. Common Problems
=====================

* Menu:

* Section 12.1.1:: NASM Generates Inefficient Code
* Section 12.1.2:: My Jumps are Out of Range
* Section 12.1.3:: 'ORG' Doesn't Work
* Section 12.1.4:: 'TIMES' Doesn't Work


File: nasm.info,  Node: Section 12.1.1,  Next: Section 12.1.2,  Prev: Section 12.1,  Up: Section 12.1

12.1.1. NASM Generates Inefficient Code
---------------------------------------

We sometimes get 'bug' reports about NASM generating inefficient, or
even 'wrong', code on instructions such as 'ADD ESP,8'.  This is a
deliberate design feature, connected to predictability of output: NASM,
on seeing 'ADD ESP,8', will generate the form of the instruction which
leaves room for a 32-bit offset.  You need to code 'ADD ESP,BYTE 8' if
you want the space-efficient form of the instruction.  This isn't a bug,
it's user error: if you prefer to have NASM produce the more efficient
code automatically enable optimization with the '-O' option (see *note
Section 2.1.22::).


File: nasm.info,  Node: Section 12.1.2,  Next: Section 12.1.3,  Prev: Section 12.1.1,  Up: Section 12.1

12.1.2. My Jumps are Out of Range
---------------------------------

Similarly, people complain that when they issue conditional jumps (which
are 'SHORT' by default) that try to jump too far, NASM reports 'short
jump out of range' instead of making the jumps longer.

   This, again, is partly a predictability issue, but in fact has a more
practical reason as well.  NASM has no means of being told what type of
processor the code it is generating will be run on; so it cannot decide
for itself that it should generate 'Jcc NEAR' type instructions, because
it doesn't know that it's working for a 386 or above.  Alternatively, it
could replace the out-of-range short 'JNE' instruction with a very short
'JE' instruction that jumps over a 'JMP NEAR'; this is a sensible
solution for processors below a 386, but hardly efficient on processors
which have good branch prediction _and_ could have used 'JNE NEAR'
instead.  So, once again, it's up to the user, not the assembler, to
decide what instructions should be generated.  See *note Section
2.1.22::.


File: nasm.info,  Node: Section 12.1.3,  Next: Section 12.1.4,  Prev: Section 12.1.2,  Up: Section 12.1

12.1.3. 'ORG' Doesn't Work
--------------------------

People writing boot sector programs in the 'bin' format often complain
that 'ORG' doesn't work the way they'd like: in order to place the
'0xAA55' signature word at the end of a 512-byte boot sector, people who
are used to MASM tend to code

             ORG 0

             ; some boot sector code

             ORG 510
             DW 0xAA55

   This is not the intended use of the 'ORG' directive in NASM, and will
not work.  The correct way to solve this problem in NASM is to use the
'TIMES' directive, like this:

             ORG 0

             ; some boot sector code

             TIMES 510-($-$$) DB 0
             DW 0xAA55

   The 'TIMES' directive will insert exactly enough zero bytes into the
output to move the assembly point up to 510.  This method also has the
advantage that if you accidentally fill your boot sector too full, NASM
will catch the problem at assembly time and report it, so you won't end
up with a boot sector that you have to disassemble to find out what's
wrong with it.


File: nasm.info,  Node: Section 12.1.4,  Next: Section 12.2,  Prev: Section 12.1.3,  Up: Section 12.1

12.1.4. 'TIMES' Doesn't Work
----------------------------

The other common problem with the above code is people who write the
'TIMES' line as

             TIMES 510-$ DB 0

   by reasoning that '$' should be a pure number, just like 510, so the
difference between them is also a pure number and can happily be fed to
'TIMES'.

   NASM is a _modular_ assembler: the various component parts are
designed to be easily separable for re-use, so they don't exchange
information unnecessarily.  In consequence, the 'bin' output format,
even though it has been told by the 'ORG' directive that the '.text'
section should start at 0, does not pass that information back to the
expression evaluator.  So from the evaluator's point of view, '$' isn't
a pure number: it's an offset from a section base.  Therefore the
difference between '$' and 510 is also not a pure number, but involves a
section base.  Values involving section bases cannot be passed as
arguments to 'TIMES'.

   The solution, as in the previous section, is to code the 'TIMES' line
in the form

             TIMES 510-($-$$) DB 0

   in which '$' and '$$' are offsets from the same section base, and so
their difference is a pure number.  This will solve the problem and
generate sensible code.


File: nasm.info,  Node: Section 12.2,  Next: Appendix A,  Prev: Section 12.1.4,  Up: Chapter 12

12.2. Bugs
==========

We have never yet released a version of NASM with any _known_ bugs.
That doesn't usually stop there being plenty we didn't know about,
though.  Any that you find should be reported firstly via the
'bugtracker' at 'http://www.nasm.us/' (click on "Bug Tracker"), or if
that fails then through one of the contacts in *note Section 1.2::.

   Please read *note Section 2.2:: first, and don't report the bug if
it's listed in there as a deliberate feature.  (If you think the feature
is badly thought out, feel free to send us reasons why you think it
should be changed, but don't just send us mail saying 'This is a bug' if
the documentation says we did it on purpose.)  Then read *note Section
12.1::, and don't bother reporting the bug if it's listed there.

   If you do report a bug, _please_ give us all of the following
information:

   * What operating system you're running NASM under.  DOS, Linux,
     NetBSD, Win16, Win32, VMS (I'd be impressed), whatever.

   * If you're running NASM under DOS or Win32, tell us whether you've
     compiled your own executable from the DOS source archive, or
     whether you were using the standard distribution binaries out of
     the archive.  If you were using a locally built executable, try to
     reproduce the problem using one of the standard binaries, as this
     will make it easier for us to reproduce your problem prior to
     fixing it.

   * Which version of NASM you're using, and exactly how you invoked it.
     Give us the precise command line, and the contents of the 'NASMENV'
     environment variable if any.

   * Which versions of any supplementary programs you're using, and how
     you invoked them.  If the problem only becomes visible at link
     time, tell us what linker you're using, what version of it you've
     got, and the exact linker command line.  If the problem involves
     linking against object files generated by a compiler, tell us what
     compiler, what version, and what command line or options you used.
     (If you're compiling in an IDE, please try to reproduce the problem
     with the command-line version of the compiler.)

   * If at all possible, send us a NASM source file which exhibits the
     problem.  If this causes copyright problems (e.g.  you can only
     reproduce the bug in restricted-distribution code) then bear in
     mind the following two points: firstly, we guarantee that any
     source code sent to us for the purposes of debugging NASM will be
     used _only_ for the purposes of debugging NASM, and that we will
     delete all our copies of it as soon as we have found and fixed the
     bug or bugs in question; and secondly, we would prefer _not_ to be
     mailed large chunks of code anyway.  The smaller the file, the
     better.  A three-line sample file that does nothing useful _except_
     demonstrate the problem is much easier to work with than a fully
     fledged ten-thousand- line program.  (Of course, some errors _do_
     only crop up in large files, so this may not be possible.)

   * A description of what the problem actually _is_.  'It doesn't work'
     is _not_ a helpful description!  Please describe exactly what is
     happening that shouldn't be, or what isn't happening that should.
     Examples might be: 'NASM generates an error message saying Line 3
     for an error that's actually on Line 5'; 'NASM generates an error
     message that I believe it shouldn't be generating at all'; 'NASM
     fails to generate an error message that I believe it _should_ be
     generating'; 'the object file produced from this source code
     crashes my linker'; 'the ninth byte of the output file is 66 and I
     think it should be 77 instead'.

   * If you believe the output file from NASM to be faulty, send it to
     us.  That allows us to determine whether our own copy of NASM
     generates the same file, or whether the problem is related to
     portability issues between our development platforms and yours.  We
     can handle binary files mailed to us as MIME attachments,
     uuencoded, and even BinHex.  Alternatively, we may be able to
     provide an FTP site you can upload the suspect files to; but
     mailing them is easier for us.

   * Any other information or data files that might be helpful.  If, for
     example, the problem involves NASM failing to generate an object
     file while TASM can generate an equivalent file without trouble,
     then send us _both_ object files, so we can see what TASM is doing
     differently from us.


File: nasm.info,  Node: Appendix A,  Next: Section A.1,  Prev: Section 12.2,  Up: Top

Appendix A: Ndisasm
*******************

The Netwide Disassembler, NDISASM

* Menu:

* Section A.1:: Introduction
* Section A.2:: Getting Started: Installation
* Section A.3:: Running NDISASM
* Section A.4:: Bugs and Improvements


File: nasm.info,  Node: Section A.1,  Next: Section A.2,  Prev: Appendix A,  Up: Appendix A

A.1. Introduction
=================

The Netwide Disassembler is a small companion program to the Netwide
Assembler, NASM. It seemed a shame to have an x86 assembler, complete
with a full instruction table, and not make as much use of it as
possible, so here's a disassembler which shares the instruction table
(and some other bits of code) with NASM.

   The Netwide Disassembler does nothing except to produce disassemblies
of _binary_ source files.  NDISASM does not have any understanding of
object file formats, like 'objdump', and it will not understand 'DOS
.EXE' files like 'debug' will.  It just disassembles.


File: nasm.info,  Node: Section A.2,  Next: Section A.3,  Prev: Section A.1,  Up: Appendix A

A.2. Getting Started: Installation
==================================

See *note Section 1.3:: for installation instructions.  NDISASM, like
NASM, has a 'man page' which you may want to put somewhere useful, if
you are on a Unix system.


File: nasm.info,  Node: Section A.3,  Next: Section A.3.1,  Prev: Section A.2,  Up: Appendix A

A.3. Running NDISASM
====================

To disassemble a file, you will typically use a command of the form

            ndisasm -b {16|32|64} filename

   NDISASM can disassemble 16-, 32- or 64-bit code equally easily,
provided of course that you remember to specify which it is to work
with.  If no '-b' switch is present, NDISASM works in 16-bit mode by
default.  The '-u' switch (for USE32) also invokes 32-bit mode.

   Two more command line options are '-r' which reports the version
number of NDISASM you are running, and '-h' which gives a short summary
of command line options.

* Menu:

* Section A.3.1:: COM Files: Specifying an Origin
* Section A.3.2:: Code Following Data: Synchronisation
* Section A.3.3:: Mixed Code and Data: Automatic (Intelligent) Synchronisation
* Section A.3.4:: Other Options


File: nasm.info,  Node: Section A.3.1,  Next: Section A.3.2,  Prev: Section A.3,  Up: Section A.3

A.3.1. COM Files: Specifying an Origin
--------------------------------------

To disassemble a 'DOS .COM' file correctly, a disassembler must assume
that the first instruction in the file is loaded at address '0x100',
rather than at zero.  NDISASM, which assumes by default that any file
you give it is loaded at zero, will therefore need to be informed of
this.

   The '-o' option allows you to declare a different origin for the file
you are disassembling.  Its argument may be expressed in any of the NASM
numeric formats: decimal by default, if it begins with ''$'' or ''0x''
or ends in ''H'' it's 'hex', if it ends in ''Q'' it's 'octal', and if it
ends in ''B'' it's 'binary'.

   Hence, to disassemble a '.COM' file:

            ndisasm -o100h filename.com

   will do the trick.


File: nasm.info,  Node: Section A.3.2,  Next: Section A.3.3,  Prev: Section A.3.1,  Up: Section A.3

A.3.2. Code Following Data: Synchronisation
-------------------------------------------

Suppose you are disassembling a file which contains some data which
isn't machine code, and _then_ contains some machine code.  NDISASM will
faithfully plough through the data section, producing machine
instructions wherever it can (although most of them will look bizarre,
and some may have unusual prefixes, e.g.  ''FS OR AX,0x240A''), and
generating 'DB' instructions ever so often if it's totally stumped.
Then it will reach the code section.

   Supposing NDISASM has just finished generating a strange machine
instruction from part of the data section, and its file position is now
one byte _before_ the beginning of the code section.  It's entirely
possible that another spurious instruction will get generated, starting
with the final byte of the data section, and then the correct first
instruction in the code section will not be seen because the starting
point skipped over it.  This isn't really ideal.

   To avoid this, you can specify a ''synchronisation'' point, or indeed
as many synchronisation points as you like (although NDISASM can only
handle 2147483647 sync points internally).  The definition of a sync
point is this: NDISASM guarantees to hit sync points exactly during
disassembly.  If it is thinking about generating an instruction which
would cause it to jump over a sync point, it will discard that
instruction and output a ''db'' instead.  So it _will_ start disassembly
exactly from the sync point, and so you _will_ see all the instructions
in your code section.

   Sync points are specified using the '-s' option: they are measured in
terms of the program origin, not the file position.  So if you want to
synchronize after 32 bytes of a '.COM' file, you would have to do

            ndisasm -o100h -s120h file.com

   rather than

            ndisasm -o100h -s20h file.com

   As stated above, you can specify multiple sync markers if you need
to, just by repeating the '-s' option.


File: nasm.info,  Node: Section A.3.3,  Next: Section A.3.4,  Prev: Section A.3.2,  Up: Section A.3

A.3.3. Mixed Code and Data: Automatic (Intelligent) Synchronisation
-------------------------------------------------------------------

Suppose you are disassembling the boot sector of a 'DOS' floppy (maybe
it has a virus, and you need to understand the virus so that you know
what kinds of damage it might have done you).  Typically, this will
contain a 'JMP' instruction, then some data, then the rest of the code.
So there is a very good chance of NDISASM being _misaligned_ when the
data ends and the code begins.  Hence a sync point is needed.

   On the other hand, why should you have to specify the sync point
manually?  What you'd do in order to find where the sync point would be,
surely, would be to read the 'JMP' instruction, and then to use its
target address as a sync point.  So can NDISASM do that for you?

   The answer, of course, is yes: using either of the synonymous
switches '-a' (for automatic sync) or '-i' (for intelligent sync) will
enable 'auto-sync' mode.  Auto-sync mode automatically generates a sync
point for any forward-referring PC-relative jump or call instruction
that NDISASM encounters.  (Since NDISASM is one-pass, if it encounters a
PC- relative jump whose target has already been processed, there isn't
much it can do about it...)

   Only PC-relative jumps are processed, since an absolute jump is
either through a register (in which case NDISASM doesn't know what the
register contains) or involves a segment address (in which case the
target code isn't in the same segment that NDISASM is working in, and so
the sync point can't be placed anywhere useful).

   For some kinds of file, this mechanism will automatically put sync
points in all the right places, and save you from having to place any
sync points manually.  However, it should be stressed that auto-sync
mode is _not_ guaranteed to catch all the sync points, and you may still
have to place some manually.

   Auto-sync mode doesn't prevent you from declaring manual sync points:
it just adds automatically generated ones to the ones you provide.  It's
perfectly feasible to specify '-i' _and_ some '-s' options.

   Another caveat with auto-sync mode is that if, by some unpleasant
fluke, something in your data section should disassemble to a
PC-relative call or jump instruction, NDISASM may obediently place a
sync point in a totally random place, for example in the middle of one
of the instructions in your code section.  So you may end up with a
wrong disassembly even if you use auto-sync.  Again, there isn't much I
can do about this.  If you have problems, you'll have to use manual sync
points, or use the '-k' option (documented below) to suppress
disassembly of the data area.


File: nasm.info,  Node: Section A.3.4,  Next: Section A.4,  Prev: Section A.3.3,  Up: Section A.3

A.3.4. Other Options
--------------------

The '-e' option skips a header on the file, by ignoring the first N
bytes.  This means that the header is _not_ counted towards the
disassembly offset: if you give '-e10 -o10', disassembly will start at
byte 10 in the file, and this will be given offset 10, not 20.

   The '-k' option is provided with two comma-separated numeric
arguments, the first of which is an assembly offset and the second is a
number of bytes to skip.  This _will_ count the skipped bytes towards
the assembly offset: its use is to suppress disassembly of a data
section which wouldn't contain anything you wanted to see anyway.


File: nasm.info,  Node: Section A.4,  Next: Appendix B,  Prev: Section A.3.4,  Up: Appendix A

A.4. Bugs and Improvements
==========================

There are no known bugs.  However, any you find, with patches if
possible, should be sent to 'nasm-bugs@lists.sourceforge.net', or to the
developer's site at 'http://www.nasm.us/' and we'll try to fix them.
Feel free to send contributions and new features as well.


File: nasm.info,  Node: Appendix B,  Next: Section B.1,  Prev: Section A.4,  Up: Top

Appendix B: Instruction List
****************************

* Menu:

* Section B.1:: Introduction


File: nasm.info,  Node: Section B.1,  Next: Section B.1.1,  Prev: Appendix B,  Up: Appendix B

B.1. Introduction
=================

The following sections show the instructions which NASM currently
supports.  For each instruction, there is a separate entry for each
supported addressing mode.  The third column shows the processor type in
which the instruction was introduced and, when appropriate, one or more
usage flags.

* Menu:

* Section B.1.1:: Special instructions...
* Section B.1.2:: Conventional instructions
* Section B.1.3:: Katmai Streaming SIMD instructions (SSE --- a.k.a. KNI, XMM, MMX2)
* Section B.1.4:: Introduced in Deschutes but necessary for SSE support
* Section B.1.5:: XSAVE group (AVX and extended state)
* Section B.1.6:: Generic memory operations
* Section B.1.7:: New MMX instructions introduced in Katmai
* Section B.1.8:: AMD Enhanced 3DNow! (Athlon) instructions
* Section B.1.9:: Willamette SSE2 Cacheability Instructions
* Section B.1.10:: Willamette MMX instructions (SSE2 SIMD Integer Instructions)
* Section B.1.11:: Willamette Streaming SIMD instructions (SSE2)
* Section B.1.12:: Prescott New Instructions (SSE3)
* Section B.1.13:: VMX/SVM Instructions
* Section B.1.14:: Extended Page Tables VMX instructions
* Section B.1.15:: Tejas New Instructions (SSSE3)
* Section B.1.16:: AMD SSE4A
* Section B.1.17:: New instructions in Barcelona
* Section B.1.18:: Penryn New Instructions (SSE4.1)
* Section B.1.19:: Nehalem New Instructions (SSE4.2)
* Section B.1.20:: Intel SMX
* Section B.1.21:: Geode (Cyrix) 3DNow! additions
* Section B.1.22:: Intel new instructions in ???
* Section B.1.23:: Intel AES instructions
* Section B.1.24:: Intel AVX AES instructions
* Section B.1.25:: Intel AVX instructions
* Section B.1.26:: Intel Carry-Less Multiplication instructions (CLMUL)
* Section B.1.27:: Intel AVX Carry-Less Multiplication instructions (CLMUL)
* Section B.1.28:: Intel Fused Multiply-Add instructions (FMA)
* Section B.1.29:: Intel post-32 nm processor instructions
* Section B.1.30:: VIA (Centaur) security instructions
* Section B.1.31:: AMD Lightweight Profiling (LWP) instructions
* Section B.1.32:: AMD XOP and FMA4 instructions (SSE5)
* Section B.1.33:: Intel AVX2 instructions
* Section B.1.34:: Transactional Synchronization Extensions (TSX)
* Section B.1.35:: Intel BMI1 and BMI2 instructions, AMD TBM instructions
* Section B.1.36:: MJC PUBLIC BEGIN
* Section B.1.37:: MJC PUBLIC END
* Section B.1.38:: Systematic names for the hinting nop instructions


File: nasm.info,  Node: Section B.1.1,  Next: Section B.1.2,  Prev: Section B.1,  Up: Section B.1

B.1.1. Special instructions...
------------------------------

     DB
     DW
     DD
     DQ
     DT
     DO
     DY
     DZ
     RESB             imm                      8086
     RESW
     RESD
     RESQ
     REST
     RESO
     RESY
     RESZ


File: nasm.info,  Node: Section B.1.2,  Next: Section B.1.3,  Prev: Section B.1.1,  Up: Section B.1

B.1.2. Conventional instructions
--------------------------------

     AAA                                       8086,NOLONG
     AAD                                       8086,NOLONG
     AAD              imm                      8086,NOLONG
     AAM                                       8086,NOLONG
     AAM              imm                      8086,NOLONG
     AAS                                       8086,NOLONG
     ADC              mem,reg8                 8086,LOCK
     ADC              reg8,reg8                8086
     ADC              mem,reg16                8086,LOCK
     ADC              reg16,reg16              8086
     ADC              mem,reg32                386,LOCK
     ADC              reg32,reg32              386
     ADC              mem,reg64                X64,LOCK
     ADC              reg64,reg64              X64
     ADC              reg8,mem                 8086
     ADC              reg8,reg8                8086
     ADC              reg16,mem                8086
     ADC              reg16,reg16              8086
     ADC              reg32,mem                386
     ADC              reg32,reg32              386
     ADC              reg64,mem                X64
     ADC              reg64,reg64              X64
     ADC              rm16,imm8                8086,LOCK
     ADC              rm32,imm8                386,LOCK
     ADC              rm64,imm8                X64,LOCK
     ADC              reg_al,imm               8086
     ADC              reg_ax,sbyteword         8086,ND
     ADC              reg_ax,imm               8086
     ADC              reg_eax,sbytedword       386,ND
     ADC              reg_eax,imm              386
     ADC              reg_rax,sbytedword       X64,ND
     ADC              reg_rax,imm              X64
     ADC              rm8,imm                  8086,LOCK
     ADC              rm16,sbyteword           8086,LOCK,ND
     ADC              rm16,imm                 8086,LOCK
     ADC              rm32,sbytedword          386,LOCK,ND
     ADC              rm32,imm                 386,LOCK
     ADC              rm64,sbytedword          X64,LOCK,ND
     ADC              rm64,imm                 X64,LOCK
     ADC              mem,imm8                 8086,LOCK,ND
     ADC              mem,sbyteword16          8086,LOCK,ND
     ADC              mem,imm16                8086,LOCK
     ADC              mem,sbytedword32         386,LOCK,ND
     ADC              mem,imm32                386,LOCK
     ADC              rm8,imm                  8086,LOCK,ND,NOLONG
     ADD              mem,reg8                 8086,LOCK
     ADD              reg8,reg8                8086
     ADD              mem,reg16                8086,LOCK
     ADD              reg16,reg16              8086
     ADD              mem,reg32                386,LOCK
     ADD              reg32,reg32              386
     ADD              mem,reg64                X64,LOCK
     ADD              reg64,reg64              X64
     ADD              reg8,mem                 8086
     ADD              reg8,reg8                8086
     ADD              reg16,mem                8086
     ADD              reg16,reg16              8086
     ADD              reg32,mem                386
     ADD              reg32,reg32              386
     ADD              reg64,mem                X64
     ADD              reg64,reg64              X64
     ADD              rm16,imm8                8086,LOCK
     ADD              rm32,imm8                386,LOCK
     ADD              rm64,imm8                X64,LOCK
     ADD              reg_al,imm               8086
     ADD              reg_ax,sbyteword         8086,ND
     ADD              reg_ax,imm               8086
     ADD              reg_eax,sbytedword       386,ND
     ADD              reg_eax,imm              386
     ADD              reg_rax,sbytedword       X64,ND
     ADD              reg_rax,imm              X64
     ADD              rm8,imm                  8086,LOCK
     ADD              rm16,sbyteword           8086,LOCK,ND
     ADD              rm16,imm                 8086,LOCK
     ADD              rm32,sbytedword          386,LOCK,ND
     ADD              rm32,imm                 386,LOCK
     ADD              rm64,sbytedword          X64,LOCK,ND
     ADD              rm64,imm                 X64,LOCK
     ADD              mem,imm8                 8086,LOCK
     ADD              mem,sbyteword16          8086,LOCK,ND
     ADD              mem,imm16                8086,LOCK
     ADD              mem,sbytedword32         386,LOCK,ND
     ADD              mem,imm32                386,LOCK
     ADD              rm8,imm                  8086,LOCK,ND,NOLONG
     AND              mem,reg8                 8086,LOCK
     AND              reg8,reg8                8086
     AND              mem,reg16                8086,LOCK
     AND              reg16,reg16              8086
     AND              mem,reg32                386,LOCK
     AND              reg32,reg32              386
     AND              mem,reg64                X64,LOCK
     AND              reg64,reg64              X64
     AND              reg8,mem                 8086
     AND              reg8,reg8                8086
     AND              reg16,mem                8086
     AND              reg16,reg16              8086
     AND              reg32,mem                386
     AND              reg32,reg32              386
     AND              reg64,mem                X64
     AND              reg64,reg64              X64
     AND              rm16,imm8                8086,LOCK
     AND              rm32,imm8                386,LOCK
     AND              rm64,imm8                X64,LOCK
     AND              reg_al,imm               8086
     AND              reg_ax,sbyteword         8086,ND
     AND              reg_ax,imm               8086
     AND              reg_eax,sbytedword       386,ND
     AND              reg_eax,imm              386
     AND              reg_rax,sbytedword       X64,ND
     AND              reg_rax,imm              X64
     AND              rm8,imm                  8086,LOCK
     AND              rm16,sbyteword           8086,LOCK,ND
     AND              rm16,imm                 8086,LOCK
     AND              rm32,sbytedword          386,LOCK,ND
     AND              rm32,imm                 386,LOCK
     AND              rm64,sbytedword          X64,LOCK,ND
     AND              rm64,imm                 X64,LOCK
     AND              mem,imm8                 8086,LOCK
     AND              mem,sbyteword16          8086,LOCK,ND
     AND              mem,imm16                8086,LOCK
     AND              mem,sbytedword32         386,LOCK,ND
     AND              mem,imm32                386,LOCK
     AND              rm8,imm                  8086,LOCK,ND,NOLONG
     ARPL             mem,reg16                286,PROT,NOLONG
     ARPL             reg16,reg16              286,PROT,NOLONG
     BB0_RESET                                 PENT,CYRIX,ND
     BB1_RESET                                 PENT,CYRIX,ND
     BOUND            reg16,mem                186,NOLONG
     BOUND            reg32,mem                386,NOLONG
     BSF              reg16,mem                386
     BSF              reg16,reg16              386
     BSF              reg32,mem                386
     BSF              reg32,reg32              386
     BSF              reg64,mem                X64
     BSF              reg64,reg64              X64
     BSR              reg16,mem                386
     BSR              reg16,reg16              386
     BSR              reg32,mem                386
     BSR              reg32,reg32              386
     BSR              reg64,mem                X64
     BSR              reg64,reg64              X64
     BSWAP            reg32                    486
     BSWAP            reg64                    X64
     BT               mem,reg16                386
     BT               reg16,reg16              386
     BT               mem,reg32                386
     BT               reg32,reg32              386
     BT               mem,reg64                X64
     BT               reg64,reg64              X64
     BT               rm16,imm                 386
     BT               rm32,imm                 386
     BT               rm64,imm                 X64
     BTC              mem,reg16                386,LOCK
     BTC              reg16,reg16              386
     BTC              mem,reg32                386,LOCK
     BTC              reg32,reg32              386
     BTC              mem,reg64                X64,LOCK
     BTC              reg64,reg64              X64
     BTC              rm16,imm                 386,LOCK
     BTC              rm32,imm                 386,LOCK
     BTC              rm64,imm                 X64,LOCK
     BTR              mem,reg16                386,LOCK
     BTR              reg16,reg16              386
     BTR              mem,reg32                386,LOCK
     BTR              reg32,reg32              386
     BTR              mem,reg64                X64,LOCK
     BTR              reg64,reg64              X64
     BTR              rm16,imm                 386,LOCK
     BTR              rm32,imm                 386,LOCK
     BTR              rm64,imm                 X64,LOCK
     BTS              mem,reg16                386,LOCK
     BTS              reg16,reg16              386
     BTS              mem,reg32                386,LOCK
     BTS              reg32,reg32              386
     BTS              mem,reg64                X64,LOCK
     BTS              reg64,reg64              X64
     BTS              rm16,imm                 386,LOCK
     BTS              rm32,imm                 386,LOCK
     BTS              rm64,imm                 X64,LOCK
     CALL             imm                      8086,BND
     CALL             imm|near                 8086,ND,BND
     CALL             imm|far                  8086,ND,NOLONG
     CALL             imm16                    8086,NOLONG,BND
     CALL             imm16|near               8086,ND,NOLONG,BND
     CALL             imm16|far                8086,ND,NOLONG
     CALL             imm32                    386,NOLONG,BND
     CALL             imm32|near               386,ND,NOLONG,BND
     CALL             imm32|far                386,ND,NOLONG
     CALL             imm64                    X64,BND
     CALL             imm64|near               X64,ND,BND
     CALL             imm:imm                  8086,NOLONG
     CALL             imm16:imm                8086,NOLONG
     CALL             imm:imm16                8086,NOLONG
     CALL             imm32:imm                386,NOLONG
     CALL             imm:imm32                386,NOLONG
     CALL             mem|far                  8086,NOLONG
     CALL             mem|far                  X64
     CALL             mem16|far                8086
     CALL             mem32|far                386
     CALL             mem64|far                X64
     CALL             mem|near                 8086,ND,BND
     CALL             rm16|near                8086,NOLONG,ND,BND
     CALL             rm32|near                386,NOLONG,ND,BND
     CALL             rm64|near                X64,ND,BND
     CALL             mem                      8086,BND
     CALL             rm16                     8086,NOLONG,BND
     CALL             rm32                     386,NOLONG,BND
     CALL             rm64                     X64,BND
     CBW                                       8086
     CDQ                                       386
     CDQE                                      X64
     CLC                                       8086
     CLD                                       8086
     CLI                                       8086
     CLTS                                      286,PRIV
     CMC                                       8086
     CMP              mem,reg8                 8086
     CMP              reg8,reg8                8086
     CMP              mem,reg16                8086
     CMP              reg16,reg16              8086
     CMP              mem,reg32                386
     CMP              reg32,reg32              386
     CMP              mem,reg64                X64
     CMP              reg64,reg64              X64
     CMP              reg8,mem                 8086
     CMP              reg8,reg8                8086
     CMP              reg16,mem                8086
     CMP              reg16,reg16              8086
     CMP              reg32,mem                386
     CMP              reg32,reg32              386
     CMP              reg64,mem                X64
     CMP              reg64,reg64              X64
     CMP              rm16,imm8                8086
     CMP              rm32,imm8                386
     CMP              rm64,imm8                X64
     CMP              reg_al,imm               8086
     CMP              reg_ax,sbyteword         8086,ND
     CMP              reg_ax,imm               8086
     CMP              reg_eax,sbytedword       386,ND
     CMP              reg_eax,imm              386
     CMP              reg_rax,sbytedword       X64,ND
     CMP              reg_rax,imm              X64
     CMP              rm8,imm                  8086
     CMP              rm16,sbyteword           8086,ND
     CMP              rm16,imm                 8086
     CMP              rm32,sbytedword          386,ND
     CMP              rm32,imm                 386
     CMP              rm64,sbytedword          X64,ND
     CMP              rm64,imm                 X64
     CMP              mem,imm8                 8086
     CMP              mem,sbyteword16          8086,ND
     CMP              mem,imm16                8086
     CMP              mem,sbytedword32         386,ND
     CMP              mem,imm32                386
     CMP              rm8,imm                  8086,ND,NOLONG
     CMPSB                                     8086
     CMPSD                                     386
     CMPSQ                                     X64
     CMPSW                                     8086
     CMPXCHG          mem,reg8                 PENT,LOCK
     CMPXCHG          reg8,reg8                PENT
     CMPXCHG          mem,reg16                PENT,LOCK
     CMPXCHG          reg16,reg16              PENT
     CMPXCHG          mem,reg32                PENT,LOCK
     CMPXCHG          reg32,reg32              PENT
     CMPXCHG          mem,reg64                X64,LOCK
     CMPXCHG          reg64,reg64              X64
     CMPXCHG486       mem,reg8                 486,UNDOC,ND,LOCK
     CMPXCHG486       reg8,reg8                486,UNDOC,ND
     CMPXCHG486       mem,reg16                486,UNDOC,ND,LOCK
     CMPXCHG486       reg16,reg16              486,UNDOC,ND
     CMPXCHG486       mem,reg32                486,UNDOC,ND,LOCK
     CMPXCHG486       reg32,reg32              486,UNDOC,ND
     CMPXCHG8B        mem                      PENT,LOCK
     CMPXCHG16B       mem                      X64,LOCK
     CPUID                                     PENT
     CPU_READ                                  PENT,CYRIX
     CPU_WRITE                                 PENT,CYRIX
     CQO                                       X64
     CWD                                       8086
     CWDE                                      386
     DAA                                       8086,NOLONG
     DAS                                       8086,NOLONG
     DEC              reg16                    8086,NOLONG
     DEC              reg32                    386,NOLONG
     DEC              rm8                      8086,LOCK
     DEC              rm16                     8086,LOCK
     DEC              rm32                     386,LOCK
     DEC              rm64                     X64,LOCK
     DIV              rm8                      8086
     DIV              rm16                     8086
     DIV              rm32                     386
     DIV              rm64                     X64
     DMINT                                     P6,CYRIX
     EMMS                                      PENT,MMX
     ENTER            imm,imm                  186
     EQU              imm                      8086
     EQU              imm:imm                  8086
     F2XM1                                     8086,FPU
     FABS                                      8086,FPU
     FADD             mem32                    8086,FPU
     FADD             mem64                    8086,FPU
     FADD             fpureg|to                8086,FPU
     FADD             fpureg                   8086,FPU
     FADD             fpureg,fpu0              8086,FPU
     FADD             fpu0,fpureg              8086,FPU
     FADD                                      8086,FPU,ND
     FADDP            fpureg                   8086,FPU
     FADDP            fpureg,fpu0              8086,FPU
     FADDP                                     8086,FPU,ND
     FBLD             mem80                    8086,FPU
     FBLD             mem                      8086,FPU
     FBSTP            mem80                    8086,FPU
     FBSTP            mem                      8086,FPU
     FCHS                                      8086,FPU
     FCLEX                                     8086,FPU
     FCMOVB           fpureg                   P6,FPU
     FCMOVB           fpu0,fpureg              P6,FPU
     FCMOVB                                    P6,FPU,ND
     FCMOVBE          fpureg                   P6,FPU
     FCMOVBE          fpu0,fpureg              P6,FPU
     FCMOVBE                                   P6,FPU,ND
     FCMOVE           fpureg                   P6,FPU
     FCMOVE           fpu0,fpureg              P6,FPU
     FCMOVE                                    P6,FPU,ND
     FCMOVNB          fpureg                   P6,FPU
     FCMOVNB          fpu0,fpureg              P6,FPU
     FCMOVNB                                   P6,FPU,ND
     FCMOVNBE         fpureg                   P6,FPU
     FCMOVNBE         fpu0,fpureg              P6,FPU
     FCMOVNBE                                  P6,FPU,ND
     FCMOVNE          fpureg                   P6,FPU
     FCMOVNE          fpu0,fpureg              P6,FPU
     FCMOVNE                                   P6,FPU,ND
     FCMOVNU          fpureg                   P6,FPU
     FCMOVNU          fpu0,fpureg              P6,FPU
     FCMOVNU                                   P6,FPU,ND
     FCMOVU           fpureg                   P6,FPU
     FCMOVU           fpu0,fpureg              P6,FPU
     FCMOVU                                    P6,FPU,ND
     FCOM             mem32                    8086,FPU
     FCOM             mem64                    8086,FPU
     FCOM             fpureg                   8086,FPU
     FCOM             fpu0,fpureg              8086,FPU
     FCOM                                      8086,FPU,ND
     FCOMI            fpureg                   P6,FPU
     FCOMI            fpu0,fpureg              P6,FPU
     FCOMI                                     P6,FPU,ND
     FCOMIP           fpureg                   P6,FPU
     FCOMIP           fpu0,fpureg              P6,FPU
     FCOMIP                                    P6,FPU,ND
     FCOMP            mem32                    8086,FPU
     FCOMP            mem64                    8086,FPU
     FCOMP            fpureg                   8086,FPU
     FCOMP            fpu0,fpureg              8086,FPU
     FCOMP                                     8086,FPU,ND
     FCOMPP                                    8086,FPU
     FCOS                                      386,FPU
     FDECSTP                                   8086,FPU
     FDISI                                     8086,FPU
     FDIV             mem32                    8086,FPU
     FDIV             mem64                    8086,FPU
     FDIV             fpureg|to                8086,FPU
     FDIV             fpureg                   8086,FPU
     FDIV             fpureg,fpu0              8086,FPU
     FDIV             fpu0,fpureg              8086,FPU
     FDIV                                      8086,FPU,ND
     FDIVP            fpureg                   8086,FPU
     FDIVP            fpureg,fpu0              8086,FPU
     FDIVP                                     8086,FPU,ND
     FDIVR            mem32                    8086,FPU
     FDIVR            mem64                    8086,FPU
     FDIVR            fpureg|to                8086,FPU
     FDIVR            fpureg,fpu0              8086,FPU
     FDIVR            fpureg                   8086,FPU
     FDIVR            fpu0,fpureg              8086,FPU
     FDIVR                                     8086,FPU,ND
     FDIVRP           fpureg                   8086,FPU
     FDIVRP           fpureg,fpu0              8086,FPU
     FDIVRP                                    8086,FPU,ND
     FEMMS                                     PENT,3DNOW
     FENI                                      8086,FPU
     FFREE            fpureg                   8086,FPU
     FFREE                                     8086,FPU
     FFREEP           fpureg                   286,FPU,UNDOC
     FFREEP                                    286,FPU,UNDOC
     FIADD            mem32                    8086,FPU
     FIADD            mem16                    8086,FPU
     FICOM            mem32                    8086,FPU
     FICOM            mem16                    8086,FPU
     FICOMP           mem32                    8086,FPU
     FICOMP           mem16                    8086,FPU
     FIDIV            mem32                    8086,FPU
     FIDIV            mem16                    8086,FPU
     FIDIVR           mem32                    8086,FPU
     FIDIVR           mem16                    8086,FPU
     FILD             mem32                    8086,FPU
     FILD             mem16                    8086,FPU
     FILD             mem64                    8086,FPU
     FIMUL            mem32                    8086,FPU
     FIMUL            mem16                    8086,FPU
     FINCSTP                                   8086,FPU
     FINIT                                     8086,FPU
     FIST             mem32                    8086,FPU
     FIST             mem16                    8086,FPU
     FISTP            mem32                    8086,FPU
     FISTP            mem16                    8086,FPU
     FISTP            mem64                    8086,FPU
     FISTTP           mem16                    PRESCOTT,FPU
     FISTTP           mem32                    PRESCOTT,FPU
     FISTTP           mem64                    PRESCOTT,FPU
     FISUB            mem32                    8086,FPU
     FISUB            mem16                    8086,FPU
     FISUBR           mem32                    8086,FPU
     FISUBR           mem16                    8086,FPU
     FLD              mem32                    8086,FPU
     FLD              mem64                    8086,FPU
     FLD              mem80                    8086,FPU
     FLD              fpureg                   8086,FPU
     FLD                                       8086,FPU,ND
     FLD1                                      8086,FPU
     FLDCW            mem                      8086,FPU,SW
     FLDENV           mem                      8086,FPU
     FLDL2E                                    8086,FPU
     FLDL2T                                    8086,FPU
     FLDLG2                                    8086,FPU
     FLDLN2                                    8086,FPU
     FLDPI                                     8086,FPU
     FLDZ                                      8086,FPU
     FMUL             mem32                    8086,FPU
     FMUL             mem64                    8086,FPU
     FMUL             fpureg|to                8086,FPU
     FMUL             fpureg,fpu0              8086,FPU
     FMUL             fpureg                   8086,FPU
     FMUL             fpu0,fpureg              8086,FPU
     FMUL                                      8086,FPU,ND
     FMULP            fpureg                   8086,FPU
     FMULP            fpureg,fpu0              8086,FPU
     FMULP                                     8086,FPU,ND
     FNCLEX                                    8086,FPU
     FNDISI                                    8086,FPU
     FNENI                                     8086,FPU
     FNINIT                                    8086,FPU
     FNOP                                      8086,FPU
     FNSAVE           mem                      8086,FPU
     FNSTCW           mem                      8086,FPU,SW
     FNSTENV          mem                      8086,FPU
     FNSTSW           mem                      8086,FPU,SW
     FNSTSW           reg_ax                   286,FPU
     FPATAN                                    8086,FPU
     FPREM                                     8086,FPU
     FPREM1                                    386,FPU
     FPTAN                                     8086,FPU
     FRNDINT                                   8086,FPU
     FRSTOR           mem                      8086,FPU
     FSAVE            mem                      8086,FPU
     FSCALE                                    8086,FPU
     FSETPM                                    286,FPU
     FSIN                                      386,FPU
     FSINCOS                                   386,FPU
     FSQRT                                     8086,FPU
     FST              mem32                    8086,FPU
     FST              mem64                    8086,FPU
     FST              fpureg                   8086,FPU
     FST                                       8086,FPU,ND
     FSTCW            mem                      8086,FPU,SW
     FSTENV           mem                      8086,FPU
     FSTP             mem32                    8086,FPU
     FSTP             mem64                    8086,FPU
     FSTP             mem80                    8086,FPU
     FSTP             fpureg                   8086,FPU
     FSTP                                      8086,FPU,ND
     FSTSW            mem                      8086,FPU,SW
     FSTSW            reg_ax                   286,FPU
     FSUB             mem32                    8086,FPU
     FSUB             mem64                    8086,FPU
     FSUB             fpureg|to                8086,FPU
     FSUB             fpureg,fpu0              8086,FPU
     FSUB             fpureg                   8086,FPU
     FSUB             fpu0,fpureg              8086,FPU
     FSUB                                      8086,FPU,ND
     FSUBP            fpureg                   8086,FPU
     FSUBP            fpureg,fpu0              8086,FPU
     FSUBP                                     8086,FPU,ND
     FSUBR            mem32                    8086,FPU
     FSUBR            mem64                    8086,FPU
     FSUBR            fpureg|to                8086,FPU
     FSUBR            fpureg,fpu0              8086,FPU
     FSUBR            fpureg                   8086,FPU
     FSUBR            fpu0,fpureg              8086,FPU
     FSUBR                                     8086,FPU,ND
     FSUBRP           fpureg                   8086,FPU
     FSUBRP           fpureg,fpu0              8086,FPU
     FSUBRP                                    8086,FPU,ND
     FTST                                      8086,FPU
     FUCOM            fpureg                   386,FPU
     FUCOM            fpu0,fpureg              386,FPU
     FUCOM                                     386,FPU,ND
     FUCOMI           fpureg                   P6,FPU
     FUCOMI           fpu0,fpureg              P6,FPU
     FUCOMI                                    P6,FPU,ND
     FUCOMIP          fpureg                   P6,FPU
     FUCOMIP          fpu0,fpureg              P6,FPU
     FUCOMIP                                   P6,FPU,ND
     FUCOMP           fpureg                   386,FPU
     FUCOMP           fpu0,fpureg              386,FPU
     FUCOMP                                    386,FPU,ND
     FUCOMPP                                   386,FPU
     FXAM                                      8086,FPU
     FXCH             fpureg                   8086,FPU
     FXCH             fpureg,fpu0              8086,FPU
     FXCH             fpu0,fpureg              8086,FPU
     FXCH                                      8086,FPU,ND
     FXTRACT                                   8086,FPU
     FYL2X                                     8086,FPU
     FYL2XP1                                   8086,FPU
     HLT                                       8086,PRIV
     IBTS             mem,reg16                386,SW,UNDOC,ND
     IBTS             reg16,reg16              386,UNDOC,ND
     IBTS             mem,reg32                386,SD,UNDOC,ND
     IBTS             reg32,reg32              386,UNDOC,ND
     ICEBP                                     386,ND
     IDIV             rm8                      8086
     IDIV             rm16                     8086
     IDIV             rm32                     386
     IDIV             rm64                     X64
     IMUL             rm8                      8086
     IMUL             rm16                     8086
     IMUL             rm32                     386
     IMUL             rm64                     X64
     IMUL             reg16,mem                386
     IMUL             reg16,reg16              386
     IMUL             reg32,mem                386
     IMUL             reg32,reg32              386
     IMUL             reg64,mem                X64
     IMUL             reg64,reg64              X64
     IMUL             reg16,mem,imm8           186
     IMUL             reg16,mem,sbyteword      186,ND
     IMUL             reg16,mem,imm16          186
     IMUL             reg16,mem,imm            186,ND
     IMUL             reg16,reg16,imm8         186
     IMUL             reg16,reg16,sbyteword    186,ND
     IMUL             reg16,reg16,imm16        186
     IMUL             reg16,reg16,imm          186,ND
     IMUL             reg32,mem,imm8           386
     IMUL             reg32,mem,sbytedword     386,ND
     IMUL             reg32,mem,imm32          386
     IMUL             reg32,mem,imm            386,ND
     IMUL             reg32,reg32,imm8         386
     IMUL             reg32,reg32,sbytedword   386,ND
     IMUL             reg32,reg32,imm32        386
     IMUL             reg32,reg32,imm          386,ND
     IMUL             reg64,mem,imm8           X64
     IMUL             reg64,mem,sbytedword     X64,ND
     IMUL             reg64,mem,imm32          X64
     IMUL             reg64,mem,imm            X64,ND
     IMUL             reg64,reg64,imm8         X64
     IMUL             reg64,reg64,sbytedword   X64,ND
     IMUL             reg64,reg64,imm32        X64
     IMUL             reg64,reg64,imm          X64,ND
     IMUL             reg16,imm8               186
     IMUL             reg16,sbyteword          186,ND
     IMUL             reg16,imm16              186
     IMUL             reg16,imm                186,ND
     IMUL             reg32,imm8               386
     IMUL             reg32,sbytedword         386,ND
     IMUL             reg32,imm32              386
     IMUL             reg32,imm                386,ND
     IMUL             reg64,imm8               X64
     IMUL             reg64,sbytedword         X64,ND
     IMUL             reg64,imm32              X64
     IMUL             reg64,imm                X64,ND
     IN               reg_al,imm               8086
     IN               reg_ax,imm               8086
     IN               reg_eax,imm              386
     IN               reg_al,reg_dx            8086
     IN               reg_ax,reg_dx            8086
     IN               reg_eax,reg_dx           386
     INC              reg16                    8086,NOLONG
     INC              reg32                    386,NOLONG
     INC              rm8                      8086,LOCK
     INC              rm16                     8086,LOCK
     INC              rm32                     386,LOCK
     INC              rm64                     X64,LOCK
     INCBIN
     INSB                                      186
     INSD                                      386
     INSW                                      186
     INT              imm                      8086
     INT01                                     386,ND
     INT1                                      386
     INT03                                     8086,ND
     INT3                                      8086
     INTO                                      8086,NOLONG
     INVD                                      486,PRIV
     INVPCID          reg32,mem128             FUTURE,INVPCID,PRIV,NOLONG
     INVPCID          reg64,mem128             FUTURE,INVPCID,PRIV,LONG
     INVLPG           mem                      486,PRIV
     INVLPGA          reg_ax,reg_ecx           X86_64,AMD,NOLONG
     INVLPGA          reg_eax,reg_ecx          X86_64,AMD
     INVLPGA          reg_rax,reg_ecx          X64,AMD
     INVLPGA                                   X86_64,AMD
     IRET                                      8086
     IRETD                                     386
     IRETQ                                     X64
     IRETW                                     8086
     JCXZ             imm                      8086,NOLONG
     JECXZ            imm                      386
     JRCXZ            imm                      X64
     JMP              imm|short                8086
     JMP              imm                      8086,ND
     JMP              imm                      8086,BND
     JMP              imm|near                 8086,ND,BND
     JMP              imm|far                  8086,ND,NOLONG
     JMP              imm16                    8086,NOLONG,BND
     JMP              imm16|near               8086,ND,NOLONG,BND
     JMP              imm16|far                8086,ND,NOLONG
     JMP              imm32                    386,NOLONG,BND
     JMP              imm32|near               386,ND,NOLONG,BND
     JMP              imm32|far                386,ND,NOLONG
     JMP              imm64                    X64,BND
     JMP              imm64|near               X64,ND,BND
     JMP              imm:imm                  8086,NOLONG
     JMP              imm16:imm                8086,NOLONG
     JMP              imm:imm16                8086,NOLONG
     JMP              imm32:imm                386,NOLONG
     JMP              imm:imm32                386,NOLONG
     JMP              mem|far                  8086,NOLONG
     JMP              mem|far                  X64
     JMP              mem16|far                8086
     JMP              mem32|far                386
     JMP              mem64|far                X64
     JMP              mem|near                 8086,ND,BND
     JMP              rm16|near                8086,NOLONG,ND,BND
     JMP              rm32|near                386,NOLONG,ND,BND
     JMP              rm64|near                X64,ND,BND
     JMP              mem                      8086,BND
     JMP              rm16                     8086,NOLONG,BND
     JMP              rm32                     386,NOLONG,BND
     JMP              rm64                     X64,BND
     JMPE             imm                      IA64
     JMPE             imm16                    IA64
     JMPE             imm32                    IA64
     JMPE             rm16                     IA64
     JMPE             rm32                     IA64
     LAHF                                      8086
     LAR              reg16,mem                286,PROT,SW
     LAR              reg16,reg16              286,PROT
     LAR              reg16,reg32              386,PROT
     LAR              reg16,reg64              X64,PROT,ND
     LAR              reg32,mem                386,PROT,SW
     LAR              reg32,reg16              386,PROT
     LAR              reg32,reg32              386,PROT
     LAR              reg32,reg64              X64,PROT,ND
     LAR              reg64,mem                X64,PROT,SW
     LAR              reg64,reg16              X64,PROT
     LAR              reg64,reg32              X64,PROT
     LAR              reg64,reg64              X64,PROT
     LDS              reg16,mem                8086,NOLONG
     LDS              reg32,mem                386,NOLONG
     LEA              reg16,mem                8086
     LEA              reg32,mem                386
     LEA              reg64,mem                X64
     LEAVE                                     186
     LES              reg16,mem                8086,NOLONG
     LES              reg32,mem                386,NOLONG
     LFENCE                                    X64,AMD
     LFS              reg16,mem                386
     LFS              reg32,mem                386
     LFS              reg64,mem                X64
     LGDT             mem                      286,PRIV
     LGS              reg16,mem                386
     LGS              reg32,mem                386
     LGS              reg64,mem                X64
     LIDT             mem                      286,PRIV
     LLDT             mem                      286,PROT,PRIV
     LLDT             mem16                    286,PROT,PRIV
     LLDT             reg16                    286,PROT,PRIV
     LMSW             mem                      286,PRIV
     LMSW             mem16                    286,PRIV
     LMSW             reg16                    286,PRIV
     LOADALL                                   386,UNDOC,ND
     LOADALL286                                286,UNDOC,ND
     LODSB                                     8086
     LODSD                                     386
     LODSQ                                     X64
     LODSW                                     8086
     LOOP             imm                      8086
     LOOP             imm,reg_cx               8086,NOLONG
     LOOP             imm,reg_ecx              386
     LOOP             imm,reg_rcx              X64
     LOOPE            imm                      8086
     LOOPE            imm,reg_cx               8086,NOLONG
     LOOPE            imm,reg_ecx              386
     LOOPE            imm,reg_rcx              X64
     LOOPNE           imm                      8086
     LOOPNE           imm,reg_cx               8086,NOLONG
     LOOPNE           imm,reg_ecx              386
     LOOPNE           imm,reg_rcx              X64
     LOOPNZ           imm                      8086
     LOOPNZ           imm,reg_cx               8086,NOLONG
     LOOPNZ           imm,reg_ecx              386
     LOOPNZ           imm,reg_rcx              X64
     LOOPZ            imm                      8086
     LOOPZ            imm,reg_cx               8086,NOLONG
     LOOPZ            imm,reg_ecx              386
     LOOPZ            imm,reg_rcx              X64
     LSL              reg16,mem                286,PROT,SW
     LSL              reg16,reg16              286,PROT
     LSL              reg16,reg32              386,PROT
     LSL              reg16,reg64              X64,PROT,ND
     LSL              reg32,mem                386,PROT,SW
     LSL              reg32,reg16              386,PROT
     LSL              reg32,reg32              386,PROT
     LSL              reg32,reg64              X64,PROT,ND
     LSL              reg64,mem                X64,PROT,SW
     LSL              reg64,reg16              X64,PROT
     LSL              reg64,reg32              X64,PROT
     LSL              reg64,reg64              X64,PROT
     LSS              reg16,mem                386
     LSS              reg32,mem                386
     LSS              reg64,mem                X64
     LTR              mem                      286,PROT,PRIV
     LTR              mem16                    286,PROT,PRIV
     LTR              reg16                    286,PROT,PRIV
     MFENCE                                    X64,AMD
     MONITOR                                   PRESCOTT
     MONITOR          reg_eax,reg_ecx,reg_edx  PRESCOTT,NOLONG,ND
     MONITOR          reg_rax,reg_ecx,reg_edx  X64,ND
     MONITORX                                  AMD
     MONITORX         reg_rax,reg_ecx,reg_edx  X64,AMD,ND
     MONITORX         reg_eax,reg_ecx,reg_edx  AMD,ND
     MONITORX         reg_ax,reg_ecx,reg_edx   AMD,ND
     MOV              mem,reg_sreg             8086,SW
     MOV              reg16,reg_sreg           8086
     MOV              reg32,reg_sreg           386
     MOV              reg64,reg_sreg           X64,OPT,ND
     MOV              rm64,reg_sreg            X64
     MOV              reg_sreg,mem             8086,SW
     MOV              reg_sreg,reg16           8086,OPT,ND
     MOV              reg_sreg,reg32           386,OPT,ND
     MOV              reg_sreg,reg64           X64,OPT,ND
     MOV              reg_sreg,reg16           8086
     MOV              reg_sreg,reg32           386
     MOV              reg_sreg,rm64            X64
     MOV              reg_al,mem_offs          8086
     MOV              reg_ax,mem_offs          8086
     MOV              reg_eax,mem_offs         386
     MOV              reg_rax,mem_offs         X64
     MOV              mem_offs,reg_al          8086,NOHLE
     MOV              mem_offs,reg_ax          8086,NOHLE
     MOV              mem_offs,reg_eax         386,NOHLE
     MOV              mem_offs,reg_rax         X64,NOHLE
     MOV              reg32,reg_creg           386,PRIV,NOLONG
     MOV              reg64,reg_creg           X64,PRIV
     MOV              reg_creg,reg32           386,PRIV,NOLONG
     MOV              reg_creg,reg64           X64,PRIV
     MOV              reg32,reg_dreg           386,PRIV,NOLONG
     MOV              reg64,reg_dreg           X64,PRIV
     MOV              reg_dreg,reg32           386,PRIV,NOLONG
     MOV              reg_dreg,reg64           X64,PRIV
     MOV              reg32,reg_treg           386,NOLONG,ND
     MOV              reg_treg,reg32           386,NOLONG,ND
     MOV              mem,reg8                 8086
     MOV              reg8,reg8                8086
     MOV              mem,reg16                8086
     MOV              reg16,reg16              8086
     MOV              mem,reg32                386
     MOV              reg32,reg32              386
     MOV              mem,reg64                X64
     MOV              reg64,reg64              X64
     MOV              reg8,mem                 8086
     MOV              reg8,reg8                8086
     MOV              reg16,mem                8086
     MOV              reg16,reg16              8086
     MOV              reg32,mem                386
     MOV              reg32,reg32              386
     MOV              reg64,mem                X64
     MOV              reg64,reg64              X64
     MOV              reg8,imm                 8086
     MOV              reg16,imm                8086
     MOV              reg32,imm                386
     MOV              reg64,udword             X64,OPT,ND
     MOV              reg64,sdword             X64,OPT,ND
     MOV              reg64,imm                X64
     MOV              rm8,imm                  8086
     MOV              rm16,imm                 8086
     MOV              rm32,imm                 386
     MOV              rm64,imm                 X64
     MOV              rm64,imm32               X64
     MOV              mem,imm8                 8086
     MOV              mem,imm16                8086
     MOV              mem,imm32                386
     MOVD             mmxreg,rm32              PENT,MMX,SD
     MOVD             rm32,mmxreg              PENT,MMX,SD
     MOVD             mmxreg,rm64              X64,MMX,SX,ND
     MOVD             rm64,mmxreg              X64,MMX,SX,ND
     MOVQ             mmxreg,mmxrm             PENT,MMX
     MOVQ             mmxrm,mmxreg             PENT,MMX
     MOVQ             mmxreg,rm64              X64,MMX
     MOVQ             rm64,mmxreg              X64,MMX
     MOVSB                                     8086
     MOVSD                                     386
     MOVSQ                                     X64
     MOVSW                                     8086
     MOVSX            reg16,mem                386
     MOVSX            reg16,reg8               386
     MOVSX            reg32,rm8                386
     MOVSX            reg32,rm16               386
     MOVSX            reg64,rm8                X64
     MOVSX            reg64,rm16               X64
     MOVSXD           reg64,rm32               X64
     MOVSX            reg64,rm32               X64,ND
     MOVZX            reg16,mem                386
     MOVZX            reg16,reg8               386
     MOVZX            reg32,rm8                386
     MOVZX            reg32,rm16               386
     MOVZX            reg64,rm8                X64
     MOVZX            reg64,rm16               X64
     MUL              rm8                      8086
     MUL              rm16                     8086
     MUL              rm32                     386
     MUL              rm64                     X64
     MWAIT                                     PRESCOTT
     MWAIT            reg_eax,reg_ecx          PRESCOTT,ND
     MWAITX                                    AMD
     MWAITX           reg_eax,reg_ecx          AMD,ND
     NEG              rm8                      8086,LOCK
     NEG              rm16                     8086,LOCK
     NEG              rm32                     386,LOCK
     NEG              rm64                     X64,LOCK
     NOP                                       8086
     NOP              rm16                     P6
     NOP              rm32                     P6
     NOP              rm64                     X64
     NOT              rm8                      8086,LOCK
     NOT              rm16                     8086,LOCK
     NOT              rm32                     386,LOCK
     NOT              rm64                     X64,LOCK
     OR               mem,reg8                 8086,LOCK
     OR               reg8,reg8                8086
     OR               mem,reg16                8086,LOCK
     OR               reg16,reg16              8086
     OR               mem,reg32                386,LOCK
     OR               reg32,reg32              386
     OR               mem,reg64                X64,LOCK
     OR               reg64,reg64              X64
     OR               reg8,mem                 8086
     OR               reg8,reg8                8086
     OR               reg16,mem                8086
     OR               reg16,reg16              8086
     OR               reg32,mem                386
     OR               reg32,reg32              386
     OR               reg64,mem                X64
     OR               reg64,reg64              X64
     OR               rm16,imm8                8086,LOCK
     OR               rm32,imm8                386,LOCK
     OR               rm64,imm8                X64,LOCK
     OR               reg_al,imm               8086
     OR               reg_ax,sbyteword         8086,ND
     OR               reg_ax,imm               8086
     OR               reg_eax,sbytedword       386,ND
     OR               reg_eax,imm              386
     OR               reg_rax,sbytedword       X64,ND
     OR               reg_rax,imm              X64
     OR               rm8,imm                  8086,LOCK
     OR               rm16,sbyteword           8086,LOCK,ND
     OR               rm16,imm                 8086,LOCK
     OR               rm32,sbytedword          386,LOCK,ND
     OR               rm32,imm                 386,LOCK
     OR               rm64,sbytedword          X64,LOCK,ND
     OR               rm64,imm                 X64,LOCK
     OR               mem,imm8                 8086,LOCK
     OR               mem,sbyteword16          8086,LOCK,ND
     OR               mem,imm16                8086,LOCK
     OR               mem,sbytedword32         386,LOCK,ND
     OR               mem,imm32                386,LOCK
     OR               rm8,imm                  8086,LOCK,ND,NOLONG
     OUT              imm,reg_al               8086
     OUT              imm,reg_ax               8086
     OUT              imm,reg_eax              386
     OUT              reg_dx,reg_al            8086
     OUT              reg_dx,reg_ax            8086
     OUT              reg_dx,reg_eax           386
     OUTSB                                     186
     OUTSD                                     386
     OUTSW                                     186
     PACKSSDW         mmxreg,mmxrm             PENT,MMX
     PACKSSWB         mmxreg,mmxrm             PENT,MMX
     PACKUSWB         mmxreg,mmxrm             PENT,MMX
     PADDB            mmxreg,mmxrm             PENT,MMX
     PADDD            mmxreg,mmxrm             PENT,MMX
     PADDSB           mmxreg,mmxrm             PENT,MMX
     PADDSIW          mmxreg,mmxrm             PENT,MMX,CYRIX
     PADDSW           mmxreg,mmxrm             PENT,MMX
     PADDUSB          mmxreg,mmxrm             PENT,MMX
     PADDUSW          mmxreg,mmxrm             PENT,MMX
     PADDW            mmxreg,mmxrm             PENT,MMX
     PAND             mmxreg,mmxrm             PENT,MMX
     PANDN            mmxreg,mmxrm             PENT,MMX
     PAUSE                                     8086
     PAVEB            mmxreg,mmxrm             PENT,MMX,CYRIX
     PAVGUSB          mmxreg,mmxrm             PENT,3DNOW
     PCMPEQB          mmxreg,mmxrm             PENT,MMX
     PCMPEQD          mmxreg,mmxrm             PENT,MMX
     PCMPEQW          mmxreg,mmxrm             PENT,MMX
     PCMPGTB          mmxreg,mmxrm             PENT,MMX
     PCMPGTD          mmxreg,mmxrm             PENT,MMX
     PCMPGTW          mmxreg,mmxrm             PENT,MMX
     PDISTIB          mmxreg,mem               PENT,MMX,CYRIX
     PF2ID            mmxreg,mmxrm             PENT,3DNOW
     PFACC            mmxreg,mmxrm             PENT,3DNOW
     PFADD            mmxreg,mmxrm             PENT,3DNOW
     PFCMPEQ          mmxreg,mmxrm             PENT,3DNOW
     PFCMPGE          mmxreg,mmxrm             PENT,3DNOW
     PFCMPGT          mmxreg,mmxrm             PENT,3DNOW
     PFMAX            mmxreg,mmxrm             PENT,3DNOW
     PFMIN            mmxreg,mmxrm             PENT,3DNOW
     PFMUL            mmxreg,mmxrm             PENT,3DNOW
     PFRCP            mmxreg,mmxrm             PENT,3DNOW
     PFRCPIT1         mmxreg,mmxrm             PENT,3DNOW
     PFRCPIT2         mmxreg,mmxrm             PENT,3DNOW
     PFRSQIT1         mmxreg,mmxrm             PENT,3DNOW
     PFRSQRT          mmxreg,mmxrm             PENT,3DNOW
     PFSUB            mmxreg,mmxrm             PENT,3DNOW
     PFSUBR           mmxreg,mmxrm             PENT,3DNOW
     PI2FD            mmxreg,mmxrm             PENT,3DNOW
     PMACHRIW         mmxreg,mem               PENT,MMX,CYRIX
     PMADDWD          mmxreg,mmxrm             PENT,MMX
     PMAGW            mmxreg,mmxrm             PENT,MMX,CYRIX
     PMULHRIW         mmxreg,mmxrm             PENT,MMX,CYRIX
     PMULHRWA         mmxreg,mmxrm             PENT,3DNOW
     PMULHRWC         mmxreg,mmxrm             PENT,MMX,CYRIX
     PMULHW           mmxreg,mmxrm             PENT,MMX
     PMULLW           mmxreg,mmxrm             PENT,MMX
     PMVGEZB          mmxreg,mem               PENT,MMX,CYRIX
     PMVLZB           mmxreg,mem               PENT,MMX,CYRIX
     PMVNZB           mmxreg,mem               PENT,MMX,CYRIX
     PMVZB            mmxreg,mem               PENT,MMX,CYRIX
     POP              reg16                    8086
     POP              reg32                    386,NOLONG
     POP              reg64                    X64
     POP              rm16                     8086
     POP              rm32                     386,NOLONG
     POP              rm64                     X64
     POP              reg_es                   8086,NOLONG
     POP              reg_cs                   8086,UNDOC,ND
     POP              reg_ss                   8086,NOLONG
     POP              reg_ds                   8086,NOLONG
     POP              reg_fs                   386
     POP              reg_gs                   386
     POPA                                      186,NOLONG
     POPAD                                     386,NOLONG
     POPAW                                     186,NOLONG
     POPF                                      8086
     POPFD                                     386,NOLONG
     POPFQ                                     X64
     POPFW                                     8086
     POR              mmxreg,mmxrm             PENT,MMX
     PREFETCH         mem                      PENT,3DNOW
     PREFETCHW        mem                      PENT,3DNOW
     PSLLD            mmxreg,mmxrm             PENT,MMX
     PSLLD            mmxreg,imm               PENT,MMX
     PSLLQ            mmxreg,mmxrm             PENT,MMX
     PSLLQ            mmxreg,imm               PENT,MMX
     PSLLW            mmxreg,mmxrm             PENT,MMX
     PSLLW            mmxreg,imm               PENT,MMX
     PSRAD            mmxreg,mmxrm             PENT,MMX
     PSRAD            mmxreg,imm               PENT,MMX
     PSRAW            mmxreg,mmxrm             PENT,MMX
     PSRAW            mmxreg,imm               PENT,MMX
     PSRLD            mmxreg,mmxrm             PENT,MMX
     PSRLD            mmxreg,imm               PENT,MMX
     PSRLQ            mmxreg,mmxrm             PENT,MMX
     PSRLQ            mmxreg,imm               PENT,MMX
     PSRLW            mmxreg,mmxrm             PENT,MMX
     PSRLW            mmxreg,imm               PENT,MMX
     PSUBB            mmxreg,mmxrm             PENT,MMX
     PSUBD            mmxreg,mmxrm             PENT,MMX
     PSUBSB           mmxreg,mmxrm             PENT,MMX
     PSUBSIW          mmxreg,mmxrm             PENT,MMX,CYRIX
     PSUBSW           mmxreg,mmxrm             PENT,MMX
     PSUBUSB          mmxreg,mmxrm             PENT,MMX
     PSUBUSW          mmxreg,mmxrm             PENT,MMX
     PSUBW            mmxreg,mmxrm             PENT,MMX
     PUNPCKHBW        mmxreg,mmxrm             PENT,MMX
     PUNPCKHDQ        mmxreg,mmxrm             PENT,MMX
     PUNPCKHWD        mmxreg,mmxrm             PENT,MMX
     PUNPCKLBW        mmxreg,mmxrm             PENT,MMX
     PUNPCKLDQ        mmxreg,mmxrm             PENT,MMX
     PUNPCKLWD        mmxreg,mmxrm             PENT,MMX
     PUSH             reg16                    8086
     PUSH             reg32                    386,NOLONG
     PUSH             reg64                    X64
     PUSH             rm16                     8086
     PUSH             rm32                     386,NOLONG
     PUSH             rm64                     X64
     PUSH             reg_es                   8086,NOLONG
     PUSH             reg_cs                   8086,NOLONG
     PUSH             reg_ss                   8086,NOLONG
     PUSH             reg_ds                   8086,NOLONG
     PUSH             reg_fs                   386
     PUSH             reg_gs                   386
     PUSH             imm8                     186
     PUSH             sbyteword16              186,AR0,SIZE,ND
     PUSH             imm16                    186,AR0,SIZE
     PUSH             sbytedword32             386,NOLONG,AR0,SIZE,ND
     PUSH             imm32                    386,NOLONG,AR0,SIZE
     PUSH             sbytedword32             386,NOLONG,SD,ND
     PUSH             imm32                    386,NOLONG,SD
     PUSH             sbytedword64             X64,AR0,SIZE,ND
     PUSH             imm64                    X64,AR0,SIZE
     PUSH             sbytedword32             X64,AR0,SIZE,ND
     PUSH             imm32                    X64,AR0,SIZE
     PUSHA                                     186,NOLONG
     PUSHAD                                    386,NOLONG
     PUSHAW                                    186,NOLONG
     PUSHF                                     8086
     PUSHFD                                    386,NOLONG
     PUSHFQ                                    X64
     PUSHFW                                    8086
     PXOR             mmxreg,mmxrm             PENT,MMX
     RCL              rm8,unity                8086
     RCL              rm8,reg_cl               8086
     RCL              rm8,imm8                 186
     RCL              rm16,unity               8086
     RCL              rm16,reg_cl              8086
     RCL              rm16,imm8                186
     RCL              rm32,unity               386
     RCL              rm32,reg_cl              386
     RCL              rm32,imm8                386
     RCL              rm64,unity               X64
     RCL              rm64,reg_cl              X64
     RCL              rm64,imm8                X64
     RCR              rm8,unity                8086
     RCR              rm8,reg_cl               8086
     RCR              rm8,imm8                 186
     RCR              rm16,unity               8086
     RCR              rm16,reg_cl              8086
     RCR              rm16,imm8                186
     RCR              rm32,unity               386
     RCR              rm32,reg_cl              386
     RCR              rm32,imm8                386
     RCR              rm64,unity               X64
     RCR              rm64,reg_cl              X64
     RCR              rm64,imm8                X64
     RDSHR            rm32                     P6,CYRIXM
     RDMSR                                     PENT,PRIV
     RDPMC                                     P6
     RDTSC                                     PENT
     RDTSCP                                    X86_64
     RET                                       8086,BND
     RET              imm                      8086,SW,BND
     RETF                                      8086
     RETF             imm                      8086,SW
     RETN                                      8086,BND
     RETN             imm                      8086,SW,BND
     ROL              rm8,unity                8086
     ROL              rm8,reg_cl               8086
     ROL              rm8,imm8                 186
     ROL              rm16,unity               8086
     ROL              rm16,reg_cl              8086
     ROL              rm16,imm8                186
     ROL              rm32,unity               386
     ROL              rm32,reg_cl              386
     ROL              rm32,imm8                386
     ROL              rm64,unity               X64
     ROL              rm64,reg_cl              X64
     ROL              rm64,imm8                X64
     ROR              rm8,unity                8086
     ROR              rm8,reg_cl               8086
     ROR              rm8,imm8                 186
     ROR              rm16,unity               8086
     ROR              rm16,reg_cl              8086
     ROR              rm16,imm8                186
     ROR              rm32,unity               386
     ROR              rm32,reg_cl              386
     ROR              rm32,imm8                386
     ROR              rm64,unity               X64
     ROR              rm64,reg_cl              X64
     ROR              rm64,imm8                X64
     RDM                                       P6,CYRIX,ND
     RSDC             reg_sreg,mem80           486,CYRIXM
     RSLDT            mem80                    486,CYRIXM
     RSM                                       PENTM
     RSTS             mem80                    486,CYRIXM
     SAHF                                      8086
     SAL              rm8,unity                8086,ND
     SAL              rm8,reg_cl               8086,ND
     SAL              rm8,imm8                 186,ND
     SAL              rm16,unity               8086,ND
     SAL              rm16,reg_cl              8086,ND
     SAL              rm16,imm8                186,ND
     SAL              rm32,unity               386,ND
     SAL              rm32,reg_cl              386,ND
     SAL              rm32,imm8                386,ND
     SAL              rm64,unity               X64,ND
     SAL              rm64,reg_cl              X64,ND
     SAL              rm64,imm8                X64,ND
     SALC                                      8086,UNDOC
     SAR              rm8,unity                8086
     SAR              rm8,reg_cl               8086
     SAR              rm8,imm8                 186
     SAR              rm16,unity               8086
     SAR              rm16,reg_cl              8086
     SAR              rm16,imm8                186
     SAR              rm32,unity               386
     SAR              rm32,reg_cl              386
     SAR              rm32,imm8                386
     SAR              rm64,unity               X64
     SAR              rm64,reg_cl              X64
     SAR              rm64,imm8                X64
     SBB              mem,reg8                 8086,LOCK
     SBB              reg8,reg8                8086
     SBB              mem,reg16                8086,LOCK
     SBB              reg16,reg16              8086
     SBB              mem,reg32                386,LOCK
     SBB              reg32,reg32              386
     SBB              mem,reg64                X64,LOCK
     SBB              reg64,reg64              X64
     SBB              reg8,mem                 8086
     SBB              reg8,reg8                8086
     SBB              reg16,mem                8086
     SBB              reg16,reg16              8086
     SBB              reg32,mem                386
     SBB              reg32,reg32              386
     SBB              reg64,mem                X64
     SBB              reg64,reg64              X64
     SBB              rm16,imm8                8086,LOCK
     SBB              rm32,imm8                386,LOCK
     SBB              rm64,imm8                X64,LOCK
     SBB              reg_al,imm               8086
     SBB              reg_ax,sbyteword         8086,ND
     SBB              reg_ax,imm               8086
     SBB              reg_eax,sbytedword       386,ND
     SBB              reg_eax,imm              386
     SBB              reg_rax,sbytedword       X64,ND
     SBB              reg_rax,imm              X64
     SBB              rm8,imm                  8086,LOCK
     SBB              rm16,sbyteword           8086,LOCK,ND
     SBB              rm16,imm                 8086,LOCK
     SBB              rm32,sbytedword          386,LOCK,ND
     SBB              rm32,imm                 386,LOCK
     SBB              rm64,sbytedword          X64,LOCK,ND
     SBB              rm64,imm                 X64,LOCK
     SBB              mem,imm8                 8086,LOCK
     SBB              mem,sbyteword16          8086,LOCK,ND
     SBB              mem,imm16                8086,LOCK
     SBB              mem,sbytedword32         386,LOCK,ND
     SBB              mem,imm32                386,LOCK
     SBB              rm8,imm                  8086,LOCK,ND,NOLONG
     SCASB                                     8086
     SCASD                                     386
     SCASQ                                     X64
     SCASW                                     8086
     SFENCE                                    X64,AMD
     SGDT             mem                      286
     SHL              rm8,unity                8086
     SHL              rm8,reg_cl               8086
     SHL              rm8,imm8                 186
     SHL              rm16,unity               8086
     SHL              rm16,reg_cl              8086
     SHL              rm16,imm8                186
     SHL              rm32,unity               386
     SHL              rm32,reg_cl              386
     SHL              rm32,imm8                386
     SHL              rm64,unity               X64
     SHL              rm64,reg_cl              X64
     SHL              rm64,imm8                X64
     SHLD             mem,reg16,imm            3862
     SHLD             reg16,reg16,imm          3862
     SHLD             mem,reg32,imm            3862
     SHLD             reg32,reg32,imm          3862
     SHLD             mem,reg64,imm            X642
     SHLD             reg64,reg64,imm          X642
     SHLD             mem,reg16,reg_cl         386
     SHLD             reg16,reg16,reg_cl       386
     SHLD             mem,reg32,reg_cl         386
     SHLD             reg32,reg32,reg_cl       386
     SHLD             mem,reg64,reg_cl         X64
     SHLD             reg64,reg64,reg_cl       X64
     SHR              rm8,unity                8086
     SHR              rm8,reg_cl               8086
     SHR              rm8,imm8                 186
     SHR              rm16,unity               8086
     SHR              rm16,reg_cl              8086
     SHR              rm16,imm8                186
     SHR              rm32,unity               386
     SHR              rm32,reg_cl              386
     SHR              rm32,imm8                386
     SHR              rm64,unity               X64
     SHR              rm64,reg_cl              X64
     SHR              rm64,imm8                X64
     SHRD             mem,reg16,imm            3862
     SHRD             reg16,reg16,imm          3862
     SHRD             mem,reg32,imm            3862
     SHRD             reg32,reg32,imm          3862
     SHRD             mem,reg64,imm            X642
     SHRD             reg64,reg64,imm          X642
     SHRD             mem,reg16,reg_cl         386
     SHRD             reg16,reg16,reg_cl       386
     SHRD             mem,reg32,reg_cl         386
     SHRD             reg32,reg32,reg_cl       386
     SHRD             mem,reg64,reg_cl         X64
     SHRD             reg64,reg64,reg_cl       X64
     SIDT             mem                      286
     SLDT             mem                      286
     SLDT             mem16                    286
     SLDT             reg16                    286
     SLDT             reg32                    386
     SLDT             reg64                    X64,ND
     SLDT             reg64                    X64
     SKINIT                                    X64
     SMI                                       386,UNDOC
     SMINT                                     P6,CYRIX,ND
     SMINTOLD                                  486,CYRIX,ND
     SMSW             mem                      286
     SMSW             mem16                    286
     SMSW             reg16                    286
     SMSW             reg32                    386
     SMSW             reg64                    X64
     STC                                       8086
     STD                                       8086
     STI                                       8086
     STOSB                                     8086
     STOSD                                     386
     STOSQ                                     X64
     STOSW                                     8086
     STR              mem                      286,PROT
     STR              mem16                    286,PROT
     STR              reg16                    286,PROT
     STR              reg32                    386,PROT
     STR              reg64                    X64
     SUB              mem,reg8                 8086,LOCK
     SUB              reg8,reg8                8086
     SUB              mem,reg16                8086,LOCK
     SUB              reg16,reg16              8086
     SUB              mem,reg32                386,LOCK
     SUB              reg32,reg32              386
     SUB              mem,reg64                X64,LOCK
     SUB              reg64,reg64              X64
     SUB              reg8,mem                 8086
     SUB              reg8,reg8                8086
     SUB              reg16,mem                8086
     SUB              reg16,reg16              8086
     SUB              reg32,mem                386
     SUB              reg32,reg32              386
     SUB              reg64,mem                X64
     SUB              reg64,reg64              X64
     SUB              rm16,imm8                8086,LOCK
     SUB              rm32,imm8                386,LOCK
     SUB              rm64,imm8                X64,LOCK
     SUB              reg_al,imm               8086
     SUB              reg_ax,sbyteword         8086,ND
     SUB              reg_ax,imm               8086
     SUB              reg_eax,sbytedword       386,ND
     SUB              reg_eax,imm              386
     SUB              reg_rax,sbytedword       X64,ND
     SUB              reg_rax,imm              X64
     SUB              rm8,imm                  8086,LOCK
     SUB              rm16,sbyteword           8086,LOCK,ND
     SUB              rm16,imm                 8086,LOCK
     SUB              rm32,sbytedword          386,LOCK,ND
     SUB              rm32,imm                 386,LOCK
     SUB              rm64,sbytedword          X64,LOCK,ND
     SUB              rm64,imm                 X64,LOCK
     SUB              mem,imm8                 8086,LOCK
     SUB              mem,sbyteword16          8086,LOCK,ND
     SUB              mem,imm16                8086,LOCK
     SUB              mem,sbytedword32         386,LOCK,ND
     SUB              mem,imm32                386,LOCK
     SUB              rm8,imm                  8086,LOCK,ND,NOLONG
     SVDC             mem80,reg_sreg           486,CYRIXM
     SVLDT            mem80                    486,CYRIXM,ND
     SVTS             mem80                    486,CYRIXM
     SWAPGS                                    X64
     SYSCALL                                   P6,AMD
     SYSENTER                                  P6
     SYSEXIT                                   P6,PRIV
     SYSRET                                    P6,PRIV,AMD
     TEST             mem,reg8                 8086
     TEST             reg8,reg8                8086
     TEST             mem,reg16                8086
     TEST             reg16,reg16              8086
     TEST             mem,reg32                386
     TEST             reg32,reg32              386
     TEST             mem,reg64                X64
     TEST             reg64,reg64              X64
     TEST             reg8,mem                 8086
     TEST             reg16,mem                8086
     TEST             reg32,mem                386
     TEST             reg64,mem                X64
     TEST             reg_al,imm               8086
     TEST             reg_ax,imm               8086
     TEST             reg_eax,imm              386
     TEST             reg_rax,imm              X64
     TEST             rm8,imm                  8086
     TEST             rm16,imm                 8086
     TEST             rm32,imm                 386
     TEST             rm64,imm                 X64
     TEST             mem,imm8                 8086
     TEST             mem,imm16                8086
     TEST             mem,imm32                386
     UD0                                       186,UNDOC
     UD1                                       186,UNDOC
     UD2B                                      186,UNDOC,ND
     UD2                                       186
     UD2A                                      186,ND
     UMOV             mem,reg8                 386,UNDOC,ND
     UMOV             reg8,reg8                386,UNDOC,ND
     UMOV             mem,reg16                386,UNDOC,ND
     UMOV             reg16,reg16              386,UNDOC,ND
     UMOV             mem,reg32                386,UNDOC,ND
     UMOV             reg32,reg32              386,UNDOC,ND
     UMOV             reg8,mem                 386,UNDOC,ND
     UMOV             reg8,reg8                386,UNDOC,ND
     UMOV             reg16,mem                386,UNDOC,ND
     UMOV             reg16,reg16              386,UNDOC,ND
     UMOV             reg32,mem                386,UNDOC,ND
     UMOV             reg32,reg32              386,UNDOC,ND
     VERR             mem                      286,PROT
     VERR             mem16                    286,PROT
     VERR             reg16                    286,PROT
     VERW             mem                      286,PROT
     VERW             mem16                    286,PROT
     VERW             reg16                    286,PROT
     FWAIT                                     8086
     WBINVD                                    486,PRIV
     WRSHR            rm32                     P6,CYRIXM
     WRMSR                                     PENT,PRIV
     XADD             mem,reg8                 486,LOCK
     XADD             reg8,reg8                486
     XADD             mem,reg16                486,LOCK
     XADD             reg16,reg16              486
     XADD             mem,reg32                486,LOCK
     XADD             reg32,reg32              486
     XADD             mem,reg64                X64,LOCK
     XADD             reg64,reg64              X64
     XBTS             reg16,mem                386,SW,UNDOC,ND
     XBTS             reg16,reg16              386,UNDOC,ND
     XBTS             reg32,mem                386,SD,UNDOC,ND
     XBTS             reg32,reg32              386,UNDOC,ND
     XCHG             reg_ax,reg16             8086
     XCHG             reg_eax,reg32na          386
     XCHG             reg_rax,reg64            X64
     XCHG             reg16,reg_ax             8086
     XCHG             reg32na,reg_eax          386
     XCHG             reg64,reg_rax            X64
     XCHG             reg_eax,reg_eax          386,NOLONG
     XCHG             reg8,mem                 8086,LOCK
     XCHG             reg8,reg8                8086
     XCHG             reg16,mem                8086,LOCK
     XCHG             reg16,reg16              8086
     XCHG             reg32,mem                386,LOCK
     XCHG             reg32,reg32              386
     XCHG             reg64,mem                X64,LOCK
     XCHG             reg64,reg64              X64
     XCHG             mem,reg8                 8086,LOCK
     XCHG             reg8,reg8                8086
     XCHG             mem,reg16                8086,LOCK
     XCHG             reg16,reg16              8086
     XCHG             mem,reg32                386,LOCK
     XCHG             reg32,reg32              386
     XCHG             mem,reg64                X64,LOCK
     XCHG             reg64,reg64              X64
     XLATB                                     8086
     XLAT                                      8086
     XOR              mem,reg8                 8086,LOCK
     XOR              reg8,reg8                8086
     XOR              mem,reg16                8086,LOCK
     XOR              reg16,reg16              8086
     XOR              mem,reg32                386,LOCK
     XOR              reg32,reg32              386
     XOR              mem,reg64                X64,LOCK
     XOR              reg64,reg64              X64
     XOR              reg8,mem                 8086
     XOR              reg8,reg8                8086
     XOR              reg16,mem                8086
     XOR              reg16,reg16              8086
     XOR              reg32,mem                386
     XOR              reg32,reg32              386
     XOR              reg64,mem                X64
     XOR              reg64,reg64              X64
     XOR              rm16,imm8                8086,LOCK
     XOR              rm32,imm8                386,LOCK
     XOR              rm64,imm8                X64,LOCK
     XOR              reg_al,imm               8086
     XOR              reg_ax,sbyteword         8086,ND
     XOR              reg_ax,imm               8086
     XOR              reg_eax,sbytedword       386,ND
     XOR              reg_eax,imm              386
     XOR              reg_rax,sbytedword       X64,ND
     XOR              reg_rax,imm              X64
     XOR              rm8,imm                  8086,LOCK
     XOR              rm16,sbyteword           8086,LOCK,ND
     XOR              rm16,imm                 8086,LOCK
     XOR              rm32,sbytedword          386,LOCK,ND
     XOR              rm32,imm                 386,LOCK
     XOR              rm64,sbytedword          X64,LOCK,ND
     XOR              rm64,imm                 X64,LOCK
     XOR              mem,imm8                 8086,LOCK
     XOR              mem,sbyteword16          8086,LOCK,ND
     XOR              mem,imm16                8086,LOCK
     XOR              mem,sbytedword32         386,LOCK,ND
     XOR              mem,imm32                386,LOCK
     XOR              rm8,imm                  8086,LOCK,ND,NOLONG
     CMOVcc           reg16,mem                P6
     CMOVcc           reg16,reg16              P6
     CMOVcc           reg32,mem                P6
     CMOVcc           reg32,reg32              P6
     CMOVcc           reg64,mem                X64
     CMOVcc           reg64,reg64              X64
     Jcc              imm|near                 386,BND
     Jcc              imm16|near               386,NOLONG,BND
     Jcc              imm32|near               386,NOLONG,BND
     Jcc              imm64|near               X64,BND
     Jcc              imm|short                8086,ND,BND
     Jcc              imm                      8086,ND,BND
     Jcc              imm                      386,ND,BND
     Jcc              imm                      8086,ND,BND
     Jcc              imm                      8086,BND
     SETcc            mem                      386
     SETcc            reg8                     386


File: nasm.info,  Node: Section B.1.3,  Next: Section B.1.4,  Prev: Section B.1.2,  Up: Section B.1

B.1.3. Katmai Streaming SIMD instructions (SSE --- a.k.a. KNI, XMM, MMX2)
-------------------------------------------------------------------------

     ADDPS            xmmreg,xmmrm128          KATMAI,SSE
     ADDSS            xmmreg,xmmrm32           KATMAI,SSE
     ANDNPS           xmmreg,xmmrm128          KATMAI,SSE
     ANDPS            xmmreg,xmmrm128          KATMAI,SSE
     CMPEQPS          xmmreg,xmmrm128          KATMAI,SSE
     CMPEQSS          xmmreg,xmmrm32           KATMAI,SSE
     CMPLEPS          xmmreg,xmmrm128          KATMAI,SSE
     CMPLESS          xmmreg,xmmrm32           KATMAI,SSE
     CMPLTPS          xmmreg,xmmrm128          KATMAI,SSE
     CMPLTSS          xmmreg,xmmrm32           KATMAI,SSE
     CMPNEQPS         xmmreg,xmmrm128          KATMAI,SSE
     CMPNEQSS         xmmreg,xmmrm32           KATMAI,SSE
     CMPNLEPS         xmmreg,xmmrm128          KATMAI,SSE
     CMPNLESS         xmmreg,xmmrm32           KATMAI,SSE
     CMPNLTPS         xmmreg,xmmrm128          KATMAI,SSE
     CMPNLTSS         xmmreg,xmmrm32           KATMAI,SSE
     CMPORDPS         xmmreg,xmmrm128          KATMAI,SSE
     CMPORDSS         xmmreg,xmmrm32           KATMAI,SSE
     CMPUNORDPS       xmmreg,xmmrm128          KATMAI,SSE
     CMPUNORDSS       xmmreg,xmmrm32           KATMAI,SSE
     CMPPS            xmmreg,mem,imm           KATMAI,SSE
     CMPPS            xmmreg,xmmreg,imm        KATMAI,SSE
     CMPSS            xmmreg,mem,imm           KATMAI,SSE
     CMPSS            xmmreg,xmmreg,imm        KATMAI,SSE
     COMISS           xmmreg,xmmrm32           KATMAI,SSE
     CVTPI2PS         xmmreg,mmxrm64           KATMAI,SSE,MMX
     CVTPS2PI         mmxreg,xmmrm64           KATMAI,SSE,MMX
     CVTSI2SS         xmmreg,mem               KATMAI,SSE,SD,AR1,ND
     CVTSI2SS         xmmreg,rm32              KATMAI,SSE,SD,AR1
     CVTSI2SS         xmmreg,rm64              X64,SSE,AR1
     CVTSS2SI         reg32,xmmreg             KATMAI,SSE,SD,AR1
     CVTSS2SI         reg32,mem                KATMAI,SSE,SD,AR1
     CVTSS2SI         reg64,xmmreg             X64,SSE,SD,AR1
     CVTSS2SI         reg64,mem                X64,SSE,SD,AR1
     CVTTPS2PI        mmxreg,xmmrm             KATMAI,SSE,MMX
     CVTTSS2SI        reg32,xmmrm              KATMAI,SSE,SD,AR1
     CVTTSS2SI        reg64,xmmrm              X64,SSE,SD,AR1
     DIVPS            xmmreg,xmmrm128          KATMAI,SSE
     DIVSS            xmmreg,xmmrm32           KATMAI,SSE
     LDMXCSR          mem32                    KATMAI,SSE
     MAXPS            xmmreg,xmmrm128          KATMAI,SSE
     MAXSS            xmmreg,xmmrm32           KATMAI,SSE
     MINPS            xmmreg,xmmrm128          KATMAI,SSE
     MINSS            xmmreg,xmmrm32           KATMAI,SSE
     MOVAPS           xmmreg,xmmrm128          KATMAI,SSE
     MOVAPS           xmmrm128,xmmreg          KATMAI,SSE
     MOVHPS           xmmreg,mem64             KATMAI,SSE
     MOVHPS           mem64,xmmreg             KATMAI,SSE
     MOVLHPS          xmmreg,xmmreg            KATMAI,SSE
     MOVLPS           xmmreg,mem64             KATMAI,SSE
     MOVLPS           mem64,xmmreg             KATMAI,SSE
     MOVHLPS          xmmreg,xmmreg            KATMAI,SSE
     MOVMSKPS         reg32,xmmreg             KATMAI,SSE
     MOVMSKPS         reg64,xmmreg             X64,SSE
     MOVNTPS          mem128,xmmreg            KATMAI,SSE
     MOVSS            xmmreg,xmmrm32           KATMAI,SSE
     MOVSS            mem32,xmmreg             KATMAI,SSE
     MOVSS            xmmreg,xmmreg            KATMAI,SSE
     MOVUPS           xmmreg,xmmrm128          KATMAI,SSE
     MOVUPS           xmmrm128,xmmreg          KATMAI,SSE
     MULPS            xmmreg,xmmrm128          KATMAI,SSE
     MULSS            xmmreg,xmmrm32           KATMAI,SSE
     ORPS             xmmreg,xmmrm128          KATMAI,SSE
     RCPPS            xmmreg,xmmrm128          KATMAI,SSE
     RCPSS            xmmreg,xmmrm32           KATMAI,SSE
     RSQRTPS          xmmreg,xmmrm128          KATMAI,SSE
     RSQRTSS          xmmreg,xmmrm32           KATMAI,SSE
     SHUFPS           xmmreg,xmmrm128,imm8     KATMAI,SSE
     SQRTPS           xmmreg,xmmrm128          KATMAI,SSE
     SQRTSS           xmmreg,xmmrm32           KATMAI,SSE
     STMXCSR          mem32                    KATMAI,SSE
     SUBPS            xmmreg,xmmrm128          KATMAI,SSE
     SUBSS            xmmreg,xmmrm32           KATMAI,SSE
     UCOMISS          xmmreg,xmmrm32           KATMAI,SSE
     UNPCKHPS         xmmreg,xmmrm128          KATMAI,SSE
     UNPCKLPS         xmmreg,xmmrm128          KATMAI,SSE
     XORPS            xmmreg,xmmrm128          KATMAI,SSE


File: nasm.info,  Node: Section B.1.4,  Next: Section B.1.5,  Prev: Section B.1.3,  Up: Section B.1

B.1.4. Introduced in Deschutes but necessary for SSE support
------------------------------------------------------------

     FXRSTOR          mem                      P6,SSE,FPU
     FXRSTOR64        mem                      X64,SSE,FPU
     FXSAVE           mem                      P6,SSE,FPU
     FXSAVE64         mem                      X64,SSE,FPU


File: nasm.info,  Node: Section B.1.5,  Next: Section B.1.6,  Prev: Section B.1.4,  Up: Section B.1

B.1.5. XSAVE group (AVX and extended state)
-------------------------------------------

     XGETBV                                    NEHALEM
     XSETBV                                    NEHALEM,PRIV
     XSAVE            mem                      NEHALEM
     XSAVE64          mem                      LONG,NEHALEM
     XSAVEC           mem                      FUTURE
     XSAVEC64         mem                      LONG,FUTURE
     XSAVEOPT         mem                      FUTURE
     XSAVEOPT64       mem                      LONG,FUTURE
     XSAVES           mem                      FUTURE
     XSAVES64         mem                      LONG,FUTURE
     XRSTOR           mem                      NEHALEM
     XRSTOR64         mem                      LONG,NEHALEM
     XRSTORS          mem                      FUTURE
     XRSTORS64        mem                      LONG,FUTURE


File: nasm.info,  Node: Section B.1.6,  Next: Section B.1.7,  Prev: Section B.1.5,  Up: Section B.1

B.1.6. Generic memory operations
--------------------------------

     PREFETCHNTA      mem8                     KATMAI
     PREFETCHT0       mem8                     KATMAI
     PREFETCHT1       mem8                     KATMAI
     PREFETCHT2       mem8                     KATMAI
     SFENCE                                    KATMAI


File: nasm.info,  Node: Section B.1.7,  Next: Section B.1.8,  Prev: Section B.1.6,  Up: Section B.1

B.1.7. New MMX instructions introduced in Katmai
------------------------------------------------

     MASKMOVQ         mmxreg,mmxreg            KATMAI,MMX
     MOVNTQ           mem,mmxreg               KATMAI,MMX
     PAVGB            mmxreg,mmxrm             KATMAI,MMX
     PAVGW            mmxreg,mmxrm             KATMAI,MMX
     PEXTRW           reg32,mmxreg,imm         KATMAI,MMX
     PINSRW           mmxreg,mem,imm           KATMAI,MMX
     PINSRW           mmxreg,rm16,imm          KATMAI,MMX
     PINSRW           mmxreg,reg32,imm         KATMAI,MMX
     PMAXSW           mmxreg,mmxrm             KATMAI,MMX
     PMAXUB           mmxreg,mmxrm             KATMAI,MMX
     PMINSW           mmxreg,mmxrm             KATMAI,MMX
     PMINUB           mmxreg,mmxrm             KATMAI,MMX
     PMOVMSKB         reg32,mmxreg             KATMAI,MMX
     PMULHUW          mmxreg,mmxrm             KATMAI,MMX
     PSADBW           mmxreg,mmxrm             KATMAI,MMX
     PSHUFW           mmxreg,mmxrm,imm         KATMAI,MMX2


File: nasm.info,  Node: Section B.1.8,  Next: Section B.1.9,  Prev: Section B.1.7,  Up: Section B.1

B.1.8. AMD Enhanced 3DNow! (Athlon) instructions
------------------------------------------------

     PF2IW            mmxreg,mmxrm             PENT,3DNOW
     PFNACC           mmxreg,mmxrm             PENT,3DNOW
     PFPNACC          mmxreg,mmxrm             PENT,3DNOW
     PI2FW            mmxreg,mmxrm             PENT,3DNOW
     PSWAPD           mmxreg,mmxrm             PENT,3DNOW


File: nasm.info,  Node: Section B.1.9,  Next: Section B.1.10,  Prev: Section B.1.8,  Up: Section B.1

B.1.9. Willamette SSE2 Cacheability Instructions
------------------------------------------------

     MASKMOVDQU       xmmreg,xmmreg            WILLAMETTE,SSE2
     CLFLUSH          mem                      WILLAMETTE,SSE2
     MOVNTDQ          mem,xmmreg               WILLAMETTE,SSE2,SO
     MOVNTI           mem,reg32                WILLAMETTE,SD
     MOVNTI           mem,reg64                X64
     MOVNTPD          mem,xmmreg               WILLAMETTE,SSE2,SO
     LFENCE                                    WILLAMETTE,SSE2
     MFENCE                                    WILLAMETTE,SSE2


File: nasm.info,  Node: Section B.1.10,  Next: Section B.1.11,  Prev: Section B.1.9,  Up: Section B.1

B.1.10. Willamette MMX instructions (SSE2 SIMD Integer Instructions)
--------------------------------------------------------------------

     MOVD             mem,xmmreg               WILLAMETTE,SSE2,SD
     MOVD             xmmreg,mem               WILLAMETTE,SSE2,SD
     MOVD             xmmreg,rm32              WILLAMETTE,SSE2
     MOVD             rm32,xmmreg              WILLAMETTE,SSE2
     MOVDQA           xmmreg,xmmreg            WILLAMETTE,SSE2
     MOVDQA           mem,xmmreg               WILLAMETTE,SSE2,SO
     MOVDQA           xmmreg,mem               WILLAMETTE,SSE2,SO
     MOVDQA           xmmreg,xmmreg            WILLAMETTE,SSE2
     MOVDQU           xmmreg,xmmreg            WILLAMETTE,SSE2
     MOVDQU           mem,xmmreg               WILLAMETTE,SSE2,SO
     MOVDQU           xmmreg,mem               WILLAMETTE,SSE2,SO
     MOVDQU           xmmreg,xmmreg            WILLAMETTE,SSE2
     MOVDQ2Q          mmxreg,xmmreg            WILLAMETTE,SSE2
     MOVQ             xmmreg,xmmreg            WILLAMETTE,SSE2
     MOVQ             xmmreg,xmmreg            WILLAMETTE,SSE2
     MOVQ             mem,xmmreg               WILLAMETTE,SSE2
     MOVQ             xmmreg,mem               WILLAMETTE,SSE2
     MOVQ             xmmreg,rm64              X64,SSE2
     MOVQ             rm64,xmmreg              X64,SSE2
     MOVQ2DQ          xmmreg,mmxreg            WILLAMETTE,SSE2
     PACKSSWB         xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PACKSSDW         xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PACKUSWB         xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PADDB            xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PADDW            xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PADDD            xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PADDQ            mmxreg,mmxrm             WILLAMETTE,MMX
     PADDQ            xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PADDSB           xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PADDSW           xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PADDUSB          xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PADDUSW          xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PAND             xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PANDN            xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PAVGB            xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PAVGW            xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PCMPEQB          xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PCMPEQW          xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PCMPEQD          xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PCMPGTB          xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PCMPGTW          xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PCMPGTD          xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PEXTRW           reg32,xmmreg,imm         WILLAMETTE,SSE2
     PINSRW           xmmreg,reg16,imm         WILLAMETTE,SSE2
     PINSRW           xmmreg,reg32,imm         WILLAMETTE,SSE2,ND
     PINSRW           xmmreg,mem,imm           WILLAMETTE,SSE2
     PINSRW           xmmreg,mem16,imm         WILLAMETTE,SSE2
     PMADDWD          xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PMAXSW           xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PMAXUB           xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PMINSW           xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PMINUB           xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PMOVMSKB         reg32,xmmreg             WILLAMETTE,SSE2
     PMULHUW          xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PMULHW           xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PMULLW           xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PMULUDQ          mmxreg,mmxrm             WILLAMETTE,SSE2,SO
     PMULUDQ          xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     POR              xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PSADBW           xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PSHUFD           xmmreg,xmmreg,imm        WILLAMETTE,SSE2
     PSHUFD           xmmreg,mem,imm           WILLAMETTE,SSE22
     PSHUFHW          xmmreg,xmmreg,imm        WILLAMETTE,SSE2
     PSHUFHW          xmmreg,mem,imm           WILLAMETTE,SSE22
     PSHUFLW          xmmreg,xmmreg,imm        WILLAMETTE,SSE2
     PSHUFLW          xmmreg,mem,imm           WILLAMETTE,SSE22
     PSLLDQ           xmmreg,imm               WILLAMETTE,SSE2,AR1
     PSLLW            xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PSLLW            xmmreg,imm               WILLAMETTE,SSE2,AR1
     PSLLD            xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PSLLD            xmmreg,imm               WILLAMETTE,SSE2,AR1
     PSLLQ            xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PSLLQ            xmmreg,imm               WILLAMETTE,SSE2,AR1
     PSRAW            xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PSRAW            xmmreg,imm               WILLAMETTE,SSE2,AR1
     PSRAD            xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PSRAD            xmmreg,imm               WILLAMETTE,SSE2,AR1
     PSRLDQ           xmmreg,imm               WILLAMETTE,SSE2,AR1
     PSRLW            xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PSRLW            xmmreg,imm               WILLAMETTE,SSE2,AR1
     PSRLD            xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PSRLD            xmmreg,imm               WILLAMETTE,SSE2,AR1
     PSRLQ            xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PSRLQ            xmmreg,imm               WILLAMETTE,SSE2,AR1
     PSUBB            xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PSUBW            xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PSUBD            xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PSUBQ            mmxreg,mmxrm             WILLAMETTE,SSE2,SO
     PSUBQ            xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PSUBSB           xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PSUBSW           xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PSUBUSB          xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PSUBUSW          xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PUNPCKHBW        xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PUNPCKHWD        xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PUNPCKHDQ        xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PUNPCKHQDQ       xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PUNPCKLBW        xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PUNPCKLWD        xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PUNPCKLDQ        xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PUNPCKLQDQ       xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     PXOR             xmmreg,xmmrm             WILLAMETTE,SSE2,SO


File: nasm.info,  Node: Section B.1.11,  Next: Section B.1.12,  Prev: Section B.1.10,  Up: Section B.1

B.1.11. Willamette Streaming SIMD instructions (SSE2)
-----------------------------------------------------

     ADDPD            xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     ADDSD            xmmreg,xmmrm             WILLAMETTE,SSE2
     ANDNPD           xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     ANDPD            xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     CMPEQPD          xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     CMPEQSD          xmmreg,xmmrm             WILLAMETTE,SSE2
     CMPLEPD          xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     CMPLESD          xmmreg,xmmrm             WILLAMETTE,SSE2
     CMPLTPD          xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     CMPLTSD          xmmreg,xmmrm             WILLAMETTE,SSE2
     CMPNEQPD         xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     CMPNEQSD         xmmreg,xmmrm             WILLAMETTE,SSE2
     CMPNLEPD         xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     CMPNLESD         xmmreg,xmmrm             WILLAMETTE,SSE2
     CMPNLTPD         xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     CMPNLTSD         xmmreg,xmmrm             WILLAMETTE,SSE2
     CMPORDPD         xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     CMPORDSD         xmmreg,xmmrm             WILLAMETTE,SSE2
     CMPUNORDPD       xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     CMPUNORDSD       xmmreg,xmmrm             WILLAMETTE,SSE2
     CMPPD            xmmreg,xmmrm128,imm8     WILLAMETTE,SSE2
     CMPSD            xmmreg,xmmrm128,imm8     WILLAMETTE,SSE2
     COMISD           xmmreg,xmmrm             WILLAMETTE,SSE2
     CVTDQ2PD         xmmreg,xmmrm             WILLAMETTE,SSE2
     CVTDQ2PS         xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     CVTPD2DQ         xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     CVTPD2PI         mmxreg,xmmrm             WILLAMETTE,SSE2,SO
     CVTPD2PS         xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     CVTPI2PD         xmmreg,mmxrm             WILLAMETTE,SSE2
     CVTPS2DQ         xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     CVTPS2PD         xmmreg,xmmrm             WILLAMETTE,SSE2
     CVTSD2SI         reg32,xmmreg             WILLAMETTE,SSE2,AR1
     CVTSD2SI         reg32,mem                WILLAMETTE,SSE2,AR1
     CVTSD2SI         reg64,xmmreg             X64,SSE2,AR1
     CVTSD2SI         reg64,mem                X64,SSE2,AR1
     CVTSD2SS         xmmreg,xmmrm             WILLAMETTE,SSE2
     CVTSI2SD         xmmreg,mem               WILLAMETTE,SSE2,SD,AR1,ND
     CVTSI2SD         xmmreg,rm32              WILLAMETTE,SSE2,SD,AR1
     CVTSI2SD         xmmreg,rm64              X64,SSE2,AR1
     CVTSS2SD         xmmreg,xmmrm             WILLAMETTE,SSE2,SD
     CVTTPD2PI        mmxreg,xmmrm             WILLAMETTE,SSE2,SO
     CVTTPD2DQ        xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     CVTTPS2DQ        xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     CVTTSD2SI        reg32,xmmreg             WILLAMETTE,SSE2,AR1
     CVTTSD2SI        reg32,mem                WILLAMETTE,SSE2,AR1
     CVTTSD2SI        reg64,xmmreg             X64,SSE2,AR1
     CVTTSD2SI        reg64,mem                X64,SSE2,AR1
     DIVPD            xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     DIVSD            xmmreg,xmmrm             WILLAMETTE,SSE2
     MAXPD            xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     MAXSD            xmmreg,xmmrm             WILLAMETTE,SSE2
     MINPD            xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     MINSD            xmmreg,xmmrm             WILLAMETTE,SSE2
     MOVAPD           xmmreg,xmmreg            WILLAMETTE,SSE2
     MOVAPD           xmmreg,xmmreg            WILLAMETTE,SSE2
     MOVAPD           mem,xmmreg               WILLAMETTE,SSE2,SO
     MOVAPD           xmmreg,mem               WILLAMETTE,SSE2,SO
     MOVHPD           mem,xmmreg               WILLAMETTE,SSE2
     MOVHPD           xmmreg,mem               WILLAMETTE,SSE2
     MOVLPD           mem64,xmmreg             WILLAMETTE,SSE2
     MOVLPD           xmmreg,mem64             WILLAMETTE,SSE2
     MOVMSKPD         reg32,xmmreg             WILLAMETTE,SSE2
     MOVMSKPD         reg64,xmmreg             X64,SSE2
     MOVSD            xmmreg,xmmreg            WILLAMETTE,SSE2
     MOVSD            xmmreg,xmmreg            WILLAMETTE,SSE2
     MOVSD            mem64,xmmreg             WILLAMETTE,SSE2
     MOVSD            xmmreg,mem64             WILLAMETTE,SSE2
     MOVUPD           xmmreg,xmmreg            WILLAMETTE,SSE2
     MOVUPD           xmmreg,xmmreg            WILLAMETTE,SSE2
     MOVUPD           mem,xmmreg               WILLAMETTE,SSE2,SO
     MOVUPD           xmmreg,mem               WILLAMETTE,SSE2,SO
     MULPD            xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     MULSD            xmmreg,xmmrm             WILLAMETTE,SSE2
     ORPD             xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     SHUFPD           xmmreg,xmmreg,imm        WILLAMETTE,SSE2
     SHUFPD           xmmreg,mem,imm           WILLAMETTE,SSE2
     SQRTPD           xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     SQRTSD           xmmreg,xmmrm             WILLAMETTE,SSE2
     SUBPD            xmmreg,xmmrm             WILLAMETTE,SSE2,SO
     SUBSD            xmmreg,xmmrm             WILLAMETTE,SSE2
     UCOMISD          xmmreg,xmmrm             WILLAMETTE,SSE2
     UNPCKHPD         xmmreg,xmmrm128          WILLAMETTE,SSE2
     UNPCKLPD         xmmreg,xmmrm128          WILLAMETTE,SSE2
     XORPD            xmmreg,xmmrm128          WILLAMETTE,SSE2


File: nasm.info,  Node: Section B.1.12,  Next: Section B.1.13,  Prev: Section B.1.11,  Up: Section B.1

B.1.12. Prescott New Instructions (SSE3)
----------------------------------------

     ADDSUBPD         xmmreg,xmmrm             PRESCOTT,SSE3,SO
     ADDSUBPS         xmmreg,xmmrm             PRESCOTT,SSE3,SO
     HADDPD           xmmreg,xmmrm             PRESCOTT,SSE3,SO
     HADDPS           xmmreg,xmmrm             PRESCOTT,SSE3,SO
     HSUBPD           xmmreg,xmmrm             PRESCOTT,SSE3,SO
     HSUBPS           xmmreg,xmmrm             PRESCOTT,SSE3,SO
     LDDQU            xmmreg,mem               PRESCOTT,SSE3,SO
     MOVDDUP          xmmreg,xmmrm             PRESCOTT,SSE3
     MOVSHDUP         xmmreg,xmmrm             PRESCOTT,SSE3
     MOVSLDUP         xmmreg,xmmrm             PRESCOTT,SSE3


File: nasm.info,  Node: Section B.1.13,  Next: Section B.1.14,  Prev: Section B.1.12,  Up: Section B.1

B.1.13. VMX/SVM Instructions
----------------------------

     CLGI                                      VMX,AMD
     STGI                                      VMX,AMD
     VMCALL                                    VMX
     VMCLEAR          mem                      VMX
     VMFUNC                                    VMX
     VMLAUNCH                                  VMX
     VMLOAD                                    VMX,AMD
     VMMCALL                                   VMX,AMD
     VMPTRLD          mem                      VMX
     VMPTRST          mem                      VMX
     VMREAD           rm32,reg32               VMX,NOLONG,SD
     VMREAD           rm64,reg64               X64,VMX
     VMRESUME                                  VMX
     VMRUN                                     VMX,AMD
     VMSAVE                                    VMX,AMD
     VMWRITE          reg32,rm32               VMX,NOLONG,SD
     VMWRITE          reg64,rm64               X64,VMX
     VMXOFF                                    VMX
     VMXON            mem                      VMX


File: nasm.info,  Node: Section B.1.14,  Next: Section B.1.15,  Prev: Section B.1.13,  Up: Section B.1

B.1.14. Extended Page Tables VMX instructions
---------------------------------------------

     INVEPT           reg32,mem                VMX,SO,NOLONG
     INVEPT           reg64,mem                VMX,SO,LONG
     INVVPID          reg32,mem                VMX,SO,NOLONG
     INVVPID          reg64,mem                VMX,SO,LONG


File: nasm.info,  Node: Section B.1.15,  Next: Section B.1.16,  Prev: Section B.1.14,  Up: Section B.1

B.1.15. Tejas New Instructions (SSSE3)
--------------------------------------

     PABSB            mmxreg,mmxrm             SSSE3,MMX
     PABSB            xmmreg,xmmrm             SSSE3
     PABSW            mmxreg,mmxrm             SSSE3,MMX
     PABSW            xmmreg,xmmrm             SSSE3
     PABSD            mmxreg,mmxrm             SSSE3,MMX
     PABSD            xmmreg,xmmrm             SSSE3
     PALIGNR          mmxreg,mmxrm,imm         SSSE3,MMX
     PALIGNR          xmmreg,xmmrm,imm         SSSE3
     PHADDW           mmxreg,mmxrm             SSSE3,MMX
     PHADDW           xmmreg,xmmrm             SSSE3
     PHADDD           mmxreg,mmxrm             SSSE3,MMX
     PHADDD           xmmreg,xmmrm             SSSE3
     PHADDSW          mmxreg,mmxrm             SSSE3,MMX
     PHADDSW          xmmreg,xmmrm             SSSE3
     PHSUBW           mmxreg,mmxrm             SSSE3,MMX
     PHSUBW           xmmreg,xmmrm             SSSE3
     PHSUBD           mmxreg,mmxrm             SSSE3,MMX
     PHSUBD           xmmreg,xmmrm             SSSE3
     PHSUBSW          mmxreg,mmxrm             SSSE3,MMX
     PHSUBSW          xmmreg,xmmrm             SSSE3
     PMADDUBSW        mmxreg,mmxrm             SSSE3,MMX
     PMADDUBSW        xmmreg,xmmrm             SSSE3
     PMULHRSW         mmxreg,mmxrm             SSSE3,MMX
     PMULHRSW         xmmreg,xmmrm             SSSE3
     PSHUFB           mmxreg,mmxrm             SSSE3,MMX
     PSHUFB           xmmreg,xmmrm             SSSE3
     PSIGNB           mmxreg,mmxrm             SSSE3,MMX
     PSIGNB           xmmreg,xmmrm             SSSE3
     PSIGNW           mmxreg,mmxrm             SSSE3,MMX
     PSIGNW           xmmreg,xmmrm             SSSE3
     PSIGND           mmxreg,mmxrm             SSSE3,MMX
     PSIGND           xmmreg,xmmrm             SSSE3


File: nasm.info,  Node: Section B.1.16,  Next: Section B.1.17,  Prev: Section B.1.15,  Up: Section B.1

B.1.16. AMD SSE4A
-----------------

     EXTRQ            xmmreg,imm,imm           SSE4A,AMD
     EXTRQ            xmmreg,xmmreg            SSE4A,AMD
     INSERTQ          xmmreg,xmmreg,imm,imm    SSE4A,AMD
     INSERTQ          xmmreg,xmmreg            SSE4A,AMD
     MOVNTSD          mem,xmmreg               SSE4A,AMD
     MOVNTSS          mem,xmmreg               SSE4A,AMD,SD


File: nasm.info,  Node: Section B.1.17,  Next: Section B.1.18,  Prev: Section B.1.16,  Up: Section B.1

B.1.17. New instructions in Barcelona
-------------------------------------

     LZCNT            reg16,rm16               P6,AMD
     LZCNT            reg32,rm32               P6,AMD
     LZCNT            reg64,rm64               X64,AMD


File: nasm.info,  Node: Section B.1.18,  Next: Section B.1.19,  Prev: Section B.1.17,  Up: Section B.1

B.1.18. Penryn New Instructions (SSE4.1)
----------------------------------------

     BLENDPD          xmmreg,xmmrm,imm         SSE41
     BLENDPS          xmmreg,xmmrm,imm         SSE41
     BLENDVPD         xmmreg,xmmrm,xmm0        SSE41
     BLENDVPD         xmmreg,xmmrm             SSE41
     BLENDVPS         xmmreg,xmmrm,xmm0        SSE41
     BLENDVPS         xmmreg,xmmrm             SSE41
     DPPD             xmmreg,xmmrm,imm         SSE41
     DPPS             xmmreg,xmmrm,imm         SSE41
     EXTRACTPS        rm32,xmmreg,imm          SSE41
     EXTRACTPS        reg64,xmmreg,imm         SSE41,X64
     INSERTPS         xmmreg,xmmrm,imm         SSE41,SD
     MOVNTDQA         xmmreg,mem128            SSE41
     MPSADBW          xmmreg,xmmrm,imm         SSE41
     PACKUSDW         xmmreg,xmmrm             SSE41
     PBLENDVB         xmmreg,xmmrm,xmm0        SSE41
     PBLENDVB         xmmreg,xmmrm             SSE41
     PBLENDW          xmmreg,xmmrm,imm         SSE41
     PCMPEQQ          xmmreg,xmmrm             SSE41
     PEXTRB           reg32,xmmreg,imm         SSE41
     PEXTRB           mem8,xmmreg,imm          SSE41
     PEXTRB           reg64,xmmreg,imm         SSE41,X64
     PEXTRD           rm32,xmmreg,imm          SSE41
     PEXTRQ           rm64,xmmreg,imm          SSE41,X64
     PEXTRW           reg32,xmmreg,imm         SSE41
     PEXTRW           mem16,xmmreg,imm         SSE41
     PEXTRW           reg64,xmmreg,imm         SSE41,X64
     PHMINPOSUW       xmmreg,xmmrm             SSE41
     PINSRB           xmmreg,mem,imm           SSE41
     PINSRB           xmmreg,rm8,imm           SSE41
     PINSRB           xmmreg,reg32,imm         SSE41
     PINSRD           xmmreg,mem,imm           SSE41
     PINSRD           xmmreg,rm32,imm          SSE41
     PINSRQ           xmmreg,mem,imm           SSE41,X64
     PINSRQ           xmmreg,rm64,imm          SSE41,X64
     PMAXSB           xmmreg,xmmrm             SSE41
     PMAXSD           xmmreg,xmmrm             SSE41
     PMAXUD           xmmreg,xmmrm             SSE41
     PMAXUW           xmmreg,xmmrm             SSE41
     PMINSB           xmmreg,xmmrm             SSE41
     PMINSD           xmmreg,xmmrm             SSE41
     PMINUD           xmmreg,xmmrm             SSE41
     PMINUW           xmmreg,xmmrm             SSE41
     PMOVSXBW         xmmreg,xmmrm             SSE41
     PMOVSXBD         xmmreg,xmmrm             SSE41,SD
     PMOVSXBQ         xmmreg,xmmrm             SSE41,SW
     PMOVSXWD         xmmreg,xmmrm             SSE41
     PMOVSXWQ         xmmreg,xmmrm             SSE41,SD
     PMOVSXDQ         xmmreg,xmmrm             SSE41
     PMOVZXBW         xmmreg,xmmrm             SSE41
     PMOVZXBD         xmmreg,xmmrm             SSE41,SD
     PMOVZXBQ         xmmreg,xmmrm             SSE41,SW
     PMOVZXWD         xmmreg,xmmrm             SSE41
     PMOVZXWQ         xmmreg,xmmrm             SSE41,SD
     PMOVZXDQ         xmmreg,xmmrm             SSE41
     PMULDQ           xmmreg,xmmrm             SSE41
     PMULLD           xmmreg,xmmrm             SSE41
     PTEST            xmmreg,xmmrm             SSE41
     ROUNDPD          xmmreg,xmmrm,imm         SSE41
     ROUNDPS          xmmreg,xmmrm,imm         SSE41
     ROUNDSD          xmmreg,xmmrm,imm         SSE41
     ROUNDSS          xmmreg,xmmrm,imm         SSE41


File: nasm.info,  Node: Section B.1.19,  Next: Section B.1.20,  Prev: Section B.1.18,  Up: Section B.1

B.1.19. Nehalem New Instructions (SSE4.2)
-----------------------------------------

     CRC32            reg32,rm8                SSE42
     CRC32            reg32,rm16               SSE42
     CRC32            reg32,rm32               SSE42
     CRC32            reg64,rm8                SSE42,X64
     CRC32            reg64,rm64               SSE42,X64
     PCMPESTRI        xmmreg,xmmrm,imm         SSE42
     PCMPESTRM        xmmreg,xmmrm,imm         SSE42
     PCMPISTRI        xmmreg,xmmrm,imm         SSE42
     PCMPISTRM        xmmreg,xmmrm,imm         SSE42
     PCMPGTQ          xmmreg,xmmrm             SSE42
     POPCNT           reg16,rm16               NEHALEM,SW
     POPCNT           reg32,rm32               NEHALEM,SD
     POPCNT           reg64,rm64               NEHALEM,X64


File: nasm.info,  Node: Section B.1.20,  Next: Section B.1.21,  Prev: Section B.1.19,  Up: Section B.1

B.1.20. Intel SMX
-----------------

     GETSEC                                    KATMAI


File: nasm.info,  Node: Section B.1.21,  Next: Section B.1.22,  Prev: Section B.1.20,  Up: Section B.1

B.1.21. Geode (Cyrix) 3DNow! additions
--------------------------------------

     PFRCPV           mmxreg,mmxrm             PENT,3DNOW,CYRIX
     PFRSQRTV         mmxreg,mmxrm             PENT,3DNOW,CYRIX


File: nasm.info,  Node: Section B.1.22,  Next: Section B.1.23,  Prev: Section B.1.21,  Up: Section B.1

B.1.22. Intel new instructions in ???
-------------------------------------

     MOVBE            reg16,mem16              NEHALEM
     MOVBE            reg32,mem32              NEHALEM
     MOVBE            reg64,mem64              NEHALEM
     MOVBE            mem16,reg16              NEHALEM
     MOVBE            mem32,reg32              NEHALEM
     MOVBE            mem64,reg64              NEHALEM


File: nasm.info,  Node: Section B.1.23,  Next: Section B.1.24,  Prev: Section B.1.22,  Up: Section B.1

B.1.23. Intel AES instructions
------------------------------

     AESENC           xmmreg,xmmrm128          SSE,WESTMERE
     AESENCLAST       xmmreg,xmmrm128          SSE,WESTMERE
     AESDEC           xmmreg,xmmrm128          SSE,WESTMERE
     AESDECLAST       xmmreg,xmmrm128          SSE,WESTMERE
     AESIMC           xmmreg,xmmrm128          SSE,WESTMERE
     AESKEYGENASSIST  xmmreg,xmmrm128,imm8     SSE,WESTMERE


File: nasm.info,  Node: Section B.1.24,  Next: Section B.1.25,  Prev: Section B.1.23,  Up: Section B.1

B.1.24. Intel AVX AES instructions
----------------------------------

     VAESENC          xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VAESENCLAST      xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VAESDEC          xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VAESDECLAST      xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VAESIMC          xmmreg,xmmrm128          AVX,SANDYBRIDGE
     VAESKEYGENASSIST xmmreg,xmmrm128,imm8     AVX,SANDYBRIDGE


File: nasm.info,  Node: Section B.1.25,  Next: Section B.1.26,  Prev: Section B.1.24,  Up: Section B.1

B.1.25. Intel AVX instructions
------------------------------

     VADDPD           xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VADDPD           ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VADDPS           xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VADDPS           ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VADDSD           xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VADDSS           xmmreg,xmmreg*,xmmrm32   AVX,SANDYBRIDGE
     VADDSUBPD        xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VADDSUBPD        ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VADDSUBPS        xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VADDSUBPS        ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VANDPD           xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VANDPD           ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VANDPS           xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VANDPS           ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VANDNPD          xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VANDNPD          ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VANDNPS          xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VANDNPS          ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VBLENDPD         xmmreg,xmmreg*,xmmrm128,imm8 AVX,SANDYBRIDGE
     VBLENDPD         ymmreg,ymmreg*,ymmrm256,imm8 AVX,SANDYBRIDGE
     VBLENDPS         xmmreg,xmmreg*,xmmrm128,imm8 AVX,SANDYBRIDGE
     VBLENDPS         ymmreg,ymmreg*,ymmrm256,imm8 AVX,SANDYBRIDGE
     VBLENDVPD        xmmreg,xmmreg*,xmmrm128,xmmreg AVX,SANDYBRIDGE
     VBLENDVPD        ymmreg,ymmreg*,ymmrm256,ymmreg AVX,SANDYBRIDGE
     VBLENDVPS        xmmreg,xmmreg*,xmmrm128,xmmreg AVX,SANDYBRIDGE
     VBLENDVPS        ymmreg,ymmreg*,ymmrm256,ymmreg AVX,SANDYBRIDGE
     VBROADCASTSS     xmmreg,mem32             AVX,SANDYBRIDGE
     VBROADCASTSS     ymmreg,mem32             AVX,SANDYBRIDGE
     VBROADCASTSD     ymmreg,mem64             AVX,SANDYBRIDGE
     VBROADCASTF128   ymmreg,mem128            AVX,SANDYBRIDGE
     VCMPEQ_OSPD      xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPEQ_OSPD      ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPEQPD         xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPEQPD         ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPLT_OSPD      xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPLT_OSPD      ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPLTPD         xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPLTPD         ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPLE_OSPD      xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPLE_OSPD      ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPLEPD         xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPLEPD         ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPUNORD_QPD    xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPUNORD_QPD    ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPUNORDPD      xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPUNORDPD      ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPNEQ_UQPD     xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPNEQ_UQPD     ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPNEQPD        xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPNEQPD        ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPNLT_USPD     xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPNLT_USPD     ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPNLTPD        xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPNLTPD        ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPNLE_USPD     xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPNLE_USPD     ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPNLEPD        xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPNLEPD        ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPORD_QPD      xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPORD_QPD      ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPORDPD        xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPORDPD        ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPEQ_UQPD      xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPEQ_UQPD      ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPNGE_USPD     xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPNGE_USPD     ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPNGEPD        xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPNGEPD        ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPNGT_USPD     xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPNGT_USPD     ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPNGTPD        xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPNGTPD        ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPFALSE_OQPD   xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPFALSE_OQPD   ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPFALSEPD      xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPFALSEPD      ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPNEQ_OQPD     xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPNEQ_OQPD     ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPGE_OSPD      xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPGE_OSPD      ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPGEPD         xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPGEPD         ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPGT_OSPD      xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPGT_OSPD      ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPGTPD         xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPGTPD         ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPTRUE_UQPD    xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPTRUE_UQPD    ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPTRUEPD       xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPTRUEPD       ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPEQ_OSPD      xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPEQ_OSPD      ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPLT_OQPD      xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPLT_OQPD      ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPLE_OQPD      xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPLE_OQPD      ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPUNORD_SPD    xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPUNORD_SPD    ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPNEQ_USPD     xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPNEQ_USPD     ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPNLT_UQPD     xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPNLT_UQPD     ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPNLE_UQPD     xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPNLE_UQPD     ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPORD_SPD      xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPORD_SPD      ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPEQ_USPD      xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPEQ_USPD      ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPNGE_UQPD     xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPNGE_UQPD     ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPNGT_UQPD     xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPNGT_UQPD     ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPFALSE_OSPD   xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPFALSE_OSPD   ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPNEQ_OSPD     xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPNEQ_OSPD     ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPGE_OQPD      xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPGE_OQPD      ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPGT_OQPD      xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPGT_OQPD      ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPTRUE_USPD    xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPTRUE_USPD    ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPPD           xmmreg,xmmreg*,xmmrm128,imm8 AVX,SANDYBRIDGE
     VCMPPD           ymmreg,ymmreg*,ymmrm256,imm8 AVX,SANDYBRIDGE
     VCMPEQ_OSPS      xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPEQ_OSPS      ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPEQPS         xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPEQPS         ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPLT_OSPS      xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPLT_OSPS      ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPLTPS         xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPLTPS         ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPLE_OSPS      xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPLE_OSPS      ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPLEPS         xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPLEPS         ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPUNORD_QPS    xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPUNORD_QPS    ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPUNORDPS      xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPUNORDPS      ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPNEQ_UQPS     xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPNEQ_UQPS     ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPNEQPS        xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPNEQPS        ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPNLT_USPS     xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPNLT_USPS     ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPNLTPS        xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPNLTPS        ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPNLE_USPS     xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPNLE_USPS     ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPNLEPS        xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPNLEPS        ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPORD_QPS      xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPORD_QPS      ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPORDPS        xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPORDPS        ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPEQ_UQPS      xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPEQ_UQPS      ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPNGE_USPS     xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPNGE_USPS     ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPNGEPS        xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPNGEPS        ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPNGT_USPS     xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPNGT_USPS     ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPNGTPS        xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPNGTPS        ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPFALSE_OQPS   xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPFALSE_OQPS   ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPFALSEPS      xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPFALSEPS      ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPNEQ_OQPS     xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPNEQ_OQPS     ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPGE_OSPS      xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPGE_OSPS      ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPGEPS         xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPGEPS         ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPGT_OSPS      xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPGT_OSPS      ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPGTPS         xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPGTPS         ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPTRUE_UQPS    xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPTRUE_UQPS    ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPTRUEPS       xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPTRUEPS       ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPEQ_OSPS      xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPEQ_OSPS      ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPLT_OQPS      xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPLT_OQPS      ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPLE_OQPS      xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPLE_OQPS      ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPUNORD_SPS    xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPUNORD_SPS    ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPNEQ_USPS     xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPNEQ_USPS     ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPNLT_UQPS     xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPNLT_UQPS     ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPNLE_UQPS     xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPNLE_UQPS     ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPORD_SPS      xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPORD_SPS      ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPEQ_USPS      xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPEQ_USPS      ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPNGE_UQPS     xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPNGE_UQPS     ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPNGT_UQPS     xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPNGT_UQPS     ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPFALSE_OSPS   xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPFALSE_OSPS   ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPNEQ_OSPS     xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPNEQ_OSPS     ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPGE_OQPS      xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPGE_OQPS      ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPGT_OQPS      xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPGT_OQPS      ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPTRUE_USPS    xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VCMPTRUE_USPS    ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VCMPPS           xmmreg,xmmreg*,xmmrm128,imm8 AVX,SANDYBRIDGE
     VCMPPS           ymmreg,ymmreg*,ymmrm256,imm8 AVX,SANDYBRIDGE
     VCMPEQ_OSSD      xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPEQSD         xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPLT_OSSD      xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPLTSD         xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPLE_OSSD      xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPLESD         xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPUNORD_QSD    xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPUNORDSD      xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPNEQ_UQSD     xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPNEQSD        xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPNLT_USSD     xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPNLTSD        xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPNLE_USSD     xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPNLESD        xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPORD_QSD      xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPORDSD        xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPEQ_UQSD      xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPNGE_USSD     xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPNGESD        xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPNGT_USSD     xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPNGTSD        xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPFALSE_OQSD   xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPFALSESD      xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPNEQ_OQSD     xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPGE_OSSD      xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPGESD         xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPGT_OSSD      xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPGTSD         xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPTRUE_UQSD    xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPTRUESD       xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPEQ_OSSD      xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPLT_OQSD      xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPLE_OQSD      xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPUNORD_SSD    xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPNEQ_USSD     xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPNLT_UQSD     xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPNLE_UQSD     xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPORD_SSD      xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPEQ_USSD      xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPNGE_UQSD     xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPNGT_UQSD     xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPFALSE_OSSD   xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPNEQ_OSSD     xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPGE_OQSD      xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPGT_OQSD      xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPTRUE_USSD    xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPSD           xmmreg,xmmreg*,xmmrm64,imm8 AVX,SANDYBRIDGE
     VCMPEQ_OSSS      xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPEQSS         xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPLT_OSSS      xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPLTSS         xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPLE_OSSS      xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPLESS         xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPUNORD_QSS    xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPUNORDSS      xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPNEQ_UQSS     xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPNEQSS        xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPNLT_USSS     xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPNLTSS        xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPNLE_USSS     xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPNLESS        xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPORD_QSS      xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPORDSS        xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPEQ_UQSS      xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPNGE_USSS     xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPNGESS        xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPNGT_USSS     xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPNGTSS        xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPFALSE_OQSS   xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPFALSESS      xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPNEQ_OQSS     xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPGE_OSSS      xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPGESS         xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPGT_OSSS      xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPGTSS         xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPTRUE_UQSS    xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPTRUESS       xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPEQ_OSSS      xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPLT_OQSS      xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPLE_OQSS      xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPUNORD_SSS    xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPNEQ_USSS     xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPNLT_UQSS     xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPNLE_UQSS     xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPORD_SSS      xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPEQ_USSS      xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPNGE_UQSS     xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPNGT_UQSS     xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPFALSE_OSSS   xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPNEQ_OSSS     xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPGE_OQSS      xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPGT_OQSS      xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPTRUE_USSS    xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCMPSS           xmmreg,xmmreg*,xmmrm64,imm8 AVX,SANDYBRIDGE
     VCOMISD          xmmreg,xmmrm64           AVX,SANDYBRIDGE
     VCOMISS          xmmreg,xmmrm32           AVX,SANDYBRIDGE
     VCVTDQ2PD        xmmreg,xmmrm64           AVX,SANDYBRIDGE
     VCVTDQ2PD        ymmreg,xmmrm128          AVX,SANDYBRIDGE
     VCVTDQ2PS        xmmreg,xmmrm128          AVX,SANDYBRIDGE
     VCVTDQ2PS        ymmreg,ymmrm256          AVX,SANDYBRIDGE
     VCVTPD2DQ        xmmreg,xmmreg            AVX,SANDYBRIDGE
     VCVTPD2DQ        xmmreg,mem128            AVX,SANDYBRIDGE,SO
     VCVTPD2DQ        xmmreg,ymmreg            AVX,SANDYBRIDGE
     VCVTPD2DQ        xmmreg,mem256            AVX,SANDYBRIDGE,SY
     VCVTPD2PS        xmmreg,xmmreg            AVX,SANDYBRIDGE
     VCVTPD2PS        xmmreg,mem128            AVX,SANDYBRIDGE,SO
     VCVTPD2PS        xmmreg,ymmreg            AVX,SANDYBRIDGE
     VCVTPD2PS        xmmreg,mem256            AVX,SANDYBRIDGE,SY
     VCVTPS2DQ        xmmreg,xmmrm128          AVX,SANDYBRIDGE
     VCVTPS2DQ        ymmreg,ymmrm256          AVX,SANDYBRIDGE
     VCVTPS2PD        xmmreg,xmmrm64           AVX,SANDYBRIDGE
     VCVTPS2PD        ymmreg,xmmrm128          AVX,SANDYBRIDGE
     VCVTSD2SI        reg32,xmmrm64            AVX,SANDYBRIDGE
     VCVTSD2SI        reg64,xmmrm64            AVX,SANDYBRIDGE,LONG
     VCVTSD2SS        xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VCVTSI2SD        xmmreg,xmmreg*,rm32      AVX,SANDYBRIDGE,SD
     VCVTSI2SD        xmmreg,xmmreg*,mem32     AVX,SANDYBRIDGE,ND,SD
     VCVTSI2SD        xmmreg,xmmreg*,rm64      AVX,SANDYBRIDGE,LONG
     VCVTSI2SS        xmmreg,xmmreg*,rm32      AVX,SANDYBRIDGE,SD
     VCVTSI2SS        xmmreg,xmmreg*,mem32     AVX,SANDYBRIDGE,ND,SD
     VCVTSI2SS        xmmreg,xmmreg*,rm64      AVX,SANDYBRIDGE,LONG
     VCVTSS2SD        xmmreg,xmmreg*,xmmrm32   AVX,SANDYBRIDGE
     VCVTSS2SI        reg32,xmmrm32            AVX,SANDYBRIDGE
     VCVTSS2SI        reg64,xmmrm32            AVX,SANDYBRIDGE,LONG
     VCVTTPD2DQ       xmmreg,xmmreg            AVX,SANDYBRIDGE
     VCVTTPD2DQ       xmmreg,mem128            AVX,SANDYBRIDGE,SO
     VCVTTPD2DQ       xmmreg,ymmreg            AVX,SANDYBRIDGE
     VCVTTPD2DQ       xmmreg,mem256            AVX,SANDYBRIDGE,SY
     VCVTTPS2DQ       xmmreg,xmmrm128          AVX,SANDYBRIDGE
     VCVTTPS2DQ       ymmreg,ymmrm256          AVX,SANDYBRIDGE
     VCVTTSD2SI       reg32,xmmrm64            AVX,SANDYBRIDGE
     VCVTTSD2SI       reg64,xmmrm64            AVX,SANDYBRIDGE,LONG
     VCVTTSS2SI       reg32,xmmrm32            AVX,SANDYBRIDGE
     VCVTTSS2SI       reg64,xmmrm32            AVX,SANDYBRIDGE,LONG
     VDIVPD           xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VDIVPD           ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VDIVPS           xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VDIVPS           ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VDIVSD           xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VDIVSS           xmmreg,xmmreg*,xmmrm32   AVX,SANDYBRIDGE
     VDPPD            xmmreg,xmmreg*,xmmrm128,imm8 AVX,SANDYBRIDGE
     VDPPS            xmmreg,xmmreg*,xmmrm128,imm8 AVX,SANDYBRIDGE
     VDPPS            ymmreg,ymmreg*,ymmrm256,imm8 AVX,SANDYBRIDGE
     VEXTRACTF128     xmmrm128,ymmreg,imm8     AVX,SANDYBRIDGE
     VEXTRACTPS       rm32,xmmreg,imm8         AVX,SANDYBRIDGE
     VHADDPD          xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VHADDPD          ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VHADDPS          xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VHADDPS          ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VHSUBPD          xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VHSUBPD          ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VHSUBPS          xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VHSUBPS          ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VINSERTF128      ymmreg,ymmreg,xmmrm128,imm8 AVX,SANDYBRIDGE
     VINSERTPS        xmmreg,xmmreg*,xmmrm32,imm8 AVX,SANDYBRIDGE
     VLDDQU           xmmreg,mem128            AVX,SANDYBRIDGE
     VLDQQU           ymmreg,mem256            AVX,SANDYBRIDGE
     VLDDQU           ymmreg,mem256            AVX,SANDYBRIDGE
     VLDMXCSR         mem32                    AVX,SANDYBRIDGE
     VMASKMOVDQU      xmmreg,xmmreg            AVX,SANDYBRIDGE
     VMASKMOVPS       xmmreg,xmmreg,mem128     AVX,SANDYBRIDGE
     VMASKMOVPS       ymmreg,ymmreg,mem256     AVX,SANDYBRIDGE
     VMASKMOVPS       mem128,xmmreg,xmmreg     AVX,SANDYBRIDGE,SO
     VMASKMOVPS       mem256,ymmreg,ymmreg     AVX,SANDYBRIDGE,SY
     VMASKMOVPD       xmmreg,xmmreg,mem128     AVX,SANDYBRIDGE
     VMASKMOVPD       ymmreg,ymmreg,mem256     AVX,SANDYBRIDGE
     VMASKMOVPD       mem128,xmmreg,xmmreg     AVX,SANDYBRIDGE
     VMASKMOVPD       mem256,ymmreg,ymmreg     AVX,SANDYBRIDGE
     VMAXPD           xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VMAXPD           ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VMAXPS           xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VMAXPS           ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VMAXSD           xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VMAXSS           xmmreg,xmmreg*,xmmrm32   AVX,SANDYBRIDGE
     VMINPD           xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VMINPD           ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VMINPS           xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VMINPS           ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VMINSD           xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VMINSS           xmmreg,xmmreg*,xmmrm32   AVX,SANDYBRIDGE
     VMOVAPD          xmmreg,xmmrm128          AVX,SANDYBRIDGE
     VMOVAPD          xmmrm128,xmmreg          AVX,SANDYBRIDGE
     VMOVAPD          ymmreg,ymmrm256          AVX,SANDYBRIDGE
     VMOVAPD          ymmrm256,ymmreg          AVX,SANDYBRIDGE
     VMOVAPS          xmmreg,xmmrm128          AVX,SANDYBRIDGE
     VMOVAPS          xmmrm128,xmmreg          AVX,SANDYBRIDGE
     VMOVAPS          ymmreg,ymmrm256          AVX,SANDYBRIDGE
     VMOVAPS          ymmrm256,ymmreg          AVX,SANDYBRIDGE
     VMOVD            xmmreg,rm32              AVX,SANDYBRIDGE
     VMOVD            rm32,xmmreg              AVX,SANDYBRIDGE
     VMOVQ            xmmreg,xmmrm64           AVX,SANDYBRIDGE
     VMOVQ            xmmrm64,xmmreg           AVX,SANDYBRIDGE
     VMOVQ            xmmreg,rm64              AVX,SANDYBRIDGE,LONG
     VMOVQ            rm64,xmmreg              AVX,SANDYBRIDGE,LONG
     VMOVDDUP         xmmreg,xmmrm64           AVX,SANDYBRIDGE
     VMOVDDUP         ymmreg,ymmrm256          AVX,SANDYBRIDGE
     VMOVDQA          xmmreg,xmmrm128          AVX,SANDYBRIDGE
     VMOVDQA          xmmrm128,xmmreg          AVX,SANDYBRIDGE
     VMOVQQA          ymmreg,ymmrm256          AVX,SANDYBRIDGE
     VMOVQQA          ymmrm256,ymmreg          AVX,SANDYBRIDGE
     VMOVDQA          ymmreg,ymmrm             AVX,SANDYBRIDGE
     VMOVDQA          ymmrm256,ymmreg          AVX,SANDYBRIDGE
     VMOVDQU          xmmreg,xmmrm128          AVX,SANDYBRIDGE
     VMOVDQU          xmmrm128,xmmreg          AVX,SANDYBRIDGE
     VMOVQQU          ymmreg,ymmrm256          AVX,SANDYBRIDGE
     VMOVQQU          ymmrm256,ymmreg          AVX,SANDYBRIDGE
     VMOVDQU          ymmreg,ymmrm256          AVX,SANDYBRIDGE
     VMOVDQU          ymmrm256,ymmreg          AVX,SANDYBRIDGE
     VMOVHLPS         xmmreg,xmmreg*,xmmreg    AVX,SANDYBRIDGE
     VMOVHPD          xmmreg,xmmreg*,mem64     AVX,SANDYBRIDGE
     VMOVHPD          mem64,xmmreg             AVX,SANDYBRIDGE
     VMOVHPS          xmmreg,xmmreg*,mem64     AVX,SANDYBRIDGE
     VMOVHPS          mem64,xmmreg             AVX,SANDYBRIDGE
     VMOVLHPS         xmmreg,xmmreg*,xmmreg    AVX,SANDYBRIDGE
     VMOVLPD          xmmreg,xmmreg*,mem64     AVX,SANDYBRIDGE
     VMOVLPD          mem64,xmmreg             AVX,SANDYBRIDGE
     VMOVLPS          xmmreg,xmmreg*,mem64     AVX,SANDYBRIDGE
     VMOVLPS          mem64,xmmreg             AVX,SANDYBRIDGE
     VMOVMSKPD        reg64,xmmreg             AVX,SANDYBRIDGE,LONG
     VMOVMSKPD        reg32,xmmreg             AVX,SANDYBRIDGE
     VMOVMSKPD        reg64,ymmreg             AVX,SANDYBRIDGE,LONG
     VMOVMSKPD        reg32,ymmreg             AVX,SANDYBRIDGE
     VMOVMSKPS        reg64,xmmreg             AVX,SANDYBRIDGE,LONG
     VMOVMSKPS        reg32,xmmreg             AVX,SANDYBRIDGE
     VMOVMSKPS        reg64,ymmreg             AVX,SANDYBRIDGE,LONG
     VMOVMSKPS        reg32,ymmreg             AVX,SANDYBRIDGE
     VMOVNTDQ         mem128,xmmreg            AVX,SANDYBRIDGE
     VMOVNTQQ         mem256,ymmreg            AVX,SANDYBRIDGE
     VMOVNTDQ         mem256,ymmreg            AVX,SANDYBRIDGE
     VMOVNTDQA        xmmreg,mem128            AVX,SANDYBRIDGE
     VMOVNTPD         mem128,xmmreg            AVX,SANDYBRIDGE
     VMOVNTPD         mem256,ymmreg            AVX,SANDYBRIDGE
     VMOVNTPS         mem128,xmmreg            AVX,SANDYBRIDGE
     VMOVNTPS         mem256,ymmreg            AVX,SANDYBRIDGE
     VMOVSD           xmmreg,xmmreg*,xmmreg    AVX,SANDYBRIDGE
     VMOVSD           xmmreg,mem64             AVX,SANDYBRIDGE
     VMOVSD           xmmreg,xmmreg*,xmmreg    AVX,SANDYBRIDGE
     VMOVSD           mem64,xmmreg             AVX,SANDYBRIDGE
     VMOVSHDUP        xmmreg,xmmrm128          AVX,SANDYBRIDGE
     VMOVSHDUP        ymmreg,ymmrm256          AVX,SANDYBRIDGE
     VMOVSLDUP        xmmreg,xmmrm128          AVX,SANDYBRIDGE
     VMOVSLDUP        ymmreg,ymmrm256          AVX,SANDYBRIDGE
     VMOVSS           xmmreg,xmmreg*,xmmreg    AVX,SANDYBRIDGE
     VMOVSS           xmmreg,mem32             AVX,SANDYBRIDGE
     VMOVSS           xmmreg,xmmreg*,xmmreg    AVX,SANDYBRIDGE
     VMOVSS           mem32,xmmreg             AVX,SANDYBRIDGE
     VMOVUPD          xmmreg,xmmrm128          AVX,SANDYBRIDGE
     VMOVUPD          xmmrm128,xmmreg          AVX,SANDYBRIDGE
     VMOVUPD          ymmreg,ymmrm256          AVX,SANDYBRIDGE
     VMOVUPD          ymmrm256,ymmreg          AVX,SANDYBRIDGE
     VMOVUPS          xmmreg,xmmrm128          AVX,SANDYBRIDGE
     VMOVUPS          xmmrm128,xmmreg          AVX,SANDYBRIDGE
     VMOVUPS          ymmreg,ymmrm256          AVX,SANDYBRIDGE
     VMOVUPS          ymmrm256,ymmreg          AVX,SANDYBRIDGE
     VMPSADBW         xmmreg,xmmreg*,xmmrm128,imm8 AVX,SANDYBRIDGE
     VMULPD           xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VMULPD           ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VMULPS           xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VMULPS           ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VMULSD           xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VMULSS           xmmreg,xmmreg*,xmmrm32   AVX,SANDYBRIDGE
     VORPD            xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VORPD            ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VORPS            xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VORPS            ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VPABSB           xmmreg,xmmrm128          AVX,SANDYBRIDGE
     VPABSW           xmmreg,xmmrm128          AVX,SANDYBRIDGE
     VPABSD           xmmreg,xmmrm128          AVX,SANDYBRIDGE
     VPACKSSWB        xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPACKSSDW        xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPACKUSWB        xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPACKUSDW        xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPADDB           xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPADDW           xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPADDD           xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPADDQ           xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPADDSB          xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPADDSW          xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPADDUSB         xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPADDUSW         xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPALIGNR         xmmreg,xmmreg*,xmmrm128,imm8 AVX,SANDYBRIDGE
     VPAND            xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPANDN           xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPAVGB           xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPAVGW           xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPBLENDVB        xmmreg,xmmreg*,xmmrm128,xmmreg AVX,SANDYBRIDGE
     VPBLENDW         xmmreg,xmmreg*,xmmrm128,imm8 AVX,SANDYBRIDGE
     VPCMPESTRI       xmmreg,xmmrm128,imm8     AVX,SANDYBRIDGE
     VPCMPESTRM       xmmreg,xmmrm128,imm8     AVX,SANDYBRIDGE
     VPCMPISTRI       xmmreg,xmmrm128,imm8     AVX,SANDYBRIDGE
     VPCMPISTRM       xmmreg,xmmrm128,imm8     AVX,SANDYBRIDGE
     VPCMPEQB         xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPCMPEQW         xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPCMPEQD         xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPCMPEQQ         xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPCMPGTB         xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPCMPGTW         xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPCMPGTD         xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPCMPGTQ         xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPERMILPD        xmmreg,xmmreg,xmmrm128   AVX,SANDYBRIDGE
     VPERMILPD        ymmreg,ymmreg,ymmrm256   AVX,SANDYBRIDGE
     VPERMILPD        xmmreg,xmmrm128,imm8     AVX,SANDYBRIDGE
     VPERMILPD        ymmreg,ymmrm256,imm8     AVX,SANDYBRIDGE
     VPERMILPS        xmmreg,xmmreg,xmmrm128   AVX,SANDYBRIDGE
     VPERMILPS        ymmreg,ymmreg,ymmrm256   AVX,SANDYBRIDGE
     VPERMILPS        xmmreg,xmmrm128,imm8     AVX,SANDYBRIDGE
     VPERMILPS        ymmreg,ymmrm256,imm8     AVX,SANDYBRIDGE
     VPERM2F128       ymmreg,ymmreg,ymmrm256,imm8 AVX,SANDYBRIDGE
     VPEXTRB          reg64,xmmreg,imm8        AVX,SANDYBRIDGE,LONG
     VPEXTRB          reg32,xmmreg,imm8        AVX,SANDYBRIDGE
     VPEXTRB          mem8,xmmreg,imm8         AVX,SANDYBRIDGE
     VPEXTRW          reg64,xmmreg,imm8        AVX,SANDYBRIDGE,LONG
     VPEXTRW          reg32,xmmreg,imm8        AVX,SANDYBRIDGE
     VPEXTRW          reg64,xmmreg,imm8        AVX,SANDYBRIDGE,LONG
     VPEXTRW          reg32,xmmreg,imm8        AVX,SANDYBRIDGE
     VPEXTRW          mem16,xmmreg,imm8        AVX,SANDYBRIDGE
     VPEXTRD          reg64,xmmreg,imm8        AVX,SANDYBRIDGE,LONG
     VPEXTRD          rm32,xmmreg,imm8         AVX,SANDYBRIDGE
     VPEXTRQ          rm64,xmmreg,imm8         AVX,SANDYBRIDGE,LONG
     VPHADDW          xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPHADDD          xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPHADDSW         xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPHMINPOSUW      xmmreg,xmmrm128          AVX,SANDYBRIDGE
     VPHSUBW          xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPHSUBD          xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPHSUBSW         xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPINSRB          xmmreg,xmmreg*,mem8,imm8 AVX,SANDYBRIDGE
     VPINSRB          xmmreg,xmmreg*,rm8,imm8  AVX,SANDYBRIDGE
     VPINSRB          xmmreg,xmmreg*,reg32,imm8 AVX,SANDYBRIDGE
     VPINSRW          xmmreg,xmmreg*,mem16,imm8 AVX,SANDYBRIDGE
     VPINSRW          xmmreg,xmmreg*,rm16,imm8 AVX,SANDYBRIDGE
     VPINSRW          xmmreg,xmmreg*,reg32,imm8 AVX,SANDYBRIDGE
     VPINSRD          xmmreg,xmmreg*,mem32,imm8 AVX,SANDYBRIDGE
     VPINSRD          xmmreg,xmmreg*,rm32,imm8 AVX,SANDYBRIDGE
     VPINSRQ          xmmreg,xmmreg*,mem64,imm8 AVX,SANDYBRIDGE,LONG
     VPINSRQ          xmmreg,xmmreg*,rm64,imm8 AVX,SANDYBRIDGE,LONG
     VPMADDWD         xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPMADDUBSW       xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPMAXSB          xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPMAXSW          xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPMAXSD          xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPMAXUB          xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPMAXUW          xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPMAXUD          xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPMINSB          xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPMINSW          xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPMINSD          xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPMINUB          xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPMINUW          xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPMINUD          xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPMOVMSKB        reg64,xmmreg             AVX,SANDYBRIDGE,LONG
     VPMOVMSKB        reg32,xmmreg             AVX,SANDYBRIDGE
     VPMOVSXBW        xmmreg,xmmrm64           AVX,SANDYBRIDGE
     VPMOVSXBD        xmmreg,xmmrm32           AVX,SANDYBRIDGE
     VPMOVSXBQ        xmmreg,xmmrm16           AVX,SANDYBRIDGE
     VPMOVSXWD        xmmreg,xmmrm64           AVX,SANDYBRIDGE
     VPMOVSXWQ        xmmreg,xmmrm32           AVX,SANDYBRIDGE
     VPMOVSXDQ        xmmreg,xmmrm64           AVX,SANDYBRIDGE
     VPMOVZXBW        xmmreg,xmmrm64           AVX,SANDYBRIDGE
     VPMOVZXBD        xmmreg,xmmrm32           AVX,SANDYBRIDGE
     VPMOVZXBQ        xmmreg,xmmrm16           AVX,SANDYBRIDGE
     VPMOVZXWD        xmmreg,xmmrm64           AVX,SANDYBRIDGE
     VPMOVZXWQ        xmmreg,xmmrm32           AVX,SANDYBRIDGE
     VPMOVZXDQ        xmmreg,xmmrm64           AVX,SANDYBRIDGE
     VPMULHUW         xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPMULHRSW        xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPMULHW          xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPMULLW          xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPMULLD          xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPMULUDQ         xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPMULDQ          xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPOR             xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPSADBW          xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPSHUFB          xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPSHUFD          xmmreg,xmmrm128,imm8     AVX,SANDYBRIDGE
     VPSHUFHW         xmmreg,xmmrm128,imm8     AVX,SANDYBRIDGE
     VPSHUFLW         xmmreg,xmmrm128,imm8     AVX,SANDYBRIDGE
     VPSIGNB          xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPSIGNW          xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPSIGND          xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPSLLDQ          xmmreg,xmmreg*,imm8      AVX,SANDYBRIDGE
     VPSRLDQ          xmmreg,xmmreg*,imm8      AVX,SANDYBRIDGE
     VPSLLW           xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPSLLW           xmmreg,xmmreg*,imm8      AVX,SANDYBRIDGE
     VPSLLD           xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPSLLD           xmmreg,xmmreg*,imm8      AVX,SANDYBRIDGE
     VPSLLQ           xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPSLLQ           xmmreg,xmmreg*,imm8      AVX,SANDYBRIDGE
     VPSRAW           xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPSRAW           xmmreg,xmmreg*,imm8      AVX,SANDYBRIDGE
     VPSRAD           xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPSRAD           xmmreg,xmmreg*,imm8      AVX,SANDYBRIDGE
     VPSRLW           xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPSRLW           xmmreg,xmmreg*,imm8      AVX,SANDYBRIDGE
     VPSRLD           xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPSRLD           xmmreg,xmmreg*,imm8      AVX,SANDYBRIDGE
     VPSRLQ           xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPSRLQ           xmmreg,xmmreg*,imm8      AVX,SANDYBRIDGE
     VPTEST           xmmreg,xmmrm128          AVX,SANDYBRIDGE
     VPTEST           ymmreg,ymmrm256          AVX,SANDYBRIDGE
     VPSUBB           xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPSUBW           xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPSUBD           xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPSUBQ           xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPSUBSB          xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPSUBSW          xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPSUBUSB         xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPSUBUSW         xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPUNPCKHBW       xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPUNPCKHWD       xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPUNPCKHDQ       xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPUNPCKHQDQ      xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPUNPCKLBW       xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPUNPCKLWD       xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPUNPCKLDQ       xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPUNPCKLQDQ      xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPXOR            xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VRCPPS           xmmreg,xmmrm128          AVX,SANDYBRIDGE
     VRCPPS           ymmreg,ymmrm256          AVX,SANDYBRIDGE
     VRCPSS           xmmreg,xmmreg*,xmmrm32   AVX,SANDYBRIDGE
     VRSQRTPS         xmmreg,xmmrm128          AVX,SANDYBRIDGE
     VRSQRTPS         ymmreg,ymmrm256          AVX,SANDYBRIDGE
     VRSQRTSS         xmmreg,xmmreg*,xmmrm32   AVX,SANDYBRIDGE
     VROUNDPD         xmmreg,xmmrm128,imm8     AVX,SANDYBRIDGE
     VROUNDPD         ymmreg,ymmrm256,imm8     AVX,SANDYBRIDGE
     VROUNDPS         xmmreg,xmmrm128,imm8     AVX,SANDYBRIDGE
     VROUNDPS         ymmreg,ymmrm256,imm8     AVX,SANDYBRIDGE
     VROUNDSD         xmmreg,xmmreg*,xmmrm64,imm8 AVX,SANDYBRIDGE
     VROUNDSS         xmmreg,xmmreg*,xmmrm32,imm8 AVX,SANDYBRIDGE
     VSHUFPD          xmmreg,xmmreg*,xmmrm128,imm8 AVX,SANDYBRIDGE
     VSHUFPD          ymmreg,ymmreg*,ymmrm256,imm8 AVX,SANDYBRIDGE
     VSHUFPS          xmmreg,xmmreg*,xmmrm128,imm8 AVX,SANDYBRIDGE
     VSHUFPS          ymmreg,ymmreg*,ymmrm256,imm8 AVX,SANDYBRIDGE
     VSQRTPD          xmmreg,xmmrm128          AVX,SANDYBRIDGE
     VSQRTPD          ymmreg,ymmrm256          AVX,SANDYBRIDGE
     VSQRTPS          xmmreg,xmmrm128          AVX,SANDYBRIDGE
     VSQRTPS          ymmreg,ymmrm256          AVX,SANDYBRIDGE
     VSQRTSD          xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VSQRTSS          xmmreg,xmmreg*,xmmrm32   AVX,SANDYBRIDGE
     VSTMXCSR         mem32                    AVX,SANDYBRIDGE
     VSUBPD           xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VSUBPD           ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VSUBPS           xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VSUBPS           ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VSUBSD           xmmreg,xmmreg*,xmmrm64   AVX,SANDYBRIDGE
     VSUBSS           xmmreg,xmmreg*,xmmrm32   AVX,SANDYBRIDGE
     VTESTPS          xmmreg,xmmrm128          AVX,SANDYBRIDGE
     VTESTPS          ymmreg,ymmrm256          AVX,SANDYBRIDGE
     VTESTPD          xmmreg,xmmrm128          AVX,SANDYBRIDGE
     VTESTPD          ymmreg,ymmrm256          AVX,SANDYBRIDGE
     VUCOMISD         xmmreg,xmmrm64           AVX,SANDYBRIDGE
     VUCOMISS         xmmreg,xmmrm32           AVX,SANDYBRIDGE
     VUNPCKHPD        xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VUNPCKHPD        ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VUNPCKHPS        xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VUNPCKHPS        ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VUNPCKLPD        xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VUNPCKLPD        ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VUNPCKLPS        xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VUNPCKLPS        ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VXORPD           xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VXORPD           ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VXORPS           xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VXORPS           ymmreg,ymmreg*,ymmrm256  AVX,SANDYBRIDGE
     VZEROALL                                  AVX,SANDYBRIDGE
     VZEROUPPER                                AVX,SANDYBRIDGE


File: nasm.info,  Node: Section B.1.26,  Next: Section B.1.27,  Prev: Section B.1.25,  Up: Section B.1

B.1.26. Intel Carry-Less Multiplication instructions (CLMUL)
------------------------------------------------------------

     PCLMULLQLQDQ     xmmreg,xmmrm128          SSE,WESTMERE
     PCLMULHQLQDQ     xmmreg,xmmrm128          SSE,WESTMERE
     PCLMULLQHQDQ     xmmreg,xmmrm128          SSE,WESTMERE
     PCLMULHQHQDQ     xmmreg,xmmrm128          SSE,WESTMERE
     PCLMULQDQ        xmmreg,xmmrm128,imm8     SSE,WESTMERE


File: nasm.info,  Node: Section B.1.27,  Next: Section B.1.28,  Prev: Section B.1.26,  Up: Section B.1

B.1.27. Intel AVX Carry-Less Multiplication instructions (CLMUL)
----------------------------------------------------------------

     VPCLMULLQLQDQ    xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPCLMULHQLQDQ    xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPCLMULLQHQDQ    xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPCLMULHQHQDQ    xmmreg,xmmreg*,xmmrm128  AVX,SANDYBRIDGE
     VPCLMULQDQ       xmmreg,xmmreg*,xmmrm128,imm8 AVX,SANDYBRIDGE


File: nasm.info,  Node: Section B.1.28,  Next: Section B.1.29,  Prev: Section B.1.27,  Up: Section B.1

B.1.28. Intel Fused Multiply-Add instructions (FMA)
---------------------------------------------------

     VFMADD132PS      xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFMADD132PS      ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFMADD132PD      xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFMADD132PD      ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFMADD312PS      xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFMADD312PS      ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFMADD312PD      xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFMADD312PD      ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFMADD213PS      xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFMADD213PS      ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFMADD213PD      xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFMADD213PD      ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFMADD123PS      xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFMADD123PS      ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFMADD123PD      xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFMADD123PD      ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFMADD231PS      xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFMADD231PS      ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFMADD231PD      xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFMADD231PD      ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFMADD321PS      xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFMADD321PS      ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFMADD321PD      xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFMADD321PD      ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFMADDSUB132PS   xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFMADDSUB132PS   ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFMADDSUB132PD   xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFMADDSUB132PD   ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFMADDSUB312PS   xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFMADDSUB312PS   ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFMADDSUB312PD   xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFMADDSUB312PD   ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFMADDSUB213PS   xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFMADDSUB213PS   ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFMADDSUB213PD   xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFMADDSUB213PD   ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFMADDSUB123PS   xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFMADDSUB123PS   ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFMADDSUB123PD   xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFMADDSUB123PD   ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFMADDSUB231PS   xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFMADDSUB231PS   ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFMADDSUB231PD   xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFMADDSUB231PD   ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFMADDSUB321PS   xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFMADDSUB321PS   ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFMADDSUB321PD   xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFMADDSUB321PD   ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFMSUB132PS      xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFMSUB132PS      ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFMSUB132PD      xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFMSUB132PD      ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFMSUB312PS      xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFMSUB312PS      ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFMSUB312PD      xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFMSUB312PD      ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFMSUB213PS      xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFMSUB213PS      ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFMSUB213PD      xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFMSUB213PD      ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFMSUB123PS      xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFMSUB123PS      ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFMSUB123PD      xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFMSUB123PD      ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFMSUB231PS      xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFMSUB231PS      ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFMSUB231PD      xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFMSUB231PD      ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFMSUB321PS      xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFMSUB321PS      ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFMSUB321PD      xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFMSUB321PD      ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFMSUBADD132PS   xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFMSUBADD132PS   ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFMSUBADD132PD   xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFMSUBADD132PD   ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFMSUBADD312PS   xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFMSUBADD312PS   ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFMSUBADD312PD   xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFMSUBADD312PD   ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFMSUBADD213PS   xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFMSUBADD213PS   ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFMSUBADD213PD   xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFMSUBADD213PD   ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFMSUBADD123PS   xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFMSUBADD123PS   ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFMSUBADD123PD   xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFMSUBADD123PD   ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFMSUBADD231PS   xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFMSUBADD231PS   ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFMSUBADD231PD   xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFMSUBADD231PD   ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFMSUBADD321PS   xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFMSUBADD321PS   ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFMSUBADD321PD   xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFMSUBADD321PD   ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFNMADD132PS     xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFNMADD132PS     ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFNMADD132PD     xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFNMADD132PD     ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFNMADD312PS     xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFNMADD312PS     ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFNMADD312PD     xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFNMADD312PD     ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFNMADD213PS     xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFNMADD213PS     ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFNMADD213PD     xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFNMADD213PD     ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFNMADD123PS     xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFNMADD123PS     ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFNMADD123PD     xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFNMADD123PD     ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFNMADD231PS     xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFNMADD231PS     ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFNMADD231PD     xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFNMADD231PD     ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFNMADD321PS     xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFNMADD321PS     ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFNMADD321PD     xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFNMADD321PD     ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFNMSUB132PS     xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFNMSUB132PS     ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFNMSUB132PD     xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFNMSUB132PD     ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFNMSUB312PS     xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFNMSUB312PS     ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFNMSUB312PD     xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFNMSUB312PD     ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFNMSUB213PS     xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFNMSUB213PS     ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFNMSUB213PD     xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFNMSUB213PD     ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFNMSUB123PS     xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFNMSUB123PS     ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFNMSUB123PD     xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFNMSUB123PD     ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFNMSUB231PS     xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFNMSUB231PS     ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFNMSUB231PD     xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFNMSUB231PD     ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFNMSUB321PS     xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFNMSUB321PS     ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFNMSUB321PD     xmmreg,xmmreg,xmmrm128   FMA,FUTURE
     VFNMSUB321PD     ymmreg,ymmreg,ymmrm256   FMA,FUTURE
     VFMADD132SS      xmmreg,xmmreg,xmmrm32    FMA,FUTURE
     VFMADD132SD      xmmreg,xmmreg,xmmrm64    FMA,FUTURE
     VFMADD312SS      xmmreg,xmmreg,xmmrm32    FMA,FUTURE
     VFMADD312SD      xmmreg,xmmreg,xmmrm64    FMA,FUTURE
     VFMADD213SS      xmmreg,xmmreg,xmmrm32    FMA,FUTURE
     VFMADD213SD      xmmreg,xmmreg,xmmrm64    FMA,FUTURE
     VFMADD123SS      xmmreg,xmmreg,xmmrm32    FMA,FUTURE
     VFMADD123SD      xmmreg,xmmreg,xmmrm64    FMA,FUTURE
     VFMADD231SS      xmmreg,xmmreg,xmmrm32    FMA,FUTURE
     VFMADD231SD      xmmreg,xmmreg,xmmrm64    FMA,FUTURE
     VFMADD321SS      xmmreg,xmmreg,xmmrm32    FMA,FUTURE
     VFMADD321SD      xmmreg,xmmreg,xmmrm64    FMA,FUTURE
     VFMSUB132SS      xmmreg,xmmreg,xmmrm32    FMA,FUTURE
     VFMSUB132SD      xmmreg,xmmreg,xmmrm64    FMA,FUTURE
     VFMSUB312SS      xmmreg,xmmreg,xmmrm32    FMA,FUTURE
     VFMSUB312SD      xmmreg,xmmreg,xmmrm64    FMA,FUTURE
     VFMSUB213SS      xmmreg,xmmreg,xmmrm32    FMA,FUTURE
     VFMSUB213SD      xmmreg,xmmreg,xmmrm64    FMA,FUTURE
     VFMSUB123SS      xmmreg,xmmreg,xmmrm32    FMA,FUTURE
     VFMSUB123SD      xmmreg,xmmreg,xmmrm64    FMA,FUTURE
     VFMSUB231SS      xmmreg,xmmreg,xmmrm32    FMA,FUTURE
     VFMSUB231SD      xmmreg,xmmreg,xmmrm64    FMA,FUTURE
     VFMSUB321SS      xmmreg,xmmreg,xmmrm32    FMA,FUTURE
     VFMSUB321SD      xmmreg,xmmreg,xmmrm64    FMA,FUTURE
     VFNMADD132SS     xmmreg,xmmreg,xmmrm32    FMA,FUTURE
     VFNMADD132SD     xmmreg,xmmreg,xmmrm64    FMA,FUTURE
     VFNMADD312SS     xmmreg,xmmreg,xmmrm32    FMA,FUTURE
     VFNMADD312SD     xmmreg,xmmreg,xmmrm64    FMA,FUTURE
     VFNMADD213SS     xmmreg,xmmreg,xmmrm32    FMA,FUTURE
     VFNMADD213SD     xmmreg,xmmreg,xmmrm64    FMA,FUTURE
     VFNMADD123SS     xmmreg,xmmreg,xmmrm32    FMA,FUTURE
     VFNMADD123SD     xmmreg,xmmreg,xmmrm64    FMA,FUTURE
     VFNMADD231SS     xmmreg,xmmreg,xmmrm32    FMA,FUTURE
     VFNMADD231SD     xmmreg,xmmreg,xmmrm64    FMA,FUTURE
     VFNMADD321SS     xmmreg,xmmreg,xmmrm32    FMA,FUTURE
     VFNMADD321SD     xmmreg,xmmreg,xmmrm64    FMA,FUTURE
     VFNMSUB132SS     xmmreg,xmmreg,xmmrm32    FMA,FUTURE
     VFNMSUB132SD     xmmreg,xmmreg,xmmrm64    FMA,FUTURE
     VFNMSUB312SS     xmmreg,xmmreg,xmmrm32    FMA,FUTURE
     VFNMSUB312SD     xmmreg,xmmreg,xmmrm64    FMA,FUTURE
     VFNMSUB213SS     xmmreg,xmmreg,xmmrm32    FMA,FUTURE
     VFNMSUB213SD     xmmreg,xmmreg,xmmrm64    FMA,FUTURE
     VFNMSUB123SS     xmmreg,xmmreg,xmmrm32    FMA,FUTURE
     VFNMSUB123SD     xmmreg,xmmreg,xmmrm64    FMA,FUTURE
     VFNMSUB231SS     xmmreg,xmmreg,xmmrm32    FMA,FUTURE
     VFNMSUB231SD     xmmreg,xmmreg,xmmrm64    FMA,FUTURE
     VFNMSUB321SS     xmmreg,xmmreg,xmmrm32    FMA,FUTURE
     VFNMSUB321SD     xmmreg,xmmreg,xmmrm64    FMA,FUTURE


File: nasm.info,  Node: Section B.1.29,  Next: Section B.1.30,  Prev: Section B.1.28,  Up: Section B.1

B.1.29. Intel post-32 nm processor instructions
-----------------------------------------------

     RDFSBASE         reg32                    LONG,FUTURE
     RDFSBASE         reg64                    LONG,FUTURE
     RDGSBASE         reg32                    LONG,FUTURE
     RDGSBASE         reg64                    LONG,FUTURE
     RDRAND           reg16                    FUTURE
     RDRAND           reg32                    FUTURE
     RDRAND           reg64                    LONG,FUTURE
     WRFSBASE         reg32                    LONG,FUTURE
     WRFSBASE         reg64                    LONG,FUTURE
     WRGSBASE         reg32                    LONG,FUTURE
     WRGSBASE         reg64                    LONG,FUTURE
     VCVTPH2PS        ymmreg,xmmrm128          AVX,FUTURE
     VCVTPH2PS        xmmreg,xmmrm64           AVX,FUTURE
     VCVTPS2PH        xmmrm128,ymmreg,imm8     AVX,FUTURE
     VCVTPS2PH        xmmrm64,xmmreg,imm8      AVX,FUTURE
     ADCX             reg32,rm32               FUTURE
     ADCX             reg64,rm64               LONG,FUTURE
     ADOX             reg32,rm32               FUTURE
     ADOX             reg64,rm64               LONG,FUTURE
     RDSEED           reg16                    FUTURE
     RDSEED           reg32                    FUTURE
     RDSEED           reg64                    LONG,FUTURE
     CLAC                                      PRIV,FUTURE
     STAC                                      PRIV,FUTURE


File: nasm.info,  Node: Section B.1.30,  Next: Section B.1.31,  Prev: Section B.1.29,  Up: Section B.1

B.1.30. VIA (Centaur) security instructions
-------------------------------------------

     XSTORE                                    PENT,CYRIX
     XCRYPTECB                                 PENT,CYRIX
     XCRYPTCBC                                 PENT,CYRIX
     XCRYPTCTR                                 PENT,CYRIX
     XCRYPTCFB                                 PENT,CYRIX
     XCRYPTOFB                                 PENT,CYRIX
     MONTMUL                                   PENT,CYRIX
     XSHA1                                     PENT,CYRIX
     XSHA256                                   PENT,CYRIX


File: nasm.info,  Node: Section B.1.31,  Next: Section B.1.32,  Prev: Section B.1.30,  Up: Section B.1

B.1.31. AMD Lightweight Profiling (LWP) instructions
----------------------------------------------------

     LLWPCB           reg32                    AMD,386
     LLWPCB           reg64                    AMD,X64
     SLWPCB           reg32                    AMD,386
     SLWPCB           reg64                    AMD,X64
     LWPVAL           reg32,rm32,imm32         AMD,386
     LWPVAL           reg64,rm32,imm32         AMD,X64
     LWPINS           reg32,rm32,imm32         AMD,386
     LWPINS           reg64,rm32,imm32         AMD,X64


File: nasm.info,  Node: Section B.1.32,  Next: Section B.1.33,  Prev: Section B.1.31,  Up: Section B.1

B.1.32. AMD XOP and FMA4 instructions (SSE5)
--------------------------------------------

     VFMADDPD         xmmreg,xmmreg*,xmmrm128,xmmreg AMD,SSE5
     VFMADDPD         ymmreg,ymmreg*,ymmrm256,ymmreg AMD,SSE5
     VFMADDPD         xmmreg,xmmreg*,xmmreg,xmmrm128 AMD,SSE5
     VFMADDPD         ymmreg,ymmreg*,ymmreg,ymmrm256 AMD,SSE5
     VFMADDPS         xmmreg,xmmreg*,xmmrm128,xmmreg AMD,SSE5
     VFMADDPS         ymmreg,ymmreg*,ymmrm256,ymmreg AMD,SSE5
     VFMADDPS         xmmreg,xmmreg*,xmmreg,xmmrm128 AMD,SSE5
     VFMADDPS         ymmreg,ymmreg*,ymmreg,ymmrm256 AMD,SSE5
     VFMADDSD         xmmreg,xmmreg*,xmmrm64,xmmreg AMD,SSE5
     VFMADDSD         xmmreg,xmmreg*,xmmreg,xmmrm64 AMD,SSE5
     VFMADDSS         xmmreg,xmmreg*,xmmrm32,xmmreg AMD,SSE5
     VFMADDSS         xmmreg,xmmreg*,xmmreg,xmmrm32 AMD,SSE5
     VFMADDSUBPD      xmmreg,xmmreg*,xmmrm128,xmmreg AMD,SSE5
     VFMADDSUBPD      ymmreg,ymmreg*,ymmrm256,ymmreg AMD,SSE5
     VFMADDSUBPD      xmmreg,xmmreg*,xmmreg,xmmrm128 AMD,SSE5
     VFMADDSUBPD      ymmreg,ymmreg*,ymmreg,ymmrm256 AMD,SSE5
     VFMADDSUBPS      xmmreg,xmmreg*,xmmrm128,xmmreg AMD,SSE5
     VFMADDSUBPS      ymmreg,ymmreg*,ymmrm256,ymmreg AMD,SSE5
     VFMADDSUBPS      xmmreg,xmmreg*,xmmreg,xmmrm128 AMD,SSE5
     VFMADDSUBPS      ymmreg,ymmreg*,ymmreg,ymmrm256 AMD,SSE5
     VFMSUBADDPD      xmmreg,xmmreg*,xmmrm128,xmmreg AMD,SSE5
     VFMSUBADDPD      ymmreg,ymmreg*,ymmrm256,ymmreg AMD,SSE5
     VFMSUBADDPD      xmmreg,xmmreg*,xmmreg,xmmrm128 AMD,SSE5
     VFMSUBADDPD      ymmreg,ymmreg*,ymmreg,ymmrm256 AMD,SSE5
     VFMSUBADDPS      xmmreg,xmmreg*,xmmrm128,xmmreg AMD,SSE5
     VFMSUBADDPS      ymmreg,ymmreg*,ymmrm256,ymmreg AMD,SSE5
     VFMSUBADDPS      xmmreg,xmmreg*,xmmreg,xmmrm128 AMD,SSE5
     VFMSUBADDPS      ymmreg,ymmreg*,ymmreg,ymmrm256 AMD,SSE5
     VFMSUBPD         xmmreg,xmmreg*,xmmrm128,xmmreg AMD,SSE5
     VFMSUBPD         ymmreg,ymmreg*,ymmrm256,ymmreg AMD,SSE5
     VFMSUBPD         xmmreg,xmmreg*,xmmreg,xmmrm128 AMD,SSE5
     VFMSUBPD         ymmreg,ymmreg*,ymmreg,ymmrm256 AMD,SSE5
     VFMSUBPS         xmmreg,xmmreg*,xmmrm128,xmmreg AMD,SSE5
     VFMSUBPS         ymmreg,ymmreg*,ymmrm256,ymmreg AMD,SSE5
     VFMSUBPS         xmmreg,xmmreg*,xmmreg,xmmrm128 AMD,SSE5
     VFMSUBPS         ymmreg,ymmreg*,ymmreg,ymmrm256 AMD,SSE5
     VFMSUBSD         xmmreg,xmmreg*,xmmrm64,xmmreg AMD,SSE5
     VFMSUBSD         xmmreg,xmmreg*,xmmreg,xmmrm64 AMD,SSE5
     VFMSUBSS         xmmreg,xmmreg*,xmmrm32,xmmreg AMD,SSE5
     VFMSUBSS         xmmreg,xmmreg*,xmmreg,xmmrm32 AMD,SSE5
     VFNMADDPD        xmmreg,xmmreg*,xmmrm128,xmmreg AMD,SSE5
     VFNMADDPD        ymmreg,ymmreg*,ymmrm256,ymmreg AMD,SSE5
     VFNMADDPD        xmmreg,xmmreg*,xmmreg,xmmrm128 AMD,SSE5
     VFNMADDPD        ymmreg,ymmreg*,ymmreg,ymmrm256 AMD,SSE5
     VFNMADDPS        xmmreg,xmmreg*,xmmrm128,xmmreg AMD,SSE5
     VFNMADDPS        ymmreg,ymmreg*,ymmrm256,ymmreg AMD,SSE5
     VFNMADDPS        xmmreg,xmmreg*,xmmreg,xmmrm128 AMD,SSE5
     VFNMADDPS        ymmreg,ymmreg*,ymmreg,ymmrm256 AMD,SSE5
     VFNMADDSD        xmmreg,xmmreg*,xmmrm64,xmmreg AMD,SSE5
     VFNMADDSD        xmmreg,xmmreg*,xmmreg,xmmrm64 AMD,SSE5
     VFNMADDSS        xmmreg,xmmreg*,xmmrm32,xmmreg AMD,SSE5
     VFNMADDSS        xmmreg,xmmreg*,xmmreg,xmmrm32 AMD,SSE5
     VFNMSUBPD        xmmreg,xmmreg*,xmmrm128,xmmreg AMD,SSE5
     VFNMSUBPD        ymmreg,ymmreg*,ymmrm256,ymmreg AMD,SSE5
     VFNMSUBPD        xmmreg,xmmreg*,xmmreg,xmmrm128 AMD,SSE5
     VFNMSUBPD        ymmreg,ymmreg*,ymmreg,ymmrm256 AMD,SSE5
     VFNMSUBPS        xmmreg,xmmreg*,xmmrm128,xmmreg AMD,SSE5
     VFNMSUBPS        ymmreg,ymmreg*,ymmrm256,ymmreg AMD,SSE5
     VFNMSUBPS        xmmreg,xmmreg*,xmmreg,xmmrm128 AMD,SSE5
     VFNMSUBPS        ymmreg,ymmreg*,ymmreg,ymmrm256 AMD,SSE5
     VFNMSUBSD        xmmreg,xmmreg*,xmmrm64,xmmreg AMD,SSE5
     VFNMSUBSD        xmmreg,xmmreg*,xmmreg,xmmrm64 AMD,SSE5
     VFNMSUBSS        xmmreg,xmmreg*,xmmrm32,xmmreg AMD,SSE5
     VFNMSUBSS        xmmreg,xmmreg*,xmmreg,xmmrm32 AMD,SSE5
     VFRCZPD          xmmreg,xmmrm128*         AMD,SSE5
     VFRCZPD          ymmreg,ymmrm256*         AMD,SSE5
     VFRCZPS          xmmreg,xmmrm128*         AMD,SSE5
     VFRCZPS          ymmreg,ymmrm256*         AMD,SSE5
     VFRCZSD          xmmreg,xmmrm64*          AMD,SSE5
     VFRCZSS          xmmreg,xmmrm32*          AMD,SSE5
     VPCMOV           xmmreg,xmmreg*,xmmrm128,xmmreg AMD,SSE5
     VPCMOV           ymmreg,ymmreg*,ymmrm256,ymmreg AMD,SSE5
     VPCMOV           xmmreg,xmmreg*,xmmreg,xmmrm128 AMD,SSE5
     VPCMOV           ymmreg,ymmreg*,ymmreg,ymmrm256 AMD,SSE5
     VPCOMB           xmmreg,xmmreg*,xmmrm128,imm8 AMD,SSE5
     VPCOMD           xmmreg,xmmreg*,xmmrm128,imm8 AMD,SSE5
     VPCOMQ           xmmreg,xmmreg*,xmmrm128,imm8 AMD,SSE5
     VPCOMUB          xmmreg,xmmreg*,xmmrm128,imm8 AMD,SSE5
     VPCOMUD          xmmreg,xmmreg*,xmmrm128,imm8 AMD,SSE5
     VPCOMUQ          xmmreg,xmmreg*,xmmrm128,imm8 AMD,SSE5
     VPCOMUW          xmmreg,xmmreg*,xmmrm128,imm8 AMD,SSE5
     VPCOMW           xmmreg,xmmreg*,xmmrm128,imm8 AMD,SSE5
     VPHADDBD         xmmreg,xmmrm128*         AMD,SSE5
     VPHADDBQ         xmmreg,xmmrm128*         AMD,SSE5
     VPHADDBW         xmmreg,xmmrm128*         AMD,SSE5
     VPHADDDQ         xmmreg,xmmrm128*         AMD,SSE5
     VPHADDUBD        xmmreg,xmmrm128*         AMD,SSE5
     VPHADDUBQ        xmmreg,xmmrm128*         AMD,SSE5
     VPHADDUBW        xmmreg,xmmrm128*         AMD,SSE5
     VPHADDUDQ        xmmreg,xmmrm128*         AMD,SSE5
     VPHADDUWD        xmmreg,xmmrm128*         AMD,SSE5
     VPHADDUWQ        xmmreg,xmmrm128*         AMD,SSE5
     VPHADDWD         xmmreg,xmmrm128*         AMD,SSE5
     VPHADDWQ         xmmreg,xmmrm128*         AMD,SSE5
     VPHSUBBW         xmmreg,xmmrm128*         AMD,SSE5
     VPHSUBDQ         xmmreg,xmmrm128*         AMD,SSE5
     VPHSUBWD         xmmreg,xmmrm128*         AMD,SSE5
     VPMACSDD         xmmreg,xmmreg*,xmmrm128,xmmreg AMD,SSE5
     VPMACSDQH        xmmreg,xmmreg*,xmmrm128,xmmreg AMD,SSE5
     VPMACSDQL        xmmreg,xmmreg*,xmmrm128,xmmreg AMD,SSE5
     VPMACSSDD        xmmreg,xmmreg*,xmmrm128,xmmreg AMD,SSE5
     VPMACSSDQH       xmmreg,xmmreg*,xmmrm128,xmmreg AMD,SSE5
     VPMACSSDQL       xmmreg,xmmreg*,xmmrm128,xmmreg AMD,SSE5
     VPMACSSWD        xmmreg,xmmreg*,xmmrm128,xmmreg AMD,SSE5
     VPMACSSWW        xmmreg,xmmreg*,xmmrm128,xmmreg AMD,SSE5
     VPMACSWD         xmmreg,xmmreg*,xmmrm128,xmmreg AMD,SSE5
     VPMACSWW         xmmreg,xmmreg*,xmmrm128,xmmreg AMD,SSE5
     VPMADCSSWD       xmmreg,xmmreg*,xmmrm128,xmmreg AMD,SSE5
     VPMADCSWD        xmmreg,xmmreg*,xmmrm128,xmmreg AMD,SSE5
     VPPERM           xmmreg,xmmreg*,xmmreg,xmmrm128 AMD,SSE5
     VPPERM           xmmreg,xmmreg*,xmmrm128,xmmreg AMD,SSE5
     VPROTB           xmmreg,xmmrm128*,xmmreg  AMD,SSE5
     VPROTB           xmmreg,xmmreg*,xmmrm128  AMD,SSE5
     VPROTB           xmmreg,xmmrm128*,imm8    AMD,SSE5
     VPROTD           xmmreg,xmmrm128*,xmmreg  AMD,SSE5
     VPROTD           xmmreg,xmmreg*,xmmrm128  AMD,SSE5
     VPROTD           xmmreg,xmmrm128*,imm8    AMD,SSE5
     VPROTQ           xmmreg,xmmrm128*,xmmreg  AMD,SSE5
     VPROTQ           xmmreg,xmmreg*,xmmrm128  AMD,SSE5
     VPROTQ           xmmreg,xmmrm128*,imm8    AMD,SSE5
     VPROTW           xmmreg,xmmrm128*,xmmreg  AMD,SSE5
     VPROTW           xmmreg,xmmreg*,xmmrm128  AMD,SSE5
     VPROTW           xmmreg,xmmrm128*,imm8    AMD,SSE5
     VPSHAB           xmmreg,xmmrm128*,xmmreg  AMD,SSE5
     VPSHAB           xmmreg,xmmreg*,xmmrm128  AMD,SSE5
     VPSHAD           xmmreg,xmmrm128*,xmmreg  AMD,SSE5
     VPSHAD           xmmreg,xmmreg*,xmmrm128  AMD,SSE5
     VPSHAQ           xmmreg,xmmrm128*,xmmreg  AMD,SSE5
     VPSHAQ           xmmreg,xmmreg*,xmmrm128  AMD,SSE5
     VPSHAW           xmmreg,xmmrm128*,xmmreg  AMD,SSE5
     VPSHAW           xmmreg,xmmreg*,xmmrm128  AMD,SSE5
     VPSHLB           xmmreg,xmmrm128*,xmmreg  AMD,SSE5
     VPSHLB           xmmreg,xmmreg*,xmmrm128  AMD,SSE5
     VPSHLD           xmmreg,xmmrm128*,xmmreg  AMD,SSE5
     VPSHLD           xmmreg,xmmreg*,xmmrm128  AMD,SSE5
     VPSHLQ           xmmreg,xmmrm128*,xmmreg  AMD,SSE5
     VPSHLQ           xmmreg,xmmreg*,xmmrm128  AMD,SSE5
     VPSHLW           xmmreg,xmmrm128*,xmmreg  AMD,SSE5
     VPSHLW           xmmreg,xmmreg*,xmmrm128  AMD,SSE5


File: nasm.info,  Node: Section B.1.33,  Next: Section B.1.34,  Prev: Section B.1.32,  Up: Section B.1

B.1.33. Intel AVX2 instructions
-------------------------------

     VMPSADBW         ymmreg,ymmreg*,ymmrm256,imm8 FUTURE,AVX2
     VPABSB           ymmreg,ymmrm256          FUTURE,AVX2
     VPABSW           ymmreg,ymmrm256          FUTURE,AVX2
     VPABSD           ymmreg,ymmrm256          FUTURE,AVX2
     VPACKSSWB        ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPACKSSDW        ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPACKUSDW        ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPACKUSWB        ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPADDB           ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPADDW           ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPADDD           ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPADDQ           ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPADDSB          ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPADDSW          ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPADDUSB         ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPADDUSW         ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPALIGNR         ymmreg,ymmreg*,ymmrm256,imm8 FUTURE,AVX2
     VPAND            ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPANDN           ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPAVGB           ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPAVGW           ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPBLENDVB        ymmreg,ymmreg*,ymmrm256,ymmreg FUTURE,AVX2
     VPBLENDW         ymmreg,ymmreg*,ymmrm256,imm8 FUTURE,AVX2
     VPCMPEQB         ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPCMPEQW         ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPCMPEQD         ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPCMPEQQ         ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPCMPGTB         ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPCMPGTW         ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPCMPGTD         ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPCMPGTQ         ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPHADDW          ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPHADDD          ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPHADDSW         ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPHSUBW          ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPHSUBD          ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPHSUBSW         ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPMADDUBSW       ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPMADDWD         ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPMAXSB          ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPMAXSW          ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPMAXSD          ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPMAXUB          ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPMAXUW          ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPMAXUD          ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPMINSB          ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPMINSW          ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPMINSD          ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPMINUB          ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPMINUW          ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPMINUD          ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPMOVMSKB        reg32,ymmreg             FUTURE,AVX2
     VPMOVMSKB        reg64,ymmreg             FUTURE,AVX2
     VPMOVSXBW        ymmreg,xmmrm128          FUTURE,AVX2
     VPMOVSXBD        ymmreg,mem64             FUTURE,AVX2
     VPMOVSXBD        ymmreg,xmmreg            FUTURE,AVX2
     VPMOVSXBQ        ymmreg,mem32             FUTURE,AVX2
     VPMOVSXBQ        ymmreg,xmmreg            FUTURE,AVX2
     VPMOVSXWD        ymmreg,xmmrm128          FUTURE,AVX2
     VPMOVSXWQ        ymmreg,mem64             FUTURE,AVX2
     VPMOVSXWQ        ymmreg,xmmreg            FUTURE,AVX2
     VPMOVSXDQ        ymmreg,xmmrm128          FUTURE,AVX2
     VPMOVZXBW        ymmreg,xmmrm128          FUTURE,AVX2
     VPMOVZXBD        ymmreg,mem64             FUTURE,AVX2
     VPMOVZXBD        ymmreg,xmmreg            FUTURE,AVX2
     VPMOVZXBQ        ymmreg,mem32             FUTURE,AVX2
     VPMOVZXBQ        ymmreg,xmmreg            FUTURE,AVX2
     VPMOVZXWD        ymmreg,xmmrm128          FUTURE,AVX2
     VPMOVZXWQ        ymmreg,mem64             FUTURE,AVX2
     VPMOVZXWQ        ymmreg,xmmreg            FUTURE,AVX2
     VPMOVZXDQ        ymmreg,xmmrm128          FUTURE,AVX2
     VPMULDQ          ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPMULHRSW        ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPMULHUW         ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPMULHW          ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPMULLW          ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPMULLD          ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPMULUDQ         ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPOR             ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPSADBW          ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPSHUFB          ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPSHUFD          ymmreg,ymmrm256,imm8     FUTURE,AVX2
     VPSHUFHW         ymmreg,ymmrm256,imm8     FUTURE,AVX2
     VPSHUFLW         ymmreg,ymmrm256,imm8     FUTURE,AVX2
     VPSIGNB          ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPSIGNW          ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPSIGND          ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPSLLDQ          ymmreg,ymmreg*,imm8      FUTURE,AVX2
     VPSLLW           ymmreg,ymmreg*,xmmrm128  FUTURE,AVX2
     VPSLLW           ymmreg,ymmreg*,imm8      FUTURE,AVX2
     VPSLLD           ymmreg,ymmreg*,xmmrm128  FUTURE,AVX2
     VPSLLD           ymmreg,ymmreg*,imm8      FUTURE,AVX2
     VPSLLQ           ymmreg,ymmreg*,xmmrm128  FUTURE,AVX2
     VPSLLQ           ymmreg,ymmreg*,imm8      FUTURE,AVX2
     VPSRAW           ymmreg,ymmreg*,xmmrm128  FUTURE,AVX2
     VPSRAW           ymmreg,ymmreg*,imm8      FUTURE,AVX2
     VPSRAD           ymmreg,ymmreg*,xmmrm128  FUTURE,AVX2
     VPSRAD           ymmreg,ymmreg*,imm8      FUTURE,AVX2
     VPSRLDQ          ymmreg,ymmreg*,imm8      FUTURE,AVX2
     VPSRLW           ymmreg,ymmreg*,xmmrm128  FUTURE,AVX2
     VPSRLW           ymmreg,ymmreg*,imm8      FUTURE,AVX2
     VPSRLD           ymmreg,ymmreg*,xmmrm128  FUTURE,AVX2
     VPSRLD           ymmreg,ymmreg*,imm8      FUTURE,AVX2
     VPSRLQ           ymmreg,ymmreg*,xmmrm128  FUTURE,AVX2
     VPSRLQ           ymmreg,ymmreg*,imm8      FUTURE,AVX2
     VPSUBB           ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPSUBW           ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPSUBD           ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPSUBQ           ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPSUBSB          ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPSUBSW          ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPSUBUSB         ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPSUBUSW         ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPUNPCKHBW       ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPUNPCKHWD       ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPUNPCKHDQ       ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPUNPCKHQDQ      ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPUNPCKLBW       ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPUNPCKLWD       ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPUNPCKLDQ       ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPUNPCKLQDQ      ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPXOR            ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VMOVNTDQA        ymmreg,mem256            FUTURE,AVX2
     VBROADCASTSS     xmmreg,xmmreg            FUTURE,AVX2
     VBROADCASTSS     ymmreg,xmmreg            FUTURE,AVX2
     VBROADCASTSD     ymmreg,xmmreg            FUTURE,AVX2
     VBROADCASTI128   ymmreg,mem128            FUTURE,AVX2
     VPBLENDD         xmmreg,xmmreg*,xmmrm128,imm8 FUTURE,AVX2
     VPBLENDD         ymmreg,ymmreg*,ymmrm256,imm8 FUTURE,AVX2
     VPBROADCASTB     xmmreg,mem8              FUTURE,AVX2
     VPBROADCASTB     xmmreg,xmmreg            FUTURE,AVX2
     VPBROADCASTB     ymmreg,mem8              FUTURE,AVX2
     VPBROADCASTB     ymmreg,xmmreg            FUTURE,AVX2
     VPBROADCASTW     xmmreg,mem16             FUTURE,AVX2
     VPBROADCASTW     xmmreg,xmmreg            FUTURE,AVX2
     VPBROADCASTW     ymmreg,mem16             FUTURE,AVX2
     VPBROADCASTW     ymmreg,xmmreg            FUTURE,AVX2
     VPBROADCASTD     xmmreg,mem32             FUTURE,AVX2
     VPBROADCASTD     xmmreg,xmmreg            FUTURE,AVX2
     VPBROADCASTD     ymmreg,mem32             FUTURE,AVX2
     VPBROADCASTD     ymmreg,xmmreg            FUTURE,AVX2
     VPBROADCASTQ     xmmreg,mem64             FUTURE,AVX2
     VPBROADCASTQ     xmmreg,xmmreg            FUTURE,AVX2
     VPBROADCASTQ     ymmreg,mem64             FUTURE,AVX2
     VPBROADCASTQ     ymmreg,xmmreg            FUTURE,AVX2
     VPERMD           ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPERMPD          ymmreg,ymmrm256,imm8     FUTURE,AVX2
     VPERMPS          ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPERMQ           ymmreg,ymmrm256,imm8     FUTURE,AVX2
     VPERM2I128       ymmreg,ymmreg,ymmrm256,imm8 FUTURE,AVX2
     VEXTRACTI128     xmmrm128,ymmreg,imm8     FUTURE,AVX2
     VINSERTI128      ymmreg,ymmreg*,xmmrm128,imm8 FUTURE,AVX2
     VPMASKMOVD       xmmreg,xmmreg*,mem128    FUTURE,AVX2
     VPMASKMOVD       ymmreg,ymmreg*,mem256    FUTURE,AVX2
     VPMASKMOVQ       xmmreg,xmmreg*,mem128    FUTURE,AVX2
     VPMASKMOVQ       ymmreg,ymmreg*,mem256    FUTURE,AVX2
     VPMASKMOVD       mem128,xmmreg*,xmmreg    FUTURE,AVX2
     VPMASKMOVD       mem256,ymmreg*,ymmreg    FUTURE,AVX2
     VPMASKMOVQ       mem128,xmmreg*,xmmreg    FUTURE,AVX2
     VPMASKMOVQ       mem256,ymmreg*,ymmreg    FUTURE,AVX2
     VPSLLVD          xmmreg,xmmreg*,xmmrm128  FUTURE,AVX2
     VPSLLVQ          xmmreg,xmmreg*,xmmrm128  FUTURE,AVX2
     VPSLLVD          ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPSLLVQ          ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPSRAVD          xmmreg,xmmreg*,xmmrm128  FUTURE,AVX2
     VPSRAVD          ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPSRLVD          xmmreg,xmmreg*,xmmrm128  FUTURE,AVX2
     VPSRLVQ          xmmreg,xmmreg*,xmmrm128  FUTURE,AVX2
     VPSRLVD          ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VPSRLVQ          ymmreg,ymmreg*,ymmrm256  FUTURE,AVX2
     VGATHERDPD       xmmreg,xmem64,xmmreg     FUTURE,AVX2
     VGATHERQPD       xmmreg,xmem64,xmmreg     FUTURE,AVX2
     VGATHERDPD       ymmreg,xmem64,ymmreg     FUTURE,AVX2
     VGATHERQPD       ymmreg,ymem64,ymmreg     FUTURE,AVX2
     VGATHERDPS       xmmreg,xmem32,xmmreg     FUTURE,AVX2
     VGATHERQPS       xmmreg,xmem32,xmmreg     FUTURE,AVX2
     VGATHERDPS       ymmreg,ymem32,ymmreg     FUTURE,AVX2
     VGATHERQPS       xmmreg,ymem32,xmmreg     FUTURE,AVX2
     VPGATHERDD       xmmreg,xmem32,xmmreg     FUTURE,AVX2
     VPGATHERQD       xmmreg,xmem32,xmmreg     FUTURE,AVX2
     VPGATHERDD       ymmreg,ymem32,ymmreg     FUTURE,AVX2
     VPGATHERQD       xmmreg,ymem32,xmmreg     FUTURE,AVX2
     VPGATHERDQ       xmmreg,xmem64,xmmreg     FUTURE,AVX2
     VPGATHERQQ       xmmreg,xmem64,xmmreg     FUTURE,AVX2
     VPGATHERDQ       ymmreg,xmem64,ymmreg     FUTURE,AVX2
     VPGATHERQQ       ymmreg,ymem64,ymmreg     FUTURE,AVX2


File: nasm.info,  Node: Section B.1.34,  Next: Section B.1.35,  Prev: Section B.1.33,  Up: Section B.1

B.1.34. Transactional Synchronization Extensions (TSX)
------------------------------------------------------

     XABORT           imm                      FUTURE,RTM
     XABORT           imm8                     FUTURE,RTM
     XBEGIN           imm                      FUTURE,RTM
     XBEGIN           imm|near                 FUTURE,RTM,ND
     XBEGIN           imm16                    FUTURE,RTM,NOLONG
     XBEGIN           imm16|near               FUTURE,RTM,NOLONG,ND
     XBEGIN           imm32                    FUTURE,RTM,NOLONG
     XBEGIN           imm32|near               FUTURE,RTM,NOLONG,ND
     XBEGIN           imm64                    FUTURE,RTM,LONG
     XBEGIN           imm64|near               FUTURE,RTM,LONG,ND
     XEND                                      FUTURE,RTM
     XTEST                                     FUTURE,HLE,RTM


File: nasm.info,  Node: Section B.1.35,  Next: Section B.1.36,  Prev: Section B.1.34,  Up: Section B.1

B.1.35. Intel BMI1 and BMI2 instructions, AMD TBM instructions
--------------------------------------------------------------

     ANDN             reg32,reg32,rm32         FUTURE,BMI1
     ANDN             reg64,reg64,rm64         LONG,FUTURE,BMI1
     BEXTR            reg32,rm32,reg32         FUTURE,BMI1
     BEXTR            reg64,rm64,reg64         LONG,FUTURE,BMI1
     BEXTR            reg32,rm32,imm32         FUTURE,TBM
     BEXTR            reg64,rm64,imm32         LONG,FUTURE,TBM
     BLCI             reg32,rm32               FUTURE,TBM
     BLCI             reg64,rm64               LONG,FUTURE,TBM
     BLCIC            reg32,rm32               FUTURE,TBM
     BLCIC            reg64,rm64               LONG,FUTURE,TBM
     BLSI             reg32,rm32               FUTURE,BMI1
     BLSI             reg64,rm64               LONG,FUTURE,BMI1
     BLSIC            reg32,rm32               FUTURE,TBM
     BLSIC            reg64,rm64               LONG,FUTURE,TBM
     BLCFILL          reg32,rm32               FUTURE,TBM
     BLCFILL          reg64,rm64               LONG,FUTURE,TBM
     BLSFILL          reg32,rm32               FUTURE,TBM
     BLSFILL          reg64,rm64               LONG,FUTURE,TBM
     BLCMSK           reg32,rm32               FUTURE,TBM
     BLCMSK           reg64,rm64               LONG,FUTURE,TBM
     BLSMSK           reg32,rm32               FUTURE,BMI1
     BLSMSK           reg64,rm64               LONG,FUTURE,BMI1
     BLSR             reg32,rm32               FUTURE,BMI1
     BLSR             reg64,rm64               LONG,FUTURE,BMI1
     BLCS             reg32,rm32               FUTURE,TBM
     BLCS             reg64,rm64               LONG,FUTURE,TBM
     BZHI             reg32,rm32,reg32         FUTURE,BMI2
     BZHI             reg64,rm64,reg64         LONG,FUTURE,BMI2
     MULX             reg32,reg32,rm32         FUTURE,BMI2
     MULX             reg64,reg64,rm64         LONG,FUTURE,BMI2
     PDEP             reg32,reg32,rm32         FUTURE,BMI2
     PDEP             reg64,reg64,rm64         LONG,FUTURE,BMI2
     PEXT             reg32,reg32,rm32         FUTURE,BMI2
     PEXT             reg64,reg64,rm64         LONG,FUTURE,BMI2
     RORX             reg32,rm32,imm8          FUTURE,BMI2
     RORX             reg64,rm64,imm8          LONG,FUTURE,BMI2
     SARX             reg32,rm32,reg32         FUTURE,BMI2
     SARX             reg64,rm64,reg64         LONG,FUTURE,BMI2
     SHLX             reg32,rm32,reg32         FUTURE,BMI2
     SHLX             reg64,rm64,reg64         LONG,FUTURE,BMI2
     SHRX             reg32,rm32,reg32         FUTURE,BMI2
     SHRX             reg64,rm64,reg64         LONG,FUTURE,BMI2
     TZCNT            reg16,rm16               FUTURE,BMI1
     TZCNT            reg32,rm32               FUTURE,BMI1
     TZCNT            reg64,rm64               LONG,FUTURE,BMI1
     TZMSK            reg32,rm32               FUTURE,TBM
     TZMSK            reg64,rm64               LONG,FUTURE,TBM
     T1MSKC           reg32,rm32               FUTURE,TBM
     T1MSKC           reg64,rm64               LONG,FUTURE,TBM
     PREFETCHWT1      mem8                     PREFETCHWT1,FUTURE
     BNDMK            bndreg,mem               MPX,MIB,FUTURE
     BNDCL            bndreg,mem               MPX,FUTURE
     BNDCL            bndreg,reg32             MPX,NOLONG,FUTURE
     BNDCL            bndreg,reg64             MPX,LONG,FUTURE
     BNDCU            bndreg,mem               MPX,FUTURE
     BNDCU            bndreg,reg32             MPX,NOLONG,FUTURE
     BNDCU            bndreg,reg64             MPX,LONG,FUTURE
     BNDCN            bndreg,mem               MPX,FUTURE
     BNDCN            bndreg,reg32             MPX,NOLONG,FUTURE
     BNDCN            bndreg,reg64             MPX,LONG,FUTURE
     BNDMOV           bndreg,bndreg            MPX,FUTURE
     BNDMOV           bndreg,mem               MPX,FUTURE
     BNDMOV           bndreg,bndreg            MPX,FUTURE
     BNDMOV           mem,bndreg               MPX,FUTURE
     BNDLDX           bndreg,mem               MPX,MIB,FUTURE
     BNDLDX           bndreg,mem,reg32         MPX,MIB,NOLONG,FUTURE
     BNDLDX           bndreg,mem,reg64         MPX,MIB,LONG,FUTURE
     BNDSTX           mem,bndreg               MPX,MIB,FUTURE
     BNDSTX           mem,reg32,bndreg         MPX,MIB,NOLONG,FUTURE
     BNDSTX           mem,reg64,bndreg         MPX,MIB,LONG,FUTURE
     BNDSTX           mem,bndreg,reg32         MPX,MIB,NOLONG,FUTURE
     BNDSTX           mem,bndreg,reg64         MPX,MIB,LONG,FUTURE


File: nasm.info,  Node: Section B.1.36,  Next: Section B.1.37,  Prev: Section B.1.35,  Up: Section B.1

B.1.36. MJC PUBLIC BEGIN
------------------------

     KADDB            kreg,kreg,kreg           FUTURE
     KADDD            kreg,kreg,kreg           FUTURE
     KADDQ            kreg,kreg,kreg           FUTURE
     KADDW            kreg,kreg,kreg           FUTURE
     KANDB            kreg,kreg,kreg           FUTURE
     KANDD            kreg,kreg,kreg           FUTURE
     KANDNB           kreg,kreg,kreg           FUTURE
     KANDND           kreg,kreg,kreg           FUTURE
     KANDNQ           kreg,kreg,kreg           FUTURE
     KANDNW           kreg,kreg,kreg           FUTURE
     KANDQ            kreg,kreg,kreg           FUTURE
     KANDW            kreg,kreg,kreg           FUTURE
     KMOVB            kreg,krm8                FUTURE
     KMOVB            mem8,kreg                FUTURE
     KMOVB            kreg,reg32               FUTURE
     KMOVB            reg32,kreg               FUTURE
     KMOVD            kreg,krm32               FUTURE
     KMOVD            mem32,kreg               FUTURE
     KMOVD            kreg,reg32               FUTURE
     KMOVD            reg32,kreg               FUTURE
     KMOVQ            kreg,krm64               FUTURE
     KMOVQ            mem64,kreg               FUTURE
     KMOVQ            kreg,reg64               FUTURE
     KMOVQ            reg64,kreg               FUTURE
     KMOVW            kreg,krm16               FUTURE
     KMOVW            mem16,kreg               FUTURE
     KMOVW            kreg,reg32               FUTURE
     KMOVW            reg32,kreg               FUTURE
     KNOTB            kreg,kreg                FUTURE
     KNOTD            kreg,kreg                FUTURE
     KNOTQ            kreg,kreg                FUTURE
     KNOTW            kreg,kreg                FUTURE
     KORB             kreg,kreg,kreg           FUTURE
     KORD             kreg,kreg,kreg           FUTURE
     KORQ             kreg,kreg,kreg           FUTURE
     KORTESTB         kreg,kreg                FUTURE
     KORTESTD         kreg,kreg                FUTURE
     KORTESTQ         kreg,kreg                FUTURE
     KORTESTW         kreg,kreg                FUTURE
     KORW             kreg,kreg,kreg           FUTURE
     KSHIFTLB         kreg,kreg,imm8           FUTURE
     KSHIFTLD         kreg,kreg,imm8           FUTURE
     KSHIFTLQ         kreg,kreg,imm8           FUTURE
     KSHIFTLW         kreg,kreg,imm8           FUTURE
     KSHIFTRB         kreg,kreg,imm8           FUTURE
     KSHIFTRD         kreg,kreg,imm8           FUTURE
     KSHIFTRQ         kreg,kreg,imm8           FUTURE
     KSHIFTRW         kreg,kreg,imm8           FUTURE
     KTESTB           kreg,kreg                FUTURE
     KTESTD           kreg,kreg                FUTURE
     KTESTQ           kreg,kreg                FUTURE
     KTESTW           kreg,kreg                FUTURE
     KUNPCKBW         kreg,kreg,kreg           FUTURE
     KUNPCKDQ         kreg,kreg,kreg           FUTURE
     KUNPCKWD         kreg,kreg,kreg           FUTURE
     KXNORB           kreg,kreg,kreg           FUTURE
     KXNORD           kreg,kreg,kreg           FUTURE
     KXNORQ           kreg,kreg,kreg           FUTURE
     KXNORW           kreg,kreg,kreg           FUTURE
     KXORB            kreg,kreg,kreg           FUTURE
     KXORD            kreg,kreg,kreg           FUTURE
     KXORQ            kreg,kreg,kreg           FUTURE
     KXORW            kreg,kreg,kreg           FUTURE
     SHA1MSG1         xmmreg,xmmrm128          SHA,FUTURE
     SHA1MSG2         xmmreg,xmmrm128          SHA,FUTURE
     SHA1NEXTE        xmmreg,xmmrm128          SHA,FUTURE
     SHA1RNDS4        xmmreg,xmmrm128,imm8     SHA,FUTURE
     SHA256MSG1       xmmreg,xmmrm128          SHA,FUTURE
     SHA256MSG2       xmmreg,xmmrm128          SHA,FUTURE
     SHA256RNDS2      xmmreg,xmmrm128,xmm0     SHA,FUTURE
     VADDPD           xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VADDPD           ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VADDPD           zmmreg|mask|z,zmmreg,zmmrm512|b64|er AVX512,FUTURE
     VADDPS           xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VADDPS           ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VADDPS           zmmreg|mask|z,zmmreg,zmmrm512|b32|er AVX512,FUTURE
     VADDSD           xmmreg|mask|z,xmmreg,xmmrm64|er AVX512,FUTURE
     VADDSS           xmmreg|mask|z,xmmreg,xmmrm32|er AVX512,FUTURE
     VALIGND          xmmreg|mask|z,xmmreg,xmmrm128|b32,imm8 AVX512VL,AVX512,FUTURE
     VALIGND          ymmreg|mask|z,ymmreg,ymmrm256|b32,imm8 AVX512VL,AVX512,FUTURE
     VALIGND          zmmreg|mask|z,zmmreg,zmmrm512|b32,imm8 AVX512,FUTURE
     VALIGNQ          xmmreg|mask|z,xmmreg,xmmrm128|b64,imm8 AVX512VL,AVX512,FUTURE
     VALIGNQ          ymmreg|mask|z,ymmreg,ymmrm256|b64,imm8 AVX512VL,AVX512,FUTURE
     VALIGNQ          zmmreg|mask|z,zmmreg,zmmrm512|b64,imm8 AVX512,FUTURE
     VANDNPD          xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512DQ,FUTURE
     VANDNPD          ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512DQ,FUTURE
     VANDNPD          zmmreg|mask|z,zmmreg,zmmrm512|b64 AVX512DQ,FUTURE
     VANDNPS          xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512DQ,FUTURE
     VANDNPS          ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512DQ,FUTURE
     VANDNPS          zmmreg|mask|z,zmmreg,zmmrm512|b32 AVX512DQ,FUTURE
     VANDPD           xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512DQ,FUTURE
     VANDPD           ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512DQ,FUTURE
     VANDPD           zmmreg|mask|z,zmmreg,zmmrm512|b64 AVX512DQ,FUTURE
     VANDPS           xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512DQ,FUTURE
     VANDPS           ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512DQ,FUTURE
     VANDPS           zmmreg|mask|z,zmmreg,zmmrm512|b32 AVX512DQ,FUTURE
     VBLENDMPD        xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VBLENDMPD        ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VBLENDMPD        zmmreg|mask|z,zmmreg,zmmrm512|b64 AVX512,FUTURE
     VBLENDMPS        xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VBLENDMPS        ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VBLENDMPS        zmmreg|mask|z,zmmreg,zmmrm512|b32 AVX512,FUTURE
     VBROADCASTF32X2  ymmreg|mask|z,xmmrm64    AVX512VL,AVX512DQ,FUTURE
     VBROADCASTF32X2  zmmreg|mask|z,xmmrm64    AVX512DQ,FUTURE
     VBROADCASTF32X4  ymmreg|mask|z,mem128     AVX512VL,AVX512,FUTURE
     VBROADCASTF32X4  zmmreg|mask|z,mem128     AVX512,FUTURE
     VBROADCASTF32X8  zmmreg|mask|z,mem256     AVX512DQ,FUTURE
     VBROADCASTF64X2  ymmreg|mask|z,mem128     AVX512VL,AVX512DQ,FUTURE
     VBROADCASTF64X2  zmmreg|mask|z,mem128     AVX512DQ,FUTURE
     VBROADCASTF64X4  zmmreg|mask|z,mem256     AVX512,FUTURE
     VBROADCASTI32X2  xmmreg|mask|z,xmmrm64    AVX512VL,AVX512DQ,FUTURE
     VBROADCASTI32X2  ymmreg|mask|z,xmmrm64    AVX512VL,AVX512DQ,FUTURE
     VBROADCASTI32X2  zmmreg|mask|z,xmmrm64    AVX512DQ,FUTURE
     VBROADCASTI32X4  ymmreg|mask|z,mem128     AVX512VL,AVX512,FUTURE
     VBROADCASTI32X4  zmmreg|mask|z,mem128     AVX512,FUTURE
     VBROADCASTI32X8  zmmreg|mask|z,mem256     AVX512DQ,FUTURE
     VBROADCASTI64X2  ymmreg|mask|z,mem128     AVX512VL,AVX512DQ,FUTURE
     VBROADCASTI64X2  zmmreg|mask|z,mem128     AVX512DQ,FUTURE
     VBROADCASTI64X4  zmmreg|mask|z,mem256     AVX512,FUTURE
     VBROADCASTSD     ymmreg|mask|z,mem64      AVX512VL,AVX512,FUTURE
     VBROADCASTSD     zmmreg|mask|z,mem64      AVX512,FUTURE
     VBROADCASTSD     ymmreg|mask|z,xmmreg     AVX512VL,AVX512,FUTURE
     VBROADCASTSD     zmmreg|mask|z,xmmreg     AVX512,FUTURE
     VBROADCASTSS     xmmreg|mask|z,mem32      AVX512VL,AVX512,FUTURE
     VBROADCASTSS     ymmreg|mask|z,mem32      AVX512VL,AVX512,FUTURE
     VBROADCASTSS     zmmreg|mask|z,mem32      AVX512,FUTURE
     VBROADCASTSS     xmmreg|mask|z,xmmreg     AVX512VL,AVX512,FUTURE
     VBROADCASTSS     ymmreg|mask|z,xmmreg     AVX512VL,AVX512,FUTURE
     VBROADCASTSS     zmmreg|mask|z,xmmreg     AVX512,FUTURE
     VCMPPD           kreg|mask,xmmreg,xmmrm128|b64,imm8 AVX512VL,AVX512,FUTURE
     VCMPPD           kreg|mask,ymmreg,ymmrm256|b64,imm8 AVX512VL,AVX512,FUTURE
     VCMPPD           kreg|mask,zmmreg,zmmrm512|b64|sae,imm8 AVX512,FUTURE
     VCMPPS           kreg|mask,xmmreg,xmmrm128|b32,imm8 AVX512VL,AVX512,FUTURE
     VCMPPS           kreg|mask,ymmreg,ymmrm256|b32,imm8 AVX512VL,AVX512,FUTURE
     VCMPPS           kreg|mask,zmmreg,zmmrm512|b32|sae,imm8 AVX512,FUTURE
     VCMPSD           kreg|mask,xmmreg,xmmrm64|sae,imm8 AVX512,FUTURE
     VCMPSS           kreg|mask,xmmreg,xmmrm32|sae,imm8 AVX512,FUTURE
     VCOMISD          xmmreg,xmmrm64|sae       AVX512,FUTURE
     VCOMISS          xmmreg,xmmrm32|sae       AVX512,FUTURE
     VCOMPRESSPD      mem128|mask,xmmreg       AVX512VL,AVX512,FUTURE
     VCOMPRESSPD      mem256|mask,ymmreg       AVX512VL,AVX512,FUTURE
     VCOMPRESSPD      mem512|mask,zmmreg       AVX512,FUTURE
     VCOMPRESSPD      xmmreg|mask|z,xmmreg     AVX512VL,AVX512,FUTURE
     VCOMPRESSPD      ymmreg|mask|z,ymmreg     AVX512VL,AVX512,FUTURE
     VCOMPRESSPD      zmmreg|mask|z,zmmreg     AVX512,FUTURE
     VCOMPRESSPS      mem128|mask,xmmreg       AVX512VL,AVX512,FUTURE
     VCOMPRESSPS      mem256|mask,ymmreg       AVX512VL,AVX512,FUTURE
     VCOMPRESSPS      mem512|mask,zmmreg       AVX512,FUTURE
     VCOMPRESSPS      xmmreg|mask|z,xmmreg     AVX512VL,AVX512,FUTURE
     VCOMPRESSPS      ymmreg|mask|z,ymmreg     AVX512VL,AVX512,FUTURE
     VCOMPRESSPS      zmmreg|mask|z,zmmreg     AVX512,FUTURE
     VCVTDQ2PD        xmmreg|mask|z,xmmrm64|b32 AVX512VL,AVX512,FUTURE
     VCVTDQ2PD        ymmreg|mask|z,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VCVTDQ2PD        zmmreg|mask|z,ymmrm256|b32|er AVX512,FUTURE
     VCVTDQ2PS        xmmreg|mask|z,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VCVTDQ2PS        ymmreg|mask|z,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VCVTDQ2PS        zmmreg|mask|z,zmmrm512|b32|er AVX512,FUTURE
     VCVTPD2DQ        xmmreg|mask|z,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VCVTPD2DQ        xmmreg|mask|z,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VCVTPD2DQ        ymmreg|mask|z,zmmrm512|b64|er AVX512,FUTURE
     VCVTPD2PS        xmmreg|mask|z,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VCVTPD2PS        xmmreg|mask|z,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VCVTPD2PS        ymmreg|mask|z,zmmrm512|b64|er AVX512,FUTURE
     VCVTPD2QQ        xmmreg|mask|z,xmmrm128|b64 AVX512VL,AVX512DQ,FUTURE
     VCVTPD2QQ        ymmreg|mask|z,ymmrm256|b64 AVX512VL,AVX512DQ,FUTURE
     VCVTPD2QQ        zmmreg|mask|z,zmmrm512|b64|er AVX512DQ,FUTURE
     VCVTPD2UDQ       xmmreg|mask|z,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VCVTPD2UDQ       xmmreg|mask|z,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VCVTPD2UDQ       ymmreg|mask|z,zmmrm512|b64|er AVX512,FUTURE
     VCVTPD2UQQ       xmmreg|mask|z,xmmrm128|b64 AVX512VL,AVX512DQ,FUTURE
     VCVTPD2UQQ       ymmreg|mask|z,ymmrm256|b64 AVX512VL,AVX512DQ,FUTURE
     VCVTPD2UQQ       zmmreg|mask|z,zmmrm512|b64|er AVX512DQ,FUTURE
     VCVTPH2PS        xmmreg|mask|z,xmmrm64    AVX512VL,AVX512,FUTURE
     VCVTPH2PS        ymmreg|mask|z,xmmrm128   AVX512VL,AVX512,FUTURE
     VCVTPH2PS        zmmreg|mask|z,ymmrm256|sae AVX512,FUTURE
     VCVTPS2DQ        xmmreg|mask|z,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VCVTPS2DQ        ymmreg|mask|z,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VCVTPS2DQ        zmmreg|mask|z,zmmrm512|b32|er AVX512,FUTURE
     VCVTPS2PD        xmmreg|mask|z,xmmrm64|b32 AVX512VL,AVX512,FUTURE
     VCVTPS2PD        ymmreg|mask|z,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VCVTPS2PD        zmmreg|mask|z,ymmrm256|b32|sae AVX512,FUTURE
     VCVTPS2PH        xmmreg|mask|z,xmmreg,imm8 AVX512VL,AVX512,FUTURE
     VCVTPS2PH        xmmreg|mask|z,ymmreg,imm8 AVX512VL,AVX512,FUTURE
     VCVTPS2PH        ymmreg|mask|z,zmmreg|sae,imm8 AVX512,FUTURE
     VCVTPS2PH        mem64|mask,xmmreg,imm8   AVX512VL,AVX512,FUTURE
     VCVTPS2PH        mem128|mask,ymmreg,imm8  AVX512VL,AVX512,FUTURE
     VCVTPS2PH        mem256|mask,zmmreg|sae,imm8 AVX512,FUTURE
     VCVTPS2QQ        xmmreg|mask|z,xmmrm64|b32 AVX512VL,AVX512DQ,FUTURE
     VCVTPS2QQ        ymmreg|mask|z,xmmrm128|b32 AVX512VL,AVX512DQ,FUTURE
     VCVTPS2QQ        zmmreg|mask|z,ymmrm256|b32|er AVX512DQ,FUTURE
     VCVTPS2UDQ       xmmreg|mask|z,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VCVTPS2UDQ       ymmreg|mask|z,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VCVTPS2UDQ       zmmreg|mask|z,zmmrm512|b32|er AVX512,FUTURE
     VCVTPS2UQQ       xmmreg|mask|z,xmmrm64|b32 AVX512VL,AVX512DQ,FUTURE
     VCVTPS2UQQ       ymmreg|mask|z,xmmrm128|b32 AVX512VL,AVX512DQ,FUTURE
     VCVTPS2UQQ       zmmreg|mask|z,ymmrm256|b32|er AVX512DQ,FUTURE
     VCVTQQ2PD        xmmreg|mask|z,xmmrm128|b64 AVX512VL,AVX512DQ,FUTURE
     VCVTQQ2PD        ymmreg|mask|z,ymmrm256|b64 AVX512VL,AVX512DQ,FUTURE
     VCVTQQ2PD        zmmreg|mask|z,zmmrm512|b64|er AVX512DQ,FUTURE
     VCVTQQ2PS        xmmreg|mask|z,xmmrm128|b64 AVX512VL,AVX512DQ,FUTURE
     VCVTQQ2PS        xmmreg|mask|z,ymmrm256|b64 AVX512VL,AVX512DQ,FUTURE
     VCVTQQ2PS        ymmreg|mask|z,zmmrm512|b64|er AVX512DQ,FUTURE
     VCVTSD2SI        reg32,xmmrm64|er         AVX512,FUTURE
     VCVTSD2SI        reg64,xmmrm64|er         AVX512,FUTURE
     VCVTSD2SS        xmmreg|mask|z,xmmreg,xmmrm64|er AVX512,FUTURE
     VCVTSD2USI       reg32,xmmrm64|er         AVX512,FUTURE
     VCVTSD2USI       reg64,xmmrm64|er         AVX512,FUTURE
     VCVTSI2SD        xmmreg,xmmreg|er,rm32    AVX512,FUTURE
     VCVTSI2SD        xmmreg,xmmreg|er,rm64    AVX512,FUTURE
     VCVTSI2SS        xmmreg,xmmreg|er,rm32    AVX512,FUTURE
     VCVTSI2SS        xmmreg,xmmreg|er,rm64    AVX512,FUTURE
     VCVTSS2SD        xmmreg|mask|z,xmmreg,xmmrm32|sae AVX512,FUTURE
     VCVTSS2SI        reg32,xmmrm32|er         AVX512,FUTURE
     VCVTSS2SI        reg64,xmmrm32|er         AVX512,FUTURE
     VCVTSS2USI       reg32,xmmrm32|er         AVX512,FUTURE
     VCVTSS2USI       reg64,xmmrm32|er         AVX512,FUTURE
     VCVTTPD2DQ       xmmreg|mask|z,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VCVTTPD2DQ       xmmreg|mask|z,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VCVTTPD2DQ       ymmreg|mask|z,zmmrm512|b64|sae AVX512,FUTURE
     VCVTTPD2QQ       xmmreg|mask|z,xmmrm128|b64 AVX512VL,AVX512DQ,FUTURE
     VCVTTPD2QQ       ymmreg|mask|z,ymmrm256|b64 AVX512VL,AVX512DQ,FUTURE
     VCVTTPD2QQ       zmmreg|mask|z,zmmrm512|b64|sae AVX512DQ,FUTURE
     VCVTTPD2UDQ      xmmreg|mask|z,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VCVTTPD2UDQ      xmmreg|mask|z,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VCVTTPD2UDQ      ymmreg|mask|z,zmmrm512|b64|sae AVX512,FUTURE
     VCVTTPD2UQQ      xmmreg|mask|z,xmmrm128|b64 AVX512VL,AVX512DQ,FUTURE
     VCVTTPD2UQQ      ymmreg|mask|z,ymmrm256|b64 AVX512VL,AVX512DQ,FUTURE
     VCVTTPD2UQQ      zmmreg|mask|z,zmmrm512|b64|sae AVX512DQ,FUTURE
     VCVTTPS2DQ       xmmreg|mask|z,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VCVTTPS2DQ       ymmreg|mask|z,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VCVTTPS2DQ       zmmreg|mask|z,zmmrm512|b32|sae AVX512,FUTURE
     VCVTTPS2QQ       xmmreg|mask|z,xmmrm64|b32 AVX512VL,AVX512DQ,FUTURE
     VCVTTPS2QQ       ymmreg|mask|z,xmmrm128|b32 AVX512VL,AVX512DQ,FUTURE
     VCVTTPS2QQ       zmmreg|mask|z,ymmrm256|b32|sae AVX512DQ,FUTURE
     VCVTTPS2UDQ      xmmreg|mask|z,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VCVTTPS2UDQ      ymmreg|mask|z,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VCVTTPS2UDQ      zmmreg|mask|z,zmmrm512|b32|sae AVX512,FUTURE
     VCVTTPS2UQQ      xmmreg|mask|z,xmmrm64|b32 AVX512VL,AVX512DQ,FUTURE
     VCVTTPS2UQQ      ymmreg|mask|z,xmmrm128|b32 AVX512VL,AVX512DQ,FUTURE
     VCVTTPS2UQQ      zmmreg|mask|z,ymmrm256|b32|sae AVX512DQ,FUTURE
     VCVTTSD2SI       reg32,xmmrm64|sae        AVX512,FUTURE
     VCVTTSD2SI       reg64,xmmrm64|sae        AVX512,FUTURE
     VCVTTSD2USI      reg32,xmmrm64|sae        AVX512,FUTURE
     VCVTTSD2USI      reg64,xmmrm64|sae        AVX512,FUTURE
     VCVTTSS2SI       reg32,xmmrm32|sae        AVX512,FUTURE
     VCVTTSS2SI       reg64,xmmrm32|sae        AVX512,FUTURE
     VCVTTSS2USI      reg32,xmmrm32|sae        AVX512,FUTURE
     VCVTTSS2USI      reg64,xmmrm32|sae        AVX512,FUTURE
     VCVTUDQ2PD       xmmreg|mask|z,xmmrm64|b32 AVX512VL,AVX512,FUTURE
     VCVTUDQ2PD       ymmreg|mask|z,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VCVTUDQ2PD       zmmreg|mask|z,ymmrm256|b32|er AVX512,FUTURE
     VCVTUDQ2PS       xmmreg|mask|z,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VCVTUDQ2PS       ymmreg|mask|z,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VCVTUDQ2PS       zmmreg|mask|z,zmmrm512|b32|er AVX512,FUTURE
     VCVTUQQ2PD       xmmreg|mask|z,xmmrm128|b64 AVX512VL,AVX512DQ,FUTURE
     VCVTUQQ2PD       ymmreg|mask|z,ymmrm256|b64 AVX512VL,AVX512DQ,FUTURE
     VCVTUQQ2PD       zmmreg|mask|z,zmmrm512|b64|er AVX512DQ,FUTURE
     VCVTUQQ2PS       xmmreg|mask|z,xmmrm128|b64 AVX512VL,AVX512DQ,FUTURE
     VCVTUQQ2PS       xmmreg|mask|z,ymmrm256|b64 AVX512VL,AVX512DQ,FUTURE
     VCVTUQQ2PS       ymmreg|mask|z,zmmrm512|b64|er AVX512DQ,FUTURE
     VCVTUSI2SD       xmmreg,xmmreg|er,rm32    AVX512,FUTURE
     VCVTUSI2SD       xmmreg,xmmreg|er,rm64    AVX512,FUTURE
     VCVTUSI2SS       xmmreg,xmmreg|er,rm32    AVX512,FUTURE
     VCVTUSI2SS       xmmreg,xmmreg|er,rm64    AVX512,FUTURE
     VDBPSADBW        xmmreg|mask|z,xmmreg,xmmrm128,imm8 AVX512VL,AVX512BW,FUTURE
     VDBPSADBW        ymmreg|mask|z,ymmreg,ymmrm256,imm8 AVX512VL,AVX512BW,FUTURE
     VDBPSADBW        zmmreg|mask|z,zmmreg,zmmrm512,imm8 AVX512BW,FUTURE
     VDIVPD           xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VDIVPD           ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VDIVPD           zmmreg|mask|z,zmmreg,zmmrm512|b64|er AVX512,FUTURE
     VDIVPS           xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VDIVPS           ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VDIVPS           zmmreg|mask|z,zmmreg,zmmrm512|b32|er AVX512,FUTURE
     VDIVSD           xmmreg|mask|z,xmmreg,xmmrm64|er AVX512,FUTURE
     VDIVSS           xmmreg|mask|z,xmmreg,xmmrm32|er AVX512,FUTURE
     VEXP2PD          zmmreg|mask|z,zmmrm512|b64|sae AVX512ER,FUTURE
     VEXP2PS          zmmreg|mask|z,zmmrm512|b32|sae AVX512ER,FUTURE
     VEXPANDPD        xmmreg|mask|z,mem128     AVX512VL,AVX512,FUTURE
     VEXPANDPD        ymmreg|mask|z,mem256     AVX512VL,AVX512,FUTURE
     VEXPANDPD        zmmreg|mask|z,mem512     AVX512,FUTURE
     VEXPANDPD        xmmreg|mask|z,xmmreg     AVX512VL,AVX512,FUTURE
     VEXPANDPD        ymmreg|mask|z,ymmreg     AVX512VL,AVX512,FUTURE
     VEXPANDPD        zmmreg|mask|z,zmmreg     AVX512,FUTURE
     VEXPANDPS        xmmreg|mask|z,mem128     AVX512VL,AVX512,FUTURE
     VEXPANDPS        ymmreg|mask|z,mem256     AVX512VL,AVX512,FUTURE
     VEXPANDPS        zmmreg|mask|z,mem512     AVX512,FUTURE
     VEXPANDPS        xmmreg|mask|z,xmmreg     AVX512VL,AVX512,FUTURE
     VEXPANDPS        ymmreg|mask|z,ymmreg     AVX512VL,AVX512,FUTURE
     VEXPANDPS        zmmreg|mask|z,zmmreg     AVX512,FUTURE
     VEXTRACTF32X4    xmmreg|mask|z,ymmreg,imm8 AVX512VL,AVX512,FUTURE
     VEXTRACTF32X4    xmmreg|mask|z,zmmreg,imm8 AVX512,FUTURE
     VEXTRACTF32X4    mem128|mask,ymmreg,imm8  AVX512VL,AVX512,FUTURE
     VEXTRACTF32X4    mem128|mask,zmmreg,imm8  AVX512,FUTURE
     VEXTRACTF32X8    ymmreg|mask|z,zmmreg,imm8 AVX512DQ,FUTURE
     VEXTRACTF32X8    mem256|mask,zmmreg,imm8  AVX512DQ,FUTURE
     VEXTRACTF64X2    xmmreg|mask|z,ymmreg,imm8 AVX512VL,AVX512DQ,FUTURE
     VEXTRACTF64X2    xmmreg|mask|z,zmmreg,imm8 AVX512DQ,FUTURE
     VEXTRACTF64X2    mem128|mask,ymmreg,imm8  AVX512VL,AVX512DQ,FUTURE
     VEXTRACTF64X2    mem128|mask,zmmreg,imm8  AVX512DQ,FUTURE
     VEXTRACTF64X4    ymmreg|mask|z,zmmreg,imm8 AVX512,FUTURE
     VEXTRACTF64X4    mem256|mask,zmmreg,imm8  AVX512,FUTURE
     VEXTRACTI32X4    xmmreg|mask|z,ymmreg,imm8 AVX512VL,AVX512,FUTURE
     VEXTRACTI32X4    xmmreg|mask|z,zmmreg,imm8 AVX512,FUTURE
     VEXTRACTI32X4    mem128|mask,ymmreg,imm8  AVX512VL,AVX512,FUTURE
     VEXTRACTI32X4    mem128|mask,zmmreg,imm8  AVX512,FUTURE
     VEXTRACTI32X8    ymmreg|mask|z,zmmreg,imm8 AVX512DQ,FUTURE
     VEXTRACTI32X8    mem256|mask,zmmreg,imm8  AVX512DQ,FUTURE
     VEXTRACTI64X2    xmmreg|mask|z,ymmreg,imm8 AVX512VL,AVX512DQ,FUTURE
     VEXTRACTI64X2    xmmreg|mask|z,zmmreg,imm8 AVX512DQ,FUTURE
     VEXTRACTI64X2    mem128|mask,ymmreg,imm8  AVX512VL,AVX512DQ,FUTURE
     VEXTRACTI64X2    mem128|mask,zmmreg,imm8  AVX512DQ,FUTURE
     VEXTRACTI64X4    ymmreg|mask|z,zmmreg,imm8 AVX512,FUTURE
     VEXTRACTI64X4    mem256|mask,zmmreg,imm8  AVX512,FUTURE
     VEXTRACTPS       reg32,xmmreg,imm8        AVX512,FUTURE
     VEXTRACTPS       reg64,xmmreg,imm8        AVX512,FUTURE
     VEXTRACTPS       mem32,xmmreg,imm8        AVX512,FUTURE
     VFIXUPIMMPD      xmmreg|mask|z,xmmreg,xmmrm128|b64,imm8 AVX512VL,AVX512,FUTURE
     VFIXUPIMMPD      ymmreg|mask|z,ymmreg,ymmrm256|b64,imm8 AVX512VL,AVX512,FUTURE
     VFIXUPIMMPD      zmmreg|mask|z,zmmreg,zmmrm512|b64|sae,imm8 AVX512,FUTURE
     VFIXUPIMMPS      xmmreg|mask|z,xmmreg,xmmrm128|b32,imm8 AVX512VL,AVX512,FUTURE
     VFIXUPIMMPS      ymmreg|mask|z,ymmreg,ymmrm256|b32,imm8 AVX512VL,AVX512,FUTURE
     VFIXUPIMMPS      zmmreg|mask|z,zmmreg,zmmrm512|b32|sae,imm8 AVX512,FUTURE
     VFIXUPIMMSD      xmmreg|mask|z,xmmreg,xmmrm64|sae,imm8 AVX512,FUTURE
     VFIXUPIMMSS      xmmreg|mask|z,xmmreg,xmmrm32|sae,imm8 AVX512,FUTURE
     VFMADD132PD      xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VFMADD132PD      ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VFMADD132PD      zmmreg|mask|z,zmmreg,zmmrm512|b64|er AVX512,FUTURE
     VFMADD132PS      xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VFMADD132PS      ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VFMADD132PS      zmmreg|mask|z,zmmreg,zmmrm512|b32|er AVX512,FUTURE
     VFMADD132SD      xmmreg|mask|z,xmmreg,xmmrm64|er AVX512,FUTURE
     VFMADD132SS      xmmreg|mask|z,xmmreg,xmmrm32|er AVX512,FUTURE
     VFMADD213PD      xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VFMADD213PD      ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VFMADD213PD      zmmreg|mask|z,zmmreg,zmmrm512|b64|er AVX512,FUTURE
     VFMADD213PS      xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VFMADD213PS      ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VFMADD213PS      zmmreg|mask|z,zmmreg,zmmrm512|b32|er AVX512,FUTURE
     VFMADD213SD      xmmreg|mask|z,xmmreg,xmmrm64|er AVX512,FUTURE
     VFMADD213SS      xmmreg|mask|z,xmmreg,xmmrm32|er AVX512,FUTURE
     VFMADD231PD      xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VFMADD231PD      ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VFMADD231PD      zmmreg|mask|z,zmmreg,zmmrm512|b64|er AVX512,FUTURE
     VFMADD231PS      xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VFMADD231PS      ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VFMADD231PS      zmmreg|mask|z,zmmreg,zmmrm512|b32|er AVX512,FUTURE
     VFMADD231SD      xmmreg|mask|z,xmmreg,xmmrm64|er AVX512,FUTURE
     VFMADD231SS      xmmreg|mask|z,xmmreg,xmmrm32|er AVX512,FUTURE
     VFMADDSUB132PD   xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VFMADDSUB132PD   ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VFMADDSUB132PD   zmmreg|mask|z,zmmreg,zmmrm512|b64|er AVX512,FUTURE
     VFMADDSUB132PS   xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VFMADDSUB132PS   ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VFMADDSUB132PS   zmmreg|mask|z,zmmreg,zmmrm512|b32|er AVX512,FUTURE
     VFMADDSUB213PD   xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VFMADDSUB213PD   ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VFMADDSUB213PD   zmmreg|mask|z,zmmreg,zmmrm512|b64|er AVX512,FUTURE
     VFMADDSUB213PS   xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VFMADDSUB213PS   ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VFMADDSUB213PS   zmmreg|mask|z,zmmreg,zmmrm512|b32|er AVX512,FUTURE
     VFMADDSUB231PD   xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VFMADDSUB231PD   ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VFMADDSUB231PD   zmmreg|mask|z,zmmreg,zmmrm512|b64|er AVX512,FUTURE
     VFMADDSUB231PS   xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VFMADDSUB231PS   ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VFMADDSUB231PS   zmmreg|mask|z,zmmreg,zmmrm512|b32|er AVX512,FUTURE
     VFMSUB132PD      xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VFMSUB132PD      ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VFMSUB132PD      zmmreg|mask|z,zmmreg,zmmrm512|b64|er AVX512,FUTURE
     VFMSUB132PS      xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VFMSUB132PS      ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VFMSUB132PS      zmmreg|mask|z,zmmreg,zmmrm512|b32|er AVX512,FUTURE
     VFMSUB132SD      xmmreg|mask|z,xmmreg,xmmrm64|er AVX512,FUTURE
     VFMSUB132SS      xmmreg|mask|z,xmmreg,xmmrm32|er AVX512,FUTURE
     VFMSUB213PD      xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VFMSUB213PD      ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VFMSUB213PD      zmmreg|mask|z,zmmreg,zmmrm512|b64|er AVX512,FUTURE
     VFMSUB213PS      xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VFMSUB213PS      ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VFMSUB213PS      zmmreg|mask|z,zmmreg,zmmrm512|b32|er AVX512,FUTURE
     VFMSUB213SD      xmmreg|mask|z,xmmreg,xmmrm64|er AVX512,FUTURE
     VFMSUB213SS      xmmreg|mask|z,xmmreg,xmmrm32|er AVX512,FUTURE
     VFMSUB231PD      xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VFMSUB231PD      ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VFMSUB231PD      zmmreg|mask|z,zmmreg,zmmrm512|b64|er AVX512,FUTURE
     VFMSUB231PS      xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VFMSUB231PS      ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VFMSUB231PS      zmmreg|mask|z,zmmreg,zmmrm512|b32|er AVX512,FUTURE
     VFMSUB231SD      xmmreg|mask|z,xmmreg,xmmrm64|er AVX512,FUTURE
     VFMSUB231SS      xmmreg|mask|z,xmmreg,xmmrm32|er AVX512,FUTURE
     VFMSUBADD132PD   xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VFMSUBADD132PD   ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VFMSUBADD132PD   zmmreg|mask|z,zmmreg,zmmrm512|b64|er AVX512,FUTURE
     VFMSUBADD132PS   xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VFMSUBADD132PS   ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VFMSUBADD132PS   zmmreg|mask|z,zmmreg,zmmrm512|b32|er AVX512,FUTURE
     VFMSUBADD213PD   xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VFMSUBADD213PD   ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VFMSUBADD213PD   zmmreg|mask|z,zmmreg,zmmrm512|b64|er AVX512,FUTURE
     VFMSUBADD213PS   xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VFMSUBADD213PS   ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VFMSUBADD213PS   zmmreg|mask|z,zmmreg,zmmrm512|b32|er AVX512,FUTURE
     VFMSUBADD231PD   xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VFMSUBADD231PD   ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VFMSUBADD231PD   zmmreg|mask|z,zmmreg,zmmrm512|b64|er AVX512,FUTURE
     VFMSUBADD231PS   xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VFMSUBADD231PS   ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VFMSUBADD231PS   zmmreg|mask|z,zmmreg,zmmrm512|b32|er AVX512,FUTURE
     VFNMADD132PD     xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VFNMADD132PD     ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VFNMADD132PD     zmmreg|mask|z,zmmreg,zmmrm512|b64|er AVX512,FUTURE
     VFNMADD132PS     xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VFNMADD132PS     ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VFNMADD132PS     zmmreg|mask|z,zmmreg,zmmrm512|b32|er AVX512,FUTURE
     VFNMADD132SD     xmmreg|mask|z,xmmreg,xmmrm64|er AVX512,FUTURE
     VFNMADD132SS     xmmreg|mask|z,xmmreg,xmmrm32|er AVX512,FUTURE
     VFNMADD213PD     xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VFNMADD213PD     ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VFNMADD213PD     zmmreg|mask|z,zmmreg,zmmrm512|b64|er AVX512,FUTURE
     VFNMADD213PS     xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VFNMADD213PS     ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VFNMADD213PS     zmmreg|mask|z,zmmreg,zmmrm512|b32|er AVX512,FUTURE
     VFNMADD213SD     xmmreg|mask|z,xmmreg,xmmrm64|er AVX512,FUTURE
     VFNMADD213SS     xmmreg|mask|z,xmmreg,xmmrm32|er AVX512,FUTURE
     VFNMADD231PD     xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VFNMADD231PD     ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VFNMADD231PD     zmmreg|mask|z,zmmreg,zmmrm512|b64|er AVX512,FUTURE
     VFNMADD231PS     xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VFNMADD231PS     ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VFNMADD231PS     zmmreg|mask|z,zmmreg,zmmrm512|b32|er AVX512,FUTURE
     VFNMADD231SD     xmmreg|mask|z,xmmreg,xmmrm64|er AVX512,FUTURE
     VFNMADD231SS     xmmreg|mask|z,xmmreg,xmmrm32|er AVX512,FUTURE
     VFNMSUB132PD     xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VFNMSUB132PD     ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VFNMSUB132PD     zmmreg|mask|z,zmmreg,zmmrm512|b64|er AVX512,FUTURE
     VFNMSUB132PS     xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VFNMSUB132PS     ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VFNMSUB132PS     zmmreg|mask|z,zmmreg,zmmrm512|b32|er AVX512,FUTURE
     VFNMSUB132SD     xmmreg|mask|z,xmmreg,xmmrm64|er AVX512,FUTURE
     VFNMSUB132SS     xmmreg|mask|z,xmmreg,xmmrm32|er AVX512,FUTURE
     VFNMSUB213PD     xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VFNMSUB213PD     ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VFNMSUB213PD     zmmreg|mask|z,zmmreg,zmmrm512|b64|er AVX512,FUTURE
     VFNMSUB213PS     xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VFNMSUB213PS     ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VFNMSUB213PS     zmmreg|mask|z,zmmreg,zmmrm512|b32|er AVX512,FUTURE
     VFNMSUB213SD     xmmreg|mask|z,xmmreg,xmmrm64|er AVX512,FUTURE
     VFNMSUB213SS     xmmreg|mask|z,xmmreg,xmmrm32|er AVX512,FUTURE
     VFNMSUB231PD     xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VFNMSUB231PD     ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VFNMSUB231PD     zmmreg|mask|z,zmmreg,zmmrm512|b64|er AVX512,FUTURE
     VFNMSUB231PS     xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VFNMSUB231PS     ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VFNMSUB231PS     zmmreg|mask|z,zmmreg,zmmrm512|b32|er AVX512,FUTURE
     VFNMSUB231SD     xmmreg|mask|z,xmmreg,xmmrm64|er AVX512,FUTURE
     VFNMSUB231SS     xmmreg|mask|z,xmmreg,xmmrm32|er AVX512,FUTURE
     VFPCLASSPD       kreg|mask,xmmrm128|b64,imm8 AVX512VL,AVX512DQ,FUTURE
     VFPCLASSPD       kreg|mask,ymmrm256|b64,imm8 AVX512VL,AVX512DQ,FUTURE
     VFPCLASSPD       kreg|mask,zmmrm512|b64,imm8 AVX512DQ,FUTURE
     VFPCLASSPS       kreg|mask,xmmrm128|b32,imm8 AVX512VL,AVX512DQ,FUTURE
     VFPCLASSPS       kreg|mask,ymmrm256|b32,imm8 AVX512VL,AVX512DQ,FUTURE
     VFPCLASSPS       kreg|mask,zmmrm512|b32,imm8 AVX512DQ,FUTURE
     VFPCLASSSD       kreg|mask,xmmrm64,imm8   AVX512DQ,FUTURE
     VFPCLASSSS       kreg|mask,xmmrm32,imm8   AVX512DQ,FUTURE
     VGATHERDPD       xmmreg|mask,xmem64       AVX512VL,AVX512,FUTURE
     VGATHERDPD       ymmreg|mask,xmem64       AVX512VL,AVX512,FUTURE
     VGATHERDPD       zmmreg|mask,ymem64       AVX512,FUTURE
     VGATHERDPS       xmmreg|mask,xmem32       AVX512VL,AVX512,FUTURE
     VGATHERDPS       ymmreg|mask,ymem32       AVX512VL,AVX512,FUTURE
     VGATHERDPS       zmmreg|mask,zmem32       AVX512,FUTURE
     VGATHERPF0DPD    ymem64|mask              AVX512PF,FUTURE
     VGATHERPF0DPS    zmem32|mask              AVX512PF,FUTURE
     VGATHERPF0QPD    zmem64|mask              AVX512PF,FUTURE
     VGATHERPF0QPS    zmem32|mask              AVX512PF,FUTURE
     VGATHERPF1DPD    ymem64|mask              AVX512PF,FUTURE
     VGATHERPF1DPS    zmem32|mask              AVX512PF,FUTURE
     VGATHERPF1QPD    zmem64|mask              AVX512PF,FUTURE
     VGATHERPF1QPS    zmem32|mask              AVX512PF,FUTURE
     VGATHERQPD       xmmreg|mask,xmem64       AVX512VL,AVX512,FUTURE
     VGATHERQPD       ymmreg|mask,ymem64       AVX512VL,AVX512,FUTURE
     VGATHERQPD       zmmreg|mask,zmem64       AVX512,FUTURE
     VGATHERQPS       xmmreg|mask,xmem32       AVX512VL,AVX512,FUTURE
     VGATHERQPS       xmmreg|mask,ymem32       AVX512VL,AVX512,FUTURE
     VGATHERQPS       ymmreg|mask,zmem32       AVX512,FUTURE
     VGETEXPPD        xmmreg|mask|z,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VGETEXPPD        ymmreg|mask|z,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VGETEXPPD        zmmreg|mask|z,zmmrm512|b64|sae AVX512,FUTURE
     VGETEXPPS        xmmreg|mask|z,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VGETEXPPS        ymmreg|mask|z,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VGETEXPPS        zmmreg|mask|z,zmmrm512|b32|sae AVX512,FUTURE
     VGETEXPSD        xmmreg|mask|z,xmmreg,xmmrm64|sae AVX512,FUTURE
     VGETEXPSS        xmmreg|mask|z,xmmreg,xmmrm32|sae AVX512,FUTURE
     VGETMANTPD       xmmreg|mask|z,xmmrm128|b64,imm8 AVX512VL,AVX512,FUTURE
     VGETMANTPD       ymmreg|mask|z,ymmrm256|b64,imm8 AVX512VL,AVX512,FUTURE
     VGETMANTPD       zmmreg|mask|z,zmmrm512|b64|sae,imm8 AVX512,FUTURE
     VGETMANTPS       xmmreg|mask|z,xmmrm128|b32,imm8 AVX512VL,AVX512,FUTURE
     VGETMANTPS       ymmreg|mask|z,ymmrm256|b32,imm8 AVX512VL,AVX512,FUTURE
     VGETMANTPS       zmmreg|mask|z,zmmrm512|b32|sae,imm8 AVX512,FUTURE
     VGETMANTSD       xmmreg|mask|z,xmmreg,xmmrm64|sae,imm8 AVX512,FUTURE
     VGETMANTSS       xmmreg|mask|z,xmmreg,xmmrm32|sae,imm8 AVX512,FUTURE
     VINSERTF32X4     ymmreg|mask|z,ymmreg,xmmrm128,imm8 AVX512VL,AVX512,FUTURE
     VINSERTF32X4     zmmreg|mask|z,zmmreg,xmmrm128,imm8 AVX512,FUTURE
     VINSERTF32X8     zmmreg|mask|z,zmmreg,ymmrm256,imm8 AVX512DQ,FUTURE
     VINSERTF64X2     ymmreg|mask|z,ymmreg,xmmrm128,imm8 AVX512VL,AVX512DQ,FUTURE
     VINSERTF64X2     zmmreg|mask|z,zmmreg,xmmrm128,imm8 AVX512DQ,FUTURE
     VINSERTF64X4     zmmreg|mask|z,zmmreg,ymmrm256,imm8 AVX512,FUTURE
     VINSERTI32X4     ymmreg|mask|z,ymmreg,xmmrm128,imm8 AVX512VL,AVX512,FUTURE
     VINSERTI32X4     zmmreg|mask|z,zmmreg,xmmrm128,imm8 AVX512,FUTURE
     VINSERTI32X8     zmmreg|mask|z,zmmreg,ymmrm256,imm8 AVX512DQ,FUTURE
     VINSERTI64X2     ymmreg|mask|z,ymmreg,xmmrm128,imm8 AVX512VL,AVX512DQ,FUTURE
     VINSERTI64X2     zmmreg|mask|z,zmmreg,xmmrm128,imm8 AVX512DQ,FUTURE
     VINSERTI64X4     zmmreg|mask|z,zmmreg,ymmrm256,imm8 AVX512,FUTURE
     VINSERTPS        xmmreg,xmmreg,xmmrm32,imm8 AVX512,FUTURE
     VMAXPD           xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VMAXPD           ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VMAXPD           zmmreg|mask|z,zmmreg,zmmrm512|b64|sae AVX512,FUTURE
     VMAXPS           xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VMAXPS           ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VMAXPS           zmmreg|mask|z,zmmreg,zmmrm512|b32|sae AVX512,FUTURE
     VMAXSD           xmmreg|mask|z,xmmreg,xmmrm64|sae AVX512,FUTURE
     VMAXSS           xmmreg|mask|z,xmmreg,xmmrm32|sae AVX512,FUTURE
     VMINPD           xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VMINPD           ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VMINPD           zmmreg|mask|z,zmmreg,zmmrm512|b64|sae AVX512,FUTURE
     VMINPS           xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VMINPS           ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VMINPS           zmmreg|mask|z,zmmreg,zmmrm512|b32|sae AVX512,FUTURE
     VMINSD           xmmreg|mask|z,xmmreg,xmmrm64|sae AVX512,FUTURE
     VMINSS           xmmreg|mask|z,xmmreg,xmmrm32|sae AVX512,FUTURE
     VMOVAPD          xmmreg|mask|z,xmmrm128   AVX512VL,AVX512,FUTURE
     VMOVAPD          ymmreg|mask|z,ymmrm256   AVX512VL,AVX512,FUTURE
     VMOVAPD          zmmreg|mask|z,zmmrm512   AVX512,FUTURE
     VMOVAPD          xmmreg|mask|z,xmmreg     AVX512VL,AVX512,FUTURE
     VMOVAPD          ymmreg|mask|z,ymmreg     AVX512VL,AVX512,FUTURE
     VMOVAPD          zmmreg|mask|z,zmmreg     AVX512,FUTURE
     VMOVAPD          mem128|mask,xmmreg       AVX512VL,AVX512,FUTURE
     VMOVAPD          mem256|mask,ymmreg       AVX512VL,AVX512,FUTURE
     VMOVAPD          mem512|mask,zmmreg       AVX512,FUTURE
     VMOVAPS          xmmreg|mask|z,xmmrm128   AVX512VL,AVX512,FUTURE
     VMOVAPS          ymmreg|mask|z,ymmrm256   AVX512VL,AVX512,FUTURE
     VMOVAPS          zmmreg|mask|z,zmmrm512   AVX512,FUTURE
     VMOVAPS          xmmreg|mask|z,xmmreg     AVX512VL,AVX512,FUTURE
     VMOVAPS          ymmreg|mask|z,ymmreg     AVX512VL,AVX512,FUTURE
     VMOVAPS          zmmreg|mask|z,zmmreg     AVX512,FUTURE
     VMOVAPS          mem128|mask,xmmreg       AVX512VL,AVX512,FUTURE
     VMOVAPS          mem256|mask,ymmreg       AVX512VL,AVX512,FUTURE
     VMOVAPS          mem512|mask,zmmreg       AVX512,FUTURE
     VMOVD            xmmreg,rm32              AVX512,FUTURE
     VMOVD            rm32,xmmreg              AVX512,FUTURE
     VMOVDDUP         xmmreg|mask|z,xmmrm64    AVX512VL,AVX512,FUTURE
     VMOVDDUP         ymmreg|mask|z,ymmrm256   AVX512VL,AVX512,FUTURE
     VMOVDDUP         zmmreg|mask|z,zmmrm512   AVX512,FUTURE
     VMOVDQA32        xmmreg|mask|z,xmmrm128   AVX512VL,AVX512,FUTURE
     VMOVDQA32        ymmreg|mask|z,ymmrm256   AVX512VL,AVX512,FUTURE
     VMOVDQA32        zmmreg|mask|z,zmmrm512   AVX512,FUTURE
     VMOVDQA32        xmmreg|mask|z,xmmreg     AVX512VL,AVX512,FUTURE
     VMOVDQA32        ymmreg|mask|z,ymmreg     AVX512VL,AVX512,FUTURE
     VMOVDQA32        zmmreg|mask|z,zmmreg     AVX512,FUTURE
     VMOVDQA32        mem128|mask,xmmreg       AVX512VL,AVX512,FUTURE
     VMOVDQA32        mem256|mask,ymmreg       AVX512VL,AVX512,FUTURE
     VMOVDQA32        mem512|mask,zmmreg       AVX512,FUTURE
     VMOVDQA64        xmmreg|mask|z,xmmrm128   AVX512VL,AVX512,FUTURE
     VMOVDQA64        ymmreg|mask|z,ymmrm256   AVX512VL,AVX512,FUTURE
     VMOVDQA64        zmmreg|mask|z,zmmrm512   AVX512,FUTURE
     VMOVDQA64        xmmreg|mask|z,xmmreg     AVX512VL,AVX512,FUTURE
     VMOVDQA64        ymmreg|mask|z,ymmreg     AVX512VL,AVX512,FUTURE
     VMOVDQA64        zmmreg|mask|z,zmmreg     AVX512,FUTURE
     VMOVDQA64        mem128|mask,xmmreg       AVX512VL,AVX512,FUTURE
     VMOVDQA64        mem256|mask,ymmreg       AVX512VL,AVX512,FUTURE
     VMOVDQA64        mem512|mask,zmmreg       AVX512,FUTURE
     VMOVDQU16        xmmreg|mask|z,xmmrm128   AVX512VL,AVX512BW,FUTURE
     VMOVDQU16        ymmreg|mask|z,ymmrm256   AVX512VL,AVX512BW,FUTURE
     VMOVDQU16        zmmreg|mask|z,zmmrm512   AVX512BW,FUTURE
     VMOVDQU16        xmmreg|mask|z,xmmreg     AVX512VL,AVX512BW,FUTURE
     VMOVDQU16        ymmreg|mask|z,ymmreg     AVX512VL,AVX512BW,FUTURE
     VMOVDQU16        zmmreg|mask|z,zmmreg     AVX512BW,FUTURE
     VMOVDQU16        mem128|mask,xmmreg       AVX512VL,AVX512BW,FUTURE
     VMOVDQU16        mem256|mask,ymmreg       AVX512VL,AVX512BW,FUTURE
     VMOVDQU16        mem512|mask,zmmreg       AVX512BW,FUTURE
     VMOVDQU32        xmmreg|mask|z,xmmrm128   AVX512VL,AVX512,FUTURE
     VMOVDQU32        ymmreg|mask|z,ymmrm256   AVX512VL,AVX512,FUTURE
     VMOVDQU32        zmmreg|mask|z,zmmrm512   AVX512,FUTURE
     VMOVDQU32        xmmreg|mask|z,xmmreg     AVX512VL,AVX512,FUTURE
     VMOVDQU32        ymmreg|mask|z,ymmreg     AVX512VL,AVX512,FUTURE
     VMOVDQU32        zmmreg|mask|z,zmmreg     AVX512,FUTURE
     VMOVDQU32        mem128|mask,xmmreg       AVX512VL,AVX512,FUTURE
     VMOVDQU32        mem256|mask,ymmreg       AVX512VL,AVX512,FUTURE
     VMOVDQU32        mem512|mask,zmmreg       AVX512,FUTURE
     VMOVDQU64        xmmreg|mask|z,xmmrm128   AVX512VL,AVX512,FUTURE
     VMOVDQU64        ymmreg|mask|z,ymmrm256   AVX512VL,AVX512,FUTURE
     VMOVDQU64        zmmreg|mask|z,zmmrm512   AVX512,FUTURE
     VMOVDQU64        xmmreg|mask|z,xmmreg     AVX512VL,AVX512,FUTURE
     VMOVDQU64        ymmreg|mask|z,ymmreg     AVX512VL,AVX512,FUTURE
     VMOVDQU64        zmmreg|mask|z,zmmreg     AVX512,FUTURE
     VMOVDQU64        mem128|mask,xmmreg       AVX512VL,AVX512,FUTURE
     VMOVDQU64        mem256|mask,ymmreg       AVX512VL,AVX512,FUTURE
     VMOVDQU64        mem512|mask,zmmreg       AVX512,FUTURE
     VMOVDQU8         xmmreg|mask|z,xmmrm128   AVX512VL,AVX512BW,FUTURE
     VMOVDQU8         ymmreg|mask|z,ymmrm256   AVX512VL,AVX512BW,FUTURE
     VMOVDQU8         zmmreg|mask|z,zmmrm512   AVX512BW,FUTURE
     VMOVDQU8         xmmreg|mask|z,xmmreg     AVX512VL,AVX512BW,FUTURE
     VMOVDQU8         ymmreg|mask|z,ymmreg     AVX512VL,AVX512BW,FUTURE
     VMOVDQU8         zmmreg|mask|z,zmmreg     AVX512BW,FUTURE
     VMOVDQU8         mem128|mask,xmmreg       AVX512VL,AVX512BW,FUTURE
     VMOVDQU8         mem256|mask,ymmreg       AVX512VL,AVX512BW,FUTURE
     VMOVDQU8         mem512|mask,zmmreg       AVX512BW,FUTURE
     VMOVHLPS         xmmreg,xmmreg,xmmreg     AVX512,FUTURE
     VMOVHPD          xmmreg,xmmreg,mem64      AVX512,FUTURE
     VMOVHPD          mem64,xmmreg             AVX512,FUTURE
     VMOVHPS          xmmreg,xmmreg,mem64      AVX512,FUTURE
     VMOVHPS          mem64,xmmreg             AVX512,FUTURE
     VMOVLHPS         xmmreg,xmmreg,xmmreg     AVX512,FUTURE
     VMOVLPD          xmmreg,xmmreg,mem64      AVX512,FUTURE
     VMOVLPD          mem64,xmmreg             AVX512,FUTURE
     VMOVLPS          xmmreg,xmmreg,mem64      AVX512,FUTURE
     VMOVLPS          mem64,xmmreg             AVX512,FUTURE
     VMOVNTDQ         mem128,xmmreg            AVX512VL,AVX512,FUTURE
     VMOVNTDQ         mem256,ymmreg            AVX512VL,AVX512,FUTURE
     VMOVNTDQ         mem512,zmmreg            AVX512,FUTURE
     VMOVNTDQA        xmmreg,mem128            AVX512VL,AVX512,FUTURE
     VMOVNTDQA        ymmreg,mem256            AVX512VL,AVX512,FUTURE
     VMOVNTDQA        zmmreg,mem512            AVX512,FUTURE
     VMOVNTPD         mem128,xmmreg            AVX512VL,AVX512,FUTURE
     VMOVNTPD         mem256,ymmreg            AVX512VL,AVX512,FUTURE
     VMOVNTPD         mem512,zmmreg            AVX512,FUTURE
     VMOVNTPS         mem128,xmmreg            AVX512VL,AVX512,FUTURE
     VMOVNTPS         mem256,ymmreg            AVX512VL,AVX512,FUTURE
     VMOVNTPS         mem512,zmmreg            AVX512,FUTURE
     VMOVQ            xmmreg,rm64              AVX512,FUTURE
     VMOVQ            rm64,xmmreg              AVX512,FUTURE
     VMOVQ            xmmreg,xmmrm64           AVX512,FUTURE
     VMOVQ            xmmrm64,xmmreg           AVX512,FUTURE
     VMOVSD           xmmreg|mask|z,mem64      AVX512,FUTURE
     VMOVSD           mem64|mask,xmmreg        AVX512,FUTURE
     VMOVSD           xmmreg|mask|z,xmmreg,xmmreg AVX512,FUTURE
     VMOVSD           xmmreg|mask|z,xmmreg,xmmreg AVX512,FUTURE
     VMOVSHDUP        xmmreg|mask|z,xmmrm128   AVX512VL,AVX512,FUTURE
     VMOVSHDUP        ymmreg|mask|z,ymmrm256   AVX512VL,AVX512,FUTURE
     VMOVSHDUP        zmmreg|mask|z,zmmrm512   AVX512,FUTURE
     VMOVSLDUP        xmmreg|mask|z,xmmrm128   AVX512VL,AVX512,FUTURE
     VMOVSLDUP        ymmreg|mask|z,ymmrm256   AVX512VL,AVX512,FUTURE
     VMOVSLDUP        zmmreg|mask|z,zmmrm512   AVX512,FUTURE
     VMOVSS           xmmreg|mask|z,mem32      AVX512,FUTURE
     VMOVSS           mem32|mask,xmmreg        AVX512,FUTURE
     VMOVSS           xmmreg|mask|z,xmmreg,xmmreg AVX512,FUTURE
     VMOVSS           xmmreg|mask|z,xmmreg,xmmreg AVX512,FUTURE
     VMOVUPD          xmmreg|mask|z,xmmrm128   AVX512VL,AVX512,FUTURE
     VMOVUPD          ymmreg|mask|z,ymmrm256   AVX512VL,AVX512,FUTURE
     VMOVUPD          zmmreg|mask|z,zmmrm512   AVX512,FUTURE
     VMOVUPD          xmmreg|mask|z,xmmreg     AVX512VL,AVX512,FUTURE
     VMOVUPD          ymmreg|mask|z,ymmreg     AVX512VL,AVX512,FUTURE
     VMOVUPD          zmmreg|mask|z,zmmreg     AVX512,FUTURE
     VMOVUPD          mem128|mask,xmmreg       AVX512VL,AVX512,FUTURE
     VMOVUPD          mem256|mask,ymmreg       AVX512VL,AVX512,FUTURE
     VMOVUPD          mem512|mask,zmmreg       AVX512,FUTURE
     VMOVUPS          xmmreg|mask|z,xmmrm128   AVX512VL,AVX512,FUTURE
     VMOVUPS          ymmreg|mask|z,ymmrm256   AVX512VL,AVX512,FUTURE
     VMOVUPS          zmmreg|mask|z,zmmrm512   AVX512,FUTURE
     VMOVUPS          xmmreg|mask|z,xmmreg     AVX512VL,AVX512,FUTURE
     VMOVUPS          ymmreg|mask|z,ymmreg     AVX512VL,AVX512,FUTURE
     VMOVUPS          zmmreg|mask|z,zmmreg     AVX512,FUTURE
     VMOVUPS          mem128|mask,xmmreg       AVX512VL,AVX512,FUTURE
     VMOVUPS          mem256|mask,ymmreg       AVX512VL,AVX512,FUTURE
     VMOVUPS          mem512|mask,zmmreg       AVX512,FUTURE
     VMULPD           xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VMULPD           ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VMULPD           zmmreg|mask|z,zmmreg,zmmrm512|b64|er AVX512,FUTURE
     VMULPS           xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VMULPS           ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VMULPS           zmmreg|mask|z,zmmreg,zmmrm512|b32|er AVX512,FUTURE
     VMULSD           xmmreg|mask|z,xmmreg,xmmrm64|er AVX512,FUTURE
     VMULSS           xmmreg|mask|z,xmmreg,xmmrm32|er AVX512,FUTURE
     VORPD            xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512DQ,FUTURE
     VORPD            ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512DQ,FUTURE
     VORPD            zmmreg|mask|z,zmmreg,zmmrm512|b64 AVX512DQ,FUTURE
     VORPS            xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512DQ,FUTURE
     VORPS            ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512DQ,FUTURE
     VORPS            zmmreg|mask|z,zmmreg,zmmrm512|b32 AVX512DQ,FUTURE
     VPABSB           xmmreg|mask|z,xmmrm128   AVX512VL,AVX512BW,FUTURE
     VPABSB           ymmreg|mask|z,ymmrm256   AVX512VL,AVX512BW,FUTURE
     VPABSB           zmmreg|mask|z,zmmrm512   AVX512BW,FUTURE
     VPABSD           xmmreg|mask|z,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VPABSD           ymmreg|mask|z,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VPABSD           zmmreg|mask|z,zmmrm512|b32 AVX512,FUTURE
     VPABSQ           xmmreg|mask|z,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VPABSQ           ymmreg|mask|z,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VPABSQ           zmmreg|mask|z,zmmrm512|b64 AVX512,FUTURE
     VPABSW           xmmreg|mask|z,xmmrm128   AVX512VL,AVX512BW,FUTURE
     VPABSW           ymmreg|mask|z,ymmrm256   AVX512VL,AVX512BW,FUTURE
     VPABSW           zmmreg|mask|z,zmmrm512   AVX512BW,FUTURE
     VPACKSSDW        xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512BW,FUTURE
     VPACKSSDW        ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512BW,FUTURE
     VPACKSSDW        zmmreg|mask|z,zmmreg,zmmrm512|b32 AVX512BW,FUTURE
     VPACKSSWB        xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPACKSSWB        ymmreg|mask|z,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPACKSSWB        zmmreg|mask|z,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPACKUSDW        xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512BW,FUTURE
     VPACKUSDW        ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512BW,FUTURE
     VPACKUSDW        zmmreg|mask|z,zmmreg,zmmrm512|b32 AVX512BW,FUTURE
     VPACKUSWB        xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPACKUSWB        ymmreg|mask|z,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPACKUSWB        zmmreg|mask|z,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPADDB           xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPADDB           ymmreg|mask|z,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPADDB           zmmreg|mask|z,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPADDD           xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VPADDD           ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VPADDD           zmmreg|mask|z,zmmreg,zmmrm512|b32 AVX512,FUTURE
     VPADDQ           xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VPADDQ           ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VPADDQ           zmmreg|mask|z,zmmreg,zmmrm512|b64 AVX512,FUTURE
     VPADDSB          xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPADDSB          ymmreg|mask|z,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPADDSB          zmmreg|mask|z,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPADDSW          xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPADDSW          ymmreg|mask|z,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPADDSW          zmmreg|mask|z,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPADDUSB         xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPADDUSB         ymmreg|mask|z,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPADDUSB         zmmreg|mask|z,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPADDUSW         xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPADDUSW         ymmreg|mask|z,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPADDUSW         zmmreg|mask|z,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPADDW           xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPADDW           ymmreg|mask|z,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPADDW           zmmreg|mask|z,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPALIGNR         xmmreg|mask|z,xmmreg,xmmrm128,imm8 AVX512VL,AVX512BW,FUTURE
     VPALIGNR         ymmreg|mask|z,ymmreg,ymmrm256,imm8 AVX512VL,AVX512BW,FUTURE
     VPALIGNR         zmmreg|mask|z,zmmreg,zmmrm512,imm8 AVX512BW,FUTURE
     VPANDD           xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VPANDD           ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VPANDD           zmmreg|mask|z,zmmreg,zmmrm512|b32 AVX512,FUTURE
     VPANDND          xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VPANDND          ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VPANDND          zmmreg|mask|z,zmmreg,zmmrm512|b32 AVX512,FUTURE
     VPANDNQ          xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VPANDNQ          ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VPANDNQ          zmmreg|mask|z,zmmreg,zmmrm512|b64 AVX512,FUTURE
     VPANDQ           xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VPANDQ           ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VPANDQ           zmmreg|mask|z,zmmreg,zmmrm512|b64 AVX512,FUTURE
     VPAVGB           xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPAVGB           ymmreg|mask|z,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPAVGB           zmmreg|mask|z,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPAVGW           xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPAVGW           ymmreg|mask|z,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPAVGW           zmmreg|mask|z,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPBLENDMB        xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPBLENDMB        ymmreg|mask|z,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPBLENDMB        zmmreg|mask|z,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPBLENDMD        xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VPBLENDMD        ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VPBLENDMD        zmmreg|mask|z,zmmreg,zmmrm512|b32 AVX512,FUTURE
     VPBLENDMQ        xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VPBLENDMQ        ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VPBLENDMQ        zmmreg|mask|z,zmmreg,zmmrm512|b64 AVX512,FUTURE
     VPBLENDMW        xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPBLENDMW        ymmreg|mask|z,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPBLENDMW        zmmreg|mask|z,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPBROADCASTB     xmmreg|mask|z,xmmrm8     AVX512VL,AVX512BW,FUTURE
     VPBROADCASTB     ymmreg|mask|z,xmmrm8     AVX512VL,AVX512BW,FUTURE
     VPBROADCASTB     zmmreg|mask|z,xmmrm8     AVX512BW,FUTURE
     VPBROADCASTB     xmmreg|mask|z,reg8       AVX512VL,AVX512BW,FUTURE
     VPBROADCASTB     xmmreg|mask|z,reg16      AVX512VL,AVX512BW,FUTURE
     VPBROADCASTB     xmmreg|mask|z,reg32      AVX512VL,AVX512BW,FUTURE
     VPBROADCASTB     xmmreg|mask|z,reg64      AVX512VL,AVX512BW,FUTURE
     VPBROADCASTB     ymmreg|mask|z,reg8       AVX512VL,AVX512BW,FUTURE
     VPBROADCASTB     ymmreg|mask|z,reg16      AVX512VL,AVX512BW,FUTURE
     VPBROADCASTB     ymmreg|mask|z,reg32      AVX512VL,AVX512BW,FUTURE
     VPBROADCASTB     ymmreg|mask|z,reg64      AVX512VL,AVX512BW,FUTURE
     VPBROADCASTB     zmmreg|mask|z,reg8       AVX512BW,FUTURE
     VPBROADCASTB     zmmreg|mask|z,reg16      AVX512BW,FUTURE
     VPBROADCASTB     zmmreg|mask|z,reg32      AVX512BW,FUTURE
     VPBROADCASTB     zmmreg|mask|z,reg64      AVX512BW,FUTURE
     VPBROADCASTD     xmmreg|mask|z,mem32      AVX512VL,AVX512,FUTURE
     VPBROADCASTD     ymmreg|mask|z,mem32      AVX512VL,AVX512,FUTURE
     VPBROADCASTD     zmmreg|mask|z,mem32      AVX512,FUTURE
     VPBROADCASTD     xmmreg|mask|z,xmmreg     AVX512VL,AVX512,FUTURE
     VPBROADCASTD     ymmreg|mask|z,xmmreg     AVX512VL,AVX512,FUTURE
     VPBROADCASTD     zmmreg|mask|z,xmmreg     AVX512,FUTURE
     VPBROADCASTD     xmmreg|mask|z,reg32      AVX512VL,AVX512,FUTURE
     VPBROADCASTD     ymmreg|mask|z,reg32      AVX512VL,AVX512,FUTURE
     VPBROADCASTD     zmmreg|mask|z,reg32      AVX512,FUTURE
     VPBROADCASTMB2Q  xmmreg,kreg              AVX512VL,AVX512CD,FUTURE
     VPBROADCASTMB2Q  ymmreg,kreg              AVX512VL,AVX512CD,FUTURE
     VPBROADCASTMB2Q  zmmreg,kreg              AVX512CD,FUTURE
     VPBROADCASTMW2D  xmmreg,kreg              AVX512VL,AVX512CD,FUTURE
     VPBROADCASTMW2D  ymmreg,kreg              AVX512VL,AVX512CD,FUTURE
     VPBROADCASTMW2D  zmmreg,kreg              AVX512CD,FUTURE
     VPBROADCASTQ     xmmreg|mask|z,mem64      AVX512VL,AVX512,FUTURE
     VPBROADCASTQ     ymmreg|mask|z,mem64      AVX512VL,AVX512,FUTURE
     VPBROADCASTQ     zmmreg|mask|z,mem64      AVX512,FUTURE
     VPBROADCASTQ     xmmreg|mask|z,xmmreg     AVX512VL,AVX512,FUTURE
     VPBROADCASTQ     ymmreg|mask|z,xmmreg     AVX512VL,AVX512,FUTURE
     VPBROADCASTQ     zmmreg|mask|z,xmmreg     AVX512,FUTURE
     VPBROADCASTQ     xmmreg|mask|z,reg64      AVX512VL,AVX512,FUTURE
     VPBROADCASTQ     ymmreg|mask|z,reg64      AVX512VL,AVX512,FUTURE
     VPBROADCASTQ     zmmreg|mask|z,reg64      AVX512,FUTURE
     VPBROADCASTW     xmmreg|mask|z,xmmrm16    AVX512VL,AVX512BW,FUTURE
     VPBROADCASTW     ymmreg|mask|z,xmmrm16    AVX512VL,AVX512BW,FUTURE
     VPBROADCASTW     zmmreg|mask|z,xmmrm16    AVX512BW,FUTURE
     VPBROADCASTW     xmmreg|mask|z,reg16      AVX512VL,AVX512BW,FUTURE
     VPBROADCASTW     xmmreg|mask|z,reg32      AVX512VL,AVX512BW,FUTURE
     VPBROADCASTW     xmmreg|mask|z,reg64      AVX512VL,AVX512BW,FUTURE
     VPBROADCASTW     ymmreg|mask|z,reg16      AVX512VL,AVX512BW,FUTURE
     VPBROADCASTW     ymmreg|mask|z,reg32      AVX512VL,AVX512BW,FUTURE
     VPBROADCASTW     ymmreg|mask|z,reg64      AVX512VL,AVX512BW,FUTURE
     VPBROADCASTW     zmmreg|mask|z,reg16      AVX512BW,FUTURE
     VPBROADCASTW     zmmreg|mask|z,reg32      AVX512BW,FUTURE
     VPBROADCASTW     zmmreg|mask|z,reg64      AVX512BW,FUTURE
     VPCMPB           kreg|mask,xmmreg,xmmrm128,imm8 AVX512VL,AVX512BW,FUTURE
     VPCMPB           kreg|mask,ymmreg,ymmrm256,imm8 AVX512VL,AVX512BW,FUTURE
     VPCMPB           kreg|mask,zmmreg,zmmrm512,imm8 AVX512BW,FUTURE
     VPCMPD           kreg|mask,xmmreg,xmmrm128|b32,imm8 AVX512VL,AVX512,FUTURE
     VPCMPD           kreg|mask,ymmreg,ymmrm256|b32,imm8 AVX512VL,AVX512,FUTURE
     VPCMPD           kreg|mask,zmmreg,zmmrm512|b32,imm8 AVX512,FUTURE
     VPCMPEQB         kreg|mask,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPCMPEQB         kreg|mask,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPCMPEQB         kreg|mask,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPCMPEQD         kreg|mask,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VPCMPEQD         kreg|mask,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VPCMPEQD         kreg|mask,zmmreg,zmmrm512|b32 AVX512,FUTURE
     VPCMPEQQ         kreg|mask,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VPCMPEQQ         kreg|mask,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VPCMPEQQ         kreg|mask,zmmreg,zmmrm512|b64 AVX512,FUTURE
     VPCMPEQW         kreg|mask,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPCMPEQW         kreg|mask,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPCMPEQW         kreg|mask,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPCMPGTB         kreg|mask,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPCMPGTB         kreg|mask,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPCMPGTB         kreg|mask,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPCMPGTD         kreg|mask,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VPCMPGTD         kreg|mask,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VPCMPGTD         kreg|mask,zmmreg,zmmrm512|b32 AVX512,FUTURE
     VPCMPGTQ         kreg|mask,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VPCMPGTQ         kreg|mask,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VPCMPGTQ         kreg|mask,zmmreg,zmmrm512|b64 AVX512,FUTURE
     VPCMPGTW         kreg|mask,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPCMPGTW         kreg|mask,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPCMPGTW         kreg|mask,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPCMPQ           kreg|mask,xmmreg,xmmrm128|b64,imm8 AVX512VL,AVX512,FUTURE
     VPCMPQ           kreg|mask,ymmreg,ymmrm256|b64,imm8 AVX512VL,AVX512,FUTURE
     VPCMPQ           kreg|mask,zmmreg,zmmrm512|b64,imm8 AVX512,FUTURE
     VPCMPUB          kreg|mask,xmmreg,xmmrm128,imm8 AVX512VL,AVX512BW,FUTURE
     VPCMPUB          kreg|mask,ymmreg,ymmrm256,imm8 AVX512VL,AVX512BW,FUTURE
     VPCMPUB          kreg|mask,zmmreg,zmmrm512,imm8 AVX512BW,FUTURE
     VPCMPUD          kreg|mask,xmmreg,xmmrm128|b32,imm8 AVX512VL,AVX512,FUTURE
     VPCMPUD          kreg|mask,ymmreg,ymmrm256|b32,imm8 AVX512VL,AVX512,FUTURE
     VPCMPUD          kreg|mask,zmmreg,zmmrm512|b32,imm8 AVX512,FUTURE
     VPCMPUQ          kreg|mask,xmmreg,xmmrm128|b64,imm8 AVX512VL,AVX512,FUTURE
     VPCMPUQ          kreg|mask,ymmreg,ymmrm256|b64,imm8 AVX512VL,AVX512,FUTURE
     VPCMPUQ          kreg|mask,zmmreg,zmmrm512|b64,imm8 AVX512,FUTURE
     VPCMPUW          kreg|mask,xmmreg,xmmrm128,imm8 AVX512VL,AVX512BW,FUTURE
     VPCMPUW          kreg|mask,ymmreg,ymmrm256,imm8 AVX512VL,AVX512BW,FUTURE
     VPCMPUW          kreg|mask,zmmreg,zmmrm512,imm8 AVX512BW,FUTURE
     VPCMPW           kreg|mask,xmmreg,xmmrm128,imm8 AVX512VL,AVX512BW,FUTURE
     VPCMPW           kreg|mask,ymmreg,ymmrm256,imm8 AVX512VL,AVX512BW,FUTURE
     VPCMPW           kreg|mask,zmmreg,zmmrm512,imm8 AVX512BW,FUTURE
     VPCOMPRESSD      mem128|mask,xmmreg       AVX512VL,AVX512,FUTURE
     VPCOMPRESSD      mem256|mask,ymmreg       AVX512VL,AVX512,FUTURE
     VPCOMPRESSD      mem512|mask,zmmreg       AVX512,FUTURE
     VPCOMPRESSD      xmmreg|mask|z,xmmreg     AVX512VL,AVX512,FUTURE
     VPCOMPRESSD      ymmreg|mask|z,ymmreg     AVX512VL,AVX512,FUTURE
     VPCOMPRESSD      zmmreg|mask|z,zmmreg     AVX512,FUTURE
     VPCOMPRESSQ      mem128|mask,xmmreg       AVX512VL,AVX512,FUTURE
     VPCOMPRESSQ      mem256|mask,ymmreg       AVX512VL,AVX512,FUTURE
     VPCOMPRESSQ      mem512|mask,zmmreg       AVX512,FUTURE
     VPCOMPRESSQ      xmmreg|mask|z,xmmreg     AVX512VL,AVX512,FUTURE
     VPCOMPRESSQ      ymmreg|mask|z,ymmreg     AVX512VL,AVX512,FUTURE
     VPCOMPRESSQ      zmmreg|mask|z,zmmreg     AVX512,FUTURE
     VPCONFLICTD      xmmreg|mask|z,xmmrm128|b32 AVX512VL,AVX512CD,FUTURE
     VPCONFLICTD      ymmreg|mask|z,ymmrm256|b32 AVX512VL,AVX512CD,FUTURE
     VPCONFLICTD      zmmreg|mask|z,zmmrm512|b32 AVX512CD,FUTURE
     VPCONFLICTQ      xmmreg|mask|z,xmmrm128|b64 AVX512VL,AVX512CD,FUTURE
     VPCONFLICTQ      ymmreg|mask|z,ymmrm256|b64 AVX512VL,AVX512CD,FUTURE
     VPCONFLICTQ      zmmreg|mask|z,zmmrm512|b64 AVX512CD,FUTURE
     VPERMB           xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512VBMI,FUTURE
     VPERMB           ymmreg|mask|z,ymmreg,ymmrm256 AVX512VL,AVX512VBMI,FUTURE
     VPERMB           zmmreg|mask|z,zmmreg,zmmrm512 AVX512VBMI,FUTURE
     VPERMD           ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VPERMD           zmmreg|mask|z,zmmreg,zmmrm512|b32 AVX512,FUTURE
     VPERMI2B         xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512VBMI,FUTURE
     VPERMI2B         ymmreg|mask|z,ymmreg,ymmrm256 AVX512VL,AVX512VBMI,FUTURE
     VPERMI2B         zmmreg|mask|z,zmmreg,zmmrm512 AVX512VBMI,FUTURE
     VPERMI2D         xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VPERMI2D         ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VPERMI2D         zmmreg|mask|z,zmmreg,zmmrm512|b32 AVX512,FUTURE
     VPERMI2PD        xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VPERMI2PD        ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VPERMI2PD        zmmreg|mask|z,zmmreg,zmmrm512|b64 AVX512,FUTURE
     VPERMI2PS        xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VPERMI2PS        ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VPERMI2PS        zmmreg|mask|z,zmmreg,zmmrm512|b32 AVX512,FUTURE
     VPERMI2Q         xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VPERMI2Q         ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VPERMI2Q         zmmreg|mask|z,zmmreg,zmmrm512|b64 AVX512,FUTURE
     VPERMI2W         xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPERMI2W         ymmreg|mask|z,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPERMI2W         zmmreg|mask|z,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPERMILPD        xmmreg|mask|z,xmmrm128|b64,imm8 AVX512VL,AVX512,FUTURE
     VPERMILPD        ymmreg|mask|z,ymmrm256|b64,imm8 AVX512VL,AVX512,FUTURE
     VPERMILPD        zmmreg|mask|z,zmmrm512|b64,imm8 AVX512,FUTURE
     VPERMILPD        xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VPERMILPD        ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VPERMILPD        zmmreg|mask|z,zmmreg,zmmrm512|b64 AVX512,FUTURE
     VPERMILPS        xmmreg|mask|z,xmmrm128|b32,imm8 AVX512VL,AVX512,FUTURE
     VPERMILPS        ymmreg|mask|z,ymmrm256|b32,imm8 AVX512VL,AVX512,FUTURE
     VPERMILPS        zmmreg|mask|z,zmmrm512|b32,imm8 AVX512,FUTURE
     VPERMILPS        xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VPERMILPS        ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VPERMILPS        zmmreg|mask|z,zmmreg,zmmrm512|b32 AVX512,FUTURE
     VPERMPD          ymmreg|mask|z,ymmrm256|b64,imm8 AVX512VL,AVX512,FUTURE
     VPERMPD          zmmreg|mask|z,zmmrm512|b64,imm8 AVX512,FUTURE
     VPERMPD          ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VPERMPD          zmmreg|mask|z,zmmreg,zmmrm512|b64 AVX512,FUTURE
     VPERMPS          ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VPERMPS          zmmreg|mask|z,zmmreg,zmmrm512|b32 AVX512,FUTURE
     VPERMQ           ymmreg|mask|z,ymmrm256|b64,imm8 AVX512VL,AVX512,FUTURE
     VPERMQ           zmmreg|mask|z,zmmrm512|b64,imm8 AVX512,FUTURE
     VPERMQ           ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VPERMQ           zmmreg|mask|z,zmmreg,zmmrm512|b64 AVX512,FUTURE
     VPERMT2B         xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512VBMI,FUTURE
     VPERMT2B         ymmreg|mask|z,ymmreg,ymmrm256 AVX512VL,AVX512VBMI,FUTURE
     VPERMT2B         zmmreg|mask|z,zmmreg,zmmrm512 AVX512VBMI,FUTURE
     VPERMT2D         xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VPERMT2D         ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VPERMT2D         zmmreg|mask|z,zmmreg,zmmrm512|b32 AVX512,FUTURE
     VPERMT2PD        xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VPERMT2PD        ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VPERMT2PD        zmmreg|mask|z,zmmreg,zmmrm512|b64 AVX512,FUTURE
     VPERMT2PS        xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VPERMT2PS        ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VPERMT2PS        zmmreg|mask|z,zmmreg,zmmrm512|b32 AVX512,FUTURE
     VPERMT2Q         xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VPERMT2Q         ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VPERMT2Q         zmmreg|mask|z,zmmreg,zmmrm512|b64 AVX512,FUTURE
     VPERMT2W         xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPERMT2W         ymmreg|mask|z,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPERMT2W         zmmreg|mask|z,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPERMW           xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPERMW           ymmreg|mask|z,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPERMW           zmmreg|mask|z,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPEXPANDD        xmmreg|mask|z,mem128     AVX512VL,AVX512,FUTURE
     VPEXPANDD        ymmreg|mask|z,mem256     AVX512VL,AVX512,FUTURE
     VPEXPANDD        zmmreg|mask|z,mem512     AVX512,FUTURE
     VPEXPANDD        xmmreg|mask|z,xmmreg     AVX512VL,AVX512,FUTURE
     VPEXPANDD        ymmreg|mask|z,ymmreg     AVX512VL,AVX512,FUTURE
     VPEXPANDD        zmmreg|mask|z,zmmreg     AVX512,FUTURE
     VPEXPANDQ        xmmreg|mask|z,mem128     AVX512VL,AVX512,FUTURE
     VPEXPANDQ        ymmreg|mask|z,mem256     AVX512VL,AVX512,FUTURE
     VPEXPANDQ        zmmreg|mask|z,mem512     AVX512,FUTURE
     VPEXPANDQ        xmmreg|mask|z,xmmreg     AVX512VL,AVX512,FUTURE
     VPEXPANDQ        ymmreg|mask|z,ymmreg     AVX512VL,AVX512,FUTURE
     VPEXPANDQ        zmmreg|mask|z,zmmreg     AVX512,FUTURE
     VPEXTRB          reg8,xmmreg,imm8         AVX512BW,FUTURE
     VPEXTRB          reg16,xmmreg,imm8        AVX512BW,FUTURE
     VPEXTRB          reg32,xmmreg,imm8        AVX512BW,FUTURE
     VPEXTRB          reg64,xmmreg,imm8        AVX512BW,FUTURE
     VPEXTRB          mem8,xmmreg,imm8         AVX512BW,FUTURE
     VPEXTRD          rm32,xmmreg,imm8         AVX512DQ,FUTURE
     VPEXTRQ          rm64,xmmreg,imm8         AVX512DQ,FUTURE
     VPEXTRW          reg16,xmmreg,imm8        AVX512BW,FUTURE
     VPEXTRW          reg32,xmmreg,imm8        AVX512BW,FUTURE
     VPEXTRW          reg64,xmmreg,imm8        AVX512BW,FUTURE
     VPEXTRW          mem16,xmmreg,imm8        AVX512BW,FUTURE
     VPEXTRW          reg16,xmmreg,imm8        AVX512BW,FUTURE
     VPEXTRW          reg32,xmmreg,imm8        AVX512BW,FUTURE
     VPEXTRW          reg64,xmmreg,imm8        AVX512BW,FUTURE
     VPGATHERDD       xmmreg|mask,xmem32       AVX512VL,AVX512,FUTURE
     VPGATHERDD       ymmreg|mask,ymem32       AVX512VL,AVX512,FUTURE
     VPGATHERDD       zmmreg|mask,zmem32       AVX512,FUTURE
     VPGATHERDQ       xmmreg|mask,xmem64       AVX512VL,AVX512,FUTURE
     VPGATHERDQ       ymmreg|mask,xmem64       AVX512VL,AVX512,FUTURE
     VPGATHERDQ       zmmreg|mask,ymem64       AVX512,FUTURE
     VPGATHERQD       xmmreg|mask,xmem32       AVX512VL,AVX512,FUTURE
     VPGATHERQD       xmmreg|mask,ymem32       AVX512VL,AVX512,FUTURE
     VPGATHERQD       ymmreg|mask,zmem32       AVX512,FUTURE
     VPGATHERQQ       xmmreg|mask,xmem64       AVX512VL,AVX512,FUTURE
     VPGATHERQQ       ymmreg|mask,ymem64       AVX512VL,AVX512,FUTURE
     VPGATHERQQ       zmmreg|mask,zmem64       AVX512,FUTURE
     VPINSRB          xmmreg,xmmreg,reg32,imm8 AVX512BW,FUTURE
     VPINSRB          xmmreg,xmmreg,mem8,imm8  AVX512BW,FUTURE
     VPINSRD          xmmreg,xmmreg,rm32,imm8  AVX512DQ,FUTURE
     VPINSRQ          xmmreg,xmmreg,rm64,imm8  AVX512DQ,FUTURE
     VPINSRW          xmmreg,xmmreg,reg32,imm8 AVX512BW,FUTURE
     VPINSRW          xmmreg,xmmreg,mem16,imm8 AVX512BW,FUTURE
     VPLZCNTD         xmmreg|mask|z,xmmrm128|b32 AVX512VL,AVX512CD,FUTURE
     VPLZCNTD         ymmreg|mask|z,ymmrm256|b32 AVX512VL,AVX512CD,FUTURE
     VPLZCNTD         zmmreg|mask|z,zmmrm512|b32 AVX512CD,FUTURE
     VPLZCNTQ         xmmreg|mask|z,xmmrm128|b64 AVX512VL,AVX512CD,FUTURE
     VPLZCNTQ         ymmreg|mask|z,ymmrm256|b64 AVX512VL,AVX512CD,FUTURE
     VPLZCNTQ         zmmreg|mask|z,zmmrm512|b64 AVX512CD,FUTURE
     VPMADD52HUQ      xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512IFMA,FUTURE
     VPMADD52HUQ      ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512IFMA,FUTURE
     VPMADD52HUQ      zmmreg|mask|z,zmmreg,zmmrm512|b64 AVX512IFMA,FUTURE
     VPMADD52LUQ      xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512IFMA,FUTURE
     VPMADD52LUQ      ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512IFMA,FUTURE
     VPMADD52LUQ      zmmreg|mask|z,zmmreg,zmmrm512|b64 AVX512IFMA,FUTURE
     VPMADDUBSW       xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPMADDUBSW       ymmreg|mask|z,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPMADDUBSW       zmmreg|mask|z,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPMADDWD         xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPMADDWD         ymmreg|mask|z,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPMADDWD         zmmreg|mask|z,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPMAXSB          xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPMAXSB          ymmreg|mask|z,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPMAXSB          zmmreg|mask|z,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPMAXSD          xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VPMAXSD          ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VPMAXSD          zmmreg|mask|z,zmmreg,zmmrm512|b32 AVX512,FUTURE
     VPMAXSQ          xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VPMAXSQ          ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VPMAXSQ          zmmreg|mask|z,zmmreg,zmmrm512|b64 AVX512,FUTURE
     VPMAXSW          xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPMAXSW          ymmreg|mask|z,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPMAXSW          zmmreg|mask|z,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPMAXUB          xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPMAXUB          ymmreg|mask|z,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPMAXUB          zmmreg|mask|z,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPMAXUD          xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VPMAXUD          ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VPMAXUD          zmmreg|mask|z,zmmreg,zmmrm512|b32 AVX512,FUTURE
     VPMAXUQ          xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VPMAXUQ          ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VPMAXUQ          zmmreg|mask|z,zmmreg,zmmrm512|b64 AVX512,FUTURE
     VPMAXUW          xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPMAXUW          ymmreg|mask|z,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPMAXUW          zmmreg|mask|z,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPMINSB          xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPMINSB          ymmreg|mask|z,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPMINSB          zmmreg|mask|z,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPMINSD          xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VPMINSD          ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VPMINSD          zmmreg|mask|z,zmmreg,zmmrm512|b32 AVX512,FUTURE
     VPMINSQ          xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VPMINSQ          ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VPMINSQ          zmmreg|mask|z,zmmreg,zmmrm512|b64 AVX512,FUTURE
     VPMINSW          xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPMINSW          ymmreg|mask|z,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPMINSW          zmmreg|mask|z,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPMINUB          xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPMINUB          ymmreg|mask|z,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPMINUB          zmmreg|mask|z,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPMINUD          xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VPMINUD          ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VPMINUD          zmmreg|mask|z,zmmreg,zmmrm512|b32 AVX512,FUTURE
     VPMINUQ          xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VPMINUQ          ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VPMINUQ          zmmreg|mask|z,zmmreg,zmmrm512|b64 AVX512,FUTURE
     VPMINUW          xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPMINUW          ymmreg|mask|z,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPMINUW          zmmreg|mask|z,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPMOVB2M         kreg,xmmreg              AVX512VL,AVX512BW,FUTURE
     VPMOVB2M         kreg,ymmreg              AVX512VL,AVX512BW,FUTURE
     VPMOVB2M         kreg,zmmreg              AVX512BW,FUTURE
     VPMOVD2M         kreg,xmmreg              AVX512VL,AVX512DQ,FUTURE
     VPMOVD2M         kreg,ymmreg              AVX512VL,AVX512DQ,FUTURE
     VPMOVD2M         kreg,zmmreg              AVX512DQ,FUTURE
     VPMOVDB          xmmreg|mask|z,xmmreg     AVX512VL,AVX512,FUTURE
     VPMOVDB          xmmreg|mask|z,ymmreg     AVX512VL,AVX512,FUTURE
     VPMOVDB          xmmreg|mask|z,zmmreg     AVX512,FUTURE
     VPMOVDB          mem32|mask,xmmreg        AVX512VL,AVX512,FUTURE
     VPMOVDB          mem64|mask,ymmreg        AVX512VL,AVX512,FUTURE
     VPMOVDB          mem128|mask,zmmreg       AVX512,FUTURE
     VPMOVDW          xmmreg|mask|z,xmmreg     AVX512VL,AVX512,FUTURE
     VPMOVDW          xmmreg|mask|z,ymmreg     AVX512VL,AVX512,FUTURE
     VPMOVDW          ymmreg|mask|z,zmmreg     AVX512,FUTURE
     VPMOVDW          mem64|mask,xmmreg        AVX512VL,AVX512,FUTURE
     VPMOVDW          mem128|mask,ymmreg       AVX512VL,AVX512,FUTURE
     VPMOVDW          mem256|mask,zmmreg       AVX512,FUTURE
     VPMOVM2B         xmmreg,kreg              AVX512VL,AVX512BW,FUTURE
     VPMOVM2B         ymmreg,kreg              AVX512VL,AVX512BW,FUTURE
     VPMOVM2B         zmmreg,kreg              AVX512BW,FUTURE
     VPMOVM2D         xmmreg,kreg              AVX512VL,AVX512DQ,FUTURE
     VPMOVM2D         ymmreg,kreg              AVX512VL,AVX512DQ,FUTURE
     VPMOVM2D         zmmreg,kreg              AVX512DQ,FUTURE
     VPMOVM2Q         xmmreg,kreg              AVX512VL,AVX512DQ,FUTURE
     VPMOVM2Q         ymmreg,kreg              AVX512VL,AVX512DQ,FUTURE
     VPMOVM2Q         zmmreg,kreg              AVX512DQ,FUTURE
     VPMOVM2W         xmmreg,kreg              AVX512VL,AVX512BW,FUTURE
     VPMOVM2W         ymmreg,kreg              AVX512VL,AVX512BW,FUTURE
     VPMOVM2W         zmmreg,kreg              AVX512BW,FUTURE
     VPMOVQ2M         kreg,xmmreg              AVX512VL,AVX512DQ,FUTURE
     VPMOVQ2M         kreg,ymmreg              AVX512VL,AVX512DQ,FUTURE
     VPMOVQ2M         kreg,zmmreg              AVX512DQ,FUTURE
     VPMOVQB          xmmreg|mask|z,xmmreg     AVX512VL,AVX512,FUTURE
     VPMOVQB          xmmreg|mask|z,ymmreg     AVX512VL,AVX512,FUTURE
     VPMOVQB          xmmreg|mask|z,zmmreg     AVX512,FUTURE
     VPMOVQB          mem16|mask,xmmreg        AVX512VL,AVX512,FUTURE
     VPMOVQB          mem32|mask,ymmreg        AVX512VL,AVX512,FUTURE
     VPMOVQB          mem64|mask,zmmreg        AVX512,FUTURE
     VPMOVQD          xmmreg|mask|z,xmmreg     AVX512VL,AVX512,FUTURE
     VPMOVQD          xmmreg|mask|z,ymmreg     AVX512VL,AVX512,FUTURE
     VPMOVQD          ymmreg|mask|z,zmmreg     AVX512,FUTURE
     VPMOVQD          mem64|mask,xmmreg        AVX512VL,AVX512,FUTURE
     VPMOVQD          mem128|mask,ymmreg       AVX512VL,AVX512,FUTURE
     VPMOVQD          mem256|mask,zmmreg       AVX512,FUTURE
     VPMOVQW          xmmreg|mask|z,xmmreg     AVX512VL,AVX512,FUTURE
     VPMOVQW          xmmreg|mask|z,ymmreg     AVX512VL,AVX512,FUTURE
     VPMOVQW          xmmreg|mask|z,zmmreg     AVX512,FUTURE
     VPMOVQW          mem32|mask,xmmreg        AVX512VL,AVX512,FUTURE
     VPMOVQW          mem64|mask,ymmreg        AVX512VL,AVX512,FUTURE
     VPMOVQW          mem128|mask,zmmreg       AVX512,FUTURE
     VPMOVSDB         xmmreg|mask|z,xmmreg     AVX512VL,AVX512,FUTURE
     VPMOVSDB         xmmreg|mask|z,ymmreg     AVX512VL,AVX512,FUTURE
     VPMOVSDB         xmmreg|mask|z,zmmreg     AVX512,FUTURE
     VPMOVSDB         mem32|mask,xmmreg        AVX512VL,AVX512,FUTURE
     VPMOVSDB         mem64|mask,ymmreg        AVX512VL,AVX512,FUTURE
     VPMOVSDB         mem128|mask,zmmreg       AVX512,FUTURE
     VPMOVSDW         xmmreg|mask|z,xmmreg     AVX512VL,AVX512,FUTURE
     VPMOVSDW         xmmreg|mask|z,ymmreg     AVX512VL,AVX512,FUTURE
     VPMOVSDW         ymmreg|mask|z,zmmreg     AVX512,FUTURE
     VPMOVSDW         mem64|mask,xmmreg        AVX512VL,AVX512,FUTURE
     VPMOVSDW         mem128|mask,ymmreg       AVX512VL,AVX512,FUTURE
     VPMOVSDW         mem256|mask,zmmreg       AVX512,FUTURE
     VPMOVSQB         xmmreg|mask|z,xmmreg     AVX512VL,AVX512,FUTURE
     VPMOVSQB         xmmreg|mask|z,ymmreg     AVX512VL,AVX512,FUTURE
     VPMOVSQB         xmmreg|mask|z,zmmreg     AVX512,FUTURE
     VPMOVSQB         mem16|mask,xmmreg        AVX512VL,AVX512,FUTURE
     VPMOVSQB         mem32|mask,ymmreg        AVX512VL,AVX512,FUTURE
     VPMOVSQB         mem64|mask,zmmreg        AVX512,FUTURE
     VPMOVSQD         xmmreg|mask|z,xmmreg     AVX512VL,AVX512,FUTURE
     VPMOVSQD         xmmreg|mask|z,ymmreg     AVX512VL,AVX512,FUTURE
     VPMOVSQD         ymmreg|mask|z,zmmreg     AVX512,FUTURE
     VPMOVSQD         mem64|mask,xmmreg        AVX512VL,AVX512,FUTURE
     VPMOVSQD         mem128|mask,ymmreg       AVX512VL,AVX512,FUTURE
     VPMOVSQD         mem256|mask,zmmreg       AVX512,FUTURE
     VPMOVSQW         xmmreg|mask|z,xmmreg     AVX512VL,AVX512,FUTURE
     VPMOVSQW         xmmreg|mask|z,ymmreg     AVX512VL,AVX512,FUTURE
     VPMOVSQW         xmmreg|mask|z,zmmreg     AVX512,FUTURE
     VPMOVSQW         mem32|mask,xmmreg        AVX512VL,AVX512,FUTURE
     VPMOVSQW         mem64|mask,ymmreg        AVX512VL,AVX512,FUTURE
     VPMOVSQW         mem128|mask,zmmreg       AVX512,FUTURE
     VPMOVSWB         xmmreg|mask|z,xmmreg     AVX512VL,AVX512BW,FUTURE
     VPMOVSWB         xmmreg|mask|z,ymmreg     AVX512VL,AVX512BW,FUTURE
     VPMOVSWB         ymmreg|mask|z,zmmreg     AVX512BW,FUTURE
     VPMOVSWB         mem64|mask,xmmreg        AVX512VL,AVX512BW,FUTURE
     VPMOVSWB         mem128|mask,ymmreg       AVX512VL,AVX512BW,FUTURE
     VPMOVSWB         mem256|mask,zmmreg       AVX512BW,FUTURE
     VPMOVSXBD        xmmreg|mask|z,xmmrm32    AVX512VL,AVX512,FUTURE
     VPMOVSXBD        ymmreg|mask|z,xmmrm64    AVX512VL,AVX512,FUTURE
     VPMOVSXBD        zmmreg|mask|z,xmmrm128   AVX512,FUTURE
     VPMOVSXBQ        xmmreg|mask|z,xmmrm16    AVX512VL,AVX512,FUTURE
     VPMOVSXBQ        ymmreg|mask|z,xmmrm32    AVX512VL,AVX512,FUTURE
     VPMOVSXBQ        zmmreg|mask|z,xmmrm64    AVX512,FUTURE
     VPMOVSXBW        xmmreg|mask|z,xmmrm64    AVX512VL,AVX512BW,FUTURE
     VPMOVSXBW        ymmreg|mask|z,xmmrm128   AVX512VL,AVX512BW,FUTURE
     VPMOVSXBW        zmmreg|mask|z,ymmrm256   AVX512BW,FUTURE
     VPMOVSXDQ        xmmreg|mask|z,xmmrm64    AVX512VL,AVX512,FUTURE
     VPMOVSXDQ        ymmreg|mask|z,xmmrm128   AVX512VL,AVX512,FUTURE
     VPMOVSXDQ        zmmreg|mask|z,ymmrm256   AVX512,FUTURE
     VPMOVSXWD        xmmreg|mask|z,xmmrm64    AVX512VL,AVX512,FUTURE
     VPMOVSXWD        ymmreg|mask|z,xmmrm128   AVX512VL,AVX512,FUTURE
     VPMOVSXWD        zmmreg|mask|z,ymmrm256   AVX512,FUTURE
     VPMOVSXWQ        xmmreg|mask|z,xmmrm32    AVX512VL,AVX512,FUTURE
     VPMOVSXWQ        ymmreg|mask|z,xmmrm64    AVX512VL,AVX512,FUTURE
     VPMOVSXWQ        zmmreg|mask|z,xmmrm128   AVX512,FUTURE
     VPMOVUSDB        xmmreg|mask|z,xmmreg     AVX512VL,AVX512,FUTURE
     VPMOVUSDB        xmmreg|mask|z,ymmreg     AVX512VL,AVX512,FUTURE
     VPMOVUSDB        xmmreg|mask|z,zmmreg     AVX512,FUTURE
     VPMOVUSDB        mem32|mask,xmmreg        AVX512VL,AVX512,FUTURE
     VPMOVUSDB        mem64|mask,ymmreg        AVX512VL,AVX512,FUTURE
     VPMOVUSDB        mem128|mask,zmmreg       AVX512,FUTURE
     VPMOVUSDW        xmmreg|mask|z,xmmreg     AVX512VL,AVX512,FUTURE
     VPMOVUSDW        xmmreg|mask|z,ymmreg     AVX512VL,AVX512,FUTURE
     VPMOVUSDW        ymmreg|mask|z,zmmreg     AVX512,FUTURE
     VPMOVUSDW        mem64|mask,xmmreg        AVX512VL,AVX512,FUTURE
     VPMOVUSDW        mem128|mask,ymmreg       AVX512VL,AVX512,FUTURE
     VPMOVUSDW        mem256|mask,zmmreg       AVX512,FUTURE
     VPMOVUSQB        xmmreg|mask|z,xmmreg     AVX512VL,AVX512,FUTURE
     VPMOVUSQB        xmmreg|mask|z,ymmreg     AVX512VL,AVX512,FUTURE
     VPMOVUSQB        xmmreg|mask|z,zmmreg     AVX512,FUTURE
     VPMOVUSQB        mem16|mask,xmmreg        AVX512VL,AVX512,FUTURE
     VPMOVUSQB        mem32|mask,ymmreg        AVX512VL,AVX512,FUTURE
     VPMOVUSQB        mem64|mask,zmmreg        AVX512,FUTURE
     VPMOVUSQD        xmmreg|mask|z,xmmreg     AVX512VL,AVX512,FUTURE
     VPMOVUSQD        xmmreg|mask|z,ymmreg     AVX512VL,AVX512,FUTURE
     VPMOVUSQD        ymmreg|mask|z,zmmreg     AVX512,FUTURE
     VPMOVUSQD        mem64|mask,xmmreg        AVX512VL,AVX512,FUTURE
     VPMOVUSQD        mem128|mask,ymmreg       AVX512VL,AVX512,FUTURE
     VPMOVUSQD        mem256|mask,zmmreg       AVX512,FUTURE
     VPMOVUSQW        xmmreg|mask|z,xmmreg     AVX512VL,AVX512,FUTURE
     VPMOVUSQW        xmmreg|mask|z,ymmreg     AVX512VL,AVX512,FUTURE
     VPMOVUSQW        xmmreg|mask|z,zmmreg     AVX512,FUTURE
     VPMOVUSQW        mem32|mask,xmmreg        AVX512VL,AVX512,FUTURE
     VPMOVUSQW        mem64|mask,ymmreg        AVX512VL,AVX512,FUTURE
     VPMOVUSQW        mem128|mask,zmmreg       AVX512,FUTURE
     VPMOVUSWB        xmmreg|mask|z,xmmreg     AVX512VL,AVX512BW,FUTURE
     VPMOVUSWB        xmmreg|mask|z,ymmreg     AVX512VL,AVX512BW,FUTURE
     VPMOVUSWB        ymmreg|mask|z,zmmreg     AVX512BW,FUTURE
     VPMOVUSWB        mem64|mask,xmmreg        AVX512VL,AVX512BW,FUTURE
     VPMOVUSWB        mem128|mask,ymmreg       AVX512VL,AVX512BW,FUTURE
     VPMOVUSWB        mem256|mask,zmmreg       AVX512BW,FUTURE
     VPMOVW2M         kreg,xmmreg              AVX512VL,AVX512BW,FUTURE
     VPMOVW2M         kreg,ymmreg              AVX512VL,AVX512BW,FUTURE
     VPMOVW2M         kreg,zmmreg              AVX512BW,FUTURE
     VPMOVWB          xmmreg|mask|z,xmmreg     AVX512VL,AVX512BW,FUTURE
     VPMOVWB          xmmreg|mask|z,ymmreg     AVX512VL,AVX512BW,FUTURE
     VPMOVWB          ymmreg|mask|z,zmmreg     AVX512BW,FUTURE
     VPMOVWB          mem64|mask,xmmreg        AVX512VL,AVX512BW,FUTURE
     VPMOVWB          mem128|mask,ymmreg       AVX512VL,AVX512BW,FUTURE
     VPMOVWB          mem256|mask,zmmreg       AVX512BW,FUTURE
     VPMOVZXBD        xmmreg|mask|z,xmmrm32    AVX512VL,AVX512,FUTURE
     VPMOVZXBD        ymmreg|mask|z,xmmrm64    AVX512VL,AVX512,FUTURE
     VPMOVZXBD        zmmreg|mask|z,xmmrm128   AVX512,FUTURE
     VPMOVZXBQ        xmmreg|mask|z,xmmrm16    AVX512VL,AVX512,FUTURE
     VPMOVZXBQ        ymmreg|mask|z,xmmrm32    AVX512VL,AVX512,FUTURE
     VPMOVZXBQ        zmmreg|mask|z,xmmrm64    AVX512,FUTURE
     VPMOVZXBW        xmmreg|mask|z,xmmrm64    AVX512VL,AVX512BW,FUTURE
     VPMOVZXBW        ymmreg|mask|z,xmmrm128   AVX512VL,AVX512BW,FUTURE
     VPMOVZXBW        zmmreg|mask|z,ymmrm256   AVX512BW,FUTURE
     VPMOVZXDQ        xmmreg|mask|z,xmmrm64    AVX512VL,AVX512,FUTURE
     VPMOVZXDQ        ymmreg|mask|z,xmmrm128   AVX512VL,AVX512,FUTURE
     VPMOVZXDQ        zmmreg|mask|z,ymmrm256   AVX512,FUTURE
     VPMOVZXWD        xmmreg|mask|z,xmmrm64    AVX512VL,AVX512,FUTURE
     VPMOVZXWD        ymmreg|mask|z,xmmrm128   AVX512VL,AVX512,FUTURE
     VPMOVZXWD        zmmreg|mask|z,ymmrm256   AVX512,FUTURE
     VPMOVZXWQ        xmmreg|mask|z,xmmrm32    AVX512VL,AVX512,FUTURE
     VPMOVZXWQ        ymmreg|mask|z,xmmrm64    AVX512VL,AVX512,FUTURE
     VPMOVZXWQ        zmmreg|mask|z,xmmrm128   AVX512,FUTURE
     VPMULDQ          xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VPMULDQ          ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VPMULDQ          zmmreg|mask|z,zmmreg,zmmrm512|b64 AVX512,FUTURE
     VPMULHRSW        xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPMULHRSW        ymmreg|mask|z,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPMULHRSW        zmmreg|mask|z,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPMULHUW         xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPMULHUW         ymmreg|mask|z,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPMULHUW         zmmreg|mask|z,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPMULHW          xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPMULHW          ymmreg|mask|z,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPMULHW          zmmreg|mask|z,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPMULLD          xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VPMULLD          ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VPMULLD          zmmreg|mask|z,zmmreg,zmmrm512|b32 AVX512,FUTURE
     VPMULLQ          xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512DQ,FUTURE
     VPMULLQ          ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512DQ,FUTURE
     VPMULLQ          zmmreg|mask|z,zmmreg,zmmrm512|b64 AVX512DQ,FUTURE
     VPMULLW          xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPMULLW          ymmreg|mask|z,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPMULLW          zmmreg|mask|z,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPMULTISHIFTQB   xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512VBMI,FUTURE
     VPMULTISHIFTQB   ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512VBMI,FUTURE
     VPMULTISHIFTQB   zmmreg|mask|z,zmmreg,zmmrm512|b64 AVX512VBMI,FUTURE
     VPMULUDQ         xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VPMULUDQ         ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VPMULUDQ         zmmreg|mask|z,zmmreg,zmmrm512|b64 AVX512,FUTURE
     VPORD            xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VPORD            ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VPORD            zmmreg|mask|z,zmmreg,zmmrm512|b32 AVX512,FUTURE
     VPORQ            xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VPORQ            ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VPORQ            zmmreg|mask|z,zmmreg,zmmrm512|b64 AVX512,FUTURE
     VPROLD           xmmreg|mask|z,xmmrm128|b32,imm8 AVX512VL,AVX512,FUTURE
     VPROLD           ymmreg|mask|z,ymmrm256|b32,imm8 AVX512VL,AVX512,FUTURE
     VPROLD           zmmreg|mask|z,zmmrm512|b32,imm8 AVX512,FUTURE
     VPROLQ           xmmreg|mask|z,xmmrm128|b64,imm8 AVX512VL,AVX512,FUTURE
     VPROLQ           ymmreg|mask|z,ymmrm256|b64,imm8 AVX512VL,AVX512,FUTURE
     VPROLQ           zmmreg|mask|z,zmmrm512|b64,imm8 AVX512,FUTURE
     VPROLVD          xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VPROLVD          ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VPROLVD          zmmreg|mask|z,zmmreg,zmmrm512|b32 AVX512,FUTURE
     VPROLVQ          xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VPROLVQ          ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VPROLVQ          zmmreg|mask|z,zmmreg,zmmrm512|b64 AVX512,FUTURE
     VPRORD           xmmreg|mask|z,xmmrm128|b32,imm8 AVX512VL,AVX512,FUTURE
     VPRORD           ymmreg|mask|z,ymmrm256|b32,imm8 AVX512VL,AVX512,FUTURE
     VPRORD           zmmreg|mask|z,zmmrm512|b32,imm8 AVX512,FUTURE
     VPRORQ           xmmreg|mask|z,xmmrm128|b64,imm8 AVX512VL,AVX512,FUTURE
     VPRORQ           ymmreg|mask|z,ymmrm256|b64,imm8 AVX512VL,AVX512,FUTURE
     VPRORQ           zmmreg|mask|z,zmmrm512|b64,imm8 AVX512,FUTURE
     VPRORVD          xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VPRORVD          ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VPRORVD          zmmreg|mask|z,zmmreg,zmmrm512|b32 AVX512,FUTURE
     VPRORVQ          xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VPRORVQ          ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VPRORVQ          zmmreg|mask|z,zmmreg,zmmrm512|b64 AVX512,FUTURE
     VPSADBW          xmmreg,xmmreg,xmmrm128   AVX512VL,AVX512BW,FUTURE
     VPSADBW          ymmreg,ymmreg,ymmrm256   AVX512VL,AVX512BW,FUTURE
     VPSADBW          zmmreg,zmmreg,zmmrm512   AVX512BW,FUTURE
     VPSCATTERDD      xmem32|mask,xmmreg       AVX512VL,AVX512,FUTURE
     VPSCATTERDD      ymem32|mask,ymmreg       AVX512VL,AVX512,FUTURE
     VPSCATTERDD      zmem32|mask,zmmreg       AVX512,FUTURE
     VPSCATTERDQ      xmem64|mask,xmmreg       AVX512VL,AVX512,FUTURE
     VPSCATTERDQ      xmem64|mask,ymmreg       AVX512VL,AVX512,FUTURE
     VPSCATTERDQ      ymem64|mask,zmmreg       AVX512,FUTURE
     VPSCATTERQD      xmem32|mask,xmmreg       AVX512VL,AVX512,FUTURE
     VPSCATTERQD      ymem32|mask,xmmreg       AVX512VL,AVX512,FUTURE
     VPSCATTERQD      zmem32|mask,ymmreg       AVX512,FUTURE
     VPSCATTERQQ      xmem64|mask,xmmreg       AVX512VL,AVX512,FUTURE
     VPSCATTERQQ      ymem64|mask,ymmreg       AVX512VL,AVX512,FUTURE
     VPSCATTERQQ      zmem64|mask,zmmreg       AVX512,FUTURE
     VPSHUFB          xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPSHUFB          ymmreg|mask|z,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPSHUFB          zmmreg|mask|z,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPSHUFD          xmmreg|mask|z,xmmrm128|b32,imm8 AVX512VL,AVX512,FUTURE
     VPSHUFD          ymmreg|mask|z,ymmrm256|b32,imm8 AVX512VL,AVX512,FUTURE
     VPSHUFD          zmmreg|mask|z,zmmrm512|b32,imm8 AVX512,FUTURE
     VPSHUFHW         xmmreg|mask|z,xmmrm128,imm8 AVX512VL,AVX512BW,FUTURE
     VPSHUFHW         ymmreg|mask|z,ymmrm256,imm8 AVX512VL,AVX512BW,FUTURE
     VPSHUFHW         zmmreg|mask|z,zmmrm512,imm8 AVX512BW,FUTURE
     VPSHUFLW         xmmreg|mask|z,xmmrm128,imm8 AVX512VL,AVX512BW,FUTURE
     VPSHUFLW         ymmreg|mask|z,ymmrm256,imm8 AVX512VL,AVX512BW,FUTURE
     VPSHUFLW         zmmreg|mask|z,zmmrm512,imm8 AVX512BW,FUTURE
     VPSLLD           xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512,FUTURE
     VPSLLD           ymmreg|mask|z,ymmreg,xmmrm128 AVX512VL,AVX512,FUTURE
     VPSLLD           zmmreg|mask|z,zmmreg,xmmrm128 AVX512,FUTURE
     VPSLLD           xmmreg|mask|z,xmmrm128|b32,imm8 AVX512VL,AVX512,FUTURE
     VPSLLD           ymmreg|mask|z,ymmrm256|b32,imm8 AVX512VL,AVX512,FUTURE
     VPSLLD           zmmreg|mask|z,zmmrm512|b32,imm8 AVX512,FUTURE
     VPSLLDQ          xmmreg,xmmrm128,imm8     AVX512VL,AVX512BW,FUTURE
     VPSLLDQ          ymmreg,ymmrm256,imm8     AVX512VL,AVX512BW,FUTURE
     VPSLLDQ          zmmreg,zmmrm512,imm8     AVX512BW,FUTURE
     VPSLLQ           xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512,FUTURE
     VPSLLQ           ymmreg|mask|z,ymmreg,xmmrm128 AVX512VL,AVX512,FUTURE
     VPSLLQ           zmmreg|mask|z,zmmreg,xmmrm128 AVX512,FUTURE
     VPSLLQ           xmmreg|mask|z,xmmrm128|b64,imm8 AVX512VL,AVX512,FUTURE
     VPSLLQ           ymmreg|mask|z,ymmrm256|b64,imm8 AVX512VL,AVX512,FUTURE
     VPSLLQ           zmmreg|mask|z,zmmrm512|b64,imm8 AVX512,FUTURE
     VPSLLVD          xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VPSLLVD          ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VPSLLVD          zmmreg|mask|z,zmmreg,zmmrm512|b32 AVX512,FUTURE
     VPSLLVQ          xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VPSLLVQ          ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VPSLLVQ          zmmreg|mask|z,zmmreg,zmmrm512|b64 AVX512,FUTURE
     VPSLLVW          xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPSLLVW          ymmreg|mask|z,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPSLLVW          zmmreg|mask|z,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPSLLW           xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPSLLW           ymmreg|mask|z,ymmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPSLLW           zmmreg|mask|z,zmmreg,xmmrm128 AVX512BW,FUTURE
     VPSLLW           xmmreg|mask|z,xmmrm128,imm8 AVX512VL,AVX512BW,FUTURE
     VPSLLW           ymmreg|mask|z,ymmrm256,imm8 AVX512VL,AVX512BW,FUTURE
     VPSLLW           zmmreg|mask|z,zmmrm512,imm8 AVX512BW,FUTURE
     VPSRAD           xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512,FUTURE
     VPSRAD           ymmreg|mask|z,ymmreg,xmmrm128 AVX512VL,AVX512,FUTURE
     VPSRAD           zmmreg|mask|z,zmmreg,xmmrm128 AVX512,FUTURE
     VPSRAD           xmmreg|mask|z,xmmrm128|b32,imm8 AVX512VL,AVX512,FUTURE
     VPSRAD           ymmreg|mask|z,ymmrm256|b32,imm8 AVX512VL,AVX512,FUTURE
     VPSRAD           zmmreg|mask|z,zmmrm512|b32,imm8 AVX512,FUTURE
     VPSRAQ           xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512,FUTURE
     VPSRAQ           ymmreg|mask|z,ymmreg,xmmrm128 AVX512VL,AVX512,FUTURE
     VPSRAQ           zmmreg|mask|z,zmmreg,xmmrm128 AVX512,FUTURE
     VPSRAQ           xmmreg|mask|z,xmmrm128|b64,imm8 AVX512VL,AVX512,FUTURE
     VPSRAQ           ymmreg|mask|z,ymmrm256|b64,imm8 AVX512VL,AVX512,FUTURE
     VPSRAQ           zmmreg|mask|z,zmmrm512|b64,imm8 AVX512,FUTURE
     VPSRAVD          xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VPSRAVD          ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VPSRAVD          zmmreg|mask|z,zmmreg,zmmrm512|b32 AVX512,FUTURE
     VPSRAVQ          xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VPSRAVQ          ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VPSRAVQ          zmmreg|mask|z,zmmreg,zmmrm512|b64 AVX512,FUTURE
     VPSRAVW          xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPSRAVW          ymmreg|mask|z,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPSRAVW          zmmreg|mask|z,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPSRAW           xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPSRAW           ymmreg|mask|z,ymmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPSRAW           zmmreg|mask|z,zmmreg,xmmrm128 AVX512BW,FUTURE
     VPSRAW           xmmreg|mask|z,xmmrm128,imm8 AVX512VL,AVX512BW,FUTURE
     VPSRAW           ymmreg|mask|z,ymmrm256,imm8 AVX512VL,AVX512BW,FUTURE
     VPSRAW           zmmreg|mask|z,zmmrm512,imm8 AVX512BW,FUTURE
     VPSRLD           xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512,FUTURE
     VPSRLD           ymmreg|mask|z,ymmreg,xmmrm128 AVX512VL,AVX512,FUTURE
     VPSRLD           zmmreg|mask|z,zmmreg,xmmrm128 AVX512,FUTURE
     VPSRLD           xmmreg|mask|z,xmmrm128|b32,imm8 AVX512VL,AVX512,FUTURE
     VPSRLD           ymmreg|mask|z,ymmrm256|b32,imm8 AVX512VL,AVX512,FUTURE
     VPSRLD           zmmreg|mask|z,zmmrm512|b32,imm8 AVX512,FUTURE
     VPSRLDQ          xmmreg,xmmrm128,imm8     AVX512VL,AVX512BW,FUTURE
     VPSRLDQ          ymmreg,ymmrm256,imm8     AVX512VL,AVX512BW,FUTURE
     VPSRLDQ          zmmreg,zmmrm512,imm8     AVX512BW,FUTURE
     VPSRLQ           xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512,FUTURE
     VPSRLQ           ymmreg|mask|z,ymmreg,xmmrm128 AVX512VL,AVX512,FUTURE
     VPSRLQ           zmmreg|mask|z,zmmreg,xmmrm128 AVX512,FUTURE
     VPSRLQ           xmmreg|mask|z,xmmrm128|b64,imm8 AVX512VL,AVX512,FUTURE
     VPSRLQ           ymmreg|mask|z,ymmrm256|b64,imm8 AVX512VL,AVX512,FUTURE
     VPSRLQ           zmmreg|mask|z,zmmrm512|b64,imm8 AVX512,FUTURE
     VPSRLVD          xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VPSRLVD          ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VPSRLVD          zmmreg|mask|z,zmmreg,zmmrm512|b32 AVX512,FUTURE
     VPSRLVQ          xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VPSRLVQ          ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VPSRLVQ          zmmreg|mask|z,zmmreg,zmmrm512|b64 AVX512,FUTURE
     VPSRLVW          xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPSRLVW          ymmreg|mask|z,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPSRLVW          zmmreg|mask|z,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPSRLW           xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPSRLW           ymmreg|mask|z,ymmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPSRLW           zmmreg|mask|z,zmmreg,xmmrm128 AVX512BW,FUTURE
     VPSRLW           xmmreg|mask|z,xmmrm128,imm8 AVX512VL,AVX512BW,FUTURE
     VPSRLW           ymmreg|mask|z,ymmrm256,imm8 AVX512VL,AVX512BW,FUTURE
     VPSRLW           zmmreg|mask|z,zmmrm512,imm8 AVX512BW,FUTURE
     VPSUBB           xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPSUBB           ymmreg|mask|z,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPSUBB           zmmreg|mask|z,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPSUBD           xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VPSUBD           ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VPSUBD           zmmreg|mask|z,zmmreg,zmmrm512|b32 AVX512,FUTURE
     VPSUBQ           xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VPSUBQ           ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VPSUBQ           zmmreg|mask|z,zmmreg,zmmrm512|b64 AVX512,FUTURE
     VPSUBSB          xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPSUBSB          ymmreg|mask|z,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPSUBSB          zmmreg|mask|z,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPSUBSW          xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPSUBSW          ymmreg|mask|z,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPSUBSW          zmmreg|mask|z,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPSUBUSB         xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPSUBUSB         ymmreg|mask|z,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPSUBUSB         zmmreg|mask|z,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPSUBUSW         xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPSUBUSW         ymmreg|mask|z,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPSUBUSW         zmmreg|mask|z,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPSUBW           xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPSUBW           ymmreg|mask|z,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPSUBW           zmmreg|mask|z,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPTERNLOGD       xmmreg|mask|z,xmmreg,xmmrm128|b32,imm8 AVX512VL,AVX512,FUTURE
     VPTERNLOGD       ymmreg|mask|z,ymmreg,ymmrm256|b32,imm8 AVX512VL,AVX512,FUTURE
     VPTERNLOGD       zmmreg|mask|z,zmmreg,zmmrm512|b32,imm8 AVX512,FUTURE
     VPTERNLOGQ       xmmreg|mask|z,xmmreg,xmmrm128|b64,imm8 AVX512VL,AVX512,FUTURE
     VPTERNLOGQ       ymmreg|mask|z,ymmreg,ymmrm256|b64,imm8 AVX512VL,AVX512,FUTURE
     VPTERNLOGQ       zmmreg|mask|z,zmmreg,zmmrm512|b64,imm8 AVX512,FUTURE
     VPTESTMB         kreg|mask,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPTESTMB         kreg|mask,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPTESTMB         kreg|mask,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPTESTMD         kreg|mask,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VPTESTMD         kreg|mask,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VPTESTMD         kreg|mask,zmmreg,zmmrm512|b32 AVX512,FUTURE
     VPTESTMQ         kreg|mask,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VPTESTMQ         kreg|mask,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VPTESTMQ         kreg|mask,zmmreg,zmmrm512|b64 AVX512,FUTURE
     VPTESTMW         kreg|mask,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPTESTMW         kreg|mask,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPTESTMW         kreg|mask,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPTESTNMB        kreg|mask,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPTESTNMB        kreg|mask,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPTESTNMB        kreg|mask,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPTESTNMD        kreg|mask,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VPTESTNMD        kreg|mask,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VPTESTNMD        kreg|mask,zmmreg,zmmrm512|b32 AVX512,FUTURE
     VPTESTNMQ        kreg|mask,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VPTESTNMQ        kreg|mask,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VPTESTNMQ        kreg|mask,zmmreg,zmmrm512|b64 AVX512,FUTURE
     VPTESTNMW        kreg|mask,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPTESTNMW        kreg|mask,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPTESTNMW        kreg|mask,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPUNPCKHBW       xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPUNPCKHBW       ymmreg|mask|z,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPUNPCKHBW       zmmreg|mask|z,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPUNPCKHDQ       xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VPUNPCKHDQ       ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VPUNPCKHDQ       zmmreg|mask|z,zmmreg,zmmrm512|b32 AVX512,FUTURE
     VPUNPCKHQDQ      xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VPUNPCKHQDQ      ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VPUNPCKHQDQ      zmmreg|mask|z,zmmreg,zmmrm512|b64 AVX512,FUTURE
     VPUNPCKHWD       xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPUNPCKHWD       ymmreg|mask|z,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPUNPCKHWD       zmmreg|mask|z,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPUNPCKLBW       xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPUNPCKLBW       ymmreg|mask|z,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPUNPCKLBW       zmmreg|mask|z,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPUNPCKLDQ       xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VPUNPCKLDQ       ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VPUNPCKLDQ       zmmreg|mask|z,zmmreg,zmmrm512|b32 AVX512,FUTURE
     VPUNPCKLQDQ      xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VPUNPCKLQDQ      ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VPUNPCKLQDQ      zmmreg|mask|z,zmmreg,zmmrm512|b64 AVX512,FUTURE
     VPUNPCKLWD       xmmreg|mask|z,xmmreg,xmmrm128 AVX512VL,AVX512BW,FUTURE
     VPUNPCKLWD       ymmreg|mask|z,ymmreg,ymmrm256 AVX512VL,AVX512BW,FUTURE
     VPUNPCKLWD       zmmreg|mask|z,zmmreg,zmmrm512 AVX512BW,FUTURE
     VPXORD           xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VPXORD           ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VPXORD           zmmreg|mask|z,zmmreg,zmmrm512|b32 AVX512,FUTURE
     VPXORQ           xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VPXORQ           ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VPXORQ           zmmreg|mask|z,zmmreg,zmmrm512|b64 AVX512,FUTURE
     VRANGEPD         xmmreg|mask|z,xmmreg,xmmrm128|b64,imm8 AVX512VL,AVX512DQ,FUTURE
     VRANGEPD         ymmreg|mask|z,ymmreg,ymmrm256|b64,imm8 AVX512VL,AVX512DQ,FUTURE
     VRANGEPD         zmmreg|mask|z,zmmreg,zmmrm512|b64|sae,imm8 AVX512DQ,FUTURE
     VRANGEPS         xmmreg|mask|z,xmmreg,xmmrm128|b32,imm8 AVX512VL,AVX512DQ,FUTURE
     VRANGEPS         ymmreg|mask|z,ymmreg,ymmrm256|b32,imm8 AVX512VL,AVX512DQ,FUTURE
     VRANGEPS         zmmreg|mask|z,zmmreg,zmmrm512|b32|sae,imm8 AVX512DQ,FUTURE
     VRANGESD         xmmreg|mask|z,xmmreg,xmmrm64|sae,imm8 AVX512DQ,FUTURE
     VRANGESS         xmmreg|mask|z,xmmreg,xmmrm32|sae,imm8 AVX512DQ,FUTURE
     VRCP14PD         xmmreg|mask|z,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VRCP14PD         ymmreg|mask|z,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VRCP14PD         zmmreg|mask|z,zmmrm512|b64 AVX512,FUTURE
     VRCP14PS         xmmreg|mask|z,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VRCP14PS         ymmreg|mask|z,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VRCP14PS         zmmreg|mask|z,zmmrm512|b32 AVX512,FUTURE
     VRCP14SD         xmmreg|mask|z,xmmreg,xmmrm64 AVX512,FUTURE
     VRCP14SS         xmmreg|mask|z,xmmreg,xmmrm32 AVX512,FUTURE
     VRCP28PD         zmmreg|mask|z,zmmrm512|b64|sae AVX512ER,FUTURE
     VRCP28PS         zmmreg|mask|z,zmmrm512|b32|sae AVX512ER,FUTURE
     VRCP28SD         xmmreg|mask|z,xmmreg,xmmrm64|sae AVX512ER,FUTURE
     VRCP28SS         xmmreg|mask|z,xmmreg,xmmrm32|sae AVX512ER,FUTURE
     VREDUCEPD        xmmreg|mask|z,xmmrm128|b64,imm8 AVX512VL,AVX512DQ,FUTURE
     VREDUCEPD        ymmreg|mask|z,ymmrm256|b64,imm8 AVX512VL,AVX512DQ,FUTURE
     VREDUCEPD        zmmreg|mask|z,zmmrm512|b64|sae,imm8 AVX512DQ,FUTURE
     VREDUCEPS        xmmreg|mask|z,xmmrm128|b32,imm8 AVX512VL,AVX512DQ,FUTURE
     VREDUCEPS        ymmreg|mask|z,ymmrm256|b32,imm8 AVX512VL,AVX512DQ,FUTURE
     VREDUCEPS        zmmreg|mask|z,zmmrm512|b32|sae,imm8 AVX512DQ,FUTURE
     VREDUCESD        xmmreg|mask|z,xmmreg,xmmrm64|sae,imm8 AVX512DQ,FUTURE
     VREDUCESS        xmmreg|mask|z,xmmreg,xmmrm32|sae,imm8 AVX512DQ,FUTURE
     VRNDSCALEPD      xmmreg|mask|z,xmmrm128|b64,imm8 AVX512VL,AVX512,FUTURE
     VRNDSCALEPD      ymmreg|mask|z,ymmrm256|b64,imm8 AVX512VL,AVX512,FUTURE
     VRNDSCALEPD      zmmreg|mask|z,zmmrm512|b64|sae,imm8 AVX512,FUTURE
     VRNDSCALEPS      xmmreg|mask|z,xmmrm128|b32,imm8 AVX512VL,AVX512,FUTURE
     VRNDSCALEPS      ymmreg|mask|z,ymmrm256|b32,imm8 AVX512VL,AVX512,FUTURE
     VRNDSCALEPS      zmmreg|mask|z,zmmrm512|b32|sae,imm8 AVX512,FUTURE
     VRNDSCALESD      xmmreg|mask|z,xmmreg,xmmrm64|sae,imm8 AVX512,FUTURE
     VRNDSCALESS      xmmreg|mask|z,xmmreg,xmmrm32|sae,imm8 AVX512,FUTURE
     VRSQRT14PD       xmmreg|mask|z,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VRSQRT14PD       ymmreg|mask|z,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VRSQRT14PD       zmmreg|mask|z,zmmrm512|b64 AVX512,FUTURE
     VRSQRT14PS       xmmreg|mask|z,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VRSQRT14PS       ymmreg|mask|z,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VRSQRT14PS       zmmreg|mask|z,zmmrm512|b32 AVX512,FUTURE
     VRSQRT14SD       xmmreg|mask|z,xmmreg,xmmrm64 AVX512,FUTURE
     VRSQRT14SS       xmmreg|mask|z,xmmreg,xmmrm32 AVX512,FUTURE
     VRSQRT28PD       zmmreg|mask|z,zmmrm512|b64|sae AVX512ER,FUTURE
     VRSQRT28PS       zmmreg|mask|z,zmmrm512|b32|sae AVX512ER,FUTURE
     VRSQRT28SD       xmmreg|mask|z,xmmreg,xmmrm64|sae AVX512ER,FUTURE
     VRSQRT28SS       xmmreg|mask|z,xmmreg,xmmrm32|sae AVX512ER,FUTURE
     VSCALEFPD        xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VSCALEFPD        ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VSCALEFPD        zmmreg|mask|z,zmmreg,zmmrm512|b64|er AVX512,FUTURE
     VSCALEFPS        xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VSCALEFPS        ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VSCALEFPS        zmmreg|mask|z,zmmreg,zmmrm512|b32|er AVX512,FUTURE
     VSCALEFSD        xmmreg|mask|z,xmmreg,xmmrm64|er AVX512,FUTURE
     VSCALEFSS        xmmreg|mask|z,xmmreg,xmmrm32|er AVX512,FUTURE
     VSCATTERDPD      xmem64|mask,xmmreg       AVX512VL,AVX512,FUTURE
     VSCATTERDPD      xmem64|mask,ymmreg       AVX512VL,AVX512,FUTURE
     VSCATTERDPD      ymem64|mask,zmmreg       AVX512,FUTURE
     VSCATTERDPS      xmem32|mask,xmmreg       AVX512VL,AVX512,FUTURE
     VSCATTERDPS      ymem32|mask,ymmreg       AVX512VL,AVX512,FUTURE
     VSCATTERDPS      zmem32|mask,zmmreg       AVX512,FUTURE
     VSCATTERPF0DPD   ymem64|mask              AVX512PF,FUTURE
     VSCATTERPF0DPS   zmem32|mask              AVX512PF,FUTURE
     VSCATTERPF0QPD   zmem64|mask              AVX512PF,FUTURE
     VSCATTERPF0QPS   zmem32|mask              AVX512PF,FUTURE
     VSCATTERPF1DPD   ymem64|mask              AVX512PF,FUTURE
     VSCATTERPF1DPS   zmem32|mask              AVX512PF,FUTURE
     VSCATTERPF1QPD   zmem64|mask              AVX512PF,FUTURE
     VSCATTERPF1QPS   zmem32|mask              AVX512PF,FUTURE
     VSCATTERQPD      xmem64|mask,xmmreg       AVX512VL,AVX512,FUTURE
     VSCATTERQPD      ymem64|mask,ymmreg       AVX512VL,AVX512,FUTURE
     VSCATTERQPD      zmem64|mask,zmmreg       AVX512,FUTURE
     VSCATTERQPS      xmem32|mask,xmmreg       AVX512VL,AVX512,FUTURE
     VSCATTERQPS      ymem32|mask,xmmreg       AVX512VL,AVX512,FUTURE
     VSCATTERQPS      zmem32|mask,ymmreg       AVX512,FUTURE
     VSHUFF32X4       ymmreg|mask|z,ymmreg,ymmrm256|b32,imm8 AVX512VL,AVX512,FUTURE
     VSHUFF32X4       zmmreg|mask|z,zmmreg,zmmrm512|b32,imm8 AVX512,FUTURE
     VSHUFF64X2       ymmreg|mask|z,ymmreg,ymmrm256|b64,imm8 AVX512VL,AVX512,FUTURE
     VSHUFF64X2       zmmreg|mask|z,zmmreg,zmmrm512|b64,imm8 AVX512,FUTURE
     VSHUFI32X4       ymmreg|mask|z,ymmreg,ymmrm256|b32,imm8 AVX512VL,AVX512,FUTURE
     VSHUFI32X4       zmmreg|mask|z,zmmreg,zmmrm512|b32,imm8 AVX512,FUTURE
     VSHUFI64X2       ymmreg|mask|z,ymmreg,ymmrm256|b64,imm8 AVX512VL,AVX512,FUTURE
     VSHUFI64X2       zmmreg|mask|z,zmmreg,zmmrm512|b64,imm8 AVX512,FUTURE
     VSHUFPD          xmmreg|mask|z,xmmreg,xmmrm128|b64,imm8 AVX512VL,AVX512,FUTURE
     VSHUFPD          ymmreg|mask|z,ymmreg,ymmrm256|b64,imm8 AVX512VL,AVX512,FUTURE
     VSHUFPD          zmmreg|mask|z,zmmreg,zmmrm512|b64,imm8 AVX512,FUTURE
     VSHUFPS          xmmreg|mask|z,xmmreg,xmmrm128|b32,imm8 AVX512VL,AVX512,FUTURE
     VSHUFPS          ymmreg|mask|z,ymmreg,ymmrm256|b32,imm8 AVX512VL,AVX512,FUTURE
     VSHUFPS          zmmreg|mask|z,zmmreg,zmmrm512|b32,imm8 AVX512,FUTURE
     VSQRTPD          xmmreg|mask|z,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VSQRTPD          ymmreg|mask|z,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VSQRTPD          zmmreg|mask|z,zmmrm512|b64|er AVX512,FUTURE
     VSQRTPS          xmmreg|mask|z,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VSQRTPS          ymmreg|mask|z,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VSQRTPS          zmmreg|mask|z,zmmrm512|b32|er AVX512,FUTURE
     VSQRTSD          xmmreg|mask|z,xmmreg,xmmrm64|er AVX512,FUTURE
     VSQRTSS          xmmreg|mask|z,xmmreg,xmmrm32|er AVX512,FUTURE
     VSUBPD           xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VSUBPD           ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VSUBPD           zmmreg|mask|z,zmmreg,zmmrm512|b64|er AVX512,FUTURE
     VSUBPS           xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VSUBPS           ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VSUBPS           zmmreg|mask|z,zmmreg,zmmrm512|b32|er AVX512,FUTURE
     VSUBSD           xmmreg|mask|z,xmmreg,xmmrm64|er AVX512,FUTURE
     VSUBSS           xmmreg|mask|z,xmmreg,xmmrm32|er AVX512,FUTURE
     VUCOMISD         xmmreg,xmmrm64|sae       AVX512,FUTURE
     VUCOMISS         xmmreg,xmmrm32|sae       AVX512,FUTURE
     VUNPCKHPD        xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VUNPCKHPD        ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VUNPCKHPD        zmmreg|mask|z,zmmreg,zmmrm512|b64 AVX512,FUTURE
     VUNPCKHPS        xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VUNPCKHPS        ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VUNPCKHPS        zmmreg|mask|z,zmmreg,zmmrm512|b32 AVX512,FUTURE
     VUNPCKLPD        xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512,FUTURE
     VUNPCKLPD        ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512,FUTURE
     VUNPCKLPD        zmmreg|mask|z,zmmreg,zmmrm512|b64 AVX512,FUTURE
     VUNPCKLPS        xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512,FUTURE
     VUNPCKLPS        ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512,FUTURE
     VUNPCKLPS        zmmreg|mask|z,zmmreg,zmmrm512|b32 AVX512,FUTURE
     VXORPD           xmmreg|mask|z,xmmreg,xmmrm128|b64 AVX512VL,AVX512DQ,FUTURE
     VXORPD           ymmreg|mask|z,ymmreg,ymmrm256|b64 AVX512VL,AVX512DQ,FUTURE
     VXORPD           zmmreg|mask|z,zmmreg,zmmrm512|b64 AVX512DQ,FUTURE
     VXORPS           xmmreg|mask|z,xmmreg,xmmrm128|b32 AVX512VL,AVX512DQ,FUTURE
     VXORPS           ymmreg|mask|z,ymmreg,ymmrm256|b32 AVX512VL,AVX512DQ,FUTURE
     VXORPS           zmmreg|mask|z,zmmreg,zmmrm512|b32 AVX512DQ,FUTURE

