STARSProgram.cpp

	OptCategory[STARS_NN_vcmpps] = 1;               // Packed Single-FP Compare
	OptCategory[STARS_NN_vcmpsd] = 1;               // Compare Scalar Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vcmpss] = 1;               // Scalar Single-FP Compare
	OptCategory[STARS_NN_vcomisd] = 1;              // Compare Scalar Ordered Double-Precision Floating-Point Values and Set EFLAGS
	OptCategory[STARS_NN_vcomiss] = 1;              // Scalar Ordered Single-FP Compare and Set EFLAGS
	OptCategory[STARS_NN_vcvtdq2pd] = 1;            // Convert Packed Doubleword Integers to Packed Single-Precision Floating-Point Values
	OptCategory[STARS_NN_vcvtdq2ps] = 1;            // Convert Packed Doubleword Integers to Packed Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vcvtpd2dq] = 1;            // Convert Packed Double-Precision Floating-Point Values to Packed Doubleword Integers
	OptCategory[STARS_NN_vcvtpd2ps] = 1;            // Convert Packed Double-Precision Floating-Point Values to Packed Single-Precision Floating-Point Values
	OptCategory[STARS_NN_vcvtph2ps] = 1;            // Convert 16-bit FP Values to Single-Precision FP Values
	OptCategory[STARS_NN_vcvtps2dq] = 1;            // Convert Packed Single-Precision Floating-Point Values to Packed Doubleword Integers
	OptCategory[STARS_NN_vcvtps2pd] = 1;            // Convert Packed Single-Precision Floating-Point Values to Packed Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vcvtps2ph] = 1;            // Convert Single-Precision FP value to 16-bit FP value
	OptCategory[STARS_NN_vcvtsd2si] = 1;            // Convert Scalar Double-Precision Floating-Point Value to Doubleword Integer
	OptCategory[STARS_NN_vcvtsd2ss] = 1;            // Convert Scalar Double-Precision Floating-Point Value to Scalar Single-Precision Floating-Point Value
	OptCategory[STARS_NN_vcvtsi2sd] = 1;            // Convert Doubleword Integer to Scalar Double-Precision Floating-Point Value
	OptCategory[STARS_NN_vcvtsi2ss] = 1;            // Scalar signed INT32 to Single-FP conversion
	OptCategory[STARS_NN_vcvtss2sd] = 1;            // Convert Scalar Single-Precision Floating-Point Value to Scalar Double-Precision Floating-Point Value
	OptCategory[STARS_NN_vcvtss2si] = 1;            // Scalar Single-FP to signed INT32 conversion
	OptCategory[STARS_NN_vcvttpd2dq] = 1;           // Convert With Truncation Packed Double-Precision Floating-Point Values to Packed Doubleword Integers
	OptCategory[STARS_NN_vcvttps2dq] = 1;           // Convert With Truncation Packed Single-Precision Floating-Point Values to Packed Doubleword Integers
	OptCategory[STARS_NN_vcvttsd2si] = 1;           // Convert with Truncation Scalar Double-Precision Floating-Point Value to Doubleword Integer
	OptCategory[STARS_NN_vcvttss2si] = 1;           // Scalar Single-FP to signed INT32 conversion (truncate)
	OptCategory[STARS_NN_vdivpd] = 1;               // Divide Packed Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vdivps] = 1;               // Packed Single-FP Divide
	OptCategory[STARS_NN_vdivsd] = 1;               // Divide Scalar Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vdivss] = 1;               // Scalar Single-FP Divide
	OptCategory[STARS_NN_vdppd] = 1;                // Dot Product of Packed Double Precision Floating-Point Values
	OptCategory[STARS_NN_vdpps] = 1;                // Dot Product of Packed Single Precision Floating-Point Values
	OptCategory[STARS_NN_vextractf128] = 1;         // Extract Packed Floating-Point Values
	OptCategory[STARS_NN_vextracti128] = 1;         // Extract Packed Integer Values
	OptCategory[STARS_NN_vextractps] = 1;           // Extract Packed Floating-Point Values
	OptCategory[STARS_NN_vfmadd132pd] = 1;          // Fused Multiply-Add of Packed Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vfmadd132ps] = 1;          // Fused Multiply-Add of Packed Single-Precision Floating-Point Values
	OptCategory[STARS_NN_vfmadd132sd] = 1;          // Fused Multiply-Add of Scalar Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vfmadd132ss] = 1;          // Fused Multiply-Add of Scalar Single-Precision Floating-Point Values
	OptCategory[STARS_NN_vfmadd213pd] = 1;          // Fused Multiply-Add of Packed Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vfmadd213ps] = 1;          // Fused Multiply-Add of Packed Single-Precision Floating-Point Values
	OptCategory[STARS_NN_vfmadd213sd] = 1;          // Fused Multiply-Add of Scalar Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vfmadd213ss] = 1;          // Fused Multiply-Add of Scalar Single-Precision Floating-Point Values
	OptCategory[STARS_NN_vfmadd231pd] = 1;          // Fused Multiply-Add of Packed Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vfmadd231ps] = 1;          // Fused Multiply-Add of Packed Single-Precision Floating-Point Values
	OptCategory[STARS_NN_vfmadd231sd] = 1;          // Fused Multiply-Add of Scalar Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vfmadd231ss] = 1;          // Fused Multiply-Add of Scalar Single-Precision Floating-Point Values
	OptCategory[STARS_NN_vfmaddsub132pd] = 1;       // Fused Multiply-Alternating Add/Subtract of Packed Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vfmaddsub132ps] = 1;       // Fused Multiply-Alternating Add/Subtract of Packed Single-Precision Floating-Point Values
	OptCategory[STARS_NN_vfmaddsub213pd] = 1;       // Fused Multiply-Alternating Add/Subtract of Packed Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vfmaddsub213ps] = 1;       // Fused Multiply-Alternating Add/Subtract of Packed Single-Precision Floating-Point Values
	OptCategory[STARS_NN_vfmaddsub231pd] = 1;       // Fused Multiply-Alternating Add/Subtract of Packed Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vfmaddsub231ps] = 1;       // Fused Multiply-Alternating Add/Subtract of Packed Single-Precision Floating-Point Values
	OptCategory[STARS_NN_vfmsub132pd] = 1;          // Fused Multiply-Subtract of Packed Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vfmsub132ps] = 1;          // Fused Multiply-Subtract of Packed Single-Precision Floating-Point Values
	OptCategory[STARS_NN_vfmsub132sd] = 1;          // Fused Multiply-Subtract of Scalar Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vfmsub132ss] = 1;          // Fused Multiply-Subtract of Scalar Single-Precision Floating-Point Values
	OptCategory[STARS_NN_vfmsub213pd] = 1;          // Fused Multiply-Subtract of Packed Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vfmsub213ps] = 1;          // Fused Multiply-Subtract of Packed Single-Precision Floating-Point Values
	OptCategory[STARS_NN_vfmsub213sd] = 1;          // Fused Multiply-Subtract of Scalar Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vfmsub213ss] = 1;          // Fused Multiply-Subtract of Scalar Single-Precision Floating-Point Values
	OptCategory[STARS_NN_vfmsub231pd] = 1;          // Fused Multiply-Subtract of Packed Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vfmsub231ps] = 1;          // Fused Multiply-Subtract of Packed Single-Precision Floating-Point Values
	OptCategory[STARS_NN_vfmsub231sd] = 1;          // Fused Multiply-Subtract of Scalar Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vfmsub231ss] = 1;          // Fused Multiply-Subtract of Scalar Single-Precision Floating-Point Values
	OptCategory[STARS_NN_vfmsubadd132pd] = 1;       // Fused Multiply-Alternating Subtract/Add of Packed Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vfmsubadd132ps] = 1;       // Fused Multiply-Alternating Subtract/Add of Packed Single-Precision Floating-Point Values
	OptCategory[STARS_NN_vfmsubadd213pd] = 1;       // Fused Multiply-Alternating Subtract/Add of Packed Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vfmsubadd213ps] = 1;       // Fused Multiply-Alternating Subtract/Add of Packed Single-Precision Floating-Point Values
	OptCategory[STARS_NN_vfmsubadd231pd] = 1;       // Fused Multiply-Alternating Subtract/Add of Packed Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vfmsubadd231ps] = 1;       // Fused Multiply-Alternating Subtract/Add of Packed Single-Precision Floating-Point Values
	OptCategory[STARS_NN_vfnmadd132pd] = 1;         // Fused Negative Multiply-Add of Packed Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vfnmadd132ps] = 1;         // Fused Negative Multiply-Add of Packed Single-Precision Floating-Point Values
	OptCategory[STARS_NN_vfnmadd132sd] = 1;         // Fused Negative Multiply-Add of Scalar Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vfnmadd132ss] = 1;         // Fused Negative Multiply-Add of Scalar Single-Precision Floating-Point Values
	OptCategory[STARS_NN_vfnmadd213pd] = 1;         // Fused Negative Multiply-Add of Packed Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vfnmadd213ps] = 1;         // Fused Negative Multiply-Add of Packed Single-Precision Floating-Point Values
	OptCategory[STARS_NN_vfnmadd213sd] = 1;         // Fused Negative Multiply-Add of Scalar Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vfnmadd213ss] = 1;         // Fused Negative Multiply-Add of Scalar Single-Precision Floating-Point Values
	OptCategory[STARS_NN_vfnmadd231pd] = 1;         // Fused Negative Multiply-Add of Packed Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vfnmadd231ps] = 1;         // Fused Negative Multiply-Add of Packed Single-Precision Floating-Point Values
	OptCategory[STARS_NN_vfnmadd231sd] = 1;         // Fused Negative Multiply-Add of Scalar Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vfnmadd231ss] = 1;         // Fused Negative Multiply-Add of Scalar Single-Precision Floating-Point Values
	OptCategory[STARS_NN_vfnmsub132pd] = 1;         // Fused Negative Multiply-Subtract of Packed Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vfnmsub132ps] = 1;         // Fused Negative Multiply-Subtract of Packed Single-Precision Floating-Point Values
	OptCategory[STARS_NN_vfnmsub132sd] = 1;         // Fused Negative Multiply-Subtract of Scalar Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vfnmsub132ss] = 1;         // Fused Negative Multiply-Subtract of Scalar Single-Precision Floating-Point Values
	OptCategory[STARS_NN_vfnmsub213pd] = 1;         // Fused Negative Multiply-Subtract of Packed Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vfnmsub213ps] = 1;         // Fused Negative Multiply-Subtract of Packed Single-Precision Floating-Point Values
	OptCategory[STARS_NN_vfnmsub213sd] = 1;         // Fused Negative Multiply-Subtract of Scalar Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vfnmsub213ss] = 1;         // Fused Negative Multiply-Subtract of Scalar Single-Precision Floating-Point Values
	OptCategory[STARS_NN_vfnmsub231pd] = 1;         // Fused Negative Multiply-Subtract of Packed Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vfnmsub231ps] = 1;         // Fused Negative Multiply-Subtract of Packed Single-Precision Floating-Point Values
	OptCategory[STARS_NN_vfnmsub231sd] = 1;         // Fused Negative Multiply-Subtract of Scalar Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vfnmsub231ss] = 1;         // Fused Negative Multiply-Subtract of Scalar Single-Precision Floating-Point Values
	OptCategory[STARS_NN_vgatherdps] = 1;           // Gather Packed SP FP Values Using Signed Dword Indices
	OptCategory[STARS_NN_vgatherdpd] = 1;           // Gather Packed DP FP Values Using Signed Dword Indices
	OptCategory[STARS_NN_vgatherqps] = 1;           // Gather Packed SP FP Values Using Signed Qword Indices
	OptCategory[STARS_NN_vgatherqpd] = 1;           // Gather Packed DP FP Values Using Signed Qword Indices
	OptCategory[STARS_NN_vhaddpd] = 1;              // Add horizontally packed DP FP numbers
	OptCategory[STARS_NN_vhaddps] = 1;              // Add horizontally packed SP FP numbers
	OptCategory[STARS_NN_vhsubpd] = 1;              // Sub horizontally packed DP FP numbers
	OptCategory[STARS_NN_vhsubps] = 1;              // Sub horizontally packed SP FP numbers
	OptCategory[STARS_NN_vinsertf128] = 1;          // Insert Packed Floating-Point Values
	OptCategory[STARS_NN_vinserti128] = 1;          // Insert Packed Integer Values
	OptCategory[STARS_NN_vinsertps] = 1;            // Insert Packed Single Precision Floating-Point Value
	OptCategory[STARS_NN_vlddqu] = 1;               // Load Unaligned Packed Integer Values
	OptCategory[STARS_NN_vldmxcsr] = 1;             // Load Streaming SIMD Extensions Technology Control/Status Register
	OptCategory[STARS_NN_vmaskmovdqu] = 9;          // Store Selected Bytes of Double Quadword with NT Hint
	OptCategory[STARS_NN_vmaskmovpd] = 9;           // Conditionally Load Packed Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vmaskmovps] = 9;           // Conditionally Load Packed Single-Precision Floating-Point Values
	OptCategory[STARS_NN_vmaxpd] = 1;               // Return Maximum Packed Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vmaxps] = 1;               // Packed Single-FP Maximum
	OptCategory[STARS_NN_vmaxsd] = 1;               // Return Maximum Scalar Double-Precision Floating-Point Value
	OptCategory[STARS_NN_vmaxss] = 1;               // Scalar Single-FP Maximum
	OptCategory[STARS_NN_vminpd] = 1;               // Return Minimum Packed Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vminps] = 1;               // Packed Single-FP Minimum
	OptCategory[STARS_NN_vminsd] = 1;               // Return Minimum Scalar Double-Precision Floating-Point Value
	OptCategory[STARS_NN_vminss] = 1;               // Scalar Single-FP Minimum
	OptCategory[STARS_NN_vmovapd] = 9;              // Move Aligned Packed Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vmovaps] = 9;              // Move Aligned Four Packed Single-FP
	OptCategory[STARS_NN_vmovd] = 9;                // Move 32 bits
	OptCategory[STARS_NN_vmovddup] = 1;             // Move One Double-FP and Duplicate
	OptCategory[STARS_NN_vmovdqa] = 1;              // Move Aligned Double Quadword
	OptCategory[STARS_NN_vmovdqu] = 1;              // Move Unaligned Double Quadword
	OptCategory[STARS_NN_vmovhlps] = 1;             // Move High to Low Packed Single-FP
	OptCategory[STARS_NN_vmovhpd] = 1;              // Move High Packed Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vmovhps] = 1;              // Move High Packed Single-FP
	OptCategory[STARS_NN_vmovlhps] = 1;             // Move Low to High Packed Single-FP
	OptCategory[STARS_NN_vmovlpd] = 1;              // Move Low Packed Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vmovlps] = 1;              // Move Low Packed Single-FP
	OptCategory[STARS_NN_vmovmskpd] = 1;            // Extract Packed Double-Precision Floating-Point Sign Mask
	OptCategory[STARS_NN_vmovmskps] = 1;            // Move Mask to Register
	OptCategory[STARS_NN_vmovntdq] = 1;             // Store Double Quadword Using Non-Temporal Hint
	OptCategory[STARS_NN_vmovntdqa] = 1;            // Load Double Quadword Non-Temporal Aligned Hint
	OptCategory[STARS_NN_vmovntpd] = 1;             // Store Packed Double-Precision Floating-Point Values Using Non-Temporal Hint
	OptCategory[STARS_NN_vmovntps] = 1;             // Move Aligned Four Packed Single-FP Non Temporal
