SMPDataFlowAnalysis.cpp

SMPTypeCategory[NN_pextrq] = 15;              // Extract Qword
SMPTypeCategory[NN_phminposuw] = 14;          // Packed Horizontal Word Minimum
SMPTypeCategory[NN_pinsrb] = 14;              // Insert Byte  !!! Could this be used as a generic move???
SMPTypeCategory[NN_pinsrd] = 14;              // Insert Dword  !!! Could this be used as a generic move???
SMPTypeCategory[NN_pinsrq] = 14;              // Insert Qword  !!! Could this be used as a generic move???
SMPTypeCategory[NN_pmaxsb] = 14;              // Maximum of Packed Signed Byte Integers
SMPTypeCategory[NN_pmaxsd] = 14;              // Maximum of Packed Signed Dword Integers
SMPTypeCategory[NN_pmaxud] = 14;              // Maximum of Packed Unsigned Dword Integers
SMPTypeCategory[NN_pmaxuw] = 14;              // Maximum of Packed Word Integers
SMPTypeCategory[NN_pminsb] = 14;              // Minimum of Packed Signed Byte Integers
SMPTypeCategory[NN_pminsd] = 14;              // Minimum of Packed Signed Dword Integers
SMPTypeCategory[NN_pminud] = 14;              // Minimum of Packed Unsigned Dword Integers
SMPTypeCategory[NN_pminuw] = 14;              // Minimum of Packed Word Integers
SMPTypeCategory[NN_pmovsxbw] = 14;            // Packed Move with Sign Extend
SMPTypeCategory[NN_pmovsxbd] = 14;            // Packed Move with Sign Extend
SMPTypeCategory[NN_pmovsxbq] = 14;            // Packed Move with Sign Extend
SMPTypeCategory[NN_pmovsxwd] = 14;            // Packed Move with Sign Extend
SMPTypeCategory[NN_pmovsxwq] = 14;            // Packed Move with Sign Extend
SMPTypeCategory[NN_pmovsxdq] = 14;            // Packed Move with Sign Extend
SMPTypeCategory[NN_pmovzxbw] = 14;            // Packed Move with Zero Extend
SMPTypeCategory[NN_pmovzxbd] = 14;            // Packed Move with Zero Extend
SMPTypeCategory[NN_pmovzxbq] = 14;            // Packed Move with Zero Extend
SMPTypeCategory[NN_pmovzxwd] = 14;            // Packed Move with Zero Extend
SMPTypeCategory[NN_pmovzxwq] = 14;            // Packed Move with Zero Extend
SMPTypeCategory[NN_pmovzxdq] = 14;            // Packed Move with Zero Extend
SMPTypeCategory[NN_pmuldq] = 14;              // Multiply Packed Signed Dword Integers
SMPTypeCategory[NN_pmulld] = 14;              // Multiply Packed Signed Dword Integers and Store Low Result
SMPTypeCategory[NN_ptest] = 1;                // Logical Compare
SMPTypeCategory[NN_roundpd] = 14;             // Round Packed Double Precision Floating-Point Values
SMPTypeCategory[NN_roundps] = 14;             // Round Packed Single Precision Floating-Point Values
SMPTypeCategory[NN_roundsd] = 14;             // Round Scalar Double Precision Floating-Point Values
SMPTypeCategory[NN_roundss] = 14;             // Round Scalar Single Precision Floating-Point Values

// SSSE4.2 instructions
SMPTypeCategory[NN_crc32] = 14;               // Accumulate CRC32 Value
SMPTypeCategory[NN_pcmpestri] = 2;            // Packed Compare Explicit Length Strings, Return Index
SMPTypeCategory[NN_pcmpestrm] = 2;            // Packed Compare Explicit Length Strings, Return Mask
SMPTypeCategory[NN_pcmpistri] = 2;            // Packed Compare Implicit Length Strings, Return Index
SMPTypeCategory[NN_pcmpistrm] = 2;            // Packed Compare Implicit Length Strings, Return Mask
SMPTypeCategory[NN_pcmpgtq] = 14;             // Compare Packed Data for Greater Than
SMPTypeCategory[NN_popcnt] = 2;               // Return the Count of Number of Bits Set to 1

// AMD SSE4a instructions

SMPTypeCategory[NN_extrq] = 1;               // Extract Field From Register
SMPTypeCategory[NN_insertq] = 1;             // Insert Field
SMPTypeCategory[NN_movntsd] = 13;             // Move Non-Temporal Scalar Double-Precision Floating-Point !!! Could this be used as a generic move???
SMPTypeCategory[NN_movntss] = 13;             // Move Non-Temporal Scalar Single-Precision Floating-Point !!! Could this be used as a generic move???
SMPTypeCategory[NN_lzcnt] = 2;                // Leading Zero Count

// xsave/xrstor instructions

SMPTypeCategory[NN_xgetbv] = 8;               // Get Value of Extended Control Register
SMPTypeCategory[NN_xrstor] = 0;               // Restore Processor Extended States
SMPTypeCategory[NN_xsave] = 1;                // Save Processor Extended States
SMPTypeCategory[NN_xsetbv] = 1;               // Set Value of Extended Control Register

// Intel Safer Mode Extensions (SMX)

SMPTypeCategory[NN_getsec] = 1;               // Safer Mode Extensions (SMX) Instruction

// AMD-V Virtualization ISA Extension

SMPTypeCategory[NN_clgi] = 0;                 // Clear Global Interrupt Flag
SMPTypeCategory[NN_invlpga] = 1;              // Invalidate TLB Entry in a Specified ASID
SMPTypeCategory[NN_skinit] = 1;               // Secure Init and Jump with Attestation
SMPTypeCategory[NN_stgi] = 0;                 // Set Global Interrupt Flag
SMPTypeCategory[NN_vmexit] = 1;               // Stop Executing Guest, Begin Executing Host
SMPTypeCategory[NN_vmload] = 0;               // Load State from VMCB
SMPTypeCategory[NN_vmmcall] = 1;              // Call VMM
SMPTypeCategory[NN_vmrun] = 1;                // Run Virtual Machine
SMPTypeCategory[NN_vmsave] = 0;               // Save State to VMCB

// VMX+ instructions

SMPTypeCategory[NN_invept] = 1;               // Invalidate Translations Derived from EPT
SMPTypeCategory[NN_invvpid] = 1;              // Invalidate Translations Based on VPID

// Intel Atom instructions

// !!!! continue work here
SMPTypeCategory[NN_movbe] = 3;                // Move Data After Swapping Bytes

// Intel AES instructions

