diff options
| author | Egor Bogatov <egorbo@gmail.com> | 2020-01-13 15:51:51 +0300 |
|---|---|---|
| committer | Zoltan Varga <vargaz@gmail.com> | 2020-01-13 15:51:51 +0300 |
| commit | 423192ed85c0b2263b46f3f4cfa63ec7b90b3f31 (patch) | |
| tree | 6b24b4136bbcf6dbaa7fd676cfb1c2ced40b7e59 /netcore | |
| parent | e92fe19fa62db2d74525eec55f06e8e05bf82f25 (diff) | |
[netcore][llvm] Implement Sse1-4.2 subsets used by corlib (#18103)
* Implement SSE41 subset used by corlib
* Implement Sse2.MoveMask
* only works with llvm
* Implement Sse3 and Ssse3 subsets used by corlib
* Implement a few SSE1 methods
* Address feedback, also, implement Sse.Add/Subtract
* Fix build
* Implement Sse.Multiply, Sse.Store
* Implement Sse.CompareNotEquals
* Implement Sse.MoveScalar
* Finish SSE1 corlib subset
* Implement Sse.LoadVector128, Sse.Shuffle
* Sse.Shuffle cleanup
* Implement Sse2 APIs
* More of SSE2: LoadAlignedVector128, Compare*
* Implement Sse2.Unpack* and Sse2.StoreScalar
* Implement Sse2.PackUnsignedSaturate
* Implement Sse2.ShiftRightLogical
* Implement Sse2.Shuffle
* Implement Vector128<T>.Zero
* Fix CreateScalarUnsafe
* Implement Vector128.As*, Fix Vector128.CreateScalarUnsafe
* Fix failures
* Fix failures
* Fix Sse.MoveMask
* remove redundant null checks
* Fix AOT failures
* fix compilation warrning
* rename create_vector_mask_*
* Fix failures found via tests
* Index in Sse41.Insert has to be a constant
* add local tests for mono
* Update tests (cleanup)
* Code cleanup
* test
* fix typo
* Clean up
* Clean up
* Implement And, AndNot, Or, Xor, Divide for Sse1
* Cleanup
* Fix build
* limit emit_vector128 with LLVM
* enable IsSupported for corlib
* Fix build on wasm (if-defs issue)
* Don't intrinsify Vector256
* Address feedback
Diffstat (limited to 'netcore')
| -rw-r--r--[-rwxr-xr-x] | netcore/Makefile | 22 | ||||
| -rw-r--r-- | netcore/tests/HwIntrinsics/HwIntrinsics.csproj | 11 | ||||
| -rw-r--r-- | netcore/tests/HwIntrinsics/Program.cs | 844 | ||||
| -rw-r--r-- | netcore/tests/HwIntrinsics/SRI-reference-data.txt | 595 |
4 files changed, 1472 insertions, 0 deletions
diff --git a/netcore/Makefile b/netcore/Makefile index 7c56582b3af..d96668e68ed 100755..100644 --- a/netcore/Makefile +++ b/netcore/Makefile @@ -274,6 +274,28 @@ run-tests-coreclr: prepare update-tests-coreclr corerun echo "Failed: $$failures" endif +run-tests-mono: prepare + failures=0; \ + counter=0; \ + test_prj_dir=''; \ + test_prj_name=''; \ + test_projects=$$(find tests -type f -name "*.csproj"); \ + for test_prj in $$test_projects; do \ + counter=$$((counter+1)); \ + echo "Running $$test_prj_dir"; \ + test_prj_dir=$$(dirname $$test_prj); \ + test_prj_name=$$(basename $$test_prj); \ + test_prj_name=$${test_prj_name%.*}; \ + $(DOTNET) build -c Release $$test_prj; \ + MONO_ENV_OPTIONS="--debug $(MONO_ENV_OPTIONS)" COMPlus_DebugWriteToStdErr=1 ./dotnet --fx-version "$(NETCOREAPP_VERSION)" $$test_prj_dir/bin/netcoreapp3.0/$$test_prj_name.dll; \ + if [ $$? -ne 0 ]; then \ + failures=$$((failures+1)); \ + fi; \ + done; \ + echo "======================"; \ + echo "Tests Count: $$counter"; \ + echo "Failed: $$failures" + run-tests-coreclr-%: prepare update-tests-coreclr @echo "" @echo "***************** $* *********************" diff --git a/netcore/tests/HwIntrinsics/HwIntrinsics.csproj b/netcore/tests/HwIntrinsics/HwIntrinsics.csproj new file mode 100644 index 00000000000..08cba7b3151 --- /dev/null +++ b/netcore/tests/HwIntrinsics/HwIntrinsics.csproj @@ -0,0 +1,11 @@ +<Project Sdk="Microsoft.NET.Sdk"> + <PropertyGroup> + <OutputType>Exe</OutputType> + <Optimize>True</Optimize> + <DebugType>Full</DebugType> + <OutputPath>bin</OutputPath> + <TargetFramework>netcoreapp3.0</TargetFramework> + <EnableSourceControlManagerQueries>false</EnableSourceControlManagerQueries> + <AllowUnsafeBlocks>true</AllowUnsafeBlocks> + </PropertyGroup> +</Project> diff --git a/netcore/tests/HwIntrinsics/Program.cs b/netcore/tests/HwIntrinsics/Program.cs new file mode 100644 index 00000000000..a906f23969a --- /dev/null +++ b/netcore/tests/HwIntrinsics/Program.cs @@ -0,0 +1,844 @@ +using System; +using System.IO; +using System.Linq; +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.X86; +using System.Text; + +class HWIntrinsicsTests +{ + static void Main () + { + bool generateReferenceData = false; // enable to update SRI-reference-data.txt (e.g. on CoreCLR for Mono) + int failures = 0; + string refDataFile = Path.Combine (Path.GetDirectoryName (Assembly.GetExecutingAssembly ().Location), "../../SRI-reference-data.txt"); + string [] refData = null; + + if (generateReferenceData) + File.Delete (refDataFile); + else + refData = File.ReadAllLines (refDataFile); + + int sse1Methods = typeof (Sse).GetMethods ().Length; + int sse2Methods = typeof (Sse2).GetMethods ().Length; + int sse3Methods = typeof (Sse3).GetMethods ().Length; + int ssse3Methods = typeof (Ssse3).GetMethods ().Length; + int sse41Methods = typeof (Sse41).GetMethods ().Length; + int sse42Methods = typeof (Sse42).GetMethods ().Length; + + Console.WriteLine ($"Sse: {sse1Methods} methods"); + Console.WriteLine ($"Sse2: {sse2Methods} methods"); + Console.WriteLine ($"Sse3: {sse3Methods} methods"); + Console.WriteLine ($"Ssse3: {ssse3Methods} methods"); + Console.WriteLine ($"Sse41: {sse41Methods} methods"); + Console.WriteLine ($"Sse42: {sse42Methods} methods"); + Console.WriteLine (); + + if (sse1Methods != 92) + throw new Exception ("New changes in Sse (don't forget to update simd-intrinsics-netcore.c if necessary)"); + if (sse2Methods != 302) + throw new Exception ("New changes in Sse2 (don't forget to update simd-intrinsics-netcore.c if necessary)"); + if (sse3Methods != 23) + throw new Exception ("New changes in Sse3 (don't forget to update simd-intrinsics-netcore.c if necessary)"); + if (ssse3Methods != 29) + throw new Exception ("New changes in Ssse3 (don't forget to update simd-intrinsics-netcore.c if necessary)"); + if (sse41Methods != 144) + throw new Exception ("New changes in Sse41 (don't forget to update simd-intrinsics-netcore.c if necessary)"); + if (sse42Methods != 9) + throw new Exception ("New changes in Sse42 (don't forget to update simd-intrinsics-netcore.c if necessary)"); + + int skipped = 0; + var tests = new SseTests (); + foreach (var method in typeof (SseTests).GetMethods () + .OrderBy (m => m.Name) // TODO: the default order is different in Mono + .Where (m => m.GetParameters ().Length == 0 && m.DeclaringType == typeof (SseTests))) + { + try + { + // clear test data each iteration + tests.ReloadArrays (); + var obj = method.Invoke (tests, null); + string array2Data = tests.GetArray2Data (); + string actualResult = $"{method.Name}: {obj}. array2: ({array2Data})\n"; + if (generateReferenceData) + { + File.AppendAllText (refDataFile, actualResult); + } + else + { + var expectedResult = refData.FirstOrDefault (l => l.StartsWith (method.Name)); + if (expectedResult.Trim ('\r', '\n', ' ') != actualResult.Trim ('\r', '\n', ' ')) + { + Console.WriteLine ($"[FAIL] Expected: {expectedResult}, Actual: {actualResult}"); + failures++; + } + } + } + catch (TargetInvocationException e) + { + if (e.GetBaseException () is PlatformNotSupportedException) // Not supported by Mono yet + { + skipped++; + continue; + } + throw; + } + } + + Console.WriteLine (); + Console.WriteLine ("Skipped: " + skipped); + Console.WriteLine ("Done."); + + if (failures != 0) + throw new Exception ("Test failed."); + } +} + +public unsafe class SseTests +{ + Random rand = new Random (42); + float* pArray1Float = null; + float* pArray2Float = null; + double* pArray1Double = null; + double* pArray2Double = null; + byte* pArray1 = null; + byte* pArray2 = null; + + // some SRI methods require memory to be aligned to 16bytes boundary (in case of Vector128) + static T* AllocateAligned<T> (int elements) where T : unmanaged + { + IntPtr ptr = Marshal.AllocHGlobal (elements * sizeof (T) + 15); + return (T*)(16 * (((long)ptr + 15) / 16)); + } + + public void ReloadArrays () + { + if (pArray1Float == null) + { + pArray1Float = AllocateAligned<float> (4); + pArray2Float = AllocateAligned<float> (4); + pArray1Double = AllocateAligned<double> (2); + pArray2Double = AllocateAligned<double> (2); + pArray1 = AllocateAligned<byte> (16); + pArray2 = AllocateAligned<byte> (16); + } + + for (byte i = 0; i < 16; i++) + { + pArray1 [i] = i; + pArray2 [i] = 0; + } + + for (int i = 0; i < 4; i++) + { + pArray1Float [i] = i / 2f; + pArray2Float [i] = 0; + } + + for (int i = 0; i < 2; i++) + { + pArray1Double [i] = i / 3f; + pArray2Double [i] = 0; + } + } + + private bool IsEmpty<T> (T* array) where T : unmanaged + { + for (var i = 0; i < Vector128<T>.Count; i++) + { + var item = array [i]; + if (item is float f && f != 0.0f) + return false; + if (item is double d && d != 0.0f) + return false; + if (item is byte b && b != 0) + return false; + } + return true; + } + + private string PrintArray<T> (T* array) where T : unmanaged + { + var sb = new StringBuilder (); + sb.Append ("<"); + for (var i = 0; i < Vector128<T>.Count; i++) + sb.Append (array [i]).Append (", "); + sb.Append (">"); + return sb.ToString ().Replace (", >", ">"); + } + + public string GetArray2Data () + { + if (!IsEmpty (pArray2)) + return PrintArray (pArray2); + if (!IsEmpty (pArray2Float)) + return PrintArray (pArray2Float); + if (!IsEmpty (pArray2Double)) + return PrintArray (pArray2Double); + return ""; + } + + [MethodImpl (MethodImplOptions.NoInlining)] + Vector128<T> GetV128<T> () where T : unmanaged + { + int randMult = 1; + int rand0_10 = rand.Next (0, 11); + if (rand0_10 % 3 == 0) + randMult = -1; + else if (rand0_10 > 8) + randMult = 0; + + if (typeof(T) == typeof (float)) + { + return Vector128.Create ( + (float)(rand.Next () * randMult) / 2.0f, + (float)(rand.Next () * randMult) / 3.0f, + (float)(rand.Next () * randMult) / 4.0f, + (float)(rand.Next () * randMult) / 5.0f).As<float, T> (); + } + else if (typeof(T) == typeof (double)) + { + return Vector128.Create ( + (double)(rand.Next () * randMult), + (double)(rand.Next () * randMult)).As<double, T> (); + } + + return Vector128.Create ( + rand.Next (0, int.MaxValue) * randMult, + rand.Next (0, int.MaxValue) * randMult, + rand.Next (0, int.MaxValue) * randMult, + rand.Next (0, int.MaxValue) * randMult).As<int, T> (); + } + + T Get<T> () + { + int randMult = 1; + int rand0_10 = rand.Next (0, 11); + if (rand0_10 % 3 == 0) + randMult = -1; + else if (rand0_10 > 8) + randMult = 0; + + if (typeof (T) == typeof (float)) + return (T)(object)(float)((rand.Next() * randMult) / 2.0f); + if (typeof (T) == typeof (double)) + return (T)(object)(double)((rand.Next() * randMult) / 2.0); + if (typeof (T) == typeof (byte)) + return (T)(object)(byte)((rand.Next (byte.MinValue, byte.MaxValue + 1))); + if (typeof (T) == typeof (sbyte)) + return (T)(object)(sbyte)((rand.Next (sbyte.MinValue, sbyte.MaxValue + 1))); + if (typeof (T) == typeof (short)) + return (T)(object)(short)((rand.Next (short.MinValue, short.MaxValue + 1))); + if (typeof (T) == typeof (ushort)) + return (T)(object)(ushort)((rand.Next (ushort.MinValue, ushort.MaxValue + 1))); + if (typeof (T) == typeof (int)) + return (T)(object)(int)((rand.Next (int.MinValue, int.MaxValue))); + if (typeof (T) == typeof (uint)) + return (T)(object)(uint)((rand.Next (int.MinValue, int.MaxValue))); + if (typeof (T) == typeof (long)) + return (T)(object)(long)((rand.Next (int.MinValue, int.MaxValue))); + if (typeof (T) == typeof (ulong)) + return (T)(object)(ulong)((rand.Next (int.MinValue, int.MaxValue))); + throw new NotSupportedException (); + } + + public Vector128<Single> Sse_Add_0() => Sse.Add(GetV128<Single>(), GetV128<Single>()); + public Vector128<Single> Sse_AddScalar_1() => Sse.AddScalar(GetV128<Single>(), GetV128<Single>()); + public Vector128<Single> Sse_And_2() => Sse.And(GetV128<Single>(), GetV128<Single>()); + public Vector128<Single> Sse_AndNot_3() => Sse.AndNot(GetV128<Single>(), GetV128<Single>()); + public Vector128<Single> Sse_CompareEqual_4() => Sse.CompareEqual(GetV128<Single>(), GetV128<Single>()); + public Vector128<Single> Sse_CompareGreaterThan_5() => Sse.CompareGreaterThan(GetV128<Single>(), GetV128<Single>()); + public Vector128<Single> Sse_CompareGreaterThanOrEqual_6() => Sse.CompareGreaterThanOrEqual(GetV128<Single>(), GetV128<Single>()); + public Vector128<Single> Sse_CompareLessThan_7() => Sse.CompareLessThan(GetV128<Single>(), GetV128<Single>()); + public Vector128<Single> Sse_CompareLessThanOrEqual_8() => Sse.CompareLessThanOrEqual(GetV128<Single>(), GetV128<Single>()); + public Vector128<Single> Sse_CompareNotEqual_9() => Sse.CompareNotEqual(GetV128<Single>(), GetV128<Single>()); + public Vector128<Single> Sse_CompareNotGreaterThan_10() => Sse.CompareNotGreaterThan(GetV128<Single>(), GetV128<Single>()); + public Vector128<Single> Sse_CompareNotGreaterThanOrEqual_11() => Sse.CompareNotGreaterThanOrEqual(GetV128<Single>(), GetV128<Single>()); + public Vector128<Single> Sse_CompareNotLessThan_12() => Sse.CompareNotLessThan(GetV128<Single>(), GetV128<Single>()); + public Vector128<Single> Sse_CompareNotLessThanOrEqual_13() => Sse.CompareNotLessThanOrEqual(GetV128<Single>(), GetV128<Single>()); + public Vector128<Single> Sse_CompareOrdered_14() => Sse.CompareOrdered(GetV128<Single>(), GetV128<Single>()); + public Vector128<Single> Sse_CompareScalarEqual_15() => Sse.CompareScalarEqual(GetV128<Single>(), GetV128<Single>()); + public Vector128<Single> Sse_CompareScalarGreaterThan_16() => Sse.CompareScalarGreaterThan(GetV128<Single>(), GetV128<Single>()); + public Vector128<Single> Sse_CompareScalarGreaterThanOrEqual_17() => Sse.CompareScalarGreaterThanOrEqual(GetV128<Single>(), GetV128<Single>()); + public Vector128<Single> Sse_CompareScalarLessThan_18() => Sse.CompareScalarLessThan(GetV128<Single>(), GetV128<Single>()); + public Vector128<Single> Sse_CompareScalarLessThanOrEqual_19() => Sse.CompareScalarLessThanOrEqual(GetV128<Single>(), GetV128<Single>()); + public Vector128<Single> Sse_CompareScalarNotEqual_20() => Sse.CompareScalarNotEqual(GetV128<Single>(), GetV128<Single>()); + public Vector128<Single> Sse_CompareScalarNotGreaterThan_21() => Sse.CompareScalarNotGreaterThan(GetV128<Single>(), GetV128<Single>()); + public Vector128<Single> Sse_CompareScalarNotGreaterThanOrEqual_22() => Sse.CompareScalarNotGreaterThanOrEqual(GetV128<Single>(), GetV128<Single>()); + public Vector128<Single> Sse_CompareScalarNotLessThan_23() => Sse.CompareScalarNotLessThan(GetV128<Single>(), GetV128<Single>()); + public Vector128<Single> Sse_CompareScalarNotLessThanOrEqual_24() => Sse.CompareScalarNotLessThanOrEqual(GetV128<Single>(), GetV128<Single>()); + public Vector128<Single> Sse_CompareScalarOrdered_25() => Sse.CompareScalarOrdered(GetV128<Single>(), GetV128<Single>()); + public Boolean Sse_CompareScalarOrderedEqual_26() => Sse.CompareScalarOrderedEqual(GetV128<Single>(), GetV128<Single>()); + public Boolean Sse_CompareScalarOrderedGreaterThan_27() => Sse.CompareScalarOrderedGreaterThan(GetV128<Single>(), GetV128<Single>()); + public Boolean Sse_CompareScalarOrderedGreaterThanOrEqual_28() => Sse.CompareScalarOrderedGreaterThanOrEqual(GetV128<Single>(), GetV128<Single>()); + public Boolean Sse_CompareScalarOrderedLessThan_29() => Sse.CompareScalarOrderedLessThan(GetV128<Single>(), GetV128<Single>()); + public Boolean Sse_CompareScalarOrderedLessThanOrEqual_30() => Sse.CompareScalarOrderedLessThanOrEqual(GetV128<Single>(), GetV128<Single>()); + public Boolean Sse_CompareScalarOrderedNotEqual_31() => Sse.CompareScalarOrderedNotEqual(GetV128<Single>(), GetV128<Single>()); + public Vector128<Single> Sse_CompareScalarUnordered_32() => Sse.CompareScalarUnordered(GetV128<Single>(), GetV128<Single>()); + public Boolean Sse_CompareScalarUnorderedEqual_33() => Sse.CompareScalarUnorderedEqual(GetV128<Single>(), GetV128<Single>()); + public Boolean Sse_CompareScalarUnorderedGreaterThan_34() => Sse.CompareScalarUnorderedGreaterThan(GetV128<Single>(), GetV128<Single>()); + public Boolean Sse_CompareScalarUnorderedGreaterThanOrEqual_35() => Sse.CompareScalarUnorderedGreaterThanOrEqual(GetV128<Single>(), GetV128<Single>()); + public Boolean Sse_CompareScalarUnorderedLessThan_36() => Sse.CompareScalarUnorderedLessThan(GetV128<Single>(), GetV128<Single>()); + public Boolean Sse_CompareScalarUnorderedLessThanOrEqual_37() => Sse.CompareScalarUnorderedLessThanOrEqual(GetV128<Single>(), GetV128<Single>()); + public Boolean Sse_CompareScalarUnorderedNotEqual_38() => Sse.CompareScalarUnorderedNotEqual(GetV128<Single>(), GetV128<Single>()); + public Vector128<Single> Sse_CompareUnordered_39() => Sse.CompareUnordered(GetV128<Single>(), GetV128<Single>()); + public Vector128<Single> Sse_ConvertScalarToVector128Single_40() => Sse.ConvertScalarToVector128Single(GetV128<Single>(), Get<System.Int32>()); + public Int32 Sse_ConvertToInt32_41() => Sse.ConvertToInt32(GetV128<Single>()); + public Int32 Sse_ConvertToInt32WithTruncation_42() => Sse.ConvertToInt32WithTruncation(GetV128<Single>()); + public Vector128<Single> Sse_Divide_43() => Sse.Divide(GetV128<Single>(), GetV128<Single>()); + public Vector128<Single> Sse_DivideScalar_44() => Sse.DivideScalar(GetV128<Single>(), GetV128<Single>()); + public Vector128<Single> Sse_LoadAlignedVector128_46() => Sse.LoadAlignedVector128((pArray1Float)); + public Vector128<Single> Sse_LoadHigh_47() => Sse.LoadHigh(GetV128<Single>(), pArray1Float); + public Vector128<Single> Sse_LoadLow_48() => Sse.LoadLow(GetV128<Single>(), pArray1Float); + public Vector128<Single> Sse_LoadScalarVector128_49() => Sse.LoadScalarVector128(pArray1Float); + public Vector128<Single> Sse_LoadVector128_50() => Sse.LoadVector128(pArray1Float); + public Vector128<Single> Sse_Max_51() => Sse.Max(GetV128<Single>(), GetV128<Single>()); + public Vector128<Single> Sse_MaxScalar_52() => Sse.MaxScalar(GetV128<Single>(), GetV128<Single>()); + public Vector128<Single> Sse_Min_53() => Sse.Min(GetV128<Single>(), GetV128<Single>()); + public Vector128<Single> Sse_MinScalar_54() => Sse.MinScalar(GetV128<Single>(), GetV128<Single>()); + public Vector128<Single> Sse_MoveHighToLow_55() => Sse.MoveHighToLow(GetV128<Single>(), GetV128<Single>()); + public Vector128<Single> Sse_MoveLowToHigh_56() => Sse.MoveLowToHigh(GetV128<Single>(), GetV128<Single>()); + public Int32 Sse_MoveMask_57() => Sse.MoveMask(GetV128<Single>()); + public Vector128<Single> Sse_MoveScalar_58() => Sse.MoveScalar(GetV128<Single>(), GetV128<Single>()); + public Vector128<Single> Sse_Multiply_59() => Sse.Multiply(GetV128<Single>(), GetV128<Single>()); + public Vector128<Single> Sse_MultiplyScalar_60() => Sse.MultiplyScalar(GetV128<Single>(), GetV128<Single>()); + public Vector128<Single> Sse_Or_61() => Sse.Or(GetV128<Single>(), GetV128<Single>()); + public void Sse_Prefetch0_62() => Sse.Prefetch0(pArray1); + public void Sse_Prefetch1_63() => Sse.Prefetch1(pArray1); + public void Sse_Prefetch2_64() => Sse.Prefetch2(pArray1); + public void Sse_PrefetchNonTemporal_65() => Sse.PrefetchNonTemporal(pArray1); + public Vector128<Single> Sse_Reciprocal_66() => Sse.Reciprocal(GetV128<Single>()); + public Vector128<Single> Sse_ReciprocalScalar_67() => Sse.ReciprocalScalar(GetV128<Single>()); + public Vector128<Single> Sse_ReciprocalScalar_68() => Sse.ReciprocalScalar(GetV128<Single>(), GetV128<Single>()); + public Vector128<Single> Sse_ReciprocalSqrt_69() => Sse.ReciprocalSqrt(GetV128<Single>()); + public Vector128<Single> Sse_ReciprocalSqrtScalar_70() => Sse.ReciprocalSqrtScalar(GetV128<Single>()); + public Vector128<Single> Sse_ReciprocalSqrtScalar_71() => Sse.ReciprocalSqrtScalar(GetV128<Single>(), GetV128<Single>()); + public Vector128<Single> Sse_Shuffle_72() => Sse.Shuffle(GetV128<Single>(), GetV128<Single>(), 22); + public Vector128<Single> Sse_Sqrt_73() => Sse.Sqrt(GetV128<Single>()); + public Vector128<Single> Sse_SqrtScalar_74() => Sse.SqrtScalar(GetV128<Single>()); + public Vector128<Single> Sse_SqrtScalar_75() => Sse.SqrtScalar(GetV128<Single>(), GetV128<Single>()); + public void Sse_Store_76() => Sse.Store(pArray2Float, GetV128<Single>()); + public void Sse_StoreAligned_77() => Sse.StoreAligned((pArray2Float), GetV128<Single>()); + public void Sse_StoreAlignedNonTemporal_78() => Sse.StoreAlignedNonTemporal((pArray2Float), GetV128<Single>()); + public void Sse_StoreFence_79() => Sse.StoreFence(); + public void Sse_StoreHigh_80() => Sse.StoreHigh(pArray2Float, GetV128<Single>()); + public void Sse_StoreLow_81() => Sse.StoreLow(pArray2Float, GetV128<Single>()); + public void Sse_StoreScalar_82() => Sse.StoreScalar(pArray2Float, GetV128<Single>()); + public Vector128<Single> Sse_Subtract_83() => Sse.Subtract(GetV128<Single>(), GetV128<Single>()); + public Vector128<Single> Sse_SubtractScalar_84() => Sse.SubtractScalar(GetV128<Single>(), GetV128<Single>()); + public Vector128<Single> Sse_UnpackHigh_85() => Sse.UnpackHigh(GetV128<Single>(), GetV128<Single>()); + public Vector128<Single> Sse_UnpackLow_86() => Sse.UnpackLow(GetV128<Single>(), GetV128<Single>()); + public Vector128<Single> Sse_Xor_87() => Sse.Xor(GetV128<Single>(), GetV128<Single>()); + public Vector128<Byte> Sse2_Add_0() => Sse2.Add(GetV128<Byte>(), GetV128<Byte>()); + public Vector128<SByte> Sse2_Add_1() => Sse2.Add(GetV128<SByte>(), GetV128<SByte>()); + public Vector128<Int16> Sse2_Add_2() => Sse2.Add(GetV128<Int16>(), GetV128<Int16>()); + public Vector128<UInt16> Sse2_Add_3() => Sse2.Add(GetV128<UInt16>(), GetV128<UInt16>()); + public Vector128<Int32> Sse2_Add_4() => Sse2.Add(GetV128<Int32>(), GetV128<Int32>()); + public Vector128<UInt32> Sse2_Add_5() => Sse2.Add(GetV128<UInt32>(), GetV128<UInt32>()); + public Vector128<Int64> Sse2_Add_6() => Sse2.Add(GetV128<Int64>(), GetV128<Int64>()); + public Vector128<UInt64> Sse2_Add_7() => Sse2.Add(GetV128<UInt64>(), GetV128<UInt64>()); + public Vector128<Double> Sse2_Add_8() => Sse2.Add(GetV128<Double>(), GetV128<Double>()); + public Vector128<SByte> Sse2_AddSaturate_9() => Sse2.AddSaturate(GetV128<SByte>(), GetV128<SByte>()); + public Vector128<Byte> Sse2_AddSaturate_10() => Sse2.AddSaturate(GetV128<Byte>(), GetV128<Byte>()); + public Vector128<Int16> Sse2_AddSaturate_11() => Sse2.AddSaturate(GetV128<Int16>(), GetV128<Int16>()); + public Vector128<UInt16> Sse2_AddSaturate_12() => Sse2.AddSaturate(GetV128<UInt16>(), GetV128<UInt16>()); + public Vector128<Double> Sse2_AddScalar_13() => Sse2.AddScalar(GetV128<Double>(), GetV128<Double>()); + public Vector128<Byte> Sse2_And_14() => Sse2.And(GetV128<Byte>(), GetV128<Byte>()); + public Vector128<SByte> Sse2_And_15() => Sse2.And(GetV128<SByte>(), GetV128<SByte>()); + public Vector128<Int16> Sse2_And_16() => Sse2.And(GetV128<Int16>(), GetV128<Int16>()); + public Vector128<UInt16> Sse2_And_17() => Sse2.And(GetV128<UInt16>(), GetV128<UInt16>()); + public Vector128<Int32> Sse2_And_18() => Sse2.And(GetV128<Int32>(), GetV128<Int32>()); + public Vector128<UInt32> Sse2_And_19() => Sse2.And(GetV128<UInt32>(), GetV128<UInt32>()); + public Vector128<Int64> Sse2_And_20() => Sse2.And(GetV128<Int64>(), GetV128<Int64>()); + public Vector128<UInt64> Sse2_And_21() => Sse2.And(GetV128<UInt64>(), GetV128<UInt64>()); + public Vector128<Double> Sse2_And_22() => Sse2.And(GetV128<Double>(), GetV128<Double>()); + public Vector128<Byte> Sse2_AndNot_23() => Sse2.AndNot(GetV128<Byte>(), GetV128<Byte>()); + public Vector128<SByte> Sse2_AndNot_24() => Sse2.AndNot(GetV128<SByte>(), GetV128<SByte>()); + public Vector128<Int16> Sse2_AndNot_25() => Sse2.AndNot(GetV128<Int16>(), GetV128<Int16>()); + public Vector128<UInt16> Sse2_AndNot_26() => Sse2.AndNot(GetV128<UInt16>(), GetV128<UInt16>()); + public Vector128<Int32> Sse2_AndNot_27() => Sse2.AndNot(GetV128<Int32>(), GetV128<Int32>()); + public Vector128<UInt32> Sse2_AndNot_28() => Sse2.AndNot(GetV128<UInt32>(), GetV128<UInt32>()); + public Vector128<Int64> Sse2_AndNot_29() => Sse2.AndNot(GetV128<Int64>(), GetV128<Int64>()); + public Vector128<UInt64> Sse2_AndNot_30() => Sse2.AndNot(GetV128<UInt64>(), GetV128<UInt64>()); + public Vector128<Double> Sse2_AndNot_31() => Sse2.AndNot(GetV128<Double>(), GetV128<Double>()); + public Vector128<Byte> Sse2_Average_32() => Sse2.Average(GetV128<Byte>(), GetV128<Byte>()); + public Vector128<UInt16> Sse2_Average_33() => Sse2.Average(GetV128<UInt16>(), GetV128<UInt16>()); + public Vector128<SByte> Sse2_CompareEqual_34() => Sse2.CompareEqual(GetV128<SByte>(), GetV128<SByte>()); + public Vector128<Byte> Sse2_CompareEqual_35() => Sse2.CompareEqual(GetV128<Byte>(), GetV128<Byte>()); + public Vector128<Int16> Sse2_CompareEqual_36() => Sse2.CompareEqual(GetV128<Int16>(), GetV128<Int16>()); + public Vector128<UInt16> Sse2_CompareEqual_37() => Sse2.CompareEqual(GetV128<UInt16>(), GetV128<UInt16>()); + public Vector128<Int32> Sse2_CompareEqual_38() => Sse2.CompareEqual(GetV128<Int32>(), GetV128<Int32>()); + public Vector128<UInt32> Sse2_CompareEqual_39() => Sse2.CompareEqual(GetV128<UInt32>(), GetV128<UInt32>()); + public Vector128<Double> Sse2_CompareEqual_40() => Sse2.CompareEqual(GetV128<Double>(), GetV128<Double>()); + public Vector128<SByte> Sse2_CompareGreaterThan_41() => Sse2.CompareGreaterThan(GetV128<SByte>(), GetV128<SByte>()); + public Vector128<Int16> Sse2_CompareGreaterThan_42() => Sse2.CompareGreaterThan(GetV128<Int16>(), GetV128<Int16>()); + public Vector128<Int32> Sse2_CompareGreaterThan_43() => Sse2.CompareGreaterThan(GetV128<Int32>(), GetV128<Int32>()); + public Vector128<Double> Sse2_CompareGreaterThan_44() => Sse2.CompareGreaterThan(GetV128<Double>(), GetV128<Double>()); + public Vector128<Double> Sse2_CompareGreaterThanOrEqual_45() => Sse2.CompareGreaterThanOrEqual(GetV128<Double>(), GetV128<Double>()); + public Vector128<SByte> Sse2_CompareLessThan_46() => Sse2.CompareLessThan(GetV128<SByte>(), GetV128<SByte>()); + public Vector128<Int16> Sse2_CompareLessThan_47() => Sse2.CompareLessThan(GetV128<Int16>(), GetV128<Int16>()); + public Vector128<Int32> Sse2_CompareLessThan_48() => Sse2.CompareLessThan(GetV128<Int32>(), GetV128<Int32>()); + public Vector128<Double> Sse2_CompareLessThan_49() => Sse2.CompareLessThan(GetV128<Double>(), GetV128<Double>()); + public Vector128<Double> Sse2_CompareLessThanOrEqual_50() => Sse2.CompareLessThanOrEqual(GetV128<Double>(), GetV128<Double>()); + public Vector128<Double> Sse2_CompareNotEqual_51() => Sse2.CompareNotEqual(GetV128<Double>(), GetV128<Double>()); + public Vector128<Double> Sse2_CompareNotGreaterThan_52() => Sse2.CompareNotGreaterThan(GetV128<Double>(), GetV128<Double>()); + public Vector128<Double> Sse2_CompareNotGreaterThanOrEqual_53() => Sse2.CompareNotGreaterThanOrEqual(GetV128<Double>(), GetV128<Double>()); + public Vector128<Double> Sse2_CompareNotLessThan_54() => Sse2.CompareNotLessThan(GetV128<Double>(), GetV128<Double>()); + public Vector128<Double> Sse2_CompareNotLessThanOrEqual_55() => Sse2.CompareNotLessThanOrEqual(GetV128<Double>(), GetV128<Double>()); + public Vector128<Double> Sse2_CompareOrdered_56() => Sse2.CompareOrdered(GetV128<Double>(), GetV128<Double>()); + public Vector128<Double> Sse2_CompareScalarEqual_57() => Sse2.CompareScalarEqual(GetV128<Double>(), GetV128<Double>()); + public Vector128<Double> Sse2_CompareScalarGreaterThan_58() => Sse2.CompareScalarGreaterThan(GetV128<Double>(), GetV128<Double>()); + public Vector128<Double> Sse2_CompareScalarGreaterThanOrEqual_59() => Sse2.CompareScalarGreaterThanOrEqual(GetV128<Double>(), GetV128<Double>()); + public Vector128<Double> Sse2_CompareScalarLessThan_60() => Sse2.CompareScalarLessThan(GetV128<Double>(), GetV128<Double>()); + public Vector128<Double> Sse2_CompareScalarLessThanOrEqual_61() => Sse2.CompareScalarLessThanOrEqual(GetV128<Double>(), GetV128<Double>()); + public Vector128<Double> Sse2_CompareScalarNotEqual_62() => Sse2.CompareScalarNotEqual(GetV128<Double>(), GetV128<Double>()); + public Vector128<Double> Sse2_CompareScalarNotGreaterThan_63() => Sse2.CompareScalarNotGreaterThan(GetV128<Double>(), GetV128<Double>()); + public Vector128<Double> Sse2_CompareScalarNotGreaterThanOrEqual_64() => Sse2.CompareScalarNotGreaterThanOrEqual(GetV128<Double>(), GetV128<Double>()); + public Vector128<Double> Sse2_CompareScalarNotLessThan_65() => Sse2.CompareScalarNotLessThan(GetV128<Double>(), GetV128<Double>()); + public Vector128<Double> Sse2_CompareScalarNotLessThanOrEqual_66() => Sse2.CompareScalarNotLessThanOrEqual(GetV128<Double>(), GetV128<Double>()); + public Vector128<Double> Sse2_CompareScalarOrdered_67() => Sse2.CompareScalarOrdered(GetV128<Double>(), GetV128<Double>()); + public Boolean Sse2_CompareScalarOrderedEqual_68() => Sse2.CompareScalarOrderedEqual(GetV128<Double>(), GetV128<Double>()); + public Boolean Sse2_CompareScalarOrderedGreaterThan_69() => Sse2.CompareScalarOrderedGreaterThan(GetV128<Double>(), GetV128<Double>()); + public Boolean Sse2_CompareScalarOrderedGreaterThanOrEqual_70() => Sse2.CompareScalarOrderedGreaterThanOrEqual(GetV128<Double>(), GetV128<Double>()); + public Boolean Sse2_CompareScalarOrderedLessThan_71() => Sse2.CompareScalarOrderedLessThan(GetV128<Double>(), GetV128<Double>()); + public Boolean Sse2_CompareScalarOrderedLessThanOrEqual_72() => Sse2.CompareScalarOrderedLessThanOrEqual(GetV128<Double>(), GetV128<Double>()); + public Boolean Sse2_CompareScalarOrderedNotEqual_73() => Sse2.CompareScalarOrderedNotEqual(GetV128<Double>(), GetV128<Double>()); + public Vector128<Double> Sse2_CompareScalarUnordered_74() => Sse2.CompareScalarUnordered(GetV128<Double>(), GetV128<Double>()); + public Boolean Sse2_CompareScalarUnorderedEqual_75() => Sse2.CompareScalarUnorderedEqual(GetV128<Double>(), GetV128<Double>()); + public Boolean Sse2_CompareScalarUnorderedGreaterThan_76() => Sse2.CompareScalarUnorderedGreaterThan(GetV128<Double>(), GetV128<Double>()); + public Boolean Sse2_CompareScalarUnorderedGreaterThanOrEqual_77() => Sse2.CompareScalarUnorderedGreaterThanOrEqual(GetV128<Double>(), GetV128<Double>()); + public Boolean Sse2_CompareScalarUnorderedLessThan_78() => Sse2.CompareScalarUnorderedLessThan(GetV128<Double>(), GetV128<Double>()); + public Boolean Sse2_CompareScalarUnorderedLessThanOrEqual_79() => Sse2.CompareScalarUnorderedLessThanOrEqual(GetV128<Double>(), GetV128<Double>()); + public Boolean Sse2_CompareScalarUnorderedNotEqual_80() => Sse2.CompareScalarUnorderedNotEqual(GetV128<Double>(), GetV128<Double>()); + public Vector128<Double> Sse2_CompareUnordered_81() => Sse2.CompareUnordered(GetV128<Double>(), GetV128<Double>()); + public Vector128<Double> Sse2_ConvertScalarToVector128Double_82() => Sse2.ConvertScalarToVector128Double(GetV128<Double>(), Get<System.Int32>()); + public Vector128<Double> Sse2_ConvertScalarToVector128Double_83() => Sse2.ConvertScalarToVector128Double(GetV128<Double>(), GetV128<Single>()); + public Vector128<Int32> Sse2_ConvertScalarToVector128Int32_84() => Sse2.ConvertScalarToVector128Int32(Get<System.Int32>()); + public Vector128<Single> Sse2_ConvertScalarToVector128Single_85() => Sse2.ConvertScalarToVector128Single(GetV128<Single>(), GetV128<Double>()); + public Vector128<UInt32> Sse2_ConvertScalarToVector128UInt32_86() => Sse2.ConvertScalarToVector128UInt32(Get<System.UInt32>()); + public Int32 Sse2_ConvertToInt32_87() => Sse2.ConvertToInt32(GetV128<Double>()); + public Int32 Sse2_ConvertToInt32_88() => Sse2.ConvertToInt32(GetV128<Int32>()); + public Int32 Sse2_ConvertToInt32WithTruncation_89() => Sse2.ConvertToInt32WithTruncation(GetV128<Double>()); + public UInt32 Sse2_ConvertToUInt32_90() => Sse2.ConvertToUInt32(GetV128<UInt32>()); + public Vector128<Double> Sse2_ConvertToVector128Double_91() => Sse2.ConvertToVector128Double(GetV128<Int32>()); + public Vector128<Double> Sse2_ConvertToVector128Double_92() => Sse2.ConvertToVector128Double(GetV128<Single>()); + public Vector128<Int32> Sse2_ConvertToVector128Int32_93() => Sse2.ConvertToVector128Int32(GetV128<Single>()); + public Vector128<Int32> Sse2_ConvertToVector128Int32_94() => Sse2.ConvertToVector128Int32(GetV128<Double>()); + public Vector128<Int32> Sse2_ConvertToVector128Int32WithTruncation_95() => Sse2.ConvertToVector128Int32WithTruncation(GetV128<Single>()); + public Vector128<Int32> Sse2_ConvertToVector128Int32WithTruncation_96() => Sse2.ConvertToVector128Int32WithTruncation(GetV128<Double>()); + public Vector128<Single> Sse2_ConvertToVector128Single_97() => Sse2.ConvertToVector128Single(GetV128<Int32>()); + public Vector128<Single> Sse2_ConvertToVector128Single_98() => Sse2.ConvertToVector128Single(GetV128<Double>()); + public Vector128<Double> Sse2_Divide_99() => Sse2.Divide(GetV128<Double>(), GetV128<Double>()); + public Vector128<Double> Sse2_DivideScalar_100() => Sse2.DivideScalar(GetV128<Double>(), GetV128<Double>()); + public UInt16 Sse2_Extract_101() => Sse2.Extract(GetV128<UInt16>(), Get<System.Byte>()); + public Vector128<Int16> Sse2_Insert_103() => Sse2.Insert(GetV128<Int16>(), Get<System.Int16>(), Get<System.Byte>()); + public Vector128<UInt16> Sse2_Insert_104() => Sse2.Insert(GetV128<UInt16>(), Get<System.UInt16>(), Get<System.Byte>()); + public Vector128<SByte> Sse2_LoadAlignedVector128_105() => Sse2.LoadAlignedVector128(((sbyte*)pArray1)); + public Vector128<Byte> Sse2_LoadAlignedVector128_106() => Sse2.LoadAlignedVector128(((byte*)pArray1)); + public Vector128<Int16> Sse2_LoadAlignedVector128_107() => Sse2.LoadAlignedVector128(((short*)pArray1)); + public Vector128<UInt16> Sse2_LoadAlignedVector128_108() => Sse2.LoadAlignedVector128(((ushort*)pArray1)); + public Vector128<Int32> Sse2_LoadAlignedVector128_109() => Sse2.LoadAlignedVector128(((int*)pArray1)); + public Vector128<UInt32> Sse2_LoadAlignedVector128_110() => Sse2.LoadAlignedVector128(((uint*)pArray1)); + public Vector128<Int64> Sse2_LoadAlignedVector128_111() => Sse2.LoadAlignedVector128(((long*)pArray1)); + public Vector128<UInt64> Sse2_LoadAlignedVector128_112() => Sse2.LoadAlignedVector128(((ulong*)pArray1)); + public Vector128<Double> Sse2_LoadAlignedVector128_113() => Sse2.LoadAlignedVector128((pArray1Double)); + public void Sse2_LoadFence_114() => Sse2.LoadFence(); + public Vector128<Double> Sse2_LoadHigh_115() => Sse2.LoadHigh(GetV128<Double>(), pArray1Double); + public Vector128<Double> Sse2_LoadLow_116() => Sse2.LoadLow(GetV128<Double>(), pArray1Double); + public Vector128<Double> Sse2_LoadScalarVector128_117() => Sse2.LoadScalarVector128(pArray1Double); + public Vector128<Int32> Sse2_LoadScalarVector128_118() => Sse2.LoadScalarVector128((int*)pArray1); + public Vector128<UInt32> Sse2_LoadScalarVector128_119() => Sse2.LoadScalarVector128((uint*)pArray1); + public Vector128<Int64> Sse2_LoadScalarVector128_120() => Sse2.LoadScalarVector128((long*)pArray1); + public Vector128<UInt64> Sse2_LoadScalarVector128_121() => Sse2.LoadScalarVector128((ulong*)pArray1); + public Vector128<SByte> Sse2_LoadVector128_122() => Sse2.LoadVector128((sbyte*)pArray1); + public Vector128<Byte> Sse2_LoadVector128_123() => Sse2.LoadVector128((byte*)pArray1); + public Vector128<Int16> Sse2_LoadVector128_124() => Sse2.LoadVector128((short*)pArray1); + public Vector128<UInt16> Sse2_LoadVector128_125() => Sse2.LoadVector128((ushort*)pArray1); + public Vector128<Int32> Sse2_LoadVector128_126() => Sse2.LoadVector128((int*)pArray1); + public Vector128<UInt32> Sse2_LoadVector128_127() => Sse2.LoadVector128((uint*)pArray1); + public Vector128<Int64> Sse2_LoadVector128_128() => Sse2.LoadVector128((long*)pArray1); + public Vector128<UInt64> Sse2_LoadVector128_129() => Sse2.LoadVector128((ulong*)pArray1); + public Vector128<Double> Sse2_LoadVector128_130() => Sse2.LoadVector128(pArray1Double); + public void Sse2_MaskMove_131() => Sse2.MaskMove(GetV128<SByte>(), GetV128<SByte>(), (sbyte*)pArray1); + public void Sse2_MaskMove_132() => Sse2.MaskMove(GetV128<Byte>(), GetV128<Byte>(), (byte*)pArray1); + public Vector128<Byte> Sse2_Max_133() => Sse2.Max(GetV128<Byte>(), GetV128<Byte>()); + public Vector128<Int16> Sse2_Max_134() => Sse2.Max(GetV128<Int16>(), GetV128<Int16>()); + public Vector128<Double> Sse2_Max_135() => Sse2.Max(GetV128<Double>(), GetV128<Double>()); + public Vector128<Double> Sse2_MaxScalar_136() => Sse2.MaxScalar(GetV128<Double>(), GetV128<Double>()); + public void Sse2_MemoryFence_137() => Sse2.MemoryFence(); + public Vector128<Byte> Sse2_Min_138() => Sse2.Min(GetV128<Byte>(), GetV128<Byte>()); + public Vector128<Int16> Sse2_Min_139() => Sse2.Min(GetV128<Int16>(), GetV128<Int16>()); + public Vector128<Double> Sse2_Min_140() => Sse2.Min(GetV128<Double>(), GetV128<Double>()); + public Vector128<Double> Sse2_MinScalar_141() => Sse2.MinScalar(GetV128<Double>(), GetV128<Double>()); + public Int32 Sse2_MoveMask_142() => Sse2.MoveMask(GetV128<SByte>()); + public Int32 Sse2_MoveMask_143() => Sse2.MoveMask(GetV128<Byte>()); + public Int32 Sse2_MoveMask_144() => Sse2.MoveMask(GetV128<Double>()); + public Vector128<Double> Sse2_MoveScalar_145() => Sse2.MoveScalar(GetV128<Double>(), GetV128<Double>()); + public Vector128<Int64> Sse2_MoveScalar_146() => Sse2.MoveScalar(GetV128<Int64>()); + public Vector128<UInt64> Sse2_MoveScalar_147() => Sse2.MoveScalar(GetV128<UInt64>()); + public Vector128<UInt64> Sse2_Multiply_148() => Sse2.Multiply(GetV128<UInt32>(), GetV128<UInt32>()); + public Vector128<Double> Sse2_Multiply_149() => Sse2.Multiply(GetV128<Double>(), GetV128<Double>()); + public Vector128<Int32> Sse2_MultiplyAddAdjacent_150() => Sse2.MultiplyAddAdjacent(GetV128<Int16>(), GetV128<Int16>()); + public Vector128<Int16> Sse2_MultiplyHigh_151() => Sse2.MultiplyHigh(GetV128<Int16>(), GetV128<Int16>()); + public Vector128<UInt16> Sse2_MultiplyHigh_152() => Sse2.MultiplyHigh(GetV128<UInt16>(), GetV128<UInt16>()); + public Vector128<Int16> Sse2_MultiplyLow_153() => Sse2.MultiplyLow(GetV128<Int16>(), GetV128<Int16>()); + public Vector128<UInt16> Sse2_MultiplyLow_154() => Sse2.MultiplyLow(GetV128<UInt16>(), GetV128<UInt16>()); + public Vector128<Double> Sse2_MultiplyScalar_155() => Sse2.MultiplyScalar(GetV128<Double>(), GetV128<Double>()); + public Vector128<Byte> Sse2_Or_156() => Sse2.Or(GetV128<Byte>(), GetV128<Byte>()); + public Vector128<SByte> Sse2_Or_157() => Sse2.Or(GetV128<SByte>(), GetV128<SByte>()); + public Vector128<Int16> Sse2_Or_158() => Sse2.Or(GetV128<Int16>(), GetV128<Int16>()); + public Vector128<UInt16> Sse2_Or_159() => Sse2.Or(GetV128<UInt16>(), GetV128<UInt16>()); + public Vector128<Int32> Sse2_Or_160() => Sse2.Or(GetV128<Int32>(), GetV128<Int32>()); + public Vector128<UInt32> Sse2_Or_161() => Sse2.Or(GetV128<UInt32>(), GetV128<UInt32>()); + public Vector128<Int64> Sse2_Or_162() => Sse2.Or(GetV128<Int64>(), GetV128<Int64>()); + public Vector128<UInt64> Sse2_Or_163() => Sse2.Or(GetV128<UInt64>(), GetV128<UInt64>()); + public Vector128<Double> Sse2_Or_164() => Sse2.Or(GetV128<Double>(), GetV128<Double>()); + public Vector128<SByte> Sse2_PackSignedSaturate_165() => Sse2.PackSignedSaturate(GetV128<Int16>(), GetV128<Int16>()); + public Vector128<Int16> Sse2_PackSignedSaturate_166() => Sse2.PackSignedSaturate(GetV128<Int32>(), GetV128<Int32>()); + public Vector128<Byte> Sse2_PackUnsignedSaturate_167() => Sse2.PackUnsignedSaturate(GetV128<Int16>(), GetV128<Int16>()); + public Vector128<Int16> Sse2_ShiftLeftLogical_168() => Sse2.ShiftLeftLogical(GetV128<Int16>(), GetV128<Int16>()); + public Vector128<UInt16> Sse2_ShiftLeftLogical_169() => Sse2.ShiftLeftLogical(GetV128<UInt16>(), GetV128<UInt16>()); + public Vector128<Int32> Sse2_ShiftLeftLogical_170() => Sse2.ShiftLeftLogical(GetV128<Int32>(), GetV128<Int32>()); + public Vector128<UInt32> Sse2_ShiftLeftLogical_171() => Sse2.ShiftLeftLogical(GetV128<UInt32>(), GetV128<UInt32>()); + public Vector128<Int64> Sse2_ShiftLeftLogical_172() => Sse2.ShiftLeftLogical(GetV128<Int64>(), GetV128<Int64>()); + public Vector128<UInt64> Sse2_ShiftLeftLogical_173() => Sse2.ShiftLeftLogical(GetV128<UInt64>(), GetV128<UInt64>()); + public Vector128<Int16> Sse2_ShiftLeftLogical_174() => Sse2.ShiftLeftLogical(GetV128<Int16>(), Get<System.Byte>()); + public Vector128<UInt16> Sse2_ShiftLeftLogical_175() => Sse2.ShiftLeftLogical(GetV128<UInt16>(), Get<System.Byte>()); + public Vector128<Int32> Sse2_ShiftLeftLogical_176() => Sse2.ShiftLeftLogical(GetV128<Int32>(), Get<System.Byte>()); + public Vector128<UInt32> Sse2_ShiftLeftLogical_177() => Sse2.ShiftLeftLogical(GetV128<UInt32>(), Get<System.Byte>()); + public Vector128<Int64> Sse2_ShiftLeftLogical_178() => Sse2.ShiftLeftLogical(GetV128<Int64>(), Get<System.Byte>()); + public Vector128<UInt64> Sse2_ShiftLeftLogical_179() => Sse2.ShiftLeftLogical(GetV128<UInt64>(), Get<System.Byte>()); + public Vector128<SByte> Sse2_ShiftLeftLogical128BitLane_180() => Sse2.ShiftLeftLogical128BitLane(GetV128<SByte>(), Get<System.Byte>()); + public Vector128<Byte> Sse2_ShiftLeftLogical128BitLane_181() => Sse2.ShiftLeftLogical128BitLane(GetV128<Byte>(), Get<System.Byte>()); + public Vector128<Int16> Sse2_ShiftLeftLogical128BitLane_182() => Sse2.ShiftLeftLogical128BitLane(GetV128<Int16>(), Get<System.Byte>()); + public Vector128<UInt16> Sse2_ShiftLeftLogical128BitLane_183() => Sse2.ShiftLeftLogical128BitLane(GetV128<UInt16>(), Get<System.Byte>()); + public Vector128<Int32> Sse2_ShiftLeftLogical128BitLane_184() => Sse2.ShiftLeftLogical128BitLane(GetV128<Int32>(), Get<System.Byte>()); + public Vector128<UInt32> Sse2_ShiftLeftLogical128BitLane_185() => Sse2.ShiftLeftLogical128BitLane(GetV128<UInt32>(), Get<System.Byte>()); + public Vector128<Int64> Sse2_ShiftLeftLogical128BitLane_186() => Sse2.ShiftLeftLogical128BitLane(GetV128<Int64>(), Get<System.Byte>()); + public Vector128<UInt64> Sse2_ShiftLeftLogical128BitLane_187() => Sse2.ShiftLeftLogical128BitLane(GetV128<UInt64>(), Get<System.Byte>()); + public Vector128<Int16> Sse2_ShiftRightArithmetic_188() => Sse2.ShiftRightArithmetic(GetV128<Int16>(), GetV128<Int16>()); + public Vector128<Int32> Sse2_ShiftRightArithmetic_189() => Sse2.ShiftRightArithmetic(GetV128<Int32>(), GetV128<Int32>()); + public Vector128<Int16> Sse2_ShiftRightArithmetic_190() => Sse2.ShiftRightArithmetic(GetV128<Int16>(), Get<System.Byte>()); + public Vector128<Int32> Sse2_ShiftRightArithmetic_191() => Sse2.ShiftRightArithmetic(GetV128<Int32>(), Get<System.Byte>()); + public Vector128<Int16> Sse2_ShiftRightLogical_192() => Sse2.ShiftRightLogical(GetV128<Int16>(), GetV128<Int16>()); + public Vector128<UInt16> Sse2_ShiftRightLogical_193() => Sse2.ShiftRightLogical(GetV128<UInt16>(), GetV128<UInt16>()); + public Vector128<Int32> Sse2_ShiftRightLogical_194() => Sse2.ShiftRightLogical(GetV128<Int32>(), GetV128<Int32>()); + public Vector128<UInt32> Sse2_ShiftRightLogical_195() => Sse2.ShiftRightLogical(GetV128<UInt32>(), GetV128<UInt32>()); + public Vector128<Int64> Sse2_ShiftRightLogical_196() => Sse2.ShiftRightLogical(GetV128<Int64>(), GetV128<Int64>()); + public Vector128<UInt64> Sse2_ShiftRightLogical_197() => Sse2.ShiftRightLogical(GetV128<UInt64>(), GetV128<UInt64>()); + public Vector128<Int16> Sse2_ShiftRightLogical_198() => Sse2.ShiftRightLogical(GetV128<Int16>(), Get<System.Byte>()); + public Vector128<UInt16> Sse2_ShiftRightLogical_199() => Sse2.ShiftRightLogical(GetV128<UInt16>(), Get<System.Byte>()); + public Vector128<Int32> Sse2_ShiftRightLogical_200() => Sse2.ShiftRightLogical(GetV128<Int32>(), Get<System.Byte>()); + public Vector128<UInt32> Sse2_ShiftRightLogical_201() => Sse2.ShiftRightLogical(GetV128<UInt32>(), Get<System.Byte>()); + public Vector128<Int64> Sse2_ShiftRightLogical_202() => Sse2.ShiftRightLogical(GetV128<Int64>(), Get<System.Byte>()); + public Vector128<UInt64> Sse2_ShiftRightLogical_203() => Sse2.ShiftRightLogical(GetV128<UInt64>(), Get<System.Byte>()); + public Vector128<SByte> Sse2_ShiftRightLogical128BitLane_204() => Sse2.ShiftRightLogical128BitLane(GetV128<SByte>(), Get<System.Byte>()); + public Vector128<Byte> Sse2_ShiftRightLogical128BitLane_205() => Sse2.ShiftRightLogical128BitLane(GetV128<Byte>(), Get<System.Byte>()); + public Vector128<Int16> Sse2_ShiftRightLogical128BitLane_206() => Sse2.ShiftRightLogical128BitLane(GetV128<Int16>(), Get<System.Byte>()); + public Vector128<UInt16> Sse2_ShiftRightLogical128BitLane_207() => Sse2.ShiftRightLogical128BitLane(GetV128<UInt16>(), Get<System.Byte>()); + public Vector128<Int32> Sse2_ShiftRightLogical128BitLane_208() => Sse2.ShiftRightLogical128BitLane(GetV128<Int32>(), Get<System.Byte>()); + public Vector128<UInt32> Sse2_ShiftRightLogical128BitLane_209() => Sse2.ShiftRightLogical128BitLane(GetV128<UInt32>(), Get<System.Byte>()); + public Vector128<Int64> Sse2_ShiftRightLogical128BitLane_210() => Sse2.ShiftRightLogical128BitLane(GetV128<Int64>(), Get<System.Byte>()); + public Vector128<UInt64> Sse2_ShiftRightLogical128BitLane_211() => Sse2.ShiftRightLogical128BitLane(GetV128<UInt64>(), Get<System.Byte>()); + public Vector128<UInt32> Sse2_Shuffle_212() => Sse2.Shuffle(GetV128<UInt32>(), 12); + public Vector128<Double> Sse2_Shuffle_213() => Sse2.Shuffle(GetV128<Double>(), GetV128<Double>(), 3); + public Vector128<Int32> Sse2_Shuffle_214() => Sse2.Shuffle(GetV128<Int32>(), 42); + public Vector128<Int16> Sse2_ShuffleHigh_215() => Sse2.ShuffleHigh(GetV128<Int16>(), 23); + public Vector128<UInt16> Sse2_ShuffleHigh_216() => Sse2.ShuffleHigh(GetV128<UInt16>(), 12); + public Vector128<Int16> Sse2_ShuffleLow_217() => Sse2.ShuffleLow(GetV128<Int16>(), 5); + public Vector128<UInt16> Sse2_ShuffleLow_218() => Sse2.ShuffleLow(GetV128<UInt16>(), 3); + public Vector128<Double> Sse2_Sqrt_219() => Sse2.Sqrt(GetV128<Double>()); + public Vector128<Double> Sse2_SqrtScalar_220() => Sse2.SqrtScalar(GetV128<Double>()); + public Vector128<Double> Sse2_SqrtScalar_221() => Sse2.SqrtScalar(GetV128<Double>(), GetV128<Double>()); + public void Sse2_Store_222() => Sse2.Store((sbyte*)pArray2, GetV128<SByte>()); + public void Sse2_Store_223() => Sse2.Store((byte*)pArray2, GetV128<Byte>()); + public void Sse2_Store_224() => Sse2.Store((short*)pArray2, GetV128<Int16>()); + public void Sse2_Store_225() => Sse2.Store((ushort*)pArray2, GetV128<UInt16>()); + public void Sse2_Store_226() => Sse2.Store((int*)pArray2, GetV128<Int32>()); + public void Sse2_Store_227() => Sse2.Store((uint*)pArray2, GetV128<UInt32>()); + public void Sse2_Store_228() => Sse2.Store((long*)pArray2, GetV128<Int64>()); + public void Sse2_Store_229() => Sse2.Store((ulong*)pArray2, GetV128<UInt64>()); + public void Sse2_Store_230() => Sse2.Store(pArray1Double, GetV128<Double>()); + public void Sse2_StoreAligned_231() => Sse2.StoreAligned(((sbyte*)pArray2), GetV128<SByte>()); + public void Sse2_StoreAligned_232() => Sse2.StoreAligned(((byte*)pArray2), GetV128<Byte>()); + public void Sse2_StoreAligned_233() => Sse2.StoreAligned(((short*)pArray2), GetV128<Int16>()); + public void Sse2_StoreAligned_234() => Sse2.StoreAligned(((ushort*)pArray2), GetV128<UInt16>()); + public void Sse2_StoreAligned_235() => Sse2.StoreAligned(((int*)pArray2), GetV128<Int32>()); + public void Sse2_StoreAligned_236() => Sse2.StoreAligned(((uint*)pArray2), GetV128<UInt32>()); + public void Sse2_StoreAligned_237() => Sse2.StoreAligned(((long*)pArray2), GetV128<Int64>()); + public void Sse2_StoreAligned_238() => Sse2.StoreAligned(((ulong*)pArray2), GetV128<UInt64>()); + public void Sse2_StoreAligned_239() => Sse2.StoreAligned((pArray2Double), GetV128<Double>()); + public void Sse2_StoreAlignedNonTemporal_240() => Sse2.StoreAlignedNonTemporal(((sbyte*)pArray2), GetV128<SByte>()); + public void Sse2_StoreAlignedNonTemporal_241() => Sse2.StoreAlignedNonTemporal(((byte*)pArray2), GetV128<Byte>()); + public void Sse2_StoreAlignedNonTemporal_242() => Sse2.StoreAlignedNonTemporal(((short*)pArray2), GetV128<Int16>()); + public void Sse2_StoreAlignedNonTemporal_243() => Sse2.StoreAlignedNonTemporal(((ushort*)pArray2), GetV128<UInt16>()); + public void Sse2_StoreAlignedNonTemporal_244() => Sse2.StoreAlignedNonTemporal(((int*)pArray2), GetV128<Int32>()); + public void Sse2_StoreAlignedNonTemporal_245() => Sse2.StoreAlignedNonTemporal(((uint*)pArray2), GetV128<UInt32>()); + public void Sse2_StoreAlignedNonTemporal_246() => Sse2.StoreAlignedNonTemporal(((long*)pArray2), GetV128<Int64>()); + public void Sse2_StoreAlignedNonTemporal_247() => Sse2.StoreAlignedNonTemporal(((ulong*)pArray2), GetV128<UInt64>()); + public void Sse2_StoreAlignedNonTemporal_248() => Sse2.StoreAlignedNonTemporal((pArray2Double), GetV128<Double>()); + public void Sse2_StoreHigh_249() => Sse2.StoreHigh(pArray2Double, GetV128<Double>()); + public void Sse2_StoreLow_250() => Sse2.StoreLow(pArray2Double, GetV128<Double>()); + public void Sse2_StoreNonTemporal_251() => Sse2.StoreNonTemporal((int*)pArray2, Get<System.Int32>()); + public void Sse2_StoreNonTemporal_252() => Sse2.StoreNonTemporal((uint*)pArray2, Get<System.UInt32>()); + public void Sse2_StoreScalar_253() => Sse2.StoreScalar(pArray2Double, GetV128<Double>()); + public void Sse2_StoreScalar_254() => Sse2.StoreScalar((long*)pArray2, GetV128<Int64>()); + public void Sse2_StoreScalar_255() => Sse2.StoreScalar((ulong*)pArray2, GetV128<UInt64>()); + public Vector128<Byte> Sse2_Subtract_256() => Sse2.Subtract(GetV128<Byte>(), GetV128<Byte>()); + public Vector128<SByte> Sse2_Subtract_257() => Sse2.Subtract(GetV128<SByte>(), GetV128<SByte>()); + public Vector128<Int16> Sse2_Subtract_258() => Sse2.Subtract(GetV128<Int16>(), GetV128<Int16>()); + public Vector128<UInt16> Sse2_Subtract_259() => Sse2.Subtract(GetV128<UInt16>(), GetV128<UInt16>()); + public Vector128<Int32> Sse2_Subtract_260() => Sse2.Subtract(GetV128<Int32>(), GetV128<Int32>()); + public Vector128<UInt32> Sse2_Subtract_261() => Sse2.Subtract(GetV128<UInt32>(), GetV128<UInt32>()); + public Vector128<Int64> Sse2_Subtract_262() => Sse2.Subtract(GetV128<Int64>(), GetV128<Int64>()); + public Vector128<UInt64> Sse2_Subtract_263() => Sse2.Subtract(GetV128<UInt64>(), GetV128<UInt64>()); + public Vector128<Double> Sse2_Subtract_264() => Sse2.Subtract(GetV128<Double>(), GetV128<Double>()); + public Vector128<SByte> Sse2_SubtractSaturate_265() => Sse2.SubtractSaturate(GetV128<SByte>(), GetV128<SByte>()); + public Vector128<Int16> Sse2_SubtractSaturate_266() => Sse2.SubtractSaturate(GetV128<Int16>(), GetV128<Int16>()); + public Vector128<Byte> Sse2_SubtractSaturate_267() => Sse2.SubtractSaturate(GetV128<Byte>(), GetV128<Byte>()); + public Vector128<UInt16> Sse2_SubtractSaturate_268() => Sse2.SubtractSaturate(GetV128<UInt16>(), GetV128<UInt16>()); + public Vector128<Double> Sse2_SubtractScalar_269() => Sse2.SubtractScalar(GetV128<Double>(), GetV128<Double>()); + public Vector128<UInt16> Sse2_SumAbsoluteDifferences_270() => Sse2.SumAbsoluteDifferences(GetV128<Byte>(), GetV128<Byte>()); + public Vector128<Byte> Sse2_UnpackHigh_271() => Sse2.UnpackHigh(GetV128<Byte>(), GetV128<Byte>()); + public Vector128<SByte> Sse2_UnpackHigh_272() => Sse2.UnpackHigh(GetV128<SByte>(), GetV128<SByte>()); + public Vector128<Int16> Sse2_UnpackHigh_273() => Sse2.UnpackHigh(GetV128<Int16>(), GetV128<Int16>()); + public Vector128<UInt16> Sse2_UnpackHigh_274() => Sse2.UnpackHigh(GetV128<UInt16>(), GetV128<UInt16>()); + public Vector128<Int32> Sse2_UnpackHigh_275() => Sse2.UnpackHigh(GetV128<Int32>(), GetV128<Int32>()); + public Vector128<UInt32> Sse2_UnpackHigh_276() => Sse2.UnpackHigh(GetV128<UInt32>(), GetV128<UInt32>()); + public Vector128<Int64> Sse2_UnpackHigh_277() => Sse2.UnpackHigh(GetV128<Int64>(), GetV128<Int64>()); + public Vector128<UInt64> Sse2_UnpackHigh_278() => Sse2.UnpackHigh(GetV128<UInt64>(), GetV128<UInt64>()); + public Vector128<Double> Sse2_UnpackHigh_279() => Sse2.UnpackHigh(GetV128<Double>(), GetV128<Double>()); + public Vector128<Byte> Sse2_UnpackLow_280() => Sse2.UnpackLow(GetV128<Byte>(), GetV128<Byte>()); + public Vector128<SByte> Sse2_UnpackLow_281() => Sse2.UnpackLow(GetV128<SByte>(), GetV128<SByte>()); + public Vector128<Int16> Sse2_UnpackLow_282() => Sse2.UnpackLow(GetV128<Int16>(), GetV128<Int16>()); + public Vector128<UInt16> Sse2_UnpackLow_283() => Sse2.UnpackLow(GetV128<UInt16>(), GetV128<UInt16>()); + public Vector128<Int32> Sse2_UnpackLow_284() => Sse2.UnpackLow(GetV128<Int32>(), GetV128<Int32>()); + public Vector128<UInt32> Sse2_UnpackLow_285() => Sse2.UnpackLow(GetV128<UInt32>(), GetV128<UInt32>()); + public Vector128<Int64> Sse2_UnpackLow_286() => Sse2.UnpackLow(GetV128<Int64>(), GetV128<Int64>()); + public Vector128<UInt64> Sse2_UnpackLow_287() => Sse2.UnpackLow(GetV128<UInt64>(), GetV128<UInt64>()); + public Vector128<Double> Sse2_UnpackLow_288() => Sse2.UnpackLow(GetV128<Double>(), GetV128<Double>()); + public Vector128<Byte> Sse2_Xor_289() => Sse2.Xor(GetV128<Byte>(), GetV128<Byte>()); + public Vector128<SByte> Sse2_Xor_290() => Sse2.Xor(GetV128<SByte>(), GetV128<SByte>()); + public Vector128<Int16> Sse2_Xor_291() => Sse2.Xor(GetV128<Int16>(), GetV128<Int16>()); + public Vector128<UInt16> Sse2_Xor_292() => Sse2.Xor(GetV128<UInt16>(), GetV128<UInt16>()); + public Vector128<Int32> Sse2_Xor_293() => Sse2.Xor(GetV128<Int32>(), GetV128<Int32>()); + public Vector128<UInt32> Sse2_Xor_294() => Sse2.Xor(GetV128<UInt32>(), GetV128<UInt32>()); + public Vector128<Int64> Sse2_Xor_295() => Sse2.Xor(GetV128<Int64>(), GetV128<Int64>()); + public Vector128<UInt64> Sse2_Xor_296() => Sse2.Xor(GetV128<UInt64>(), GetV128<UInt64>()); + public Vector128<Double> Sse2_Xor_297() => Sse2.Xor(GetV128<Double>(), GetV128<Double>()); + public Vector128<Single> Sse3_AddSubtract_0() => Sse3.AddSubtract(GetV128<Single>(), GetV128<Single>()); + public Vector128<Double> Sse3_AddSubtract_1() => Sse3.AddSubtract(GetV128<Double>(), GetV128<Double>()); + public Vector128<Single> Sse3_HorizontalAdd_3() => Sse3.HorizontalAdd(GetV128<Single>(), GetV128<Single>()); + public Vector128<Double> Sse3_HorizontalAdd_4() => Sse3.HorizontalAdd(GetV128<Double>(), GetV128<Double>()); + public Vector128<Single> Sse3_HorizontalSubtract_5() => Sse3.HorizontalSubtract(GetV128<Single>(), GetV128<Single>()); + public Vector128<Double> Sse3_HorizontalSubtract_6() => Sse3.HorizontalSubtract(GetV128<Double>(), GetV128<Double>()); + public Vector128<Double> Sse3_LoadAndDuplicateToVector128_7() => Sse3.LoadAndDuplicateToVector128(pArray1Double); + public Vector128<SByte> Sse3_LoadDquVector128_8() => Sse3.LoadDquVector128((sbyte*)pArray1); + public Vector128<Byte> Sse3_LoadDquVector128_9() => Sse3.LoadDquVector128((byte*)pArray1); + public Vector128<Int16> Sse3_LoadDquVector128_10() => Sse3.LoadDquVector128((short*)pArray1); + public Vector128<UInt16> Sse3_LoadDquVector128_11() => Sse3.LoadDquVector128((ushort*)pArray1); + public Vector128<Int32> Sse3_LoadDquVector128_12() => Sse3.LoadDquVector128((int*)pArray1); + public Vector128<UInt32> Sse3_LoadDquVector128_13() => Sse3.LoadDquVector128((uint*)pArray1); + public Vector128<Int64> Sse3_LoadDquVector128_14() => Sse3.LoadDquVector128((long*)pArray1); + public Vector128<UInt64> Sse3_LoadDquVector128_15() => Sse3.LoadDquVector128((ulong*)pArray1); + public Vector128<Double> Sse3_MoveAndDuplicate_16() => Sse3.MoveAndDuplicate(GetV128<Double>()); + public Vector128<Single> Sse3_MoveHighAndDuplicate_17() => Sse3.MoveHighAndDuplicate(GetV128<Single>()); + public Vector128<Single> Sse3_MoveLowAndDuplicate_18() => Sse3.MoveLowAndDuplicate(GetV128<Single>()); + public Vector128<Byte> Ssse3_Abs_0() => Ssse3.Abs(GetV128<SByte>()); + public Vector128<UInt16> Ssse3_Abs_1() => Ssse3.Abs(GetV128<Int16>()); + public Vector128<UInt32> Ssse3_Abs_2() => Ssse3.Abs(GetV128<Int32>()); + public Vector128<SByte> Ssse3_AlignRight_3() => Ssse3.AlignRight(GetV128<SByte>(), GetV128<SByte>(), Get<System.Byte>()); + public Vector128<Byte> Ssse3_AlignRight_4() => Ssse3.AlignRight(GetV128<Byte>(), GetV128<Byte>(), Get<System.Byte>()); + public Vector128<Int16> Ssse3_AlignRight_5() => Ssse3.AlignRight(GetV128<Int16>(), GetV128<Int16>(), Get<System.Byte>()); + public Vector128<UInt16> Ssse3_AlignRight_6() => Ssse3.AlignRight(GetV128<UInt16>(), GetV128<UInt16>(), Get<System.Byte>()); + public Vector128<Int32> Ssse3_AlignRight_7() => Ssse3.AlignRight(GetV128<Int32>(), GetV128<Int32>(), Get<System.Byte>()); + public Vector128<UInt32> Ssse3_AlignRight_8() => Ssse3.AlignRight(GetV128<UInt32>(), GetV128<UInt32>(), Get<System.Byte>()); + public Vector128<Int64> Ssse3_AlignRight_9() => Ssse3.AlignRight(GetV128<Int64>(), GetV128<Int64>(), Get<System.Byte>()); + public Vector128<UInt64> Ssse3_AlignRight_10() => Ssse3.AlignRight(GetV128<UInt64>(), GetV128<UInt64>(), Get<System.Byte>()); + public Vector128<Int16> Ssse3_HorizontalAdd_12() => Ssse3.HorizontalAdd(GetV128<Int16>(), GetV128<Int16>()); + public Vector128<Int32> Ssse3_HorizontalAdd_13() => Ssse3.HorizontalAdd(GetV128<Int32>(), GetV128<Int32>()); + public Vector128<Int16> Ssse3_HorizontalAddSaturate_14() => Ssse3.HorizontalAddSaturate(GetV128<Int16>(), GetV128<Int16>()); + public Vector128<Int16> Ssse3_HorizontalSubtract_15() => Ssse3.HorizontalSubtract(GetV128<Int16>(), GetV128<Int16>()); + public Vector128<Int32> Ssse3_HorizontalSubtract_16() => Ssse3.HorizontalSubtract(GetV128<Int32>(), GetV128<Int32>()); + public Vector128<Int16> Ssse3_HorizontalSubtractSaturate_17() => Ssse3.HorizontalSubtractSaturate(GetV128<Int16>(), GetV128<Int16>()); + public Vector128<Int16> Ssse3_MultiplyAddAdjacent_18() => Ssse3.MultiplyAddAdjacent(GetV128<Byte>(), GetV128<SByte>()); + public Vector128<Int16> Ssse3_MultiplyHighRoundScale_19() => Ssse3.MultiplyHighRoundScale(GetV128<Int16>(), GetV128<Int16>()); + public Vector128<SByte> Ssse3_Shuffle_20() => Ssse3.Shuffle(GetV128<SByte>(), GetV128<SByte>()); + public Vector128<Byte> Ssse3_Shuffle_21() => Ssse3.Shuffle(GetV128<Byte>(), GetV128<Byte>()); + public Vector128<SByte> Ssse3_Sign_22() => Ssse3.Sign(GetV128<SByte>(), GetV128<SByte>()); + public Vector128<Int16> Ssse3_Sign_23() => Ssse3.Sign(GetV128<Int16>(), GetV128<Int16>()); + public Vector128<Int32> Ssse3_Sign_24() => Ssse3.Sign(GetV128<Int32>(), GetV128<Int32>()); + public Vector128<Int16> Sse41_Blend_0() => Sse41.Blend(GetV128<Int16>(), GetV128<Int16>(), Get<System.Byte>()); + public Vector128<UInt16> Sse41_Blend_1() => Sse41.Blend(GetV128<UInt16>(), GetV128<UInt16>(), Get<System.Byte>()); + public Vector128<Single> Sse41_Blend_2() => Sse41.Blend(GetV128<Single>(), GetV128<Single>(), Get<System.Byte>()); + public Vector128<Double> Sse41_Blend_3() => Sse41.Blend(GetV128<Double>(), GetV128<Double>(), Get<System.Byte>()); + public Vector128<SByte> Sse41_BlendVariable_4() => Sse41.BlendVariable(GetV128<SByte>(), GetV128<SByte>(), GetV128<SByte>()); + public Vector128<Byte> Sse41_BlendVariable_5() => Sse41.BlendVariable(GetV128<Byte>(), GetV128<Byte>(), GetV128<Byte>()); + public Vector128<Int16> Sse41_BlendVariable_6() => Sse41.BlendVariable(GetV128<Int16>(), GetV128<Int16>(), GetV128<Int16>()); + public Vector128<UInt16> Sse41_BlendVariable_7() => Sse41.BlendVariable(GetV128<UInt16>(), GetV128<UInt16>(), GetV128<UInt16>()); + public Vector128<Int32> Sse41_BlendVariable_8() => Sse41.BlendVariable(GetV128<Int32>(), GetV128<Int32>(), GetV128<Int32>()); + public Vector128<UInt32> Sse41_BlendVariable_9() => Sse41.BlendVariable(GetV128<UInt32>(), GetV128<UInt32>(), GetV128<UInt32>()); + public Vector128<Int64> Sse41_BlendVariable_10() => Sse41.BlendVariable(GetV128<Int64>(), GetV128<Int64>(), GetV128<Int64>()); + public Vector128<UInt64> Sse41_BlendVariable_11() => Sse41.BlendVariable(GetV128<UInt64>(), GetV128<UInt64>(), GetV128<UInt64>()); + public Vector128<Single> Sse41_BlendVariable_12() => Sse41.BlendVariable(GetV128<Single>(), GetV128<Single>(), GetV128<Single>()); + public Vector128<Double> Sse41_BlendVariable_13() => Sse41.BlendVariable(GetV128<Double>(), GetV128<Double>(), GetV128<Double>()); + public Vector128<Single> Sse41_Ceiling_14() => Sse41.Ceiling(GetV128<Single>()); + public Vector128<Double> Sse41_Ceiling_15() => Sse41.Ceiling(GetV128<Double>()); + public Vector128<Double> Sse41_CeilingScalar_16() => Sse41.CeilingScalar(GetV128<Double>()); + public Vector128<Single> Sse41_CeilingScalar_17() => Sse41.CeilingScalar(GetV128<Single>()); + public Vector128<Double> Sse41_CeilingScalar_18() => Sse41.CeilingScalar(GetV128<Double>(), GetV128<Double>()); + public Vector128<Single> Sse41_CeilingScalar_19() => Sse41.CeilingScalar(GetV128<Single>(), GetV128<Single>()); + public Vector128<Int64> Sse41_CompareEqual_20() => Sse41.CompareEqual(GetV128<Int64>(), GetV128<Int64>()); + public Vector128<UInt64> Sse41_CompareEqual_21() => Sse41.CompareEqual(GetV128<UInt64>(), GetV128<UInt64>()); + public Vector128<Int16> Sse41_ConvertToVector128Int16_22() => Sse41.ConvertToVector128Int16(GetV128<SByte>()); + public Vector128<Int16> Sse41_ConvertToVector128Int16_23() => Sse41.ConvertToVector128Int16(GetV128<Byte>()); + public Vector128<Int16> Sse41_ConvertToVector128Int16_24() => Sse41.ConvertToVector128Int16((sbyte*)pArray1); + public Vector128<Int16> Sse41_ConvertToVector128Int16_25() => Sse41.ConvertToVector128Int16((byte*)pArray1); + public Vector128<Int32> Sse41_ConvertToVector128Int32_26() => Sse41.ConvertToVector128Int32(GetV128<SByte>()); + public Vector128<Int32> Sse41_ConvertToVector128Int32_27() => Sse41.ConvertToVector128Int32(GetV128<Byte>()); + public Vector128<Int32> Sse41_ConvertToVector128Int32_28() => Sse41.ConvertToVector128Int32(GetV128<Int16>()); + public Vector128<Int32> Sse41_ConvertToVector128Int32_29() => Sse41.ConvertToVector128Int32(GetV128<UInt16>()); + public Vector128<Int32> Sse41_ConvertToVector128Int32_30() => Sse41.ConvertToVector128Int32((sbyte*)pArray1); + public Vector128<Int32> Sse41_ConvertToVector128Int32_31() => Sse41.ConvertToVector128Int32((byte*)pArray1); + public Vector128<Int32> Sse41_ConvertToVector128Int32_32() => Sse41.ConvertToVector128Int32((short*)pArray1); + public Vector128<Int32> Sse41_ConvertToVector128Int32_33() => Sse41.ConvertToVector128Int32((ushort*)pArray1); + public Vector128<Int64> Sse41_ConvertToVector128Int64_34() => Sse41.ConvertToVector128Int64(GetV128<SByte>()); + public Vector128<Int64> Sse41_ConvertToVector128Int64_35() => Sse41.ConvertToVector128Int64(GetV128<Byte>()); + public Vector128<Int64> Sse41_ConvertToVector128Int64_36() => Sse41.ConvertToVector128Int64(GetV128<Int16>()); + public Vector128<Int64> Sse41_ConvertToVector128Int64_37() => Sse41.ConvertToVector128Int64(GetV128<UInt16>()); + public Vector128<Int64> Sse41_ConvertToVector128Int64_38() => Sse41.ConvertToVector128Int64(GetV128<Int32>()); + public Vector128<Int64> Sse41_ConvertToVector128Int64_39() => Sse41.ConvertToVector128Int64(GetV128<UInt32>()); + public Vector128<Int64> Sse41_ConvertToVector128Int64_40() => Sse41.ConvertToVector128Int64((sbyte*)pArray1); + public Vector128<Int64> Sse41_ConvertToVector128Int64_41() => Sse41.ConvertToVector128Int64((byte*)pArray1); + public Vector128<Int64> Sse41_ConvertToVector128Int64_42() => Sse41.ConvertToVector128Int64((short*)pArray1); + public Vector128<Int64> Sse41_ConvertToVector128Int64_43() => Sse41.ConvertToVector128Int64((ushort*)pArray1); + public Vector128<Int64> Sse41_ConvertToVector128Int64_44() => Sse41.ConvertToVector128Int64((int*)pArray1); + public Vector128<Int64> Sse41_ConvertToVector128Int64_45() => Sse41.ConvertToVector128Int64((uint*)pArray1); + public Vector128<Single> Sse41_DotProduct_46() => Sse41.DotProduct(GetV128<Single>(), GetV128<Single>(), Get<System.Byte>()); + public Vector128<Double> Sse41_DotProduct_47() => Sse41.DotProduct(GetV128<Double>(), GetV128<Double>(), Get<System.Byte>()); + public Byte Sse41_Extract_48() => Sse41.Extract(GetV128<Byte>(), Get<System.Byte>()); + public Int32 Sse41_Extract_49() => Sse41.Extract(GetV128<Int32>(), Get<System.Byte>()); + public UInt32 Sse41_Extract_50() => Sse41.Extract(GetV128<UInt32>(), Get<System.Byte>()); + public Single Sse41_Extract_51() => Sse41.Extract(GetV128<Single>(), Get<System.Byte>()); + public Vector128<Single> Sse41_Floor_52() => Sse41.Floor(GetV128<Single>()); + public Vector128<Double> Sse41_Floor_53() => Sse41.Floor(GetV128<Double>()); + public Vector128<Double> Sse41_FloorScalar_54() => Sse41.FloorScalar(GetV128<Double>()); + public Vector128<Single> Sse41_FloorScalar_55() => Sse41.FloorScalar(GetV128<Single>()); + public Vector128<Double> Sse41_FloorScalar_56() => Sse41.FloorScalar(GetV128<Double>(), GetV128<Double>()); + public Vector128<Single> Sse41_FloorScalar_57() => Sse41.FloorScalar(GetV128<Single>(), GetV128<Single>()); + public Vector128<SByte> Sse41_Insert_59() => Sse41.Insert(GetV128<SByte>(), Get<System.SByte>(), 4); + public Vector128<Byte> Sse41_Insert_60() => Sse41.Insert(GetV128<Byte>(), Get<System.Byte>(), 3); + public Vector128<Int32> Sse41_Insert_61() => Sse41.Insert(GetV128<Int32>(), Get<System.Int32>(), 2); + public Vector128<UInt32> Sse41_Insert_62() => Sse41.Insert(GetV128<UInt32>(), Get<System.UInt32>(), 1); + public Vector128<Single> Sse41_Insert_63() => Sse41.Insert(GetV128<Single>(), GetV128<Single>(), 0x10); + public Vector128<SByte> Sse41_LoadAlignedVector128NonTemporal_64() => Sse41.LoadAlignedVector128NonTemporal(((sbyte*)pArray1)); + public Vector128<Byte> Sse41_LoadAlignedVector128NonTemporal_65() => Sse41.LoadAlignedVector128NonTemporal(((byte*)pArray1)); + public Vector128<Int16> Sse41_LoadAlignedVector128NonTemporal_66() => Sse41.LoadAlignedVector128NonTemporal(((short*)pArray1)); + public Vector128<UInt16> Sse41_LoadAlignedVector128NonTemporal_67() => Sse41.LoadAlignedVector128NonTemporal(((ushort*)pArray1)); + public Vector128<Int32> Sse41_LoadAlignedVector128NonTemporal_68() => Sse41.LoadAlignedVector128NonTemporal(((int*)pArray1)); + public Vector128<UInt32> Sse41_LoadAlignedVector128NonTemporal_69() => Sse41.LoadAlignedVector128NonTemporal(((uint*)pArray1)); + public Vector128<Int64> Sse41_LoadAlignedVector128NonTemporal_70() => Sse41.LoadAlignedVector128NonTemporal(((long*)pArray1)); + public Vector128<UInt64> Sse41_LoadAlignedVector128NonTemporal_71() => Sse41.LoadAlignedVector128NonTemporal(((ulong*)pArray1)); + public Vector128<SByte> Sse41_Max_72() => Sse41.Max(GetV128<SByte>(), GetV128<SByte>()); + public Vector128<UInt16> Sse41_Max_73() => Sse41.Max(GetV128<UInt16>(), GetV128<UInt16>()); + public Vector128<Int32> Sse41_Max_74() => Sse41.Max(GetV128<Int32>(), GetV128<Int32>()); + public Vector128<UInt32> Sse41_Max_75() => Sse41.Max(GetV128<UInt32>(), GetV128<UInt32>()); + public Vector128<SByte> Sse41_Min_76() => Sse41.Min(GetV128<SByte>(), GetV128<SByte>()); + public Vector128<UInt16> Sse41_Min_77() => Sse41.Min(GetV128<UInt16>(), GetV128<UInt16>()); + public Vector128<Int32> Sse41_Min_78() => Sse41.Min(GetV128<Int32>(), GetV128<Int32>()); + public Vector128<UInt32> Sse41_Min_79() => Sse41.Min(GetV128<UInt32>(), GetV128<UInt32>()); + public Vector128<UInt16> Sse41_MinHorizontal_80() => Sse41.MinHorizontal(GetV128<UInt16>()); + public Vector128<UInt16> Sse41_MultipleSumAbsoluteDifferences_81() => Sse41.MultipleSumAbsoluteDifferences(GetV128<Byte>(), GetV128<Byte>(), Get<System.Byte>()); + public Vector128<Int64> Sse41_Multiply_82() => Sse41.Multiply(GetV128<Int32>(), GetV128<Int32>()); + public Vector128<Int32> Sse41_MultiplyLow_83() => Sse41.MultiplyLow(GetV128<Int32>(), GetV128<Int32>()); + public Vector128<UInt32> Sse41_MultiplyLow_84() => Sse41.MultiplyLow(GetV128<UInt32>(), GetV128<UInt32>()); + public Vector128<UInt16> Sse41_PackUnsignedSaturate_85() => Sse41.PackUnsignedSaturate(GetV128<Int32>(), GetV128<Int32>()); + public Vector128<Double> Sse41_RoundCurrentDirection_86() => Sse41.RoundCurrentDirection(GetV128<Double>()); + public Vector128<Single> Sse41_RoundCurrentDirection_87() => Sse41.RoundCurrentDirection(GetV128<Single>()); + public Vector128<Double> Sse41_RoundCurrentDirectionScalar_88() => Sse41.RoundCurrentDirectionScalar(GetV128<Double>()); + public Vector128<Double> Sse41_RoundCurrentDirectionScalar_89() => Sse41.RoundCurrentDirectionScalar(GetV128<Double>(), GetV128<Double>()); + public Vector128<Single> Sse41_RoundCurrentDirectionScalar_90() => Sse41.RoundCurrentDirectionScalar(GetV128<Single>()); + public Vector128<Single> Sse41_RoundCurrentDirectionScalar_91() => Sse41.RoundCurrentDirectionScalar(GetV128<Single>(), GetV128<Single>()); + public Vector128<Single> Sse41_RoundToNearestInteger_92() => Sse41.RoundToNearestInteger(GetV128<Single>()); + public Vector128<Double> Sse41_RoundToNearestInteger_93() => Sse41.RoundToNearestInteger(GetV128<Double>()); + public Vector128<Double> Sse41_RoundToNearestIntegerScalar_94() => Sse41.RoundToNearestIntegerScalar(GetV128<Double>()); + public Vector128<Double> Sse41_RoundToNearestIntegerScalar_95() => Sse41.RoundToNearestIntegerScalar(GetV128<Double>(), GetV128<Double>()); + public Vector128<Single> Sse41_RoundToNearestIntegerScalar_96() => Sse41.RoundToNearestIntegerScalar(GetV128<Single>()); + public Vector128<Single> Sse41_RoundToNearestIntegerScalar_97() => Sse41.RoundToNearestIntegerScalar(GetV128<Single>(), GetV128<Single>()); + public Vector128<Single> Sse41_RoundToNegativeInfinity_98() => Sse41.RoundToNegativeInfinity(GetV128<Single>()); + public Vector128<Double> Sse41_RoundToNegativeInfinity_99() => Sse41.RoundToNegativeInfinity(GetV128<Double>()); + public Vector128<Double> Sse41_RoundToNegativeInfinityScalar_100() => Sse41.RoundToNegativeInfinityScalar(GetV128<Double>()); + public Vector128<Double> Sse41_RoundToNegativeInfinityScalar_101() => Sse41.RoundToNegativeInfinityScalar(GetV128<Double>(), GetV128<Double>()); + public Vector128<Single> Sse41_RoundToNegativeInfinityScalar_102() => Sse41.RoundToNegativeInfinityScalar(GetV128<Single>()); + public Vector128<Single> Sse41_RoundToNegativeInfinityScalar_103() => Sse41.RoundToNegativeInfinityScalar(GetV128<Single>(), GetV128<Single>()); + public Vector128<Double> Sse41_RoundToPositiveInfinity_104() => Sse41.RoundToPositiveInfinity(GetV128<Double>()); + public Vector128<Single> Sse41_RoundToPositiveInfinity_105() => Sse41.RoundToPositiveInfinity(GetV128<Single>()); + public Vector128<Double> Sse41_RoundToPositiveInfinityScalar_106() => Sse41.RoundToPositiveInfinityScalar(GetV128<Double>()); + public Vector128<Double> Sse41_RoundToPositiveInfinityScalar_107() => Sse41.RoundToPositiveInfinityScalar(GetV128<Double>(), GetV128<Double>()); + public Vector128<Single> Sse41_RoundToPositiveInfinityScalar_108() => Sse41.RoundToPositiveInfinityScalar(GetV128<Single>()); + public Vector128<Single> Sse41_RoundToPositiveInfinityScalar_109() => Sse41.RoundToPositiveInfinityScalar(GetV128<Single>(), GetV128<Single>()); + public Vector128<Double> Sse41_RoundToZero_110() => Sse41.RoundToZero(GetV128<Double>()); + public Vector128<Single> Sse41_RoundToZero_111() => Sse41.RoundToZero(GetV128<Single>()); + public Vector128<Double> Sse41_RoundToZeroScalar_112() => Sse41.RoundToZeroScalar(GetV128<Double>()); + public Vector128<Double> Sse41_RoundToZeroScalar_113() => Sse41.RoundToZeroScalar(GetV128<Double>(), GetV128<Double>()); + public Vector128<Single> Sse41_RoundToZeroScalar_114() => Sse41.RoundToZeroScalar(GetV128<Single>()); + public Vector128<Single> Sse41_RoundToZeroScalar_115() => Sse41.RoundToZeroScalar(GetV128<Single>(), GetV128<Single>()); + public Boolean Sse41_TestC_116() => Sse41.TestC(GetV128<SByte>(), GetV128<SByte>()); + public Boolean Sse41_TestC_117() => Sse41.TestC(GetV128<Byte>(), GetV128<Byte>()); + public Boolean Sse41_TestC_118() => Sse41.TestC(GetV128<Int16>(), GetV128<Int16>()); + public Boolean Sse41_TestC_119() => Sse41.TestC(GetV128<UInt16>(), GetV128<UInt16>()); + public Boolean Sse41_TestC_120() => Sse41.TestC(GetV128<Int32>(), GetV128<Int32>()); + public Boolean Sse41_TestC_121() => Sse41.TestC(GetV128<UInt32>(), GetV128<UInt32>()); + public Boolean Sse41_TestC_122() => Sse41.TestC(GetV128<Int64>(), GetV128<Int64>()); + public Boolean Sse41_TestC_123() => Sse41.TestC(GetV128<UInt64>(), GetV128<UInt64>()); + public Boolean Sse41_TestNotZAndNotC_124() => Sse41.TestNotZAndNotC(GetV128<SByte>(), GetV128<SByte>()); + public Boolean Sse41_TestNotZAndNotC_125() => Sse41.TestNotZAndNotC(GetV128<Byte>(), GetV128<Byte>()); + public Boolean Sse41_TestNotZAndNotC_126() => Sse41.TestNotZAndNotC(GetV128<Int16>(), GetV128<Int16>()); + public Boolean Sse41_TestNotZAndNotC_127() => Sse41.TestNotZAndNotC(GetV128<UInt16>(), GetV128<UInt16>()); + public Boolean Sse41_TestNotZAndNotC_128() => Sse41.TestNotZAndNotC(GetV128<Int32>(), GetV128<Int32>()); + public Boolean Sse41_TestNotZAndNotC_129() => Sse41.TestNotZAndNotC(GetV128<UInt32>(), GetV128<UInt32>()); + public Boolean Sse41_TestNotZAndNotC_130() => Sse41.TestNotZAndNotC(GetV128<Int64>(), GetV128<Int64>()); + public Boolean Sse41_TestNotZAndNotC_131() => Sse41.TestNotZAndNotC(GetV128<UInt64>(), GetV128<UInt64>()); + public Boolean Sse41_TestZ_132() => Sse41.TestZ(GetV128<SByte>(), GetV128<SByte>()); + public Boolean Sse41_TestZ_133() => Sse41.TestZ(GetV128<Byte>(), GetV128<Byte>()); + public Boolean Sse41_TestZ_134() => Sse41.TestZ(GetV128<Int16>(), GetV128<Int16>()); + public Boolean Sse41_TestZ_135() => Sse41.TestZ(GetV128<UInt16>(), GetV128<UInt16>()); + public Boolean Sse41_TestZ_136() => Sse41.TestZ(GetV128<Int32>(), GetV128<Int32>()); + public Boolean Sse41_TestZ_137() => Sse41.TestZ(GetV128<UInt32>(), GetV128<UInt32>()); + public Boolean Sse41_TestZ_138() => Sse41.TestZ(GetV128<Int64>(), GetV128<Int64>()); + public Boolean Sse41_TestZ_139() => Sse41.TestZ(GetV128<UInt64>(), GetV128<UInt64>()); + public Vector128<Int64> Sse42_CompareGreaterThan_0() => Sse42.CompareGreaterThan(GetV128<Int64>(), GetV128<Int64>()); + public UInt32 Sse42_Crc32_1() => Sse42.Crc32(Get<System.UInt32>(), Get<System.Byte>()); + public UInt32 Sse42_Crc32_2() => Sse42.Crc32(Get<System.UInt32>(), Get<System.UInt16>()); + public UInt32 Sse42_Crc32_3() => Sse42.Crc32(Get<System.UInt32>(), Get<System.UInt32>()); + + public Vector128<byte> Vector128_Create_1() => Vector128.Create(Get<byte>()); + public Vector128<sbyte> Vector128_Create_2() => Vector128.Create(Get<sbyte>()); + public Vector128<short> Vector128_Create_3() => Vector128.Create(Get<short>()); + public Vector128<ushort> Vector128_Create_4() => Vector128.Create(Get<ushort>()); + public Vector128<int> Vector128_Create_5() => Vector128.Create(Get<int>()); + public Vector128<uint> Vector128_Create_6() => Vector128.Create(Get<uint>()); + public Vector128<long> Vector128_Create_7() => Vector128.Create(Get<long>()); + public Vector128<ulong> Vector128_Create_8() => Vector128.Create(Get<ulong>()); + public Vector128<float> Vector128_Create_9() => Vector128.Create(Get<float>()); + public Vector128<double> Vector128_Create_10() => Vector128.Create(Get<double>()); + public Vector128<double> Vector128_Create_11() => Vector128.Create(Get<double>(), Get<double>()); + public Vector128<long> Vector128_Create_12() => Vector128.Create(Get<long>(), Get<long>()); + public Vector128<ulong> Vector128_Create_13() => Vector128.Create(Get<ulong>(), Get<ulong>()); + public Vector128<float> Vector128_Create_14() => Vector128.Create(Get<float>(), Get<float>(), Get<float>(), Get<float>()); + public Vector128<int> Vector128_Create_15() => Vector128.Create(Get<int>(), Get<int>(), Get<int>(), Get<int>()); + public Vector128<uint> Vector128_Create_16() => Vector128.Create(Get<uint>(), Get<uint>(), Get<uint>(), Get<uint>()); + public Vector128<ushort> Vector128_Create_17() => Vector128.Create(Get<ushort>(), Get<ushort>(), Get<ushort>(), Get<ushort>(), Get<ushort>(), Get<ushort>(), Get<ushort>(), Get<ushort>()); + public Vector128<short> Vector128_Create_18() => Vector128.Create(Get<short>(), Get<short>(), Get<short>(), Get<short>(), Get<short>(), Get<short>(), Get<short>(), Get<short>()); + public Vector128<sbyte> Vector128_Create_20() => Vector128.Create(Get<sbyte>(), Get<sbyte>(), Get<sbyte>(), Get<sbyte>(), Get<sbyte>(), Get<sbyte>(), Get<sbyte>(), Get<sbyte>(), Get<sbyte>(), Get<sbyte>(), Get<sbyte>(), Get<sbyte>(), Get<sbyte>(), Get<sbyte>(), Get<sbyte>(), Get<sbyte>()); + + public int Vector128_CreateScalarUnsafe_1() => Sse2.Add(Vector128.CreateScalarUnsafe(42), Vector128.CreateScalarUnsafe(8)).GetElement(0); + public double Vector128_CreateScalarUnsafe_2() => Sse2.Add(Vector128.CreateScalarUnsafe(42.0), Vector128.CreateScalarUnsafe(8.0)).GetElement(0); + + public Vector128<byte> Vector128_int_to_byte() => Vector128_Create_15().AsByte(); + public Vector128<ulong> Vector128_int_to_ulong() => Vector128_Create_15().AsUInt64(); + public Vector128<int> Vector128_byte_to_int() => Vector128_Create_20().AsInt32(); +}
\ No newline at end of file diff --git a/netcore/tests/HwIntrinsics/SRI-reference-data.txt b/netcore/tests/HwIntrinsics/SRI-reference-data.txt new file mode 100644 index 00000000000..f28524ffd8f --- /dev/null +++ b/netcore/tests/HwIntrinsics/SRI-reference-data.txt @@ -0,0 +1,595 @@ +GetArray2Data: . array2: () +ReloadArrays: . array2: () +Sse_Add_0: <929125630, 457013920, 373885180, 399296580>. array2: () +Sse_AddScalar_1: <831905660, 361925120, 171923890, 163625200>. array2: () +Sse_And_2: <37962244, 63456256, 77604050, 337699840>. array2: () +Sse_AndNot_3: <-7.530605E-39, -9.442987E-38, -1.5179037E-36, -2.3605184E-38>. array2: () +Sse_CompareEqual_4: <0, 0, 0, 0>. array2: () +Sse_CompareGreaterThan_5: <0, 0, 0, 0>. array2: () +Sse_CompareGreaterThanOrEqual_6: <0, 0, NaN, 0>. array2: () +Sse_CompareLessThan_7: <0, 0, 0, 0>. array2: () +Sse_CompareLessThanOrEqual_8: <0, 0, 0, 0>. array2: () +Sse_CompareNotEqual_9: <NaN, NaN, NaN, NaN>. array2: () +Sse_CompareNotGreaterThan_10: <0, NaN, 0, NaN>. array2: () +Sse_CompareNotGreaterThanOrEqual_11: <0, 0, 0, 0>. array2: () +Sse_CompareNotLessThan_12: <0, NaN, NaN, 0>. array2: () +Sse_CompareNotLessThanOrEqual_13: <0, 0, 0, 0>. array2: () +Sse_CompareOrdered_14: <NaN, NaN, NaN, NaN>. array2: () +Sse_CompareScalarEqual_15: <0, 165247660, 501148420, 424096580>. array2: () +Sse_CompareScalarGreaterThan_16: <0, -510012770, -65459412, -256915410>. array2: () +Sse_CompareScalarGreaterThanOrEqual_17: <NaN, 678421950, 435046200, 55114016>. array2: () +Sse_CompareScalarLessThan_18: <0, 286352260, 67081924, 391137340>. array2: () +Sse_CompareScalarLessThanOrEqual_19: <NaN, -588649900, -401212100, -120477656>. array2: () +Sse_CompareScalarNotEqual_20: <NaN, 198373810, 122680850, 358035900>. array2: () +Sse_CompareScalarNotGreaterThan_21: <0, 675093900, 250508290, 382580160>. array2: () +Sse_CompareScalarNotGreaterThanOrEqual_22: <NaN, 79479856, 432719200, 149407550>. array2: () +Sse_CompareScalarNotLessThan_23: <0, -669115970, -28078068, -23915620>. array2: () +Sse_CompareScalarNotLessThanOrEqual_24: <0, -263062030, -243626220, -327881220>. array2: () +Sse_CompareScalarOrdered_25: <NaN, 424523140, 329012580, 166258130>. array2: () +Sse_CompareScalarOrderedEqual_26: False. array2: () +Sse_CompareScalarOrderedGreaterThan_27: True. array2: () +Sse_CompareScalarOrderedGreaterThanOrEqual_28: False. array2: () +Sse_CompareScalarOrderedLessThan_29: False. array2: () +Sse_CompareScalarOrderedLessThanOrEqual_30: True. array2: () +Sse_CompareScalarOrderedNotEqual_31: True. array2: () +Sse_CompareScalarUnordered_32: <0, 0, 0, 0>. array2: () +Sse_CompareScalarUnorderedEqual_33: False. array2: () +Sse_CompareScalarUnorderedGreaterThan_34: False. array2: () +Sse_CompareScalarUnorderedGreaterThanOrEqual_35: True. array2: () +Sse_CompareScalarUnorderedLessThan_36: False. array2: () +Sse_CompareScalarUnorderedLessThanOrEqual_37: False. array2: () +Sse_CompareScalarUnorderedNotEqual_38: True. array2: () +Sse_CompareUnordered_39: <0, 0, 0, 0>. array2: () +Sse_ConvertScalarToVector128Single_40: <1.7130938E+09, 673981570, 435517900, 284626240>. array2: () +Sse_ConvertToInt32_41: -200472784. array2: () +Sse_ConvertToInt32WithTruncation_42: 476591168. array2: () +Sse_Divide_43: <0.4255711, 1.6555679, 1.080426, 2.3567653>. array2: () +Sse_DivideScalar_44: <Infinity, 94416510, 474155170, 220063580>. array2: () +Sse_LoadAlignedVector128_46: <0, 0.5, 1, 1.5>. array2: () +Sse_LoadHigh_47: <213905200, 534451330, 0, 0.5>. array2: () +Sse_LoadLow_48: <0, 0.5, 526352540, 304848960>. array2: () +Sse_LoadScalarVector128_49: <0, 0, 0, 0>. array2: () +Sse_LoadVector128_50: <0, 0.5, 1, 1.5>. array2: () +Sse_Max_51: <-304293300, -344651520, -332293340, -228331310>. array2: () +Sse_MaxScalar_52: <0, 0, 0, 0>. array2: () +Sse_Min_53: <-659012200, -329070240, -410852960, -194900770>. array2: () +Sse_MinScalar_54: <303572000, 262783810, 75313750, 48754888>. array2: () +Sse_MoveHighToLow_55: <152952030, 120658176, 416098600, 151711410>. array2: () +Sse_MoveLowToHigh_56: <594499460, 78836810, 799263700, 431919140>. array2: () +Sse_MoveMask_57: 0. array2: () +Sse_MoveScalar_58: <581809900, 70783160, 158188660, 309818560>. array2: () +Sse_Multiply_59: <-8.335214E+16, -4.255089E+16, -7.327157E+16, -2.6699806E+15>. array2: () +Sse_MultiplyScalar_60: <1.7725418E+17, 160780880, 114840160, 312372350>. array2: () +Sse_Or_61: <-1.0672764E+09, -8.5731497E+09, -307076030, -389938500>. array2: () +Sse_Prefetch0_62: . array2: () +Sse_Prefetch1_63: . array2: () +Sse_Prefetch2_64: . array2: () +Sse_PrefetchNonTemporal_65: . array2: () +Sse_Reciprocal_66: <-1.2159944E-08, -1.1204975E-08, -1.8821993E-09, -7.841663E-09>. array2: () +Sse_ReciprocalScalar_67: <3.4578989E-09, 56211220, 81027630, 106894210>. array2: () +Sse_ReciprocalScalar_68: <1.2871624E-09, 448893340, 230181550, 34451628>. array2: () +Sse_ReciprocalSqrt_69: <4.287809E-05, 0.0001977086, 4.4345856E-05, 8.9362264E-05>. array2: () +Sse_ReciprocalSqrtScalar_70: <NaN, -647177900, -458123200, -197744160>. array2: () +Sse_ReciprocalSqrtScalar_71: <NaN, 437562400, 312167300, 75870080>. array2: () +Sse_Shuffle_72: <103318530, 633020600, 519279620, 446014980>. array2: () +Sse_Sqrt_73: <32375.541, 18467.787, 10546.897, 13361.126>. array2: () +Sse_SqrtScalar_74: <NaN, -127137670, -374733950, -304894900>. array2: () +Sse_SqrtScalar_75: <0, -161208180, -370718370, -192715920>. array2: () +Sse_Store_76: . array2: (<524471360, 692894400, 517360540, 111962010>) +Sse_StoreAligned_77: . array2: (<668176450, 603658900, 34112764, 33997604>) +Sse_StoreAlignedNonTemporal_78: . array2: (<411258080, 295905300, 370917700, 136368000>) +Sse_StoreFence_79: . array2: () +Sse_StoreHigh_80: . array2: (<-89017680, -350302900, 0, 0>) +Sse_StoreLow_81: . array2: (<-934469570, -384415970, 0, 0>) +Sse_StoreScalar_82: . array2: (<630363700, 0, 0, 0>) +Sse_Subtract_83: <388175420, -28251904, -262372130, -16946368>. array2: () +Sse_SubtractScalar_84: <1.2341728E+09, 81653990, 332236930, 231184850>. array2: () +Sse_UnpackHigh_85: <234336190, -201399150, 11366093, -227744130>. array2: () +Sse_UnpackLow_86: <-460082180, 976768400, -71266130, 684022100>. array2: () +Sse_Xor_87: <5.454208E-37, 7.558558E-37, 2.2277044E-38, 3.4608778E-35>. array2: () +Sse2_Add_0: <157, 30, 117, 68, 254, 250, 198, 109, 226, 191, 114, 70, 98, 64, 124, 115>. array2: () +Sse2_Add_1: <111, -100, 31, 18, -104, 36, 62, 15, 116, -33, -46, -39, -31, -69, 75, -12>. array2: () +Sse2_Add_2: <-17349, 32646, 27366, 17847, -14439, 23263, -28227, 26507>. array2: () +Sse2_Add_3: <48597, 44533, 11015, 30391, 1888, 41608, 61458, 29007>. array2: () +Sse2_Add_4: <-2099012909, -1214463057, 748055490, 587046172>. array2: () +Sse2_Add_5: <2692053887, 675414813, 2668354831, 2361717631>. array2: () +Sse2_Add_6: <-5569845745187161295, 8239220397857138507>. array2: () +Sse2_Add_7: <313415891815243217, 1695776975936769365>. array2: () +Sse2_Add_8: <-1377217479, -1656960814>. array2: () +Sse2_AddSaturate_10: <255, 255, 255, 255, 180, 229, 94, 255, 255, 255, 255, 255, 255, 255, 245, 223>. array2: () +Sse2_AddSaturate_11: <32767, 22517, -782, 24849, 21420, 11609, 15738, 32767>. array2: () +Sse2_AddSaturate_12: <65535, 65535, 64391, 65535, 65535, 65535, 65535, 65535>. array2: () +Sse2_AddSaturate_9: <30, -24, 56, -11, 39, 80, 124, -91, -30, -63, 34, -24, 49, 33, 116, -108>. array2: () +Sse2_AddScalar_13: <1949344437, 759608663>. array2: () +Sse2_And_14: <225, 216, 33, 65, 4, 90, 0, 20, 64, 0, 0, 0, 121, 64, 24, 28>. array2: () +Sse2_And_15: <-62, 40, 32, 68, 91, 8, 66, 20, 0, 32, -108, 1, 16, 64, 36, 17>. array2: () +Sse2_And_16: <8280, 2066, 10244, 17476, 2112, 668, 1248, 108>. array2: () +Sse2_And_17: <17713, 8192, 51449, 4120, 1280, 770, 8738, 608>. array2: () +Sse2_And_18: <1485444, 603982148, 9310754, 1078465665>. array2: () +Sse2_And_19: <2674703, 537657472, 176440336, 142610944>. array2: () +Sse2_And_20: <2459037974327738368, 2396479261679681876>. array2: () +Sse2_And_21: <5332368611468922716, 576462964233077344>. array2: () +Sse2_And_22: <1343127624, 1688764441>. array2: () +Sse2_AndNot_23: <0, 65, 217, 228, 14, 22, 64, 132, 136, 129, 61, 192, 36, 32, 198, 140>. array2: () +Sse2_AndNot_24: <4, -117, 73, 64, 26, -84, 36, 32, 1, 4, 80, 6, -128, 3, -96, 4>. array2: () +Sse2_AndNot_25: <-32112, 2875, 15473, 14848, 6145, 5914, 66, 10025>. array2: () +Sse2_AndNot_26: <4117, 2596, 32778, 1472, 40198, 16402, 228, 4164>. array2: () +Sse2_AndNot_27: <134387840, 1703968, 705053332, 190873920>. array2: () +Sse2_AndNot_28: <2217877536, 2487419010, 2370521409, 2158904832>. array2: () +Sse2_AndNot_29: <-8914749681309833840, -7200969722687336402>. array2: () +Sse2_AndNot_30: <2901470452777135120, 2596364778247046146>. array2: () +Sse2_AndNot_31: <-2.308464469769642E-308, -4.5392050050569185E-306>. array2: () +Sse2_Average_32: <121, 65, 144, 155, 187, 250, 52, 133, 208, 55, 114, 135, 121, 199, 49, 158>. array2: () +Sse2_Average_33: <29628, 1975, 15380, 11051, 12362, 8455, 11592, 6841>. array2: () +Sse2_CompareEqual_34: <0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0>. array2: () +Sse2_CompareEqual_35: <0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0>. array2: () +Sse2_CompareEqual_36: <0, 0, 0, 0, 0, 0, 0, 0>. array2: () +Sse2_CompareEqual_37: <0, 0, 0, 0, 0, 0, 0, 0>. array2: () +Sse2_CompareEqual_38: <0, 0, 0, 0>. array2: () +Sse2_CompareEqual_39: <0, 0, 0, 0>. array2: () +Sse2_CompareEqual_40: <0, 0>. array2: () +Sse2_CompareGreaterThan_41: <-1, -1, 0, 0, -1, -1, -1, 0, 0, 0, -1, 0, 0, -1, -1, 0>. array2: () +Sse2_CompareGreaterThan_42: <0, -1, -1, -1, -1, -1, 0, -1>. array2: () +Sse2_CompareGreaterThan_43: <-1, -1, -1, -1>. array2: () +Sse2_CompareGreaterThan_44: <0, NaN>. array2: () +Sse2_CompareGreaterThanOrEqual_45: <0, 0>. array2: () +Sse2_CompareLessThan_46: <0, 0, 0, 0, 0, -1, -1, 0, 0, -1, 0, 0, 0, 0, 0, 0>. array2: () +Sse2_CompareLessThan_47: <-1, 0, 0, 0, -1, 0, -1, 0>. array2: () +Sse2_CompareLessThan_48: <0, 0, 0, 0>. array2: () +Sse2_CompareLessThan_49: <0, 0>. array2: () +Sse2_CompareLessThanOrEqual_50: <NaN, NaN>. array2: () +Sse2_CompareNotEqual_51: <NaN, NaN>. array2: () +Sse2_CompareNotGreaterThan_52: <NaN, NaN>. array2: () +Sse2_CompareNotGreaterThanOrEqual_53: <0, 0>. array2: () +Sse2_CompareNotLessThan_54: <0, 0>. array2: () +Sse2_CompareNotLessThanOrEqual_55: <NaN, NaN>. array2: () +Sse2_CompareOrdered_56: <NaN, NaN>. array2: () +Sse2_CompareScalarEqual_57: <0, 2083712820>. array2: () +Sse2_CompareScalarGreaterThan_58: <0, 1650780952>. array2: () +Sse2_CompareScalarGreaterThanOrEqual_59: <NaN, 708005949>. array2: () +Sse2_CompareScalarLessThan_60: <0, 1627148431>. array2: () +Sse2_CompareScalarLessThanOrEqual_61: <0, 1720855119>. array2: () +Sse2_CompareScalarNotEqual_62: <NaN, 1203562733>. array2: () +Sse2_CompareScalarNotGreaterThan_63: <0, 743511762>. array2: () +Sse2_CompareScalarNotGreaterThanOrEqual_64: <0, 2122767112>. array2: () +Sse2_CompareScalarNotLessThan_65: <0, -495948320>. array2: () +Sse2_CompareScalarNotLessThanOrEqual_66: <NaN, 308710313>. array2: () +Sse2_CompareScalarOrdered_67: <NaN, 406820521>. array2: () +Sse2_CompareScalarOrderedEqual_68: False. array2: () +Sse2_CompareScalarOrderedGreaterThan_69: False. array2: () +Sse2_CompareScalarOrderedGreaterThanOrEqual_70: True. array2: () +Sse2_CompareScalarOrderedLessThan_71: False. array2: () +Sse2_CompareScalarOrderedLessThanOrEqual_72: False. array2: () +Sse2_CompareScalarOrderedNotEqual_73: True. array2: () +Sse2_CompareScalarUnordered_74: <0, 1260970130>. array2: () +Sse2_CompareScalarUnorderedEqual_75: False. array2: () +Sse2_CompareScalarUnorderedGreaterThan_76: False. array2: () +Sse2_CompareScalarUnorderedGreaterThanOrEqual_77: False. array2: () +Sse2_CompareScalarUnorderedLessThan_78: False. array2: () +Sse2_CompareScalarUnorderedLessThanOrEqual_79: False. array2: () +Sse2_CompareScalarUnorderedNotEqual_80: True. array2: () +Sse2_CompareUnordered_81: <0, 0>. array2: () +Sse2_ConvertScalarToVector128Double_82: <-593819705, -1566865401>. array2: () +Sse2_ConvertScalarToVector128Double_83: <264559328, 0>. array2: () +Sse2_ConvertScalarToVector128Int32_84: <1234688916, 0, 0, 0>. array2: () +Sse2_ConvertScalarToVector128Single_85: <336991780, 0, 0, 0>. array2: () +Sse2_ConvertScalarToVector128UInt32_86: <3853626177, 0, 0, 0>. array2: () +Sse2_ConvertToInt32_87: 1026923545. array2: () +Sse2_ConvertToInt32_88: 1003953677. array2: () +Sse2_ConvertToInt32WithTruncation_89: -1221922084. array2: () +Sse2_ConvertToUInt32_90: 2969051109. array2: () +Sse2_ConvertToVector128Double_91: <-324237430, -610879060>. array2: () +Sse2_ConvertToVector128Double_92: <0, 0>. array2: () +Sse2_ConvertToVector128Int32_93: <401491456, 32911600, 307468416, 3629614>. array2: () +Sse2_ConvertToVector128Int32_94: <695640577, 175680099, 0, 0>. array2: () +Sse2_ConvertToVector128Int32WithTruncation_95: <-341060096, -260400640, -35966700, -315059424>. array2: () +Sse2_ConvertToVector128Int32WithTruncation_96: <605491771, 1198610225, 0, 0>. array2: () +Sse2_ConvertToVector128Single_97: <1.8590148E+09, 741157630, 88313440, 1.6104324E+09>. array2: () +Sse2_ConvertToVector128Single_98: <861460740, 2.0822572E+09, 0, 0>. array2: () +Sse2_Divide_99: <-0.41013863773247955, -2.2583900973508606>. array2: () +Sse2_DivideScalar_100: <0.23868365208310682, 453983282>. array2: () +Sse2_Extract_101: 9206. array2: () +Sse2_Insert_103: <0, 0, -10045, 0, 0, 0, 0, 0>. array2: () +Sse2_Insert_104: <20620, 35164, 54090, 58235, 16240, 65465, 19696, 17652>. array2: () +Sse2_LoadAlignedVector128_105: <0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15>. array2: () +Sse2_LoadAlignedVector128_106: <0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15>. array2: () +Sse2_LoadAlignedVector128_107: <256, 770, 1284, 1798, 2312, 2826, 3340, 3854>. array2: () +Sse2_LoadAlignedVector128_108: <256, 770, 1284, 1798, 2312, 2826, 3340, 3854>. array2: () +Sse2_LoadAlignedVector128_109: <50462976, 117835012, 185207048, 252579084>. array2: () +Sse2_LoadAlignedVector128_110: <50462976, 117835012, 185207048, 252579084>. array2: () +Sse2_LoadAlignedVector128_111: <506097522914230528, 1084818905618843912>. array2: () +Sse2_LoadAlignedVector128_112: <506097522914230528, 1084818905618843912>. array2: () +Sse2_LoadAlignedVector128_113: <0, 0.3333333432674408>. array2: () +Sse2_LoadFence_114: . array2: () +Sse2_LoadHigh_115: <242191237, 0>. array2: () +Sse2_LoadLow_116: <0, 0>. array2: () +Sse2_LoadScalarVector128_117: <0, 0>. array2: () +Sse2_LoadScalarVector128_118: <50462976, 0, 0, 0>. array2: () +Sse2_LoadScalarVector128_119: <50462976, 0, 0, 0>. array2: () +Sse2_LoadScalarVector128_120: <506097522914230528, 0>. array2: () +Sse2_LoadScalarVector128_121: <506097522914230528, 0>. array2: () +Sse2_LoadVector128_122: <0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15>. array2: () +Sse2_LoadVector128_123: <0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15>. array2: () +Sse2_LoadVector128_124: <256, 770, 1284, 1798, 2312, 2826, 3340, 3854>. array2: () +Sse2_LoadVector128_125: <256, 770, 1284, 1798, 2312, 2826, 3340, 3854>. array2: () +Sse2_LoadVector128_126: <50462976, 117835012, 185207048, 252579084>. array2: () +Sse2_LoadVector128_127: <50462976, 117835012, 185207048, 252579084>. array2: () +Sse2_LoadVector128_128: <506097522914230528, 1084818905618843912>. array2: () +Sse2_LoadVector128_129: <506097522914230528, 1084818905618843912>. array2: () +Sse2_LoadVector128_130: <0, 0.3333333432674408>. array2: () +Sse2_MaskMove_131: . array2: () +Sse2_MaskMove_132: . array2: () +Sse2_Max_133: <46, 154, 117, 221, 251, 245, 249, 212, 128, 167, 140, 244, 205, 138, 224, 238>. array2: () +Sse2_Max_134: <17360, 32429, 18775, 858, 14102, 30506, -5851, 30258>. array2: () +Sse2_Max_135: <0, 0>. array2: () +Sse2_MaxScalar_136: <1355081192, 371420829>. array2: () +Sse2_MemoryFence_137: . array2: () +Sse2_Min_138: <117, 60, 0, 28, 52, 46, 24, 73, 91, 55, 124, 123, 212, 167, 206, 71>. array2: () +Sse2_Min_139: <4773, -26258, -31045, -14134, -19902, -7278, 200, -20325>. array2: () +Sse2_Min_140: <-498292418, -287844603>. array2: () +Sse2_MinScalar_141: <-719494121, 556225841>. array2: () +Sse2_MoveMask_142: 0. array2: () +Sse2_MoveMask_143: 17749. array2: () +Sse2_MoveMask_144: 3. array2: () +Sse2_MoveScalar_145: <358216876, 14573030>. array2: () +Sse2_MoveScalar_146: <8026354353478850732, 0>. array2: () +Sse2_MoveScalar_147: <11960848426434193404, 0>. array2: () +Sse2_Multiply_148: <946464580954712675, 1322844109440369358>. array2: () +Sse2_Multiply_149: <3.889913259521027E+18, 4.28768515710415E+17>. array2: () +Sse2_MultiplyAddAdjacent_150: <0, 0, 0, 0>. array2: () +Sse2_MultiplyHigh_151: <-136, -665, -3509, -2039, 681, -3653, -2098, -2340>. array2: () +Sse2_MultiplyHigh_152: <26601, 1648, 2913, 1028, 2499, 1409, 42537, 3604>. array2: () +Sse2_MultiplyLow_153: <18244, -27954, -20206, 24690, 3356, 12024, -31581, -73>. array2: () +Sse2_MultiplyLow_154: <47482, 14636, 24333, 13435, 33030, 46832, 57179, 12537>. array2: () +Sse2_MultiplyScalar_155: <-5.863772895193802E+17, 1111050795>. array2: () +Sse2_Or_156: <247, 124, 221, 191, 116, 178, 185, 249, 127, 223, 127, 207, 185, 211, 231, 131>. array2: () +Sse2_Or_157: <-3, -68, -69, -65, 65, 89, -1, -23, -39, -20, -41, -2, -1, -11, -12, -1>. array2: () +Sse2_Or_158: <-1159, -16514, 32723, -4130, 18431, -1, 24238, -16525>. array2: () +Sse2_Or_159: <64282, 25131, 53526, 24527, 15801, 20397, 6444, 9233>. array2: () +Sse2_Or_160: <-1363169726, -427819146, -16777987, -123350034>. array2: () +Sse2_Or_161: <4021272047, 3992975279, 3681512439, 4277138431>. array2: () +Sse2_Or_162: <8070443587545201599, 9219844371637592951>. array2: () +Sse2_Or_163: <9104447756691958458, 8610876712411787262>. array2: () +Sse2_Or_164: <6406789608, 2012196350>. array2: () +Sse2_PackSignedSaturate_165: <-128, -128, 127, -128, 127, -128, 127, -128, 127, 127, 127, 127, -128, 127, 127, 127>. array2: () +Sse2_PackSignedSaturate_166: <-32768, -32768, -32768, -32768, -32768, -32768, -32768, -32768>. array2: () +Sse2_PackUnsignedSaturate_167: <0, 0, 255, 0, 255, 0, 0, 0, 0, 0, 255, 0, 255, 0, 255, 0>. array2: () +Sse2_ShiftLeftLogical_168: <0, 0, 0, 0, 0, 0, 0, 0>. array2: () +Sse2_ShiftLeftLogical_169: <0, 0, 0, 0, 0, 0, 0, 0>. array2: () +Sse2_ShiftLeftLogical_170: <0, 0, 0, 0>. array2: () +Sse2_ShiftLeftLogical_171: <0, 0, 0, 0>. array2: () +Sse2_ShiftLeftLogical_172: <0, 0>. array2: () +Sse2_ShiftLeftLogical_173: <0, 0>. array2: () +Sse2_ShiftLeftLogical_174: <0, 0, 0, 0, 0, 0, 0, 0>. array2: () +Sse2_ShiftLeftLogical_175: <0, 0, 0, 0, 0, 0, 0, 0>. array2: () +Sse2_ShiftLeftLogical_176: <0, 0, 0, 0>. array2: () +Sse2_ShiftLeftLogical_177: <0, 0, 0, 0>. array2: () +Sse2_ShiftLeftLogical_178: <0, 0>. array2: () +Sse2_ShiftLeftLogical_179: <0, 0>. array2: () +Sse2_ShiftLeftLogical128BitLane_180: <0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0>. array2: () +Sse2_ShiftLeftLogical128BitLane_181: <0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0>. array2: () +Sse2_ShiftLeftLogical128BitLane_182: <0, 0, 0, 0, 0, 0, 0, 0>. array2: () +Sse2_ShiftLeftLogical128BitLane_183: <0, 0, 0, 0, 0, 0, 0, 0>. array2: () +Sse2_ShiftLeftLogical128BitLane_184: <0, 0, 0, 0>. array2: () +Sse2_ShiftLeftLogical128BitLane_185: <0, 2927165440, 1053439790, 1500076848>. array2: () +Sse2_ShiftLeftLogical128BitLane_186: <0, 0>. array2: () +Sse2_ShiftLeftLogical128BitLane_187: <0, 0>. array2: () +Sse2_ShiftRightArithmetic_188: <-1, 0, 0, 0, -1, 0, -1, 0>. array2: () +Sse2_ShiftRightArithmetic_189: <0, 0, 0, 0>. array2: () +Sse2_ShiftRightArithmetic_190: <-1, 0, -1, 0, -1, 0, -1, 0>. array2: () +Sse2_ShiftRightArithmetic_191: <0, 0, 0, 0>. array2: () +Sse2_ShiftRightLogical_192: <0, 0, 0, 0, 0, 0, 0, 0>. array2: () +Sse2_ShiftRightLogical_193: <0, 0, 0, 0, 0, 0, 0, 0>. array2: () +Sse2_ShiftRightLogical_194: <0, 0, 0, 0>. array2: () +Sse2_ShiftRightLogical_195: <0, 0, 0, 0>. array2: () +Sse2_ShiftRightLogical_196: <5844001493094162482, 6955472380474049021>. array2: () +Sse2_ShiftRightLogical_197: <0, 0>. array2: () +Sse2_ShiftRightLogical_198: <0, 0, 0, 0, 0, 0, 0, 0>. array2: () +Sse2_ShiftRightLogical_199: <0, 0, 0, 0, 0, 0, 0, 0>. array2: () +Sse2_ShiftRightLogical_200: <607, 772, 805, 541>. array2: () +Sse2_ShiftRightLogical_201: <0, 0, 0, 0>. array2: () +Sse2_ShiftRightLogical_202: <0, 0>. array2: () +Sse2_ShiftRightLogical_203: <0, 0>. array2: () +Sse2_ShiftRightLogical128BitLane_204: <-122, 120, 50, -69, -84, 56, 111, 51, -56, 0, 0, 0, 0, 0, 0, 0>. array2: () +Sse2_ShiftRightLogical128BitLane_205: <0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0>. array2: () +Sse2_ShiftRightLogical128BitLane_206: <0, 0, 0, 0, 0, 0, 0, 0>. array2: () +Sse2_ShiftRightLogical128BitLane_207: <0, 0, 0, 0, 0, 0, 0, 0>. array2: () +Sse2_ShiftRightLogical128BitLane_208: <0, 0, 0, 0>. array2: () +Sse2_ShiftRightLogical128BitLane_209: <0, 0, 0, 0>. array2: () +Sse2_ShiftRightLogical128BitLane_210: <0, 0>. array2: () +Sse2_ShiftRightLogical128BitLane_211: <0, 0>. array2: () +Sse2_Shuffle_212: <170398073, 1558314255, 170398073, 170398073>. array2: () +Sse2_Shuffle_213: <1028956739, 400946704>. array2: () +Sse2_Shuffle_214: <525659078, 525659078, 525659078, 836067957>. array2: () +Sse2_ShuffleHigh_215: <-30644, 9774, 5424, 9064, 22189, 20978, 20978, -13303>. array2: () +Sse2_ShuffleHigh_216: <15529, 15138, 12456, 25850, 11624, 18411, 11624, 11624>. array2: () +Sse2_ShuffleLow_217: <2167, 2167, 11159, 11159, -6897, 30123, -28312, 31844>. array2: () +Sse2_ShuffleLow_218: <20074, 15183, 15183, 15183, 61168, 15156, 23107, 363>. array2: () +Sse2_Sqrt_219: <0, 0>. array2: () +Sse2_SqrtScalar_220: <NaN, -857790740>. array2: () +Sse2_SqrtScalar_221: <NaN, 0>. array2: () +Sse2_Store_222: . array2: (<195, 45, 98, 147, 221, 239, 202, 231, 116, 155, 244, 160, 200, 64, 32, 146>) +Sse2_Store_223: . array2: (<70, 19, 250, 175, 238, 14, 37, 240, 49, 43, 250, 176, 136, 252, 84, 230>) +Sse2_Store_224: . array2: (<194, 151, 9, 235, 109, 26, 11, 183, 67, 160, 63, 166, 253, 115, 188, 164>) +Sse2_Store_225: . array2: (<29, 146, 117, 106, 149, 161, 240, 52, 127, 242, 243, 123, 51, 244, 106, 99>) +Sse2_Store_226: . array2: () +Sse2_Store_227: . array2: (<66, 56, 184, 20, 228, 16, 141, 35, 174, 186, 42, 75, 156, 29, 56, 110>) +Sse2_Store_228: . array2: (<21, 186, 82, 120, 252, 42, 165, 83, 89, 127, 91, 41, 164, 226, 131, 91>) +Sse2_Store_229: . array2: () +Sse2_Store_230: . array2: () +Sse2_StoreAligned_231: . array2: (<88, 151, 180, 106, 64, 107, 212, 36, 30, 113, 136, 60, 9, 52, 122, 99>) +Sse2_StoreAligned_232: . array2: (<230, 220, 156, 17, 238, 140, 116, 98, 25, 209, 206, 34, 210, 128, 191, 39>) +Sse2_StoreAligned_233: . array2: (<94, 50, 184, 106, 112, 183, 9, 15, 238, 235, 206, 126, 16, 245, 237, 21>) +Sse2_StoreAligned_234: . array2: (<70, 255, 10, 176, 95, 53, 17, 165, 42, 36, 135, 211, 157, 201, 79, 187>) +Sse2_StoreAligned_235: . array2: (<126, 69, 112, 12, 192, 218, 117, 81, 65, 61, 81, 65, 58, 102, 153, 31>) +Sse2_StoreAligned_236: . array2: () +Sse2_StoreAligned_237: . array2: (<172, 114, 6, 101, 164, 156, 202, 79, 13, 12, 132, 107, 143, 185, 42, 16>) +Sse2_StoreAligned_238: . array2: (<141, 73, 143, 71, 95, 77, 98, 97, 56, 4, 62, 49, 211, 195, 175, 75>) +Sse2_StoreAligned_239: . array2: (<197365934, 1785457888>) +Sse2_StoreAlignedNonTemporal_240: . array2: (<165, 74, 54, 189, 6, 179, 92, 193, 204, 212, 133, 179, 238, 167, 91, 137>) +Sse2_StoreAlignedNonTemporal_241: . array2: (<227, 130, 78, 213, 121, 107, 223, 218, 55, 146, 69, 180, 80, 90, 20, 174>) +Sse2_StoreAlignedNonTemporal_242: . array2: (<65, 206, 151, 81, 65, 231, 51, 81, 152, 188, 62, 25, 254, 45, 131, 99>) +Sse2_StoreAlignedNonTemporal_243: . array2: (<240, 182, 61, 101, 14, 5, 13, 114, 24, 180, 10, 9, 173, 39, 88, 21>) +Sse2_StoreAlignedNonTemporal_244: . array2: (<189, 198, 116, 82, 244, 2, 213, 43, 186, 149, 237, 26, 98, 171, 133, 35>) +Sse2_StoreAlignedNonTemporal_245: . array2: (<171, 142, 164, 129, 207, 153, 231, 212, 166, 76, 109, 145, 151, 57, 79, 214>) +Sse2_StoreAlignedNonTemporal_246: . array2: (<155, 88, 34, 11, 132, 38, 10, 85, 157, 88, 4, 34, 125, 161, 226, 0>) +Sse2_StoreAlignedNonTemporal_247: . array2: () +Sse2_StoreAlignedNonTemporal_248: . array2: (<448427980, 160451659>) +Sse2_StoreHigh_249: . array2: (<434912716, 0>) +Sse2_StoreLow_250: . array2: (<2119419681, 0>) +Sse2_StoreNonTemporal_251: . array2: (<183, 178, 255, 179, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0>) +Sse2_StoreNonTemporal_252: . array2: (<255, 104, 107, 118, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0>) +Sse2_StoreScalar_253: . array2: () +Sse2_StoreScalar_254: . array2: (<77, 218, 255, 247, 122, 145, 210, 182, 0, 0, 0, 0, 0, 0, 0, 0>) +Sse2_StoreScalar_255: . array2: (<173, 141, 34, 113, 223, 110, 135, 91, 0, 0, 0, 0, 0, 0, 0, 0>) +Sse2_Subtract_256: <160, 230, 233, 215, 157, 62, 50, 132, 126, 224, 96, 124, 24, 75, 156, 27>. array2: () +Sse2_Subtract_257: <-73, -25, 74, 103, 80, -70, -44, 55, 30, -39, -89, 91, 37, 8, -85, -90>. array2: () +Sse2_Subtract_258: <21645, -29975, 1094, 17601, -13472, -9964, 11560, -24249>. array2: () +Sse2_Subtract_259: <26186, 3481, 38415, 7518, 17321, 4039, 44038, 26103>. array2: () +Sse2_Subtract_260: <1752063807, -2120203365, 1228453705, -2119657212>. array2: () +Sse2_Subtract_261: <3969082326, 2184163409, 4081145663, 4176352062>. array2: () +Sse2_Subtract_262: <-4910781699293484746, -3370418193084307290>. array2: () +Sse2_Subtract_263: <14342934063833242115, 17414808663155410193>. array2: () +Sse2_Subtract_264: <193503084, 843643408>. array2: () +Sse2_SubtractSaturate_265: <21, 1, 71, 127, -128, 68, 48, 127, -80, -19, 127, 105, 3, -128, 10, 53>. array2: () +Sse2_SubtractSaturate_266: <23654, 9415, -29015, -26904, -32768, -7444, 32767, -19469>. array2: () +Sse2_SubtractSaturate_267: <63, 171, 105, 0, 9, 0, 148, 1, 120, 0, 0, 45, 0, 59, 0, 39>. array2: () +Sse2_SubtractSaturate_268: <0, 0, 0, 0, 7195, 0, 0, 0>. array2: () +Sse2_SubtractScalar_269: <1970504049, 1505837714>. array2: () +Sse2_SumAbsoluteDifferences_270: <1022, 0, 0, 0, 992, 0, 0, 0>. array2: () +Sse2_UnpackHigh_271: <81, 59, 45, 174, 151, 115, 109, 178, 220, 64, 156, 107, 96, 28, 86, 177>. array2: () +Sse2_UnpackHigh_272: <4, -78, 15, 97, 85, -39, 70, 39, 85, -3, 114, 51, -86, 63, 19, 68>. array2: () +Sse2_UnpackHigh_273: <-24344, 10928, 20063, 8655, -23489, 23439, 12848, 27682>. array2: () +Sse2_UnpackHigh_274: <56624, 49657, 6555, 16770, 54792, 47497, 12329, 10935>. array2: () +Sse2_UnpackHigh_275: <-825727960, 1120004366, -1677873319, 440059928>. array2: () +Sse2_UnpackHigh_276: <3319442934, 996575506, 3072538177, 547440493>. array2: () +Sse2_UnpackHigh_277: <3425509541459654197, 0>. array2: () +Sse2_UnpackHigh_278: <9433075728538032088, 1802401848097591360>. array2: () +Sse2_UnpackHigh_279: <-1940783574, -88790362>. array2: () +Sse2_UnpackLow_280: <185, 20, 19, 134, 60, 169, 6, 226, 112, 116, 19, 133, 191, 30, 80, 223>. array2: () +Sse2_UnpackLow_281: <-24, -31, -112, -62, -57, 45, 120, -90, 17, 42, -63, 47, -83, -12, 1, -19>. array2: () +Sse2_UnpackLow_282: <12424, -6520, -32517, -20374, -22126, -7716, -15631, -8804>. array2: () +Sse2_UnpackLow_283: <55838, 34857, 45686, 46119, 7765, 50349, 47937, 63597>. array2: () +Sse2_UnpackLow_284: <1887548648, -106265407, 1948132023, -30817730>. array2: () +Sse2_UnpackLow_285: <1638019327, 1227734346, 291565234, 1511475018>. array2: () +Sse2_UnpackLow_286: <7967186738692185031, 6300179238364950333>. array2: () +Sse2_UnpackLow_287: <4302923488072565196, 1107715779998428353>. array2: () +Sse2_UnpackLow_288: <0, -1169211751>. array2: () +Sse2_Xor_289: <123, 176, 95, 128, 70, 47, 227, 174, 227, 215, 80, 165, 213, 114, 45, 254>. array2: () +Sse2_Xor_290: <12, 93, -36, -8, 125, 111, -58, -28, -48, 90, -44, -97, 7, -47, 41, -123>. array2: () +Sse2_Xor_291: <-29920, -4133, 13956, -16810, -24522, -15331, -17686, -32266>. array2: () +Sse2_Xor_292: <3063, 22132, 38842, 28704, 25905, 32058, 39706, 26936>. array2: () +Sse2_Xor_293: <755389418, 769245143, 76269295, 1263766898>. array2: () +Sse2_Xor_294: <2382442687, 3163532978, 2204809151, 4234290081>. array2: () +Sse2_Xor_295: <2709152929969082560, 6804690265923088076>. array2: () +Sse2_Xor_296: <10966841827685851620, 17485109639731884102>. array2: () +Sse2_Xor_297: <1.3179603345489727E-306, 2.7753908835538394E-306>. array2: () +Sse3_AddSubtract_0: <-288245800, 485282300, -148528380, 175195780>. array2: () +Sse3_AddSubtract_1: <377350428, 2880251686>. array2: () +Sse3_HorizontalAdd_3: <-1.4537478E+09, -608964740, 932101440, 317462530>. array2: () +Sse3_HorizontalAdd_4: <0, -1011215482>. array2: () +Sse3_HorizontalSubtract_5: <134859580, 290265800, -410409730, 225053500>. array2: () +Sse3_HorizontalSubtract_6: <-39981208, 772075022>. array2: () +Sse3_LoadAndDuplicateToVector128_7: <0, 0>. array2: () +Sse3_LoadDquVector128_10: <256, 770, 1284, 1798, 2312, 2826, 3340, 3854>. array2: () +Sse3_LoadDquVector128_11: <256, 770, 1284, 1798, 2312, 2826, 3340, 3854>. array2: () +Sse3_LoadDquVector128_12: <50462976, 117835012, 185207048, 252579084>. array2: () +Sse3_LoadDquVector128_13: <50462976, 117835012, 185207048, 252579084>. array2: () +Sse3_LoadDquVector128_14: <506097522914230528, 1084818905618843912>. array2: () +Sse3_LoadDquVector128_15: <506097522914230528, 1084818905618843912>. array2: () +Sse3_LoadDquVector128_8: <0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15>. array2: () +Sse3_LoadDquVector128_9: <0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15>. array2: () +Sse3_MoveAndDuplicate_16: <422894897, 422894897>. array2: () +Sse3_MoveHighAndDuplicate_17: <571501200, 571501200, 329727360, 329727360>. array2: () +Sse3_MoveLowAndDuplicate_18: <-189382530, -189382530, -201301700, -201301700>. array2: () +Sse41_Blend_0: <-28181, 8056, -26435, 1838, 18747, 5118, 1458, -6560>. array2: () +Sse41_Blend_1: <14880, 34662, 8325, 12447, 3177, 16199, 6880, 7815>. array2: () +Sse41_Blend_2: <491788830, 7742888, 361228860, 142832030>. array2: () +Sse41_Blend_3: <1824188881, -718259854>. array2: () +Sse41_BlendVariable_10: <-4986989475177804591, -3411647568405592666>. array2: () +Sse41_BlendVariable_11: <16427713610026539347, 17248869451145481562>. array2: () +Sse41_BlendVariable_12: <114734470, 113439390, 161092800, 334321300>. array2: () +Sse41_BlendVariable_13: <1271945793, 621651665>. array2: () +Sse41_BlendVariable_4: <-17, 87, 20, 53, 10, -33, 0, 65, 18, 7, 89, 73, -61, -105, -73, 48>. array2: () +Sse41_BlendVariable_5: <102, 26, 159, 80, 223, 125, 208, 80, 109, 87, 34, 5, 251, 3, 71, 85>. array2: () +Sse41_BlendVariable_6: <-31512, 848, -24102, 17728, 13830, 4091, 11118, 31413>. array2: () +Sse41_BlendVariable_7: <60928, 0, 6153, 5, 0, 13, 61440, 188>. array2: () +Sse41_BlendVariable_8: <1417959254, 237094035, 1139339792, 1710903878>. array2: () +Sse41_BlendVariable_9: <1936970067, 1287167484, 861093958, 1596488650>. array2: () +Sse41_Ceiling_14: <976807230, 387127940, 231049630, 95996256>. array2: () +Sse41_Ceiling_15: <-1271902475, -1320771022>. array2: () +Sse41_CeilingScalar_16: <596644776, 576770326>. array2: () +Sse41_CeilingScalar_17: <-996174700, -26349984, -199809980, -374892500>. array2: () +Sse41_CeilingScalar_18: <-1474400142, 1343022939>. array2: () +Sse41_CeilingScalar_19: <841868900, -645329300, -447306460, -27179420>. array2: () +Sse41_CompareEqual_20: <0, 0>. array2: () +Sse41_CompareEqual_21: <0, 0>. array2: () +Sse41_ConvertToVector128Int16_22: <-75, -56, 63, 60, -92, -10, -36, 7>. array2: () +Sse41_ConvertToVector128Int16_23: <242, 81, 177, 67, 109, 131, 246, 49>. array2: () +Sse41_ConvertToVector128Int16_24: <0, 1, 2, 3, 4, 5, 6, 7>. array2: () +Sse41_ConvertToVector128Int16_25: <0, 1, 2, 3, 4, 5, 6, 7>. array2: () +Sse41_ConvertToVector128Int32_26: <-58, 119, 104, -119>. array2: () +Sse41_ConvertToVector128Int32_27: <161, 95, 181, 45>. array2: () +Sse41_ConvertToVector128Int32_28: <-20353, -28133, -5483, -2632>. array2: () +Sse41_ConvertToVector128Int32_29: <58696, 60254, 11748, 60669>. array2: () +Sse41_ConvertToVector128Int32_30: <0, 1, 2, 3>. array2: () +Sse41_ConvertToVector128Int32_31: <0, 1, 2, 3>. array2: () +Sse41_ConvertToVector128Int32_32: <256, 770, 1284, 1798>. array2: () +Sse41_ConvertToVector128Int32_33: <256, 770, 1284, 1798>. array2: () +Sse41_ConvertToVector128Int64_34: <-89, -82>. array2: () +Sse41_ConvertToVector128Int64_35: <231, 107>. array2: () +Sse41_ConvertToVector128Int64_36: <18053, -15316>. array2: () +Sse41_ConvertToVector128Int64_37: <30546, 35535>. array2: () +Sse41_ConvertToVector128Int64_38: <2005088466, 1180082193>. array2: () +Sse41_ConvertToVector128Int64_39: <0, 0>. array2: () +Sse41_ConvertToVector128Int64_40: <0, 1>. array2: () +Sse41_ConvertToVector128Int64_41: <0, 1>. array2: () +Sse41_ConvertToVector128Int64_42: <256, 770>. array2: () +Sse41_ConvertToVector128Int64_43: <256, 770>. array2: () +Sse41_ConvertToVector128Int64_44: <50462976, 117835012>. array2: () +Sse41_ConvertToVector128Int64_45: <50462976, 117835012>. array2: () +Sse41_DotProduct_46: <0, 0, 0, 0>. array2: () +Sse41_DotProduct_47: <0, 0>. array2: () +Sse41_Extract_48: 0. array2: () +Sse41_Extract_49: 205898021. array2: () +Sse41_Extract_50: 2010097471. array2: () +Sse41_Extract_51: 443243500. array2: () +Sse41_Floor_52: <386100000, 207527100, 495481120, 19563034>. array2: () +Sse41_Floor_53: <1749484095, 254253946>. array2: () +Sse41_FloorScalar_54: <2105495297, 1615400991>. array2: () +Sse41_FloorScalar_55: <600926660, 470214500, 195817310, 346740700>. array2: () +Sse41_FloorScalar_56: <751097772, 0>. array2: () +Sse41_FloorScalar_57: <938370050, -39845504, -43406284, -151803180>. array2: () +Sse41_Insert_59: <-1, -27, 59, 87, -116, -128, -32, 82, 126, -109, -14, 83, -108, 61, 90, 39>. array2: () +Sse41_Insert_60: <50, 137, 132, 245, 172, 251, 139, 204, 26, 85, 175, 202, 195, 167, 175, 133>. array2: () +Sse41_Insert_61: <113469686, 366453791, -1696173006, 1426620191>. array2: () +Sse41_Insert_62: <3319556977, 1821918078, 2572121724, 2432579270>. array2: () +Sse41_Insert_63: <794284160, -10099458, 440350530, 106081200>. array2: () +Sse41_LoadAlignedVector128NonTemporal_64: <0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15>. array2: () +Sse41_LoadAlignedVector128NonTemporal_65: <0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15>. array2: () +Sse41_LoadAlignedVector128NonTemporal_66: <256, 770, 1284, 1798, 2312, 2826, 3340, 3854>. array2: () +Sse41_LoadAlignedVector128NonTemporal_67: <256, 770, 1284, 1798, 2312, 2826, 3340, 3854>. array2: () +Sse41_LoadAlignedVector128NonTemporal_68: <50462976, 117835012, 185207048, 252579084>. array2: () +Sse41_LoadAlignedVector128NonTemporal_69: <50462976, 117835012, 185207048, 252579084>. array2: () +Sse41_LoadAlignedVector128NonTemporal_70: <506097522914230528, 1084818905618843912>. array2: () +Sse41_LoadAlignedVector128NonTemporal_71: <506097522914230528, 1084818905618843912>. array2: () +Sse41_Max_72: <0, 62, 14, 0, 0, 23, 0, 0, 0, 44, 0, 0, 60, 0, 18, 0>. array2: () +Sse41_Max_73: <64529, 24246, 60292, 11349, 52920, 7767, 46095, 16553>. array2: () +Sse41_Max_74: <1468978862, 1260319873, 1553029212, 1159805043>. array2: () +Sse41_Max_75: <3303376326, 2933272066, 2724997452, 3968450988>. array2: () +Sse41_Min_76: <-24, -70, 89, 50, -41, -78, -86, 4, 4, 2, -54, 70, -63, -34, 67, 19>. array2: () +Sse41_Min_77: <19072, 10363, 7372, 16990, 17907, 25895, 25631, 8780>. array2: () +Sse41_Min_78: <227355155, 833264934, 182554724, 552275494>. array2: () +Sse41_Min_79: <1682696560, 1415080162, 1093433754, 1402296729>. array2: () +Sse41_MinHorizontal_80: <7625, 4, 0, 0, 0, 0, 0, 0>. array2: () +Sse41_MultipleSumAbsoluteDifferences_81: <510, 411, 458, 485, 446, 477, 418, 429>. array2: () +Sse41_Multiply_82: <0, 0>. array2: () +Sse41_MultiplyLow_83: <-444023120, -1604807418, -513618072, 364285130>. array2: () +Sse41_MultiplyLow_84: <2842399402, 3219790566, 82485812, 798265648>. array2: () +Sse41_PackUnsignedSaturate_85: <65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535>. array2: () +Sse41_RoundCurrentDirection_86: <1439949737, 982687573>. array2: () +Sse41_RoundCurrentDirection_87: <94789504, 306488300, 300036380, 200679310>. array2: () +Sse41_RoundCurrentDirectionScalar_88: <-514290506, -975606360>. array2: () +Sse41_RoundCurrentDirectionScalar_89: <-151982141, 1381285838>. array2: () +Sse41_RoundCurrentDirectionScalar_90: <1.0009005E+09, 82311576, 420004580, 377080260>. array2: () +Sse41_RoundCurrentDirectionScalar_91: <908986750, 0, 0, 0>. array2: () +Sse41_RoundToNearestInteger_92: <971570600, 342674340, 84637136, 279661020>. array2: () +Sse41_RoundToNearestInteger_93: <0, 0>. array2: () +Sse41_RoundToNearestIntegerScalar_94: <1503033702, 1356128743>. array2: () +Sse41_RoundToNearestIntegerScalar_95: <1958960619, 397956293>. array2: () +Sse41_RoundToNearestIntegerScalar_96: <115528456, 284659620, 172975940, 167663550>. array2: () +Sse41_RoundToNearestIntegerScalar_97: <-829306000, 0, 0, 0>. array2: () +Sse41_RoundToNegativeInfinity_98: <613514000, 556777100, 409394500, 70652570>. array2: () +Sse41_RoundToNegativeInfinity_99: <901160652, 699665279>. array2: () +Sse41_RoundToNegativeInfinityScalar_100: <0, 0>. array2: () +Sse41_RoundToNegativeInfinityScalar_101: <1083911923, -369574546>. array2: () +Sse41_RoundToNegativeInfinityScalar_102: <1.0058966E+09, 224250110, 97383590, 256521380>. array2: () +Sse41_RoundToNegativeInfinityScalar_103: <569111040, -706565950, -134511490, -170974940>. array2: () +Sse41_RoundToPositiveInfinity_104: <-1346950085, -1061512967>. array2: () +Sse41_RoundToPositiveInfinity_105: <-437554370, -688066100, -401424450, -24426856>. array2: () +Sse41_RoundToPositiveInfinityScalar_106: <1678875284, 1006413517>. array2: () +Sse41_RoundToPositiveInfinityScalar_107: <0, 1793942551>. array2: () +Sse41_RoundToPositiveInfinityScalar_108: <-949690750, -20584142, -125257490, -132031256>. array2: () +Sse41_RoundToPositiveInfinityScalar_109: <0, -7623213.5, -369909760, -333072740>. array2: () +Sse41_RoundToZero_110: <-164666379, -6857492>. array2: () +Sse41_RoundToZero_111: <-727772600, -644844740, -52200804, -334492600>. array2: () +Sse41_RoundToZeroScalar_112: <0, 0>. array2: () +Sse41_RoundToZeroScalar_113: <325755288, 284278557>. array2: () +Sse41_RoundToZeroScalar_114: <370526980, 450870270, 114232630, 101882510>. array2: () +Sse41_RoundToZeroScalar_115: <199417310, 575768600, 454732830, 146941410>. array2: () +Sse41_TestC_116: False. array2: () +Sse41_TestC_117: False. array2: () +Sse41_TestC_118: False. array2: () +Sse41_TestC_119: False. array2: () +Sse41_TestC_120: False. array2: () +Sse41_TestC_121: False. array2: () +Sse41_TestC_122: False. array2: () +Sse41_TestC_123: False. array2: () +Sse41_TestNotZAndNotC_124: True. array2: () +Sse41_TestNotZAndNotC_125: True. array2: () +Sse41_TestNotZAndNotC_126: True. array2: () +Sse41_TestNotZAndNotC_127: True. array2: () +Sse41_TestNotZAndNotC_128: True. array2: () +Sse41_TestNotZAndNotC_129: True. array2: () +Sse41_TestNotZAndNotC_130: False. array2: () +Sse41_TestNotZAndNotC_131: True. array2: () +Sse41_TestZ_132: False. array2: () +Sse41_TestZ_133: False. array2: () +Sse41_TestZ_134: True. array2: () +Sse41_TestZ_135: False. array2: () +Sse41_TestZ_136: False. array2: () +Sse41_TestZ_137: True. array2: () +Sse41_TestZ_138: True. array2: () +Sse41_TestZ_139: True. array2: () +Sse42_CompareGreaterThan_0: <-1, -1>. array2: () +Sse42_Crc32_1: 3048296493. array2: () +Sse42_Crc32_2: 720008765. array2: () +Sse42_Crc32_3: 1709792733. array2: () +Ssse3_Abs_0: <20, 123, 42, 117, 5, 108, 125, 122, 2, 74, 125, 98, 15, 83, 90, 120>. array2: () +Ssse3_Abs_1: <15049, 32579, 12411, 18332, 19344, 20844, 19247, 7169>. array2: () +Ssse3_Abs_2: <1289855926, 1521543026, 1209975474, 1048481122>. array2: () +Ssse3_AlignRight_10: <0, 0>. array2: () +Ssse3_AlignRight_3: <0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0>. array2: () +Ssse3_AlignRight_4: <0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0>. array2: () +Ssse3_AlignRight_5: <0, 0, 0, 0, 0, 0, 0, 0>. array2: () +Ssse3_AlignRight_6: <0, 0, 0, 0, 0, 0, 0, 0>. array2: () +Ssse3_AlignRight_7: <-588188473, -861861738, -970398219, 0>. array2: () +Ssse3_AlignRight_8: <0, 0, 0, 0>. array2: () +Ssse3_AlignRight_9: <0, 0>. array2: () +Ssse3_HorizontalAdd_12: <-28016, -14356, -25639, -6147, 29319, 31790, 19886, -11366>. array2: () +Ssse3_HorizontalAdd_13: <0, 0, 0, 0>. array2: () +Ssse3_HorizontalAddSaturate_14: <30343, 25832, 71, 3968, 25111, 5416, 13362, -27366>. array2: () +Ssse3_HorizontalSubtract_15: <-17693, -24059, 14090, 11294, -30328, 3313, -3245, -31852>. array2: () +Ssse3_HorizontalSubtract_16: <1423497201, 543575668, -141636812, 445982764>. array2: () +Ssse3_HorizontalSubtractSaturate_17: <-32768, -23864, -11719, -32768, -18996, -16034, 7266, -21252>. array2: () +Ssse3_MultiplyAddAdjacent_18: <-8018, -6804, 12098, -25160, 26653, -13540, 32767, 5758>. array2: () +Ssse3_MultiplyHighRoundScale_19: <0, 0, 0, 0, 0, 0, 0, 0>. array2: () +Ssse3_Shuffle_20: <41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41>. array2: () +Ssse3_Shuffle_21: <131, 180, 36, 211, 140, 71, 0, 36, 0, 0, 32, 252, 250, 5, 0, 245>. array2: () +Ssse3_Sign_22: <114, -57, 105, -103, -101, 43, -3, -94, -64, -80, -24, -55, 57, 70, -96, -85>. array2: () +Ssse3_Sign_23: <8146, 23251, -5348, 13795, 16285, 31796, -1712, 19564>. array2: () +Ssse3_Sign_24: <-1690542095, -1073268168, -1839363387, -426479517>. array2: () +Vector128_byte_to_int: <1881994049, -584023631, -1957556255, 1248354443>. array2: () +Vector128_Create_1: <37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37>. array2: () +Vector128_Create_10: <-112905214.5, -112905214.5>. array2: () +Vector128_Create_11: <1043346112.5, -989284283>. array2: () +Vector128_Create_12: <-1494540230, -1006562512>. array2: () +Vector128_Create_13: <1739630930, 18446744073526515366>. array2: () +Vector128_Create_14: <706899800, -723907460, -320707740, 634857800>. array2: () +Vector128_Create_15: <-1325323419, 815439320, -1175553948, -2143918760>. array2: () +Vector128_Create_16: <380379792, 702957838, 734971347, 975465225>. array2: () +Vector128_Create_17: <36832, 33999, 43142, 4384, 48727, 60061, 19158, 56428>. array2: () +Vector128_Create_18: <3028, -26498, -7017, -2304, -23167, 20218, 23682, 25060>. array2: () +Vector128_Create_2: <-48, -48, -48, -48, -48, -48, -48, -48, -48, -48, -48, -48, -48, -48, -48, -48>. array2: () +Vector128_Create_20: <81, -49, 50, 110, -51, -100, -120, 55, -25, -37, -18, 47, 40, 62, 104, 42>. array2: () +Vector128_Create_3: <11289, 11289, 11289, 11289, 11289, 11289, 11289, 11289>. array2: () +Vector128_Create_4: <17230, 17230, 17230, 17230, 17230, 17230, 17230, 17230>. array2: () +Vector128_Create_5: <1644952972, 1644952972, 1644952972, 1644952972>. array2: () +Vector128_Create_6: <687315921, 687315921, 687315921, 687315921>. array2: () +Vector128_Create_7: <-1945223177, -1945223177>. array2: () +Vector128_Create_8: <2012609464, 2012609464>. array2: () +Vector128_Create_9: <7037300, 7037300, 7037300, 7037300>. array2: () +Vector128_CreateScalarUnsafe_1: 50. array2: () +Vector128_CreateScalarUnsafe_2: 50. array2: () +Vector128_int_to_byte: <39, 29, 58, 30, 232, 148, 103, 159, 80, 53, 164, 98, 116, 134, 103, 206>. array2: () +Vector128_int_to_ulong: <15148853770521024483, 12898404362374625286>. array2: () |