From 022b26327afba2329307bfbda6dc0a2c51b41cc2 Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Thu, 28 Dec 2017 16:28:42 -0800
Subject: [PATCH 1/2] Adding scalar hardware intrinsics for x86

---
 .../ref/System.Runtime.Intrinsics.X86.cs      | 130 +++++++++++++++++-
 1 file changed, 128 insertions(+), 2 deletions(-)

diff --git a/src/System.Runtime.Intrinsics.X86/ref/System.Runtime.Intrinsics.X86.cs b/src/System.Runtime.Intrinsics.X86/ref/System.Runtime.Intrinsics.X86.cs
index 6b30333c3c9b..fb2b303e2e91 100644
--- a/src/System.Runtime.Intrinsics.X86/ref/System.Runtime.Intrinsics.X86.cs
+++ b/src/System.Runtime.Intrinsics.X86/ref/System.Runtime.Intrinsics.X86.cs
@@ -59,6 +59,9 @@ public static class Avx
         public static Vector128<double> Compare(Vector128<double> left, Vector128<double> right, FloatComparisonMode mode) { throw null; }
         public static Vector256<float> Compare(Vector256<float> left, Vector256<float> right, FloatComparisonMode mode) { throw null; }
         public static Vector256<double> Compare(Vector256<double> left, Vector256<double> right, FloatComparisonMode mode) { throw null; }
+        public static Vector128<double> CompareScalar(Vector128<double> left, Vector128<double> right, FloatComparisonMode mode) { throw null; }
+        public static Vector128<float> CompareScalar(Vector128<float> left, Vector128<float> right, FloatComparisonMode mode) { throw null; }
+        public static float ConvertToSingle(Vector256<float> value) { throw null; }
         public static Vector128<int> ConvertToVector128Int32(Vector256<double> value) { throw null; }
         public static Vector128<float> ConvertToVector128Single(Vector256<double> value) { throw null; }
         public static Vector256<int> ConvertToVector256Int32(Vector256<float> value) { throw null; }
@@ -322,6 +325,9 @@ public static class Avx2
         public static Vector256<short> CompareGreaterThan(Vector256<short> left, Vector256<short> right) { throw null; }
         public static Vector256<int> CompareGreaterThan(Vector256<int> left, Vector256<int> right) { throw null; }
         public static Vector256<long> CompareGreaterThan(Vector256<long> left, Vector256<long> right) { throw null; }
+        public static double ConvertToDouble(Vector256<double> value) { throw null; }
+        public static int ConvertToInt32(Vector256<int> value) { throw null; }
+        public static uint ConvertToUInt32(Vector256<uint> value) { throw null; }
         public static Vector256<short> ConvertToVector256Int16(Vector128<sbyte> value) { throw null; }
         public static Vector256<ushort> ConvertToVector256UInt16(Vector128<byte> value) { throw null; }
         public static Vector256<int> ConvertToVector256Int32(Vector128<sbyte> value) { throw null; }
@@ -639,7 +645,8 @@ public enum FloatComparisonMode : byte
         GreaterThanOrderedNonSignaling = 30,
         TrueUnorderedSignaling = 31,
     }