#if (IDA_SDK_VERSION < 700)      // Incredibly, these opcodes were removed in IDA Pro 7.0
	OptCategory[STARS_NN_vmovntsd] = 1;             // Move Non-Temporal Scalar Double-Precision Floating-Point
	OptCategory[STARS_NN_vmovntss] = 1;             // Move Non-Temporal Scalar Single-Precision Floating-Point
#endif
	OptCategory[STARS_NN_vmovq] = 1;                // Move 64 bits
	OptCategory[STARS_NN_vmovsd] = 1;               // Move Scalar Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vmovshdup] = 1;            // Move Packed Single-FP High and Duplicate
	OptCategory[STARS_NN_vmovsldup] = 1;            // Move Packed Single-FP Low and Duplicate
	OptCategory[STARS_NN_vmovss] = 1;               // Move Scalar Single-FP
	OptCategory[STARS_NN_vmovupd] = 1;              // Move Unaligned Packed Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vmovups] = 1;              // Move Unaligned Four Packed Single-FP
	OptCategory[STARS_NN_vmpsadbw] = 1;             // Compute Multiple Packed Sums of Absolute Difference
	OptCategory[STARS_NN_vmulpd] = 1;               // Multiply Packed Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vmulps] = 1;               // Packed Single-FP Multiply
	OptCategory[STARS_NN_vmulsd] = 1;               // Multiply Scalar Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vmulss] = 1;               // Scalar Single-FP Multiply
	OptCategory[STARS_NN_vorpd] = 1;                // Bitwise Logical OR of Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vorps] = 1;                // Bitwise Logical OR for Single-FP Data
	OptCategory[STARS_NN_vpabsb] = 1;               // Packed Absolute Value Byte
	OptCategory[STARS_NN_vpabsd] = 1;               // Packed Absolute Value Doubleword
	OptCategory[STARS_NN_vpabsw] = 1;               // Packed Absolute Value Word
	OptCategory[STARS_NN_vpackssdw] = 1;            // Pack with Signed Saturation (Dword->Word)
	OptCategory[STARS_NN_vpacksswb] = 1;            // Pack with Signed Saturation (Word->Byte)
	OptCategory[STARS_NN_vpackusdw] = 1;            // Pack with Unsigned Saturation
	OptCategory[STARS_NN_vpackuswb] = 1;            // Pack with Unsigned Saturation (Word->Byte)
	OptCategory[STARS_NN_vpaddb] = 1;               // Packed Add Byte
	OptCategory[STARS_NN_vpaddd] = 1;               // Packed Add Dword
	OptCategory[STARS_NN_vpaddq] = 1;               // Add Packed Quadword Integers
	OptCategory[STARS_NN_vpaddsb] = 1;              // Packed Add with Saturation (Byte)
	OptCategory[STARS_NN_vpaddsw] = 1;              // Packed Add with Saturation (Word)
	OptCategory[STARS_NN_vpaddusb] = 1;             // Packed Add Unsigned with Saturation (Byte)
	OptCategory[STARS_NN_vpaddusw] = 1;             // Packed Add Unsigned with Saturation (Word)
	OptCategory[STARS_NN_vpaddw] = 1;               // Packed Add Word
	OptCategory[STARS_NN_vpalignr] = 1;             // Packed Align Right
	OptCategory[STARS_NN_vpand] = 1;                // Bitwise Logical And
	OptCategory[STARS_NN_vpandn] = 1;               // Bitwise Logical And Not
	OptCategory[STARS_NN_vpavgb] = 1;               // Packed Average (Byte)
	OptCategory[STARS_NN_vpavgw] = 1;               // Packed Average (Word)
	OptCategory[STARS_NN_vpblendd] = 1;             // Blend Packed Dwords
	OptCategory[STARS_NN_vpblendvb] = 1;            // Variable Blend Packed Bytes
	OptCategory[STARS_NN_vpblendw] = 1;             // Blend Packed Words
	OptCategory[STARS_NN_vpbroadcastb] = 1;         // Broadcast a Byte Integer
	OptCategory[STARS_NN_vpbroadcastd] = 1;         // Broadcast a Dword Integer
	OptCategory[STARS_NN_vpbroadcastq] = 1;         // Broadcast a Qword Integer
	OptCategory[STARS_NN_vpbroadcastw] = 1;         // Broadcast a Word Integer
	OptCategory[STARS_NN_vpclmulqdq] = 1;           // Carry-Less Multiplication Quadword
	OptCategory[STARS_NN_vpcmpeqb] = 1;             // Packed Compare for Equal (Byte)
	OptCategory[STARS_NN_vpcmpeqd] = 1;             // Packed Compare for Equal (Dword)
	OptCategory[STARS_NN_vpcmpeqq] = 1;             // Compare Packed Qword Data for Equal
	OptCategory[STARS_NN_vpcmpeqw] = 1;             // Packed Compare for Equal (Word)
	OptCategory[STARS_NN_vpcmpestri] = 1;           // Packed Compare Explicit Length Strings, Return Index
	OptCategory[STARS_NN_vpcmpestrm] = 1;           // Packed Compare Explicit Length Strings, Return Mask
	OptCategory[STARS_NN_vpcmpgtb] = 1;             // Packed Compare for Greater Than (Byte)
	OptCategory[STARS_NN_vpcmpgtd] = 1;             // Packed Compare for Greater Than (Dword)
	OptCategory[STARS_NN_vpcmpgtq] = 1;             // Compare Packed Data for Greater Than
	OptCategory[STARS_NN_vpcmpgtw] = 1;             // Packed Compare for Greater Than (Word)
	OptCategory[STARS_NN_vpcmpistri] = 1;           // Packed Compare Implicit Length Strings, Return Index
	OptCategory[STARS_NN_vpcmpistrm] = 1;           // Packed Compare Implicit Length Strings, Return Mask
	OptCategory[STARS_NN_vperm2f128] = 1;           // Permute Floating-Point Values
	OptCategory[STARS_NN_vperm2i128] = 1;           // Permute Integer Values
	OptCategory[STARS_NN_vpermd] = 1;               // Full Doublewords Element Permutation
	OptCategory[STARS_NN_vpermilpd] = 1;            // Permute Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vpermilps] = 1;            // Permute Single-Precision Floating-Point Values
	OptCategory[STARS_NN_vpermpd] = 1;              // Permute Double-Precision Floating-Point Elements
	OptCategory[STARS_NN_vpermps] = 1;              // Permute Single-Precision Floating-Point Elements
	OptCategory[STARS_NN_vpermq] = 1;               // Qwords Element Permutation
	OptCategory[STARS_NN_vpextrb] = 1;              // Extract Byte
	OptCategory[STARS_NN_vpextrd] = 1;              // Extract Dword
	OptCategory[STARS_NN_vpextrq] = 1;              // Extract Qword
	OptCategory[STARS_NN_vpextrw] = 1;              // Extract Word
	OptCategory[STARS_NN_vpgatherdd] = 1;           // Gather Packed Dword Values Using Signed Dword Indices
	OptCategory[STARS_NN_vpgatherdq] = 1;           // Gather Packed Qword Values Using Signed Dword Indices
	OptCategory[STARS_NN_vpgatherqd] = 1;           // Gather Packed Dword Values Using Signed Qword Indices
	OptCategory[STARS_NN_vpgatherqq] = 1;           // Gather Packed Qword Values Using Signed Qword Indices
	OptCategory[STARS_NN_vphaddd] = 1;              // Packed Horizontal Add Doubleword
	OptCategory[STARS_NN_vphaddsw] = 1;          // Packed Horizontal Add and Saturate
	OptCategory[STARS_NN_vphaddw] = 1;           // Packed Horizontal Add Word
	OptCategory[STARS_NN_vphminposuw] = 1;       // Packed Horizontal Word Minimum
	OptCategory[STARS_NN_vphsubd] = 1;           // Packed Horizontal Subtract Doubleword
	OptCategory[STARS_NN_vphsubsw] = 1;          // Packed Horizontal Subtract and Saturate
	OptCategory[STARS_NN_vphsubw] = 1;           // Packed Horizontal Subtract Word
	OptCategory[STARS_NN_vpinsrb] = 1;           // Insert Byte
	OptCategory[STARS_NN_vpinsrd] = 1;           // Insert Dword
	OptCategory[STARS_NN_vpinsrq] = 1;           // Insert Qword
	OptCategory[STARS_NN_vpinsrw] = 1;           // Insert Word
	OptCategory[STARS_NN_vpmaddubsw] = 1;        // Multiply and Add Packed Signed and Unsigned Bytes
	OptCategory[STARS_NN_vpmaddwd] = 1;          // Packed Multiply and Add
	OptCategory[STARS_NN_vpmaskmovd] = 1;        // Conditionally Store Dword Values Using Mask
	OptCategory[STARS_NN_vpmaskmovq] = 1;        // Conditionally Store Qword Values Using Mask
	OptCategory[STARS_NN_vpmaxsb] = 1;           // Maximum of Packed Signed Byte Integers
	OptCategory[STARS_NN_vpmaxsd] = 1;           // Maximum of Packed Signed Dword Integers
	OptCategory[STARS_NN_vpmaxsw] = 1;           // Packed Signed Integer Word Maximum
	OptCategory[STARS_NN_vpmaxub] = 1;           // Packed Unsigned Integer Byte Maximum
	OptCategory[STARS_NN_vpmaxud] = 1;           // Maximum of Packed Unsigned Dword Integers
	OptCategory[STARS_NN_vpmaxuw] = 1;           // Maximum of Packed Word Integers
	OptCategory[STARS_NN_vpminsb] = 1;           // Minimum of Packed Signed Byte Integers
	OptCategory[STARS_NN_vpminsd] = 1;           // Minimum of Packed Signed Dword Integers
	OptCategory[STARS_NN_vpminsw] = 1;           // Packed Signed Integer Word Minimum
	OptCategory[STARS_NN_vpminub] = 1;           // Packed Unsigned Integer Byte Minimum
	OptCategory[STARS_NN_vpminud] = 1;           // Minimum of Packed Unsigned Dword Integers
	OptCategory[STARS_NN_vpminuw] = 1;           // Minimum of Packed Word Integers
	OptCategory[STARS_NN_vpmovmskb] = 1;         // Move Byte Mask to Integer
	OptCategory[STARS_NN_vpmovsxbd] = 1;         // Packed Move with Sign Extend
	OptCategory[STARS_NN_vpmovsxbq] = 1;         // Packed Move with Sign Extend
	OptCategory[STARS_NN_vpmovsxbw] = 1;         // Packed Move with Sign Extend
	OptCategory[STARS_NN_vpmovsxdq] = 1;         // Packed Move with Sign Extend
	OptCategory[STARS_NN_vpmovsxwd] = 1;         // Packed Move with Sign Extend
	OptCategory[STARS_NN_vpmovsxwq] = 1;         // Packed Move with Sign Extend
	OptCategory[STARS_NN_vpmovzxbd] = 1;         // Packed Move with Zero Extend
	OptCategory[STARS_NN_vpmovzxbq] = 1;         // Packed Move with Zero Extend
	OptCategory[STARS_NN_vpmovzxbw] = 1;         // Packed Move with Zero Extend
	OptCategory[STARS_NN_vpmovzxdq] = 1;         // Packed Move with Zero Extend
	OptCategory[STARS_NN_vpmovzxwd] = 1;         // Packed Move with Zero Extend
	OptCategory[STARS_NN_vpmovzxwq] = 1;         // Packed Move with Zero Extend
	OptCategory[STARS_NN_vpmuldq] = 1;           // Multiply Packed Signed Dword Integers
	OptCategory[STARS_NN_vpmulhrsw] = 1;         // Packed Multiply High with Round and Scale
	OptCategory[STARS_NN_vpmulhuw] = 1;          // Packed Multiply High Unsigned
	OptCategory[STARS_NN_vpmulhw] = 1;           // Packed Multiply High
	OptCategory[STARS_NN_vpmulld] = 1;           // Multiply Packed Signed Dword Integers and Store Low Result
	OptCategory[STARS_NN_vpmullw] = 1;           // Packed Multiply Low
	OptCategory[STARS_NN_vpmuludq] = 1;          // Multiply Packed Unsigned Doubleword Integers
	OptCategory[STARS_NN_vpor] = 1;              // Bitwise Logical Or
	OptCategory[STARS_NN_vpsadbw] = 1;           // Packed Sum of Absolute Differences
	OptCategory[STARS_NN_vpshufb] = 1;           // Packed Shuffle Bytes
	OptCategory[STARS_NN_vpshufd] = 1;           // Shuffle Packed Doublewords
	OptCategory[STARS_NN_vpshufhw] = 1;          // Shuffle Packed High Words
	OptCategory[STARS_NN_vpshuflw] = 1;          // Shuffle Packed Low Words
	OptCategory[STARS_NN_vpsignb] = 1;           // Packed SIGN Byte
	OptCategory[STARS_NN_vpsignd] = 1;           // Packed SIGN Doubleword
	OptCategory[STARS_NN_vpsignw] = 1;           // Packed SIGN Word
	OptCategory[STARS_NN_vpslld] = 1;            // Packed Shift Left Logical (Dword)
	OptCategory[STARS_NN_vpslldq] = 1;           // Shift Double Quadword Left Logical
	OptCategory[STARS_NN_vpsllq] = 1;            // Packed Shift Left Logical (Qword)
	OptCategory[STARS_NN_vpsllvd] = 1;           // Variable Bit Shift Left Logical (Dword)
	OptCategory[STARS_NN_vpsllvq] = 1;           // Variable Bit Shift Left Logical (Qword)
	OptCategory[STARS_NN_vpsllw] = 1;            // Packed Shift Left Logical (Word)
	OptCategory[STARS_NN_vpsrad] = 1;            // Packed Shift Right Arithmetic (Dword)
	OptCategory[STARS_NN_vpsravd] = 1;           // Variable Bit Shift Right Arithmetic
	OptCategory[STARS_NN_vpsraw] = 1;            // Packed Shift Right Arithmetic (Word)
	OptCategory[STARS_NN_vpsrld] = 1;            // Packed Shift Right Logical (Dword)
	OptCategory[STARS_NN_vpsrldq] = 1;           // Shift Double Quadword Right Logical (Qword)
	OptCategory[STARS_NN_vpsrlq] = 1;            // Packed Shift Right Logical (Qword)
	OptCategory[STARS_NN_vpsrlvd] = 1;           // Variable Bit Shift Right Logical (Dword)
	OptCategory[STARS_NN_vpsrlvq] = 1;           // Variable Bit Shift Right Logical (Qword)
	OptCategory[STARS_NN_vpsrlw] = 1;            // Packed Shift Right Logical (Word)
	OptCategory[STARS_NN_vpsubb] = 1;            // Packed Subtract Byte
	OptCategory[STARS_NN_vpsubd] = 1;            // Packed Subtract Dword
	OptCategory[STARS_NN_vpsubq] = 1;            // Subtract Packed Quadword Integers
	OptCategory[STARS_NN_vpsubsb] = 1;           // Packed Subtract with Saturation (Byte)
	OptCategory[STARS_NN_vpsubsw] = 1;           // Packed Subtract with Saturation (Word)
	OptCategory[STARS_NN_vpsubusb] = 1;          // Packed Subtract Unsigned with Saturation (Byte)
	OptCategory[STARS_NN_vpsubusw] = 1;          // Packed Subtract Unsigned with Saturation (Word)
	OptCategory[STARS_NN_vpsubw] = 1;            // Packed Subtract Word
	OptCategory[STARS_NN_vptest] = 1;            // Logical Compare
	OptCategory[STARS_NN_vpunpckhbw] = 1;        // Unpack High Packed Data (Byte->Word)
	OptCategory[STARS_NN_vpunpckhdq] = 1;        // Unpack High Packed Data (Dword->Qword)
	OptCategory[STARS_NN_vpunpckhqdq] = 1;       // Unpack High Packed Data (Qword->Xmmword)
	OptCategory[STARS_NN_vpunpckhwd] = 1;        // Unpack High Packed Data (Word->Dword)
	OptCategory[STARS_NN_vpunpcklbw] = 1;        // Unpack Low Packed Data (Byte->Word)
	OptCategory[STARS_NN_vpunpckldq] = 1;        // Unpack Low Packed Data (Dword->Qword)
	OptCategory[STARS_NN_vpunpcklqdq] = 1;       // Unpack Low Packed Data (Qword->Xmmword)
	OptCategory[STARS_NN_vpunpcklwd] = 1;        // Unpack Low Packed Data (Word->Dword)
	OptCategory[STARS_NN_vpxor] = 1;             // Bitwise Logical Exclusive Or
	OptCategory[STARS_NN_vrcpps] = 1;            // Packed Single-FP Reciprocal
	OptCategory[STARS_NN_vrcpss] = 1;            // Scalar Single-FP Reciprocal
	OptCategory[STARS_NN_vroundpd] = 1;          // Round Packed Double Precision Floating-Point Values
	OptCategory[STARS_NN_vroundps] = 1;          // Round Packed Single Precision Floating-Point Values
	OptCategory[STARS_NN_vroundsd] = 1;          // Round Scalar Double Precision Floating-Point Values
	OptCategory[STARS_NN_vroundss] = 1;          // Round Scalar Single Precision Floating-Point Values
	OptCategory[STARS_NN_vrsqrtps] = 1;          // Packed Single-FP Square Root Reciprocal
	OptCategory[STARS_NN_vrsqrtss] = 1;          // Scalar Single-FP Square Root Reciprocal
	OptCategory[STARS_NN_vshufpd] = 1;           // Shuffle Packed Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vshufps] = 1;           // Shuffle Single-FP
	OptCategory[STARS_NN_vsqrtpd] = 1;           // Compute Square Roots of Packed Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vsqrtps] = 1;           // Packed Single-FP Square Root
	OptCategory[STARS_NN_vsqrtsd] = 1;           // Compute Square Rootof Scalar Double-Precision Floating-Point Value
	OptCategory[STARS_NN_vsqrtss] = 1;           // Scalar Single-FP Square Root
	OptCategory[STARS_NN_vstmxcsr] = 1;          // Store Streaming SIMD Extensions Technology Control/Status Register
	OptCategory[STARS_NN_vsubpd] = 1;            // Subtract Packed Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vsubps] = 1;            // Packed Single-FP Subtract
	OptCategory[STARS_NN_vsubsd] = 1;            // Subtract Scalar Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vsubss] = 1;            // Scalar Single-FP Subtract
	OptCategory[STARS_NN_vtestpd] = 1;           // Packed Double-Precision Floating-Point Bit Test
	OptCategory[STARS_NN_vtestps] = 1;           // Packed Single-Precision Floating-Point Bit Test
	OptCategory[STARS_NN_vucomisd] = 1;          // Unordered Compare Scalar Ordered Double-Precision Floating-Point Values and Set EFLAGS
	OptCategory[STARS_NN_vucomiss] = 1;          // Scalar Unordered Single-FP Compare and Set EFLAGS
	OptCategory[STARS_NN_vunpckhpd] = 1;         // Unpack and Interleave High Packed Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vunpckhps] = 1;         // Unpack High Packed Single-FP Data
	OptCategory[STARS_NN_vunpcklpd] = 1;         // Unpack and Interleave Low Packed Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vunpcklps] = 1;         // Unpack Low Packed Single-FP Data
	OptCategory[STARS_NN_vxorpd] = 1;            // Bitwise Logical OR of Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vxorps] = 1;            // Bitwise Logical XOR for Single-FP Data
	OptCategory[STARS_NN_vzeroall] = 1;          // Zero All YMM Registers
	OptCategory[STARS_NN_vzeroupper] = 1;        // Zero Upper Bits of YMM Registers

	// Transactional Synchronization Extensions

	OptCategory[STARS_NN_xabort] = 1;               // Transaction Abort
	OptCategory[STARS_NN_xbegin] = 1;               // Transaction Begin
	OptCategory[STARS_NN_xend] = 1;                 // Transaction End
	OptCategory[STARS_NN_xtest] = 1;                // Test If In Transactional Execution

	// Virtual PC synthetic instructions

	OptCategory[STARS_NN_vmgetinfo] = 1;            // Virtual PC - Get VM Information
	OptCategory[STARS_NN_vmsetinfo] = 1;            // Virtual PC - Set VM Information
	OptCategory[STARS_NN_vmdxdsbl] = 1;             // Virtual PC - Disable Direct Execution
	OptCategory[STARS_NN_vmdxenbl] = 1;             // Virtual PC - Enable Direct Execution
	OptCategory[STARS_NN_vmcpuid] = 1;              // Virtual PC - Virtualized CPU Information
	OptCategory[STARS_NN_vmhlt] = 1;                // Virtual PC - Halt
	OptCategory[STARS_NN_vmsplaf] = 1;              // Virtual PC - Spin Lock Acquisition Failed
	OptCategory[STARS_NN_vmpushfd] = 1;             // Virtual PC - Push virtualized flags register
	OptCategory[STARS_NN_vmpopfd] = 1;              // Virtual PC - Pop virtualized flags register
	OptCategory[STARS_NN_vmcli] = 1;                // Virtual PC - Clear Interrupt Flag
	OptCategory[STARS_NN_vmsti] = 1;                // Virtual PC - Set Interrupt Flag
	OptCategory[STARS_NN_vmiretd] = 1;              // Virtual PC - Return From Interrupt
	OptCategory[STARS_NN_vmsgdt] = 1;               // Virtual PC - Store Global Descriptor Table
	OptCategory[STARS_NN_vmsidt] = 1;               // Virtual PC - Store Interrupt Descriptor Table
	OptCategory[STARS_NN_vmsldt] = 1;               // Virtual PC - Store Local Descriptor Table
	OptCategory[STARS_NN_vmstr] = 1;                // Virtual PC - Store Task Register
	OptCategory[STARS_NN_vmsdte] = 1;               // Virtual PC - Store to Descriptor Table Entry
	OptCategory[STARS_NN_vpcext] = 1;               // Virtual PC - ISA extension

	// FMA4
	OptCategory[STARS_NN_vfmaddsubps] = 1;          // Multiply with Alternating Add/Subtract of Packed Single-Precision Floating-Point
	OptCategory[STARS_NN_vfmaddsubpd] = 1;          // Multiply with Alternating Add/Subtract of Packed Double-Precision Floating-Point
	OptCategory[STARS_NN_vfmsubaddps] = 1;          // Multiply with Alternating Subtract/Add of Packed Single-Precision Floating-Point
	OptCategory[STARS_NN_vfmsubaddpd] = 1;          // Multiply with Alternating Subtract/Add of Packed Double-Precision Floating-Point
	OptCategory[STARS_NN_vfmaddps] = 1;             // Multiply and Add Packed Single-Precision Floating-Point
	OptCategory[STARS_NN_vfmaddpd] = 1;             // Multiply and Add Packed Double-Precision Floating-Point
	OptCategory[STARS_NN_vfmaddss] = 1;             // Multiply and Add Scalar Single-Precision Floating-Point
	OptCategory[STARS_NN_vfmaddsd] = 1;             // Multiply and Add Scalar Double-Precision Floating-Point
	OptCategory[STARS_NN_vfmsubps] = 1;             // Multiply and Subtract Packed Single-Precision Floating-Point
	OptCategory[STARS_NN_vfmsubpd] = 1;             // Multiply and Subtract Packed Double-Precision Floating-Point
	OptCategory[STARS_NN_vfmsubss] = 1;             // Multiply and Subtract Scalar Single-Precision Floating-Point
	OptCategory[STARS_NN_vfmsubsd] = 1;             // Multiply and Subtract Scalar Double-Precision Floating-Point
	OptCategory[STARS_NN_vfnmaddps] = 1;            // Negative Multiply and Add Packed Single-Precision Floating-Point
	OptCategory[STARS_NN_vfnmaddpd] = 1;            // Negative Multiply and Add Packed Double-Precision Floating-Point
	OptCategory[STARS_NN_vfnmaddss] = 1;            // Negative Multiply and Add Scalar Single-Precision Floating-Point
	OptCategory[STARS_NN_vfnmaddsd] = 1;            // Negative Multiply and Add Double Single-Precision Floating-Point
	OptCategory[STARS_NN_vfnmsubps] = 1;            // Negative Multiply and Subtract Packed Single-Precision Floating-Point
	OptCategory[STARS_NN_vfnmsubpd] = 1;            // Negative Multiply and Subtract Packed Double-Precision Floating-Point
	OptCategory[STARS_NN_vfnmsubss] = 1;            // Negative Multiply and Subtract Scalar Single-Precision Floating-Point
	OptCategory[STARS_NN_vfnmsubsd] = 1;            // Negative Multiply and Subtract Double Single-Precision Floating-Point

	// Intel Memory Protection Extensions (MPX)

	OptCategory[STARS_NN_bndmk] = 1;                // Make Bounds
	OptCategory[STARS_NN_bndcl] = 1;                // Check Lower Bound
	OptCategory[STARS_NN_bndcu] = 1;                // Check Upper Bound
	OptCategory[STARS_NN_bndcn] = 1;                // Check Upper Bound
	OptCategory[STARS_NN_bndmov] = 1;               // Move Bounds
	OptCategory[STARS_NN_bndldx] = 1;               // Load Extended Bounds Using Address Translation
	OptCategory[STARS_NN_bndstx] = 1;               // Store Extended Bounds Using Address Translation

	// New xstate instructions

	OptCategory[STARS_NN_xrstors] = 1;              // Restore Processor Extended States Supervisor
	OptCategory[STARS_NN_xsavec] = 1;               // Save Processor Extended States with Compaction
	OptCategory[STARS_NN_xsaves] = 1;               // Save Processor Extended States Supervisor

	// PREFETCHWT1 support

	OptCategory[STARS_NN_prefetchwt1] = 1;          // Prefetch Vector Data Into Caches with Intent to Write and T1 Hint

	// Memory instructions

	OptCategory[STARS_NN_clflushopt] = 1;           // Flush a Cache Line Optimized
	OptCategory[STARS_NN_clwb] = 1;                 // Cache Line Write Back
	OptCategory[STARS_NN_pcommit] = 1;              // Persistent Commit (deprecated by Intel)

	// Protection Key Rights for User Pages

	OptCategory[STARS_NN_rdpkru] = 1;               // Read Protection Key Rights for User Pages
	OptCategory[STARS_NN_wrpkru] = 1;               // Write Data to User Page Key Register

	// AVX comparison pseudo-ops

	OptCategory[STARS_NN_vcmpeqpd] = 1;             // Compare Packed Double-Precision Floating-Point Values - Equal (ordered, non-signaling)
	OptCategory[STARS_NN_vcmpltpd] = 1;             // Compare Packed Double-Precision Floating-Point Values - Less-than (ordered, signaling)
	OptCategory[STARS_NN_vcmplepd] = 1;             // Compare Packed Double-Precision Floating-Point Values - Less-than-or-equal (ordered, signaling)
	OptCategory[STARS_NN_vcmpunordpd] = 1;          // Compare Packed Double-Precision Floating-Point Values - Unordered (non-signaling)
	OptCategory[STARS_NN_vcmpneqpd] = 1;            // Compare Packed Double-Precision Floating-Point Values - Not-equal (unordered, non-signaling)
	OptCategory[STARS_NN_vcmpnltpd] = 1;            // Compare Packed Double-Precision Floating-Point Values - Not-less-than (unordered, signaling)
	OptCategory[STARS_NN_vcmpnlepd] = 1;            // Compare Packed Double-Precision Floating-Point Values - Not-less-than-or-equal (unordered, signaling)
	OptCategory[STARS_NN_vcmpordpd] = 1;            // Compare Packed Double-Precision Floating-Point Values - Ordered (non-signaling)
	OptCategory[STARS_NN_vcmpeq_uqpd] = 1;          // Compare Packed Double-Precision Floating-Point Values - Equal (unordered, non-signaling)
	OptCategory[STARS_NN_vcmpngepd] = 1;            // Compare Packed Double-Precision Floating-Point Values - Not-greater-than-or-equal (unordered, signaling)
	OptCategory[STARS_NN_vcmpngtpd] = 1;            // Compare Packed Double-Precision Floating-Point Values - Not-greater-than (unordered, signaling)
	OptCategory[STARS_NN_vcmpfalsepd] = 1;          // Compare Packed Double-Precision Floating-Point Values - False (ordered, non-signaling)
	OptCategory[STARS_NN_vcmpneq_oqpd] = 1;         // Compare Packed Double-Precision Floating-Point Values - Not-equal (ordered, non-signaling)
	OptCategory[STARS_NN_vcmpgepd] = 1;             // Compare Packed Double-Precision Floating-Point Values - Greater-than-or-equal (ordered, signaling)
	OptCategory[STARS_NN_vcmpgtpd] = 1;             // Compare Packed Double-Precision Floating-Point Values - Greater-than (ordered, signaling)
	OptCategory[STARS_NN_vcmptruepd] = 1;           // Compare Packed Double-Precision Floating-Point Values - True (unordered, non-signaling)
	OptCategory[STARS_NN_vcmpeq_ospd] = 1;          // Compare Packed Double-Precision Floating-Point Values - Equal (ordered, signaling)
	OptCategory[STARS_NN_vcmplt_oqpd] = 1;          // Compare Packed Double-Precision Floating-Point Values - Less-than (ordered, non-signaling)
	OptCategory[STARS_NN_vcmple_oqpd] = 1;          // Compare Packed Double-Precision Floating-Point Values - Less-than-or-equal (ordered, non-signaling)
	OptCategory[STARS_NN_vcmpunord_spd] = 1;        // Compare Packed Double-Precision Floating-Point Values - Unordered (signaling)
	OptCategory[STARS_NN_vcmpneq_uspd] = 1;         // Compare Packed Double-Precision Floating-Point Values - Not-equal (unordered, signaling)
	OptCategory[STARS_NN_vcmpnlt_uqpd] = 1;         // Compare Packed Double-Precision Floating-Point Values - Not-less-than (unordered, non-signaling)
	OptCategory[STARS_NN_vcmpnle_uqpd] = 1;         // Compare Packed Double-Precision Floating-Point Values - Not-less-than-or-equal (unordered, non-signaling)
	OptCategory[STARS_NN_vcmpord_spd] = 1;          // Compare Packed Double-Precision Floating-Point Values - Ordered (signaling)
	OptCategory[STARS_NN_vcmpeq_uspd] = 1;          // Compare Packed Double-Precision Floating-Point Values - Equal (unordered, signaling)
	OptCategory[STARS_NN_vcmpnge_uqpd] = 1;         // Compare Packed Double-Precision Floating-Point Values - Not-greater-than-or-equal (unordered, non-signaling)
	OptCategory[STARS_NN_vcmpngt_uqpd] = 1;         // Compare Packed Double-Precision Floating-Point Values - Not-greater-than (unordered, non-signaling)
	OptCategory[STARS_NN_vcmpfalse_ospd] = 1;       // Compare Packed Double-Precision Floating-Point Values - False (ordered, signaling)
	OptCategory[STARS_NN_vcmpneq_ospd] = 1;         // Compare Packed Double-Precision Floating-Point Values - Not-equal (ordered, signaling)
	OptCategory[STARS_NN_vcmpge_oqpd] = 1;          // Compare Packed Double-Precision Floating-Point Values - Greater-than-or-equal (ordered, non-signaling)
	OptCategory[STARS_NN_vcmpgt_oqpd] = 1;          // Compare Packed Double-Precision Floating-Point Values - Greater-than (ordered, non-signaling)
	OptCategory[STARS_NN_vcmptrue_uspd] = 1;        // Compare Packed Double-Precision Floating-Point Values - True (unordered, signaling)

	OptCategory[STARS_NN_vcmpeqps] = 1;             // Packed Single-FP Compare - Equal (ordered, non-signaling)
	OptCategory[STARS_NN_vcmpltps] = 1;             // Packed Single-FP Compare - Less-than (ordered, signaling)
	OptCategory[STARS_NN_vcmpleps] = 1;             // Packed Single-FP Compare - Less-than-or-equal (ordered, signaling)
	OptCategory[STARS_NN_vcmpunordps] = 1;          // Packed Single-FP Compare - Unordered (non-signaling)
	OptCategory[STARS_NN_vcmpneqps] = 1;            // Packed Single-FP Compare - Not-equal (unordered, non-signaling)

	OptCategory[STARS_NN_vcmpnltps] = 1;            // Packed Single-FP Compare - Not-less-than (unordered, signaling)
	OptCategory[STARS_NN_vcmpnleps] = 1;            // Packed Single-FP Compare - Not-less-than-or-equal (unordered, signaling)
	OptCategory[STARS_NN_vcmpordps] = 1;            // Packed Single-FP Compare - Ordered (non-signaling)
	OptCategory[STARS_NN_vcmpeq_uqps] = 1;          // Packed Single-FP Compare - Equal (unordered, non-signaling)
	OptCategory[STARS_NN_vcmpngeps] = 1;            // Packed Single-FP Compare - Not-greater-than-or-equal (unordered, signaling)
	OptCategory[STARS_NN_vcmpngtps] = 1;            // Packed Single-FP Compare - Not-greater-than (unordered, signaling)
	OptCategory[STARS_NN_vcmpfalseps] = 1;          // Packed Single-FP Compare - False (ordered, non-signaling)
	OptCategory[STARS_NN_vcmpneq_oqps] = 1;         // Packed Single-FP Compare - Not-equal (ordered, non-signaling)
	OptCategory[STARS_NN_vcmpgeps] = 1;             // Packed Single-FP Compare - Greater-than-or-equal (ordered, signaling)
	OptCategory[STARS_NN_vcmpgtps] = 1;             // Packed Single-FP Compare - Greater-than (ordered, signaling)
	OptCategory[STARS_NN_vcmptrueps] = 1;           // Packed Single-FP Compare - True (unordered, non-signaling)
	OptCategory[STARS_NN_vcmpeq_osps] = 1;          // Packed Single-FP Compare - Equal (ordered, signaling)
	OptCategory[STARS_NN_vcmplt_oqps] = 1;          // Packed Single-FP Compare - Less-than (ordered, non-signaling)
	OptCategory[STARS_NN_vcmple_oqps] = 1;          // Packed Single-FP Compare - Less-than-or-equal (ordered, non-signaling)
	OptCategory[STARS_NN_vcmpunord_sps] = 1;        // Packed Single-FP Compare - Unordered (signaling)
	OptCategory[STARS_NN_vcmpneq_usps] = 1;         // Packed Single-FP Compare - Not-equal (unordered, signaling)
	OptCategory[STARS_NN_vcmpnlt_uqps] = 1;         // Packed Single-FP Compare - Not-less-than (unordered, non-signaling)
	OptCategory[STARS_NN_vcmpnle_uqps] = 1;         // Packed Single-FP Compare - Not-less-than-or-equal (unordered, non-signaling)
	OptCategory[STARS_NN_vcmpord_sps] = 1;          // Packed Single-FP Compare - Ordered (signaling)
	OptCategory[STARS_NN_vcmpeq_usps] = 1;          // Packed Single-FP Compare - Equal (unordered, signaling)
	OptCategory[STARS_NN_vcmpnge_uqps] = 1;         // Packed Single-FP Compare - Not-greater-than-or-equal (unordered, non-signaling)
	OptCategory[STARS_NN_vcmpngt_uqps] = 1;         // Packed Single-FP Compare - Not-greater-than (unordered, non-signaling)
	OptCategory[STARS_NN_vcmpfalse_osps] = 1;       // Packed Single-FP Compare - False (ordered, signaling)
	OptCategory[STARS_NN_vcmpneq_osps] = 1;         // Packed Single-FP Compare - Not-equal (ordered, signaling)
	OptCategory[STARS_NN_vcmpge_oqps] = 1;          // Packed Single-FP Compare - Greater-than-or-equal (ordered, non-signaling)
	OptCategory[STARS_NN_vcmpgt_oqps] = 1;          // Packed Single-FP Compare - Greater-than (ordered, non-signaling)
	OptCategory[STARS_NN_vcmptrue_usps] = 1;        // Packed Single-FP Compare - True (unordered, signaling)


	OptCategory[STARS_NN_vcmpeqsd] = 1;             // Compare Scalar Double-Precision Floating-Point Values - Equal (ordered, non-signaling)
	OptCategory[STARS_NN_vcmpltsd] = 1;             // Compare Scalar Double-Precision Floating-Point Values - Less-than (ordered, signaling)
	OptCategory[STARS_NN_vcmplesd] = 1;             // Compare Scalar Double-Precision Floating-Point Values - Less-than-or-equal (ordered, signaling)
	OptCategory[STARS_NN_vcmpunordsd] = 1;          // Compare Scalar Double-Precision Floating-Point Values - Unordered (non-signaling)
	OptCategory[STARS_NN_vcmpneqsd] = 1;            // Compare Scalar Double-Precision Floating-Point Values - Not-equal (unordered, non-signaling)
	OptCategory[STARS_NN_vcmpnltsd] = 1;            // Compare Scalar Double-Precision Floating-Point Values - Not-less-than (unordered, signaling)
	OptCategory[STARS_NN_vcmpnlesd] = 1;            // Compare Scalar Double-Precision Floating-Point Values - Not-less-than-or-equal (unordered, signaling)
	OptCategory[STARS_NN_vcmpordsd] = 1;            // Compare Scalar Double-Precision Floating-Point Values - Ordered (non-signaling)
	OptCategory[STARS_NN_vcmpeq_uqsd] = 1;          // Compare Scalar Double-Precision Floating-Point Values - Equal (unordered, non-signaling)
	OptCategory[STARS_NN_vcmpngesd] = 1;            // Compare Scalar Double-Precision Floating-Point Values - Not-greater-than-or-equal (unordered, signaling)
	OptCategory[STARS_NN_vcmpngtsd] = 1;            // Compare Scalar Double-Precision Floating-Point Values - Not-greater-than (unordered, signaling)
	OptCategory[STARS_NN_vcmpfalsesd] = 1;          // Compare Scalar Double-Precision Floating-Point Values - False (ordered, non-signaling)
	OptCategory[STARS_NN_vcmpneq_oqsd] = 1;         // Compare Scalar Double-Precision Floating-Point Values - Not-equal (ordered, non-signaling)
	OptCategory[STARS_NN_vcmpgesd] = 1;             // Compare Scalar Double-Precision Floating-Point Values - Greater-than-or-equal (ordered, signaling)
	OptCategory[STARS_NN_vcmpgtsd] = 1;             // Compare Scalar Double-Precision Floating-Point Values - Greater-than (ordered, signaling)
	OptCategory[STARS_NN_vcmptruesd] = 1;           // Compare Scalar Double-Precision Floating-Point Values - True (unordered, non-signaling)
	OptCategory[STARS_NN_vcmpeq_ossd] = 1;          // Compare Scalar Double-Precision Floating-Point Values - Equal (ordered, signaling)
	OptCategory[STARS_NN_vcmplt_oqsd] = 1;          // Compare Scalar Double-Precision Floating-Point Values - Less-than (ordered, non-signaling)
	OptCategory[STARS_NN_vcmple_oqsd] = 1;          // Compare Scalar Double-Precision Floating-Point Values - Less-than-or-equal (ordered, non-signaling)
	OptCategory[STARS_NN_vcmpunord_ssd] = 1;        // Compare Scalar Double-Precision Floating-Point Values - Unordered (signaling)
	OptCategory[STARS_NN_vcmpneq_ussd] = 1;         // Compare Scalar Double-Precision Floating-Point Values - Not-equal (unordered, signaling)
	OptCategory[STARS_NN_vcmpnlt_uqsd] = 1;         // Compare Scalar Double-Precision Floating-Point Values - Not-less-than (unordered, non-signaling)
	OptCategory[STARS_NN_vcmpnle_uqsd] = 1;         // Compare Scalar Double-Precision Floating-Point Values - Not-less-than-or-equal (unordered, non-signaling)
	OptCategory[STARS_NN_vcmpord_ssd] = 1;          // Compare Scalar Double-Precision Floating-Point Values - Ordered (signaling)
	OptCategory[STARS_NN_vcmpeq_ussd] = 1;          // Compare Scalar Double-Precision Floating-Point Values - Equal (unordered, signaling)
	OptCategory[STARS_NN_vcmpnge_uqsd] = 1;         // Compare Scalar Double-Precision Floating-Point Values - Not-greater-than-or-equal (unordered, non-signaling)
	OptCategory[STARS_NN_vcmpngt_uqsd] = 1;         // Compare Scalar Double-Precision Floating-Point Values - Not-greater-than (unordered, non-signaling)
	OptCategory[STARS_NN_vcmpfalse_ossd] = 1;       // Compare Scalar Double-Precision Floating-Point Values - False (ordered, signaling)
	OptCategory[STARS_NN_vcmpneq_ossd] = 1;         // Compare Scalar Double-Precision Floating-Point Values - Not-equal (ordered, signaling)
	OptCategory[STARS_NN_vcmpge_oqsd] = 1;          // Compare Scalar Double-Precision Floating-Point Values - Greater-than-or-equal (ordered, non-signaling)
	OptCategory[STARS_NN_vcmpgt_oqsd] = 1;          // Compare Scalar Double-Precision Floating-Point Values - Greater-than (ordered, non-signaling)
	OptCategory[STARS_NN_vcmptrue_ussd] = 1;        // Compare Scalar Double-Precision Floating-Point Values - True (unordered, signaling)


	OptCategory[STARS_NN_vcmpeqss] = 1;             // Scalar Single-FP Compare - Equal (ordered, non-signaling)
	OptCategory[STARS_NN_vcmpltss] = 1;             // Scalar Single-FP Compare - Less-than (ordered, signaling)
	OptCategory[STARS_NN_vcmpless] = 1;             // Scalar Single-FP Compare - Less-than-or-equal (ordered, signaling)
	OptCategory[STARS_NN_vcmpunordss] = 1;          // Scalar Single-FP Compare - Unordered (non-signaling)
	OptCategory[STARS_NN_vcmpneqss] = 1;            // Scalar Single-FP Compare - Not-equal (unordered, non-signaling)
	OptCategory[STARS_NN_vcmpnltss] = 1;            // Scalar Single-FP Compare - Not-less-than (unordered, signaling)
	OptCategory[STARS_NN_vcmpnless] = 1;            // Scalar Single-FP Compare - Not-less-than-or-equal (unordered, signaling)
	OptCategory[STARS_NN_vcmpordss] = 1;            // Scalar Single-FP Compare - Ordered (non-signaling)
	OptCategory[STARS_NN_vcmpeq_uqss] = 1;          // Scalar Single-FP Compare - Equal (unordered, non-signaling)
	OptCategory[STARS_NN_vcmpngess] = 1;            // Scalar Single-FP Compare - Not-greater-than-or-equal (unordered, signaling)
	OptCategory[STARS_NN_vcmpngtss] = 1;            // Scalar Single-FP Compare - Not-greater-than (unordered, signaling)
	OptCategory[STARS_NN_vcmpfalsess] = 1;          // Scalar Single-FP Compare - False (ordered, non-signaling)
	OptCategory[STARS_NN_vcmpneq_oqss] = 1;         // Scalar Single-FP Compare - Not-equal (ordered, non-signaling)
	OptCategory[STARS_NN_vcmpgess] = 1;             // Scalar Single-FP Compare - Greater-than-or-equal (ordered, signaling)
	OptCategory[STARS_NN_vcmpgtss] = 1;             // Scalar Single-FP Compare - Greater-than (ordered, signaling)
	OptCategory[STARS_NN_vcmptruess] = 1;           // Scalar Single-FP Compare - True (unordered, non-signaling)
	OptCategory[STARS_NN_vcmpeq_osss] = 1;          // Scalar Single-FP Compare - Equal (ordered, signaling)
	OptCategory[STARS_NN_vcmplt_oqss] = 1;          // Scalar Single-FP Compare - Less-than (ordered, non-signaling)
	OptCategory[STARS_NN_vcmple_oqss] = 1;          // Scalar Single-FP Compare - Less-than-or-equal (ordered, non-signaling)
	OptCategory[STARS_NN_vcmpunord_sss] = 1;        // Scalar Single-FP Compare - Unordered (signaling)
	OptCategory[STARS_NN_vcmpneq_usss] = 1;         // Scalar Single-FP Compare - Not-equal (unordered, signaling)
	OptCategory[STARS_NN_vcmpnlt_uqss] = 1;         // Scalar Single-FP Compare - Not-less-than (unordered, non-signaling)
	OptCategory[STARS_NN_vcmpnle_uqss] = 1;         // Scalar Single-FP Compare - Not-less-than-or-equal (unordered, non-signaling)
	OptCategory[STARS_NN_vcmpord_sss] = 1;          // Scalar Single-FP Compare - Ordered (signaling)
	OptCategory[STARS_NN_vcmpeq_usss] = 1;          // Scalar Single-FP Compare - Equal (unordered, signaling)
	OptCategory[STARS_NN_vcmpnge_uqss] = 1;         // Scalar Single-FP Compare - Not-greater-than-or-equal (unordered, non-signaling)
	OptCategory[STARS_NN_vcmpngt_uqss] = 1;         // Scalar Single-FP Compare - Not-greater-than (unordered, non-signaling)
	OptCategory[STARS_NN_vcmpfalse_osss] = 1;       // Scalar Single-FP Compare - False (ordered, signaling)
	OptCategory[STARS_NN_vcmpneq_osss] = 1;         // Scalar Single-FP Compare - Not-equal (ordered, signaling)
	OptCategory[STARS_NN_vcmpge_oqss] = 1;          // Scalar Single-FP Compare - Greater-than-or-equal (ordered, non-signaling)
	OptCategory[STARS_NN_vcmpgt_oqss] = 1;          // Scalar Single-FP Compare - Greater-than (ordered, non-signaling)
	OptCategory[STARS_NN_vcmptrue_usss] = 1;        // Scalar Single-FP Compare - True (unordered, signaling)

	// AVX-512 instructions

	OptCategory[STARS_NN_valignd] = 1;              // Align Doubleword Vectors
	OptCategory[STARS_NN_valignq] = 1;              // Align Quadword Vectors
	OptCategory[STARS_NN_vblendmpd] = 1;            // Blend Float64 Vectors Using an OpMask Control
	OptCategory[STARS_NN_vblendmps] = 1;            // Blend Float32 Vectors Using an OpMask Control
	OptCategory[STARS_NN_vpblendmb] = 1;            // Blend Byte Vectors Using an Opmask Control
	OptCategory[STARS_NN_vpblendmw] = 1;            // Blend Word Vectors Using an Opmask Control
	OptCategory[STARS_NN_vpblendmd] = 1;            // Blend Int32 Vectors Using an OpMask Control
	OptCategory[STARS_NN_vpblendmq] = 1;            // Blend Int64 Vectors Using an OpMask Control
	OptCategory[STARS_NN_vbroadcastf32x2] = 1;      // Load with Broadcast Floating-Point Data
	OptCategory[STARS_NN_vbroadcastf32x4] = 1;      // Load with Broadcast Floating-Point Data
	OptCategory[STARS_NN_vbroadcastf64x2] = 1;      // Load with Broadcast Floating-Point Data
	OptCategory[STARS_NN_vbroadcastf32x8] = 1;      // Load with Broadcast Floating-Point Data
	OptCategory[STARS_NN_vbroadcastf64x4] = 1;      // Load with Broadcast Floating-Point Data
	OptCategory[STARS_NN_vbroadcasti32x2] = 1;      // Load Integer and Broadcast
	OptCategory[STARS_NN_vbroadcasti32x4] = 1;      // Load Integer and Broadcast
	OptCategory[STARS_NN_vbroadcasti64x2] = 1;      // Load Integer and Broadcast
	OptCategory[STARS_NN_vbroadcasti32x8] = 1;      // Load Integer and Broadcast
	OptCategory[STARS_NN_vbroadcasti64x4] = 1;      // Load Integer and Broadcast
	OptCategory[STARS_NN_vcompresspd] = 1;          // Store Sparse Packed Double-Precision Floating-Point Values into Dense Memory
	OptCategory[STARS_NN_vcompressps] = 1;          // Store Sparse Packed Single-Precision Floating-Point Values into Dense Memory
	OptCategory[STARS_NN_vcvtpd2qq] = 1;            // Convert Packed Double-Precision Floating-Point Values to Packed Quadword Integers
	OptCategory[STARS_NN_vcvtpd2udq] = 1;           // Convert Packed Double-Precision Floating-Point Values to Packed Unsigned Doubleword Integers
	OptCategory[STARS_NN_vcvtpd2uqq] = 1;           // Convert Packed Double-Precision Floating-Point Values to Packed Unsigned Quadword Integers
	OptCategory[STARS_NN_vcvtps2udq] = 1;           // Convert Packed Single-Precision Floating-Point Values to Packed Unsigned Doubleword Integer Values
	OptCategory[STARS_NN_vcvtps2qq] = 1;            // Convert Packed Single Precision Floating-Point Values to Packed Singed Quadword Integer Values
	OptCategory[STARS_NN_vcvtps2uqq] = 1;           // Convert Packed Single Precision Floating-Point Values to Packed Unsigned Quadword Integer Values
	OptCategory[STARS_NN_vcvtqq2pd] = 1;            // Convert Packed Quadword Integers to Packed Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vcvtqq2ps] = 1;            // Convert Packed Quadword Integers to Packed Single-Precision Floating-Point Values
	OptCategory[STARS_NN_vcvtsd2usi] = 1;           // Convert Scalar Double-Precision Floating-Point Value to Unsigned Doubleword Integer
	OptCategory[STARS_NN_vcvtss2usi] = 1;           // Convert Scalar Single-Precision Floating-Point Value to Unsigned Doubleword Integer
	OptCategory[STARS_NN_vcvttpd2qq] = 1;           // Convert with Truncation Packed Double-Precision Floating-Point Values to Packed Quadword Integers
	OptCategory[STARS_NN_vcvttpd2udq] = 1;          // Convert with Truncation Packed Double-Precision Floating-Point Values to Packed Unsigned Doubleword Integers
	OptCategory[STARS_NN_vcvttpd2uqq] = 1;          // Convert with Truncation Packed Double-Precision Floating-Point Values to Packed Unsigned Quadword Integers
	OptCategory[STARS_NN_vcvttps2udq] = 1;          // Convert with Truncation Packed Single-Precision Floating-Point Values to Packed Unsigned Doubleword Integer Values
	OptCategory[STARS_NN_vcvttps2qq] = 1;           // Convert with Truncation Packed Single Precision Floating-Point Values to Packed Singed Quadword Integer Values
	OptCategory[STARS_NN_vcvttps2uqq] = 1;          // Convert with Truncation Packed Single Precision Floating-Point Values to Packed Unsigned Quadword Integer Values
	OptCategory[STARS_NN_vcvttsd2usi] = 1;          // Convert with Truncation Scalar Double-Precision Floating-Point Value to Unsigned Integer
	OptCategory[STARS_NN_vcvttss2usi] = 1;          // Convert with Truncation Scalar Single-Precision Floating-Point Value to Unsigned Integer
	OptCategory[STARS_NN_vcvtudq2pd] = 1;           // Convert Packed Unsigned Doubleword Integers to Packed Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vcvtudq2ps] = 1;           // Convert Packed Unsigned Doubleword Integers to Packed Single-Precision Floating-Point Values
	OptCategory[STARS_NN_vcvtuqq2pd] = 1;           // Convert Packed Unsigned Quadword Integers to Packed Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vcvtuqq2ps] = 1;           // Convert Packed Unsigned Quadword Integers to Packed Single-Precision Floating-Point Values
	OptCategory[STARS_NN_vcvtusi2sd] = 1;           // Convert Unsigned Integer to Scalar Double-Precision Floating-Point Value
	OptCategory[STARS_NN_vcvtusi2ss] = 1;           // Convert Unsigned Integer to Scalar Single-Precision Floating-Point Value
	OptCategory[STARS_NN_vdbpsadbw] = 1;            // Double Block Packed Sum-Absolute-Differences (SAD) on Unsigned Bytes
	OptCategory[STARS_NN_vexpandpd] = 1;            // Load Sparse Packed Double-Precision Floating-Point Values from Dense Memory
	OptCategory[STARS_NN_vexpandps] = 1;            // Load Sparse Packed Single-Precision Floating-Point Values from Dense Memory
	OptCategory[STARS_NN_vextractf32x4] = 1;        // Extract Packed Floating-Point Values
	OptCategory[STARS_NN_vextractf64x2] = 1;        // Extract Packed Floating-Point Values
	OptCategory[STARS_NN_vextractf32x8] = 1;        // Extract Packed Floating-Point Values
	OptCategory[STARS_NN_vextractf64x4] = 1;        // Extract Packed Floating-Point Values
	OptCategory[STARS_NN_vextracti32x4] = 1;        // Extract packed Integer Values
	OptCategory[STARS_NN_vextracti64x2] = 1;        // Extract packed Integer Values
	OptCategory[STARS_NN_vextracti32x8] = 1;        // Extract packed Integer Values
	OptCategory[STARS_NN_vextracti64x4] = 1;        // Extract packed Integer Values
	OptCategory[STARS_NN_vfixupimmpd] = 1;          // Fix Up Special Packed Float64 Values
	OptCategory[STARS_NN_vfixupimmps] = 1;          // Fix Up Special Packed Float32 Values
	OptCategory[STARS_NN_vfixupimmsd] = 1;          // Fix Up Special Scalar Float64 Value
	OptCategory[STARS_NN_vfixupimmss] = 1;          // Fix Up Special Scalar Float32 Value
	OptCategory[STARS_NN_vfpclasspd] = 1;           // Tests Types Of a Packed Float64 Values
	OptCategory[STARS_NN_vfpclassps] = 1;           // Tests Types Of a Packed Float32 Values
	OptCategory[STARS_NN_vfpclasssd] = 1;           // Tests Types Of a Scalar Float64 Values
	OptCategory[STARS_NN_vfpclassss] = 1;           // Tests Types Of a Scalar Float32 Values
	OptCategory[STARS_NN_vgetexppd] = 1;            // Convert Exponents of Packed DP FP Values to DP FP Values
	OptCategory[STARS_NN_vgetexpps] = 1;            // Convert Exponents of Packed SP FP Values to SP FP Values
	OptCategory[STARS_NN_vgetexpsd] = 1;            // Convert Exponents of Scalar DP FP Values to DP FP Value
	OptCategory[STARS_NN_vgetexpss] = 1;            // Convert Exponents of Scalar SP FP Values to SP FP Value
	OptCategory[STARS_NN_vgetmantpd] = 1;           // Extract Float64 Vector of Normalized Mantissas from Float64 Vector
	OptCategory[STARS_NN_vgetmantps] = 1;           // Extract Float32 Vector of Normalized Mantissas from Float32 Vector
	OptCategory[STARS_NN_vgetmantsd] = 1;           // Extract Float64 of Normalized Mantissas from Float64 Scalar
	OptCategory[STARS_NN_vgetmantss] = 1;           // Extract Float32 Vector of Normalized Mantissa from Float32 Vector
	OptCategory[STARS_NN_vinsertf32x4] = 1;         // Insert Packed Floating-Point Values
	OptCategory[STARS_NN_vinsertf64x2] = 1;         // Insert Packed Floating-Point Values
	OptCategory[STARS_NN_vinsertf32x8] = 1;         // Insert Packed Floating-Point Values
	OptCategory[STARS_NN_vinsertf64x4] = 1;         // Insert Packed Floating-Point Values
	OptCategory[STARS_NN_vinserti32x4] = 1;         // Insert Packed Integer Values
	OptCategory[STARS_NN_vinserti64x2] = 1;         // Insert Packed Integer Values
	OptCategory[STARS_NN_vinserti32x8] = 1;         // Insert Packed Integer Values
	OptCategory[STARS_NN_vinserti64x4] = 1;         // Insert Packed Integer Values
	OptCategory[STARS_NN_vmovdqa32] = 1;            // Move Aligned Packed Integer Values
	OptCategory[STARS_NN_vmovdqa64] = 1;            // Move Aligned Packed Integer Values
	OptCategory[STARS_NN_vmovdqu8] = 1;             // Move Unaligned Packed Integer Values
	OptCategory[STARS_NN_vmovdqu16] = 1;            // Move Unaligned Packed Integer Values
	OptCategory[STARS_NN_vmovdqu32] = 1;            // Move Unaligned Packed Integer Values
	OptCategory[STARS_NN_vmovdqu64] = 1;            // Move Unaligned Packed Integer Values
	OptCategory[STARS_NN_vpabsq] = 1;               // Packed Absolute Value
	OptCategory[STARS_NN_vpandd] = 1;               // Logical AND
	OptCategory[STARS_NN_vpandq] = 1;               // Logical AND
	OptCategory[STARS_NN_vpandnd] = 1;              // Logical AND NOT
	OptCategory[STARS_NN_vpandnq] = 1;              // Logical AND NOT
	OptCategory[STARS_NN_vpbroadcastmb2q] = 1;      // Broadcast Mask to Vector Register
	OptCategory[STARS_NN_vpbroadcastmw2d] = 1;      // Broadcast Mask to Vector Register
	OptCategory[STARS_NN_vpcmpb] = 1;               // Compare Packed Byte Values Into Mask
	OptCategory[STARS_NN_vpcmpub] = 1;              // Compare Packed Byte Values Into Mask
	OptCategory[STARS_NN_vpcmpd] = 1;               // Compare Packed Integer Values into Mask
	OptCategory[STARS_NN_vpcmpud] = 1;              // Compare Packed Integer Values into Mask
	OptCategory[STARS_NN_vpcmpq] = 1;               // Compare Packed Integer Values into Mask
	OptCategory[STARS_NN_vpcmpuq] = 1;              // Compare Packed Integer Values into Mask
	OptCategory[STARS_NN_vpcmpw] = 1;               // Compare Packed Word Values Into Mask
	OptCategory[STARS_NN_vpcmpuw] = 1;              // Compare Packed Word Values Into Mask
	OptCategory[STARS_NN_vpcompressd] = 1;          // Store Sparse Packed Doubleword Integer Values into Dense Memory/Register
	OptCategory[STARS_NN_vpcompressq] = 1;          // Store Sparse Packed Quadword Integer Values into Dense Memory/Register
	OptCategory[STARS_NN_vpconflictd] = 1;          // Detect Conflicts Within a Vector of Packed Dword Values into Dense Memory/Register
	OptCategory[STARS_NN_vpconflictq] = 1;          // Detect Conflicts Within a Vector of Packed Qword Values into Dense Memory/Register
	OptCategory[STARS_NN_vpermb] = 1;               // Permute Packed Bytes Elements
	OptCategory[STARS_NN_vpermw] = 1;               // Permute Packed Words Elements
	OptCategory[STARS_NN_vpermi2b] = 1;             // Full Permute of Bytes From Two Tables Overwriting the Index
	OptCategory[STARS_NN_vpermi2w] = 1;             // Full Permute From Two Tables Overwriting the Index
	OptCategory[STARS_NN_vpermi2d] = 1;             // Full Permute From Two Tables Overwriting the Index
	OptCategory[STARS_NN_vpermi2q] = 1;             // Full Permute From Two Tables Overwriting the Index
	OptCategory[STARS_NN_vpermi2ps] = 1;            // Full Permute From Two Tables Overwriting the Index
	OptCategory[STARS_NN_vpermi2pd] = 1;            // Full Permute From Two Tables Overwriting the Index
	OptCategory[STARS_NN_vpermt2b] = 1;             // Full Permute of Bytes From Two Tables Overwriting a Table
	OptCategory[STARS_NN_vpermt2w] = 1;             // Full Permute from Two Tables Overwriting one Table
	OptCategory[STARS_NN_vpermt2d] = 1;             // Full Permute from Two Tables Overwriting one Table
	OptCategory[STARS_NN_vpermt2q] = 1;             // Full Permute from Two Tables Overwriting one Table
	OptCategory[STARS_NN_vpermt2ps] = 1;            // Full Permute from Two Tables Overwriting one Table
	OptCategory[STARS_NN_vpermt2pd] = 1;            // Full Permute from Two Tables Overwriting one Table
	OptCategory[STARS_NN_vpexpandd] = 1;            // Load Sparse Packed Doubleword Integer Values from Dense Memory/Register
	OptCategory[STARS_NN_vpexpandq] = 1;            // Load Sparse Packed Quadword Integer Values from Dense Memory/Register
	OptCategory[STARS_NN_vplzcntd] = 1;             // Count the Number of Leading Zero Bits for Packed Dword Values
	OptCategory[STARS_NN_vplzcntq] = 1;             // Count the Number of Leading Zero Bits for Packed Qword Values
	OptCategory[STARS_NN_vpmadd52luq] = 1;          // Packed Multiply of Unsigned 52-bit Integers and Add the Low 52-bit Products to Qword Accumulators
	OptCategory[STARS_NN_vpmadd52huq] = 1;          // Packed Multiply of Unsigned 52-bit Unsigned Integers and Add High 52-bit Products to 64-bit Accumulators
	OptCategory[STARS_NN_vpmaxsq] = 1;              // Maximum of Packed Signed Integers
	OptCategory[STARS_NN_vpmaxuq] = 1;              // Maximum of Packed Unsigned Integers
	OptCategory[STARS_NN_vpminsq] = 1;              // Minimum of Packed Signed Integers
	OptCategory[STARS_NN_vpminuq] = 1;              // Minimum of Packed Unsigned Integers
	OptCategory[STARS_NN_vpmovm2b] = 1;             // Convert a Mask Register to a Vector Register
	OptCategory[STARS_NN_vpmovm2w] = 1;             // Convert a Mask Register to a Vector Register
	OptCategory[STARS_NN_vpmovm2d] = 1;             // Convert a Mask Register to a Vector Register
	OptCategory[STARS_NN_vpmovm2q] = 1;             // Convert a Mask Register to a Vector Register
	OptCategory[STARS_NN_vpmovb2m] = 1;             // Convert a Vector Register to a Mask
	OptCategory[STARS_NN_vpmovw2m] = 1;             // Convert a Vector Register to a Mask
	OptCategory[STARS_NN_vpmovd2m] = 1;             // Convert a Vector Register to a Mask
	OptCategory[STARS_NN_vpmovq2m] = 1;             // Convert a Vector Register to a Mask
	OptCategory[STARS_NN_vpmovqb] = 1;              // Down Convert QWord to Byte
	OptCategory[STARS_NN_vpmovsqb] = 1;             // Down Convert QWord to Byte
	OptCategory[STARS_NN_vpmovusqb] = 1;            // Down Convert QWord to Byte
	OptCategory[STARS_NN_vpmovqw] = 1;              // Down Convert QWord to Word
	OptCategory[STARS_NN_vpmovsqw] = 1;             // Down Convert QWord to Word
	OptCategory[STARS_NN_vpmovusqw] = 1;            // Down Convert QWord to Word
	OptCategory[STARS_NN_vpmovqd] = 1;              // Down Convert QWord to DWord
	OptCategory[STARS_NN_vpmovsqd] = 1;             // Down Convert QWord to DWord
	OptCategory[STARS_NN_vpmovusqd] = 1;            // Down Convert QWord to DWord
	OptCategory[STARS_NN_vpmovdb] = 1;              // Down Convert DWord to Byte
	OptCategory[STARS_NN_vpmovsdb] = 1;             // Down Convert DWord to Byte
	OptCategory[STARS_NN_vpmovusdb] = 1;            // Down Convert DWord to Byte
	OptCategory[STARS_NN_vpmovdw] = 1;              // Down Convert DWord to Word
	OptCategory[STARS_NN_vpmovsdw] = 1;             // Down Convert DWord to Word
	OptCategory[STARS_NN_vpmovusdw] = 1;            // Down Convert DWord to Word
	OptCategory[STARS_NN_vpmovwb] = 1;              // Down Convert Word to Byte
	OptCategory[STARS_NN_vpmovswb] = 1;             // Down Convert Word to Byte
	OptCategory[STARS_NN_vpmovuswb] = 1;            // Down Convert Word to Byte
	OptCategory[STARS_NN_vpmullq] = 1;              // Multiply Packed Integers and Store Low Result
	OptCategory[STARS_NN_vpmultishiftqb] = 1;       // Select Packed Unaligned Bytes from Quadword Sources
	OptCategory[STARS_NN_vpord] = 1;                // Bitwise Logical Or
	OptCategory[STARS_NN_vporq] = 1;                // Bitwise Logical Or
	OptCategory[STARS_NN_vprold] = 1;               // Bit Rotate Left
	OptCategory[STARS_NN_vprolvd] = 1;              // Bit Rotate Left
	OptCategory[STARS_NN_vprolq] = 1;               // Bit Rotate Left
	OptCategory[STARS_NN_vprolvq] = 1;              // Bit Rotate Left
	OptCategory[STARS_NN_vprord] = 1;               // Bit Rotate Right
	OptCategory[STARS_NN_vprorvd] = 1;              // Bit Rotate Right
	OptCategory[STARS_NN_vprorq] = 1;               // Bit Rotate Right
	OptCategory[STARS_NN_vprorvq] = 1;              // Bit Rotate Right
	OptCategory[STARS_NN_vpscatterdd] = 1;          // Scatter Packed Dword with Signed Dword
	OptCategory[STARS_NN_vpscatterdq] = 1;          // Scatter Packed Qword with Signed Qword Indices
	OptCategory[STARS_NN_vpscatterqd] = 1;          // Scatter Packed Dword with Signed Dword
	OptCategory[STARS_NN_vpscatterqq] = 1;          // Scatter Packed Qword with Signed Qword Indices
	OptCategory[STARS_NN_vpsraq] = 1;               // Bit Shift Arithmetic Right
	OptCategory[STARS_NN_vpsllvw] = 1;              // Variable Bit Shift Left Logical
	OptCategory[STARS_NN_vpsrlvw] = 1;              // Variable Bit Shift Right Logical
	OptCategory[STARS_NN_vptestnmb] = 1;            // Logical NAND and Set
	OptCategory[STARS_NN_vptestnmw] = 1;            // Logical NAND and Set
	OptCategory[STARS_NN_vptestnmd] = 1;            // Logical NAND and Set
	OptCategory[STARS_NN_vptestnmq] = 1;            // Logical NAND and Set
	OptCategory[STARS_NN_vshuff32x4] = 1;           // Shuffle Packed Values at 128-bit Granularity
	OptCategory[STARS_NN_vshuff64x2] = 1;           // Shuffle Packed Values at 128-bit Granularity
	OptCategory[STARS_NN_vshufi32x4] = 1;           // Shuffle Packed Values at 128-bit Granularity
	OptCategory[STARS_NN_vshufi64x2] = 1;           // Shuffle Packed Values at 128-bit Granularity
	OptCategory[STARS_NN_vpternlogd] = 1;           // Bitwise Ternary Logic
	OptCategory[STARS_NN_vpternlogq] = 1;           // Bitwise Ternary Logic
	OptCategory[STARS_NN_vptestmb] = 1;             // Logical AND and Set Mask
	OptCategory[STARS_NN_vptestmw] = 1;             // Logical AND and Set Mask
	OptCategory[STARS_NN_vptestmd] = 1;             // Logical AND and Set Mask
	OptCategory[STARS_NN_vptestmq] = 1;             // Logical AND and Set Mask
	OptCategory[STARS_NN_vpsravw] = 1;              // Variable Bit Shift Right Arithmetic
	OptCategory[STARS_NN_vpsravq] = 1;              // Variable Bit Shift Right Arithmetic
	OptCategory[STARS_NN_vpxord] = 1;               // Exclusive Or
	OptCategory[STARS_NN_vpxorq] = 1;               // Exclusive Or
	OptCategory[STARS_NN_vrangepd] = 1;             // Range Restriction Calculation For Packed Pairs of Float64 Values
	OptCategory[STARS_NN_vrangeps] = 1;             // Range Restriction Calculation For Packed Pairs of Float32 Values
	OptCategory[STARS_NN_vrangesd] = 1;             // Range Restriction Calculation From a pair of Scalar Float64 Values
	OptCategory[STARS_NN_vrangess] = 1;             // Range Restriction Calculation From a Pair of Scalar Float32 Values
	OptCategory[STARS_NN_vrcp14pd] = 1;             // Compute Approximate Reciprocals of Packed Float64 Values
	OptCategory[STARS_NN_vrcp14sd] = 1;             // Compute Approximate Reciprocal of Scalar Float64 Value
	OptCategory[STARS_NN_vrcp14ps] = 1;             // Compute Approximate Reciprocals of Packed Float32 Values
	OptCategory[STARS_NN_vrcp14ss] = 1;             // Compute Approximate Reciprocal of Scalar Float32 Value
	OptCategory[STARS_NN_vreducepd] = 1;            // Perform Reduction Transformation on Packed Float64 Values
	OptCategory[STARS_NN_vreducesd] = 1;            // Perform a Reduction Transformation on a Scalar Float64 Value
	OptCategory[STARS_NN_vreduceps] = 1;            // Perform Reduction Transformation on Packed Float32 Values
	OptCategory[STARS_NN_vreducess] = 1;            // Perform a Reduction Transformation on a Scalar Float32 Value
	OptCategory[STARS_NN_vrndscalepd] = 1;          // Round Packed Float64 Values To Include A Given Number Of Fraction Bits
	OptCategory[STARS_NN_vrndscalesd] = 1;          // Round Scalar Float64 Value To Include A Given Number Of Fraction Bits
	OptCategory[STARS_NN_vrndscaleps] = 1;          // Round Packed Float32 Values To Include A Given Number Of Fraction Bits
	OptCategory[STARS_NN_vrndscaless] = 1;          // Round Scalar Float32 Value To Include A Given Number Of Fraction Bits
	OptCategory[STARS_NN_vrsqrt14pd] = 1;           // Compute Approximate Reciprocals of Square Roots of Packed Float64 Values
	OptCategory[STARS_NN_vrsqrt14sd] = 1;           // Compute Approximate Reciprocal of Square Root of Scalar Float64 Value
	OptCategory[STARS_NN_vrsqrt14ps] = 1;           // Compute Approximate Reciprocals of Square Roots of Packed Float32 Values
	OptCategory[STARS_NN_vrsqrt14ss] = 1;           // Compute Approximate Reciprocal of Square Root of Scalar Float32 Value
	OptCategory[STARS_NN_vscalefpd] = 1;            // Scale Packed Float64 Values With Float64 Values
	OptCategory[STARS_NN_vscalefsd] = 1;            // Scale Scalar Float64 Values With Float64 Values
	OptCategory[STARS_NN_vscalefps] = 1;            // Scale Packed Float32 Values With Float32 Values
	OptCategory[STARS_NN_vscalefss] = 1;            // Scale Scalar Float32 Value With Float32 Value
	OptCategory[STARS_NN_vscatterdps] = 1;          // Scatter Packed Single, Packed Double with Signed Dword and Qword Indices
	OptCategory[STARS_NN_vscatterdpd] = 1;          // Scatter Packed Single, Packed Double with Signed Dword and Qword Indices
	OptCategory[STARS_NN_vscatterqps] = 1;          // Scatter Packed Single, Packed Double with Signed Dword and Qword Indices
	OptCategory[STARS_NN_vscatterqpd] = 1;          // Scatter Packed Single, Packed Double with Signed Dword and Qword Indices

	OptCategory[STARS_NN_vexp2pd] = 1;              // Approximation to the Exponential 2^x of Packed Double-Precision Floating-Point Values with Less Than 2^-23 Relative Error
	OptCategory[STARS_NN_vexp2ps] = 1;              // Approximation to the Exponential 2^x of Packed Single-Precision Floating-Point Values with Less Than 2^-23 Relative Error
	OptCategory[STARS_NN_vrcp28pd] = 1;             // Approximation to the Reciprocal of Packed Double-Precision Floating-Point Values with Less Than 2^-28 Relative Error
	OptCategory[STARS_NN_vrcp28sd] = 1;             // Approximation to the Reciprocal of Scalar Double-Precision Floating-Point Value with Less Than 2^-28 Relative Error
	OptCategory[STARS_NN_vrcp28ps] = 1;             // Approximation to the Reciprocal of Packed Single-Precision Floating-Point Values with Less Than 2^-28 Relative Error
	OptCategory[STARS_NN_vrcp28ss] = 1;             // Approximation to the Reciprocal of Scalar Single-Precision Floating-Point Value with Less Than 2^-28 Relative Error
	OptCategory[STARS_NN_vrsqrt28pd] = 1;           // Approximation to the Reciprocal Square Root of Packed Double-Precision Floating-Point Values with Less Than 2^-28 Relative Error
	OptCategory[STARS_NN_vrsqrt28sd] = 1;           // Approximation to the Reciprocal Square Root of Scalar Double-Precision Floating-Point Value with Less Than 2^-28 Relative Error
	OptCategory[STARS_NN_vrsqrt28ps] = 1;           // Approximation to the Reciprocal Square Root of Packed Single-Precision Floating-Point Values with Less Than 2^-28 Relative Error
	OptCategory[STARS_NN_vrsqrt28ss] = 1;           // Approximation to the Reciprocal Square Root of Scalar Single-Precision Floating-Point Value with Less Than 2^-28 Relative Error

	OptCategory[STARS_NN_vgatherpf0dps] = 1;        // Sparse Prefetch Packed SP/DP Data Values with Signed Dword, Signed Qword Indices Using T0 Hint
	OptCategory[STARS_NN_vgatherpf0qps] = 1;        // Sparse Prefetch Packed SP/DP Data Values with Signed Dword, Signed Qword Indices Using T0 Hint
	OptCategory[STARS_NN_vgatherpf0dpd] = 1;        // Sparse Prefetch Packed SP/DP Data Values with Signed Dword, Signed Qword Indices Using T0 Hint
	OptCategory[STARS_NN_vgatherpf0qpd] = 1;        // Sparse Prefetch Packed SP/DP Data Values with Signed Dword, Signed Qword Indices Using T0 Hint
	OptCategory[STARS_NN_vgatherpf1dps] = 1;        // Sparse Prefetch Packed SP/DP Data Values with Signed Dword, Signed Qword Indices Using T1 Hint
	OptCategory[STARS_NN_vgatherpf1qps] = 1;        // Sparse Prefetch Packed SP/DP Data Values with Signed Dword, Signed Qword Indices Using T1 Hint
	OptCategory[STARS_NN_vgatherpf1dpd] = 1;        // Sparse Prefetch Packed SP/DP Data Values with Signed Dword, Signed Qword Indices Using T1 Hint
	OptCategory[STARS_NN_vgatherpf1qpd] = 1;        // Sparse Prefetch Packed SP/DP Data Values with Signed Dword, Signed Qword Indices Using T1 Hint
	OptCategory[STARS_NN_vscatterpf0dps] = 1;       // Sparse Prefetch Packed SP/DP Data Values with Signed Dword, Signed Qword Indices Using T0 Hint with Intent to Write
	OptCategory[STARS_NN_vscatterpf0qps] = 1;       // Sparse Prefetch Packed SP/DP Data Values with Signed Dword, Signed Qword Indices Using T0 Hint with Intent to Write
	OptCategory[STARS_NN_vscatterpf0dpd] = 1;       // Sparse Prefetch Packed SP/DP Data Values with Signed Dword, Signed Qword Indices Using T0 Hint with Intent to Write
	OptCategory[STARS_NN_vscatterpf0qpd] = 1;       // Sparse Prefetch Packed SP/DP Data Values with Signed Dword, Signed Qword Indices Using T0 Hint with Intent to Write
	OptCategory[STARS_NN_vscatterpf1dps] = 1;       // Sparse Prefetch Packed SP/DP Data Values with Signed Dword, Signed Qword Indices Using T1 Hint with Intent to Write
	OptCategory[STARS_NN_vscatterpf1qps] = 1;       // Sparse Prefetch Packed SP/DP Data Values with Signed Dword, Signed Qword Indices Using T1 Hint with Intent to Write
	OptCategory[STARS_NN_vscatterpf1dpd] = 1;       // Sparse Prefetch Packed SP/DP Data Values with Signed Dword, Signed Qword Indices Using T1 Hint with Intent to Write
	OptCategory[STARS_NN_vscatterpf1qpd] = 1;       // Sparse Prefetch Packed SP/DP Data Values with Signed Dword, Signed Qword Indices Using T1 Hint with Intent to Write

	// AVX-512 comparison pseudo-ops

	OptCategory[STARS_NN_vpcmpltd] = 1;             // Compare Packed Integer Values into Mask
	OptCategory[STARS_NN_vpcmpled] = 1;             // Compare Packed Integer Values into Mask
	OptCategory[STARS_NN_vpcmpneqd] = 1;            // Compare Packed Integer Values into Mask
	OptCategory[STARS_NN_vpcmpnltd] = 1;            // Compare Packed Integer Values into Mask
	OptCategory[STARS_NN_vpcmpnled] = 1;            // Compare Packed Integer Values into Mask

	OptCategory[STARS_NN_vpcmpequd] = 1;            // Compare Packed Integer Values into Mask
	OptCategory[STARS_NN_vpcmpltud] = 1;            // Compare Packed Integer Values into Mask
	OptCategory[STARS_NN_vpcmpleud] = 1;            // Compare Packed Integer Values into Mask
	OptCategory[STARS_NN_vpcmpnequd] = 1;           // Compare Packed Integer Values into Mask
	OptCategory[STARS_NN_vpcmpnltud] = 1;           // Compare Packed Integer Values into Mask
	OptCategory[STARS_NN_vpcmpnleud] = 1;           // Compare Packed Integer Values into Mask

	OptCategory[STARS_NN_vpcmpltq] = 1;             // Compare Packed Integer Values into Mask
	OptCategory[STARS_NN_vpcmpleq] = 1;             // Compare Packed Integer Values into Mask
	OptCategory[STARS_NN_vpcmpneqq] = 1;            // Compare Packed Integer Values into Mask
	OptCategory[STARS_NN_vpcmpnltq] = 1;            // Compare Packed Integer Values into Mask
	OptCategory[STARS_NN_vpcmpnleq] = 1;            // Compare Packed Integer Values into Mask

	OptCategory[STARS_NN_vpcmpequq] = 1;            // Compare Packed Integer Values into Mask
	OptCategory[STARS_NN_vpcmpltuq] = 1;            // Compare Packed Integer Values into Mask
	OptCategory[STARS_NN_vpcmpleuq] = 1;            // Compare Packed Integer Values into Mask
	OptCategory[STARS_NN_vpcmpnequq] = 1;           // Compare Packed Integer Values into Mask
	OptCategory[STARS_NN_vpcmpnltuq] = 1;           // Compare Packed Integer Values into Mask
	OptCategory[STARS_NN_vpcmpnleuq] = 1;           // Compare Packed Integer Values into Mask

	// Opmask instructions

	OptCategory[STARS_NN_kaddw] = 1;                // ADD Two Masks
	OptCategory[STARS_NN_kaddb] = 1;                // ADD Two Masks
	OptCategory[STARS_NN_kaddq] = 1;                // ADD Two Masks
	OptCategory[STARS_NN_kaddd] = 1;                // ADD Two Masks
	OptCategory[STARS_NN_kandw] = 1;                // Bitwise Logical AND Masks
	OptCategory[STARS_NN_kandb] = 1;                // Bitwise Logical AND Masks
	OptCategory[STARS_NN_kandq] = 1;                // Bitwise Logical AND Masks
	OptCategory[STARS_NN_kandd] = 1;                // Bitwise Logical AND Masks
	OptCategory[STARS_NN_kandnw] = 1;               // Bitwise Logical AND NOT Masks
	OptCategory[STARS_NN_kandnb] = 1;               // Bitwise Logical AND NOT Masks
	OptCategory[STARS_NN_kandnq] = 1;               // Bitwise Logical AND NOT Masks
	OptCategory[STARS_NN_kandnd] = 1;               // Bitwise Logical AND NOT Masks
	OptCategory[STARS_NN_kmovw] = 1;                // Move from and to Mask Registers
	OptCategory[STARS_NN_kmovb] = 1;                // Move from and to Mask Registers
	OptCategory[STARS_NN_kmovq] = 1;                // Move from and to Mask Registers
	OptCategory[STARS_NN_kmovd] = 1;                // Move from and to Mask Registers
	OptCategory[STARS_NN_kunpckbw] = 1;             // Unpack for Mask Registers
	OptCategory[STARS_NN_kunpckwd] = 1;             // Unpack for Mask Registers
	OptCategory[STARS_NN_kunpckdq] = 1;             // Unpack for Mask Registers
	OptCategory[STARS_NN_knotw] = 1;                // NOT Mask Register
	OptCategory[STARS_NN_knotb] = 1;                // NOT Mask Register
	OptCategory[STARS_NN_knotq] = 1;                // NOT Mask Register
	OptCategory[STARS_NN_knotd] = 1;                // NOT Mask Register
	OptCategory[STARS_NN_korw] = 1;                 // Bitwise Logical OR Masks
	OptCategory[STARS_NN_korb] = 1;                 // Bitwise Logical OR Masks
	OptCategory[STARS_NN_korq] = 1;                 // Bitwise Logical OR Masks
	OptCategory[STARS_NN_kord] = 1;                 // Bitwise Logical OR Masks
	OptCategory[STARS_NN_kortestw] = 1;             // OR Masks And Set Flags
	OptCategory[STARS_NN_kortestb] = 1;             // OR Masks And Set Flags
	OptCategory[STARS_NN_kortestq] = 1;             // OR Masks And Set Flags
	OptCategory[STARS_NN_kortestd] = 1;             // OR Masks And Set Flags
	OptCategory[STARS_NN_kshiftlw] = 1;             // Shift Left Mask Registers
	OptCategory[STARS_NN_kshiftlb] = 1;             // Shift Left Mask Registers
	OptCategory[STARS_NN_kshiftlq] = 1;             // Shift Left Mask Registers
	OptCategory[STARS_NN_kshiftld] = 1;             // Shift Left Mask Registers
	OptCategory[STARS_NN_kshiftrw] = 1;             // Shift Right Mask Registers
	OptCategory[STARS_NN_kshiftrb] = 1;             // Shift Right Mask Registers
	OptCategory[STARS_NN_kshiftrq] = 1;             // Shift Right Mask Registers
	OptCategory[STARS_NN_kshiftrd] = 1;             // Shift Right Mask Registers
	OptCategory[STARS_NN_kxnorw] = 1;               // Bitwise Logical XNOR Masks
	OptCategory[STARS_NN_kxnorb] = 1;               // Bitwise Logical XNOR Masks
	OptCategory[STARS_NN_kxnorq] = 1;               // Bitwise Logical XNOR Masks
	OptCategory[STARS_NN_kxnord] = 1;               // Bitwise Logical XNOR Masks
	OptCategory[STARS_NN_ktestw] = 1;               // Packed Bit Test Masks and Set Flags
	OptCategory[STARS_NN_ktestb] = 1;               // Packed Bit Test Masks and Set Flags
	OptCategory[STARS_NN_ktestq] = 1;               // Packed Bit Test Masks and Set Flags
	OptCategory[STARS_NN_ktestd] = 1;               // Packed Bit Test Masks and Set Flags
	OptCategory[STARS_NN_kxorw] = 1;                // Bitwise Logical XOR Masks
	OptCategory[STARS_NN_kxorb] = 1;                // Bitwise Logical XOR Masks
	OptCategory[STARS_NN_kxorq] = 1;                // Bitwise Logical XOR Masks
	OptCategory[STARS_NN_kxord] = 1;                // Bitwise Logical XOR Masks

	// SHA Extensions

	OptCategory[STARS_NN_sha1rnds4] = 1;            // Perform Four Rounds of SHA1 Operation
	OptCategory[STARS_NN_sha1nexte] = 1;            // Calculate SHA1 State Variable E after Four Rounds
	OptCategory[STARS_NN_sha1msg1] = 1;             // Perform an Intermediate Calculation for the Next Four SHA1 Message Dwords
	OptCategory[STARS_NN_sha1msg2] = 1;             // Perform a Final Calculation for the Next Four SHA1 Message Dwords
	OptCategory[STARS_NN_sha256rnds2] = 1;          // Perform Two Rounds of SHA256 Operation
	OptCategory[STARS_NN_sha256msg1] = 1;           // Perform an Intermediate Calculation for the Next Four SHA256 Message Dwords
	OptCategory[STARS_NN_sha256msg2] = 1;           // Perform a Final Calculation for the Next Four SHA256 Message Dwords

	// Intel Software Guard Extensions

	OptCategory[STARS_NN_encls] = 1;                // Execute an Enclave System Function of Specified Leaf Number
	OptCategory[STARS_NN_enclu] = 1;                // Execute an Enclave User Function of Specified Leaf Number

	// AMD XOP

	OptCategory[STARS_NN_vfrczpd] = 1;              // Extract Fraction Packed Double-Precision Floating-Point
	OptCategory[STARS_NN_vfrczps] = 1;              // Extract Fraction Packed Single-Precision Floating-Point
	OptCategory[STARS_NN_vfrczsd] = 1;              // Extract Fraction Scalar Double-Precision Floating-Point
	OptCategory[STARS_NN_vfrczss] = 1;              // Extract Fraction Scalar Single-Precision Floating Point
	OptCategory[STARS_NN_vpcmov] = 1;               // Vector Conditional Moves
	OptCategory[STARS_NN_vpcomb] = 1;               // Compare Vector Signed Bytes
	OptCategory[STARS_NN_vpcomd] = 1;               // Compare Vector Signed Doublewords
	OptCategory[STARS_NN_vpcomq] = 1;               // Compare Vector Signed Quadwords
	OptCategory[STARS_NN_vpcomub] = 1;              // Compare Vector Unsigned Bytes
	OptCategory[STARS_NN_vpcomud] = 1;              // Compare Vector Unsigned Doublewords
	OptCategory[STARS_NN_vpcomuq] = 1;              // Compare Vector Unsigned Quadwords
	OptCategory[STARS_NN_vpcomuw] = 1;              // Compare Vector Unsigned Words
	OptCategory[STARS_NN_vpcomw] = 1;               // Compare Vector Signed Words
	OptCategory[STARS_NN_vpermil2pd] = 1;           // Permute Two-Source Double-Precision Floating-Point Values
	OptCategory[STARS_NN_vpermil2ps] = 1;           // Permute Two-Source Single-Precision Floating-Point Values
	OptCategory[STARS_NN_vphaddbd] = 1;             // Packed Horizontal Add Signed Byte to Signed Doubleword
	OptCategory[STARS_NN_vphaddbq] = 1;             // Packed Horizontal Add Signed Byte to Signed Quadword
	OptCategory[STARS_NN_vphaddbw] = 1;             // Packed Horizontal Add Signed Byte to Signed Word
	OptCategory[STARS_NN_vphadddq] = 1;             // Packed Horizontal Add Signed Doubleword to Signed Quadword
	OptCategory[STARS_NN_vphaddubd] = 1;            // Packed Horizontal Add Unsigned Byte to Doubleword
	OptCategory[STARS_NN_vphaddubq] = 1;            // Packed Horizontal Add Unsigned Byte to Quadword
	OptCategory[STARS_NN_vphaddubw] = 1;            // Packed Horizontal Add Unsigned Byte to Word
	OptCategory[STARS_NN_vphaddudq] = 1;            // Packed Horizontal Add Unsigned Doubleword to Quadword
	OptCategory[STARS_NN_vphadduwd] = 1;            // Packed Horizontal Add Unsigned Word to Doubleword
	OptCategory[STARS_NN_vphadduwq] = 1;            // Packed Horizontal Add Unsigned Word to Quadword
	OptCategory[STARS_NN_vphaddwd] = 1;             // Packed Horizontal Add Signed Word to Signed Doubleword
	OptCategory[STARS_NN_vphaddwq] = 1;             // Packed Horizontal Add Signed Word to Signed Quadword
	OptCategory[STARS_NN_vphsubbw] = 1;             // Packed Horizontal Subtract Signed Byte to Signed Word
	OptCategory[STARS_NN_vphsubdq] = 1;             // Packed Horizontal Subtract Signed Doubleword to Signed Quadword
	OptCategory[STARS_NN_vphsubwd] = 1;             // Packed Horizontal Subtract Signed Word to Signed Doubleword
	OptCategory[STARS_NN_vpmacsdd] = 1;             // Packed Multiply Accumulate Signed Doubleword to Signed Doubleword
	OptCategory[STARS_NN_vpmacsdqh] = 1;            // Packed Multiply Accumulate Signed High Doubleword to Signed Quadword
	OptCategory[STARS_NN_vpmacsdql] = 1;            // Packed Multiply Accumulate Signed Low Doubleword to Signed Quadword
	OptCategory[STARS_NN_vpmacssdd] = 1;            // Packed Multiply Accumulate Signed Doubleword to Signed Doubleword with Saturation
	OptCategory[STARS_NN_vpmacssdqh] = 1;           // Packed Multiply Accumulate Signed High Doubleword to Signed Quadword with Saturation
	OptCategory[STARS_NN_vpmacssdql] = 1;           // Packed Multiply Accumulate Signed Low Doubleword to Signed Quadword with Saturation
	OptCategory[STARS_NN_vpmacsswd] = 1;            // Packed Multiply Accumulate Signed Word to Signed Doubleword with Saturation
	OptCategory[STARS_NN_vpmacssww] = 1;            // Packed Multiply Accumulate Signed Word to Signed Word with Saturation
	OptCategory[STARS_NN_vpmacswd] = 1;             // Packed Multiply Accumulate Signed Word to Signed Doubleword
	OptCategory[STARS_NN_vpmacsww] = 1;             // Packed Multiply Accumulate Signed Word to Signed Word
	OptCategory[STARS_NN_vpmadcsswd] = 1;           // Packed Multiply, Add and Accumulate Signed Word to Signed Doubleword with Saturation
	OptCategory[STARS_NN_vpmadcswd] = 1;            // Packed Multiply Add and Accumulate Signed Word to Signed Doubleword
	OptCategory[STARS_NN_vpperm] = 1;               // Packed Permute Bytes
	OptCategory[STARS_NN_vprotb] = 1;               // Packed Rotate Bytes
	OptCategory[STARS_NN_vprotd] = 1;               // Packed Rotate Doublewords
	OptCategory[STARS_NN_vprotq] = 1;               // Packed Rotate Quadwords
	OptCategory[STARS_NN_vprotw] = 1;               // Packed Rotate Words
	OptCategory[STARS_NN_vpshab] = 1;               // Packed Shift Arithmetic Bytes
	OptCategory[STARS_NN_vpshad] = 1;               // Packed Shift Arithmetic Doublewords
	OptCategory[STARS_NN_vpshaq] = 1;               // Packed Shift Arithmetic Quadwords
	OptCategory[STARS_NN_vpshaw] = 1;               // Packed Shift Arithmetic Words
	OptCategory[STARS_NN_vpshlb] = 1;               // Packed Shift Logical Bytes
	OptCategory[STARS_NN_vpshld] = 1;               // Packed Shift Logical Doublewords
	OptCategory[STARS_NN_vpshlq] = 1;               // Packed Shift Logical Quadwords
	OptCategory[STARS_NN_vpshlw] = 1;               // Packed Shift Logical Words

	// AMP XOP comparison pseudo-ops

	OptCategory[STARS_NN_vpcomltb] = 1;             // Compare Vector Signed Bytes
	OptCategory[STARS_NN_vpcomleb] = 1;             // Compare Vector Signed Bytes
	OptCategory[STARS_NN_vpcomgtb] = 1;             // Compare Vector Signed Bytes
	OptCategory[STARS_NN_vpcomgeb] = 1;             // Compare Vector Signed Bytes
	OptCategory[STARS_NN_vpcomeqb] = 1;             // Compare Vector Signed Bytes
	OptCategory[STARS_NN_vpcomneqb] = 1;            // Compare Vector Signed Bytes
	OptCategory[STARS_NN_vpcomfalseb] = 1;          // Compare Vector Signed Bytes
	OptCategory[STARS_NN_vpcomtrueb] = 1;           // Compare Vector Signed Bytes

	OptCategory[STARS_NN_vpcomltw] = 1;             // Compare Vector Signed Words
	OptCategory[STARS_NN_vpcomlew] = 1;             // Compare Vector Signed Words
	OptCategory[STARS_NN_vpcomgtw] = 1;             // Compare Vector Signed Words
	OptCategory[STARS_NN_vpcomgew] = 1;             // Compare Vector Signed Words
	OptCategory[STARS_NN_vpcomeqw] = 1;             // Compare Vector Signed Words
	OptCategory[STARS_NN_vpcomneqw] = 1;            // Compare Vector Signed Words
	OptCategory[STARS_NN_vpcomfalsew] = 1;          // Compare Vector Signed Words
	OptCategory[STARS_NN_vpcomtruew] = 1;           // Compare Vector Signed Words

	OptCategory[STARS_NN_vpcomltd] = 1;             // Compare Vector Signed Doublewords
	OptCategory[STARS_NN_vpcomled] = 1;             // Compare Vector Signed Doublewords
	OptCategory[STARS_NN_vpcomgtd] = 1;             // Compare Vector Signed Doublewords
	OptCategory[STARS_NN_vpcomged] = 1;             // Compare Vector Signed Doublewords
	OptCategory[STARS_NN_vpcomeqd] = 1;             // Compare Vector Signed Doublewords
	OptCategory[STARS_NN_vpcomneqd] = 1;            // Compare Vector Signed Doublewords
	OptCategory[STARS_NN_vpcomfalsed] = 1;          // Compare Vector Signed Doublewords
	OptCategory[STARS_NN_vpcomtrued] = 1;           // Compare Vector Signed Doublewords

	OptCategory[STARS_NN_vpcomltq] = 1;             // Compare Vector Signed Quadwords
	OptCategory[STARS_NN_vpcomleq] = 1;             // Compare Vector Signed Quadwords
	OptCategory[STARS_NN_vpcomgtq] = 1;             // Compare Vector Signed Quadwords
	OptCategory[STARS_NN_vpcomgeq] = 1;             // Compare Vector Signed Quadwords
	OptCategory[STARS_NN_vpcomeqq] = 1;             // Compare Vector Signed Quadwords
	OptCategory[STARS_NN_vpcomneqq] = 1;            // Compare Vector Signed Quadwords
	OptCategory[STARS_NN_vpcomfalseq] = 1;          // Compare Vector Signed Quadwords
	OptCategory[STARS_NN_vpcomtrueq] = 1;           // Compare Vector Signed Quadwords

	OptCategory[STARS_NN_vpcomltub] = 1;            // Compare Vector Unsigned Bytes
	OptCategory[STARS_NN_vpcomleub] = 1;            // Compare Vector Unsigned Bytes
	OptCategory[STARS_NN_vpcomgtub] = 1;            // Compare Vector Unsigned Bytes
	OptCategory[STARS_NN_vpcomgeub] = 1;            // Compare Vector Unsigned Bytes
	OptCategory[STARS_NN_vpcomequb] = 1;            // Compare Vector Unsigned Bytes
	OptCategory[STARS_NN_vpcomnequb] = 1;           // Compare Vector Unsigned Bytes
	OptCategory[STARS_NN_vpcomfalseub] = 1;         // Compare Vector Unsigned Bytes
	OptCategory[STARS_NN_vpcomtrueub] = 1;          // Compare Vector Unsigned Bytes

	OptCategory[STARS_NN_vpcomltuw] = 1;            // Compare Vector Unsigned Words