SMPTypeCategory[NN_aesenc] = 14;              // Perform One Round of an AES Encryption Flow
SMPTypeCategory[NN_aesenclast] = 14;          // Perform the Last Round of an AES Encryption Flow
SMPTypeCategory[NN_aesdec] = 14;              // Perform One Round of an AES Decryption Flow
SMPTypeCategory[NN_aesdeclast] = 14;          // Perform the Last Round of an AES Decryption Flow
SMPTypeCategory[NN_aesimc] = 14;              // Perform the AES InvMixColumn Transformation
SMPTypeCategory[NN_aeskeygenassist] = 14;     // AES Round Key Generation Assist

// Carryless multiplication

SMPTypeCategory[NN_pclmulqdq] = 14;           // Carry-Less Multiplication Quadword

// Returns modified by operand size prefixes

SMPTypeCategory[NN_retnw] = 0;               // Return Near from Procedure (use16)
SMPTypeCategory[NN_retnd] = 0;               // Return Near from Procedure (use32)
SMPTypeCategory[NN_retnq] = 0;               // Return Near from Procedure (use64)
SMPTypeCategory[NN_retfw] = 0;               // Return Far from Procedure (use16)
SMPTypeCategory[NN_retfd] = 0;               // Return Far from Procedure (use32)
SMPTypeCategory[NN_retfq] = 0;               // Return Far from Procedure (use64)

// RDRAND support

SMPTypeCategory[NN_rdrand] = 2;              // Read Random Number

// new GPR instructions

SMPTypeCategory[NN_adcx] = 5;                 // Unsigned Integer Addition of Two Operands with Carry Flag
SMPTypeCategory[NN_adox] = 5;                 // Unsigned Integer Addition of Two Operands with Overflow Flag
SMPTypeCategory[NN_andn] = 10;                // Logical AND NOT
SMPTypeCategory[NN_bextr] = 14;               // Bit Field Extract
SMPTypeCategory[NN_blsi] = 14;                // Extract Lowest Set Isolated Bit
SMPTypeCategory[NN_blsmsk] = 2;               // Get Mask Up to Lowest Set Bit
SMPTypeCategory[NN_blsr] = 2;                 // Reset Lowest Set Bit
SMPTypeCategory[NN_bzhi] = 2;                 // Zero High Bits Starting with Specified Bit Position
SMPTypeCategory[NN_clac] = 1;                 // Clear AC Flag in EFLAGS Register
SMPTypeCategory[NN_mulx] = 2;                 // Unsigned Multiply Without Affecting Flags
SMPTypeCategory[NN_pdep] = 2;                 // Parallel Bits Deposit
SMPTypeCategory[NN_pext] = 2;                 // Parallel Bits Extract
SMPTypeCategory[NN_rorx] = 2;                 // Rotate Right Logical Without Affecting Flags
SMPTypeCategory[NN_sarx] = 2;                 // Shift Arithmetically Right Without Affecting Flags
SMPTypeCategory[NN_shlx] = 2;                 // Shift Logically Left Without Affecting Flags
SMPTypeCategory[NN_shrx] = 2;                 // Shift Logically Right Without Affecting Flags
SMPTypeCategory[NN_stac] = 1;                  // Set AC Flag in EFLAGS Register
SMPTypeCategory[NN_tzcnt] = 2;                // Count the Number of Trailing Zero Bits
SMPTypeCategory[NN_xsaveopt] = 1;             // Save Processor Extended States Optimized
SMPTypeCategory[NN_invpcid] = 1;              // Invalidate Processor Context ID
SMPTypeCategory[NN_rdseed] = 2;               // Read Random Seed
SMPTypeCategory[NN_rdfsbase] = 6;             // Read FS Segment Base
SMPTypeCategory[NN_rdgsbase] = 6;             // Read GS Segment Base
SMPTypeCategory[NN_wrfsbase] = 6;             // Write FS Segment Base
SMPTypeCategory[NN_wrgsbase] = 6;             // Write GS Segment Base

// new AVX instructions

