Updating the x86 hardware-intrin test templates to use named format arguments

17 files changed, 2612 insertions, 2632 deletions

diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Program.Avx2.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Program.Avx2.cs
index bc12228824..4d15e34f42 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Program.Avx2.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Program.Avx2.cs
@@ -80,22 +80,6 @@ namespace JIT.HardwareIntrinsics.X86
                 ["Or.UInt16"] = OrUInt16,
                 ["Or.UInt32"] = OrUInt32,
                 ["Or.UInt64"] = OrUInt64,
-                ["Subtract.Byte"] = SubtractByte,
-                ["Subtract.Int16"] = SubtractInt16,
-                ["Subtract.Int32"] = SubtractInt32,
-                ["Subtract.Int64"] = SubtractInt64,
-                ["Subtract.SByte"] = SubtractSByte,
-                ["Subtract.UInt16"] = SubtractUInt16,
-                ["Subtract.UInt32"] = SubtractUInt32,
-                ["Subtract.UInt64"] = SubtractUInt64,
-                ["Xor.Byte"] = XorByte,
-                ["Xor.Int16"] = XorInt16,
-                ["Xor.Int32"] = XorInt32,
-                ["Xor.Int64"] = XorInt64,
-                ["Xor.SByte"] = XorSByte,
-                ["Xor.UInt16"] = XorUInt16,
-                ["Xor.UInt32"] = XorUInt32,
-                ["Xor.UInt64"] = XorUInt64,
                 ["ShiftLeftLogical.Int16.1"] = ShiftLeftLogicalInt161,
                 ["ShiftLeftLogical.UInt16.1"] = ShiftLeftLogicalUInt161,
                 ["ShiftLeftLogical.Int32.1"] = ShiftLeftLogicalInt321,
@@ -108,6 +92,18 @@ namespace JIT.HardwareIntrinsics.X86
                 ["ShiftLeftLogical.UInt32.32"] = ShiftLeftLogicalUInt3232,
                 ["ShiftLeftLogical.Int64.64"] = ShiftLeftLogicalInt6464,
                 ["ShiftLeftLogical.UInt64.64"] = ShiftLeftLogicalUInt6464,
+                ["ShiftLeftLogical128BitLane.SByte.1"] = ShiftLeftLogical128BitLaneSByte1,
+                ["ShiftLeftLogical128BitLane.Byte.1"] = ShiftLeftLogical128BitLaneByte1,
+                ["ShiftLeftLogical128BitLane.Int16.1"] = ShiftLeftLogical128BitLaneInt161,
+                ["ShiftLeftLogical128BitLane.UInt16.1"] = ShiftLeftLogical128BitLaneUInt161,
+                ["ShiftLeftLogical128BitLane.Int32.1"] = ShiftLeftLogical128BitLaneInt321,
+                ["ShiftLeftLogical128BitLane.UInt32.1"] = ShiftLeftLogical128BitLaneUInt321,
+                ["ShiftLeftLogical128BitLane.Int64.1"] = ShiftLeftLogical128BitLaneInt641,
+                ["ShiftLeftLogical128BitLane.UInt64.1"] = ShiftLeftLogical128BitLaneUInt641,
+                ["ShiftRightArithmetic.Int16.1"] = ShiftRightArithmeticInt161,
+                ["ShiftRightArithmetic.Int32.1"] = ShiftRightArithmeticInt321,
+                ["ShiftRightArithmetic.Int16.16"] = ShiftRightArithmeticInt1616,
+                ["ShiftRightArithmetic.Int32.32"] = ShiftRightArithmeticInt3232,
                 ["ShiftRightLogical.Int16.1"] = ShiftRightLogicalInt161,
                 ["ShiftRightLogical.UInt16.1"] = ShiftRightLogicalUInt161,
                 ["ShiftRightLogical.Int32.1"] = ShiftRightLogicalInt321,
@@ -120,18 +116,6 @@ namespace JIT.HardwareIntrinsics.X86
                 ["ShiftRightLogical.UInt32.32"] = ShiftRightLogicalUInt3232,
                 ["ShiftRightLogical.Int64.64"] = ShiftRightLogicalInt6464,
                 ["ShiftRightLogical.UInt64.64"] = ShiftRightLogicalUInt6464,
-                ["ShiftRightArithmetic.Int16.1"] = ShiftRightArithmeticInt161,
-                ["ShiftRightArithmetic.Int32.1"] = ShiftRightArithmeticInt321,
-                ["ShiftRightArithmetic.Int16.16"] = ShiftRightArithmeticInt1616,
-                ["ShiftRightArithmetic.Int32.32"] = ShiftRightArithmeticInt3232,
-                ["ShiftLeftLogical128BitLane.SByte.1"] = ShiftLeftLogical128BitLaneSByte1,
-                ["ShiftLeftLogical128BitLane.Byte.1"] = ShiftLeftLogical128BitLaneByte1,
-                ["ShiftLeftLogical128BitLane.Int16.1"] = ShiftLeftLogical128BitLaneInt161,
-                ["ShiftLeftLogical128BitLane.UInt16.1"] = ShiftLeftLogical128BitLaneUInt161,
-                ["ShiftLeftLogical128BitLane.Int32.1"] = ShiftLeftLogical128BitLaneInt321,
-                ["ShiftLeftLogical128BitLane.UInt32.1"] = ShiftLeftLogical128BitLaneUInt321,
-                ["ShiftLeftLogical128BitLane.Int64.1"] = ShiftLeftLogical128BitLaneInt641,
-                ["ShiftLeftLogical128BitLane.UInt64.1"] = ShiftLeftLogical128BitLaneUInt641,
                 ["ShiftRightLogical128BitLane.SByte.1"] = ShiftRightLogical128BitLaneSByte1,
                 ["ShiftRightLogical128BitLane.Byte.1"] = ShiftRightLogical128BitLaneByte1,
                 ["ShiftRightLogical128BitLane.Int16.1"] = ShiftRightLogical128BitLaneInt161,
@@ -140,6 +124,22 @@ namespace JIT.HardwareIntrinsics.X86
                 ["ShiftRightLogical128BitLane.UInt32.1"] = ShiftRightLogical128BitLaneUInt321,
                 ["ShiftRightLogical128BitLane.Int64.1"] = ShiftRightLogical128BitLaneInt641,
                 ["ShiftRightLogical128BitLane.UInt64.1"] = ShiftRightLogical128BitLaneUInt641,
+                ["Subtract.Byte"] = SubtractByte,
+                ["Subtract.Int16"] = SubtractInt16,
+                ["Subtract.Int32"] = SubtractInt32,
+                ["Subtract.Int64"] = SubtractInt64,
+                ["Subtract.SByte"] = SubtractSByte,
+                ["Subtract.UInt16"] = SubtractUInt16,
+                ["Subtract.UInt32"] = SubtractUInt32,
+                ["Subtract.UInt64"] = SubtractUInt64,
+                ["Xor.Byte"] = XorByte,
+                ["Xor.Int16"] = XorInt16,
+                ["Xor.Int32"] = XorInt32,
+                ["Xor.Int64"] = XorInt64,
+                ["Xor.SByte"] = XorSByte,
+                ["Xor.UInt16"] = XorUInt16,
+                ["Xor.UInt32"] = XorUInt32,
+                ["Xor.UInt64"] = XorUInt64,
             };
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/AlternatingBinOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/AlternatingBinOpTest.template
index f455f4b9a2..dee7f6c590 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/AlternatingBinOpTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/AlternatingBinOpTest.template
@@ -16,38 +16,38 @@ using System.Runtime.Intrinsics;
 using System.Runtime.Intrinsics.X86;
 
 namespace JIT.HardwareIntrinsics.X86
-{{
+{
     public static partial class Program
-    {{
-        private static void {2}{4}()
-        {{
-            var test = new AlternatingBinaryOpTest__{2}{4}();
+    {
+        private static void {Method}{RetBaseType}()
+        {
+            var test = new AlternatingBinaryOpTest__{Method}{RetBaseType}();
 
             if (test.IsSupported)
-            {{
+            {
                 // Validates basic functionality works, using Unsafe.Read
                 test.RunBasicScenario_UnsafeRead();
 
-                if ({1}.IsSupported)
-                {{
+                if ({LoadIsa}.IsSupported)
+                {
                     // Validates basic functionality works, using Load
                     test.RunBasicScenario_Load();
 
                     // Validates basic functionality works, using LoadAligned
                     test.RunBasicScenario_LoadAligned();
-                }}
+                }
 
                 // Validates calling via reflection works, using Unsafe.Read
                 test.RunReflectionScenario_UnsafeRead();
 
-                if ({1}.IsSupported)
-                {{
+                if ({LoadIsa}.IsSupported)
+                {
                     // Validates calling via reflection works, using Load
                     test.RunReflectionScenario_Load();
 
                     // Validates calling via reflection works, using LoadAligned
                     test.RunReflectionScenario_LoadAligned();
-                }}
+                }
 
                 // Validates passing a static member works
                 test.RunClsVarScenario();
@@ -55,275 +55,275 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates passing a local works, using Unsafe.Read
                 test.RunLclVarScenario_UnsafeRead();
 
-                if ({1}.IsSupported)
-                {{
+                if ({LoadIsa}.IsSupported)
+                {
                     // Validates passing a local works, using Load
                     test.RunLclVarScenario_Load();
 
                     // Validates passing a local works, using LoadAligned
                     test.RunLclVarScenario_LoadAligned();
-                }}
+                }
 
                 // Validates passing the field of a local works
                 test.RunLclFldScenario();
 
                 // Validates passing an instance member works
                 test.RunFldScenario();
-            }}
+            }
             else
-            {{
+            {
                 // Validates we throw on unsupported hardware
                 test.RunUnsupportedScenario();
-            }}
+            }
 
             if (!test.Succeeded)
-            {{
+            {
                 throw new Exception("One or more scenarios did not complete as expected.");
-            }}
-        }}
-    }}
+            }
+        }
+    }
 
-    public sealed unsafe class AlternatingBinaryOpTest__{2}{4}
-    {{
-        private const int VectorSize = {9};
+    public sealed unsafe class AlternatingBinaryOpTest__{Method}{RetBaseType}
+    {
+        private const int VectorSize = {VectorSize};
 
-        private const int Op1ElementCount = VectorSize / sizeof({6});
-        private const int Op2ElementCount = VectorSize / sizeof({8});
-        private const int RetElementCount = VectorSize / sizeof({4});
+        private const int Op1ElementCount = VectorSize / sizeof({Op1BaseType});
+        private const int Op2ElementCount = VectorSize / sizeof({Op2BaseType});
+        private const int RetElementCount = VectorSize / sizeof({RetBaseType});
 
-        private static {6}[] _data1 = new {6}[Op1ElementCount];
-        private static {8}[] _data2 = new {8}[Op2ElementCount];
+        private static {Op1BaseType}[] _data1 = new {Op1BaseType}[Op1ElementCount];
+        private static {Op2BaseType}[] _data2 = new {Op2BaseType}[Op2ElementCount];
 
-        private static {5}<{6}> _clsVar1;
-        private static {7}<{8}> _clsVar2;
+        private static {Op1VectorType}<{Op1BaseType}> _clsVar1;
+        private static {Op2VectorType}<{Op2BaseType}> _clsVar2;
 
-        private {5}<{6}> _fld1;
-        private {7}<{8}> _fld2;
+        private {Op1VectorType}<{Op1BaseType}> _fld1;
+        private {Op2VectorType}<{Op2BaseType}> _fld2;
 
-        private AlternatingBinaryOpTest__DataTable<{4}, {6}, {8}> _dataTable;
+        private AlternatingBinaryOpTest__DataTable<{RetBaseType}, {Op1BaseType}, {Op2BaseType}> _dataTable;
 
-        static AlternatingBinaryOpTest__{2}{4}()
-        {{
+        static AlternatingBinaryOpTest__{Method}{RetBaseType}()
+        {
             var random = new Random();
 
-            for (var i = 0; i < Op1ElementCount; i++) {{ _data1[i] = {10}; }}
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{5}<{6}>, byte>(ref _clsVar1), ref Unsafe.As<{6}, byte>(ref _data1[0]), VectorSize);
-            for (var i = 0; i < Op2ElementCount; i++) {{ _data2[i] = {11}; }}
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{7}<{8}>, byte>(ref _clsVar2), ref Unsafe.As<{8}, byte>(ref _data2[0]), VectorSize);
-        }}
+            for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; }
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), VectorSize);
+            for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = {NextValueOp2}; }
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref _clsVar2), ref Unsafe.As<{Op2BaseType}, byte>(ref _data2[0]), VectorSize);
+        }
 
-        public AlternatingBinaryOpTest__{2}{4}()
-        {{
+        public AlternatingBinaryOpTest__{Method}{RetBaseType}()
+        {
             Succeeded = true;
 
             var random = new Random();
 
-            for (var i = 0; i < Op1ElementCount; i++) {{ _data1[i] = {10}; }}
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{5}<{6}>, byte>(ref _fld1), ref Unsafe.As<{6}, byte>(ref _data1[0]), VectorSize);
-            for (var i = 0; i < Op2ElementCount; i++) {{ _data2[i] = {11}; }}
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{7}<{8}>, byte>(ref _fld2), ref Unsafe.As<{8}, byte>(ref _data2[0]), VectorSize);
+            for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; }
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _fld1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), VectorSize);
+            for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = {NextValueOp2}; }
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref _fld2), ref Unsafe.As<{Op2BaseType}, byte>(ref _data2[0]), VectorSize);
 
-            for (var i = 0; i < Op1ElementCount; i++) {{ _data1[i] = {10}; }}
-            for (var i = 0; i < Op2ElementCount; i++) {{ _data2[i] = {11}; }}
-            _dataTable = new AlternatingBinaryOpTest__DataTable<{4}, {6}, {8}>(_data1, _data2, new {4}[RetElementCount], VectorSize);
-        }}
+            for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; }
+            for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = {NextValueOp2}; }
+            _dataTable = new AlternatingBinaryOpTest__DataTable<{RetBaseType}, {Op1BaseType}, {Op2BaseType}>(_data1, _data2, new {RetBaseType}[RetElementCount], VectorSize);
+        }
 
-        public bool IsSupported => {0}.IsSupported;
+        public bool IsSupported => {Isa}.IsSupported;
 
-        public bool Succeeded {{ get; set; }}
+        public bool Succeeded { get; set; }
 
         public void RunBasicScenario_UnsafeRead()
-        {{
-            var result = {0}.{2}(
-                Unsafe.Read<{5}<{6}>>(_dataTable.inArray1Ptr),
-                Unsafe.Read<{7}<{8}>>(_dataTable.inArray2Ptr)
+        {
+            var result = {Isa}.{Method}(
+                Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArray1Ptr),
+                Unsafe.Read<{Op2VectorType}<{Op2BaseType}>>(_dataTable.inArray2Ptr)
             );
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunBasicScenario_Load()
-        {{
-            var result = {0}.{2}(
-                {1}.Load{5}(({6}*)(_dataTable.inArray1Ptr)),
-                {1}.Load{7}(({8}*)(_dataTable.inArray2Ptr))
+        {
+            var result = {Isa}.{Method}(
+                {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)),
+                {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr))
             );
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunBasicScenario_LoadAligned()
-        {{
-            var result = {0}.{2}(
-                {1}.LoadAligned{5}(({6}*)(_dataTable.inArray1Ptr)),
-                {1}.LoadAligned{7}(({8}*)(_dataTable.inArray2Ptr))
+        {
+            var result = {Isa}.{Method}(
+                {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)),
+                {LoadIsa}.LoadAligned{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr))
             );
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunReflectionScenario_UnsafeRead()
-        {{
-            var result = typeof({0}).GetMethod(nameof({0}.{2}), new Type[] {{ typeof({5}<{6}>), typeof({7}<{8}>) }})
-                                     .Invoke(null, new object[] {{
-                                        Unsafe.Read<{5}<{6}>>(_dataTable.inArray1Ptr),
-                                        Unsafe.Read<{7}<{8}>>(_dataTable.inArray2Ptr)
-                                     }});
-
-            Unsafe.Write(_dataTable.outArrayPtr, ({3}<{4}>)(result));
+        {
+            var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof({Op2VectorType}<{Op2BaseType}>) })
+                                     .Invoke(null, new object[] {
+                                        Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArray1Ptr),
+                                        Unsafe.Read<{Op2VectorType}<{Op2BaseType}>>(_dataTable.inArray2Ptr)
+                                     });
+
+            Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result));
             ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunReflectionScenario_Load()
-        {{
-            var result = typeof({0}).GetMethod(nameof({0}.{2}), new Type[] {{ typeof({5}<{6}>), typeof({7}<{8}>) }})
-                                     .Invoke(null, new object[] {{
-                                        {1}.Load{5}(({6}*)(_dataTable.inArray1Ptr)),
-                                        {1}.Load{7}(({8}*)(_dataTable.inArray2Ptr))
-                                     }});
-
-            Unsafe.Write(_dataTable.outArrayPtr, ({3}<{4}>)(result));
+        {
+            var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof({Op2VectorType}<{Op2BaseType}>) })
+                                     .Invoke(null, new object[] {
+                                        {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)),
+                                        {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr))
+                                     });
+
+            Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result));
             ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunReflectionScenario_LoadAligned()
-        {{
-            var result = typeof({0}).GetMethod(nameof({0}.{2}), new Type[] {{ typeof({5}<{6}>), typeof({7}<{8}>) }})
-                                     .Invoke(null, new object[] {{
-                                        {1}.LoadAligned{5}(({6}*)(_dataTable.inArray1Ptr)),
-                                        {1}.LoadAligned{7}(({8}*)(_dataTable.inArray2Ptr))
-                                     }});
-
-            Unsafe.Write(_dataTable.outArrayPtr, ({3}<{4}>)(result));
+        {
+            var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof({Op2VectorType}<{Op2BaseType}>) })
+                                     .Invoke(null, new object[] {
+                                        {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)),
+                                        {LoadIsa}.LoadAligned{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr))
+                                     });
+
+            Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result));
             ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunClsVarScenario()
-        {{
-            var result = {0}.{2}(
+        {
+            var result = {Isa}.{Method}(
                 _clsVar1,
                 _clsVar2
             );
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(_clsVar1, _clsVar2, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunLclVarScenario_UnsafeRead()
-        {{
-            var left = Unsafe.Read<{5}<{6}>>(_dataTable.inArray1Ptr);
-            var right = Unsafe.Read<{7}<{8}>>(_dataTable.inArray2Ptr);
-            var result = {0}.{2}(left, right);
+        {
+            var left = Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArray1Ptr);
+            var right = Unsafe.Read<{Op2VectorType}<{Op2BaseType}>>(_dataTable.inArray2Ptr);
+            var result = {Isa}.{Method}(left, right);
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(left, right, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunLclVarScenario_Load()
-        {{
-            var left = {1}.Load{5}(({6}*)(_dataTable.inArray1Ptr));
-            var right = {1}.Load{7}(({8}*)(_dataTable.inArray2Ptr));
-            var result = {0}.{2}(left, right);
+        {
+            var left = {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr));
+            var right = {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr));
+            var result = {Isa}.{Method}(left, right);
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(left, right, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunLclVarScenario_LoadAligned()
-        {{
-            var left = {1}.LoadAligned{5}(({6}*)(_dataTable.inArray1Ptr));
-            var right = {1}.LoadAligned{7}(({8}*)(_dataTable.inArray2Ptr));
-            var result = {0}.{2}(left, right);
+        {
+            var left = {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr));
+            var right = {LoadIsa}.LoadAligned{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr));
+            var result = {Isa}.{Method}(left, right);
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(left, right, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunLclFldScenario()
-        {{
-            var test = new AlternatingBinaryOpTest__{2}{4}();
-            var result = {0}.{2}(test._fld1, test._fld2);
+        {
+            var test = new AlternatingBinaryOpTest__{Method}{RetBaseType}();
+            var result = {Isa}.{Method}(test._fld1, test._fld2);
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunFldScenario()
-        {{
-            var result = {0}.{2}(_fld1, _fld2);
+        {
+            var result = {Isa}.{Method}(_fld1, _fld2);
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunUnsupportedScenario()
-        {{
+        {
             Succeeded = false;
 
             try
-            {{
+            {
                 RunBasicScenario_UnsafeRead();
-            }}
+            }
             catch (PlatformNotSupportedException)
-            {{
+            {
                 Succeeded = true;
-            }}
-        }}
+            }
+        }
 
-        private void ValidateResult({5}<{6}> left, {7}<{8}> right, void* result, [CallerMemberName] string method = "")
-        {{
-            {6}[] inArray1 = new {6}[Op1ElementCount];
-            {8}[] inArray2 = new {8}[Op2ElementCount];
-            {4}[] outArray = new {4}[RetElementCount];
+        private void ValidateResult({Op1VectorType}<{Op1BaseType}> left, {Op2VectorType}<{Op2BaseType}> right, void* result, [CallerMemberName] string method = "")
+        {
+            {Op1BaseType}[] inArray1 = new {Op1BaseType}[Op1ElementCount];
+            {Op2BaseType}[] inArray2 = new {Op2BaseType}[Op2ElementCount];
+            {RetBaseType}[] outArray = new {RetBaseType}[RetElementCount];
 
             Unsafe.Write(Unsafe.AsPointer(ref inArray1[0]), left);
             Unsafe.Write(Unsafe.AsPointer(ref inArray2[0]), right);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{4}, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), VectorSize);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{RetBaseType}, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), VectorSize);
 
             ValidateResult(inArray1, inArray2, outArray, method);
-        }}
+        }
 
         private void ValidateResult(void* left, void* right, void* result, [CallerMemberName] string method = "")
-        {{
-            {6}[] inArray1 = new {6}[Op1ElementCount];
-            {8}[] inArray2 = new {8}[Op2ElementCount];
-            {4}[] outArray = new {4}[RetElementCount];
+        {
+            {Op1BaseType}[] inArray1 = new {Op1BaseType}[Op1ElementCount];
+            {Op2BaseType}[] inArray2 = new {Op2BaseType}[Op2ElementCount];
+            {RetBaseType}[] outArray = new {RetBaseType}[RetElementCount];
 
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{6}, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(left), VectorSize);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{8}, byte>(ref inArray2[0]), ref Unsafe.AsRef<byte>(right), VectorSize);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{4}, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), VectorSize);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1BaseType}, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(left), VectorSize);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2BaseType}, byte>(ref inArray2[0]), ref Unsafe.AsRef<byte>(right), VectorSize);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{RetBaseType}, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), VectorSize);
 
             ValidateResult(inArray1, inArray2, outArray, method);
-        }}
+        }
 
-        private void ValidateResult({6}[] left, {8}[] right, {4}[] result, [CallerMemberName] string method = "")
-        {{
+        private void ValidateResult({Op1BaseType}[] left, {Op2BaseType}[] right, {RetBaseType}[] result, [CallerMemberName] string method = "")
+        {
             for (var i = 0; i < RetElementCount; i += 2)
-            {{
-                if ({12})
-                {{
+            {
+                if ({ValidateFirstResult})
+                {
                     Succeeded = false;
                     break;
-                }}
+                }
 
-                if ({13})
-                {{
+                if ({ValidateRemainingResults})
+                {
                     Succeeded = false;
                     break;
-                }}
-            }}
+                }
+            }
 
             if (!Succeeded)
-            {{
-                Console.WriteLine($"{{nameof({0})}}.{{nameof({0}.{2})}}<{4}>({5}<{6}>, {7}<{8}>): {{method}} failed:");
-                Console.WriteLine($"    left: ({{string.Join(", ", left)}})");
-                Console.WriteLine($"   right: ({{string.Join(", ", right)}})");
-                Console.WriteLine($"  result: ({{string.Join(", ", result)}})");
+            {
+                Console.WriteLine($"{nameof({Isa})}.{nameof({Isa}.{Method})}<{RetBaseType}>({Op1VectorType}<{Op1BaseType}>, {Op2VectorType}<{Op2BaseType}>): {method} failed:");
+                Console.WriteLine($"    left: ({string.Join(", ", left)})");
+                Console.WriteLine($"   right: ({string.Join(", ", right)})");
+                Console.WriteLine($"  result: ({string.Join(", ", result)})");
                 Console.WriteLine();
-            }}
-        }}
-    }}
-}}
+            }
+        }
+    }
+}
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanBinOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanBinOpTest.template
index 6b6b728265..bb60168666 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanBinOpTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanBinOpTest.template
@@ -16,38 +16,38 @@ using System.Runtime.Intrinsics;
 using System.Runtime.Intrinsics.X86;
 
 namespace JIT.HardwareIntrinsics.X86
-{{
+{
     public static partial class Program
-    {{
-        private static void {2}{4}()
-        {{
-            var test = new BooleanBinaryOpTest__{2}{4}();
+    {
+        private static void {Method}{RetBaseType}()
+        {
+            var test = new BooleanBinaryOpTest__{Method}{RetBaseType}();
 
             if (test.IsSupported)
-            {{
+            {
                 // Validates basic functionality works, using Unsafe.Read
                 test.RunBasicScenario_UnsafeRead();
 
-                if ({1}.IsSupported)
-                {{
+                if ({LoadIsa}.IsSupported)
+                {
                     // Validates basic functionality works, using Load
                     test.RunBasicScenario_Load();
 
                     // Validates basic functionality works, using LoadAligned
                     test.RunBasicScenario_LoadAligned();
-                }}
+                }
 
                 // Validates calling via reflection works, using Unsafe.Read
                 test.RunReflectionScenario_UnsafeRead();
 
-                if ({1}.IsSupported)
-                {{
+                if ({LoadIsa}.IsSupported)
+                {
                     // Validates calling via reflection works, using Load
                     test.RunReflectionScenario_Load();
 
                     // Validates calling via reflection works, using LoadAligned
                     test.RunReflectionScenario_LoadAligned();
-                }}
+                }
 
                 // Validates passing a static member works
                 test.RunClsVarScenario();
@@ -55,264 +55,264 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates passing a local works, using Unsafe.Read
                 test.RunLclVarScenario_UnsafeRead();
 
-                if ({1}.IsSupported)
-                {{
+                if ({LoadIsa}.IsSupported)
+                {
                     // Validates passing a local works, using Load
                     test.RunLclVarScenario_Load();
 
                     // Validates passing a local works, using LoadAligned
                     test.RunLclVarScenario_LoadAligned();
-                }}
+                }
 
                 // Validates passing the field of a local works
                 test.RunLclFldScenario();
 
                 // Validates passing an instance member works
                 test.RunFldScenario();
-            }}
+            }
             else
-            {{
+            {
                 // Validates we throw on unsupported hardware
                 test.RunUnsupportedScenario();
-            }}
+            }
 
             if (!test.Succeeded)
-            {{
+            {
                 throw new Exception("One or more scenarios did not complete as expected.");
-            }}
-        }}
-    }}
+            }
+        }
+    }
 
-    public sealed unsafe class BooleanBinaryOpTest__{2}{4}
-    {{
-        private const int VectorSize = {9};
+    public sealed unsafe class BooleanBinaryOpTest__{Method}{RetBaseType}
+    {
+        private const int VectorSize = {VectorSize};
 
-        private const int Op1ElementCount = VectorSize / sizeof({6});
-        private const int Op2ElementCount = VectorSize / sizeof({8});
+        private const int Op1ElementCount = VectorSize / sizeof({Op1BaseType});
+        private const int Op2ElementCount = VectorSize / sizeof({Op2BaseType});
 
-        private static {6}[] _data1 = new {6}[Op1ElementCount];
-        private static {8}[] _data2 = new {8}[Op2ElementCount];
+        private static {Op1BaseType}[] _data1 = new {Op1BaseType}[Op1ElementCount];
+        private static {Op2BaseType}[] _data2 = new {Op2BaseType}[Op2ElementCount];
 
-        private static {5}<{6}> _clsVar1;
-        private static {7}<{8}> _clsVar2;
+        private static {Op1VectorType}<{Op1BaseType}> _clsVar1;
+        private static {Op2VectorType}<{Op2BaseType}> _clsVar2;
 
-        private {5}<{6}> _fld1;
-        private {7}<{8}> _fld2;
+        private {Op1VectorType}<{Op1BaseType}> _fld1;
+        private {Op2VectorType}<{Op2BaseType}> _fld2;
 
-        private BooleanBinaryOpTest__DataTable<{6}, {8}> _dataTable;
+        private BooleanBinaryOpTest__DataTable<{Op1BaseType}, {Op2BaseType}> _dataTable;
 
-        static BooleanBinaryOpTest__{2}{4}()
-        {{
+        static BooleanBinaryOpTest__{Method}{RetBaseType}()
+        {
             var random = new Random();
 
-            for (var i = 0; i < Op1ElementCount; i++) {{ _data1[i] = {10}; }}
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{5}<{6}>, byte>(ref _clsVar1), ref Unsafe.As<{6}, byte>(ref _data1[0]), VectorSize);
-            for (var i = 0; i < Op2ElementCount; i++) {{ _data2[i] = {11}; }}
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{7}<{8}>, byte>(ref _clsVar2), ref Unsafe.As<{8}, byte>(ref _data2[0]), VectorSize);
-        }}
+            for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; }
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), VectorSize);
+            for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = {NextValueOp2}; }
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref _clsVar2), ref Unsafe.As<{Op2BaseType}, byte>(ref _data2[0]), VectorSize);
+        }
 
-        public BooleanBinaryOpTest__{2}{4}()
-        {{
+        public BooleanBinaryOpTest__{Method}{RetBaseType}()
+        {
             Succeeded = true;
 
             var random = new Random();
 
-            for (var i = 0; i < Op1ElementCount; i++) {{ _data1[i] = {10}; }}
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{5}<{6}>, byte>(ref _fld1), ref Unsafe.As<{6}, byte>(ref _data1[0]), VectorSize);
-            for (var i = 0; i < Op2ElementCount; i++) {{ _data2[i] = {11}; }}
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{7}<{8}>, byte>(ref _fld2), ref Unsafe.As<{8}, byte>(ref _data2[0]), VectorSize);
+            for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; }
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _fld1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), VectorSize);
+            for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = {NextValueOp2}; }
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref _fld2), ref Unsafe.As<{Op2BaseType}, byte>(ref _data2[0]), VectorSize);
 
-            for (var i = 0; i < Op1ElementCount; i++) {{ _data1[i] = {10}; }}
-            for (var i = 0; i < Op2ElementCount; i++) {{ _data2[i] = {11}; }}
-            _dataTable = new BooleanBinaryOpTest__DataTable<{6}, {8}>(_data1, _data2, VectorSize);
-        }}
+            for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; }
+            for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = {NextValueOp2}; }
+            _dataTable = new BooleanBinaryOpTest__DataTable<{Op1BaseType}, {Op2BaseType}>(_data1, _data2, VectorSize);
+        }
 
-        public bool IsSupported => {0}.IsSupported;
+        public bool IsSupported => {Isa}.IsSupported;
 
-        public bool Succeeded {{ get; set; }}
+        public bool Succeeded { get; set; }
 
         public void RunBasicScenario_UnsafeRead()
-        {{
-            var result = {0}.{2}(
-                Unsafe.Read<{5}<{6}>>(_dataTable.inArray1Ptr),
-                Unsafe.Read<{7}<{8}>>(_dataTable.inArray2Ptr)
+        {
+            var result = {Isa}.{Method}(
+                Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArray1Ptr),
+                Unsafe.Read<{Op2VectorType}<{Op2BaseType}>>(_dataTable.inArray2Ptr)
             );
 
             ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, result);
-        }}
+        }
 
         public void RunBasicScenario_Load()
-        {{
-            var result = {0}.{2}(
-                {1}.Load{5}(({6}*)(_dataTable.inArray1Ptr)),
-                {1}.Load{7}(({8}*)(_dataTable.inArray2Ptr))
+        {
+            var result = {Isa}.{Method}(
+                {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)),
+                {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr))
             );
 
             ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, result);
-        }}
+        }
 
         public void RunBasicScenario_LoadAligned()
-        {{
-            var result = {0}.{2}(
-                {1}.LoadAligned{5}(({6}*)(_dataTable.inArray1Ptr)),
-                {1}.LoadAligned{7}(({8}*)(_dataTable.inArray2Ptr))
+        {
+            var result = {Isa}.{Method}(
+                {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)),
+                {LoadIsa}.LoadAligned{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr))
             );
 
             ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, result);
-        }}
+        }
 
         public void RunReflectionScenario_UnsafeRead()
-        {{
-            var method = typeof({0}).GetMethod(nameof({0}.{2}), new Type[] {{ typeof({5}<{6}>), typeof({7}<{8}>) }});
+        {
+            var method = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof({Op2VectorType}<{Op2BaseType}>) });
             
             if (method != null)
-            {{
-                var result = method.Invoke(null, new object[] {{
-                                        Unsafe.Read<{5}<{6}>>(_dataTable.inArray1Ptr),
-                                        Unsafe.Read<{7}<{8}>>(_dataTable.inArray2Ptr)
-                                     }});
+            {
+                var result = method.Invoke(null, new object[] {
+                                        Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArray1Ptr),
+                                        Unsafe.Read<{Op2VectorType}<{Op2BaseType}>>(_dataTable.inArray2Ptr)
+                                     });
 
                 ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, (bool)(result));
-            }}
-        }}
+            }
+        }
 
         public void RunReflectionScenario_Load()
-        {{
-            var method = typeof({0}).GetMethod(nameof({0}.{2}), new Type[] {{ typeof({5}<{6}>), typeof({7}<{8}>) }});
+        {
+            var method = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof({Op2VectorType}<{Op2BaseType}>) });
             
             if (method != null)
-            {{
-                var result = method.Invoke(null, new object[] {{
-                                        {1}.Load{5}(({6}*)(_dataTable.inArray1Ptr)),
-                                        {1}.Load{7}(({8}*)(_dataTable.inArray2Ptr))
-                                     }});
+            {
+                var result = method.Invoke(null, new object[] {
+                                        {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)),
+                                        {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr))
+                                     });
 
                 ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, (bool)(result));
-            }}
-        }}
+            }
+        }
 
         public void RunReflectionScenario_LoadAligned()
-        {{
-            var method = typeof({0}).GetMethod(nameof({0}.{2}), new Type[] {{ typeof({5}<{6}>), typeof({7}<{8}>) }});
+        {
+            var method = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof({Op2VectorType}<{Op2BaseType}>) });
             
             if (method != null)
-            {{
-                var result = method.Invoke(null, new object[] {{
-                                        {1}.LoadAligned{5}(({6}*)(_dataTable.inArray1Ptr)),
-                                        {1}.LoadAligned{7}(({8}*)(_dataTable.inArray2Ptr))
-                                     }});
+            {
+                var result = method.Invoke(null, new object[] {
+                                        {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)),
+                                        {LoadIsa}.LoadAligned{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr))
+                                     });
 
                 ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, (bool)(result));
-            }}
-        }}
+            }
+        }
 
         public void RunClsVarScenario()
-        {{
-            var result = {0}.{2}(
+        {
+            var result = {Isa}.{Method}(
                 _clsVar1,
                 _clsVar2
             );
 
             ValidateResult(_clsVar1, _clsVar2, result);
-        }}
+        }
 
         public void RunLclVarScenario_UnsafeRead()
-        {{
-            var left = Unsafe.Read<{5}<{6}>>(_dataTable.inArray1Ptr);
-            var right = Unsafe.Read<{7}<{8}>>(_dataTable.inArray2Ptr);
-            var result = {0}.{2}(left, right);
+        {
+            var left = Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArray1Ptr);
+            var right = Unsafe.Read<{Op2VectorType}<{Op2BaseType}>>(_dataTable.inArray2Ptr);
+            var result = {Isa}.{Method}(left, right);
 
             ValidateResult(left, right, result);
-        }}
+        }
 
         public void RunLclVarScenario_Load()
-        {{
-            var left = {1}.Load{5}(({6}*)(_dataTable.inArray1Ptr));
-            var right = {1}.Load{7}(({8}*)(_dataTable.inArray2Ptr));
-            var result = {0}.{2}(left, right);
+        {
+            var left = {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr));
+            var right = {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr));
+            var result = {Isa}.{Method}(left, right);
 
             ValidateResult(left, right, result);
-        }}
+        }
 
         public void RunLclVarScenario_LoadAligned()
-        {{
-            var left = {1}.LoadAligned{5}(({6}*)(_dataTable.inArray1Ptr));
-            var right = {1}.LoadAligned{7}(({8}*)(_dataTable.inArray2Ptr));
-            var result = {0}.{2}(left, right);
+        {
+            var left = {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr));
+            var right = {LoadIsa}.LoadAligned{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr));
+            var result = {Isa}.{Method}(left, right);
 
             ValidateResult(left, right, result);
-        }}
+        }
 
         public void RunLclFldScenario()
-        {{
-            var test = new BooleanBinaryOpTest__{2}{4}();
-            var result = {0}.{2}(test._fld1, test._fld2);
+        {
+            var test = new BooleanBinaryOpTest__{Method}{RetBaseType}();
+            var result = {Isa}.{Method}(test._fld1, test._fld2);
 
             ValidateResult(test._fld1, test._fld2, result);
-        }}
+        }
 
         public void RunFldScenario()
-        {{
-            var result = {0}.{2}(_fld1, _fld2);
+        {
+            var result = {Isa}.{Method}(_fld1, _fld2);
 
             ValidateResult(_fld1, _fld2, result);
-        }}
+        }
 
         public void RunUnsupportedScenario()
-        {{
+        {
             Succeeded = false;
 
             try
-            {{
+            {
                 RunBasicScenario_UnsafeRead();
-            }}
+            }
             catch (PlatformNotSupportedException)
-            {{
+            {
                 Succeeded = true;
-            }}
-        }}
+            }
+        }
 
-        private void ValidateResult({5}<{6}> left, {7}<{8}> right, bool result, [CallerMemberName] string method = "")
-        {{
-            {6}[] inArray1 = new {6}[Op1ElementCount];
-            {8}[] inArray2 = new {8}[Op2ElementCount];
+        private void ValidateResult({Op1VectorType}<{Op1BaseType}> left, {Op2VectorType}<{Op2BaseType}> right, bool result, [CallerMemberName] string method = "")
+        {
+            {Op1BaseType}[] inArray1 = new {Op1BaseType}[Op1ElementCount];
+            {Op2BaseType}[] inArray2 = new {Op2BaseType}[Op2ElementCount];
 
             Unsafe.Write(Unsafe.AsPointer(ref inArray1[0]), left);
             Unsafe.Write(Unsafe.AsPointer(ref inArray2[0]), right);
 
             ValidateResult(inArray1, inArray2, result, method);
-        }}
+        }
 
         private void ValidateResult(void* left, void* right, bool result, [CallerMemberName] string method = "")
-        {{
-            {6}[] inArray1 = new {6}[Op1ElementCount];
-            {8}[] inArray2 = new {8}[Op2ElementCount];
+        {
+            {Op1BaseType}[] inArray1 = new {Op1BaseType}[Op1ElementCount];
+            {Op2BaseType}[] inArray2 = new {Op2BaseType}[Op2ElementCount];
 
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{6}, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(left), VectorSize);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{8}, byte>(ref inArray2[0]), ref Unsafe.AsRef<byte>(right), VectorSize);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1BaseType}, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(left), VectorSize);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2BaseType}, byte>(ref inArray2[0]), ref Unsafe.AsRef<byte>(right), VectorSize);
 
             ValidateResult(inArray1, inArray2, result, method);
-        }}
+        }
 
-        private void ValidateResult({6}[] left, {8}[] right, bool result, [CallerMemberName] string method = "")
-        {{
+        private void ValidateResult({Op1BaseType}[] left, {Op2BaseType}[] right, bool result, [CallerMemberName] string method = "")
+        {
             var expectedResult = true;
 
             for (var i = 0; i < Op1ElementCount; i++)
-            {{
-                expectedResult &= ({12});
-            }}
+            {
+                expectedResult &= ({ValidateFirstResult});
+            }
 
             if (expectedResult != result)
-            {{
+            {
                 Succeeded = false;
 
-                Console.WriteLine($"{{nameof({0})}}.{{nameof({0}.{2})}}<{4}>({5}<{6}>, {7}<{8}>): {{method}} failed:");
-                Console.WriteLine($"    left: ({{string.Join(", ", left)}})");
-                Console.WriteLine($"   right: ({{string.Join(", ", right)}})");
-                Console.WriteLine($"  result: ({{string.Join(", ", result)}})");
+                Console.WriteLine($"{nameof({Isa})}.{nameof({Isa}.{Method})}<{RetBaseType}>({Op1VectorType}<{Op1BaseType}>, {Op2VectorType}<{Op2BaseType}>): {method} failed:");
+                Console.WriteLine($"    left: ({string.Join(", ", left)})");
+                Console.WriteLine($"   right: ({string.Join(", ", right)})");
+                Console.WriteLine($"  result: ({string.Join(", ", result)})");
                 Console.WriteLine();
-            }}
-        }}
-    }}
-}}
+            }
+        }
+    }
+}
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanCmpOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanCmpOpTest.template
index 58df4e18b5..b16b17a45f 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanCmpOpTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanCmpOpTest.template
@@ -16,38 +16,38 @@ using System.Runtime.Intrinsics;
 using System.Runtime.Intrinsics.X86;
 
 namespace JIT.HardwareIntrinsics.X86
-{{
+{
     public static partial class Program
-    {{
-        private static void {2}{4}()
-        {{
-            var test = new BooleanComparisonOpTest__{2}{4}();
+    {
+        private static void {Method}{RetBaseType}()
+        {
+            var test = new BooleanComparisonOpTest__{Method}{RetBaseType}();
 
             if (test.IsSupported)
-            {{
+            {
                 // Validates basic functionality works, using Unsafe.Read
                 test.RunBasicScenario_UnsafeRead();
 
-                if ({1}.IsSupported)
-                {{
+                if ({LoadIsa}.IsSupported)
+                {
                     // Validates basic functionality works, using Load
                     test.RunBasicScenario_Load();
 
                     // Validates basic functionality works, using LoadAligned
                     test.RunBasicScenario_LoadAligned();
-                }}
+                }
 
                 // Validates calling via reflection works, using Unsafe.Read
                 test.RunReflectionScenario_UnsafeRead();
 
-                if ({1}.IsSupported)
-                {{
+                if ({LoadIsa}.IsSupported)
+                {
                     // Validates calling via reflection works, using Load
                     test.RunReflectionScenario_Load();
 
                     // Validates calling via reflection works, using LoadAligned
                     test.RunReflectionScenario_LoadAligned();
-                }}
+                }
 
                 // Validates passing a static member works
                 test.RunClsVarScenario();
@@ -55,245 +55,245 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates passing a local works, using Unsafe.Read
                 test.RunLclVarScenario_UnsafeRead();
 
-                if ({1}.IsSupported)
-                {{
+                if ({LoadIsa}.IsSupported)
+                {
                     // Validates passing a local works, using Load
                     test.RunLclVarScenario_Load();
 
                     // Validates passing a local works, using LoadAligned
                     test.RunLclVarScenario_LoadAligned();
-                }}
+                }
 
                 // Validates passing the field of a local works
                 test.RunLclFldScenario();
 
                 // Validates passing an instance member works
                 test.RunFldScenario();
-            }}
+            }
             else
-            {{
+            {
                 // Validates we throw on unsupported hardware
                 test.RunUnsupportedScenario();
-            }}
+            }
 
             if (!test.Succeeded)
-            {{
+            {
                 throw new Exception("One or more scenarios did not complete as expected.");
-            }}
-        }}
-    }}
+            }
+        }
+    }
 
-    public sealed unsafe class BooleanComparisonOpTest__{2}{4}
-    {{
-        private const int VectorSize = {9};
+    public sealed unsafe class BooleanComparisonOpTest__{Method}{RetBaseType}
+    {
+        private const int VectorSize = {VectorSize};
 
-        private const int Op1ElementCount = VectorSize / sizeof({6});
-        private const int Op2ElementCount = VectorSize / sizeof({8});
+        private const int Op1ElementCount = VectorSize / sizeof({Op1BaseType});
+        private const int Op2ElementCount = VectorSize / sizeof({Op2BaseType});
 
-        private static {6}[] _data1 = new {6}[Op1ElementCount];
-        private static {8}[] _data2 = new {8}[Op2ElementCount];
+        private static {Op1BaseType}[] _data1 = new {Op1BaseType}[Op1ElementCount];
+        private static {Op2BaseType}[] _data2 = new {Op2BaseType}[Op2ElementCount];
 
-        private static {5}<{6}> _clsVar1;
-        private static {7}<{8}> _clsVar2;
+        private static {Op1VectorType}<{Op1BaseType}> _clsVar1;
+        private static {Op2VectorType}<{Op2BaseType}> _clsVar2;
 
-        private {5}<{6}> _fld1;
-        private {7}<{8}> _fld2;
+        private {Op1VectorType}<{Op1BaseType}> _fld1;
+        private {Op2VectorType}<{Op2BaseType}> _fld2;
 
-        private BooleanComparisonOpTest__DataTable<{6}, {8}> _dataTable;
+        private BooleanComparisonOpTest__DataTable<{Op1BaseType}, {Op2BaseType}> _dataTable;
 
-        static BooleanComparisonOpTest__{2}{4}()
-        {{
+        static BooleanComparisonOpTest__{Method}{RetBaseType}()
+        {
             var random = new Random();
 
-            for (var i = 0; i < Op1ElementCount; i++) {{ _data1[i] = {10}; }}
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{5}<{6}>, byte>(ref _clsVar1), ref Unsafe.As<{6}, byte>(ref _data1[0]), VectorSize);
-            for (var i = 0; i < Op2ElementCount; i++) {{ _data2[i] = {11}; }}
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{7}<{8}>, byte>(ref _clsVar2), ref Unsafe.As<{8}, byte>(ref _data2[0]), VectorSize);
-        }}
+            for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; }
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), VectorSize);
+            for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = {NextValueOp2}; }
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref _clsVar2), ref Unsafe.As<{Op2BaseType}, byte>(ref _data2[0]), VectorSize);
+        }
 
-        public BooleanComparisonOpTest__{2}{4}()
-        {{
+        public BooleanComparisonOpTest__{Method}{RetBaseType}()
+        {
             Succeeded = true;
 
             var random = new Random();
 
-            for (var i = 0; i < Op1ElementCount; i++) {{ _data1[i] = {10}; }}
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{5}<{6}>, byte>(ref _fld1), ref Unsafe.As<{6}, byte>(ref _data1[0]), VectorSize);
-            for (var i = 0; i < Op2ElementCount; i++) {{ _data2[i] = {11}; }}
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{7}<{8}>, byte>(ref _fld2), ref Unsafe.As<{8}, byte>(ref _data2[0]), VectorSize);
+            for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; }
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _fld1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), VectorSize);
+            for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = {NextValueOp2}; }
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref _fld2), ref Unsafe.As<{Op2BaseType}, byte>(ref _data2[0]), VectorSize);
 
-            for (var i = 0; i < Op1ElementCount; i++) {{ _data1[i] = {10}; }}
-            for (var i = 0; i < Op2ElementCount; i++) {{ _data2[i] = {11}; }}
-            _dataTable = new BooleanComparisonOpTest__DataTable<{6}, {8}>(_data1, _data2, VectorSize);
-        }}
+            for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; }
+            for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = {NextValueOp2}; }
+            _dataTable = new BooleanComparisonOpTest__DataTable<{Op1BaseType}, {Op2BaseType}>(_data1, _data2, VectorSize);
+        }
 
-        public bool IsSupported => {0}.IsSupported;
+        public bool IsSupported => {Isa}.IsSupported;
 
-        public bool Succeeded {{ get; set; }}
+        public bool Succeeded { get; set; }
 
         public void RunBasicScenario_UnsafeRead()
-        {{
-            var result = {0}.{2}(
-                Unsafe.Read<{5}<{6}>>(_dataTable.inArray1Ptr),
-                Unsafe.Read<{7}<{8}>>(_dataTable.inArray2Ptr)
+        {
+            var result = {Isa}.{Method}(
+                Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArray1Ptr),
+                Unsafe.Read<{Op2VectorType}<{Op2BaseType}>>(_dataTable.inArray2Ptr)
             );
 
             ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, result);
-        }}
+        }
 
         public void RunBasicScenario_Load()
-        {{
-            var result = {0}.{2}(
-                {1}.Load{5}(({6}*)(_dataTable.inArray1Ptr)),
-                {1}.Load{7}(({8}*)(_dataTable.inArray2Ptr))
+        {
+            var result = {Isa}.{Method}(
+                {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)),
+                {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr))
             );
 
             ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, result);
-        }}
+        }
 
         public void RunBasicScenario_LoadAligned()
-        {{
-            var result = {0}.{2}(
-                {1}.LoadAligned{5}(({6}*)(_dataTable.inArray1Ptr)),
-                {1}.LoadAligned{7}(({8}*)(_dataTable.inArray2Ptr))
+        {
+            var result = {Isa}.{Method}(
+                {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)),
+                {LoadIsa}.LoadAligned{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr))
             );
 
             ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, result);
-        }}
+        }
 
         public void RunReflectionScenario_UnsafeRead()
-        {{
-            var result = typeof({0}).GetMethod(nameof({0}.{2}), new Type[] {{ typeof({5}<{6}>), typeof({7}<{8}>) }})
-                                     .Invoke(null, new object[] {{
-                                        Unsafe.Read<{5}<{6}>>(_dataTable.inArray1Ptr),
-                                        Unsafe.Read<{7}<{8}>>(_dataTable.inArray2Ptr)
-                                     }});
+        {
+            var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof({Op2VectorType}<{Op2BaseType}>) })
+                                     .Invoke(null, new object[] {
+                                        Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArray1Ptr),
+                                        Unsafe.Read<{Op2VectorType}<{Op2BaseType}>>(_dataTable.inArray2Ptr)
+                                     });
 
             ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, (bool)(result));
-        }}
+        }
 
         public void RunReflectionScenario_Load()
-        {{
-            var result = typeof({0}).GetMethod(nameof({0}.{2}), new Type[] {{ typeof({5}<{6}>), typeof({7}<{8}>) }})
-                                     .Invoke(null, new object[] {{
-                                        {1}.Load{5}(({6}*)(_dataTable.inArray1Ptr)),
-                                        {1}.Load{7}(({8}*)(_dataTable.inArray2Ptr))
-                                     }});
+        {
+            var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof({Op2VectorType}<{Op2BaseType}>) })
+                                     .Invoke(null, new object[] {
+                                        {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)),
+                                        {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr))
+                                     });
 
             ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, (bool)(result));
-        }}
+        }
 
         public void RunReflectionScenario_LoadAligned()
-        {{
-            var result = typeof({0}).GetMethod(nameof({0}.{2}), new Type[] {{ typeof({5}<{6}>), typeof({7}<{8}>) }})
-                                     .Invoke(null, new object[] {{
-                                        {1}.LoadAligned{5}(({6}*)(_dataTable.inArray1Ptr)),
-                                        {1}.LoadAligned{7}(({8}*)(_dataTable.inArray2Ptr))
-                                     }});
+        {
+            var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof({Op2VectorType}<{Op2BaseType}>) })
+                                     .Invoke(null, new object[] {
+                                        {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)),
+                                        {LoadIsa}.LoadAligned{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr))
+                                     });
 
             ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, (bool)(result));
-        }}
+        }
 
         public void RunClsVarScenario()
-        {{
-            var result = {0}.{2}(
+        {
+            var result = {Isa}.{Method}(
                 _clsVar1,
                 _clsVar2
             );
 
             ValidateResult(_clsVar1, _clsVar2, result);
-        }}
+        }
 
         public void RunLclVarScenario_UnsafeRead()
-        {{
-            var left = Unsafe.Read<{5}<{6}>>(_dataTable.inArray1Ptr);
-            var right = Unsafe.Read<{7}<{8}>>(_dataTable.inArray2Ptr);
-            var result = {0}.{2}(left, right);
+        {
+            var left = Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArray1Ptr);
+            var right = Unsafe.Read<{Op2VectorType}<{Op2BaseType}>>(_dataTable.inArray2Ptr);
+            var result = {Isa}.{Method}(left, right);
 
             ValidateResult(left, right, result);
-        }}
+        }
 
         public void RunLclVarScenario_Load()
-        {{
-            var left = {1}.Load{5}(({6}*)(_dataTable.inArray1Ptr));
-            var right = {1}.Load{7}(({8}*)(_dataTable.inArray2Ptr));
-            var result = {0}.{2}(left, right);
+        {
+            var left = {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr));
+            var right = {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr));
+            var result = {Isa}.{Method}(left, right);
 
             ValidateResult(left, right, result);
-        }}
+        }
 
         public void RunLclVarScenario_LoadAligned()
-        {{
-            var left = {1}.LoadAligned{5}(({6}*)(_dataTable.inArray1Ptr));
-            var right = {1}.LoadAligned{7}(({8}*)(_dataTable.inArray2Ptr));
-            var result = {0}.{2}(left, right);
+        {
+            var left = {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr));
+            var right = {LoadIsa}.LoadAligned{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr));
+            var result = {Isa}.{Method}(left, right);
 
             ValidateResult(left, right, result);
-        }}
+        }
 
         public void RunLclFldScenario()
-        {{
-            var test = new BooleanComparisonOpTest__{2}{4}();
-            var result = {0}.{2}(test._fld1, test._fld2);
+        {
+            var test = new BooleanComparisonOpTest__{Method}{RetBaseType}();
+            var result = {Isa}.{Method}(test._fld1, test._fld2);
 
             ValidateResult(test._fld1, test._fld2, result);
-        }}
+        }
 
         public void RunFldScenario()
-        {{
-            var result = {0}.{2}(_fld1, _fld2);
+        {
+            var result = {Isa}.{Method}(_fld1, _fld2);
 
             ValidateResult(_fld1, _fld2, result);
-        }}
+        }
 
         public void RunUnsupportedScenario()
-        {{
+        {
             Succeeded = false;
 
             try
-            {{
+            {
                 RunBasicScenario_UnsafeRead();
-            }}
+            }
             catch (PlatformNotSupportedException)
-            {{
+            {
                 Succeeded = true;
-            }}
-        }}
+            }
+        }
 
-        private void ValidateResult({5}<{6}> left, {7}<{8}> right, bool result, [CallerMemberName] string method = "")
-        {{
-            {6}[] inArray1 = new {6}[Op1ElementCount];
-            {8}[] inArray2 = new {8}[Op2ElementCount];
+        private void ValidateResult({Op1VectorType}<{Op1BaseType}> left, {Op2VectorType}<{Op2BaseType}> right, bool result, [CallerMemberName] string method = "")
+        {
+            {Op1BaseType}[] inArray1 = new {Op1BaseType}[Op1ElementCount];
+            {Op2BaseType}[] inArray2 = new {Op2BaseType}[Op2ElementCount];
 
             Unsafe.Write(Unsafe.AsPointer(ref inArray1[0]), left);
             Unsafe.Write(Unsafe.AsPointer(ref inArray2[0]), right);
 
             ValidateResult(inArray1, inArray2, result, method);
-        }}
+        }
 
         private void ValidateResult(void* left, void* right, bool result, [CallerMemberName] string method = "")
-        {{
-            {6}[] inArray1 = new {6}[Op1ElementCount];
-            {8}[] inArray2 = new {8}[Op2ElementCount];
+        {
+            {Op1BaseType}[] inArray1 = new {Op1BaseType}[Op1ElementCount];
+            {Op2BaseType}[] inArray2 = new {Op2BaseType}[Op2ElementCount];
 
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{6}, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(left), VectorSize);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{8}, byte>(ref inArray2[0]), ref Unsafe.AsRef<byte>(right), VectorSize);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1BaseType}, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(left), VectorSize);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2BaseType}, byte>(ref inArray2[0]), ref Unsafe.AsRef<byte>(right), VectorSize);
 
             ValidateResult(inArray1, inArray2, result, method);
-        }}
+        }
 
-        private void ValidateResult({6}[] left, {8}[] right, bool result, [CallerMemberName] string method = "")
-        {{
-            if ({12})
-            {{
+        private void ValidateResult({Op1BaseType}[] left, {Op2BaseType}[] right, bool result, [CallerMemberName] string method = "")
+        {
+            if ({ValidateFirstResult})
+            {
                 Succeeded = false;
 
-                Console.WriteLine($"{{nameof({0})}}.{{nameof({0}.{2})}}<{4}>({5}<{6}>, {7}<{8}>): {{method}} failed:");
-                Console.WriteLine($"    left: ({{string.Join(", ", left)}})");
-                Console.WriteLine($"   right: ({{string.Join(", ", right)}})");
-                Console.WriteLine($"  result: ({{string.Join(", ", result)}})");
+                Console.WriteLine($"{nameof({Isa})}.{nameof({Isa}.{Method})}<{RetBaseType}>({Op1VectorType}<{Op1BaseType}>, {Op2VectorType}<{Op2BaseType}>): {method} failed:");
+                Console.WriteLine($"    left: ({string.Join(", ", left)})");
+                Console.WriteLine($"   right: ({string.Join(", ", right)})");
+                Console.WriteLine($"  result: ({string.Join(", ", result)})");
                 Console.WriteLine();
-            }}
-        }}
-    }}
-}}
+            }
+        }
+    }
+}
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanTwoCmpOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanTwoCmpOpTest.template
index babd01dedf..53c9cacd13 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanTwoCmpOpTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanTwoCmpOpTest.template
@@ -16,38 +16,38 @@ using System.Runtime.Intrinsics;
 using System.Runtime.Intrinsics.X86;
 
 namespace JIT.HardwareIntrinsics.X86
-{{
+{
     public static partial class Program
-    {{
-        private static void {2}{4}()
-        {{
-            var test = new BooleanTwoComparisonOpTest__{2}{4}();
+    {
+        private static void {Method}{RetBaseType}()
+        {
+            var test = new BooleanTwoComparisonOpTest__{Method}{RetBaseType}();
 
             if (test.IsSupported)
-            {{
+            {
                 // Validates basic functionality works, using Unsafe.Read
                 test.RunBasicScenario_UnsafeRead();
 
-                if ({1}.IsSupported)
-                {{
+                if ({LoadIsa}.IsSupported)
+                {
                     // Validates basic functionality works, using Load
                     test.RunBasicScenario_Load();
 
                     // Validates basic functionality works, using LoadAligned
                     test.RunBasicScenario_LoadAligned();
-                }}
+                }
 
                 // Validates calling via reflection works, using Unsafe.Read
                 test.RunReflectionScenario_UnsafeRead();
 
-                if ({1}.IsSupported)
-                {{
+                if ({LoadIsa}.IsSupported)
+                {
                     // Validates calling via reflection works, using Load
                     test.RunReflectionScenario_Load();
 
                     // Validates calling via reflection works, using LoadAligned
                     test.RunReflectionScenario_LoadAligned();
-                }}
+                }
 
                 // Validates passing a static member works
                 test.RunClsVarScenario();
@@ -55,270 +55,270 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates passing a local works, using Unsafe.Read
                 test.RunLclVarScenario_UnsafeRead();
 
-                if ({1}.IsSupported)
-                {{
+                if ({LoadIsa}.IsSupported)
+                {
                     // Validates passing a local works, using Load
                     test.RunLclVarScenario_Load();
 
                     // Validates passing a local works, using LoadAligned
                     test.RunLclVarScenario_LoadAligned();
-                }}
+                }
 
                 // Validates passing the field of a local works
                 test.RunLclFldScenario();
 
                 // Validates passing an instance member works
                 test.RunFldScenario();
-            }}
+            }
             else
-            {{
+            {
                 // Validates we throw on unsupported hardware
                 test.RunUnsupportedScenario();
-            }}
+            }
 
             if (!test.Succeeded)
-            {{
+            {
                 throw new Exception("One or more scenarios did not complete as expected.");
-            }}
-        }}
-    }}
+            }
+        }
+    }
 
-    public sealed unsafe class BooleanTwoComparisonOpTest__{2}{4}
-    {{
-        private const int VectorSize = {9};
+    public sealed unsafe class BooleanTwoComparisonOpTest__{Method}{RetBaseType}
+    {
+        private const int VectorSize = {VectorSize};
 
-        private const int Op1ElementCount = VectorSize / sizeof({6});
-        private const int Op2ElementCount = VectorSize / sizeof({8});
+        private const int Op1ElementCount = VectorSize / sizeof({Op1BaseType});
+        private const int Op2ElementCount = VectorSize / sizeof({Op2BaseType});
 
-        private static {6}[] _data1 = new {6}[Op1ElementCount];
-        private static {8}[] _data2 = new {8}[Op2ElementCount];
+        private static {Op1BaseType}[] _data1 = new {Op1BaseType}[Op1ElementCount];
+        private static {Op2BaseType}[] _data2 = new {Op2BaseType}[Op2ElementCount];
 
-        private static {5}<{6}> _clsVar1;
-        private static {7}<{8}> _clsVar2;
+        private static {Op1VectorType}<{Op1BaseType}> _clsVar1;
+        private static {Op2VectorType}<{Op2BaseType}> _clsVar2;
 
-        private {5}<{6}> _fld1;
-        private {7}<{8}> _fld2;
+        private {Op1VectorType}<{Op1BaseType}> _fld1;
+        private {Op2VectorType}<{Op2BaseType}> _fld2;
 
-        private BooleanTwoComparisonOpTest__DataTable<{6}, {8}> _dataTable;
+        private BooleanTwoComparisonOpTest__DataTable<{Op1BaseType}, {Op2BaseType}> _dataTable;
 
-        static BooleanTwoComparisonOpTest__{2}{4}()
-        {{
+        static BooleanTwoComparisonOpTest__{Method}{RetBaseType}()
+        {
             var random = new Random();
 
-            for (var i = 0; i < Op1ElementCount; i++) {{ _data1[i] = {10}; }}
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{5}<{6}>, byte>(ref _clsVar1), ref Unsafe.As<{6}, byte>(ref _data1[0]), VectorSize);
-            for (var i = 0; i < Op2ElementCount; i++) {{ _data2[i] = {11}; }}
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{7}<{8}>, byte>(ref _clsVar2), ref Unsafe.As<{8}, byte>(ref _data2[0]), VectorSize);
-        }}
+            for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; }
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), VectorSize);
+            for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = {NextValueOp2}; }
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref _clsVar2), ref Unsafe.As<{Op2BaseType}, byte>(ref _data2[0]), VectorSize);
+        }
 
-        public BooleanTwoComparisonOpTest__{2}{4}()
-        {{
+        public BooleanTwoComparisonOpTest__{Method}{RetBaseType}()
+        {
             Succeeded = true;
 
             var random = new Random();
 
-            for (var i = 0; i < Op1ElementCount; i++) {{ _data1[i] = {10}; }}
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{5}<{6}>, byte>(ref _fld1), ref Unsafe.As<{6}, byte>(ref _data1[0]), VectorSize);
-            for (var i = 0; i < Op2ElementCount; i++) {{ _data2[i] = {11}; }}
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{7}<{8}>, byte>(ref _fld2), ref Unsafe.As<{8}, byte>(ref _data2[0]), VectorSize);
+            for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; }
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _fld1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), VectorSize);
+            for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = {NextValueOp2}; }
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref _fld2), ref Unsafe.As<{Op2BaseType}, byte>(ref _data2[0]), VectorSize);
 
-            for (var i = 0; i < Op1ElementCount; i++) {{ _data1[i] = {10}; }}
-            for (var i = 0; i < Op2ElementCount; i++) {{ _data2[i] = {11}; }}
-            _dataTable = new BooleanTwoComparisonOpTest__DataTable<{6}, {8}>(_data1, _data2, VectorSize);
-        }}
+            for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; }
+            for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = {NextValueOp2}; }
+            _dataTable = new BooleanTwoComparisonOpTest__DataTable<{Op1BaseType}, {Op2BaseType}>(_data1, _data2, VectorSize);
+        }
 
-        public bool IsSupported => {0}.IsSupported;
+        public bool IsSupported => {Isa}.IsSupported;
 
-        public bool Succeeded {{ get; set; }}
+        public bool Succeeded { get; set; }
 
         public void RunBasicScenario_UnsafeRead()
-        {{
-            var result = {0}.{2}(
-                Unsafe.Read<{5}<{6}>>(_dataTable.inArray1Ptr),
-                Unsafe.Read<{7}<{8}>>(_dataTable.inArray2Ptr)
+        {
+            var result = {Isa}.{Method}(
+                Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArray1Ptr),
+                Unsafe.Read<{Op2VectorType}<{Op2BaseType}>>(_dataTable.inArray2Ptr)
             );
 
             ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, result);
-        }}
+        }
 
         public void RunBasicScenario_Load()
-        {{
-            var result = {0}.{2}(
-                {1}.Load{5}(({6}*)(_dataTable.inArray1Ptr)),
-                {1}.Load{7}(({8}*)(_dataTable.inArray2Ptr))
+        {
+            var result = {Isa}.{Method}(
+                {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)),
+                {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr))
             );
 
             ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, result);
-        }}
+        }
 
         public void RunBasicScenario_LoadAligned()
-        {{
-            var result = {0}.{2}(
-                {1}.LoadAligned{5}(({6}*)(_dataTable.inArray1Ptr)),
-                {1}.LoadAligned{7}(({8}*)(_dataTable.inArray2Ptr))
+        {
+            var result = {Isa}.{Method}(
+                {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)),
+                {LoadIsa}.LoadAligned{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr))
             );
 
             ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, result);
-        }}
+        }
 
         public void RunReflectionScenario_UnsafeRead()
-        {{
-            var method = typeof({0}).GetMethod(nameof({0}.{2}), new Type[] {{ typeof({5}<{6}>), typeof({7}<{8}>) }});
+        {
+            var method = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof({Op2VectorType}<{Op2BaseType}>) });
             
             if (method != null)
-            {{
-                var result = method.Invoke(null, new object[] {{
-                                        Unsafe.Read<{5}<{6}>>(_dataTable.inArray1Ptr),
-                                        Unsafe.Read<{7}<{8}>>(_dataTable.inArray2Ptr)
-                                     }});
+            {
+                var result = method.Invoke(null, new object[] {
+                                        Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArray1Ptr),
+                                        Unsafe.Read<{Op2VectorType}<{Op2BaseType}>>(_dataTable.inArray2Ptr)
+                                     });
 
                 ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, (bool)(result));
-            }}
-        }}
+            }
+        }
 
         public void RunReflectionScenario_Load()
-        {{
-            var method = typeof({0}).GetMethod(nameof({0}.{2}), new Type[] {{ typeof({5}<{6}>), typeof({7}<{8}>) }});
+        {
+            var method = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof({Op2VectorType}<{Op2BaseType}>) });
             
             if (method != null)
-            {{
-                var result = method.Invoke(null, new object[] {{
-                                        {1}.Load{5}(({6}*)(_dataTable.inArray1Ptr)),
-                                        {1}.Load{7}(({8}*)(_dataTable.inArray2Ptr))
-                                     }});
+            {
+                var result = method.Invoke(null, new object[] {
+                                        {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)),
+                                        {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr))
+                                     });
 
                 ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, (bool)(result));
-            }}
-        }}
+            }
+        }
 
         public void RunReflectionScenario_LoadAligned()
-        {{var method = typeof({0}).GetMethod(nameof({0}.{2}), new Type[] {{ typeof({5}<{6}>), typeof({7}<{8}>) }});
+        {var method = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof({Op2VectorType}<{Op2BaseType}>) });
             
             if (method != null)
-            {{
-                var result = method.Invoke(null, new object[] {{
-                                        {1}.LoadAligned{5}(({6}*)(_dataTable.inArray1Ptr)),
-                                        {1}.LoadAligned{7}(({8}*)(_dataTable.inArray2Ptr))
-                                     }});
+            {
+                var result = method.Invoke(null, new object[] {
+                                        {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)),
+                                        {LoadIsa}.LoadAligned{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr))
+                                     });
 
                 ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, (bool)(result));
-            }}
-        }}
+            }
+        }
 
         public void RunClsVarScenario()
-        {{
-            var result = {0}.{2}(
+        {
+            var result = {Isa}.{Method}(
                 _clsVar1,
                 _clsVar2
             );
 
             ValidateResult(_clsVar1, _clsVar2, result);
-        }}
+        }
 
         public void RunLclVarScenario_UnsafeRead()
-        {{
-            var left = Unsafe.Read<{5}<{6}>>(_dataTable.inArray1Ptr);
-            var right = Unsafe.Read<{7}<{8}>>(_dataTable.inArray2Ptr);
-            var result = {0}.{2}(left, right);
+        {
+            var left = Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArray1Ptr);
+            var right = Unsafe.Read<{Op2VectorType}<{Op2BaseType}>>(_dataTable.inArray2Ptr);
+            var result = {Isa}.{Method}(left, right);
 
             ValidateResult(left, right, result);
-        }}
+        }
 
         public void RunLclVarScenario_Load()
-        {{
-            var left = {1}.Load{5}(({6}*)(_dataTable.inArray1Ptr));
-            var right = {1}.Load{7}(({8}*)(_dataTable.inArray2Ptr));
-            var result = {0}.{2}(left, right);
+        {
+            var left = {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr));
+            var right = {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr));
+            var result = {Isa}.{Method}(left, right);
 
             ValidateResult(left, right, result);
-        }}
+        }
 
         public void RunLclVarScenario_LoadAligned()
-        {{
-            var left = {1}.LoadAligned{5}(({6}*)(_dataTable.inArray1Ptr));
-            var right = {1}.LoadAligned{7}(({8}*)(_dataTable.inArray2Ptr));
-            var result = {0}.{2}(left, right);
+        {
+            var left = {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr));
+            var right = {LoadIsa}.LoadAligned{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr));
+            var result = {Isa}.{Method}(left, right);
 
             ValidateResult(left, right, result);
-        }}
+        }
 
         public void RunLclFldScenario()
-        {{
-            var test = new BooleanTwoComparisonOpTest__{2}{4}();
-            var result = {0}.{2}(test._fld1, test._fld2);
+        {
+            var test = new BooleanTwoComparisonOpTest__{Method}{RetBaseType}();
+            var result = {Isa}.{Method}(test._fld1, test._fld2);
 
             ValidateResult(test._fld1, test._fld2, result);
-        }}
+        }
 
         public void RunFldScenario()
-        {{
-            var result = {0}.{2}(_fld1, _fld2);
+        {
+            var result = {Isa}.{Method}(_fld1, _fld2);
 
             ValidateResult(_fld1, _fld2, result);
-        }}
+        }
 
         public void RunUnsupportedScenario()
-        {{
+        {
             Succeeded = false;
 
             try
-            {{
+            {
                 RunBasicScenario_UnsafeRead();
-            }}
+            }
             catch (PlatformNotSupportedException)
-            {{
+            {
                 Succeeded = true;
-            }}
-        }}
+            }
+        }
 
-        private void ValidateResult({5}<{6}> left, {7}<{8}> right, bool result, [CallerMemberName] string method = "")
-        {{
-            {6}[] inArray1 = new {6}[Op1ElementCount];
-            {8}[] inArray2 = new {8}[Op2ElementCount];
+        private void ValidateResult({Op1VectorType}<{Op1BaseType}> left, {Op2VectorType}<{Op2BaseType}> right, bool result, [CallerMemberName] string method = "")
+        {
+            {Op1BaseType}[] inArray1 = new {Op1BaseType}[Op1ElementCount];
+            {Op2BaseType}[] inArray2 = new {Op2BaseType}[Op2ElementCount];
 
             Unsafe.Write(Unsafe.AsPointer(ref inArray1[0]), left);
             Unsafe.Write(Unsafe.AsPointer(ref inArray2[0]), right);
 
             ValidateResult(inArray1, inArray2, result, method);
-        }}
+        }
 
         private void ValidateResult(void* left, void* right, bool result, [CallerMemberName] string method = "")
-        {{
-            {6}[] inArray1 = new {6}[Op1ElementCount];
-            {8}[] inArray2 = new {8}[Op2ElementCount];
+        {
+            {Op1BaseType}[] inArray1 = new {Op1BaseType}[Op1ElementCount];
+            {Op2BaseType}[] inArray2 = new {Op2BaseType}[Op2ElementCount];
 
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{6}, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(left), VectorSize);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{8}, byte>(ref inArray2[0]), ref Unsafe.AsRef<byte>(right), VectorSize);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1BaseType}, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(left), VectorSize);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2BaseType}, byte>(ref inArray2[0]), ref Unsafe.AsRef<byte>(right), VectorSize);
 
             ValidateResult(inArray1, inArray2, result, method);
-        }}
+        }
 
-        private void ValidateResult({6}[] left, {8}[] right, bool result, [CallerMemberName] string method = "")
-        {{
+        private void ValidateResult({Op1BaseType}[] left, {Op2BaseType}[] right, bool result, [CallerMemberName] string method = "")
+        {
             var expectedResult1 = true;
 
             for (var i = 0; i < Op1ElementCount; i++)
-            {{
-                expectedResult1 &= ({12});
-            }}
+            {
+                expectedResult1 &= ({ValidateFirstResult});
+            }
 
             var expectedResult2 = true;
 
             for (var i = 0; i < Op1ElementCount; i++)
-            {{
-                expectedResult2 &= ({13});
-            }}
+            {
+                expectedResult2 &= ({ValidateRemainingResults});
+            }
 
             if (((expectedResult1 == false) && (expectedResult2 == false)) != result)
-            {{
+            {
                 Succeeded = false;
 
-                Console.WriteLine($"{{nameof({0})}}.{{nameof({0}.{2})}}<{4}>({5}<{6}>, {7}<{8}>): {{method}} failed:");
-                Console.WriteLine($"    left: ({{string.Join(", ", left)}})");
-                Console.WriteLine($"   right: ({{string.Join(", ", right)}})");
-                Console.WriteLine($"  result: ({{string.Join(", ", result)}})");
+                Console.WriteLine($"{nameof({Isa})}.{nameof({Isa}.{Method})}<{RetBaseType}>({Op1VectorType}<{Op1BaseType}>, {Op2VectorType}<{Op2BaseType}>): {method} failed:");
+                Console.WriteLine($"    left: ({string.Join(", ", left)})");
+                Console.WriteLine($"   right: ({string.Join(", ", right)})");
+                Console.WriteLine($"  result: ({string.Join(", ", result)})");
                 Console.WriteLine();
-            }}
-        }}
-    }}
-}}
+            }
+        }
+    }
+}
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanUnOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanUnOpTest.template
index 21623a5bbb..422c4603ac 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanUnOpTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanUnOpTest.template
@@ -17,38 +17,38 @@ using System.Runtime.Intrinsics;
 using System.Runtime.Intrinsics.X86;
 
 namespace JIT.HardwareIntrinsics.X86
-{{
+{
     public static partial class Program
-    {{
-        private static void {2}{4}()
-        {{
-            var test = new BooleanComparisonOpTest__{2}{4}();
+    {
+        private static void {Method}{RetBaseType}()
+        {
+            var test = new BooleanComparisonOpTest__{Method}{RetBaseType}();
 
             if (test.IsSupported)
-            {{
+            {
                 // Validates basic functionality works, using Unsafe.Read
                 test.RunBasicScenario_UnsafeRead();
 
-                if ({1}.IsSupported)
-                {{
+                if ({LoadIsa}.IsSupported)
+                {
                     // Validates basic functionality works, using Load
                     test.RunBasicScenario_Load();
 
                     // Validates basic functionality works, using LoadAligned
                     test.RunBasicScenario_LoadAligned();
-                }}
+                }
 
                 // Validates calling via reflection works, using Unsafe.Read
                 test.RunReflectionScenario_UnsafeRead();
 
-                if ({1}.IsSupported)
-                {{
+                if ({LoadIsa}.IsSupported)
+                {
                     // Validates calling via reflection works, using Load
                     test.RunReflectionScenario_Load();
 
                     // Validates calling via reflection works, using LoadAligned
                     test.RunReflectionScenario_LoadAligned();
-                }}
+                }
 
                 // Validates passing a static member works
                 test.RunClsVarScenario();
@@ -56,228 +56,228 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates passing a local works, using Unsafe.Read
                 test.RunLclVarScenario_UnsafeRead();
 
-                if ({1}.IsSupported)
-                {{
+                if ({LoadIsa}.IsSupported)
+                {
                     // Validates passing a local works, using Load
                     test.RunLclVarScenario_Load();
 
                     // Validates passing a local works, using LoadAligned
                     test.RunLclVarScenario_LoadAligned();
-                }}
+                }
 
                 // Validates passing the field of a local works
                 test.RunLclFldScenario();
 
                 // Validates passing an instance member works
                 test.RunFldScenario();
-            }}
+            }
             else
-            {{
+            {
                 // Validates we throw on unsupported hardware
                 test.RunUnsupportedScenario();
-            }}
+            }
 
             if (!test.Succeeded)
-            {{
+            {
                 throw new Exception("One or more scenarios did not complete as expected.");
-            }}
-        }}
-    }}
+            }
+        }
+    }
 
-    public sealed unsafe class BooleanComparisonOpTest__{2}{4}
-    {{
-        private const int VectorSize = {7};
+    public sealed unsafe class BooleanComparisonOpTest__{Method}{RetBaseType}
+    {
+        private const int VectorSize = {VectorSize};
 
-        private const int Op1ElementCount = VectorSize / sizeof({6});
+        private const int Op1ElementCount = VectorSize / sizeof({Op1BaseType});
 
-        private static {6}[] _data = new {6}[Op1ElementCount];
+        private static {Op1BaseType}[] _data = new {Op1BaseType}[Op1ElementCount];
 
-        private static {5}<{6}> _clsVar;
+        private static {Op1VectorType}<{Op1BaseType}> _clsVar;
 
-        private {5}<{6}> _fld;
+        private {Op1VectorType}<{Op1BaseType}> _fld;
 
-        private BooleanUnaryOpTest__DataTable<{6}> _dataTable;
+        private BooleanUnaryOpTest__DataTable<{Op1BaseType}> _dataTable;
 
-        static BooleanComparisonOpTest__{2}{4}()
-        {{
+        static BooleanComparisonOpTest__{Method}{RetBaseType}()
+        {
             var random = new Random();
 
-            for (var i = 0; i < Op1ElementCount; i++) {{ _data[i] = {8}; }}
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{5}<{6}>, byte>(ref _clsVar), ref Unsafe.As<{6}, byte>(ref _data[0]), VectorSize);
-        }}
+            for (var i = 0; i < Op1ElementCount; i++) { _data[i] = {NextValueOp1}; }
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar), ref Unsafe.As<{Op1BaseType}, byte>(ref _data[0]), VectorSize);
+        }
 
-        public BooleanComparisonOpTest__{2}{4}()
-        {{
+        public BooleanComparisonOpTest__{Method}{RetBaseType}()
+        {
             Succeeded = true;
 
             var random = new Random();
 
-            for (var i = 0; i < Op1ElementCount; i++) {{ _data[i] = {8}; }}
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{5}<{6}>, byte>(ref _fld), ref Unsafe.As<{6}, byte>(ref _data[0]), VectorSize);
+            for (var i = 0; i < Op1ElementCount; i++) { _data[i] = {NextValueOp1}; }
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _fld), ref Unsafe.As<{Op1BaseType}, byte>(ref _data[0]), VectorSize);
 
-            for (var i = 0; i < Op1ElementCount; i++) {{ _data[i] = {8}; }}
-            _dataTable = new BooleanUnaryOpTest__DataTable<{6}>(_data, VectorSize);
-        }}
+            for (var i = 0; i < Op1ElementCount; i++) { _data[i] = {NextValueOp1}; }
+            _dataTable = new BooleanUnaryOpTest__DataTable<{Op1BaseType}>(_data, VectorSize);
+        }
 
-        public bool IsSupported => {0}.IsSupported;
+        public bool IsSupported => {Isa}.IsSupported;
 
-        public bool Succeeded {{ get; set; }}
+        public bool Succeeded { get; set; }
 
         public void RunBasicScenario_UnsafeRead()
-        {{
-            var result = {0}.{2}(
-                Unsafe.Read<{5}<{6}>>(_dataTable.inArrayPtr)
+        {
+            var result = {Isa}.{Method}(
+                Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArrayPtr)
             );
 
             ValidateResult(_dataTable.inArrayPtr, result);
-        }}
+        }
 
         public void RunBasicScenario_Load()
-        {{
-            var result = {0}.{2}(
-                {1}.Load{5}(({6}*)(_dataTable.inArrayPtr))
+        {
+            var result = {Isa}.{Method}(
+                {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr))
             );
 
             ValidateResult(_dataTable.inArrayPtr, result);
-        }}
+        }
 
         public void RunBasicScenario_LoadAligned()
-        {{
-            var result = {0}.{2}(
-                {1}.LoadAligned{5}(({6}*)(_dataTable.inArrayPtr))
+        {
+            var result = {Isa}.{Method}(
+                {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr))
             );
 
             ValidateResult(_dataTable.inArrayPtr, result);
-        }}
+        }
 
         public void RunReflectionScenario_UnsafeRead()
-        {{
-            var result = typeof({0}).GetMethod(nameof({0}.{2}), new Type[] {{ typeof({5}<{6}>) }})
-                                     .Invoke(null, new object[] {{
-                                        Unsafe.Read<{5}<{6}>>(_dataTable.inArrayPtr)
-                                     }});
+        {
+            var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>) })
+                                     .Invoke(null, new object[] {
+                                        Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArrayPtr)
+                                     });
 
             ValidateResult(_dataTable.inArrayPtr, (bool)(result));
-        }}
+        }
 
         public void RunReflectionScenario_Load()
-        {{
-            var result = typeof({0}).GetMethod(nameof({0}.{2}), new Type[] {{ typeof({5}<{6}>) }})
-                                     .Invoke(null, new object[] {{
-                                        {1}.Load{5}(({6}*)(_dataTable.inArrayPtr))
-                                     }});
+        {
+            var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>) })
+                                     .Invoke(null, new object[] {
+                                        {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr))
+                                     });
 
             ValidateResult(_dataTable.inArrayPtr, (bool)(result));
-        }}
+        }
 
         public void RunReflectionScenario_LoadAligned()
-        {{
-            var result = typeof({0}).GetMethod(nameof({0}.{2}), new Type[] {{ typeof({5}<{6}>) }})
-                                     .Invoke(null, new object[] {{
-                                        {1}.LoadAligned{5}(({6}*)(_dataTable.inArrayPtr))
-                                     }});
+        {
+            var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>) })
+                                     .Invoke(null, new object[] {
+                                        {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr))
+                                     });
 
             ValidateResult(_dataTable.inArrayPtr, (bool)(result));
-        }}
+        }
 
         public void RunClsVarScenario()
-        {{
-            var result = {0}.{2}(
+        {
+            var result = {Isa}.{Method}(
                 _clsVar
             );
 
             ValidateResult(_clsVar, result);
-        }}
+        }
 
         public void RunLclVarScenario_UnsafeRead()
-        {{
-            var value = Unsafe.Read<{5}<{6}>>(_dataTable.inArrayPtr);
-            var result = {0}.{2}(value);
+        {
+            var value = Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArrayPtr);
+            var result = {Isa}.{Method}(value);
 
             ValidateResult(value, result);
-        }}
+        }
 
         public void RunLclVarScenario_Load()
-        {{
-            var value = {1}.Load{5}(({6}*)(_dataTable.inArrayPtr));
-            var result = {0}.{2}(value);
+        {
+            var value = {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr));
+            var result = {Isa}.{Method}(value);
 
             ValidateResult(value, result);
-        }}
+        }
 
         public void RunLclVarScenario_LoadAligned()
-        {{
-            var value = {1}.LoadAligned{5}(({6}*)(_dataTable.inArrayPtr));
-            var result = {0}.{2}(value);
+        {
+            var value = {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr));
+            var result = {Isa}.{Method}(value);
 
             ValidateResult(value, result);
-        }}
+        }
 
         public void RunLclFldScenario()
-        {{
-            var test = new BooleanComparisonOpTest__{2}{4}();
-            var result = {0}.{2}(test._fld);
+        {
+            var test = new BooleanComparisonOpTest__{Method}{RetBaseType}();
+            var result = {Isa}.{Method}(test._fld);
 
             ValidateResult(test._fld, result);
-        }}
+        }
 
         public void RunFldScenario()
-        {{
-            var result = {0}.{2}(_fld);
+        {
+            var result = {Isa}.{Method}(_fld);
 
             ValidateResult(_fld, result);
-        }}
+        }
 
         public void RunUnsupportedScenario()
-        {{
+        {
             Succeeded = false;
 
             try
-            {{
+            {
                 RunBasicScenario_UnsafeRead();
-            }}
+            }
             catch (PlatformNotSupportedException)
-            {{
+            {
                 Succeeded = true;
-            }}
-        }}
+            }
+        }
 
-        private void ValidateResult({5}<{6}> value, bool result, [CallerMemberName] string method = "")
-        {{
-            {6}[] inArray = new {6}[Op1ElementCount];
+        private void ValidateResult({Op1VectorType}<{Op1BaseType}> value, bool result, [CallerMemberName] string method = "")
+        {
+            {Op1BaseType}[] inArray = new {Op1BaseType}[Op1ElementCount];
 
             Unsafe.Write(Unsafe.AsPointer(ref inArray[0]), value);
 
             ValidateResult(inArray, result, method);
-        }}
+        }
 
         private void ValidateResult(void* value, bool result, [CallerMemberName] string method = "")
-        {{
-            {6}[] inArray = new {6}[Op1ElementCount];
+        {
+            {Op1BaseType}[] inArray = new {Op1BaseType}[Op1ElementCount];
 
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{6}, byte>(ref inArray[0]), ref Unsafe.AsRef<byte>(value), VectorSize);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1BaseType}, byte>(ref inArray[0]), ref Unsafe.AsRef<byte>(value), VectorSize);
 
             ValidateResult(inArray, result, method);
-        }}
+        }
 
-        private void ValidateResult({6}[] value, bool result, [CallerMemberName] string method = "")
-        {{
+        private void ValidateResult({Op1BaseType}[] value, bool result, [CallerMemberName] string method = "")
+        {
             var expectedResult = true;
 
             for (var i = 0; i < Op1ElementCount; i++)
-            {{
-                expectedResult &= ({9});
-            }}
+            {
+                expectedResult &= ({ValidateFirstResult});
+            }
 
             if (expectedResult != result)
-            {{
+            {
                 Succeeded = false;
 
-                Console.WriteLine($"{{nameof({0})}}.{{nameof({0}.{2})}}<{4}>({5}<{6}>): {{method}} failed:");
-                Console.WriteLine($"    value: ({{string.Join(", ", value)}})");
-                Console.WriteLine($"  result: ({{string.Join(", ", result)}})");
+                Console.WriteLine($"{nameof({Isa})}.{nameof({Isa}.{Method})}<{RetBaseType}>({Op1VectorType}<{Op1BaseType}>): {method} failed:");
+                Console.WriteLine($"    value: ({string.Join(", ", value)})");
+                Console.WriteLine($"  result: ({string.Join(", ", result)})");
                 Console.WriteLine();
-            }}
-        }}
-    }}
-}}
+            }
+        }
+    }
+}
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/ExtractScalarTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/ExtractScalarTest.template
index fae1d35fb1..0fb09bb987 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/ExtractScalarTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/ExtractScalarTest.template
@@ -16,40 +16,40 @@ using System.Runtime.Intrinsics;
 using System.Runtime.Intrinsics.X86;
 
 namespace JIT.HardwareIntrinsics.X86
-{{
+{
     public static partial class Program
-    {{
-        private static void {2}{4}{7}()
-        {{
-            var test = new SimpleUnaryOpTest__{2}{4}{7}();
+    {
+        private static void {Method}{RetBaseType}{Imm}()
+        {
+            var test = new SimpleUnaryOpTest__{Method}{RetBaseType}{Imm}();
             
             try
-            {{
+            {
             if (test.IsSupported)
-            {{
+            {
                 // Validates basic functionality works, using Unsafe.Read
                 test.RunBasicScenario_UnsafeRead();
 
-                if ({1}.IsSupported)
-                {{
+                if ({LoadIsa}.IsSupported)
+                {
                     // Validates basic functionality works, using Load
                     test.RunBasicScenario_Load();
 
                     // Validates basic functionality works, using LoadAligned
                     test.RunBasicScenario_LoadAligned();
-                }}
+                }
 
                 // Validates calling via reflection works, using Unsafe.Read
                 test.RunReflectionScenario_UnsafeRead();
 
-                if ({1}.IsSupported)
-                {{
+                if ({LoadIsa}.IsSupported)
+                {
                     // Validates calling via reflection works, using Load
                     test.RunReflectionScenario_Load();
 
                     // Validates calling via reflection works, using LoadAligned
                     test.RunReflectionScenario_LoadAligned();
-                }}
+                }
 
                 // Validates passing a static member works
                 test.RunClsVarScenario();
@@ -57,253 +57,253 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates passing a local works, using Unsafe.Read
                 test.RunLclVarScenario_UnsafeRead();
 
-                if ({1}.IsSupported)
-                {{
+                if ({LoadIsa}.IsSupported)
+                {
                     // Validates passing a local works, using Load
                     test.RunLclVarScenario_Load();
 
                     // Validates passing a local works, using LoadAligned
                     test.RunLclVarScenario_LoadAligned();
-                }}
+                }
 
                 // Validates passing the field of a local works
                 test.RunLclFldScenario();
 
                 // Validates passing an instance member works
                 test.RunFldScenario();
-            }}
+            }
             else
-            {{
+            {
                 // Validates we throw on unsupported hardware
                 test.RunUnsupportedScenario();
-            }}
-            }}
+            }
+            }
             catch (PlatformNotSupportedException)
-            {{
+            {
                 test.Succeeded = true;
-            }}
+            }
 
             if (!test.Succeeded)
-            {{
+            {
                 throw new Exception("One or more scenarios did not complete as expected.");
-            }}
-        }}
-    }}
+            }
+        }
+    }
 
-    public sealed unsafe class SimpleUnaryOpTest__{2}{4}{7}
-    {{
-        private const int VectorSize = {8};
+    public sealed unsafe class SimpleUnaryOpTest__{Method}{RetBaseType}{Imm}
+    {
+        private const int VectorSize = {VectorSize};
 
-        private const int Op1ElementCount = VectorSize / sizeof({6});
-        private const int RetElementCount = VectorSize / sizeof({4});
+        private const int Op1ElementCount = VectorSize / sizeof({Op1BaseType});
+        private const int RetElementCount = VectorSize / sizeof({RetBaseType});
 
-        private static {6}[] _data = new {6}[Op1ElementCount];
+        private static {Op1BaseType}[] _data = new {Op1BaseType}[Op1ElementCount];
 
-        private static {5}<{6}> _clsVar;
+        private static {Op1VectorType}<{Op1BaseType}> _clsVar;
 
-        private {5}<{6}> _fld;
+        private {Op1VectorType}<{Op1BaseType}> _fld;
 
-        private SimpleUnaryOpTest__DataTable<{4}, {6}> _dataTable;
+        private SimpleUnaryOpTest__DataTable<{RetBaseType}, {Op1BaseType}> _dataTable;
 
-        static SimpleUnaryOpTest__{2}{4}{7}()
-        {{
+        static SimpleUnaryOpTest__{Method}{RetBaseType}{Imm}()
+        {
             var random = new Random();
 
-            for (var i = 0; i < Op1ElementCount; i++) {{ _data[i] = {9}; }}
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{5}<{6}>, byte>(ref _clsVar), ref Unsafe.As<{6}, byte>(ref _data[0]), VectorSize);
-        }}
+            for (var i = 0; i < Op1ElementCount; i++) { _data[i] = {NextValueOp1}; }
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar), ref Unsafe.As<{Op1BaseType}, byte>(ref _data[0]), VectorSize);
+        }
 
-        public SimpleUnaryOpTest__{2}{4}{7}()
-        {{
+        public SimpleUnaryOpTest__{Method}{RetBaseType}{Imm}()
+        {
             Succeeded = true;
 
             var random = new Random();
 
-            for (var i = 0; i < Op1ElementCount; i++) {{ _data[i] = {9}; }}
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{5}<{6}>, byte>(ref _fld), ref Unsafe.As<{6}, byte>(ref _data[0]), VectorSize);
+            for (var i = 0; i < Op1ElementCount; i++) { _data[i] = {NextValueOp1}; }
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _fld), ref Unsafe.As<{Op1BaseType}, byte>(ref _data[0]), VectorSize);
 
-            for (var i = 0; i < Op1ElementCount; i++) {{ _data[i] = {9}; }}
-            _dataTable = new SimpleUnaryOpTest__DataTable<{4}, {6}>(_data, new {4}[RetElementCount], VectorSize);
-        }}
+            for (var i = 0; i < Op1ElementCount; i++) { _data[i] = {NextValueOp1}; }
+            _dataTable = new SimpleUnaryOpTest__DataTable<{RetBaseType}, {Op1BaseType}>(_data, new {RetBaseType}[RetElementCount], VectorSize);
+        }
 
-        public bool IsSupported => {0}.IsSupported;
+        public bool IsSupported => {Isa}.IsSupported;
 
-        public bool Succeeded {{ get; set; }}
+        public bool Succeeded { get; set; }
 
         public void RunBasicScenario_UnsafeRead()
-        {{
-            var result = {0}.{2}(
-                Unsafe.Read<{5}<{6}>>(_dataTable.inArrayPtr),
-                {7}
+        {
+            var result = {Isa}.{Method}(
+                Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArrayPtr),
+                {Imm}
             );
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunBasicScenario_Load()
-        {{
-            var result = {0}.{2}(
-                {1}.Load{5}(({6}*)(_dataTable.inArrayPtr)),
-                {7}
+        {
+            var result = {Isa}.{Method}(
+                {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)),
+                {Imm}
             );
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunBasicScenario_LoadAligned()
-        {{
-            var result = {0}.{2}(
-                {1}.LoadAligned{5}(({6}*)(_dataTable.inArrayPtr)),
-                {7}
+        {
+            var result = {Isa}.{Method}(
+                {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)),
+                {Imm}
             );
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunReflectionScenario_UnsafeRead()
-        {{
-            var result = typeof({0}).GetMethod(nameof({0}.{2}), new Type[] {{ typeof({5}<{6}>), typeof(byte) }})
-                                     .Invoke(null, new object[] {{
-                                        Unsafe.Read<{5}<{6}>>(_dataTable.inArrayPtr),
-                                        (byte){7}
-                                     }});
-
-            Unsafe.Write(_dataTable.outArrayPtr, ({4})(result));
+        {
+            var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof(byte) })
+                                     .Invoke(null, new object[] {
+                                        Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArrayPtr),
+                                        (byte){Imm}
+                                     });
+
+            Unsafe.Write(_dataTable.outArrayPtr, ({RetBaseType})(result));
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunReflectionScenario_Load()
-        {{
-            var result = typeof({0}).GetMethod(nameof({0}.{2}), new Type[] {{ typeof({5}<{6}>), typeof(byte) }})
-                                     .Invoke(null, new object[] {{
-                                        {1}.Load{5}(({6}*)(_dataTable.inArrayPtr)),
-                                        (byte){7}
-                                     }});
-
-            Unsafe.Write(_dataTable.outArrayPtr, ({4})(result));
+        {
+            var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof(byte) })
+                                     .Invoke(null, new object[] {
+                                        {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)),
+                                        (byte){Imm}
+                                     });
+
+            Unsafe.Write(_dataTable.outArrayPtr, ({RetBaseType})(result));
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunReflectionScenario_LoadAligned()
-        {{
-            var result = typeof({0}).GetMethod(nameof({0}.{2}), new Type[] {{ typeof({5}<{6}>), typeof(byte) }})
-                                     .Invoke(null, new object[] {{
-                                        {1}.LoadAligned{5}(({6}*)(_dataTable.inArrayPtr)),
-                                        (byte){7}
-                                     }});
-
-            Unsafe.Write(_dataTable.outArrayPtr, ({4})(result));
+        {
+            var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof(byte) })
+                                     .Invoke(null, new object[] {
+                                        {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)),
+                                        (byte){Imm}
+                                     });
+
+            Unsafe.Write(_dataTable.outArrayPtr, ({RetBaseType})(result));
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunClsVarScenario()
-        {{
-            var result = {0}.{2}(
+        {
+            var result = {Isa}.{Method}(
                 _clsVar,
-                {7}
+                {Imm}
             );
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(_clsVar, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunLclVarScenario_UnsafeRead()
-        {{
-            var firstOp = Unsafe.Read<{5}<{6}>>(_dataTable.inArrayPtr);
-            var result = {0}.{2}(firstOp, {7});
+        {
+            var firstOp = Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArrayPtr);
+            var result = {Isa}.{Method}(firstOp, {Imm});
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(firstOp, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunLclVarScenario_Load()
-        {{
-            var firstOp = {1}.Load{5}(({6}*)(_dataTable.inArrayPtr));
-            var result = {0}.{2}(firstOp, {7});
+        {
+            var firstOp = {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr));
+            var result = {Isa}.{Method}(firstOp, {Imm});
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(firstOp, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunLclVarScenario_LoadAligned()
-        {{
-            var firstOp = {1}.LoadAligned{5}(({6}*)(_dataTable.inArrayPtr));
-            var result = {0}.{2}(firstOp, {7});
+        {
+            var firstOp = {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr));
+            var result = {Isa}.{Method}(firstOp, {Imm});
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(firstOp, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunLclFldScenario()
-        {{
-            var test = new SimpleUnaryOpTest__{2}{4}{7}();
-            var result = {0}.{2}(test._fld, {7});
+        {
+            var test = new SimpleUnaryOpTest__{Method}{RetBaseType}{Imm}();
+            var result = {Isa}.{Method}(test._fld, {Imm});
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(test._fld, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunFldScenario()
-        {{
-            var result = {0}.{2}(_fld, {7});
+        {
+            var result = {Isa}.{Method}(_fld, {Imm});
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(_fld, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunUnsupportedScenario()
-        {{
+        {
             Succeeded = false;
 
             try
-            {{
+            {
                 RunBasicScenario_UnsafeRead();
-            }}
+            }
             catch (PlatformNotSupportedException)
-            {{
+            {
                 Succeeded = true;
-            }}
-        }}
+            }
+        }
 
-        private void ValidateResult({5}<{6}> firstOp, void* result, [CallerMemberName] string method = "")
-        {{
-            {6}[] inArray = new {6}[Op1ElementCount];
-            {4}[] outArray = new {4}[RetElementCount];
+        private void ValidateResult({Op1VectorType}<{Op1BaseType}> firstOp, void* result, [CallerMemberName] string method = "")
+        {
+            {Op1BaseType}[] inArray = new {Op1BaseType}[Op1ElementCount];
+            {RetBaseType}[] outArray = new {RetBaseType}[RetElementCount];
 
             Unsafe.Write(Unsafe.AsPointer(ref inArray[0]), firstOp);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{4}, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), VectorSize);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{RetBaseType}, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), VectorSize);
 
             ValidateResult(inArray, outArray, method);
-        }}
+        }
 
         private void ValidateResult(void* firstOp, void* result, [CallerMemberName] string method = "")
-        {{
-            {6}[] inArray = new {6}[Op1ElementCount];
-            {4}[] outArray = new {4}[RetElementCount];
+        {
+            {Op1BaseType}[] inArray = new {Op1BaseType}[Op1ElementCount];
+            {RetBaseType}[] outArray = new {RetBaseType}[RetElementCount];
 
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{6}, byte>(ref inArray[0]), ref Unsafe.AsRef<byte>(firstOp), VectorSize);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{4}, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), VectorSize);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1BaseType}, byte>(ref inArray[0]), ref Unsafe.AsRef<byte>(firstOp), VectorSize);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{RetBaseType}, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), VectorSize);
 
             ValidateResult(inArray, outArray, method);
-        }}
+        }
 
-        private void ValidateResult({6}[] firstOp, {4}[] result, [CallerMemberName] string method = "")
-        {{
-            if ({10})
-            {{
+        private void ValidateResult({Op1BaseType}[] firstOp, {RetBaseType}[] result, [CallerMemberName] string method = "")
+        {
+            if ({ValidateFirstResult})
+            {
                 Succeeded = false;
-            }}
+            }
 
             if (!Succeeded)
-            {{
-                Console.WriteLine($"{{nameof({0})}}.{{nameof({0}.{2})}}<{4}>({5}<{6}><9>): {{method}} failed:");
-                Console.WriteLine($"  firstOp: ({{string.Join(", ", firstOp)}})");
-                Console.WriteLine($"   result: ({{string.Join(", ", result)}})");
+            {
+                Console.WriteLine($"{nameof({Isa})}.{nameof({Isa}.{Method})}<{RetBaseType}>({Op1VectorType}<{Op1BaseType}><9>): {method} failed:");
+                Console.WriteLine($"  firstOp: ({string.Join(", ", firstOp)})");
+                Console.WriteLine($"   result: ({string.Join(", ", result)})");
                 Console.WriteLine();
-            }}
-        }}
-    }}
-}}
+            }
+        }
+    }
+}
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/GenerateTests.csx b/tests/src/JIT/HardwareIntrinsics/X86/Shared/GenerateTests.csx
index 65ab4e356e..40fdbea223 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/GenerateTests.csx
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/GenerateTests.csx
@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
+using System.Collections.Generic;
 using System.IO;
 
 // DIRECTIONS:
@@ -18,585 +19,564 @@ using System.IO;
 //    You can support a new Isa by creating a new array and adding a new
 //    "ProcessInputs" call at the bottom of the script.
 
-private static readonly (string templateFileName, string[] templateData)[] SseInputs = new []
+private static readonly (string templateFileName, Dictionary<string, string> templateData)[] SseInputs = new []
 {
-    // TemplateName                              Isa,   LoadIsa, Method,                                     RetVectorType RetBaseType, Op1VectorType, Op1BaseType,  Op2VectorType, Op2BaseType, Op3VectorType, Op3TBaseype, VectorSize, NextValueOp1,                   NextValueOp2,                   NextValueOp3, ValidateFirstResult,                                                                                                                  ValidateRemainingResults
-    ("SimpleBinOpTest.template",  new string[] { "Sse", "Sse",   "Add",                                      "Vector128",  "Single",    "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "BitConverter.SingleToInt32Bits(left[0] + right[0]) != BitConverter.SingleToInt32Bits(result[0])",                                    "BitConverter.SingleToInt32Bits(left[i] + right[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
-    ("SimpleBinOpTest.template",  new string[] { "Sse", "Sse",   "AddScalar",                                "Vector128",  "Single",    "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "BitConverter.SingleToInt32Bits(left[0] + right[0]) != BitConverter.SingleToInt32Bits(result[0])",                                    "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
-    ("SimpleBinOpTest.template",  new string[] { "Sse", "Sse",   "And",                                      "Vector128",  "Single",    "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "(BitConverter.SingleToInt32Bits(left[0]) & BitConverter.SingleToInt32Bits(right[0])) != BitConverter.SingleToInt32Bits(result[0])",  "(BitConverter.SingleToInt32Bits(left[0]) & BitConverter.SingleToInt32Bits(right[0])) != BitConverter.SingleToInt32Bits(result[0])"}),
-    ("SimpleBinOpTest.template",  new string[] { "Sse", "Sse",   "AndNot",                                   "Vector128",  "Single",    "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "(~BitConverter.SingleToInt32Bits(left[0]) & BitConverter.SingleToInt32Bits(right[0])) != BitConverter.SingleToInt32Bits(result[0])", "(~BitConverter.SingleToInt32Bits(left[0]) & BitConverter.SingleToInt32Bits(right[0])) != BitConverter.SingleToInt32Bits(result[0])"}),
-    ("SimpleBinOpTest.template",  new string[] { "Sse", "Sse",   "CompareEqual",                             "Vector128",  "Single",    "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "BitConverter.SingleToInt32Bits(result[0]) != ((left[0] == right[0]) ? -1 : 0)",                                                      "BitConverter.SingleToInt32Bits(result[i]) != ((left[i] == right[i]) ? -1 : 0)"}),
-    ("SimpleBinOpTest.template",  new string[] { "Sse", "Sse",   "CompareEqualScalar",                       "Vector128",  "Single",    "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "BitConverter.SingleToInt32Bits(result[0]) != ((left[0] == right[0]) ? -1 : 0)",                                                      "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
-    ("BooleanCmpOpTest.template", new string[] { "Sse", "Sse",   "CompareEqualOrderedScalar",                "Vector128",  "Boolean",   "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "(left[0] == right[0]) != result"}),
-    ("BooleanCmpOpTest.template", new string[] { "Sse", "Sse",   "CompareEqualUnorderedScalar",              "Vector128",  "Boolean",   "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "(left[0] == right[0]) != result"}),
-    ("SimpleBinOpTest.template",  new string[] { "Sse", "Sse",   "CompareGreaterThan",                       "Vector128",  "Single",    "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "BitConverter.SingleToInt32Bits(result[0]) != ((left[0] > right[0]) ? -1 : 0)",                                                       "BitConverter.SingleToInt32Bits(result[i]) != ((left[i] > right[i]) ? -1 : 0)"}),
-    ("SimpleBinOpTest.template",  new string[] { "Sse", "Sse",   "CompareGreaterThanScalar",                 "Vector128",  "Single",    "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "BitConverter.SingleToInt32Bits(result[0]) != ((left[0] > right[0]) ? -1 : 0)",                                                       "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
-    ("BooleanCmpOpTest.template", new string[] { "Sse", "Sse",   "CompareGreaterThanOrderedScalar",          "Vector128",  "Boolean",   "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "(left[0] > right[0]) != result"}),
-    ("BooleanCmpOpTest.template", new string[] { "Sse", "Sse",   "CompareGreaterThanUnorderedScalar",        "Vector128",  "Boolean",   "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "(left[0] > right[0]) != result"}),
-    ("SimpleBinOpTest.template",  new string[] { "Sse", "Sse",   "CompareGreaterThanOrEqual",                "Vector128",  "Single",    "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "BitConverter.SingleToInt32Bits(result[0]) != ((left[0] >= right[0]) ? -1 : 0)",                                                      "BitConverter.SingleToInt32Bits(result[i]) != ((left[i] >= right[i]) ? -1 : 0)"}),
-    ("SimpleBinOpTest.template",  new string[] { "Sse", "Sse",   "CompareGreaterThanOrEqualScalar",          "Vector128",  "Single",    "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "BitConverter.SingleToInt32Bits(result[0]) != ((left[0] >= right[0]) ? -1 : 0)",                                                      "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
-    ("BooleanCmpOpTest.template", new string[] { "Sse", "Sse",   "CompareGreaterThanOrEqualOrderedScalar",   "Vector128",  "Boolean",   "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "(left[0] >= right[0]) != result"}),
-    ("BooleanCmpOpTest.template", new string[] { "Sse", "Sse",   "CompareGreaterThanOrEqualUnorderedScalar", "Vector128",  "Boolean",   "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "(left[0] >= right[0]) != result"}),
-    ("SimpleBinOpTest.template",  new string[] { "Sse", "Sse",   "CompareLessThan",                          "Vector128",  "Single",    "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "BitConverter.SingleToInt32Bits(result[0]) != ((left[0] < right[0]) ? -1 : 0)",                                                       "BitConverter.SingleToInt32Bits(result[i]) != ((left[i] < right[i]) ? -1 : 0)"}),
-    ("SimpleBinOpTest.template",  new string[] { "Sse", "Sse",   "CompareLessThanScalar",                    "Vector128",  "Single",    "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "BitConverter.SingleToInt32Bits(result[0]) != ((left[0] < right[0]) ? -1 : 0)",                                                       "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
-    ("BooleanCmpOpTest.template", new string[] { "Sse", "Sse",   "CompareLessThanOrderedScalar",             "Vector128",  "Boolean",   "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "(left[0] < right[0]) != result"}),
-    ("BooleanCmpOpTest.template", new string[] { "Sse", "Sse",   "CompareLessThanUnorderedScalar",           "Vector128",  "Boolean",   "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "(left[0] < right[0]) != result"}),
-    ("SimpleBinOpTest.template",  new string[] { "Sse", "Sse",   "CompareLessThanOrEqual",                   "Vector128",  "Single",    "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "BitConverter.SingleToInt32Bits(result[0]) != ((left[0] <= right[0]) ? -1 : 0)",                                                      "BitConverter.SingleToInt32Bits(result[i]) != ((left[i] <= right[i]) ? -1 : 0)"}),
-    ("SimpleBinOpTest.template",  new string[] { "Sse", "Sse",   "CompareLessThanOrEqualScalar",             "Vector128",  "Single",    "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "BitConverter.SingleToInt32Bits(result[0]) != ((left[0] <= right[0]) ? -1 : 0)",                                                      "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
-    ("BooleanCmpOpTest.template", new string[] { "Sse", "Sse",   "CompareLessThanOrEqualOrderedScalar",      "Vector128",  "Boolean",   "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "(left[0] <= right[0]) != result"}),
-    ("BooleanCmpOpTest.template", new string[] { "Sse", "Sse",   "CompareLessThanOrEqualUnorderedScalar",    "Vector128",  "Boolean",   "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "(left[0] <= right[0]) != result"}),
-    ("SimpleBinOpTest.template",  new string[] { "Sse", "Sse",   "CompareNotEqual",                          "Vector128",  "Single",    "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "BitConverter.SingleToInt32Bits(result[0]) != ((left[0] != right[0]) ? -1 : 0)",                                                      "BitConverter.SingleToInt32Bits(result[i]) != ((left[i] != right[i]) ? -1 : 0)"}),
-    ("SimpleBinOpTest.template",  new string[] { "Sse", "Sse",   "CompareNotEqualScalar",                    "Vector128",  "Single",    "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "BitConverter.SingleToInt32Bits(result[0]) != ((left[0] != right[0]) ? -1 : 0)",                                                      "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
-    ("BooleanCmpOpTest.template", new string[] { "Sse", "Sse",   "CompareNotEqualOrderedScalar",             "Vector128",  "Boolean",   "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "(left[0] != right[0]) != result"}),
-    ("BooleanCmpOpTest.template", new string[] { "Sse", "Sse",   "CompareNotEqualUnorderedScalar",           "Vector128",  "Boolean",   "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "(left[0] != right[0]) != result"}),
-    ("SimpleBinOpTest.template",  new string[] { "Sse", "Sse",   "CompareNotGreaterThan",                    "Vector128",  "Single",    "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "BitConverter.SingleToInt32Bits(result[0]) != (!(left[0] > right[0]) ? -1 : 0)",                                                      "BitConverter.SingleToInt32Bits(result[i]) != (!(left[i] > right[i]) ? -1 : 0)"}),
-    ("SimpleBinOpTest.template",  new string[] { "Sse", "Sse",   "CompareNotGreaterThanScalar",              "Vector128",  "Single",    "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "BitConverter.SingleToInt32Bits(result[0]) != (!(left[0] > right[0]) ? -1 : 0)",                                                      "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
-    ("SimpleBinOpTest.template",  new string[] { "Sse", "Sse",   "CompareNotGreaterThanOrEqual",             "Vector128",  "Single",    "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "BitConverter.SingleToInt32Bits(result[0]) != (!(left[0] >= right[0]) ? -1 : 0)",                                                     "BitConverter.SingleToInt32Bits(result[i]) != (!(left[i] >= right[i]) ? -1 : 0)"}),
-    ("SimpleBinOpTest.template",  new string[] { "Sse", "Sse",   "CompareNotGreaterThanOrEqualScalar",       "Vector128",  "Single",    "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "BitConverter.SingleToInt32Bits(result[0]) != (!(left[0] >= right[0]) ? -1 : 0)",                                                     "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
-    ("SimpleBinOpTest.template",  new string[] { "Sse", "Sse",   "CompareNotLessThan",                       "Vector128",  "Single",    "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "BitConverter.SingleToInt32Bits(result[0]) != (!(left[0] < right[0]) ? -1 : 0)",                                                      "BitConverter.SingleToInt32Bits(result[i]) != (!(left[i] < right[i]) ? -1 : 0)"}),
-    ("SimpleBinOpTest.template",  new string[] { "Sse", "Sse",   "CompareNotLessThanScalar",                 "Vector128",  "Single",    "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "BitConverter.SingleToInt32Bits(result[0]) != (!(left[0] < right[0]) ? -1 : 0)",                                                      "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
-    ("SimpleBinOpTest.template",  new string[] { "Sse", "Sse",   "CompareNotLessThanOrEqual",                "Vector128",  "Single",    "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "BitConverter.SingleToInt32Bits(result[0]) != (!(left[0] <= right[0]) ? -1 : 0)",                                                     "BitConverter.SingleToInt32Bits(result[i]) != (!(left[i] <= right[i]) ? -1 : 0)"}),
-    ("SimpleBinOpTest.template",  new string[] { "Sse", "Sse",   "CompareNotLessThanOrEqualScalar",          "Vector128",  "Single",    "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "BitConverter.SingleToInt32Bits(result[0]) != (!(left[0] <= right[0]) ? -1 : 0)",                                                     "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
-    ("SimpleBinOpTest.template",  new string[] { "Sse", "Sse",   "CompareOrdered",                           "Vector128",  "Single",    "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "BitConverter.SingleToInt32Bits(result[0]) != ((!float.IsNaN(left[0]) && !float.IsNaN(right[0])) ? -1 : 0)",                          "BitConverter.SingleToInt32Bits(result[i]) != ((!float.IsNaN(left[i]) && !float.IsNaN(right[i])) ? -1 : 0)"}),
-    ("SimpleBinOpTest.template",  new string[] { "Sse", "Sse",   "CompareOrderedScalar",                     "Vector128",  "Single",    "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "BitConverter.SingleToInt32Bits(result[0]) != ((!float.IsNaN(left[0]) && !float.IsNaN(right[0])) ? -1 : 0)",                          "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
-    ("SimpleBinOpTest.template",  new string[] { "Sse", "Sse",   "CompareUnordered",                         "Vector128",  "Single",    "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "BitConverter.SingleToInt32Bits(result[0]) != ((float.IsNaN(left[0]) || float.IsNaN(right[0])) ? -1 : 0)",                            "BitConverter.SingleToInt32Bits(result[i]) != ((float.IsNaN(left[i]) || float.IsNaN(right[i])) ? -1 : 0)"}),
-    ("SimpleBinOpTest.template",  new string[] { "Sse", "Sse",   "CompareUnorderedScalar",                   "Vector128",  "Single",    "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "BitConverter.SingleToInt32Bits(result[0]) != ((float.IsNaN(left[0]) || float.IsNaN(right[0])) ? -1 : 0)",                            "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
-    ("SimpleBinOpTest.template",  new string[] { "Sse", "Sse",   "Divide",                                   "Vector128",  "Single",    "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "BitConverter.SingleToInt32Bits(left[0] / right[0]) != BitConverter.SingleToInt32Bits(result[0])",                                    "BitConverter.SingleToInt32Bits(left[i] / right[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
-    ("SimpleBinOpTest.template",  new string[] { "Sse", "Sse",   "DivideScalar",                             "Vector128",  "Single",    "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "BitConverter.SingleToInt32Bits(left[0] / right[0]) != BitConverter.SingleToInt32Bits(result[0])",                                    "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
-    ("SimpleBinOpTest.template",  new string[] { "Sse", "Sse",   "Max",                                      "Vector128",  "Single",    "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "BitConverter.SingleToInt32Bits(Math.Max(left[0], right[0])) != BitConverter.SingleToInt32Bits(result[0])",                           "BitConverter.SingleToInt32Bits(Math.Max(left[i], right[i])) != BitConverter.SingleToInt32Bits(result[i])"}),
-    ("SimpleBinOpTest.template",  new string[] { "Sse", "Sse",   "MaxScalar",                                "Vector128",  "Single",    "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "BitConverter.SingleToInt32Bits(Math.Max(left[0], right[0])) != BitConverter.SingleToInt32Bits(result[0])",                           "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
-    ("SimpleBinOpTest.template",  new string[] { "Sse", "Sse",   "Min",                                      "Vector128",  "Single",    "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "BitConverter.SingleToInt32Bits(Math.Min(left[0], right[0])) != BitConverter.SingleToInt32Bits(result[0])",                           "BitConverter.SingleToInt32Bits(Math.Min(left[i], right[i])) != BitConverter.SingleToInt32Bits(result[i])"}),
-    ("SimpleBinOpTest.template",  new string[] { "Sse", "Sse",   "MinScalar",                                "Vector128",  "Single",    "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "BitConverter.SingleToInt32Bits(Math.Min(left[0], right[0])) != BitConverter.SingleToInt32Bits(result[0])",                           "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
-    ("SimpleBinOpTest.template",  new string[] { "Sse", "Sse",   "Multiply",                                 "Vector128",  "Single",    "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "BitConverter.SingleToInt32Bits(left[0] * right[0]) != BitConverter.SingleToInt32Bits(result[0])",                                    "BitConverter.SingleToInt32Bits(left[i] * right[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
-    ("SimpleBinOpTest.template",  new string[] { "Sse", "Sse",   "MultiplyScalar",                           "Vector128",  "Single",    "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "BitConverter.SingleToInt32Bits(left[0] * right[0]) != BitConverter.SingleToInt32Bits(result[0])",                                    "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
-    ("SimpleBinOpTest.template",  new string[] { "Sse", "Sse",   "Or",                                       "Vector128",  "Single",    "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "(BitConverter.SingleToInt32Bits(left[0]) | BitConverter.SingleToInt32Bits(right[0])) != BitConverter.SingleToInt32Bits(result[0])",  "(BitConverter.SingleToInt32Bits(left[0]) | BitConverter.SingleToInt32Bits(right[0])) != BitConverter.SingleToInt32Bits(result[0])"}),
-    ("SimpleBinOpTest.template",  new string[] { "Sse", "Sse",   "Subtract",                                 "Vector128",  "Single",    "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "BitConverter.SingleToInt32Bits(left[0] - right[0]) != BitConverter.SingleToInt32Bits(result[0])",                                    "BitConverter.SingleToInt32Bits(left[i] - right[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
-    ("SimpleBinOpTest.template",  new string[] { "Sse", "Sse",   "SubtractScalar",                           "Vector128",  "Single",    "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "BitConverter.SingleToInt32Bits(left[0] - right[0]) != BitConverter.SingleToInt32Bits(result[0])",                                    "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
-    ("SimpleBinOpTest.template",  new string[] { "Sse", "Sse",   "Xor",                                      "Vector128",  "Single",    "Vector128",   "Single",     "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())", "(float)(random.NextDouble())",               "(BitConverter.SingleToInt32Bits(left[0]) ^ BitConverter.SingleToInt32Bits(right[0])) != BitConverter.SingleToInt32Bits(result[0])",  "(BitConverter.SingleToInt32Bits(left[0]) ^ BitConverter.SingleToInt32Bits(right[0])) != BitConverter.SingleToInt32Bits(result[0])"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "Add",                                     ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(left[0] + right[0]) != BitConverter.SingleToInt32Bits(result[0])",                                    ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i] + right[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "AddScalar",                               ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(left[0] + right[0]) != BitConverter.SingleToInt32Bits(result[0])",                                    ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "And",                                     ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "(BitConverter.SingleToInt32Bits(left[0]) & BitConverter.SingleToInt32Bits(right[0])) != BitConverter.SingleToInt32Bits(result[0])",  ["ValidateRemainingResults"] = "(BitConverter.SingleToInt32Bits(left[0]) & BitConverter.SingleToInt32Bits(right[0])) != BitConverter.SingleToInt32Bits(result[0])"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "AndNot",                                  ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "(~BitConverter.SingleToInt32Bits(left[0]) & BitConverter.SingleToInt32Bits(right[0])) != BitConverter.SingleToInt32Bits(result[0])", ["ValidateRemainingResults"] = "(~BitConverter.SingleToInt32Bits(left[0]) & BitConverter.SingleToInt32Bits(right[0])) != BitConverter.SingleToInt32Bits(result[0])"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareEqual",                            ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != ((left[0] == right[0]) ? -1 : 0)",                                                      ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != ((left[i] == right[i]) ? -1 : 0)"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareEqualScalar",                      ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != ((left[0] == right[0]) ? -1 : 0)",                                                      ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
+    ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareEqualOrderedScalar",               ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "(left[0] == right[0]) != result"}),
+    ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareEqualUnorderedScalar",             ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "(left[0] == right[0]) != result"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareGreaterThan",                      ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != ((left[0] > right[0]) ? -1 : 0)",                                                       ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != ((left[i] > right[i]) ? -1 : 0)"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareGreaterThanScalar",                ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != ((left[0] > right[0]) ? -1 : 0)",                                                       ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
+    ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareGreaterThanOrderedScalar",         ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "(left[0] > right[0]) != result"}),
+    ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareGreaterThanUnorderedScalar",       ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "(left[0] > right[0]) != result"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareGreaterThanOrEqual",               ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != ((left[0] >= right[0]) ? -1 : 0)",                                                      ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != ((left[i] >= right[i]) ? -1 : 0)"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareGreaterThanOrEqualScalar",         ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != ((left[0] >= right[0]) ? -1 : 0)",                                                      ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
+    ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareGreaterThanOrEqualOrderedScalar",  ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "(left[0] >= right[0]) != result"}),
+    ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareGreaterThanOrEqualUnorderedScalar",["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "(left[0] >= right[0]) != result"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareLessThan",                         ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != ((left[0] < right[0]) ? -1 : 0)",                                                       ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != ((left[i] < right[i]) ? -1 : 0)"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareLessThanScalar",                   ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != ((left[0] < right[0]) ? -1 : 0)",                                                       ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
+    ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareLessThanOrderedScalar",            ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "(left[0] < right[0]) != result"}),
+    ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareLessThanUnorderedScalar",          ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "(left[0] < right[0]) != result"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareLessThanOrEqual",                  ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != ((left[0] <= right[0]) ? -1 : 0)",                                                      ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != ((left[i] <= right[i]) ? -1 : 0)"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareLessThanOrEqualScalar",            ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != ((left[0] <= right[0]) ? -1 : 0)",                                                      ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
+    ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareLessThanOrEqualOrderedScalar",     ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "(left[0] <= right[0]) != result"}),
+    ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareLessThanOrEqualUnorderedScalar",   ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "(left[0] <= right[0]) != result"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareNotEqual",                         ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != ((left[0] != right[0]) ? -1 : 0)",                                                      ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != ((left[i] != right[i]) ? -1 : 0)"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareNotEqualScalar",                   ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != ((left[0] != right[0]) ? -1 : 0)",                                                      ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
+    ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareNotEqualOrderedScalar",            ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "(left[0] != right[0]) != result"}),
+    ("BooleanCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareNotEqualUnorderedScalar",          ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Boolean", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "(left[0] != right[0]) != result"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareNotGreaterThan",                   ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != (!(left[0] > right[0]) ? -1 : 0)",                                                      ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != (!(left[i] > right[i]) ? -1 : 0)"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareNotGreaterThanScalar",             ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != (!(left[0] > right[0]) ? -1 : 0)",                                                      ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareNotGreaterThanOrEqual",            ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != (!(left[0] >= right[0]) ? -1 : 0)",                                                     ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != (!(left[i] >= right[i]) ? -1 : 0)"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareNotGreaterThanOrEqualScalar",      ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != (!(left[0] >= right[0]) ? -1 : 0)",                                                     ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareNotLessThan",                      ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != (!(left[0] < right[0]) ? -1 : 0)",                                                      ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != (!(left[i] < right[i]) ? -1 : 0)"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareNotLessThanScalar",                ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != (!(left[0] < right[0]) ? -1 : 0)",                                                      ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareNotLessThanOrEqual",               ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != (!(left[0] <= right[0]) ? -1 : 0)",                                                     ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != (!(left[i] <= right[i]) ? -1 : 0)"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareNotLessThanOrEqualScalar",         ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != (!(left[0] <= right[0]) ? -1 : 0)",                                                     ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareOrdered",                          ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != ((!float.IsNaN(left[0]) && !float.IsNaN(right[0])) ? -1 : 0)",                          ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != ((!float.IsNaN(left[i]) && !float.IsNaN(right[i])) ? -1 : 0)"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareOrderedScalar",                    ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != ((!float.IsNaN(left[0]) && !float.IsNaN(right[0])) ? -1 : 0)",                          ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareUnordered",                        ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != ((float.IsNaN(left[0]) || float.IsNaN(right[0])) ? -1 : 0)",                            ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != ((float.IsNaN(left[i]) || float.IsNaN(right[i])) ? -1 : 0)"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "CompareUnorderedScalar",                  ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != ((float.IsNaN(left[0]) || float.IsNaN(right[0])) ? -1 : 0)",                            ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "Divide",                                  ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(left[0] / right[0]) != BitConverter.SingleToInt32Bits(result[0])",                                    ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i] / right[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "DivideScalar",                            ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(left[0] / right[0]) != BitConverter.SingleToInt32Bits(result[0])",                                    ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "Max",                                     ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(Math.Max(left[0], right[0])) != BitConverter.SingleToInt32Bits(result[0])",                           ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(Math.Max(left[i], right[i])) != BitConverter.SingleToInt32Bits(result[i])"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "MaxScalar",                               ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(Math.Max(left[0], right[0])) != BitConverter.SingleToInt32Bits(result[0])",                           ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "Min",                                     ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(Math.Min(left[0], right[0])) != BitConverter.SingleToInt32Bits(result[0])",                           ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(Math.Min(left[i], right[i])) != BitConverter.SingleToInt32Bits(result[i])"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "MinScalar",                               ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(Math.Min(left[0], right[0])) != BitConverter.SingleToInt32Bits(result[0])",                           ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "Multiply",                                ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(left[0] * right[0]) != BitConverter.SingleToInt32Bits(result[0])",                                    ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i] * right[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "MultiplyScalar",                          ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(left[0] * right[0]) != BitConverter.SingleToInt32Bits(result[0])",                                    ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "Or",                                      ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "(BitConverter.SingleToInt32Bits(left[0]) | BitConverter.SingleToInt32Bits(right[0])) != BitConverter.SingleToInt32Bits(result[0])",  ["ValidateRemainingResults"] = "(BitConverter.SingleToInt32Bits(left[0]) | BitConverter.SingleToInt32Bits(right[0])) != BitConverter.SingleToInt32Bits(result[0])"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "Subtract",                                ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(left[0] - right[0]) != BitConverter.SingleToInt32Bits(result[0])",                                    ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i] - right[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "SubtractScalar",                          ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(left[0] - right[0]) != BitConverter.SingleToInt32Bits(result[0])",                                    ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Sse", ["LoadIsa"] = "Sse", ["Method"] = "Xor",                                     ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] =  "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())", ["NextValueOp2"] = "(float)(random.NextDouble())", ["ValidateFirstResult"] = "(BitConverter.SingleToInt32Bits(left[0]) ^ BitConverter.SingleToInt32Bits(right[0])) != BitConverter.SingleToInt32Bits(result[0])",  ["ValidateRemainingResults"] = "(BitConverter.SingleToInt32Bits(left[0]) ^ BitConverter.SingleToInt32Bits(right[0])) != BitConverter.SingleToInt32Bits(result[0])"}),
 };
 
-private static readonly (string templateFileName, string[] templateData)[] Sse2Inputs = new []
+private static readonly (string templateFileName, Dictionary<string, string> templateData)[] Sse2Inputs = new []
 {
-    // TemplateName                             Isa,    LoadIsa, Method,                         RetVectorType, RetBaseType, Op1VectorType,  Op1BaseType, Op2VectorType, Op2BaseType, Op3VectorType, Op3BaseType,  VectorSize, NextValueOp1,                                           NextValueOp2,                                           NextValueOp3, ValidateFirstResult,                                                                                                                  ValidateRemainingResults
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "Add",                          "Vector128",   "Double",    "Vector128",    "Double",    "Vector128",   "Double",                                 "16",       "(double)(random.NextDouble())",                        "(double)(random.NextDouble())",                                      "BitConverter.DoubleToInt64Bits(left[0] + right[0]) != BitConverter.DoubleToInt64Bits(result[0])",                                    "BitConverter.DoubleToInt64Bits(left[i] + right[i]) != BitConverter.DoubleToInt64Bits(result[i])"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "Add",                          "Vector128",   "Byte",      "Vector128",    "Byte",      "Vector128",   "Byte",                                   "16",       "(byte)(random.Next(0, byte.MaxValue))",                "(byte)(random.Next(0, byte.MaxValue))",                              "(byte)(left[0] + right[0]) != result[0]",                                                                                            "(byte)(left[i] + right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "Add",                          "Vector128",   "Int16",     "Vector128",    "Int16",     "Vector128",   "Int16",                                  "16",       "(short)(random.Next(short.MinValue, short.MaxValue))", "(short)(random.Next(short.MinValue, short.MaxValue))",               "(short)(left[0] + right[0]) != result[0]",                                                                                           "(short)(left[i] + right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "Add",                          "Vector128",   "Int32",     "Vector128",    "Int32",     "Vector128",   "Int32",                                  "16",       "(int)(random.Next(int.MinValue, int.MaxValue))",       "(int)(random.Next(int.MinValue, int.MaxValue))",                     "(int)(left[0] + right[0]) != result[0]",                                                                                             "(int)(left[i] + right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "Add",                          "Vector128",   "Int64",     "Vector128",    "Int64",     "Vector128",   "Int64",                                  "16",       "(long)(random.Next(int.MinValue, int.MaxValue))",      "(long)(random.Next(int.MinValue, int.MaxValue))",                    "(long)(left[0] + right[0]) != result[0]",                                                                                            "(long)(left[i] + right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "Add",                          "Vector128",   "SByte",     "Vector128",    "SByte",     "Vector128",   "SByte",                                  "16",       "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))", "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",               "(sbyte)(left[0] + right[0]) != result[0]",                                                                                           "(sbyte)(left[i] + right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "Add",                          "Vector128",   "UInt16",    "Vector128",    "UInt16",    "Vector128",   "UInt16",                                 "16",       "(ushort)(random.Next(0, ushort.MaxValue))",            "(ushort)(random.Next(0, ushort.MaxValue))",                          "(ushort)(left[0] + right[0]) != result[0]",                                                                                          "(ushort)(left[i] + right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "Add",                          "Vector128",   "UInt32",    "Vector128",    "UInt32",    "Vector128",   "UInt32",                                 "16",       "(uint)(random.Next(0, int.MaxValue))",                 "(uint)(random.Next(0, int.MaxValue))",                               "(uint)(left[0] + right[0]) != result[0]",                                                                                            "(uint)(left[i] + right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "Add",                          "Vector128",   "UInt64",    "Vector128",    "UInt64",    "Vector128",   "UInt64",                                 "16",       "(ulong)(random.Next(0, int.MaxValue))",                "(ulong)(random.Next(0, int.MaxValue))",                              "(ulong)(left[0] + right[0]) != result[0]",                                                                                           "(ulong)(left[i] + right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "And",                          "Vector128",   "Double",    "Vector128",    "Double",    "Vector128",   "Double",                                 "16",       "(double)(random.NextDouble())",                        "(double)(random.NextDouble())",                                      "(BitConverter.DoubleToInt64Bits(left[0]) & BitConverter.DoubleToInt64Bits(right[0])) != BitConverter.DoubleToInt64Bits(result[0])",  "(BitConverter.DoubleToInt64Bits(left[i]) & BitConverter.DoubleToInt64Bits(right[i])) != BitConverter.DoubleToInt64Bits(result[i])"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "And",                          "Vector128",   "Byte",      "Vector128",    "Byte",      "Vector128",   "Byte",                                   "16",       "(byte)(random.Next(0, byte.MaxValue))",                "(byte)(random.Next(0, byte.MaxValue))",                              "(byte)(left[0] & right[0]) != result[0]",                                                                                            "(byte)(left[i] & right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "And",                          "Vector128",   "Int16",     "Vector128",    "Int16",     "Vector128",   "Int16",                                  "16",       "(short)(random.Next(short.MinValue, short.MaxValue))", "(short)(random.Next(short.MinValue, short.MaxValue))",               "(short)(left[0] & right[0]) != result[0]",                                                                                           "(short)(left[i] & right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "And",                          "Vector128",   "Int32",     "Vector128",    "Int32",     "Vector128",   "Int32",                                  "16",       "(int)(random.Next(int.MinValue, int.MaxValue))",       "(int)(random.Next(int.MinValue, int.MaxValue))",                     "(int)(left[0] & right[0]) != result[0]",                                                                                             "(int)(left[i] & right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "And",                          "Vector128",   "Int64",     "Vector128",    "Int64",     "Vector128",   "Int64",                                  "16",       "(long)(random.Next(int.MinValue, int.MaxValue))",      "(long)(random.Next(int.MinValue, int.MaxValue))",                    "(long)(left[0] & right[0]) != result[0]",                                                                                            "(long)(left[i] & right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "And",                          "Vector128",   "SByte",     "Vector128",    "SByte",     "Vector128",   "SByte",                                  "16",       "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))", "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",               "(sbyte)(left[0] & right[0]) != result[0]",                                                                                           "(sbyte)(left[i] & right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "And",                          "Vector128",   "UInt16",    "Vector128",    "UInt16",    "Vector128",   "UInt16",                                 "16",       "(ushort)(random.Next(0, ushort.MaxValue))",            "(ushort)(random.Next(0, ushort.MaxValue))",                          "(ushort)(left[0] & right[0]) != result[0]",                                                                                          "(ushort)(left[i] & right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "And",                          "Vector128",   "UInt32",    "Vector128",    "UInt32",    "Vector128",   "UInt32",                                 "16",       "(uint)(random.Next(0, int.MaxValue))",                 "(uint)(random.Next(0, int.MaxValue))",                               "(uint)(left[0] & right[0]) != result[0]",                                                                                            "(uint)(left[i] & right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "And",                          "Vector128",   "UInt64",    "Vector128",    "UInt64",    "Vector128",   "UInt64",                                 "16",       "(ulong)(random.Next(0, int.MaxValue))",                "(ulong)(random.Next(0, int.MaxValue))",                              "(ulong)(left[0] & right[0]) != result[0]",                                                                                           "(ulong)(left[i] & right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "AndNot",                       "Vector128",   "Double",    "Vector128",    "Double",    "Vector128",   "Double",                                 "16",       "(double)(random.NextDouble())",                        "(double)(random.NextDouble())",                                      "(~BitConverter.DoubleToInt64Bits(left[0]) & BitConverter.DoubleToInt64Bits(right[0])) != BitConverter.DoubleToInt64Bits(result[0])", "(~BitConverter.DoubleToInt64Bits(left[i]) & BitConverter.DoubleToInt64Bits(right[i])) != BitConverter.DoubleToInt64Bits(result[i])"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "AndNot",                       "Vector128",   "Byte",      "Vector128",    "Byte",      "Vector128",   "Byte",                                   "16",       "(byte)(random.Next(0, byte.MaxValue))",                "(byte)(random.Next(0, byte.MaxValue))",                              "(byte)(~left[0] & right[0]) != result[0]",                                                                                           "(byte)(~left[i] & right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "AndNot",                       "Vector128",   "Int16",     "Vector128",    "Int16",     "Vector128",   "Int16",                                  "16",       "(short)(random.Next(short.MinValue, short.MaxValue))", "(short)(random.Next(short.MinValue, short.MaxValue))",               "(short)(~left[0] & right[0]) != result[0]",                                                                                          "(short)(~left[i] & right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "AndNot",                       "Vector128",   "Int32",     "Vector128",    "Int32",     "Vector128",   "Int32",                                  "16",       "(int)(random.Next(int.MinValue, int.MaxValue))",       "(int)(random.Next(int.MinValue, int.MaxValue))",                     "(int)(~left[0] & right[0]) != result[0]",                                                                                            "(int)(~left[i] & right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "AndNot",                       "Vector128",   "Int64",     "Vector128",    "Int64",     "Vector128",   "Int64",                                  "16",       "(long)(random.Next(int.MinValue, int.MaxValue))",      "(long)(random.Next(int.MinValue, int.MaxValue))",                    "(long)(~left[0] & right[0]) != result[0]",                                                                                           "(long)(~left[i] & right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "AndNot",                       "Vector128",   "SByte",     "Vector128",    "SByte",     "Vector128",   "SByte",                                  "16",       "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))", "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",               "(sbyte)(~left[0] & right[0]) != result[0]",                                                                                          "(sbyte)(~left[i] & right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "AndNot",                       "Vector128",   "UInt16",    "Vector128",    "UInt16",    "Vector128",   "UInt16",                                 "16",       "(ushort)(random.Next(0, ushort.MaxValue))",            "(ushort)(random.Next(0, ushort.MaxValue))",                          "(ushort)(~left[0] & right[0]) != result[0]",                                                                                         "(ushort)(~left[i] & right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "AndNot",                       "Vector128",   "UInt32",    "Vector128",    "UInt32",    "Vector128",   "UInt32",                                 "16",       "(uint)(random.Next(0, int.MaxValue))",                 "(uint)(random.Next(0, int.MaxValue))",                               "(uint)(~left[0] & right[0]) != result[0]",                                                                                           "(uint)(~left[i] & right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "AndNot",                       "Vector128",   "UInt64",    "Vector128",    "UInt64",    "Vector128",   "UInt64",                                 "16",       "(ulong)(random.Next(0, int.MaxValue))",                "(ulong)(random.Next(0, int.MaxValue))",                              "(ulong)(~left[0] & right[0]) != result[0]",                                                                                          "(ulong)(~left[i] & right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "CompareEqual",                 "Vector128",   "Double",    "Vector128",    "Double",    "Vector128",   "Double",                                 "16",       "(double)(random.NextDouble())",                        "(double)(random.NextDouble())",                                      "BitConverter.DoubleToInt64Bits(result[0]) != ((left[0] == right[0]) ? -1 : 0)",                                                      "BitConverter.DoubleToInt64Bits(result[i]) != ((left[i] == right[i]) ? -1 : 0)"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "CompareEqual",                 "Vector128",   "Byte",      "Vector128",    "Byte",      "Vector128",   "Byte",                                   "16",       "(byte)(random.Next(0, byte.MaxValue))",                "(byte)(random.Next(0, byte.MaxValue))",                              "result[0] != ((left[0] == right[0]) ? unchecked((byte)(-1)) : 0)",                                                                   "result[i] != ((left[i] == right[i]) ? unchecked((byte)(-1)) : 0)"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "CompareEqual",                 "Vector128",   "Int16",     "Vector128",    "Int16",     "Vector128",   "Int16",                                  "16",       "(short)(random.Next(short.MinValue, short.MaxValue))", "(short)(random.Next(short.MinValue, short.MaxValue))",               "result[0] != ((left[0] == right[0]) ? unchecked((short)(-1)) : 0)",                                                                  "result[i] != ((left[i] == right[i]) ? unchecked((short)(-1)) : 0)"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "CompareEqual",                 "Vector128",   "Int32",     "Vector128",    "Int32",     "Vector128",   "Int32",                                  "16",       "(int)(random.Next(int.MinValue, int.MaxValue))",       "(int)(random.Next(int.MinValue, int.MaxValue))",                     "result[0] != ((left[0] == right[0]) ? unchecked((int)(-1)) : 0)",                                                                    "result[i] != ((left[i] == right[i]) ? unchecked((int)(-1)) : 0)"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "CompareEqual",                 "Vector128",   "SByte",     "Vector128",    "SByte",     "Vector128",   "SByte",                                  "16",       "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))", "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",               "result[0] != ((left[0] == right[0]) ? unchecked((sbyte)(-1)) : 0)",                                                                  "result[i] != ((left[i] == right[i]) ? unchecked((sbyte)(-1)) : 0)"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "CompareEqual",                 "Vector128",   "UInt16",    "Vector128",    "UInt16",    "Vector128",   "UInt16",                                 "16",       "(ushort)(random.Next(0, ushort.MaxValue))",            "(ushort)(random.Next(0, ushort.MaxValue))",                          "result[0] != ((left[0] == right[0]) ? unchecked((ushort)(-1)) : 0)",                                                                 "result[i] != ((left[i] == right[i]) ? unchecked((ushort)(-1)) : 0)"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "CompareEqual",                 "Vector128",   "UInt32",    "Vector128",    "UInt32",    "Vector128",   "UInt32",                                 "16",       "(uint)(random.Next(0, int.MaxValue))",                 "(uint)(random.Next(0, int.MaxValue))",                               "result[0] != ((left[0] == right[0]) ? unchecked((uint)(-1)) : 0)",                                                                   "result[i] != ((left[i] == right[i]) ? unchecked((uint)(-1)) : 0)"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "CompareGreaterThan",           "Vector128",   "Double",    "Vector128",    "Double",    "Vector128",   "Double",                                 "16",       "(double)(random.NextDouble())",                        "(double)(random.NextDouble())",                                      "BitConverter.DoubleToInt64Bits(result[0]) != ((left[0] > right[0]) ? -1 : 0)",                                                       "BitConverter.DoubleToInt64Bits(result[i]) != ((left[i] > right[i]) ? -1 : 0)"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "CompareGreaterThan",           "Vector128",   "Int16",     "Vector128",    "Int16",     "Vector128",   "Int16",                                  "16",       "(short)(random.Next(short.MinValue, short.MaxValue))", "(short)(random.Next(short.MinValue, short.MaxValue))",               "result[0] != ((left[0] > right[0]) ? unchecked((short)(-1)) : 0)",                                                                   "result[i] != ((left[i] > right[i]) ? unchecked((short)(-1)) : 0)"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "CompareGreaterThan",           "Vector128",   "Int32",     "Vector128",    "Int32",     "Vector128",   "Int32",                                  "16",       "(int)(random.Next(int.MinValue, int.MaxValue))",       "(int)(random.Next(int.MinValue, int.MaxValue))",                     "result[0] != ((left[0] > right[0]) ? unchecked((int)(-1)) : 0)",                                                                     "result[i] != ((left[i] > right[i]) ? unchecked((int)(-1)) : 0)"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "CompareGreaterThan",           "Vector128",   "SByte",     "Vector128",    "SByte",     "Vector128",   "SByte",                                  "16",       "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))", "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",               "result[0] != ((left[0] > right[0]) ? unchecked((sbyte)(-1)) : 0)",                                                                   "result[i] != ((left[i] > right[i]) ? unchecked((sbyte)(-1)) : 0)"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "CompareGreaterThanOrEqual",    "Vector128",   "Double",    "Vector128",    "Double",    "Vector128",   "Double",                                 "16",       "(double)(random.NextDouble())",                        "(double)(random.NextDouble())",                                      "BitConverter.DoubleToInt64Bits(result[0]) != ((left[0] >= right[0]) ? -1 : 0)",                                                      "BitConverter.DoubleToInt64Bits(result[i]) != ((left[i] >= right[i]) ? -1 : 0)"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "CompareLessThan",              "Vector128",   "Double",    "Vector128",    "Double",    "Vector128",   "Double",                                 "16",       "(double)(random.NextDouble())",                        "(double)(random.NextDouble())",                                      "BitConverter.DoubleToInt64Bits(result[0]) != ((left[0] < right[0]) ? -1 : 0)",                                                       "BitConverter.DoubleToInt64Bits(result[i]) != ((left[i] < right[i]) ? -1 : 0)"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "CompareLessThan",              "Vector128",   "Int16",     "Vector128",    "Int16",     "Vector128",   "Int16",                                  "16",       "(short)(random.Next(short.MinValue, short.MaxValue))", "(short)(random.Next(short.MinValue, short.MaxValue))",               "result[0] != ((left[0] < right[0]) ? unchecked((short)(-1)) : 0)",                                                                   "result[i] != ((left[i] < right[i]) ? unchecked((short)(-1)) : 0)"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "CompareLessThan",              "Vector128",   "Int32",     "Vector128",    "Int32",     "Vector128",   "Int32",                                  "16",       "(int)(random.Next(int.MinValue, int.MaxValue))",       "(int)(random.Next(int.MinValue, int.MaxValue))",                     "result[0] != ((left[0] < right[0]) ? unchecked((int)(-1)) : 0)",                                                                     "result[i] != ((left[i] < right[i]) ? unchecked((int)(-1)) : 0)"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "CompareLessThan",              "Vector128",   "SByte",     "Vector128",    "SByte",     "Vector128",   "SByte",                                  "16",       "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))", "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",               "result[0] != ((left[0] < right[0]) ? unchecked((sbyte)(-1)) : 0)",                                                                   "result[i] != ((left[i] < right[i]) ? unchecked((sbyte)(-1)) : 0)"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "CompareLessThanOrEqual",       "Vector128",   "Double",    "Vector128",    "Double",    "Vector128",   "Double",                                 "16",       "(double)(random.NextDouble())",                        "(double)(random.NextDouble())",                                      "BitConverter.DoubleToInt64Bits(result[0]) != ((left[0] <= right[0]) ? -1 : 0)",                                                      "BitConverter.DoubleToInt64Bits(result[i]) != ((left[i] <= right[i]) ? -1 : 0)"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "CompareNotEqual",              "Vector128",   "Double",    "Vector128",    "Double",    "Vector128",   "Double",                                 "16",       "(double)(random.NextDouble())",                        "(double)(random.NextDouble())",                                      "BitConverter.DoubleToInt64Bits(result[0]) != ((left[0] != right[0]) ? -1 : 0)",                                                      "BitConverter.DoubleToInt64Bits(result[i]) != ((left[i] != right[i]) ? -1 : 0)"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "CompareNotGreaterThan",        "Vector128",   "Double",    "Vector128",    "Double",    "Vector128",   "Double",                                 "16",       "(double)(random.NextDouble())",                        "(double)(random.NextDouble())",                                      "BitConverter.DoubleToInt64Bits(result[0]) != (!(left[0] > right[0]) ? -1 : 0)",                                                      "BitConverter.DoubleToInt64Bits(result[i]) != (!(left[i] > right[i]) ? -1 : 0)"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "CompareNotGreaterThanOrEqual", "Vector128",   "Double",    "Vector128",    "Double",    "Vector128",   "Double",                                 "16",       "(double)(random.NextDouble())",                        "(double)(random.NextDouble())",                                      "BitConverter.DoubleToInt64Bits(result[0]) != (!(left[0] >= right[0]) ? -1 : 0)",                                                     "BitConverter.DoubleToInt64Bits(result[i]) != (!(left[i] >= right[i]) ? -1 : 0)"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "CompareNotLessThan",           "Vector128",   "Double",    "Vector128",    "Double",    "Vector128",   "Double",                                 "16",       "(double)(random.NextDouble())",                        "(double)(random.NextDouble())",                                      "BitConverter.DoubleToInt64Bits(result[0]) != (!(left[0] < right[0]) ? -1 : 0)",                                                      "BitConverter.DoubleToInt64Bits(result[i]) != (!(left[i] < right[i]) ? -1 : 0)"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "CompareNotLessThanOrEqual",    "Vector128",   "Double",    "Vector128",    "Double",    "Vector128",   "Double",                                 "16",       "(double)(random.NextDouble())",                        "(double)(random.NextDouble())",                                      "BitConverter.DoubleToInt64Bits(result[0]) != (!(left[0] <= right[0]) ? -1 : 0)",                                                     "BitConverter.DoubleToInt64Bits(result[i]) != (!(left[i] <= right[i]) ? -1 : 0)"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "CompareOrdered",               "Vector128",   "Double",    "Vector128",    "Double",    "Vector128",   "Double",                                 "16",       "(double)(random.NextDouble())",                        "(double)(random.NextDouble())",                                      "BitConverter.DoubleToInt64Bits(result[0]) != ((!double.IsNaN(left[0]) && !double.IsNaN(right[0])) ? -1 : 0)",                        "BitConverter.DoubleToInt64Bits(result[i]) != ((!double.IsNaN(left[i]) && !double.IsNaN(right[i])) ? -1 : 0)"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "CompareUnordered",             "Vector128",   "Double",    "Vector128",    "Double",    "Vector128",   "Double",                                 "16",       "(double)(random.NextDouble())",                        "(double)(random.NextDouble())",                                      "BitConverter.DoubleToInt64Bits(result[0]) != ((double.IsNaN(left[0]) || double.IsNaN(right[0])) ? -1 : 0)",                          "BitConverter.DoubleToInt64Bits(result[i]) != ((double.IsNaN(left[i]) || double.IsNaN(right[i])) ? -1 : 0)"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "Divide",                       "Vector128",   "Double",    "Vector128",    "Double",    "Vector128",   "Double",                                 "16",       "(double)(random.NextDouble())",                        "(double)(random.NextDouble())",                                      "BitConverter.DoubleToInt64Bits(left[0] / right[0]) != BitConverter.DoubleToInt64Bits(result[0])",                                    "BitConverter.DoubleToInt64Bits(left[i] / right[i]) != BitConverter.DoubleToInt64Bits(result[i])"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "Max",                          "Vector128",   "Double",    "Vector128",    "Double",    "Vector128",   "Double",                                 "16",       "(double)(random.NextDouble())",                        "(double)(random.NextDouble())",                                      "BitConverter.DoubleToInt64Bits(Math.Max(left[0], right[0])) != BitConverter.DoubleToInt64Bits(result[0])",                           "BitConverter.DoubleToInt64Bits(Math.Max(left[i], right[i])) != BitConverter.DoubleToInt64Bits(result[i])"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "Max",                          "Vector128",   "Byte",      "Vector128",    "Byte",      "Vector128",   "Byte",                                   "16",       "(byte)(random.Next(0, byte.MaxValue))",                "(byte)(random.Next(0, byte.MaxValue))",                              "Math.Max(left[0], right[0]) != result[0]",                                                                                           "Math.Max(left[i], right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "Max",                          "Vector128",   "Int16",     "Vector128",    "Int16",     "Vector128",   "Int16",                                  "16",       "(short)(random.Next(short.MinValue, short.MaxValue))", "(short)(random.Next(short.MinValue, short.MaxValue))",               "Math.Max(left[0], right[0]) != result[0]",                                                                                           "Math.Max(left[i], right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "Min",                          "Vector128",   "Double",    "Vector128",    "Double",    "Vector128",   "Double",                                 "16",       "(double)(random.NextDouble())",                        "(double)(random.NextDouble())",                                      "BitConverter.DoubleToInt64Bits(Math.Min(left[0], right[0])) != BitConverter.DoubleToInt64Bits(result[0])",                           "BitConverter.DoubleToInt64Bits(Math.Min(left[i], right[i])) != BitConverter.DoubleToInt64Bits(result[i])"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "Min",                          "Vector128",   "Byte",      "Vector128",    "Byte",      "Vector128",   "Byte",                                   "16",       "(byte)(random.Next(0, byte.MinValue))",                "(byte)(random.Next(0, byte.MinValue))",                              "Math.Min(left[0], right[0]) != result[0]",                                                                                           "Math.Min(left[i], right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "Min",                          "Vector128",   "Int16",     "Vector128",    "Int16",     "Vector128",   "Int16",                                  "16",       "(short)(random.Next(short.MinValue, short.MinValue))", "(short)(random.Next(short.MinValue, short.MinValue))",               "Math.Min(left[0], right[0]) != result[0]",                                                                                           "Math.Min(left[i], right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "Multiply",                     "Vector128",   "Double",    "Vector128",    "Double",    "Vector128",   "Double",                                 "16",       "(double)(random.NextDouble())",                        "(double)(random.NextDouble())",                                      "BitConverter.DoubleToInt64Bits(left[0] * right[0]) != BitConverter.DoubleToInt64Bits(result[0])",                                    "BitConverter.DoubleToInt64Bits(left[i] * right[i]) != BitConverter.DoubleToInt64Bits(result[i])"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "Or",                           "Vector128",   "Double",    "Vector128",    "Double",    "Vector128",   "Double",                                 "16",       "(double)(random.NextDouble())",                        "(double)(random.NextDouble())",                                      "(BitConverter.DoubleToInt64Bits(left[0]) | BitConverter.DoubleToInt64Bits(right[0])) != BitConverter.DoubleToInt64Bits(result[0])",  "(BitConverter.DoubleToInt64Bits(left[i]) | BitConverter.DoubleToInt64Bits(right[i])) != BitConverter.DoubleToInt64Bits(result[i])"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "Or",                           "Vector128",   "Byte",      "Vector128",    "Byte",      "Vector128",   "Byte",                                   "16",       "(byte)(random.Next(0, byte.MaxValue))",                "(byte)(random.Next(0, byte.MaxValue))",                              "(byte)(left[0] | right[0]) != result[0]",                                                                                            "(byte)(left[i] | right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "Or",                           "Vector128",   "Int16",     "Vector128",    "Int16",     "Vector128",   "Int16",                                  "16",       "(short)(random.Next(short.MinValue, short.MaxValue))", "(short)(random.Next(short.MinValue, short.MaxValue))",               "(short)(left[0] | right[0]) != result[0]",                                                                                           "(short)(left[i] | right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "Or",                           "Vector128",   "Int32",     "Vector128",    "Int32",     "Vector128",   "Int32",                                  "16",       "(int)(random.Next(int.MinValue, int.MaxValue))",       "(int)(random.Next(int.MinValue, int.MaxValue))",                     "(int)(left[0] | right[0]) != result[0]",                                                                                             "(int)(left[i] | right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "Or",                           "Vector128",   "Int64",     "Vector128",    "Int64",     "Vector128",   "Int64",                                  "16",       "(long)(random.Next(int.MinValue, int.MaxValue))",      "(long)(random.Next(int.MinValue, int.MaxValue))",                    "(long)(left[0] | right[0]) != result[0]",                                                                                            "(long)(left[i] | right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "Or",                           "Vector128",   "SByte",     "Vector128",    "SByte",     "Vector128",   "SByte",                                  "16",       "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))", "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",               "(sbyte)(left[0] | right[0]) != result[0]",                                                                                           "(sbyte)(left[i] | right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "Or",                           "Vector128",   "UInt16",    "Vector128",    "UInt16",    "Vector128",   "UInt16",                                 "16",       "(ushort)(random.Next(0, ushort.MaxValue))",            "(ushort)(random.Next(0, ushort.MaxValue))",                          "(ushort)(left[0] | right[0]) != result[0]",                                                                                          "(ushort)(left[i] | right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "Or",                           "Vector128",   "UInt32",    "Vector128",    "UInt32",    "Vector128",   "UInt32",                                 "16",       "(uint)(random.Next(0, int.MaxValue))",                 "(uint)(random.Next(0, int.MaxValue))",                               "(uint)(left[0] | right[0]) != result[0]",                                                                                            "(uint)(left[i] | right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "Or",                           "Vector128",   "UInt64",    "Vector128",    "UInt64",    "Vector128",   "UInt64",                                 "16",       "(ulong)(random.Next(0, int.MaxValue))",                "(ulong)(random.Next(0, int.MaxValue))",                              "(ulong)(left[0] | right[0]) != result[0]",                                                                                           "(ulong)(left[i] | right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "Subtract",                     "Vector128",   "Double",    "Vector128",    "Double",    "Vector128",   "Double",                                 "16",       "(double)(random.NextDouble())",                        "(double)(random.NextDouble())",                                      "BitConverter.DoubleToInt64Bits(left[0] - right[0]) != BitConverter.DoubleToInt64Bits(result[0])",                                    "BitConverter.DoubleToInt64Bits(left[i] - right[i]) != BitConverter.DoubleToInt64Bits(result[i])"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "Subtract",                     "Vector128",   "Byte",      "Vector128",    "Byte",      "Vector128",   "Byte",                                   "16",       "(byte)(random.Next(0, byte.MaxValue))",                "(byte)(random.Next(0, byte.MaxValue))",                              "(byte)(left[0] - right[0]) != result[0]",                                                                                            "(byte)(left[i] - right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "Subtract",                     "Vector128",   "Int16",     "Vector128",    "Int16",     "Vector128",   "Int16",                                  "16",       "(short)(random.Next(short.MinValue, short.MaxValue))", "(short)(random.Next(short.MinValue, short.MaxValue))",               "(short)(left[0] - right[0]) != result[0]",                                                                                           "(short)(left[i] - right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "Subtract",                     "Vector128",   "Int32",     "Vector128",    "Int32",     "Vector128",   "Int32",                                  "16",       "(int)(random.Next(int.MinValue, int.MaxValue))",       "(int)(random.Next(int.MinValue, int.MaxValue))",                     "(int)(left[0] - right[0]) != result[0]",                                                                                             "(int)(left[i] - right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "Subtract",                     "Vector128",   "Int64",     "Vector128",    "Int64",     "Vector128",   "Int64",                                  "16",       "(long)(random.Next(int.MinValue, int.MaxValue))",      "(long)(random.Next(int.MinValue, int.MaxValue))",                    "(long)(left[0] - right[0]) != result[0]",                                                                                            "(long)(left[i] - right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "Subtract",                     "Vector128",   "SByte",     "Vector128",    "SByte",     "Vector128",   "SByte",                                  "16",       "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))", "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",               "(sbyte)(left[0] - right[0]) != result[0]",                                                                                           "(sbyte)(left[i] - right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "Subtract",                     "Vector128",   "UInt16",    "Vector128",    "UInt16",    "Vector128",   "UInt16",                                 "16",       "(ushort)(random.Next(0, ushort.MaxValue))",            "(ushort)(random.Next(0, ushort.MaxValue))",                          "(ushort)(left[0] - right[0]) != result[0]",                                                                                          "(ushort)(left[i] - right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "Subtract",                     "Vector128",   "UInt32",    "Vector128",    "UInt32",    "Vector128",   "UInt32",                                 "16",       "(uint)(random.Next(0, int.MaxValue))",                 "(uint)(random.Next(0, int.MaxValue))",                               "(uint)(left[0] - right[0]) != result[0]",                                                                                            "(uint)(left[i] - right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "Subtract",                     "Vector128",   "UInt64",    "Vector128",    "UInt64",    "Vector128",   "UInt64",                                 "16",       "(ulong)(random.Next(0, int.MaxValue))",                "(ulong)(random.Next(0, int.MaxValue))",                              "(ulong)(left[0] - right[0]) != result[0]",                                                                                           "(ulong)(left[i] - right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "Xor",                          "Vector128",   "Double",    "Vector128",    "Double",    "Vector128",   "Double",                                 "16",       "(double)(random.NextDouble())",                        "(double)(random.NextDouble())",                                      "(BitConverter.DoubleToInt64Bits(left[0]) ^ BitConverter.DoubleToInt64Bits(right[0])) != BitConverter.DoubleToInt64Bits(result[0])",  "(BitConverter.DoubleToInt64Bits(left[i]) ^ BitConverter.DoubleToInt64Bits(right[i])) != BitConverter.DoubleToInt64Bits(result[i])"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "Xor",                          "Vector128",   "Byte",      "Vector128",    "Byte",      "Vector128",   "Byte",                                   "16",       "(byte)(random.Next(0, byte.MaxValue))",                "(byte)(random.Next(0, byte.MaxValue))",                              "(byte)(left[0] ^ right[0]) != result[0]",                                                                                            "(byte)(left[i] ^ right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "Xor",                          "Vector128",   "Int16",     "Vector128",    "Int16",     "Vector128",   "Int16",                                  "16",       "(short)(random.Next(short.MinValue, short.MaxValue))", "(short)(random.Next(short.MinValue, short.MaxValue))",               "(short)(left[0] ^ right[0]) != result[0]",                                                                                           "(short)(left[i] ^ right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "Xor",                          "Vector128",   "Int32",     "Vector128",    "Int32",     "Vector128",   "Int32",                                  "16",       "(int)(random.Next(int.MinValue, int.MaxValue))",       "(int)(random.Next(int.MinValue, int.MaxValue))",                     "(int)(left[0] ^ right[0]) != result[0]",                                                                                             "(int)(left[i] ^ right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "Xor",                          "Vector128",   "Int64",     "Vector128",    "Int64",     "Vector128",   "Int64",                                  "16",       "(long)(random.Next(int.MinValue, int.MaxValue))",      "(long)(random.Next(int.MinValue, int.MaxValue))",                    "(long)(left[0] ^ right[0]) != result[0]",                                                                                            "(long)(left[i] ^ right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "Xor",                          "Vector128",   "SByte",     "Vector128",    "SByte",     "Vector128",   "SByte",                                  "16",       "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))", "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",               "(sbyte)(left[0] ^ right[0]) != result[0]",                                                                                           "(sbyte)(left[i] ^ right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "Xor",                          "Vector128",   "UInt16",    "Vector128",    "UInt16",    "Vector128",   "UInt16",                                 "16",       "(ushort)(random.Next(0, ushort.MaxValue))",            "(ushort)(random.Next(0, ushort.MaxValue))",                          "(ushort)(left[0] ^ right[0]) != result[0]",                                                                                          "(ushort)(left[i] ^ right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "Xor",                          "Vector128",   "UInt32",    "Vector128",    "UInt32",    "Vector128",   "UInt32",                                 "16",       "(uint)(random.Next(0, int.MaxValue))",                 "(uint)(random.Next(0, int.MaxValue))",                               "(uint)(left[0] ^ right[0]) != result[0]",                                                                                            "(uint)(left[i] ^ right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template", new string[] { "Sse2", "Sse2",  "Xor",                          "Vector128",   "UInt64",    "Vector128",    "UInt64",    "Vector128",   "UInt64",                                 "16",       "(ulong)(random.Next(0, int.MaxValue))",                "(ulong)(random.Next(0, int.MaxValue))",                              "(ulong)(left[0] ^ right[0]) != result[0]",                                                                                           "(ulong)(left[i] ^ right[i]) != result[i]"}),
-    
-    // IMM intrinsics
-    // TemplateName                              Isa,    LoadIsa,     Method,                            RetVectorType, RetBaseType, Op1VectorType, Op1BaseType,      IMM,        VectorSize,          NextValueOp1,                                             ValidateFirstResult,                                                                 ValidateRemainingResults
-    ("ImmUnOpTest.template",    new string[] { "Sse2",  "Sse2",    "ShiftLeftLogical",                    "Vector128",  "Int16",      "Vector128",  "Int16",           "1",         "16",       "(short)(random.Next(0, short.MaxValue))",                "(short)(firstOp[0] << 1) != result[0]",                                            "(short)(firstOp[i] << 1) != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Sse2",  "Sse2",    "ShiftLeftLogical",                    "Vector128",  "UInt16",     "Vector128",  "UInt16",          "1",         "16",       "(ushort)(random.Next(0, ushort.MaxValue))",              "(ushort)(firstOp[0] << 1) != result[0]",                                           "(ushort)(firstOp[i] << 1) != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Sse2",  "Sse2",    "ShiftLeftLogical",                    "Vector128",  "Int32",      "Vector128",  "Int32",           "1",         "16",       "(int)(random.Next(0, int.MaxValue))",                    "(int)(firstOp[0] << 1) != result[0]",                                              "(int)(firstOp[i] << 1) != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Sse2",  "Sse2",    "ShiftLeftLogical",                    "Vector128",  "UInt32",     "Vector128",  "UInt32",          "1",         "16",       "(uint)(random.Next(0, int.MaxValue))",                   "(uint)(firstOp[0] << 1) != result[0]",                                             "(uint)(firstOp[i] << 1) != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Sse2",  "Sse2",    "ShiftLeftLogical",                    "Vector128",  "Int64",      "Vector128",  "Int64",           "1",         "16",       "(long)(random.Next(0, int.MaxValue))",                   "(long)(firstOp[0] << 1) != result[0]",                                             "(long)(firstOp[i] << 1) != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Sse2",  "Sse2",    "ShiftLeftLogical",                    "Vector128",  "UInt64",     "Vector128",  "UInt64",          "1",         "16",       "(ulong)(random.Next(0, int.MaxValue))",                  "(ulong)(firstOp[0] << 1) != result[0]",                                            "(ulong)(firstOp[i] << 1) != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Sse2",  "Sse2",    "ShiftLeftLogical",                    "Vector128",  "Int16",      "Vector128",  "Int16",           "16",        "16",       "(short)(random.Next(0, short.MaxValue))",                "0 != result[0]",                                                                   "0 != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Sse2",  "Sse2",    "ShiftLeftLogical",                    "Vector128",  "UInt16",     "Vector128",  "UInt16",          "16",        "16",       "(ushort)(random.Next(0, ushort.MaxValue))",              "0 != result[0]",                                                                   "0 != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Sse2",  "Sse2",    "ShiftLeftLogical",                    "Vector128",  "Int32",      "Vector128",  "Int32",           "32",        "16",       "(int)(random.Next(0, int.MaxValue))",                    "0 != result[0]",                                                                   "0 != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Sse2",  "Sse2",    "ShiftLeftLogical",                    "Vector128",  "UInt32",     "Vector128",  "UInt32",          "32",        "16",       "(uint)(random.Next(0, int.MaxValue))",                   "0 != result[0]",                                                                   "0!= result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Sse2",  "Sse2",    "ShiftLeftLogical",                    "Vector128",  "Int64",      "Vector128",  "Int64",           "64",        "16",       "(long)(random.Next(0, int.MaxValue))",                   "0 != result[0]",                                                                   "0 != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Sse2",  "Sse2",    "ShiftLeftLogical",                    "Vector128",  "UInt64",     "Vector128",  "UInt64",          "64",        "16",       "(ulong)(random.Next(0, int.MaxValue))",                  "0 != result[0]",                                                                   "0 != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Sse2",  "Sse2",    "ShiftRightLogical",                   "Vector128",  "Int16",      "Vector128",  "Int16",           "1",         "16",       "(short)(random.Next(0, short.MaxValue))",                "(short)(firstOp[0] >> 1) != result[0]",                                            "(short)(firstOp[i] >> 1) != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Sse2",  "Sse2",    "ShiftRightLogical",                   "Vector128",  "UInt16",     "Vector128",  "UInt16",          "1",         "16",       "(ushort)(random.Next(0, ushort.MaxValue))",              "(ushort)(firstOp[0] >> 1) != result[0]",                                           "(ushort)(firstOp[i] >> 1) != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Sse2",  "Sse2",    "ShiftRightLogical",                   "Vector128",  "Int32",      "Vector128",  "Int32",           "1",         "16",       "(int)(random.Next(0, int.MaxValue))",                    "(int)(firstOp[0] >> 1) != result[0]",                                              "(int)(firstOp[i] >> 1) != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Sse2",  "Sse2",    "ShiftRightLogical",                   "Vector128",  "UInt32",     "Vector128",  "UInt32",          "1",         "16",       "(uint)(random.Next(0, int.MaxValue))",                   "(uint)(firstOp[0] >> 1) != result[0]",                                             "(uint)(firstOp[i] >> 1) != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Sse2",  "Sse2",    "ShiftRightLogical",                   "Vector128",  "Int64",      "Vector128",  "Int64",           "1",         "16",       "(long)(random.Next(0, int.MaxValue))",                   "(long)(firstOp[0] >> 1) != result[0]",                                             "(long)(firstOp[i] >> 1) != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Sse2",  "Sse2",    "ShiftRightLogical",                   "Vector128",  "UInt64",     "Vector128",  "UInt64",          "1",         "16",       "(ulong)(random.Next(0, int.MaxValue))",                  "(ulong)(firstOp[0] >> 1) != result[0]",                                            "(ulong)(firstOp[i] >> 1) != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Sse2",  "Sse2",    "ShiftRightLogical",                   "Vector128",  "Int16",      "Vector128",  "Int16",           "16",        "16",       "(short)(random.Next(0, short.MaxValue))",                "0 != result[0]",                                                                   "0 != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Sse2",  "Sse2",    "ShiftRightLogical",                   "Vector128",  "UInt16",     "Vector128",  "UInt16",          "16",        "16",       "(ushort)(random.Next(0, ushort.MaxValue))",              "0 != result[0]",                                                                   "0 != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Sse2",  "Sse2",    "ShiftRightLogical",                   "Vector128",  "Int32",      "Vector128",  "Int32",           "32",        "16",       "(int)(random.Next(0, int.MaxValue))",                    "0 != result[0]",                                                                   "0 != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Sse2",  "Sse2",    "ShiftRightLogical",                   "Vector128",  "UInt32",     "Vector128",  "UInt32",          "32",        "16",       "(uint)(random.Next(0, int.MaxValue))",                   "0 != result[0]",                                                                   "0!= result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Sse2",  "Sse2",    "ShiftRightLogical",                   "Vector128",  "Int64",      "Vector128",  "Int64",           "64",        "16",       "(long)(random.Next(0, int.MaxValue))",                   "0 != result[0]",                                                                   "0 != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Sse2",  "Sse2",    "ShiftRightLogical",                   "Vector128",  "UInt64",     "Vector128",  "UInt64",          "64",        "16",       "(ulong)(random.Next(0, int.MaxValue))",                  "0 != result[0]",                                                                   "0 != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Sse2",  "Sse2",    "ShiftRightArithmetic",                "Vector128",  "Int16",      "Vector128",  "Int16",           "1",         "16",       "(short)(random.Next(0, short.MaxValue))",                "(short)(firstOp[0] >> 1) != result[0]",                                            "(short)(firstOp[i] >> 1) != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Sse2",  "Sse2",    "ShiftRightArithmetic",                "Vector128",  "Int32",      "Vector128",  "Int32",           "1",         "16",       "(int)(random.Next(0, int.MaxValue))",                    "(int)(firstOp[0] >> 1) != result[0]",                                              "(int)(firstOp[i] >> 1) != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Sse2",  "Sse2",    "ShiftRightArithmetic",                "Vector128",  "Int16",      "Vector128",  "Int16",           "16",        "16",       "(short)(random.Next(0, short.MaxValue))",                "(short)(firstOp[0] >> 15) != result[0]",                                           "(short)(firstOp[i] >> 15) != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Sse2",  "Sse2",    "ShiftRightArithmetic",                "Vector128",  "Int32",      "Vector128",  "Int32",           "32",        "16",       "(int)(random.Next(0, int.MaxValue))",                    "(int)(firstOp[0] >> 31) != result[0]",                                             "(int)(firstOp[i] >> 31) != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Sse2",  "Sse2",    "ShiftLeftLogical128BitLane",          "Vector128",  "SByte",      "Vector128",  "SByte",           "1",         "16",      "(sbyte)8",                                                "result[0] != 0",                                                                    "result[i] != 8"}),
-    ("ImmUnOpTest.template",    new string[] { "Sse2",  "Sse2",    "ShiftLeftLogical128BitLane",          "Vector128",  "Byte",       "Vector128",  "Byte",            "1",         "16",      "(byte)8",                                                 "result[0] != 0",                                                                    "result[i] != 8"}),
-    ("ImmUnOpTest.template",    new string[] { "Sse2",  "Sse2",    "ShiftLeftLogical128BitLane",          "Vector128",  "Int16",      "Vector128",  "Int16",           "1",         "16",      "(short)8",                                                "result[0] != 2048",                                                                 "result[i] != 2048"}),
-    ("ImmUnOpTest.template",    new string[] { "Sse2",  "Sse2",    "ShiftLeftLogical128BitLane",          "Vector128",  "UInt16",     "Vector128",  "UInt16",          "1",         "16",      "(ushort)8",                                               "result[0] != 2048",                                                                 "result[i] != 2048"}),
-    ("ImmUnOpTest.template",    new string[] { "Sse2",  "Sse2",    "ShiftLeftLogical128BitLane",          "Vector128",  "Int32",      "Vector128",  "Int32",           "1",         "16",      "(int)8",                                                  "result[0] != 2048",                                                                 "result[i] != 2048"}),
-    ("ImmUnOpTest.template",    new string[] { "Sse2",  "Sse2",    "ShiftLeftLogical128BitLane",          "Vector128",  "UInt32",     "Vector128",  "UInt32",          "1",         "16",      "(uint)8",                                                 "result[0] != 2048",                                                                 "result[i] != 2048"}),
-    ("ImmUnOpTest.template",    new string[] { "Sse2",  "Sse2",    "ShiftLeftLogical128BitLane",          "Vector128",  "Int64",      "Vector128",  "Int64",           "1",         "16",      "(long)8",                                                 "result[0] != 2048",                                                                 "result[i] != 2048"}),
-    ("ImmUnOpTest.template",    new string[] { "Sse2",  "Sse2",    "ShiftLeftLogical128BitLane",          "Vector128",  "UInt64",     "Vector128",  "UInt64",          "1",         "16",      "(ulong)8",                                                "result[0] != 2048",                                                                 "result[i] != 2048"}),
-    ("ImmUnOpTest.template",    new string[] { "Sse2",  "Sse2",    "ShiftRightLogical128BitLane",          "Vector128",  "SByte",     "Vector128",  "SByte",           "1",         "16",      "(sbyte)8",                                                "result[0] != 8",                                                                   "(i == 15 ? result[i] != 0 : result[i] != 8)"}),
-    ("ImmUnOpTest.template",    new string[] { "Sse2",  "Sse2",    "ShiftRightLogical128BitLane",          "Vector128",  "Byte",      "Vector128",  "Byte",            "1",         "16",      "(byte)8",                                                 "result[0] != 8",                                                                   "(i == 15 ? result[i] != 0 : result[i] != 8)"}),
-    ("ImmUnOpTest.template",    new string[] { "Sse2",  "Sse2",    "ShiftRightLogical128BitLane",          "Vector128",  "Int16",     "Vector128",  "Int16",           "1",         "16",      "(short)8",                                                "result[0] != 2048",                                                                "(i == 7 ? result[i] != 0 : result[i] != 2048)"}),
-    ("ImmUnOpTest.template",    new string[] { "Sse2",  "Sse2",    "ShiftRightLogical128BitLane",          "Vector128",  "UInt16",    "Vector128",  "UInt16",          "1",         "16",      "(ushort)8",                                               "result[0] != 2048",                                                                "(i == 7 ? result[i] != 0 : result[i] != 2048)"}),
-    ("ImmUnOpTest.template",    new string[] { "Sse2",  "Sse2",    "ShiftRightLogical128BitLane",          "Vector128",  "Int32",     "Vector128",  "Int32",           "1",         "16",      "(int)8",                                                  "result[0] != 134217728",                                                           "(i == 3 ? result[i] != 0 : result[i] != 134217728)"}),
-    ("ImmUnOpTest.template",    new string[] { "Sse2",  "Sse2",    "ShiftRightLogical128BitLane",          "Vector128",  "UInt32",    "Vector128",  "UInt32",          "1",         "16",      "(uint)8",                                                 "result[0] != 134217728",                                                           "(i == 3 ? result[i] != 0 : result[i] != 134217728)"}),
-    ("ImmUnOpTest.template",    new string[] { "Sse2",  "Sse2",    "ShiftRightLogical128BitLane",          "Vector128",  "Int64",     "Vector128",  "Int64",           "1",         "16",      "(long)8",                                                 "result[0] != 576460752303423488L",                                                 "(result[i] != 0)"}),
-    ("ImmUnOpTest.template",    new string[] { "Sse2",  "Sse2",    "ShiftRightLogical128BitLane",          "Vector128",  "UInt64",    "Vector128",  "UInt64",          "1",         "16",      "(ulong)8",                                                "result[0] != 576460752303423488UL",                                                "(result[i] != 0)"}),
-    ("ExtractScalarTest.template",new string[] {"Sse2", "Sse2",    "Extract",                              "Vector128",  "Int16",     "Vector128",   "Int16",          "1",              "16", "(short)(random.Next(0, int.MaxValue))",                   "(result[0] != firstOp[1])"}),
-    ("ExtractScalarTest.template",new string[] {"Sse2", "Sse2",    "Extract",                              "Vector128",  "UInt16",    "Vector128",   "UInt16",         "1",              "16", "(ushort)(random.Next(0, int.MaxValue))",                  "(result[0] != firstOp[1])"}),
-    ("ExtractScalarTest.template",new string[] {"Sse2", "Sse2",    "Extract",                              "Vector128",  "Int16",     "Vector128",   "Int16",          "129",            "16", "(short)(random.Next(0, int.MaxValue))",                   "(result[0] != firstOp[1])"}),
-    ("ExtractScalarTest.template",new string[] {"Sse2", "Sse2",    "Extract",                              "Vector128",  "UInt16",    "Vector128",   "UInt16",         "129",            "16", "(ushort)(random.Next(0, int.MaxValue))",                  "(result[0] != firstOp[1])"}),
-    ("InsertScalarTest.template",new string[] { "Sse2", "Sse2",    "Insert",                               "Vector128",  "Int16",     "Vector128",   "Int16",          "1",  "(short)2", "16", "(short)0",                                               "(i == 1 ? result[i] != 2 : result[i] != 0)"}),
-    ("InsertScalarTest.template",new string[] { "Sse2", "Sse2",    "Insert",                               "Vector128",  "UInt16",    "Vector128",   "UInt16",         "1",  "(ushort)2","16", "(ushort)0",                                              "(i == 1 ? result[i] != 2 : result[i] != 0)"}),
-    ("InsertScalarTest.template",new string[] { "Sse2", "Sse2",    "Insert",                               "Vector128",  "Int16",     "Vector128",   "Int16",          "129","(short)2", "16", "(short)0",                                               "(i == 1 ? result[i] != 2 : result[i] != 0)"}),
-    ("InsertScalarTest.template",new string[] { "Sse2", "Sse2",    "Insert",                               "Vector128",  "UInt16",    "Vector128",   "UInt16",         "129","(ushort)2","16", "(ushort)0",                                              "(i == 1 ? result[i] != 2 : result[i] != 0)"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Add",                          ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double",                                          ["VectorSize"] = "16", ["NextValueOp1"] = "(double)(random.NextDouble())",                        ["NextValueOp2"] = "(double)(random.NextDouble())",                                     ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(left[0] + right[0]) != BitConverter.DoubleToInt64Bits(result[0])",                                    ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(left[i] + right[i]) != BitConverter.DoubleToInt64Bits(result[i])"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Add",                          ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Byte",   ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Byte",   ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Byte",                                            ["VectorSize"] = "16", ["NextValueOp1"] = "(byte)(random.Next(0, byte.MaxValue))",                ["NextValueOp2"] = "(byte)(random.Next(0, byte.MaxValue))",                             ["ValidateFirstResult"] = "(byte)(left[0] + right[0]) != result[0]",                                                                                            ["ValidateRemainingResults"] = "(byte)(left[i] + right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Add",                          ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int16",                                           ["VectorSize"] = "16", ["NextValueOp1"] = "(short)(random.Next(short.MinValue, short.MaxValue))", ["NextValueOp2"] = "(short)(random.Next(short.MinValue, short.MaxValue))",              ["ValidateFirstResult"] = "(short)(left[0] + right[0]) != result[0]",                                                                                           ["ValidateRemainingResults"] = "(short)(left[i] + right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Add",                          ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int32",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int32",                                           ["VectorSize"] = "16", ["NextValueOp1"] = "(int)(random.Next(int.MinValue, int.MaxValue))",       ["NextValueOp2"] = "(int)(random.Next(int.MinValue, int.MaxValue))",                    ["ValidateFirstResult"] = "(int)(left[0] + right[0]) != result[0]",                                                                                             ["ValidateRemainingResults"] = "(int)(left[i] + right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Add",                          ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int64",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int64",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int64",                                           ["VectorSize"] = "16", ["NextValueOp1"] = "(long)(random.Next(int.MinValue, int.MaxValue))",      ["NextValueOp2"] = "(long)(random.Next(int.MinValue, int.MaxValue))",                   ["ValidateFirstResult"] = "(long)(left[0] + right[0]) != result[0]",                                                                                            ["ValidateRemainingResults"] = "(long)(left[i] + right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Add",                          ["RetVectorType"] = "Vector128", ["RetBaseType"] = "SByte",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "SByte",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "SByte",                                           ["VectorSize"] = "16", ["NextValueOp1"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))", ["NextValueOp2"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",              ["ValidateFirstResult"] = "(sbyte)(left[0] + right[0]) != result[0]",                                                                                           ["ValidateRemainingResults"] = "(sbyte)(left[i] + right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Add",                          ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt16",                                          ["VectorSize"] = "16", ["NextValueOp1"] = "(ushort)(random.Next(0, ushort.MaxValue))",            ["NextValueOp2"] = "(ushort)(random.Next(0, ushort.MaxValue))",                         ["ValidateFirstResult"] = "(ushort)(left[0] + right[0]) != result[0]",                                                                                          ["ValidateRemainingResults"] = "(ushort)(left[i] + right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Add",                          ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt32",                                          ["VectorSize"] = "16", ["NextValueOp1"] = "(uint)(random.Next(0, int.MaxValue))",                 ["NextValueOp2"] = "(uint)(random.Next(0, int.MaxValue))",                              ["ValidateFirstResult"] = "(uint)(left[0] + right[0]) != result[0]",                                                                                            ["ValidateRemainingResults"] = "(uint)(left[i] + right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Add",                          ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt64",                                          ["VectorSize"] = "16", ["NextValueOp1"] = "(ulong)(random.Next(0, int.MaxValue))",                ["NextValueOp2"] = "(ulong)(random.Next(0, int.MaxValue))",                             ["ValidateFirstResult"] = "(ulong)(left[0] + right[0]) != result[0]",                                                                                           ["ValidateRemainingResults"] = "(ulong)(left[i] + right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "And",                          ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double",                                          ["VectorSize"] = "16", ["NextValueOp1"] = "(double)(random.NextDouble())",                        ["NextValueOp2"] = "(double)(random.NextDouble())",                                     ["ValidateFirstResult"] = "(BitConverter.DoubleToInt64Bits(left[0]) & BitConverter.DoubleToInt64Bits(right[0])) != BitConverter.DoubleToInt64Bits(result[0])",  ["ValidateRemainingResults"] = "(BitConverter.DoubleToInt64Bits(left[i]) & BitConverter.DoubleToInt64Bits(right[i])) != BitConverter.DoubleToInt64Bits(result[i])"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "And",                          ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Byte",   ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Byte",   ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Byte",                                            ["VectorSize"] = "16", ["NextValueOp1"] = "(byte)(random.Next(0, byte.MaxValue))",                ["NextValueOp2"] = "(byte)(random.Next(0, byte.MaxValue))",                             ["ValidateFirstResult"] = "(byte)(left[0] & right[0]) != result[0]",                                                                                            ["ValidateRemainingResults"] = "(byte)(left[i] & right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "And",                          ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int16",                                           ["VectorSize"] = "16", ["NextValueOp1"] = "(short)(random.Next(short.MinValue, short.MaxValue))", ["NextValueOp2"] = "(short)(random.Next(short.MinValue, short.MaxValue))",              ["ValidateFirstResult"] = "(short)(left[0] & right[0]) != result[0]",                                                                                           ["ValidateRemainingResults"] = "(short)(left[i] & right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "And",                          ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int32",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int32",                                           ["VectorSize"] = "16", ["NextValueOp1"] = "(int)(random.Next(int.MinValue, int.MaxValue))",       ["NextValueOp2"] = "(int)(random.Next(int.MinValue, int.MaxValue))",                    ["ValidateFirstResult"] = "(int)(left[0] & right[0]) != result[0]",                                                                                             ["ValidateRemainingResults"] = "(int)(left[i] & right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "And",                          ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int64",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int64",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int64",                                           ["VectorSize"] = "16", ["NextValueOp1"] = "(long)(random.Next(int.MinValue, int.MaxValue))",      ["NextValueOp2"] = "(long)(random.Next(int.MinValue, int.MaxValue))",                   ["ValidateFirstResult"] = "(long)(left[0] & right[0]) != result[0]",                                                                                            ["ValidateRemainingResults"] = "(long)(left[i] & right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "And",                          ["RetVectorType"] = "Vector128", ["RetBaseType"] = "SByte",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "SByte",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "SByte",                                           ["VectorSize"] = "16", ["NextValueOp1"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))", ["NextValueOp2"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",              ["ValidateFirstResult"] = "(sbyte)(left[0] & right[0]) != result[0]",                                                                                           ["ValidateRemainingResults"] = "(sbyte)(left[i] & right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "And",                          ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt16",                                          ["VectorSize"] = "16", ["NextValueOp1"] = "(ushort)(random.Next(0, ushort.MaxValue))",            ["NextValueOp2"] = "(ushort)(random.Next(0, ushort.MaxValue))",                         ["ValidateFirstResult"] = "(ushort)(left[0] & right[0]) != result[0]",                                                                                          ["ValidateRemainingResults"] = "(ushort)(left[i] & right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "And",                          ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt32",                                          ["VectorSize"] = "16", ["NextValueOp1"] = "(uint)(random.Next(0, int.MaxValue))",                 ["NextValueOp2"] = "(uint)(random.Next(0, int.MaxValue))",                              ["ValidateFirstResult"] = "(uint)(left[0] & right[0]) != result[0]",                                                                                            ["ValidateRemainingResults"] = "(uint)(left[i] & right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "And",                          ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt64",                                          ["VectorSize"] = "16", ["NextValueOp1"] = "(ulong)(random.Next(0, int.MaxValue))",                ["NextValueOp2"] = "(ulong)(random.Next(0, int.MaxValue))",                             ["ValidateFirstResult"] = "(ulong)(left[0] & right[0]) != result[0]",                                                                                           ["ValidateRemainingResults"] = "(ulong)(left[i] & right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "AndNot",                       ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double",                                          ["VectorSize"] = "16", ["NextValueOp1"] = "(double)(random.NextDouble())",                        ["NextValueOp2"] = "(double)(random.NextDouble())",                                     ["ValidateFirstResult"] = "(~BitConverter.DoubleToInt64Bits(left[0]) & BitConverter.DoubleToInt64Bits(right[0])) != BitConverter.DoubleToInt64Bits(result[0])", ["ValidateRemainingResults"] = "(~BitConverter.DoubleToInt64Bits(left[i]) & BitConverter.DoubleToInt64Bits(right[i])) != BitConverter.DoubleToInt64Bits(result[i])"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "AndNot",                       ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Byte",   ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Byte",   ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Byte",                                            ["VectorSize"] = "16", ["NextValueOp1"] = "(byte)(random.Next(0, byte.MaxValue))",                ["NextValueOp2"] = "(byte)(random.Next(0, byte.MaxValue))",                             ["ValidateFirstResult"] = "(byte)(~left[0] & right[0]) != result[0]",                                                                                           ["ValidateRemainingResults"] = "(byte)(~left[i] & right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "AndNot",                       ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int16",                                           ["VectorSize"] = "16", ["NextValueOp1"] = "(short)(random.Next(short.MinValue, short.MaxValue))", ["NextValueOp2"] = "(short)(random.Next(short.MinValue, short.MaxValue))",              ["ValidateFirstResult"] = "(short)(~left[0] & right[0]) != result[0]",                                                                                          ["ValidateRemainingResults"] = "(short)(~left[i] & right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "AndNot",                       ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int32",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int32",                                           ["VectorSize"] = "16", ["NextValueOp1"] = "(int)(random.Next(int.MinValue, int.MaxValue))",       ["NextValueOp2"] = "(int)(random.Next(int.MinValue, int.MaxValue))",                    ["ValidateFirstResult"] = "(int)(~left[0] & right[0]) != result[0]",                                                                                            ["ValidateRemainingResults"] = "(int)(~left[i] & right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "AndNot",                       ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int64",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int64",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int64",                                           ["VectorSize"] = "16", ["NextValueOp1"] = "(long)(random.Next(int.MinValue, int.MaxValue))",      ["NextValueOp2"] = "(long)(random.Next(int.MinValue, int.MaxValue))",                   ["ValidateFirstResult"] = "(long)(~left[0] & right[0]) != result[0]",                                                                                           ["ValidateRemainingResults"] = "(long)(~left[i] & right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "AndNot",                       ["RetVectorType"] = "Vector128", ["RetBaseType"] = "SByte",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "SByte",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "SByte",                                           ["VectorSize"] = "16", ["NextValueOp1"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))", ["NextValueOp2"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",              ["ValidateFirstResult"] = "(sbyte)(~left[0] & right[0]) != result[0]",                                                                                          ["ValidateRemainingResults"] = "(sbyte)(~left[i] & right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "AndNot",                       ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt16",                                          ["VectorSize"] = "16", ["NextValueOp1"] = "(ushort)(random.Next(0, ushort.MaxValue))",            ["NextValueOp2"] = "(ushort)(random.Next(0, ushort.MaxValue))",                         ["ValidateFirstResult"] = "(ushort)(~left[0] & right[0]) != result[0]",                                                                                         ["ValidateRemainingResults"] = "(ushort)(~left[i] & right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "AndNot",                       ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt32",                                          ["VectorSize"] = "16", ["NextValueOp1"] = "(uint)(random.Next(0, int.MaxValue))",                 ["NextValueOp2"] = "(uint)(random.Next(0, int.MaxValue))",                              ["ValidateFirstResult"] = "(uint)(~left[0] & right[0]) != result[0]",                                                                                           ["ValidateRemainingResults"] = "(uint)(~left[i] & right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "AndNot",                       ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt64",                                          ["VectorSize"] = "16", ["NextValueOp1"] = "(ulong)(random.Next(0, int.MaxValue))",                ["NextValueOp2"] = "(ulong)(random.Next(0, int.MaxValue))",                             ["ValidateFirstResult"] = "(ulong)(~left[0] & right[0]) != result[0]",                                                                                          ["ValidateRemainingResults"] = "(ulong)(~left[i] & right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareEqual",                 ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double",                                          ["VectorSize"] = "16", ["NextValueOp1"] = "(double)(random.NextDouble())",                        ["NextValueOp2"] = "(double)(random.NextDouble())",                                     ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != ((left[0] == right[0]) ? -1 : 0)",                                                      ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != ((left[i] == right[i]) ? -1 : 0)"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareEqual",                 ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Byte",   ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Byte",   ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Byte",                                            ["VectorSize"] = "16", ["NextValueOp1"] = "(byte)(random.Next(0, byte.MaxValue))",                ["NextValueOp2"] = "(byte)(random.Next(0, byte.MaxValue))",                             ["ValidateFirstResult"] = "result[0] != ((left[0] == right[0]) ? unchecked((byte)(-1)) : 0)",                                                                   ["ValidateRemainingResults"] = "result[i] != ((left[i] == right[i]) ? unchecked((byte)(-1)) : 0)"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareEqual",                 ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int16",                                           ["VectorSize"] = "16", ["NextValueOp1"] = "(short)(random.Next(short.MinValue, short.MaxValue))", ["NextValueOp2"] = "(short)(random.Next(short.MinValue, short.MaxValue))",              ["ValidateFirstResult"] = "result[0] != ((left[0] == right[0]) ? unchecked((short)(-1)) : 0)",                                                                  ["ValidateRemainingResults"] = "result[i] != ((left[i] == right[i]) ? unchecked((short)(-1)) : 0)"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareEqual",                 ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int32",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int32",                                           ["VectorSize"] = "16", ["NextValueOp1"] = "(int)(random.Next(int.MinValue, int.MaxValue))",       ["NextValueOp2"] = "(int)(random.Next(int.MinValue, int.MaxValue))",                    ["ValidateFirstResult"] = "result[0] != ((left[0] == right[0]) ? unchecked((int)(-1)) : 0)",                                                                    ["ValidateRemainingResults"] = "result[i] != ((left[i] == right[i]) ? unchecked((int)(-1)) : 0)"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareEqual",                 ["RetVectorType"] = "Vector128", ["RetBaseType"] = "SByte",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "SByte",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "SByte",                                           ["VectorSize"] = "16", ["NextValueOp1"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))", ["NextValueOp2"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",              ["ValidateFirstResult"] = "result[0] != ((left[0] == right[0]) ? unchecked((sbyte)(-1)) : 0)",                                                                  ["ValidateRemainingResults"] = "result[i] != ((left[i] == right[i]) ? unchecked((sbyte)(-1)) : 0)"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareEqual",                 ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt16",                                          ["VectorSize"] = "16", ["NextValueOp1"] = "(ushort)(random.Next(0, ushort.MaxValue))",            ["NextValueOp2"] = "(ushort)(random.Next(0, ushort.MaxValue))",                         ["ValidateFirstResult"] = "result[0] != ((left[0] == right[0]) ? unchecked((ushort)(-1)) : 0)",                                                                 ["ValidateRemainingResults"] = "result[i] != ((left[i] == right[i]) ? unchecked((ushort)(-1)) : 0)"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareEqual",                 ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt32",                                          ["VectorSize"] = "16", ["NextValueOp1"] = "(uint)(random.Next(0, int.MaxValue))",                 ["NextValueOp2"] = "(uint)(random.Next(0, int.MaxValue))",                              ["ValidateFirstResult"] = "result[0] != ((left[0] == right[0]) ? unchecked((uint)(-1)) : 0)",                                                                   ["ValidateRemainingResults"] = "result[i] != ((left[i] == right[i]) ? unchecked((uint)(-1)) : 0)"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareGreaterThan",           ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double",                                          ["VectorSize"] = "16", ["NextValueOp1"] = "(double)(random.NextDouble())",                        ["NextValueOp2"] = "(double)(random.NextDouble())",                                     ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != ((left[0] > right[0]) ? -1 : 0)",                                                       ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != ((left[i] > right[i]) ? -1 : 0)"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareGreaterThan",           ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int16",                                           ["VectorSize"] = "16", ["NextValueOp1"] = "(short)(random.Next(short.MinValue, short.MaxValue))", ["NextValueOp2"] = "(short)(random.Next(short.MinValue, short.MaxValue))",              ["ValidateFirstResult"] = "result[0] != ((left[0] > right[0]) ? unchecked((short)(-1)) : 0)",                                                                   ["ValidateRemainingResults"] = "result[i] != ((left[i] > right[i]) ? unchecked((short)(-1)) : 0)"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareGreaterThan",           ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int32",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int32",                                           ["VectorSize"] = "16", ["NextValueOp1"] = "(int)(random.Next(int.MinValue, int.MaxValue))",       ["NextValueOp2"] = "(int)(random.Next(int.MinValue, int.MaxValue))",                    ["ValidateFirstResult"] = "result[0] != ((left[0] > right[0]) ? unchecked((int)(-1)) : 0)",                                                                     ["ValidateRemainingResults"] = "result[i] != ((left[i] > right[i]) ? unchecked((int)(-1)) : 0)"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareGreaterThan",           ["RetVectorType"] = "Vector128", ["RetBaseType"] = "SByte",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "SByte",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "SByte",                                           ["VectorSize"] = "16", ["NextValueOp1"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))", ["NextValueOp2"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",              ["ValidateFirstResult"] = "result[0] != ((left[0] > right[0]) ? unchecked((sbyte)(-1)) : 0)",                                                                   ["ValidateRemainingResults"] = "result[i] != ((left[i] > right[i]) ? unchecked((sbyte)(-1)) : 0)"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareGreaterThanOrEqual",    ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double",                                          ["VectorSize"] = "16", ["NextValueOp1"] = "(double)(random.NextDouble())",                        ["NextValueOp2"] = "(double)(random.NextDouble())",                                     ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != ((left[0] >= right[0]) ? -1 : 0)",                                                      ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != ((left[i] >= right[i]) ? -1 : 0)"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareLessThan",              ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double",                                          ["VectorSize"] = "16", ["NextValueOp1"] = "(double)(random.NextDouble())",                        ["NextValueOp2"] = "(double)(random.NextDouble())",                                     ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != ((left[0] < right[0]) ? -1 : 0)",                                                       ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != ((left[i] < right[i]) ? -1 : 0)"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareLessThan",              ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int16",                                           ["VectorSize"] = "16", ["NextValueOp1"] = "(short)(random.Next(short.MinValue, short.MaxValue))", ["NextValueOp2"] = "(short)(random.Next(short.MinValue, short.MaxValue))",              ["ValidateFirstResult"] = "result[0] != ((left[0] < right[0]) ? unchecked((short)(-1)) : 0)",                                                                   ["ValidateRemainingResults"] = "result[i] != ((left[i] < right[i]) ? unchecked((short)(-1)) : 0)"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareLessThan",              ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int32",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int32",                                           ["VectorSize"] = "16", ["NextValueOp1"] = "(int)(random.Next(int.MinValue, int.MaxValue))",       ["NextValueOp2"] = "(int)(random.Next(int.MinValue, int.MaxValue))",                    ["ValidateFirstResult"] = "result[0] != ((left[0] < right[0]) ? unchecked((int)(-1)) : 0)",                                                                     ["ValidateRemainingResults"] = "result[i] != ((left[i] < right[i]) ? unchecked((int)(-1)) : 0)"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareLessThan",              ["RetVectorType"] = "Vector128", ["RetBaseType"] = "SByte",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "SByte",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "SByte",                                           ["VectorSize"] = "16", ["NextValueOp1"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))", ["NextValueOp2"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",              ["ValidateFirstResult"] = "result[0] != ((left[0] < right[0]) ? unchecked((sbyte)(-1)) : 0)",                                                                   ["ValidateRemainingResults"] = "result[i] != ((left[i] < right[i]) ? unchecked((sbyte)(-1)) : 0)"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareLessThanOrEqual",       ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double",                                          ["VectorSize"] = "16", ["NextValueOp1"] = "(double)(random.NextDouble())",                        ["NextValueOp2"] = "(double)(random.NextDouble())",                                     ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != ((left[0] <= right[0]) ? -1 : 0)",                                                      ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != ((left[i] <= right[i]) ? -1 : 0)"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareNotEqual",              ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double",                                          ["VectorSize"] = "16", ["NextValueOp1"] = "(double)(random.NextDouble())",                        ["NextValueOp2"] = "(double)(random.NextDouble())",                                     ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != ((left[0] != right[0]) ? -1 : 0)",                                                      ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != ((left[i] != right[i]) ? -1 : 0)"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareNotGreaterThan",        ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double",                                          ["VectorSize"] = "16", ["NextValueOp1"] = "(double)(random.NextDouble())",                        ["NextValueOp2"] = "(double)(random.NextDouble())",                                     ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != (!(left[0] > right[0]) ? -1 : 0)",                                                      ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != (!(left[i] > right[i]) ? -1 : 0)"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareNotGreaterThanOrEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double",                                          ["VectorSize"] = "16", ["NextValueOp1"] = "(double)(random.NextDouble())",                        ["NextValueOp2"] = "(double)(random.NextDouble())",                                     ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != (!(left[0] >= right[0]) ? -1 : 0)",                                                     ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != (!(left[i] >= right[i]) ? -1 : 0)"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareNotLessThan",           ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double",                                          ["VectorSize"] = "16", ["NextValueOp1"] = "(double)(random.NextDouble())",                        ["NextValueOp2"] = "(double)(random.NextDouble())",                                     ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != (!(left[0] < right[0]) ? -1 : 0)",                                                      ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != (!(left[i] < right[i]) ? -1 : 0)"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareNotLessThanOrEqual",    ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double",                                          ["VectorSize"] = "16", ["NextValueOp1"] = "(double)(random.NextDouble())",                        ["NextValueOp2"] = "(double)(random.NextDouble())",                                     ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != (!(left[0] <= right[0]) ? -1 : 0)",                                                     ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != (!(left[i] <= right[i]) ? -1 : 0)"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareOrdered",               ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double",                                          ["VectorSize"] = "16", ["NextValueOp1"] = "(double)(random.NextDouble())",                        ["NextValueOp2"] = "(double)(random.NextDouble())",                                     ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != ((!double.IsNaN(left[0]) && !double.IsNaN(right[0])) ? -1 : 0)",                        ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != ((!double.IsNaN(left[i]) && !double.IsNaN(right[i])) ? -1 : 0)"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "CompareUnordered",             ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double",                                          ["VectorSize"] = "16", ["NextValueOp1"] = "(double)(random.NextDouble())",                        ["NextValueOp2"] = "(double)(random.NextDouble())",                                     ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != ((double.IsNaN(left[0]) || double.IsNaN(right[0])) ? -1 : 0)",                          ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != ((double.IsNaN(left[i]) || double.IsNaN(right[i])) ? -1 : 0)"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Divide",                       ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double",                                          ["VectorSize"] = "16", ["NextValueOp1"] = "(double)(random.NextDouble())",                        ["NextValueOp2"] = "(double)(random.NextDouble())",                                     ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(left[0] / right[0]) != BitConverter.DoubleToInt64Bits(result[0])",                                    ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(left[i] / right[i]) != BitConverter.DoubleToInt64Bits(result[i])"}),
+    ("ExtractScalarTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Extract",                      ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16",                                                                                       ["Imm"] = "1",   ["VectorSize"] = "16", ["NextValueOp1"] = "(short)(random.Next(0, int.MaxValue))",                                                                                                        ["ValidateFirstResult"] = "(result[0] != firstOp[1])"}),
+    ("ExtractScalarTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Extract",                      ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16",                                                                                      ["Imm"] = "1",   ["VectorSize"] = "16", ["NextValueOp1"] = "(ushort)(random.Next(0, int.MaxValue))",                                                                                                       ["ValidateFirstResult"] = "(result[0] != firstOp[1])"}),
+    ("ExtractScalarTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Extract",                      ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16",                                                                                       ["Imm"] = "129", ["VectorSize"] = "16", ["NextValueOp1"] = "(short)(random.Next(0, int.MaxValue))",                                                                                                        ["ValidateFirstResult"] = "(result[0] != firstOp[1])"}),
+    ("ExtractScalarTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Extract",                      ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16",                                                                                      ["Imm"] = "129", ["VectorSize"] = "16", ["NextValueOp1"] = "(ushort)(random.Next(0, int.MaxValue))",                                                                                                       ["ValidateFirstResult"] = "(result[0] != firstOp[1])"}),
+    ("InsertScalarTest.template",  new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Insert",                       ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16",                                                               ["Data"] = "(short)2",  ["Imm"] = "1",   ["VectorSize"] = "16", ["NextValueOp1"] = "(short)0",                                                                                                                                     ["ValidateFirstResult"] = "(i == 1 ? result[i] != 2 : result[i] != 0)"}),
+    ("InsertScalarTest.template",  new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Insert",                       ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16",                                                              ["Data"] = "(ushort)2", ["Imm"] = "1",   ["VectorSize"] = "16", ["NextValueOp1"] = "(ushort)0",                                                                                                                                    ["ValidateFirstResult"] = "(i == 1 ? result[i] != 2 : result[i] != 0)"}),
+    ("InsertScalarTest.template",  new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Insert",                       ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16",                                                               ["Data"] = "(short)2",  ["Imm"] = "129", ["VectorSize"] = "16", ["NextValueOp1"] = "(short)0",                                                                                                                                     ["ValidateFirstResult"] = "(i == 1 ? result[i] != 2 : result[i] != 0)"}),
+    ("InsertScalarTest.template",  new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Insert",                       ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16",                                                              ["Data"] = "(ushort)2", ["Imm"] = "129", ["VectorSize"] = "16", ["NextValueOp1"] = "(ushort)0",                                                                                                                                    ["ValidateFirstResult"] = "(i == 1 ? result[i] != 2 : result[i] != 0)"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Max",                          ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double",                                          ["VectorSize"] = "16", ["NextValueOp1"] = "(double)(random.NextDouble())",                        ["NextValueOp2"] = "(double)(random.NextDouble())",                                     ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(Math.Max(left[0], right[0])) != BitConverter.DoubleToInt64Bits(result[0])",                           ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(Math.Max(left[i], right[i])) != BitConverter.DoubleToInt64Bits(result[i])"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Max",                          ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Byte",   ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Byte",   ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Byte",                                            ["VectorSize"] = "16", ["NextValueOp1"] = "(byte)(random.Next(0, byte.MaxValue))",                ["NextValueOp2"] = "(byte)(random.Next(0, byte.MaxValue))",                             ["ValidateFirstResult"] = "Math.Max(left[0], right[0]) != result[0]",                                                                                           ["ValidateRemainingResults"] = "Math.Max(left[i], right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Max",                          ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int16",                                           ["VectorSize"] = "16", ["NextValueOp1"] = "(short)(random.Next(short.MinValue, short.MaxValue))", ["NextValueOp2"] = "(short)(random.Next(short.MinValue, short.MaxValue))",              ["ValidateFirstResult"] = "Math.Max(left[0], right[0]) != result[0]",                                                                                           ["ValidateRemainingResults"] = "Math.Max(left[i], right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Min",                          ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double",                                          ["VectorSize"] = "16", ["NextValueOp1"] = "(double)(random.NextDouble())",                        ["NextValueOp2"] = "(double)(random.NextDouble())",                                     ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(Math.Min(left[0], right[0])) != BitConverter.DoubleToInt64Bits(result[0])",                           ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(Math.Min(left[i], right[i])) != BitConverter.DoubleToInt64Bits(result[i])"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Min",                          ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Byte",   ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Byte",   ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Byte",                                            ["VectorSize"] = "16", ["NextValueOp1"] = "(byte)(random.Next(0, byte.MinValue))",                ["NextValueOp2"] = "(byte)(random.Next(0, byte.MinValue))",                             ["ValidateFirstResult"] = "Math.Min(left[0], right[0]) != result[0]",                                                                                           ["ValidateRemainingResults"] = "Math.Min(left[i], right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Min",                          ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int16",                                           ["VectorSize"] = "16", ["NextValueOp1"] = "(short)(random.Next(short.MinValue, short.MinValue))", ["NextValueOp2"] = "(short)(random.Next(short.MinValue, short.MinValue))",              ["ValidateFirstResult"] = "Math.Min(left[0], right[0]) != result[0]",                                                                                           ["ValidateRemainingResults"] = "Math.Min(left[i], right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Multiply",                     ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double",                                          ["VectorSize"] = "16", ["NextValueOp1"] = "(double)(random.NextDouble())",                        ["NextValueOp2"] = "(double)(random.NextDouble())",                                     ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(left[0] * right[0]) != BitConverter.DoubleToInt64Bits(result[0])",                                    ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(left[i] * right[i]) != BitConverter.DoubleToInt64Bits(result[i])"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Or",                           ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double",                                          ["VectorSize"] = "16", ["NextValueOp1"] = "(double)(random.NextDouble())",                        ["NextValueOp2"] = "(double)(random.NextDouble())",                                     ["ValidateFirstResult"] = "(BitConverter.DoubleToInt64Bits(left[0]) | BitConverter.DoubleToInt64Bits(right[0])) != BitConverter.DoubleToInt64Bits(result[0])",  ["ValidateRemainingResults"] = "(BitConverter.DoubleToInt64Bits(left[i]) | BitConverter.DoubleToInt64Bits(right[i])) != BitConverter.DoubleToInt64Bits(result[i])"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Or",                           ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Byte",   ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Byte",   ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Byte",                                            ["VectorSize"] = "16", ["NextValueOp1"] = "(byte)(random.Next(0, byte.MaxValue))",                ["NextValueOp2"] = "(byte)(random.Next(0, byte.MaxValue))",                             ["ValidateFirstResult"] = "(byte)(left[0] | right[0]) != result[0]",                                                                                            ["ValidateRemainingResults"] = "(byte)(left[i] | right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Or",                           ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int16",                                           ["VectorSize"] = "16", ["NextValueOp1"] = "(short)(random.Next(short.MinValue, short.MaxValue))", ["NextValueOp2"] = "(short)(random.Next(short.MinValue, short.MaxValue))",              ["ValidateFirstResult"] = "(short)(left[0] | right[0]) != result[0]",                                                                                           ["ValidateRemainingResults"] = "(short)(left[i] | right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Or",                           ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int32",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int32",                                           ["VectorSize"] = "16", ["NextValueOp1"] = "(int)(random.Next(int.MinValue, int.MaxValue))",       ["NextValueOp2"] = "(int)(random.Next(int.MinValue, int.MaxValue))",                    ["ValidateFirstResult"] = "(int)(left[0] | right[0]) != result[0]",                                                                                             ["ValidateRemainingResults"] = "(int)(left[i] | right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Or",                           ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int64",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int64",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int64",                                           ["VectorSize"] = "16", ["NextValueOp1"] = "(long)(random.Next(int.MinValue, int.MaxValue))",      ["NextValueOp2"] = "(long)(random.Next(int.MinValue, int.MaxValue))",                   ["ValidateFirstResult"] = "(long)(left[0] | right[0]) != result[0]",                                                                                            ["ValidateRemainingResults"] = "(long)(left[i] | right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Or",                           ["RetVectorType"] = "Vector128", ["RetBaseType"] = "SByte",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "SByte",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "SByte",                                           ["VectorSize"] = "16", ["NextValueOp1"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))", ["NextValueOp2"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",              ["ValidateFirstResult"] = "(sbyte)(left[0] | right[0]) != result[0]",                                                                                           ["ValidateRemainingResults"] = "(sbyte)(left[i] | right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Or",                           ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt16",                                          ["VectorSize"] = "16", ["NextValueOp1"] = "(ushort)(random.Next(0, ushort.MaxValue))",            ["NextValueOp2"] = "(ushort)(random.Next(0, ushort.MaxValue))",                         ["ValidateFirstResult"] = "(ushort)(left[0] | right[0]) != result[0]",                                                                                          ["ValidateRemainingResults"] = "(ushort)(left[i] | right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Or",                           ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt32",                                          ["VectorSize"] = "16", ["NextValueOp1"] = "(uint)(random.Next(0, int.MaxValue))",                 ["NextValueOp2"] = "(uint)(random.Next(0, int.MaxValue))",                              ["ValidateFirstResult"] = "(uint)(left[0] | right[0]) != result[0]",                                                                                            ["ValidateRemainingResults"] = "(uint)(left[i] | right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Or",                           ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt64",                                          ["VectorSize"] = "16", ["NextValueOp1"] = "(ulong)(random.Next(0, int.MaxValue))",                ["NextValueOp2"] = "(ulong)(random.Next(0, int.MaxValue))",                             ["ValidateFirstResult"] = "(ulong)(left[0] | right[0]) != result[0]",                                                                                           ["ValidateRemainingResults"] = "(ulong)(left[i] | right[i]) != result[i]"}),
+    ("ImmUnOpTest.template",       new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ShiftLeftLogical",             ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16",                                                                                       ["Imm"] = "1",   ["VectorSize"] = "16", ["NextValueOp1"] = "(short)(random.Next(0, short.MaxValue))",                                                                                                      ["ValidateFirstResult"] = "(short)(firstOp[0] << 1) != result[0]",                                                                                              ["ValidateRemainingResults"] = "(short)(firstOp[i] << 1) != result[i]"}),
+    ("ImmUnOpTest.template",       new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ShiftLeftLogical",             ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16",                                                                                      ["Imm"] = "1",   ["VectorSize"] = "16", ["NextValueOp1"] = "(ushort)(random.Next(0, ushort.MaxValue))",                                                                                                    ["ValidateFirstResult"] = "(ushort)(firstOp[0] << 1) != result[0]",                                                                                             ["ValidateRemainingResults"] = "(ushort)(firstOp[i] << 1) != result[i]"}),
+    ("ImmUnOpTest.template",       new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ShiftLeftLogical",             ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int32",                                                                                       ["Imm"] = "1",   ["VectorSize"] = "16", ["NextValueOp1"] = "(int)(random.Next(0, int.MaxValue))",                                                                                                          ["ValidateFirstResult"] = "(int)(firstOp[0] << 1) != result[0]",                                                                                                ["ValidateRemainingResults"] = "(int)(firstOp[i] << 1) != result[i]"}),
+    ("ImmUnOpTest.template",       new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ShiftLeftLogical",             ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt32",                                                                                      ["Imm"] = "1",   ["VectorSize"] = "16", ["NextValueOp1"] = "(uint)(random.Next(0, int.MaxValue))",                                                                                                         ["ValidateFirstResult"] = "(uint)(firstOp[0] << 1) != result[0]",                                                                                               ["ValidateRemainingResults"] = "(uint)(firstOp[i] << 1) != result[i]"}),
+    ("ImmUnOpTest.template",       new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ShiftLeftLogical",             ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int64",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int64",                                                                                       ["Imm"] = "1",   ["VectorSize"] = "16", ["NextValueOp1"] = "(long)(random.Next(0, int.MaxValue))",                                                                                                         ["ValidateFirstResult"] = "(long)(firstOp[0] << 1) != result[0]",                                                                                               ["ValidateRemainingResults"] = "(long)(firstOp[i] << 1) != result[i]"}),
+    ("ImmUnOpTest.template",       new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ShiftLeftLogical",             ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt64",                                                                                      ["Imm"] = "1",   ["VectorSize"] = "16", ["NextValueOp1"] = "(ulong)(random.Next(0, int.MaxValue))",                                                                                                        ["ValidateFirstResult"] = "(ulong)(firstOp[0] << 1) != result[0]",                                                                                              ["ValidateRemainingResults"] = "(ulong)(firstOp[i] << 1) != result[i]"}),
+    ("ImmUnOpTest.template",       new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ShiftLeftLogical",             ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16",                                                                                       ["Imm"] = "16",  ["VectorSize"] = "16", ["NextValueOp1"] = "(short)(random.Next(0, short.MaxValue))",                                                                                                      ["ValidateFirstResult"] = "0 != result[0]",                                                                                                                     ["ValidateRemainingResults"] = "0 != result[i]"}),
+    ("ImmUnOpTest.template",       new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ShiftLeftLogical",             ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16",                                                                                      ["Imm"] = "16",  ["VectorSize"] = "16", ["NextValueOp1"] = "(ushort)(random.Next(0, ushort.MaxValue))",                                                                                                    ["ValidateFirstResult"] = "0 != result[0]",                                                                                                                     ["ValidateRemainingResults"] = "0 != result[i]"}),
+    ("ImmUnOpTest.template",       new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ShiftLeftLogical",             ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int32",                                                                                       ["Imm"] = "32",  ["VectorSize"] = "16", ["NextValueOp1"] = "(int)(random.Next(0, int.MaxValue))",                                                                                                          ["ValidateFirstResult"] = "0 != result[0]",                                                                                                                     ["ValidateRemainingResults"] = "0 != result[i]"}),
+    ("ImmUnOpTest.template",       new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ShiftLeftLogical",             ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt32",                                                                                      ["Imm"] = "32",  ["VectorSize"] = "16", ["NextValueOp1"] = "(uint)(random.Next(0, int.MaxValue))",                                                                                                         ["ValidateFirstResult"] = "0 != result[0]",                                                                                                                     ["ValidateRemainingResults"] = "0!= result[i]"}),
+    ("ImmUnOpTest.template",       new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ShiftLeftLogical",             ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int64",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int64",                                                                                       ["Imm"] = "64",  ["VectorSize"] = "16", ["NextValueOp1"] = "(long)(random.Next(0, int.MaxValue))",                                                                                                         ["ValidateFirstResult"] = "0 != result[0]",                                                                                                                     ["ValidateRemainingResults"] = "0 != result[i]"}),
+    ("ImmUnOpTest.template",       new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ShiftLeftLogical",             ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt64",                                                                                      ["Imm"] = "64",  ["VectorSize"] = "16", ["NextValueOp1"] = "(ulong)(random.Next(0, int.MaxValue))",                                                                                                        ["ValidateFirstResult"] = "0 != result[0]",                                                                                                                     ["ValidateRemainingResults"] = "0 != result[i]"}),
+    ("ImmUnOpTest.template",       new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ShiftLeftLogical128BitLane",   ["RetVectorType"] = "Vector128", ["RetBaseType"] = "SByte",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "SByte",                                                                                       ["Imm"] = "1",   ["VectorSize"] = "16", ["NextValueOp1"] = "(sbyte)8",                                                                                                                                     ["ValidateFirstResult"] = "result[0] != 0",                                                                                                                     ["ValidateRemainingResults"] =  "result[i] != 8"}),
+    ("ImmUnOpTest.template",       new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ShiftLeftLogical128BitLane",   ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Byte",   ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Byte",                                                                                        ["Imm"] = "1",   ["VectorSize"] = "16", ["NextValueOp1"] = "(byte)8",                                                                                                                                      ["ValidateFirstResult"] = "result[0] != 0",                                                                                                                     ["ValidateRemainingResults"] =  "result[i] != 8"}),
+    ("ImmUnOpTest.template",       new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ShiftLeftLogical128BitLane",   ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16",                                                                                       ["Imm"] = "1",   ["VectorSize"] = "16", ["NextValueOp1"] = "(short)8",                                                                                                                                     ["ValidateFirstResult"] = "result[0] != 2048",                                                                                                                  ["ValidateRemainingResults"] =  "result[i] != 2048"}),
+    ("ImmUnOpTest.template",       new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ShiftLeftLogical128BitLane",   ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16",                                                                                      ["Imm"] = "1",   ["VectorSize"] = "16", ["NextValueOp1"] = "(ushort)8",                                                                                                                                    ["ValidateFirstResult"] = "result[0] != 2048",                                                                                                                  ["ValidateRemainingResults"] =  "result[i] != 2048"}),
+    ("ImmUnOpTest.template",       new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ShiftLeftLogical128BitLane",   ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int32",                                                                                       ["Imm"] = "1",   ["VectorSize"] = "16", ["NextValueOp1"] = "(int)8",                                                                                                                                       ["ValidateFirstResult"] = "result[0] != 2048",                                                                                                                  ["ValidateRemainingResults"] =  "result[i] != 2048"}),
+    ("ImmUnOpTest.template",       new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ShiftLeftLogical128BitLane",   ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt32",                                                                                      ["Imm"] = "1",   ["VectorSize"] = "16", ["NextValueOp1"] = "(uint)8",                                                                                                                                      ["ValidateFirstResult"] = "result[0] != 2048",                                                                                                                  ["ValidateRemainingResults"] =  "result[i] != 2048"}),
+    ("ImmUnOpTest.template",       new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ShiftLeftLogical128BitLane",   ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int64",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int64",                                                                                       ["Imm"] = "1",   ["VectorSize"] = "16", ["NextValueOp1"] = "(long)8",                                                                                                                                      ["ValidateFirstResult"] = "result[0] != 2048",                                                                                                                  ["ValidateRemainingResults"] =  "result[i] != 2048"}),
+    ("ImmUnOpTest.template",       new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ShiftLeftLogical128BitLane",   ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt64",                                                                                      ["Imm"] = "1",   ["VectorSize"] = "16", ["NextValueOp1"] = "(ulong)8",                                                                                                                                     ["ValidateFirstResult"] = "result[0] != 2048",                                                                                                                  ["ValidateRemainingResults"] =  "result[i] != 2048"}),
+    ("ImmUnOpTest.template",       new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ShiftRightArithmetic",         ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16",                                                                                       ["Imm"] = "1",   ["VectorSize"] = "16", ["NextValueOp1"] = "(short)(random.Next(0, short.MaxValue))",                                                                                                      ["ValidateFirstResult"] = "(short)(firstOp[0] >> 1) != result[0]",                                                                                              ["ValidateRemainingResults"] = "(short)(firstOp[i] >> 1) != result[i]"}),
+    ("ImmUnOpTest.template",       new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ShiftRightArithmetic",         ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int32",                                                                                       ["Imm"] = "1",   ["VectorSize"] = "16", ["NextValueOp1"] = "(int)(random.Next(0, int.MaxValue))",                                                                                                          ["ValidateFirstResult"] = "(int)(firstOp[0] >> 1) != result[0]",                                                                                                ["ValidateRemainingResults"] = "(int)(firstOp[i] >> 1) != result[i]"}),
+    ("ImmUnOpTest.template",       new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ShiftRightArithmetic",         ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16",                                                                                       ["Imm"] = "16",  ["VectorSize"] = "16", ["NextValueOp1"] = "(short)(random.Next(0, short.MaxValue))",                                                                                                      ["ValidateFirstResult"] = "(short)(firstOp[0] >> 15) != result[0]",                                                                                             ["ValidateRemainingResults"] = "(short)(firstOp[i] >> 15) != result[i]"}),
+    ("ImmUnOpTest.template",       new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ShiftRightArithmetic",         ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int32",                                                                                       ["Imm"] = "32",  ["VectorSize"] = "16", ["NextValueOp1"] = "(int)(random.Next(0, int.MaxValue))",                                                                                                          ["ValidateFirstResult"] = "(int)(firstOp[0] >> 31) != result[0]",                                                                                               ["ValidateRemainingResults"] = "(int)(firstOp[i] >> 31) != result[i]"}),
+    ("ImmUnOpTest.template",       new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ShiftRightLogical",            ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16",                                                                                       ["Imm"] = "1",   ["VectorSize"] = "16", ["NextValueOp1"] = "(short)(random.Next(0, short.MaxValue))",                                                                                                      ["ValidateFirstResult"] = "(short)(firstOp[0] >> 1) != result[0]",                                                                                              ["ValidateRemainingResults"] = "(short)(firstOp[i] >> 1) != result[i]"}),
+    ("ImmUnOpTest.template",       new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ShiftRightLogical",            ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16",                                                                                      ["Imm"] = "1",   ["VectorSize"] = "16", ["NextValueOp1"] = "(ushort)(random.Next(0, ushort.MaxValue))",                                                                                                    ["ValidateFirstResult"] = "(ushort)(firstOp[0] >> 1) != result[0]",                                                                                             ["ValidateRemainingResults"] = "(ushort)(firstOp[i] >> 1) != result[i]"}),
+    ("ImmUnOpTest.template",       new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ShiftRightLogical",            ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int32",                                                                                       ["Imm"] = "1",   ["VectorSize"] = "16", ["NextValueOp1"] = "(int)(random.Next(0, int.MaxValue))",                                                                                                          ["ValidateFirstResult"] = "(int)(firstOp[0] >> 1) != result[0]",                                                                                                ["ValidateRemainingResults"] = "(int)(firstOp[i] >> 1) != result[i]"}),
+    ("ImmUnOpTest.template",       new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ShiftRightLogical",            ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt32",                                                                                      ["Imm"] = "1",   ["VectorSize"] = "16", ["NextValueOp1"] = "(uint)(random.Next(0, int.MaxValue))",                                                                                                         ["ValidateFirstResult"] = "(uint)(firstOp[0] >> 1) != result[0]",                                                                                               ["ValidateRemainingResults"] = "(uint)(firstOp[i] >> 1) != result[i]"}),
+    ("ImmUnOpTest.template",       new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ShiftRightLogical",            ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int64",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int64",                                                                                       ["Imm"] = "1",   ["VectorSize"] = "16", ["NextValueOp1"] = "(long)(random.Next(0, int.MaxValue))",                                                                                                         ["ValidateFirstResult"] = "(long)(firstOp[0] >> 1) != result[0]",                                                                                               ["ValidateRemainingResults"] = "(long)(firstOp[i] >> 1) != result[i]"}),
+    ("ImmUnOpTest.template",       new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ShiftRightLogical",            ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt64",                                                                                      ["Imm"] = "1",   ["VectorSize"] = "16", ["NextValueOp1"] = "(ulong)(random.Next(0, int.MaxValue))",                                                                                                        ["ValidateFirstResult"] = "(ulong)(firstOp[0] >> 1) != result[0]",                                                                                              ["ValidateRemainingResults"] = "(ulong)(firstOp[i] >> 1) != result[i]"}),
+    ("ImmUnOpTest.template",       new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ShiftRightLogical",            ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16",                                                                                       ["Imm"] = "16",  ["VectorSize"] = "16", ["NextValueOp1"] = "(short)(random.Next(0, short.MaxValue))",                                                                                                      ["ValidateFirstResult"] = "0 != result[0]",                                                                                                                     ["ValidateRemainingResults"] = "0 != result[i]"}),
+    ("ImmUnOpTest.template",       new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ShiftRightLogical",            ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16",                                                                                      ["Imm"] = "16",  ["VectorSize"] = "16", ["NextValueOp1"] = "(ushort)(random.Next(0, ushort.MaxValue))",                                                                                                    ["ValidateFirstResult"] = "0 != result[0]",                                                                                                                     ["ValidateRemainingResults"] = "0 != result[i]"}),
+    ("ImmUnOpTest.template",       new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ShiftRightLogical",            ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int32",                                                                                       ["Imm"] = "32",  ["VectorSize"] = "16", ["NextValueOp1"] = "(int)(random.Next(0, int.MaxValue))",                                                                                                          ["ValidateFirstResult"] = "0 != result[0]",                                                                                                                     ["ValidateRemainingResults"] = "0 != result[i]"}),
+    ("ImmUnOpTest.template",       new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ShiftRightLogical",            ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt32",                                                                                      ["Imm"] = "32",  ["VectorSize"] = "16", ["NextValueOp1"] = "(uint)(random.Next(0, int.MaxValue))",                                                                                                         ["ValidateFirstResult"] = "0 != result[0]",                                                                                                                     ["ValidateRemainingResults"] = "0!= result[i]"}),
+    ("ImmUnOpTest.template",       new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ShiftRightLogical",            ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int64",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int64",                                                                                       ["Imm"] = "64",  ["VectorSize"] = "16", ["NextValueOp1"] = "(long)(random.Next(0, int.MaxValue))",                                                                                                         ["ValidateFirstResult"] = "0 != result[0]",                                                                                                                     ["ValidateRemainingResults"] = "0 != result[i]"}),
+    ("ImmUnOpTest.template",       new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ShiftRightLogical",            ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt64",                                                                                      ["Imm"] = "64",  ["VectorSize"] = "16", ["NextValueOp1"] = "(ulong)(random.Next(0, int.MaxValue))",                                                                                                        ["ValidateFirstResult"] = "0 != result[0]",                                                                                                                     ["ValidateRemainingResults"] = "0 != result[i]"}),
+    ("ImmUnOpTest.template",       new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ShiftRightLogical128BitLane",  ["RetVectorType"] = "Vector128", ["RetBaseType"] = "SByte",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "SByte",                                                                                       ["Imm"] = "1",   ["VectorSize"] = "16", ["NextValueOp1"] = "(sbyte)8",                                                                                                                                     ["ValidateFirstResult"] = "result[0] != 8",                                                                                                                     ["ValidateRemainingResults"] = "(i == 15 ? result[i] != 0 : result[i] != 8)"}),
+    ("ImmUnOpTest.template",       new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ShiftRightLogical128BitLane",  ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Byte",   ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Byte",                                                                                        ["Imm"] = "1",   ["VectorSize"] = "16", ["NextValueOp1"] = "(byte)8",                                                                                                                                      ["ValidateFirstResult"] = "result[0] != 8",                                                                                                                     ["ValidateRemainingResults"] = "(i == 15 ? result[i] != 0 : result[i] != 8)"}),
+    ("ImmUnOpTest.template",       new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ShiftRightLogical128BitLane",  ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16",                                                                                       ["Imm"] = "1",   ["VectorSize"] = "16", ["NextValueOp1"] = "(short)8",                                                                                                                                     ["ValidateFirstResult"] = "result[0] != 2048",                                                                                                                  ["ValidateRemainingResults"] = "(i == 7 ? result[i] != 0 : result[i] != 2048)"}),
+    ("ImmUnOpTest.template",       new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ShiftRightLogical128BitLane",  ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16",                                                                                      ["Imm"] = "1",   ["VectorSize"] = "16", ["NextValueOp1"] = "(ushort)8",                                                                                                                                    ["ValidateFirstResult"] = "result[0] != 2048",                                                                                                                  ["ValidateRemainingResults"] = "(i == 7 ? result[i] != 0 : result[i] != 2048)"}),
+    ("ImmUnOpTest.template",       new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ShiftRightLogical128BitLane",  ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int32",                                                                                       ["Imm"] = "1",   ["VectorSize"] = "16", ["NextValueOp1"] = "(int)8",                                                                                                                                       ["ValidateFirstResult"] = "result[0] != 134217728",                                                                                                             ["ValidateRemainingResults"] = "(i == 3 ? result[i] != 0 : result[i] != 134217728)"}),
+    ("ImmUnOpTest.template",       new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ShiftRightLogical128BitLane",  ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt32",                                                                                      ["Imm"] = "1",   ["VectorSize"] = "16", ["NextValueOp1"] = "(uint)8",                                                                                                                                      ["ValidateFirstResult"] = "result[0] != 134217728",                                                                                                             ["ValidateRemainingResults"] = "(i == 3 ? result[i] != 0 : result[i] != 134217728)"}),
+    ("ImmUnOpTest.template",       new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ShiftRightLogical128BitLane",  ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int64",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int64",                                                                                       ["Imm"] = "1",   ["VectorSize"] = "16", ["NextValueOp1"] = "(long)8",                                                                                                                                      ["ValidateFirstResult"] = "result[0] != 576460752303423488L",                                                                                                   ["ValidateRemainingResults"] = "(result[i] != 0)"}),
+    ("ImmUnOpTest.template",       new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ShiftRightLogical128BitLane",  ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt64",                                                                                      ["Imm"] = "1",   ["VectorSize"] = "16", ["NextValueOp1"] = "(ulong)8",                                                                                                                                     ["ValidateFirstResult"] = "result[0] != 576460752303423488UL",                                                                                                  ["ValidateRemainingResults"] = "(result[i] != 0)"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Subtract",                     ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double",                                          ["VectorSize"] = "16", ["NextValueOp1"] = "(double)(random.NextDouble())",                        ["NextValueOp2"] = "(double)(random.NextDouble())",                                     ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(left[0] - right[0]) != BitConverter.DoubleToInt64Bits(result[0])",                                    ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(left[i] - right[i]) != BitConverter.DoubleToInt64Bits(result[i])"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Subtract",                     ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Byte",   ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Byte",   ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Byte",                                            ["VectorSize"] = "16", ["NextValueOp1"] = "(byte)(random.Next(0, byte.MaxValue))",                ["NextValueOp2"] = "(byte)(random.Next(0, byte.MaxValue))",                             ["ValidateFirstResult"] = "(byte)(left[0] - right[0]) != result[0]",                                                                                            ["ValidateRemainingResults"] = "(byte)(left[i] - right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Subtract",                     ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int16",                                           ["VectorSize"] = "16", ["NextValueOp1"] = "(short)(random.Next(short.MinValue, short.MaxValue))", ["NextValueOp2"] = "(short)(random.Next(short.MinValue, short.MaxValue))",              ["ValidateFirstResult"] = "(short)(left[0] - right[0]) != result[0]",                                                                                           ["ValidateRemainingResults"] = "(short)(left[i] - right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Subtract",                     ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int32",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int32",                                           ["VectorSize"] = "16", ["NextValueOp1"] = "(int)(random.Next(int.MinValue, int.MaxValue))",       ["NextValueOp2"] = "(int)(random.Next(int.MinValue, int.MaxValue))",                    ["ValidateFirstResult"] = "(int)(left[0] - right[0]) != result[0]",                                                                                             ["ValidateRemainingResults"] = "(int)(left[i] - right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Subtract",                     ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int64",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int64",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int64",                                           ["VectorSize"] = "16", ["NextValueOp1"] = "(long)(random.Next(int.MinValue, int.MaxValue))",      ["NextValueOp2"] = "(long)(random.Next(int.MinValue, int.MaxValue))",                   ["ValidateFirstResult"] = "(long)(left[0] - right[0]) != result[0]",                                                                                            ["ValidateRemainingResults"] = "(long)(left[i] - right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Subtract",                     ["RetVectorType"] = "Vector128", ["RetBaseType"] = "SByte",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "SByte",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "SByte",                                           ["VectorSize"] = "16", ["NextValueOp1"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))", ["NextValueOp2"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",              ["ValidateFirstResult"] = "(sbyte)(left[0] - right[0]) != result[0]",                                                                                           ["ValidateRemainingResults"] = "(sbyte)(left[i] - right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Subtract",                     ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt16",                                          ["VectorSize"] = "16", ["NextValueOp1"] = "(ushort)(random.Next(0, ushort.MaxValue))",            ["NextValueOp2"] = "(ushort)(random.Next(0, ushort.MaxValue))",                         ["ValidateFirstResult"] = "(ushort)(left[0] - right[0]) != result[0]",                                                                                          ["ValidateRemainingResults"] = "(ushort)(left[i] - right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Subtract",                     ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt32",                                          ["VectorSize"] = "16", ["NextValueOp1"] = "(uint)(random.Next(0, int.MaxValue))",                 ["NextValueOp2"] = "(uint)(random.Next(0, int.MaxValue))",                              ["ValidateFirstResult"] = "(uint)(left[0] - right[0]) != result[0]",                                                                                            ["ValidateRemainingResults"] = "(uint)(left[i] - right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Subtract",                     ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt64",                                          ["VectorSize"] = "16", ["NextValueOp1"] = "(ulong)(random.Next(0, int.MaxValue))",                ["NextValueOp2"] = "(ulong)(random.Next(0, int.MaxValue))",                             ["ValidateFirstResult"] = "(ulong)(left[0] - right[0]) != result[0]",                                                                                           ["ValidateRemainingResults"] = "(ulong)(left[i] - right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Xor",                          ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double",                                          ["VectorSize"] = "16", ["NextValueOp1"] = "(double)(random.NextDouble())",                        ["NextValueOp2"] = "(double)(random.NextDouble())",                                     ["ValidateFirstResult"] = "(BitConverter.DoubleToInt64Bits(left[0]) ^ BitConverter.DoubleToInt64Bits(right[0])) != BitConverter.DoubleToInt64Bits(result[0])",  ["ValidateRemainingResults"] = "(BitConverter.DoubleToInt64Bits(left[i]) ^ BitConverter.DoubleToInt64Bits(right[i])) != BitConverter.DoubleToInt64Bits(result[i])"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Xor",                          ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Byte",   ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Byte",   ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Byte",                                            ["VectorSize"] = "16", ["NextValueOp1"] = "(byte)(random.Next(0, byte.MaxValue))",                ["NextValueOp2"] = "(byte)(random.Next(0, byte.MaxValue))",                             ["ValidateFirstResult"] = "(byte)(left[0] ^ right[0]) != result[0]",                                                                                            ["ValidateRemainingResults"] = "(byte)(left[i] ^ right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Xor",                          ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int16",                                           ["VectorSize"] = "16", ["NextValueOp1"] = "(short)(random.Next(short.MinValue, short.MaxValue))", ["NextValueOp2"] = "(short)(random.Next(short.MinValue, short.MaxValue))",              ["ValidateFirstResult"] = "(short)(left[0] ^ right[0]) != result[0]",                                                                                           ["ValidateRemainingResults"] = "(short)(left[i] ^ right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Xor",                          ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int32",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int32",                                           ["VectorSize"] = "16", ["NextValueOp1"] = "(int)(random.Next(int.MinValue, int.MaxValue))",       ["NextValueOp2"] = "(int)(random.Next(int.MinValue, int.MaxValue))",                    ["ValidateFirstResult"] = "(int)(left[0] ^ right[0]) != result[0]",                                                                                             ["ValidateRemainingResults"] = "(int)(left[i] ^ right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Xor",                          ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int64",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int64",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int64",                                           ["VectorSize"] = "16", ["NextValueOp1"] = "(long)(random.Next(int.MinValue, int.MaxValue))",      ["NextValueOp2"] = "(long)(random.Next(int.MinValue, int.MaxValue))",                   ["ValidateFirstResult"] = "(long)(left[0] ^ right[0]) != result[0]",                                                                                            ["ValidateRemainingResults"] = "(long)(left[i] ^ right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Xor",                          ["RetVectorType"] = "Vector128", ["RetBaseType"] = "SByte",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "SByte",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "SByte",                                           ["VectorSize"] = "16", ["NextValueOp1"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))", ["NextValueOp2"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",              ["ValidateFirstResult"] = "(sbyte)(left[0] ^ right[0]) != result[0]",                                                                                           ["ValidateRemainingResults"] = "(sbyte)(left[i] ^ right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Xor",                          ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt16",                                          ["VectorSize"] = "16", ["NextValueOp1"] = "(ushort)(random.Next(0, ushort.MaxValue))",            ["NextValueOp2"] = "(ushort)(random.Next(0, ushort.MaxValue))",                         ["ValidateFirstResult"] = "(ushort)(left[0] ^ right[0]) != result[0]",                                                                                          ["ValidateRemainingResults"] = "(ushort)(left[i] ^ right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Xor",                          ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt32",                                          ["VectorSize"] = "16", ["NextValueOp1"] = "(uint)(random.Next(0, int.MaxValue))",                 ["NextValueOp2"] = "(uint)(random.Next(0, int.MaxValue))",                              ["ValidateFirstResult"] = "(uint)(left[0] ^ right[0]) != result[0]",                                                                                            ["ValidateRemainingResults"] = "(uint)(left[i] ^ right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Xor",                          ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt64",                                          ["VectorSize"] = "16", ["NextValueOp1"] = "(ulong)(random.Next(0, int.MaxValue))",                ["NextValueOp2"] = "(ulong)(random.Next(0, int.MaxValue))",                             ["ValidateFirstResult"] = "(ulong)(left[0] ^ right[0]) != result[0]",                                                                                           ["ValidateRemainingResults"] = "(ulong)(left[i] ^ right[i]) != result[i]"}),
 };
 
-private static readonly (string templateFileName, string[] templateData)[] Sse3Inputs = new []
+private static readonly (string templateFileName, Dictionary<string, string> templateData)[] Sse3Inputs = new []
 {
-    // TemplateName                                  Isa,    LoadIsa, Method,               RetVectorType, RetBaseType, Op1VectorType, Op1BaseType, Op2VectorType, Op2BaseType, Op3VectorType, Op3BaseType, VectorSize, NextValueOp1,                    NextValueOp2,                    NextValueOp3, ValidateFirstResult,                                                                                     ValidateRemainingResults
-    ("AlternatingBinOpTest.template", new string[] { "Sse3", "Sse2",  "AddSubtract",        "Vector128",   "Double",    "Vector128",   "Double",    "Vector128",   "Double",                                "16",       "(double)(random.NextDouble())", "(double)(random.NextDouble())",               "BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(left[i] - right[i])",       "BitConverter.DoubleToInt64Bits(result[i + 1]) != BitConverter.DoubleToInt64Bits(left[i + 1] + right[i + 1])"}),
-    ("AlternatingBinOpTest.template", new string[] { "Sse3", "Sse" ,  "AddSubtract",        "Vector128",   "Single",    "Vector128",   "Single",    "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())",  "(float)(random.NextDouble())",                "BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(left[i] - right[i])",       "BitConverter.SingleToInt32Bits(result[i + 1]) != BitConverter.SingleToInt32Bits(left[i + 1] + right[i + 1])"}),
-    ("HorizontalBinOpTest.template",  new string[] { "Sse3", "Sse2",  "HorizontalAdd",      "Vector128",   "Double",    "Vector128",   "Double",    "Vector128",   "Double",                                "16",       "(double)(random.NextDouble())", "(double)(random.NextDouble())",               "BitConverter.DoubleToInt64Bits(result[i1]) != BitConverter.DoubleToInt64Bits(left[i3] + left[i3 + 1])", "BitConverter.DoubleToInt64Bits(result[i2]) != BitConverter.DoubleToInt64Bits(right[i3] + right[i3 + 1])"}),
-    ("HorizontalBinOpTest.template",  new string[] { "Sse3", "Sse",   "HorizontalAdd",      "Vector128",   "Single",    "Vector128",   "Single",    "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())",  "(float)(random.NextDouble())",                "BitConverter.SingleToInt32Bits(result[i1]) != BitConverter.SingleToInt32Bits(left[i3] + left[i3 + 1])", "BitConverter.SingleToInt32Bits(result[i2]) != BitConverter.SingleToInt32Bits(right[i3] + right[i3 + 1])"}),
-    ("HorizontalBinOpTest.template",  new string[] { "Sse3", "Sse2",  "HorizontalSubtract", "Vector128",   "Double",    "Vector128",   "Double",    "Vector128",   "Double",                                "16",       "(double)(random.NextDouble())", "(double)(random.NextDouble())",               "BitConverter.DoubleToInt64Bits(result[i1]) != BitConverter.DoubleToInt64Bits(left[i3] - left[i3 + 1])", "BitConverter.DoubleToInt64Bits(result[i2]) != BitConverter.DoubleToInt64Bits(right[i3] - right[i3 + 1])"}),
-    ("HorizontalBinOpTest.template",  new string[] { "Sse3", "Sse",   "HorizontalSubtract", "Vector128",   "Single",    "Vector128",   "Single",    "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())",  "(float)(random.NextDouble())",                "BitConverter.SingleToInt32Bits(result[i1]) != BitConverter.SingleToInt32Bits(left[i3] - left[i3 + 1])", "BitConverter.SingleToInt32Bits(result[i2]) != BitConverter.SingleToInt32Bits(right[i3] - right[i3 + 1])"}),
+    ("AlternatingBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse3", ["LoadIsa"] = "Sse2", ["Method"] = "AddSubtract",        ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["VectorSize"] = "16", ["NextValueOp1"] = "(double)(random.NextDouble())", ["NextValueOp2"] = "(double)(random.NextDouble())", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(left[i] - right[i])",       ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i + 1]) != BitConverter.DoubleToInt64Bits(left[i + 1] + right[i + 1])"}),
+    ("AlternatingBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse3", ["LoadIsa"] = "Sse" , ["Method"] = "AddSubtract",        ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())",  ["NextValueOp2"] = "(float)(random.NextDouble())",  ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(left[i] - right[i])",       ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i + 1]) != BitConverter.SingleToInt32Bits(left[i + 1] + right[i + 1])"}),
+    ("HorizontalBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Sse3", ["LoadIsa"] = "Sse2", ["Method"] = "HorizontalAdd",      ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["VectorSize"] = "16", ["NextValueOp1"] = "(double)(random.NextDouble())", ["NextValueOp2"] = "(double)(random.NextDouble())", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[i1]) != BitConverter.DoubleToInt64Bits(left[i3] + left[i3 + 1])", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i2]) != BitConverter.DoubleToInt64Bits(right[i3] + right[i3 + 1])"}),
+    ("HorizontalBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Sse3", ["LoadIsa"] = "Sse",  ["Method"] = "HorizontalAdd",      ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())",  ["NextValueOp2"] = "(float)(random.NextDouble())",  ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[i1]) != BitConverter.SingleToInt32Bits(left[i3] + left[i3 + 1])", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i2]) != BitConverter.SingleToInt32Bits(right[i3] + right[i3 + 1])"}),
+    ("HorizontalBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Sse3", ["LoadIsa"] = "Sse2", ["Method"] = "HorizontalSubtract", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["VectorSize"] = "16", ["NextValueOp1"] = "(double)(random.NextDouble())", ["NextValueOp2"] = "(double)(random.NextDouble())", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[i1]) != BitConverter.DoubleToInt64Bits(left[i3] - left[i3 + 1])", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i2]) != BitConverter.DoubleToInt64Bits(right[i3] - right[i3 + 1])"}),
+    ("HorizontalBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Sse3", ["LoadIsa"] = "Sse",  ["Method"] = "HorizontalSubtract", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())",  ["NextValueOp2"] = "(float)(random.NextDouble())",  ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[i1]) != BitConverter.SingleToInt32Bits(left[i3] - left[i3 + 1])", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i2]) != BitConverter.SingleToInt32Bits(right[i3] - right[i3 + 1])"}),
 };
 
-private static readonly (string templateFileName, string[] templateData)[] Ssse3Inputs = new []
+private static readonly (string templateFileName, Dictionary<string, string> templateData)[] Ssse3Inputs = new []
 {
-    // TemplateName                                  Isa,     LoadIsa, Method,                       RetVectorType, RetBaseType, Op1VectorType, Op1BaseType, Op2VectorType, Op2BaseType, Op3VectorType, Op3BaseType, VectorSize, NextValueOp1,                                               NextValueOp2,                                           NextValueOp3, ValidateFirstResult,                                                                                      ValidateRemainingResults
-    ("SimpleUnOpTest.template",       new string[] { "Ssse3", "Sse2",  "Abs",                        "Vector128",   "Byte",      "Vector128",   "SByte",                                                             "16",       "(sbyte)(random.Next(sbyte.MinValue + 1, sbyte.MaxValue))",                                                                       "result[0] != Math.Abs(firstOp[0])",                                                                      "result[i] != Math.Abs(firstOp[i])"}),
-    ("SimpleUnOpTest.template",       new string[] { "Ssse3", "Sse2",  "Abs",                        "Vector128",   "UInt16",    "Vector128",   "Int16",                                                             "16",       "(short)(random.Next(short.MinValue + 1, short.MaxValue))",                                                                       "result[0] != Math.Abs(firstOp[0])",                                                                      "result[i] != Math.Abs(firstOp[i])"}),
-    ("SimpleUnOpTest.template",       new string[] { "Ssse3", "Sse2",  "Abs",                        "Vector128",   "UInt32",    "Vector128",   "Int32",                                                             "16",       "(int)(random.Next(int.MinValue + 1, int.MaxValue))",                                                                             "result[0] != Math.Abs(firstOp[0])",                                                                      "result[i] != Math.Abs(firstOp[i])"}),
-    ("HorizontalBinOpTest.template",  new string[] { "Ssse3", "Sse2",  "HorizontalAdd",              "Vector128",   "Int16",     "Vector128",   "Int16",     "Vector128",   "Int16",                                 "16",       "(short)(random.Next(short.MinValue, short.MaxValue))",     "(short)(random.Next(short.MinValue, short.MaxValue))",               "result[i1] != (short)(left[i3] + left[i3 + 1])",                                                         "result[i2] != (short)(right[i3] + right[i3 + 1])"}),
-    ("HorizontalBinOpTest.template",  new string[] { "Ssse3", "Sse2",  "HorizontalAdd",              "Vector128",   "Int32",     "Vector128",   "Int32",     "Vector128",   "Int32",                                 "16",       "(int)(random.Next(int.MinValue, int.MaxValue))",           "(int)(random.Next(int.MinValue, int.MaxValue))",                     "result[i1] != (int)(left[i3] + left[i3 + 1])",                                                           "result[i2] != (int)(right[i3] + right[i3 + 1])"}),    
-    ("HorizontalBinOpTest.template",  new string[] { "Ssse3", "Sse2",  "HorizontalAddSaturate",      "Vector128",   "Int16",     "Vector128",   "Int16",     "Vector128",   "Int16",                                 "16",       "(short)(random.Next(short.MinValue, short.MaxValue))",     "(short)(random.Next(short.MinValue, short.MaxValue))",               "result[i1] != Math.Clamp((left[i3] + left[i3 + 1]), short.MinValue, short.MaxValue)",                    "result[i2] != Math.Clamp((right[i3] + right[i3 + 1]), short.MinValue, short.MaxValue)"}),
-    ("HorizontalBinOpTest.template",  new string[] { "Ssse3", "Sse2",  "HorizontalSubtract",         "Vector128",   "Int16",     "Vector128",   "Int16",     "Vector128",   "Int16",                                 "16",       "(short)(random.Next(short.MinValue, short.MaxValue))",     "(short)(random.Next(short.MinValue, short.MaxValue))",               "result[i1] != (short)(left[i3] - left[i3 + 1])",                                                         "result[i2] != (short)(right[i3] - right[i3 + 1])"}),
-    ("HorizontalBinOpTest.template",  new string[] { "Ssse3", "Sse2",  "HorizontalSubtract",         "Vector128",   "Int32",     "Vector128",   "Int32",     "Vector128",   "Int32",                                 "16",       "(int)(random.Next(int.MinValue, int.MaxValue))",           "(int)(random.Next(int.MinValue, int.MaxValue))",                     "result[i1] != (int)(left[i3] - left[i3 + 1])",                                                           "result[i2] != (int)(right[i3] - right[i3 + 1])"}),
-    ("HorizontalBinOpTest.template",  new string[] { "Ssse3", "Sse2",  "HorizontalSubtractSaturate", "Vector128",   "Int16",     "Vector128",   "Int16",     "Vector128",   "Int16",                                 "16",       "(short)(random.Next(short.MinValue, short.MaxValue))",     "(short)(random.Next(short.MinValue, short.MaxValue))",               "result[i1] != Math.Clamp((left[i3] - left[i3 + 1]), short.MinValue, short.MaxValue)",                    "result[i2] != Math.Clamp((right[i3] - right[i3 + 1]), short.MinValue, short.MaxValue)"}),
-    ("SimpleBinOpTest.template",      new string[] { "Ssse3", "Sse2",  "MultiplyAddAdjacent",        "Vector128",   "Int16",     "Vector128",   "Byte",      "Vector128",   "SByte",                                 "16",       "(byte)(random.Next(0, byte.MaxValue))",                    "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",               "result[0] != Math.Clamp(((right[1] * left[1]) + (right[0] * left[0])), short.MinValue, short.MaxValue)", "result[i] != Math.Clamp(((right[(i * 2) + 1] * left[(i * 2) + 1]) + (right[i * 2] * left[i * 2])), short.MinValue, short.MaxValue)"}),
-    ("SimpleBinOpTest.template",      new string[] { "Ssse3", "Sse2",  "MultiplyHighRoundScale",     "Vector128",   "Int16",     "Vector128",   "Int16",     "Vector128",   "Int16",                                 "16",       "(short)(random.Next(short.MinValue, short.MaxValue))",     "(short)(random.Next(short.MinValue, short.MaxValue))",               "result[0] != (short)((((left[0] * right[0]) >> 14) + 1) >> 1)",                                          "result[i] != (short)((((left[i] * right[i]) >> 14) + 1) >> 1)"}),
-    ("SimpleBinOpTest.template",      new string[] { "Ssse3", "Sse2",  "Shuffle",                    "Vector128",   "SByte",     "Vector128",   "SByte",     "Vector128",   "SByte",                                 "16",       "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",     "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",               "result[0] != ((right[0] < 0) ? 0 : left[right[0] & 0x0F])",                                              "result[i] != ((right[i] < 0) ? 0 : left[right[i] & 0x0F])"}),
-    ("SimpleBinOpTest.template",      new string[] { "Ssse3", "Sse2",  "Sign",                       "Vector128",   "SByte",     "Vector128",   "SByte",     "Vector128",   "SByte",                                 "16",       "(sbyte)(random.Next(sbyte.MinValue + 1, sbyte.MaxValue))", "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",               "result[0] != (right[0] < 0 ? (sbyte)(-left[0]) : (right[0] > 0 ? left[0] : 0))",                                              "result[i] != (right[i] < 0 ? (sbyte)(-left[i]) : (right[i] > 0 ? left[i] : 0))"}),
-    ("SimpleBinOpTest.template",      new string[] { "Ssse3", "Sse2",  "Sign",                       "Vector128",   "Int16",     "Vector128",   "Int16",     "Vector128",   "Int16",                                 "16",       "(short)(random.Next(short.MinValue + 1, short.MaxValue))", "(short)(random.Next(short.MinValue, short.MaxValue))",               "result[0] != (right[0] < 0 ? (short)(-left[0]) : (right[0] > 0 ? left[0] : 0))",                                              "result[i] != (right[i] < 0 ? (short)(-left[i]) : (right[i] > 0 ? left[i] : 0))"}),
-    ("SimpleBinOpTest.template",      new string[] { "Ssse3", "Sse2",  "Sign",                       "Vector128",   "Int32",     "Vector128",   "Int32",     "Vector128",   "Int32",                                 "16",       "(int)(random.Next(int.MinValue + 1, int.MaxValue))",       "(int)(random.Next(int.MinValue, int.MaxValue))",                     "result[0] != (right[0] < 0 ? (int)(-left[0]) : (right[0] > 0 ? left[0] : 0))",                                                "result[i] != (right[i] < 0 ? (int)(-left[i]) : (right[i] > 0 ? left[i] : 0))"}),
+    ("SimpleUnOpTest.template",       new Dictionary<string, string> { ["Isa"] = "Ssse3", ["LoadIsa"] = "Sse2", ["Method"] = "Abs",                        ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Byte",   ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "SByte",                                                             ["VectorSize"] = "16", ["NextValueOp1"] = "(sbyte)(random.Next(sbyte.MinValue + 1, sbyte.MaxValue))",                                                                            ["ValidateFirstResult"] = "result[0] != Math.Abs(firstOp[0])",                                                                      ["ValidateRemainingResults"] = "result[i] != Math.Abs(firstOp[i])"}),
+    ("SimpleUnOpTest.template",       new Dictionary<string, string> { ["Isa"] = "Ssse3", ["LoadIsa"] = "Sse2", ["Method"] = "Abs",                        ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16",                                                             ["VectorSize"] = "16", ["NextValueOp1"] = "(short)(random.Next(short.MinValue + 1, short.MaxValue))",                                                                            ["ValidateFirstResult"] = "result[0] != Math.Abs(firstOp[0])",                                                                      ["ValidateRemainingResults"] = "result[i] != Math.Abs(firstOp[i])"}),
+    ("SimpleUnOpTest.template",       new Dictionary<string, string> { ["Isa"] = "Ssse3", ["LoadIsa"] = "Sse2", ["Method"] = "Abs",                        ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int32",                                                             ["VectorSize"] = "16", ["NextValueOp1"] = "(int)(random.Next(int.MinValue + 1, int.MaxValue))",                                                                                  ["ValidateFirstResult"] = "result[0] != Math.Abs(firstOp[0])",                                                                      ["ValidateRemainingResults"] = "result[i] != Math.Abs(firstOp[i])"}),
+    ("HorizontalBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Ssse3", ["LoadIsa"] = "Sse2", ["Method"] = "HorizontalAdd",              ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int16", ["VectorSize"] = "16", ["NextValueOp1"] = "(short)(random.Next(short.MinValue, short.MaxValue))",     ["NextValueOp2"] = "(short)(random.Next(short.MinValue, short.MaxValue))", ["ValidateFirstResult"] = "result[i1] != (short)(left[i3] + left[i3 + 1])",                                                         ["ValidateRemainingResults"] = "result[i2] != (short)(right[i3] + right[i3 + 1])"}),
+    ("HorizontalBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Ssse3", ["LoadIsa"] = "Sse2", ["Method"] = "HorizontalAdd",              ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int32", ["VectorSize"] = "16", ["NextValueOp1"] = "(int)(random.Next(int.MinValue, int.MaxValue))",           ["NextValueOp2"] = "(int)(random.Next(int.MinValue, int.MaxValue))",       ["ValidateFirstResult"] = "result[i1] != (int)(left[i3] + left[i3 + 1])",                                                           ["ValidateRemainingResults"] = "result[i2] != (int)(right[i3] + right[i3 + 1])"}),    
+    ("HorizontalBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Ssse3", ["LoadIsa"] = "Sse2", ["Method"] = "HorizontalAddSaturate",      ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int16", ["VectorSize"] = "16", ["NextValueOp1"] = "(short)(random.Next(short.MinValue, short.MaxValue))",     ["NextValueOp2"] = "(short)(random.Next(short.MinValue, short.MaxValue))", ["ValidateFirstResult"] = "result[i1] != Math.Clamp((left[i3] + left[i3 + 1]), short.MinValue, short.MaxValue)",                    ["ValidateRemainingResults"] = "result[i2] != Math.Clamp((right[i3] + right[i3 + 1]), short.MinValue, short.MaxValue)"}),
+    ("HorizontalBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Ssse3", ["LoadIsa"] = "Sse2", ["Method"] = "HorizontalSubtract",         ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int16", ["VectorSize"] = "16", ["NextValueOp1"] = "(short)(random.Next(short.MinValue, short.MaxValue))",     ["NextValueOp2"] = "(short)(random.Next(short.MinValue, short.MaxValue))", ["ValidateFirstResult"] = "result[i1] != (short)(left[i3] - left[i3 + 1])",                                                         ["ValidateRemainingResults"] = "result[i2] != (short)(right[i3] - right[i3 + 1])"}),
+    ("HorizontalBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Ssse3", ["LoadIsa"] = "Sse2", ["Method"] = "HorizontalSubtract",         ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int32", ["VectorSize"] = "16", ["NextValueOp1"] = "(int)(random.Next(int.MinValue, int.MaxValue))",           ["NextValueOp2"] = "(int)(random.Next(int.MinValue, int.MaxValue))",       ["ValidateFirstResult"] = "result[i1] != (int)(left[i3] - left[i3 + 1])",                                                           ["ValidateRemainingResults"] = "result[i2] != (int)(right[i3] - right[i3 + 1])"}),
+    ("HorizontalBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Ssse3", ["LoadIsa"] = "Sse2", ["Method"] = "HorizontalSubtractSaturate", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int16", ["VectorSize"] = "16", ["NextValueOp1"] = "(short)(random.Next(short.MinValue, short.MaxValue))",     ["NextValueOp2"] = "(short)(random.Next(short.MinValue, short.MaxValue))", ["ValidateFirstResult"] = "result[i1] != Math.Clamp((left[i3] - left[i3 + 1]), short.MinValue, short.MaxValue)",                    ["ValidateRemainingResults"] = "result[i2] != Math.Clamp((right[i3] - right[i3 + 1]), short.MinValue, short.MaxValue)"}),
+    ("SimpleBinOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Ssse3", ["LoadIsa"] = "Sse2", ["Method"] = "MultiplyAddAdjacent",        ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Byte",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "SByte", ["VectorSize"] = "16", ["NextValueOp1"] = "(byte)(random.Next(0, byte.MaxValue))",                    ["NextValueOp2"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))", ["ValidateFirstResult"] = "result[0] != Math.Clamp(((right[1] * left[1]) + (right[0] * left[0])), short.MinValue, short.MaxValue)", ["ValidateRemainingResults"] = "result[i] != Math.Clamp(((right[(i * 2) + 1] * left[(i * 2) + 1]) + (right[i * 2] * left[i * 2])), short.MinValue, short.MaxValue)"}),
+    ("SimpleBinOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Ssse3", ["LoadIsa"] = "Sse2", ["Method"] = "MultiplyHighRoundScale",     ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int16", ["VectorSize"] = "16", ["NextValueOp1"] = "(short)(random.Next(short.MinValue, short.MaxValue))",     ["NextValueOp2"] = "(short)(random.Next(short.MinValue, short.MaxValue))", ["ValidateFirstResult"] = "result[0] != (short)((((left[0] * right[0]) >> 14) + 1) >> 1)",                                          ["ValidateRemainingResults"] = "result[i] != (short)((((left[i] * right[i]) >> 14) + 1) >> 1)"}),
+    ("SimpleBinOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Ssse3", ["LoadIsa"] = "Sse2", ["Method"] = "Shuffle",                    ["RetVectorType"] = "Vector128", ["RetBaseType"] = "SByte",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "SByte", ["VectorSize"] = "16", ["NextValueOp1"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",     ["NextValueOp2"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))", ["ValidateFirstResult"] = "result[0] != ((right[0] < 0) ? 0 : left[right[0] & 0x0F])",                                              ["ValidateRemainingResults"] = "result[i] != ((right[i] < 0) ? 0 : left[right[i] & 0x0F])"}),
+    ("SimpleBinOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Ssse3", ["LoadIsa"] = "Sse2", ["Method"] = "Sign",                       ["RetVectorType"] = "Vector128", ["RetBaseType"] = "SByte",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "SByte", ["VectorSize"] = "16", ["NextValueOp1"] = "(sbyte)(random.Next(sbyte.MinValue + 1, sbyte.MaxValue))", ["NextValueOp2"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))", ["ValidateFirstResult"] = "result[0] != (right[0] < 0 ? (sbyte)(-left[0]) : (right[0] > 0 ? left[0] : 0))",                         ["ValidateRemainingResults"] = "result[i] != (right[i] < 0 ? (sbyte)(-left[i]) : (right[i] > 0 ? left[i] : 0))"}),
+    ("SimpleBinOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Ssse3", ["LoadIsa"] = "Sse2", ["Method"] = "Sign",                       ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int16", ["VectorSize"] = "16", ["NextValueOp1"] = "(short)(random.Next(short.MinValue + 1, short.MaxValue))", ["NextValueOp2"] = "(short)(random.Next(short.MinValue, short.MaxValue))", ["ValidateFirstResult"] = "result[0] != (right[0] < 0 ? (short)(-left[0]) : (right[0] > 0 ? left[0] : 0))",                         ["ValidateRemainingResults"] = "result[i] != (right[i] < 0 ? (short)(-left[i]) : (right[i] > 0 ? left[i] : 0))"}),
+    ("SimpleBinOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Ssse3", ["LoadIsa"] = "Sse2", ["Method"] = "Sign",                       ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int32", ["VectorSize"] = "16", ["NextValueOp1"] = "(int)(random.Next(int.MinValue + 1, int.MaxValue))",       ["NextValueOp2"] = "(int)(random.Next(int.MinValue, int.MaxValue))",       ["ValidateFirstResult"] = "result[0] != (right[0] < 0 ? (int)(-left[0]) : (right[0] > 0 ? left[0] : 0))",                           ["ValidateRemainingResults"] = "result[i] != (right[i] < 0 ? (int)(-left[i]) : (right[i] > 0 ? left[i] : 0))"}),
 };
 
-private static readonly (string templateFileName, string[] templateData)[] Sse41Inputs = new []
+private static readonly (string templateFileName, Dictionary<string, string> templateData)[] Sse41Inputs = new []
 {
-    // TemplateName                                 Isa,     LoadIsa, Method,                          RetVectorType, RetBaseType, Op1VectorType, Op1BaseType, Op2VectorType, Op2BaseType, Op3VectorType, Op3BaseType, VectorSize, NextValueOp1,                                           NextValueOp2,                                           NextValueOp3,                            ValidateFirstResult,                                                 ValidateRemainingResults 
-    ("SimpleTernOpTest.template",    new string[] { "Sse41", "Sse2",  "BlendVariable",                 "Vector128",   "Byte",      "Vector128",   "Byte",      "Vector128",   "Byte",      "Vector128",   "Byte",      "16",       "(byte)(random.Next(0, byte.MaxValue))",                "(byte)(random.Next(0, byte.MaxValue))",                "(byte)(((i % 2) == 0) ? 128 : 1)",      "((thirdOp[0] >> 7) & 1) == 1 ? secondOp[0] != result[0] : firstOp[0] != result[0]",                                                                                                                                                                  "((thirdOp[i] >> 7) & 1) == 1 ? secondOp[i] != result[i] : firstOp[i] != result[i]"}),
-    ("SimpleTernOpTest.template",    new string[] { "Sse41", "Sse2",  "BlendVariable",                 "Vector128",   "Double",    "Vector128",   "Double",    "Vector128",   "Double",    "Vector128",   "Double",    "16",       "(double)(random.NextDouble())",                        "(double)(random.NextDouble())",                        "(double)(((i % 2) == 0) ? -0.0 : 1.0)", "((BitConverter.DoubleToInt64Bits(thirdOp[0]) >> 63) & 1) == 1 ? BitConverter.DoubleToInt64Bits(secondOp[0]) != BitConverter.DoubleToInt64Bits(result[0]) : BitConverter.DoubleToInt64Bits(firstOp[0]) != BitConverter.DoubleToInt64Bits(result[0])", "((BitConverter.DoubleToInt64Bits(thirdOp[i]) >> 63) & 1) == 1 ? BitConverter.DoubleToInt64Bits(secondOp[i]) != BitConverter.DoubleToInt64Bits(result[i]) : BitConverter.DoubleToInt64Bits(firstOp[i]) != BitConverter.DoubleToInt64Bits(result[i])"}),
-    ("SimpleTernOpTest.template",    new string[] { "Sse41", "Sse2",  "BlendVariable",                 "Vector128",   "SByte",     "Vector128",   "SByte",     "Vector128",   "SByte",     "Vector128",   "SByte",     "16",       "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))", "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))", "(sbyte)(((i % 2) == 0) ? -128 : 1)",    "((thirdOp[0] >> 7) & 1) == 1 ? secondOp[0] != result[0] : firstOp[0] != result[0]",                                                                                                                                                                  "((thirdOp[i] >> 7) & 1) == 1 ? secondOp[i] != result[i] : firstOp[i] != result[i]"}),
-    ("SimpleTernOpTest.template",    new string[] { "Sse41", "Sse",   "BlendVariable",                 "Vector128",   "Single",    "Vector128",   "Single",    "Vector128",   "Single",    "Vector128",   "Single",    "16",       "(float)(random.NextDouble())",                         "(float)(random.NextDouble())",                         "(float)(((i % 2) == 0) ? -0.0 : 1.0)",  "((BitConverter.SingleToInt32Bits(thirdOp[0]) >> 31) & 1) == 1 ? BitConverter.SingleToInt32Bits(secondOp[0]) != BitConverter.SingleToInt32Bits(result[0]) : BitConverter.SingleToInt32Bits(firstOp[0]) != BitConverter.SingleToInt32Bits(result[0])", "((BitConverter.SingleToInt32Bits(thirdOp[i]) >> 31) & 1) == 1 ? BitConverter.SingleToInt32Bits(secondOp[i]) != BitConverter.SingleToInt32Bits(result[i]) : BitConverter.SingleToInt32Bits(firstOp[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
-    ("SimpleUnOpTest.template",      new string[] { "Sse41", "Sse2",  "Ceiling",                       "Vector128",   "Double",    "Vector128",   "Double",                                                            "16",       "(double)(random.NextDouble())",                                                                                                                         "BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Ceiling(firstOp[0]))",                                                                                                                                              "BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(Math.Ceiling(firstOp[i]))"}),
-    ("SimpleUnOpTest.template",      new string[] { "Sse41", "Sse",   "Ceiling",                       "Vector128",   "Single",    "Vector128",   "Single",                                                            "16",       "(float)(random.NextDouble())",                                                                                                                          "BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Ceiling(firstOp[0]))",                                                                                                                                             "BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(MathF.Ceiling(firstOp[i]))"}),
-    ("SimpleBinOpTest.template",     new string[] { "Sse41", "Sse2",  "CeilingScalar",                 "Vector128",   "Double",    "Vector128",   "Double",    "Vector128",   "Double",                                "16",       "(double)(random.NextDouble())",                        "(double)(random.NextDouble())",                                                                 "BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Ceiling(right[0]))",                                                                                                                                                "BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(left[i])"}),
-    ("SimpleBinOpTest.template",     new string[] { "Sse41", "Sse",   "CeilingScalar",                 "Vector128",   "Single",    "Vector128",   "Single",    "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())",                         "(float)(random.NextDouble())",                                                                  "BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Ceiling(right[0]))",                                                                                                                                               "BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(left[i])"}),
-    ("SimpleBinOpTest.template",     new string[] { "Sse41", "Sse2",  "CompareEqual",                  "Vector128",   "Int64",     "Vector128",   "Int64",     "Vector128",   "Int64",                                 "16",       "(long)(random.Next(int.MinValue, int.MaxValue))",      "(long)(random.Next(int.MinValue, int.MaxValue))",                                               "result[0] != ((left[0] == right[0]) ? unchecked((long)(-1)) : 0)",                                                                                                                                                                                   "result[i] != ((left[i] == right[i]) ? unchecked((long)(-1)) : 0)"}),
-    ("SimpleBinOpTest.template",     new string[] { "Sse41", "Sse2",  "CompareEqual",                  "Vector128",   "UInt64",    "Vector128",   "UInt64",    "Vector128",   "UInt64",                                "16",       "(ulong)(random.Next(0, int.MaxValue))",                "(ulong)(random.Next(0, int.MaxValue))",                                                         "result[0] != ((left[0] == right[0]) ? unchecked((ulong)(-1)) : 0)",                                                                                                                                                                                  "result[i] != ((left[i] == right[i]) ? unchecked((ulong)(-1)) : 0)"}),
-    ("SimpleUnOpTest.template",      new string[] { "Sse41", "Sse2",  "Floor",                         "Vector128",   "Double",    "Vector128",   "Double",                                                            "16",       "(double)(random.NextDouble())",                                                                                                                         "BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Floor(firstOp[0]))",                                                                                                                                                "BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(Math.Floor(firstOp[i]))"}),
-    ("SimpleUnOpTest.template",      new string[] { "Sse41", "Sse",   "Floor",                         "Vector128",   "Single",    "Vector128",   "Single",                                                            "16",       "(float)(random.NextDouble())",                                                                                                                          "BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Floor(firstOp[0]))",                                                                                                                                               "BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(MathF.Floor(firstOp[i]))"}),
-    ("SimpleBinOpTest.template",     new string[] { "Sse41", "Sse2",  "FloorScalar",                   "Vector128",   "Double",    "Vector128",   "Double",    "Vector128",   "Double",                                "16",       "(double)(random.NextDouble())",                        "(double)(random.NextDouble())",                                                                 "BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Floor(right[0]))",                                                                                                                                                  "BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(left[i])"}),
-    ("SimpleBinOpTest.template",     new string[] { "Sse41", "Sse",   "FloorScalar",                   "Vector128",   "Single",    "Vector128",   "Single",    "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())",                         "(float)(random.NextDouble())",                                                                  "BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Floor(right[0]))",                                                                                                                                                 "BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(left[i])"}),
-    ("SimpleBinOpTest.template",     new string[] { "Sse41", "Sse2",  "Max",                           "Vector128",   "Int32",     "Vector128",   "Int32",     "Vector128",   "Int32",                                 "16",       "(int)(random.Next(int.MinValue, int.MaxValue))",       "(int)(random.Next(int.MinValue, int.MaxValue))",                                                "result[0] != Math.Max(left[0], right[0])",                                                                                                                                                                                                           "result[i] != Math.Max(left[i], right[i])"}),
-    ("SimpleBinOpTest.template",     new string[] { "Sse41", "Sse2",  "Max",                           "Vector128",   "SByte",     "Vector128",   "SByte",     "Vector128",   "SByte",                                 "16",       "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))", "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",                                          "result[0] != Math.Max(left[0], right[0])",                                                                                                                                                                                                           "result[i] != Math.Max(left[i], right[i])"}),
-    ("SimpleBinOpTest.template",     new string[] { "Sse41", "Sse2",  "Max",                           "Vector128",   "UInt16",    "Vector128",   "UInt16",    "Vector128",   "UInt16",                                "16",       "(ushort)(random.Next(0, ushort.MaxValue))",            "(ushort)(random.Next(0, ushort.MaxValue))",                                                     "result[0] != Math.Max(left[0], right[0])",                                                                                                                                                                                                           "result[i] != Math.Max(left[i], right[i])"}),
-    ("SimpleBinOpTest.template",     new string[] { "Sse41", "Sse2",  "Max",                           "Vector128",   "UInt32",    "Vector128",   "UInt32",    "Vector128",   "UInt32",                                "16",       "(uint)(random.Next(0, int.MaxValue))",                 "(uint)(random.Next(0, int.MaxValue))",                                                          "result[0] != Math.Max(left[0], right[0])",                                                                                                                                                                                                           "result[i] != Math.Max(left[i], right[i])"}),
-    ("SimpleBinOpTest.template",     new string[] { "Sse41", "Sse2",  "Min",                           "Vector128",   "Int32",     "Vector128",   "Int32",     "Vector128",   "Int32",                                 "16",       "(int)(random.Next(int.MinValue, int.MaxValue))",       "(int)(random.Next(int.MinValue, int.MaxValue))",                                                "result[0] != Math.Min(left[0], right[0])",                                                                                                                                                                                                           "result[i] != Math.Min(left[i], right[i])"}),
-    ("SimpleBinOpTest.template",     new string[] { "Sse41", "Sse2",  "Min",                           "Vector128",   "SByte",     "Vector128",   "SByte",     "Vector128",   "SByte",                                 "16",       "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))", "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",                                          "result[0] != Math.Min(left[0], right[0])",                                                                                                                                                                                                           "result[i] != Math.Min(left[i], right[i])"}),
-    ("SimpleBinOpTest.template",     new string[] { "Sse41", "Sse2",  "Min",                           "Vector128",   "UInt16",    "Vector128",   "UInt16",    "Vector128",   "UInt16",                                "16",       "(ushort)(random.Next(0, ushort.MaxValue))",            "(ushort)(random.Next(0, ushort.MaxValue))",                                                     "result[0] != Math.Min(left[0], right[0])",                                                                                                                                                                                                           "result[i] != Math.Min(left[i], right[i])"}),
-    ("SimpleBinOpTest.template",     new string[] { "Sse41", "Sse2",  "Min",                           "Vector128",   "UInt32",    "Vector128",   "UInt32",    "Vector128",   "UInt32",                                "16",       "(uint)(random.Next(0, int.MaxValue))",                 "(uint)(random.Next(0, int.MaxValue))",                                                          "result[0] != Math.Min(left[0], right[0])",                                                                                                                                                                                                           "result[i] != Math.Min(left[i], right[i])"}),
-    ("SimpleBinOpTest.template",     new string[] { "Sse41", "Sse2",  "MultiplyLow",                   "Vector128",   "Int32",     "Vector128",   "Int32",     "Vector128",   "Int32",                                 "16",       "(int)(random.Next(int.MinValue, int.MaxValue))",       "(int)(random.Next(int.MinValue, int.MaxValue))",                                                "result[0] != BitConverter.ToInt32(BitConverter.GetBytes(((long)(left[0])) * right[0]), 0)",                                                                                                                                                          "result[i] != BitConverter.ToInt32(BitConverter.GetBytes(((long)(left[i])) * right[i]), 0)"}),
-    ("HorizontalBinOpTest.template", new string[] { "Sse41", "Sse2",  "PackUnsignedSaturate",          "Vector128",   "UInt16",    "Vector128",   "Int32",     "Vector128",   "Int32",                                 "16",       "(int)(random.Next(int.MinValue, int.MaxValue))",       "(int)(random.Next(int.MinValue, int.MaxValue))",                                                "result[i1] != ((left[i3 - inner] > 0xFFFF) ? 0xFFFF : ((left[i3 - inner] < 0) ? 0 : BitConverter.ToUInt16(BitConverter.GetBytes(left[i3 - inner]), 0)))",                                                                                            "result[i2] != ((right[i3 - inner] > 0xFFFF) ? 0xFFFF : ((right[i3 - inner] < 0) ? 0 : BitConverter.ToUInt16(BitConverter.GetBytes(right[i3 - inner]), 0)))"}),
-    ("SimpleUnOpTest.template",      new string[] { "Sse41", "Sse2",  "RoundCurrentDirection",         "Vector128",   "Double",    "Vector128",   "Double",                                                            "16",       "(double)(random.NextDouble())",                                                                                                                         "BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Round(firstOp[0]))",                                                                                                                                                "BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(Math.Round(firstOp[i]))"}),
-    ("SimpleUnOpTest.template",      new string[] { "Sse41", "Sse",   "RoundCurrentDirection",         "Vector128",   "Single",    "Vector128",   "Single",                                                            "16",       "(float)(random.NextDouble())",                                                                                                                          "BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Round(firstOp[0]))",                                                                                                                                               "BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(MathF.Round(firstOp[i]))"}),
-    ("SimpleBinOpTest.template",     new string[] { "Sse41", "Sse2",  "RoundCurrentDirectionScalar",   "Vector128",   "Double",    "Vector128",   "Double",    "Vector128",   "Double",                                "16",       "(double)(random.NextDouble())",                        "(double)(random.NextDouble())",                                                                 "BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Round(right[0]))",                                                                                                                                                  "BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(left[i])"}),
-    ("SimpleBinOpTest.template",     new string[] { "Sse41", "Sse",   "RoundCurrentDirectionScalar",   "Vector128",   "Single",    "Vector128",   "Single",    "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())",                         "(float)(random.NextDouble())",                                                                  "BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Round(right[0]))",                                                                                                                                                 "BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(left[i])"}),
-    ("SimpleUnOpTest.template",      new string[] { "Sse41", "Sse2",  "RoundToNearestInteger",         "Vector128",   "Double",    "Vector128",   "Double",                                                            "16",       "(double)(random.NextDouble())",                                                                                                                         "BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Round(firstOp[0], MidpointRounding.AwayFromZero))",                                                                                                                 "BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(Math.Round(firstOp[i], MidpointRounding.AwayFromZero))"}),
-    ("SimpleUnOpTest.template",      new string[] { "Sse41", "Sse",   "RoundToNearestInteger",         "Vector128",   "Single",    "Vector128",   "Single",                                                            "16",       "(float)(random.NextDouble())",                                                                                                                          "BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Round(firstOp[0], MidpointRounding.AwayFromZero))",                                                                                                                "BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(MathF.Round(firstOp[i], MidpointRounding.AwayFromZero))"}),
-    ("SimpleBinOpTest.template",     new string[] { "Sse41", "Sse2",  "RoundToNearestIntegerScalar",   "Vector128",   "Double",    "Vector128",   "Double",    "Vector128",   "Double",                                "16",       "(double)(random.NextDouble())",                        "(double)(random.NextDouble())",                                                                 "BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Round(right[0], MidpointRounding.AwayFromZero))",                                                                                                                   "BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(left[i])"}),
-    ("SimpleBinOpTest.template",     new string[] { "Sse41", "Sse",   "RoundToNearestIntegerScalar",   "Vector128",   "Single",    "Vector128",   "Single",    "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())",                         "(float)(random.NextDouble())",                                                                  "BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Round(right[0], MidpointRounding.AwayFromZero))",                                                                                                                  "BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(left[i])"}),
-    ("SimpleUnOpTest.template",      new string[] { "Sse41", "Sse2",  "RoundToNegativeInfinity",       "Vector128",   "Double",    "Vector128",   "Double",                                                            "16",       "(double)(random.NextDouble())",                                                                                                                         "BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Floor(firstOp[0]))",                                                                                                                                                "BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(Math.Floor(firstOp[i]))"}),
-    ("SimpleUnOpTest.template",      new string[] { "Sse41", "Sse",   "RoundToNegativeInfinity",       "Vector128",   "Single",    "Vector128",   "Single",                                                            "16",       "(float)(random.NextDouble())",                                                                                                                          "BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Floor(firstOp[0]))",                                                                                                                                               "BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(MathF.Floor(firstOp[i]))"}),
-    ("SimpleBinOpTest.template",     new string[] { "Sse41", "Sse2",  "RoundToNegativeInfinityScalar", "Vector128",   "Double",    "Vector128",   "Double",    "Vector128",   "Double",                                "16",       "(double)(random.NextDouble())",                        "(double)(random.NextDouble())",                                                                 "BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Floor(right[0]))",                                                                                                                                                  "BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(left[i])"}),
-    ("SimpleBinOpTest.template",     new string[] { "Sse41", "Sse",   "RoundToNegativeInfinityScalar", "Vector128",   "Single",    "Vector128",   "Single",    "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())",                         "(float)(random.NextDouble())",                                                                  "BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Floor(right[0]))",                                                                                                                                                 "BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(left[i])"}),
-    ("SimpleUnOpTest.template",      new string[] { "Sse41", "Sse2",  "RoundToPositiveInfinity",       "Vector128",   "Double",    "Vector128",   "Double",                                                            "16",       "(double)(random.NextDouble())",                                                                                                                         "BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Ceiling(firstOp[0]))",                                                                                                                                              "BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(Math.Ceiling(firstOp[i]))"}),
-    ("SimpleUnOpTest.template",      new string[] { "Sse41", "Sse",   "RoundToPositiveInfinity",       "Vector128",   "Single",    "Vector128",   "Single",                                                            "16",       "(float)(random.NextDouble())",                                                                                                                          "BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Ceiling(firstOp[0]))",                                                                                                                                             "BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(MathF.Ceiling(firstOp[i]))"}),
-    ("SimpleBinOpTest.template",     new string[] { "Sse41", "Sse2",  "RoundToPositiveInfinityScalar", "Vector128",   "Double",    "Vector128",   "Double",    "Vector128",   "Double",                                "16",       "(double)(random.NextDouble())",                        "(double)(random.NextDouble())",                                                                 "BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Ceiling(right[0]))",                                                                                                                                                "BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(left[i])"}),
-    ("SimpleBinOpTest.template",     new string[] { "Sse41", "Sse",   "RoundToPositiveInfinityScalar", "Vector128",   "Single",    "Vector128",   "Single",    "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())",                         "(float)(random.NextDouble())",                                                                  "BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Ceiling(right[0]))",                                                                                                                                               "BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(left[i])"}),
-    ("SimpleUnOpTest.template",      new string[] { "Sse41", "Sse2",  "RoundToZero",                   "Vector128",   "Double",    "Vector128",   "Double",                                                            "16",       "(double)(random.NextDouble())",                                                                                                                         "BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits((firstOp[0] > 0) ? Math.Floor(firstOp[0]) : Math.Ceiling(firstOp[0]))",                                                                                                  "BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits((firstOp[i] > 0) ? Math.Floor(firstOp[i]) : Math.Ceiling(firstOp[i]))"}),
-    ("SimpleUnOpTest.template",      new string[] { "Sse41", "Sse",   "RoundToZero",                   "Vector128",   "Single",    "Vector128",   "Single",                                                            "16",       "(float)(random.NextDouble())",                                                                                                                          "BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits((firstOp[0] > 0) ? MathF.Floor(firstOp[0]) : MathF.Ceiling(firstOp[0]))",                                                                                                "BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits((firstOp[i] > 0) ? MathF.Floor(firstOp[i]) : MathF.Ceiling(firstOp[i]))"}),
-    ("SimpleBinOpTest.template",     new string[] { "Sse41", "Sse2",  "RoundToZeroScalar",             "Vector128",   "Double",    "Vector128",   "Double",    "Vector128",   "Double",                                "16",       "(double)(random.NextDouble())",                        "(double)(random.NextDouble())",                                                                 "BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits((right[0] > 0) ? Math.Floor(right[0]) : Math.Ceiling(right[0]))",                                                                                                        "BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(left[i])"}),
-    ("SimpleBinOpTest.template",     new string[] { "Sse41", "Sse",   "RoundToZeroScalar",             "Vector128",   "Single",    "Vector128",   "Single",    "Vector128",   "Single",                                "16",       "(float)(random.NextDouble())",                         "(float)(random.NextDouble())",                                                                  "BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits((right[0] > 0) ? MathF.Floor(right[0]) : MathF.Ceiling(right[0]))",                                                                                                      "BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(left[i])"}),
-    ("BooleanUnOpTest.template",     new string[] { "Sse41", "Sse2",  "TestAllOnes",                   "Vector128",   "Byte",      "Vector128",   "Byte",                                                              "16",       "(byte)(random.Next(0, byte.MaxValue))",                                                                                                                 "(~value[i] & byte.MaxValue) == 0"}),
-    ("BooleanUnOpTest.template",     new string[] { "Sse41", "Sse2",  "TestAllOnes",                   "Vector128",   "Int16",     "Vector128",   "Int16",                                                             "16",       "(short)(random.Next(short.MinValue, short.MaxValue))",                                                                                                  "(~value[i] & -1) == 0"}),
-    ("BooleanUnOpTest.template",     new string[] { "Sse41", "Sse2",  "TestAllOnes",                   "Vector128",   "Int32",     "Vector128",   "Int32",                                                             "16",       "(int)(random.Next(int.MinValue, int.MaxValue))",                                                                                                        "(~value[i] & -1) == 0"}),
-    ("BooleanUnOpTest.template",     new string[] { "Sse41", "Sse2",  "TestAllOnes",                   "Vector128",   "Int64",     "Vector128",   "Int64",                                                             "16",       "(long)(random.Next(int.MinValue, int.MaxValue))",                                                                                                       "(~value[i] & -1) == 0"}),
-    ("BooleanUnOpTest.template",     new string[] { "Sse41", "Sse2",  "TestAllOnes",                   "Vector128",   "SByte",     "Vector128",   "SByte",                                                             "16",       "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",                                                                                                  "(~value[i] & -1) == 0"}),
-    ("BooleanUnOpTest.template",     new string[] { "Sse41", "Sse2",  "TestAllOnes",                   "Vector128",   "UInt16",    "Vector128",   "UInt16",                                                            "16",       "(ushort)(random.Next(0, ushort.MaxValue))",                                                                                                             "(~value[i] & ushort.MaxValue) == 0"}),
-    ("BooleanUnOpTest.template",     new string[] { "Sse41", "Sse2",  "TestAllOnes",                   "Vector128",   "UInt32",    "Vector128",   "UInt32",                                                            "16",       "(uint)(random.Next(0, int.MaxValue))",                                                                                                                  "(~value[i] & uint.MaxValue) == 0"}),
-    ("BooleanUnOpTest.template",     new string[] { "Sse41", "Sse2",  "TestAllOnes",                   "Vector128",   "UInt64",    "Vector128",   "UInt64",                                                            "16",       "(ulong)(random.Next(0, int.MaxValue))",                                                                                                                 "(~value[i] & ulong.MaxValue) == 0"}),
-    ("BooleanBinOpTest.template",    new string[] { "Sse41", "Sse2",  "TestAllZeros",                  "Vector128",   "Byte",      "Vector128",   "Byte",      "Vector128",   "Byte",                                  "16",       "(byte)(random.Next(0, byte.MaxValue))",                "(byte)(random.Next(0, byte.MaxValue))",                                                         "(left[i] & right[i]) == 0"}),
-    ("BooleanBinOpTest.template",    new string[] { "Sse41", "Sse2",  "TestAllZeros",                  "Vector128",   "Int16",     "Vector128",   "Int16",     "Vector128",   "Int16",                                 "16",       "(short)(random.Next(short.MinValue, short.MaxValue))", "(short)(random.Next(short.MinValue, short.MaxValue))",                                          "(left[i] & right[i]) == 0"}),
-    ("BooleanBinOpTest.template",    new string[] { "Sse41", "Sse2",  "TestAllZeros",                  "Vector128",   "Int32",     "Vector128",   "Int32",     "Vector128",   "Int32",                                 "16",       "(int)(random.Next(int.MinValue, int.MaxValue))",       "(int)(random.Next(int.MinValue, int.MaxValue))",                                                "(left[i] & right[i]) == 0"}),
-    ("BooleanBinOpTest.template",    new string[] { "Sse41", "Sse2",  "TestAllZeros",                  "Vector128",   "Int64",     "Vector128",   "Int64",     "Vector128",   "Int64",                                 "16",       "(long)(random.Next(int.MinValue, int.MaxValue))",      "(long)(random.Next(int.MinValue, int.MaxValue))",                                               "(left[i] & right[i]) == 0"}),
-    ("BooleanBinOpTest.template",    new string[] { "Sse41", "Sse2",  "TestAllZeros",                  "Vector128",   "SByte",     "Vector128",   "SByte",     "Vector128",   "SByte",                                 "16",       "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))", "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",                                          "(left[i] & right[i]) == 0"}),
-    ("BooleanBinOpTest.template",    new string[] { "Sse41", "Sse2",  "TestAllZeros",                  "Vector128",   "UInt16",    "Vector128",   "UInt16",    "Vector128",   "UInt16",                                "16",       "(ushort)(random.Next(0, ushort.MaxValue))",            "(ushort)(random.Next(0, ushort.MaxValue))",                                                     "(left[i] & right[i]) == 0"}),
-    ("BooleanBinOpTest.template",    new string[] { "Sse41", "Sse2",  "TestAllZeros",                  "Vector128",   "UInt32",    "Vector128",   "UInt32",    "Vector128",   "UInt32",                                "16",       "(uint)(random.Next(0, int.MaxValue))",                 "(uint)(random.Next(0, int.MaxValue))",                                                          "(left[i] & right[i]) == 0"}),
-    ("BooleanBinOpTest.template",    new string[] { "Sse41", "Sse2",  "TestAllZeros",                  "Vector128",   "UInt64",    "Vector128",   "UInt64",    "Vector128",   "UInt64",                                "16",       "(ulong)(random.Next(0, int.MaxValue))",                "(ulong)(random.Next(0, int.MaxValue))",                                                         "(left[i] & right[i]) == 0"}),
-    ("BooleanBinOpTest.template",    new string[] { "Sse41", "Sse2",  "TestC",                         "Vector128",   "Byte",      "Vector128",   "Byte",      "Vector128",   "Byte",                                  "16",       "(byte)(random.Next(0, byte.MaxValue))",                "(byte)(random.Next(0, byte.MaxValue))",                                                         "(~left[i] & right[i]) == 0"}),
-    ("BooleanBinOpTest.template",    new string[] { "Sse41", "Sse2",  "TestC",                         "Vector128",   "Int16",     "Vector128",   "Int16",     "Vector128",   "Int16",                                 "16",       "(short)(random.Next(short.MinValue, short.MaxValue))", "(short)(random.Next(short.MinValue, short.MaxValue))",                                          "(~left[i] & right[i]) == 0"}),
-    ("BooleanBinOpTest.template",    new string[] { "Sse41", "Sse2",  "TestC",                         "Vector128",   "Int32",     "Vector128",   "Int32",     "Vector128",   "Int32",                                 "16",       "(int)(random.Next(int.MinValue, int.MaxValue))",       "(int)(random.Next(int.MinValue, int.MaxValue))",                                                "(~left[i] & right[i]) == 0"}),
-    ("BooleanBinOpTest.template",    new string[] { "Sse41", "Sse2",  "TestC",                         "Vector128",   "Int64",     "Vector128",   "Int64",     "Vector128",   "Int64",                                 "16",       "(long)(random.Next(int.MinValue, int.MaxValue))",      "(long)(random.Next(int.MinValue, int.MaxValue))",                                               "(~left[i] & right[i]) == 0"}),
-    ("BooleanBinOpTest.template",    new string[] { "Sse41", "Sse2",  "TestC",                         "Vector128",   "SByte",     "Vector128",   "SByte",     "Vector128",   "SByte",                                 "16",       "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))", "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",                                          "(~left[i] & right[i]) == 0"}),
-    ("BooleanBinOpTest.template",    new string[] { "Sse41", "Sse2",  "TestC",                         "Vector128",   "UInt16",    "Vector128",   "UInt16",    "Vector128",   "UInt16",                                "16",       "(ushort)(random.Next(0, ushort.MaxValue))",            "(ushort)(random.Next(0, ushort.MaxValue))",                                                     "(~left[i] & right[i]) == 0"}),
-    ("BooleanBinOpTest.template",    new string[] { "Sse41", "Sse2",  "TestC",                         "Vector128",   "UInt32",    "Vector128",   "UInt32",    "Vector128",   "UInt32",                                "16",       "(uint)(random.Next(0, int.MaxValue))",                 "(uint)(random.Next(0, int.MaxValue))",                                                          "(~left[i] & right[i]) == 0"}),
-    ("BooleanBinOpTest.template",    new string[] { "Sse41", "Sse2",  "TestC",                         "Vector128",   "UInt64",    "Vector128",   "UInt64",    "Vector128",   "UInt64",                                "16",       "(ulong)(random.Next(0, int.MaxValue))",                "(ulong)(random.Next(0, int.MaxValue))",                                                         "(~left[i] & right[i]) == 0"}),
-    ("BooleanTwoCmpOpTest.template", new string[] { "Sse41", "Sse2",  "TestMixOnesZeros",              "Vector128",   "Byte",      "Vector128",   "Byte",      "Vector128",   "Byte",                                  "16",       "(byte)(random.Next(0, byte.MaxValue))",                "(byte)(random.Next(0, byte.MaxValue))",                                                         "((left[i] & right[i]) == 0)",                                                                                                                                                                                                                        "((~left[i] & right[i]) == 0)"}),
-    ("BooleanTwoCmpOpTest.template", new string[] { "Sse41", "Sse2",  "TestMixOnesZeros",              "Vector128",   "Int16",     "Vector128",   "Int16",     "Vector128",   "Int16",                                 "16",       "(short)(random.Next(short.MinValue, short.MaxValue))", "(short)(random.Next(short.MinValue, short.MaxValue))",                                          "((left[i] & right[i]) == 0)",                                                                                                                                                                                                                        "((~left[i] & right[i]) == 0)"}),
-    ("BooleanTwoCmpOpTest.template", new string[] { "Sse41", "Sse2",  "TestMixOnesZeros",              "Vector128",   "Int32",     "Vector128",   "Int32",     "Vector128",   "Int32",                                 "16",       "(int)(random.Next(int.MinValue, int.MaxValue))",       "(int)(random.Next(int.MinValue, int.MaxValue))",                                                "((left[i] & right[i]) == 0)",                                                                                                                                                                                                                        "((~left[i] & right[i]) == 0)"}),
-    ("BooleanTwoCmpOpTest.template", new string[] { "Sse41", "Sse2",  "TestMixOnesZeros",              "Vector128",   "Int64",     "Vector128",   "Int64",     "Vector128",   "Int64",                                 "16",       "(long)(random.Next(int.MinValue, int.MaxValue))",      "(long)(random.Next(int.MinValue, int.MaxValue))",                                               "((left[i] & right[i]) == 0)",                                                                                                                                                                                                                        "((~left[i] & right[i]) == 0)"}),
-    ("BooleanTwoCmpOpTest.template", new string[] { "Sse41", "Sse2",  "TestMixOnesZeros",              "Vector128",   "SByte",     "Vector128",   "SByte",     "Vector128",   "SByte",                                 "16",       "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))", "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",                                          "((left[i] & right[i]) == 0)",                                                                                                                                                                                                                        "((~left[i] & right[i]) == 0)"}),
-    ("BooleanTwoCmpOpTest.template", new string[] { "Sse41", "Sse2",  "TestMixOnesZeros",              "Vector128",   "UInt16",    "Vector128",   "UInt16",    "Vector128",   "UInt16",                                "16",       "(ushort)(random.Next(0, ushort.MaxValue))",            "(ushort)(random.Next(0, ushort.MaxValue))",                                                     "((left[i] & right[i]) == 0)",                                                                                                                                                                                                                        "((~left[i] & right[i]) == 0)"}),
-    ("BooleanTwoCmpOpTest.template", new string[] { "Sse41", "Sse2",  "TestMixOnesZeros",              "Vector128",   "UInt32",    "Vector128",   "UInt32",    "Vector128",   "UInt32",                                "16",       "(uint)(random.Next(0, int.MaxValue))",                 "(uint)(random.Next(0, int.MaxValue))",                                                          "((left[i] & right[i]) == 0)",                                                                                                                                                                                                                        "((~left[i] & right[i]) == 0)"}),
-    ("BooleanTwoCmpOpTest.template", new string[] { "Sse41", "Sse2",  "TestMixOnesZeros",              "Vector128",   "UInt64",    "Vector128",   "UInt64",    "Vector128",   "UInt64",                                "16",       "(ulong)(random.Next(0, int.MaxValue))",                "(ulong)(random.Next(0, int.MaxValue))",                                                         "((left[i] & right[i]) == 0)",                                                                                                                                                                                                                        "((~left[i] & right[i]) == 0)"}),
-    ("BooleanTwoCmpOpTest.template", new string[] { "Sse41", "Sse2",  "TestNotZAndNotC",               "Vector128",   "Byte",      "Vector128",   "Byte",      "Vector128",   "Byte",                                  "16",       "(byte)(random.Next(0, byte.MaxValue))",                "(byte)(random.Next(0, byte.MaxValue))",                                                         "((left[i] & right[i]) == 0)",                                                                                                                                                                                                                        "((~left[i] & right[i]) == 0)"}),
-    ("BooleanTwoCmpOpTest.template", new string[] { "Sse41", "Sse2",  "TestNotZAndNotC",               "Vector128",   "Int16",     "Vector128",   "Int16",     "Vector128",   "Int16",                                 "16",       "(short)(random.Next(short.MinValue, short.MaxValue))", "(short)(random.Next(short.MinValue, short.MaxValue))",                                          "((left[i] & right[i]) == 0)",                                                                                                                                                                                                                        "((~left[i] & right[i]) == 0)"}),
-    ("BooleanTwoCmpOpTest.template", new string[] { "Sse41", "Sse2",  "TestNotZAndNotC",               "Vector128",   "Int32",     "Vector128",   "Int32",     "Vector128",   "Int32",                                 "16",       "(int)(random.Next(int.MinValue, int.MaxValue))",       "(int)(random.Next(int.MinValue, int.MaxValue))",                                                "((left[i] & right[i]) == 0)",                                                                                                                                                                                                                        "((~left[i] & right[i]) == 0)"}),
-    ("BooleanTwoCmpOpTest.template", new string[] { "Sse41", "Sse2",  "TestNotZAndNotC",               "Vector128",   "Int64",     "Vector128",   "Int64",     "Vector128",   "Int64",                                 "16",       "(long)(random.Next(int.MinValue, int.MaxValue))",      "(long)(random.Next(int.MinValue, int.MaxValue))",                                               "((left[i] & right[i]) == 0)",                                                                                                                                                                                                                        "((~left[i] & right[i]) == 0)"}),
-    ("BooleanTwoCmpOpTest.template", new string[] { "Sse41", "Sse2",  "TestNotZAndNotC",               "Vector128",   "SByte",     "Vector128",   "SByte",     "Vector128",   "SByte",                                 "16",       "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))", "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",                                          "((left[i] & right[i]) == 0)",                                                                                                                                                                                                                        "((~left[i] & right[i]) == 0)"}),
-    ("BooleanTwoCmpOpTest.template", new string[] { "Sse41", "Sse2",  "TestNotZAndNotC",               "Vector128",   "UInt16",    "Vector128",   "UInt16",    "Vector128",   "UInt16",                                "16",       "(ushort)(random.Next(0, ushort.MaxValue))",            "(ushort)(random.Next(0, ushort.MaxValue))",                                                     "((left[i] & right[i]) == 0)",                                                                                                                                                                                                                        "((~left[i] & right[i]) == 0)"}),
-    ("BooleanTwoCmpOpTest.template", new string[] { "Sse41", "Sse2",  "TestNotZAndNotC",               "Vector128",   "UInt32",    "Vector128",   "UInt32",    "Vector128",   "UInt32",                                "16",       "(uint)(random.Next(0, int.MaxValue))",                 "(uint)(random.Next(0, int.MaxValue))",                                                          "((left[i] & right[i]) == 0)",                                                                                                                                                                                                                        "((~left[i] & right[i]) == 0)"}),
-    ("BooleanTwoCmpOpTest.template", new string[] { "Sse41", "Sse2",  "TestNotZAndNotC",               "Vector128",   "UInt64",    "Vector128",   "UInt64",    "Vector128",   "UInt64",                                "16",       "(ulong)(random.Next(0, int.MaxValue))",                "(ulong)(random.Next(0, int.MaxValue))",                                                         "((left[i] & right[i]) == 0)",                                                                                                                                                                                                                        "((~left[i] & right[i]) == 0)"}),
-    ("BooleanBinOpTest.template",    new string[] { "Sse41", "Sse2",  "TestZ",                         "Vector128",   "Byte",      "Vector128",   "Byte",      "Vector128",   "Byte",                                  "16",       "(byte)(random.Next(0, byte.MaxValue))",                "(byte)(random.Next(0, byte.MaxValue))",                                                         "(left[i] & right[i]) == 0"}),
-    ("BooleanBinOpTest.template",    new string[] { "Sse41", "Sse2",  "TestZ",                         "Vector128",   "Int16",     "Vector128",   "Int16",     "Vector128",   "Int16",                                 "16",       "(short)(random.Next(short.MinValue, short.MaxValue))", "(short)(random.Next(short.MinValue, short.MaxValue))",                                          "(left[i] & right[i]) == 0"}),
-    ("BooleanBinOpTest.template",    new string[] { "Sse41", "Sse2",  "TestZ",                         "Vector128",   "Int32",     "Vector128",   "Int32",     "Vector128",   "Int32",                                 "16",       "(int)(random.Next(int.MinValue, int.MaxValue))",       "(int)(random.Next(int.MinValue, int.MaxValue))",                                                "(left[i] & right[i]) == 0"}),
-    ("BooleanBinOpTest.template",    new string[] { "Sse41", "Sse2",  "TestZ",                         "Vector128",   "Int64",     "Vector128",   "Int64",     "Vector128",   "Int64",                                 "16",       "(long)(random.Next(int.MinValue, int.MaxValue))",      "(long)(random.Next(int.MinValue, int.MaxValue))",                                               "(left[i] & right[i]) == 0"}),
-    ("BooleanBinOpTest.template",    new string[] { "Sse41", "Sse2",  "TestZ",                         "Vector128",   "SByte",     "Vector128",   "SByte",     "Vector128",   "SByte",                                 "16",       "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))", "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",                                          "(left[i] & right[i]) == 0"}),
-    ("BooleanBinOpTest.template",    new string[] { "Sse41", "Sse2",  "TestZ",                         "Vector128",   "UInt16",    "Vector128",   "UInt16",    "Vector128",   "UInt16",                                "16",       "(ushort)(random.Next(0, ushort.MaxValue))",            "(ushort)(random.Next(0, ushort.MaxValue))",                                                     "(left[i] & right[i]) == 0"}),
-    ("BooleanBinOpTest.template",    new string[] { "Sse41", "Sse2",  "TestZ",                         "Vector128",   "UInt32",    "Vector128",   "UInt32",    "Vector128",   "UInt32",                                "16",       "(uint)(random.Next(0, int.MaxValue))",                 "(uint)(random.Next(0, int.MaxValue))",                                                          "(left[i] & right[i]) == 0"}),
-    ("BooleanBinOpTest.template",    new string[] { "Sse41", "Sse2",  "TestZ",                         "Vector128",   "UInt64",    "Vector128",   "UInt64",    "Vector128",   "UInt64",                                "16",       "(ulong)(random.Next(0, int.MaxValue))",                "(ulong)(random.Next(0, int.MaxValue))",                                                         "(left[i] & right[i]) == 0"}),
-    // IMM intrinsics
-    // TemplateName                              Isa,    LoadIsa,     Method,   RetVectorType, RetBaseType, Op1VectorType, Op1BaseType,    IMM,    Op2           VectorSize,          NextValueOp1,                                            ValidateResults
-    ("ExtractScalarTest.template",new string[] { "Sse41", "Sse2",    "Extract",   "Vector128",   "Byte",      "Vector128",   "Byte",      "1",                    "16",              "(byte)(random.Next(0, byte.MaxValue))",         "(result[0] != firstOp[1])"}),
-    ("ExtractScalarTest.template",new string[] { "Sse41", "Sse2",    "Extract",   "Vector128",   "SByte",     "Vector128",   "SByte",     "1",                    "16",              "(sbyte)(random.Next(0, sbyte.MaxValue))",       "(result[0] != firstOp[1])"}),
-    ("ExtractScalarTest.template",new string[] { "Sse41", "Sse2",    "Extract",   "Vector128",   "Int32",     "Vector128",   "Int32",     "1",                    "16",              "(int)(random.Next(0, int.MaxValue))",           "(result[0] != firstOp[1])"}),
-    ("ExtractScalarTest.template",new string[] { "Sse41", "Sse2",    "Extract",   "Vector128",   "UInt32",    "Vector128",   "UInt32",    "1",                    "16",              "(uint)(random.Next(0, int.MaxValue))",          "(result[0] != firstOp[1])"}),
-    ("ExtractScalarTest.template",new string[] { "Sse41", "Sse2",    "Extract",   "Vector128",   "Int64",     "Vector128",   "Int64",     "1",                    "16",              "(long)(random.Next(0, int.MaxValue))",          "(result[0] != firstOp[1])"}),
-    ("ExtractScalarTest.template",new string[] { "Sse41", "Sse2",    "Extract",   "Vector128",   "UInt64",    "Vector128",   "UInt64",    "1",                    "16",              "(ulong)(random.Next(0, int.MaxValue))",         "(result[0] != firstOp[1])"}),
-    ("ExtractScalarTest.template",new string[] { "Sse41", "Sse",     "Extract",   "Vector128",   "Single",    "Vector128",   "Single",    "1",                    "16",              "(float)(random.NextDouble())",                  "(BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(firstOp[1]))"}),
-    ("ExtractScalarTest.template",new string[] { "Sse41", "Sse2",    "Extract",   "Vector128",   "Byte",      "Vector128",   "Byte",      "129",                  "16",              "(byte)(random.Next(0, byte.MaxValue))",         "(result[0] != firstOp[1])"}),
-    ("ExtractScalarTest.template",new string[] { "Sse41", "Sse2",    "Extract",   "Vector128",   "SByte",     "Vector128",   "SByte",     "129",                  "16",              "(sbyte)(random.Next(0, sbyte.MaxValue))",       "(result[0] != firstOp[1])"}),
-    ("ExtractScalarTest.template",new string[] { "Sse41", "Sse2",    "Extract",   "Vector128",   "Int32",     "Vector128",   "Int32",     "129",                  "16",              "(int)(random.Next(0, int.MaxValue))",           "(result[0] != firstOp[1])"}),
-    ("ExtractScalarTest.template",new string[] { "Sse41", "Sse2",    "Extract",   "Vector128",   "UInt32",    "Vector128",   "UInt32",    "129",                  "16",              "(uint)(random.Next(0, int.MaxValue))",          "(result[0] != firstOp[1])"}),
-    ("ExtractScalarTest.template",new string[] { "Sse41", "Sse2",    "Extract",   "Vector128",   "Int64",     "Vector128",   "Int64",     "129",                  "16",              "(long)(random.Next(0, int.MaxValue))",          "(result[0] != firstOp[1])"}),
-    ("ExtractScalarTest.template",new string[] { "Sse41", "Sse2",    "Extract",   "Vector128",   "UInt64",    "Vector128",   "UInt64",    "129",                  "16",              "(ulong)(random.Next(0, int.MaxValue))",         "(result[0] != firstOp[1])"}),
-    ("ExtractScalarTest.template",new string[] { "Sse41", "Sse",     "Extract",   "Vector128",   "Single",    "Vector128",   "Single",    "129",                  "16",              "(float)(random.NextDouble())",                  "(BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(firstOp[1]))"}),
-    ("InsertScalarTest.template",new string[] { "Sse41", "Sse2",     "Insert",    "Vector128",   "Byte",      "Vector128",   "Byte",      "1",    "(byte)2",      "16",              "(byte)0",                                       "(i == 1 ? result[i] != 2 : result[i] != 0)"}),
-    ("InsertScalarTest.template",new string[] { "Sse41", "Sse2",     "Insert",    "Vector128",   "SByte",     "Vector128",   "SByte",     "1",    "(sbyte)2",     "16",              "(sbyte)0",                                      "(i == 1 ? result[i] != 2 : result[i] != 0)"}),
-    ("InsertScalarTest.template",new string[] { "Sse41", "Sse2",     "Insert",    "Vector128",   "Int32",     "Vector128",   "Int32",     "1",    "(int)2",       "16",              "(int)0",                                        "(i == 1 ? result[i] != 2 : result[i] != 0)"}),
-    ("InsertScalarTest.template",new string[] { "Sse41", "Sse2",     "Insert",    "Vector128",   "UInt32",    "Vector128",   "UInt32",    "1",    "(uint)2",      "16",              "(uint)0",                                       "(i == 1 ? result[i] != 2 : result[i] != 0)"}),
-    ("InsertScalarTest.template",new string[] { "Sse41", "Sse2",     "Insert",    "Vector128",   "Int64",     "Vector128",   "Int64",     "1",    "(long)2",      "16",              "(long)0",                                       "(i == 1 ? result[i] != 2 : result[i] != 0)"}),
-    ("InsertScalarTest.template",new string[] { "Sse41", "Sse2",     "Insert",    "Vector128",   "UInt64",    "Vector128",   "UInt64",    "1",    "(ulong)2",     "16",              "(ulong)0",                                      "(i == 1 ? result[i] != 2 : result[i] != 0)"}),
-    ("InsertScalarTest.template",new string[] { "Sse41", "Sse",      "Insert",    "Vector128",   "Single",    "Vector128",   "Single",    "0",    "(float)2",     "16",              "(float)0",                                      "(i == 0 ? BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits((float)2) : BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits((float)0))"}),
-    ("InsertScalarTest.template",new string[] { "Sse41", "Sse2",     "Insert",    "Vector128",   "Byte",      "Vector128",   "Byte",      "129",  "(byte)2",      "16",              "(byte)0",                                       "(i == 1 ? result[i] != 2 : result[i] != 0)"}),
-    ("InsertScalarTest.template",new string[] { "Sse41", "Sse2",     "Insert",    "Vector128",   "SByte",     "Vector128",   "SByte",     "129",  "(sbyte)2",     "16",              "(sbyte)0",                                      "(i == 1 ? result[i] != 2 : result[i] != 0)"}),
-    ("InsertScalarTest.template",new string[] { "Sse41", "Sse2",     "Insert",    "Vector128",   "Int32",     "Vector128",   "Int32",     "129",  "(int)2",       "16",              "(int)0",                                        "(i == 1 ? result[i] != 2 : result[i] != 0)"}),
-    ("InsertScalarTest.template",new string[] { "Sse41", "Sse2",     "Insert",    "Vector128",   "UInt32",    "Vector128",   "UInt32",    "129",  "(uint)2",      "16",              "(uint)0",                                       "(i == 1 ? result[i] != 2 : result[i] != 0)"}),
-    ("InsertScalarTest.template",new string[] { "Sse41", "Sse2",     "Insert",    "Vector128",   "Int64",     "Vector128",   "Int64",     "129",  "(long)2",      "16",              "(long)0",                                       "(i == 1 ? result[i] != 2 : result[i] != 0)"}),
-    ("InsertScalarTest.template",new string[] { "Sse41", "Sse2",     "Insert",    "Vector128",   "UInt64",    "Vector128",   "UInt64",    "129",  "(ulong)2",     "16",              "(ulong)0",                                      "(i == 1 ? result[i] != 2 : result[i] != 0)"}),
-    ("InsertScalarTest.template",new string[] { "Sse41", "Sse",      "Insert",    "Vector128",   "Single",    "Vector128",   "Single",    "217",  "(float)2",     "16",              "(float)(random.NextDouble())",                  "(i == 2 ? BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(firstOp[i]) : BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits((float)0))"}),
+    ("SimpleTernOpTest.template",    new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "BlendVariable",                 ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Byte",    ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Byte",   ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Byte",   ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "Byte",                                           ["VectorSize"] = "16", ["NextValueOp1"] = "(byte)(random.Next(0, byte.MaxValue))",                ["NextValueOp2"] = "(byte)(random.Next(0, byte.MaxValue))",                ["NextValueOp3"] = "(byte)(((i % 2) == 0) ? 128 : 1)",      ["ValidateFirstResult"] = "((thirdOp[0] >> 7) & 1) == 1 ? secondOp[0] != result[0] : firstOp[0] != result[0]",                                                                                                                                                                  ["ValidateRemainingResults"] = "((thirdOp[i] >> 7) & 1) == 1 ? secondOp[i] != result[i] : firstOp[i] != result[i]"}),
+    ("SimpleTernOpTest.template",    new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "BlendVariable",                 ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "Double",                                         ["VectorSize"] = "16", ["NextValueOp1"] = "(double)(random.NextDouble())",                        ["NextValueOp2"] = "(double)(random.NextDouble())",                        ["NextValueOp3"] = "(double)(((i % 2) == 0) ? -0.0 : 1.0)", ["ValidateFirstResult"] = "((BitConverter.DoubleToInt64Bits(thirdOp[0]) >> 63) & 1) == 1 ? BitConverter.DoubleToInt64Bits(secondOp[0]) != BitConverter.DoubleToInt64Bits(result[0]) : BitConverter.DoubleToInt64Bits(firstOp[0]) != BitConverter.DoubleToInt64Bits(result[0])", ["ValidateRemainingResults"] = "((BitConverter.DoubleToInt64Bits(thirdOp[i]) >> 63) & 1) == 1 ? BitConverter.DoubleToInt64Bits(secondOp[i]) != BitConverter.DoubleToInt64Bits(result[i]) : BitConverter.DoubleToInt64Bits(firstOp[i]) != BitConverter.DoubleToInt64Bits(result[i])"}),
+    ("SimpleTernOpTest.template",    new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "BlendVariable",                 ["RetVectorType"] = "Vector128", ["RetBaseType"] = "SByte",   ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "SByte",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "SByte",  ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "SByte",                                          ["VectorSize"] = "16", ["NextValueOp1"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))", ["NextValueOp2"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))", ["NextValueOp3"] = "(sbyte)(((i % 2) == 0) ? -128 : 1)",    ["ValidateFirstResult"] = "((thirdOp[0] >> 7) & 1) == 1 ? secondOp[0] != result[0] : firstOp[0] != result[0]",                                                                                                                                                                  ["ValidateRemainingResults"] = "((thirdOp[i] >> 7) & 1) == 1 ? secondOp[i] != result[i] : firstOp[i] != result[i]"}),
+    ("SimpleTernOpTest.template",    new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse",  ["Method"] = "BlendVariable",                 ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single", ["Op3VectorType"] = "Vector128", ["Op3BaseType"] = "Single",                                         ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())",                         ["NextValueOp2"] = "(float)(random.NextDouble())",                         ["NextValueOp3"] = "(float)(((i % 2) == 0) ? -0.0 : 1.0)",  ["ValidateFirstResult"] = "((BitConverter.SingleToInt32Bits(thirdOp[0]) >> 31) & 1) == 1 ? BitConverter.SingleToInt32Bits(secondOp[0]) != BitConverter.SingleToInt32Bits(result[0]) : BitConverter.SingleToInt32Bits(firstOp[0]) != BitConverter.SingleToInt32Bits(result[0])", ["ValidateRemainingResults"] = "((BitConverter.SingleToInt32Bits(thirdOp[i]) >> 31) & 1) == 1 ? BitConverter.SingleToInt32Bits(secondOp[i]) != BitConverter.SingleToInt32Bits(result[i]) : BitConverter.SingleToInt32Bits(firstOp[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
+    ("SimpleUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "Ceiling",                       ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Double",                                                                                                                                                                   ["VectorSize"] = "16", ["NextValueOp1"] = "(double)(random.NextDouble())",                                                                                                                                                               ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Ceiling(firstOp[0]))",                                                                                                                                              ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(Math.Ceiling(firstOp[i]))"}),
+    ("SimpleUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse",  ["Method"] = "Ceiling",                       ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Single",                                                                                                                                                                   ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())",                                                                                                                                                                ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Ceiling(firstOp[0]))",                                                                                                                                             ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(MathF.Ceiling(firstOp[i]))"}),
+    ("SimpleBinOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "CeilingScalar",                 ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double",                                                                                                      ["VectorSize"] = "16", ["NextValueOp1"] = "(double)(random.NextDouble())",                        ["NextValueOp2"] = "(double)(random.NextDouble())",                                                                                    ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Ceiling(right[0]))",                                                                                                                                                ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(left[i])"}),
+    ("SimpleBinOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse",  ["Method"] = "CeilingScalar",                 ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single",                                                                                                      ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())",                         ["NextValueOp2"] = "(float)(random.NextDouble())",                                                                                     ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Ceiling(right[0]))",                                                                                                                                               ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(left[i])"}),
+    ("SimpleBinOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "CompareEqual",                  ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int64",   ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Int64",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int64",                                                                                                       ["VectorSize"] = "16", ["NextValueOp1"] = "(long)(random.Next(int.MinValue, int.MaxValue))",      ["NextValueOp2"] = "(long)(random.Next(int.MinValue, int.MaxValue))",                                                                  ["ValidateFirstResult"] = "result[0] != ((left[0] == right[0]) ? unchecked((long)(-1)) : 0)",                                                                                                                                                                                   ["ValidateRemainingResults"] = "result[i] != ((left[i] == right[i]) ? unchecked((long)(-1)) : 0)"}),
+    ("SimpleBinOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "CompareEqual",                  ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt64",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt64",                                                                                                      ["VectorSize"] = "16", ["NextValueOp1"] = "(ulong)(random.Next(0, int.MaxValue))",                ["NextValueOp2"] = "(ulong)(random.Next(0, int.MaxValue))",                                                                            ["ValidateFirstResult"] = "result[0] != ((left[0] == right[0]) ? unchecked((ulong)(-1)) : 0)",                                                                                                                                                                                  ["ValidateRemainingResults"] = "result[i] != ((left[i] == right[i]) ? unchecked((ulong)(-1)) : 0)"}),
+    ("ExtractScalarTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "Extract",                       ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Byte",    ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Byte",                                                                                                                                                    ["Imm"] = "1",   ["VectorSize"] = "16", ["NextValueOp1"] = "(byte)(random.Next(0, byte.MaxValue))",                                                                                                                                                       ["ValidateFirstResult"] = "(result[0] != firstOp[1])"}),
+    ("ExtractScalarTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "Extract",                       ["RetVectorType"] = "Vector128", ["RetBaseType"] = "SByte",   ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "SByte",                                                                                                                                                   ["Imm"] = "1",   ["VectorSize"] = "16", ["NextValueOp1"] = "(sbyte)(random.Next(0, sbyte.MaxValue))",                                                                                                                                                     ["ValidateFirstResult"] = "(result[0] != firstOp[1])"}),
+    ("ExtractScalarTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "Extract",                       ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32",   ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Int32",                                                                                                                                                   ["Imm"] = "1",   ["VectorSize"] = "16", ["NextValueOp1"] = "(int)(random.Next(0, int.MaxValue))",                                                                                                                                                         ["ValidateFirstResult"] = "(result[0] != firstOp[1])"}),
+    ("ExtractScalarTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "Extract",                       ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "UInt32",                                                                                                                                                  ["Imm"] = "1",   ["VectorSize"] = "16", ["NextValueOp1"] = "(uint)(random.Next(0, int.MaxValue))",                                                                                                                                                        ["ValidateFirstResult"] = "(result[0] != firstOp[1])"}),
+    ("ExtractScalarTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "Extract",                       ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int64",   ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Int64",                                                                                                                                                   ["Imm"] = "1",   ["VectorSize"] = "16", ["NextValueOp1"] = "(long)(random.Next(0, int.MaxValue))",                                                                                                                                                        ["ValidateFirstResult"] = "(result[0] != firstOp[1])"}),
+    ("ExtractScalarTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "Extract",                       ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt64",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "UInt64",                                                                                                                                                  ["Imm"] = "1",   ["VectorSize"] = "16", ["NextValueOp1"] = "(ulong)(random.Next(0, int.MaxValue))",                                                                                                                                                       ["ValidateFirstResult"] = "(result[0] != firstOp[1])"}),
+    ("ExtractScalarTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse",  ["Method"] = "Extract",                       ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Single",                                                                                                                                                  ["Imm"] = "1",   ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())",                                                                                                                                                                ["ValidateFirstResult"] = "(BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(firstOp[1]))"}),
+    ("ExtractScalarTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "Extract",                       ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Byte",    ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Byte",                                                                                                                                                    ["Imm"] = "129", ["VectorSize"] = "16", ["NextValueOp1"] = "(byte)(random.Next(0, byte.MaxValue))",                                                                                                                                                       ["ValidateFirstResult"] = "(result[0] != firstOp[1])"}),
+    ("ExtractScalarTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "Extract",                       ["RetVectorType"] = "Vector128", ["RetBaseType"] = "SByte",   ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "SByte",                                                                                                                                                   ["Imm"] = "129", ["VectorSize"] = "16", ["NextValueOp1"] = "(sbyte)(random.Next(0, sbyte.MaxValue))",                                                                                                                                                     ["ValidateFirstResult"] = "(result[0] != firstOp[1])"}),
+    ("ExtractScalarTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "Extract",                       ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32",   ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Int32",                                                                                                                                                   ["Imm"] = "129", ["VectorSize"] = "16", ["NextValueOp1"] = "(int)(random.Next(0, int.MaxValue))",                                                                                                                                                         ["ValidateFirstResult"] = "(result[0] != firstOp[1])"}),
+    ("ExtractScalarTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "Extract",                       ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "UInt32",                                                                                                                                                  ["Imm"] = "129", ["VectorSize"] = "16", ["NextValueOp1"] = "(uint)(random.Next(0, int.MaxValue))",                                                                                                                                                        ["ValidateFirstResult"] = "(result[0] != firstOp[1])"}),
+    ("ExtractScalarTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "Extract",                       ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int64",   ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Int64",                                                                                                                                                   ["Imm"] = "129", ["VectorSize"] = "16", ["NextValueOp1"] = "(long)(random.Next(0, int.MaxValue))",                                                                                                                                                        ["ValidateFirstResult"] = "(result[0] != firstOp[1])"}),
+    ("ExtractScalarTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "Extract",                       ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt64",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "UInt64",                                                                                                                                                  ["Imm"] = "129", ["VectorSize"] = "16", ["NextValueOp1"] = "(ulong)(random.Next(0, int.MaxValue))",                                                                                                                                                       ["ValidateFirstResult"] = "(result[0] != firstOp[1])"}),
+    ("ExtractScalarTest.template",   new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse",  ["Method"] = "Extract",                       ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Single",                                                                                                                                                  ["Imm"] = "129", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())",                                                                                                                                                                ["ValidateFirstResult"] = "(BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(firstOp[1]))"}),
+    ("SimpleUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "Floor",                         ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Double",                                                                                                                                                                   ["VectorSize"] = "16", ["NextValueOp1"] = "(double)(random.NextDouble())",                                                                                                                                                               ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Floor(firstOp[0]))",                                                                                                                                                ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(Math.Floor(firstOp[i]))"}),
+    ("SimpleUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse",  ["Method"] = "Floor",                         ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Single",                                                                                                                                                                   ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())",                                                                                                                                                                ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Floor(firstOp[0]))",                                                                                                                                               ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(MathF.Floor(firstOp[i]))"}),
+    ("SimpleBinOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "FloorScalar",                   ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double",                                                                                                      ["VectorSize"] = "16", ["NextValueOp1"] = "(double)(random.NextDouble())",                        ["NextValueOp2"] = "(double)(random.NextDouble())",                                                                                    ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Floor(right[0]))",                                                                                                                                                  ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(left[i])"}),
+    ("SimpleBinOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse",  ["Method"] = "FloorScalar",                   ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single",                                                                                                      ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())",                         ["NextValueOp2"] = "(float)(random.NextDouble())",                                                                                     ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Floor(right[0]))",                                                                                                                                                 ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(left[i])"}),
+    ("InsertScalarTest.template",    new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "Insert",                        ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Byte",    ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Byte",                                                                                                                             ["Data"] = "(byte)2",  ["Imm"] = "1",   ["VectorSize"] = "16", ["NextValueOp1"] = "(byte)0",                                                                                                                                                                                     ["ValidateFirstResult"] = "(i == 1 ? result[i] != 2 : result[i] != 0)"}),
+    ("InsertScalarTest.template",    new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "Insert",                        ["RetVectorType"] = "Vector128", ["RetBaseType"] = "SByte",   ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "SByte",                                                                                                                            ["Data"] = "(sbyte)2", ["Imm"] = "1",   ["VectorSize"] = "16", ["NextValueOp1"] = "(sbyte)0",                                                                                                                                                                                    ["ValidateFirstResult"] = "(i == 1 ? result[i] != 2 : result[i] != 0)"}),
+    ("InsertScalarTest.template",    new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "Insert",                        ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32",   ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Int32",                                                                                                                            ["Data"] = "(int)2",   ["Imm"] = "1",   ["VectorSize"] = "16", ["NextValueOp1"] = "(int)0",                                                                                                                                                                                      ["ValidateFirstResult"] = "(i == 1 ? result[i] != 2 : result[i] != 0)"}),
+    ("InsertScalarTest.template",    new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "Insert",                        ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "UInt32",                                                                                                                           ["Data"] = "(uint)2",  ["Imm"] = "1",   ["VectorSize"] = "16", ["NextValueOp1"] = "(uint)0",                                                                                                                                                                                     ["ValidateFirstResult"] = "(i == 1 ? result[i] != 2 : result[i] != 0)"}),
+    ("InsertScalarTest.template",    new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "Insert",                        ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int64",   ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Int64",                                                                                                                            ["Data"] = "(long)2",  ["Imm"] = "1",   ["VectorSize"] = "16", ["NextValueOp1"] = "(long)0",                                                                                                                                                                                     ["ValidateFirstResult"] = "(i == 1 ? result[i] != 2 : result[i] != 0)"}),
+    ("InsertScalarTest.template",    new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "Insert",                        ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt64",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "UInt64",                                                                                                                           ["Data"] = "(ulong)2", ["Imm"] = "1",   ["VectorSize"] = "16", ["NextValueOp1"] = "(ulong)0",                                                                                                                                                                                    ["ValidateFirstResult"] = "(i == 1 ? result[i] != 2 : result[i] != 0)"}),
+    ("InsertScalarTest.template",    new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse",  ["Method"] = "Insert",                        ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Single",                                                                                                                           ["Data"] = "(float)2", ["Imm"] = "0",   ["VectorSize"] = "16", ["NextValueOp1"] = "(float)0",                                                                                                                                                                                    ["ValidateFirstResult"] = "(i == 0 ? BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits((float)2) : BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits((float)0))"}),
+    ("InsertScalarTest.template",    new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "Insert",                        ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Byte",    ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Byte",                                                                                                                             ["Data"] = "(byte)2",  ["Imm"] = "129", ["VectorSize"] = "16", ["NextValueOp1"] = "(byte)0",                                                                                                                                                                                     ["ValidateFirstResult"] = "(i == 1 ? result[i] != 2 : result[i] != 0)"}),
+    ("InsertScalarTest.template",    new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "Insert",                        ["RetVectorType"] = "Vector128", ["RetBaseType"] = "SByte",   ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "SByte",                                                                                                                            ["Data"] = "(sbyte)2", ["Imm"] = "129", ["VectorSize"] = "16", ["NextValueOp1"] = "(sbyte)0",                                                                                                                                                                                    ["ValidateFirstResult"] = "(i == 1 ? result[i] != 2 : result[i] != 0)"}),
+    ("InsertScalarTest.template",    new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "Insert",                        ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32",   ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Int32",                                                                                                                            ["Data"] = "(int)2",   ["Imm"] = "129", ["VectorSize"] = "16", ["NextValueOp1"] = "(int)0",                                                                                                                                                                                      ["ValidateFirstResult"] = "(i == 1 ? result[i] != 2 : result[i] != 0)"}),
+    ("InsertScalarTest.template",    new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "Insert",                        ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "UInt32",                                                                                                                           ["Data"] = "(uint)2",  ["Imm"] = "129", ["VectorSize"] = "16", ["NextValueOp1"] = "(uint)0",                                                                                                                                                                                     ["ValidateFirstResult"] = "(i == 1 ? result[i] != 2 : result[i] != 0)"}),
+    ("InsertScalarTest.template",    new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "Insert",                        ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int64",   ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Int64",                                                                                                                            ["Data"] = "(long)2",  ["Imm"] = "129", ["VectorSize"] = "16", ["NextValueOp1"] = "(long)0",                                                                                                                                                                                     ["ValidateFirstResult"] = "(i == 1 ? result[i] != 2 : result[i] != 0)"}),
+    ("InsertScalarTest.template",    new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "Insert",                        ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt64",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "UInt64",                                                                                                                           ["Data"] = "(ulong)2", ["Imm"] = "129", ["VectorSize"] = "16", ["NextValueOp1"] = "(ulong)0",                                                                                                                                                                                    ["ValidateFirstResult"] = "(i == 1 ? result[i] != 2 : result[i] != 0)"}),
+    ("InsertScalarTest.template",    new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse",  ["Method"] = "Insert",                        ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Single",                                                                                                                           ["Data"] = "(float)2", ["Imm"] = "217", ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())",                                                                                                                                                                ["ValidateFirstResult"] = "(i == 2 ? BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(firstOp[i]) : BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits((float)0))"}),
+    ("SimpleBinOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "Max",                           ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32",   ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Int32",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int32",                                                                                                       ["VectorSize"] = "16", ["NextValueOp1"] = "(int)(random.Next(int.MinValue, int.MaxValue))",       ["NextValueOp2"] = "(int)(random.Next(int.MinValue, int.MaxValue))",                                                                   ["ValidateFirstResult"] = "result[0] != Math.Max(left[0], right[0])",                                                                                                                                                                                                           ["ValidateRemainingResults"] = "result[i] != Math.Max(left[i], right[i])"}),
+    ("SimpleBinOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "Max",                           ["RetVectorType"] = "Vector128", ["RetBaseType"] = "SByte",   ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "SByte",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "SByte",                                                                                                       ["VectorSize"] = "16", ["NextValueOp1"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))", ["NextValueOp2"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",                                                             ["ValidateFirstResult"] = "result[0] != Math.Max(left[0], right[0])",                                                                                                                                                                                                           ["ValidateRemainingResults"] = "result[i] != Math.Max(left[i], right[i])"}),
+    ("SimpleBinOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "Max",                           ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt16",                                                                                                      ["VectorSize"] = "16", ["NextValueOp1"] = "(ushort)(random.Next(0, ushort.MaxValue))",            ["NextValueOp2"] = "(ushort)(random.Next(0, ushort.MaxValue))",                                                                        ["ValidateFirstResult"] = "result[0] != Math.Max(left[0], right[0])",                                                                                                                                                                                                           ["ValidateRemainingResults"] = "result[i] != Math.Max(left[i], right[i])"}),
+    ("SimpleBinOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "Max",                           ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt32",                                                                                                      ["VectorSize"] = "16", ["NextValueOp1"] = "(uint)(random.Next(0, int.MaxValue))",                 ["NextValueOp2"] = "(uint)(random.Next(0, int.MaxValue))",                                                                             ["ValidateFirstResult"] = "result[0] != Math.Max(left[0], right[0])",                                                                                                                                                                                                           ["ValidateRemainingResults"] = "result[i] != Math.Max(left[i], right[i])"}),
+    ("SimpleBinOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "Min",                           ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32",   ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Int32",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int32",                                                                                                       ["VectorSize"] = "16", ["NextValueOp1"] = "(int)(random.Next(int.MinValue, int.MaxValue))",       ["NextValueOp2"] = "(int)(random.Next(int.MinValue, int.MaxValue))",                                                                   ["ValidateFirstResult"] = "result[0] != Math.Min(left[0], right[0])",                                                                                                                                                                                                           ["ValidateRemainingResults"] = "result[i] != Math.Min(left[i], right[i])"}),
+    ("SimpleBinOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "Min",                           ["RetVectorType"] = "Vector128", ["RetBaseType"] = "SByte",   ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "SByte",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "SByte",                                                                                                       ["VectorSize"] = "16", ["NextValueOp1"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))", ["NextValueOp2"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",                                                             ["ValidateFirstResult"] = "result[0] != Math.Min(left[0], right[0])",                                                                                                                                                                                                           ["ValidateRemainingResults"] = "result[i] != Math.Min(left[i], right[i])"}),
+    ("SimpleBinOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "Min",                           ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt16",                                                                                                      ["VectorSize"] = "16", ["NextValueOp1"] = "(ushort)(random.Next(0, ushort.MaxValue))",            ["NextValueOp2"] = "(ushort)(random.Next(0, ushort.MaxValue))",                                                                        ["ValidateFirstResult"] = "result[0] != Math.Min(left[0], right[0])",                                                                                                                                                                                                           ["ValidateRemainingResults"] = "result[i] != Math.Min(left[i], right[i])"}),
+    ("SimpleBinOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "Min",                           ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt32",                                                                                                      ["VectorSize"] = "16", ["NextValueOp1"] = "(uint)(random.Next(0, int.MaxValue))",                 ["NextValueOp2"] = "(uint)(random.Next(0, int.MaxValue))",                                                                             ["ValidateFirstResult"] = "result[0] != Math.Min(left[0], right[0])",                                                                                                                                                                                                           ["ValidateRemainingResults"] = "result[i] != Math.Min(left[i], right[i])"}),
+    ("SimpleBinOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "MultiplyLow",                   ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32",   ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Int32",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int32",                                                                                                       ["VectorSize"] = "16", ["NextValueOp1"] = "(int)(random.Next(int.MinValue, int.MaxValue))",       ["NextValueOp2"] = "(int)(random.Next(int.MinValue, int.MaxValue))",                                                                   ["ValidateFirstResult"] = "result[0] != BitConverter.ToInt32(BitConverter.GetBytes(((long)(left[0])) * right[0]), 0)",                                                                                                                                                          ["ValidateRemainingResults"] = "result[i] != BitConverter.ToInt32(BitConverter.GetBytes(((long)(left[i])) * right[i]), 0)"}),
+    ("HorizontalBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "PackUnsignedSaturate",          ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Int32",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int32",                                                                                                       ["VectorSize"] = "16", ["NextValueOp1"] = "(int)(random.Next(int.MinValue, int.MaxValue))",       ["NextValueOp2"] = "(int)(random.Next(int.MinValue, int.MaxValue))",                                                                   ["ValidateFirstResult"] = "result[i1] != ((left[i3 - inner] > 0xFFFF) ? 0xFFFF : ((left[i3 - inner] < 0) ? 0 : BitConverter.ToUInt16(BitConverter.GetBytes(left[i3 - inner]), 0)))",                                                                                            ["ValidateRemainingResults"] = "result[i2] != ((right[i3 - inner] > 0xFFFF) ? 0xFFFF : ((right[i3 - inner] < 0) ? 0 : BitConverter.ToUInt16(BitConverter.GetBytes(right[i3 - inner]), 0)))"}),
+    ("SimpleUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "RoundCurrentDirection",         ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Double",                                                                                                                                                                   ["VectorSize"] = "16", ["NextValueOp1"] = "(double)(random.NextDouble())",                                                                                                                                                               ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Round(firstOp[0]))",                                                                                                                                                ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(Math.Round(firstOp[i]))"}),
+    ("SimpleUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse",  ["Method"] = "RoundCurrentDirection",         ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Single",                                                                                                                                                                   ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())",                                                                                                                                                                ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Round(firstOp[0]))",                                                                                                                                               ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(MathF.Round(firstOp[i]))"}),
+    ("SimpleBinOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "RoundCurrentDirectionScalar",   ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double",                                                                                                      ["VectorSize"] = "16", ["NextValueOp1"] = "(double)(random.NextDouble())",                        ["NextValueOp2"] = "(double)(random.NextDouble())",                                                                                    ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Round(right[0]))",                                                                                                                                                  ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(left[i])"}),
+    ("SimpleBinOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse",  ["Method"] = "RoundCurrentDirectionScalar",   ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single",                                                                                                      ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())",                         ["NextValueOp2"] = "(float)(random.NextDouble())",                                                                                     ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Round(right[0]))",                                                                                                                                                 ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(left[i])"}),
+    ("SimpleUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "RoundToNearestInteger",         ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Double",                                                                                                                                                                   ["VectorSize"] = "16", ["NextValueOp1"] = "(double)(random.NextDouble())",                                                                                                                                                               ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Round(firstOp[0], MidpointRounding.AwayFromZero))",                                                                                                                 ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(Math.Round(firstOp[i], MidpointRounding.AwayFromZero))"}),
+    ("SimpleUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse",  ["Method"] = "RoundToNearestInteger",         ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Single",                                                                                                                                                                   ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())",                                                                                                                                                                ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Round(firstOp[0], MidpointRounding.AwayFromZero))",                                                                                                                ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(MathF.Round(firstOp[i], MidpointRounding.AwayFromZero))"}),
+    ("SimpleBinOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "RoundToNearestIntegerScalar",   ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double",                                                                                                      ["VectorSize"] = "16", ["NextValueOp1"] = "(double)(random.NextDouble())",                        ["NextValueOp2"] = "(double)(random.NextDouble())",                                                                                    ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Round(right[0], MidpointRounding.AwayFromZero))",                                                                                                                   ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(left[i])"}),
+    ("SimpleBinOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse",  ["Method"] = "RoundToNearestIntegerScalar",   ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single",                                                                                                      ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())",                         ["NextValueOp2"] = "(float)(random.NextDouble())",                                                                                     ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Round(right[0], MidpointRounding.AwayFromZero))",                                                                                                                  ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(left[i])"}),
+    ("SimpleUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "RoundToNegativeInfinity",       ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Double",                                                                                                                                                                   ["VectorSize"] = "16", ["NextValueOp1"] = "(double)(random.NextDouble())",                                                                                                                                                               ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Floor(firstOp[0]))",                                                                                                                                                ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(Math.Floor(firstOp[i]))"}),
+    ("SimpleUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse",  ["Method"] = "RoundToNegativeInfinity",       ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Single",                                                                                                                                                                   ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())",                                                                                                                                                                ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Floor(firstOp[0]))",                                                                                                                                               ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(MathF.Floor(firstOp[i]))"}),
+    ("SimpleBinOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "RoundToNegativeInfinityScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double",                                                                                                      ["VectorSize"] = "16", ["NextValueOp1"] = "(double)(random.NextDouble())",                        ["NextValueOp2"] = "(double)(random.NextDouble())",                                                                                    ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Floor(right[0]))",                                                                                                                                                  ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(left[i])"}),
+    ("SimpleBinOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse",  ["Method"] = "RoundToNegativeInfinityScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single",                                                                                                      ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())",                         ["NextValueOp2"] = "(float)(random.NextDouble())",                                                                                     ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Floor(right[0]))",                                                                                                                                                 ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(left[i])"}),
+    ("SimpleUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "RoundToPositiveInfinity",       ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Double",                                                                                                                                                                   ["VectorSize"] = "16", ["NextValueOp1"] = "(double)(random.NextDouble())",                                                                                                                                                               ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Ceiling(firstOp[0]))",                                                                                                                                              ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(Math.Ceiling(firstOp[i]))"}),
+    ("SimpleUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse",  ["Method"] = "RoundToPositiveInfinity",       ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Single",                                                                                                                                                                   ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())",                                                                                                                                                                ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Ceiling(firstOp[0]))",                                                                                                                                             ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(MathF.Ceiling(firstOp[i]))"}),
+    ("SimpleBinOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "RoundToPositiveInfinityScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double",                                                                                                      ["VectorSize"] = "16", ["NextValueOp1"] = "(double)(random.NextDouble())",                        ["NextValueOp2"] = "(double)(random.NextDouble())",                                                                                    ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Ceiling(right[0]))",                                                                                                                                                ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(left[i])"}),
+    ("SimpleBinOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse",  ["Method"] = "RoundToPositiveInfinityScalar", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single",                                                                                                      ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())",                         ["NextValueOp2"] = "(float)(random.NextDouble())",                                                                                     ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Ceiling(right[0]))",                                                                                                                                               ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(left[i])"}),
+    ("SimpleUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "RoundToZero",                   ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Double",                                                                                                                                                                   ["VectorSize"] = "16", ["NextValueOp1"] = "(double)(random.NextDouble())",                                                                                                                                                               ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits((firstOp[0] > 0) ? Math.Floor(firstOp[0]) : Math.Ceiling(firstOp[0]))",                                                                                                  ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits((firstOp[i] > 0) ? Math.Floor(firstOp[i]) : Math.Ceiling(firstOp[i]))"}),
+    ("SimpleUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse",  ["Method"] = "RoundToZero",                   ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Single",                                                                                                                                                                   ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())",                                                                                                                                                                ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits((firstOp[0] > 0) ? MathF.Floor(firstOp[0]) : MathF.Ceiling(firstOp[0]))",                                                                                                ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits((firstOp[i] > 0) ? MathF.Floor(firstOp[i]) : MathF.Ceiling(firstOp[i]))"}),
+    ("SimpleBinOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "RoundToZeroScalar",             ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double",                                                                                                      ["VectorSize"] = "16", ["NextValueOp1"] = "(double)(random.NextDouble())",                        ["NextValueOp2"] = "(double)(random.NextDouble())",                                                                                    ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits((right[0] > 0) ? Math.Floor(right[0]) : Math.Ceiling(right[0]))",                                                                                                        ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(left[i])"}),
+    ("SimpleBinOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse",  ["Method"] = "RoundToZeroScalar",             ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Single",                                                                                                      ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())",                         ["NextValueOp2"] = "(float)(random.NextDouble())",                                                                                     ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits((right[0] > 0) ? MathF.Floor(right[0]) : MathF.Ceiling(right[0]))",                                                                                                      ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(left[i])"}),
+    ("BooleanUnOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "TestAllOnes",                   ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Byte",    ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Byte",                                                                                                                                                                     ["VectorSize"] = "16", ["NextValueOp1"] = "(byte)(random.Next(0, byte.MaxValue))",                                                                                                                                                       ["ValidateFirstResult"] = "(~value[i] & byte.MaxValue) == 0"}),
+    ("BooleanUnOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "TestAllOnes",                   ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16",   ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Int16",                                                                                                                                                                    ["VectorSize"] = "16", ["NextValueOp1"] = "(short)(random.Next(short.MinValue, short.MaxValue))",                                                                                                                                        ["ValidateFirstResult"] = "(~value[i] & -1) == 0"}),
+    ("BooleanUnOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "TestAllOnes",                   ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32",   ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Int32",                                                                                                                                                                    ["VectorSize"] = "16", ["NextValueOp1"] = "(int)(random.Next(int.MinValue, int.MaxValue))",                                                                                                                                              ["ValidateFirstResult"] = "(~value[i] & -1) == 0"}),
+    ("BooleanUnOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "TestAllOnes",                   ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int64",   ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Int64",                                                                                                                                                                    ["VectorSize"] = "16", ["NextValueOp1"] = "(long)(random.Next(int.MinValue, int.MaxValue))",                                                                                                                                             ["ValidateFirstResult"] = "(~value[i] & -1) == 0"}),
+    ("BooleanUnOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "TestAllOnes",                   ["RetVectorType"] = "Vector128", ["RetBaseType"] = "SByte",   ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "SByte",                                                                                                                                                                    ["VectorSize"] = "16", ["NextValueOp1"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",                                                                                                                                        ["ValidateFirstResult"] = "(~value[i] & -1) == 0"}),
+    ("BooleanUnOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "TestAllOnes",                   ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "UInt16",                                                                                                                                                                   ["VectorSize"] = "16", ["NextValueOp1"] = "(ushort)(random.Next(0, ushort.MaxValue))",                                                                                                                                                   ["ValidateFirstResult"] = "(~value[i] & ushort.MaxValue) == 0"}),
+    ("BooleanUnOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "TestAllOnes",                   ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "UInt32",                                                                                                                                                                   ["VectorSize"] = "16", ["NextValueOp1"] = "(uint)(random.Next(0, int.MaxValue))",                                                                                                                                                        ["ValidateFirstResult"] = "(~value[i] & uint.MaxValue) == 0"}),
+    ("BooleanUnOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "TestAllOnes",                   ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt64",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "UInt64",                                                                                                                                                                   ["VectorSize"] = "16", ["NextValueOp1"] = "(ulong)(random.Next(0, int.MaxValue))",                                                                                                                                                       ["ValidateFirstResult"] = "(~value[i] & ulong.MaxValue) == 0"}),
+    ("BooleanBinOpTest.template",    new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "TestAllZeros",                  ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Byte",    ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Byte",   ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Byte",                                                                                                        ["VectorSize"] = "16", ["NextValueOp1"] = "(byte)(random.Next(0, byte.MaxValue))",                ["NextValueOp2"] = "(byte)(random.Next(0, byte.MaxValue))",                                                                            ["ValidateFirstResult"] = "(left[i] & right[i]) == 0"}),
+    ("BooleanBinOpTest.template",    new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "TestAllZeros",                  ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16",   ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Int16",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int16",                                                                                                       ["VectorSize"] = "16", ["NextValueOp1"] = "(short)(random.Next(short.MinValue, short.MaxValue))", ["NextValueOp2"] = "(short)(random.Next(short.MinValue, short.MaxValue))",                                                             ["ValidateFirstResult"] = "(left[i] & right[i]) == 0"}),
+    ("BooleanBinOpTest.template",    new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "TestAllZeros",                  ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32",   ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Int32",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int32",                                                                                                       ["VectorSize"] = "16", ["NextValueOp1"] = "(int)(random.Next(int.MinValue, int.MaxValue))",       ["NextValueOp2"] = "(int)(random.Next(int.MinValue, int.MaxValue))",                                                                   ["ValidateFirstResult"] = "(left[i] & right[i]) == 0"}),
+    ("BooleanBinOpTest.template",    new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "TestAllZeros",                  ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int64",   ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Int64",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int64",                                                                                                       ["VectorSize"] = "16", ["NextValueOp1"] = "(long)(random.Next(int.MinValue, int.MaxValue))",      ["NextValueOp2"] = "(long)(random.Next(int.MinValue, int.MaxValue))",                                                                  ["ValidateFirstResult"] = "(left[i] & right[i]) == 0"}),
+    ("BooleanBinOpTest.template",    new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "TestAllZeros",                  ["RetVectorType"] = "Vector128", ["RetBaseType"] = "SByte",   ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "SByte",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "SByte",                                                                                                       ["VectorSize"] = "16", ["NextValueOp1"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))", ["NextValueOp2"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",                                                             ["ValidateFirstResult"] = "(left[i] & right[i]) == 0"}),
+    ("BooleanBinOpTest.template",    new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "TestAllZeros",                  ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt16",                                                                                                      ["VectorSize"] = "16", ["NextValueOp1"] = "(ushort)(random.Next(0, ushort.MaxValue))",            ["NextValueOp2"] = "(ushort)(random.Next(0, ushort.MaxValue))",                                                                        ["ValidateFirstResult"] = "(left[i] & right[i]) == 0"}),
+    ("BooleanBinOpTest.template",    new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "TestAllZeros",                  ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt32",                                                                                                      ["VectorSize"] = "16", ["NextValueOp1"] = "(uint)(random.Next(0, int.MaxValue))",                 ["NextValueOp2"] = "(uint)(random.Next(0, int.MaxValue))",                                                                             ["ValidateFirstResult"] = "(left[i] & right[i]) == 0"}),
+    ("BooleanBinOpTest.template",    new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "TestAllZeros",                  ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt64",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt64",                                                                                                      ["VectorSize"] = "16", ["NextValueOp1"] = "(ulong)(random.Next(0, int.MaxValue))",                ["NextValueOp2"] = "(ulong)(random.Next(0, int.MaxValue))",                                                                            ["ValidateFirstResult"] = "(left[i] & right[i]) == 0"}),
+    ("BooleanBinOpTest.template",    new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "TestC",                         ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Byte",    ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Byte",   ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Byte",                                                                                                        ["VectorSize"] = "16", ["NextValueOp1"] = "(byte)(random.Next(0, byte.MaxValue))",                ["NextValueOp2"] = "(byte)(random.Next(0, byte.MaxValue))",                                                                            ["ValidateFirstResult"] = "(~left[i] & right[i]) == 0"}),
+    ("BooleanBinOpTest.template",    new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "TestC",                         ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16",   ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Int16",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int16",                                                                                                       ["VectorSize"] = "16", ["NextValueOp1"] = "(short)(random.Next(short.MinValue, short.MaxValue))", ["NextValueOp2"] = "(short)(random.Next(short.MinValue, short.MaxValue))",                                                             ["ValidateFirstResult"] = "(~left[i] & right[i]) == 0"}),
+    ("BooleanBinOpTest.template",    new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "TestC",                         ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32",   ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Int32",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int32",                                                                                                       ["VectorSize"] = "16", ["NextValueOp1"] = "(int)(random.Next(int.MinValue, int.MaxValue))",       ["NextValueOp2"] = "(int)(random.Next(int.MinValue, int.MaxValue))",                                                                   ["ValidateFirstResult"] = "(~left[i] & right[i]) == 0"}),
+    ("BooleanBinOpTest.template",    new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "TestC",                         ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int64",   ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Int64",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int64",                                                                                                       ["VectorSize"] = "16", ["NextValueOp1"] = "(long)(random.Next(int.MinValue, int.MaxValue))",      ["NextValueOp2"] = "(long)(random.Next(int.MinValue, int.MaxValue))",                                                                  ["ValidateFirstResult"] = "(~left[i] & right[i]) == 0"}),
+    ("BooleanBinOpTest.template",    new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "TestC",                         ["RetVectorType"] = "Vector128", ["RetBaseType"] = "SByte",   ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "SByte",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "SByte",                                                                                                       ["VectorSize"] = "16", ["NextValueOp1"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))", ["NextValueOp2"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",                                                             ["ValidateFirstResult"] = "(~left[i] & right[i]) == 0"}),
+    ("BooleanBinOpTest.template",    new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "TestC",                         ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt16",                                                                                                      ["VectorSize"] = "16", ["NextValueOp1"] = "(ushort)(random.Next(0, ushort.MaxValue))",            ["NextValueOp2"] = "(ushort)(random.Next(0, ushort.MaxValue))",                                                                        ["ValidateFirstResult"] = "(~left[i] & right[i]) == 0"}),
+    ("BooleanBinOpTest.template",    new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "TestC",                         ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt32",                                                                                                      ["VectorSize"] = "16", ["NextValueOp1"] = "(uint)(random.Next(0, int.MaxValue))",                 ["NextValueOp2"] = "(uint)(random.Next(0, int.MaxValue))",                                                                             ["ValidateFirstResult"] = "(~left[i] & right[i]) == 0"}),
+    ("BooleanBinOpTest.template",    new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "TestC",                         ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt64",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt64",                                                                                                      ["VectorSize"] = "16", ["NextValueOp1"] = "(ulong)(random.Next(0, int.MaxValue))",                ["NextValueOp2"] = "(ulong)(random.Next(0, int.MaxValue))",                                                                            ["ValidateFirstResult"] = "(~left[i] & right[i]) == 0"}),
+    ("BooleanTwoCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "TestMixOnesZeros",              ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Byte",    ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Byte",   ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Byte",                                                                                                        ["VectorSize"] = "16", ["NextValueOp1"] = "(byte)(random.Next(0, byte.MaxValue))",                ["NextValueOp2"] = "(byte)(random.Next(0, byte.MaxValue))",                                                                            ["ValidateFirstResult"] = "((left[i] & right[i]) == 0)",                                                                                                                                                                                                                        ["ValidateRemainingResults"] = "((~left[i] & right[i]) == 0)"}),
+    ("BooleanTwoCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "TestMixOnesZeros",              ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16",   ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Int16",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int16",                                                                                                       ["VectorSize"] = "16", ["NextValueOp1"] = "(short)(random.Next(short.MinValue, short.MaxValue))", ["NextValueOp2"] = "(short)(random.Next(short.MinValue, short.MaxValue))",                                                             ["ValidateFirstResult"] = "((left[i] & right[i]) == 0)",                                                                                                                                                                                                                        ["ValidateRemainingResults"] = "((~left[i] & right[i]) == 0)"}),
+    ("BooleanTwoCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "TestMixOnesZeros",              ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32",   ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Int32",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int32",                                                                                                       ["VectorSize"] = "16", ["NextValueOp1"] = "(int)(random.Next(int.MinValue, int.MaxValue))",       ["NextValueOp2"] = "(int)(random.Next(int.MinValue, int.MaxValue))",                                                                   ["ValidateFirstResult"] = "((left[i] & right[i]) == 0)",                                                                                                                                                                                                                        ["ValidateRemainingResults"] = "((~left[i] & right[i]) == 0)"}),
+    ("BooleanTwoCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "TestMixOnesZeros",              ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int64",   ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Int64",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int64",                                                                                                       ["VectorSize"] = "16", ["NextValueOp1"] = "(long)(random.Next(int.MinValue, int.MaxValue))",      ["NextValueOp2"] = "(long)(random.Next(int.MinValue, int.MaxValue))",                                                                  ["ValidateFirstResult"] = "((left[i] & right[i]) == 0)",                                                                                                                                                                                                                        ["ValidateRemainingResults"] = "((~left[i] & right[i]) == 0)"}),
+    ("BooleanTwoCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "TestMixOnesZeros",              ["RetVectorType"] = "Vector128", ["RetBaseType"] = "SByte",   ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "SByte",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "SByte",                                                                                                       ["VectorSize"] = "16", ["NextValueOp1"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))", ["NextValueOp2"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",                                                             ["ValidateFirstResult"] = "((left[i] & right[i]) == 0)",                                                                                                                                                                                                                        ["ValidateRemainingResults"] = "((~left[i] & right[i]) == 0)"}),
+    ("BooleanTwoCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "TestMixOnesZeros",              ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt16",                                                                                                      ["VectorSize"] = "16", ["NextValueOp1"] = "(ushort)(random.Next(0, ushort.MaxValue))",            ["NextValueOp2"] = "(ushort)(random.Next(0, ushort.MaxValue))",                                                                        ["ValidateFirstResult"] = "((left[i] & right[i]) == 0)",                                                                                                                                                                                                                        ["ValidateRemainingResults"] = "((~left[i] & right[i]) == 0)"}),
+    ("BooleanTwoCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "TestMixOnesZeros",              ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt32",                                                                                                      ["VectorSize"] = "16", ["NextValueOp1"] = "(uint)(random.Next(0, int.MaxValue))",                 ["NextValueOp2"] = "(uint)(random.Next(0, int.MaxValue))",                                                                             ["ValidateFirstResult"] = "((left[i] & right[i]) == 0)",                                                                                                                                                                                                                        ["ValidateRemainingResults"] = "((~left[i] & right[i]) == 0)"}),
+    ("BooleanTwoCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "TestMixOnesZeros",              ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt64",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt64",                                                                                                      ["VectorSize"] = "16", ["NextValueOp1"] = "(ulong)(random.Next(0, int.MaxValue))",                ["NextValueOp2"] = "(ulong)(random.Next(0, int.MaxValue))",                                                                            ["ValidateFirstResult"] = "((left[i] & right[i]) == 0)",                                                                                                                                                                                                                        ["ValidateRemainingResults"] = "((~left[i] & right[i]) == 0)"}),
+    ("BooleanTwoCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "TestNotZAndNotC",               ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Byte",    ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Byte",   ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Byte",                                                                                                        ["VectorSize"] = "16", ["NextValueOp1"] = "(byte)(random.Next(0, byte.MaxValue))",                ["NextValueOp2"] = "(byte)(random.Next(0, byte.MaxValue))",                                                                            ["ValidateFirstResult"] = "((left[i] & right[i]) == 0)",                                                                                                                                                                                                                        ["ValidateRemainingResults"] = "((~left[i] & right[i]) == 0)"}),
+    ("BooleanTwoCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "TestNotZAndNotC",               ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16",   ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Int16",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int16",                                                                                                       ["VectorSize"] = "16", ["NextValueOp1"] = "(short)(random.Next(short.MinValue, short.MaxValue))", ["NextValueOp2"] = "(short)(random.Next(short.MinValue, short.MaxValue))",                                                             ["ValidateFirstResult"] = "((left[i] & right[i]) == 0)",                                                                                                                                                                                                                        ["ValidateRemainingResults"] = "((~left[i] & right[i]) == 0)"}),
+    ("BooleanTwoCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "TestNotZAndNotC",               ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32",   ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Int32",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int32",                                                                                                       ["VectorSize"] = "16", ["NextValueOp1"] = "(int)(random.Next(int.MinValue, int.MaxValue))",       ["NextValueOp2"] = "(int)(random.Next(int.MinValue, int.MaxValue))",                                                                   ["ValidateFirstResult"] = "((left[i] & right[i]) == 0)",                                                                                                                                                                                                                        ["ValidateRemainingResults"] = "((~left[i] & right[i]) == 0)"}),
+    ("BooleanTwoCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "TestNotZAndNotC",               ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int64",   ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Int64",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int64",                                                                                                       ["VectorSize"] = "16", ["NextValueOp1"] = "(long)(random.Next(int.MinValue, int.MaxValue))",      ["NextValueOp2"] = "(long)(random.Next(int.MinValue, int.MaxValue))",                                                                  ["ValidateFirstResult"] = "((left[i] & right[i]) == 0)",                                                                                                                                                                                                                        ["ValidateRemainingResults"] = "((~left[i] & right[i]) == 0)"}),
+    ("BooleanTwoCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "TestNotZAndNotC",               ["RetVectorType"] = "Vector128", ["RetBaseType"] = "SByte",   ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "SByte",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "SByte",                                                                                                       ["VectorSize"] = "16", ["NextValueOp1"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))", ["NextValueOp2"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",                                                             ["ValidateFirstResult"] = "((left[i] & right[i]) == 0)",                                                                                                                                                                                                                        ["ValidateRemainingResults"] = "((~left[i] & right[i]) == 0)"}),
+    ("BooleanTwoCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "TestNotZAndNotC",               ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt16",                                                                                                      ["VectorSize"] = "16", ["NextValueOp1"] = "(ushort)(random.Next(0, ushort.MaxValue))",            ["NextValueOp2"] = "(ushort)(random.Next(0, ushort.MaxValue))",                                                                        ["ValidateFirstResult"] = "((left[i] & right[i]) == 0)",                                                                                                                                                                                                                        ["ValidateRemainingResults"] = "((~left[i] & right[i]) == 0)"}),
+    ("BooleanTwoCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "TestNotZAndNotC",               ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt32",                                                                                                      ["VectorSize"] = "16", ["NextValueOp1"] = "(uint)(random.Next(0, int.MaxValue))",                 ["NextValueOp2"] = "(uint)(random.Next(0, int.MaxValue))",                                                                             ["ValidateFirstResult"] = "((left[i] & right[i]) == 0)",                                                                                                                                                                                                                        ["ValidateRemainingResults"] = "((~left[i] & right[i]) == 0)"}),
+    ("BooleanTwoCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "TestNotZAndNotC",               ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt64",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt64",                                                                                                      ["VectorSize"] = "16", ["NextValueOp1"] = "(ulong)(random.Next(0, int.MaxValue))",                ["NextValueOp2"] = "(ulong)(random.Next(0, int.MaxValue))",                                                                            ["ValidateFirstResult"] = "((left[i] & right[i]) == 0)",                                                                                                                                                                                                                        ["ValidateRemainingResults"] = "((~left[i] & right[i]) == 0)"}),
+    ("BooleanBinOpTest.template",    new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "TestZ",                         ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Byte",    ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Byte",   ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Byte",                                                                                                        ["VectorSize"] = "16", ["NextValueOp1"] = "(byte)(random.Next(0, byte.MaxValue))",                ["NextValueOp2"] = "(byte)(random.Next(0, byte.MaxValue))",                                                                            ["ValidateFirstResult"] = "(left[i] & right[i]) == 0"}),
+    ("BooleanBinOpTest.template",    new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "TestZ",                         ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16",   ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Int16",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int16",                                                                                                       ["VectorSize"] = "16", ["NextValueOp1"] = "(short)(random.Next(short.MinValue, short.MaxValue))", ["NextValueOp2"] = "(short)(random.Next(short.MinValue, short.MaxValue))",                                                             ["ValidateFirstResult"] = "(left[i] & right[i]) == 0"}),
+    ("BooleanBinOpTest.template",    new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "TestZ",                         ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32",   ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Int32",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int32",                                                                                                       ["VectorSize"] = "16", ["NextValueOp1"] = "(int)(random.Next(int.MinValue, int.MaxValue))",       ["NextValueOp2"] = "(int)(random.Next(int.MinValue, int.MaxValue))",                                                                   ["ValidateFirstResult"] = "(left[i] & right[i]) == 0"}),
+    ("BooleanBinOpTest.template",    new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "TestZ",                         ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int64",   ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "Int64",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int64",                                                                                                       ["VectorSize"] = "16", ["NextValueOp1"] = "(long)(random.Next(int.MinValue, int.MaxValue))",      ["NextValueOp2"] = "(long)(random.Next(int.MinValue, int.MaxValue))",                                                                  ["ValidateFirstResult"] = "(left[i] & right[i]) == 0"}),
+    ("BooleanBinOpTest.template",    new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "TestZ",                         ["RetVectorType"] = "Vector128", ["RetBaseType"] = "SByte",   ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "SByte",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "SByte",                                                                                                       ["VectorSize"] = "16", ["NextValueOp1"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))", ["NextValueOp2"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",                                                             ["ValidateFirstResult"] = "(left[i] & right[i]) == 0"}),
+    ("BooleanBinOpTest.template",    new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "TestZ",                         ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt16",                                                                                                      ["VectorSize"] = "16", ["NextValueOp1"] = "(ushort)(random.Next(0, ushort.MaxValue))",            ["NextValueOp2"] = "(ushort)(random.Next(0, ushort.MaxValue))",                                                                        ["ValidateFirstResult"] = "(left[i] & right[i]) == 0"}),
+    ("BooleanBinOpTest.template",    new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "TestZ",                         ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt32",                                                                                                      ["VectorSize"] = "16", ["NextValueOp1"] = "(uint)(random.Next(0, int.MaxValue))",                 ["NextValueOp2"] = "(uint)(random.Next(0, int.MaxValue))",                                                                             ["ValidateFirstResult"] = "(left[i] & right[i]) == 0"}),
+    ("BooleanBinOpTest.template",    new Dictionary<string, string> { ["Isa"] = "Sse41", ["LoadIsa"] = "Sse2", ["Method"] = "TestZ",                         ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt64",  ["Op1VectorType"] ="Vector128", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt64",                                                                                                      ["VectorSize"] = "16", ["NextValueOp1"] = "(ulong)(random.Next(0, int.MaxValue))",                ["NextValueOp2"] = "(ulong)(random.Next(0, int.MaxValue))",                                                                            ["ValidateFirstResult"] = "(left[i] & right[i]) == 0"}),
 };
 
-private static readonly (string templateFileName, string[] templateData)[] Sse42Inputs = new []
+private static readonly (string templateFileName, Dictionary<string, string> templateData)[] Sse42Inputs = new []
 {
-    // TemplateName                             Isa,     LoadIsa, Method,               RetVectorType, RetBaseType, Op1VectorType, Op1BaseType, Op2VectorType, Op2BaseType, Op3VectorType, Op3BaseType, VectorSize, NextValueOp1,                                      NextValueOp2,                                      NextValueOp3, ValidateFirstResult,                                               ValidateRemainingResults
-    ("SimpleBinOpTest.template", new string[] { "Sse42", "Sse2",  "CompareGreaterThan", "Vector128",   "Int64",     "Vector128",   "Int64",     "Vector128",   "Int64",                                 "16",       "(long)(random.Next(int.MinValue, int.MaxValue))", "(long)(random.Next(int.MinValue, int.MaxValue))",               "result[0] != ((left[0] > right[0]) ? unchecked((long)(-1)) : 0)", "result[i] != ((left[i] > right[i]) ? unchecked((long)(-1)) : 0)"}),
+    ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse42", ["LoadIsa"] = "Sse2", ["Method"] = "CompareGreaterThan", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int64", ["VectorSize"] = "16", ["NextValueOp1"] = "(long)(random.Next(int.MinValue, int.MaxValue))", ["NextValueOp2"] = "(long)(random.Next(int.MinValue, int.MaxValue))", ["ValidateFirstResult"] = "result[0] != ((left[0] > right[0]) ? unchecked((long)(-1)) : 0)", ["ValidateRemainingResults"] = "result[i] != ((left[i] > right[i]) ? unchecked((long)(-1)) : 0)"}),
 };
 
-private static readonly (string templateFileName, string[] templateData)[] AvxInputs = new []
+private static readonly (string templateFileName, Dictionary<string, string> templateData)[] AvxInputs = new []
 {                                                                                                                                                                                                                                                                                                                                          
-    // TemplateName                                 Isa,   LoadIsa, Method,                    RetVectorType, RetBaseType, Op1VectorType, Op1BaseType, Op2VectorType, Op2BaseType, Op3VectorType, Op3BaseType, VectorSize, NextValueOp1,                                           NextValueOp2,                    NextValueOp3,                            ValidateFirstResult,                                                                                                                                                                                                                                  ValidateRemainingResults
-    ("SimpleBinOpTest.template",     new string[] { "Avx", "Avx",   "Add",                     "Vector256",   "Double",    "Vector256",   "Double",    "Vector256",   "Double",                                "32",       "(double)(random.NextDouble())",                        "(double)(random.NextDouble())",                                          "BitConverter.DoubleToInt64Bits(left[0] + right[0]) != BitConverter.DoubleToInt64Bits(result[0])",                                                                                                                                                    "BitConverter.DoubleToInt64Bits(left[i] + right[i]) != BitConverter.DoubleToInt64Bits(result[i])"}),
-    ("SimpleBinOpTest.template",     new string[] { "Avx", "Avx",   "Add",                     "Vector256",   "Single",    "Vector256",   "Single",    "Vector256",   "Single",                                "32",       "(float)(random.NextDouble())",                         "(float)(random.NextDouble())",                                           "BitConverter.SingleToInt32Bits(left[0] + right[0]) != BitConverter.SingleToInt32Bits(result[0])",                                                                                                                                                    "BitConverter.SingleToInt32Bits(left[i] + right[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
-    ("SimpleBinOpTest.template",     new string[] { "Avx", "Avx",   "AddSubtract",             "Vector256",   "Double",    "Vector256",   "Double",    "Vector256",   "Double",                                "32",       "(double)(random.NextDouble())",                        "(double)(random.NextDouble())",                                          "BitConverter.DoubleToInt64Bits(left[0] - right[0]) != BitConverter.DoubleToInt64Bits(result[0])",                                                                                                                                                    "((i % 2 != 0) && (BitConverter.DoubleToInt64Bits(left[i] + right[i]) != BitConverter.DoubleToInt64Bits(result[i]))) || ((i % 2 == 0) && (BitConverter.DoubleToInt64Bits(left[i] - right[i]) != BitConverter.DoubleToInt64Bits(result[i])))"}),
-    ("SimpleBinOpTest.template",     new string[] { "Avx", "Avx",   "AddSubtract",             "Vector256",   "Single",    "Vector256",   "Single",    "Vector256",   "Single",                                "32",       "(float)(random.NextDouble())",                         "(float)(random.NextDouble())",                                           "BitConverter.SingleToInt32Bits(left[0] - right[0]) != BitConverter.SingleToInt32Bits(result[0])",                                                                                                                                                    "((i % 2 != 0) && (BitConverter.SingleToInt32Bits(left[i] + right[i]) != BitConverter.SingleToInt32Bits(result[i]))) || ((i % 2 == 0) && (BitConverter.SingleToInt32Bits(left[i] - right[i]) != BitConverter.SingleToInt32Bits(result[i])))"}),    
-    ("SimpleBinOpTest.template",     new string[] { "Avx", "Avx",   "And",                     "Vector256",   "Double",    "Vector256",   "Double",    "Vector256",   "Double",                                "32",       "(double)(random.NextDouble())",                        "(double)(random.NextDouble())",                                          "(BitConverter.DoubleToInt64Bits(left[0]) & BitConverter.DoubleToInt64Bits(right[0])) != BitConverter.DoubleToInt64Bits(result[0])",                                                                                                                  "(BitConverter.DoubleToInt64Bits(left[i]) & BitConverter.DoubleToInt64Bits(right[i])) != BitConverter.DoubleToInt64Bits(result[i])"}),
-    ("SimpleBinOpTest.template",     new string[] { "Avx", "Avx",   "And",                     "Vector256",   "Single",    "Vector256",   "Single",    "Vector256",   "Single",                                "32",       "(float)(random.NextDouble())",                         "(float)(random.NextDouble())",                                           "(BitConverter.SingleToInt32Bits(left[0]) & BitConverter.SingleToInt32Bits(right[0])) != BitConverter.SingleToInt32Bits(result[0])",                                                                                                                  "(BitConverter.SingleToInt32Bits(left[i]) & BitConverter.SingleToInt32Bits(right[i])) != BitConverter.SingleToInt32Bits(result[i])"}),
-    ("SimpleBinOpTest.template",     new string[] { "Avx", "Avx",   "AndNot",                  "Vector256",   "Double",    "Vector256",   "Double",    "Vector256",   "Double",                                "32",       "(double)(random.NextDouble())",                        "(double)(random.NextDouble())",                                          "((~BitConverter.DoubleToInt64Bits(left[0])) & BitConverter.DoubleToInt64Bits(right[0])) != BitConverter.DoubleToInt64Bits(result[0])",                                                                                                               "((~BitConverter.DoubleToInt64Bits(left[i])) & BitConverter.DoubleToInt64Bits(right[i])) != BitConverter.DoubleToInt64Bits(result[i])"}),
-    ("SimpleBinOpTest.template",     new string[] { "Avx", "Avx",   "AndNot",                  "Vector256",   "Single",    "Vector256",   "Single",    "Vector256",   "Single",                                "32",       "(float)(random.NextDouble())",                         "(float)(random.NextDouble())",                                           "((~BitConverter.SingleToInt32Bits(left[0])) & BitConverter.SingleToInt32Bits(right[0])) != BitConverter.SingleToInt32Bits(result[0])",                                                                                                               "((~BitConverter.SingleToInt32Bits(left[i])) & BitConverter.SingleToInt32Bits(right[i])) != BitConverter.SingleToInt32Bits(result[i])"}),
-    ("SimpleTernOpTest.template",    new string[] { "Avx", "Avx",   "BlendVariable",           "Vector256",   "Double",    "Vector256",   "Double",    "Vector256",   "Double",    "Vector256",   "Double",    "32",       "(double)(random.NextDouble())",                        "(double)(random.NextDouble())", "(double)(((i % 2) == 0) ? -0.0 : 1.0)", "((BitConverter.DoubleToInt64Bits(thirdOp[0]) >> 63) & 1) == 1 ? BitConverter.DoubleToInt64Bits(secondOp[0]) != BitConverter.DoubleToInt64Bits(result[0]) : BitConverter.DoubleToInt64Bits(firstOp[0]) != BitConverter.DoubleToInt64Bits(result[0])", "((BitConverter.DoubleToInt64Bits(thirdOp[i]) >> 63) & 1) == 1 ? BitConverter.DoubleToInt64Bits(secondOp[i]) != BitConverter.DoubleToInt64Bits(result[i]) : BitConverter.DoubleToInt64Bits(firstOp[i]) != BitConverter.DoubleToInt64Bits(result[i])"}),
-    ("SimpleTernOpTest.template",    new string[] { "Avx", "Avx",   "BlendVariable",           "Vector256",   "Single",    "Vector256",   "Single",    "Vector256",   "Single",    "Vector256",   "Single",    "32",       "(float)(random.NextDouble())",                         "(float)(random.NextDouble())",  "(float)(((i % 2) == 0) ? -0.0 : 1.0)",  "((BitConverter.SingleToInt32Bits(thirdOp[0]) >> 31) & 1) == 1 ? BitConverter.SingleToInt32Bits(secondOp[0]) != BitConverter.SingleToInt32Bits(result[0]) : BitConverter.SingleToInt32Bits(firstOp[0]) != BitConverter.SingleToInt32Bits(result[0])", "((BitConverter.SingleToInt32Bits(thirdOp[i]) >> 31) & 1) == 1 ? BitConverter.SingleToInt32Bits(secondOp[i]) != BitConverter.SingleToInt32Bits(result[i]) : BitConverter.SingleToInt32Bits(firstOp[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
-    ("SimpleUnOpTest.template",      new string[] { "Avx", "Avx",   "Ceiling",                 "Vector256",   "Double",    "Vector256",   "Double",                                                            "32",       "(double)(random.NextDouble())",                                                                                                  "BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Ceiling(firstOp[0]))",                                                                                                                                              "BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(Math.Ceiling(firstOp[i]))"}),
-    ("SimpleUnOpTest.template",      new string[] { "Avx", "Avx",   "Ceiling",                 "Vector256",   "Single",    "Vector256",   "Single",                                                            "32",       "(float)(random.NextDouble())",                                                                                                   "BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Ceiling(firstOp[0]))",                                                                                                                                             "BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(MathF.Ceiling(firstOp[i]))"}),
-    ("SimpleBinOpTest.template",     new string[] { "Avx", "Avx",   "Divide",                  "Vector256",   "Double",    "Vector256",   "Double",    "Vector256",   "Double",                                "32",       "(double)(random.NextDouble())",                        "(double)(random.NextDouble())",                                          "BitConverter.DoubleToInt64Bits(left[0] / right[0]) != BitConverter.DoubleToInt64Bits(result[0])",                                                                                                                                                    "BitConverter.DoubleToInt64Bits(left[i] / right[i]) != BitConverter.DoubleToInt64Bits(result[i])"}),
-    ("SimpleBinOpTest.template",     new string[] { "Avx", "Avx",   "Divide",                  "Vector256",   "Single",    "Vector256",   "Single",    "Vector256",   "Single",                                "32",       "(float)(random.NextDouble())",                         "(float)(random.NextDouble())",                                           "BitConverter.SingleToInt32Bits(left[0] / right[0]) != BitConverter.SingleToInt32Bits(result[0])",                                                                                                                                                    "BitConverter.SingleToInt32Bits(left[i] / right[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
-    ("SimpleUnOpTest.template",      new string[] { "Avx", "Avx",   "DuplicateEvenIndexed",    "Vector256",   "Double",    "Vector256",   "Double",                                                            "32",       "(double)(random.NextDouble())",                                                                                                  "BitConverter.DoubleToInt64Bits(firstOp[0]) != BitConverter.DoubleToInt64Bits(result[0])",                                                                                                                                                            "(i % 2 == 0) ? (BitConverter.DoubleToInt64Bits(firstOp[i]) != BitConverter.DoubleToInt64Bits(result[i])) : (BitConverter.DoubleToInt64Bits(firstOp[i - 1]) != BitConverter.DoubleToInt64Bits(result[i]))"}),
-    ("SimpleUnOpTest.template",      new string[] { "Avx", "Avx",   "DuplicateEvenIndexed",    "Vector256",   "Single",    "Vector256",   "Single",                                                            "32",       "(float)(random.NextDouble())",                                                                                                   "BitConverter.SingleToInt32Bits(firstOp[0]) != BitConverter.SingleToInt32Bits(result[0])",                                                                                                                                                            "(i % 2 == 0) ? (BitConverter.SingleToInt32Bits(firstOp[i]) != BitConverter.SingleToInt32Bits(result[i])) : (BitConverter.SingleToInt32Bits(firstOp[i - 1]) != BitConverter.SingleToInt32Bits(result[i]))"}),
-    ("SimpleUnOpTest.template",      new string[] { "Avx", "Avx",   "DuplicateOddIndexed",     "Vector256",   "Single",    "Vector256",   "Single",                                                            "32",       "(float)(random.NextDouble())",                                                                                                   "BitConverter.SingleToInt32Bits(firstOp[1]) != BitConverter.SingleToInt32Bits(result[0])",                                                                                                                                                            "(i % 2 == 0) ? (BitConverter.SingleToInt32Bits(firstOp[i + 1]) != BitConverter.SingleToInt32Bits(result[i])) : (BitConverter.SingleToInt32Bits(firstOp[i]) != BitConverter.SingleToInt32Bits(result[i]))"}),
-    ("SimpleUnOpTest.template",      new string[] { "Avx", "Avx",   "Floor",                   "Vector256",   "Double",    "Vector256",   "Double",                                                            "32",       "(double)(random.NextDouble())",                                                                                                  "BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Floor(firstOp[0]))",                                                                                                                                                "BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(Math.Floor(firstOp[i]))"}),
-    ("SimpleUnOpTest.template",      new string[] { "Avx", "Avx",   "Floor",                   "Vector256",   "Single",    "Vector256",   "Single",                                                            "32",       "(float)(random.NextDouble())",                                                                                                   "BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Floor(firstOp[0]))",                                                                                                                                               "BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(MathF.Floor(firstOp[i]))"}),
-    ("SimpleBinOpTest.template",     new string[] { "Avx", "Avx",   "Max",                     "Vector256",   "Double",    "Vector256",   "Double",    "Vector256",   "Double",                                "32",       "(double)(random.NextDouble())",                        "(double)(random.NextDouble())",                                          "BitConverter.DoubleToInt64Bits(Math.Max(left[0], right[0])) != BitConverter.DoubleToInt64Bits(result[0])",                                                                                                                                           "BitConverter.DoubleToInt64Bits(Math.Max(left[i], right[i])) != BitConverter.DoubleToInt64Bits(result[i])"}),
-    ("SimpleBinOpTest.template",     new string[] { "Avx", "Avx",   "Max",                     "Vector256",   "Single",    "Vector256",   "Single",    "Vector256",   "Single",                                "32",       "(float)(random.NextDouble())",                         "(float)(random.NextDouble())",                                           "BitConverter.SingleToInt32Bits(MathF.Max(left[0], right[0])) != BitConverter.SingleToInt32Bits(result[0])",                                                                                                                                          "BitConverter.SingleToInt32Bits(MathF.Max(left[i], right[i])) != BitConverter.SingleToInt32Bits(result[i])"}),
-    ("SimpleBinOpTest.template",     new string[] { "Avx", "Avx",   "Min",                     "Vector256",   "Double",    "Vector256",   "Double",    "Vector256",   "Double",                                "32",       "(double)(random.NextDouble())",                        "(double)(random.NextDouble())",                                          "BitConverter.DoubleToInt64Bits(Math.Min(left[0], right[0])) != BitConverter.DoubleToInt64Bits(result[0])",                                                                                                                                           "BitConverter.DoubleToInt64Bits(Math.Min(left[i], right[i])) != BitConverter.DoubleToInt64Bits(result[i])"}),
-    ("SimpleBinOpTest.template",     new string[] { "Avx", "Avx",   "Min",                     "Vector256",   "Single",    "Vector256",   "Single",    "Vector256",   "Single",                                "32",       "(float)(random.NextDouble())",                         "(float)(random.NextDouble())",                                           "BitConverter.SingleToInt32Bits(MathF.Min(left[0], right[0])) != BitConverter.SingleToInt32Bits(result[0])",                                                                                                                                          "BitConverter.SingleToInt32Bits(MathF.Min(left[i], right[i])) != BitConverter.SingleToInt32Bits(result[i])"}),
-    ("SimpleBinOpTest.template",     new string[] { "Avx", "Avx",   "Multiply",                "Vector256",   "Double",    "Vector256",   "Double",    "Vector256",   "Double",                                "32",       "(double)(random.NextDouble())",                        "(double)(random.NextDouble())",                                          "BitConverter.DoubleToInt64Bits(left[0] * right[0]) != BitConverter.DoubleToInt64Bits(result[0])",                                                                                                                                                    "BitConverter.DoubleToInt64Bits(left[i] * right[i]) != BitConverter.DoubleToInt64Bits(result[i])"}),
-    ("SimpleBinOpTest.template",     new string[] { "Avx", "Avx",   "Multiply",                "Vector256",   "Single",    "Vector256",   "Single",    "Vector256",   "Single",                                "32",       "(float)(random.NextDouble())",                         "(float)(random.NextDouble())",                                           "BitConverter.SingleToInt32Bits(left[0] * right[0]) != BitConverter.SingleToInt32Bits(result[0])",                                                                                                                                                    "BitConverter.SingleToInt32Bits(left[i] * right[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
-    ("SimpleBinOpTest.template",     new string[] { "Avx", "Avx",   "Or",                      "Vector256",   "Double",    "Vector256",   "Double",    "Vector256",   "Double",                                "32",       "(double)(random.NextDouble())",                        "(double)(random.NextDouble())",                                          "(BitConverter.DoubleToInt64Bits(left[0]) | BitConverter.DoubleToInt64Bits(right[0])) != BitConverter.DoubleToInt64Bits(result[0])",                                                                                                                  "(BitConverter.DoubleToInt64Bits(left[i]) | BitConverter.DoubleToInt64Bits(right[i])) != BitConverter.DoubleToInt64Bits(result[i])"}),
-    ("SimpleBinOpTest.template",     new string[] { "Avx", "Avx",   "Or",                      "Vector256",   "Single",    "Vector256",   "Single",    "Vector256",   "Single",                                "32",       "(float)(random.NextDouble())",                         "(float)(random.NextDouble())",                                           "(BitConverter.SingleToInt32Bits(left[0]) | BitConverter.SingleToInt32Bits(right[0])) != BitConverter.SingleToInt32Bits(result[0])",                                                                                                                  "(BitConverter.SingleToInt32Bits(left[i]) | BitConverter.SingleToInt32Bits(right[i])) != BitConverter.SingleToInt32Bits(result[i])"}),
-    ("SimpleUnOpTest.template",      new string[] { "Avx", "Avx",   "RoundCurrentDirection",   "Vector256",   "Double",    "Vector256",   "Double",                                                            "32",       "(double)(random.NextDouble())",                                                                                                  "BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Round(firstOp[0]))",                                                                                                                                                "BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(Math.Round(firstOp[i]))"}),
-    ("SimpleUnOpTest.template",      new string[] { "Avx", "Avx",   "RoundCurrentDirection",   "Vector256",   "Single",    "Vector256",   "Single",                                                            "32",       "(float)(random.NextDouble())",                                                                                                   "BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Round(firstOp[0]))",                                                                                                                                               "BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(MathF.Round(firstOp[i]))"}),
-    ("SimpleUnOpTest.template",      new string[] { "Avx", "Avx",   "RoundToNearestInteger",   "Vector256",   "Double",    "Vector256",   "Double",                                                            "32",       "(double)(random.NextDouble())",                                                                                                  "BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Round(firstOp[0], MidpointRounding.AwayFromZero))",                                                                                                                 "BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(Math.Round(firstOp[i], MidpointRounding.AwayFromZero))"}),
-    ("SimpleUnOpTest.template",      new string[] { "Avx", "Avx",   "RoundToNearestInteger",   "Vector256",   "Single",    "Vector256",   "Single",                                                            "32",       "(float)(random.NextDouble())",                                                                                                   "BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Round(firstOp[0], MidpointRounding.AwayFromZero))",                                                                                                                "BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(MathF.Round(firstOp[i], MidpointRounding.AwayFromZero))"}),
-    ("SimpleUnOpTest.template",      new string[] { "Avx", "Avx",   "RoundToNegativeInfinity", "Vector256",   "Double",    "Vector256",   "Double",                                                            "32",       "(double)(random.NextDouble())",                                                                                                  "BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Floor(firstOp[0]))",                                                                                                                                                "BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(Math.Floor(firstOp[i]))"}),
-    ("SimpleUnOpTest.template",      new string[] { "Avx", "Avx",   "RoundToNegativeInfinity", "Vector256",   "Single",    "Vector256",   "Single",                                                            "32",       "(float)(random.NextDouble())",                                                                                                   "BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Floor(firstOp[0]))",                                                                                                                                               "BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(MathF.Floor(firstOp[i]))"}),
-    ("SimpleUnOpTest.template",      new string[] { "Avx", "Avx",   "RoundToPositiveInfinity", "Vector256",   "Double",    "Vector256",   "Double",                                                            "32",       "(double)(random.NextDouble())",                                                                                                  "BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Ceiling(firstOp[0]))",                                                                                                                                              "BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(Math.Ceiling(firstOp[i]))"}),
-    ("SimpleUnOpTest.template",      new string[] { "Avx", "Avx",   "RoundToPositiveInfinity", "Vector256",   "Single",    "Vector256",   "Single",                                                            "32",       "(float)(random.NextDouble())",                                                                                                   "BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Ceiling(firstOp[0]))",                                                                                                                                             "BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(MathF.Ceiling(firstOp[i]))"}),
-    ("SimpleUnOpTest.template",      new string[] { "Avx", "Avx",   "RoundToZero",             "Vector256",   "Double",    "Vector256",   "Double",                                                            "32",       "(double)(random.NextDouble())",                                                                                                  "BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits((firstOp[0] > 0) ? Math.Floor(firstOp[0]) : Math.Ceiling(firstOp[0]))",                                                                                                  "BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits((firstOp[i] > 0) ? Math.Floor(firstOp[i]) : Math.Ceiling(firstOp[i]))"}),
-    ("SimpleUnOpTest.template",      new string[] { "Avx", "Avx",   "RoundToZero",             "Vector256",   "Single",    "Vector256",   "Single",                                                            "32",       "(float)(random.NextDouble())",                                                                                                   "BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits((firstOp[0] > 0) ? MathF.Floor(firstOp[0]) : MathF.Ceiling(firstOp[0]))",                                                                                                "BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits((firstOp[i] > 0) ? MathF.Floor(firstOp[i]) : MathF.Ceiling(firstOp[i]))"}),
-    ("SimpleBinOpTest.template",     new string[] { "Avx", "Avx",   "Subtract",                "Vector256",   "Double",    "Vector256",   "Double",    "Vector256",   "Double",                                "32",       "(double)(random.NextDouble())",                        "(double)(random.NextDouble())",                                          "BitConverter.DoubleToInt64Bits(left[0] - right[0]) != BitConverter.DoubleToInt64Bits(result[0])",                                                                                                                                                    "BitConverter.DoubleToInt64Bits(left[i] - right[i]) != BitConverter.DoubleToInt64Bits(result[i])"}),
-    ("SimpleBinOpTest.template",     new string[] { "Avx", "Avx",   "Subtract",                "Vector256",   "Single",    "Vector256",   "Single",    "Vector256",   "Single",                                "32",       "(float)(random.NextDouble())",                         "(float)(random.NextDouble())",                                           "BitConverter.SingleToInt32Bits(left[0] - right[0]) != BitConverter.SingleToInt32Bits(result[0])",                                                                                                                                                    "BitConverter.SingleToInt32Bits(left[i] - right[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
-    ("BooleanBinOpTest.template",    new string[] { "Avx", "Avx",   "TestC",                   "Vector256",   "Byte",      "Vector256",   "Byte",      "Vector256",   "Byte",                                  "32",       "(byte)(random.Next(0, byte.MaxValue))",                "(byte)(random.Next(0, byte.MaxValue))",                                  "(~left[i] & right[i]) == 0"}),
-    ("BooleanBinOpTest.template",    new string[] { "Avx", "Avx",   "TestC",                   "Vector256",   "Int16",     "Vector256",   "Int16",     "Vector256",   "Int16",                                 "32",       "(short)(random.Next(short.MinValue, short.MaxValue))", "(short)(random.Next(short.MinValue, short.MaxValue))",                   "(~left[i] & right[i]) == 0"}),
-    ("BooleanBinOpTest.template",    new string[] { "Avx", "Avx",   "TestC",                   "Vector256",   "Int32",     "Vector256",   "Int32",     "Vector256",   "Int32",                                 "32",       "(int)(random.Next(int.MinValue, int.MaxValue))",       "(int)(random.Next(int.MinValue, int.MaxValue))",                         "(~left[i] & right[i]) == 0"}),
-    ("BooleanBinOpTest.template",    new string[] { "Avx", "Avx",   "TestC",                   "Vector256",   "Int64",     "Vector256",   "Int64",     "Vector256",   "Int64",                                 "32",       "(long)(random.Next(int.MinValue, int.MaxValue))",      "(long)(random.Next(int.MinValue, int.MaxValue))",                        "(~left[i] & right[i]) == 0"}),
-    ("BooleanBinOpTest.template",    new string[] { "Avx", "Avx",   "TestC",                   "Vector256",   "SByte",     "Vector256",   "SByte",     "Vector256",   "SByte",                                 "32",       "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))", "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",                   "(~left[i] & right[i]) == 0"}),
-    ("BooleanBinOpTest.template",    new string[] { "Avx", "Avx",   "TestC",                   "Vector256",   "UInt16",    "Vector256",   "UInt16",    "Vector256",   "UInt16",                                "32",       "(ushort)(random.Next(0, ushort.MaxValue))",            "(ushort)(random.Next(0, ushort.MaxValue))",                              "(~left[i] & right[i]) == 0"}),
-    ("BooleanBinOpTest.template",    new string[] { "Avx", "Avx",   "TestC",                   "Vector256",   "UInt32",    "Vector256",   "UInt32",    "Vector256",   "UInt32",                                "32",       "(uint)(random.Next(0, int.MaxValue))",                 "(uint)(random.Next(0, int.MaxValue))",                                   "(~left[i] & right[i]) == 0"}),
-    ("BooleanBinOpTest.template",    new string[] { "Avx", "Avx",   "TestC",                   "Vector256",   "UInt64",    "Vector256",   "UInt64",    "Vector256",   "UInt64",                                "32",       "(ulong)(random.Next(0, int.MaxValue))",                "(ulong)(random.Next(0, int.MaxValue))",                                  "(~left[i] & right[i]) == 0"}),
-    ("BooleanTwoCmpOpTest.template", new string[] { "Avx", "Avx",   "TestNotZAndNotC",         "Vector256",   "Byte",      "Vector256",   "Byte",      "Vector256",   "Byte",                                  "32",       "(byte)(random.Next(0, byte.MaxValue))",                "(byte)(random.Next(0, byte.MaxValue))",                                  "((left[i] & right[i]) == 0)",                                                                                                                                                                                                                        "((~left[i] & right[i]) == 0)"}),
-    ("BooleanTwoCmpOpTest.template", new string[] { "Avx", "Avx",   "TestNotZAndNotC",         "Vector256",   "Int16",     "Vector256",   "Int16",     "Vector256",   "Int16",                                 "32",       "(short)(random.Next(short.MinValue, short.MaxValue))", "(short)(random.Next(short.MinValue, short.MaxValue))",                   "((left[i] & right[i]) == 0)",                                                                                                                                                                                                                        "((~left[i] & right[i]) == 0)"}),
-    ("BooleanTwoCmpOpTest.template", new string[] { "Avx", "Avx",   "TestNotZAndNotC",         "Vector256",   "Int32",     "Vector256",   "Int32",     "Vector256",   "Int32",                                 "32",       "(int)(random.Next(int.MinValue, int.MaxValue))",       "(int)(random.Next(int.MinValue, int.MaxValue))",                         "((left[i] & right[i]) == 0)",                                                                                                                                                                                                                        "((~left[i] & right[i]) == 0)"}),
-    ("BooleanTwoCmpOpTest.template", new string[] { "Avx", "Avx",   "TestNotZAndNotC",         "Vector256",   "Int64",     "Vector256",   "Int64",     "Vector256",   "Int64",                                 "32",       "(long)(random.Next(int.MinValue, int.MaxValue))",      "(long)(random.Next(int.MinValue, int.MaxValue))",                        "((left[i] & right[i]) == 0)",                                                                                                                                                                                                                        "((~left[i] & right[i]) == 0)"}),
-    ("BooleanTwoCmpOpTest.template", new string[] { "Avx", "Avx",   "TestNotZAndNotC",         "Vector256",   "SByte",     "Vector256",   "SByte",     "Vector256",   "SByte",                                 "32",       "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))", "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",                   "((left[i] & right[i]) == 0)",                                                                                                                                                                                                                        "((~left[i] & right[i]) == 0)"}),
-    ("BooleanTwoCmpOpTest.template", new string[] { "Avx", "Avx",   "TestNotZAndNotC",         "Vector256",   "UInt16",    "Vector256",   "UInt16",    "Vector256",   "UInt16",                                "32",       "(ushort)(random.Next(0, ushort.MaxValue))",            "(ushort)(random.Next(0, ushort.MaxValue))",                              "((left[i] & right[i]) == 0)",                                                                                                                                                                                                                        "((~left[i] & right[i]) == 0)"}),
-    ("BooleanTwoCmpOpTest.template", new string[] { "Avx", "Avx",   "TestNotZAndNotC",         "Vector256",   "UInt32",    "Vector256",   "UInt32",    "Vector256",   "UInt32",                                "32",       "(uint)(random.Next(0, int.MaxValue))",                 "(uint)(random.Next(0, int.MaxValue))",                                   "((left[i] & right[i]) == 0)",                                                                                                                                                                                                                        "((~left[i] & right[i]) == 0)"}),
-    ("BooleanTwoCmpOpTest.template", new string[] { "Avx", "Avx",   "TestNotZAndNotC",         "Vector256",   "UInt64",    "Vector256",   "UInt64",    "Vector256",   "UInt64",                                "32",       "(ulong)(random.Next(0, int.MaxValue))",                "(ulong)(random.Next(0, int.MaxValue))",                                  "((left[i] & right[i]) == 0)",                                                                                                                                                                                                                        "((~left[i] & right[i]) == 0)"}),
-    ("BooleanBinOpTest.template",    new string[] { "Avx", "Avx",   "TestZ",                   "Vector256",   "Byte",      "Vector256",   "Byte",      "Vector256",   "Byte",                                  "32",       "(byte)(random.Next(0, byte.MaxValue))",                "(byte)(random.Next(0, byte.MaxValue))",                                  "(left[i] & right[i]) == 0"}),
-    ("BooleanBinOpTest.template",    new string[] { "Avx", "Avx",   "TestZ",                   "Vector256",   "Int16",     "Vector256",   "Int16",     "Vector256",   "Int16",                                 "32",       "(short)(random.Next(short.MinValue, short.MaxValue))", "(short)(random.Next(short.MinValue, short.MaxValue))",                   "(left[i] & right[i]) == 0"}),
-    ("BooleanBinOpTest.template",    new string[] { "Avx", "Avx",   "TestZ",                   "Vector256",   "Int32",     "Vector256",   "Int32",     "Vector256",   "Int32",                                 "32",       "(int)(random.Next(int.MinValue, int.MaxValue))",       "(int)(random.Next(int.MinValue, int.MaxValue))",                         "(left[i] & right[i]) == 0"}),
-    ("BooleanBinOpTest.template",    new string[] { "Avx", "Avx",   "TestZ",                   "Vector256",   "Int64",     "Vector256",   "Int64",     "Vector256",   "Int64",                                 "32",       "(long)(random.Next(int.MinValue, int.MaxValue))",      "(long)(random.Next(int.MinValue, int.MaxValue))",                        "(left[i] & right[i]) == 0"}),
-    ("BooleanBinOpTest.template",    new string[] { "Avx", "Avx",   "TestZ",                   "Vector256",   "SByte",     "Vector256",   "SByte",     "Vector256",   "SByte",                                 "32",       "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))", "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",                   "(left[i] & right[i]) == 0"}),
-    ("BooleanBinOpTest.template",    new string[] { "Avx", "Avx",   "TestZ",                   "Vector256",   "UInt16",    "Vector256",   "UInt16",    "Vector256",   "UInt16",                                "32",       "(ushort)(random.Next(0, ushort.MaxValue))",            "(ushort)(random.Next(0, ushort.MaxValue))",                              "(left[i] & right[i]) == 0"}),
-    ("BooleanBinOpTest.template",    new string[] { "Avx", "Avx",   "TestZ",                   "Vector256",   "UInt32",    "Vector256",   "UInt32",    "Vector256",   "UInt32",                                "32",       "(uint)(random.Next(0, int.MaxValue))",                 "(uint)(random.Next(0, int.MaxValue))",                                   "(left[i] & right[i]) == 0"}),
-    ("BooleanBinOpTest.template",    new string[] { "Avx", "Avx",   "TestZ",                   "Vector256",   "UInt64",    "Vector256",   "UInt64",    "Vector256",   "UInt64",                                "32",       "(ulong)(random.Next(0, int.MaxValue))",                "(ulong)(random.Next(0, int.MaxValue))",                                  "(left[i] & right[i]) == 0"}),
-    ("SimpleBinOpTest.template",     new string[] { "Avx", "Avx",   "Xor",                     "Vector256",   "Double",    "Vector256",   "Double",    "Vector256",   "Double",                                "32",       "(double)(random.NextDouble())",                        "(double)(random.NextDouble())",                                          "(BitConverter.DoubleToInt64Bits(left[0]) ^ BitConverter.DoubleToInt64Bits(right[0])) != BitConverter.DoubleToInt64Bits(result[0])",                                                                                                                  "(BitConverter.DoubleToInt64Bits(left[i]) ^ BitConverter.DoubleToInt64Bits(right[i])) != BitConverter.DoubleToInt64Bits(result[i])"}),
-    ("SimpleBinOpTest.template",     new string[] { "Avx", "Avx",   "Xor",                     "Vector256",   "Single",    "Vector256",   "Single",    "Vector256",   "Single",                                "32",       "(float)(random.NextDouble())",                         "(float)(random.NextDouble())",                                           "(BitConverter.SingleToInt32Bits(left[0]) ^ BitConverter.SingleToInt32Bits(right[0])) != BitConverter.SingleToInt32Bits(result[0])",                                                                                                                  "(BitConverter.SingleToInt32Bits(left[i]) ^ BitConverter.SingleToInt32Bits(right[i])) != BitConverter.SingleToInt32Bits(result[i])"}),
+    ("SimpleBinOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "Add",                     ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Double",                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(double)(random.NextDouble())",                        ["NextValueOp2"] = "(double)(random.NextDouble())",                                                             ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(left[0] + right[0]) != BitConverter.DoubleToInt64Bits(result[0])",                                                                                                                                                    ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(left[i] + right[i]) != BitConverter.DoubleToInt64Bits(result[i])"}),
+    ("SimpleBinOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "Add",                     ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Single",                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(float)(random.NextDouble())",                         ["NextValueOp2"] = "(float)(random.NextDouble())",                                                              ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(left[0] + right[0]) != BitConverter.SingleToInt32Bits(result[0])",                                                                                                                                                    ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i] + right[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
+    ("SimpleBinOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "AddSubtract",             ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Double",                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(double)(random.NextDouble())",                        ["NextValueOp2"] = "(double)(random.NextDouble())",                                                             ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(left[0] - right[0]) != BitConverter.DoubleToInt64Bits(result[0])",                                                                                                                                                    ["ValidateRemainingResults"] = "((i % 2 != 0) && (BitConverter.DoubleToInt64Bits(left[i] + right[i]) != BitConverter.DoubleToInt64Bits(result[i]))) || ((i % 2 == 0) && (BitConverter.DoubleToInt64Bits(left[i] - right[i]) != BitConverter.DoubleToInt64Bits(result[i])))"}),
+    ("SimpleBinOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "AddSubtract",             ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Single",                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(float)(random.NextDouble())",                         ["NextValueOp2"] = "(float)(random.NextDouble())",                                                              ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(left[0] - right[0]) != BitConverter.SingleToInt32Bits(result[0])",                                                                                                                                                    ["ValidateRemainingResults"] = "((i % 2 != 0) && (BitConverter.SingleToInt32Bits(left[i] + right[i]) != BitConverter.SingleToInt32Bits(result[i]))) || ((i % 2 == 0) && (BitConverter.SingleToInt32Bits(left[i] - right[i]) != BitConverter.SingleToInt32Bits(result[i])))"}),    
+    ("SimpleBinOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "And",                     ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Double",                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(double)(random.NextDouble())",                        ["NextValueOp2"] = "(double)(random.NextDouble())",                                                             ["ValidateFirstResult"] = "(BitConverter.DoubleToInt64Bits(left[0]) & BitConverter.DoubleToInt64Bits(right[0])) != BitConverter.DoubleToInt64Bits(result[0])",                                                                                                                  ["ValidateRemainingResults"] = "(BitConverter.DoubleToInt64Bits(left[i]) & BitConverter.DoubleToInt64Bits(right[i])) != BitConverter.DoubleToInt64Bits(result[i])"}),
+    ("SimpleBinOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "And",                     ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Single",                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(float)(random.NextDouble())",                         ["NextValueOp2"] = "(float)(random.NextDouble())",                                                              ["ValidateFirstResult"] = "(BitConverter.SingleToInt32Bits(left[0]) & BitConverter.SingleToInt32Bits(right[0])) != BitConverter.SingleToInt32Bits(result[0])",                                                                                                                  ["ValidateRemainingResults"] = "(BitConverter.SingleToInt32Bits(left[i]) & BitConverter.SingleToInt32Bits(right[i])) != BitConverter.SingleToInt32Bits(result[i])"}),
+    ("SimpleBinOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "AndNot",                  ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Double",                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(double)(random.NextDouble())",                        ["NextValueOp2"] = "(double)(random.NextDouble())",                                                             ["ValidateFirstResult"] = "((~BitConverter.DoubleToInt64Bits(left[0])) & BitConverter.DoubleToInt64Bits(right[0])) != BitConverter.DoubleToInt64Bits(result[0])",                                                                                                               ["ValidateRemainingResults"] = "((~BitConverter.DoubleToInt64Bits(left[i])) & BitConverter.DoubleToInt64Bits(right[i])) != BitConverter.DoubleToInt64Bits(result[i])"}),
+    ("SimpleBinOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "AndNot",                  ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Single",                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(float)(random.NextDouble())",                         ["NextValueOp2"] = "(float)(random.NextDouble())",                                                              ["ValidateFirstResult"] = "((~BitConverter.SingleToInt32Bits(left[0])) & BitConverter.SingleToInt32Bits(right[0])) != BitConverter.SingleToInt32Bits(result[0])",                                                                                                               ["ValidateRemainingResults"] = "((~BitConverter.SingleToInt32Bits(left[i])) & BitConverter.SingleToInt32Bits(right[i])) != BitConverter.SingleToInt32Bits(result[i])"}),
+    ("SimpleTernOpTest.template",    new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "BlendVariable",           ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Double", ["Op3VectorType"] = "Vector256", ["Op3BaseType"] = "Double", ["VectorSize"] = "32", ["NextValueOp1"] = "(double)(random.NextDouble())",                        ["NextValueOp2"] = "(double)(random.NextDouble())", ["NextValueOp3"] = "(double)(((i % 2) == 0) ? -0.0 : 1.0)", ["ValidateFirstResult"] = "((BitConverter.DoubleToInt64Bits(thirdOp[0]) >> 63) & 1) == 1 ? BitConverter.DoubleToInt64Bits(secondOp[0]) != BitConverter.DoubleToInt64Bits(result[0]) : BitConverter.DoubleToInt64Bits(firstOp[0]) != BitConverter.DoubleToInt64Bits(result[0])", ["ValidateRemainingResults"] = "((BitConverter.DoubleToInt64Bits(thirdOp[i]) >> 63) & 1) == 1 ? BitConverter.DoubleToInt64Bits(secondOp[i]) != BitConverter.DoubleToInt64Bits(result[i]) : BitConverter.DoubleToInt64Bits(firstOp[i]) != BitConverter.DoubleToInt64Bits(result[i])"}),
+    ("SimpleTernOpTest.template",    new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "BlendVariable",           ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Single", ["Op3VectorType"] = "Vector256", ["Op3BaseType"] = "Single", ["VectorSize"] = "32", ["NextValueOp1"] = "(float)(random.NextDouble())",                         ["NextValueOp2"] = "(float)(random.NextDouble())",  ["NextValueOp3"] = "(float)(((i % 2) == 0) ? -0.0 : 1.0)",  ["ValidateFirstResult"] = "((BitConverter.SingleToInt32Bits(thirdOp[0]) >> 31) & 1) == 1 ? BitConverter.SingleToInt32Bits(secondOp[0]) != BitConverter.SingleToInt32Bits(result[0]) : BitConverter.SingleToInt32Bits(firstOp[0]) != BitConverter.SingleToInt32Bits(result[0])", ["ValidateRemainingResults"] = "((BitConverter.SingleToInt32Bits(thirdOp[i]) >> 31) & 1) == 1 ? BitConverter.SingleToInt32Bits(secondOp[i]) != BitConverter.SingleToInt32Bits(result[i]) : BitConverter.SingleToInt32Bits(firstOp[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
+    ("SimpleUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "Ceiling",                 ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Double",                                                                                                                           ["VectorSize"] = "32", ["NextValueOp1"] = "(double)(random.NextDouble())",                                                                                                                                        ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Ceiling(firstOp[0]))",                                                                                                                                              ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(Math.Ceiling(firstOp[i]))"}),
+    ("SimpleUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "Ceiling",                 ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Single",                                                                                                                           ["VectorSize"] = "32", ["NextValueOp1"] = "(float)(random.NextDouble())",                                                                                                                                         ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Ceiling(firstOp[0]))",                                                                                                                                             ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(MathF.Ceiling(firstOp[i]))"}),
+    ("SimpleBinOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "Divide",                  ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Double",                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(double)(random.NextDouble())",                        ["NextValueOp2"] = "(double)(random.NextDouble())",                                                             ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(left[0] / right[0]) != BitConverter.DoubleToInt64Bits(result[0])",                                                                                                                                                    ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(left[i] / right[i]) != BitConverter.DoubleToInt64Bits(result[i])"}),
+    ("SimpleBinOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "Divide",                  ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Single",                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(float)(random.NextDouble())",                         ["NextValueOp2"] = "(float)(random.NextDouble())",                                                              ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(left[0] / right[0]) != BitConverter.SingleToInt32Bits(result[0])",                                                                                                                                                    ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i] / right[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
+    ("SimpleUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "DuplicateEvenIndexed",    ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Double",                                                                                                                           ["VectorSize"] = "32", ["NextValueOp1"] = "(double)(random.NextDouble())",                                                                                                                                        ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(firstOp[0]) != BitConverter.DoubleToInt64Bits(result[0])",                                                                                                                                                            ["ValidateRemainingResults"] = "(i % 2 == 0) ? (BitConverter.DoubleToInt64Bits(firstOp[i]) != BitConverter.DoubleToInt64Bits(result[i])) : (BitConverter.DoubleToInt64Bits(firstOp[i - 1]) != BitConverter.DoubleToInt64Bits(result[i]))"}),
+    ("SimpleUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "DuplicateEvenIndexed",    ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Single",                                                                                                                           ["VectorSize"] = "32", ["NextValueOp1"] = "(float)(random.NextDouble())",                                                                                                                                         ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(firstOp[0]) != BitConverter.SingleToInt32Bits(result[0])",                                                                                                                                                            ["ValidateRemainingResults"] = "(i % 2 == 0) ? (BitConverter.SingleToInt32Bits(firstOp[i]) != BitConverter.SingleToInt32Bits(result[i])) : (BitConverter.SingleToInt32Bits(firstOp[i - 1]) != BitConverter.SingleToInt32Bits(result[i]))"}),
+    ("SimpleUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "DuplicateOddIndexed",     ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Single",                                                                                                                           ["VectorSize"] = "32", ["NextValueOp1"] = "(float)(random.NextDouble())",                                                                                                                                         ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(firstOp[1]) != BitConverter.SingleToInt32Bits(result[0])",                                                                                                                                                            ["ValidateRemainingResults"] = "(i % 2 == 0) ? (BitConverter.SingleToInt32Bits(firstOp[i + 1]) != BitConverter.SingleToInt32Bits(result[i])) : (BitConverter.SingleToInt32Bits(firstOp[i]) != BitConverter.SingleToInt32Bits(result[i]))"}),
+    ("SimpleUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "Floor",                   ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Double",                                                                                                                           ["VectorSize"] = "32", ["NextValueOp1"] = "(double)(random.NextDouble())",                                                                                                                                        ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Floor(firstOp[0]))",                                                                                                                                                ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(Math.Floor(firstOp[i]))"}),
+    ("SimpleUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "Floor",                   ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Single",                                                                                                                           ["VectorSize"] = "32", ["NextValueOp1"] = "(float)(random.NextDouble())",                                                                                                                                         ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Floor(firstOp[0]))",                                                                                                                                               ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(MathF.Floor(firstOp[i]))"}),
+    ("SimpleBinOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "Max",                     ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Double",                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(double)(random.NextDouble())",                        ["NextValueOp2"] = "(double)(random.NextDouble())",                                                             ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(Math.Max(left[0], right[0])) != BitConverter.DoubleToInt64Bits(result[0])",                                                                                                                                           ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(Math.Max(left[i], right[i])) != BitConverter.DoubleToInt64Bits(result[i])"}),
+    ("SimpleBinOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "Max",                     ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Single",                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(float)(random.NextDouble())",                         ["NextValueOp2"] = "(float)(random.NextDouble())",                                                              ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(MathF.Max(left[0], right[0])) != BitConverter.SingleToInt32Bits(result[0])",                                                                                                                                          ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(MathF.Max(left[i], right[i])) != BitConverter.SingleToInt32Bits(result[i])"}),
+    ("SimpleBinOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "Min",                     ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Double",                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(double)(random.NextDouble())",                        ["NextValueOp2"] = "(double)(random.NextDouble())",                                                             ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(Math.Min(left[0], right[0])) != BitConverter.DoubleToInt64Bits(result[0])",                                                                                                                                           ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(Math.Min(left[i], right[i])) != BitConverter.DoubleToInt64Bits(result[i])"}),
+    ("SimpleBinOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "Min",                     ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Single",                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(float)(random.NextDouble())",                         ["NextValueOp2"] = "(float)(random.NextDouble())",                                                              ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(MathF.Min(left[0], right[0])) != BitConverter.SingleToInt32Bits(result[0])",                                                                                                                                          ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(MathF.Min(left[i], right[i])) != BitConverter.SingleToInt32Bits(result[i])"}),
+    ("SimpleBinOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "Multiply",                ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Double",                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(double)(random.NextDouble())",                        ["NextValueOp2"] = "(double)(random.NextDouble())",                                                             ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(left[0] * right[0]) != BitConverter.DoubleToInt64Bits(result[0])",                                                                                                                                                    ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(left[i] * right[i]) != BitConverter.DoubleToInt64Bits(result[i])"}),
+    ("SimpleBinOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "Multiply",                ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Single",                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(float)(random.NextDouble())",                         ["NextValueOp2"] = "(float)(random.NextDouble())",                                                              ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(left[0] * right[0]) != BitConverter.SingleToInt32Bits(result[0])",                                                                                                                                                    ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i] * right[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
+    ("SimpleBinOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "Or",                      ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Double",                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(double)(random.NextDouble())",                        ["NextValueOp2"] = "(double)(random.NextDouble())",                                                             ["ValidateFirstResult"] = "(BitConverter.DoubleToInt64Bits(left[0]) | BitConverter.DoubleToInt64Bits(right[0])) != BitConverter.DoubleToInt64Bits(result[0])",                                                                                                                  ["ValidateRemainingResults"] = "(BitConverter.DoubleToInt64Bits(left[i]) | BitConverter.DoubleToInt64Bits(right[i])) != BitConverter.DoubleToInt64Bits(result[i])"}),
+    ("SimpleBinOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "Or",                      ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Single",                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(float)(random.NextDouble())",                         ["NextValueOp2"] = "(float)(random.NextDouble())",                                                              ["ValidateFirstResult"] = "(BitConverter.SingleToInt32Bits(left[0]) | BitConverter.SingleToInt32Bits(right[0])) != BitConverter.SingleToInt32Bits(result[0])",                                                                                                                  ["ValidateRemainingResults"] = "(BitConverter.SingleToInt32Bits(left[i]) | BitConverter.SingleToInt32Bits(right[i])) != BitConverter.SingleToInt32Bits(result[i])"}),
+    ("SimpleUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "RoundCurrentDirection",   ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Double",                                                                                                                           ["VectorSize"] = "32", ["NextValueOp1"] = "(double)(random.NextDouble())",                                                                                                                                        ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Round(firstOp[0]))",                                                                                                                                                ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(Math.Round(firstOp[i]))"}),
+    ("SimpleUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "RoundCurrentDirection",   ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Single",                                                                                                                           ["VectorSize"] = "32", ["NextValueOp1"] = "(float)(random.NextDouble())",                                                                                                                                         ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Round(firstOp[0]))",                                                                                                                                               ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(MathF.Round(firstOp[i]))"}),
+    ("SimpleUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "RoundToNearestInteger",   ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Double",                                                                                                                           ["VectorSize"] = "32", ["NextValueOp1"] = "(double)(random.NextDouble())",                                                                                                                                        ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Round(firstOp[0], MidpointRounding.AwayFromZero))",                                                                                                                 ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(Math.Round(firstOp[i], MidpointRounding.AwayFromZero))"}),
+    ("SimpleUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "RoundToNearestInteger",   ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Single",                                                                                                                           ["VectorSize"] = "32", ["NextValueOp1"] = "(float)(random.NextDouble())",                                                                                                                                         ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Round(firstOp[0], MidpointRounding.AwayFromZero))",                                                                                                                ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(MathF.Round(firstOp[i], MidpointRounding.AwayFromZero))"}),
+    ("SimpleUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "RoundToNegativeInfinity", ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Double",                                                                                                                           ["VectorSize"] = "32", ["NextValueOp1"] = "(double)(random.NextDouble())",                                                                                                                                        ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Floor(firstOp[0]))",                                                                                                                                                ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(Math.Floor(firstOp[i]))"}),
+    ("SimpleUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "RoundToNegativeInfinity", ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Single",                                                                                                                           ["VectorSize"] = "32", ["NextValueOp1"] = "(float)(random.NextDouble())",                                                                                                                                         ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Floor(firstOp[0]))",                                                                                                                                               ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(MathF.Floor(firstOp[i]))"}),
+    ("SimpleUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "RoundToPositiveInfinity", ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Double",                                                                                                                           ["VectorSize"] = "32", ["NextValueOp1"] = "(double)(random.NextDouble())",                                                                                                                                        ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(Math.Ceiling(firstOp[0]))",                                                                                                                                              ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits(Math.Ceiling(firstOp[i]))"}),
+    ("SimpleUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "RoundToPositiveInfinity", ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Single",                                                                                                                           ["VectorSize"] = "32", ["NextValueOp1"] = "(float)(random.NextDouble())",                                                                                                                                         ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(MathF.Ceiling(firstOp[0]))",                                                                                                                                             ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits(MathF.Ceiling(firstOp[i]))"}),
+    ("SimpleUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "RoundToZero",             ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Double",                                                                                                                           ["VectorSize"] = "32", ["NextValueOp1"] = "(double)(random.NextDouble())",                                                                                                                                        ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits((firstOp[0] > 0) ? Math.Floor(firstOp[0]) : Math.Ceiling(firstOp[0]))",                                                                                                  ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != BitConverter.DoubleToInt64Bits((firstOp[i] > 0) ? Math.Floor(firstOp[i]) : Math.Ceiling(firstOp[i]))"}),
+    ("SimpleUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "RoundToZero",             ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Single",                                                                                                                           ["VectorSize"] = "32", ["NextValueOp1"] = "(float)(random.NextDouble())",                                                                                                                                         ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits((firstOp[0] > 0) ? MathF.Floor(firstOp[0]) : MathF.Ceiling(firstOp[0]))",                                                                                                ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != BitConverter.SingleToInt32Bits((firstOp[i] > 0) ? MathF.Floor(firstOp[i]) : MathF.Ceiling(firstOp[i]))"}),
+    ("SimpleBinOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "Subtract",                ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Double",                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(double)(random.NextDouble())",                        ["NextValueOp2"] = "(double)(random.NextDouble())",                                                             ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(left[0] - right[0]) != BitConverter.DoubleToInt64Bits(result[0])",                                                                                                                                                    ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(left[i] - right[i]) != BitConverter.DoubleToInt64Bits(result[i])"}),
+    ("SimpleBinOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "Subtract",                ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Single",                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(float)(random.NextDouble())",                         ["NextValueOp2"] = "(float)(random.NextDouble())",                                                              ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(left[0] - right[0]) != BitConverter.SingleToInt32Bits(result[0])",                                                                                                                                                    ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(left[i] - right[i]) != BitConverter.SingleToInt32Bits(result[i])"}),
+    ("BooleanBinOpTest.template",    new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "TestC",                   ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Byte",   ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Byte",   ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Byte",                                                                ["VectorSize"] = "32", ["NextValueOp1"] = "(byte)(random.Next(0, byte.MaxValue))",                ["NextValueOp2"] = "(byte)(random.Next(0, byte.MaxValue))",                                                     ["ValidateFirstResult"] = "(~left[i] & right[i]) == 0"}),
+    ("BooleanBinOpTest.template",    new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "TestC",                   ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int16",  ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Int16",                                                               ["VectorSize"] = "32", ["NextValueOp1"] = "(short)(random.Next(short.MinValue, short.MaxValue))", ["NextValueOp2"] = "(short)(random.Next(short.MinValue, short.MaxValue))",                                      ["ValidateFirstResult"] = "(~left[i] & right[i]) == 0"}),
+    ("BooleanBinOpTest.template",    new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "TestC",                   ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int32",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int32",  ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Int32",                                                               ["VectorSize"] = "32", ["NextValueOp1"] = "(int)(random.Next(int.MinValue, int.MaxValue))",       ["NextValueOp2"] = "(int)(random.Next(int.MinValue, int.MaxValue))",                                            ["ValidateFirstResult"] = "(~left[i] & right[i]) == 0"}),
+    ("BooleanBinOpTest.template",    new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "TestC",                   ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int64",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int64",  ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Int64",                                                               ["VectorSize"] = "32", ["NextValueOp1"] = "(long)(random.Next(int.MinValue, int.MaxValue))",      ["NextValueOp2"] = "(long)(random.Next(int.MinValue, int.MaxValue))",                                           ["ValidateFirstResult"] = "(~left[i] & right[i]) == 0"}),
+    ("BooleanBinOpTest.template",    new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "TestC",                   ["RetVectorType"] = "Vector256", ["RetBaseType"] = "SByte",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "SByte",  ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "SByte",                                                               ["VectorSize"] = "32", ["NextValueOp1"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))", ["NextValueOp2"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",                                      ["ValidateFirstResult"] = "(~left[i] & right[i]) == 0"}),
+    ("BooleanBinOpTest.template",    new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "TestC",                   ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "UInt16",                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(ushort)(random.Next(0, ushort.MaxValue))",            ["NextValueOp2"] = "(ushort)(random.Next(0, ushort.MaxValue))",                                                 ["ValidateFirstResult"] = "(~left[i] & right[i]) == 0"}),
+    ("BooleanBinOpTest.template",    new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "TestC",                   ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "UInt32",                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(uint)(random.Next(0, int.MaxValue))",                 ["NextValueOp2"] = "(uint)(random.Next(0, int.MaxValue))",                                                      ["ValidateFirstResult"] = "(~left[i] & right[i]) == 0"}),
+    ("BooleanBinOpTest.template",    new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "TestC",                   ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "UInt64",                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(ulong)(random.Next(0, int.MaxValue))",                ["NextValueOp2"] = "(ulong)(random.Next(0, int.MaxValue))",                                                     ["ValidateFirstResult"] = "(~left[i] & right[i]) == 0"}),
+    ("BooleanTwoCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "TestNotZAndNotC",         ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Byte",   ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Byte",   ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Byte",                                                                ["VectorSize"] = "32", ["NextValueOp1"] = "(byte)(random.Next(0, byte.MaxValue))",                ["NextValueOp2"] = "(byte)(random.Next(0, byte.MaxValue))",                                                     ["ValidateFirstResult"] = "((left[i] & right[i]) == 0)",                                                                                                                                                                                                                        ["ValidateRemainingResults"] = "((~left[i] & right[i]) == 0)"}),
+    ("BooleanTwoCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "TestNotZAndNotC",         ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int16",  ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Int16",                                                               ["VectorSize"] = "32", ["NextValueOp1"] = "(short)(random.Next(short.MinValue, short.MaxValue))", ["NextValueOp2"] = "(short)(random.Next(short.MinValue, short.MaxValue))",                                      ["ValidateFirstResult"] = "((left[i] & right[i]) == 0)",                                                                                                                                                                                                                        ["ValidateRemainingResults"] = "((~left[i] & right[i]) == 0)"}),
+    ("BooleanTwoCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "TestNotZAndNotC",         ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int32",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int32",  ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Int32",                                                               ["VectorSize"] = "32", ["NextValueOp1"] = "(int)(random.Next(int.MinValue, int.MaxValue))",       ["NextValueOp2"] = "(int)(random.Next(int.MinValue, int.MaxValue))",                                            ["ValidateFirstResult"] = "((left[i] & right[i]) == 0)",                                                                                                                                                                                                                        ["ValidateRemainingResults"] = "((~left[i] & right[i]) == 0)"}),
+    ("BooleanTwoCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "TestNotZAndNotC",         ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int64",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int64",  ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Int64",                                                               ["VectorSize"] = "32", ["NextValueOp1"] = "(long)(random.Next(int.MinValue, int.MaxValue))",      ["NextValueOp2"] = "(long)(random.Next(int.MinValue, int.MaxValue))",                                           ["ValidateFirstResult"] = "((left[i] & right[i]) == 0)",                                                                                                                                                                                                                        ["ValidateRemainingResults"] = "((~left[i] & right[i]) == 0)"}),
+    ("BooleanTwoCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "TestNotZAndNotC",         ["RetVectorType"] = "Vector256", ["RetBaseType"] = "SByte",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "SByte",  ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "SByte",                                                               ["VectorSize"] = "32", ["NextValueOp1"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))", ["NextValueOp2"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",                                      ["ValidateFirstResult"] = "((left[i] & right[i]) == 0)",                                                                                                                                                                                                                        ["ValidateRemainingResults"] = "((~left[i] & right[i]) == 0)"}),
+    ("BooleanTwoCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "TestNotZAndNotC",         ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "UInt16",                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(ushort)(random.Next(0, ushort.MaxValue))",            ["NextValueOp2"] = "(ushort)(random.Next(0, ushort.MaxValue))",                                                 ["ValidateFirstResult"] = "((left[i] & right[i]) == 0)",                                                                                                                                                                                                                        ["ValidateRemainingResults"] = "((~left[i] & right[i]) == 0)"}),
+    ("BooleanTwoCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "TestNotZAndNotC",         ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "UInt32",                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(uint)(random.Next(0, int.MaxValue))",                 ["NextValueOp2"] = "(uint)(random.Next(0, int.MaxValue))",                                                      ["ValidateFirstResult"] = "((left[i] & right[i]) == 0)",                                                                                                                                                                                                                        ["ValidateRemainingResults"] = "((~left[i] & right[i]) == 0)"}),
+    ("BooleanTwoCmpOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "TestNotZAndNotC",         ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "UInt64",                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(ulong)(random.Next(0, int.MaxValue))",                ["NextValueOp2"] = "(ulong)(random.Next(0, int.MaxValue))",                                                     ["ValidateFirstResult"] = "((left[i] & right[i]) == 0)",                                                                                                                                                                                                                        ["ValidateRemainingResults"] = "((~left[i] & right[i]) == 0)"}),
+    ("BooleanBinOpTest.template",    new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "TestZ",                   ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Byte",   ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Byte",   ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Byte",                                                                ["VectorSize"] = "32", ["NextValueOp1"] = "(byte)(random.Next(0, byte.MaxValue))",                ["NextValueOp2"] = "(byte)(random.Next(0, byte.MaxValue))",                                                     ["ValidateFirstResult"] = "(left[i] & right[i]) == 0"}),
+    ("BooleanBinOpTest.template",    new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "TestZ",                   ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int16",  ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Int16",                                                               ["VectorSize"] = "32", ["NextValueOp1"] = "(short)(random.Next(short.MinValue, short.MaxValue))", ["NextValueOp2"] = "(short)(random.Next(short.MinValue, short.MaxValue))",                                      ["ValidateFirstResult"] = "(left[i] & right[i]) == 0"}),
+    ("BooleanBinOpTest.template",    new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "TestZ",                   ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int32",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int32",  ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Int32",                                                               ["VectorSize"] = "32", ["NextValueOp1"] = "(int)(random.Next(int.MinValue, int.MaxValue))",       ["NextValueOp2"] = "(int)(random.Next(int.MinValue, int.MaxValue))",                                            ["ValidateFirstResult"] = "(left[i] & right[i]) == 0"}),
+    ("BooleanBinOpTest.template",    new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "TestZ",                   ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int64",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int64",  ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Int64",                                                               ["VectorSize"] = "32", ["NextValueOp1"] = "(long)(random.Next(int.MinValue, int.MaxValue))",      ["NextValueOp2"] = "(long)(random.Next(int.MinValue, int.MaxValue))",                                           ["ValidateFirstResult"] = "(left[i] & right[i]) == 0"}),
+    ("BooleanBinOpTest.template",    new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "TestZ",                   ["RetVectorType"] = "Vector256", ["RetBaseType"] = "SByte",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "SByte",  ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "SByte",                                                               ["VectorSize"] = "32", ["NextValueOp1"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))", ["NextValueOp2"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",                                      ["ValidateFirstResult"] = "(left[i] & right[i]) == 0"}),
+    ("BooleanBinOpTest.template",    new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "TestZ",                   ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "UInt16",                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(ushort)(random.Next(0, ushort.MaxValue))",            ["NextValueOp2"] = "(ushort)(random.Next(0, ushort.MaxValue))",                                                 ["ValidateFirstResult"] = "(left[i] & right[i]) == 0"}),
+    ("BooleanBinOpTest.template",    new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "TestZ",                   ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "UInt32",                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(uint)(random.Next(0, int.MaxValue))",                 ["NextValueOp2"] = "(uint)(random.Next(0, int.MaxValue))",                                                      ["ValidateFirstResult"] = "(left[i] & right[i]) == 0"}),
+    ("BooleanBinOpTest.template",    new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "TestZ",                   ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "UInt64",                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(ulong)(random.Next(0, int.MaxValue))",                ["NextValueOp2"] = "(ulong)(random.Next(0, int.MaxValue))",                                                     ["ValidateFirstResult"] = "(left[i] & right[i]) == 0"}),
+    ("SimpleBinOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "Xor",                     ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Double",                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(double)(random.NextDouble())",                        ["NextValueOp2"] = "(double)(random.NextDouble())",                                                             ["ValidateFirstResult"] = "(BitConverter.DoubleToInt64Bits(left[0]) ^ BitConverter.DoubleToInt64Bits(right[0])) != BitConverter.DoubleToInt64Bits(result[0])",                                                                                                                  ["ValidateRemainingResults"] = "(BitConverter.DoubleToInt64Bits(left[i]) ^ BitConverter.DoubleToInt64Bits(right[i])) != BitConverter.DoubleToInt64Bits(result[i])"}),
+    ("SimpleBinOpTest.template",     new Dictionary<string, string> { ["Isa"] = "Avx", ["LoadIsa"] = "Avx", ["Method"] = "Xor",                     ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Single",                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(float)(random.NextDouble())",                         ["NextValueOp2"] = "(float)(random.NextDouble())",                                                              ["ValidateFirstResult"] = "(BitConverter.SingleToInt32Bits(left[0]) ^ BitConverter.SingleToInt32Bits(right[0])) != BitConverter.SingleToInt32Bits(result[0])",                                                                                                                  ["ValidateRemainingResults"] = "(BitConverter.SingleToInt32Bits(left[i]) ^ BitConverter.SingleToInt32Bits(right[i])) != BitConverter.SingleToInt32Bits(result[i])"}),
 };
 
-private static readonly (string templateFileName, string[] templateData)[] Avx2Inputs = new []
+private static readonly (string templateFileName, Dictionary<string, string> templateData)[] Avx2Inputs = new []
 {
-    // TemplateName                              Isa,    LoadIsa, Method,               RetVectorType, RetBaseType, Op1VectorType, Op1BaseType,  Op2VectorType, Op2BaseType, Op3VectorType, Op3BaseType, VectorSize, NextValueOp1,                                            NextValueOp2,                                            NextValueOp3,                         ValidateFirstResult,                                                                 ValidateRemainingResults
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "Add",                "Vector256",   "Byte",      "Vector256",   "Byte",       "Vector256",   "Byte",                                  "32",       "(byte)(random.Next(0, byte.MaxValue))",                 "(byte)(random.Next(0, byte.MaxValue))",                                                       "(byte)(left[0] + right[0]) != result[0]",                                           "(byte)(left[i] + right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "Add",                "Vector256",   "Int16",     "Vector256",   "Int16",      "Vector256",   "Int16",                                 "32",       "(short)(random.Next(short.MinValue, short.MaxValue))",  "(short)(random.Next(short.MinValue, short.MaxValue))",                                        "(short)(left[0] + right[0]) != result[0]",                                          "(short)(left[i] + right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "Add",                "Vector256",   "Int32",     "Vector256",   "Int32",      "Vector256",   "Int32",                                 "32",       "(int)(random.Next(int.MinValue, int.MaxValue))",        "(int)(random.Next(int.MinValue, int.MaxValue))",                                              "(int)(left[0] + right[0]) != result[0]",                                            "(int)(left[i] + right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "Add",                "Vector256",   "Int64",     "Vector256",   "Int64",      "Vector256",   "Int64",                                 "32",       "(long)(random.Next(int.MinValue, int.MaxValue))",       "(long)(random.Next(int.MinValue, int.MaxValue))",                                             "(long)(left[0] + right[0]) != result[0]",                                           "(long)(left[i] + right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "Add",                "Vector256",   "SByte",     "Vector256",   "SByte",      "Vector256",   "SByte",                                 "32",       "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",  "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",                                        "(sbyte)(left[0] + right[0]) != result[0]",                                          "(sbyte)(left[i] + right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "Add",                "Vector256",   "UInt16",    "Vector256",   "UInt16",     "Vector256",   "UInt16",                                "32",       "(ushort)(random.Next(0, ushort.MaxValue))",             "(ushort)(random.Next(0, ushort.MaxValue))",                                                   "(ushort)(left[0] + right[0]) != result[0]",                                         "(ushort)(left[i] + right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "Add",                "Vector256",   "UInt32",    "Vector256",   "UInt32",     "Vector256",   "UInt32",                                "32",       "(uint)(random.Next(0, int.MaxValue))",                  "(uint)(random.Next(0, int.MaxValue))",                                                        "(uint)(left[0] + right[0]) != result[0]",                                           "(uint)(left[i] + right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "Add",                "Vector256",   "UInt64",    "Vector256",   "UInt64",     "Vector256",   "UInt64",                                "32",       "(ulong)(random.Next(0, int.MaxValue))",                 "(ulong)(random.Next(0, int.MaxValue))",                                                       "(ulong)(left[0] + right[0]) != result[0]",                                          "(ulong)(left[i] + right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "And",                "Vector256",   "Byte",      "Vector256",   "Byte",       "Vector256",   "Byte",                                  "32",       "(byte)(random.Next(0, byte.MaxValue))",                 "(byte)(random.Next(0, byte.MaxValue))",                                                       "(byte)(left[0] & right[0]) != result[0]",                                           "(byte)(left[i] & right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "And",                "Vector256",   "Int16",     "Vector256",   "Int16",      "Vector256",   "Int16",                                 "32",       "(short)(random.Next(short.MinValue, short.MaxValue))",  "(short)(random.Next(short.MinValue, short.MaxValue))",                                        "(short)(left[0] & right[0]) != result[0]",                                          "(short)(left[i] & right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "And",                "Vector256",   "Int32",     "Vector256",   "Int32",      "Vector256",   "Int32",                                 "32",       "(int)(random.Next(int.MinValue, int.MaxValue))",        "(int)(random.Next(int.MinValue, int.MaxValue))",                                              "(int)(left[0] & right[0]) != result[0]",                                            "(int)(left[i] & right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "And",                "Vector256",   "Int64",     "Vector256",   "Int64",      "Vector256",   "Int64",                                 "32",       "(long)(random.Next(int.MinValue, int.MaxValue))",       "(long)(random.Next(int.MinValue, int.MaxValue))",                                             "(long)(left[0] & right[0]) != result[0]",                                           "(long)(left[i] & right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "And",                "Vector256",   "SByte",     "Vector256",   "SByte",      "Vector256",   "SByte",                                 "32",       "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",  "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",                                        "(sbyte)(left[0] & right[0]) != result[0]",                                          "(sbyte)(left[i] & right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "And",                "Vector256",   "UInt16",    "Vector256",   "UInt16",     "Vector256",   "UInt16",                                "32",       "(ushort)(random.Next(0, ushort.MaxValue))",             "(ushort)(random.Next(0, ushort.MaxValue))",                                                   "(ushort)(left[0] & right[0]) != result[0]",                                         "(ushort)(left[i] & right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "And",                "Vector256",   "UInt32",    "Vector256",   "UInt32",     "Vector256",   "UInt32",                                "32",       "(uint)(random.Next(0, int.MaxValue))",                  "(uint)(random.Next(0, int.MaxValue))",                                                        "(uint)(left[0] & right[0]) != result[0]",                                           "(uint)(left[i] & right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "And",                "Vector256",   "UInt64",    "Vector256",   "UInt64",     "Vector256",   "UInt64",                                "32",       "(ulong)(random.Next(0, int.MaxValue))",                 "(ulong)(random.Next(0, int.MaxValue))",                                                       "(ulong)(left[0] & right[0]) != result[0]",                                          "(ulong)(left[i] & right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "AndNot",             "Vector256",   "Byte",      "Vector256",   "Byte",       "Vector256",   "Byte",                                  "32",       "(byte)(random.Next(0, byte.MaxValue))",                 "(byte)(random.Next(0, byte.MaxValue))",                                                       "(byte)(~left[0] & right[0]) != result[0]",                                          "(byte)(~left[i] & right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "AndNot",             "Vector256",   "Int16",     "Vector256",   "Int16",      "Vector256",   "Int16",                                 "32",       "(short)(random.Next(short.MinValue, short.MaxValue))",  "(short)(random.Next(short.MinValue, short.MaxValue))",                                        "(short)(~left[0] & right[0]) != result[0]",                                         "(short)(~left[i] & right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "AndNot",             "Vector256",   "Int32",     "Vector256",   "Int32",      "Vector256",   "Int32",                                 "32",       "(int)(random.Next(int.MinValue, int.MaxValue))",        "(int)(random.Next(int.MinValue, int.MaxValue))",                                              "(int)(~left[0] & right[0]) != result[0]",                                           "(int)(~left[i] & right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "AndNot",             "Vector256",   "Int64",     "Vector256",   "Int64",      "Vector256",   "Int64",                                 "32",       "(long)(random.Next(int.MinValue, int.MaxValue))",       "(long)(random.Next(int.MinValue, int.MaxValue))",                                             "(long)(~left[0] & right[0]) != result[0]",                                          "(long)(~left[i] & right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "AndNot",             "Vector256",   "SByte",     "Vector256",   "SByte",      "Vector256",   "SByte",                                 "32",       "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",  "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",                                        "(sbyte)(~left[0] & right[0]) != result[0]",                                         "(sbyte)(~left[i] & right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "AndNot",             "Vector256",   "UInt16",    "Vector256",   "UInt16",     "Vector256",   "UInt16",                                "32",       "(ushort)(random.Next(0, ushort.MaxValue))",             "(ushort)(random.Next(0, ushort.MaxValue))",                                                   "(ushort)(~left[0] & right[0]) != result[0]",                                        "(ushort)(~left[i] & right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "AndNot",             "Vector256",   "UInt32",    "Vector256",   "UInt32",     "Vector256",   "UInt32",                                "32",       "(uint)(random.Next(0, int.MaxValue))",                  "(uint)(random.Next(0, int.MaxValue))",                                                        "(uint)(~left[0] & right[0]) != result[0]",                                          "(uint)(~left[i] & right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "AndNot",             "Vector256",   "UInt64",    "Vector256",   "UInt64",     "Vector256",   "UInt64",                                "32",       "(ulong)(random.Next(0, int.MaxValue))",                 "(ulong)(random.Next(0, int.MaxValue))",                                                       "(ulong)(~left[0] & right[0]) != result[0]",                                         "(ulong)(~left[i] & right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "Average",            "Vector256",   "Byte",      "Vector256",   "Byte",       "Vector256",   "Byte",                                  "32",       "(byte)(random.Next(0, byte.MaxValue))",                 "(byte)(random.Next(0, byte.MaxValue))",                                                       "(byte)((left[0] + right[0] + 1) >> 1) != result[0]",                                "(byte)((left[i] + right[i] + 1) >> 1) != result[i]"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "Average",            "Vector256",   "UInt16",    "Vector256",   "UInt16",     "Vector256",   "UInt16",                                "32",       "(ushort)(random.Next(short.MinValue, short.MaxValue))", "(ushort)(random.Next(short.MinValue, short.MaxValue))",                                       "(ushort)((left[0] + right[0] + 1) >> 1) != result[0]",                              "(ushort)((left[i] + right[i] + 1) >> 1) != result[i]"}),
-    ("SimpleTernOpTest.template", new string[] { "Avx2", "Avx",   "BlendVariable",      "Vector256",   "Byte",      "Vector256",   "Byte",       "Vector256",   "Byte",      "Vector256",   "Byte",      "32",       "(byte)(random.Next(0, byte.MaxValue))",                 "(byte)(random.Next(0, byte.MaxValue))",                 "(byte)(((i % 2) == 0) ? 128 : 1)",   "((thirdOp[0] >> 7) & 1) == 1 ? secondOp[0] != result[0] : firstOp[0] != result[0]", "((thirdOp[i] >> 7) & 1) == 1 ? secondOp[i] != result[i] : firstOp[i] != result[i]"}),
-    ("SimpleTernOpTest.template", new string[] { "Avx2", "Avx",   "BlendVariable",      "Vector256",   "SByte",     "Vector256",   "SByte",      "Vector256",   "SByte",     "Vector256",   "SByte",     "32",       "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",  "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",  "(sbyte)(((i % 2) == 0) ? -128 : 1)", "((thirdOp[0] >> 7) & 1) == 1 ? secondOp[0] != result[0] : firstOp[0] != result[0]", "((thirdOp[i] >> 7) & 1) == 1 ? secondOp[i] != result[i] : firstOp[i] != result[i]"}),
-
-
-    ("GenericUnOpTest.template",  new string[] { "Avx2", "Sse2",  "BroadcastScalarToVector128",  "Vector128","Byte",  "Vector128",   "Byte",                                                               "16",       "(byte)(random.Next(0, byte.MaxValue))",                                                                                                                "firstOp[0] != result[0]",                                                           "(firstOp[0] != result[i])"}),
-    ("GenericUnOpTest.template",  new string[] { "Avx2", "Sse2",  "BroadcastScalarToVector128", "Vector128","SByte", "Vector128",   "SByte",                                                              "16",       "(sbyte)(random.Next(0, sbyte.MaxValue))",                                                                                                              "firstOp[0] != result[0]",                                                           "(firstOp[0] != result[i])"}),
-    ("GenericUnOpTest.template",  new string[] { "Avx2", "Sse2",  "BroadcastScalarToVector128", "Vector128","Int16", "Vector128",   "Int16",                                                              "16",       "(short)(random.Next(0, short.MaxValue))",                                                                                                              "firstOp[0] != result[0]",                                                           "(firstOp[0] != result[i])"}),
-    ("GenericUnOpTest.template",  new string[] { "Avx2", "Sse2",  "BroadcastScalarToVector128","Vector128","UInt16","Vector128",   "UInt16",                                                             "16",       "(ushort)(random.Next(0, ushort.MaxValue))",                                                                                                            "firstOp[0] != result[0]",                                                           "(firstOp[0] != result[i])"}),    
-    ("GenericUnOpTest.template",  new string[] { "Avx2", "Sse2",  "BroadcastScalarToVector128", "Vector128","Int32", "Vector128",   "Int32",                                                              "16",       "(int)(random.Next(0, int.MaxValue))",                                                                                                                  "firstOp[0] != result[0]",                                                           "(firstOp[0] != result[i])"}),
-    ("GenericUnOpTest.template",  new string[] { "Avx2", "Sse2",  "BroadcastScalarToVector128","Vector128","UInt32","Vector128",   "UInt32",                                                             "16",       "(uint)(random.Next(0, int.MaxValue))",                                                                                                                 "firstOp[0] != result[0]",                                                           "(firstOp[0] != result[i])"}),  
-    ("GenericUnOpTest.template",  new string[] { "Avx2", "Sse2",  "BroadcastScalarToVector128", "Vector128","Int64", "Vector128",   "Int64",                                                              "16",       "(long)(random.Next(0, int.MaxValue))",                                                                                                                 "firstOp[0] != result[0]",                                                           "(firstOp[0] != result[i])"}),
-    ("GenericUnOpTest.template",  new string[] { "Avx2", "Sse2",  "BroadcastScalarToVector128","Vector128","UInt64","Vector128",   "UInt64",                                                             "16",       "(ulong)(random.Next(0, int.MaxValue))",                                                                                                                "firstOp[0] != result[0]",                                                           "(firstOp[0] != result[i])"}),  
-    ("GenericUnOpTest.template",  new string[] { "Avx2", "Sse",   "BroadcastScalarToVector128","Vector128","Single","Vector128",   "Single",                                                             "16",       "(float)(random.NextDouble())",                                                                                                                         "BitConverter.SingleToInt32Bits(firstOp[0]) != BitConverter.SingleToInt32Bits(result[0])",    "(BitConverter.SingleToInt32Bits(firstOp[0]) != BitConverter.SingleToInt32Bits(result[i]))"}),    
-    ("GenericUnOpTest.template",  new string[] { "Avx2", "Sse2",  "BroadcastScalarToVector128","Vector128","Double","Vector128",   "Double",                                                             "16",       "(double)(random.NextDouble())",                                                                                                                        "BitConverter.DoubleToInt64Bits(firstOp[0]) != BitConverter.DoubleToInt64Bits(result[0])",    "(BitConverter.DoubleToInt64Bits(firstOp[0]) != BitConverter.DoubleToInt64Bits(result[i]))"}),
-    
-    ("GenericUnOpTest.template",  new string[] { "Avx2", "Sse2",   "BroadcastScalarToVector256",  "Vector256","Byte",  "Vector128",   "Byte",                                                               "32",       "(byte)(random.Next(0, byte.MaxValue))",                                                                                                                "firstOp[0] != result[0]",                                                           "(firstOp[0] != result[i])"}),
-    ("GenericUnOpTest.template",  new string[] { "Avx2", "Sse2",   "BroadcastScalarToVector256", "Vector256","SByte", "Vector128",   "SByte",                                                              "32",       "(sbyte)(random.Next(0, sbyte.MaxValue))",                                                                                                              "firstOp[0] != result[0]",                                                           "(firstOp[0] != result[i])"}),
-    ("GenericUnOpTest.template",  new string[] { "Avx2", "Sse2",   "BroadcastScalarToVector256", "Vector256","Int16", "Vector128",   "Int16",                                                              "32",       "(short)(random.Next(0, short.MaxValue))",                                                                                                              "firstOp[0] != result[0]",                                                           "(firstOp[0] != result[i])"}),
-    ("GenericUnOpTest.template",  new string[] { "Avx2", "Sse2",   "BroadcastScalarToVector256","Vector256","UInt16","Vector128",   "UInt16",                                                             "32",       "(ushort)(random.Next(0, ushort.MaxValue))",                                                                                                            "firstOp[0] != result[0]",                                                           "(firstOp[0] != result[i])"}),    
-    ("GenericUnOpTest.template",  new string[] { "Avx2", "Sse2",   "BroadcastScalarToVector256", "Vector256","Int32", "Vector128",   "Int32",                                                              "32",       "(int)(random.Next(0, int.MaxValue))",                                                                                                                  "firstOp[0] != result[0]",                                                           "(firstOp[0] != result[i])"}),
-    ("GenericUnOpTest.template",  new string[] { "Avx2", "Sse2",   "BroadcastScalarToVector256","Vector256","UInt32","Vector128",   "UInt32",                                                             "32",       "(uint)(random.Next(0, int.MaxValue))",                                                                                                                 "firstOp[0] != result[0]",                                                           "(firstOp[0] != result[i])"}),  
-    ("GenericUnOpTest.template",  new string[] { "Avx2", "Sse2",   "BroadcastScalarToVector256", "Vector256","Int64", "Vector128",   "Int64",                                                              "32",       "(long)(random.Next(0, int.MaxValue))",                                                                                                                 "firstOp[0] != result[0]",                                                           "(firstOp[0] != result[i])"}),
-    ("GenericUnOpTest.template",  new string[] { "Avx2", "Sse2",   "BroadcastScalarToVector256","Vector256","UInt64","Vector128",   "UInt64",                                                             "32",       "(ulong)(random.Next(0, int.MaxValue))",                                                                                                                "firstOp[0] != result[0]",                                                           "(firstOp[0] != result[i])"}),  
-    ("GenericUnOpTest.template",  new string[] { "Avx2", "Sse",   "BroadcastScalarToVector256","Vector256","Single","Vector128",   "Single",                                                             "32",       "(float)(random.NextDouble())",                                                                                                                         "BitConverter.SingleToInt32Bits(firstOp[0]) != BitConverter.SingleToInt32Bits(result[0])",    "(BitConverter.SingleToInt32Bits(firstOp[0]) != BitConverter.SingleToInt32Bits(result[i]))"}),    
-    ("GenericUnOpTest.template",  new string[] { "Avx2", "Sse2",   "BroadcastScalarToVector256","Vector256","Double","Vector128",   "Double",                                                             "32",       "(double)(random.NextDouble())",                                                                                                                        "BitConverter.DoubleToInt64Bits(firstOp[0]) != BitConverter.DoubleToInt64Bits(result[0])",    "(BitConverter.DoubleToInt64Bits(firstOp[0]) != BitConverter.DoubleToInt64Bits(result[i]))"}),
-
-
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "CompareEqual",       "Vector256",   "Byte",      "Vector256",   "Byte",       "Vector256",   "Byte",                                  "32",       "(byte)(random.Next(0, byte.MaxValue))",                 "(byte)(random.Next(0, byte.MaxValue))",                                                       "result[0] != ((left[0] == right[0]) ? unchecked((byte)(-1)) : 0)",                  "result[i] != ((left[i] == right[i]) ? unchecked((byte)(-1)) : 0)"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "CompareEqual",       "Vector256",   "Int16",     "Vector256",   "Int16",      "Vector256",   "Int16",                                 "32",       "(short)(random.Next(short.MinValue, short.MaxValue))",  "(short)(random.Next(short.MinValue, short.MaxValue))",                                        "result[0] != ((left[0] == right[0]) ? unchecked((short)(-1)) : 0)",                 "result[i] != ((left[i] == right[i]) ? unchecked((short)(-1)) : 0)"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "CompareEqual",       "Vector256",   "Int32",     "Vector256",   "Int32",      "Vector256",   "Int32",                                 "32",       "(int)(random.Next(int.MinValue, int.MaxValue))",        "(int)(random.Next(int.MinValue, int.MaxValue))",                                              "result[0] != ((left[0] == right[0]) ? unchecked((int)(-1)) : 0)",                   "result[i] != ((left[i] == right[i]) ? unchecked((int)(-1)) : 0)"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "CompareEqual",       "Vector256",   "Int64",     "Vector256",   "Int64",      "Vector256",   "Int64",                                 "32",       "(long)(random.Next(int.MinValue, int.MaxValue))",       "(long)(random.Next(int.MinValue, int.MaxValue))",                                             "result[0] != ((left[0] == right[0]) ? unchecked((long)(-1)) : 0)",                  "result[i] != ((left[i] == right[i]) ? unchecked((long)(-1)) : 0)"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "CompareEqual",       "Vector256",   "SByte",     "Vector256",   "SByte",      "Vector256",   "SByte",                                 "32",       "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",  "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",                                        "result[0] != ((left[0] == right[0]) ? unchecked((sbyte)(-1)) : 0)",                 "result[i] != ((left[i] == right[i]) ? unchecked((sbyte)(-1)) : 0)"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "CompareEqual",       "Vector256",   "UInt16",    "Vector256",   "UInt16",     "Vector256",   "UInt16",                                "32",       "(ushort)(random.Next(0, ushort.MaxValue))",             "(ushort)(random.Next(0, ushort.MaxValue))",                                                   "result[0] != ((left[0] == right[0]) ? unchecked((ushort)(-1)) : 0)",                "result[i] != ((left[i] == right[i]) ? unchecked((ushort)(-1)) : 0)"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "CompareEqual",       "Vector256",   "UInt32",    "Vector256",   "UInt32",     "Vector256",   "UInt32",                                "32",       "(uint)(random.Next(0, int.MaxValue))",                  "(uint)(random.Next(0, int.MaxValue))",                                                        "result[0] != ((left[0] == right[0]) ? unchecked((uint)(-1)) : 0)",                  "result[i] != ((left[i] == right[i]) ? unchecked((uint)(-1)) : 0)"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "CompareEqual",       "Vector256",   "UInt64",    "Vector256",   "UInt64",     "Vector256",   "UInt64",                                "32",       "(ulong)(random.Next(0, int.MaxValue))",                 "(ulong)(random.Next(0, int.MaxValue))",                                                       "result[0] != ((left[0] == right[0]) ? unchecked((ulong)(-1)) : 0)",                 "result[i] != ((left[i] == right[i]) ? unchecked((ulong)(-1)) : 0)"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "CompareGreaterThan", "Vector256",   "Int16",     "Vector256",   "Int16",      "Vector256",   "Int16",                                 "32",       "(short)(random.Next(short.MinValue, short.MaxValue))",  "(short)(random.Next(short.MinValue, short.MaxValue))",                                        "result[0] != ((left[0] > right[0]) ? unchecked((short)(-1)) : 0)",                  "result[i] != ((left[i] > right[i]) ? unchecked((short)(-1)) : 0)"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "CompareGreaterThan", "Vector256",   "Int32",     "Vector256",   "Int32",      "Vector256",   "Int32",                                 "32",       "(int)(random.Next(int.MinValue, int.MaxValue))",        "(int)(random.Next(int.MinValue, int.MaxValue))",                                              "result[0] != ((left[0] > right[0]) ? unchecked((int)(-1)) : 0)",                    "result[i] != ((left[i] > right[i]) ? unchecked((int)(-1)) : 0)"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "CompareGreaterThan", "Vector256",   "Int64",     "Vector256",   "Int64",      "Vector256",   "Int64",                                 "32",       "(long)(random.Next(int.MinValue, int.MaxValue))",       "(long)(random.Next(int.MinValue, int.MaxValue))",                                             "result[0] != ((left[0] > right[0]) ? unchecked((long)(-1)) : 0)",                   "result[i] != ((left[i] > right[i]) ? unchecked((long)(-1)) : 0)"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "CompareGreaterThan", "Vector256",   "SByte",     "Vector256",   "SByte",      "Vector256",   "SByte",                                 "32",       "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",  "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",                                        "result[0] != ((left[0] > right[0]) ? unchecked((sbyte)(-1)) : 0)",                  "result[i] != ((left[i] > right[i]) ? unchecked((sbyte)(-1)) : 0)"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "Or",                 "Vector256",   "Byte",      "Vector256",   "Byte",       "Vector256",   "Byte",                                  "32",       "(byte)(random.Next(0, byte.MaxValue))",                 "(byte)(random.Next(0, byte.MaxValue))",                                                       "(byte)(left[0] | right[0]) != result[0]",                                           "(byte)(left[i] | right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "Or",                 "Vector256",   "Int16",     "Vector256",   "Int16",      "Vector256",   "Int16",                                 "32",       "(short)(random.Next(short.MinValue, short.MaxValue))",  "(short)(random.Next(short.MinValue, short.MaxValue))",                                        "(short)(left[0] | right[0]) != result[0]",                                          "(short)(left[i] | right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "Or",                 "Vector256",   "Int32",     "Vector256",   "Int32",      "Vector256",   "Int32",                                 "32",       "(int)(random.Next(int.MinValue, int.MaxValue))",        "(int)(random.Next(int.MinValue, int.MaxValue))",                                              "(int)(left[0] | right[0]) != result[0]",                                            "(int)(left[i] | right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "Or",                 "Vector256",   "Int64",     "Vector256",   "Int64",      "Vector256",   "Int64",                                 "32",       "(long)(random.Next(int.MinValue, int.MaxValue))",       "(long)(random.Next(int.MinValue, int.MaxValue))",                                             "(long)(left[0] | right[0]) != result[0]",                                           "(long)(left[i] | right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "Or",                 "Vector256",   "SByte",     "Vector256",   "SByte",      "Vector256",   "SByte",                                 "32",       "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",  "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",                                        "(sbyte)(left[0] | right[0]) != result[0]",                                          "(sbyte)(left[i] | right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "Or",                 "Vector256",   "UInt16",    "Vector256",   "UInt16",     "Vector256",   "UInt16",                                "32",       "(ushort)(random.Next(0, ushort.MaxValue))",             "(ushort)(random.Next(0, ushort.MaxValue))",                                                   "(ushort)(left[0] | right[0]) != result[0]",                                         "(ushort)(left[i] | right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "Or",                 "Vector256",   "UInt32",    "Vector256",   "UInt32",     "Vector256",   "UInt32",                                "32",       "(uint)(random.Next(0, int.MaxValue))",                  "(uint)(random.Next(0, int.MaxValue))",                                                        "(uint)(left[0] | right[0]) != result[0]",                                           "(uint)(left[i] | right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "Or",                 "Vector256",   "UInt64",    "Vector256",   "UInt64",     "Vector256",   "UInt64",                                "32",       "(ulong)(random.Next(0, int.MaxValue))",                 "(ulong)(random.Next(0, int.MaxValue))",                                                       "(ulong)(left[0] | right[0]) != result[0]",                                          "(ulong)(left[i] | right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "Subtract",           "Vector256",   "Byte",      "Vector256",   "Byte",       "Vector256",   "Byte",                                  "32",       "(byte)(random.Next(0, byte.MaxValue))",                 "(byte)(random.Next(0, byte.MaxValue))",                                                       "(byte)(left[0] - right[0]) != result[0]",                                           "(byte)(left[i] - right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "Subtract",           "Vector256",   "Int16",     "Vector256",   "Int16",      "Vector256",   "Int16",                                 "32",       "(short)(random.Next(short.MinValue, short.MaxValue))",  "(short)(random.Next(short.MinValue, short.MaxValue))",                                        "(short)(left[0] - right[0]) != result[0]",                                          "(short)(left[i] - right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "Subtract",           "Vector256",   "Int32",     "Vector256",   "Int32",      "Vector256",   "Int32",                                 "32",       "(int)(random.Next(int.MinValue, int.MaxValue))",        "(int)(random.Next(int.MinValue, int.MaxValue))",                                              "(int)(left[0] - right[0]) != result[0]",                                            "(int)(left[i] - right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "Subtract",           "Vector256",   "Int64",     "Vector256",   "Int64",      "Vector256",   "Int64",                                 "32",       "(long)(random.Next(int.MinValue, int.MaxValue))",       "(long)(random.Next(int.MinValue, int.MaxValue))",                                             "(long)(left[0] - right[0]) != result[0]",                                           "(long)(left[i] - right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "Subtract",           "Vector256",   "SByte",     "Vector256",   "SByte",      "Vector256",   "SByte",                                 "32",       "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",  "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",                                        "(sbyte)(left[0] - right[0]) != result[0]",                                          "(sbyte)(left[i] - right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "Subtract",           "Vector256",   "UInt16",    "Vector256",   "UInt16",     "Vector256",   "UInt16",                                "32",       "(ushort)(random.Next(0, ushort.MaxValue))",             "(ushort)(random.Next(0, ushort.MaxValue))",                                                   "(ushort)(left[0] - right[0]) != result[0]",                                         "(ushort)(left[i] - right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "Subtract",           "Vector256",   "UInt32",    "Vector256",   "UInt32",     "Vector256",   "UInt32",                                "32",       "(uint)(random.Next(0, int.MaxValue))",                  "(uint)(random.Next(0, int.MaxValue))",                                                        "(uint)(left[0] - right[0]) != result[0]",                                           "(uint)(left[i] - right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "Subtract",           "Vector256",   "UInt64",    "Vector256",   "UInt64",     "Vector256",   "UInt64",                                "32",       "(ulong)(random.Next(0, int.MaxValue))",                 "(ulong)(random.Next(0, int.MaxValue))",                                                       "(ulong)(left[0] - right[0]) != result[0]",                                          "(ulong)(left[i] - right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "Xor",                "Vector256",   "Byte",      "Vector256",   "Byte",       "Vector256",   "Byte",                                  "32",       "(byte)(random.Next(0, byte.MaxValue))",                 "(byte)(random.Next(0, byte.MaxValue))",                                                       "(byte)(left[0] ^ right[0]) != result[0]",                                           "(byte)(left[i] ^ right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "Xor",                "Vector256",   "Int16",     "Vector256",   "Int16",      "Vector256",   "Int16",                                 "32",       "(short)(random.Next(short.MinValue, short.MaxValue))",  "(short)(random.Next(short.MinValue, short.MaxValue))",                                        "(short)(left[0] ^ right[0]) != result[0]",                                          "(short)(left[i] ^ right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "Xor",                "Vector256",   "Int32",     "Vector256",   "Int32",      "Vector256",   "Int32",                                 "32",       "(int)(random.Next(int.MinValue, int.MaxValue))",        "(int)(random.Next(int.MinValue, int.MaxValue))",                                              "(int)(left[0] ^ right[0]) != result[0]",                                            "(int)(left[i] ^ right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "Xor",                "Vector256",   "Int64",     "Vector256",   "Int64",      "Vector256",   "Int64",                                 "32",       "(long)(random.Next(int.MinValue, int.MaxValue))",       "(long)(random.Next(int.MinValue, int.MaxValue))",                                             "(long)(left[0] ^ right[0]) != result[0]",                                           "(long)(left[i] ^ right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "Xor",                "Vector256",   "SByte",     "Vector256",   "SByte",      "Vector256",   "SByte",                                 "32",       "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",  "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",                                        "(sbyte)(left[0] ^ right[0]) != result[0]",                                          "(sbyte)(left[i] ^ right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "Xor",                "Vector256",   "UInt16",    "Vector256",   "UInt16",     "Vector256",   "UInt16",                                "32",       "(ushort)(random.Next(0, ushort.MaxValue))",             "(ushort)(random.Next(0, ushort.MaxValue))",                                                   "(ushort)(left[0] ^ right[0]) != result[0]",                                         "(ushort)(left[i] ^ right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "Xor",                "Vector256",   "UInt32",    "Vector256",   "UInt32",     "Vector256",   "UInt32",                                "32",       "(uint)(random.Next(0, int.MaxValue))",                  "(uint)(random.Next(0, int.MaxValue))",                                                        "(uint)(left[0] ^ right[0]) != result[0]",                                           "(uint)(left[i] ^ right[i]) != result[i]"}),
-    ("SimpleBinOpTest.template",  new string[] { "Avx2", "Avx",   "Xor",                "Vector256",   "UInt64",    "Vector256",   "UInt64",     "Vector256",   "UInt64",                                "32",       "(ulong)(random.Next(0, int.MaxValue))",                 "(ulong)(random.Next(0, int.MaxValue))",                                                       "(ulong)(left[0] ^ right[0]) != result[0]",                                          "(ulong)(left[i] ^ right[i]) != result[i]"}),
-
-    // IMM intrinsics
-    // TemplateName                              Isa,    LoadIsa,     Method,                            RetVectorType, RetBaseType, Op1VectorType, Op1BaseType,      IMM,        VectorSize,          NextValueOp1,                                             ValidateFirstResult,                                                                 ValidateRemainingResults
-    ("ImmUnOpTest.template",    new string[] { "Avx2",  "Avx",    "ShiftLeftLogical",                    "Vector256",  "Int16",      "Vector256",  "Int16",           "1",         "32",       "(short)(random.Next(0, short.MaxValue))",                "(short)(firstOp[0] << 1) != result[0]",                                            "(short)(firstOp[i] << 1) != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Avx2",  "Avx",    "ShiftLeftLogical",                    "Vector256",  "UInt16",     "Vector256",  "UInt16",          "1",         "32",       "(ushort)(random.Next(0, ushort.MaxValue))",              "(ushort)(firstOp[0] << 1) != result[0]",                                           "(ushort)(firstOp[i] << 1) != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Avx2",  "Avx",    "ShiftLeftLogical",                    "Vector256",  "Int32",      "Vector256",  "Int32",           "1",         "32",       "(int)(random.Next(0, int.MaxValue))",                    "(int)(firstOp[0] << 1) != result[0]",                                              "(int)(firstOp[i] << 1) != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Avx2",  "Avx",    "ShiftLeftLogical",                    "Vector256",  "UInt32",     "Vector256",  "UInt32",          "1",         "32",       "(uint)(random.Next(0, int.MaxValue))",                   "(uint)(firstOp[0] << 1) != result[0]",                                             "(uint)(firstOp[i] << 1) != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Avx2",  "Avx",    "ShiftLeftLogical",                    "Vector256",  "Int64",      "Vector256",  "Int64",           "1",         "32",       "(long)(random.Next(0, int.MaxValue))",                   "(long)(firstOp[0] << 1) != result[0]",                                             "(long)(firstOp[i] << 1) != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Avx2",  "Avx",    "ShiftLeftLogical",                    "Vector256",  "UInt64",     "Vector256",  "UInt64",          "1",         "32",       "(ulong)(random.Next(0, int.MaxValue))",                  "(ulong)(firstOp[0] << 1) != result[0]",                                            "(ulong)(firstOp[i] << 1) != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Avx2",  "Avx",    "ShiftLeftLogical",                    "Vector256",  "Int16",      "Vector256",  "Int16",           "16",        "32",       "(short)(random.Next(0, short.MaxValue))",                "0 != result[0]",                                                                   "0 != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Avx2",  "Avx",    "ShiftLeftLogical",                    "Vector256",  "UInt16",     "Vector256",  "UInt16",          "16",        "32",       "(ushort)(random.Next(0, ushort.MaxValue))",              "0 != result[0]",                                                                   "0 != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Avx2",  "Avx",    "ShiftLeftLogical",                    "Vector256",  "Int32",      "Vector256",  "Int32",           "32",        "32",       "(int)(random.Next(0, int.MaxValue))",                    "0 != result[0]",                                                                   "0 != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Avx2",  "Avx",    "ShiftLeftLogical",                    "Vector256",  "UInt32",     "Vector256",  "UInt32",          "32",        "32",       "(uint)(random.Next(0, int.MaxValue))",                   "0 != result[0]",                                                                   "0!= result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Avx2",  "Avx",    "ShiftLeftLogical",                    "Vector256",  "Int64",      "Vector256",  "Int64",           "64",        "32",       "(long)(random.Next(0, int.MaxValue))",                   "0 != result[0]",                                                                   "0 != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Avx2",  "Avx",    "ShiftLeftLogical",                    "Vector256",  "UInt64",     "Vector256",  "UInt64",          "64",        "32",       "(ulong)(random.Next(0, int.MaxValue))",                  "0 != result[0]",                                                                   "0 != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Avx2",  "Avx",    "ShiftRightLogical",                   "Vector256",  "Int16",      "Vector256",  "Int16",           "1",         "32",       "(short)(random.Next(0, short.MaxValue))",                "(short)(firstOp[0] >> 1) != result[0]",                                            "(short)(firstOp[i] >> 1) != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Avx2",  "Avx",    "ShiftRightLogical",                   "Vector256",  "UInt16",     "Vector256",  "UInt16",          "1",         "32",       "(ushort)(random.Next(0, ushort.MaxValue))",              "(ushort)(firstOp[0] >> 1) != result[0]",                                           "(ushort)(firstOp[i] >> 1) != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Avx2",  "Avx",    "ShiftRightLogical",                   "Vector256",  "Int32",      "Vector256",  "Int32",           "1",         "32",       "(int)(random.Next(0, int.MaxValue))",                    "(int)(firstOp[0] >> 1) != result[0]",                                              "(int)(firstOp[i] >> 1) != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Avx2",  "Avx",    "ShiftRightLogical",                   "Vector256",  "UInt32",     "Vector256",  "UInt32",          "1",         "32",       "(uint)(random.Next(0, int.MaxValue))",                   "(uint)(firstOp[0] >> 1) != result[0]",                                             "(uint)(firstOp[i] >> 1) != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Avx2",  "Avx",    "ShiftRightLogical",                   "Vector256",  "Int64",      "Vector256",  "Int64",           "1",         "32",       "(long)(random.Next(0, int.MaxValue))",                   "(long)(firstOp[0] >> 1) != result[0]",                                             "(long)(firstOp[i] >> 1) != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Avx2",  "Avx",    "ShiftRightLogical",                   "Vector256",  "UInt64",     "Vector256",  "UInt64",          "1",         "32",       "(ulong)(random.Next(0, int.MaxValue))",                  "(ulong)(firstOp[0] >> 1) != result[0]",                                            "(ulong)(firstOp[i] >> 1) != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Avx2",  "Avx",    "ShiftRightLogical",                   "Vector256",  "Int16",      "Vector256",  "Int16",           "16",        "32",       "(short)(random.Next(0, short.MaxValue))",                "0 != result[0]",                                                                   "0 != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Avx2",  "Avx",    "ShiftRightLogical",                   "Vector256",  "UInt16",     "Vector256",  "UInt16",          "16",        "32",       "(ushort)(random.Next(0, ushort.MaxValue))",              "0 != result[0]",                                                                   "0 != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Avx2",  "Avx",    "ShiftRightLogical",                   "Vector256",  "Int32",      "Vector256",  "Int32",           "32",        "32",       "(int)(random.Next(0, int.MaxValue))",                    "0 != result[0]",                                                                   "0 != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Avx2",  "Avx",    "ShiftRightLogical",                   "Vector256",  "UInt32",     "Vector256",  "UInt32",          "32",        "32",       "(uint)(random.Next(0, int.MaxValue))",                   "0 != result[0]",                                                                   "0!= result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Avx2",  "Avx",    "ShiftRightLogical",                   "Vector256",  "Int64",      "Vector256",  "Int64",           "64",        "32",       "(long)(random.Next(0, int.MaxValue))",                   "0 != result[0]",                                                                   "0 != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Avx2",  "Avx",    "ShiftRightLogical",                   "Vector256",  "UInt64",     "Vector256",  "UInt64",          "64",        "32",       "(ulong)(random.Next(0, int.MaxValue))",                  "0 != result[0]",                                                                   "0 != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Avx2",  "Avx",    "ShiftRightArithmetic",                "Vector256",  "Int16",      "Vector256",  "Int16",           "1",         "32",       "(short)(random.Next(0, short.MaxValue))",                "(short)(firstOp[0] >> 1) != result[0]",                                            "(short)(firstOp[i] >> 1) != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Avx2",  "Avx",    "ShiftRightArithmetic",                "Vector256",  "Int32",      "Vector256",  "Int32",           "1",         "32",       "(int)(random.Next(0, int.MaxValue))",                    "(int)(firstOp[0] >> 1) != result[0]",                                              "(int)(firstOp[i] >> 1) != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Avx2",  "Avx",    "ShiftRightArithmetic",                "Vector256",  "Int16",      "Vector256",  "Int16",           "16",        "32",       "(short)(random.Next(0, short.MaxValue))",                "(short)(firstOp[0] >> 15) != result[0]",                                           "(short)(firstOp[i] >> 15) != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Avx2",  "Avx",    "ShiftRightArithmetic",                "Vector256",  "Int32",      "Vector256",  "Int32",           "32",        "32",       "(int)(random.Next(0, int.MaxValue))",                    "(int)(firstOp[0] >> 31) != result[0]",                                             "(int)(firstOp[i] >> 31) != result[i]"}),
-    ("ImmUnOpTest.template",    new string[] { "Avx2",  "Avx",    "ShiftLeftLogical128BitLane",          "Vector256",  "SByte",      "Vector256",  "SByte",           "1",         "32",      "(sbyte)8",                                                "result[0] != 0",                                                                    "(i == 16 ? result[i] != 0 : result[i] != 8)"}),
-    ("ImmUnOpTest.template",    new string[] { "Avx2",  "Avx",    "ShiftLeftLogical128BitLane",          "Vector256",  "Byte",       "Vector256",  "Byte",            "1",         "32",      "(byte)8",                                                 "result[0] != 0",                                                                    "(i == 16 ? result[i] != 0 : result[i] != 8)"}),
-    ("ImmUnOpTest.template",    new string[] { "Avx2",  "Avx",    "ShiftLeftLogical128BitLane",          "Vector256",  "Int16",      "Vector256",  "Int16",           "1",         "32",      "(short)8",                                                "result[0] != 2048",                                                                 "result[i] != 2048"}),
-    ("ImmUnOpTest.template",    new string[] { "Avx2",  "Avx",    "ShiftLeftLogical128BitLane",          "Vector256",  "UInt16",     "Vector256",  "UInt16",          "1",         "32",      "(ushort)8",                                               "result[0] != 2048",                                                                 "result[i] != 2048"}),
-    ("ImmUnOpTest.template",    new string[] { "Avx2",  "Avx",    "ShiftLeftLogical128BitLane",          "Vector256",  "Int32",      "Vector256",  "Int32",           "1",         "32",      "(int)8",                                                  "result[0] != 2048",                                                                 "result[i] != 2048"}),
-    ("ImmUnOpTest.template",    new string[] { "Avx2",  "Avx",    "ShiftLeftLogical128BitLane",          "Vector256",  "UInt32",     "Vector256",  "UInt32",          "1",         "32",      "(uint)8",                                                 "result[0] != 2048",                                                                 "result[i] != 2048"}),
-    ("ImmUnOpTest.template",    new string[] { "Avx2",  "Avx",    "ShiftLeftLogical128BitLane",          "Vector256",  "Int64",      "Vector256",  "Int64",           "1",         "32",      "(long)8",                                                 "result[0] != 2048",                                                                 "result[i] != 2048"}),
-    ("ImmUnOpTest.template",    new string[] { "Avx2",  "Avx",    "ShiftLeftLogical128BitLane",          "Vector256",  "UInt64",     "Vector256",  "UInt64",          "1",         "32",      "(ulong)8",                                                "result[0] != 2048",                                                                 "result[i] != 2048"}),
-    ("ImmUnOpTest.template",    new string[] { "Avx2",  "Avx",    "ShiftRightLogical128BitLane",          "Vector256",  "SByte",     "Vector256",  "SByte",           "1",         "32",      "(sbyte)8",                                                "result[0] != 8",                                                                   "(i == 31 || i == 15 ? result[i] != 0 : result[i] != 8)"}),
-    ("ImmUnOpTest.template",    new string[] { "Avx2",  "Avx",    "ShiftRightLogical128BitLane",          "Vector256",  "Byte",      "Vector256",  "Byte",            "1",         "32",      "(byte)8",                                                 "result[0] != 8",                                                                   "(i == 31 || i == 15 ? result[i] != 0 : result[i] != 8)"}),
-    ("ImmUnOpTest.template",    new string[] { "Avx2",  "Avx",    "ShiftRightLogical128BitLane",          "Vector256",  "Int16",     "Vector256",  "Int16",           "1",         "32",      "(short)8",                                                "result[0] != 2048",                                                                "(i == 7 || i == 15 ? result[i] != 0 : result[i] != 2048)"}),
-    ("ImmUnOpTest.template",    new string[] { "Avx2",  "Avx",    "ShiftRightLogical128BitLane",          "Vector256",  "UInt16",    "Vector256",  "UInt16",          "1",         "32",      "(ushort)8",                                               "result[0] != 2048",                                                                "(i == 7 || i == 15 ? result[i] != 0 : result[i] != 2048)"}),
-    ("ImmUnOpTest.template",    new string[] { "Avx2",  "Avx",    "ShiftRightLogical128BitLane",          "Vector256",  "Int32",     "Vector256",  "Int32",           "1",         "32",      "(int)8",                                                  "result[0] != 134217728",                                                           "(i == 3 || i == 7 ? result[i] != 0 : result[i] != 134217728)"}),
-    ("ImmUnOpTest.template",    new string[] { "Avx2",  "Avx",    "ShiftRightLogical128BitLane",          "Vector256",  "UInt32",    "Vector256",  "UInt32",          "1",         "32",      "(uint)8",                                                 "result[0] != 134217728",                                                           "(i == 3 || i == 7 ? result[i] != 0 : result[i] != 134217728)"}),
-    ("ImmUnOpTest.template",    new string[] { "Avx2",  "Avx",    "ShiftRightLogical128BitLane",          "Vector256",  "Int64",     "Vector256",  "Int64",           "1",         "32",      "(long)8",                                                 "result[0] != 576460752303423488L",                                                 "(i == 2 ? result[i] != 576460752303423488L : result[i] != 0)"}),
-    ("ImmUnOpTest.template",    new string[] { "Avx2",  "Avx",    "ShiftRightLogical128BitLane",          "Vector256",  "UInt64",    "Vector256",  "UInt64",          "1",         "32",      "(ulong)8",                                                "result[0] != 576460752303423488UL",                                                "(i == 2 ? result[i] != 576460752303423488UL : result[i] != 0)"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "Add",                         ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Byte",   ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Byte",   ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Byte",                                                                                ["VectorSize"] = "32", ["NextValueOp1"] = "(byte)(random.Next(0, byte.MaxValue))",                 ["NextValueOp2"] = "(byte)(random.Next(0, byte.MaxValue))",                                                                          ["ValidateFirstResult"] = "(byte)(left[0] + right[0]) != result[0]",                                                 ["ValidateRemainingResults"] = "(byte)(left[i] + right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "Add",                         ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int16",  ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Int16",                                                                               ["VectorSize"] = "32", ["NextValueOp1"] = "(short)(random.Next(short.MinValue, short.MaxValue))",  ["NextValueOp2"] = "(short)(random.Next(short.MinValue, short.MaxValue))",                                                           ["ValidateFirstResult"] = "(short)(left[0] + right[0]) != result[0]",                                                ["ValidateRemainingResults"] = "(short)(left[i] + right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "Add",                         ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int32",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int32",  ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Int32",                                                                               ["VectorSize"] = "32", ["NextValueOp1"] = "(int)(random.Next(int.MinValue, int.MaxValue))",        ["NextValueOp2"] = "(int)(random.Next(int.MinValue, int.MaxValue))",                                                                 ["ValidateFirstResult"] = "(int)(left[0] + right[0]) != result[0]",                                                  ["ValidateRemainingResults"] = "(int)(left[i] + right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "Add",                         ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int64",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int64",  ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Int64",                                                                               ["VectorSize"] = "32", ["NextValueOp1"] = "(long)(random.Next(int.MinValue, int.MaxValue))",       ["NextValueOp2"] = "(long)(random.Next(int.MinValue, int.MaxValue))",                                                                ["ValidateFirstResult"] = "(long)(left[0] + right[0]) != result[0]",                                                 ["ValidateRemainingResults"] = "(long)(left[i] + right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "Add",                         ["RetVectorType"] = "Vector256", ["RetBaseType"] = "SByte",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "SByte",  ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "SByte",                                                                               ["VectorSize"] = "32", ["NextValueOp1"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",  ["NextValueOp2"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",                                                           ["ValidateFirstResult"] = "(sbyte)(left[0] + right[0]) != result[0]",                                                ["ValidateRemainingResults"] = "(sbyte)(left[i] + right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "Add",                         ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "UInt16",                                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(ushort)(random.Next(0, ushort.MaxValue))",             ["NextValueOp2"] = "(ushort)(random.Next(0, ushort.MaxValue))",                                                                      ["ValidateFirstResult"] = "(ushort)(left[0] + right[0]) != result[0]",                                               ["ValidateRemainingResults"] = "(ushort)(left[i] + right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "Add",                         ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "UInt32",                                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(uint)(random.Next(0, int.MaxValue))",                  ["NextValueOp2"] = "(uint)(random.Next(0, int.MaxValue))",                                                                           ["ValidateFirstResult"] = "(uint)(left[0] + right[0]) != result[0]",                                                 ["ValidateRemainingResults"] = "(uint)(left[i] + right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "Add",                         ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "UInt64",                                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(ulong)(random.Next(0, int.MaxValue))",                 ["NextValueOp2"] = "(ulong)(random.Next(0, int.MaxValue))",                                                                          ["ValidateFirstResult"] = "(ulong)(left[0] + right[0]) != result[0]",                                                ["ValidateRemainingResults"] = "(ulong)(left[i] + right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "And",                         ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Byte",   ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Byte",   ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Byte",                                                                                ["VectorSize"] = "32", ["NextValueOp1"] = "(byte)(random.Next(0, byte.MaxValue))",                 ["NextValueOp2"] = "(byte)(random.Next(0, byte.MaxValue))",                                                                          ["ValidateFirstResult"] = "(byte)(left[0] & right[0]) != result[0]",                                                 ["ValidateRemainingResults"] = "(byte)(left[i] & right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "And",                         ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int16",  ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Int16",                                                                               ["VectorSize"] = "32", ["NextValueOp1"] = "(short)(random.Next(short.MinValue, short.MaxValue))",  ["NextValueOp2"] = "(short)(random.Next(short.MinValue, short.MaxValue))",                                                           ["ValidateFirstResult"] = "(short)(left[0] & right[0]) != result[0]",                                                ["ValidateRemainingResults"] = "(short)(left[i] & right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "And",                         ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int32",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int32",  ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Int32",                                                                               ["VectorSize"] = "32", ["NextValueOp1"] = "(int)(random.Next(int.MinValue, int.MaxValue))",        ["NextValueOp2"] = "(int)(random.Next(int.MinValue, int.MaxValue))",                                                                 ["ValidateFirstResult"] = "(int)(left[0] & right[0]) != result[0]",                                                  ["ValidateRemainingResults"] = "(int)(left[i] & right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "And",                         ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int64",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int64",  ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Int64",                                                                               ["VectorSize"] = "32", ["NextValueOp1"] = "(long)(random.Next(int.MinValue, int.MaxValue))",       ["NextValueOp2"] = "(long)(random.Next(int.MinValue, int.MaxValue))",                                                                ["ValidateFirstResult"] = "(long)(left[0] & right[0]) != result[0]",                                                 ["ValidateRemainingResults"] = "(long)(left[i] & right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "And",                         ["RetVectorType"] = "Vector256", ["RetBaseType"] = "SByte",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "SByte",  ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "SByte",                                                                               ["VectorSize"] = "32", ["NextValueOp1"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",  ["NextValueOp2"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",                                                           ["ValidateFirstResult"] = "(sbyte)(left[0] & right[0]) != result[0]",                                                ["ValidateRemainingResults"] = "(sbyte)(left[i] & right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "And",                         ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "UInt16",                                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(ushort)(random.Next(0, ushort.MaxValue))",             ["NextValueOp2"] = "(ushort)(random.Next(0, ushort.MaxValue))",                                                                      ["ValidateFirstResult"] = "(ushort)(left[0] & right[0]) != result[0]",                                               ["ValidateRemainingResults"] = "(ushort)(left[i] & right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "And",                         ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "UInt32",                                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(uint)(random.Next(0, int.MaxValue))",                  ["NextValueOp2"] = "(uint)(random.Next(0, int.MaxValue))",                                                                           ["ValidateFirstResult"] = "(uint)(left[0] & right[0]) != result[0]",                                                 ["ValidateRemainingResults"] = "(uint)(left[i] & right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "And",                         ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "UInt64",                                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(ulong)(random.Next(0, int.MaxValue))",                 ["NextValueOp2"] = "(ulong)(random.Next(0, int.MaxValue))",                                                                          ["ValidateFirstResult"] = "(ulong)(left[0] & right[0]) != result[0]",                                                ["ValidateRemainingResults"] = "(ulong)(left[i] & right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "AndNot",                      ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Byte",   ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Byte",   ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Byte",                                                                                ["VectorSize"] = "32", ["NextValueOp1"] = "(byte)(random.Next(0, byte.MaxValue))",                 ["NextValueOp2"] = "(byte)(random.Next(0, byte.MaxValue))",                                                                          ["ValidateFirstResult"] = "(byte)(~left[0] & right[0]) != result[0]",                                                ["ValidateRemainingResults"] = "(byte)(~left[i] & right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "AndNot",                      ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int16",  ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Int16",                                                                               ["VectorSize"] = "32", ["NextValueOp1"] = "(short)(random.Next(short.MinValue, short.MaxValue))",  ["NextValueOp2"] = "(short)(random.Next(short.MinValue, short.MaxValue))",                                                           ["ValidateFirstResult"] = "(short)(~left[0] & right[0]) != result[0]",                                               ["ValidateRemainingResults"] = "(short)(~left[i] & right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "AndNot",                      ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int32",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int32",  ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Int32",                                                                               ["VectorSize"] = "32", ["NextValueOp1"] = "(int)(random.Next(int.MinValue, int.MaxValue))",        ["NextValueOp2"] = "(int)(random.Next(int.MinValue, int.MaxValue))",                                                                 ["ValidateFirstResult"] = "(int)(~left[0] & right[0]) != result[0]",                                                 ["ValidateRemainingResults"] = "(int)(~left[i] & right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "AndNot",                      ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int64",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int64",  ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Int64",                                                                               ["VectorSize"] = "32", ["NextValueOp1"] = "(long)(random.Next(int.MinValue, int.MaxValue))",       ["NextValueOp2"] = "(long)(random.Next(int.MinValue, int.MaxValue))",                                                                ["ValidateFirstResult"] = "(long)(~left[0] & right[0]) != result[0]",                                                ["ValidateRemainingResults"] = "(long)(~left[i] & right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "AndNot",                      ["RetVectorType"] = "Vector256", ["RetBaseType"] = "SByte",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "SByte",  ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "SByte",                                                                               ["VectorSize"] = "32", ["NextValueOp1"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",  ["NextValueOp2"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",                                                           ["ValidateFirstResult"] = "(sbyte)(~left[0] & right[0]) != result[0]",                                               ["ValidateRemainingResults"] = "(sbyte)(~left[i] & right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "AndNot",                      ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "UInt16",                                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(ushort)(random.Next(0, ushort.MaxValue))",             ["NextValueOp2"] = "(ushort)(random.Next(0, ushort.MaxValue))",                                                                      ["ValidateFirstResult"] = "(ushort)(~left[0] & right[0]) != result[0]",                                              ["ValidateRemainingResults"] = "(ushort)(~left[i] & right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "AndNot",                      ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "UInt32",                                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(uint)(random.Next(0, int.MaxValue))",                  ["NextValueOp2"] = "(uint)(random.Next(0, int.MaxValue))",                                                                           ["ValidateFirstResult"] = "(uint)(~left[0] & right[0]) != result[0]",                                                ["ValidateRemainingResults"] = "(uint)(~left[i] & right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "AndNot",                      ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "UInt64",                                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(ulong)(random.Next(0, int.MaxValue))",                 ["NextValueOp2"] = "(ulong)(random.Next(0, int.MaxValue))",                                                                          ["ValidateFirstResult"] = "(ulong)(~left[0] & right[0]) != result[0]",                                               ["ValidateRemainingResults"] = "(ulong)(~left[i] & right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "Average",                     ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Byte",   ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Byte",   ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Byte",                                                                                ["VectorSize"] = "32", ["NextValueOp1"] = "(byte)(random.Next(0, byte.MaxValue))",                 ["NextValueOp2"] = "(byte)(random.Next(0, byte.MaxValue))",                                                                          ["ValidateFirstResult"] = "(byte)((left[0] + right[0] + 1) >> 1) != result[0]",                                      ["ValidateRemainingResults"] = "(byte)((left[i] + right[i] + 1) >> 1) != result[i]"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "Average",                     ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "UInt16",                                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(ushort)(random.Next(short.MinValue, short.MaxValue))", ["NextValueOp2"] = "(ushort)(random.Next(short.MinValue, short.MaxValue))",                                                          ["ValidateFirstResult"] = "(ushort)((left[0] + right[0] + 1) >> 1) != result[0]",                                    ["ValidateRemainingResults"] = "(ushort)((left[i] + right[i] + 1) >> 1) != result[i]"}),
+    ("SimpleTernOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "BlendVariable",               ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Byte",   ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Byte",   ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Byte",   ["Op3VectorType"] = "Vector256", ["Op3BaseType"] = "Byte",                   ["VectorSize"] = "32", ["NextValueOp1"] = "(byte)(random.Next(0, byte.MaxValue))",                 ["NextValueOp2"] = "(byte)(random.Next(0, byte.MaxValue))",                 ["NextValueOp3"] = "(byte)(((i % 2) == 0) ? 128 : 1)",   ["ValidateFirstResult"] = "((thirdOp[0] >> 7) & 1) == 1 ? secondOp[0] != result[0] : firstOp[0] != result[0]",       ["ValidateRemainingResults"] = "((thirdOp[i] >> 7) & 1) == 1 ? secondOp[i] != result[i] : firstOp[i] != result[i]"}),
+    ("SimpleTernOpTest.template", new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "BlendVariable",               ["RetVectorType"] = "Vector256", ["RetBaseType"] = "SByte",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "SByte",  ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "SByte",  ["Op3VectorType"] = "Vector256", ["Op3BaseType"] = "SByte",                  ["VectorSize"] = "32", ["NextValueOp1"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",  ["NextValueOp2"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",  ["NextValueOp3"] = "(sbyte)(((i % 2) == 0) ? -128 : 1)", ["ValidateFirstResult"] = "((thirdOp[0] >> 7) & 1) == 1 ? secondOp[0] != result[0] : firstOp[0] != result[0]",       ["ValidateRemainingResults"] = "((thirdOp[i] >> 7) & 1) == 1 ? secondOp[i] != result[i] : firstOp[i] != result[i]"}),
+    ("GenericUnOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Sse2", ["Method"] = "BroadcastScalarToVector128",  ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Byte",   ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Byte",                                                                                                                                             ["VectorSize"] = "16", ["NextValueOp1"] = "(byte)(random.Next(0, byte.MaxValue))",                                                                                                                                                      ["ValidateFirstResult"] = "firstOp[0] != result[0]",                                                                 ["ValidateRemainingResults"] = "(firstOp[0] != result[i])"}),
+    ("GenericUnOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Sse2", ["Method"] = "BroadcastScalarToVector128",  ["RetVectorType"] = "Vector128", ["RetBaseType"] = "SByte",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "SByte",                                                                                                                                            ["VectorSize"] = "16", ["NextValueOp1"] = "(sbyte)(random.Next(0, sbyte.MaxValue))",                                                                                                                                                    ["ValidateFirstResult"] = "firstOp[0] != result[0]",                                                                 ["ValidateRemainingResults"] = "(firstOp[0] != result[i])"}),
+    ("GenericUnOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Sse2", ["Method"] = "BroadcastScalarToVector128",  ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16",                                                                                                                                            ["VectorSize"] = "16", ["NextValueOp1"] = "(short)(random.Next(0, short.MaxValue))",                                                                                                                                                    ["ValidateFirstResult"] = "firstOp[0] != result[0]",                                                                 ["ValidateRemainingResults"] = "(firstOp[0] != result[i])"}),
+    ("GenericUnOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Sse2", ["Method"] = "BroadcastScalarToVector128",  ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16",                                                                                                                                           ["VectorSize"] = "16", ["NextValueOp1"] = "(ushort)(random.Next(0, ushort.MaxValue))",                                                                                                                                                  ["ValidateFirstResult"] = "firstOp[0] != result[0]",                                                                 ["ValidateRemainingResults"] = "(firstOp[0] != result[i])"}),
+    ("GenericUnOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Sse2", ["Method"] = "BroadcastScalarToVector128",  ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int32",                                                                                                                                            ["VectorSize"] = "16", ["NextValueOp1"] = "(int)(random.Next(0, int.MaxValue))",                                                                                                                                                        ["ValidateFirstResult"] = "firstOp[0] != result[0]",                                                                 ["ValidateRemainingResults"] = "(firstOp[0] != result[i])"}),
+    ("GenericUnOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Sse2", ["Method"] = "BroadcastScalarToVector128",  ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt32",                                                                                                                                           ["VectorSize"] = "16", ["NextValueOp1"] = "(uint)(random.Next(0, int.MaxValue))",                                                                                                                                                       ["ValidateFirstResult"] = "firstOp[0] != result[0]",                                                                 ["ValidateRemainingResults"] = "(firstOp[0] != result[i])"}),
+    ("GenericUnOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Sse2", ["Method"] = "BroadcastScalarToVector128",  ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int64",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int64",                                                                                                                                            ["VectorSize"] = "16", ["NextValueOp1"] = "(long)(random.Next(0, int.MaxValue))",                                                                                                                                                       ["ValidateFirstResult"] = "firstOp[0] != result[0]",                                                                 ["ValidateRemainingResults"] = "(firstOp[0] != result[i])"}),
+    ("GenericUnOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Sse2", ["Method"] = "BroadcastScalarToVector128",  ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt64",                                                                                                                                           ["VectorSize"] = "16", ["NextValueOp1"] = "(ulong)(random.Next(0, int.MaxValue))",                                                                                                                                                      ["ValidateFirstResult"] = "firstOp[0] != result[0]",                                                                 ["ValidateRemainingResults"] = "(firstOp[0] != result[i])"}),
+    ("GenericUnOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Sse",  ["Method"] = "BroadcastScalarToVector128",  ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single",                                                                                                                                           ["VectorSize"] = "16", ["NextValueOp1"] = "(float)(random.NextDouble())",                                                                                                                                                               ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(firstOp[0]) != BitConverter.SingleToInt32Bits(result[0])", ["ValidateRemainingResults"] = "(BitConverter.SingleToInt32Bits(firstOp[0]) != BitConverter.SingleToInt32Bits(result[i]))"}),
+    ("GenericUnOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Sse2", ["Method"] = "BroadcastScalarToVector128",  ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double",                                                                                                                                           ["VectorSize"] = "16", ["NextValueOp1"] = "(double)(random.NextDouble())",                                                                                                                                                              ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(firstOp[0]) != BitConverter.DoubleToInt64Bits(result[0])", ["ValidateRemainingResults"] = "(BitConverter.DoubleToInt64Bits(firstOp[0]) != BitConverter.DoubleToInt64Bits(result[i]))"}),
+    ("GenericUnOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Sse2", ["Method"] = "BroadcastScalarToVector256",  ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Byte",   ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Byte",                                                                                                                                             ["VectorSize"] = "32", ["NextValueOp1"] = "(byte)(random.Next(0, byte.MaxValue))",                                                                                                                                                      ["ValidateFirstResult"] = "firstOp[0] != result[0]",                                                                 ["ValidateRemainingResults"] = "(firstOp[0] != result[i])"}),
+    ("GenericUnOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Sse2", ["Method"] = "BroadcastScalarToVector256",  ["RetVectorType"] = "Vector256", ["RetBaseType"] = "SByte",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "SByte",                                                                                                                                            ["VectorSize"] = "32", ["NextValueOp1"] = "(sbyte)(random.Next(0, sbyte.MaxValue))",                                                                                                                                                    ["ValidateFirstResult"] = "firstOp[0] != result[0]",                                                                 ["ValidateRemainingResults"] = "(firstOp[0] != result[i])"}),
+    ("GenericUnOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Sse2", ["Method"] = "BroadcastScalarToVector256",  ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16",                                                                                                                                            ["VectorSize"] = "32", ["NextValueOp1"] = "(short)(random.Next(0, short.MaxValue))",                                                                                                                                                    ["ValidateFirstResult"] = "firstOp[0] != result[0]",                                                                 ["ValidateRemainingResults"] = "(firstOp[0] != result[i])"}),
+    ("GenericUnOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Sse2", ["Method"] = "BroadcastScalarToVector256",  ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16",                                                                                                                                           ["VectorSize"] = "32", ["NextValueOp1"] = "(ushort)(random.Next(0, ushort.MaxValue))",                                                                                                                                                  ["ValidateFirstResult"] = "firstOp[0] != result[0]",                                                                 ["ValidateRemainingResults"] = "(firstOp[0] != result[i])"}),    
+    ("GenericUnOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Sse2", ["Method"] = "BroadcastScalarToVector256",  ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int32",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int32",                                                                                                                                            ["VectorSize"] = "32", ["NextValueOp1"] = "(int)(random.Next(0, int.MaxValue))",                                                                                                                                                        ["ValidateFirstResult"] = "firstOp[0] != result[0]",                                                                 ["ValidateRemainingResults"] = "(firstOp[0] != result[i])"}),
+    ("GenericUnOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Sse2", ["Method"] = "BroadcastScalarToVector256",  ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt32",                                                                                                                                           ["VectorSize"] = "32", ["NextValueOp1"] = "(uint)(random.Next(0, int.MaxValue))",                                                                                                                                                       ["ValidateFirstResult"] = "firstOp[0] != result[0]",                                                                 ["ValidateRemainingResults"] = "(firstOp[0] != result[i])"}),  
+    ("GenericUnOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Sse2", ["Method"] = "BroadcastScalarToVector256",  ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int64",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int64",                                                                                                                                            ["VectorSize"] = "32", ["NextValueOp1"] = "(long)(random.Next(0, int.MaxValue))",                                                                                                                                                       ["ValidateFirstResult"] = "firstOp[0] != result[0]",                                                                 ["ValidateRemainingResults"] = "(firstOp[0] != result[i])"}),
+    ("GenericUnOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Sse2", ["Method"] = "BroadcastScalarToVector256",  ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt64",                                                                                                                                           ["VectorSize"] = "32", ["NextValueOp1"] = "(ulong)(random.Next(0, int.MaxValue))",                                                                                                                                                      ["ValidateFirstResult"] = "firstOp[0] != result[0]",                                                                 ["ValidateRemainingResults"] = "(firstOp[0] != result[i])"}),  
+    ("GenericUnOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Sse",  ["Method"] = "BroadcastScalarToVector256",  ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single",                                                                                                                                           ["VectorSize"] = "32", ["NextValueOp1"] = "(float)(random.NextDouble())",                                                                                                                                                               ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(firstOp[0]) != BitConverter.SingleToInt32Bits(result[0])", ["ValidateRemainingResults"] = "(BitConverter.SingleToInt32Bits(firstOp[0]) != BitConverter.SingleToInt32Bits(result[i]))"}),    
+    ("GenericUnOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Sse2", ["Method"] = "BroadcastScalarToVector256",  ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double",                                                                                                                                           ["VectorSize"] = "32", ["NextValueOp1"] = "(double)(random.NextDouble())",                                                                                                                                                              ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(firstOp[0]) != BitConverter.DoubleToInt64Bits(result[0])", ["ValidateRemainingResults"] = "(BitConverter.DoubleToInt64Bits(firstOp[0]) != BitConverter.DoubleToInt64Bits(result[i]))"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "CompareEqual",                ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Byte",   ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Byte",   ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Byte",                                                                                ["VectorSize"] = "32", ["NextValueOp1"] = "(byte)(random.Next(0, byte.MaxValue))",                 ["NextValueOp2"] = "(byte)(random.Next(0, byte.MaxValue))",                                                                          ["ValidateFirstResult"] = "result[0] != ((left[0] == right[0]) ? unchecked((byte)(-1)) : 0)",                        ["ValidateRemainingResults"] = "result[i] != ((left[i] == right[i]) ? unchecked((byte)(-1)) : 0)"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "CompareEqual",                ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int16",  ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Int16",                                                                               ["VectorSize"] = "32", ["NextValueOp1"] = "(short)(random.Next(short.MinValue, short.MaxValue))",  ["NextValueOp2"] = "(short)(random.Next(short.MinValue, short.MaxValue))",                                                           ["ValidateFirstResult"] = "result[0] != ((left[0] == right[0]) ? unchecked((short)(-1)) : 0)",                       ["ValidateRemainingResults"] = "result[i] != ((left[i] == right[i]) ? unchecked((short)(-1)) : 0)"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "CompareEqual",                ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int32",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int32",  ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Int32",                                                                               ["VectorSize"] = "32", ["NextValueOp1"] = "(int)(random.Next(int.MinValue, int.MaxValue))",        ["NextValueOp2"] = "(int)(random.Next(int.MinValue, int.MaxValue))",                                                                 ["ValidateFirstResult"] = "result[0] != ((left[0] == right[0]) ? unchecked((int)(-1)) : 0)",                         ["ValidateRemainingResults"] = "result[i] != ((left[i] == right[i]) ? unchecked((int)(-1)) : 0)"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "CompareEqual",                ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int64",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int64",  ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Int64",                                                                               ["VectorSize"] = "32", ["NextValueOp1"] = "(long)(random.Next(int.MinValue, int.MaxValue))",       ["NextValueOp2"] = "(long)(random.Next(int.MinValue, int.MaxValue))",                                                                ["ValidateFirstResult"] = "result[0] != ((left[0] == right[0]) ? unchecked((long)(-1)) : 0)",                        ["ValidateRemainingResults"] = "result[i] != ((left[i] == right[i]) ? unchecked((long)(-1)) : 0)"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "CompareEqual",                ["RetVectorType"] = "Vector256", ["RetBaseType"] = "SByte",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "SByte",  ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "SByte",                                                                               ["VectorSize"] = "32", ["NextValueOp1"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",  ["NextValueOp2"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",                                                           ["ValidateFirstResult"] = "result[0] != ((left[0] == right[0]) ? unchecked((sbyte)(-1)) : 0)",                       ["ValidateRemainingResults"] = "result[i] != ((left[i] == right[i]) ? unchecked((sbyte)(-1)) : 0)"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "CompareEqual",                ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "UInt16",                                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(ushort)(random.Next(0, ushort.MaxValue))",             ["NextValueOp2"] = "(ushort)(random.Next(0, ushort.MaxValue))",                                                                      ["ValidateFirstResult"] = "result[0] != ((left[0] == right[0]) ? unchecked((ushort)(-1)) : 0)",                      ["ValidateRemainingResults"] = "result[i] != ((left[i] == right[i]) ? unchecked((ushort)(-1)) : 0)"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "CompareEqual",                ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "UInt32",                                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(uint)(random.Next(0, int.MaxValue))",                  ["NextValueOp2"] = "(uint)(random.Next(0, int.MaxValue))",                                                                           ["ValidateFirstResult"] = "result[0] != ((left[0] == right[0]) ? unchecked((uint)(-1)) : 0)",                        ["ValidateRemainingResults"] = "result[i] != ((left[i] == right[i]) ? unchecked((uint)(-1)) : 0)"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "CompareEqual",                ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "UInt64",                                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(ulong)(random.Next(0, int.MaxValue))",                 ["NextValueOp2"] = "(ulong)(random.Next(0, int.MaxValue))",                                                                          ["ValidateFirstResult"] = "result[0] != ((left[0] == right[0]) ? unchecked((ulong)(-1)) : 0)",                       ["ValidateRemainingResults"] = "result[i] != ((left[i] == right[i]) ? unchecked((ulong)(-1)) : 0)"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "CompareGreaterThan",          ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int16",  ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Int16",                                                                               ["VectorSize"] = "32", ["NextValueOp1"] = "(short)(random.Next(short.MinValue, short.MaxValue))",  ["NextValueOp2"] = "(short)(random.Next(short.MinValue, short.MaxValue))",                                                           ["ValidateFirstResult"] = "result[0] != ((left[0] > right[0]) ? unchecked((short)(-1)) : 0)",                        ["ValidateRemainingResults"] = "result[i] != ((left[i] > right[i]) ? unchecked((short)(-1)) : 0)"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "CompareGreaterThan",          ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int32",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int32",  ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Int32",                                                                               ["VectorSize"] = "32", ["NextValueOp1"] = "(int)(random.Next(int.MinValue, int.MaxValue))",        ["NextValueOp2"] = "(int)(random.Next(int.MinValue, int.MaxValue))",                                                                 ["ValidateFirstResult"] = "result[0] != ((left[0] > right[0]) ? unchecked((int)(-1)) : 0)",                          ["ValidateRemainingResults"] = "result[i] != ((left[i] > right[i]) ? unchecked((int)(-1)) : 0)"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "CompareGreaterThan",          ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int64",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int64",  ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Int64",                                                                               ["VectorSize"] = "32", ["NextValueOp1"] = "(long)(random.Next(int.MinValue, int.MaxValue))",       ["NextValueOp2"] = "(long)(random.Next(int.MinValue, int.MaxValue))",                                                                ["ValidateFirstResult"] = "result[0] != ((left[0] > right[0]) ? unchecked((long)(-1)) : 0)",                         ["ValidateRemainingResults"] = "result[i] != ((left[i] > right[i]) ? unchecked((long)(-1)) : 0)"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "CompareGreaterThan",          ["RetVectorType"] = "Vector256", ["RetBaseType"] = "SByte",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "SByte",  ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "SByte",                                                                               ["VectorSize"] = "32", ["NextValueOp1"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",  ["NextValueOp2"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",                                                           ["ValidateFirstResult"] = "result[0] != ((left[0] > right[0]) ? unchecked((sbyte)(-1)) : 0)",                        ["ValidateRemainingResults"] = "result[i] != ((left[i] > right[i]) ? unchecked((sbyte)(-1)) : 0)"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "Or",                          ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Byte",   ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Byte",   ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Byte",                                                                                ["VectorSize"] = "32", ["NextValueOp1"] = "(byte)(random.Next(0, byte.MaxValue))",                 ["NextValueOp2"] = "(byte)(random.Next(0, byte.MaxValue))",                                                                          ["ValidateFirstResult"] = "(byte)(left[0] | right[0]) != result[0]",                                                 ["ValidateRemainingResults"] = "(byte)(left[i] | right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "Or",                          ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int16",  ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Int16",                                                                               ["VectorSize"] = "32", ["NextValueOp1"] = "(short)(random.Next(short.MinValue, short.MaxValue))",  ["NextValueOp2"] = "(short)(random.Next(short.MinValue, short.MaxValue))",                                                           ["ValidateFirstResult"] = "(short)(left[0] | right[0]) != result[0]",                                                ["ValidateRemainingResults"] = "(short)(left[i] | right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "Or",                          ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int32",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int32",  ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Int32",                                                                               ["VectorSize"] = "32", ["NextValueOp1"] = "(int)(random.Next(int.MinValue, int.MaxValue))",        ["NextValueOp2"] = "(int)(random.Next(int.MinValue, int.MaxValue))",                                                                 ["ValidateFirstResult"] = "(int)(left[0] | right[0]) != result[0]",                                                  ["ValidateRemainingResults"] = "(int)(left[i] | right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "Or",                          ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int64",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int64",  ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Int64",                                                                               ["VectorSize"] = "32", ["NextValueOp1"] = "(long)(random.Next(int.MinValue, int.MaxValue))",       ["NextValueOp2"] = "(long)(random.Next(int.MinValue, int.MaxValue))",                                                                ["ValidateFirstResult"] = "(long)(left[0] | right[0]) != result[0]",                                                 ["ValidateRemainingResults"] = "(long)(left[i] | right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "Or",                          ["RetVectorType"] = "Vector256", ["RetBaseType"] = "SByte",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "SByte",  ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "SByte",                                                                               ["VectorSize"] = "32", ["NextValueOp1"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",  ["NextValueOp2"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",                                                           ["ValidateFirstResult"] = "(sbyte)(left[0] | right[0]) != result[0]",                                                ["ValidateRemainingResults"] = "(sbyte)(left[i] | right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "Or",                          ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "UInt16",                                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(ushort)(random.Next(0, ushort.MaxValue))",             ["NextValueOp2"] = "(ushort)(random.Next(0, ushort.MaxValue))",                                                                      ["ValidateFirstResult"] = "(ushort)(left[0] | right[0]) != result[0]",                                               ["ValidateRemainingResults"] = "(ushort)(left[i] | right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "Or",                          ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "UInt32",                                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(uint)(random.Next(0, int.MaxValue))",                  ["NextValueOp2"] = "(uint)(random.Next(0, int.MaxValue))",                                                                           ["ValidateFirstResult"] = "(uint)(left[0] | right[0]) != result[0]",                                                 ["ValidateRemainingResults"] = "(uint)(left[i] | right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "Or",                          ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "UInt64",                                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(ulong)(random.Next(0, int.MaxValue))",                 ["NextValueOp2"] = "(ulong)(random.Next(0, int.MaxValue))",                                                                          ["ValidateFirstResult"] = "(ulong)(left[0] | right[0]) != result[0]",                                                ["ValidateRemainingResults"] = "(ulong)(left[i] | right[i]) != result[i]"}),
+    ("ImmUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "ShiftLeftLogical",            ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int16",                                                                                                                           ["Imm"] = "1",   ["VectorSize"] = "32", ["NextValueOp1"] = "(short)(random.Next(0, short.MaxValue))",                                                                                                                                                    ["ValidateFirstResult"] = "(short)(firstOp[0] << 1) != result[0]",                                                   ["ValidateRemainingResults"] = "(short)(firstOp[i] << 1) != result[i]"}),
+    ("ImmUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "ShiftLeftLogical",            ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt16",                                                                                                                          ["Imm"] = "1",   ["VectorSize"] = "32", ["NextValueOp1"] = "(ushort)(random.Next(0, ushort.MaxValue))",                                                                                                                                                  ["ValidateFirstResult"] = "(ushort)(firstOp[0] << 1) != result[0]",                                                  ["ValidateRemainingResults"] = "(ushort)(firstOp[i] << 1) != result[i]"}),
+    ("ImmUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "ShiftLeftLogical",            ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int32",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int32",                                                                                                                           ["Imm"] = "1",   ["VectorSize"] = "32", ["NextValueOp1"] = "(int)(random.Next(0, int.MaxValue))",                                                                                                                                                        ["ValidateFirstResult"] = "(int)(firstOp[0] << 1) != result[0]",                                                     ["ValidateRemainingResults"] = "(int)(firstOp[i] << 1) != result[i]"}),
+    ("ImmUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "ShiftLeftLogical",            ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt32",                                                                                                                          ["Imm"] = "1",   ["VectorSize"] = "32", ["NextValueOp1"] = "(uint)(random.Next(0, int.MaxValue))",                                                                                                                                                       ["ValidateFirstResult"] = "(uint)(firstOp[0] << 1) != result[0]",                                                    ["ValidateRemainingResults"] = "(uint)(firstOp[i] << 1) != result[i]"}),
+    ("ImmUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "ShiftLeftLogical",            ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int64",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int64",                                                                                                                           ["Imm"] = "1",   ["VectorSize"] = "32", ["NextValueOp1"] = "(long)(random.Next(0, int.MaxValue))",                                                                                                                                                       ["ValidateFirstResult"] = "(long)(firstOp[0] << 1) != result[0]",                                                    ["ValidateRemainingResults"] = "(long)(firstOp[i] << 1) != result[i]"}),
+    ("ImmUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "ShiftLeftLogical",            ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt64",                                                                                                                          ["Imm"] = "1",   ["VectorSize"] = "32", ["NextValueOp1"] = "(ulong)(random.Next(0, int.MaxValue))",                                                                                                                                                      ["ValidateFirstResult"] = "(ulong)(firstOp[0] << 1) != result[0]",                                                   ["ValidateRemainingResults"] = "(ulong)(firstOp[i] << 1) != result[i]"}),
+    ("ImmUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "ShiftLeftLogical",            ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int16",                                                                                                                           ["Imm"] = "16",  ["VectorSize"] = "32", ["NextValueOp1"] = "(short)(random.Next(0, short.MaxValue))",                                                                                                                                                    ["ValidateFirstResult"] = "0 != result[0]",                                                                          ["ValidateRemainingResults"] = "0 != result[i]"}),
+    ("ImmUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "ShiftLeftLogical",            ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt16",                                                                                                                          ["Imm"] = "16",  ["VectorSize"] = "32", ["NextValueOp1"] = "(ushort)(random.Next(0, ushort.MaxValue))",                                                                                                                                                  ["ValidateFirstResult"] = "0 != result[0]",                                                                          ["ValidateRemainingResults"] = "0 != result[i]"}),
+    ("ImmUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "ShiftLeftLogical",            ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int32",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int32",                                                                                                                           ["Imm"] = "32",  ["VectorSize"] = "32", ["NextValueOp1"] = "(int)(random.Next(0, int.MaxValue))",                                                                                                                                                        ["ValidateFirstResult"] = "0 != result[0]",                                                                          ["ValidateRemainingResults"] = "0 != result[i]"}),
+    ("ImmUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "ShiftLeftLogical",            ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt32",                                                                                                                          ["Imm"] = "32",  ["VectorSize"] = "32", ["NextValueOp1"] = "(uint)(random.Next(0, int.MaxValue))",                                                                                                                                                       ["ValidateFirstResult"] = "0 != result[0]",                                                                          ["ValidateRemainingResults"] = "0!= result[i]"}),
+    ("ImmUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "ShiftLeftLogical",            ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int64",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int64",                                                                                                                           ["Imm"] = "64",  ["VectorSize"] = "32", ["NextValueOp1"] = "(long)(random.Next(0, int.MaxValue))",                                                                                                                                                       ["ValidateFirstResult"] = "0 != result[0]",                                                                          ["ValidateRemainingResults"] = "0 != result[i]"}),
+    ("ImmUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "ShiftLeftLogical",            ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt64",                                                                                                                          ["Imm"] = "64",  ["VectorSize"] = "32", ["NextValueOp1"] = "(ulong)(random.Next(0, int.MaxValue))",                                                                                                                                                      ["ValidateFirstResult"] = "0 != result[0]",                                                                          ["ValidateRemainingResults"] = "0 != result[i]"}),
+    ("ImmUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "ShiftLeftLogical128BitLane",  ["RetVectorType"] = "Vector256", ["RetBaseType"] = "SByte",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "SByte",                                                                                                                           ["Imm"] = "1",   ["VectorSize"] = "32", ["NextValueOp1"] = "(sbyte)8",                                                                                                                                                                                   ["ValidateFirstResult"] = "result[0] != 0",                                                                          ["ValidateRemainingResults"] = "(i == 16 ? result[i] != 0 : result[i] != 8)"}),
+    ("ImmUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "ShiftLeftLogical128BitLane",  ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Byte",   ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Byte",                                                                                                                            ["Imm"] = "1",   ["VectorSize"] = "32", ["NextValueOp1"] = "(byte)8",                                                                                                                                                                                    ["ValidateFirstResult"] = "result[0] != 0",                                                                          ["ValidateRemainingResults"] = "(i == 16 ? result[i] != 0 : result[i] != 8)"}),
+    ("ImmUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "ShiftLeftLogical128BitLane",  ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int16",                                                                                                                           ["Imm"] = "1",   ["VectorSize"] = "32", ["NextValueOp1"] = "(short)8",                                                                                                                                                                                   ["ValidateFirstResult"] = "result[0] != 2048",                                                                       ["ValidateRemainingResults"] = "result[i] != 2048"}),
+    ("ImmUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "ShiftLeftLogical128BitLane",  ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt16",                                                                                                                          ["Imm"] = "1",   ["VectorSize"] = "32", ["NextValueOp1"] = "(ushort)8",                                                                                                                                                                                  ["ValidateFirstResult"] = "result[0] != 2048",                                                                       ["ValidateRemainingResults"] = "result[i] != 2048"}),
+    ("ImmUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "ShiftLeftLogical128BitLane",  ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int32",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int32",                                                                                                                           ["Imm"] = "1",   ["VectorSize"] = "32", ["NextValueOp1"] = "(int)8",                                                                                                                                                                                     ["ValidateFirstResult"] = "result[0] != 2048",                                                                       ["ValidateRemainingResults"] = "result[i] != 2048"}),
+    ("ImmUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "ShiftLeftLogical128BitLane",  ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt32",                                                                                                                          ["Imm"] = "1",   ["VectorSize"] = "32", ["NextValueOp1"] = "(uint)8",                                                                                                                                                                                    ["ValidateFirstResult"] = "result[0] != 2048",                                                                       ["ValidateRemainingResults"] = "result[i] != 2048"}),
+    ("ImmUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "ShiftLeftLogical128BitLane",  ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int64",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int64",                                                                                                                           ["Imm"] = "1",   ["VectorSize"] = "32", ["NextValueOp1"] = "(long)8",                                                                                                                                                                                    ["ValidateFirstResult"] = "result[0] != 2048",                                                                       ["ValidateRemainingResults"] = "result[i] != 2048"}),
+    ("ImmUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "ShiftLeftLogical128BitLane",  ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt64",                                                                                                                          ["Imm"] = "1",   ["VectorSize"] = "32", ["NextValueOp1"] = "(ulong)8",                                                                                                                                                                                   ["ValidateFirstResult"] = "result[0] != 2048",                                                                       ["ValidateRemainingResults"] = "result[i] != 2048"}),
+    ("ImmUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "ShiftRightArithmetic",        ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int16",                                                                                                                           ["Imm"] = "1",   ["VectorSize"] = "32", ["NextValueOp1"] = "(short)(random.Next(0, short.MaxValue))",                                                                                                                                                    ["ValidateFirstResult"] = "(short)(firstOp[0] >> 1) != result[0]",                                                   ["ValidateRemainingResults"] = "(short)(firstOp[i] >> 1) != result[i]"}),
+    ("ImmUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "ShiftRightArithmetic",        ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int32",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int32",                                                                                                                           ["Imm"] = "1",   ["VectorSize"] = "32", ["NextValueOp1"] = "(int)(random.Next(0, int.MaxValue))",                                                                                                                                                        ["ValidateFirstResult"] = "(int)(firstOp[0] >> 1) != result[0]",                                                     ["ValidateRemainingResults"] = "(int)(firstOp[i] >> 1) != result[i]"}),
+    ("ImmUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "ShiftRightArithmetic",        ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int16",                                                                                                                           ["Imm"] = "16",  ["VectorSize"] = "32", ["NextValueOp1"] = "(short)(random.Next(0, short.MaxValue))",                                                                                                                                                    ["ValidateFirstResult"] = "(short)(firstOp[0] >> 15) != result[0]",                                                  ["ValidateRemainingResults"] = "(short)(firstOp[i] >> 15) != result[i]"}),
+    ("ImmUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "ShiftRightArithmetic",        ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int32",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int32",                                                                                                                           ["Imm"] = "32",  ["VectorSize"] = "32", ["NextValueOp1"] = "(int)(random.Next(0, int.MaxValue))",                                                                                                                                                        ["ValidateFirstResult"] = "(int)(firstOp[0] >> 31) != result[0]",                                                    ["ValidateRemainingResults"] = "(int)(firstOp[i] >> 31) != result[i]"}),
+    ("ImmUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "ShiftRightLogical",           ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int16",                                                                                                                           ["Imm"] = "1",   ["VectorSize"] = "32", ["NextValueOp1"] = "(short)(random.Next(0, short.MaxValue))",                                                                                                                                                    ["ValidateFirstResult"] = "(short)(firstOp[0] >> 1) != result[0]",                                                   ["ValidateRemainingResults"] = "(short)(firstOp[i] >> 1) != result[i]"}),
+    ("ImmUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "ShiftRightLogical",           ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt16",                                                                                                                          ["Imm"] = "1",   ["VectorSize"] = "32", ["NextValueOp1"] = "(ushort)(random.Next(0, ushort.MaxValue))",                                                                                                                                                  ["ValidateFirstResult"] = "(ushort)(firstOp[0] >> 1) != result[0]",                                                  ["ValidateRemainingResults"] = "(ushort)(firstOp[i] >> 1) != result[i]"}),
+    ("ImmUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "ShiftRightLogical",           ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int32",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int32",                                                                                                                           ["Imm"] = "1",   ["VectorSize"] = "32", ["NextValueOp1"] = "(int)(random.Next(0, int.MaxValue))",                                                                                                                                                        ["ValidateFirstResult"] = "(int)(firstOp[0] >> 1) != result[0]",                                                     ["ValidateRemainingResults"] = "(int)(firstOp[i] >> 1) != result[i]"}),
+    ("ImmUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "ShiftRightLogical",           ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt32",                                                                                                                          ["Imm"] = "1",   ["VectorSize"] = "32", ["NextValueOp1"] = "(uint)(random.Next(0, int.MaxValue))",                                                                                                                                                       ["ValidateFirstResult"] = "(uint)(firstOp[0] >> 1) != result[0]",                                                    ["ValidateRemainingResults"] = "(uint)(firstOp[i] >> 1) != result[i]"}),
+    ("ImmUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "ShiftRightLogical",           ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int64",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int64",                                                                                                                           ["Imm"] = "1",   ["VectorSize"] = "32", ["NextValueOp1"] = "(long)(random.Next(0, int.MaxValue))",                                                                                                                                                       ["ValidateFirstResult"] = "(long)(firstOp[0] >> 1) != result[0]",                                                    ["ValidateRemainingResults"] = "(long)(firstOp[i] >> 1) != result[i]"}),
+    ("ImmUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "ShiftRightLogical",           ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt64",                                                                                                                          ["Imm"] = "1",   ["VectorSize"] = "32", ["NextValueOp1"] = "(ulong)(random.Next(0, int.MaxValue))",                                                                                                                                                      ["ValidateFirstResult"] = "(ulong)(firstOp[0] >> 1) != result[0]",                                                   ["ValidateRemainingResults"] = "(ulong)(firstOp[i] >> 1) != result[i]"}),
+    ("ImmUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "ShiftRightLogical",           ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int16",                                                                                                                           ["Imm"] = "16",  ["VectorSize"] = "32", ["NextValueOp1"] = "(short)(random.Next(0, short.MaxValue))",                                                                                                                                                    ["ValidateFirstResult"] = "0 != result[0]",                                                                          ["ValidateRemainingResults"] = "0 != result[i]"}),
+    ("ImmUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "ShiftRightLogical",           ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt16",                                                                                                                          ["Imm"] = "16",  ["VectorSize"] = "32", ["NextValueOp1"] = "(ushort)(random.Next(0, ushort.MaxValue))",                                                                                                                                                  ["ValidateFirstResult"] = "0 != result[0]",                                                                          ["ValidateRemainingResults"] = "0 != result[i]"}),
+    ("ImmUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "ShiftRightLogical",           ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int32",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int32",                                                                                                                           ["Imm"] = "32",  ["VectorSize"] = "32", ["NextValueOp1"] = "(int)(random.Next(0, int.MaxValue))",                                                                                                                                                        ["ValidateFirstResult"] = "0 != result[0]",                                                                          ["ValidateRemainingResults"] = "0 != result[i]"}),
+    ("ImmUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "ShiftRightLogical",           ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt32",                                                                                                                          ["Imm"] = "32",  ["VectorSize"] = "32", ["NextValueOp1"] = "(uint)(random.Next(0, int.MaxValue))",                                                                                                                                                       ["ValidateFirstResult"] = "0 != result[0]",                                                                          ["ValidateRemainingResults"] = "0!= result[i]"}),
+    ("ImmUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "ShiftRightLogical",           ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int64",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int64",                                                                                                                           ["Imm"] = "64",  ["VectorSize"] = "32", ["NextValueOp1"] = "(long)(random.Next(0, int.MaxValue))",                                                                                                                                                       ["ValidateFirstResult"] = "0 != result[0]",                                                                          ["ValidateRemainingResults"] = "0 != result[i]"}),
+    ("ImmUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "ShiftRightLogical",           ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt64",                                                                                                                          ["Imm"] = "64",  ["VectorSize"] = "32", ["NextValueOp1"] = "(ulong)(random.Next(0, int.MaxValue))",                                                                                                                                                      ["ValidateFirstResult"] = "0 != result[0]",                                                                          ["ValidateRemainingResults"] = "0 != result[i]"}),
+    ("ImmUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "ShiftRightLogical128BitLane", ["RetVectorType"] = "Vector256", ["RetBaseType"] = "SByte",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "SByte",                                                                                                                           ["Imm"] = "1",   ["VectorSize"] = "32", ["NextValueOp1"] = "(sbyte)8",                                                                                                                                                                                   ["ValidateFirstResult"] = "result[0] != 8",                                                                          ["ValidateRemainingResults"] = "(i == 31 || i == 15 ? result[i] != 0 : result[i] != 8)"}),
+    ("ImmUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "ShiftRightLogical128BitLane", ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Byte",   ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Byte",                                                                                                                            ["Imm"] = "1",   ["VectorSize"] = "32", ["NextValueOp1"] = "(byte)8",                                                                                                                                                                                    ["ValidateFirstResult"] = "result[0] != 8",                                                                          ["ValidateRemainingResults"] = "(i == 31 || i == 15 ? result[i] != 0 : result[i] != 8)"}),
+    ("ImmUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "ShiftRightLogical128BitLane", ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int16",                                                                                                                           ["Imm"] = "1",   ["VectorSize"] = "32", ["NextValueOp1"] = "(short)8",                                                                                                                                                                                   ["ValidateFirstResult"] = "result[0] != 2048",                                                                       ["ValidateRemainingResults"] = "(i == 7 || i == 15 ? result[i] != 0 : result[i] != 2048)"}),
+    ("ImmUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "ShiftRightLogical128BitLane", ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt16",                                                                                                                          ["Imm"] = "1",   ["VectorSize"] = "32", ["NextValueOp1"] = "(ushort)8",                                                                                                                                                                                  ["ValidateFirstResult"] = "result[0] != 2048",                                                                       ["ValidateRemainingResults"] = "(i == 7 || i == 15 ? result[i] != 0 : result[i] != 2048)"}),
+    ("ImmUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "ShiftRightLogical128BitLane", ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int32",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int32",                                                                                                                           ["Imm"] = "1",   ["VectorSize"] = "32", ["NextValueOp1"] = "(int)8",                                                                                                                                                                                     ["ValidateFirstResult"] = "result[0] != 134217728",                                                                  ["ValidateRemainingResults"] = "(i == 3 || i == 7 ? result[i] != 0 : result[i] != 134217728)"}),
+    ("ImmUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "ShiftRightLogical128BitLane", ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt32",                                                                                                                          ["Imm"] = "1",   ["VectorSize"] = "32", ["NextValueOp1"] = "(uint)8",                                                                                                                                                                                    ["ValidateFirstResult"] = "result[0] != 134217728",                                                                  ["ValidateRemainingResults"] = "(i == 3 || i == 7 ? result[i] != 0 : result[i] != 134217728)"}),
+    ("ImmUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "ShiftRightLogical128BitLane", ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int64",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int64",                                                                                                                           ["Imm"] = "1",   ["VectorSize"] = "32", ["NextValueOp1"] = "(long)8",                                                                                                                                                                                    ["ValidateFirstResult"] = "result[0] != 576460752303423488L",                                                        ["ValidateRemainingResults"] = "(i == 2 ? result[i] != 576460752303423488L : result[i] != 0)"}),
+    ("ImmUnOpTest.template",      new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "ShiftRightLogical128BitLane", ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt64",                                                                                                                          ["Imm"] = "1",   ["VectorSize"] = "32", ["NextValueOp1"] = "(ulong)8",                                                                                                                                                                                   ["ValidateFirstResult"] = "result[0] != 576460752303423488UL",                                                       ["ValidateRemainingResults"] = "(i == 2 ? result[i] != 576460752303423488UL : result[i] != 0)"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "Subtract",                    ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Byte",   ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Byte",   ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Byte",                                                                                ["VectorSize"] = "32", ["NextValueOp1"] = "(byte)(random.Next(0, byte.MaxValue))",                 ["NextValueOp2"] = "(byte)(random.Next(0, byte.MaxValue))",                                                                          ["ValidateFirstResult"] = "(byte)(left[0] - right[0]) != result[0]",                                                 ["ValidateRemainingResults"] = "(byte)(left[i] - right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "Subtract",                    ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int16",  ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Int16",                                                                               ["VectorSize"] = "32", ["NextValueOp1"] = "(short)(random.Next(short.MinValue, short.MaxValue))",  ["NextValueOp2"] = "(short)(random.Next(short.MinValue, short.MaxValue))",                                                           ["ValidateFirstResult"] = "(short)(left[0] - right[0]) != result[0]",                                                ["ValidateRemainingResults"] = "(short)(left[i] - right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "Subtract",                    ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int32",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int32",  ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Int32",                                                                               ["VectorSize"] = "32", ["NextValueOp1"] = "(int)(random.Next(int.MinValue, int.MaxValue))",        ["NextValueOp2"] = "(int)(random.Next(int.MinValue, int.MaxValue))",                                                                 ["ValidateFirstResult"] = "(int)(left[0] - right[0]) != result[0]",                                                  ["ValidateRemainingResults"] = "(int)(left[i] - right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "Subtract",                    ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int64",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int64",  ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Int64",                                                                               ["VectorSize"] = "32", ["NextValueOp1"] = "(long)(random.Next(int.MinValue, int.MaxValue))",       ["NextValueOp2"] = "(long)(random.Next(int.MinValue, int.MaxValue))",                                                                ["ValidateFirstResult"] = "(long)(left[0] - right[0]) != result[0]",                                                 ["ValidateRemainingResults"] = "(long)(left[i] - right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "Subtract",                    ["RetVectorType"] = "Vector256", ["RetBaseType"] = "SByte",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "SByte",  ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "SByte",                                                                               ["VectorSize"] = "32", ["NextValueOp1"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",  ["NextValueOp2"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",                                                           ["ValidateFirstResult"] = "(sbyte)(left[0] - right[0]) != result[0]",                                                ["ValidateRemainingResults"] = "(sbyte)(left[i] - right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "Subtract",                    ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "UInt16",                                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(ushort)(random.Next(0, ushort.MaxValue))",             ["NextValueOp2"] = "(ushort)(random.Next(0, ushort.MaxValue))",                                                                      ["ValidateFirstResult"] = "(ushort)(left[0] - right[0]) != result[0]",                                               ["ValidateRemainingResults"] = "(ushort)(left[i] - right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "Subtract",                    ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "UInt32",                                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(uint)(random.Next(0, int.MaxValue))",                  ["NextValueOp2"] = "(uint)(random.Next(0, int.MaxValue))",                                                                           ["ValidateFirstResult"] = "(uint)(left[0] - right[0]) != result[0]",                                                 ["ValidateRemainingResults"] = "(uint)(left[i] - right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "Subtract",                    ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "UInt64",                                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(ulong)(random.Next(0, int.MaxValue))",                 ["NextValueOp2"] = "(ulong)(random.Next(0, int.MaxValue))",                                                                          ["ValidateFirstResult"] = "(ulong)(left[0] - right[0]) != result[0]",                                                ["ValidateRemainingResults"] = "(ulong)(left[i] - right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "Xor",                         ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Byte",   ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Byte",   ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Byte",                                                                                ["VectorSize"] = "32", ["NextValueOp1"] = "(byte)(random.Next(0, byte.MaxValue))",                 ["NextValueOp2"] = "(byte)(random.Next(0, byte.MaxValue))",                                                                          ["ValidateFirstResult"] = "(byte)(left[0] ^ right[0]) != result[0]",                                                 ["ValidateRemainingResults"] = "(byte)(left[i] ^ right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "Xor",                         ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int16",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int16",  ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Int16",                                                                               ["VectorSize"] = "32", ["NextValueOp1"] = "(short)(random.Next(short.MinValue, short.MaxValue))",  ["NextValueOp2"] = "(short)(random.Next(short.MinValue, short.MaxValue))",                                                           ["ValidateFirstResult"] = "(short)(left[0] ^ right[0]) != result[0]",                                                ["ValidateRemainingResults"] = "(short)(left[i] ^ right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "Xor",                         ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int32",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int32",  ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Int32",                                                                               ["VectorSize"] = "32", ["NextValueOp1"] = "(int)(random.Next(int.MinValue, int.MaxValue))",        ["NextValueOp2"] = "(int)(random.Next(int.MinValue, int.MaxValue))",                                                                 ["ValidateFirstResult"] = "(int)(left[0] ^ right[0]) != result[0]",                                                  ["ValidateRemainingResults"] = "(int)(left[i] ^ right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "Xor",                         ["RetVectorType"] = "Vector256", ["RetBaseType"] = "Int64",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "Int64",  ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "Int64",                                                                               ["VectorSize"] = "32", ["NextValueOp1"] = "(long)(random.Next(int.MinValue, int.MaxValue))",       ["NextValueOp2"] = "(long)(random.Next(int.MinValue, int.MaxValue))",                                                                ["ValidateFirstResult"] = "(long)(left[0] ^ right[0]) != result[0]",                                                 ["ValidateRemainingResults"] = "(long)(left[i] ^ right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "Xor",                         ["RetVectorType"] = "Vector256", ["RetBaseType"] = "SByte",  ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "SByte",  ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "SByte",                                                                               ["VectorSize"] = "32", ["NextValueOp1"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",  ["NextValueOp2"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))",                                                           ["ValidateFirstResult"] = "(sbyte)(left[0] ^ right[0]) != result[0]",                                                ["ValidateRemainingResults"] = "(sbyte)(left[i] ^ right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "Xor",                         ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "UInt16",                                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(ushort)(random.Next(0, ushort.MaxValue))",             ["NextValueOp2"] = "(ushort)(random.Next(0, ushort.MaxValue))",                                                                      ["ValidateFirstResult"] = "(ushort)(left[0] ^ right[0]) != result[0]",                                               ["ValidateRemainingResults"] = "(ushort)(left[i] ^ right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "Xor",                         ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "UInt32",                                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(uint)(random.Next(0, int.MaxValue))",                  ["NextValueOp2"] = "(uint)(random.Next(0, int.MaxValue))",                                                                           ["ValidateFirstResult"] = "(uint)(left[0] ^ right[0]) != result[0]",                                                 ["ValidateRemainingResults"] = "(uint)(left[i] ^ right[i]) != result[i]"}),
+    ("SimpleBinOpTest.template",  new Dictionary<string, string> { ["Isa"] = "Avx2", ["LoadIsa"] = "Avx",  ["Method"] = "Xor",                         ["RetVectorType"] = "Vector256", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector256", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector256", ["Op2BaseType"] = "UInt64",                                                                              ["VectorSize"] = "32", ["NextValueOp1"] = "(ulong)(random.Next(0, int.MaxValue))",                 ["NextValueOp2"] = "(ulong)(random.Next(0, int.MaxValue))",                                                                          ["ValidateFirstResult"] = "(ulong)(left[0] ^ right[0]) != result[0]",                                                ["ValidateRemainingResults"] = "(ulong)(left[i] ^ right[i]) != result[i]"}),
 };
 
-private static void ProcessInputs(string isa, (string templateFileName, string[] templateData)[] inputs)
+private static void ProcessInputs(string isa, (string templateFileName, Dictionary<string, string> templateData)[] inputs)
 {
     var testListFileName = Path.Combine("..", isa, $"Program.{isa}.cs");
 
@@ -635,24 +615,24 @@ private static bool isImmTemplate(string name)
            name == "ExtractScalarTest.template";
 }
 
-private static void ProcessInput(StreamWriter testListFile, (string templateFileName, string[] templateData) input)
+private static void ProcessInput(StreamWriter testListFile, (string templateFileName, Dictionary<string, string> templateData) input)
 {
-    var testName = $"{input.templateData[2]}.{input.templateData[4]}";
+    var testName = $"{input.templateData["Method"]}.{input.templateData["RetBaseType"]}";
 
     if (isImmTemplate(input.templateFileName))
     {
-        testName += $".{input.templateData[7]}";
+        testName += $".{input.templateData["Imm"]}";
     }
 
     // Ex: ["Add.Single"] = AddSingle
-    testListFile.WriteLine($@"                [""{testName}""] = {input.templateData[2]}{input.templateData[4]}{(isImmTemplate(input.templateFileName) ? input.templateData[7] : "")},");
+    testListFile.WriteLine($@"                [""{testName}""] = {input.templateData["Method"]}{input.templateData["RetBaseType"]}{(isImmTemplate(input.templateFileName) ? input.templateData["Imm"] : "")},");
 
-    var testFileName = Path.Combine("..", input.templateData[0], $"{testName}.cs");
+    var testFileName = Path.Combine("..", input.templateData["Isa"], $"{testName}.cs");
     var template = File.ReadAllText(input.templateFileName);
 
-    if (input.templateData.Length != 0)
+    foreach (var kvp in input.templateData)
     {
-        template = string.Format(template, input.templateData);
+        template = template.Replace($"{{{kvp.Key}}}", kvp.Value);
     }
 
     File.WriteAllText(testFileName, template);
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/GenericUnOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/GenericUnOpTest.template
index a1ec142220..3285e506ff 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/GenericUnOpTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/GenericUnOpTest.template
@@ -16,38 +16,38 @@ using System.Runtime.Intrinsics;
 using System.Runtime.Intrinsics.X86;
 
 namespace JIT.HardwareIntrinsics.X86
-{{
+{
     public static partial class Program
-    {{
-        private static void {2}{4}()
-        {{
-            var test = new SimpleUnaryOpTest__{2}{4}();
+    {
+        private static void {Method}{RetBaseType}()
+        {
+            var test = new SimpleUnaryOpTest__{Method}{RetBaseType}();
 
             if (test.IsSupported)
-            {{
+            {
                 // Validates basic functionality works, using Unsafe.Read
                 test.RunBasicScenario_UnsafeRead();
 
-                if ({1}.IsSupported)
-                {{
+                if ({LoadIsa}.IsSupported)
+                {
                     // Validates basic functionality works, using Load
                     test.RunBasicScenario_Load();
 
                     // Validates basic functionality works, using LoadAligned
                     test.RunBasicScenario_LoadAligned();
-                }}
+                }
 
                 // Validates calling via reflection works, using Unsafe.Read
                 test.RunReflectionScenario_UnsafeRead();
 
-                if ({1}.IsSupported)
-                {{
+                if ({LoadIsa}.IsSupported)
+                {
                     // Validates calling via reflection works, using Load
                     test.RunReflectionScenario_Load();
 
                     // Validates calling via reflection works, using LoadAligned
                     test.RunReflectionScenario_LoadAligned();
-                }}
+                }
 
                 // Validates passing a static member works
                 test.RunClsVarScenario();
@@ -55,255 +55,255 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates passing a local works, using Unsafe.Read
                 test.RunLclVarScenario_UnsafeRead();
 
-                if ({1}.IsSupported)
-                {{
+                if ({LoadIsa}.IsSupported)
+                {
                     // Validates passing a local works, using Load
                     test.RunLclVarScenario_Load();
 
                     // Validates passing a local works, using LoadAligned
                     test.RunLclVarScenario_LoadAligned();
-                }}
+                }
 
                 // Validates passing the field of a local works
                 test.RunLclFldScenario();
 
                 // Validates passing an instance member works
                 test.RunFldScenario();
-            }}
+            }
             else
-            {{
+            {
                 // Validates we throw on unsupported hardware
                 test.RunUnsupportedScenario();
-            }}
+            }
 
             if (!test.Succeeded)
-            {{
+            {
                 throw new Exception("One or more scenarios did not complete as expected.");
-            }}
-        }}
-    }}
+            }
+        }
+    }
 
-    public sealed unsafe class SimpleUnaryOpTest__{2}{4}
-    {{
-        private const int VectorSize = {7};
+    public sealed unsafe class SimpleUnaryOpTest__{Method}{RetBaseType}
+    {
+        private const int VectorSize = {VectorSize};
 
-        private const int Op1ElementCount = VectorSize / sizeof({6});
-        private const int RetElementCount = VectorSize / sizeof({4});
+        private const int Op1ElementCount = VectorSize / sizeof({Op1BaseType});
+        private const int RetElementCount = VectorSize / sizeof({RetBaseType});
 
-        private static {6}[] _data = new {6}[Op1ElementCount];
+        private static {Op1BaseType}[] _data = new {Op1BaseType}[Op1ElementCount];
 
-        private static {5}<{6}> _clsVar;
+        private static {Op1VectorType}<{Op1BaseType}> _clsVar;
 
-        private {5}<{6}> _fld;
+        private {Op1VectorType}<{Op1BaseType}> _fld;
 
-        private SimpleUnaryOpTest__DataTable<{4}, {6}> _dataTable;
+        private SimpleUnaryOpTest__DataTable<{RetBaseType}, {Op1BaseType}> _dataTable;
 
-        static SimpleUnaryOpTest__{2}{4}()
-        {{
+        static SimpleUnaryOpTest__{Method}{RetBaseType}()
+        {
             var random = new Random();
 
-            for (var i = 0; i < Op1ElementCount; i++) {{ _data[i] = {8}; }}
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{5}<{6}>, byte>(ref _clsVar), ref Unsafe.As<{6}, byte>(ref _data[0]), VectorSize);
-        }}
+            for (var i = 0; i < Op1ElementCount; i++) { _data[i] = {NextValueOp1}; }
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar), ref Unsafe.As<{Op1BaseType}, byte>(ref _data[0]), VectorSize);
+        }
 
-        public SimpleUnaryOpTest__{2}{4}()
-        {{
+        public SimpleUnaryOpTest__{Method}{RetBaseType}()
+        {
             Succeeded = true;
 
             var random = new Random();
 
-            for (var i = 0; i < Op1ElementCount; i++) {{ _data[i] = {8}; }}
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{5}<{6}>, byte>(ref _fld), ref Unsafe.As<{6}, byte>(ref _data[0]), VectorSize);
+            for (var i = 0; i < Op1ElementCount; i++) { _data[i] = {NextValueOp1}; }
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _fld), ref Unsafe.As<{Op1BaseType}, byte>(ref _data[0]), VectorSize);
 
-            for (var i = 0; i < Op1ElementCount; i++) {{ _data[i] = {8}; }}
-            _dataTable = new SimpleUnaryOpTest__DataTable<{4}, {6}>(_data, new {4}[RetElementCount], VectorSize);
-        }}
+            for (var i = 0; i < Op1ElementCount; i++) { _data[i] = {NextValueOp1}; }
+            _dataTable = new SimpleUnaryOpTest__DataTable<{RetBaseType}, {Op1BaseType}>(_data, new {RetBaseType}[RetElementCount], VectorSize);
+        }
 
-        public bool IsSupported => {0}.IsSupported;
+        public bool IsSupported => {Isa}.IsSupported;
 
-        public bool Succeeded {{ get; set; }}
+        public bool Succeeded { get; set; }
 
         public void RunBasicScenario_UnsafeRead()
-        {{
-            var result = {0}.{2}<{4}>(
-                Unsafe.Read<{5}<{6}>>(_dataTable.inArrayPtr)
+        {
+            var result = {Isa}.{Method}<{RetBaseType}>(
+                Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArrayPtr)
             );
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunBasicScenario_Load()
-        {{
-            var result = {0}.{2}<{4}>(
-                {1}.Load{5}(({6}*)(_dataTable.inArrayPtr))
+        {
+            var result = {Isa}.{Method}<{RetBaseType}>(
+                {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr))
             );
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunBasicScenario_LoadAligned()
-        {{
-            var result = {0}.{2}<{4}>(
-                {1}.LoadAligned{5}(({6}*)(_dataTable.inArrayPtr))
+        {
+            var result = {Isa}.{Method}<{RetBaseType}>(
+                {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr))
             );
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunReflectionScenario_UnsafeRead()
-        {{
-            var result = typeof({0}).GetMethod(nameof({0}.{2}))
-                                     .MakeGenericMethod( new Type[] {{ typeof({6}) }})
-                                     .Invoke(null, new object[] {{
-                                        Unsafe.Read<{5}<{6}>>(_dataTable.inArrayPtr)
-                                     }});
-
-            Unsafe.Write(_dataTable.outArrayPtr, ({3}<{4}>)(result));
+        {
+            var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}))
+                                     .MakeGenericMethod( new Type[] { typeof({Op1BaseType}) })
+                                     .Invoke(null, new object[] {
+                                        Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArrayPtr)
+                                     });
+
+            Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result));
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunReflectionScenario_Load()
-        {{
-            var result = typeof({0}).GetMethod(nameof({0}.{2}))
-                                     .MakeGenericMethod( new Type[] {{ typeof({6}) }})
-                                     .Invoke(null, new object[] {{
-                                        {1}.Load{5}(({6}*)(_dataTable.inArrayPtr))
-                                     }});
-
-            Unsafe.Write(_dataTable.outArrayPtr, ({3}<{4}>)(result));
+        {
+            var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}))
+                                     .MakeGenericMethod( new Type[] { typeof({Op1BaseType}) })
+                                     .Invoke(null, new object[] {
+                                        {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr))
+                                     });
+
+            Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result));
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunReflectionScenario_LoadAligned()
-        {{
-            var result = typeof({0}).GetMethod(nameof({0}.{2}))
-                                     .MakeGenericMethod( new Type[] {{ typeof({6}) }})
-                                     .Invoke(null, new object[] {{
-                                        {1}.LoadAligned{5}(({6}*)(_dataTable.inArrayPtr))
-                                     }});
-
-            Unsafe.Write(_dataTable.outArrayPtr, ({3}<{4}>)(result));
+        {
+            var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}))
+                                     .MakeGenericMethod( new Type[] { typeof({Op1BaseType}) })
+                                     .Invoke(null, new object[] {
+                                        {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr))
+                                     });
+
+            Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result));
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunClsVarScenario()
-        {{
-            var result = {0}.{2}<{4}>(
+        {
+            var result = {Isa}.{Method}<{RetBaseType}>(
                 _clsVar
             );
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(_clsVar, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunLclVarScenario_UnsafeRead()
-        {{
-            var firstOp = Unsafe.Read<{5}<{6}>>(_dataTable.inArrayPtr);
-            var result = {0}.{2}<{4}>(firstOp);
+        {
+            var firstOp = Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArrayPtr);
+            var result = {Isa}.{Method}<{RetBaseType}>(firstOp);
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(firstOp, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunLclVarScenario_Load()
-        {{
-            var firstOp = {1}.Load{5}(({6}*)(_dataTable.inArrayPtr));
-            var result = {0}.{2}<{4}>(firstOp);
+        {
+            var firstOp = {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr));
+            var result = {Isa}.{Method}<{RetBaseType}>(firstOp);
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(firstOp, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunLclVarScenario_LoadAligned()
-        {{
-            var firstOp = {1}.LoadAligned{5}(({6}*)(_dataTable.inArrayPtr));
-            var result = {0}.{2}<{4}>(firstOp);
+        {
+            var firstOp = {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr));
+            var result = {Isa}.{Method}<{RetBaseType}>(firstOp);
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(firstOp, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunLclFldScenario()
-        {{
-            var test = new SimpleUnaryOpTest__{2}{4}();
-            var result = {0}.{2}<{4}>(test._fld);
+        {
+            var test = new SimpleUnaryOpTest__{Method}{RetBaseType}();
+            var result = {Isa}.{Method}<{RetBaseType}>(test._fld);
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(test._fld, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunFldScenario()
-        {{
-            var result = {0}.{2}<{4}>(_fld);
+        {
+            var result = {Isa}.{Method}<{RetBaseType}>(_fld);
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(_fld, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunUnsupportedScenario()
-        {{
+        {
             Succeeded = false;
 
             try
-            {{
+            {
                 RunBasicScenario_UnsafeRead();
-            }}
+            }
             catch (PlatformNotSupportedException)
-            {{
+            {
                 Succeeded = true;
-            }}
-        }}
+            }
+        }
 
-        private void ValidateResult({5}<{6}> firstOp, void* result, [CallerMemberName] string method = "")
-        {{
-            {6}[] inArray = new {6}[Op1ElementCount];
-            {4}[] outArray = new {4}[RetElementCount];
+        private void ValidateResult({Op1VectorType}<{Op1BaseType}> firstOp, void* result, [CallerMemberName] string method = "")
+        {
+            {Op1BaseType}[] inArray = new {Op1BaseType}[Op1ElementCount];
+            {RetBaseType}[] outArray = new {RetBaseType}[RetElementCount];
 
             Unsafe.Write(Unsafe.AsPointer(ref inArray[0]), firstOp);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{4}, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), VectorSize);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{RetBaseType}, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), VectorSize);
 
             ValidateResult(inArray, outArray, method);
-        }}
+        }
 
         private void ValidateResult(void* firstOp, void* result, [CallerMemberName] string method = "")
-        {{
-            {6}[] inArray = new {6}[Op1ElementCount];
-            {4}[] outArray = new {4}[RetElementCount];
+        {
+            {Op1BaseType}[] inArray = new {Op1BaseType}[Op1ElementCount];
+            {RetBaseType}[] outArray = new {RetBaseType}[RetElementCount];
 
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{6}, byte>(ref inArray[0]), ref Unsafe.AsRef<byte>(firstOp), VectorSize);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{4}, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), VectorSize);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1BaseType}, byte>(ref inArray[0]), ref Unsafe.AsRef<byte>(firstOp), VectorSize);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{RetBaseType}, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), VectorSize);
 
             ValidateResult(inArray, outArray, method);
-        }}
+        }
 
-        private void ValidateResult({6}[] firstOp, {4}[] result, [CallerMemberName] string method = "")
-        {{
-            if ({9})
-            {{
+        private void ValidateResult({Op1BaseType}[] firstOp, {RetBaseType}[] result, [CallerMemberName] string method = "")
+        {
+            if ({ValidateFirstResult})
+            {
                 Succeeded = false;
-            }}
+            }
             else
-            {{
+            {
                 for (var i = 1; i < RetElementCount; i++)
-                {{
-                    if ({10})
-                    {{
+                {
+                    if ({ValidateRemainingResults})
+                    {
                         Succeeded = false;
                         break;
-                    }}
-                }}
-            }}
+                    }
+                }
+            }
 
             if (!Succeeded)
-            {{
-                Console.WriteLine($"{{nameof({0})}}.{{nameof({0}.{2})}}<{4}>({5}<{6}>): {{method}} failed:");
-                Console.WriteLine($"  firstOp: ({{string.Join(", ", firstOp)}})");
-                Console.WriteLine($"   result: ({{string.Join(", ", result)}})");
+            {
+                Console.WriteLine($"{nameof({Isa})}.{nameof({Isa}.{Method})}<{RetBaseType}>({Op1VectorType}<{Op1BaseType}>): {method} failed:");
+                Console.WriteLine($"  firstOp: ({string.Join(", ", firstOp)})");
+                Console.WriteLine($"   result: ({string.Join(", ", result)})");
                 Console.WriteLine();
-            }}
-        }}
-    }}
-}}
+            }
+        }
+    }
+}
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/HorizontalBinOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/HorizontalBinOpTest.template
index 08611f7acd..bc05d9b04d 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/HorizontalBinOpTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/HorizontalBinOpTest.template
@@ -16,38 +16,38 @@ using System.Runtime.Intrinsics;
 using System.Runtime.Intrinsics.X86;
 
 namespace JIT.HardwareIntrinsics.X86
-{{
+{
     public static partial class Program
-    {{
-        private static void {2}{4}()
-        {{
-            var test = new HorizontalBinaryOpTest__{2}{4}();
+    {
+        private static void {Method}{RetBaseType}()
+        {
+            var test = new HorizontalBinaryOpTest__{Method}{RetBaseType}();
 
             if (test.IsSupported)
-            {{
+            {
                 // Validates basic functionality works, using Unsafe.Read
                 test.RunBasicScenario_UnsafeRead();
 
-                if ({1}.IsSupported)
-                {{
+                if ({LoadIsa}.IsSupported)
+                {
                     // Validates basic functionality works, using Load
                     test.RunBasicScenario_Load();
 
                     // Validates basic functionality works, using LoadAligned
                     test.RunBasicScenario_LoadAligned();
-                }}
+                }
 
                 // Validates calling via reflection works, using Unsafe.Read
                 test.RunReflectionScenario_UnsafeRead();
 
-                if ({1}.IsSupported)
-                {{
+                if ({LoadIsa}.IsSupported)
+                {
                     // Validates calling via reflection works, using Load
                     test.RunReflectionScenario_Load();
 
                     // Validates calling via reflection works, using LoadAligned
                     test.RunReflectionScenario_LoadAligned();
-                }}
+                }
 
                 // Validates passing a static member works
                 test.RunClsVarScenario();
@@ -55,282 +55,282 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates passing a local works, using Unsafe.Read
                 test.RunLclVarScenario_UnsafeRead();
 
-                if ({1}.IsSupported)
-                {{
+                if ({LoadIsa}.IsSupported)
+                {
                     // Validates passing a local works, using Load
                     test.RunLclVarScenario_Load();
 
                     // Validates passing a local works, using LoadAligned
                     test.RunLclVarScenario_LoadAligned();
-                }}
+                }
 
                 // Validates passing the field of a local works
                 test.RunLclFldScenario();
 
                 // Validates passing an instance member works
                 test.RunFldScenario();
-            }}
+            }
             else
-            {{
+            {
                 // Validates we throw on unsupported hardware
                 test.RunUnsupportedScenario();
-            }}
+            }
 
             if (!test.Succeeded)
-            {{
+            {
                 throw new Exception("One or more scenarios did not complete as expected.");
-            }}
-        }}
-    }}
+            }
+        }
+    }
 
-    public sealed unsafe class HorizontalBinaryOpTest__{2}{4}
-    {{
-        private const int VectorSize = {9};
+    public sealed unsafe class HorizontalBinaryOpTest__{Method}{RetBaseType}
+    {
+        private const int VectorSize = {VectorSize};
 
-        private const int Op1ElementCount = VectorSize / sizeof({6});
-        private const int Op2ElementCount = VectorSize / sizeof({8});
-        private const int RetElementCount = VectorSize / sizeof({4});
+        private const int Op1ElementCount = VectorSize / sizeof({Op1BaseType});
+        private const int Op2ElementCount = VectorSize / sizeof({Op2BaseType});
+        private const int RetElementCount = VectorSize / sizeof({RetBaseType});
 
-        private static {6}[] _data1 = new {6}[Op1ElementCount];
-        private static {8}[] _data2 = new {8}[Op2ElementCount];
+        private static {Op1BaseType}[] _data1 = new {Op1BaseType}[Op1ElementCount];
+        private static {Op2BaseType}[] _data2 = new {Op2BaseType}[Op2ElementCount];
 
-        private static {5}<{6}> _clsVar1;
-        private static {7}<{8}> _clsVar2;
+        private static {Op1VectorType}<{Op1BaseType}> _clsVar1;
+        private static {Op2VectorType}<{Op2BaseType}> _clsVar2;
 
-        private {5}<{6}> _fld1;
-        private {7}<{8}> _fld2;
+        private {Op1VectorType}<{Op1BaseType}> _fld1;
+        private {Op2VectorType}<{Op2BaseType}> _fld2;
 
-        private HorizontalBinaryOpTest__DataTable<{4}, {6}, {8}> _dataTable;
+        private HorizontalBinaryOpTest__DataTable<{RetBaseType}, {Op1BaseType}, {Op2BaseType}> _dataTable;
 
-        static HorizontalBinaryOpTest__{2}{4}()
-        {{
+        static HorizontalBinaryOpTest__{Method}{RetBaseType}()
+        {
             var random = new Random();
 
-            for (var i = 0; i < Op1ElementCount; i++) {{ _data1[i] = {10}; }}
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{5}<{6}>, byte>(ref _clsVar1), ref Unsafe.As<{6}, byte>(ref _data1[0]), VectorSize);
-            for (var i = 0; i < Op2ElementCount; i++) {{ _data2[i] = {11}; }}
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{7}<{8}>, byte>(ref _clsVar2), ref Unsafe.As<{8}, byte>(ref _data2[0]), VectorSize);
-        }}
+            for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; }
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), VectorSize);
+            for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = {NextValueOp2}; }
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref _clsVar2), ref Unsafe.As<{Op2BaseType}, byte>(ref _data2[0]), VectorSize);
+        }
 
-        public HorizontalBinaryOpTest__{2}{4}()
-        {{
+        public HorizontalBinaryOpTest__{Method}{RetBaseType}()
+        {
             Succeeded = true;
 
             var random = new Random();
 
-            for (var i = 0; i < Op1ElementCount; i++) {{ _data1[i] = {10}; }}
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{5}<{6}>, byte>(ref _fld1), ref Unsafe.As<{6}, byte>(ref _data1[0]), VectorSize);
-            for (var i = 0; i < Op2ElementCount; i++) {{ _data2[i] = {11}; }}
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{7}<{8}>, byte>(ref _fld2), ref Unsafe.As<{8}, byte>(ref _data2[0]), VectorSize);
+            for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; }
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _fld1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), VectorSize);
+            for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = {NextValueOp2}; }
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref _fld2), ref Unsafe.As<{Op2BaseType}, byte>(ref _data2[0]), VectorSize);
 
-            for (var i = 0; i < Op1ElementCount; i++) {{ _data1[i] = {10}; }}
-            for (var i = 0; i < Op2ElementCount; i++) {{ _data2[i] = {11}; }}
-            _dataTable = new HorizontalBinaryOpTest__DataTable<{4}, {6}, {8}>(_data1, _data2, new {4}[RetElementCount], VectorSize);
-        }}
+            for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; }
+            for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = {NextValueOp2}; }
+            _dataTable = new HorizontalBinaryOpTest__DataTable<{RetBaseType}, {Op1BaseType}, {Op2BaseType}>(_data1, _data2, new {RetBaseType}[RetElementCount], VectorSize);
+        }
 
-        public bool IsSupported => {0}.IsSupported;
+        public bool IsSupported => {Isa}.IsSupported;
 
-        public bool Succeeded {{ get; set; }}
+        public bool Succeeded { get; set; }
 
         public void RunBasicScenario_UnsafeRead()
-        {{
-            var result = {0}.{2}(
-                Unsafe.Read<{5}<{6}>>(_dataTable.inArray1Ptr),
-                Unsafe.Read<{7}<{8}>>(_dataTable.inArray2Ptr)
+        {
+            var result = {Isa}.{Method}(
+                Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArray1Ptr),
+                Unsafe.Read<{Op2VectorType}<{Op2BaseType}>>(_dataTable.inArray2Ptr)
             );
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunBasicScenario_Load()
-        {{
-            var result = {0}.{2}(
-                {1}.Load{5}(({6}*)(_dataTable.inArray1Ptr)),
-                {1}.Load{7}(({8}*)(_dataTable.inArray2Ptr))
+        {
+            var result = {Isa}.{Method}(
+                {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)),
+                {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr))
             );
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunBasicScenario_LoadAligned()
-        {{
-            var result = {0}.{2}(
-                {1}.LoadAligned{5}(({6}*)(_dataTable.inArray1Ptr)),
-                {1}.LoadAligned{7}(({8}*)(_dataTable.inArray2Ptr))
+        {
+            var result = {Isa}.{Method}(
+                {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)),
+                {LoadIsa}.LoadAligned{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr))
             );
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunReflectionScenario_UnsafeRead()
-        {{
-            var result = typeof({0}).GetMethod(nameof({0}.{2}), new Type[] {{ typeof({5}<{6}>), typeof({7}<{8}>) }})
-                                     .Invoke(null, new object[] {{
-                                        Unsafe.Read<{5}<{6}>>(_dataTable.inArray1Ptr),
-                                        Unsafe.Read<{7}<{8}>>(_dataTable.inArray2Ptr)
-                                     }});
-
-            Unsafe.Write(_dataTable.outArrayPtr, ({3}<{4}>)(result));
+        {
+            var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof({Op2VectorType}<{Op2BaseType}>) })
+                                     .Invoke(null, new object[] {
+                                        Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArray1Ptr),
+                                        Unsafe.Read<{Op2VectorType}<{Op2BaseType}>>(_dataTable.inArray2Ptr)
+                                     });
+
+            Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result));
             ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunReflectionScenario_Load()
-        {{
-            var result = typeof({0}).GetMethod(nameof({0}.{2}), new Type[] {{ typeof({5}<{6}>), typeof({7}<{8}>) }})
-                                     .Invoke(null, new object[] {{
-                                        {1}.Load{5}(({6}*)(_dataTable.inArray1Ptr)),
-                                        {1}.Load{7}(({8}*)(_dataTable.inArray2Ptr))
-                                     }});
-
-            Unsafe.Write(_dataTable.outArrayPtr, ({3}<{4}>)(result));
+        {
+            var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof({Op2VectorType}<{Op2BaseType}>) })
+                                     .Invoke(null, new object[] {
+                                        {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)),
+                                        {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr))
+                                     });
+
+            Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result));
             ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunReflectionScenario_LoadAligned()
-        {{
-            var result = typeof({0}).GetMethod(nameof({0}.{2}), new Type[] {{ typeof({5}<{6}>), typeof({7}<{8}>) }})
-                                     .Invoke(null, new object[] {{
-                                        {1}.LoadAligned{5}(({6}*)(_dataTable.inArray1Ptr)),
-                                        {1}.LoadAligned{7}(({8}*)(_dataTable.inArray2Ptr))
-                                     }});
-
-            Unsafe.Write(_dataTable.outArrayPtr, ({3}<{4}>)(result));
+        {
+            var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof({Op2VectorType}<{Op2BaseType}>) })
+                                     .Invoke(null, new object[] {
+                                        {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)),
+                                        {LoadIsa}.LoadAligned{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr))
+                                     });
+
+            Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result));
             ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunClsVarScenario()
-        {{
-            var result = {0}.{2}(
+        {
+            var result = {Isa}.{Method}(
                 _clsVar1,
                 _clsVar2
             );
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(_clsVar1, _clsVar2, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunLclVarScenario_UnsafeRead()
-        {{
-            var left = Unsafe.Read<{5}<{6}>>(_dataTable.inArray1Ptr);
-            var right = Unsafe.Read<{7}<{8}>>(_dataTable.inArray2Ptr);
-            var result = {0}.{2}(left, right);
+        {
+            var left = Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArray1Ptr);
+            var right = Unsafe.Read<{Op2VectorType}<{Op2BaseType}>>(_dataTable.inArray2Ptr);
+            var result = {Isa}.{Method}(left, right);
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(left, right, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunLclVarScenario_Load()
-        {{
-            var left = {1}.Load{5}(({6}*)(_dataTable.inArray1Ptr));
-            var right = {1}.Load{7}(({8}*)(_dataTable.inArray2Ptr));
-            var result = {0}.{2}(left, right);
+        {
+            var left = {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr));
+            var right = {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr));
+            var result = {Isa}.{Method}(left, right);
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(left, right, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunLclVarScenario_LoadAligned()
-        {{
-            var left = {1}.LoadAligned{5}(({6}*)(_dataTable.inArray1Ptr));
-            var right = {1}.LoadAligned{7}(({8}*)(_dataTable.inArray2Ptr));
-            var result = {0}.{2}(left, right);
+        {
+            var left = {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr));
+            var right = {LoadIsa}.LoadAligned{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr));
+            var result = {Isa}.{Method}(left, right);
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(left, right, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunLclFldScenario()
-        {{
-            var test = new HorizontalBinaryOpTest__{2}{4}();
-            var result = {0}.{2}(test._fld1, test._fld2);
+        {
+            var test = new HorizontalBinaryOpTest__{Method}{RetBaseType}();
+            var result = {Isa}.{Method}(test._fld1, test._fld2);
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunFldScenario()
-        {{
-            var result = {0}.{2}(_fld1, _fld2);
+        {
+            var result = {Isa}.{Method}(_fld1, _fld2);
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunUnsupportedScenario()
-        {{
+        {
             Succeeded = false;
 
             try
-            {{
+            {
                 RunBasicScenario_UnsafeRead();
-            }}
+            }
             catch (PlatformNotSupportedException)
-            {{
+            {
                 Succeeded = true;
-            }}
-        }}
+            }
+        }
 
-        private void ValidateResult({5}<{6}> left, {7}<{8}> right, void* result, [CallerMemberName] string method = "")
-        {{
-            {6}[] inArray1 = new {6}[Op1ElementCount];
-            {8}[] inArray2 = new {8}[Op2ElementCount];
-            {4}[] outArray = new {4}[RetElementCount];
+        private void ValidateResult({Op1VectorType}<{Op1BaseType}> left, {Op2VectorType}<{Op2BaseType}> right, void* result, [CallerMemberName] string method = "")
+        {
+            {Op1BaseType}[] inArray1 = new {Op1BaseType}[Op1ElementCount];
+            {Op2BaseType}[] inArray2 = new {Op2BaseType}[Op2ElementCount];
+            {RetBaseType}[] outArray = new {RetBaseType}[RetElementCount];
 
             Unsafe.Write(Unsafe.AsPointer(ref inArray1[0]), left);
             Unsafe.Write(Unsafe.AsPointer(ref inArray2[0]), right);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{4}, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), VectorSize);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{RetBaseType}, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), VectorSize);
 
             ValidateResult(inArray1, inArray2, outArray, method);
-        }}
+        }
 
         private void ValidateResult(void* left, void* right, void* result, [CallerMemberName] string method = "")
-        {{
-            {6}[] inArray1 = new {6}[Op1ElementCount];
-            {8}[] inArray2 = new {8}[Op2ElementCount];
-            {4}[] outArray = new {4}[RetElementCount];
+        {
+            {Op1BaseType}[] inArray1 = new {Op1BaseType}[Op1ElementCount];
+            {Op2BaseType}[] inArray2 = new {Op2BaseType}[Op2ElementCount];
+            {RetBaseType}[] outArray = new {RetBaseType}[RetElementCount];
 
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{6}, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(left), VectorSize);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{8}, byte>(ref inArray2[0]), ref Unsafe.AsRef<byte>(right), VectorSize);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{4}, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), VectorSize);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1BaseType}, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(left), VectorSize);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2BaseType}, byte>(ref inArray2[0]), ref Unsafe.AsRef<byte>(right), VectorSize);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{RetBaseType}, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), VectorSize);
 
             ValidateResult(inArray1, inArray2, outArray, method);
-        }}
+        }
 
-        private void ValidateResult({6}[] left, {8}[] right, {4}[] result, [CallerMemberName] string method = "")
-        {{
+        private void ValidateResult({Op1BaseType}[] left, {Op2BaseType}[] right, {RetBaseType}[] result, [CallerMemberName] string method = "")
+        {
             for (var outer = 0; outer < (VectorSize / 16); outer++)
-            {{
-                for (var inner = 0; inner < (8 / sizeof({4})); inner++)
-                {{
-                    var i1 = (outer * (16 / sizeof({4}))) + inner;
-                    var i2 = i1 + (8 / sizeof({4}));
-                    var i3 = (outer * (16 / sizeof({4}))) + (inner * 2);
-
-                    if ({12})
-                    {{
+            {
+                for (var inner = 0; inner < (8 / sizeof({RetBaseType})); inner++)
+                {
+                    var i1 = (outer * (16 / sizeof({RetBaseType}))) + inner;
+                    var i2 = i1 + (8 / sizeof({RetBaseType}));
+                    var i3 = (outer * (16 / sizeof({RetBaseType}))) + (inner * 2);
+
+                    if ({ValidateFirstResult})
+                    {
                         Succeeded = false;
                         break;
-                    }}
+                    }
 
-                    if ({13})
-                    {{
+                    if ({ValidateRemainingResults})
+                    {
                         Succeeded = false;
                         break;
-                    }}
-                }}
-            }}
+                    }
+                }
+            }
 
             if (!Succeeded)
-            {{
-                Console.WriteLine($"{{nameof({0})}}.{{nameof({0}.{2})}}<{4}>({5}<{6}>, {7}<{8}>): {{method}} failed:");
-                Console.WriteLine($"    left: ({{string.Join(", ", left)}})");
-                Console.WriteLine($"   right: ({{string.Join(", ", right)}})");
-                Console.WriteLine($"  result: ({{string.Join(", ", result)}})");
+            {
+                Console.WriteLine($"{nameof({Isa})}.{nameof({Isa}.{Method})}<{RetBaseType}>({Op1VectorType}<{Op1BaseType}>, {Op2VectorType}<{Op2BaseType}>): {method} failed:");
+                Console.WriteLine($"    left: ({string.Join(", ", left)})");
+                Console.WriteLine($"   right: ({string.Join(", ", right)})");
+                Console.WriteLine($"  result: ({string.Join(", ", result)})");
                 Console.WriteLine();
-            }}
-        }}
-    }}
-}}
+            }
+        }
+    }
+}
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/ImmUnOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/ImmUnOpTest.template
index f63b40db2a..6403add2cd 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/ImmUnOpTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/ImmUnOpTest.template
@@ -16,38 +16,38 @@ using System.Runtime.Intrinsics;
 using System.Runtime.Intrinsics.X86;
 
 namespace JIT.HardwareIntrinsics.X86
-{{
+{
     public static partial class Program
-    {{
-        private static void {2}{4}{7}()
-        {{
-            var test = new SimpleUnaryOpTest__{2}{4}{7}();
+    {
+        private static void {Method}{RetBaseType}{Imm}()
+        {
+            var test = new SimpleUnaryOpTest__{Method}{RetBaseType}{Imm}();
 
             if (test.IsSupported)
-            {{
+            {
                 // Validates basic functionality works, using Unsafe.Read
                 test.RunBasicScenario_UnsafeRead();
 
-                if ({1}.IsSupported)
-                {{
+                if ({LoadIsa}.IsSupported)
+                {
                     // Validates basic functionality works, using Load
                     test.RunBasicScenario_Load();
 
                     // Validates basic functionality works, using LoadAligned
                     test.RunBasicScenario_LoadAligned();
-                }}
+                }
 
                 // Validates calling via reflection works, using Unsafe.Read
                 test.RunReflectionScenario_UnsafeRead();
 
-                if ({1}.IsSupported)
-                {{
+                if ({LoadIsa}.IsSupported)
+                {
                     // Validates calling via reflection works, using Load
                     test.RunReflectionScenario_Load();
 
                     // Validates calling via reflection works, using LoadAligned
                     test.RunReflectionScenario_LoadAligned();
-                }}
+                }
 
                 // Validates passing a static member works
                 test.RunClsVarScenario();
@@ -55,259 +55,259 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates passing a local works, using Unsafe.Read
                 test.RunLclVarScenario_UnsafeRead();
 
-                if ({1}.IsSupported)
-                {{
+                if ({LoadIsa}.IsSupported)
+                {
                     // Validates passing a local works, using Load
                     test.RunLclVarScenario_Load();
 
                     // Validates passing a local works, using LoadAligned
                     test.RunLclVarScenario_LoadAligned();
-                }}
+                }
 
                 // Validates passing the field of a local works
                 test.RunLclFldScenario();
 
                 // Validates passing an instance member works
                 test.RunFldScenario();
-            }}
+            }
             else
-            {{
+            {
                 // Validates we throw on unsupported hardware
                 test.RunUnsupportedScenario();
-            }}
+            }
 
             if (!test.Succeeded)
-            {{
+            {
                 throw new Exception("One or more scenarios did not complete as expected.");
-            }}
-        }}
-    }}
+            }
+        }
+    }
 
-    public sealed unsafe class SimpleUnaryOpTest__{2}{4}{7}
-    {{
-        private const int VectorSize = {8};
+    public sealed unsafe class SimpleUnaryOpTest__{Method}{RetBaseType}{Imm}
+    {
+        private const int VectorSize = {VectorSize};
 
-        private const int Op1ElementCount = VectorSize / sizeof({6});
-        private const int RetElementCount = VectorSize / sizeof({4});
+        private const int Op1ElementCount = VectorSize / sizeof({Op1BaseType});
+        private const int RetElementCount = VectorSize / sizeof({RetBaseType});
 
-        private static {6}[] _data = new {6}[Op1ElementCount];
+        private static {Op1BaseType}[] _data = new {Op1BaseType}[Op1ElementCount];
 
-        private static {5}<{6}> _clsVar;
+        private static {Op1VectorType}<{Op1BaseType}> _clsVar;
 
-        private {5}<{6}> _fld;
+        private {Op1VectorType}<{Op1BaseType}> _fld;
 
-        private SimpleUnaryOpTest__DataTable<{4}, {6}> _dataTable;
+        private SimpleUnaryOpTest__DataTable<{RetBaseType}, {Op1BaseType}> _dataTable;
 
-        static SimpleUnaryOpTest__{2}{4}{7}()
-        {{
+        static SimpleUnaryOpTest__{Method}{RetBaseType}{Imm}()
+        {
             var random = new Random();
 
-            for (var i = 0; i < Op1ElementCount; i++) {{ _data[i] = {9}; }}
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{5}<{6}>, byte>(ref _clsVar), ref Unsafe.As<{6}, byte>(ref _data[0]), VectorSize);
-        }}
+            for (var i = 0; i < Op1ElementCount; i++) { _data[i] = {NextValueOp1}; }
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar), ref Unsafe.As<{Op1BaseType}, byte>(ref _data[0]), VectorSize);
+        }
 
-        public SimpleUnaryOpTest__{2}{4}{7}()
-        {{
+        public SimpleUnaryOpTest__{Method}{RetBaseType}{Imm}()
+        {
             Succeeded = true;
 
             var random = new Random();
 
-            for (var i = 0; i < Op1ElementCount; i++) {{ _data[i] = {9}; }}
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{5}<{6}>, byte>(ref _fld), ref Unsafe.As<{6}, byte>(ref _data[0]), VectorSize);
+            for (var i = 0; i < Op1ElementCount; i++) { _data[i] = {NextValueOp1}; }
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _fld), ref Unsafe.As<{Op1BaseType}, byte>(ref _data[0]), VectorSize);
 
-            for (var i = 0; i < Op1ElementCount; i++) {{ _data[i] = {9}; }}
-            _dataTable = new SimpleUnaryOpTest__DataTable<{4}, {6}>(_data, new {4}[RetElementCount], VectorSize);
-        }}
+            for (var i = 0; i < Op1ElementCount; i++) { _data[i] = {NextValueOp1}; }
+            _dataTable = new SimpleUnaryOpTest__DataTable<{RetBaseType}, {Op1BaseType}>(_data, new {RetBaseType}[RetElementCount], VectorSize);
+        }
 
-        public bool IsSupported => {0}.IsSupported;
+        public bool IsSupported => {Isa}.IsSupported;
 
-        public bool Succeeded {{ get; set; }}
+        public bool Succeeded { get; set; }
 
         public void RunBasicScenario_UnsafeRead()
-        {{
-            var result = {0}.{2}(
-                Unsafe.Read<{5}<{6}>>(_dataTable.inArrayPtr),
-                {7}
+        {
+            var result = {Isa}.{Method}(
+                Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArrayPtr),
+                {Imm}
             );
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunBasicScenario_Load()
-        {{
-            var result = {0}.{2}(
-                {1}.Load{5}(({6}*)(_dataTable.inArrayPtr)),
-                {7}
+        {
+            var result = {Isa}.{Method}(
+                {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)),
+                {Imm}
             );
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunBasicScenario_LoadAligned()
-        {{
-            var result = {0}.{2}(
-                {1}.LoadAligned{5}(({6}*)(_dataTable.inArrayPtr)),
-                {7}
+        {
+            var result = {Isa}.{Method}(
+                {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)),
+                {Imm}
             );
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunReflectionScenario_UnsafeRead()
-        {{
-            var result = typeof({0}).GetMethod(nameof({0}.{2}), new Type[] {{ typeof({5}<{6}>), typeof(byte) }})
-                                     .Invoke(null, new object[] {{
-                                        Unsafe.Read<{5}<{6}>>(_dataTable.inArrayPtr),
-                                        (byte){7}
-                                     }});
-
-            Unsafe.Write(_dataTable.outArrayPtr, ({3}<{4}>)(result));
+        {
+            var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof(byte) })
+                                     .Invoke(null, new object[] {
+                                        Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArrayPtr),
+                                        (byte){Imm}
+                                     });
+
+            Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result));
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunReflectionScenario_Load()
-        {{
-            var result = typeof({0}).GetMethod(nameof({0}.{2}), new Type[] {{ typeof({5}<{6}>), typeof(byte) }})
-                                     .Invoke(null, new object[] {{
-                                        {1}.Load{5}(({6}*)(_dataTable.inArrayPtr)),
-                                        (byte){7}
-                                     }});
-
-            Unsafe.Write(_dataTable.outArrayPtr, ({3}<{4}>)(result));
+        {
+            var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof(byte) })
+                                     .Invoke(null, new object[] {
+                                        {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)),
+                                        (byte){Imm}
+                                     });
+
+            Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result));
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunReflectionScenario_LoadAligned()
-        {{
-            var result = typeof({0}).GetMethod(nameof({0}.{2}), new Type[] {{ typeof({5}<{6}>), typeof(byte) }})
-                                     .Invoke(null, new object[] {{
-                                        {1}.LoadAligned{5}(({6}*)(_dataTable.inArrayPtr)),
-                                        (byte){7}
-                                     }});
-
-            Unsafe.Write(_dataTable.outArrayPtr, ({3}<{4}>)(result));
+        {
+            var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof(byte) })
+                                     .Invoke(null, new object[] {
+                                        {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)),
+                                        (byte){Imm}
+                                     });
+
+            Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result));
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunClsVarScenario()
-        {{
-            var result = {0}.{2}(
+        {
+            var result = {Isa}.{Method}(
                 _clsVar,
-                {7}
+                {Imm}
             );
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(_clsVar, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunLclVarScenario_UnsafeRead()
-        {{
-            var firstOp = Unsafe.Read<{5}<{6}>>(_dataTable.inArrayPtr);
-            var result = {0}.{2}(firstOp, {7});
+        {
+            var firstOp = Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArrayPtr);
+            var result = {Isa}.{Method}(firstOp, {Imm});
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(firstOp, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunLclVarScenario_Load()
-        {{
-            var firstOp = {1}.Load{5}(({6}*)(_dataTable.inArrayPtr));
-            var result = {0}.{2}(firstOp, {7});
+        {
+            var firstOp = {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr));
+            var result = {Isa}.{Method}(firstOp, {Imm});
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(firstOp, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunLclVarScenario_LoadAligned()
-        {{
-            var firstOp = {1}.LoadAligned{5}(({6}*)(_dataTable.inArrayPtr));
-            var result = {0}.{2}(firstOp, {7});
+        {
+            var firstOp = {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr));
+            var result = {Isa}.{Method}(firstOp, {Imm});
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(firstOp, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunLclFldScenario()
-        {{
-            var test = new SimpleUnaryOpTest__{2}{4}{7}();
-            var result = {0}.{2}(test._fld, {7});
+        {
+            var test = new SimpleUnaryOpTest__{Method}{RetBaseType}{Imm}();
+            var result = {Isa}.{Method}(test._fld, {Imm});
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(test._fld, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunFldScenario()
-        {{
-            var result = {0}.{2}(_fld, {7});
+        {
+            var result = {Isa}.{Method}(_fld, {Imm});
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(_fld, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunUnsupportedScenario()
-        {{
+        {
             Succeeded = false;
 
             try
-            {{
+            {
                 RunBasicScenario_UnsafeRead();
-            }}
+            }
             catch (PlatformNotSupportedException)
-            {{
+            {
                 Succeeded = true;
-            }}
-        }}
+            }
+        }
 
-        private void ValidateResult({5}<{6}> firstOp, void* result, [CallerMemberName] string method = "")
-        {{
-            {6}[] inArray = new {6}[Op1ElementCount];
-            {4}[] outArray = new {4}[RetElementCount];
+        private void ValidateResult({Op1VectorType}<{Op1BaseType}> firstOp, void* result, [CallerMemberName] string method = "")
+        {
+            {Op1BaseType}[] inArray = new {Op1BaseType}[Op1ElementCount];
+            {RetBaseType}[] outArray = new {RetBaseType}[RetElementCount];
 
             Unsafe.Write(Unsafe.AsPointer(ref inArray[0]), firstOp);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{4}, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), VectorSize);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{RetBaseType}, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), VectorSize);
 
             ValidateResult(inArray, outArray, method);
-        }}
+        }
 
         private void ValidateResult(void* firstOp, void* result, [CallerMemberName] string method = "")
-        {{
-            {6}[] inArray = new {6}[Op1ElementCount];
-            {4}[] outArray = new {4}[RetElementCount];
+        {
+            {Op1BaseType}[] inArray = new {Op1BaseType}[Op1ElementCount];
+            {RetBaseType}[] outArray = new {RetBaseType}[RetElementCount];
 
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{6}, byte>(ref inArray[0]), ref Unsafe.AsRef<byte>(firstOp), VectorSize);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{4}, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), VectorSize);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1BaseType}, byte>(ref inArray[0]), ref Unsafe.AsRef<byte>(firstOp), VectorSize);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{RetBaseType}, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), VectorSize);
 
             ValidateResult(inArray, outArray, method);
-        }}
+        }
 
-        private void ValidateResult({6}[] firstOp, {4}[] result, [CallerMemberName] string method = "")
-        {{
-            if ({10})
-            {{
+        private void ValidateResult({Op1BaseType}[] firstOp, {RetBaseType}[] result, [CallerMemberName] string method = "")
+        {
+            if ({ValidateFirstResult})
+            {
                 Succeeded = false;
-            }}
+            }
             else
-            {{
+            {
                 for (var i = 1; i < RetElementCount; i++)
-                {{
-                    if ({11})
-                    {{
+                {
+                    if ({ValidateRemainingResults})
+                    {
                         Succeeded = false;
                         break;
-                    }}
-                }}
-            }}
+                    }
+                }
+            }
 
             if (!Succeeded)
-            {{
-                Console.WriteLine($"{{nameof({0})}}.{{nameof({0}.{2})}}<{4}>({5}<{6}><9>): {{method}} failed:");
-                Console.WriteLine($"  firstOp: ({{string.Join(", ", firstOp)}})");
-                Console.WriteLine($"   result: ({{string.Join(", ", result)}})");
+            {
+                Console.WriteLine($"{nameof({Isa})}.{nameof({Isa}.{Method})}<{RetBaseType}>({Op1VectorType}<{Op1BaseType}><9>): {method} failed:");
+                Console.WriteLine($"  firstOp: ({string.Join(", ", firstOp)})");
+                Console.WriteLine($"   result: ({string.Join(", ", result)})");
                 Console.WriteLine();
-            }}
-        }}
-    }}
-}}
+            }
+        }
+    }
+}
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/InsertScalarTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/InsertScalarTest.template
index 987a2dd6ac..22eaf24bdb 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/InsertScalarTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/InsertScalarTest.template
@@ -16,40 +16,40 @@ using System.Runtime.Intrinsics;
 using System.Runtime.Intrinsics.X86;
 
 namespace JIT.HardwareIntrinsics.X86
-{{
+{
     public static partial class Program
-    {{
-        private static void {2}{4}{7}()
-        {{
-            var test = new SimpleUnaryOpTest__{2}{4}{7}();
+    {
+        private static void {Method}{RetBaseType}{Imm}()
+        {
+            var test = new SimpleUnaryOpTest__{Method}{RetBaseType}{Imm}();
             
             try
-            {{
+            {
             if (test.IsSupported)
-            {{
+            {
                 // Validates basic functionality works, using Unsafe.Read
                 test.RunBasicScenario_UnsafeRead();
 
-                if ({1}.IsSupported)
-                {{
+                if ({LoadIsa}.IsSupported)
+                {
                     // Validates basic functionality works, using Load
                     test.RunBasicScenario_Load();
 
                     // Validates basic functionality works, using LoadAligned
                     test.RunBasicScenario_LoadAligned();
-                }}
+                }
 
                 // Validates calling via reflection works, using Unsafe.Read
                 test.RunReflectionScenario_UnsafeRead();
 
-                if ({1}.IsSupported)
-                {{
+                if ({LoadIsa}.IsSupported)
+                {
                     // Validates calling via reflection works, using Load
                     test.RunReflectionScenario_Load();
 
                     // Validates calling via reflection works, using LoadAligned
                     test.RunReflectionScenario_LoadAligned();
-                }}
+                }
 
                 // Validates passing a static member works
                 test.RunClsVarScenario();
@@ -57,265 +57,265 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates passing a local works, using Unsafe.Read
                 test.RunLclVarScenario_UnsafeRead();
 
-                if ({1}.IsSupported)
-                {{
+                if ({LoadIsa}.IsSupported)
+                {
                     // Validates passing a local works, using Load
                     test.RunLclVarScenario_Load();
 
                     // Validates passing a local works, using LoadAligned
                     test.RunLclVarScenario_LoadAligned();
-                }}
+                }
 
                 // Validates passing the field of a local works
                 test.RunLclFldScenario();
 
                 // Validates passing an instance member works
                 test.RunFldScenario();
-            }}
+            }
             else
-            {{
+            {
                 // Validates we throw on unsupported hardware
                 test.RunUnsupportedScenario();
-            }}
-            }}
+            }
+            }
             catch (PlatformNotSupportedException)
-            {{
+            {
                 test.Succeeded = true;
-            }}
+            }
 
             if (!test.Succeeded)
-            {{
+            {
                 throw new Exception("One or more scenarios did not complete as expected.");
-            }}
-        }}
-    }}
+            }
+        }
+    }
 
-    public sealed unsafe class SimpleUnaryOpTest__{2}{4}{7}
-    {{
-        private const int VectorSize = {9};
+    public sealed unsafe class SimpleUnaryOpTest__{Method}{RetBaseType}{Imm}
+    {
+        private const int VectorSize = {VectorSize};
 
-        private const int Op1ElementCount = VectorSize / sizeof({6});
-        private const int RetElementCount = VectorSize / sizeof({4});
+        private const int Op1ElementCount = VectorSize / sizeof({Op1BaseType});
+        private const int RetElementCount = VectorSize / sizeof({RetBaseType});
 
-        private static {6}[] _data = new {6}[Op1ElementCount];
+        private static {Op1BaseType}[] _data = new {Op1BaseType}[Op1ElementCount];
 
-        private static {5}<{6}> _clsVar;
+        private static {Op1VectorType}<{Op1BaseType}> _clsVar;
 
-        private {5}<{6}> _fld;
+        private {Op1VectorType}<{Op1BaseType}> _fld;
 
-        private SimpleUnaryOpTest__DataTable<{4}, {6}> _dataTable;
+        private SimpleUnaryOpTest__DataTable<{RetBaseType}, {Op1BaseType}> _dataTable;
 
-        static SimpleUnaryOpTest__{2}{4}{7}()
-        {{
+        static SimpleUnaryOpTest__{Method}{RetBaseType}{Imm}()
+        {
             var random = new Random();
 
-            for (var i = 0; i < Op1ElementCount; i++) {{ _data[i] = {10}; }}
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{5}<{6}>, byte>(ref _clsVar), ref Unsafe.As<{6}, byte>(ref _data[0]), VectorSize);
-        }}
+            for (var i = 0; i < Op1ElementCount; i++) { _data[i] = {NextValueOp1}; }
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar), ref Unsafe.As<{Op1BaseType}, byte>(ref _data[0]), VectorSize);
+        }
 
-        public SimpleUnaryOpTest__{2}{4}{7}()
-        {{
+        public SimpleUnaryOpTest__{Method}{RetBaseType}{Imm}()
+        {
             Succeeded = true;
 
             var random = new Random();
 
-            for (var i = 0; i < Op1ElementCount; i++) {{ _data[i] = {10}; }}
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{5}<{6}>, byte>(ref _fld), ref Unsafe.As<{6}, byte>(ref _data[0]), VectorSize);
+            for (var i = 0; i < Op1ElementCount; i++) { _data[i] = {NextValueOp1}; }
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _fld), ref Unsafe.As<{Op1BaseType}, byte>(ref _data[0]), VectorSize);
 
-            for (var i = 0; i < Op1ElementCount; i++) {{ _data[i] = {10}; }}
-            _dataTable = new SimpleUnaryOpTest__DataTable<{4}, {6}>(_data, new {4}[RetElementCount], VectorSize);
-        }}
+            for (var i = 0; i < Op1ElementCount; i++) { _data[i] = {NextValueOp1}; }
+            _dataTable = new SimpleUnaryOpTest__DataTable<{RetBaseType}, {Op1BaseType}>(_data, new {RetBaseType}[RetElementCount], VectorSize);
+        }
 
-        public bool IsSupported => {0}.IsSupported;
+        public bool IsSupported => {Isa}.IsSupported;
 
-        public bool Succeeded {{ get; set; }}
+        public bool Succeeded { get; set; }
 
         public void RunBasicScenario_UnsafeRead()
-        {{
-            var result = {0}.{2}(
-                Unsafe.Read<{5}<{6}>>(_dataTable.inArrayPtr),
-                {8},
-                {7}
+        {
+            var result = {Isa}.{Method}(
+                Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArrayPtr),
+                {Data},
+                {Imm}
             );
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunBasicScenario_Load()
-        {{
-            var result = {0}.{2}(
-                {1}.Load{5}(({6}*)(_dataTable.inArrayPtr)),
-                {8},
-                {7}
+        {
+            var result = {Isa}.{Method}(
+                {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)),
+                {Data},
+                {Imm}
             );
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunBasicScenario_LoadAligned()
-        {{
-            var result = {0}.{2}(
-                {1}.LoadAligned{5}(({6}*)(_dataTable.inArrayPtr)),
-                {8},
-                {7}
+        {
+            var result = {Isa}.{Method}(
+                {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)),
+                {Data},
+                {Imm}
             );
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunReflectionScenario_UnsafeRead()
-        {{
-            var result = typeof({0}).GetMethod(nameof({0}.{2}), new Type[] {{ typeof({5}<{6}>), typeof({4}), typeof(byte) }})
-                                     .Invoke(null, new object[] {{
-                                        Unsafe.Read<{5}<{6}>>(_dataTable.inArrayPtr),
-                                        {8},
-                                        (byte){7}
-                                     }});
-
-            Unsafe.Write(_dataTable.outArrayPtr, ({3}<{4}>)(result));
+        {
+            var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof({RetBaseType}), typeof(byte) })
+                                     .Invoke(null, new object[] {
+                                        Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArrayPtr),
+                                        {Data},
+                                        (byte){Imm}
+                                     });
+
+            Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result));
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunReflectionScenario_Load()
-        {{
-            var result = typeof({0}).GetMethod(nameof({0}.{2}), new Type[] {{ typeof({5}<{6}>), typeof({4}), typeof(byte) }})
-                                     .Invoke(null, new object[] {{
-                                        {1}.Load{5}(({6}*)(_dataTable.inArrayPtr)),
-                                        {8},
-                                        (byte){7}
-                                     }});
-
-            Unsafe.Write(_dataTable.outArrayPtr, ({3}<{4}>)(result));
+        {
+            var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof({RetBaseType}), typeof(byte) })
+                                     .Invoke(null, new object[] {
+                                        {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)),
+                                        {Data},
+                                        (byte){Imm}
+                                     });
+
+            Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result));
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunReflectionScenario_LoadAligned()
-        {{
-            var result = typeof({0}).GetMethod(nameof({0}.{2}), new Type[] {{ typeof({5}<{6}>), typeof({4}), typeof(byte) }})
-                                     .Invoke(null, new object[] {{
-                                        {1}.LoadAligned{5}(({6}*)(_dataTable.inArrayPtr)),
-                                        {8},
-                                        (byte){7}
-                                     }});
-
-            Unsafe.Write(_dataTable.outArrayPtr, ({3}<{4}>)(result));
+        {
+            var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof({RetBaseType}), typeof(byte) })
+                                     .Invoke(null, new object[] {
+                                        {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)),
+                                        {Data},
+                                        (byte){Imm}
+                                     });
+
+            Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result));
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunClsVarScenario()
-        {{
-            var result = {0}.{2}(
+        {
+            var result = {Isa}.{Method}(
                 _clsVar,
-                {8},
-                {7}
+                {Data},
+                {Imm}
             );
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(_clsVar, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunLclVarScenario_UnsafeRead()
-        {{
-            var firstOp = Unsafe.Read<{5}<{6}>>(_dataTable.inArrayPtr);
-            var result = {0}.{2}(firstOp, {8}, {7});
+        {
+            var firstOp = Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArrayPtr);
+            var result = {Isa}.{Method}(firstOp, {Data}, {Imm});
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(firstOp, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunLclVarScenario_Load()
-        {{
-            var firstOp = {1}.Load{5}(({6}*)(_dataTable.inArrayPtr));
-            var result = {0}.{2}(firstOp, {8}, {7});
+        {
+            var firstOp = {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr));
+            var result = {Isa}.{Method}(firstOp, {Data}, {Imm});
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(firstOp, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunLclVarScenario_LoadAligned()
-        {{
-            var firstOp = {1}.LoadAligned{5}(({6}*)(_dataTable.inArrayPtr));
-            var result = {0}.{2}(firstOp, {8}, {7});
+        {
+            var firstOp = {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr));
+            var result = {Isa}.{Method}(firstOp, {Data}, {Imm});
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(firstOp, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunLclFldScenario()
-        {{
-            var test = new SimpleUnaryOpTest__{2}{4}{7}();
-            var result = {0}.{2}(test._fld, {8}, {7});
+        {
+            var test = new SimpleUnaryOpTest__{Method}{RetBaseType}{Imm}();
+            var result = {Isa}.{Method}(test._fld, {Data}, {Imm});
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(test._fld, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunFldScenario()
-        {{
-            var result = {0}.{2}(_fld, {8}, {7});
+        {
+            var result = {Isa}.{Method}(_fld, {Data}, {Imm});
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(_fld, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunUnsupportedScenario()
-        {{
+        {
             Succeeded = false;
 
             try
-            {{
+            {
                 RunBasicScenario_UnsafeRead();
-            }}
+            }
             catch (PlatformNotSupportedException)
-            {{
+            {
                 Succeeded = true;
-            }}
-        }}
+            }
+        }
 
-        private void ValidateResult({5}<{6}> firstOp, void* result, [CallerMemberName] string method = "")
-        {{
-            {6}[] inArray = new {6}[Op1ElementCount];
-            {4}[] outArray = new {4}[RetElementCount];
+        private void ValidateResult({Op1VectorType}<{Op1BaseType}> firstOp, void* result, [CallerMemberName] string method = "")
+        {
+            {Op1BaseType}[] inArray = new {Op1BaseType}[Op1ElementCount];
+            {RetBaseType}[] outArray = new {RetBaseType}[RetElementCount];
 
             Unsafe.Write(Unsafe.AsPointer(ref inArray[0]), firstOp);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{4}, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), VectorSize);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{RetBaseType}, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), VectorSize);
 
             ValidateResult(inArray, outArray, method);
-        }}
+        }
 
         private void ValidateResult(void* firstOp, void* result, [CallerMemberName] string method = "")
-        {{
-            {6}[] inArray = new {6}[Op1ElementCount];
-            {4}[] outArray = new {4}[RetElementCount];
+        {
+            {Op1BaseType}[] inArray = new {Op1BaseType}[Op1ElementCount];
+            {RetBaseType}[] outArray = new {RetBaseType}[RetElementCount];
 
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{6}, byte>(ref inArray[0]), ref Unsafe.AsRef<byte>(firstOp), VectorSize);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{4}, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), VectorSize);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1BaseType}, byte>(ref inArray[0]), ref Unsafe.AsRef<byte>(firstOp), VectorSize);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{RetBaseType}, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), VectorSize);
 
             ValidateResult(inArray, outArray, method);
-        }}
+        }
 
-        private void ValidateResult({6}[] firstOp, {4}[] result, [CallerMemberName] string method = "")
-        {{
+        private void ValidateResult({Op1BaseType}[] firstOp, {RetBaseType}[] result, [CallerMemberName] string method = "")
+        {
 
             for (var i = 0; i < RetElementCount; i++)
-            {{
-                if ({11})
-                {{
+            {
+                if ({ValidateFirstResult})
+                {
                     Succeeded = false;
                     break;
-                }}
-            }}
+                }
+            }
 
             if (!Succeeded)
-            {{
-                Console.WriteLine($"{{nameof({0})}}.{{nameof({0}.{2})}}<{4}>({5}<{6}><9>): {{method}} failed:");
-                Console.WriteLine($"  firstOp: ({{string.Join(", ", firstOp)}})");
-                Console.WriteLine($"   result: ({{string.Join(", ", result)}})");
+            {
+                Console.WriteLine($"{nameof({Isa})}.{nameof({Isa}.{Method})}<{RetBaseType}>({Op1VectorType}<{Op1BaseType}><9>): {method} failed:");
+                Console.WriteLine($"  firstOp: ({string.Join(", ", firstOp)})");
+                Console.WriteLine($"   result: ({string.Join(", ", result)})");
                 Console.WriteLine();
-            }}
-        }}
-    }}
-}}
+            }
+        }
+    }
+}
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleBinOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleBinOpTest.template
index 74fd5e336e..8df00cedc1 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleBinOpTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleBinOpTest.template
@@ -16,38 +16,38 @@ using System.Runtime.Intrinsics;
 using System.Runtime.Intrinsics.X86;
 
 namespace JIT.HardwareIntrinsics.X86
-{{
+{
     public static partial class Program
-    {{
-        private static void {2}{4}()
-        {{
-            var test = new SimpleBinaryOpTest__{2}{4}();
+    {
+        private static void {Method}{RetBaseType}()
+        {
+            var test = new SimpleBinaryOpTest__{Method}{RetBaseType}();
 
             if (test.IsSupported)
-            {{
+            {
                 // Validates basic functionality works, using Unsafe.Read
                 test.RunBasicScenario_UnsafeRead();
 
-                if ({1}.IsSupported)
-                {{
+                if ({LoadIsa}.IsSupported)
+                {
                     // Validates basic functionality works, using Load
                     test.RunBasicScenario_Load();
 
                     // Validates basic functionality works, using LoadAligned
                     test.RunBasicScenario_LoadAligned();
-                }}
+                }
 
                 // Validates calling via reflection works, using Unsafe.Read
                 test.RunReflectionScenario_UnsafeRead();
 
-                if ({1}.IsSupported)
-                {{
+                if ({LoadIsa}.IsSupported)
+                {
                     // Validates calling via reflection works, using Load
                     test.RunReflectionScenario_Load();
 
                     // Validates calling via reflection works, using LoadAligned
                     test.RunReflectionScenario_LoadAligned();
-                }}
+                }
 
                 // Validates passing a static member works
                 test.RunClsVarScenario();
@@ -55,276 +55,276 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates passing a local works, using Unsafe.Read
                 test.RunLclVarScenario_UnsafeRead();
 
-                if ({1}.IsSupported)
-                {{
+                if ({LoadIsa}.IsSupported)
+                {
                     // Validates passing a local works, using Load
                     test.RunLclVarScenario_Load();
 
                     // Validates passing a local works, using LoadAligned
                     test.RunLclVarScenario_LoadAligned();
-                }}
+                }
 
                 // Validates passing the field of a local works
                 test.RunLclFldScenario();
 
                 // Validates passing an instance member works
                 test.RunFldScenario();
-            }}
+            }
             else
-            {{
+            {
                 // Validates we throw on unsupported hardware
                 test.RunUnsupportedScenario();
-            }}
+            }
 
             if (!test.Succeeded)
-            {{
+            {
                 throw new Exception("One or more scenarios did not complete as expected.");
-            }}
-        }}
-    }}
+            }
+        }
+    }
 
-    public sealed unsafe class SimpleBinaryOpTest__{2}{4}
-    {{
-        private const int VectorSize = {9};
+    public sealed unsafe class SimpleBinaryOpTest__{Method}{RetBaseType}
+    {
+        private const int VectorSize = {VectorSize};
 
-        private const int Op1ElementCount = VectorSize / sizeof({6});
-        private const int Op2ElementCount = VectorSize / sizeof({8});
-        private const int RetElementCount = VectorSize / sizeof({4});
+        private const int Op1ElementCount = VectorSize / sizeof({Op1BaseType});
+        private const int Op2ElementCount = VectorSize / sizeof({Op2BaseType});
+        private const int RetElementCount = VectorSize / sizeof({RetBaseType});
 
-        private static {6}[] _data1 = new {6}[Op1ElementCount];
-        private static {8}[] _data2 = new {8}[Op2ElementCount];
+        private static {Op1BaseType}[] _data1 = new {Op1BaseType}[Op1ElementCount];
+        private static {Op2BaseType}[] _data2 = new {Op2BaseType}[Op2ElementCount];
 
-        private static {5}<{6}> _clsVar1;
-        private static {7}<{8}> _clsVar2;
+        private static {Op1VectorType}<{Op1BaseType}> _clsVar1;
+        private static {Op2VectorType}<{Op2BaseType}> _clsVar2;
 
-        private {5}<{6}> _fld1;
-        private {7}<{8}> _fld2;
+        private {Op1VectorType}<{Op1BaseType}> _fld1;
+        private {Op2VectorType}<{Op2BaseType}> _fld2;
 
-        private SimpleBinaryOpTest__DataTable<{4}, {6}, {8}> _dataTable;
+        private SimpleBinaryOpTest__DataTable<{RetBaseType}, {Op1BaseType}, {Op2BaseType}> _dataTable;
 
-        static SimpleBinaryOpTest__{2}{4}()
-        {{
+        static SimpleBinaryOpTest__{Method}{RetBaseType}()
+        {
             var random = new Random();
 
-            for (var i = 0; i < Op1ElementCount; i++) {{ _data1[i] = {10}; }}
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{5}<{6}>, byte>(ref _clsVar1), ref Unsafe.As<{6}, byte>(ref _data1[0]), VectorSize);
-            for (var i = 0; i < Op2ElementCount; i++) {{ _data2[i] = {11}; }}
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{7}<{8}>, byte>(ref _clsVar2), ref Unsafe.As<{8}, byte>(ref _data2[0]), VectorSize);
-        }}
+            for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; }
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), VectorSize);
+            for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = {NextValueOp2}; }
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref _clsVar2), ref Unsafe.As<{Op2BaseType}, byte>(ref _data2[0]), VectorSize);
+        }
 
-        public SimpleBinaryOpTest__{2}{4}()
-        {{
+        public SimpleBinaryOpTest__{Method}{RetBaseType}()
+        {
             Succeeded = true;
 
             var random = new Random();
 
-            for (var i = 0; i < Op1ElementCount; i++) {{ _data1[i] = {10}; }}
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{5}<{6}>, byte>(ref _fld1), ref Unsafe.As<{6}, byte>(ref _data1[0]), VectorSize);
-            for (var i = 0; i < Op2ElementCount; i++) {{ _data2[i] = {11}; }}
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{7}<{8}>, byte>(ref _fld2), ref Unsafe.As<{8}, byte>(ref _data2[0]), VectorSize);
+            for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; }
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _fld1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), VectorSize);
+            for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = {NextValueOp2}; }
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref _fld2), ref Unsafe.As<{Op2BaseType}, byte>(ref _data2[0]), VectorSize);
 
-            for (var i = 0; i < Op1ElementCount; i++) {{ _data1[i] = {10}; }}
-            for (var i = 0; i < Op2ElementCount; i++) {{ _data2[i] = {11}; }}
-            _dataTable = new SimpleBinaryOpTest__DataTable<{4}, {6}, {8}>(_data1, _data2, new {4}[RetElementCount], VectorSize);
-        }}
+            for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; }
+            for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = {NextValueOp2}; }
+            _dataTable = new SimpleBinaryOpTest__DataTable<{RetBaseType}, {Op1BaseType}, {Op2BaseType}>(_data1, _data2, new {RetBaseType}[RetElementCount], VectorSize);
+        }
 
-        public bool IsSupported => {0}.IsSupported;
+        public bool IsSupported => {Isa}.IsSupported;
 
-        public bool Succeeded {{ get; set; }}
+        public bool Succeeded { get; set; }
 
         public void RunBasicScenario_UnsafeRead()
-        {{
-            var result = {0}.{2}(
-                Unsafe.Read<{5}<{6}>>(_dataTable.inArray1Ptr),
-                Unsafe.Read<{7}<{8}>>(_dataTable.inArray2Ptr)
+        {
+            var result = {Isa}.{Method}(
+                Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArray1Ptr),
+                Unsafe.Read<{Op2VectorType}<{Op2BaseType}>>(_dataTable.inArray2Ptr)
             );
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunBasicScenario_Load()
-        {{
-            var result = {0}.{2}(
-                {1}.Load{5}(({6}*)(_dataTable.inArray1Ptr)),
-                {1}.Load{7}(({8}*)(_dataTable.inArray2Ptr))
+        {
+            var result = {Isa}.{Method}(
+                {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)),
+                {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr))
             );
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunBasicScenario_LoadAligned()
-        {{
-            var result = {0}.{2}(
-                {1}.LoadAligned{5}(({6}*)(_dataTable.inArray1Ptr)),
-                {1}.LoadAligned{7}(({8}*)(_dataTable.inArray2Ptr))
+        {
+            var result = {Isa}.{Method}(
+                {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)),
+                {LoadIsa}.LoadAligned{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr))
             );
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunReflectionScenario_UnsafeRead()
-        {{
-            var result = typeof({0}).GetMethod(nameof({0}.{2}), new Type[] {{ typeof({5}<{6}>), typeof({7}<{8}>) }})
-                                     .Invoke(null, new object[] {{
-                                        Unsafe.Read<{5}<{6}>>(_dataTable.inArray1Ptr),
-                                        Unsafe.Read<{7}<{8}>>(_dataTable.inArray2Ptr)
-                                     }});
-
-            Unsafe.Write(_dataTable.outArrayPtr, ({3}<{4}>)(result));
+        {
+            var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof({Op2VectorType}<{Op2BaseType}>) })
+                                     .Invoke(null, new object[] {
+                                        Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArray1Ptr),
+                                        Unsafe.Read<{Op2VectorType}<{Op2BaseType}>>(_dataTable.inArray2Ptr)
+                                     });
+
+            Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result));
             ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunReflectionScenario_Load()
-        {{
-            var result = typeof({0}).GetMethod(nameof({0}.{2}), new Type[] {{ typeof({5}<{6}>), typeof({7}<{8}>) }})
-                                     .Invoke(null, new object[] {{
-                                        {1}.Load{5}(({6}*)(_dataTable.inArray1Ptr)),
-                                        {1}.Load{7}(({8}*)(_dataTable.inArray2Ptr))
-                                     }});
-
-            Unsafe.Write(_dataTable.outArrayPtr, ({3}<{4}>)(result));
+        {
+            var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof({Op2VectorType}<{Op2BaseType}>) })
+                                     .Invoke(null, new object[] {
+                                        {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)),
+                                        {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr))
+                                     });
+
+            Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result));
             ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunReflectionScenario_LoadAligned()
-        {{
-            var result = typeof({0}).GetMethod(nameof({0}.{2}), new Type[] {{ typeof({5}<{6}>), typeof({7}<{8}>) }})
-                                     .Invoke(null, new object[] {{
-                                        {1}.LoadAligned{5}(({6}*)(_dataTable.inArray1Ptr)),
-                                        {1}.LoadAligned{7}(({8}*)(_dataTable.inArray2Ptr))
-                                     }});
-
-            Unsafe.Write(_dataTable.outArrayPtr, ({3}<{4}>)(result));
+        {
+            var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof({Op2VectorType}<{Op2BaseType}>) })
+                                     .Invoke(null, new object[] {
+                                        {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)),
+                                        {LoadIsa}.LoadAligned{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr))
+                                     });
+
+            Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result));
             ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunClsVarScenario()
-        {{
-            var result = {0}.{2}(
+        {
+            var result = {Isa}.{Method}(
                 _clsVar1,
                 _clsVar2
             );
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(_clsVar1, _clsVar2, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunLclVarScenario_UnsafeRead()
-        {{
-            var left = Unsafe.Read<{5}<{6}>>(_dataTable.inArray1Ptr);
-            var right = Unsafe.Read<{7}<{8}>>(_dataTable.inArray2Ptr);
-            var result = {0}.{2}(left, right);
+        {
+            var left = Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArray1Ptr);
+            var right = Unsafe.Read<{Op2VectorType}<{Op2BaseType}>>(_dataTable.inArray2Ptr);
+            var result = {Isa}.{Method}(left, right);
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(left, right, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunLclVarScenario_Load()
-        {{
-            var left = {1}.Load{5}(({6}*)(_dataTable.inArray1Ptr));
-            var right = {1}.Load{7}(({8}*)(_dataTable.inArray2Ptr));
-            var result = {0}.{2}(left, right);
+        {
+            var left = {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr));
+            var right = {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr));
+            var result = {Isa}.{Method}(left, right);
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(left, right, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunLclVarScenario_LoadAligned()
-        {{
-            var left = {1}.LoadAligned{5}(({6}*)(_dataTable.inArray1Ptr));
-            var right = {1}.LoadAligned{7}(({8}*)(_dataTable.inArray2Ptr));
-            var result = {0}.{2}(left, right);
+        {
+            var left = {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr));
+            var right = {LoadIsa}.LoadAligned{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr));
+            var result = {Isa}.{Method}(left, right);
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(left, right, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunLclFldScenario()
-        {{
-            var test = new SimpleBinaryOpTest__{2}{4}();
-            var result = {0}.{2}(test._fld1, test._fld2);
+        {
+            var test = new SimpleBinaryOpTest__{Method}{RetBaseType}();
+            var result = {Isa}.{Method}(test._fld1, test._fld2);
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunFldScenario()
-        {{
-            var result = {0}.{2}(_fld1, _fld2);
+        {
+            var result = {Isa}.{Method}(_fld1, _fld2);
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunUnsupportedScenario()
-        {{
+        {
             Succeeded = false;
 
             try
-            {{
+            {
                 RunBasicScenario_UnsafeRead();
-            }}
+            }
             catch (PlatformNotSupportedException)
-            {{
+            {
                 Succeeded = true;
-            }}
-        }}
+            }
+        }
 
-        private void ValidateResult({5}<{6}> left, {7}<{8}> right, void* result, [CallerMemberName] string method = "")
-        {{
-            {6}[] inArray1 = new {6}[Op1ElementCount];
-            {8}[] inArray2 = new {8}[Op2ElementCount];
-            {4}[] outArray = new {4}[RetElementCount];
+        private void ValidateResult({Op1VectorType}<{Op1BaseType}> left, {Op2VectorType}<{Op2BaseType}> right, void* result, [CallerMemberName] string method = "")
+        {
+            {Op1BaseType}[] inArray1 = new {Op1BaseType}[Op1ElementCount];
+            {Op2BaseType}[] inArray2 = new {Op2BaseType}[Op2ElementCount];
+            {RetBaseType}[] outArray = new {RetBaseType}[RetElementCount];
 
             Unsafe.Write(Unsafe.AsPointer(ref inArray1[0]), left);
             Unsafe.Write(Unsafe.AsPointer(ref inArray2[0]), right);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{4}, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), VectorSize);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{RetBaseType}, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), VectorSize);
 
             ValidateResult(inArray1, inArray2, outArray, method);
-        }}
+        }
 
         private void ValidateResult(void* left, void* right, void* result, [CallerMemberName] string method = "")
-        {{
-            {6}[] inArray1 = new {6}[Op1ElementCount];
-            {8}[] inArray2 = new {8}[Op2ElementCount];
-            {4}[] outArray = new {4}[RetElementCount];
+        {
+            {Op1BaseType}[] inArray1 = new {Op1BaseType}[Op1ElementCount];
+            {Op2BaseType}[] inArray2 = new {Op2BaseType}[Op2ElementCount];
+            {RetBaseType}[] outArray = new {RetBaseType}[RetElementCount];
 
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{6}, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(left), VectorSize);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{8}, byte>(ref inArray2[0]), ref Unsafe.AsRef<byte>(right), VectorSize);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{4}, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), VectorSize);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1BaseType}, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(left), VectorSize);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2BaseType}, byte>(ref inArray2[0]), ref Unsafe.AsRef<byte>(right), VectorSize);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{RetBaseType}, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), VectorSize);
 
             ValidateResult(inArray1, inArray2, outArray, method);
-        }}
+        }
 
-        private void ValidateResult({6}[] left, {8}[] right, {4}[] result, [CallerMemberName] string method = "")
-        {{
-            if ({12})
-            {{
+        private void ValidateResult({Op1BaseType}[] left, {Op2BaseType}[] right, {RetBaseType}[] result, [CallerMemberName] string method = "")
+        {
+            if ({ValidateFirstResult})
+            {
                 Succeeded = false;
-            }}
+            }
             else
-            {{
+            {
                 for (var i = 1; i < RetElementCount; i++)
-                {{
-                    if ({13})
-                    {{
+                {
+                    if ({ValidateRemainingResults})
+                    {
                         Succeeded = false;
                         break;
-                    }}
-                }}
-            }}
+                    }
+                }
+            }
 
             if (!Succeeded)
-            {{
-                Console.WriteLine($"{{nameof({0})}}.{{nameof({0}.{2})}}<{4}>({5}<{6}>, {7}<{8}>): {{method}} failed:");
-                Console.WriteLine($"    left: ({{string.Join(", ", left)}})");
-                Console.WriteLine($"   right: ({{string.Join(", ", right)}})");
-                Console.WriteLine($"  result: ({{string.Join(", ", result)}})");
+            {
+                Console.WriteLine($"{nameof({Isa})}.{nameof({Isa}.{Method})}<{RetBaseType}>({Op1VectorType}<{Op1BaseType}>, {Op2VectorType}<{Op2BaseType}>): {method} failed:");
+                Console.WriteLine($"    left: ({string.Join(", ", left)})");
+                Console.WriteLine($"   right: ({string.Join(", ", right)})");
+                Console.WriteLine($"  result: ({string.Join(", ", result)})");
                 Console.WriteLine();
-            }}
-        }}
-    }}
-}}
+            }
+        }
+    }
+}
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleTernOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleTernOpTest.template
index 3a0cbf1d55..6b62c21680 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleTernOpTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleTernOpTest.template
@@ -16,38 +16,38 @@ using System.Runtime.Intrinsics;
 using System.Runtime.Intrinsics.X86;
 
 namespace JIT.HardwareIntrinsics.X86
-{{
+{
     public static partial class Program
-    {{
-        private static void {2}{4}()
-        {{
-            var test = new SimpleTernaryOpTest__{2}{4}();
+    {
+        private static void {Method}{RetBaseType}()
+        {
+            var test = new SimpleTernaryOpTest__{Method}{RetBaseType}();
 
             if (test.IsSupported)
-            {{
+            {
                 // Validates basic functionality works, using Unsafe.Read
                 test.RunBasicScenario_UnsafeRead();
 
-                if ({1}.IsSupported)
-                {{
+                if ({LoadIsa}.IsSupported)
+                {
                     // Validates basic functionality works, using Load
                     test.RunBasicScenario_Load();
 
                     // Validates basic functionality works, using LoadAligned
                     test.RunBasicScenario_LoadAligned();
-                }}
+                }
 
                 // Validates calling via reflection works, using Unsafe.Read
                 test.RunReflectionScenario_UnsafeRead();
 
-                if ({1}.IsSupported)
-                {{
+                if ({LoadIsa}.IsSupported)
+                {
                     // Validates calling via reflection works, using Load
                     test.RunReflectionScenario_Load();
 
                     // Validates calling via reflection works, using LoadAligned
                     test.RunReflectionScenario_LoadAligned();
-                }}
+                }
 
                 // Validates passing a static member works
                 test.RunClsVarScenario();
@@ -55,170 +55,170 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates passing a local works, using Unsafe.Read
                 test.RunLclVarScenario_UnsafeRead();
 
-                if ({1}.IsSupported)
-                {{
+                if ({LoadIsa}.IsSupported)
+                {
                     // Validates passing a local works, using Load
                     test.RunLclVarScenario_Load();
 
                     // Validates passing a local works, using LoadAligned
                     test.RunLclVarScenario_LoadAligned();
-                }}
+                }
 
                 // Validates passing the field of a local works
                 test.RunLclFldScenario();
 
                 // Validates passing an instance member works
                 test.RunFldScenario();
-            }}
+            }
             else
-            {{
+            {
                 // Validates we throw on unsupported hardware
                 test.RunUnsupportedScenario();
-            }}
+            }
 
             if (!test.Succeeded)
-            {{
+            {
                 throw new Exception("One or more scenarios did not complete as expected.");
-            }}
-        }}
-    }}
+            }
+        }
+    }
 
-    public sealed unsafe class SimpleTernaryOpTest__{2}{4}
-    {{
-        private const int VectorSize = {11};
+    public sealed unsafe class SimpleTernaryOpTest__{Method}{RetBaseType}
+    {
+        private const int VectorSize = {VectorSize};
 
-        private const int Op1ElementCount = VectorSize / sizeof({6});
-        private const int Op2ElementCount = VectorSize / sizeof({8});
-        private const int Op3ElementCount = VectorSize / sizeof({10});
-        private const int RetElementCount = VectorSize / sizeof({4});
+        private const int Op1ElementCount = VectorSize / sizeof({Op1BaseType});
+        private const int Op2ElementCount = VectorSize / sizeof({Op2BaseType});
+        private const int Op3ElementCount = VectorSize / sizeof({Op3BaseType});
+        private const int RetElementCount = VectorSize / sizeof({RetBaseType});
 
-        private static {6}[] _data1 = new {6}[Op1ElementCount];
-        private static {8}[] _data2 = new {8}[Op2ElementCount];
-        private static {10}[] _data3 = new {10}[Op3ElementCount];
+        private static {Op1BaseType}[] _data1 = new {Op1BaseType}[Op1ElementCount];
+        private static {Op2BaseType}[] _data2 = new {Op2BaseType}[Op2ElementCount];
+        private static {Op3BaseType}[] _data3 = new {Op3BaseType}[Op3ElementCount];
 
-        private static {5}<{6}> _clsVar1;
-        private static {7}<{8}> _clsVar2;
-        private static {9}<{10}> _clsVar3;
+        private static {Op1VectorType}<{Op1BaseType}> _clsVar1;
+        private static {Op2VectorType}<{Op2BaseType}> _clsVar2;
+        private static {Op3VectorType}<{Op3BaseType}> _clsVar3;
 
-        private {5}<{6}> _fld1;
-        private {7}<{8}> _fld2;
-        private {9}<{10}> _fld3;
+        private {Op1VectorType}<{Op1BaseType}> _fld1;
+        private {Op2VectorType}<{Op2BaseType}> _fld2;
+        private {Op3VectorType}<{Op3BaseType}> _fld3;
 
-        private SimpleTernaryOpTest__DataTable<{4}, {6}, {8}, {10}> _dataTable;
+        private SimpleTernaryOpTest__DataTable<{RetBaseType}, {Op1BaseType}, {Op2BaseType}, {Op3BaseType}> _dataTable;
 
-        static SimpleTernaryOpTest__{2}{4}()
-        {{
+        static SimpleTernaryOpTest__{Method}{RetBaseType}()
+        {
             var random = new Random();
 
-            for (var i = 0; i < Op1ElementCount; i++) {{ _data1[i] = {12}; }}
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{5}<{6}>, byte>(ref _clsVar1), ref Unsafe.As<{6}, byte>(ref _data1[0]), VectorSize);
-            for (var i = 0; i < Op2ElementCount; i++) {{ _data2[i] = {13}; }}
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{7}<{8}>, byte>(ref _clsVar2), ref Unsafe.As<{8}, byte>(ref _data2[0]), VectorSize);
-            for (var i = 0; i < Op3ElementCount; i++) {{ _data3[i] = {14}; }}
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{9}<{10}>, byte>(ref _clsVar3), ref Unsafe.As<{10}, byte>(ref _data3[0]), VectorSize);
-        }}
+            for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; }
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), VectorSize);
+            for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = {NextValueOp2}; }
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref _clsVar2), ref Unsafe.As<{Op2BaseType}, byte>(ref _data2[0]), VectorSize);
+            for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = {NextValueOp3}; }
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op3VectorType}<{Op3BaseType}>, byte>(ref _clsVar3), ref Unsafe.As<{Op3BaseType}, byte>(ref _data3[0]), VectorSize);
+        }
 
-        public SimpleTernaryOpTest__{2}{4}()
-        {{
+        public SimpleTernaryOpTest__{Method}{RetBaseType}()
+        {
             Succeeded = true;
 
             var random = new Random();
 
-            for (var i = 0; i < Op1ElementCount; i++) {{ _data1[i] = {12}; }}
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{5}<{6}>, byte>(ref _fld1), ref Unsafe.As<{6}, byte>(ref _data1[0]), VectorSize);
-            for (var i = 0; i < Op2ElementCount; i++) {{ _data2[i] = {13}; }}
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{7}<{8}>, byte>(ref _fld2), ref Unsafe.As<{8}, byte>(ref _data2[0]), VectorSize);
-            for (var i = 0; i < Op3ElementCount; i++) {{ _data3[i] = {14}; }}
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{9}<{10}>, byte>(ref _fld3), ref Unsafe.As<{10}, byte>(ref _data3[0]), VectorSize);
+            for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; }
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _fld1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), VectorSize);
+            for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = {NextValueOp2}; }
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref _fld2), ref Unsafe.As<{Op2BaseType}, byte>(ref _data2[0]), VectorSize);
+            for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = {NextValueOp3}; }
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op3VectorType}<{Op3BaseType}>, byte>(ref _fld3), ref Unsafe.As<{Op3BaseType}, byte>(ref _data3[0]), VectorSize);
 
-            for (var i = 0; i < Op1ElementCount; i++) {{ _data1[i] = {12}; }}
-            for (var i = 0; i < Op2ElementCount; i++) {{ _data2[i] = {13}; }}
-            for (var i = 0; i < Op3ElementCount; i++) {{ _data3[i] = {14}; }}
-            _dataTable = new SimpleTernaryOpTest__DataTable<{4}, {6}, {8}, {10}>(_data1, _data2, _data3, new {4}[RetElementCount], VectorSize);
-        }}
+            for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; }
+            for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = {NextValueOp2}; }
+            for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = {NextValueOp3}; }
+            _dataTable = new SimpleTernaryOpTest__DataTable<{RetBaseType}, {Op1BaseType}, {Op2BaseType}, {Op3BaseType}>(_data1, _data2, _data3, new {RetBaseType}[RetElementCount], VectorSize);
+        }
 
-        public bool IsSupported => {0}.IsSupported;
+        public bool IsSupported => {Isa}.IsSupported;
 
-        public bool Succeeded {{ get; set; }}
+        public bool Succeeded { get; set; }
 
         public void RunBasicScenario_UnsafeRead()
-        {{
-            var result = {0}.{2}(
-                Unsafe.Read<{5}<{6}>>(_dataTable.inArray1Ptr),
-                Unsafe.Read<{7}<{8}>>(_dataTable.inArray2Ptr),
-                Unsafe.Read<{9}<{10}>>(_dataTable.inArray3Ptr)
+        {
+            var result = {Isa}.{Method}(
+                Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArray1Ptr),
+                Unsafe.Read<{Op2VectorType}<{Op2BaseType}>>(_dataTable.inArray2Ptr),
+                Unsafe.Read<{Op3VectorType}<{Op3BaseType}>>(_dataTable.inArray3Ptr)
             );
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunBasicScenario_Load()
-        {{
-            var result = {0}.{2}(
-                {1}.Load{5}(({6}*)(_dataTable.inArray1Ptr)),
-                {1}.Load{7}(({8}*)(_dataTable.inArray2Ptr)),
-                {1}.Load{9}(({10}*)(_dataTable.inArray3Ptr))
+        {
+            var result = {Isa}.{Method}(
+                {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)),
+                {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr)),
+                {LoadIsa}.Load{Op3VectorType}(({Op3BaseType}*)(_dataTable.inArray3Ptr))
             );
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunBasicScenario_LoadAligned()
-        {{
-            var result = {0}.{2}(
-                {1}.LoadAligned{5}(({6}*)(_dataTable.inArray1Ptr)),
-                {1}.LoadAligned{7}(({8}*)(_dataTable.inArray2Ptr)),
-                {1}.LoadAligned{9}(({10}*)(_dataTable.inArray3Ptr))
+        {
+            var result = {Isa}.{Method}(
+                {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)),
+                {LoadIsa}.LoadAligned{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr)),
+                {LoadIsa}.LoadAligned{Op3VectorType}(({Op3BaseType}*)(_dataTable.inArray3Ptr))
             );
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunReflectionScenario_UnsafeRead()
-        {{
-            var result = typeof({0}).GetMethod(nameof({0}.{2}), new Type[] {{ typeof({5}<{6}>), typeof({7}<{8}>), typeof({9}<{10}>) }})
-                                     .Invoke(null, new object[] {{
-                                        Unsafe.Read<{5}<{6}>>(_dataTable.inArray1Ptr),
-                                        Unsafe.Read<{7}<{8}>>(_dataTable.inArray2Ptr),
-                                        Unsafe.Read<{9}<{10}>>(_dataTable.inArray3Ptr)
-                                     }});
-
-            Unsafe.Write(_dataTable.outArrayPtr, ({3}<{4}>)(result));
+        {
+            var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof({Op2VectorType}<{Op2BaseType}>), typeof({Op3VectorType}<{Op3BaseType}>) })
+                                     .Invoke(null, new object[] {
+                                        Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArray1Ptr),
+                                        Unsafe.Read<{Op2VectorType}<{Op2BaseType}>>(_dataTable.inArray2Ptr),
+                                        Unsafe.Read<{Op3VectorType}<{Op3BaseType}>>(_dataTable.inArray3Ptr)
+                                     });
+
+            Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result));
             ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunReflectionScenario_Load()
-        {{
-            var result = typeof({0}).GetMethod(nameof({0}.{2}), new Type[] {{ typeof({5}<{6}>), typeof({7}<{8}>), typeof({9}<{10}>) }})
-                                     .Invoke(null, new object[] {{
-                                        {1}.Load{5}(({6}*)(_dataTable.inArray1Ptr)),
-                                        {1}.Load{7}(({8}*)(_dataTable.inArray2Ptr)),
-                                        {1}.Load{9}(({10}*)(_dataTable.inArray3Ptr))
-                                     }});
-
-            Unsafe.Write(_dataTable.outArrayPtr, ({3}<{4}>)(result));
+        {
+            var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof({Op2VectorType}<{Op2BaseType}>), typeof({Op3VectorType}<{Op3BaseType}>) })
+                                     .Invoke(null, new object[] {
+                                        {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)),
+                                        {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr)),
+                                        {LoadIsa}.Load{Op3VectorType}(({Op3BaseType}*)(_dataTable.inArray3Ptr))
+                                     });
+
+            Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result));
             ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunReflectionScenario_LoadAligned()
-        {{
-            var result = typeof({0}).GetMethod(nameof({0}.{2}), new Type[] {{ typeof({5}<{6}>), typeof({7}<{8}>), typeof({9}<{10}>) }})
-                                     .Invoke(null, new object[] {{
-                                        {1}.LoadAligned{5}(({6}*)(_dataTable.inArray1Ptr)),
-                                        {1}.LoadAligned{7}(({8}*)(_dataTable.inArray2Ptr)),
-                                        {1}.LoadAligned{9}(({10}*)(_dataTable.inArray3Ptr))
-                                     }});
-
-            Unsafe.Write(_dataTable.outArrayPtr, ({3}<{4}>)(result));
+        {
+            var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof({Op2VectorType}<{Op2BaseType}>), typeof({Op3VectorType}<{Op3BaseType}>) })
+                                     .Invoke(null, new object[] {
+                                        {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)),
+                                        {LoadIsa}.LoadAligned{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr)),
+                                        {LoadIsa}.LoadAligned{Op3VectorType}(({Op3BaseType}*)(_dataTable.inArray3Ptr))
+                                     });
+
+            Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result));
             ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunClsVarScenario()
-        {{
-            var result = {0}.{2}(
+        {
+            var result = {Isa}.{Method}(
                 _clsVar1,
                 _clsVar2,
                 _clsVar3
@@ -226,129 +226,129 @@ namespace JIT.HardwareIntrinsics.X86
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(_clsVar1, _clsVar2, _clsVar3, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunLclVarScenario_UnsafeRead()
-        {{
-            var firstOp = Unsafe.Read<{5}<{6}>>(_dataTable.inArray1Ptr);
-            var secondOp = Unsafe.Read<{7}<{8}>>(_dataTable.inArray2Ptr);
-            var thirdOp = Unsafe.Read<{9}<{10}>>(_dataTable.inArray3Ptr);
-            var result = {0}.{2}(firstOp, secondOp, thirdOp);
+        {
+            var firstOp = Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArray1Ptr);
+            var secondOp = Unsafe.Read<{Op2VectorType}<{Op2BaseType}>>(_dataTable.inArray2Ptr);
+            var thirdOp = Unsafe.Read<{Op3VectorType}<{Op3BaseType}>>(_dataTable.inArray3Ptr);
+            var result = {Isa}.{Method}(firstOp, secondOp, thirdOp);
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(firstOp, secondOp, thirdOp, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunLclVarScenario_Load()
-        {{
-            var firstOp = {1}.Load{5}(({6}*)(_dataTable.inArray1Ptr));
-            var secondOp = {1}.Load{7}(({8}*)(_dataTable.inArray2Ptr));
-            var thirdOp = {1}.Load{9}(({10}*)(_dataTable.inArray3Ptr));
-            var result = {0}.{2}(firstOp, secondOp, thirdOp);
+        {
+            var firstOp = {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr));
+            var secondOp = {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr));
+            var thirdOp = {LoadIsa}.Load{Op3VectorType}(({Op3BaseType}*)(_dataTable.inArray3Ptr));
+            var result = {Isa}.{Method}(firstOp, secondOp, thirdOp);
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(firstOp, secondOp, thirdOp, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunLclVarScenario_LoadAligned()
-        {{
-            var firstOp = {1}.LoadAligned{5}(({6}*)(_dataTable.inArray1Ptr));
-            var secondOp = {1}.LoadAligned{7}(({8}*)(_dataTable.inArray2Ptr));
-            var thirdOp = {1}.LoadAligned{9}(({10}*)(_dataTable.inArray3Ptr));
-            var result = {0}.{2}(firstOp, secondOp, thirdOp);
+        {
+            var firstOp = {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr));
+            var secondOp = {LoadIsa}.LoadAligned{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr));
+            var thirdOp = {LoadIsa}.LoadAligned{Op3VectorType}(({Op3BaseType}*)(_dataTable.inArray3Ptr));
+            var result = {Isa}.{Method}(firstOp, secondOp, thirdOp);
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(firstOp, secondOp, thirdOp, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunLclFldScenario()
-        {{
-            var test = new SimpleTernaryOpTest__{2}{4}();
-            var result = {0}.{2}(test._fld1, test._fld2, test._fld3);
+        {
+            var test = new SimpleTernaryOpTest__{Method}{RetBaseType}();
+            var result = {Isa}.{Method}(test._fld1, test._fld2, test._fld3);
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunFldScenario()
-        {{
-            var result = {0}.{2}(_fld1, _fld2, _fld3);
+        {
+            var result = {Isa}.{Method}(_fld1, _fld2, _fld3);
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(_fld1, _fld2, _fld3, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunUnsupportedScenario()
-        {{
+        {
             Succeeded = false;
 
             try
-            {{
+            {
                 RunBasicScenario_UnsafeRead();
-            }}
+            }
             catch (PlatformNotSupportedException)
-            {{
+            {
                 Succeeded = true;
-            }}
-        }}
+            }
+        }
 
-        private void ValidateResult({5}<{6}> firstOp, {7}<{8}> secondOp, {9}<{10}> thirdOp, void* result, [CallerMemberName] string method = "")
-        {{
-            {6}[] inArray1 = new {6}[Op1ElementCount];
-            {8}[] inArray2 = new {8}[Op2ElementCount];
-            {10}[] inArray3 = new {10}[Op3ElementCount];
-            {4}[] outArray = new {4}[RetElementCount];
+        private void ValidateResult({Op1VectorType}<{Op1BaseType}> firstOp, {Op2VectorType}<{Op2BaseType}> secondOp, {Op3VectorType}<{Op3BaseType}> thirdOp, void* result, [CallerMemberName] string method = "")
+        {
+            {Op1BaseType}[] inArray1 = new {Op1BaseType}[Op1ElementCount];
+            {Op2BaseType}[] inArray2 = new {Op2BaseType}[Op2ElementCount];
+            {Op3BaseType}[] inArray3 = new {Op3BaseType}[Op3ElementCount];
+            {RetBaseType}[] outArray = new {RetBaseType}[RetElementCount];
 
             Unsafe.Write(Unsafe.AsPointer(ref inArray1[0]), firstOp);
             Unsafe.Write(Unsafe.AsPointer(ref inArray2[0]), secondOp);
             Unsafe.Write(Unsafe.AsPointer(ref inArray3[0]), thirdOp);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{4}, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), VectorSize);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{RetBaseType}, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), VectorSize);
 
             ValidateResult(inArray1, inArray2, inArray3, outArray, method);
-        }}
+        }
 
         private void ValidateResult(void* firstOp, void* secondOp, void* thirdOp, void* result, [CallerMemberName] string method = "")
-        {{
-            {6}[] inArray1 = new {6}[Op1ElementCount];
-            {8}[] inArray2 = new {8}[Op2ElementCount];
-            {10}[] inArray3 = new {10}[Op3ElementCount];
-            {4}[] outArray = new {4}[RetElementCount];
+        {
+            {Op1BaseType}[] inArray1 = new {Op1BaseType}[Op1ElementCount];
+            {Op2BaseType}[] inArray2 = new {Op2BaseType}[Op2ElementCount];
+            {Op3BaseType}[] inArray3 = new {Op3BaseType}[Op3ElementCount];
+            {RetBaseType}[] outArray = new {RetBaseType}[RetElementCount];
 
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{6}, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(firstOp), VectorSize);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{8}, byte>(ref inArray2[0]), ref Unsafe.AsRef<byte>(secondOp), VectorSize);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{10}, byte>(ref inArray3[0]), ref Unsafe.AsRef<byte>(thirdOp), VectorSize);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{4}, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), VectorSize);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1BaseType}, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(firstOp), VectorSize);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2BaseType}, byte>(ref inArray2[0]), ref Unsafe.AsRef<byte>(secondOp), VectorSize);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op3BaseType}, byte>(ref inArray3[0]), ref Unsafe.AsRef<byte>(thirdOp), VectorSize);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{RetBaseType}, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), VectorSize);
 
             ValidateResult(inArray1, inArray2, inArray3, outArray, method);
-        }}
+        }
 
-        private void ValidateResult({6}[] firstOp, {8}[] secondOp, {10}[] thirdOp, {4}[] result, [CallerMemberName] string method = "")
-        {{
-            if ({15})
-            {{
+        private void ValidateResult({Op1BaseType}[] firstOp, {Op2BaseType}[] secondOp, {Op3BaseType}[] thirdOp, {RetBaseType}[] result, [CallerMemberName] string method = "")
+        {
+            if ({ValidateFirstResult})
+            {
                 Succeeded = false;
-            }}
+            }
             else
-            {{
+            {
                 for (var i = 1; i < RetElementCount; i++)
-                {{
-                    if ({16})
-                    {{
+                {
+                    if ({ValidateRemainingResults})
+                    {
                         Succeeded = false;
                         break;
-                    }}
-                }}
-            }}
+                    }
+                }
+            }
 
             if (!Succeeded)
-            {{
-                Console.WriteLine($"{{nameof({0})}}.{{nameof({0}.{2})}}<{4}>({5}<{6}>, {7}<{8}>, {9}<{10}>): {{method}} failed:");
-                Console.WriteLine($"   firstOp: ({{string.Join(", ", firstOp)}})");
-                Console.WriteLine($"  secondOp: ({{string.Join(", ", secondOp)}})");
-                Console.WriteLine($"   thirdOp: ({{string.Join(", ", thirdOp)}})");
-                Console.WriteLine($"    result: ({{string.Join(", ", result)}})");
+            {
+                Console.WriteLine($"{nameof({Isa})}.{nameof({Isa}.{Method})}<{RetBaseType}>({Op1VectorType}<{Op1BaseType}>, {Op2VectorType}<{Op2BaseType}>, {Op3VectorType}<{Op3BaseType}>): {method} failed:");
+                Console.WriteLine($"   firstOp: ({string.Join(", ", firstOp)})");
+                Console.WriteLine($"  secondOp: ({string.Join(", ", secondOp)})");
+                Console.WriteLine($"   thirdOp: ({string.Join(", ", thirdOp)})");
+                Console.WriteLine($"    result: ({string.Join(", ", result)})");
                 Console.WriteLine();
-            }}
-        }}
-    }}
-}}
+            }
+        }
+    }
+}
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleUnOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleUnOpTest.template
index b166292ca5..ff0098aff2 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleUnOpTest.template
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleUnOpTest.template
@@ -16,38 +16,38 @@ using System.Runtime.Intrinsics;
 using System.Runtime.Intrinsics.X86;
 
 namespace JIT.HardwareIntrinsics.X86
-{{
+{
     public static partial class Program
-    {{
-        private static void {2}{4}()
-        {{
-            var test = new SimpleUnaryOpTest__{2}{4}();
+    {
+        private static void {Method}{RetBaseType}()
+        {
+            var test = new SimpleUnaryOpTest__{Method}{RetBaseType}();
 
             if (test.IsSupported)
-            {{
+            {
                 // Validates basic functionality works, using Unsafe.Read
                 test.RunBasicScenario_UnsafeRead();
 
-                if ({1}.IsSupported)
-                {{
+                if ({LoadIsa}.IsSupported)
+                {
                     // Validates basic functionality works, using Load
                     test.RunBasicScenario_Load();
 
                     // Validates basic functionality works, using LoadAligned
                     test.RunBasicScenario_LoadAligned();
-                }}
+                }
 
                 // Validates calling via reflection works, using Unsafe.Read
                 test.RunReflectionScenario_UnsafeRead();
 
-                if ({1}.IsSupported)
-                {{
+                if ({LoadIsa}.IsSupported)
+                {
                     // Validates calling via reflection works, using Load
                     test.RunReflectionScenario_Load();
 
                     // Validates calling via reflection works, using LoadAligned
                     test.RunReflectionScenario_LoadAligned();
-                }}
+                }
 
                 // Validates passing a static member works
                 test.RunClsVarScenario();
@@ -55,252 +55,252 @@ namespace JIT.HardwareIntrinsics.X86
                 // Validates passing a local works, using Unsafe.Read
                 test.RunLclVarScenario_UnsafeRead();
 
-                if ({1}.IsSupported)
-                {{
+                if ({LoadIsa}.IsSupported)
+                {
                     // Validates passing a local works, using Load
                     test.RunLclVarScenario_Load();
 
                     // Validates passing a local works, using LoadAligned
                     test.RunLclVarScenario_LoadAligned();
-                }}
+                }
 
                 // Validates passing the field of a local works
                 test.RunLclFldScenario();
 
                 // Validates passing an instance member works
                 test.RunFldScenario();
-            }}
+            }
             else
-            {{
+            {
                 // Validates we throw on unsupported hardware
                 test.RunUnsupportedScenario();
-            }}
+            }
 
             if (!test.Succeeded)
-            {{
+            {
                 throw new Exception("One or more scenarios did not complete as expected.");
-            }}
-        }}
-    }}
+            }
+        }
+    }
 
-    public sealed unsafe class SimpleUnaryOpTest__{2}{4}
-    {{
-        private const int VectorSize = {7};
+    public sealed unsafe class SimpleUnaryOpTest__{Method}{RetBaseType}
+    {
+        private const int VectorSize = {VectorSize};
 
-        private const int Op1ElementCount = VectorSize / sizeof({6});
-        private const int RetElementCount = VectorSize / sizeof({4});
+        private const int Op1ElementCount = VectorSize / sizeof({Op1BaseType});
+        private const int RetElementCount = VectorSize / sizeof({RetBaseType});
 
-        private static {6}[] _data = new {6}[Op1ElementCount];
+        private static {Op1BaseType}[] _data = new {Op1BaseType}[Op1ElementCount];
 
-        private static {5}<{6}> _clsVar;
+        private static {Op1VectorType}<{Op1BaseType}> _clsVar;
 
-        private {5}<{6}> _fld;
+        private {Op1VectorType}<{Op1BaseType}> _fld;
 
-        private SimpleUnaryOpTest__DataTable<{4}, {6}> _dataTable;
+        private SimpleUnaryOpTest__DataTable<{RetBaseType}, {Op1BaseType}> _dataTable;
 
-        static SimpleUnaryOpTest__{2}{4}()
-        {{
+        static SimpleUnaryOpTest__{Method}{RetBaseType}()
+        {
             var random = new Random();
 
-            for (var i = 0; i < Op1ElementCount; i++) {{ _data[i] = {8}; }}
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{5}<{6}>, byte>(ref _clsVar), ref Unsafe.As<{6}, byte>(ref _data[0]), VectorSize);
-        }}
+            for (var i = 0; i < Op1ElementCount; i++) { _data[i] = {NextValueOp1}; }
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar), ref Unsafe.As<{Op1BaseType}, byte>(ref _data[0]), VectorSize);
+        }
 
-        public SimpleUnaryOpTest__{2}{4}()
-        {{
+        public SimpleUnaryOpTest__{Method}{RetBaseType}()
+        {
             Succeeded = true;
 
             var random = new Random();
 
-            for (var i = 0; i < Op1ElementCount; i++) {{ _data[i] = {8}; }}
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{5}<{6}>, byte>(ref _fld), ref Unsafe.As<{6}, byte>(ref _data[0]), VectorSize);
+            for (var i = 0; i < Op1ElementCount; i++) { _data[i] = {NextValueOp1}; }
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _fld), ref Unsafe.As<{Op1BaseType}, byte>(ref _data[0]), VectorSize);
 
-            for (var i = 0; i < Op1ElementCount; i++) {{ _data[i] = {8}; }}
-            _dataTable = new SimpleUnaryOpTest__DataTable<{4}, {6}>(_data, new {4}[RetElementCount], VectorSize);
-        }}
+            for (var i = 0; i < Op1ElementCount; i++) { _data[i] = {NextValueOp1}; }
+            _dataTable = new SimpleUnaryOpTest__DataTable<{RetBaseType}, {Op1BaseType}>(_data, new {RetBaseType}[RetElementCount], VectorSize);
+        }
 
-        public bool IsSupported => {0}.IsSupported;
+        public bool IsSupported => {Isa}.IsSupported;
 
-        public bool Succeeded {{ get; set; }}
+        public bool Succeeded { get; set; }
 
         public void RunBasicScenario_UnsafeRead()
-        {{
-            var result = {0}.{2}(
-                Unsafe.Read<{5}<{6}>>(_dataTable.inArrayPtr)
+        {
+            var result = {Isa}.{Method}(
+                Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArrayPtr)
             );
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunBasicScenario_Load()
-        {{
-            var result = {0}.{2}(
-                {1}.Load{5}(({6}*)(_dataTable.inArrayPtr))
+        {
+            var result = {Isa}.{Method}(
+                {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr))
             );
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunBasicScenario_LoadAligned()
-        {{
-            var result = {0}.{2}(
-                {1}.LoadAligned{5}(({6}*)(_dataTable.inArrayPtr))
+        {
+            var result = {Isa}.{Method}(
+                {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr))
             );
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunReflectionScenario_UnsafeRead()
-        {{
-            var result = typeof({0}).GetMethod(nameof({0}.{2}), new Type[] {{ typeof({5}<{6}>) }})
-                                     .Invoke(null, new object[] {{
-                                        Unsafe.Read<{5}<{6}>>(_dataTable.inArrayPtr)
-                                     }});
+        {
+            var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>) })
+                                     .Invoke(null, new object[] {
+                                        Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArrayPtr)
+                                     });
 
-            Unsafe.Write(_dataTable.outArrayPtr, ({3}<{4}>)(result));
+            Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result));
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunReflectionScenario_Load()
-        {{
-            var result = typeof({0}).GetMethod(nameof({0}.{2}), new Type[] {{ typeof({5}<{6}>) }})
-                                     .Invoke(null, new object[] {{
-                                        {1}.Load{5}(({6}*)(_dataTable.inArrayPtr))
-                                     }});
+        {
+            var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>) })
+                                     .Invoke(null, new object[] {
+                                        {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr))
+                                     });
 
-            Unsafe.Write(_dataTable.outArrayPtr, ({3}<{4}>)(result));
+            Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result));
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunReflectionScenario_LoadAligned()
-        {{
-            var result = typeof({0}).GetMethod(nameof({0}.{2}), new Type[] {{ typeof({5}<{6}>) }})
-                                     .Invoke(null, new object[] {{
-                                        {1}.LoadAligned{5}(({6}*)(_dataTable.inArrayPtr))
-                                     }});
+        {
+            var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>) })
+                                     .Invoke(null, new object[] {
+                                        {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr))
+                                     });
 
-            Unsafe.Write(_dataTable.outArrayPtr, ({3}<{4}>)(result));
+            Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result));
             ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunClsVarScenario()
-        {{
-            var result = {0}.{2}(
+        {
+            var result = {Isa}.{Method}(
                 _clsVar
             );
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(_clsVar, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunLclVarScenario_UnsafeRead()
-        {{
-            var firstOp = Unsafe.Read<{5}<{6}>>(_dataTable.inArrayPtr);
-            var result = {0}.{2}(firstOp);
+        {
+            var firstOp = Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArrayPtr);
+            var result = {Isa}.{Method}(firstOp);
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(firstOp, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunLclVarScenario_Load()
-        {{
-            var firstOp = {1}.Load{5}(({6}*)(_dataTable.inArrayPtr));
-            var result = {0}.{2}(firstOp);
+        {
+            var firstOp = {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr));
+            var result = {Isa}.{Method}(firstOp);
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(firstOp, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunLclVarScenario_LoadAligned()
-        {{
-            var firstOp = {1}.LoadAligned{5}(({6}*)(_dataTable.inArrayPtr));
-            var result = {0}.{2}(firstOp);
+        {
+            var firstOp = {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr));
+            var result = {Isa}.{Method}(firstOp);
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(firstOp, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunLclFldScenario()
-        {{
-            var test = new SimpleUnaryOpTest__{2}{4}();
-            var result = {0}.{2}(test._fld);
+        {
+            var test = new SimpleUnaryOpTest__{Method}{RetBaseType}();
+            var result = {Isa}.{Method}(test._fld);
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(test._fld, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunFldScenario()
-        {{
-            var result = {0}.{2}(_fld);
+        {
+            var result = {Isa}.{Method}(_fld);
 
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(_fld, _dataTable.outArrayPtr);
-        }}
+        }
 
         public void RunUnsupportedScenario()
-        {{
+        {
             Succeeded = false;
 
             try
-            {{
+            {
                 RunBasicScenario_UnsafeRead();
-            }}
+            }
             catch (PlatformNotSupportedException)
-            {{
+            {
                 Succeeded = true;
-            }}
-        }}
+            }
+        }
 
-        private void ValidateResult({5}<{6}> firstOp, void* result, [CallerMemberName] string method = "")
-        {{
-            {6}[] inArray = new {6}[Op1ElementCount];
-            {4}[] outArray = new {4}[RetElementCount];
+        private void ValidateResult({Op1VectorType}<{Op1BaseType}> firstOp, void* result, [CallerMemberName] string method = "")
+        {
+            {Op1BaseType}[] inArray = new {Op1BaseType}[Op1ElementCount];
+            {RetBaseType}[] outArray = new {RetBaseType}[RetElementCount];
 
             Unsafe.Write(Unsafe.AsPointer(ref inArray[0]), firstOp);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{4}, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), VectorSize);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{RetBaseType}, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), VectorSize);
 
             ValidateResult(inArray, outArray, method);
-        }}
+        }
 
         private void ValidateResult(void* firstOp, void* result, [CallerMemberName] string method = "")
-        {{
-            {6}[] inArray = new {6}[Op1ElementCount];
-            {4}[] outArray = new {4}[RetElementCount];
+        {
+            {Op1BaseType}[] inArray = new {Op1BaseType}[Op1ElementCount];
+            {RetBaseType}[] outArray = new {RetBaseType}[RetElementCount];
 
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{6}, byte>(ref inArray[0]), ref Unsafe.AsRef<byte>(firstOp), VectorSize);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{4}, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), VectorSize);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1BaseType}, byte>(ref inArray[0]), ref Unsafe.AsRef<byte>(firstOp), VectorSize);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{RetBaseType}, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), VectorSize);
 
             ValidateResult(inArray, outArray, method);
-        }}
+        }
 
-        private void ValidateResult({6}[] firstOp, {4}[] result, [CallerMemberName] string method = "")
-        {{
-            if ({9})
-            {{
+        private void ValidateResult({Op1BaseType}[] firstOp, {RetBaseType}[] result, [CallerMemberName] string method = "")
+        {
+            if ({ValidateFirstResult})
+            {
                 Succeeded = false;
-            }}
+            }
             else
-            {{
+            {
                 for (var i = 1; i < RetElementCount; i++)
-                {{
-                    if ({10})
-                    {{
+                {
+                    if ({ValidateRemainingResults})
+                    {
                         Succeeded = false;
                         break;
-                    }}
-                }}
-            }}
+                    }
+                }
+            }
 
             if (!Succeeded)
-            {{
-                Console.WriteLine($"{{nameof({0})}}.{{nameof({0}.{2})}}<{4}>({5}<{6}>): {{method}} failed:");
-                Console.WriteLine($"  firstOp: ({{string.Join(", ", firstOp)}})");
-                Console.WriteLine($"   result: ({{string.Join(", ", result)}})");
+            {
+                Console.WriteLine($"{nameof({Isa})}.{nameof({Isa}.{Method})}<{RetBaseType}>({Op1VectorType}<{Op1BaseType}>): {method} failed:");
+                Console.WriteLine($"  firstOp: ({string.Join(", ", firstOp)})");
+                Console.WriteLine($"   result: ({string.Join(", ", result)})");
                 Console.WriteLine();
-            }}
-        }}
-    }}
-}}
+            }
+        }
+    }
+}
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Program.Sse2.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Program.Sse2.cs
index ec23caaa3a..cbfd3a9e7d 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Program.Sse2.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Program.Sse2.cs
@@ -64,6 +64,14 @@ namespace JIT.HardwareIntrinsics.X86
                 ["CompareOrdered.Double"] = CompareOrderedDouble,
                 ["CompareUnordered.Double"] = CompareUnorderedDouble,
                 ["Divide.Double"] = DivideDouble,
+                ["Extract.Int16.1"] = ExtractInt161,
+                ["Extract.UInt16.1"] = ExtractUInt161,
+                ["Extract.Int16.129"] = ExtractInt16129,
+                ["Extract.UInt16.129"] = ExtractUInt16129,
+                ["Insert.Int16.1"] = InsertInt161,
+                ["Insert.UInt16.1"] = InsertUInt161,
+                ["Insert.Int16.129"] = InsertInt16129,
+                ["Insert.UInt16.129"] = InsertUInt16129,
                 ["Max.Double"] = MaxDouble,
                 ["Max.Byte"] = MaxByte,
                 ["Max.Int16"] = MaxInt16,
@@ -80,24 +88,6 @@ namespace JIT.HardwareIntrinsics.X86
                 ["Or.UInt16"] = OrUInt16,
                 ["Or.UInt32"] = OrUInt32,
                 ["Or.UInt64"] = OrUInt64,
-                ["Subtract.Double"] = SubtractDouble,
-                ["Subtract.Byte"] = SubtractByte,
-                ["Subtract.Int16"] = SubtractInt16,
-                ["Subtract.Int32"] = SubtractInt32,
-                ["Subtract.Int64"] = SubtractInt64,
-                ["Subtract.SByte"] = SubtractSByte,
-                ["Subtract.UInt16"] = SubtractUInt16,
-                ["Subtract.UInt32"] = SubtractUInt32,
-                ["Subtract.UInt64"] = SubtractUInt64,
-                ["Xor.Double"] = XorDouble,
-                ["Xor.Byte"] = XorByte,
-                ["Xor.Int16"] = XorInt16,
-                ["Xor.Int32"] = XorInt32,
-                ["Xor.Int64"] = XorInt64,
-                ["Xor.SByte"] = XorSByte,
-                ["Xor.UInt16"] = XorUInt16,
-                ["Xor.UInt32"] = XorUInt32,
-                ["Xor.UInt64"] = XorUInt64,
                 ["ShiftLeftLogical.Int16.1"] = ShiftLeftLogicalInt161,
                 ["ShiftLeftLogical.UInt16.1"] = ShiftLeftLogicalUInt161,
                 ["ShiftLeftLogical.Int32.1"] = ShiftLeftLogicalInt321,
@@ -110,6 +100,18 @@ namespace JIT.HardwareIntrinsics.X86
                 ["ShiftLeftLogical.UInt32.32"] = ShiftLeftLogicalUInt3232,
                 ["ShiftLeftLogical.Int64.64"] = ShiftLeftLogicalInt6464,
                 ["ShiftLeftLogical.UInt64.64"] = ShiftLeftLogicalUInt6464,
+                ["ShiftLeftLogical128BitLane.SByte.1"] = ShiftLeftLogical128BitLaneSByte1,
+                ["ShiftLeftLogical128BitLane.Byte.1"] = ShiftLeftLogical128BitLaneByte1,
+                ["ShiftLeftLogical128BitLane.Int16.1"] = ShiftLeftLogical128BitLaneInt161,
+                ["ShiftLeftLogical128BitLane.UInt16.1"] = ShiftLeftLogical128BitLaneUInt161,
+                ["ShiftLeftLogical128BitLane.Int32.1"] = ShiftLeftLogical128BitLaneInt321,
+                ["ShiftLeftLogical128BitLane.UInt32.1"] = ShiftLeftLogical128BitLaneUInt321,
+                ["ShiftLeftLogical128BitLane.Int64.1"] = ShiftLeftLogical128BitLaneInt641,
+                ["ShiftLeftLogical128BitLane.UInt64.1"] = ShiftLeftLogical128BitLaneUInt641,
+                ["ShiftRightArithmetic.Int16.1"] = ShiftRightArithmeticInt161,
+                ["ShiftRightArithmetic.Int32.1"] = ShiftRightArithmeticInt321,
+                ["ShiftRightArithmetic.Int16.16"] = ShiftRightArithmeticInt1616,
+                ["ShiftRightArithmetic.Int32.32"] = ShiftRightArithmeticInt3232,
                 ["ShiftRightLogical.Int16.1"] = ShiftRightLogicalInt161,
                 ["ShiftRightLogical.UInt16.1"] = ShiftRightLogicalUInt161,
                 ["ShiftRightLogical.Int32.1"] = ShiftRightLogicalInt321,
@@ -122,18 +124,6 @@ namespace JIT.HardwareIntrinsics.X86
                 ["ShiftRightLogical.UInt32.32"] = ShiftRightLogicalUInt3232,
                 ["ShiftRightLogical.Int64.64"] = ShiftRightLogicalInt6464,
                 ["ShiftRightLogical.UInt64.64"] = ShiftRightLogicalUInt6464,
-                ["ShiftRightArithmetic.Int16.1"] = ShiftRightArithmeticInt161,
-                ["ShiftRightArithmetic.Int32.1"] = ShiftRightArithmeticInt321,
-                ["ShiftRightArithmetic.Int16.16"] = ShiftRightArithmeticInt1616,
-                ["ShiftRightArithmetic.Int32.32"] = ShiftRightArithmeticInt3232,
-                ["ShiftLeftLogical128BitLane.SByte.1"] = ShiftLeftLogical128BitLaneSByte1,
-                ["ShiftLeftLogical128BitLane.Byte.1"] = ShiftLeftLogical128BitLaneByte1,
-                ["ShiftLeftLogical128BitLane.Int16.1"] = ShiftLeftLogical128BitLaneInt161,
-                ["ShiftLeftLogical128BitLane.UInt16.1"] = ShiftLeftLogical128BitLaneUInt161,
-                ["ShiftLeftLogical128BitLane.Int32.1"] = ShiftLeftLogical128BitLaneInt321,
-                ["ShiftLeftLogical128BitLane.UInt32.1"] = ShiftLeftLogical128BitLaneUInt321,
-                ["ShiftLeftLogical128BitLane.Int64.1"] = ShiftLeftLogical128BitLaneInt641,
-                ["ShiftLeftLogical128BitLane.UInt64.1"] = ShiftLeftLogical128BitLaneUInt641,
                 ["ShiftRightLogical128BitLane.SByte.1"] = ShiftRightLogical128BitLaneSByte1,
                 ["ShiftRightLogical128BitLane.Byte.1"] = ShiftRightLogical128BitLaneByte1,
                 ["ShiftRightLogical128BitLane.Int16.1"] = ShiftRightLogical128BitLaneInt161,
@@ -142,14 +132,24 @@ namespace JIT.HardwareIntrinsics.X86
                 ["ShiftRightLogical128BitLane.UInt32.1"] = ShiftRightLogical128BitLaneUInt321,
                 ["ShiftRightLogical128BitLane.Int64.1"] = ShiftRightLogical128BitLaneInt641,
                 ["ShiftRightLogical128BitLane.UInt64.1"] = ShiftRightLogical128BitLaneUInt641,
-                ["Extract.Int16.1"] = ExtractInt161,
-                ["Extract.UInt16.1"] = ExtractUInt161,
-                ["Extract.Int16.129"] = ExtractInt16129,
-                ["Extract.UInt16.129"] = ExtractUInt16129,
-                ["Insert.Int16.1"] = InsertInt161,
-                ["Insert.UInt16.1"] = InsertUInt161,
-                ["Insert.Int16.129"] = InsertInt16129,
-                ["Insert.UInt16.129"] = InsertUInt16129,
+                ["Subtract.Double"] = SubtractDouble,
+                ["Subtract.Byte"] = SubtractByte,
+                ["Subtract.Int16"] = SubtractInt16,
+                ["Subtract.Int32"] = SubtractInt32,
+                ["Subtract.Int64"] = SubtractInt64,
+                ["Subtract.SByte"] = SubtractSByte,
+                ["Subtract.UInt16"] = SubtractUInt16,
+                ["Subtract.UInt32"] = SubtractUInt32,
+                ["Subtract.UInt64"] = SubtractUInt64,
+                ["Xor.Double"] = XorDouble,
+                ["Xor.Byte"] = XorByte,
+                ["Xor.Int16"] = XorInt16,
+                ["Xor.Int32"] = XorInt32,
+                ["Xor.Int64"] = XorInt64,
+                ["Xor.SByte"] = XorSByte,
+                ["Xor.UInt16"] = XorUInt16,
+                ["Xor.UInt32"] = XorUInt32,
+                ["Xor.UInt64"] = XorUInt64,
             };
         }
     }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Program.Sse41.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Program.Sse41.cs
index 6e56c9f2f4..7302624c09 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Program.Sse41.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Program.Sse41.cs
@@ -22,10 +22,38 @@ namespace JIT.HardwareIntrinsics.X86
                 ["CeilingScalar.Single"] = CeilingScalarSingle,
                 ["CompareEqual.Int64"] = CompareEqualInt64,
                 ["CompareEqual.UInt64"] = CompareEqualUInt64,
+                ["Extract.Byte.1"] = ExtractByte1,
+                ["Extract.SByte.1"] = ExtractSByte1,
+                ["Extract.Int32.1"] = ExtractInt321,
+                ["Extract.UInt32.1"] = ExtractUInt321,
+                ["Extract.Int64.1"] = ExtractInt641,
+                ["Extract.UInt64.1"] = ExtractUInt641,
+                ["Extract.Single.1"] = ExtractSingle1,
+                ["Extract.Byte.129"] = ExtractByte129,
+                ["Extract.SByte.129"] = ExtractSByte129,
+                ["Extract.Int32.129"] = ExtractInt32129,
+                ["Extract.UInt32.129"] = ExtractUInt32129,
+                ["Extract.Int64.129"] = ExtractInt64129,
+                ["Extract.UInt64.129"] = ExtractUInt64129,
+                ["Extract.Single.129"] = ExtractSingle129,
                 ["Floor.Double"] = FloorDouble,
                 ["Floor.Single"] = FloorSingle,
                 ["FloorScalar.Double"] = FloorScalarDouble,
                 ["FloorScalar.Single"] = FloorScalarSingle,
+                ["Insert.Byte.1"] = InsertByte1,
+                ["Insert.SByte.1"] = InsertSByte1,
+                ["Insert.Int32.1"] = InsertInt321,
+                ["Insert.UInt32.1"] = InsertUInt321,
+                ["Insert.Int64.1"] = InsertInt641,
+                ["Insert.UInt64.1"] = InsertUInt641,
+                ["Insert.Single.0"] = InsertSingle0,
+                ["Insert.Byte.129"] = InsertByte129,
+                ["Insert.SByte.129"] = InsertSByte129,
+                ["Insert.Int32.129"] = InsertInt32129,
+                ["Insert.UInt32.129"] = InsertUInt32129,
+                ["Insert.Int64.129"] = InsertInt64129,
+                ["Insert.UInt64.129"] = InsertUInt64129,
+                ["Insert.Single.217"] = InsertSingle217,
                 ["Max.Int32"] = MaxInt32,
                 ["Max.SByte"] = MaxSByte,
                 ["Max.UInt16"] = MaxUInt16,
@@ -104,34 +132,6 @@ namespace JIT.HardwareIntrinsics.X86
                 ["TestZ.UInt16"] = TestZUInt16,
                 ["TestZ.UInt32"] = TestZUInt32,
                 ["TestZ.UInt64"] = TestZUInt64,
-                ["Extract.Byte.1"] = ExtractByte1,
-                ["Extract.SByte.1"] = ExtractSByte1,
-                ["Extract.Int32.1"] = ExtractInt321,
-                ["Extract.UInt32.1"] = ExtractUInt321,
-                ["Extract.Int64.1"] = ExtractInt641,
-                ["Extract.UInt64.1"] = ExtractUInt641,
-                ["Extract.Single.1"] = ExtractSingle1,
-                ["Extract.Byte.129"] = ExtractByte129,
-                ["Extract.SByte.129"] = ExtractSByte129,
-                ["Extract.Int32.129"] = ExtractInt32129,
-                ["Extract.UInt32.129"] = ExtractUInt32129,
-                ["Extract.Int64.129"] = ExtractInt64129,
-                ["Extract.UInt64.129"] = ExtractUInt64129,
-                ["Extract.Single.129"] = ExtractSingle129,
-                ["Insert.Byte.1"] = InsertByte1,
-                ["Insert.SByte.1"] = InsertSByte1,
-                ["Insert.Int32.1"] = InsertInt321,
-                ["Insert.UInt32.1"] = InsertUInt321,
-                ["Insert.Int64.1"] = InsertInt641,
-                ["Insert.UInt64.1"] = InsertUInt641,
-                ["Insert.Single.0"] = InsertSingle0,
-                ["Insert.Byte.129"] = InsertByte129,
-                ["Insert.SByte.129"] = InsertSByte129,
-                ["Insert.Int32.129"] = InsertInt32129,
-                ["Insert.UInt32.129"] = InsertUInt32129,
-                ["Insert.Int64.129"] = InsertInt64129,
-                ["Insert.UInt64.129"] = InsertUInt64129,
-                ["Insert.Single.217"] = InsertSingle217,
             };
         }
     }