-    public enum StringComparisonMode : byte {
+    public enum StringComparisonMode : byte
+    {
         EqualAny = 0x00,
         Ranges = 0x04,
         EqualEach = 0x08,
@@ -649,7 +656,8 @@ public enum StringComparisonMode : byte {
         LeastSignificant = 0x00,
         MostSignificant = 0x40,
     }
-    public enum ResultsFlag : byte {
+    public enum ResultsFlag : byte
+    {
         CFlag = 0,
         NotCFlagAndNotZFlag = 1,
         OFlag = 2,
@@ -663,6 +671,8 @@ public static class Fma
         public static Vector128<double> MultiplyAdd(Vector128<double> a, Vector128<double> b, Vector128<double> c) { throw null; }
         public static Vector256<float> MultiplyAdd(Vector256<float> a, Vector256<float> b, Vector256<float> c) { throw null; }
         public static Vector256<double> MultiplyAdd(Vector256<double> a, Vector256<double> b, Vector256<double> c) { throw null; }
+        public static Vector128<double> MultiplyAddScalar(Vector128<double> a, Vector128<double> b, Vector128<double> c) { throw null; }
+        public static Vector128<float> MultiplyAddScalar(Vector128<float> a, Vector128<float> b, Vector128<float> c) { throw null; }
         public static Vector128<float> MultiplyAddSubtract(Vector128<float> a, Vector128<float> b, Vector128<float> c) { throw null; }
         public static Vector128<double> MultiplyAddSubtract(Vector128<double> a, Vector128<double> b, Vector128<double> c) { throw null; }
         public static Vector256<float> MultiplyAddSubtract(Vector256<float> a, Vector256<float> b, Vector256<float> c) { throw null; }
@@ -675,14 +685,20 @@ public static class Fma
         public static Vector128<double> MultiplySubtractAdd(Vector128<double> a, Vector128<double> b, Vector128<double> c) { throw null; }
         public static Vector256<float> MultiplySubtractAdd(Vector256<float> a, Vector256<float> b, Vector256<float> c) { throw null; }
         public static Vector256<double> MultiplySubtractAdd(Vector256<double> a, Vector256<double> b, Vector256<double> c) { throw null; }
+        public static Vector128<double> MultiplySubtractScalar(Vector128<double> a, Vector128<double> b, Vector128<double> c) { throw null; }
+        public static Vector128<float> MultiplySubtractScalar(Vector128<float> a, Vector128<float> b, Vector128<float> c) { throw null; }
         public static Vector128<float> MultiplyAddNegated(Vector128<float> a, Vector128<float> b, Vector128<float> c) { throw null; }
         public static Vector128<double> MultiplyAddNegated(Vector128<double> a, Vector128<double> b, Vector128<double> c) { throw null; }
         public static Vector256<float> MultiplyAddNegated(Vector256<float> a, Vector256<float> b, Vector256<float> c) { throw null; }
         public static Vector256<double> MultiplyAddNegated(Vector256<double> a, Vector256<double> b, Vector256<double> c) { throw null; }
+        public static Vector128<double> MultiplyAddNegatedScalar(Vector128<double> a, Vector128<double> b, Vector128<double> c) { throw null; }
+        public static Vector128<float> MultiplyAddNegatedScalar(Vector128<float> a, Vector128<float> b, Vector128<float> c) { throw null; }
         public static Vector128<float> MultiplySubtractNegated(Vector128<float> a, Vector128<float> b, Vector128<float> c) { throw null; }
         public static Vector128<double> MultiplySubtractNegated(Vector128<double> a, Vector128<double> b, Vector128<double> c) { throw null; }
         public static Vector256<float> MultiplySubtractNegated(Vector256<float> a, Vector256<float> b, Vector256<float> c) { throw null; }
         public static Vector256<double> MultiplySubtractNegated(Vector256<double> a, Vector256<double> b, Vector256<double> c) { throw null; }
+        public static Vector128<double> MultiplySubtractNegatedScalar(Vector128<double> a, Vector128<double> b, Vector128<double> c) { throw null; }
+        public static Vector128<float> MultiplySubtractNegatedScalar(Vector128<float> a, Vector128<float> b, Vector128<float> c) { throw null; }
     }
     public static class Lzcnt
     {
@@ -706,41 +722,85 @@ public static class Sse
     {
         public static bool IsSupported { get { return false; } }
         public static Vector128<float> Add(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
+        public static Vector128<float> AddScalar(Vector128<float> left, Vector128<float> right) { throw null; }
         public static Vector128<float> And(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
         public static Vector128<float> AndNot(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
         public static Vector128<float> CompareEqual(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
+        public static bool CompareEqualOrderedScalar(Vector128<float> left, Vector128<float> right) { throw null; }
+        public static Vector128<float> CompareEqualScalar(Vector128<float> left, Vector128<float> right) { throw null; }
+        public static bool CompareEqualUnorderedScalar(Vector128<float> left, Vector128<float> right) { throw null; }
         public static Vector128<float> CompareGreaterThan(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
+        public static bool CompareGreaterThanOrderedScalar(Vector128<float> left, Vector128<float> right) { throw null; }
+        public static Vector128<float> CompareGreaterThanScalar(Vector128<float> left, Vector128<float> right) { throw null; }
+        public static bool CompareGreaterThanUnorderedScalar(Vector128<float> left, Vector128<float> right) { throw null; }
         public static Vector128<float> CompareGreaterThanOrEqual(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
+        public static bool CompareGreaterThanOrEqualOrderedScalar(Vector128<float> left, Vector128<float> right) { throw null; }
+        public static Vector128<float> CompareGreaterThanOrEqualScalar(Vector128<float> left, Vector128<float> right) { throw null; }
+        public static bool CompareGreaterThanOrEqualUnorderedScalar(Vector128<float> left, Vector128<float> right) { throw null; }
         public static Vector128<float> CompareLessThan(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
+        public static bool CompareLessThanOrderedScalar(Vector128<float> left, Vector128<float> right) { throw null; }
+        public static Vector128<float> CompareLessThanScalar(Vector128<float> left, Vector128<float> right) { throw null; }
+        public static bool CompareLessThanUnorderedScalar(Vector128<float> left, Vector128<float> right) { throw null; }
         public static Vector128<float> CompareLessThanOrEqual(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
+        public static bool CompareLessThanOrEqualOrderedScalar(Vector128<float> left, Vector128<float> right) { throw null; }
+        public static Vector128<float> CompareLessThanOrEqualScalar(Vector128<float> left, Vector128<float> right) { throw null; }
+        public static bool CompareLessThanOrEqualUnorderedScalar(Vector128<float> left, Vector128<float> right) { throw null; }
         public static Vector128<float> CompareNotEqual(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
+        public static bool CompareNotEqualOrderedScalar(Vector128<float> left, Vector128<float> right) { throw null; }
+        public static Vector128<float> CompareNotEqualScalar(Vector128<float> left, Vector128<float> right) { throw null; }
+        public static bool CompareNotEqualUnorderedScalar(Vector128<float> left, Vector128<float> right) { throw null; }
         public static Vector128<float> CompareNotGreaterThan(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
+        public static Vector128<float> CompareNotGreaterThanScalar(Vector128<float> left, Vector128<float> right) { throw null; }
         public static Vector128<float> CompareNotGreaterThanOrEqual(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
+        public static Vector128<float> CompareNotGreaterThanOrEqualScalar(Vector128<float> left, Vector128<float> right) { throw null; }
         public static Vector128<float> CompareNotLessThan(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
+        public static Vector128<float> CompareNotLessThanScalar(Vector128<float> left, Vector128<float> right) { throw null; }
         public static Vector128<float> CompareNotLessThanOrEqual(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
+        public static Vector128<float> CompareNotLessThanOrEqualScalar(Vector128<float> left, Vector128<float> right) { throw null; }
         public static Vector128<float> CompareOrdered(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
+        public static Vector128<float> CompareOrderedScalar(Vector128<float> left, Vector128<float> right) { throw null; }
         public static Vector128<float> CompareUnordered(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
+        public static Vector128<float> CompareUnorderedScalar(Vector128<float> left, Vector128<float> right) { throw null; }
+        public static int ConvertToInt32(Vector128<float> value) { throw null; }
+        public static int ConvertToInt32WithTruncation(Vector128<float> value) { throw null; }
+        public static long ConvertToInt64WithTruncation(Vector128<float> value) { throw null; }
+        public static long ConvertToInt64(Vector128<float> value) { throw null; }
+        public static float ConvertToSingle(Vector128<float> value) { throw null; }
+        public static Vector128<float> ConvertToVector128SingleScalar(Vector128<float> upper, int value) { throw null; }
+        public static Vector128<float> ConvertToVector128SingleScalar(Vector128<float> upper, long value) { throw null; }
         public static Vector128<float> Divide(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
+        public static Vector128<float> DivideScalar(Vector128<float> left, Vector128<float> right) { throw null; }
         public static unsafe Vector128<float> Load(float* address) { throw new NotImplementedException(); }
         public static unsafe Vector128<float> LoadAligned(float* address) { throw new NotImplementedException(); }
+        public static unsafe Vector128<float> LoadScalar(float* address) { throw null; }
         public static Vector128<float> Max(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
+        public static Vector128<float> MaxScalar(Vector128<float> left, Vector128<float> right) { throw null; }
         public static Vector128<float> Min(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
+        public static Vector128<float> MinScalar(Vector128<float> left, Vector128<float> right) { throw null; }
         public static Vector128<float> MoveHighToLow(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
         public static Vector128<float> MoveLowToHigh(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
+        public static Vector128<float> MoveScalar(Vector128<float> upper, Vector128<float> value) { throw null; }
         public static Vector128<float> Multiply(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
+        public static Vector128<float> MultiplyScalar(Vector128<float> left, Vector128<float> right) { throw null; }
         public static Vector128<float> Or(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
         public static Vector128<float> Reciprocal(Vector128<float> value) { throw new NotImplementedException(); }
+        public static Vector128<float> ReciprocalScalar(Vector128<float> value) { throw null; }
         public static Vector128<float> ReciprocalSqrt(Vector128<float> value) { throw new NotImplementedException(); }
+        public static Vector128<float> ReciprocalSqrtScalar(Vector128<float> value) { throw null; }
         public static Vector128<float> Set(float e3, float e2, float e1, float e0) { throw new NotImplementedException(); }
         public static Vector128<float> Set1(float value) { throw new NotImplementedException(); }
+        public static Vector128<float> SetScalar(float value) { throw null; }
         public static Vector128<float> SetZero() { throw new NotImplementedException(); }
         public static Vector128<U> StaticCast<T, U>(Vector128<T> value) where T : struct where U : struct { throw new NotImplementedException(); }
         public static Vector128<float> Shuffle(Vector128<float> left, Vector128<float> right, byte control) { throw new NotImplementedException(); }
         public static Vector128<float> Sqrt(Vector128<float> value) { throw new NotImplementedException(); }
+        public static Vector128<float> SqrtScalar(Vector128<float> value) { throw null; }
         public static unsafe void StoreAligned(float* address, Vector128<float> source) { throw new NotImplementedException(); }
         public static unsafe void StoreAlignedNonTemporal(float* address, Vector128<float> source) { throw new NotImplementedException(); }
         public static unsafe void Store(float* address, Vector128<float> source) { throw new NotImplementedException(); }
+        public static unsafe void StoreScalar(float* address, Vector128<float> source) { throw null; }
         public static Vector128<float> Subtract(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
+        public static Vector128<float> SubtractScalar(Vector128<float> left, Vector128<float> right) { throw null; }
         public static Vector128<float> UnpackHigh(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
         public static Vector128<float> UnpackLow(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
         public static Vector128<float> Xor(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
@@ -757,6 +817,7 @@ public static class Sse2
         public static Vector128<long> Add(Vector128<long> left,  Vector128<long> right) { throw new NotImplementedException(); }
         public static Vector128<ulong> Add(Vector128<ulong> left,  Vector128<ulong> right) { throw new NotImplementedException(); }
         public static Vector128<double> Add(Vector128<double> left,  Vector128<double> right) { throw new NotImplementedException(); }
+        public static Vector128<double> AddScalar(Vector128<double> left, Vector128<double> right) { throw null; }
         public static Vector128<sbyte> AddSaturate(Vector128<sbyte> left,  Vector128<sbyte> right) { throw new NotImplementedException(); }
         public static Vector128<byte> AddSaturate(Vector128<byte> left,  Vector128<byte> right) { throw new NotImplementedException(); }
         public static Vector128<short> AddSaturate(Vector128<short> left,  Vector128<short> right) { throw new NotImplementedException(); }
@@ -788,32 +849,74 @@ public static class Sse2
         public static Vector128<int> CompareEqual(Vector128<int> left,  Vector128<int> right) { throw new NotImplementedException(); }
         public static Vector128<uint> CompareEqual(Vector128<uint> left,  Vector128<uint> right) { throw new NotImplementedException(); }
         public static Vector128<double> CompareEqual(Vector128<double> left,  Vector128<double> right) { throw new NotImplementedException(); }
+        public static bool CompareEqualOrderedScalar(Vector128<double> left, Vector128<double> right) { throw null; }
+        public static Vector128<double> CompareEqualScalar(Vector128<double> left, Vector128<double> right) { throw null; }
+        public static bool CompareEqualUnorderedScalar(Vector128<double> left, Vector128<double> right) { throw null; }
         public static Vector128<sbyte> CompareGreaterThan(Vector128<sbyte> left,  Vector128<sbyte> right) { throw new NotImplementedException(); }
         public static Vector128<short> CompareGreaterThan(Vector128<short> left,  Vector128<short> right) { throw new NotImplementedException(); }
         public static Vector128<int> CompareGreaterThan(Vector128<int> left,  Vector128<int> right) { throw new NotImplementedException(); }
         public static Vector128<double> CompareGreaterThan(Vector128<double> left,  Vector128<double> right) { throw new NotImplementedException(); }
+        public static bool CompareGreaterThanOrderedScalar(Vector128<double> left, Vector128<double> right) { throw null; }
+        public static Vector128<double> CompareGreaterThanScalar(Vector128<double> left, Vector128<double> right) { throw null; }
+        public static bool CompareGreaterThanUnorderedScalar(Vector128<double> left, Vector128<double> right) { throw null; }
         public static Vector128<double> CompareGreaterThanOrEqual(Vector128<double> left,  Vector128<double> right) { throw new NotImplementedException(); }
+        public static bool CompareGreaterThanOrEqualOrderedScalar(Vector128<double> left, Vector128<double> right) { throw null; }
+        public static Vector128<double> CompareGreaterThanOrEqualScalar(Vector128<double> left, Vector128<double> right) { throw null; }
+        public static bool CompareGreaterThanOrEqualUnorderedScalar(Vector128<double> left, Vector128<double> right) { throw null; }
         public static Vector128<sbyte> CompareLessThan(Vector128<sbyte> left,  Vector128<sbyte> right) { throw new NotImplementedException(); }
         public static Vector128<short> CompareLessThan(Vector128<short> left,  Vector128<short> right) { throw new NotImplementedException(); }
         public static Vector128<int> CompareLessThan(Vector128<int> left,  Vector128<int> right) { throw new NotImplementedException(); }
         public static Vector128<double> CompareLessThan(Vector128<double> left,  Vector128<double> right) { throw new NotImplementedException(); }
+        public static bool CompareLessThanOrderedScalar(Vector128<double> left, Vector128<double> right) { throw null; }
+        public static Vector128<double> CompareLessThanScalar(Vector128<double> left, Vector128<double> right) { throw null; }
+        public static bool CompareLessThanUnorderedScalar(Vector128<double> left, Vector128<double> right) { throw null; }
         public static Vector128<double> CompareLessThanOrEqual(Vector128<double> left,  Vector128<double> right) { throw new NotImplementedException(); }
+        public static bool CompareLessThanOrEqualOrderedScalar(Vector128<double> left, Vector128<double> right) { throw null; }
+        public static Vector128<double> CompareLessThanOrEqualScalar(Vector128<double> left, Vector128<double> right) { throw null; }
+        public static bool CompareLessThanOrEqualUnorderedScalar(Vector128<double> left, Vector128<double> right) { throw null; }
         public static Vector128<double> CompareNotEqual(Vector128<double> left,  Vector128<double> right) { throw new NotImplementedException(); }
+        public static bool CompareNotEqualOrderedScalar(Vector128<double> left, Vector128<double> right) { throw null; }
+        public static Vector128<double> CompareNotEqualScalar(Vector128<double> left, Vector128<double> right) { throw null; }
+        public static bool CompareNotEqualUnorderedScalar(Vector128<double> left, Vector128<double> right) { throw null; }
         public static Vector128<double> CompareNotGreaterThan(Vector128<double> left,  Vector128<double> right) { throw new NotImplementedException(); }
+        public static Vector128<double> CompareNotGreaterThanScalar(Vector128<double> left, Vector128<double> right) { throw null; }
         public static Vector128<double> CompareNotGreaterThanOrEqual(Vector128<double> left,  Vector128<double> right) { throw new NotImplementedException(); }
+        public static Vector128<double> CompareNotGreaterThanOrEqualScalar(Vector128<double> left, Vector128<double> right) { throw null; }
         public static Vector128<double> CompareNotLessThan(Vector128<double> left,  Vector128<double> right) { throw new NotImplementedException(); }
+        public static Vector128<double> CompareNotLessThanScalar(Vector128<double> left, Vector128<double> right) { throw null; }
         public static Vector128<double> CompareNotLessThanOrEqual(Vector128<double> left,  Vector128<double> right) { throw new NotImplementedException(); }
+        public static Vector128<double> CompareNotLessThanOrEqualScalar(Vector128<double> left, Vector128<double> right) { throw null; }
         public static Vector128<double> CompareOrdered(Vector128<double> left,  Vector128<double> right) { throw new NotImplementedException(); }
+        public static Vector128<double> CompareOrderedScalar(Vector128<double> left, Vector128<double> right) { throw null; }
         public static Vector128<double> CompareUnordered(Vector128<double> left,  Vector128<double> right) { throw new NotImplementedException(); }
+        public static Vector128<double> CompareUnorderedScalar(Vector128<double> left, Vector128<double> right) { throw null; }
+        public static double ConvertToDouble(Vector128<double> value) { throw null; }
+        public static int ConvertToInt32(Vector128<double> value) { throw null; }
+        public static int ConvertToInt32(Vector128<int> value) { throw null; }
+        public static int ConvertToInt32WithTruncation(Vector128<double> value) { throw null; }
+        public static long ConvertToInt64(Vector128<double> value) { throw null; }
+        public static long ConvertToInt64(Vector128<long> value) { throw null; }
+        public static long ConvertToInt64WithTruncation(Vector128<double> value) { throw null; }
+        public static uint ConvertToUInt32(Vector128<uint> value) { throw null; }
+        public static ulong ConvertToUInt64(Vector128<ulong> value) { throw null; }
+        public static Vector128<double> ConvertToVector128DoubleScalar(Vector128<double> upper, int value) { throw null; }
+        public static Vector128<double> ConvertToVector128DoubleScalar(Vector128<double> upper, long value) { throw null; }
+        public static Vector128<double> ConvertToVector128DoubleScalar(Vector128<double> upper, Vector128<float> value) { throw null; }
         public static Vector128<int> ConvertToVector128Int32(Vector128<float> value) { throw new NotImplementedException(); }
         public static Vector128<int> ConvertToVector128Int32(Vector128<double> value) { throw new NotImplementedException(); }
+        public static Vector128<int> ConvertToVector128Int32Scalar(int value) { throw null; }
+        public static Vector128<long> ConvertToVector128Int64Scalar(long value) { throw null; }
         public static Vector128<float> ConvertToVector128Single(Vector128<int> value) { throw new NotImplementedException(); }
         public static Vector128<float> ConvertToVector128Single(Vector128<double> value) { throw new NotImplementedException(); }
+        public static Vector128<float> ConvertToVector128SingleScalar(Vector128<float> upper, Vector128<double> value) { throw null; }
         public static Vector128<double> ConvertToVector128Double(Vector128<int> value) { throw new NotImplementedException(); }
         public static Vector128<double> ConvertToVector128Double(Vector128<float> value) { throw new NotImplementedException(); }
         public static Vector128<int> ConvertToVector128Int32WithTruncation(Vector128<float> value) { throw new NotImplementedException(); }
         public static Vector128<int> ConvertToVector128Int32WithTruncation(Vector128<double> value) { throw new NotImplementedException(); }
+        public static Vector128<uint> ConvertToVector128UInt32Scalar(uint value) { throw null; }
+        public static Vector128<ulong> ConvertToVector128UInt64Scalar(ulong value) { throw null; }
         public static Vector128<double> Divide(Vector128<double> left,  Vector128<double> right) { throw new NotImplementedException(); }
+        public static Vector128<double> DivideScalar(Vector128<double> left, Vector128<double> right) { throw null; }
         public static short ExtractInt16<T>(Vector128<T> value,  byte index) where T : struct { throw new NotImplementedException(); }
         public static ushort ExtractUInt16<T>(Vector128<T> value,  byte index) where T : struct { throw new NotImplementedException(); }
         public static Vector128<T> InsertInt16<T>(Vector128<T> value,  short data, byte index) where T : struct { throw new NotImplementedException(); }
@@ -836,18 +939,23 @@ public static class Sse2
         public static unsafe Vector128<long> LoadAligned(long* address) { throw new NotImplementedException(); }
         public static unsafe Vector128<ulong> LoadAligned(ulong* address) { throw new NotImplementedException(); }
         public static unsafe Vector128<double> LoadAligned(double* address) { throw new NotImplementedException(); }
+        public static unsafe Vector128<double> LoadScalar(double* address) { throw null; }
         public static unsafe void MaskMove(Vector128<sbyte> source,  Vector128<sbyte> mask, sbyte* address) { throw new NotImplementedException(); }
         public static unsafe void MaskMove(Vector128<byte> source,  Vector128<byte> mask, byte* address) { throw new NotImplementedException(); }
         public static Vector128<byte> Max(Vector128<byte> left,  Vector128<byte> right) { throw new NotImplementedException(); }
         public static Vector128<short> Max(Vector128<short> left,  Vector128<short> right) { throw new NotImplementedException(); }
         public static Vector128<double> Max(Vector128<double> left,  Vector128<double> right) { throw new NotImplementedException(); }
+        public static Vector128<double> MaxScalar(Vector128<double> left, Vector128<double> right) { throw null; }
         public static Vector128<byte> Min(Vector128<byte> left,  Vector128<byte> right) { throw new NotImplementedException(); }
         public static Vector128<short> Min(Vector128<short> left,  Vector128<short> right) { throw new NotImplementedException(); }
         public static Vector128<double> Min(Vector128<double> left,  Vector128<double> right) { throw new NotImplementedException(); }
+        public static Vector128<double> MinScalar(Vector128<double> left, Vector128<double> right) { throw null; }
         public static int MoveMask(Vector128<sbyte> value) { throw new NotImplementedException(); }
         public static int MoveMask(Vector128<double> value) { throw new NotImplementedException(); }
+        public static Vector128<double> MoveScalar(Vector128<double> upper, Vector128<double> value) { throw null; }
         public static Vector128<ulong> Multiply(Vector128<uint> left,  Vector128<uint> right) { throw new NotImplementedException(); }
         public static Vector128<double> Multiply(Vector128<double> left,  Vector128<double> right) { throw new NotImplementedException(); }
+        public static Vector128<double> MultiplyScalar(Vector128<double> left, Vector128<double> right) { throw null; }
         public static Vector128<short> MultiplyHigh(Vector128<short> left,  Vector128<short> right) { throw new NotImplementedException(); }
         public static Vector128<ushort> MultiplyHigh(Vector128<ushort> left,  Vector128<ushort> right) { throw new NotImplementedException(); }
         public static Vector128<int> MultiplyHorizontalAdd(Vector128<short> left,  Vector128<short> right) { throw new NotImplementedException(); }
@@ -882,6 +990,7 @@ public static class Sse2
         public static Vector128<long> Set1(long value) { throw new NotImplementedException(); }
         public static Vector128<ulong> Set1(ulong value) { throw new NotImplementedException(); }
         public static Vector128<double> Set1(double value) { throw new NotImplementedException(); }
+        public static Vector128<double> SetScalar(double value) { throw null; }
         public static Vector128<T> SetZero<T>() where T : struct { throw new NotImplementedException(); }
         public static Vector128<long> SumAbsoluteDifferences(Vector128<byte> left,  Vector128<byte> right) { throw new NotImplementedException(); }
         public static Vector128<int> Shuffle(Vector128<int> value, byte control) { throw new NotImplementedException(); }
@@ -922,6 +1031,7 @@ public static class Sse2
         public static Vector128<long> ShiftRightLogical128BitLane(Vector128<long> value, byte numBytes) { throw new NotImplementedException(); }
         public static Vector128<ulong> ShiftRightLogical128BitLane(Vector128<ulong> value, byte numBytes) { throw new NotImplementedException(); }
         public static Vector128<double> Sqrt(Vector128<double> value) { throw new NotImplementedException(); }
+        public static Vector128<double> SqrtScalar(Vector128<double> value) { throw null; }
         public static unsafe void StoreAligned(sbyte* address, Vector128<sbyte> source) { throw new NotImplementedException(); }
         public static unsafe void StoreAligned(byte* address, Vector128<byte> source) { throw new NotImplementedException(); }
         public static unsafe void StoreAligned(short* address, Vector128<short> source) { throw new NotImplementedException(); }
@@ -940,6 +1050,7 @@ public static class Sse2
         public static unsafe void StoreAlignedNonTemporal(long* address, Vector128<long> source) { throw new NotImplementedException(); }
         public static unsafe void StoreAlignedNonTemporal(ulong* address, Vector128<ulong> source) { throw new NotImplementedException(); }
         public static unsafe void StoreAlignedNonTemporal(double* address, Vector128<double> source) { throw new NotImplementedException(); }
+        public static unsafe void StoreScalar(double* address, Vector128<double> source) { throw null; }
         public static unsafe void Store(sbyte* address, Vector128<sbyte> source) { throw new NotImplementedException(); }
         public static unsafe void Store(byte* address, Vector128<byte> source) { throw new NotImplementedException(); }
         public static unsafe void Store(short* address, Vector128<short> source) { throw new NotImplementedException(); }
@@ -966,6 +1077,7 @@ public static class Sse2
         public static Vector128<short> SubtractSaturate(Vector128<short> left,  Vector128<short> right) { throw new NotImplementedException(); }
         public static Vector128<byte> SubtractSaturate(Vector128<byte> left,  Vector128<byte> right) { throw new NotImplementedException(); }
         public static Vector128<ushort> SubtractSaturate(Vector128<ushort> left,  Vector128<ushort> right) { throw new NotImplementedException(); }
+        public static Vector128<double> SubtractScalar(Vector128<double> left, Vector128<double> right) { throw null; }
         public static Vector128<byte> UnpackHigh(Vector128<byte> left,  Vector128<byte> right) { throw new NotImplementedException(); }
         public static Vector128<sbyte> UnpackHigh(Vector128<sbyte> left,  Vector128<sbyte> right) { throw new NotImplementedException(); }
         public static Vector128<short> UnpackHigh(Vector128<short> left,  Vector128<short> right) { throw new NotImplementedException(); }
@@ -1029,6 +1141,8 @@ public static class Sse41
         public static Vector128<double> BlendVariable(Vector128<double> left, Vector128<double> right, Vector128<double> mask) { throw null; }
         public static Vector128<float> Ceiling(Vector128<float> value) { throw null; }
         public static Vector128<double> Ceiling(Vector128<double> value) { throw null; }
+        public static Vector128<double> CeilingScalar(Vector128<double> value) { throw null; }
+        public static Vector128<float> CeilingScalar(Vector128<float> value) { throw null; }
         public static Vector128<long> CompareEqual(Vector128<long> left, Vector128<long> right) { throw null; }
         public static Vector128<ulong> CompareEqual(Vector128<ulong> left, Vector128<ulong> right) { throw null; }
         public static Vector128<short> ConvertToVector128Int16(Vector128<sbyte> value) { throw null; }
@@ -1054,6 +1168,8 @@ public static class Sse41
         public static float ExtractSingle<T>(Vector128<T> value, byte index) where T : struct { throw null; }
         public static Vector128<float> Floor(Vector128<float> value) { throw null; }
         public static Vector128<double> Floor(Vector128<double> value) { throw null; }
+        public static Vector128<double> FloorScalar(Vector128<double> value) { throw null; }
+        public static Vector128<float> FloorScalar(Vector128<float> value) { throw null; }
         public static Vector128<T> InsertSByte<T>(Vector128<T> value, sbyte data, byte index) where T : struct { throw null; }
         public static Vector128<T> InsertByte<T>(Vector128<T> value, byte data, byte index) where T : struct { throw null; }
         public static Vector128<T> InsertInt32<T>(Vector128<T> value, int data, byte index) where T : struct { throw null; }
@@ -1074,10 +1190,20 @@ public static class Sse41
         public static Vector128<long> Multiply(Vector128<int> left, Vector128<int> right) { throw null; }
         public static Vector128<int> MultiplyLow(Vector128<int> left,  Vector128<int> right) { throw null; }
         public static Vector128<ushort> PackUnsignedSaturate(Vector128<int> left,  Vector128<int> right) { throw null; }
+        public static Vector128<double> RoundCurrentDirectionScalar(Vector128<double> value) { throw null; }
+        public static Vector128<float> RoundCurrentDirectionScalar(Vector128<float> value) { throw null; }
         public static Vector128<float> RoundToNearestInteger(Vector128<float> value) { throw null; }
+        public static Vector128<double> RoundToNearestIntegerScalar(Vector128<double> value) { throw null; }
+        public static Vector128<float> RoundToNearestIntegerScalar(Vector128<float> value) { throw null; }
         public static Vector128<float> RoundToNegativeInfinity(Vector128<float> value) { throw null; }
+        public static Vector128<double> RoundToNegativeInfinityScalar(Vector128<double> value) { throw null; }
+        public static Vector128<float> RoundToNegativeInfinityScalar(Vector128<float> value) { throw null; }
         public static Vector128<float> RoundToPositiveInfinity(Vector128<float> value) { throw null; }
+        public static Vector128<double> RoundToPositiveInfinityScalar(Vector128<double> value) { throw null; }
+        public static Vector128<float> RoundToPositiveInfinityScalar(Vector128<float> value) { throw null; }
         public static Vector128<float> RoundToZero(Vector128<float> value) { throw null; }
+        public static Vector128<double> RoundToZeroScalar(Vector128<double> value) { throw null; }
+        public static Vector128<float> RoundToZeroScalar(Vector128<float> value) { throw null; }
         public static Vector128<float> RoundCurrentDirection(Vector128<float> value) { throw null; }
         public static Vector128<double> RoundToNearestInteger(Vector128<double> value) { throw null; }
         public static Vector128<double> RoundToNegativeInfinity(Vector128<double> value) { throw null; }

From d104e6cececaa6163a42e076215caaffae865ccc Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Fri, 29 Dec 2017 10:02:11 -0800
Subject: [PATCH 2/2] Updating the System.Runtime.Intrinsics.X86 ref assembly
 to always use `throw null;`

---
 .../ref/System.Runtime.Intrinsics.X86.cs      | 568 +++++++++---------
 1 file changed, 284 insertions(+), 284 deletions(-)

diff --git a/src/System.Runtime.Intrinsics.X86/ref/System.Runtime.Intrinsics.X86.cs b/src/System.Runtime.Intrinsics.X86/ref/System.Runtime.Intrinsics.X86.cs
index fb2b303e2e91..c7cf7a939901 100644
--- a/src/System.Runtime.Intrinsics.X86/ref/System.Runtime.Intrinsics.X86.cs
+++ b/src/System.Runtime.Intrinsics.X86/ref/System.Runtime.Intrinsics.X86.cs
@@ -721,45 +721,45 @@ public static class Popcnt
     public static class Sse
     {
         public static bool IsSupported { get { return false; } }
-        public static Vector128<float> Add(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
+        public static Vector128<float> Add(Vector128<float> left,  Vector128<float> right) { throw null; }
         public static Vector128<float> AddScalar(Vector128<float> left, Vector128<float> right) { throw null; }
-        public static Vector128<float> And(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
-        public static Vector128<float> AndNot(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
-        public static Vector128<float> CompareEqual(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
+        public static Vector128<float> And(Vector128<float> left,  Vector128<float> right) { throw null; }
+        public static Vector128<float> AndNot(Vector128<float> left,  Vector128<float> right) { throw null; }
+        public static Vector128<float> CompareEqual(Vector128<float> left,  Vector128<float> right) { throw null; }
         public static bool CompareEqualOrderedScalar(Vector128<float> left, Vector128<float> right) { throw null; }
         public static Vector128<float> CompareEqualScalar(Vector128<float> left, Vector128<float> right) { throw null; }
         public static bool CompareEqualUnorderedScalar(Vector128<float> left, Vector128<float> right) { throw null; }
-        public static Vector128<float> CompareGreaterThan(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
+        public static Vector128<float> CompareGreaterThan(Vector128<float> left,  Vector128<float> right) { throw null; }
         public static bool CompareGreaterThanOrderedScalar(Vector128<float> left, Vector128<float> right) { throw null; }
         public static Vector128<float> CompareGreaterThanScalar(Vector128<float> left, Vector128<float> right) { throw null; }
         public static bool CompareGreaterThanUnorderedScalar(Vector128<float> left, Vector128<float> right) { throw null; }
-        public static Vector128<float> CompareGreaterThanOrEqual(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
+        public static Vector128<float> CompareGreaterThanOrEqual(Vector128<float> left,  Vector128<float> right) { throw null; }
         public static bool CompareGreaterThanOrEqualOrderedScalar(Vector128<float> left, Vector128<float> right) { throw null; }
         public static Vector128<float> CompareGreaterThanOrEqualScalar(Vector128<float> left, Vector128<float> right) { throw null; }
         public static bool CompareGreaterThanOrEqualUnorderedScalar(Vector128<float> left, Vector128<float> right) { throw null; }
-        public static Vector128<float> CompareLessThan(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
+        public static Vector128<float> CompareLessThan(Vector128<float> left,  Vector128<float> right) { throw null; }
         public static bool CompareLessThanOrderedScalar(Vector128<float> left, Vector128<float> right) { throw null; }
         public static Vector128<float> CompareLessThanScalar(Vector128<float> left, Vector128<float> right) { throw null; }
         public static bool CompareLessThanUnorderedScalar(Vector128<float> left, Vector128<float> right) { throw null; }
-        public static Vector128<float> CompareLessThanOrEqual(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
+        public static Vector128<float> CompareLessThanOrEqual(Vector128<float> left,  Vector128<float> right) { throw null; }
         public static bool CompareLessThanOrEqualOrderedScalar(Vector128<float> left, Vector128<float> right) { throw null; }
         public static Vector128<float> CompareLessThanOrEqualScalar(Vector128<float> left, Vector128<float> right) { throw null; }
         public static bool CompareLessThanOrEqualUnorderedScalar(Vector128<float> left, Vector128<float> right) { throw null; }
-        public static Vector128<float> CompareNotEqual(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
+        public static Vector128<float> CompareNotEqual(Vector128<float> left,  Vector128<float> right) { throw null; }
         public static bool CompareNotEqualOrderedScalar(Vector128<float> left, Vector128<float> right) { throw null; }
         public static Vector128<float> CompareNotEqualScalar(Vector128<float> left, Vector128<float> right) { throw null; }
         public static bool CompareNotEqualUnorderedScalar(Vector128<float> left, Vector128<float> right) { throw null; }
-        public static Vector128<float> CompareNotGreaterThan(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
+        public static Vector128<float> CompareNotGreaterThan(Vector128<float> left,  Vector128<float> right) { throw null; }
         public static Vector128<float> CompareNotGreaterThanScalar(Vector128<float> left, Vector128<float> right) { throw null; }
-        public static Vector128<float> CompareNotGreaterThanOrEqual(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
+        public static Vector128<float> CompareNotGreaterThanOrEqual(Vector128<float> left,  Vector128<float> right) { throw null; }
         public static Vector128<float> CompareNotGreaterThanOrEqualScalar(Vector128<float> left, Vector128<float> right) { throw null; }
-        public static Vector128<float> CompareNotLessThan(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
+        public static Vector128<float> CompareNotLessThan(Vector128<float> left,  Vector128<float> right) { throw null; }
         public static Vector128<float> CompareNotLessThanScalar(Vector128<float> left, Vector128<float> right) { throw null; }
-        public static Vector128<float> CompareNotLessThanOrEqual(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
+        public static Vector128<float> CompareNotLessThanOrEqual(Vector128<float> left,  Vector128<float> right) { throw null; }
         public static Vector128<float> CompareNotLessThanOrEqualScalar(Vector128<float> left, Vector128<float> right) { throw null; }
-        public static Vector128<float> CompareOrdered(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
+        public static Vector128<float> CompareOrdered(Vector128<float> left,  Vector128<float> right) { throw null; }
         public static Vector128<float> CompareOrderedScalar(Vector128<float> left, Vector128<float> right) { throw null; }
-        public static Vector128<float> CompareUnordered(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
+        public static Vector128<float> CompareUnordered(Vector128<float> left,  Vector128<float> right) { throw null; }
         public static Vector128<float> CompareUnorderedScalar(Vector128<float> left, Vector128<float> right) { throw null; }
         public static int ConvertToInt32(Vector128<float> value) { throw null; }
         public static int ConvertToInt32WithTruncation(Vector128<float> value) { throw null; }
@@ -768,127 +768,127 @@ public static class Sse
         public static float ConvertToSingle(Vector128<float> value) { throw null; }
         public static Vector128<float> ConvertToVector128SingleScalar(Vector128<float> upper, int value) { throw null; }
         public static Vector128<float> ConvertToVector128SingleScalar(Vector128<float> upper, long value) { throw null; }
-        public static Vector128<float> Divide(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
+        public static Vector128<float> Divide(Vector128<float> left,  Vector128<float> right) { throw null; }
         public static Vector128<float> DivideScalar(Vector128<float> left, Vector128<float> right) { throw null; }
-        public static unsafe Vector128<float> Load(float* address) { throw new NotImplementedException(); }
-        public static unsafe Vector128<float> LoadAligned(float* address) { throw new NotImplementedException(); }
+        public static unsafe Vector128<float> Load(float* address) { throw null; }
+        public static unsafe Vector128<float> LoadAligned(float* address) { throw null; }
         public static unsafe Vector128<float> LoadScalar(float* address) { throw null; }
-        public static Vector128<float> Max(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
+        public static Vector128<float> Max(Vector128<float> left,  Vector128<float> right) { throw null; }
         public static Vector128<float> MaxScalar(Vector128<float> left, Vector128<float> right) { throw null; }
-        public static Vector128<float> Min(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
+        public static Vector128<float> Min(Vector128<float> left,  Vector128<float> right) { throw null; }
         public static Vector128<float> MinScalar(Vector128<float> left, Vector128<float> right) { throw null; }
-        public static Vector128<float> MoveHighToLow(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
-        public static Vector128<float> MoveLowToHigh(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
+        public static Vector128<float> MoveHighToLow(Vector128<float> left,  Vector128<float> right) { throw null; }
+        public static Vector128<float> MoveLowToHigh(Vector128<float> left,  Vector128<float> right) { throw null; }
         public static Vector128<float> MoveScalar(Vector128<float> upper, Vector128<float> value) { throw null; }
-        public static Vector128<float> Multiply(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
+        public static Vector128<float> Multiply(Vector128<float> left,  Vector128<float> right) { throw null; }
         public static Vector128<float> MultiplyScalar(Vector128<float> left, Vector128<float> right) { throw null; }
-        public static Vector128<float> Or(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
-        public static Vector128<float> Reciprocal(Vector128<float> value) { throw new NotImplementedException(); }
+        public static Vector128<float> Or(Vector128<float> left,  Vector128<float> right) { throw null; }
+        public static Vector128<float> Reciprocal(Vector128<float> value) { throw null; }
         public static Vector128<float> ReciprocalScalar(Vector128<float> value) { throw null; }
-        public static Vector128<float> ReciprocalSqrt(Vector128<float> value) { throw new NotImplementedException(); }
+        public static Vector128<float> ReciprocalSqrt(Vector128<float> value) { throw null; }
         public static Vector128<float> ReciprocalSqrtScalar(Vector128<float> value) { throw null; }
-        public static Vector128<float> Set(float e3, float e2, float e1, float e0) { throw new NotImplementedException(); }
-        public static Vector128<float> Set1(float value) { throw new NotImplementedException(); }
+        public static Vector128<float> Set(float e3, float e2, float e1, float e0) { throw null; }
+        public static Vector128<float> Set1(float value) { throw null; }
         public static Vector128<float> SetScalar(float value) { throw null; }
-        public static Vector128<float> SetZero() { throw new NotImplementedException(); }
-        public static Vector128<U> StaticCast<T, U>(Vector128<T> value) where T : struct where U : struct { throw new NotImplementedException(); }
-        public static Vector128<float> Shuffle(Vector128<float> left, Vector128<float> right, byte control) { throw new NotImplementedException(); }
-        public static Vector128<float> Sqrt(Vector128<float> value) { throw new NotImplementedException(); }
+        public static Vector128<float> SetZero() { throw null; }
+        public static Vector128<U> StaticCast<T, U>(Vector128<T> value) where T : struct where U : struct { throw null; }
+        public static Vector128<float> Shuffle(Vector128<float> left, Vector128<float> right, byte control) { throw null; }
+        public static Vector128<float> Sqrt(Vector128<float> value) { throw null; }
         public static Vector128<float> SqrtScalar(Vector128<float> value) { throw null; }
-        public static unsafe void StoreAligned(float* address, Vector128<float> source) { throw new NotImplementedException(); }
-        public static unsafe void StoreAlignedNonTemporal(float* address, Vector128<float> source) { throw new NotImplementedException(); }
-        public static unsafe void Store(float* address, Vector128<float> source) { throw new NotImplementedException(); }
+        public static unsafe void StoreAligned(float* address, Vector128<float> source) { throw null; }
+        public static unsafe void StoreAlignedNonTemporal(float* address, Vector128<float> source) { throw null; }
+        public static unsafe void Store(float* address, Vector128<float> source) { throw null; }
         public static unsafe void StoreScalar(float* address, Vector128<float> source) { throw null; }
-        public static Vector128<float> Subtract(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
+        public static Vector128<float> Subtract(Vector128<float> left,  Vector128<float> right) { throw null; }
         public static Vector128<float> SubtractScalar(Vector128<float> left, Vector128<float> right) { throw null; }
-        public static Vector128<float> UnpackHigh(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
-        public static Vector128<float> UnpackLow(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
-        public static Vector128<float> Xor(Vector128<float> left,  Vector128<float> right) { throw new NotImplementedException(); }
+        public static Vector128<float> UnpackHigh(Vector128<float> left,  Vector128<float> right) { throw null; }
+        public static Vector128<float> UnpackLow(Vector128<float> left,  Vector128<float> right) { throw null; }
+        public static Vector128<float> Xor(Vector128<float> left,  Vector128<float> right) { throw null; }
     }
     public static class Sse2
     {
         public static bool IsSupported { get { return false; } }
-        public static Vector128<byte> Add(Vector128<byte> left,  Vector128<byte> right) { throw new NotImplementedException(); }
-        public static Vector128<sbyte> Add(Vector128<sbyte> left,  Vector128<sbyte> right) { throw new NotImplementedException(); }
-        public static Vector128<short> Add(Vector128<short> left,  Vector128<short> right) { throw new NotImplementedException(); }
-        public static Vector128<ushort> Add(Vector128<ushort> left,  Vector128<ushort> right) { throw new NotImplementedException(); }
-        public static Vector128<int> Add(Vector128<int> left,  Vector128<int> right) { throw new NotImplementedException(); }
-        public static Vector128<uint> Add(Vector128<uint> left,  Vector128<uint> right) { throw new NotImplementedException(); }
-        public static Vector128<long> Add(Vector128<long> left,  Vector128<long> right) { throw new NotImplementedException(); }
-        public static Vector128<ulong> Add(Vector128<ulong> left,  Vector128<ulong> right) { throw new NotImplementedException(); }
-        public static Vector128<double> Add(Vector128<double> left,  Vector128<double> right) { throw new NotImplementedException(); }
+        public static Vector128<byte> Add(Vector128<byte> left,  Vector128<byte> right) { throw null; }
+        public static Vector128<sbyte> Add(Vector128<sbyte> left,  Vector128<sbyte> right) { throw null; }
+        public static Vector128<short> Add(Vector128<short> left,  Vector128<short> right) { throw null; }
+        public static Vector128<ushort> Add(Vector128<ushort> left,  Vector128<ushort> right) { throw null; }
+        public static Vector128<int> Add(Vector128<int> left,  Vector128<int> right) { throw null; }
+        public static Vector128<uint> Add(Vector128<uint> left,  Vector128<uint> right) { throw null; }
+        public static Vector128<long> Add(Vector128<long> left,  Vector128<long> right) { throw null; }
+        public static Vector128<ulong> Add(Vector128<ulong> left,  Vector128<ulong> right) { throw null; }
+        public static Vector128<double> Add(Vector128<double> left,  Vector128<double> right) { throw null; }
         public static Vector128<double> AddScalar(Vector128<double> left, Vector128<double> right) { throw null; }
-        public static Vector128<sbyte> AddSaturate(Vector128<sbyte> left,  Vector128<sbyte> right) { throw new NotImplementedException(); }
-        public static Vector128<byte> AddSaturate(Vector128<byte> left,  Vector128<byte> right) { throw new NotImplementedException(); }
-        public static Vector128<short> AddSaturate(Vector128<short> left,  Vector128<short> right) { throw new NotImplementedException(); }
-        public static Vector128<ushort> AddSaturate(Vector128<ushort> left,  Vector128<ushort> right) { throw new NotImplementedException(); }
-        public static Vector128<byte> And(Vector128<byte> left,  Vector128<byte> right) { throw new NotImplementedException(); }
-        public static Vector128<sbyte> And(Vector128<sbyte> left,  Vector128<sbyte> right) { throw new NotImplementedException(); }
-        public static Vector128<short> And(Vector128<short> left,  Vector128<short> right) { throw new NotImplementedException(); }
-        public static Vector128<ushort> And(Vector128<ushort> left,  Vector128<ushort> right) { throw new NotImplementedException(); }
-        public static Vector128<int> And(Vector128<int> left,  Vector128<int> right) { throw new NotImplementedException(); }
-        public static Vector128<uint> And(Vector128<uint> left,  Vector128<uint> right) { throw new NotImplementedException(); }
-        public static Vector128<long> And(Vector128<long> left,  Vector128<long> right) { throw new NotImplementedException(); }
-        public static Vector128<ulong> And(Vector128<ulong> left,  Vector128<ulong> right) { throw new NotImplementedException(); }
-        public static Vector128<double> And(Vector128<double> left,  Vector128<double> right) { throw new NotImplementedException(); }
-        public static Vector128<byte> AndNot(Vector128<byte> left,  Vector128<byte> right) { throw new NotImplementedException(); }
-        public static Vector128<sbyte> AndNot(Vector128<sbyte> left,  Vector128<sbyte> right) { throw new NotImplementedException(); }
-        public static Vector128<short> AndNot(Vector128<short> left,  Vector128<short> right) { throw new NotImplementedException(); }
-        public static Vector128<ushort> AndNot(Vector128<ushort> left,  Vector128<ushort> right) { throw new NotImplementedException(); }
-        public static Vector128<int> AndNot(Vector128<int> left,  Vector128<int> right) { throw new NotImplementedException(); }
-        public static Vector128<uint> AndNot(Vector128<uint> left,  Vector128<uint> right) { throw new NotImplementedException(); }
-        public static Vector128<long> AndNot(Vector128<long> left,  Vector128<long> right) { throw new NotImplementedException(); }
-        public static Vector128<ulong> AndNot(Vector128<ulong> left,  Vector128<ulong> right) { throw new NotImplementedException(); }
-        public static Vector128<double> AndNot(Vector128<double> left,  Vector128<double> right) { throw new NotImplementedException(); }
-        public static Vector128<byte> Average(Vector128<byte> left,  Vector128<byte> right) { throw new NotImplementedException(); }
-        public static Vector128<ushort> Average(Vector128<ushort> left,  Vector128<ushort> right) { throw new NotImplementedException(); }
-        public static Vector128<sbyte> CompareEqual(Vector128<sbyte> left,  Vector128<sbyte> right) { throw new NotImplementedException(); }
-        public static Vector128<byte> CompareEqual(Vector128<byte> left,  Vector128<byte> right) { throw new NotImplementedException(); }
-        public static Vector128<short> CompareEqual(Vector128<short> left,  Vector128<short> right) { throw new NotImplementedException(); }
-        public static Vector128<ushort> CompareEqual(Vector128<ushort> left,  Vector128<ushort> right) { throw new NotImplementedException(); }
-        public static Vector128<int> CompareEqual(Vector128<int> left,  Vector128<int> right) { throw new NotImplementedException(); }
-        public static Vector128<uint> CompareEqual(Vector128<uint> left,  Vector128<uint> right) { throw new NotImplementedException(); }
-        public static Vector128<double> CompareEqual(Vector128<double> left,  Vector128<double> right) { throw new NotImplementedException(); }
+        public static Vector128<sbyte> AddSaturate(Vector128<sbyte> left,  Vector128<sbyte> right) { throw null; }
+        public static Vector128<byte> AddSaturate(Vector128<byte> left,  Vector128<byte> right) { throw null; }
+        public static Vector128<short> AddSaturate(Vector128<short> left,  Vector128<short> right) { throw null; }
+        public static Vector128<ushort> AddSaturate(Vector128<ushort> left,  Vector128<ushort> right) { throw null; }
+        public static Vector128<byte> And(Vector128<byte> left,  Vector128<byte> right) { throw null; }
+        public static Vector128<sbyte> And(Vector128<sbyte> left,  Vector128<sbyte> right) { throw null; }
+        public static Vector128<short> And(Vector128<short> left,  Vector128<short> right) { throw null; }
+        public static Vector128<ushort> And(Vector128<ushort> left,  Vector128<ushort> right) { throw null; }
+        public static Vector128<int> And(Vector128<int> left,  Vector128<int> right) { throw null; }
+        public static Vector128<uint> And(Vector128<uint> left,  Vector128<uint> right) { throw null; }
+        public static Vector128<long> And(Vector128<long> left,  Vector128<long> right) { throw null; }
+        public static Vector128<ulong> And(Vector128<ulong> left,  Vector128<ulong> right) { throw null; }
+        public static Vector128<double> And(Vector128<double> left,  Vector128<double> right) { throw null; }
+        public static Vector128<byte> AndNot(Vector128<byte> left,  Vector128<byte> right) { throw null; }
+        public static Vector128<sbyte> AndNot(Vector128<sbyte> left,  Vector128<sbyte> right) { throw null; }
+        public static Vector128<short> AndNot(Vector128<short> left,  Vector128<short> right) { throw null; }
+        public static Vector128<ushort> AndNot(Vector128<ushort> left,  Vector128<ushort> right) { throw null; }
+        public static Vector128<int> AndNot(Vector128<int> left,  Vector128<int> right) { throw null; }
+        public static Vector128<uint> AndNot(Vector128<uint> left,  Vector128<uint> right) { throw null; }
+        public static Vector128<long> AndNot(Vector128<long> left,  Vector128<long> right) { throw null; }
+        public static Vector128<ulong> AndNot(Vector128<ulong> left,  Vector128<ulong> right) { throw null; }
+        public static Vector128<double> AndNot(Vector128<double> left,  Vector128<double> right) { throw null; }
+        public static Vector128<byte> Average(Vector128<byte> left,  Vector128<byte> right) { throw null; }
+        public static Vector128<ushort> Average(Vector128<ushort> left,  Vector128<ushort> right) { throw null; }
+        public static Vector128<sbyte> CompareEqual(Vector128<sbyte> left,  Vector128<sbyte> right) { throw null; }
+        public static Vector128<byte> CompareEqual(Vector128<byte> left,  Vector128<byte> right) { throw null; }
+        public static Vector128<short> CompareEqual(Vector128<short> left,  Vector128<short> right) { throw null; }
+        public static Vector128<ushort> CompareEqual(Vector128<ushort> left,  Vector128<ushort> right) { throw null; }
+        public static Vector128<int> CompareEqual(Vector128<int> left,  Vector128<int> right) { throw null; }
+        public static Vector128<uint> CompareEqual(Vector128<uint> left,  Vector128<uint> right) { throw null; }
+        public static Vector128<double> CompareEqual(Vector128<double> left,  Vector128<double> right) { throw null; }
         public static bool CompareEqualOrderedScalar(Vector128<double> left, Vector128<double> right) { throw null; }
         public static Vector128<double> CompareEqualScalar(Vector128<double> left, Vector128<double> right) { throw null; }
         public static bool CompareEqualUnorderedScalar(Vector128<double> left, Vector128<double> right) { throw null; }
-        public static Vector128<sbyte> CompareGreaterThan(Vector128<sbyte> left,  Vector128<sbyte> right) { throw new NotImplementedException(); }
-        public static Vector128<short> CompareGreaterThan(Vector128<short> left,  Vector128<short> right) { throw new NotImplementedException(); }
-        public static Vector128<int> CompareGreaterThan(Vector128<int> left,  Vector128<int> right) { throw new NotImplementedException(); }
-        public static Vector128<double> CompareGreaterThan(Vector128<double> left,  Vector128<double> right) { throw new NotImplementedException(); }
+        public static Vector128<sbyte> CompareGreaterThan(Vector128<sbyte> left,  Vector128<sbyte> right) { throw null; }
+        public static Vector128<short> CompareGreaterThan(Vector128<short> left,  Vector128<short> right) { throw null; }
+        public static Vector128<int> CompareGreaterThan(Vector128<int> left,  Vector128<int> right) { throw null; }
+        public static Vector128<double> CompareGreaterThan(Vector128<double> left,  Vector128<double> right) { throw null; }
         public static bool CompareGreaterThanOrderedScalar(Vector128<double> left, Vector128<double> right) { throw null; }
         public static Vector128<double> CompareGreaterThanScalar(Vector128<double> left, Vector128<double> right) { throw null; }
         public static bool CompareGreaterThanUnorderedScalar(Vector128<double> left, Vector128<double> right) { throw null; }
-        public static Vector128<double> CompareGreaterThanOrEqual(Vector128<double> left,  Vector128<double> right) { throw new NotImplementedException(); }
+        public static Vector128<double> CompareGreaterThanOrEqual(Vector128<double> left,  Vector128<double> right) { throw null; }
         public static bool CompareGreaterThanOrEqualOrderedScalar(Vector128<double> left, Vector128<double> right) { throw null; }
         public static Vector128<double> CompareGreaterThanOrEqualScalar(Vector128<double> left, Vector128<double> right) { throw null; }
         public static bool CompareGreaterThanOrEqualUnorderedScalar(Vector128<double> left, Vector128<double> right) { throw null; }
-        public static Vector128<sbyte> CompareLessThan(Vector128<sbyte> left,  Vector128<sbyte> right) { throw new NotImplementedException(); }
-        public static Vector128<short> CompareLessThan(Vector128<short> left,  Vector128<short> right) { throw new NotImplementedException(); }
-        public static Vector128<int> CompareLessThan(Vector128<int> left,  Vector128<int> right) { throw new NotImplementedException(); }
-        public static Vector128<double> CompareLessThan(Vector128<double> left,  Vector128<double> right) { throw new NotImplementedException(); }
+        public static Vector128<sbyte> CompareLessThan(Vector128<sbyte> left,  Vector128<sbyte> right) { throw null; }
+        public static Vector128<short> CompareLessThan(Vector128<short> left,  Vector128<short> right) { throw null; }
+        public static Vector128<int> CompareLessThan(Vector128<int> left,  Vector128<int> right) { throw null; }
+        public static Vector128<double> CompareLessThan(Vector128<double> left,  Vector128<double> right) { throw null; }
         public static bool CompareLessThanOrderedScalar(Vector128<double> left, Vector128<double> right) { throw null; }
         public static Vector128<double> CompareLessThanScalar(Vector128<double> left, Vector128<double> right) { throw null; }
         public static bool CompareLessThanUnorderedScalar(Vector128<double> left, Vector128<double> right) { throw null; }
-        public static Vector128<double> CompareLessThanOrEqual(Vector128<double> left,  Vector128<double> right) { throw new NotImplementedException(); }
+        public static Vector128<double> CompareLessThanOrEqual(Vector128<double> left,  Vector128<double> right) { throw null; }
         public static bool CompareLessThanOrEqualOrderedScalar(Vector128<double> left, Vector128<double> right) { throw null; }
         public static Vector128<double> CompareLessThanOrEqualScalar(Vector128<double> left, Vector128<double> right) { throw null; }
         public static bool CompareLessThanOrEqualUnorderedScalar(Vector128<double> left, Vector128<double> right) { throw null; }
-        public static Vector128<double> CompareNotEqual(Vector128<double> left,  Vector128<double> right) { throw new NotImplementedException(); }
+        public static Vector128<double> CompareNotEqual(Vector128<double> left,  Vector128<double> right) { throw null; }
         public static bool CompareNotEqualOrderedScalar(Vector128<double> left, Vector128<double> right) { throw null; }
         public static Vector128<double> CompareNotEqualScalar(Vector128<double> left, Vector128<double> right) { throw null; }
         public static bool CompareNotEqualUnorderedScalar(Vector128<double> left, Vector128<double> right) { throw null; }
-        public static Vector128<double> CompareNotGreaterThan(Vector128<double> left,  Vector128<double> right) { throw new NotImplementedException(); }
+        public static Vector128<double> CompareNotGreaterThan(Vector128<double> left,  Vector128<double> right) { throw null; }
         public static Vector128<double> CompareNotGreaterThanScalar(Vector128<double> left, Vector128<double> right) { throw null; }
-        public static Vector128<double> CompareNotGreaterThanOrEqual(Vector128<double> left,  Vector128<double> right) { throw new NotImplementedException(); }
+        public static Vector128<double> CompareNotGreaterThanOrEqual(Vector128<double> left,  Vector128<double> right) { throw null; }
         public static Vector128<double> CompareNotGreaterThanOrEqualScalar(Vector128<double> left, Vector128<double> right) { throw null; }
-        public static Vector128<double> CompareNotLessThan(Vector128<double> left,  Vector128<double> right) { throw new NotImplementedException(); }
+        public static Vector128<double> CompareNotLessThan(Vector128<double> left,  Vector128<double> right) { throw null; }
         public static Vector128<double> CompareNotLessThanScalar(Vector128<double> left, Vector128<double> right) { throw null; }
-        public static Vector128<double> CompareNotLessThanOrEqual(Vector128<double> left,  Vector128<double> right) { throw new NotImplementedException(); }
+        public static Vector128<double> CompareNotLessThanOrEqual(Vector128<double> left,  Vector128<double> right) { throw null; }
         public static Vector128<double> CompareNotLessThanOrEqualScalar(Vector128<double> left, Vector128<double> right) { throw null; }
-        public static Vector128<double> CompareOrdered(Vector128<double> left,  Vector128<double> right) { throw new NotImplementedException(); }
+        public static Vector128<double> CompareOrdered(Vector128<double> left,  Vector128<double> right) { throw null; }
         public static Vector128<double> CompareOrderedScalar(Vector128<double> left, Vector128<double> right) { throw null; }
-        public static Vector128<double> CompareUnordered(Vector128<double> left,  Vector128<double> right) { throw new NotImplementedException(); }
+        public static Vector128<double> CompareUnordered(Vector128<double> left,  Vector128<double> right) { throw null; }
         public static Vector128<double> CompareUnorderedScalar(Vector128<double> left, Vector128<double> right) { throw null; }
         public static double ConvertToDouble(Vector128<double> value) { throw null; }
         public static int ConvertToInt32(Vector128<double> value) { throw null; }
@@ -902,209 +902,209 @@ public static class Sse2
         public static Vector128<double> ConvertToVector128DoubleScalar(Vector128<double> upper, int value) { throw null; }
         public static Vector128<double> ConvertToVector128DoubleScalar(Vector128<double> upper, long value) { throw null; }
         public static Vector128<double> ConvertToVector128DoubleScalar(Vector128<double> upper, Vector128<float> value) { throw null; }
-        public static Vector128<int> ConvertToVector128Int32(Vector128<float> value) { throw new NotImplementedException(); }
-        public static Vector128<int> ConvertToVector128Int32(Vector128<double> value) { throw new NotImplementedException(); }
+        public static Vector128<int> ConvertToVector128Int32(Vector128<float> value) { throw null; }
+        public static Vector128<int> ConvertToVector128Int32(Vector128<double> value) { throw null; }
         public static Vector128<int> ConvertToVector128Int32Scalar(int value) { throw null; }
         public static Vector128<long> ConvertToVector128Int64Scalar(long value) { throw null; }
-        public static Vector128<float> ConvertToVector128Single(Vector128<int> value) { throw new NotImplementedException(); }
-        public static Vector128<float> ConvertToVector128Single(Vector128<double> value) { throw new NotImplementedException(); }
+        public static Vector128<float> ConvertToVector128Single(Vector128<int> value) { throw null; }
+        public static Vector128<float> ConvertToVector128Single(Vector128<double> value) { throw null; }
         public static Vector128<float> ConvertToVector128SingleScalar(Vector128<float> upper, Vector128<double> value) { throw null; }
-        public static Vector128<double> ConvertToVector128Double(Vector128<int> value) { throw new NotImplementedException(); }
-        public static Vector128<double> ConvertToVector128Double(Vector128<float> value) { throw new NotImplementedException(); }
-        public static Vector128<int> ConvertToVector128Int32WithTruncation(Vector128<float> value) { throw new NotImplementedException(); }
-        public static Vector128<int> ConvertToVector128Int32WithTruncation(Vector128<double> value) { throw new NotImplementedException(); }
+        public static Vector128<double> ConvertToVector128Double(Vector128<int> value) { throw null; }
+        public static Vector128<double> ConvertToVector128Double(Vector128<float> value) { throw null; }
+        public static Vector128<int> ConvertToVector128Int32WithTruncation(Vector128<float> value) { throw null; }
+        public static Vector128<int> ConvertToVector128Int32WithTruncation(Vector128<double> value) { throw null; }
         public static Vector128<uint> ConvertToVector128UInt32Scalar(uint value) { throw null; }
         public static Vector128<ulong> ConvertToVector128UInt64Scalar(ulong value) { throw null; }
-        public static Vector128<double> Divide(Vector128<double> left,  Vector128<double> right) { throw new NotImplementedException(); }
+        public static Vector128<double> Divide(Vector128<double> left,  Vector128<double> right) { throw null; }
         public static Vector128<double> DivideScalar(Vector128<double> left, Vector128<double> right) { throw null; }
-        public static short ExtractInt16<T>(Vector128<T> value,  byte index) where T : struct { throw new NotImplementedException(); }
-        public static ushort ExtractUInt16<T>(Vector128<T> value,  byte index) where T : struct { throw new NotImplementedException(); }
-        public static Vector128<T> InsertInt16<T>(Vector128<T> value,  short data, byte index) where T : struct { throw new NotImplementedException(); }
-        public static Vector128<T> InsertUInt16<T>(Vector128<T> value,  ushort data, byte index) where T : struct { throw new NotImplementedException(); }
-        public static unsafe Vector128<sbyte> Load(sbyte* address) { throw new NotImplementedException(); }
-        public static unsafe Vector128<byte> Load(byte* address) { throw new NotImplementedException(); }
-        public static unsafe Vector128<short> Load(short* address) { throw new NotImplementedException(); }
-        public static unsafe Vector128<ushort> Load(ushort* address) { throw new NotImplementedException(); }
-        public static unsafe Vector128<int> Load(int* address) { throw new NotImplementedException(); }
-        public static unsafe Vector128<uint> Load(uint* address) { throw new NotImplementedException(); }
-        public static unsafe Vector128<long> Load(long* address) { throw new NotImplementedException(); }
-        public static unsafe Vector128<ulong> Load(ulong* address) { throw new NotImplementedException(); }
-        public static unsafe Vector128<double> Load(double* address) { throw new NotImplementedException(); }
-        public static unsafe Vector128<sbyte> LoadAligned(sbyte* address) { throw new NotImplementedException(); }
-        public static unsafe Vector128<byte> LoadAligned(byte* address) { throw new NotImplementedException(); }
-        public static unsafe Vector128<short> LoadAligned(short* address) { throw new NotImplementedException(); }
-        public static unsafe Vector128<ushort> LoadAligned(ushort* address) { throw new NotImplementedException(); }
-        public static unsafe Vector128<int> LoadAligned(int* address) { throw new NotImplementedException(); }
-        public static unsafe Vector128<uint> LoadAligned(uint* address) { throw new NotImplementedException(); }
-        public static unsafe Vector128<long> LoadAligned(long* address) { throw new NotImplementedException(); }
-        public static unsafe Vector128<ulong> LoadAligned(ulong* address) { throw new NotImplementedException(); }
-        public static unsafe Vector128<double> LoadAligned(double* address) { throw new NotImplementedException(); }
+        public static short ExtractInt16<T>(Vector128<T> value,  byte index) where T : struct { throw null; }
+        public static ushort ExtractUInt16<T>(Vector128<T> value,  byte index) where T : struct { throw null; }
+        public static Vector128<T> InsertInt16<T>(Vector128<T> value,  short data, byte index) where T : struct { throw null; }
+        public static Vector128<T> InsertUInt16<T>(Vector128<T> value,  ushort data, byte index) where T : struct { throw null; }
+        public static unsafe Vector128<sbyte> Load(sbyte* address) { throw null; }
+        public static unsafe Vector128<byte> Load(byte* address) { throw null; }
+        public static unsafe Vector128<short> Load(short* address) { throw null; }
+        public static unsafe Vector128<ushort> Load(ushort* address) { throw null; }
+        public static unsafe Vector128<int> Load(int* address) { throw null; }
+        public static unsafe Vector128<uint> Load(uint* address) { throw null; }
+        public static unsafe Vector128<long> Load(long* address) { throw null; }
+        public static unsafe Vector128<ulong> Load(ulong* address) { throw null; }
+        public static unsafe Vector128<double> Load(double* address) { throw null; }
+        public static unsafe Vector128<sbyte> LoadAligned(sbyte* address) { throw null; }
+        public static unsafe Vector128<byte> LoadAligned(byte* address) { throw null; }
+        public static unsafe Vector128<short> LoadAligned(short* address) { throw null; }
+        public static unsafe Vector128<ushort> LoadAligned(ushort* address) { throw null; }
+        public static unsafe Vector128<int> LoadAligned(int* address) { throw null; }
+        public static unsafe Vector128<uint> LoadAligned(uint* address) { throw null; }
+        public static unsafe Vector128<long> LoadAligned(long* address) { throw null; }
+        public static unsafe Vector128<ulong> LoadAligned(ulong* address) { throw null; }
+        public static unsafe Vector128<double> LoadAligned(double* address) { throw null; }
         public static unsafe Vector128<double> LoadScalar(double* address) { throw null; }
-        public static unsafe void MaskMove(Vector128<sbyte> source,  Vector128<sbyte> mask, sbyte* address) { throw new NotImplementedException(); }
-        public static unsafe void MaskMove(Vector128<byte> source,  Vector128<byte> mask, byte* address) { throw new NotImplementedException(); }
-        public static Vector128<byte> Max(Vector128<byte> left,  Vector128<byte> right) { throw new NotImplementedException(); }
-        public static Vector128<short> Max(Vector128<short> left,  Vector128<short> right) { throw new NotImplementedException(); }
-        public static Vector128<double> Max(Vector128<double> left,  Vector128<double> right) { throw new NotImplementedException(); }
+        public static unsafe void MaskMove(Vector128<sbyte> source,  Vector128<sbyte> mask, sbyte* address) { throw null; }
+        public static unsafe void MaskMove(Vector128<byte> source,  Vector128<byte> mask, byte* address) { throw null; }
+        public static Vector128<byte> Max(Vector128<byte> left,  Vector128<byte> right) { throw null; }
+        public static Vector128<short> Max(Vector128<short> left,  Vector128<short> right) { throw null; }
+        public static Vector128<double> Max(Vector128<double> left,  Vector128<double> right) { throw null; }
         public static Vector128<double> MaxScalar(Vector128<double> left, Vector128<double> right) { throw null; }
-        public static Vector128<byte> Min(Vector128<byte> left,  Vector128<byte> right) { throw new NotImplementedException(); }
-        public static Vector128<short> Min(Vector128<short> left,  Vector128<short> right) { throw new NotImplementedException(); }
-        public static Vector128<double> Min(Vector128<double> left,  Vector128<double> right) { throw new NotImplementedException(); }
+        public static Vector128<byte> Min(Vector128<byte> left,  Vector128<byte> right) { throw null; }
+        public static Vector128<short> Min(Vector128<short> left,  Vector128<short> right) { throw null; }
+        public static Vector128<double> Min(Vector128<double> left,  Vector128<double> right) { throw null; }
         public static Vector128<double> MinScalar(Vector128<double> left, Vector128<double> right) { throw null; }
-        public static int MoveMask(Vector128<sbyte> value) { throw new NotImplementedException(); }
-        public static int MoveMask(Vector128<double> value) { throw new NotImplementedException(); }
+        public static int MoveMask(Vector128<sbyte> value) { throw null; }
+        public static int MoveMask(Vector128<double> value) { throw null; }
         public static Vector128<double> MoveScalar(Vector128<double> upper, Vector128<double> value) { throw null; }
-        public static Vector128<ulong> Multiply(Vector128<uint> left,  Vector128<uint> right) { throw new NotImplementedException(); }
-        public static Vector128<double> Multiply(Vector128<double> left,  Vector128<double> right) { throw new NotImplementedException(); }
+        public static Vector128<ulong> Multiply(Vector128<uint> left,  Vector128<uint> right) { throw null; }
+        public static Vector128<double> Multiply(Vector128<double> left,  Vector128<double> right) { throw null; }
         public static Vector128<double> MultiplyScalar(Vector128<double> left, Vector128<double> right) { throw null; }
-        public static Vector128<short> MultiplyHigh(Vector128<short> left,  Vector128<short> right) { throw new NotImplementedException(); }
-        public static Vector128<ushort> MultiplyHigh(Vector128<ushort> left,  Vector128<ushort> right) { throw new NotImplementedException(); }
-        public static Vector128<int> MultiplyHorizontalAdd(Vector128<short> left,  Vector128<short> right) { throw new NotImplementedException(); }
-        public static Vector128<short> MultiplyLow(Vector128<short> left,  Vector128<short> right) { throw new NotImplementedException(); }
-        public static Vector128<byte> Or(Vector128<byte> left,  Vector128<byte> right) { throw new NotImplementedException(); }
-        public static Vector128<sbyte> Or(Vector128<sbyte> left,  Vector128<sbyte> right) { throw new NotImplementedException(); }
-        public static Vector128<short> Or(Vector128<short> left,  Vector128<short> right) { throw new NotImplementedException(); }
-        public static Vector128<ushort> Or(Vector128<ushort> left,  Vector128<ushort> right) { throw new NotImplementedException(); }
-        public static Vector128<int> Or(Vector128<int> left,  Vector128<int> right) { throw new NotImplementedException(); }
-        public static Vector128<uint> Or(Vector128<uint> left,  Vector128<uint> right) { throw new NotImplementedException(); }
-        public static Vector128<long> Or(Vector128<long> left,  Vector128<long> right) { throw new NotImplementedException(); }
-        public static Vector128<ulong> Or(Vector128<ulong> left,  Vector128<ulong> right) { throw new NotImplementedException(); }
-        public static Vector128<double> Or(Vector128<double> left,  Vector128<double> right) { throw new NotImplementedException(); }
-        public static Vector128<sbyte> PackSignedSaturate(Vector128<short> left,  Vector128<short> right) { throw new NotImplementedException(); }
-        public static Vector128<short> PackSignedSaturate(Vector128<int> left,  Vector128<int> right) { throw new NotImplementedException(); }
-        public static Vector128<byte> PackUnsignedSaturate(Vector128<short> left,  Vector128<short> right) { throw new NotImplementedException(); }
-        public static Vector128<sbyte> Set(sbyte e15, sbyte e14, sbyte e13, sbyte e12, sbyte e11, sbyte e10, sbyte e9, sbyte e8, sbyte e7, sbyte e6, sbyte e5, sbyte e4, sbyte e3, sbyte e2, sbyte e1, sbyte e0) { throw new NotImplementedException(); }
-        public static Vector128<byte> Set(byte e15, byte e14, byte e13, byte e12, byte e11, byte e10, byte e9, byte e8, byte e7, byte e6, byte e5, byte e4, byte e3, byte e2, byte e1, byte e0) { throw new NotImplementedException(); }
-        public static Vector128<short> Set(short e7, short e6, short e5, short e4, short e3, short e2, short e1, short e0) { throw new NotImplementedException(); }
-        public static Vector128<ushort> Set(ushort e7, ushort e6, ushort e5, ushort e4, ushort e3, ushort e2, ushort e1, ushort e0) { throw new NotImplementedException(); }
-        public static Vector128<int> Set(int e3, int e2, int e1, int e0) { throw new NotImplementedException(); }
-        public static Vector128<uint> Set(uint e3, uint e2, uint e1, uint e0) { throw new NotImplementedException(); }
-        public static Vector128<long> Set(long e1, long e0) { throw new NotImplementedException(); }
-        public static Vector128<ulong> Set(ulong e1, ulong e0) { throw new NotImplementedException(); }
-        public static Vector128<double> Set(double e1, double e0) { throw new NotImplementedException(); }
-        public static Vector128<byte> Set1(byte value) { throw new NotImplementedException(); }
-        public static Vector128<sbyte> Set1(sbyte value) { throw new NotImplementedException(); }
-        public static Vector128<short> Set1(short value) { throw new NotImplementedException(); }
-        public static Vector128<ushort> Set1(ushort value) { throw new NotImplementedException(); }
-        public static Vector128<int> Set1(int value) { throw new NotImplementedException(); }
-        public static Vector128<uint> Set1(uint value) { throw new NotImplementedException(); }
-        public static Vector128<long> Set1(long value) { throw new NotImplementedException(); }
-        public static Vector128<ulong> Set1(ulong value) { throw new NotImplementedException(); }
-        public static Vector128<double> Set1(double value) { throw new NotImplementedException(); }
+        public static Vector128<short> MultiplyHigh(Vector128<short> left,  Vector128<short> right) { throw null; }
+        public static Vector128<ushort> MultiplyHigh(Vector128<ushort> left,  Vector128<ushort> right) { throw null; }
+        public static Vector128<int> MultiplyHorizontalAdd(Vector128<short> left,  Vector128<short> right) { throw null; }
+        public static Vector128<short> MultiplyLow(Vector128<short> left,  Vector128<short> right) { throw null; }
+        public static Vector128<byte> Or(Vector128<byte> left,  Vector128<byte> right) { throw null; }
+        public static Vector128<sbyte> Or(Vector128<sbyte> left,  Vector128<sbyte> right) { throw null; }
+        public static Vector128<short> Or(Vector128<short> left,  Vector128<short> right) { throw null; }
+        public static Vector128<ushort> Or(Vector128<ushort> left,  Vector128<ushort> right) { throw null; }
+        public static Vector128<int> Or(Vector128<int> left,  Vector128<int> right) { throw null; }
+        public static Vector128<uint> Or(Vector128<uint> left,  Vector128<uint> right) { throw null; }
+        public static Vector128<long> Or(Vector128<long> left,  Vector128<long> right) { throw null; }
+        public static Vector128<ulong> Or(Vector128<ulong> left,  Vector128<ulong> right) { throw null; }
+        public static Vector128<double> Or(Vector128<double> left,  Vector128<double> right) { throw null; }
+        public static Vector128<sbyte> PackSignedSaturate(Vector128<short> left,  Vector128<short> right) { throw null; }
+        public static Vector128<short> PackSignedSaturate(Vector128<int> left,  Vector128<int> right) { throw null; }
+        public static Vector128<byte> PackUnsignedSaturate(Vector128<short> left,  Vector128<short> right) { throw null; }
+        public static Vector128<sbyte> Set(sbyte e15, sbyte e14, sbyte e13, sbyte e12, sbyte e11, sbyte e10, sbyte e9, sbyte e8, sbyte e7, sbyte e6, sbyte e5, sbyte e4, sbyte e3, sbyte e2, sbyte e1, sbyte e0) { throw null; }
+        public static Vector128<byte> Set(byte e15, byte e14, byte e13, byte e12, byte e11, byte e10, byte e9, byte e8, byte e7, byte e6, byte e5, byte e4, byte e3, byte e2, byte e1, byte e0) { throw null; }
+        public static Vector128<short> Set(short e7, short e6, short e5, short e4, short e3, short e2, short e1, short e0) { throw null; }
+        public static Vector128<ushort> Set(ushort e7, ushort e6, ushort e5, ushort e4, ushort e3, ushort e2, ushort e1, ushort e0) { throw null; }
+        public static Vector128<int> Set(int e3, int e2, int e1, int e0) { throw null; }
+        public static Vector128<uint> Set(uint e3, uint e2, uint e1, uint e0) { throw null; }
+        public static Vector128<long> Set(long e1, long e0) { throw null; }
+        public static Vector128<ulong> Set(ulong e1, ulong e0) { throw null; }
+        public static Vector128<double> Set(double e1, double e0) { throw null; }
+        public static Vector128<byte> Set1(byte value) { throw null; }
+        public static Vector128<sbyte> Set1(sbyte value) { throw null; }
+        public static Vector128<short> Set1(short value) { throw null; }
+        public static Vector128<ushort> Set1(ushort value) { throw null; }
+        public static Vector128<int> Set1(int value) { throw null; }
+        public static Vector128<uint> Set1(uint value) { throw null; }
+        public static Vector128<long> Set1(long value) { throw null; }
+        public static Vector128<ulong> Set1(ulong value) { throw null; }
+        public static Vector128<double> Set1(double value) { throw null; }
         public static Vector128<double> SetScalar(double value) { throw null; }
-        public static Vector128<T> SetZero<T>() where T : struct { throw new NotImplementedException(); }
-        public static Vector128<long> SumAbsoluteDifferences(Vector128<byte> left,  Vector128<byte> right) { throw new NotImplementedException(); }
-        public static Vector128<int> Shuffle(Vector128<int> value, byte control) { throw new NotImplementedException(); }
-        public static Vector128<uint> Shuffle(Vector128<uint> value,  byte control) { throw new NotImplementedException(); }
-        public static Vector128<double> Shuffle(Vector128<double> left, Vector128<double> right, byte control) { throw new NotImplementedException(); }
-        public static Vector128<short> ShuffleHigh(Vector128<short> value, byte control) { throw new NotImplementedException(); }
-        public static Vector128<ushort> ShuffleHigh(Vector128<ushort> value, byte control) { throw new NotImplementedException(); }
-        public static Vector128<short> ShuffleLow(Vector128<short> value, byte control) { throw new NotImplementedException(); }
-        public static Vector128<ushort> ShuffleLow(Vector128<ushort> value, byte control) { throw new NotImplementedException(); }
-        public static Vector128<short> ShiftLeftLogical(Vector128<short> value, byte count) { throw new NotImplementedException(); }
-        public static Vector128<ushort> ShiftLeftLogical(Vector128<ushort> value, byte count) { throw new NotImplementedException(); }
-        public static Vector128<int> ShiftLeftLogical(Vector128<int> value, byte count) { throw new NotImplementedException(); }
-        public static Vector128<uint> ShiftLeftLogical(Vector128<uint> value, byte count) { throw new NotImplementedException(); }
-        public static Vector128<long> ShiftLeftLogical(Vector128<long> value, byte count) { throw new NotImplementedException(); }
-        public static Vector128<ulong> ShiftLeftLogical(Vector128<ulong> value, byte count) { throw new NotImplementedException(); }
-        public static Vector128<sbyte> ShiftLeftLogical128BitLane(Vector128<sbyte> value, byte numBytes) { throw new NotImplementedException(); }
-        public static Vector128<byte> ShiftLeftLogical128BitLane(Vector128<byte> value, byte numBytes) { throw new NotImplementedException(); }
-        public static Vector128<short> ShiftLeftLogical128BitLane(Vector128<short> value, byte numBytes) { throw new NotImplementedException(); }
-        public static Vector128<ushort> ShiftLeftLogical128BitLane(Vector128<ushort> value, byte numBytes) { throw new NotImplementedException(); }
-        public static Vector128<int> ShiftLeftLogical128BitLane(Vector128<int> value, byte numBytes) { throw new NotImplementedException(); }
-        public static Vector128<uint> ShiftLeftLogical128BitLane(Vector128<uint> value, byte numBytes) { throw new NotImplementedException(); }
-        public static Vector128<long> ShiftLeftLogical128BitLane(Vector128<long> value, byte numBytes) { throw new NotImplementedException(); }
-        public static Vector128<ulong> ShiftLeftLogical128BitLane(Vector128<ulong> value, byte numBytes) { throw new NotImplementedException(); }
-        public static Vector128<short> ShiftRightArithmetic(Vector128<short> value, byte count) { throw new NotImplementedException(); }
-        public static Vector128<int> ShiftRightArithmetic(Vector128<int> value, byte count) { throw new NotImplementedException(); }
-        public static Vector128<short> ShiftRightLogical(Vector128<short> value, byte count) { throw new NotImplementedException(); }
-        public static Vector128<ushort> ShiftRightLogical(Vector128<ushort> value, byte count) { throw new NotImplementedException(); }
-        public static Vector128<int> ShiftRightLogical(Vector128<int> value, byte count) { throw new NotImplementedException(); }
-        public static Vector128<uint> ShiftRightLogical(Vector128<uint> value, byte count) { throw new NotImplementedException(); }
-        public static Vector128<long> ShiftRightLogical(Vector128<long> value, byte count) { throw new NotImplementedException(); }
-        public static Vector128<ulong> ShiftRightLogical(Vector128<ulong> value, byte count) { throw new NotImplementedException(); }
-        public static Vector128<sbyte> ShiftRightLogical128BitLane(Vector128<sbyte> value, byte numBytes) { throw new NotImplementedException(); }
-        public static Vector128<byte> ShiftRightLogical128BitLane(Vector128<byte> value, byte numBytes) { throw new NotImplementedException(); }
-        public static Vector128<short> ShiftRightLogical128BitLane(Vector128<short> value, byte numBytes) { throw new NotImplementedException(); }
-        public static Vector128<ushort> ShiftRightLogical128BitLane(Vector128<ushort> value, byte numBytes) { throw new NotImplementedException(); }
-        public static Vector128<int> ShiftRightLogical128BitLane(Vector128<int> value, byte numBytes) { throw new NotImplementedException(); }
-        public static Vector128<uint> ShiftRightLogical128BitLane(Vector128<uint> value, byte numBytes) { throw new NotImplementedException(); }
-        public static Vector128<long> ShiftRightLogical128BitLane(Vector128<long> value, byte numBytes) { throw new NotImplementedException(); }
-        public static Vector128<ulong> ShiftRightLogical128BitLane(Vector128<ulong> value, byte numBytes) { throw new NotImplementedException(); }
-        public static Vector128<double> Sqrt(Vector128<double> value) { throw new NotImplementedException(); }
+        public static Vector128<T> SetZero<T>() where T : struct { throw null; }
+        public static Vector128<long> SumAbsoluteDifferences(Vector128<byte> left,  Vector128<byte> right) { throw null; }
+        public static Vector128<int> Shuffle(Vector128<int> value, byte control) { throw null; }
+        public static Vector128<uint> Shuffle(Vector128<uint> value,  byte control) { throw null; }
+        public static Vector128<double> Shuffle(Vector128<double> left, Vector128<double> right, byte control) { throw null; }
+        public static Vector128<short> ShuffleHigh(Vector128<short> value, byte control) { throw null; }
+        public static Vector128<ushort> ShuffleHigh(Vector128<ushort> value, byte control) { throw null; }
+        public static Vector128<short> ShuffleLow(Vector128<short> value, byte control) { throw null; }
+        public static Vector128<ushort> ShuffleLow(Vector128<ushort> value, byte control) { throw null; }
+        public static Vector128<short> ShiftLeftLogical(Vector128<short> value, byte count) { throw null; }
+        public static Vector128<ushort> ShiftLeftLogical(Vector128<ushort> value, byte count) { throw null; }
+        public static Vector128<int> ShiftLeftLogical(Vector128<int> value, byte count) { throw null; }
+        public static Vector128<uint> ShiftLeftLogical(Vector128<uint> value, byte count) { throw null; }
+        public static Vector128<long> ShiftLeftLogical(Vector128<long> value, byte count) { throw null; }
+        public static Vector128<ulong> ShiftLeftLogical(Vector128<ulong> value, byte count) { throw null; }
+        public static Vector128<sbyte> ShiftLeftLogical128BitLane(Vector128<sbyte> value, byte numBytes) { throw null; }
+        public static Vector128<byte> ShiftLeftLogical128BitLane(Vector128<byte> value, byte numBytes) { throw null; }
+        public static Vector128<short> ShiftLeftLogical128BitLane(Vector128<short> value, byte numBytes) { throw null; }
+        public static Vector128<ushort> ShiftLeftLogical128BitLane(Vector128<ushort> value, byte numBytes) { throw null; }
+        public static Vector128<int> ShiftLeftLogical128BitLane(Vector128<int> value, byte numBytes) { throw null; }
+        public static Vector128<uint> ShiftLeftLogical128BitLane(Vector128<uint> value, byte numBytes) { throw null; }
+        public static Vector128<long> ShiftLeftLogical128BitLane(Vector128<long> value, byte numBytes) { throw null; }
+        public static Vector128<ulong> ShiftLeftLogical128BitLane(Vector128<ulong> value, byte numBytes) { throw null; }
+        public static Vector128<short> ShiftRightArithmetic(Vector128<short> value, byte count) { throw null; }
+        public static Vector128<int> ShiftRightArithmetic(Vector128<int> value, byte count) { throw null; }
+        public static Vector128<short> ShiftRightLogical(Vector128<short> value, byte count) { throw null; }
+        public static Vector128<ushort> ShiftRightLogical(Vector128<ushort> value, byte count) { throw null; }
+        public static Vector128<int> ShiftRightLogical(Vector128<int> value, byte count) { throw null; }
+        public static Vector128<uint> ShiftRightLogical(Vector128<uint> value, byte count) { throw null; }
+        public static Vector128<long> ShiftRightLogical(Vector128<long> value, byte count) { throw null; }
+        public static Vector128<ulong> ShiftRightLogical(Vector128<ulong> value, byte count) { throw null; }
+        public static Vector128<sbyte> ShiftRightLogical128BitLane(Vector128<sbyte> value, byte numBytes) { throw null; }
+        public static Vector128<byte> ShiftRightLogical128BitLane(Vector128<byte> value, byte numBytes) { throw null; }
+        public static Vector128<short> ShiftRightLogical128BitLane(Vector128<short> value, byte numBytes) { throw null; }
+        public static Vector128<ushort> ShiftRightLogical128BitLane(Vector128<ushort> value, byte numBytes) { throw null; }
+        public static Vector128<int> ShiftRightLogical128BitLane(Vector128<int> value, byte numBytes) { throw null; }
+        public static Vector128<uint> ShiftRightLogical128BitLane(Vector128<uint> value, byte numBytes) { throw null; }
+        public static Vector128<long> ShiftRightLogical128BitLane(Vector128<long> value, byte numBytes) { throw null; }
+        public static Vector128<ulong> ShiftRightLogical128BitLane(Vector128<ulong> value, byte numBytes) { throw null; }
+        public static Vector128<double> Sqrt(Vector128<double> value) { throw null; }
         public static Vector128<double> SqrtScalar(Vector128<double> value) { throw null; }
-        public static unsafe void StoreAligned(sbyte* address, Vector128<sbyte> source) { throw new NotImplementedException(); }
-        public static unsafe void StoreAligned(byte* address, Vector128<byte> source) { throw new NotImplementedException(); }
-        public static unsafe void StoreAligned(short* address, Vector128<short> source) { throw new NotImplementedException(); }
-        public static unsafe void StoreAligned(ushort* address, Vector128<ushort> source) { throw new NotImplementedException(); }
-        public static unsafe void StoreAligned(int* address, Vector128<int> source) { throw new NotImplementedException(); }
-        public static unsafe void StoreAligned(uint* address, Vector128<uint> source) { throw new NotImplementedException(); }
-        public static unsafe void StoreAligned(long* address, Vector128<long> source) { throw new NotImplementedException(); }
-        public static unsafe void StoreAligned(ulong* address, Vector128<ulong> source) { throw new NotImplementedException(); }
-        public static unsafe void StoreAligned(double* address, Vector128<double> source) { throw new NotImplementedException(); }
-        public static unsafe void StoreAlignedNonTemporal(sbyte* address, Vector128<sbyte> source) { throw new NotImplementedException(); }
-        public static unsafe void StoreAlignedNonTemporal(byte* address, Vector128<byte> source) { throw new NotImplementedException(); }
-        public static unsafe void StoreAlignedNonTemporal(short* address, Vector128<short> source) { throw new NotImplementedException(); }
-        public static unsafe void StoreAlignedNonTemporal(ushort* address, Vector128<ushort> source) { throw new NotImplementedException(); }
-        public static unsafe void StoreAlignedNonTemporal(int* address, Vector128<int> source) { throw new NotImplementedException(); }
-        public static unsafe void StoreAlignedNonTemporal(uint* address, Vector128<uint> source) { throw new NotImplementedException(); }
-        public static unsafe void StoreAlignedNonTemporal(long* address, Vector128<long> source) { throw new NotImplementedException(); }
-        public static unsafe void StoreAlignedNonTemporal(ulong* address, Vector128<ulong> source) { throw new NotImplementedException(); }
-        public static unsafe void StoreAlignedNonTemporal(double* address, Vector128<double> source) { throw new NotImplementedException(); }
+        public static unsafe void StoreAligned(sbyte* address, Vector128<sbyte> source) { throw null; }
+        public static unsafe void StoreAligned(byte* address, Vector128<byte> source) { throw null; }
+        public static unsafe void StoreAligned(short* address, Vector128<short> source) { throw null; }
+        public static unsafe void StoreAligned(ushort* address, Vector128<ushort> source) { throw null; }
+        public static unsafe void StoreAligned(int* address, Vector128<int> source) { throw null; }
+        public static unsafe void StoreAligned(uint* address, Vector128<uint> source) { throw null; }
+        public static unsafe void StoreAligned(long* address, Vector128<long> source) { throw null; }
+        public static unsafe void StoreAligned(ulong* address, Vector128<ulong> source) { throw null; }
+        public static unsafe void StoreAligned(double* address, Vector128<double> source) { throw null; }
+        public static unsafe void StoreAlignedNonTemporal(sbyte* address, Vector128<sbyte> source) { throw null; }
+        public static unsafe void StoreAlignedNonTemporal(byte* address, Vector128<byte> source) { throw null; }
+        public static unsafe void StoreAlignedNonTemporal(short* address, Vector128<short> source) { throw null; }
+        public static unsafe void StoreAlignedNonTemporal(ushort* address, Vector128<ushort> source) { throw null; }
+        public static unsafe void StoreAlignedNonTemporal(int* address, Vector128<int> source) { throw null; }
+        public static unsafe void StoreAlignedNonTemporal(uint* address, Vector128<uint> source) { throw null; }
+        public static unsafe void StoreAlignedNonTemporal(long* address, Vector128<long> source) { throw null; }
+        public static unsafe void StoreAlignedNonTemporal(ulong* address, Vector128<ulong> source) { throw null; }
+        public static unsafe void StoreAlignedNonTemporal(double* address, Vector128<double> source) { throw null; }
         public static unsafe void StoreScalar(double* address, Vector128<double> source) { throw null; }
-        public static unsafe void Store(sbyte* address, Vector128<sbyte> source) { throw new NotImplementedException(); }
-        public static unsafe void Store(byte* address, Vector128<byte> source) { throw new NotImplementedException(); }
-        public static unsafe void Store(short* address, Vector128<short> source) { throw new NotImplementedException(); }
-        public static unsafe void Store(ushort* address, Vector128<ushort> source) { throw new NotImplementedException(); }
-        public static unsafe void Store(int* address, Vector128<int> source) { throw new NotImplementedException(); }
-        public static unsafe void Store(uint* address, Vector128<uint> source) { throw new NotImplementedException(); }
-        public static unsafe void Store(long* address, Vector128<long> source) { throw new NotImplementedException(); }
-        public static unsafe void Store(ulong* address, Vector128<ulong> source) { throw new NotImplementedException(); }
-        public static unsafe void Store(double* address, Vector128<double> source) { throw new NotImplementedException(); }
-        public static unsafe void StoreHigh(double* address, Vector128<double> source) { throw new NotImplementedException(); }
-        public static unsafe void StoreLow(long* address, Vector128<long> source) { throw new NotImplementedException(); }
-        public static unsafe void StoreLow(ulong* address, Vector128<ulong> source) { throw new NotImplementedException(); }
-        public static unsafe void StoreLow(double* address, Vector128<double> source) { throw new NotImplementedException(); }
-        public static Vector128<byte> Subtract(Vector128<byte> left,  Vector128<byte> right) { throw new NotImplementedException(); }
-        public static Vector128<sbyte> Subtract(Vector128<sbyte> left,  Vector128<sbyte> right) { throw new NotImplementedException(); }
-        public static Vector128<short> Subtract(Vector128<short> left,  Vector128<short> right) { throw new NotImplementedException(); }
-        public static Vector128<ushort> Subtract(Vector128<ushort> left,  Vector128<ushort> right) { throw new NotImplementedException(); }
-        public static Vector128<int> Subtract(Vector128<int> left,  Vector128<int> right) { throw new NotImplementedException(); }
-        public static Vector128<uint> Subtract(Vector128<uint> left,  Vector128<uint> right) { throw new NotImplementedException(); }
-        public static Vector128<long> Subtract(Vector128<long> left,  Vector128<long> right) { throw new NotImplementedException(); }
-        public static Vector128<ulong> Subtract(Vector128<ulong> left,  Vector128<ulong> right) { throw new NotImplementedException(); }
-        public static Vector128<double> Subtract(Vector128<double> left,  Vector128<double> right) { throw new NotImplementedException(); }
-        public static Vector128<sbyte> SubtractSaturate(Vector128<sbyte> left,  Vector128<sbyte> right) { throw new NotImplementedException(); }
-        public static Vector128<short> SubtractSaturate(Vector128<short> left,  Vector128<short> right) { throw new NotImplementedException(); }
-        public static Vector128<byte> SubtractSaturate(Vector128<byte> left,  Vector128<byte> right) { throw new NotImplementedException(); }
-        public static Vector128<ushort> SubtractSaturate(Vector128<ushort> left,  Vector128<ushort> right) { throw new NotImplementedException(); }
+        public static unsafe void Store(sbyte* address, Vector128<sbyte> source) { throw null; }
+        public static unsafe void Store(byte* address, Vector128<byte> source) { throw null; }
+        public static unsafe void Store(short* address, Vector128<short> source) { throw null; }
+        public static unsafe void Store(ushort* address, Vector128<ushort> source) { throw null; }
+        public static unsafe void Store(int* address, Vector128<int> source) { throw null; }
+        public static unsafe void Store(uint* address, Vector128<uint> source) { throw null; }
+        public static unsafe void Store(long* address, Vector128<long> source) { throw null; }
+        public static unsafe void Store(ulong* address, Vector128<ulong> source) { throw null; }
+        public static unsafe void Store(double* address, Vector128<double> source) { throw null; }
+        public static unsafe void StoreHigh(double* address, Vector128<double> source) { throw null; }
+        public static unsafe void StoreLow(long* address, Vector128<long> source) { throw null; }
+        public static unsafe void StoreLow(ulong* address, Vector128<ulong> source) { throw null; }
+        public static unsafe void StoreLow(double* address, Vector128<double> source) { throw null; }
+        public static Vector128<byte> Subtract(Vector128<byte> left,  Vector128<byte> right) { throw null; }
+        public static Vector128<sbyte> Subtract(Vector128<sbyte> left,  Vector128<sbyte> right) { throw null; }
+        public static Vector128<short> Subtract(Vector128<short> left,  Vector128<short> right) { throw null; }
+        public static Vector128<ushort> Subtract(Vector128<ushort> left,  Vector128<ushort> right) { throw null; }
+        public static Vector128<int> Subtract(Vector128<int> left,  Vector128<int> right) { throw null; }
+        public static Vector128<uint> Subtract(Vector128<uint> left,  Vector128<uint> right) { throw null; }
+        public static Vector128<long> Subtract(Vector128<long> left,  Vector128<long> right) { throw null; }
+        public static Vector128<ulong> Subtract(Vector128<ulong> left,  Vector128<ulong> right) { throw null; }
+        public static Vector128<double> Subtract(Vector128<double> left,  Vector128<double> right) { throw null; }
+        public static Vector128<sbyte> SubtractSaturate(Vector128<sbyte> left,  Vector128<sbyte> right) { throw null; }
+        public static Vector128<short> SubtractSaturate(Vector128<short> left,  Vector128<short> right) { throw null; }
+        public static Vector128<byte> SubtractSaturate(Vector128<byte> left,  Vector128<byte> right) { throw null; }
+        public static Vector128<ushort> SubtractSaturate(Vector128<ushort> left,  Vector128<ushort> right) { throw null; }
         public static Vector128<double> SubtractScalar(Vector128<double> left, Vector128<double> right) { throw null; }
-        public static Vector128<byte> UnpackHigh(Vector128<byte> left,  Vector128<byte> right) { throw new NotImplementedException(); }
-        public static Vector128<sbyte> UnpackHigh(Vector128<sbyte> left,  Vector128<sbyte> right) { throw new NotImplementedException(); }
-        public static Vector128<short> UnpackHigh(Vector128<short> left,  Vector128<short> right) { throw new NotImplementedException(); }
-        public static Vector128<ushort> UnpackHigh(Vector128<ushort> left,  Vector128<ushort> right) { throw new NotImplementedException(); }
-        public static Vector128<int> UnpackHigh(Vector128<int> left,  Vector128<int> right) { throw new NotImplementedException(); }
-        public static Vector128<uint> UnpackHigh(Vector128<uint> left,  Vector128<uint> right) { throw new NotImplementedException(); }
-        public static Vector128<long> UnpackHigh(Vector128<long> left,  Vector128<long> right) { throw new NotImplementedException(); }
-        public static Vector128<ulong> UnpackHigh(Vector128<ulong> left,  Vector128<ulong> right) { throw new NotImplementedException(); }
-        public static Vector128<double> UnpackHigh(Vector128<double> left,  Vector128<double> right) { throw new NotImplementedException(); }
-        public static Vector128<byte> UnpackLow(Vector128<byte> left,  Vector128<byte> right) { throw new NotImplementedException(); }
-        public static Vector128<sbyte> UnpackLow(Vector128<sbyte> left,  Vector128<sbyte> right) { throw new NotImplementedException(); }
-        public static Vector128<short> UnpackLow(Vector128<short> left,  Vector128<short> right) { throw new NotImplementedException(); }
-        public static Vector128<ushort> UnpackLow(Vector128<ushort> left,  Vector128<ushort> right) { throw new NotImplementedException(); }
-        public static Vector128<int> UnpackLow(Vector128<int> left,  Vector128<int> right) { throw new NotImplementedException(); }
-        public static Vector128<uint> UnpackLow(Vector128<uint> left,  Vector128<uint> right) { throw new NotImplementedException(); }
-        public static Vector128<long> UnpackLow(Vector128<long> left,  Vector128<long> right) { throw new NotImplementedException(); }
-        public static Vector128<ulong> UnpackLow(Vector128<ulong> left,  Vector128<ulong> right) { throw new NotImplementedException(); }
-        public static Vector128<double> UnpackLow(Vector128<double> left,  Vector128<double> right) { throw new NotImplementedException(); }
-        public static Vector128<byte> Xor(Vector128<byte> left,  Vector128<byte> right) { throw new NotImplementedException(); }
-        public static Vector128<sbyte> Xor(Vector128<sbyte> left,  Vector128<sbyte> right) { throw new NotImplementedException(); }
-        public static Vector128<short> Xor(Vector128<short> left,  Vector128<short> right) { throw new NotImplementedException(); }
-        public static Vector128<ushort> Xor(Vector128<ushort> left,  Vector128<ushort> right) { throw new NotImplementedException(); }
-        public static Vector128<int> Xor(Vector128<int> left,  Vector128<int> right) { throw new NotImplementedException(); }
-        public static Vector128<uint> Xor(Vector128<uint> left,  Vector128<uint> right) { throw new NotImplementedException(); }
-        public static Vector128<long> Xor(Vector128<long> left,  Vector128<long> right) { throw new NotImplementedException(); }
-        public static Vector128<ulong> Xor(Vector128<ulong> left,  Vector128<ulong> right) { throw new NotImplementedException(); }
-        public static Vector128<double> Xor(Vector128<double> left,  Vector128<double> right) { throw new NotImplementedException(); }
+        public static Vector128<byte> UnpackHigh(Vector128<byte> left,  Vector128<byte> right) { throw null; }
+        public static Vector128<sbyte> UnpackHigh(Vector128<sbyte> left,  Vector128<sbyte> right) { throw null; }
+        public static Vector128<short> UnpackHigh(Vector128<short> left,  Vector128<short> right) { throw null; }
+        public static Vector128<ushort> UnpackHigh(Vector128<ushort> left,  Vector128<ushort> right) { throw null; }
+        public static Vector128<int> UnpackHigh(Vector128<int> left,  Vector128<int> right) { throw null; }
+        public static Vector128<uint> UnpackHigh(Vector128<uint> left,  Vector128<uint> right) { throw null; }
+        public static Vector128<long> UnpackHigh(Vector128<long> left,  Vector128<long> right) { throw null; }
+        public static Vector128<ulong> UnpackHigh(Vector128<ulong> left,  Vector128<ulong> right) { throw null; }
+        public static Vector128<double> UnpackHigh(Vector128<double> left,  Vector128<double> right) { throw null; }
+        public static Vector128<byte> UnpackLow(Vector128<byte> left,  Vector128<byte> right) { throw null; }
+        public static Vector128<sbyte> UnpackLow(Vector128<sbyte> left,  Vector128<sbyte> right) { throw null; }
+        public static Vector128<short> UnpackLow(Vector128<short> left,  Vector128<short> right) { throw null; }
+        public static Vector128<ushort> UnpackLow(Vector128<ushort> left,  Vector128<ushort> right) { throw null; }
+        public static Vector128<int> UnpackLow(Vector128<int> left,  Vector128<int> right) { throw null; }
+        public static Vector128<uint> UnpackLow(Vector128<uint> left,  Vector128<uint> right) { throw null; }
+        public static Vector128<long> UnpackLow(Vector128<long> left,  Vector128<long> right) { throw null; }
+        public static Vector128<ulong> UnpackLow(Vector128<ulong> left,  Vector128<ulong> right) { throw null; }
+        public static Vector128<double> UnpackLow(Vector128<double> left,  Vector128<double> right) { throw null; }
+        public static Vector128<byte> Xor(Vector128<byte> left,  Vector128<byte> right) { throw null; }
+        public static Vector128<sbyte> Xor(Vector128<sbyte> left,  Vector128<sbyte> right) { throw null; }
+        public static Vector128<short> Xor(Vector128<short> left,  Vector128<short> right) { throw null; }
+        public static Vector128<ushort> Xor(Vector128<ushort> left,  Vector128<ushort> right) { throw null; }
+        public static Vector128<int> Xor(Vector128<int> left,  Vector128<int> right) { throw null; }
+        public static Vector128<uint> Xor(Vector128<uint> left,  Vector128<uint> right) { throw null; }
+        public static Vector128<long> Xor(Vector128<long> left,  Vector128<long> right) { throw null; }
+        public static Vector128<ulong> Xor(Vector128<ulong> left,  Vector128<ulong> right) { throw null; }
+        public static Vector128<double> Xor(Vector128<double> left,  Vector128<double> right) { throw null; }
     }
     public static class Sse3
     {