SMPTypeCategory[NN_vaddpd] = 14;               // Add Packed Double-Precision Floating-Point Values
SMPTypeCategory[NN_vaddps] = 14;               // Packed Single-FP Add
SMPTypeCategory[NN_vaddsd] = 14;               // Add Scalar Double-Precision Floating-Point Values
SMPTypeCategory[NN_vaddss] = 14;               // Scalar Single-FP Add
SMPTypeCategory[NN_vaddsubpd] = 14;            // Add /Sub packed DP FP numbers
SMPTypeCategory[NN_vaddsubps] = 14;            // Add /Sub packed SP FP numbers
SMPTypeCategory[NN_vaesdec] = 14;              // Perform One Round of an AES Decryption Flow
SMPTypeCategory[NN_vaesdeclast] = 14;          // Perform the Last Round of an AES Decryption Flow
SMPTypeCategory[NN_vaesenc] = 14;              // Perform One Round of an AES Encryption Flow
SMPTypeCategory[NN_vaesenclast] = 14;          // Perform the Last Round of an AES Encryption Flow
SMPTypeCategory[NN_vaesimc] = 14;              // Perform the AES InvMixColumn Transformation
SMPTypeCategory[NN_vaeskeygenassist] = 14;     // AES Round Key Generation Assist
SMPTypeCategory[NN_vandnpd] = 14;              // Bitwise Logical AND NOT of Packed Double-Precision Floating-Point Values
SMPTypeCategory[NN_vandnps] = 14;              // Bitwise Logical And Not for Single-FP
SMPTypeCategory[NN_vandpd] = 14;               // Bitwise Logical AND of Packed Double-Precision Floating-Point Values
SMPTypeCategory[NN_vandps] = 14;               // Bitwise Logical And for Single-FP
SMPTypeCategory[NN_vblendpd] = 14;             // Blend Packed Double Precision Floating-Point Values
SMPTypeCategory[NN_vblendps] = 14;             // Blend Packed Single Precision Floating-Point Values
SMPTypeCategory[NN_vblendvpd] = 14;            // Variable Blend Packed Double Precision Floating-Point Values
SMPTypeCategory[NN_vblendvps] = 14;            // Variable Blend Packed Single Precision Floating-Point Values
SMPTypeCategory[NN_vbroadcastf128] = 14;       // Broadcast 128 Bits of Floating-Point Data
SMPTypeCategory[NN_vbroadcasti128] = 14;       // Broadcast 128 Bits of Integer Data
SMPTypeCategory[NN_vbroadcastsd] = 14;         // Broadcast Double-Precision Floating-Point Element
SMPTypeCategory[NN_vbroadcastss] = 14;         // Broadcast Single-Precision Floating-Point Element
SMPTypeCategory[NN_vcmppd] = 14;               // Compare Packed Double-Precision Floating-Point Values
SMPTypeCategory[NN_vcmpps] = 14;               // Packed Single-FP Compare
SMPTypeCategory[NN_vcmpsd] = 14;               // Compare Scalar Double-Precision Floating-Point Values
SMPTypeCategory[NN_vcmpss] = 14;               // Scalar Single-FP Compare
SMPTypeCategory[NN_vcomisd] = 14;              // Compare Scalar Ordered Double-Precision Floating-Point Values and Set EFLAGS
SMPTypeCategory[NN_vcomiss] = 14;              // Scalar Ordered Single-FP Compare and Set EFLAGS
SMPTypeCategory[NN_vcvtdq2pd] = 14;            // Convert Packed Doubleword Integers to Packed Single-Precision Floating-Point Values
SMPTypeCategory[NN_vcvtdq2ps] = 14;            // Convert Packed Doubleword Integers to Packed Double-Precision Floating-Point Values
SMPTypeCategory[NN_vcvtpd2dq] = 14;            // Convert Packed Double-Precision Floating-Point Values to Packed Doubleword Integers
SMPTypeCategory[NN_vcvtpd2ps] = 14;            // Convert Packed Double-Precision Floating-Point Values to Packed Single-Precision Floating-Point Values
SMPTypeCategory[NN_vcvtph2ps] = 14;            // Convert 16-bit FP Values to Single-Precision FP Values
SMPTypeCategory[NN_vcvtps2dq] = 14;            // Convert Packed Single-Precision Floating-Point Values to Packed Doubleword Integers
SMPTypeCategory[NN_vcvtps2pd] = 14;            // Convert Packed Single-Precision Floating-Point Values to Packed Double-Precision Floating-Point Values
SMPTypeCategory[NN_vcvtps2ph] = 14;            // Convert Single-Precision FP value to 16-bit FP value
SMPTypeCategory[NN_vcvtsd2si] = 14;            // Convert Scalar Double-Precision Floating-Point Value to Doubleword Integer
SMPTypeCategory[NN_vcvtsd2ss] = 14;            // Convert Scalar Double-Precision Floating-Point Value to Scalar Single-Precision Floating-Point Value
SMPTypeCategory[NN_vcvtsi2sd] = 14;            // Convert Doubleword Integer to Scalar Double-Precision Floating-Point Value
SMPTypeCategory[NN_vcvtsi2ss] = 14;            // Scalar signed INT32 to Single-FP conversion
SMPTypeCategory[NN_vcvtss2sd] = 14;            // Convert Scalar Single-Precision Floating-Point Value to Scalar Double-Precision Floating-Point Value
SMPTypeCategory[NN_vcvtss2si] = 14;            // Scalar Single-FP to signed INT32 conversion
SMPTypeCategory[NN_vcvttpd2dq] = 14;           // Convert With Truncation Packed Double-Precision Floating-Point Values to Packed Doubleword Integers
SMPTypeCategory[NN_vcvttps2dq] = 14;           // Convert With Truncation Packed Single-Precision Floating-Point Values to Packed Doubleword Integers
SMPTypeCategory[NN_vcvttsd2si] = 14;           // Convert with Truncation Scalar Double-Precision Floating-Point Value to Doubleword Integer
SMPTypeCategory[NN_vcvttss2si] = 14;           // Scalar Single-FP to signed INT32 conversion (truncate)
SMPTypeCategory[NN_vdivpd] = 14;               // Divide Packed Double-Precision Floating-Point Values
SMPTypeCategory[NN_vdivps] = 14;               // Packed Single-FP Divide
SMPTypeCategory[NN_vdivsd] = 14;               // Divide Scalar Double-Precision Floating-Point Values
SMPTypeCategory[NN_vdivss] = 14;               // Scalar Single-FP Divide
SMPTypeCategory[NN_vdppd] = 14;                // Dot Product of Packed Double Precision Floating-Point Values
SMPTypeCategory[NN_vdpps] = 14;                // Dot Product of Packed Single Precision Floating-Point Values
SMPTypeCategory[NN_vextractf128] = 14;         // Extract Packed Floating-Point Values
SMPTypeCategory[NN_vextracti128] = 14;         // Extract Packed Integer Values
SMPTypeCategory[NN_vextractps] = 14;           // Extract Packed Floating-Point Values
SMPTypeCategory[NN_vfmadd132pd] = 14;          // Fused Multiply-Add of Packed Double-Precision Floating-Point Values
SMPTypeCategory[NN_vfmadd132ps] = 14;          // Fused Multiply-Add of Packed Single-Precision Floating-Point Values
SMPTypeCategory[NN_vfmadd132sd] = 14;          // Fused Multiply-Add of Scalar Double-Precision Floating-Point Values
SMPTypeCategory[NN_vfmadd132ss] = 14;          // Fused Multiply-Add of Scalar Single-Precision Floating-Point Values
SMPTypeCategory[NN_vfmadd213pd] = 14;          // Fused Multiply-Add of Packed Double-Precision Floating-Point Values
SMPTypeCategory[NN_vfmadd213ps] = 14;          // Fused Multiply-Add of Packed Single-Precision Floating-Point Values
SMPTypeCategory[NN_vfmadd213sd] = 14;          // Fused Multiply-Add of Scalar Double-Precision Floating-Point Values
SMPTypeCategory[NN_vfmadd213ss] = 14;          // Fused Multiply-Add of Scalar Single-Precision Floating-Point Values
SMPTypeCategory[NN_vfmadd231pd] = 14;          // Fused Multiply-Add of Packed Double-Precision Floating-Point Values
SMPTypeCategory[NN_vfmadd231ps] = 14;          // Fused Multiply-Add of Packed Single-Precision Floating-Point Values
SMPTypeCategory[NN_vfmadd231sd] = 14;          // Fused Multiply-Add of Scalar Double-Precision Floating-Point Values
SMPTypeCategory[NN_vfmadd231ss] = 14;          // Fused Multiply-Add of Scalar Single-Precision Floating-Point Values
SMPTypeCategory[NN_vfmaddsub132pd] = 14;       // Fused Multiply-Alternating Add/Subtract of Packed Double-Precision Floating-Point Values
SMPTypeCategory[NN_vfmaddsub132ps] = 14;       // Fused Multiply-Alternating Add/Subtract of Packed Single-Precision Floating-Point Values
SMPTypeCategory[NN_vfmaddsub213pd] = 14;       // Fused Multiply-Alternating Add/Subtract of Packed Double-Precision Floating-Point Values
SMPTypeCategory[NN_vfmaddsub213ps] = 14;       // Fused Multiply-Alternating Add/Subtract of Packed Single-Precision Floating-Point Values
SMPTypeCategory[NN_vfmaddsub231pd] = 14;       // Fused Multiply-Alternating Add/Subtract of Packed Double-Precision Floating-Point Values
SMPTypeCategory[NN_vfmaddsub231ps] = 14;       // Fused Multiply-Alternating Add/Subtract of Packed Single-Precision Floating-Point Values
SMPTypeCategory[NN_vfmsub132pd] = 14;          // Fused Multiply-Subtract of Packed Double-Precision Floating-Point Values
SMPTypeCategory[NN_vfmsub132ps] = 14;          // Fused Multiply-Subtract of Packed Single-Precision Floating-Point Values
SMPTypeCategory[NN_vfmsub132sd] = 14;          // Fused Multiply-Subtract of Scalar Double-Precision Floating-Point Values
SMPTypeCategory[NN_vfmsub132ss] = 14;          // Fused Multiply-Subtract of Scalar Single-Precision Floating-Point Values
SMPTypeCategory[NN_vfmsub213pd] = 14;          // Fused Multiply-Subtract of Packed Double-Precision Floating-Point Values
SMPTypeCategory[NN_vfmsub213ps] = 14;          // Fused Multiply-Subtract of Packed Single-Precision Floating-Point Values
SMPTypeCategory[NN_vfmsub213sd] = 14;          // Fused Multiply-Subtract of Scalar Double-Precision Floating-Point Values
SMPTypeCategory[NN_vfmsub213ss] = 14;          // Fused Multiply-Subtract of Scalar Single-Precision Floating-Point Values
SMPTypeCategory[NN_vfmsub231pd] = 14;          // Fused Multiply-Subtract of Packed Double-Precision Floating-Point Values
SMPTypeCategory[NN_vfmsub231ps] = 14;          // Fused Multiply-Subtract of Packed Single-Precision Floating-Point Values
SMPTypeCategory[NN_vfmsub231sd] = 14;          // Fused Multiply-Subtract of Scalar Double-Precision Floating-Point Values
SMPTypeCategory[NN_vfmsub231ss] = 14;          // Fused Multiply-Subtract of Scalar Single-Precision Floating-Point Values
SMPTypeCategory[NN_vfmsubadd132pd] = 14;       // Fused Multiply-Alternating Subtract/Add of Packed Double-Precision Floating-Point Values
SMPTypeCategory[NN_vfmsubadd132ps] = 14;       // Fused Multiply-Alternating Subtract/Add of Packed Single-Precision Floating-Point Values
SMPTypeCategory[NN_vfmsubadd213pd] = 14;       // Fused Multiply-Alternating Subtract/Add of Packed Double-Precision Floating-Point Values
SMPTypeCategory[NN_vfmsubadd213ps] = 14;       // Fused Multiply-Alternating Subtract/Add of Packed Single-Precision Floating-Point Values
SMPTypeCategory[NN_vfmsubadd231pd] = 14;       // Fused Multiply-Alternating Subtract/Add of Packed Double-Precision Floating-Point Values
SMPTypeCategory[NN_vfmsubadd231ps] = 14;       // Fused Multiply-Alternating Subtract/Add of Packed Single-Precision Floating-Point Values
SMPTypeCategory[NN_vfnmadd132pd] = 14;         // Fused Negative Multiply-Add of Packed Double-Precision Floating-Point Values
SMPTypeCategory[NN_vfnmadd132ps] = 14;         // Fused Negative Multiply-Add of Packed Single-Precision Floating-Point Values
SMPTypeCategory[NN_vfnmadd132sd] = 14;         // Fused Negative Multiply-Add of Scalar Double-Precision Floating-Point Values
SMPTypeCategory[NN_vfnmadd132ss] = 14;         // Fused Negative Multiply-Add of Scalar Single-Precision Floating-Point Values
SMPTypeCategory[NN_vfnmadd213pd] = 14;         // Fused Negative Multiply-Add of Packed Double-Precision Floating-Point Values
SMPTypeCategory[NN_vfnmadd213ps] = 14;         // Fused Negative Multiply-Add of Packed Single-Precision Floating-Point Values
SMPTypeCategory[NN_vfnmadd213sd] = 14;         // Fused Negative Multiply-Add of Scalar Double-Precision Floating-Point Values
SMPTypeCategory[NN_vfnmadd213ss] = 14;         // Fused Negative Multiply-Add of Scalar Single-Precision Floating-Point Values
SMPTypeCategory[NN_vfnmadd231pd] = 14;         // Fused Negative Multiply-Add of Packed Double-Precision Floating-Point Values
SMPTypeCategory[NN_vfnmadd231ps] = 14;         // Fused Negative Multiply-Add of Packed Single-Precision Floating-Point Values
SMPTypeCategory[NN_vfnmadd231sd] = 14;         // Fused Negative Multiply-Add of Scalar Double-Precision Floating-Point Values
SMPTypeCategory[NN_vfnmadd231ss] = 14;         // Fused Negative Multiply-Add of Scalar Single-Precision Floating-Point Values
SMPTypeCategory[NN_vfnmsub132pd] = 14;         // Fused Negative Multiply-Subtract of Packed Double-Precision Floating-Point Values
SMPTypeCategory[NN_vfnmsub132ps] = 14;         // Fused Negative Multiply-Subtract of Packed Single-Precision Floating-Point Values
SMPTypeCategory[NN_vfnmsub132sd] = 14;         // Fused Negative Multiply-Subtract of Scalar Double-Precision Floating-Point Values
SMPTypeCategory[NN_vfnmsub132ss] = 14;         // Fused Negative Multiply-Subtract of Scalar Single-Precision Floating-Point Values
SMPTypeCategory[NN_vfnmsub213pd] = 14;         // Fused Negative Multiply-Subtract of Packed Double-Precision Floating-Point Values
SMPTypeCategory[NN_vfnmsub213ps] = 14;         // Fused Negative Multiply-Subtract of Packed Single-Precision Floating-Point Values
SMPTypeCategory[NN_vfnmsub213sd] = 14;         // Fused Negative Multiply-Subtract of Scalar Double-Precision Floating-Point Values
SMPTypeCategory[NN_vfnmsub213ss] = 14;         // Fused Negative Multiply-Subtract of Scalar Single-Precision Floating-Point Values
SMPTypeCategory[NN_vfnmsub231pd] = 14;         // Fused Negative Multiply-Subtract of Packed Double-Precision Floating-Point Values
SMPTypeCategory[NN_vfnmsub231ps] = 14;         // Fused Negative Multiply-Subtract of Packed Single-Precision Floating-Point Values
SMPTypeCategory[NN_vfnmsub231sd] = 14;         // Fused Negative Multiply-Subtract of Scalar Double-Precision Floating-Point Values
SMPTypeCategory[NN_vfnmsub231ss] = 14;         // Fused Negative Multiply-Subtract of Scalar Single-Precision Floating-Point Values
SMPTypeCategory[NN_vgatherdps] = 14;           // Gather Packed SP FP Values Using Signed Dword Indices
SMPTypeCategory[NN_vgatherdpd] = 14;           // Gather Packed DP FP Values Using Signed Dword Indices
SMPTypeCategory[NN_vgatherqps] = 14;           // Gather Packed SP FP Values Using Signed Qword Indices
SMPTypeCategory[NN_vgatherqpd] = 14;           // Gather Packed DP FP Values Using Signed Qword Indices
SMPTypeCategory[NN_vhaddpd] = 14;              // Add horizontally packed DP FP numbers
SMPTypeCategory[NN_vhaddps] = 14;              // Add horizontally packed SP FP numbers
SMPTypeCategory[NN_vhsubpd] = 14;              // Sub horizontally packed DP FP numbers
SMPTypeCategory[NN_vhsubps] = 14;              // Sub horizontally packed SP FP numbers
SMPTypeCategory[NN_vinsertf128] = 14;          // Insert Packed Floating-Point Values
SMPTypeCategory[NN_vinserti128] = 14;          // Insert Packed Integer Values
SMPTypeCategory[NN_vinsertps] = 14;            // Insert Packed Single Precision Floating-Point Value
SMPTypeCategory[NN_vlddqu] = 14;               // Load Unaligned Packed Integer Values
SMPTypeCategory[NN_vldmxcsr] = 14;             // Load Streaming SIMD Extensions Technology Control/Status Register
SMPTypeCategory[NN_vmaskmovdqu] = 15;          // Store Selected Bytes of Double Quadword with NT Hint
SMPTypeCategory[NN_vmaskmovpd] = 15;           // Conditionally Load Packed Double-Precision Floating-Point Values
SMPTypeCategory[NN_vmaskmovps] = 15;           // Conditionally Load Packed Single-Precision Floating-Point Values
SMPTypeCategory[NN_vmaxpd] = 14;               // Return Maximum Packed Double-Precision Floating-Point Values
SMPTypeCategory[NN_vmaxps] = 14;               // Packed Single-FP Maximum
SMPTypeCategory[NN_vmaxsd] = 14;               // Return Maximum Scalar Double-Precision Floating-Point Value
SMPTypeCategory[NN_vmaxss] = 14;               // Scalar Single-FP Maximum
SMPTypeCategory[NN_vminpd] = 14;               // Return Minimum Packed Double-Precision Floating-Point Values
SMPTypeCategory[NN_vminps] = 14;               // Packed Single-FP Minimum
SMPTypeCategory[NN_vminsd] = 14;               // Return Minimum Scalar Double-Precision Floating-Point Value
SMPTypeCategory[NN_vminss] = 14;               // Scalar Single-FP Minimum
SMPTypeCategory[NN_vmovapd] = 15;              // Move Aligned Packed Double-Precision Floating-Point Values
SMPTypeCategory[NN_vmovaps] = 15;              // Move Aligned Four Packed Single-FP
SMPTypeCategory[NN_vmovd] = 15;                // Move 32 bits
SMPTypeCategory[NN_vmovddup] = 15;             // Move One Double-FP and Duplicate
SMPTypeCategory[NN_vmovdqa] = 15;              // Move Aligned Double Quadword
SMPTypeCategory[NN_vmovdqu] = 15;              // Move Unaligned Double Quadword
SMPTypeCategory[NN_vmovhlps] = 15;             // Move High to Low Packed Single-FP
SMPTypeCategory[NN_vmovhpd] = 15;              // Move High Packed Double-Precision Floating-Point Values
SMPTypeCategory[NN_vmovhps] = 15;              // Move High Packed Single-FP
SMPTypeCategory[NN_vmovlhps] = 15;             // Move Low to High Packed Single-FP
SMPTypeCategory[NN_vmovlpd] = 15;              // Move Low Packed Double-Precision Floating-Point Values
SMPTypeCategory[NN_vmovlps] = 15;              // Move Low Packed Single-FP
SMPTypeCategory[NN_vmovmskpd] = 15;            // Extract Packed Double-Precision Floating-Point Sign Mask
SMPTypeCategory[NN_vmovmskps] = 15;            // Move Mask to Register
SMPTypeCategory[NN_vmovntdq] = 15;             // Store Double Quadword Using Non-Temporal Hint
SMPTypeCategory[NN_vmovntdqa] = 15;            // Load Double Quadword Non-Temporal Aligned Hint
SMPTypeCategory[NN_vmovntpd] = 15;             // Store Packed Double-Precision Floating-Point Values Using Non-Temporal Hint
SMPTypeCategory[NN_vmovntps] = 15;             // Move Aligned Four Packed Single-FP Non Temporal
SMPTypeCategory[NN_vmovntsd] = 15;             // Move Non-Temporal Scalar Double-Precision Floating-Point
SMPTypeCategory[NN_vmovntss] = 15;             // Move Non-Temporal Scalar Single-Precision Floating-Point
SMPTypeCategory[NN_vmovq] = 15;                // Move 64 bits
SMPTypeCategory[NN_vmovsd] = 15;               // Move Scalar Double-Precision Floating-Point Values
SMPTypeCategory[NN_vmovshdup] = 15;            // Move Packed Single-FP High and Duplicate
SMPTypeCategory[NN_vmovsldup] = 15;            // Move Packed Single-FP Low and Duplicate
SMPTypeCategory[NN_vmovss] = 15;               // Move Scalar Single-FP
SMPTypeCategory[NN_vmovupd] = 15;              // Move Unaligned Packed Double-Precision Floating-Point Values
SMPTypeCategory[NN_vmovups] = 15;              // Move Unaligned Four Packed Single-FP
SMPTypeCategory[NN_vmpsadbw] = 14;             // Compute Multiple Packed Sums of Absolute Difference
SMPTypeCategory[NN_vmulpd] = 14;               // Multiply Packed Double-Precision Floating-Point Values
SMPTypeCategory[NN_vmulps] = 14;               // Packed Single-FP Multiply
SMPTypeCategory[NN_vmulsd] = 14;               // Multiply Scalar Double-Precision Floating-Point Values
SMPTypeCategory[NN_vmulss] = 14;               // Scalar Single-FP Multiply
SMPTypeCategory[NN_vorpd] = 14;                // Bitwise Logical OR of Double-Precision Floating-Point Values
SMPTypeCategory[NN_vorps] = 14;                // Bitwise Logical OR for Single-FP Data
SMPTypeCategory[NN_vpabsb] = 14;               // Packed Absolute Value Byte
SMPTypeCategory[NN_vpabsd] = 14;               // Packed Absolute Value Doubleword
SMPTypeCategory[NN_vpabsw] = 14;               // Packed Absolute Value Word
SMPTypeCategory[NN_vpackssdw] = 14;            // Pack with Signed Saturation (Dword->Word)
SMPTypeCategory[NN_vpacksswb] = 14;            // Pack with Signed Saturation (Word->Byte)
SMPTypeCategory[NN_vpackusdw] = 14;            // Pack with Unsigned Saturation
SMPTypeCategory[NN_vpackuswb] = 14;            // Pack with Unsigned Saturation (Word->Byte)
SMPTypeCategory[NN_vpaddb] = 14;               // Packed Add Byte
SMPTypeCategory[NN_vpaddd] = 14;               // Packed Add Dword
SMPTypeCategory[NN_vpaddq] = 14;               // Add Packed Quadword Integers
SMPTypeCategory[NN_vpaddsb] = 14;              // Packed Add with Saturation (Byte)
SMPTypeCategory[NN_vpaddsw] = 14;              // Packed Add with Saturation (Word)
SMPTypeCategory[NN_vpaddusb] = 14;             // Packed Add Unsigned with Saturation (Byte)
SMPTypeCategory[NN_vpaddusw] = 14;             // Packed Add Unsigned with Saturation (Word)
SMPTypeCategory[NN_vpaddw] = 14;               // Packed Add Word
SMPTypeCategory[NN_vpalignr] = 14;             // Packed Align Right
SMPTypeCategory[NN_vpand] = 14;                // Bitwise Logical And
SMPTypeCategory[NN_vpandn] = 14;               // Bitwise Logical And Not
SMPTypeCategory[NN_vpavgb] = 14;               // Packed Average (Byte)
SMPTypeCategory[NN_vpavgw] = 14;               // Packed Average (Word)
SMPTypeCategory[NN_vpblendd] = 14;             // Blend Packed Dwords
SMPTypeCategory[NN_vpblendvb] = 14;            // Variable Blend Packed Bytes
SMPTypeCategory[NN_vpblendw] = 14;             // Blend Packed Words
SMPTypeCategory[NN_vpbroadcastb] = 14;         // Broadcast a Byte Integer
SMPTypeCategory[NN_vpbroadcastd] = 14;         // Broadcast a Dword Integer
SMPTypeCategory[NN_vpbroadcastq] = 14;         // Broadcast a Qword Integer
SMPTypeCategory[NN_vpbroadcastw] = 14;         // Broadcast a Word Integer
SMPTypeCategory[NN_vpclmulqdq] = 14;           // Carry-Less Multiplication Quadword
SMPTypeCategory[NN_vpcmpeqb] = 14;             // Packed Compare for Equal (Byte)
SMPTypeCategory[NN_vpcmpeqd] = 14;             // Packed Compare for Equal (Dword)
SMPTypeCategory[NN_vpcmpeqq] = 14;             // Compare Packed Qword Data for Equal
SMPTypeCategory[NN_vpcmpeqw] = 14;             // Packed Compare for Equal (Word)
SMPTypeCategory[NN_vpcmpestri] = 14;           // Packed Compare Explicit Length Strings, Return Index
SMPTypeCategory[NN_vpcmpestrm] = 14;           // Packed Compare Explicit Length Strings, Return Mask
SMPTypeCategory[NN_vpcmpgtb] = 14;             // Packed Compare for Greater Than (Byte)
SMPTypeCategory[NN_vpcmpgtd] = 14;             // Packed Compare for Greater Than (Dword)
SMPTypeCategory[NN_vpcmpgtq] = 14;             // Compare Packed Data for Greater Than
SMPTypeCategory[NN_vpcmpgtw] = 14;             // Packed Compare for Greater Than (Word)
SMPTypeCategory[NN_vpcmpistri] = 14;           // Packed Compare Implicit Length Strings, Return Index
SMPTypeCategory[NN_vpcmpistrm] = 14;           // Packed Compare Implicit Length Strings, Return Mask
SMPTypeCategory[NN_vperm2f128] = 14;           // Permute Floating-Point Values
SMPTypeCategory[NN_vperm2i128] = 14;           // Permute Integer Values
SMPTypeCategory[NN_vpermd] = 14;               // Full Doublewords Element Permutation
SMPTypeCategory[NN_vpermilpd] = 14;            // Permute Double-Precision Floating-Point Values
SMPTypeCategory[NN_vpermilps] = 14;            // Permute Single-Precision Floating-Point Values
SMPTypeCategory[NN_vpermpd] = 14;              // Permute Double-Precision Floating-Point Elements
SMPTypeCategory[NN_vpermps] = 14;              // Permute Single-Precision Floating-Point Elements
SMPTypeCategory[NN_vpermq] = 14;               // Qwords Element Permutation
SMPTypeCategory[NN_vpextrb] = 14;              // Extract Byte
SMPTypeCategory[NN_vpextrd] = 14;              // Extract Dword
SMPTypeCategory[NN_vpextrq] = 14;              // Extract Qword
SMPTypeCategory[NN_vpextrw] = 14;              // Extract Word
SMPTypeCategory[NN_vpgatherdd] = 14;           // Gather Packed Dword Values Using Signed Dword Indices
SMPTypeCategory[NN_vpgatherdq] = 14;           // Gather Packed Qword Values Using Signed Dword Indices
SMPTypeCategory[NN_vpgatherqd] = 14;           // Gather Packed Dword Values Using Signed Qword Indices
SMPTypeCategory[NN_vpgatherqq] = 14;           // Gather Packed Qword Values Using Signed Qword Indices
SMPTypeCategory[NN_vphaddd] = 14;              // Packed Horizontal Add Doubleword
SMPTypeCategory[NN_vphaddsw] = 14;          // Packed Horizontal Add and Saturate
SMPTypeCategory[NN_vphaddw] = 14;           // Packed Horizontal Add Word
SMPTypeCategory[NN_vphminposuw] = 14;       // Packed Horizontal Word Minimum
SMPTypeCategory[NN_vphsubd] = 14;           // Packed Horizontal Subtract Doubleword
SMPTypeCategory[NN_vphsubsw] = 14;          // Packed Horizontal Subtract and Saturate
SMPTypeCategory[NN_vphsubw] = 14;           // Packed Horizontal Subtract Word
SMPTypeCategory[NN_vpinsrb] = 14;           // Insert Byte
SMPTypeCategory[NN_vpinsrd] = 14;           // Insert Dword
SMPTypeCategory[NN_vpinsrq] = 14;           // Insert Qword
SMPTypeCategory[NN_vpinsrw] = 14;           // Insert Word
SMPTypeCategory[NN_vpmaddubsw] = 14;        // Multiply and Add Packed Signed and Unsigned Bytes
SMPTypeCategory[NN_vpmaddwd] = 14;          // Packed Multiply and Add
SMPTypeCategory[NN_vpmaskmovd] = 15;        // Conditionally Store Dword Values Using Mask
SMPTypeCategory[NN_vpmaskmovq] = 15;        // Conditionally Store Qword Values Using Mask
SMPTypeCategory[NN_vpmaxsb] = 14;           // Maximum of Packed Signed Byte Integers
SMPTypeCategory[NN_vpmaxsd] = 14;           // Maximum of Packed Signed Dword Integers
SMPTypeCategory[NN_vpmaxsw] = 14;           // Packed Signed Integer Word Maximum
SMPTypeCategory[NN_vpmaxub] = 14;           // Packed Unsigned Integer Byte Maximum
SMPTypeCategory[NN_vpmaxud] = 14;           // Maximum of Packed Unsigned Dword Integers
SMPTypeCategory[NN_vpmaxuw] = 14;           // Maximum of Packed Word Integers
SMPTypeCategory[NN_vpminsb] = 14;           // Minimum of Packed Signed Byte Integers
SMPTypeCategory[NN_vpminsd] = 14;           // Minimum of Packed Signed Dword Integers
SMPTypeCategory[NN_vpminsw] = 14;           // Packed Signed Integer Word Minimum
SMPTypeCategory[NN_vpminub] = 14;           // Packed Unsigned Integer Byte Minimum
SMPTypeCategory[NN_vpminud] = 14;           // Minimum of Packed Unsigned Dword Integers
SMPTypeCategory[NN_vpminuw] = 14;           // Minimum of Packed Word Integers
SMPTypeCategory[NN_vpmovmskb] = 15;         // Move Byte Mask to Integer
SMPTypeCategory[NN_vpmovsxbd] = 15;         // Packed Move with Sign Extend
SMPTypeCategory[NN_vpmovsxbq] = 15;         // Packed Move with Sign Extend
SMPTypeCategory[NN_vpmovsxbw] = 15;         // Packed Move with Sign Extend
SMPTypeCategory[NN_vpmovsxdq] = 15;         // Packed Move with Sign Extend
SMPTypeCategory[NN_vpmovsxwd] = 15;         // Packed Move with Sign Extend
SMPTypeCategory[NN_vpmovsxwq] = 15;         // Packed Move with Sign Extend
SMPTypeCategory[NN_vpmovzxbd] = 15;         // Packed Move with Zero Extend
SMPTypeCategory[NN_vpmovzxbq] = 15;         // Packed Move with Zero Extend
SMPTypeCategory[NN_vpmovzxbw] = 15;         // Packed Move with Zero Extend
SMPTypeCategory[NN_vpmovzxdq] = 15;         // Packed Move with Zero Extend
SMPTypeCategory[NN_vpmovzxwd] = 15;         // Packed Move with Zero Extend
SMPTypeCategory[NN_vpmovzxwq] = 15;         // Packed Move with Zero Extend
SMPTypeCategory[NN_vpmuldq] = 14;           // Multiply Packed Signed Dword Integers
SMPTypeCategory[NN_vpmulhrsw] = 14;         // Packed Multiply High with Round and Scale
SMPTypeCategory[NN_vpmulhuw] = 14;          // Packed Multiply High Unsigned
SMPTypeCategory[NN_vpmulhw] = 14;           // Packed Multiply High
SMPTypeCategory[NN_vpmulld] = 14;           // Multiply Packed Signed Dword Integers and Store Low Result
SMPTypeCategory[NN_vpmullw] = 14;           // Packed Multiply Low
SMPTypeCategory[NN_vpmuludq] = 14;          // Multiply Packed Unsigned Doubleword Integers
SMPTypeCategory[NN_vpor] = 14;              // Bitwise Logical Or
SMPTypeCategory[NN_vpsadbw] = 14;           // Packed Sum of Absolute Differences
SMPTypeCategory[NN_vpshufb] = 14;           // Packed Shuffle Bytes
SMPTypeCategory[NN_vpshufd] = 14;           // Shuffle Packed Doublewords
SMPTypeCategory[NN_vpshufhw] = 14;          // Shuffle Packed High Words
SMPTypeCategory[NN_vpshuflw] = 14;          // Shuffle Packed Low Words
SMPTypeCategory[NN_vpsignb] = 14;           // Packed SIGN Byte
SMPTypeCategory[NN_vpsignd] = 14;           // Packed SIGN Doubleword
SMPTypeCategory[NN_vpsignw] = 14;           // Packed SIGN Word
SMPTypeCategory[NN_vpslld] = 14;            // Packed Shift Left Logical (Dword)
SMPTypeCategory[NN_vpslldq] = 14;           // Shift Double Quadword Left Logical
SMPTypeCategory[NN_vpsllq] = 14;            // Packed Shift Left Logical (Qword)
SMPTypeCategory[NN_vpsllvd] = 14;           // Variable Bit Shift Left Logical (Dword)
SMPTypeCategory[NN_vpsllvq] = 14;           // Variable Bit Shift Left Logical (Qword)
SMPTypeCategory[NN_vpsllw] = 14;            // Packed Shift Left Logical (Word)
SMPTypeCategory[NN_vpsrad] = 14;            // Packed Shift Right Arithmetic (Dword)
SMPTypeCategory[NN_vpsravd] = 14;           // Variable Bit Shift Right Arithmetic
SMPTypeCategory[NN_vpsraw] = 14;            // Packed Shift Right Arithmetic (Word)
SMPTypeCategory[NN_vpsrld] = 14;            // Packed Shift Right Logical (Dword)
SMPTypeCategory[NN_vpsrldq] = 14;           // Shift Double Quadword Right Logical (Qword)
SMPTypeCategory[NN_vpsrlq] = 14;            // Packed Shift Right Logical (Qword)
SMPTypeCategory[NN_vpsrlvd] = 14;           // Variable Bit Shift Right Logical (Dword)
SMPTypeCategory[NN_vpsrlvq] = 14;           // Variable Bit Shift Right Logical (Qword)
SMPTypeCategory[NN_vpsrlw] = 14;            // Packed Shift Right Logical (Word)
SMPTypeCategory[NN_vpsubb] = 14;            // Packed Subtract Byte
SMPTypeCategory[NN_vpsubd] = 14;            // Packed Subtract Dword
SMPTypeCategory[NN_vpsubq] = 14;            // Subtract Packed Quadword Integers
SMPTypeCategory[NN_vpsubsb] = 14;           // Packed Subtract with Saturation (Byte)
SMPTypeCategory[NN_vpsubsw] = 14;           // Packed Subtract with Saturation (Word)
SMPTypeCategory[NN_vpsubusb] = 14;          // Packed Subtract Unsigned with Saturation (Byte)
SMPTypeCategory[NN_vpsubusw] = 14;          // Packed Subtract Unsigned with Saturation (Word)
SMPTypeCategory[NN_vpsubw] = 14;            // Packed Subtract Word
SMPTypeCategory[NN_vptest] = 14;            // Logical Compare
SMPTypeCategory[NN_vpunpckhbw] = 14;        // Unpack High Packed Data (Byte->Word)
SMPTypeCategory[NN_vpunpckhdq] = 14;        // Unpack High Packed Data (Dword->Qword)
SMPTypeCategory[NN_vpunpckhqdq] = 14;       // Unpack High Packed Data (Qword->Xmmword)
SMPTypeCategory[NN_vpunpckhwd] = 14;        // Unpack High Packed Data (Word->Dword)
SMPTypeCategory[NN_vpunpcklbw] = 14;        // Unpack Low Packed Data (Byte->Word)
SMPTypeCategory[NN_vpunpckldq] = 14;        // Unpack Low Packed Data (Dword->Qword)
SMPTypeCategory[NN_vpunpcklqdq] = 14;       // Unpack Low Packed Data (Qword->Xmmword)
SMPTypeCategory[NN_vpunpcklwd] = 14;        // Unpack Low Packed Data (Word->Dword)
SMPTypeCategory[NN_vpxor] = 14;             // Bitwise Logical Exclusive Or
SMPTypeCategory[NN_vrcpps] = 14;            // Packed Single-FP Reciprocal
SMPTypeCategory[NN_vrcpss] = 14;            // Scalar Single-FP Reciprocal
SMPTypeCategory[NN_vroundpd] = 14;          // Round Packed Double Precision Floating-Point Values
SMPTypeCategory[NN_vroundps] = 14;          // Round Packed Single Precision Floating-Point Values
SMPTypeCategory[NN_vroundsd] = 14;          // Round Scalar Double Precision Floating-Point Values
SMPTypeCategory[NN_vroundss] = 14;          // Round Scalar Single Precision Floating-Point Values
SMPTypeCategory[NN_vrsqrtps] = 14;          // Packed Single-FP Square Root Reciprocal
SMPTypeCategory[NN_vrsqrtss] = 14;          // Scalar Single-FP Square Root Reciprocal
SMPTypeCategory[NN_vshufpd] = 14;           // Shuffle Packed Double-Precision Floating-Point Values
SMPTypeCategory[NN_vshufps] = 14;           // Shuffle Single-FP
SMPTypeCategory[NN_vsqrtpd] = 14;           // Compute Square Roots of Packed Double-Precision Floating-Point Values
SMPTypeCategory[NN_vsqrtps] = 14;           // Packed Single-FP Square Root
SMPTypeCategory[NN_vsqrtsd] = 14;           // Compute Square Rootof Scalar Double-Precision Floating-Point Value
SMPTypeCategory[NN_vsqrtss] = 14;           // Scalar Single-FP Square Root
SMPTypeCategory[NN_vstmxcsr] = 14;          // Store Streaming SIMD Extensions Technology Control/Status Register
SMPTypeCategory[NN_vsubpd] = 14;            // Subtract Packed Double-Precision Floating-Point Values
SMPTypeCategory[NN_vsubps] = 14;            // Packed Single-FP Subtract
SMPTypeCategory[NN_vsubsd] = 14;            // Subtract Scalar Double-Precision Floating-Point Values
SMPTypeCategory[NN_vsubss] = 14;            // Scalar Single-FP Subtract
SMPTypeCategory[NN_vtestpd] = 14;           // Packed Double-Precision Floating-Point Bit Test
SMPTypeCategory[NN_vtestps] = 14;           // Packed Single-Precision Floating-Point Bit Test
SMPTypeCategory[NN_vucomisd] = 14;          // Unordered Compare Scalar Ordered Double-Precision Floating-Point Values and Set EFLAGS
SMPTypeCategory[NN_vucomiss] = 14;          // Scalar Unordered Single-FP Compare and Set EFLAGS
SMPTypeCategory[NN_vunpckhpd] = 14;         // Unpack and Interleave High Packed Double-Precision Floating-Point Values
SMPTypeCategory[NN_vunpckhps] = 14;         // Unpack High Packed Single-FP Data
SMPTypeCategory[NN_vunpcklpd] = 14;         // Unpack and Interleave Low Packed Double-Precision Floating-Point Values
SMPTypeCategory[NN_vunpcklps] = 14;         // Unpack Low Packed Single-FP Data
SMPTypeCategory[NN_vxorpd] = 14;            // Bitwise Logical OR of Double-Precision Floating-Point Values
SMPTypeCategory[NN_vxorps] = 14;            // Bitwise Logical XOR for Single-FP Data
SMPTypeCategory[NN_vzeroall] = 14;          // Zero All YMM Registers
SMPTypeCategory[NN_vzeroupper] = 14;        // Zero Upper Bits of YMM Registers

// Transactional Synchronization Extensions

SMPTypeCategory[NN_xabort] = 1;               // Transaction Abort
SMPTypeCategory[NN_xbegin] = 1;               // Transaction Begin
SMPTypeCategory[NN_xend] = 1;                 // Transaction End
SMPTypeCategory[NN_xtest] = 1;                // Test If In Transactional Execution

// Virtual PC synthetic instructions

SMPTypeCategory[NN_vmgetinfo] = 1;            // Virtual PC - Get VM Information
SMPTypeCategory[NN_vmsetinfo] = 1;            // Virtual PC - Set VM Information
SMPTypeCategory[NN_vmdxdsbl] = 1;             // Virtual PC - Disable Direct Execution
SMPTypeCategory[NN_vmdxenbl] = 1;             // Virtual PC - Enable Direct Execution
SMPTypeCategory[NN_vmcpuid] = 1;              // Virtual PC - Virtualized CPU Information
SMPTypeCategory[NN_vmhlt] = 1;                // Virtual PC - Halt
SMPTypeCategory[NN_vmsplaf] = 1;              // Virtual PC - Spin Lock Acquisition Failed
SMPTypeCategory[NN_vmpushfd] = 1;             // Virtual PC - Push virtualized flags register
SMPTypeCategory[NN_vmpopfd] = 1;              // Virtual PC - Pop virtualized flags register
SMPTypeCategory[NN_vmcli] = 1;                // Virtual PC - Clear Interrupt Flag
SMPTypeCategory[NN_vmsti] = 1;                // Virtual PC - Set Interrupt Flag
SMPTypeCategory[NN_vmiretd] = 1;              // Virtual PC - Return From Interrupt
SMPTypeCategory[NN_vmsgdt] = 1;               // Virtual PC - Store Global Descriptor Table
SMPTypeCategory[NN_vmsidt] = 1;               // Virtual PC - Store Interrupt Descriptor Table
SMPTypeCategory[NN_vmsldt] = 1;               // Virtual PC - Store Local Descriptor Table
SMPTypeCategory[NN_vmstr] = 1;                // Virtual PC - Store Task Register
SMPTypeCategory[NN_vmsdte] = 1;               // Virtual PC - Store to Descriptor Table Entry
SMPTypeCategory[NN_vpcext] = 1;               // Virtual PC - ISA extension

#endif  // 599 < IDA_SDK_VERSION

SMPTypeCategory[NN_last] = 1;

  return;

} // end InitTypeCategory()