diff --git a/release-notes/3.0/preview/api-diff/preview1/3.0-preview1.md b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1.md
new file mode 100644
index 00000000..63e7f43d
--- /dev/null
+++ b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1.md
@@ -0,0 +1,45 @@
+# API Difference netcoreapp2.2 vs netcoreapp3.0-preview1
+
+API listing follows standard diff formatting. Lines preceded by a '+' are
+additions and a '-' indicates removal.
+
+* [System](3.0-preview1_System.md)
+* [System.Buffers](3.0-preview1_System.Buffers.md)
+* [System.Collections.Generic](3.0-preview1_System.Collections.Generic.md)
+* [System.Collections.Immutable](3.0-preview1_System.Collections.Immutable.md)
+* [System.ComponentModel](3.0-preview1_System.ComponentModel.md)
+* [System.Diagnostics](3.0-preview1_System.Diagnostics.md)
+* [System.Globalization](3.0-preview1_System.Globalization.md)
+* [System.IO](3.0-preview1_System.IO.md)
+* [System.IO.Compression](3.0-preview1_System.IO.Compression.md)
+* [System.IO.IsolatedStorage](3.0-preview1_System.IO.IsolatedStorage.md)
+* [System.IO.Pipes](3.0-preview1_System.IO.Pipes.md)
+* [System.Linq](3.0-preview1_System.Linq.md)
+* [System.Net](3.0-preview1_System.Net.md)
+* [System.Net.Http](3.0-preview1_System.Net.Http.md)
+* [System.Net.Security](3.0-preview1_System.Net.Security.md)
+* [System.Net.Sockets](3.0-preview1_System.Net.Sockets.md)
+* [System.Net.WebSockets](3.0-preview1_System.Net.WebSockets.md)
+* [System.Numerics](3.0-preview1_System.Numerics.md)
+* [System.Reflection](3.0-preview1_System.Reflection.md)
+* [System.Reflection.Emit](3.0-preview1_System.Reflection.Emit.md)
+* [System.Runtime](3.0-preview1_System.Runtime.md)
+* [System.Runtime.CompilerServices](3.0-preview1_System.Runtime.CompilerServices.md)
+* [System.Runtime.InteropServices](3.0-preview1_System.Runtime.InteropServices.md)
+* [System.Runtime.Intrinsics](3.0-preview1_System.Runtime.Intrinsics.md)
+* [System.Runtime.Intrinsics.Arm.Arm64](3.0-preview1_System.Runtime.Intrinsics.Arm.Arm64.md)
+* [System.Runtime.Intrinsics.X86](3.0-preview1_System.Runtime.Intrinsics.X86.md)
+* [System.Runtime.Loader](3.0-preview1_System.Runtime.Loader.md)
+* [System.Runtime.Remoting](3.0-preview1_System.Runtime.Remoting.md)
+* [System.Runtime.Serialization](3.0-preview1_System.Runtime.Serialization.md)
+* [System.Security.Authentication](3.0-preview1_System.Security.Authentication.md)
+* [System.Security.Cryptography](3.0-preview1_System.Security.Cryptography.md)
+* [System.Text](3.0-preview1_System.Text.md)
+* [System.Text.Json](3.0-preview1_System.Text.Json.md)
+* [System.Text.RegularExpressions](3.0-preview1_System.Text.RegularExpressions.md)
+* [System.Threading](3.0-preview1_System.Threading.md)
+* [System.Threading.Tasks](3.0-preview1_System.Threading.Tasks.md)
+* [System.Threading.Tasks.Sources](3.0-preview1_System.Threading.Tasks.Sources.md)
+* [System.Windows.Markup](3.0-preview1_System.Windows.Markup.md)
+* [System.Xml](3.0-preview1_System.Xml.md)
+
diff --git a/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Buffers.md b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Buffers.md
new file mode 100644
index 00000000..dae2e0ad
--- /dev/null
+++ b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Buffers.md
@@ -0,0 +1,48 @@
+# System.Buffers
+
+``` diff
+ namespace System.Buffers {
++    public ref struct SequenceReader<T> where T : struct, IEquatable<T> {
++        public SequenceReader(ReadOnlySequence<T> sequence);
++        public long Consumed { get; }
++        public ReadOnlySpan<T> CurrentSpan { get; }
++        public int CurrentSpanIndex { get; }
++        public bool End { get; }
++        public long Length { get; }
++        public SequencePosition Position { get; }
++        public long Remaining { get; }
++        public ReadOnlySequence<T> Sequence { get; }
++        public ReadOnlySpan<T> UnreadSpan { get; }
++        public void Advance(long count);
++        public long AdvancePast(T value);
++        public long AdvancePastAny(ReadOnlySpan<T> values);
++        public long AdvancePastAny(T value0, T value1);
++        public long AdvancePastAny(T value0, T value1, T value2);
++        public long AdvancePastAny(T value0, T value1, T value2, T value3);
++        public bool IsNext(ReadOnlySpan<T> next, bool advancePast = false);
++        public bool IsNext(T next, bool advancePast = false);
++        public void Rewind(long count);
++        public bool TryAdvanceTo(T delimiter, bool advancePastDelimiter = true);
++        public bool TryAdvanceToAny(ReadOnlySpan<T> delimiters, bool advancePastDelimiter = true);
++        public bool TryCopyTo(Span<T> destination);
++        public bool TryPeek(out T value);
++        public bool TryRead(out T value);
++        public bool TryReadTo(out ReadOnlySequence<T> sequence, ReadOnlySpan<T> delimiter, bool advancePastDelimiter = true);
++        public bool TryReadTo(out ReadOnlySequence<T> sequence, T delimiter, bool advancePastDelimiter = true);
++        public bool TryReadTo(out ReadOnlySequence<T> sequence, T delimiter, T delimiterEscape, bool advancePastDelimiter = true);
++        public bool TryReadTo(out ReadOnlySpan<T> span, T delimiter, bool advancePastDelimiter = true);
++        public bool TryReadTo(out ReadOnlySpan<T> span, T delimiter, T delimiterEscape, bool advancePastDelimiter = true);
++        public bool TryReadToAny(out ReadOnlySequence<T> sequence, ReadOnlySpan<T> delimiters, bool advancePastDelimiter = true);
++        public bool TryReadToAny(out ReadOnlySpan<T> span, ReadOnlySpan<T> delimiters, bool advancePastDelimiter = true);
++    }
++    public static class SequenceReaderExtensions {
++        public static bool TryReadBigEndian(this ref SequenceReader<byte> reader, out short value);
++        public static bool TryReadBigEndian(this ref SequenceReader<byte> reader, out int value);
++        public static bool TryReadBigEndian(this ref SequenceReader<byte> reader, out long value);
++        public static bool TryReadLittleEndian(this ref SequenceReader<byte> reader, out short value);
++        public static bool TryReadLittleEndian(this ref SequenceReader<byte> reader, out int value);
++        public static bool TryReadLittleEndian(this ref SequenceReader<byte> reader, out long value);
++    }
+ }
+```
+
diff --git a/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Collections.Generic.md b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Collections.Generic.md
new file mode 100644
index 00000000..61888017
--- /dev/null
+++ b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Collections.Generic.md
@@ -0,0 +1,14 @@
+# System.Collections.Generic
+
+``` diff
+ namespace System.Collections.Generic {
++    public interface IAsyncEnumerable<out T> {
++        IAsyncEnumerator<T> GetAsyncEnumerator();
++    }
++    public interface IAsyncEnumerator<out T> : IAsyncDisposable {
++        T Current { get; }
++        ValueTask<bool> MoveNextAsync();
++    }
+ }
+```
+
diff --git a/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Collections.Immutable.md b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Collections.Immutable.md
new file mode 100644
index 00000000..bc63323d
--- /dev/null
+++ b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Collections.Immutable.md
@@ -0,0 +1,25 @@
+# System.Collections.Immutable
+
+``` diff
+ namespace System.Collections.Immutable {
+     public static class ImmutableArray {
++        public static ImmutableArray<TSource> ToImmutableArray<TSource>(this ImmutableArray<TSource>.Builder builder);
+     }
+     public static class ImmutableDictionary {
++        public static ImmutableDictionary<TKey, TValue> ToImmutableDictionary<TKey, TValue>(this ImmutableDictionary<TKey, TValue>.Builder builder);
+     }
+     public static class ImmutableHashSet {
++        public static ImmutableHashSet<TSource> ToImmutableHashSet<TSource>(this ImmutableHashSet<TSource>.Builder builder);
+     }
+     public static class ImmutableList {
++        public static ImmutableList<TSource> ToImmutableList<TSource>(this ImmutableList<TSource>.Builder builder);
+     }
+     public static class ImmutableSortedDictionary {
++        public static ImmutableSortedDictionary<TKey, TValue> ToImmutableSortedDictionary<TKey, TValue>(this ImmutableSortedDictionary<TKey, TValue>.Builder source);
+     }
+     public static class ImmutableSortedSet {
++        public static ImmutableSortedSet<TSource> ToImmutableSortedSet<TSource>(this ImmutableSortedSet<TSource>.Builder builder);
+     }
+ }
+```
+
diff --git a/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.ComponentModel.md b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.ComponentModel.md
new file mode 100644
index 00000000..be061b5e
--- /dev/null
+++ b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.ComponentModel.md
@@ -0,0 +1,21 @@
+# System.ComponentModel
+
+``` diff
+ namespace System.ComponentModel {
+     public class BackgroundWorker : Component {
++        protected override void Dispose(bool disposing);
+     }
++    public class VersionConverter : TypeConverter {
++        public VersionConverter();
++        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType);
++        public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType);
++        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value);
++        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType);
++        public override bool IsValid(ITypeDescriptorContext context, object value);
++    }
+     public class Win32Exception : ExternalException, ISerializable {
++        public override string ToString();
+     }
+ }
+```
+
diff --git a/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Diagnostics.md b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Diagnostics.md
new file mode 100644
index 00000000..2af5bf31
--- /dev/null
+++ b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Diagnostics.md
@@ -0,0 +1,36 @@
+# System.Diagnostics
+
+``` diff
+ namespace System.Diagnostics {
+     public class Activity {
+-        public static Activity Current { get; private set; }
++        public static Activity Current { get; set; }
+     }
++    public class ConsoleTraceListener : TextWriterTraceListener {
++        public ConsoleTraceListener();
++        public ConsoleTraceListener(bool useErrorStream);
++        public override void Close();
++    }
+     public class DiagnosticListener : DiagnosticSource, IDisposable, IObservable<KeyValuePair<string, object>> {
++        public override string ToString();
+     }
++    public class XmlWriterTraceListener : TextWriterTraceListener {
++        public XmlWriterTraceListener(Stream stream);
++        public XmlWriterTraceListener(Stream stream, string name);
++        public XmlWriterTraceListener(TextWriter writer);
++        public XmlWriterTraceListener(TextWriter writer, string name);
++        public XmlWriterTraceListener(string filename);
++        public XmlWriterTraceListener(string filename, string name);
++        public override void Close();
++        public override void Fail(string message, string detailMessage);
++        public override void TraceData(TraceEventCache eventCache, string source, TraceEventType eventType, int id, object data);
++        public override void TraceData(TraceEventCache eventCache, string source, TraceEventType eventType, int id, params object[] data);
++        public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id, string message);
++        public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id, string format, params object[] args);
++        public override void TraceTransfer(TraceEventCache eventCache, string source, int id, string message, Guid relatedActivityId);
++        public override void Write(string message);
++        public override void WriteLine(string message);
++    }
+ }
+```
+
diff --git a/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Globalization.md b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Globalization.md
new file mode 100644
index 00000000..95a5e875
--- /dev/null
+++ b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Globalization.md
@@ -0,0 +1,18 @@
+# System.Globalization
+
+``` diff
+ namespace System.Globalization {
+     public class CompareInfo : IDeserializationCallback {
++        public int GetHashCode(ReadOnlySpan<char> source, CompareOptions options);
+     }
++    public static class ISOWeek {
++        public static int GetWeekOfYear(DateTime date);
++        public static int GetWeeksInYear(int year);
++        public static int GetYear(DateTime date);
++        public static DateTime GetYearEnd(int year);
++        public static DateTime GetYearStart(int year);
++        public static DateTime ToDateTime(int year, int week, DayOfWeek dayOfWeek);
++    }
+ }
+```
+
diff --git a/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.IO.Compression.md b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.IO.Compression.md
new file mode 100644
index 00000000..c792ddbd
--- /dev/null
+++ b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.IO.Compression.md
@@ -0,0 +1,37 @@
+# System.IO.Compression
+
+``` diff
+ namespace System.IO.Compression {
+     public sealed class BrotliStream : Stream {
++        public override ValueTask DisposeAsync();
++        public override Task FlushAsync(CancellationToken cancellationToken);
++        public override int Read(Span<byte> buffer);
++        public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
++        public override void Write(ReadOnlySpan<byte> buffer);
++        public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
+     }
+     public class DeflateStream : Stream {
++        public override void CopyTo(Stream destination, int bufferSize);
++        public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken);
++        public override ValueTask DisposeAsync();
++        public override Task FlushAsync(CancellationToken cancellationToken);
++        public override int Read(Span<byte> buffer);
++        public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
++        public override int ReadByte();
++        public override void Write(ReadOnlySpan<byte> buffer);
++        public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
+     }
+     public class GZipStream : Stream {
++        public override void CopyTo(Stream destination, int bufferSize);
++        public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken);
++        public override ValueTask DisposeAsync();
++        public override Task FlushAsync(CancellationToken cancellationToken);
++        public override int Read(Span<byte> buffer);
++        public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
++        public override int ReadByte();
++        public override void Write(ReadOnlySpan<byte> buffer);
++        public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
+     }
+ }
+```
+
diff --git a/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.IO.IsolatedStorage.md b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.IO.IsolatedStorage.md
new file mode 100644
index 00000000..433e2fb5
--- /dev/null
+++ b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.IO.IsolatedStorage.md
@@ -0,0 +1,17 @@
+# System.IO.IsolatedStorage
+
+``` diff
+ namespace System.IO.IsolatedStorage {
+     public class IsolatedStorageFileStream : FileStream {
++        public override ValueTask DisposeAsync();
++        public override Task FlushAsync(CancellationToken cancellationToken);
++        public override int Read(Span<byte> buffer);
++        public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken);
++        public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
++        public override void Write(ReadOnlySpan<byte> buffer);
++        public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken);
++        public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
+     }
+ }
+```
+
diff --git a/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.IO.Pipes.md b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.IO.Pipes.md
new file mode 100644
index 00000000..b2f1a7ba
--- /dev/null
+++ b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.IO.Pipes.md
@@ -0,0 +1,13 @@
+# System.IO.Pipes
+
+``` diff
+ namespace System.IO.Pipes {
+     public abstract class PipeStream : Stream {
++        public override int Read(Span<byte> buffer);
++        public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
++        public override void Write(ReadOnlySpan<byte> buffer);
++        public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
+     }
+ }
+```
+
diff --git a/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.IO.md b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.IO.md
new file mode 100644
index 00000000..4a1d8cf6
--- /dev/null
+++ b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.IO.md
@@ -0,0 +1,53 @@
+# System.IO
+
+``` diff
+ namespace System.IO {
+     public class BinaryWriter : IDisposable {
++        public virtual ValueTask DisposeAsync();
+     }
+     public sealed class BufferedStream : Stream {
++        public override ValueTask DisposeAsync();
+     }
+     public static class File {
++        public static void Move(string sourceFileName, string destFileName, bool overwrite);
+     }
+     public sealed class FileInfo : FileSystemInfo {
++        public void MoveTo(string destFileName, bool overwrite);
+     }
+     public class FileStream : Stream {
++        public override ValueTask DisposeAsync();
++        public override int Read(Span<byte> buffer);
++        public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
++        public override void Write(ReadOnlySpan<byte> buffer);
++        public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
+     }
+     public abstract class FileSystemInfo : MarshalByRefObject, ISerializable {
++        public override string ToString();
+     }
+     public class FileSystemWatcher : Component, ISupportInitialize {
++        public Collection<string> Filters { get; }
+     }
+     public static class Path {
++        public static string Join(string path1, string path2);
++        public static string Join(string path1, string path2, string path3);
+     }
+     public abstract class Stream : MarshalByRefObject, IDisposable {
++        public virtual ValueTask DisposeAsync();
+     }
+     public class StreamWriter : TextWriter {
++        public override ValueTask DisposeAsync();
+     }
+     public abstract class TextWriter : MarshalByRefObject, IDisposable {
++        public virtual ValueTask DisposeAsync();
++        public virtual void Write(StringBuilder value);
++        public virtual Task WriteAsync(StringBuilder value, CancellationToken cancellationToken = default(CancellationToken));
++        public virtual void WriteLine(StringBuilder value);
++        public virtual Task WriteLineAsync(StringBuilder value, CancellationToken cancellationToken = default(CancellationToken));
+     }
+     public class UnmanagedMemoryStream : Stream {
++        public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
++        public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
+     }
+ }
+```
+
diff --git a/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Linq.md b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Linq.md
new file mode 100644
index 00000000..d83e68df
--- /dev/null
+++ b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Linq.md
@@ -0,0 +1,13 @@
+# System.Linq
+
+``` diff
+ namespace System.Linq {
+     public static class Enumerable {
++        public static IEnumerable<ValueTuple<TFirst, TSecond>> Zip<TFirst, TSecond>(this IEnumerable<TFirst> first, IEnumerable<TSecond> second);
+     }
+     public static class Queryable {
++        public static IQueryable<ValueTuple<TFirst, TSecond>> Zip<TFirst, TSecond>(this IQueryable<TFirst> source1, IEnumerable<TSecond> source2);
+     }
+ }
+```
+
diff --git a/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Net.Http.md b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Net.Http.md
new file mode 100644
index 00000000..e989fd2f
--- /dev/null
+++ b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Net.Http.md
@@ -0,0 +1,13 @@
+# System.Net.Http
+
+``` diff
+ namespace System.Net.Http {
+     public class MultipartContent : HttpContent, IEnumerable, IEnumerable<HttpContent> {
++        protected override Task<Stream> CreateContentReadStreamAsync();
+     }
+     public sealed class ReadOnlyMemoryContent : HttpContent {
++        protected override Task<Stream> CreateContentReadStreamAsync();
+     }
+ }
+```
+
diff --git a/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Net.Security.md b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Net.Security.md
new file mode 100644
index 00000000..01f64788
--- /dev/null
+++ b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Net.Security.md
@@ -0,0 +1,21 @@
+# System.Net.Security
+
+``` diff
+ namespace System.Net.Security {
+     public abstract class AuthenticatedStream : Stream {
++        public override ValueTask DisposeAsync();
+     }
+     public class NegotiateStream : AuthenticatedStream {
++        public override ValueTask DisposeAsync();
+     }
+     public class SslStream : AuthenticatedStream {
++        public override ValueTask DisposeAsync();
++        public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken);
++        public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
++        public override int ReadByte();
++        public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken);
++        public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
+     }
+ }
+```
+
diff --git a/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Net.Sockets.md b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Net.Sockets.md
new file mode 100644
index 00000000..3d76f0fd
--- /dev/null
+++ b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Net.Sockets.md
@@ -0,0 +1,27 @@
+# System.Net.Sockets
+
+``` diff
+ namespace System.Net.Sockets {
+     public class NetworkStream : Stream {
++        public override int Read(Span<byte> buffer);
++        public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
++        public override int ReadByte();
++        public override void Write(ReadOnlySpan<byte> buffer);
++        public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
++        public override void WriteByte(byte value);
+     }
++    public sealed class SafeSocketHandle : SafeHandleMinusOneIsInvalid {
++        public SafeSocketHandle(IntPtr preexistingHandle, bool ownsHandle);
++        protected override bool ReleaseHandle();
++    }
+     public class Socket : IDisposable {
++        public SafeSocketHandle SafeHandle { get; }
+     }
+     public enum SocketOptionName {
++        TcpKeepAliveInterval = 17,
++        TcpKeepAliveRetryCount = 16,
++        TcpKeepAliveTime = 3,
+     }
+ }
+```
+
diff --git a/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Net.WebSockets.md b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Net.WebSockets.md
new file mode 100644
index 00000000..1fdf0987
--- /dev/null
+++ b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Net.WebSockets.md
@@ -0,0 +1,11 @@
+# System.Net.WebSockets
+
+``` diff
+ namespace System.Net.WebSockets {
+     public sealed class ClientWebSocket : WebSocket {
++        public override ValueTask<ValueWebSocketReceiveResult> ReceiveAsync(Memory<byte> buffer, CancellationToken cancellationToken);
++        public override ValueTask SendAsync(ReadOnlyMemory<byte> buffer, WebSocketMessageType messageType, bool endOfMessage, CancellationToken cancellationToken);
+     }
+ }
+```
+
diff --git a/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Net.md b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Net.md
new file mode 100644
index 00000000..a5641d0d
--- /dev/null
+++ b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Net.md
@@ -0,0 +1,31 @@
+# System.Net
+
+``` diff
+ namespace System.Net {
+-    public class CookieCollection : ICollection, IEnumerable {
++    public class CookieCollection : ICollection, ICollection<Cookie>, IEnumerable, IEnumerable<Cookie>, IReadOnlyCollection<Cookie> {
++        public void Clear();
++        public bool Contains(Cookie cookie);
++        public bool Remove(Cookie cookie);
++        IEnumerator<Cookie> System.Collections.Generic.IEnumerable<System.Net.Cookie>.GetEnumerator();
+     }
+     public enum DecompressionMethods {
++        All = -1,
++        Brotli = 4,
+     }
+     public class FileWebRequest : WebRequest, ISerializable {
++        public override Task<Stream> GetRequestStreamAsync();
++        public override Task<WebResponse> GetResponseAsync();
+     }
+     public class IPEndPoint : EndPoint {
++        public static IPEndPoint Parse(ReadOnlySpan<char> s);
++        public static IPEndPoint Parse(string s);
++        public static bool TryParse(ReadOnlySpan<char> s, out IPEndPoint result);
++        public static bool TryParse(string s, out IPEndPoint result);
+     }
+     public enum SecurityProtocolType {
++        Tls13 = 12288,
+     }
+ }
+```
+
diff --git a/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Numerics.md b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Numerics.md
new file mode 100644
index 00000000..4cd1ec50
--- /dev/null
+++ b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Numerics.md
@@ -0,0 +1,30 @@
+# System.Numerics
+
+``` diff
+ namespace System.Numerics {
+     public struct Complex : IEquatable<Complex>, IFormattable {
++        public static readonly Complex Infinity;
++        public static readonly Complex NaN;
++        public static Complex Add(double left, Complex right);
++        public static Complex Add(Complex left, double right);
++        public static Complex Divide(double dividend, Complex divisor);
++        public static Complex Divide(Complex dividend, double divisor);
++        public static bool IsFinite(Complex value);
++        public static bool IsInfinity(Complex value);
++        public static bool IsNaN(Complex value);
++        public static Complex Multiply(double left, Complex right);
++        public static Complex Multiply(Complex left, double right);
++        public static Complex operator +(double left, Complex right);
++        public static Complex operator +(Complex left, double right);
++        public static Complex operator /(double left, Complex right);
++        public static Complex operator /(Complex left, double right);
++        public static Complex operator *(double left, Complex right);
++        public static Complex operator *(Complex left, double right);
++        public static Complex operator -(double left, Complex right);
++        public static Complex operator -(Complex left, double right);
++        public static Complex Subtract(double left, Complex right);
++        public static Complex Subtract(Complex left, double right);
+     }
+ }
+```
+
diff --git a/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Reflection.Emit.md b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Reflection.Emit.md
new file mode 100644
index 00000000..271b42ae
--- /dev/null
+++ b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Reflection.Emit.md
@@ -0,0 +1,19 @@
+# System.Reflection.Emit
+
+``` diff
+ namespace System.Reflection.Emit {
+     public sealed class DynamicMethod : MethodInfo {
++        public ParameterBuilder DefineParameter(int position, ParameterAttributes attributes, string parameterName);
+     }
+     public class ModuleBuilder : Module {
++        public MethodBuilder DefinePInvokeMethod(string name, string dllName, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] parameterTypes, CallingConvention nativeCallConv, CharSet nativeCharSet);
++        public MethodBuilder DefinePInvokeMethod(string name, string dllName, string entryName, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] parameterTypes, CallingConvention nativeCallConv, CharSet nativeCharSet);
+     }
+     public sealed class TypeBuilder : Type {
++        public MethodBuilder DefinePInvokeMethod(string name, string dllName, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] parameterTypes, CallingConvention nativeCallConv, CharSet nativeCharSet);
++        public MethodBuilder DefinePInvokeMethod(string name, string dllName, string entryName, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] parameterTypes, CallingConvention nativeCallConv, CharSet nativeCharSet);
++        public MethodBuilder DefinePInvokeMethod(string name, string dllName, string entryName, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] returnTypeRequiredCustomModifiers, Type[] returnTypeOptionalCustomModifiers, Type[] parameterTypes, Type[][] parameterTypeRequiredCustomModifiers, Type[][] parameterTypeOptionalCustomModifiers, CallingConvention nativeCallConv, CharSet nativeCharSet);
+     }
+ }
+```
+
diff --git a/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Reflection.md b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Reflection.md
new file mode 100644
index 00000000..d37ac13f
--- /dev/null
+++ b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Reflection.md
@@ -0,0 +1,20 @@
+# System.Reflection
+
+``` diff
+ namespace System.Reflection {
+     public class CustomAttributeData {
+-        public Type AttributeType { get; }
++        public virtual Type AttributeType { get; }
+     }
++    public interface ICustomTypeProvider {
++        Type GetCustomType();
++    }
+     public enum MethodImplAttributes {
++        AggressiveOptimization = 512,
+     }
+     public abstract class TypeInfo : Type, IReflectableType {
++        protected TypeInfo();
+     }
+ }
+```
+
diff --git a/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Runtime.CompilerServices.md b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Runtime.CompilerServices.md
new file mode 100644
index 00000000..f81ba86e
--- /dev/null
+++ b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Runtime.CompilerServices.md
@@ -0,0 +1,36 @@
+# System.Runtime.CompilerServices
+
+``` diff
+ namespace System.Runtime.CompilerServices {
++    public struct AsyncIteratorMethodBuilder {
++        public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine;
++        public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine;
++        public void Complete();
++        public static AsyncIteratorMethodBuilder Create();
++        public void MoveNext<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine;
++    }
++    public sealed class CallerArgumentExpressionAttribute : Attribute {
++        public CallerArgumentExpressionAttribute(string parameterName);
++        public string ParameterName { get; }
++    }
++    public readonly struct ConfiguredAsyncEnumerable<T> {
++        public ConfiguredAsyncEnumerable<T>.Enumerator GetAsyncEnumerator();
++        public readonly struct Enumerator {
++            public T Current { get; }
++            public ConfiguredValueTaskAwaitable DisposeAsync();
++            public ConfiguredValueTaskAwaitable<bool> MoveNextAsync();
++        }
++    }
++    public sealed class IDispatchConstantAttribute : CustomConstantAttribute {
++        public IDispatchConstantAttribute();
++        public override object Value { get; }
++    }
+     public enum MethodImplOptions {
++        AggressiveOptimization = 512,
+     }
+     public static class RuntimeFeature {
++        public const string DefaultImplementationsOfInterfaces = "DefaultImplementationsOfInterfaces";
+     }
+ }
+```
+
diff --git a/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Runtime.InteropServices.md b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Runtime.InteropServices.md
new file mode 100644
index 00000000..ea1c4f0d
--- /dev/null
+++ b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Runtime.InteropServices.md
@@ -0,0 +1,27 @@
+# System.Runtime.InteropServices
+
+``` diff
+ namespace System.Runtime.InteropServices {
+-    public struct HandleRef
++    public readonly struct HandleRef
+     public static class Marshal {
++        public static int GetEndComSlot(Type t);
++        public static IntPtr GetExceptionPointers();
++        public static bool IsTypeVisibleFromCom(Type t);
+     }
+     public static class MemoryMarshal {
++        public static ref readonly T AsRef<T>(ReadOnlySpan<byte> span) where T : struct;
++        public static ref T AsRef<T>(Span<byte> span) where T : struct;
+     }
+     public readonly struct OSPlatform : IEquatable<OSPlatform> {
++        public static OSPlatform FreeBSD { get; }
+     }
+     public static class SequenceMarshal {
++        public static bool TryRead<T>(ref SequenceReader<byte> reader, out T value) where T : struct;
+     }
++    public class StandardOleMarshalObject : MarshalByRefObject {
++        protected StandardOleMarshalObject();
++    }
+ }
+```
+
diff --git a/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Runtime.Intrinsics.Arm.Arm64.md b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Runtime.Intrinsics.Arm.Arm64.md
new file mode 100644
index 00000000..77c90fe2
--- /dev/null
+++ b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Runtime.Intrinsics.Arm.Arm64.md
@@ -0,0 +1,177 @@
+# System.Runtime.Intrinsics.Arm.Arm64
+
+``` diff
++namespace System.Runtime.Intrinsics.Arm.Arm64 {
++    public static class Aes {
++        public static bool IsSupported { get; }
++        public static Vector128<byte> Decrypt(Vector128<byte> value, Vector128<byte> roundKey);
++        public static Vector128<byte> Encrypt(Vector128<byte> value, Vector128<byte> roundKey);
++        public static Vector128<byte> InverseMixColumns(Vector128<byte> value);
++        public static Vector128<byte> MixColumns(Vector128<byte> value);
++    }
++    public static class Base {
++        public static bool IsSupported { get; }
++        public static int LeadingSignCount(int value);
++        public static int LeadingSignCount(long value);
++        public static int LeadingZeroCount(int value);
++        public static int LeadingZeroCount(long value);
++        public static int LeadingZeroCount(uint value);
++        public static int LeadingZeroCount(ulong value);
++    }
++    public static class Sha1 {
++        public static bool IsSupported { get; }
++        public static uint FixedRotate(uint hash_e);
++        public static Vector128<uint> HashChoose(Vector128<uint> hash_abcd, uint hash_e, Vector128<uint> wk);
++        public static Vector128<uint> HashMajority(Vector128<uint> hash_abcd, uint hash_e, Vector128<uint> wk);
++        public static Vector128<uint> HashParity(Vector128<uint> hash_abcd, uint hash_e, Vector128<uint> wk);
++        public static Vector128<uint> SchedulePart1(Vector128<uint> w0_3, Vector128<uint> w4_7, Vector128<uint> w8_11);
++        public static Vector128<uint> SchedulePart2(Vector128<uint> tw0_3, Vector128<uint> w12_15);
++    }
++    public static class Sha256 {
++        public static bool IsSupported { get; }
++        public static Vector128<uint> HashLower(Vector128<uint> hash_abcd, Vector128<uint> hash_efgh, Vector128<uint> wk);
++        public static Vector128<uint> HashUpper(Vector128<uint> hash_efgh, Vector128<uint> hash_abcd, Vector128<uint> wk);
++        public static Vector128<uint> SchedulePart1(Vector128<uint> w0_3, Vector128<uint> w4_7);
++        public static Vector128<uint> SchedulePart2(Vector128<uint> w0_3, Vector128<uint> w8_11, Vector128<uint> w12_15);
++    }
++    public static class Simd {
++        public static bool IsSupported { get; }
++        public static Vector128<double> Abs(Vector128<double> value);
++        public static Vector128<ushort> Abs(Vector128<short> value);
++        public static Vector128<uint> Abs(Vector128<int> value);
++        public static Vector128<ulong> Abs(Vector128<long> value);
++        public static Vector128<byte> Abs(Vector128<sbyte> value);
++        public static Vector128<float> Abs(Vector128<float> value);
++        public static Vector64<ushort> Abs(Vector64<short> value);
++        public static Vector64<uint> Abs(Vector64<int> value);
++        public static Vector64<byte> Abs(Vector64<sbyte> value);
++        public static Vector64<float> Abs(Vector64<float> value);
++        public static Vector128<T> Add<T>(Vector128<T> left, Vector128<T> right) where T : struct;
++        public static Vector64<T> Add<T>(Vector64<T> left, Vector64<T> right) where T : struct;
++        public static Vector128<T> And<T>(Vector128<T> left, Vector128<T> right) where T : struct;
++        public static Vector64<T> And<T>(Vector64<T> left, Vector64<T> right) where T : struct;
++        public static Vector128<T> AndNot<T>(Vector128<T> left, Vector128<T> right) where T : struct;
++        public static Vector64<T> AndNot<T>(Vector64<T> left, Vector64<T> right) where T : struct;
++        public static Vector128<T> BitwiseSelect<T>(Vector128<T> sel, Vector128<T> left, Vector128<T> right) where T : struct;
++        public static Vector64<T> BitwiseSelect<T>(Vector64<T> sel, Vector64<T> left, Vector64<T> right) where T : struct;
++        public static Vector128<T> CompareEqual<T>(Vector128<T> left, Vector128<T> right) where T : struct;
++        public static Vector64<T> CompareEqual<T>(Vector64<T> left, Vector64<T> right) where T : struct;
++        public static Vector128<T> CompareEqualZero<T>(Vector128<T> value) where T : struct;
++        public static Vector64<T> CompareEqualZero<T>(Vector64<T> value) where T : struct;
++        public static Vector128<T> CompareGreaterThan<T>(Vector128<T> left, Vector128<T> right) where T : struct;
++        public static Vector64<T> CompareGreaterThan<T>(Vector64<T> left, Vector64<T> right) where T : struct;
++        public static Vector128<T> CompareGreaterThanOrEqual<T>(Vector128<T> left, Vector128<T> right) where T : struct;
++        public static Vector64<T> CompareGreaterThanOrEqual<T>(Vector64<T> left, Vector64<T> right) where T : struct;
++        public static Vector128<T> CompareGreaterThanOrEqualZero<T>(Vector128<T> value) where T : struct;
++        public static Vector64<T> CompareGreaterThanOrEqualZero<T>(Vector64<T> value) where T : struct;
++        public static Vector128<T> CompareGreaterThanZero<T>(Vector128<T> value) where T : struct;
++        public static Vector64<T> CompareGreaterThanZero<T>(Vector64<T> value) where T : struct;
++        public static Vector128<T> CompareLessThanOrEqualZero<T>(Vector128<T> value) where T : struct;
++        public static Vector64<T> CompareLessThanOrEqualZero<T>(Vector64<T> value) where T : struct;
++        public static Vector128<T> CompareLessThanZero<T>(Vector128<T> value) where T : struct;
++        public static Vector64<T> CompareLessThanZero<T>(Vector64<T> value) where T : struct;
++        public static Vector128<T> CompareTest<T>(Vector128<T> left, Vector128<T> right) where T : struct;
++        public static Vector64<T> CompareTest<T>(Vector64<T> left, Vector64<T> right) where T : struct;
++        public static Vector128<double> Divide(Vector128<double> left, Vector128<double> right);
++        public static Vector128<float> Divide(Vector128<float> left, Vector128<float> right);
++        public static Vector64<float> Divide(Vector64<float> left, Vector64<float> right);
++        public static T Extract<T>(Vector128<T> vector, byte index) where T : struct;
++        public static T Extract<T>(Vector64<T> vector, byte index) where T : struct;
++        public static Vector128<T> Insert<T>(Vector128<T> vector, byte index, T data) where T : struct;
++        public static Vector64<T> Insert<T>(Vector64<T> vector, byte index, T data) where T : struct;
++        public static Vector128<short> LeadingSignCount(Vector128<short> value);
++        public static Vector128<int> LeadingSignCount(Vector128<int> value);
++        public static Vector128<sbyte> LeadingSignCount(Vector128<sbyte> value);
++        public static Vector64<short> LeadingSignCount(Vector64<short> value);
++        public static Vector64<int> LeadingSignCount(Vector64<int> value);
++        public static Vector64<sbyte> LeadingSignCount(Vector64<sbyte> value);
++        public static Vector128<byte> LeadingZeroCount(Vector128<byte> value);
++        public static Vector128<short> LeadingZeroCount(Vector128<short> value);
++        public static Vector128<int> LeadingZeroCount(Vector128<int> value);
++        public static Vector128<sbyte> LeadingZeroCount(Vector128<sbyte> value);
++        public static Vector128<ushort> LeadingZeroCount(Vector128<ushort> value);
++        public static Vector128<uint> LeadingZeroCount(Vector128<uint> value);
++        public static Vector64<byte> LeadingZeroCount(Vector64<byte> value);
++        public static Vector64<short> LeadingZeroCount(Vector64<short> value);
++        public static Vector64<int> LeadingZeroCount(Vector64<int> value);
++        public static Vector64<sbyte> LeadingZeroCount(Vector64<sbyte> value);
++        public static Vector64<ushort> LeadingZeroCount(Vector64<ushort> value);
++        public static Vector64<uint> LeadingZeroCount(Vector64<uint> value);
++        public static Vector128<byte> Max(Vector128<byte> left, Vector128<byte> right);
++        public static Vector128<double> Max(Vector128<double> left, Vector128<double> right);
++        public static Vector128<short> Max(Vector128<short> left, Vector128<short> right);
++        public static Vector128<int> Max(Vector128<int> left, Vector128<int> right);
++        public static Vector128<sbyte> Max(Vector128<sbyte> left, Vector128<sbyte> right);
++        public static Vector128<float> Max(Vector128<float> left, Vector128<float> right);
++        public static Vector128<ushort> Max(Vector128<ushort> left, Vector128<ushort> right);
++        public static Vector128<uint> Max(Vector128<uint> left, Vector128<uint> right);
++        public static Vector64<byte> Max(Vector64<byte> left, Vector64<byte> right);
++        public static Vector64<short> Max(Vector64<short> left, Vector64<short> right);
++        public static Vector64<int> Max(Vector64<int> left, Vector64<int> right);
++        public static Vector64<sbyte> Max(Vector64<sbyte> left, Vector64<sbyte> right);
++        public static Vector64<float> Max(Vector64<float> left, Vector64<float> right);
++        public static Vector64<ushort> Max(Vector64<ushort> left, Vector64<ushort> right);
++        public static Vector64<uint> Max(Vector64<uint> left, Vector64<uint> right);
++        public static Vector128<byte> Min(Vector128<byte> left, Vector128<byte> right);
++        public static Vector128<double> Min(Vector128<double> left, Vector128<double> right);
++        public static Vector128<short> Min(Vector128<short> left, Vector128<short> right);
++        public static Vector128<int> Min(Vector128<int> left, Vector128<int> right);
++        public static Vector128<sbyte> Min(Vector128<sbyte> left, Vector128<sbyte> right);
++        public static Vector128<float> Min(Vector128<float> left, Vector128<float> right);
++        public static Vector128<ushort> Min(Vector128<ushort> left, Vector128<ushort> right);
++        public static Vector128<uint> Min(Vector128<uint> left, Vector128<uint> right);
++        public static Vector64<byte> Min(Vector64<byte> left, Vector64<byte> right);
++        public static Vector64<short> Min(Vector64<short> left, Vector64<short> right);
++        public static Vector64<int> Min(Vector64<int> left, Vector64<int> right);
++        public static Vector64<sbyte> Min(Vector64<sbyte> left, Vector64<sbyte> right);
++        public static Vector64<float> Min(Vector64<float> left, Vector64<float> right);
++        public static Vector64<ushort> Min(Vector64<ushort> left, Vector64<ushort> right);
++        public static Vector64<uint> Min(Vector64<uint> left, Vector64<uint> right);
++        public static Vector128<byte> Multiply(Vector128<byte> left, Vector128<byte> right);
++        public static Vector128<double> Multiply(Vector128<double> left, Vector128<double> right);
++        public static Vector128<short> Multiply(Vector128<short> left, Vector128<short> right);
++        public static Vector128<int> Multiply(Vector128<int> left, Vector128<int> right);
++        public static Vector128<sbyte> Multiply(Vector128<sbyte> left, Vector128<sbyte> right);
++        public static Vector128<float> Multiply(Vector128<float> left, Vector128<float> right);
++        public static Vector128<ushort> Multiply(Vector128<ushort> left, Vector128<ushort> right);
++        public static Vector128<uint> Multiply(Vector128<uint> left, Vector128<uint> right);
++        public static Vector64<byte> Multiply(Vector64<byte> left, Vector64<byte> right);
++        public static Vector64<short> Multiply(Vector64<short> left, Vector64<short> right);
++        public static Vector64<int> Multiply(Vector64<int> left, Vector64<int> right);
++        public static Vector64<sbyte> Multiply(Vector64<sbyte> left, Vector64<sbyte> right);
++        public static Vector64<float> Multiply(Vector64<float> left, Vector64<float> right);
++        public static Vector64<ushort> Multiply(Vector64<ushort> left, Vector64<ushort> right);
++        public static Vector64<uint> Multiply(Vector64<uint> left, Vector64<uint> right);
++        public static Vector128<double> Negate(Vector128<double> value);
++        public static Vector128<short> Negate(Vector128<short> value);
++        public static Vector128<int> Negate(Vector128<int> value);
++        public static Vector128<long> Negate(Vector128<long> value);
++        public static Vector128<sbyte> Negate(Vector128<sbyte> value);
++        public static Vector128<float> Negate(Vector128<float> value);
++        public static Vector64<short> Negate(Vector64<short> value);
++        public static Vector64<int> Negate(Vector64<int> value);
++        public static Vector64<sbyte> Negate(Vector64<sbyte> value);
++        public static Vector64<float> Negate(Vector64<float> value);
++        public static Vector128<T> Not<T>(Vector128<T> value) where T : struct;
++        public static Vector64<T> Not<T>(Vector64<T> value) where T : struct;
++        public static Vector128<T> Or<T>(Vector128<T> left, Vector128<T> right) where T : struct;
++        public static Vector64<T> Or<T>(Vector64<T> left, Vector64<T> right) where T : struct;
++        public static Vector128<T> OrNot<T>(Vector128<T> left, Vector128<T> right) where T : struct;
++        public static Vector64<T> OrNot<T>(Vector64<T> left, Vector64<T> right) where T : struct;
++        public static Vector128<byte> PopCount(Vector128<byte> value);
++        public static Vector128<sbyte> PopCount(Vector128<sbyte> value);
++        public static Vector64<byte> PopCount(Vector64<byte> value);
++        public static Vector64<sbyte> PopCount(Vector64<sbyte> value);
++        public static Vector128<T> SetAllVector128<T>(T value) where T : struct;
++        public static Vector64<T> SetAllVector64<T>(T value) where T : struct;
++        public static Vector128<double> Sqrt(Vector128<double> value);
++        public static Vector128<float> Sqrt(Vector128<float> value);
++        public static Vector64<float> Sqrt(Vector64<float> value);
++        public static Vector128<T> Subtract<T>(Vector128<T> left, Vector128<T> right) where T : struct;
++        public static Vector64<T> Subtract<T>(Vector64<T> left, Vector64<T> right) where T : struct;
++        public static Vector128<T> Xor<T>(Vector128<T> left, Vector128<T> right) where T : struct;
++        public static Vector64<T> Xor<T>(Vector64<T> left, Vector64<T> right) where T : struct;
++    }
++}
+```
+
diff --git a/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Runtime.Intrinsics.X86.md b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Runtime.Intrinsics.X86.md
new file mode 100644
index 00000000..4b7d868b
--- /dev/null
+++ b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Runtime.Intrinsics.X86.md
@@ -0,0 +1,1499 @@
+# System.Runtime.Intrinsics.X86
+
+``` diff
++namespace System.Runtime.Intrinsics.X86 {
++    public abstract class Aes : Sse2 {
++        public static new bool IsSupported { get; }
++        public static Vector128<byte> Decrypt(Vector128<byte> value, Vector128<byte> roundKey);
++        public static Vector128<byte> DecryptLast(Vector128<byte> value, Vector128<byte> roundKey);
++        public static Vector128<byte> Encrypt(Vector128<byte> value, Vector128<byte> roundKey);
++        public static Vector128<byte> EncryptLast(Vector128<byte> value, Vector128<byte> roundKey);
++        public static Vector128<byte> InverseMixColumns(Vector128<byte> value);
++        public static Vector128<byte> KeygenAssist(Vector128<byte> value, byte control);
++    }
++    public abstract class Avx : Sse42 {
++        public static new bool IsSupported { get; }
++        public static Vector256<double> Add(Vector256<double> left, Vector256<double> right);
++        public static Vector256<float> Add(Vector256<float> left, Vector256<float> right);
++        public static Vector256<double> AddSubtract(Vector256<double> left, Vector256<double> right);
++        public static Vector256<float> AddSubtract(Vector256<float> left, Vector256<float> right);
++        public static Vector256<double> And(Vector256<double> left, Vector256<double> right);
++        public static Vector256<float> And(Vector256<float> left, Vector256<float> right);
++        public static Vector256<double> AndNot(Vector256<double> left, Vector256<double> right);
++        public static Vector256<float> AndNot(Vector256<float> left, Vector256<float> right);
++        public static Vector256<double> Blend(Vector256<double> left, Vector256<double> right, byte control);
++        public static Vector256<float> Blend(Vector256<float> left, Vector256<float> right, byte control);
++        public static Vector256<double> BlendVariable(Vector256<double> left, Vector256<double> right, Vector256<double> mask);
++        public static Vector256<float> BlendVariable(Vector256<float> left, Vector256<float> right, Vector256<float> mask);
++        public unsafe static Vector128<float> BroadcastScalarToVector128(float* source);
++        public unsafe static Vector256<double> BroadcastScalarToVector256(double* source);
++        public unsafe static Vector256<float> BroadcastScalarToVector256(float* source);
++        public unsafe static Vector256<double> BroadcastVector128ToVector256(double* address);
++        public unsafe static Vector256<float> BroadcastVector128ToVector256(float* address);
++        public static Vector256<double> Ceiling(Vector256<double> value);
++        public static Vector256<float> Ceiling(Vector256<float> value);
++        public static Vector128<double> Compare(Vector128<double> left, Vector128<double> right, FloatComparisonMode mode);
++        public static Vector128<float> Compare(Vector128<float> left, Vector128<float> right, FloatComparisonMode mode);
++        public static Vector256<double> Compare(Vector256<double> left, Vector256<double> right, FloatComparisonMode mode);
++        public static Vector256<float> Compare(Vector256<float> left, Vector256<float> right, FloatComparisonMode mode);
++        public static Vector128<double> CompareScalar(Vector128<double> left, Vector128<double> right, FloatComparisonMode mode);
++        public static Vector128<float> CompareScalar(Vector128<float> left, Vector128<float> right, FloatComparisonMode mode);
++        public static float ConvertToSingle(Vector256<float> value);
++        public static Vector128<int> ConvertToVector128Int32(Vector256<double> value);
++        public static Vector128<int> ConvertToVector128Int32WithTruncation(Vector256<double> value);
++        public static Vector128<float> ConvertToVector128Single(Vector256<double> value);
++        public static Vector256<double> ConvertToVector256Double(Vector128<int> value);
++        public static Vector256<double> ConvertToVector256Double(Vector128<float> value);
++        public static Vector256<int> ConvertToVector256Int32(Vector256<float> value);
++        public static Vector256<int> ConvertToVector256Int32WithTruncation(Vector256<float> value);
++        public static Vector256<float> ConvertToVector256Single(Vector256<int> value);
++        public static Vector256<double> Divide(Vector256<double> left, Vector256<double> right);
++        public static Vector256<float> Divide(Vector256<float> left, Vector256<float> right);
++        public static Vector256<float> DotProduct(Vector256<float> left, Vector256<float> right, byte control);
++        public static Vector256<double> DuplicateEvenIndexed(Vector256<double> value);
++        public static Vector256<float> DuplicateEvenIndexed(Vector256<float> value);
++        public static Vector256<float> DuplicateOddIndexed(Vector256<float> value);
++        public static Vector256<T> ExtendToVector256<T>(Vector128<T> value) where T : struct;
++        public static byte Extract(Vector256<byte> value, byte index);
++        public static int Extract(Vector256<int> value, byte index);
++        public static long Extract(Vector256<long> value, byte index);
++        public static ushort Extract(Vector256<ushort> value, byte index);
++        public static uint Extract(Vector256<uint> value, byte index);
++        public static ulong Extract(Vector256<ulong> value, byte index);
++        public unsafe static void ExtractVector128(byte* address, Vector256<byte> value, byte index);
++        public unsafe static void ExtractVector128(double* address, Vector256<double> value, byte index);
++        public unsafe static void ExtractVector128(short* address, Vector256<short> value, byte index);
++        public unsafe static void ExtractVector128(int* address, Vector256<int> value, byte index);
++        public unsafe static void ExtractVector128(long* address, Vector256<long> value, byte index);
++        public static Vector128<byte> ExtractVector128(Vector256<byte> value, byte index);
++        public static Vector128<double> ExtractVector128(Vector256<double> value, byte index);
++        public static Vector128<short> ExtractVector128(Vector256<short> value, byte index);
++        public static Vector128<int> ExtractVector128(Vector256<int> value, byte index);
++        public static Vector128<long> ExtractVector128(Vector256<long> value, byte index);
++        public static Vector128<sbyte> ExtractVector128(Vector256<sbyte> value, byte index);
++        public static Vector128<float> ExtractVector128(Vector256<float> value, byte index);
++        public static Vector128<ushort> ExtractVector128(Vector256<ushort> value, byte index);
++        public static Vector128<uint> ExtractVector128(Vector256<uint> value, byte index);
++        public static Vector128<ulong> ExtractVector128(Vector256<ulong> value, byte index);
++        public unsafe static void ExtractVector128(sbyte* address, Vector256<sbyte> value, byte index);
++        public unsafe static void ExtractVector128(float* address, Vector256<float> value, byte index);
++        public unsafe static void ExtractVector128(ushort* address, Vector256<ushort> value, byte index);
++        public unsafe static void ExtractVector128(uint* address, Vector256<uint> value, byte index);
++        public unsafe static void ExtractVector128(ulong* address, Vector256<ulong> value, byte index);
++        public static Vector256<double> Floor(Vector256<double> value);
++        public static Vector256<float> Floor(Vector256<float> value);
++        public static Vector128<T> GetLowerHalf<T>(Vector256<T> value) where T : struct;
++        public static Vector256<double> HorizontalAdd(Vector256<double> left, Vector256<double> right);
++        public static Vector256<float> HorizontalAdd(Vector256<float> left, Vector256<float> right);
++        public static Vector256<double> HorizontalSubtract(Vector256<double> left, Vector256<double> right);
++        public static Vector256<float> HorizontalSubtract(Vector256<float> left, Vector256<float> right);
++        public static Vector256<byte> Insert(Vector256<byte> value, byte data, byte index);
++        public static Vector256<short> Insert(Vector256<short> value, short data, byte index);
++        public static Vector256<int> Insert(Vector256<int> value, int data, byte index);
++        public static Vector256<long> Insert(Vector256<long> value, long data, byte index);
++        public static Vector256<sbyte> Insert(Vector256<sbyte> value, sbyte data, byte index);
++        public static Vector256<ushort> Insert(Vector256<ushort> value, ushort data, byte index);
++        public static Vector256<uint> Insert(Vector256<uint> value, uint data, byte index);
++        public static Vector256<ulong> Insert(Vector256<ulong> value, ulong data, byte index);
++        public unsafe static Vector256<byte> InsertVector128(Vector256<byte> value, byte* address, byte index);
++        public static Vector256<byte> InsertVector128(Vector256<byte> value, Vector128<byte> data, byte index);
++        public unsafe static Vector256<double> InsertVector128(Vector256<double> value, double* address, byte index);
++        public static Vector256<double> InsertVector128(Vector256<double> value, Vector128<double> data, byte index);
++        public unsafe static Vector256<short> InsertVector128(Vector256<short> value, short* address, byte index);
++        public static Vector256<short> InsertVector128(Vector256<short> value, Vector128<short> data, byte index);
++        public unsafe static Vector256<int> InsertVector128(Vector256<int> value, int* address, byte index);
++        public static Vector256<int> InsertVector128(Vector256<int> value, Vector128<int> data, byte index);
++        public unsafe static Vector256<long> InsertVector128(Vector256<long> value, long* address, byte index);
++        public static Vector256<long> InsertVector128(Vector256<long> value, Vector128<long> data, byte index);
++        public static Vector256<sbyte> InsertVector128(Vector256<sbyte> value, Vector128<sbyte> data, byte index);
++        public unsafe static Vector256<sbyte> InsertVector128(Vector256<sbyte> value, sbyte* address, byte index);
++        public static Vector256<float> InsertVector128(Vector256<float> value, Vector128<float> data, byte index);
++        public unsafe static Vector256<float> InsertVector128(Vector256<float> value, float* address, byte index);
++        public static Vector256<ushort> InsertVector128(Vector256<ushort> value, Vector128<ushort> data, byte index);
++        public unsafe static Vector256<ushort> InsertVector128(Vector256<ushort> value, ushort* address, byte index);
++        public static Vector256<uint> InsertVector128(Vector256<uint> value, Vector128<uint> data, byte index);
++        public unsafe static Vector256<uint> InsertVector128(Vector256<uint> value, uint* address, byte index);
++        public static Vector256<ulong> InsertVector128(Vector256<ulong> value, Vector128<ulong> data, byte index);
++        public unsafe static Vector256<ulong> InsertVector128(Vector256<ulong> value, ulong* address, byte index);
++        public unsafe static Vector256<byte> LoadAlignedVector256(byte* address);
++        public unsafe static Vector256<double> LoadAlignedVector256(double* address);
++        public unsafe static Vector256<short> LoadAlignedVector256(short* address);
++        public unsafe static Vector256<int> LoadAlignedVector256(int* address);
++        public unsafe static Vector256<long> LoadAlignedVector256(long* address);
++        public unsafe static Vector256<sbyte> LoadAlignedVector256(sbyte* address);
++        public unsafe static Vector256<float> LoadAlignedVector256(float* address);
++        public unsafe static Vector256<ushort> LoadAlignedVector256(ushort* address);
++        public unsafe static Vector256<uint> LoadAlignedVector256(uint* address);
++        public unsafe static Vector256<ulong> LoadAlignedVector256(ulong* address);
++        public unsafe static Vector256<byte> LoadDquVector256(byte* address);
++        public unsafe static Vector256<short> LoadDquVector256(short* address);
++        public unsafe static Vector256<int> LoadDquVector256(int* address);
++        public unsafe static Vector256<long> LoadDquVector256(long* address);
++        public unsafe static Vector256<sbyte> LoadDquVector256(sbyte* address);
++        public unsafe static Vector256<ushort> LoadDquVector256(ushort* address);
++        public unsafe static Vector256<uint> LoadDquVector256(uint* address);
++        public unsafe static Vector256<ulong> LoadDquVector256(ulong* address);
++        public unsafe static Vector256<byte> LoadVector256(byte* address);
++        public unsafe static Vector256<double> LoadVector256(double* address);
++        public unsafe static Vector256<short> LoadVector256(short* address);
++        public unsafe static Vector256<int> LoadVector256(int* address);
++        public unsafe static Vector256<long> LoadVector256(long* address);
++        public unsafe static Vector256<sbyte> LoadVector256(sbyte* address);
++        public unsafe static Vector256<float> LoadVector256(float* address);
++        public unsafe static Vector256<ushort> LoadVector256(ushort* address);
++        public unsafe static Vector256<uint> LoadVector256(uint* address);
++        public unsafe static Vector256<ulong> LoadVector256(ulong* address);
++        public unsafe static Vector128<double> MaskLoad(double* address, Vector128<double> mask);
++        public unsafe static Vector256<double> MaskLoad(double* address, Vector256<double> mask);
++        public unsafe static Vector128<float> MaskLoad(float* address, Vector128<float> mask);
++        public unsafe static Vector256<float> MaskLoad(float* address, Vector256<float> mask);
++        public unsafe static void MaskStore(double* address, Vector128<double> mask, Vector128<double> source);
++        public unsafe static void MaskStore(double* address, Vector256<double> mask, Vector256<double> source);
++        public unsafe static void MaskStore(float* address, Vector128<float> mask, Vector128<float> source);
++        public unsafe static void MaskStore(float* address, Vector256<float> mask, Vector256<float> source);
++        public static Vector256<double> Max(Vector256<double> left, Vector256<double> right);
++        public static Vector256<float> Max(Vector256<float> left, Vector256<float> right);
++        public static Vector256<double> Min(Vector256<double> left, Vector256<double> right);
++        public static Vector256<float> Min(Vector256<float> left, Vector256<float> right);
++        public static int MoveMask(Vector256<double> value);
++        public static int MoveMask(Vector256<float> value);
++        public static Vector256<double> Multiply(Vector256<double> left, Vector256<double> right);
++        public static Vector256<float> Multiply(Vector256<float> left, Vector256<float> right);
++        public static Vector256<double> Or(Vector256<double> left, Vector256<double> right);
++        public static Vector256<float> Or(Vector256<float> left, Vector256<float> right);
++        public static Vector128<double> Permute(Vector128<double> value, byte control);
++        public static Vector128<float> Permute(Vector128<float> value, byte control);
++        public static Vector256<double> Permute(Vector256<double> value, byte control);
++        public static Vector256<float> Permute(Vector256<float> value, byte control);
++        public static Vector256<byte> Permute2x128(Vector256<byte> left, Vector256<byte> right, byte control);
++        public static Vector256<double> Permute2x128(Vector256<double> left, Vector256<double> right, byte control);
++        public static Vector256<short> Permute2x128(Vector256<short> left, Vector256<short> right, byte control);
++        public static Vector256<int> Permute2x128(Vector256<int> left, Vector256<int> right, byte control);
++        public static Vector256<long> Permute2x128(Vector256<long> left, Vector256<long> right, byte control);
++        public static Vector256<sbyte> Permute2x128(Vector256<sbyte> left, Vector256<sbyte> right, byte control);
++        public static Vector256<float> Permute2x128(Vector256<float> left, Vector256<float> right, byte control);
++        public static Vector256<ushort> Permute2x128(Vector256<ushort> left, Vector256<ushort> right, byte control);
++        public static Vector256<uint> Permute2x128(Vector256<uint> left, Vector256<uint> right, byte control);
++        public static Vector256<ulong> Permute2x128(Vector256<ulong> left, Vector256<ulong> right, byte control);
++        public static Vector128<double> PermuteVar(Vector128<double> left, Vector128<long> control);
++        public static Vector128<float> PermuteVar(Vector128<float> left, Vector128<int> control);
++        public static Vector256<double> PermuteVar(Vector256<double> left, Vector256<long> control);
++        public static Vector256<float> PermuteVar(Vector256<float> left, Vector256<int> control);
++        public static Vector256<float> Reciprocal(Vector256<float> value);
++        public static Vector256<float> ReciprocalSqrt(Vector256<float> value);
++        public static Vector256<double> RoundCurrentDirection(Vector256<double> value);
++        public static Vector256<float> RoundCurrentDirection(Vector256<float> value);
++        public static Vector256<double> RoundToNearestInteger(Vector256<double> value);
++        public static Vector256<float> RoundToNearestInteger(Vector256<float> value);
++        public static Vector256<double> RoundToNegativeInfinity(Vector256<double> value);
++        public static Vector256<float> RoundToNegativeInfinity(Vector256<float> value);
++        public static Vector256<double> RoundToPositiveInfinity(Vector256<double> value);
++        public static Vector256<float> RoundToPositiveInfinity(Vector256<float> value);
++        public static Vector256<double> RoundToZero(Vector256<double> value);
++        public static Vector256<float> RoundToZero(Vector256<float> value);
++        public static Vector256<T> SetAllVector256<T>(T value) where T : struct;
++        public static Vector256<T> SetHighLow<T>(Vector128<T> hi, Vector128<T> lo) where T : struct;
++        public static Vector256<byte> SetVector256(byte e31, byte e30, byte e29, byte e28, byte e27, byte e26, byte e25, byte e24, byte e23, byte e22, byte e21, byte e20, byte e19, byte e18, byte e17, byte e16, 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);
++        public static Vector256<double> SetVector256(double e3, double e2, double e1, double e0);
++        public static Vector256<short> SetVector256(short e15, short e14, short e13, short e12, short e11, short e10, short e9, short e8, short e7, short e6, short e5, short e4, short e3, short e2, short e1, short e0);
++        public static Vector256<int> SetVector256(int e7, int e6, int e5, int e4, int e3, int e2, int e1, int e0);
++        public static Vector256<long> SetVector256(long e3, long e2, long e1, long e0);
++        public static Vector256<sbyte> SetVector256(sbyte e31, sbyte e30, sbyte e29, sbyte e28, sbyte e27, sbyte e26, sbyte e25, sbyte e24, sbyte e23, sbyte e22, sbyte e21, sbyte e20, sbyte e19, sbyte e18, sbyte e17, sbyte e16, 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);
++        public static Vector256<float> SetVector256(float e7, float e6, float e5, float e4, float e3, float e2, float e1, float e0);
++        public static Vector256<ushort> SetVector256(ushort e15, ushort e14, ushort e13, ushort e12, ushort e11, ushort e10, ushort e9, ushort e8, ushort e7, ushort e6, ushort e5, ushort e4, ushort e3, ushort e2, ushort e1, ushort e0);
++        public static Vector256<uint> SetVector256(uint e7, uint e6, uint e5, uint e4, uint e3, uint e2, uint e1, uint e0);
++        public static Vector256<ulong> SetVector256(ulong e3, ulong e2, ulong e1, ulong e0);
++        public static Vector256<T> SetZeroVector256<T>() where T : struct;
++        public static Vector256<double> Shuffle(Vector256<double> value, Vector256<double> right, byte control);
++        public static Vector256<float> Shuffle(Vector256<float> value, Vector256<float> right, byte control);
++        public static Vector256<double> Sqrt(Vector256<double> value);
++        public static Vector256<float> Sqrt(Vector256<float> value);
++        public static Vector256<U> StaticCast<T, U>(Vector256<T> value) where T : struct where U : struct;
++        public unsafe static void Store(byte* address, Vector256<byte> source);
++        public unsafe static void Store(double* address, Vector256<double> source);
++        public unsafe static void Store(short* address, Vector256<short> source);
++        public unsafe static void Store(int* address, Vector256<int> source);
++        public unsafe static void Store(long* address, Vector256<long> source);
++        public unsafe static void Store(sbyte* address, Vector256<sbyte> source);
++        public unsafe static void Store(float* address, Vector256<float> source);
++        public unsafe static void Store(ushort* address, Vector256<ushort> source);
++        public unsafe static void Store(uint* address, Vector256<uint> source);
++        public unsafe static void Store(ulong* address, Vector256<ulong> source);
++        public unsafe static void StoreAligned(byte* address, Vector256<byte> source);
++        public unsafe static void StoreAligned(double* address, Vector256<double> source);
++        public unsafe static void StoreAligned(short* address, Vector256<short> source);
++        public unsafe static void StoreAligned(int* address, Vector256<int> source);
++        public unsafe static void StoreAligned(long* address, Vector256<long> source);
++        public unsafe static void StoreAligned(sbyte* address, Vector256<sbyte> source);
++        public unsafe static void StoreAligned(float* address, Vector256<float> source);
++        public unsafe static void StoreAligned(ushort* address, Vector256<ushort> source);
++        public unsafe static void StoreAligned(uint* address, Vector256<uint> source);
++        public unsafe static void StoreAligned(ulong* address, Vector256<ulong> source);
++        public unsafe static void StoreAlignedNonTemporal(byte* address, Vector256<byte> source);
++        public unsafe static void StoreAlignedNonTemporal(double* address, Vector256<double> source);
++        public unsafe static void StoreAlignedNonTemporal(short* address, Vector256<short> source);
++        public unsafe static void StoreAlignedNonTemporal(int* address, Vector256<int> source);
++        public unsafe static void StoreAlignedNonTemporal(long* address, Vector256<long> source);
++        public unsafe static void StoreAlignedNonTemporal(sbyte* address, Vector256<sbyte> source);
++        public unsafe static void StoreAlignedNonTemporal(float* address, Vector256<float> source);
++        public unsafe static void StoreAlignedNonTemporal(ushort* address, Vector256<ushort> source);
++        public unsafe static void StoreAlignedNonTemporal(uint* address, Vector256<uint> source);
++        public unsafe static void StoreAlignedNonTemporal(ulong* address, Vector256<ulong> source);
++        public static Vector256<double> Subtract(Vector256<double> left, Vector256<double> right);
++        public static Vector256<float> Subtract(Vector256<float> left, Vector256<float> right);
++        public static bool TestC(Vector128<double> left, Vector128<double> right);
++        public static bool TestC(Vector128<float> left, Vector128<float> right);
++        public static bool TestC(Vector256<byte> left, Vector256<byte> right);
++        public static bool TestC(Vector256<double> left, Vector256<double> right);
++        public static bool TestC(Vector256<short> left, Vector256<short> right);
++        public static bool TestC(Vector256<int> left, Vector256<int> right);
++        public static bool TestC(Vector256<long> left, Vector256<long> right);
++        public static bool TestC(Vector256<sbyte> left, Vector256<sbyte> right);
++        public static bool TestC(Vector256<float> left, Vector256<float> right);
++        public static bool TestC(Vector256<ushort> left, Vector256<ushort> right);
++        public static bool TestC(Vector256<uint> left, Vector256<uint> right);
++        public static bool TestC(Vector256<ulong> left, Vector256<ulong> right);
++        public static bool TestNotZAndNotC(Vector128<double> left, Vector128<double> right);
++        public static bool TestNotZAndNotC(Vector128<float> left, Vector128<float> right);
++        public static bool TestNotZAndNotC(Vector256<byte> left, Vector256<byte> right);
++        public static bool TestNotZAndNotC(Vector256<double> left, Vector256<double> right);
++        public static bool TestNotZAndNotC(Vector256<short> left, Vector256<short> right);
++        public static bool TestNotZAndNotC(Vector256<int> left, Vector256<int> right);
++        public static bool TestNotZAndNotC(Vector256<long> left, Vector256<long> right);
++        public static bool TestNotZAndNotC(Vector256<sbyte> left, Vector256<sbyte> right);
++        public static bool TestNotZAndNotC(Vector256<float> left, Vector256<float> right);
++        public static bool TestNotZAndNotC(Vector256<ushort> left, Vector256<ushort> right);
++        public static bool TestNotZAndNotC(Vector256<uint> left, Vector256<uint> right);
++        public static bool TestNotZAndNotC(Vector256<ulong> left, Vector256<ulong> right);
++        public static bool TestZ(Vector128<double> left, Vector128<double> right);
++        public static bool TestZ(Vector128<float> left, Vector128<float> right);
++        public static bool TestZ(Vector256<byte> left, Vector256<byte> right);
++        public static bool TestZ(Vector256<double> left, Vector256<double> right);
++        public static bool TestZ(Vector256<short> left, Vector256<short> right);
++        public static bool TestZ(Vector256<int> left, Vector256<int> right);
++        public static bool TestZ(Vector256<long> left, Vector256<long> right);
++        public static bool TestZ(Vector256<sbyte> left, Vector256<sbyte> right);
++        public static bool TestZ(Vector256<float> left, Vector256<float> right);
++        public static bool TestZ(Vector256<ushort> left, Vector256<ushort> right);
++        public static bool TestZ(Vector256<uint> left, Vector256<uint> right);
++        public static bool TestZ(Vector256<ulong> left, Vector256<ulong> right);
++        public static Vector256<double> UnpackHigh(Vector256<double> left, Vector256<double> right);
++        public static Vector256<float> UnpackHigh(Vector256<float> left, Vector256<float> right);
++        public static Vector256<double> UnpackLow(Vector256<double> left, Vector256<double> right);
++        public static Vector256<float> UnpackLow(Vector256<float> left, Vector256<float> right);
++        public static Vector256<double> Xor(Vector256<double> left, Vector256<double> right);
++        public static Vector256<float> Xor(Vector256<float> left, Vector256<float> right);
++    }
++    public abstract class Avx2 : Avx {
++        public static new bool IsSupported { get; }
++        public static Vector256<ushort> Abs(Vector256<short> value);
++        public static Vector256<uint> Abs(Vector256<int> value);
++        public static Vector256<byte> Abs(Vector256<sbyte> value);
++        public static Vector256<byte> Add(Vector256<byte> left, Vector256<byte> right);
++        public static Vector256<short> Add(Vector256<short> left, Vector256<short> right);
++        public static Vector256<int> Add(Vector256<int> left, Vector256<int> right);
++        public static Vector256<long> Add(Vector256<long> left, Vector256<long> right);
++        public static Vector256<sbyte> Add(Vector256<sbyte> left, Vector256<sbyte> right);
++        public static Vector256<ushort> Add(Vector256<ushort> left, Vector256<ushort> right);
++        public static Vector256<uint> Add(Vector256<uint> left, Vector256<uint> right);
++        public static Vector256<ulong> Add(Vector256<ulong> left, Vector256<ulong> right);
++        public static Vector256<byte> AddSaturate(Vector256<byte> left, Vector256<byte> right);
++        public static Vector256<short> AddSaturate(Vector256<short> left, Vector256<short> right);
++        public static Vector256<sbyte> AddSaturate(Vector256<sbyte> left, Vector256<sbyte> right);
++        public static Vector256<ushort> AddSaturate(Vector256<ushort> left, Vector256<ushort> right);
++        public static Vector256<byte> AlignRight(Vector256<byte> left, Vector256<byte> right, byte mask);
++        public static Vector256<short> AlignRight(Vector256<short> left, Vector256<short> right, byte mask);
++        public static Vector256<int> AlignRight(Vector256<int> left, Vector256<int> right, byte mask);
++        public static Vector256<long> AlignRight(Vector256<long> left, Vector256<long> right, byte mask);
++        public static Vector256<sbyte> AlignRight(Vector256<sbyte> left, Vector256<sbyte> right, byte mask);
++        public static Vector256<ushort> AlignRight(Vector256<ushort> left, Vector256<ushort> right, byte mask);
++        public static Vector256<uint> AlignRight(Vector256<uint> left, Vector256<uint> right, byte mask);
++        public static Vector256<ulong> AlignRight(Vector256<ulong> left, Vector256<ulong> right, byte mask);
++        public static Vector256<byte> And(Vector256<byte> left, Vector256<byte> right);
++        public static Vector256<short> And(Vector256<short> left, Vector256<short> right);
++        public static Vector256<int> And(Vector256<int> left, Vector256<int> right);
++        public static Vector256<long> And(Vector256<long> left, Vector256<long> right);
++        public static Vector256<sbyte> And(Vector256<sbyte> left, Vector256<sbyte> right);
++        public static Vector256<ushort> And(Vector256<ushort> left, Vector256<ushort> right);
++        public static Vector256<uint> And(Vector256<uint> left, Vector256<uint> right);
++        public static Vector256<ulong> And(Vector256<ulong> left, Vector256<ulong> right);
++        public static Vector256<byte> AndNot(Vector256<byte> left, Vector256<byte> right);
++        public static Vector256<short> AndNot(Vector256<short> left, Vector256<short> right);
++        public static Vector256<int> AndNot(Vector256<int> left, Vector256<int> right);
++        public static Vector256<long> AndNot(Vector256<long> left, Vector256<long> right);
++        public static Vector256<sbyte> AndNot(Vector256<sbyte> left, Vector256<sbyte> right);
++        public static Vector256<ushort> AndNot(Vector256<ushort> left, Vector256<ushort> right);
++        public static Vector256<uint> AndNot(Vector256<uint> left, Vector256<uint> right);
++        public static Vector256<ulong> AndNot(Vector256<ulong> left, Vector256<ulong> right);
++        public static Vector256<byte> Average(Vector256<byte> left, Vector256<byte> right);
++        public static Vector256<ushort> Average(Vector256<ushort> left, Vector256<ushort> right);
++        public static Vector128<int> Blend(Vector128<int> left, Vector128<int> right, byte control);
++        public static Vector128<uint> Blend(Vector128<uint> left, Vector128<uint> right, byte control);
++        public static Vector256<short> Blend(Vector256<short> left, Vector256<short> right, byte control);
++        public static Vector256<int> Blend(Vector256<int> left, Vector256<int> right, byte control);
++        public static Vector256<ushort> Blend(Vector256<ushort> left, Vector256<ushort> right, byte control);
++        public static Vector256<uint> Blend(Vector256<uint> left, Vector256<uint> right, byte control);
++        public static Vector256<byte> BlendVariable(Vector256<byte> left, Vector256<byte> right, Vector256<byte> mask);
++        public static Vector256<short> BlendVariable(Vector256<short> left, Vector256<short> right, Vector256<short> mask);
++        public static Vector256<int> BlendVariable(Vector256<int> left, Vector256<int> right, Vector256<int> mask);
++        public static Vector256<long> BlendVariable(Vector256<long> left, Vector256<long> right, Vector256<long> mask);
++        public static Vector256<sbyte> BlendVariable(Vector256<sbyte> left, Vector256<sbyte> right, Vector256<sbyte> mask);
++        public static Vector256<ushort> BlendVariable(Vector256<ushort> left, Vector256<ushort> right, Vector256<ushort> mask);
++        public static Vector256<uint> BlendVariable(Vector256<uint> left, Vector256<uint> right, Vector256<uint> mask);
++        public static Vector256<ulong> BlendVariable(Vector256<ulong> left, Vector256<ulong> right, Vector256<ulong> mask);
++        public unsafe static Vector128<byte> BroadcastScalarToVector128(byte* source);
++        public unsafe static Vector128<short> BroadcastScalarToVector128(short* source);
++        public unsafe static Vector128<int> BroadcastScalarToVector128(int* source);
++        public unsafe static Vector128<long> BroadcastScalarToVector128(long* source);
++        public static Vector128<byte> BroadcastScalarToVector128(Vector128<byte> value);
++        public static Vector128<double> BroadcastScalarToVector128(Vector128<double> value);
++        public static Vector128<short> BroadcastScalarToVector128(Vector128<short> value);
++        public static Vector128<int> BroadcastScalarToVector128(Vector128<int> value);
++        public static Vector128<long> BroadcastScalarToVector128(Vector128<long> value);
++        public static Vector128<sbyte> BroadcastScalarToVector128(Vector128<sbyte> value);
++        public static Vector128<float> BroadcastScalarToVector128(Vector128<float> value);
++        public static Vector128<ushort> BroadcastScalarToVector128(Vector128<ushort> value);
++        public static Vector128<uint> BroadcastScalarToVector128(Vector128<uint> value);
++        public static Vector128<ulong> BroadcastScalarToVector128(Vector128<ulong> value);
++        public unsafe static Vector128<sbyte> BroadcastScalarToVector128(sbyte* source);
++        public unsafe static Vector128<ushort> BroadcastScalarToVector128(ushort* source);
++        public unsafe static Vector128<uint> BroadcastScalarToVector128(uint* source);
++        public unsafe static Vector128<ulong> BroadcastScalarToVector128(ulong* source);
++        public unsafe static Vector256<byte> BroadcastScalarToVector256(byte* source);
++        public unsafe static Vector256<short> BroadcastScalarToVector256(short* source);
++        public unsafe static Vector256<int> BroadcastScalarToVector256(int* source);
++        public unsafe static Vector256<long> BroadcastScalarToVector256(long* source);
++        public static Vector256<byte> BroadcastScalarToVector256(Vector128<byte> value);
++        public static Vector256<double> BroadcastScalarToVector256(Vector128<double> value);
++        public static Vector256<short> BroadcastScalarToVector256(Vector128<short> value);
++        public static Vector256<int> BroadcastScalarToVector256(Vector128<int> value);
++        public static Vector256<long> BroadcastScalarToVector256(Vector128<long> value);
++        public static Vector256<sbyte> BroadcastScalarToVector256(Vector128<sbyte> value);
++        public static Vector256<float> BroadcastScalarToVector256(Vector128<float> value);
++        public static Vector256<ushort> BroadcastScalarToVector256(Vector128<ushort> value);
++        public static Vector256<uint> BroadcastScalarToVector256(Vector128<uint> value);
++        public static Vector256<ulong> BroadcastScalarToVector256(Vector128<ulong> value);
++        public unsafe static Vector256<sbyte> BroadcastScalarToVector256(sbyte* source);
++        public unsafe static Vector256<ushort> BroadcastScalarToVector256(ushort* source);
++        public unsafe static Vector256<uint> BroadcastScalarToVector256(uint* source);
++        public unsafe static Vector256<ulong> BroadcastScalarToVector256(ulong* source);
++        public unsafe static Vector256<byte> BroadcastVector128ToVector256(byte* address);
++        public unsafe static Vector256<short> BroadcastVector128ToVector256(short* address);
++        public unsafe static Vector256<int> BroadcastVector128ToVector256(int* address);
++        public unsafe static Vector256<long> BroadcastVector128ToVector256(long* address);
++        public unsafe static Vector256<sbyte> BroadcastVector128ToVector256(sbyte* address);
++        public unsafe static Vector256<ushort> BroadcastVector128ToVector256(ushort* address);
++        public unsafe static Vector256<uint> BroadcastVector128ToVector256(uint* address);
++        public unsafe static Vector256<ulong> BroadcastVector128ToVector256(ulong* address);
++        public static Vector256<byte> CompareEqual(Vector256<byte> left, Vector256<byte> right);
++        public static Vector256<short> CompareEqual(Vector256<short> left, Vector256<short> right);
++        public static Vector256<int> CompareEqual(Vector256<int> left, Vector256<int> right);
++        public static Vector256<long> CompareEqual(Vector256<long> left, Vector256<long> right);
++        public static Vector256<sbyte> CompareEqual(Vector256<sbyte> left, Vector256<sbyte> right);
++        public static Vector256<ushort> CompareEqual(Vector256<ushort> left, Vector256<ushort> right);
++        public static Vector256<uint> CompareEqual(Vector256<uint> left, Vector256<uint> right);
++        public static Vector256<ulong> CompareEqual(Vector256<ulong> left, Vector256<ulong> right);
++        public static Vector256<short> CompareGreaterThan(Vector256<short> left, Vector256<short> right);
++        public static Vector256<int> CompareGreaterThan(Vector256<int> left, Vector256<int> right);
++        public static Vector256<long> CompareGreaterThan(Vector256<long> left, Vector256<long> right);
++        public static Vector256<sbyte> CompareGreaterThan(Vector256<sbyte> left, Vector256<sbyte> right);
++        public static double ConvertToDouble(Vector256<double> value);
++        public static int ConvertToInt32(Vector256<int> value);
++        public static uint ConvertToUInt32(Vector256<uint> value);
++        public static Vector256<short> ConvertToVector256Int16(Vector128<sbyte> value);
++        public static Vector256<int> ConvertToVector256Int32(Vector128<short> value);
++        public static Vector256<int> ConvertToVector256Int32(Vector128<sbyte> value);
++        public static Vector256<long> ConvertToVector256Int64(Vector128<short> value);
++        public static Vector256<long> ConvertToVector256Int64(Vector128<int> value);
++        public static Vector256<long> ConvertToVector256Int64(Vector128<sbyte> value);
++        public static Vector256<ushort> ConvertToVector256UInt16(Vector128<byte> value);
++        public static Vector256<uint> ConvertToVector256UInt32(Vector128<byte> value);
++        public static Vector256<uint> ConvertToVector256UInt32(Vector128<ushort> value);
++        public static Vector256<ulong> ConvertToVector256UInt64(Vector128<byte> value);
++        public static Vector256<ulong> ConvertToVector256UInt64(Vector128<ushort> value);
++        public static Vector256<ulong> ConvertToVector256UInt64(Vector128<uint> value);
++        public unsafe static new void ExtractVector128(byte* address, Vector256<byte> value, byte index);
++        public unsafe static new void ExtractVector128(short* address, Vector256<short> value, byte index);
++        public unsafe static new void ExtractVector128(int* address, Vector256<int> value, byte index);
++        public unsafe static new void ExtractVector128(long* address, Vector256<long> value, byte index);
++        public static new Vector128<byte> ExtractVector128(Vector256<byte> value, byte index);
++        public static new Vector128<short> ExtractVector128(Vector256<short> value, byte index);
++        public static new Vector128<int> ExtractVector128(Vector256<int> value, byte index);
++        public static new Vector128<long> ExtractVector128(Vector256<long> value, byte index);
++        public static new Vector128<sbyte> ExtractVector128(Vector256<sbyte> value, byte index);
++        public static new Vector128<ushort> ExtractVector128(Vector256<ushort> value, byte index);
++        public static new Vector128<uint> ExtractVector128(Vector256<uint> value, byte index);
++        public static new Vector128<ulong> ExtractVector128(Vector256<ulong> value, byte index);
++        public unsafe static new void ExtractVector128(sbyte* address, Vector256<sbyte> value, byte index);
++        public unsafe static new void ExtractVector128(ushort* address, Vector256<ushort> value, byte index);
++        public unsafe static new void ExtractVector128(uint* address, Vector256<uint> value, byte index);
++        public unsafe static new void ExtractVector128(ulong* address, Vector256<ulong> value, byte index);
++        public unsafe static Vector128<double> GatherMaskVector128(Vector128<double> source, double* baseAddress, Vector128<int> index, Vector128<double> mask, byte scale);
++        public unsafe static Vector128<double> GatherMaskVector128(Vector128<double> source, double* baseAddress, Vector128<long> index, Vector128<double> mask, byte scale);
++        public unsafe static Vector128<int> GatherMaskVector128(Vector128<int> source, int* baseAddress, Vector128<int> index, Vector128<int> mask, byte scale);
++        public unsafe static Vector128<int> GatherMaskVector128(Vector128<int> source, int* baseAddress, Vector128<long> index, Vector128<int> mask, byte scale);
++        public unsafe static Vector128<int> GatherMaskVector128(Vector128<int> source, int* baseAddress, Vector256<long> index, Vector128<int> mask, byte scale);
++        public unsafe static Vector128<long> GatherMaskVector128(Vector128<long> source, long* baseAddress, Vector128<int> index, Vector128<long> mask, byte scale);
++        public unsafe static Vector128<long> GatherMaskVector128(Vector128<long> source, long* baseAddress, Vector128<long> index, Vector128<long> mask, byte scale);
++        public unsafe static Vector128<float> GatherMaskVector128(Vector128<float> source, float* baseAddress, Vector128<int> index, Vector128<float> mask, byte scale);
++        public unsafe static Vector128<float> GatherMaskVector128(Vector128<float> source, float* baseAddress, Vector128<long> index, Vector128<float> mask, byte scale);
++        public unsafe static Vector128<float> GatherMaskVector128(Vector128<float> source, float* baseAddress, Vector256<long> index, Vector128<float> mask, byte scale);
++        public unsafe static Vector128<uint> GatherMaskVector128(Vector128<uint> source, uint* baseAddress, Vector128<int> index, Vector128<uint> mask, byte scale);
++        public unsafe static Vector128<uint> GatherMaskVector128(Vector128<uint> source, uint* baseAddress, Vector128<long> index, Vector128<uint> mask, byte scale);
++        public unsafe static Vector128<uint> GatherMaskVector128(Vector128<uint> source, uint* baseAddress, Vector256<long> index, Vector128<uint> mask, byte scale);
++        public unsafe static Vector128<ulong> GatherMaskVector128(Vector128<ulong> source, ulong* baseAddress, Vector128<int> index, Vector128<ulong> mask, byte scale);
++        public unsafe static Vector128<ulong> GatherMaskVector128(Vector128<ulong> source, ulong* baseAddress, Vector128<long> index, Vector128<ulong> mask, byte scale);
++        public unsafe static Vector256<double> GatherMaskVector256(Vector256<double> source, double* baseAddress, Vector128<int> index, Vector256<double> mask, byte scale);
++        public unsafe static Vector256<double> GatherMaskVector256(Vector256<double> source, double* baseAddress, Vector256<long> index, Vector256<double> mask, byte scale);
++        public unsafe static Vector256<int> GatherMaskVector256(Vector256<int> source, int* baseAddress, Vector256<int> index, Vector256<int> mask, byte scale);
++        public unsafe static Vector256<long> GatherMaskVector256(Vector256<long> source, long* baseAddress, Vector128<int> index, Vector256<long> mask, byte scale);
++        public unsafe static Vector256<long> GatherMaskVector256(Vector256<long> source, long* baseAddress, Vector256<long> index, Vector256<long> mask, byte scale);
++        public unsafe static Vector256<float> GatherMaskVector256(Vector256<float> source, float* baseAddress, Vector256<int> index, Vector256<float> mask, byte scale);
++        public unsafe static Vector256<uint> GatherMaskVector256(Vector256<uint> source, uint* baseAddress, Vector256<int> index, Vector256<uint> mask, byte scale);
++        public unsafe static Vector256<ulong> GatherMaskVector256(Vector256<ulong> source, ulong* baseAddress, Vector128<int> index, Vector256<ulong> mask, byte scale);
++        public unsafe static Vector256<ulong> GatherMaskVector256(Vector256<ulong> source, ulong* baseAddress, Vector256<long> index, Vector256<ulong> mask, byte scale);
++        public unsafe static Vector128<double> GatherVector128(double* baseAddress, Vector128<int> index, byte scale);
++        public unsafe static Vector128<double> GatherVector128(double* baseAddress, Vector128<long> index, byte scale);
++        public unsafe static Vector128<int> GatherVector128(int* baseAddress, Vector128<int> index, byte scale);
++        public unsafe static Vector128<int> GatherVector128(int* baseAddress, Vector128<long> index, byte scale);
++        public unsafe static Vector128<int> GatherVector128(int* baseAddress, Vector256<long> index, byte scale);
++        public unsafe static Vector128<long> GatherVector128(long* baseAddress, Vector128<int> index, byte scale);
++        public unsafe static Vector128<long> GatherVector128(long* baseAddress, Vector128<long> index, byte scale);
++        public unsafe static Vector128<float> GatherVector128(float* baseAddress, Vector128<int> index, byte scale);
++        public unsafe static Vector128<float> GatherVector128(float* baseAddress, Vector128<long> index, byte scale);
++        public unsafe static Vector128<float> GatherVector128(float* baseAddress, Vector256<long> index, byte scale);
++        public unsafe static Vector128<uint> GatherVector128(uint* baseAddress, Vector128<int> index, byte scale);
++        public unsafe static Vector128<uint> GatherVector128(uint* baseAddress, Vector128<long> index, byte scale);
++        public unsafe static Vector128<uint> GatherVector128(uint* baseAddress, Vector256<long> index, byte scale);
++        public unsafe static Vector128<ulong> GatherVector128(ulong* baseAddress, Vector128<int> index, byte scale);
++        public unsafe static Vector128<ulong> GatherVector128(ulong* baseAddress, Vector128<long> index, byte scale);
++        public unsafe static Vector256<double> GatherVector256(double* baseAddress, Vector128<int> index, byte scale);
++        public unsafe static Vector256<double> GatherVector256(double* baseAddress, Vector256<long> index, byte scale);
++        public unsafe static Vector256<int> GatherVector256(int* baseAddress, Vector256<int> index, byte scale);
++        public unsafe static Vector256<long> GatherVector256(long* baseAddress, Vector128<int> index, byte scale);
++        public unsafe static Vector256<long> GatherVector256(long* baseAddress, Vector256<long> index, byte scale);
++        public unsafe static Vector256<float> GatherVector256(float* baseAddress, Vector256<int> index, byte scale);
++        public unsafe static Vector256<uint> GatherVector256(uint* baseAddress, Vector256<int> index, byte scale);
++        public unsafe static Vector256<ulong> GatherVector256(ulong* baseAddress, Vector128<int> index, byte scale);
++        public unsafe static Vector256<ulong> GatherVector256(ulong* baseAddress, Vector256<long> index, byte scale);
++        public static Vector256<short> HorizontalAdd(Vector256<short> left, Vector256<short> right);
++        public static Vector256<int> HorizontalAdd(Vector256<int> left, Vector256<int> right);
++        public static Vector256<short> HorizontalAddSaturate(Vector256<short> left, Vector256<short> right);
++        public static Vector256<short> HorizontalSubtract(Vector256<short> left, Vector256<short> right);
++        public static Vector256<int> HorizontalSubtract(Vector256<int> left, Vector256<int> right);
++        public static Vector256<short> HorizontalSubtractSaturate(Vector256<short> left, Vector256<short> right);
++        public unsafe static new Vector256<byte> InsertVector128(Vector256<byte> value, byte* address, byte index);
++        public static new Vector256<byte> InsertVector128(Vector256<byte> value, Vector128<byte> data, byte index);
++        public unsafe static new Vector256<short> InsertVector128(Vector256<short> value, short* address, byte index);
++        public static new Vector256<short> InsertVector128(Vector256<short> value, Vector128<short> data, byte index);
++        public unsafe static new Vector256<int> InsertVector128(Vector256<int> value, int* address, byte index);
++        public static new Vector256<int> InsertVector128(Vector256<int> value, Vector128<int> data, byte index);
++        public unsafe static new Vector256<long> InsertVector128(Vector256<long> value, long* address, byte index);
++        public static new Vector256<long> InsertVector128(Vector256<long> value, Vector128<long> data, byte index);
++        public static new Vector256<sbyte> InsertVector128(Vector256<sbyte> value, Vector128<sbyte> data, byte index);
++        public unsafe static new Vector256<sbyte> InsertVector128(Vector256<sbyte> value, sbyte* address, byte index);
++        public static new Vector256<ushort> InsertVector128(Vector256<ushort> value, Vector128<ushort> data, byte index);
++        public unsafe static new Vector256<ushort> InsertVector128(Vector256<ushort> value, ushort* address, byte index);
++        public static new Vector256<uint> InsertVector128(Vector256<uint> value, Vector128<uint> data, byte index);
++        public unsafe static new Vector256<uint> InsertVector128(Vector256<uint> value, uint* address, byte index);
++        public static new Vector256<ulong> InsertVector128(Vector256<ulong> value, Vector128<ulong> data, byte index);
++        public unsafe static new Vector256<ulong> InsertVector128(Vector256<ulong> value, ulong* address, byte index);
++        public unsafe static Vector256<byte> LoadAlignedVector256NonTemporal(byte* address);
++        public unsafe static Vector256<short> LoadAlignedVector256NonTemporal(short* address);
++        public unsafe static Vector256<int> LoadAlignedVector256NonTemporal(int* address);
++        public unsafe static Vector256<long> LoadAlignedVector256NonTemporal(long* address);
++        public unsafe static Vector256<sbyte> LoadAlignedVector256NonTemporal(sbyte* address);
++        public unsafe static Vector256<ushort> LoadAlignedVector256NonTemporal(ushort* address);
++        public unsafe static Vector256<uint> LoadAlignedVector256NonTemporal(uint* address);
++        public unsafe static Vector256<ulong> LoadAlignedVector256NonTemporal(ulong* address);
++        public unsafe static Vector128<int> MaskLoad(int* address, Vector128<int> mask);
++        public unsafe static Vector256<int> MaskLoad(int* address, Vector256<int> mask);
++        public unsafe static Vector128<long> MaskLoad(long* address, Vector128<long> mask);
++        public unsafe static Vector256<long> MaskLoad(long* address, Vector256<long> mask);
++        public unsafe static Vector128<uint> MaskLoad(uint* address, Vector128<uint> mask);
++        public unsafe static Vector256<uint> MaskLoad(uint* address, Vector256<uint> mask);
++        public unsafe static Vector128<ulong> MaskLoad(ulong* address, Vector128<ulong> mask);
++        public unsafe static Vector256<ulong> MaskLoad(ulong* address, Vector256<ulong> mask);
++        public unsafe static void MaskStore(int* address, Vector128<int> mask, Vector128<int> source);
++        public unsafe static void MaskStore(int* address, Vector256<int> mask, Vector256<int> source);
++        public unsafe static void MaskStore(long* address, Vector128<long> mask, Vector128<long> source);
++        public unsafe static void MaskStore(long* address, Vector256<long> mask, Vector256<long> source);
++        public unsafe static void MaskStore(uint* address, Vector128<uint> mask, Vector128<uint> source);
++        public unsafe static void MaskStore(uint* address, Vector256<uint> mask, Vector256<uint> source);
++        public unsafe static void MaskStore(ulong* address, Vector128<ulong> mask, Vector128<ulong> source);
++        public unsafe static void MaskStore(ulong* address, Vector256<ulong> mask, Vector256<ulong> source);
++        public static Vector256<byte> Max(Vector256<byte> left, Vector256<byte> right);
++        public static Vector256<short> Max(Vector256<short> left, Vector256<short> right);
++        public static Vector256<int> Max(Vector256<int> left, Vector256<int> right);
++        public static Vector256<sbyte> Max(Vector256<sbyte> left, Vector256<sbyte> right);
++        public static Vector256<ushort> Max(Vector256<ushort> left, Vector256<ushort> right);
++        public static Vector256<uint> Max(Vector256<uint> left, Vector256<uint> right);
++        public static Vector256<byte> Min(Vector256<byte> left, Vector256<byte> right);
++        public static Vector256<short> Min(Vector256<short> left, Vector256<short> right);
++        public static Vector256<int> Min(Vector256<int> left, Vector256<int> right);
++        public static Vector256<sbyte> Min(Vector256<sbyte> left, Vector256<sbyte> right);
++        public static Vector256<ushort> Min(Vector256<ushort> left, Vector256<ushort> right);
++        public static Vector256<uint> Min(Vector256<uint> left, Vector256<uint> right);
++        public static int MoveMask(Vector256<byte> value);
++        public static int MoveMask(Vector256<sbyte> value);
++        public static Vector256<ushort> MultipleSumAbsoluteDifferences(Vector256<byte> left, Vector256<byte> right, byte mask);
++        public static Vector256<long> Multiply(Vector256<int> left, Vector256<int> right);
++        public static Vector256<ulong> Multiply(Vector256<uint> left, Vector256<uint> right);
++        public static Vector256<short> MultiplyAddAdjacent(Vector256<byte> left, Vector256<sbyte> right);
++        public static Vector256<int> MultiplyAddAdjacent(Vector256<short> left, Vector256<short> right);
++        public static Vector256<short> MultiplyHigh(Vector256<short> left, Vector256<short> right);
++        public static Vector256<ushort> MultiplyHigh(Vector256<ushort> left, Vector256<ushort> right);
++        public static Vector256<short> MultiplyHighRoundScale(Vector256<short> left, Vector256<short> right);
++        public static Vector256<short> MultiplyLow(Vector256<short> left, Vector256<short> right);
++        public static Vector256<int> MultiplyLow(Vector256<int> left, Vector256<int> right);
++        public static Vector256<ushort> MultiplyLow(Vector256<ushort> left, Vector256<ushort> right);
++        public static Vector256<uint> MultiplyLow(Vector256<uint> left, Vector256<uint> right);
++        public static Vector256<byte> Or(Vector256<byte> left, Vector256<byte> right);
++        public static Vector256<short> Or(Vector256<short> left, Vector256<short> right);
++        public static Vector256<int> Or(Vector256<int> left, Vector256<int> right);
++        public static Vector256<long> Or(Vector256<long> left, Vector256<long> right);
++        public static Vector256<sbyte> Or(Vector256<sbyte> left, Vector256<sbyte> right);
++        public static Vector256<ushort> Or(Vector256<ushort> left, Vector256<ushort> right);
++        public static Vector256<uint> Or(Vector256<uint> left, Vector256<uint> right);
++        public static Vector256<ulong> Or(Vector256<ulong> left, Vector256<ulong> right);
++        public static Vector256<sbyte> PackSignedSaturate(Vector256<short> left, Vector256<short> right);
++        public static Vector256<short> PackSignedSaturate(Vector256<int> left, Vector256<int> right);
++        public static Vector256<byte> PackUnsignedSaturate(Vector256<short> left, Vector256<short> right);
++        public static Vector256<ushort> PackUnsignedSaturate(Vector256<int> left, Vector256<int> right);
++        public static new Vector256<byte> Permute2x128(Vector256<byte> left, Vector256<byte> right, byte control);
++        public static new Vector256<short> Permute2x128(Vector256<short> left, Vector256<short> right, byte control);
++        public static new Vector256<int> Permute2x128(Vector256<int> left, Vector256<int> right, byte control);
++        public static new Vector256<long> Permute2x128(Vector256<long> left, Vector256<long> right, byte control);
++        public static new Vector256<sbyte> Permute2x128(Vector256<sbyte> left, Vector256<sbyte> right, byte control);
++        public static new Vector256<ushort> Permute2x128(Vector256<ushort> left, Vector256<ushort> right, byte control);
++        public static new Vector256<uint> Permute2x128(Vector256<uint> left, Vector256<uint> right, byte control);
++        public static new Vector256<ulong> Permute2x128(Vector256<ulong> left, Vector256<ulong> right, byte control);
++        public static Vector256<double> Permute4x64(Vector256<double> value, byte control);
++        public static Vector256<long> Permute4x64(Vector256<long> value, byte control);
++        public static Vector256<ulong> Permute4x64(Vector256<ulong> value, byte control);
++        public static Vector256<int> PermuteVar8x32(Vector256<int> left, Vector256<int> control);
++        public static Vector256<float> PermuteVar8x32(Vector256<float> left, Vector256<int> control);
++        public static Vector256<uint> PermuteVar8x32(Vector256<uint> left, Vector256<uint> control);
++        public static Vector256<short> ShiftLeftLogical(Vector256<short> value, byte count);
++        public static Vector256<short> ShiftLeftLogical(Vector256<short> value, Vector128<short> count);
++        public static Vector256<int> ShiftLeftLogical(Vector256<int> value, byte count);
++        public static Vector256<int> ShiftLeftLogical(Vector256<int> value, Vector128<int> count);
++        public static Vector256<long> ShiftLeftLogical(Vector256<long> value, byte count);
++        public static Vector256<long> ShiftLeftLogical(Vector256<long> value, Vector128<long> count);
++        public static Vector256<ushort> ShiftLeftLogical(Vector256<ushort> value, byte count);
++        public static Vector256<ushort> ShiftLeftLogical(Vector256<ushort> value, Vector128<ushort> count);
++        public static Vector256<uint> ShiftLeftLogical(Vector256<uint> value, byte count);
++        public static Vector256<uint> ShiftLeftLogical(Vector256<uint> value, Vector128<uint> count);
++        public static Vector256<ulong> ShiftLeftLogical(Vector256<ulong> value, byte count);
++        public static Vector256<ulong> ShiftLeftLogical(Vector256<ulong> value, Vector128<ulong> count);
++        public static Vector256<byte> ShiftLeftLogical128BitLane(Vector256<byte> value, byte numBytes);
++        public static Vector256<short> ShiftLeftLogical128BitLane(Vector256<short> value, byte numBytes);
++        public static Vector256<int> ShiftLeftLogical128BitLane(Vector256<int> value, byte numBytes);
++        public static Vector256<long> ShiftLeftLogical128BitLane(Vector256<long> value, byte numBytes);
++        public static Vector256<sbyte> ShiftLeftLogical128BitLane(Vector256<sbyte> value, byte numBytes);
++        public static Vector256<ushort> ShiftLeftLogical128BitLane(Vector256<ushort> value, byte numBytes);
++        public static Vector256<uint> ShiftLeftLogical128BitLane(Vector256<uint> value, byte numBytes);
++        public static Vector256<ulong> ShiftLeftLogical128BitLane(Vector256<ulong> value, byte numBytes);
++        public static Vector128<int> ShiftLeftLogicalVariable(Vector128<int> value, Vector128<uint> count);
++        public static Vector128<long> ShiftLeftLogicalVariable(Vector128<long> value, Vector128<ulong> count);
++        public static Vector128<uint> ShiftLeftLogicalVariable(Vector128<uint> value, Vector128<uint> count);
++        public static Vector128<ulong> ShiftLeftLogicalVariable(Vector128<ulong> value, Vector128<ulong> count);
++        public static Vector256<int> ShiftLeftLogicalVariable(Vector256<int> value, Vector256<uint> count);
++        public static Vector256<long> ShiftLeftLogicalVariable(Vector256<long> value, Vector256<ulong> count);
++        public static Vector256<uint> ShiftLeftLogicalVariable(Vector256<uint> value, Vector256<uint> count);
++        public static Vector256<ulong> ShiftLeftLogicalVariable(Vector256<ulong> value, Vector256<ulong> count);
++        public static Vector256<short> ShiftRightArithmetic(Vector256<short> value, byte count);
++        public static Vector256<short> ShiftRightArithmetic(Vector256<short> value, Vector128<short> count);
++        public static Vector256<int> ShiftRightArithmetic(Vector256<int> value, byte count);
++        public static Vector256<int> ShiftRightArithmetic(Vector256<int> value, Vector128<int> count);
++        public static Vector128<int> ShiftRightArithmeticVariable(Vector128<int> value, Vector128<uint> count);
++        public static Vector256<int> ShiftRightArithmeticVariable(Vector256<int> value, Vector256<uint> count);
++        public static Vector256<short> ShiftRightLogical(Vector256<short> value, byte count);
++        public static Vector256<short> ShiftRightLogical(Vector256<short> value, Vector128<short> count);
++        public static Vector256<int> ShiftRightLogical(Vector256<int> value, byte count);
++        public static Vector256<int> ShiftRightLogical(Vector256<int> value, Vector128<int> count);
++        public static Vector256<long> ShiftRightLogical(Vector256<long> value, byte count);
++        public static Vector256<long> ShiftRightLogical(Vector256<long> value, Vector128<long> count);
++        public static Vector256<ushort> ShiftRightLogical(Vector256<ushort> value, byte count);
++        public static Vector256<ushort> ShiftRightLogical(Vector256<ushort> value, Vector128<ushort> count);
++        public static Vector256<uint> ShiftRightLogical(Vector256<uint> value, byte count);
++        public static Vector256<uint> ShiftRightLogical(Vector256<uint> value, Vector128<uint> count);
++        public static Vector256<ulong> ShiftRightLogical(Vector256<ulong> value, byte count);
++        public static Vector256<ulong> ShiftRightLogical(Vector256<ulong> value, Vector128<ulong> count);
++        public static Vector256<byte> ShiftRightLogical128BitLane(Vector256<byte> value, byte numBytes);
++        public static Vector256<short> ShiftRightLogical128BitLane(Vector256<short> value, byte numBytes);
++        public static Vector256<int> ShiftRightLogical128BitLane(Vector256<int> value, byte numBytes);
++        public static Vector256<long> ShiftRightLogical128BitLane(Vector256<long> value, byte numBytes);
++        public static Vector256<sbyte> ShiftRightLogical128BitLane(Vector256<sbyte> value, byte numBytes);
++        public static Vector256<ushort> ShiftRightLogical128BitLane(Vector256<ushort> value, byte numBytes);
++        public static Vector256<uint> ShiftRightLogical128BitLane(Vector256<uint> value, byte numBytes);
++        public static Vector256<ulong> ShiftRightLogical128BitLane(Vector256<ulong> value, byte numBytes);
++        public static Vector128<int> ShiftRightLogicalVariable(Vector128<int> value, Vector128<uint> count);
++        public static Vector128<long> ShiftRightLogicalVariable(Vector128<long> value, Vector128<ulong> count);
++        public static Vector128<uint> ShiftRightLogicalVariable(Vector128<uint> value, Vector128<uint> count);
++        public static Vector128<ulong> ShiftRightLogicalVariable(Vector128<ulong> value, Vector128<ulong> count);
++        public static Vector256<int> ShiftRightLogicalVariable(Vector256<int> value, Vector256<uint> count);
++        public static Vector256<long> ShiftRightLogicalVariable(Vector256<long> value, Vector256<ulong> count);
++        public static Vector256<uint> ShiftRightLogicalVariable(Vector256<uint> value, Vector256<uint> count);
++        public static Vector256<ulong> ShiftRightLogicalVariable(Vector256<ulong> value, Vector256<ulong> count);
++        public static Vector256<byte> Shuffle(Vector256<byte> value, Vector256<byte> mask);
++        public static Vector256<int> Shuffle(Vector256<int> value, byte control);
++        public static Vector256<sbyte> Shuffle(Vector256<sbyte> value, Vector256<sbyte> mask);
++        public static Vector256<uint> Shuffle(Vector256<uint> value, byte control);
++        public static Vector256<short> ShuffleHigh(Vector256<short> value, byte control);
++        public static Vector256<ushort> ShuffleHigh(Vector256<ushort> value, byte control);
++        public static Vector256<short> ShuffleLow(Vector256<short> value, byte control);
++        public static Vector256<ushort> ShuffleLow(Vector256<ushort> value, byte control);
++        public static Vector256<short> Sign(Vector256<short> left, Vector256<short> right);
++        public static Vector256<int> Sign(Vector256<int> left, Vector256<int> right);
++        public static Vector256<sbyte> Sign(Vector256<sbyte> left, Vector256<sbyte> right);
++        public static Vector256<byte> Subtract(Vector256<byte> left, Vector256<byte> right);
++        public static Vector256<short> Subtract(Vector256<short> left, Vector256<short> right);
++        public static Vector256<int> Subtract(Vector256<int> left, Vector256<int> right);
++        public static Vector256<long> Subtract(Vector256<long> left, Vector256<long> right);
++        public static Vector256<sbyte> Subtract(Vector256<sbyte> left, Vector256<sbyte> right);
++        public static Vector256<ushort> Subtract(Vector256<ushort> left, Vector256<ushort> right);
++        public static Vector256<uint> Subtract(Vector256<uint> left, Vector256<uint> right);
++        public static Vector256<ulong> Subtract(Vector256<ulong> left, Vector256<ulong> right);
++        public static Vector256<byte> SubtractSaturate(Vector256<byte> left, Vector256<byte> right);
++        public static Vector256<short> SubtractSaturate(Vector256<short> left, Vector256<short> right);
++        public static Vector256<sbyte> SubtractSaturate(Vector256<sbyte> left, Vector256<sbyte> right);
++        public static Vector256<ushort> SubtractSaturate(Vector256<ushort> left, Vector256<ushort> right);
++        public static Vector256<ushort> SumAbsoluteDifferences(Vector256<byte> left, Vector256<byte> right);
++        public static Vector256<byte> UnpackHigh(Vector256<byte> left, Vector256<byte> right);
++        public static Vector256<short> UnpackHigh(Vector256<short> left, Vector256<short> right);
++        public static Vector256<int> UnpackHigh(Vector256<int> left, Vector256<int> right);
++        public static Vector256<long> UnpackHigh(Vector256<long> left, Vector256<long> right);
++        public static Vector256<sbyte> UnpackHigh(Vector256<sbyte> left, Vector256<sbyte> right);
++        public static Vector256<ushort> UnpackHigh(Vector256<ushort> left, Vector256<ushort> right);
++        public static Vector256<uint> UnpackHigh(Vector256<uint> left, Vector256<uint> right);
++        public static Vector256<ulong> UnpackHigh(Vector256<ulong> left, Vector256<ulong> right);
++        public static Vector256<byte> UnpackLow(Vector256<byte> left, Vector256<byte> right);
++        public static Vector256<short> UnpackLow(Vector256<short> left, Vector256<short> right);
++        public static Vector256<int> UnpackLow(Vector256<int> left, Vector256<int> right);
++        public static Vector256<long> UnpackLow(Vector256<long> left, Vector256<long> right);
++        public static Vector256<sbyte> UnpackLow(Vector256<sbyte> left, Vector256<sbyte> right);
++        public static Vector256<ushort> UnpackLow(Vector256<ushort> left, Vector256<ushort> right);
++        public static Vector256<uint> UnpackLow(Vector256<uint> left, Vector256<uint> right);
++        public static Vector256<ulong> UnpackLow(Vector256<ulong> left, Vector256<ulong> right);
++        public static Vector256<byte> Xor(Vector256<byte> left, Vector256<byte> right);
++        public static Vector256<short> Xor(Vector256<short> left, Vector256<short> right);
++        public static Vector256<int> Xor(Vector256<int> left, Vector256<int> right);
++        public static Vector256<long> Xor(Vector256<long> left, Vector256<long> right);
++        public static Vector256<sbyte> Xor(Vector256<sbyte> left, Vector256<sbyte> right);
++        public static Vector256<ushort> Xor(Vector256<ushort> left, Vector256<ushort> right);
++        public static Vector256<uint> Xor(Vector256<uint> left, Vector256<uint> right);
++        public static Vector256<ulong> Xor(Vector256<ulong> left, Vector256<ulong> right);
++    }
++    public abstract class Bmi1 {
++        public static bool IsSupported { get; }
++        public static uint AndNot(uint left, uint right);
++        public static ulong AndNot(ulong left, ulong right);
++        public static uint BitFieldExtract(uint value, byte start, byte length);
++        public static uint BitFieldExtract(uint value, ushort control);
++        public static ulong BitFieldExtract(ulong value, byte start, byte length);
++        public static ulong BitFieldExtract(ulong value, ushort control);
++        public static uint ExtractLowestSetBit(uint value);
++        public static ulong ExtractLowestSetBit(ulong value);
++        public static uint GetMaskUpToLowestSetBit(uint value);
++        public static ulong GetMaskUpToLowestSetBit(ulong value);
++        public static uint ResetLowestSetBit(uint value);
++        public static ulong ResetLowestSetBit(ulong value);
++        public static uint TrailingZeroCount(uint value);
++        public static ulong TrailingZeroCount(ulong value);
++        public abstract class X64 {
++            public static bool IsSupported { get; }
++            public static ulong AndNot(ulong left, ulong right);
++            public static ulong BitFieldExtract(ulong value, byte start, byte length);
++            public static ulong BitFieldExtract(ulong value, ushort control);
++            public static ulong ExtractLowestSetBit(ulong value);
++            public static ulong GetMaskUpToLowestSetBit(ulong value);
++            public static ulong ResetLowestSetBit(ulong value);
++            public static ulong TrailingZeroCount(ulong value);
++        }
++    }
++    public abstract class Bmi2 {
++        public static bool IsSupported { get; }
++        public unsafe static uint MultiplyNoFlags(uint left, uint right, uint* high);
++        public unsafe static ulong MultiplyNoFlags(ulong left, ulong right, ulong* high);
++        public static uint ParallelBitDeposit(uint value, uint mask);
++        public static ulong ParallelBitDeposit(ulong value, ulong mask);
++        public static uint ParallelBitExtract(uint value, uint mask);
++        public static ulong ParallelBitExtract(ulong value, ulong mask);
++        public static uint ZeroHighBits(uint value, uint index);
++        public static ulong ZeroHighBits(ulong value, ulong index);
++        public abstract class X64 {
++            public static bool IsSupported { get; }
++            public unsafe static ulong MultiplyNoFlags(ulong left, ulong right, ulong* high);
++            public static ulong ParallelBitDeposit(ulong value, ulong mask);
++            public static ulong ParallelBitExtract(ulong value, ulong mask);
++            public static ulong ZeroHighBits(ulong value, ulong index);
++        }
++    }
++    public enum FloatComparisonMode : byte {
++        EqualOrderedNonSignaling = (byte)0,
++        EqualOrderedSignaling = (byte)16,
++        EqualUnorderedNonSignaling = (byte)8,
++        EqualUnorderedSignaling = (byte)24,
++        FalseOrderedNonSignaling = (byte)11,
++        FalseOrderedSignaling = (byte)27,
++        GreaterThanOrderedNonSignaling = (byte)30,
++        GreaterThanOrderedSignaling = (byte)14,
++        GreaterThanOrEqualOrderedNonSignaling = (byte)29,
++        GreaterThanOrEqualOrderedSignaling = (byte)13,
++        LessThanOrderedNonSignaling = (byte)17,
++        LessThanOrderedSignaling = (byte)1,
++        LessThanOrEqualOrderedNonSignaling = (byte)18,
++        LessThanOrEqualOrderedSignaling = (byte)2,
++        NotEqualOrderedNonSignaling = (byte)12,
++        NotEqualOrderedSignaling = (byte)28,
++        NotEqualUnorderedNonSignaling = (byte)4,
++        NotEqualUnorderedSignaling = (byte)20,
++        NotGreaterThanOrEqualUnorderedNonSignaling = (byte)25,
++        NotGreaterThanOrEqualUnorderedSignaling = (byte)9,
++        NotGreaterThanUnorderedNonSignaling = (byte)26,
++        NotGreaterThanUnorderedSignaling = (byte)10,
++        NotLessThanOrEqualUnorderedNonSignaling = (byte)22,
++        NotLessThanOrEqualUnorderedSignaling = (byte)6,
++        NotLessThanUnorderedNonSignaling = (byte)21,
++        NotLessThanUnorderedSignaling = (byte)5,
++        OrderedNonSignaling = (byte)7,
++        OrderedSignaling = (byte)23,
++        TrueUnorderedNonSignaling = (byte)15,
++        TrueUnorderedSignaling = (byte)31,
++        UnorderedNonSignaling = (byte)3,
++        UnorderedSignaling = (byte)19,
++    }
++    public abstract class Fma : Avx {
++        public static new bool IsSupported { get; }
++        public static Vector128<double> MultiplyAdd(Vector128<double> a, Vector128<double> b, Vector128<double> c);
++        public static Vector128<float> MultiplyAdd(Vector128<float> a, Vector128<float> b, Vector128<float> c);
++        public static Vector256<double> MultiplyAdd(Vector256<double> a, Vector256<double> b, Vector256<double> c);
++        public static Vector256<float> MultiplyAdd(Vector256<float> a, Vector256<float> b, Vector256<float> c);
++        public static Vector128<double> MultiplyAddNegated(Vector128<double> a, Vector128<double> b, Vector128<double> c);
++        public static Vector128<float> MultiplyAddNegated(Vector128<float> a, Vector128<float> b, Vector128<float> c);
++        public static Vector256<double> MultiplyAddNegated(Vector256<double> a, Vector256<double> b, Vector256<double> c);
++        public static Vector256<float> MultiplyAddNegated(Vector256<float> a, Vector256<float> b, Vector256<float> c);
++        public static Vector128<double> MultiplyAddNegatedScalar(Vector128<double> a, Vector128<double> b, Vector128<double> c);
++        public static Vector128<float> MultiplyAddNegatedScalar(Vector128<float> a, Vector128<float> b, Vector128<float> c);
++        public static Vector128<double> MultiplyAddScalar(Vector128<double> a, Vector128<double> b, Vector128<double> c);
++        public static Vector128<float> MultiplyAddScalar(Vector128<float> a, Vector128<float> b, Vector128<float> c);
++        public static Vector128<double> MultiplyAddSubtract(Vector128<double> a, Vector128<double> b, Vector128<double> c);
++        public static Vector128<float> MultiplyAddSubtract(Vector128<float> a, Vector128<float> b, Vector128<float> c);
++        public static Vector256<double> MultiplyAddSubtract(Vector256<double> a, Vector256<double> b, Vector256<double> c);
++        public static Vector256<float> MultiplyAddSubtract(Vector256<float> a, Vector256<float> b, Vector256<float> c);
++        public static Vector128<double> MultiplySubtract(Vector128<double> a, Vector128<double> b, Vector128<double> c);
++        public static Vector128<float> MultiplySubtract(Vector128<float> a, Vector128<float> b, Vector128<float> c);
++        public static Vector256<double> MultiplySubtract(Vector256<double> a, Vector256<double> b, Vector256<double> c);
++        public static Vector256<float> MultiplySubtract(Vector256<float> a, Vector256<float> b, Vector256<float> c);
++        public static Vector128<double> MultiplySubtractAdd(Vector128<double> a, Vector128<double> b, Vector128<double> c);
++        public static Vector128<float> MultiplySubtractAdd(Vector128<float> a, Vector128<float> b, Vector128<float> c);
++        public static Vector256<double> MultiplySubtractAdd(Vector256<double> a, Vector256<double> b, Vector256<double> c);
++        public static Vector256<float> MultiplySubtractAdd(Vector256<float> a, Vector256<float> b, Vector256<float> c);
++        public static Vector128<double> MultiplySubtractNegated(Vector128<double> a, Vector128<double> b, Vector128<double> c);
++        public static Vector128<float> MultiplySubtractNegated(Vector128<float> a, Vector128<float> b, Vector128<float> c);
++        public static Vector256<double> MultiplySubtractNegated(Vector256<double> a, Vector256<double> b, Vector256<double> c);
++        public static Vector256<float> MultiplySubtractNegated(Vector256<float> a, Vector256<float> b, Vector256<float> c);
++        public static Vector128<double> MultiplySubtractNegatedScalar(Vector128<double> a, Vector128<double> b, Vector128<double> c);
++        public static Vector128<float> MultiplySubtractNegatedScalar(Vector128<float> a, Vector128<float> b, Vector128<float> c);
++        public static Vector128<double> MultiplySubtractScalar(Vector128<double> a, Vector128<double> b, Vector128<double> c);
++        public static Vector128<float> MultiplySubtractScalar(Vector128<float> a, Vector128<float> b, Vector128<float> c);
++    }
++    public abstract class Lzcnt {
++        public static bool IsSupported { get; }
++        public static uint LeadingZeroCount(uint value);
++        public static ulong LeadingZeroCount(ulong value);
++        public abstract class X64 {
++            public static bool IsSupported { get; }
++            public static ulong LeadingZeroCount(ulong value);
++        }
++    }
++    public abstract class Pclmulqdq : Sse2 {
++        public static new bool IsSupported { get; }
++        public static Vector128<long> CarrylessMultiply(Vector128<long> left, Vector128<long> right, byte control);
++        public static Vector128<ulong> CarrylessMultiply(Vector128<ulong> left, Vector128<ulong> right, byte control);
++    }
++    public abstract class Popcnt : Sse42 {
++        public static new bool IsSupported { get; }
++        public static uint PopCount(uint value);
++        public static ulong PopCount(ulong value);
++        public abstract class X64 : Sse41.X64 {
++            public static new bool IsSupported { get; }
++            public static ulong PopCount(ulong value);
++        }
++    }
++    public abstract class Sse {
++        public static bool IsSupported { get; }
++        public static Vector128<float> Add(Vector128<float> left, Vector128<float> right);
++        public static Vector128<float> AddScalar(Vector128<float> left, Vector128<float> right);
++        public static Vector128<float> And(Vector128<float> left, Vector128<float> right);
++        public static Vector128<float> AndNot(Vector128<float> left, Vector128<float> right);
++        public static Vector128<float> CompareEqual(Vector128<float> left, Vector128<float> right);
++        public static bool CompareEqualOrderedScalar(Vector128<float> left, Vector128<float> right);
++        public static Vector128<float> CompareEqualScalar(Vector128<float> left, Vector128<float> right);
++        public static bool CompareEqualUnorderedScalar(Vector128<float> left, Vector128<float> right);
++        public static Vector128<float> CompareGreaterThan(Vector128<float> left, Vector128<float> right);
++        public static bool CompareGreaterThanOrderedScalar(Vector128<float> left, Vector128<float> right);
++        public static Vector128<float> CompareGreaterThanOrEqual(Vector128<float> left, Vector128<float> right);
++        public static bool CompareGreaterThanOrEqualOrderedScalar(Vector128<float> left, Vector128<float> right);
++        public static Vector128<float> CompareGreaterThanOrEqualScalar(Vector128<float> left, Vector128<float> right);
++        public static bool CompareGreaterThanOrEqualUnorderedScalar(Vector128<float> left, Vector128<float> right);
++        public static Vector128<float> CompareGreaterThanScalar(Vector128<float> left, Vector128<float> right);
++        public static bool CompareGreaterThanUnorderedScalar(Vector128<float> left, Vector128<float> right);
++        public static Vector128<float> CompareLessThan(Vector128<float> left, Vector128<float> right);
++        public static bool CompareLessThanOrderedScalar(Vector128<float> left, Vector128<float> right);
++        public static Vector128<float> CompareLessThanOrEqual(Vector128<float> left, Vector128<float> right);
++        public static bool CompareLessThanOrEqualOrderedScalar(Vector128<float> left, Vector128<float> right);
++        public static Vector128<float> CompareLessThanOrEqualScalar(Vector128<float> left, Vector128<float> right);
++        public static bool CompareLessThanOrEqualUnorderedScalar(Vector128<float> left, Vector128<float> right);
++        public static Vector128<float> CompareLessThanScalar(Vector128<float> left, Vector128<float> right);
++        public static bool CompareLessThanUnorderedScalar(Vector128<float> left, Vector128<float> right);
++        public static Vector128<float> CompareNotEqual(Vector128<float> left, Vector128<float> right);
++        public static bool CompareNotEqualOrderedScalar(Vector128<float> left, Vector128<float> right);
++        public static Vector128<float> CompareNotEqualScalar(Vector128<float> left, Vector128<float> right);
++        public static bool CompareNotEqualUnorderedScalar(Vector128<float> left, Vector128<float> right);
++        public static Vector128<float> CompareNotGreaterThan(Vector128<float> left, Vector128<float> right);
++        public static Vector128<float> CompareNotGreaterThanOrEqual(Vector128<float> left, Vector128<float> right);
++        public static Vector128<float> CompareNotGreaterThanOrEqualScalar(Vector128<float> left, Vector128<float> right);
++        public static Vector128<float> CompareNotGreaterThanScalar(Vector128<float> left, Vector128<float> right);
++        public static Vector128<float> CompareNotLessThan(Vector128<float> left, Vector128<float> right);
++        public static Vector128<float> CompareNotLessThanOrEqual(Vector128<float> left, Vector128<float> right);
++        public static Vector128<float> CompareNotLessThanOrEqualScalar(Vector128<float> left, Vector128<float> right);
++        public static Vector128<float> CompareNotLessThanScalar(Vector128<float> left, Vector128<float> right);
++        public static Vector128<float> CompareOrdered(Vector128<float> left, Vector128<float> right);
++        public static Vector128<float> CompareOrderedScalar(Vector128<float> left, Vector128<float> right);
++        public static Vector128<float> CompareUnordered(Vector128<float> left, Vector128<float> right);
++        public static Vector128<float> CompareUnorderedScalar(Vector128<float> left, Vector128<float> right);
++        public static Vector128<float> ConvertScalarToVector128Single(Vector128<float> upper, int value);
++        public static Vector128<float> ConvertScalarToVector128Single(Vector128<float> upper, long value);
++        public static int ConvertToInt32(Vector128<float> value);
++        public static int ConvertToInt32WithTruncation(Vector128<float> value);
++        public static long ConvertToInt64(Vector128<float> value);
++        public static long ConvertToInt64WithTruncation(Vector128<float> value);
++        public static float ConvertToSingle(Vector128<float> value);
++        public static Vector128<float> Divide(Vector128<float> left, Vector128<float> right);
++        public static Vector128<float> DivideScalar(Vector128<float> left, Vector128<float> right);
++        public unsafe static Vector128<float> LoadAlignedVector128(float* address);
++        public unsafe static Vector128<float> LoadHigh(Vector128<float> lower, float* address);
++        public unsafe static Vector128<float> LoadLow(Vector128<float> upper, float* address);
++        public unsafe static Vector128<float> LoadScalarVector128(float* address);
++        public unsafe static Vector128<float> LoadVector128(float* address);
++        public static Vector128<float> Max(Vector128<float> left, Vector128<float> right);
++        public static Vector128<float> MaxScalar(Vector128<float> left, Vector128<float> right);
++        public static Vector128<float> Min(Vector128<float> left, Vector128<float> right);
++        public static Vector128<float> MinScalar(Vector128<float> left, Vector128<float> right);
++        public static Vector128<float> MoveHighToLow(Vector128<float> left, Vector128<float> right);
++        public static Vector128<float> MoveLowToHigh(Vector128<float> left, Vector128<float> right);
++        public static int MoveMask(Vector128<float> value);
++        public static Vector128<float> MoveScalar(Vector128<float> upper, Vector128<float> value);
++        public static Vector128<float> Multiply(Vector128<float> left, Vector128<float> right);
++        public static Vector128<float> MultiplyScalar(Vector128<float> left, Vector128<float> right);
++        public static Vector128<float> Or(Vector128<float> left, Vector128<float> right);
++        public unsafe static void Prefetch0(void* address);
++        public unsafe static void Prefetch1(void* address);
++        public unsafe static void Prefetch2(void* address);
++        public unsafe static void PrefetchNonTemporal(void* address);
++        public static Vector128<float> Reciprocal(Vector128<float> value);
++        public static Vector128<float> ReciprocalScalar(Vector128<float> value);
++        public static Vector128<float> ReciprocalScalar(Vector128<float> upper, Vector128<float> value);
++        public static Vector128<float> ReciprocalSqrt(Vector128<float> value);
++        public static Vector128<float> ReciprocalSqrtScalar(Vector128<float> value);
++        public static Vector128<float> ReciprocalSqrtScalar(Vector128<float> upper, Vector128<float> value);
++        public static Vector128<float> SetAllVector128(float value);
++        public static Vector128<float> SetScalarVector128(float value);
++        public static Vector128<float> SetVector128(float e3, float e2, float e1, float e0);
++        public static Vector128<float> SetZeroVector128();
++        public static Vector128<float> Shuffle(Vector128<float> left, Vector128<float> right, byte control);
++        public static Vector128<float> Sqrt(Vector128<float> value);
++        public static Vector128<float> SqrtScalar(Vector128<float> value);
++        public static Vector128<float> SqrtScalar(Vector128<float> upper, Vector128<float> value);
++        public static Vector128<U> StaticCast<T, U>(Vector128<T> value) where T : struct where U : struct;
++        public unsafe static void Store(float* address, Vector128<float> source);
++        public unsafe static void StoreAligned(float* address, Vector128<float> source);
++        public unsafe static void StoreAlignedNonTemporal(float* address, Vector128<float> source);
++        public static void StoreFence();
++        public unsafe static void StoreHigh(float* address, Vector128<float> source);
++        public unsafe static void StoreLow(float* address, Vector128<float> source);
++        public unsafe static void StoreScalar(float* address, Vector128<float> source);
++        public static Vector128<float> Subtract(Vector128<float> left, Vector128<float> right);
++        public static Vector128<float> SubtractScalar(Vector128<float> left, Vector128<float> right);
++        public static Vector128<float> UnpackHigh(Vector128<float> left, Vector128<float> right);
++        public static Vector128<float> UnpackLow(Vector128<float> left, Vector128<float> right);
++        public static Vector128<float> Xor(Vector128<float> left, Vector128<float> right);
++        public abstract class X64 {
++            public static bool IsSupported { get; }
++            public static Vector128<float> ConvertScalarToVector128Single(Vector128<float> upper, long value);
++            public static long ConvertToInt64(Vector128<float> value);
++            public static long ConvertToInt64WithTruncation(Vector128<float> value);
++        }
++    }
++    public abstract class Sse2 : Sse {
++        public static new bool IsSupported { get; }
++        public static Vector128<byte> Add(Vector128<byte> left, Vector128<byte> right);
++        public static Vector128<double> Add(Vector128<double> left, Vector128<double> right);
++        public static Vector128<short> Add(Vector128<short> left, Vector128<short> right);
++        public static Vector128<int> Add(Vector128<int> left, Vector128<int> right);
++        public static Vector128<long> Add(Vector128<long> left, Vector128<long> right);
++        public static Vector128<sbyte> Add(Vector128<sbyte> left, Vector128<sbyte> right);
++        public static Vector128<ushort> Add(Vector128<ushort> left, Vector128<ushort> right);
++        public static Vector128<uint> Add(Vector128<uint> left, Vector128<uint> right);
++        public static Vector128<ulong> Add(Vector128<ulong> left, Vector128<ulong> right);
++        public static Vector128<byte> AddSaturate(Vector128<byte> left, Vector128<byte> right);
++        public static Vector128<short> AddSaturate(Vector128<short> left, Vector128<short> right);
++        public static Vector128<sbyte> AddSaturate(Vector128<sbyte> left, Vector128<sbyte> right);
++        public static Vector128<ushort> AddSaturate(Vector128<ushort> left, Vector128<ushort> right);
++        public static Vector128<double> AddScalar(Vector128<double> left, Vector128<double> right);
++        public static Vector128<byte> And(Vector128<byte> left, Vector128<byte> right);
++        public static Vector128<double> And(Vector128<double> left, Vector128<double> right);
++        public static Vector128<short> And(Vector128<short> left, Vector128<short> right);
++        public static Vector128<int> And(Vector128<int> left, Vector128<int> right);
++        public static Vector128<long> And(Vector128<long> left, Vector128<long> right);
++        public static Vector128<sbyte> And(Vector128<sbyte> left, Vector128<sbyte> right);
++        public static Vector128<ushort> And(Vector128<ushort> left, Vector128<ushort> right);
++        public static Vector128<uint> And(Vector128<uint> left, Vector128<uint> right);
++        public static Vector128<ulong> And(Vector128<ulong> left, Vector128<ulong> right);
++        public static Vector128<byte> AndNot(Vector128<byte> left, Vector128<byte> right);
++        public static Vector128<double> AndNot(Vector128<double> left, Vector128<double> right);
++        public static Vector128<short> AndNot(Vector128<short> left, Vector128<short> right);
++        public static Vector128<int> AndNot(Vector128<int> left, Vector128<int> right);
++        public static Vector128<long> AndNot(Vector128<long> left, Vector128<long> right);
++        public static Vector128<sbyte> AndNot(Vector128<sbyte> left, Vector128<sbyte> right);
++        public static Vector128<ushort> AndNot(Vector128<ushort> left, Vector128<ushort> right);
++        public static Vector128<uint> AndNot(Vector128<uint> left, Vector128<uint> right);
++        public static Vector128<ulong> AndNot(Vector128<ulong> left, Vector128<ulong> right);
++        public static Vector128<byte> Average(Vector128<byte> left, Vector128<byte> right);
++        public static Vector128<ushort> Average(Vector128<ushort> left, Vector128<ushort> right);
++        public static Vector128<byte> CompareEqual(Vector128<byte> left, Vector128<byte> right);
++        public static Vector128<double> CompareEqual(Vector128<double> left, Vector128<double> right);
++        public static Vector128<short> CompareEqual(Vector128<short> left, Vector128<short> right);
++        public static Vector128<int> CompareEqual(Vector128<int> left, Vector128<int> right);
++        public static Vector128<sbyte> CompareEqual(Vector128<sbyte> left, Vector128<sbyte> right);
++        public static Vector128<ushort> CompareEqual(Vector128<ushort> left, Vector128<ushort> right);
++        public static Vector128<uint> CompareEqual(Vector128<uint> left, Vector128<uint> right);
++        public static bool CompareEqualOrderedScalar(Vector128<double> left, Vector128<double> right);
++        public static Vector128<double> CompareEqualScalar(Vector128<double> left, Vector128<double> right);
++        public static bool CompareEqualUnorderedScalar(Vector128<double> left, Vector128<double> right);
++        public static Vector128<double> CompareGreaterThan(Vector128<double> left, Vector128<double> right);
++        public static Vector128<short> CompareGreaterThan(Vector128<short> left, Vector128<short> right);
++        public static Vector128<int> CompareGreaterThan(Vector128<int> left, Vector128<int> right);
++        public static Vector128<sbyte> CompareGreaterThan(Vector128<sbyte> left, Vector128<sbyte> right);
++        public static bool CompareGreaterThanOrderedScalar(Vector128<double> left, Vector128<double> right);
++        public static Vector128<double> CompareGreaterThanOrEqual(Vector128<double> left, Vector128<double> right);
++        public static bool CompareGreaterThanOrEqualOrderedScalar(Vector128<double> left, Vector128<double> right);
++        public static Vector128<double> CompareGreaterThanOrEqualScalar(Vector128<double> left, Vector128<double> right);
++        public static bool CompareGreaterThanOrEqualUnorderedScalar(Vector128<double> left, Vector128<double> right);
++        public static Vector128<double> CompareGreaterThanScalar(Vector128<double> left, Vector128<double> right);
++        public static bool CompareGreaterThanUnorderedScalar(Vector128<double> left, Vector128<double> right);
++        public static Vector128<double> CompareLessThan(Vector128<double> left, Vector128<double> right);
++        public static Vector128<short> CompareLessThan(Vector128<short> left, Vector128<short> right);
++        public static Vector128<int> CompareLessThan(Vector128<int> left, Vector128<int> right);
++        public static Vector128<sbyte> CompareLessThan(Vector128<sbyte> left, Vector128<sbyte> right);
++        public static bool CompareLessThanOrderedScalar(Vector128<double> left, Vector128<double> right);
++        public static Vector128<double> CompareLessThanOrEqual(Vector128<double> left, Vector128<double> right);
++        public static bool CompareLessThanOrEqualOrderedScalar(Vector128<double> left, Vector128<double> right);
++        public static Vector128<double> CompareLessThanOrEqualScalar(Vector128<double> left, Vector128<double> right);
++        public static bool CompareLessThanOrEqualUnorderedScalar(Vector128<double> left, Vector128<double> right);
++        public static Vector128<double> CompareLessThanScalar(Vector128<double> left, Vector128<double> right);
++        public static bool CompareLessThanUnorderedScalar(Vector128<double> left, Vector128<double> right);
++        public static Vector128<double> CompareNotEqual(Vector128<double> left, Vector128<double> right);
++        public static bool CompareNotEqualOrderedScalar(Vector128<double> left, Vector128<double> right);
++        public static Vector128<double> CompareNotEqualScalar(Vector128<double> left, Vector128<double> right);
++        public static bool CompareNotEqualUnorderedScalar(Vector128<double> left, Vector128<double> right);
++        public static Vector128<double> CompareNotGreaterThan(Vector128<double> left, Vector128<double> right);
++        public static Vector128<double> CompareNotGreaterThanOrEqual(Vector128<double> left, Vector128<double> right);
++        public static Vector128<double> CompareNotGreaterThanOrEqualScalar(Vector128<double> left, Vector128<double> right);
++        public static Vector128<double> CompareNotGreaterThanScalar(Vector128<double> left, Vector128<double> right);
++        public static Vector128<double> CompareNotLessThan(Vector128<double> left, Vector128<double> right);
++        public static Vector128<double> CompareNotLessThanOrEqual(Vector128<double> left, Vector128<double> right);
++        public static Vector128<double> CompareNotLessThanOrEqualScalar(Vector128<double> left, Vector128<double> right);
++        public static Vector128<double> CompareNotLessThanScalar(Vector128<double> left, Vector128<double> right);
++        public static Vector128<double> CompareOrdered(Vector128<double> left, Vector128<double> right);
++        public static Vector128<double> CompareOrderedScalar(Vector128<double> left, Vector128<double> right);
++        public static Vector128<double> CompareUnordered(Vector128<double> left, Vector128<double> right);
++        public static Vector128<double> CompareUnorderedScalar(Vector128<double> left, Vector128<double> right);
++        public static Vector128<double> ConvertScalarToVector128Double(Vector128<double> upper, int value);
++        public static Vector128<double> ConvertScalarToVector128Double(Vector128<double> upper, long value);
++        public static Vector128<double> ConvertScalarToVector128Double(Vector128<double> upper, Vector128<float> value);
++        public static Vector128<int> ConvertScalarToVector128Int32(int value);
++        public static Vector128<long> ConvertScalarToVector128Int64(long value);
++        public static Vector128<float> ConvertScalarToVector128Single(Vector128<float> upper, Vector128<double> value);
++        public static Vector128<uint> ConvertScalarToVector128UInt32(uint value);
++        public static Vector128<ulong> ConvertScalarToVector128UInt64(ulong value);
++        public static double ConvertToDouble(Vector128<double> value);
++        public static int ConvertToInt32(Vector128<double> value);
++        public static int ConvertToInt32(Vector128<int> value);
++        public static int ConvertToInt32WithTruncation(Vector128<double> value);
++        public static long ConvertToInt64(Vector128<double> value);
++        public static long ConvertToInt64(Vector128<long> value);
++        public static long ConvertToInt64WithTruncation(Vector128<double> value);
++        public static uint ConvertToUInt32(Vector128<uint> value);
++        public static ulong ConvertToUInt64(Vector128<ulong> value);
++        public static Vector128<double> ConvertToVector128Double(Vector128<int> value);
++        public static Vector128<double> ConvertToVector128Double(Vector128<float> value);
++        public static Vector128<int> ConvertToVector128Int32(Vector128<double> value);
++        public static Vector128<int> ConvertToVector128Int32(Vector128<float> value);
++        public static Vector128<int> ConvertToVector128Int32WithTruncation(Vector128<double> value);
++        public static Vector128<int> ConvertToVector128Int32WithTruncation(Vector128<float> value);
++        public static Vector128<float> ConvertToVector128Single(Vector128<double> value);
++        public static Vector128<float> ConvertToVector128Single(Vector128<int> value);
++        public static Vector128<double> Divide(Vector128<double> left, Vector128<double> right);
++        public static Vector128<double> DivideScalar(Vector128<double> left, Vector128<double> right);
++        public static ushort Extract(Vector128<ushort> value, byte index);
++        public static Vector128<short> Insert(Vector128<short> value, short data, byte index);
++        public static Vector128<ushort> Insert(Vector128<ushort> value, ushort data, byte index);
++        public unsafe static Vector128<byte> LoadAlignedVector128(byte* address);
++        public unsafe static Vector128<double> LoadAlignedVector128(double* address);
++        public unsafe static Vector128<short> LoadAlignedVector128(short* address);
++        public unsafe static Vector128<int> LoadAlignedVector128(int* address);
++        public unsafe static Vector128<long> LoadAlignedVector128(long* address);
++        public unsafe static Vector128<sbyte> LoadAlignedVector128(sbyte* address);
++        public unsafe static Vector128<ushort> LoadAlignedVector128(ushort* address);
++        public unsafe static Vector128<uint> LoadAlignedVector128(uint* address);
++        public unsafe static Vector128<ulong> LoadAlignedVector128(ulong* address);
++        public static void LoadFence();
++        public unsafe static Vector128<double> LoadHigh(Vector128<double> lower, double* address);
++        public unsafe static Vector128<double> LoadLow(Vector128<double> upper, double* address);
++        public unsafe static Vector128<double> LoadScalarVector128(double* address);
++        public unsafe static Vector128<int> LoadScalarVector128(int* address);
++        public unsafe static Vector128<long> LoadScalarVector128(long* address);
++        public unsafe static Vector128<uint> LoadScalarVector128(uint* address);
++        public unsafe static Vector128<ulong> LoadScalarVector128(ulong* address);
++        public unsafe static Vector128<byte> LoadVector128(byte* address);
++        public unsafe static Vector128<double> LoadVector128(double* address);
++        public unsafe static Vector128<short> LoadVector128(short* address);
++        public unsafe static Vector128<int> LoadVector128(int* address);
++        public unsafe static Vector128<long> LoadVector128(long* address);
++        public unsafe static Vector128<sbyte> LoadVector128(sbyte* address);
++        public unsafe static Vector128<ushort> LoadVector128(ushort* address);
++        public unsafe static Vector128<uint> LoadVector128(uint* address);
++        public unsafe static Vector128<ulong> LoadVector128(ulong* address);
++        public unsafe static void MaskMove(Vector128<byte> source, Vector128<byte> mask, byte* address);
++        public unsafe static void MaskMove(Vector128<sbyte> source, Vector128<sbyte> mask, sbyte* address);
++        public static Vector128<byte> Max(Vector128<byte> left, Vector128<byte> right);
++        public static Vector128<double> Max(Vector128<double> left, Vector128<double> right);
++        public static Vector128<short> Max(Vector128<short> left, Vector128<short> right);
++        public static Vector128<double> MaxScalar(Vector128<double> left, Vector128<double> right);
++        public static void MemoryFence();
++        public static Vector128<byte> Min(Vector128<byte> left, Vector128<byte> right);
++        public static Vector128<double> Min(Vector128<double> left, Vector128<double> right);
++        public static Vector128<short> Min(Vector128<short> left, Vector128<short> right);
++        public static Vector128<double> MinScalar(Vector128<double> left, Vector128<double> right);
++        public static int MoveMask(Vector128<byte> value);
++        public static int MoveMask(Vector128<double> value);
++        public static int MoveMask(Vector128<sbyte> value);
++        public static Vector128<double> MoveScalar(Vector128<double> upper, Vector128<double> value);
++        public static Vector128<long> MoveScalar(Vector128<long> value);
++        public static Vector128<ulong> MoveScalar(Vector128<ulong> value);
++        public static Vector128<double> Multiply(Vector128<double> left, Vector128<double> right);
++        public static Vector128<ulong> Multiply(Vector128<uint> left, Vector128<uint> right);
++        public static Vector128<int> MultiplyAddAdjacent(Vector128<short> left, Vector128<short> right);
++        public static Vector128<short> MultiplyHigh(Vector128<short> left, Vector128<short> right);
++        public static Vector128<ushort> MultiplyHigh(Vector128<ushort> left, Vector128<ushort> right);
++        public static Vector128<short> MultiplyLow(Vector128<short> left, Vector128<short> right);
++        public static Vector128<ushort> MultiplyLow(Vector128<ushort> left, Vector128<ushort> right);
++        public static Vector128<double> MultiplyScalar(Vector128<double> left, Vector128<double> right);
++        public static Vector128<byte> Or(Vector128<byte> left, Vector128<byte> right);
++        public static Vector128<double> Or(Vector128<double> left, Vector128<double> right);
++        public static Vector128<short> Or(Vector128<short> left, Vector128<short> right);
++        public static Vector128<int> Or(Vector128<int> left, Vector128<int> right);
++        public static Vector128<long> Or(Vector128<long> left, Vector128<long> right);
++        public static Vector128<sbyte> Or(Vector128<sbyte> left, Vector128<sbyte> right);
++        public static Vector128<ushort> Or(Vector128<ushort> left, Vector128<ushort> right);
++        public static Vector128<uint> Or(Vector128<uint> left, Vector128<uint> right);
++        public static Vector128<ulong> Or(Vector128<ulong> left, Vector128<ulong> right);
++        public static Vector128<sbyte> PackSignedSaturate(Vector128<short> left, Vector128<short> right);
++        public static Vector128<short> PackSignedSaturate(Vector128<int> left, Vector128<int> right);
++        public static Vector128<byte> PackUnsignedSaturate(Vector128<short> left, Vector128<short> right);
++        public static Vector128<byte> SetAllVector128(byte value);
++        public static Vector128<double> SetAllVector128(double value);
++        public static Vector128<short> SetAllVector128(short value);
++        public static Vector128<int> SetAllVector128(int value);
++        public static Vector128<long> SetAllVector128(long value);
++        public static Vector128<sbyte> SetAllVector128(sbyte value);
++        public static Vector128<ushort> SetAllVector128(ushort value);
++        public static Vector128<uint> SetAllVector128(uint value);
++        public static Vector128<ulong> SetAllVector128(ulong value);
++        public static Vector128<double> SetScalarVector128(double value);
++        public static Vector128<byte> SetVector128(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);
++        public static Vector128<double> SetVector128(double e1, double e0);
++        public static Vector128<short> SetVector128(short e7, short e6, short e5, short e4, short e3, short e2, short e1, short e0);
++        public static Vector128<int> SetVector128(int e3, int e2, int e1, int e0);
++        public static Vector128<long> SetVector128(long e1, long e0);
++        public static Vector128<sbyte> SetVector128(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);
++        public static Vector128<ushort> SetVector128(ushort e7, ushort e6, ushort e5, ushort e4, ushort e3, ushort e2, ushort e1, ushort e0);
++        public static Vector128<uint> SetVector128(uint e3, uint e2, uint e1, uint e0);
++        public static Vector128<ulong> SetVector128(ulong e1, ulong e0);
++        public static Vector128<T> SetZeroVector128<T>() where T : struct;
++        public static Vector128<short> ShiftLeftLogical(Vector128<short> value, byte count);
++        public static Vector128<short> ShiftLeftLogical(Vector128<short> value, Vector128<short> count);
++        public static Vector128<int> ShiftLeftLogical(Vector128<int> value, byte count);
++        public static Vector128<int> ShiftLeftLogical(Vector128<int> value, Vector128<int> count);
++        public static Vector128<long> ShiftLeftLogical(Vector128<long> value, byte count);
++        public static Vector128<long> ShiftLeftLogical(Vector128<long> value, Vector128<long> count);
++        public static Vector128<ushort> ShiftLeftLogical(Vector128<ushort> value, byte count);
++        public static Vector128<ushort> ShiftLeftLogical(Vector128<ushort> value, Vector128<ushort> count);
++        public static Vector128<uint> ShiftLeftLogical(Vector128<uint> value, byte count);
++        public static Vector128<uint> ShiftLeftLogical(Vector128<uint> value, Vector128<uint> count);
++        public static Vector128<ulong> ShiftLeftLogical(Vector128<ulong> value, byte count);
++        public static Vector128<ulong> ShiftLeftLogical(Vector128<ulong> value, Vector128<ulong> count);
++        public static Vector128<byte> ShiftLeftLogical128BitLane(Vector128<byte> value, byte numBytes);
++        public static Vector128<short> ShiftLeftLogical128BitLane(Vector128<short> value, byte numBytes);
++        public static Vector128<int> ShiftLeftLogical128BitLane(Vector128<int> value, byte numBytes);
++        public static Vector128<long> ShiftLeftLogical128BitLane(Vector128<long> value, byte numBytes);
++        public static Vector128<sbyte> ShiftLeftLogical128BitLane(Vector128<sbyte> value, byte numBytes);
++        public static Vector128<ushort> ShiftLeftLogical128BitLane(Vector128<ushort> value, byte numBytes);
++        public static Vector128<uint> ShiftLeftLogical128BitLane(Vector128<uint> value, byte numBytes);
++        public static Vector128<ulong> ShiftLeftLogical128BitLane(Vector128<ulong> value, byte numBytes);
++        public static Vector128<short> ShiftRightArithmetic(Vector128<short> value, byte count);
++        public static Vector128<short> ShiftRightArithmetic(Vector128<short> value, Vector128<short> count);
++        public static Vector128<int> ShiftRightArithmetic(Vector128<int> value, byte count);
++        public static Vector128<int> ShiftRightArithmetic(Vector128<int> value, Vector128<int> count);
++        public static Vector128<short> ShiftRightLogical(Vector128<short> value, byte count);
++        public static Vector128<short> ShiftRightLogical(Vector128<short> value, Vector128<short> count);
++        public static Vector128<int> ShiftRightLogical(Vector128<int> value, byte count);
++        public static Vector128<int> ShiftRightLogical(Vector128<int> value, Vector128<int> count);
++        public static Vector128<long> ShiftRightLogical(Vector128<long> value, byte count);
++        public static Vector128<long> ShiftRightLogical(Vector128<long> value, Vector128<long> count);
++        public static Vector128<ushort> ShiftRightLogical(Vector128<ushort> value, byte count);
++        public static Vector128<ushort> ShiftRightLogical(Vector128<ushort> value, Vector128<ushort> count);
++        public static Vector128<uint> ShiftRightLogical(Vector128<uint> value, byte count);
++        public static Vector128<uint> ShiftRightLogical(Vector128<uint> value, Vector128<uint> count);
++        public static Vector128<ulong> ShiftRightLogical(Vector128<ulong> value, byte count);
++        public static Vector128<ulong> ShiftRightLogical(Vector128<ulong> value, Vector128<ulong> count);
++        public static Vector128<byte> ShiftRightLogical128BitLane(Vector128<byte> value, byte numBytes);
++        public static Vector128<short> ShiftRightLogical128BitLane(Vector128<short> value, byte numBytes);
++        public static Vector128<int> ShiftRightLogical128BitLane(Vector128<int> value, byte numBytes);
++        public static Vector128<long> ShiftRightLogical128BitLane(Vector128<long> value, byte numBytes);
++        public static Vector128<sbyte> ShiftRightLogical128BitLane(Vector128<sbyte> value, byte numBytes);
++        public static Vector128<ushort> ShiftRightLogical128BitLane(Vector128<ushort> value, byte numBytes);
++        public static Vector128<uint> ShiftRightLogical128BitLane(Vector128<uint> value, byte numBytes);
++        public static Vector128<ulong> ShiftRightLogical128BitLane(Vector128<ulong> value, byte numBytes);
++        public static Vector128<double> Shuffle(Vector128<double> left, Vector128<double> right, byte control);
++        public static Vector128<int> Shuffle(Vector128<int> value, byte control);
++        public static Vector128<uint> Shuffle(Vector128<uint> value, byte control);
++        public static Vector128<short> ShuffleHigh(Vector128<short> value, byte control);
++        public static Vector128<ushort> ShuffleHigh(Vector128<ushort> value, byte control);
++        public static Vector128<short> ShuffleLow(Vector128<short> value, byte control);
++        public static Vector128<ushort> ShuffleLow(Vector128<ushort> value, byte control);
++        public static Vector128<double> Sqrt(Vector128<double> value);
++        public static Vector128<double> SqrtScalar(Vector128<double> value);
++        public static Vector128<double> SqrtScalar(Vector128<double> upper, Vector128<double> value);
++        public unsafe static void Store(byte* address, Vector128<byte> source);
++        public unsafe static void Store(double* address, Vector128<double> source);
++        public unsafe static void Store(short* address, Vector128<short> source);
++        public unsafe static void Store(int* address, Vector128<int> source);
++        public unsafe static void Store(long* address, Vector128<long> source);
++        public unsafe static void Store(sbyte* address, Vector128<sbyte> source);
++        public unsafe static void Store(ushort* address, Vector128<ushort> source);
++        public unsafe static void Store(uint* address, Vector128<uint> source);
++        public unsafe static void Store(ulong* address, Vector128<ulong> source);
++        public unsafe static void StoreAligned(byte* address, Vector128<byte> source);
++        public unsafe static void StoreAligned(double* address, Vector128<double> source);
++        public unsafe static void StoreAligned(short* address, Vector128<short> source);
++        public unsafe static void StoreAligned(int* address, Vector128<int> source);
++        public unsafe static void StoreAligned(long* address, Vector128<long> source);
++        public unsafe static void StoreAligned(sbyte* address, Vector128<sbyte> source);
++        public unsafe static void StoreAligned(ushort* address, Vector128<ushort> source);
++        public unsafe static void StoreAligned(uint* address, Vector128<uint> source);
++        public unsafe static void StoreAligned(ulong* address, Vector128<ulong> source);
++        public unsafe static void StoreAlignedNonTemporal(byte* address, Vector128<byte> source);
++        public unsafe static void StoreAlignedNonTemporal(double* address, Vector128<double> source);
++        public unsafe static void StoreAlignedNonTemporal(short* address, Vector128<short> source);
++        public unsafe static void StoreAlignedNonTemporal(int* address, Vector128<int> source);
++        public unsafe static void StoreAlignedNonTemporal(long* address, Vector128<long> source);
++        public unsafe static void StoreAlignedNonTemporal(sbyte* address, Vector128<sbyte> source);
++        public unsafe static void StoreAlignedNonTemporal(ushort* address, Vector128<ushort> source);
++        public unsafe static void StoreAlignedNonTemporal(uint* address, Vector128<uint> source);
++        public unsafe static void StoreAlignedNonTemporal(ulong* address, Vector128<ulong> source);
++        public unsafe static void StoreHigh(double* address, Vector128<double> source);
++        public unsafe static void StoreLow(double* address, Vector128<double> source);
++        public unsafe static void StoreLow(long* address, Vector128<long> source);
++        public unsafe static void StoreLow(ulong* address, Vector128<ulong> source);
++        public unsafe static void StoreNonTemporal(int* address, int value);
++        public unsafe static void StoreNonTemporal(long* address, long value);
++        public unsafe static void StoreNonTemporal(uint* address, uint value);
++        public unsafe static void StoreNonTemporal(ulong* address, ulong value);
++        public unsafe static void StoreScalar(double* address, Vector128<double> source);
++        public static Vector128<byte> Subtract(Vector128<byte> left, Vector128<byte> right);
++        public static Vector128<double> Subtract(Vector128<double> left, Vector128<double> right);
++        public static Vector128<short> Subtract(Vector128<short> left, Vector128<short> right);
++        public static Vector128<int> Subtract(Vector128<int> left, Vector128<int> right);
++        public static Vector128<long> Subtract(Vector128<long> left, Vector128<long> right);
++        public static Vector128<sbyte> Subtract(Vector128<sbyte> left, Vector128<sbyte> right);
++        public static Vector128<ushort> Subtract(Vector128<ushort> left, Vector128<ushort> right);
++        public static Vector128<uint> Subtract(Vector128<uint> left, Vector128<uint> right);
++        public static Vector128<ulong> Subtract(Vector128<ulong> left, Vector128<ulong> right);
++        public static Vector128<byte> SubtractSaturate(Vector128<byte> left, Vector128<byte> right);
++        public static Vector128<short> SubtractSaturate(Vector128<short> left, Vector128<short> right);
++        public static Vector128<sbyte> SubtractSaturate(Vector128<sbyte> left, Vector128<sbyte> right);
++        public static Vector128<ushort> SubtractSaturate(Vector128<ushort> left, Vector128<ushort> right);
++        public static Vector128<double> SubtractScalar(Vector128<double> left, Vector128<double> right);
++        public static Vector128<ushort> SumAbsoluteDifferences(Vector128<byte> left, Vector128<byte> right);
++        public static Vector128<byte> UnpackHigh(Vector128<byte> left, Vector128<byte> right);
++        public static Vector128<double> UnpackHigh(Vector128<double> left, Vector128<double> right);
++        public static Vector128<short> UnpackHigh(Vector128<short> left, Vector128<short> right);
++        public static Vector128<int> UnpackHigh(Vector128<int> left, Vector128<int> right);
++        public static Vector128<long> UnpackHigh(Vector128<long> left, Vector128<long> right);
++        public static Vector128<sbyte> UnpackHigh(Vector128<sbyte> left, Vector128<sbyte> right);
++        public static Vector128<ushort> UnpackHigh(Vector128<ushort> left, Vector128<ushort> right);
++        public static Vector128<uint> UnpackHigh(Vector128<uint> left, Vector128<uint> right);
++        public static Vector128<ulong> UnpackHigh(Vector128<ulong> left, Vector128<ulong> right);
++        public static Vector128<byte> UnpackLow(Vector128<byte> left, Vector128<byte> right);
++        public static Vector128<double> UnpackLow(Vector128<double> left, Vector128<double> right);
++        public static Vector128<short> UnpackLow(Vector128<short> left, Vector128<short> right);
++        public static Vector128<int> UnpackLow(Vector128<int> left, Vector128<int> right);
++        public static Vector128<long> UnpackLow(Vector128<long> left, Vector128<long> right);
++        public static Vector128<sbyte> UnpackLow(Vector128<sbyte> left, Vector128<sbyte> right);
++        public static Vector128<ushort> UnpackLow(Vector128<ushort> left, Vector128<ushort> right);
++        public static Vector128<uint> UnpackLow(Vector128<uint> left, Vector128<uint> right);
++        public static Vector128<ulong> UnpackLow(Vector128<ulong> left, Vector128<ulong> right);
++        public static Vector128<byte> Xor(Vector128<byte> left, Vector128<byte> right);
++        public static Vector128<double> Xor(Vector128<double> left, Vector128<double> right);
++        public static Vector128<short> Xor(Vector128<short> left, Vector128<short> right);
++        public static Vector128<int> Xor(Vector128<int> left, Vector128<int> right);
++        public static Vector128<long> Xor(Vector128<long> left, Vector128<long> right);
++        public static Vector128<sbyte> Xor(Vector128<sbyte> left, Vector128<sbyte> right);
++        public static Vector128<ushort> Xor(Vector128<ushort> left, Vector128<ushort> right);
++        public static Vector128<uint> Xor(Vector128<uint> left, Vector128<uint> right);
++        public static Vector128<ulong> Xor(Vector128<ulong> left, Vector128<ulong> right);
++        public abstract class X64 : Sse.X64 {
++            public static new bool IsSupported { get; }
++            public static Vector128<double> ConvertScalarToVector128Double(Vector128<double> upper, long value);
++            public static Vector128<long> ConvertScalarToVector128Int64(long value);
++            public static Vector128<ulong> ConvertScalarToVector128UInt64(ulong value);
++            public static long ConvertToInt64(Vector128<double> value);
++            public static long ConvertToInt64(Vector128<long> value);
++            public static long ConvertToInt64WithTruncation(Vector128<double> value);
++            public static ulong ConvertToUInt64(Vector128<ulong> value);
++            public unsafe static void StoreNonTemporal(long* address, long value);
++            public unsafe static void StoreNonTemporal(ulong* address, ulong value);
++        }
++    }
++    public abstract class Sse3 : Sse2 {
++        public static new bool IsSupported { get; }
++        public static Vector128<double> AddSubtract(Vector128<double> left, Vector128<double> right);
++        public static Vector128<float> AddSubtract(Vector128<float> left, Vector128<float> right);
++        public static Vector128<double> HorizontalAdd(Vector128<double> left, Vector128<double> right);
++        public static Vector128<float> HorizontalAdd(Vector128<float> left, Vector128<float> right);
++        public static Vector128<double> HorizontalSubtract(Vector128<double> left, Vector128<double> right);
++        public static Vector128<float> HorizontalSubtract(Vector128<float> left, Vector128<float> right);
++        public unsafe static Vector128<double> LoadAndDuplicateToVector128(double* address);
++        public unsafe static Vector128<byte> LoadDquVector128(byte* address);
++        public unsafe static Vector128<short> LoadDquVector128(short* address);
++        public unsafe static Vector128<int> LoadDquVector128(int* address);
++        public unsafe static Vector128<long> LoadDquVector128(long* address);
++        public unsafe static Vector128<sbyte> LoadDquVector128(sbyte* address);
++        public unsafe static Vector128<ushort> LoadDquVector128(ushort* address);
++        public unsafe static Vector128<uint> LoadDquVector128(uint* address);
++        public unsafe static Vector128<ulong> LoadDquVector128(ulong* address);
++        public static Vector128<double> MoveAndDuplicate(Vector128<double> source);
++        public static Vector128<float> MoveHighAndDuplicate(Vector128<float> source);
++        public static Vector128<float> MoveLowAndDuplicate(Vector128<float> source);
++    }
++    public abstract class Sse41 : Ssse3 {
++        public static new bool IsSupported { get; }
++        public static Vector128<double> Blend(Vector128<double> left, Vector128<double> right, byte control);
++        public static Vector128<short> Blend(Vector128<short> left, Vector128<short> right, byte control);
++        public static Vector128<float> Blend(Vector128<float> left, Vector128<float> right, byte control);
++        public static Vector128<ushort> Blend(Vector128<ushort> left, Vector128<ushort> right, byte control);
++        public static Vector128<byte> BlendVariable(Vector128<byte> left, Vector128<byte> right, Vector128<byte> mask);
++        public static Vector128<double> BlendVariable(Vector128<double> left, Vector128<double> right, Vector128<double> mask);
++        public static Vector128<short> BlendVariable(Vector128<short> left, Vector128<short> right, Vector128<short> mask);
++        public static Vector128<int> BlendVariable(Vector128<int> left, Vector128<int> right, Vector128<int> mask);
++        public static Vector128<long> BlendVariable(Vector128<long> left, Vector128<long> right, Vector128<long> mask);
++        public static Vector128<sbyte> BlendVariable(Vector128<sbyte> left, Vector128<sbyte> right, Vector128<sbyte> mask);
++        public static Vector128<float> BlendVariable(Vector128<float> left, Vector128<float> right, Vector128<float> mask);
++        public static Vector128<ushort> BlendVariable(Vector128<ushort> left, Vector128<ushort> right, Vector128<ushort> mask);
++        public static Vector128<uint> BlendVariable(Vector128<uint> left, Vector128<uint> right, Vector128<uint> mask);
++        public static Vector128<ulong> BlendVariable(Vector128<ulong> left, Vector128<ulong> right, Vector128<ulong> mask);
++        public static Vector128<double> Ceiling(Vector128<double> value);
++        public static Vector128<float> Ceiling(Vector128<float> value);
++        public static Vector128<double> CeilingScalar(Vector128<double> value);
++        public static Vector128<double> CeilingScalar(Vector128<double> upper, Vector128<double> value);
++        public static Vector128<float> CeilingScalar(Vector128<float> value);
++        public static Vector128<float> CeilingScalar(Vector128<float> upper, Vector128<float> value);
++        public static Vector128<long> CompareEqual(Vector128<long> left, Vector128<long> right);
++        public static Vector128<ulong> CompareEqual(Vector128<ulong> left, Vector128<ulong> right);
++        public static Vector128<short> ConvertToVector128Int16(Vector128<byte> value);
++        public static Vector128<short> ConvertToVector128Int16(Vector128<sbyte> value);
++        public static Vector128<int> ConvertToVector128Int32(Vector128<byte> value);
++        public static Vector128<int> ConvertToVector128Int32(Vector128<short> value);
++        public static Vector128<int> ConvertToVector128Int32(Vector128<sbyte> value);
++        public static Vector128<int> ConvertToVector128Int32(Vector128<ushort> value);
++        public static Vector128<long> ConvertToVector128Int64(Vector128<byte> value);
++        public static Vector128<long> ConvertToVector128Int64(Vector128<short> value);
++        public static Vector128<long> ConvertToVector128Int64(Vector128<int> value);
++        public static Vector128<long> ConvertToVector128Int64(Vector128<sbyte> value);
++        public static Vector128<long> ConvertToVector128Int64(Vector128<ushort> value);
++        public static Vector128<long> ConvertToVector128Int64(Vector128<uint> value);
++        public static Vector128<double> DotProduct(Vector128<double> left, Vector128<double> right, byte control);
++        public static Vector128<float> DotProduct(Vector128<float> left, Vector128<float> right, byte control);
++        public static byte Extract(Vector128<byte> value, byte index);
++        public static int Extract(Vector128<int> value, byte index);
++        public static long Extract(Vector128<long> value, byte index);
++        public static float Extract(Vector128<float> value, byte index);
++        public static uint Extract(Vector128<uint> value, byte index);
++        public static ulong Extract(Vector128<ulong> value, byte index);
++        public static Vector128<double> Floor(Vector128<double> value);
++        public static Vector128<float> Floor(Vector128<float> value);
++        public static Vector128<double> FloorScalar(Vector128<double> value);
++        public static Vector128<double> FloorScalar(Vector128<double> upper, Vector128<double> value);
++        public static Vector128<float> FloorScalar(Vector128<float> value);
++        public static Vector128<float> FloorScalar(Vector128<float> upper, Vector128<float> value);
++        public static Vector128<byte> Insert(Vector128<byte> value, byte data, byte index);
++        public static Vector128<int> Insert(Vector128<int> value, int data, byte index);
++        public static Vector128<long> Insert(Vector128<long> value, long data, byte index);
++        public static Vector128<sbyte> Insert(Vector128<sbyte> value, sbyte data, byte index);
++        public static Vector128<float> Insert(Vector128<float> value, Vector128<float> data, byte index);
++        public static Vector128<uint> Insert(Vector128<uint> value, uint data, byte index);
++        public static Vector128<ulong> Insert(Vector128<ulong> value, ulong data, byte index);
++        public unsafe static Vector128<byte> LoadAlignedVector128NonTemporal(byte* address);
++        public unsafe static Vector128<short> LoadAlignedVector128NonTemporal(short* address);
++        public unsafe static Vector128<int> LoadAlignedVector128NonTemporal(int* address);
++        public unsafe static Vector128<long> LoadAlignedVector128NonTemporal(long* address);
++        public unsafe static Vector128<sbyte> LoadAlignedVector128NonTemporal(sbyte* address);
++        public unsafe static Vector128<ushort> LoadAlignedVector128NonTemporal(ushort* address);
++        public unsafe static Vector128<uint> LoadAlignedVector128NonTemporal(uint* address);
++        public unsafe static Vector128<ulong> LoadAlignedVector128NonTemporal(ulong* address);
++        public static Vector128<int> Max(Vector128<int> left, Vector128<int> right);
++        public static Vector128<sbyte> Max(Vector128<sbyte> left, Vector128<sbyte> right);
++        public static Vector128<ushort> Max(Vector128<ushort> left, Vector128<ushort> right);
++        public static Vector128<uint> Max(Vector128<uint> left, Vector128<uint> right);
++        public static Vector128<int> Min(Vector128<int> left, Vector128<int> right);
++        public static Vector128<sbyte> Min(Vector128<sbyte> left, Vector128<sbyte> right);
++        public static Vector128<ushort> Min(Vector128<ushort> left, Vector128<ushort> right);
++        public static Vector128<uint> Min(Vector128<uint> left, Vector128<uint> right);
++        public static Vector128<ushort> MinHorizontal(Vector128<ushort> value);
++        public static Vector128<ushort> MultipleSumAbsoluteDifferences(Vector128<byte> left, Vector128<byte> right, byte mask);
++        public static Vector128<long> Multiply(Vector128<int> left, Vector128<int> right);
++        public static Vector128<int> MultiplyLow(Vector128<int> left, Vector128<int> right);
++        public static Vector128<uint> MultiplyLow(Vector128<uint> left, Vector128<uint> right);
++        public static Vector128<ushort> PackUnsignedSaturate(Vector128<int> left, Vector128<int> right);
++        public static Vector128<double> RoundCurrentDirection(Vector128<double> value);
++        public static Vector128<float> RoundCurrentDirection(Vector128<float> value);
++        public static Vector128<double> RoundCurrentDirectionScalar(Vector128<double> value);
++        public static Vector128<double> RoundCurrentDirectionScalar(Vector128<double> upper, Vector128<double> value);
++        public static Vector128<float> RoundCurrentDirectionScalar(Vector128<float> value);
++        public static Vector128<float> RoundCurrentDirectionScalar(Vector128<float> upper, Vector128<float> value);
++        public static Vector128<double> RoundToNearestInteger(Vector128<double> value);
++        public static Vector128<float> RoundToNearestInteger(Vector128<float> value);
++        public static Vector128<double> RoundToNearestIntegerScalar(Vector128<double> value);
++        public static Vector128<double> RoundToNearestIntegerScalar(Vector128<double> upper, Vector128<double> value);
++        public static Vector128<float> RoundToNearestIntegerScalar(Vector128<float> value);
++        public static Vector128<float> RoundToNearestIntegerScalar(Vector128<float> upper, Vector128<float> value);
++        public static Vector128<double> RoundToNegativeInfinity(Vector128<double> value);
++        public static Vector128<float> RoundToNegativeInfinity(Vector128<float> value);
++        public static Vector128<double> RoundToNegativeInfinityScalar(Vector128<double> value);
++        public static Vector128<double> RoundToNegativeInfinityScalar(Vector128<double> upper, Vector128<double> value);
++        public static Vector128<float> RoundToNegativeInfinityScalar(Vector128<float> value);
++        public static Vector128<float> RoundToNegativeInfinityScalar(Vector128<float> upper, Vector128<float> value);
++        public static Vector128<double> RoundToPositiveInfinity(Vector128<double> value);
++        public static Vector128<float> RoundToPositiveInfinity(Vector128<float> value);
++        public static Vector128<double> RoundToPositiveInfinityScalar(Vector128<double> value);
++        public static Vector128<double> RoundToPositiveInfinityScalar(Vector128<double> upper, Vector128<double> value);
++        public static Vector128<float> RoundToPositiveInfinityScalar(Vector128<float> value);
++        public static Vector128<float> RoundToPositiveInfinityScalar(Vector128<float> upper, Vector128<float> value);
++        public static Vector128<double> RoundToZero(Vector128<double> value);
++        public static Vector128<float> RoundToZero(Vector128<float> value);
++        public static Vector128<double> RoundToZeroScalar(Vector128<double> value);
++        public static Vector128<double> RoundToZeroScalar(Vector128<double> upper, Vector128<double> value);
++        public static Vector128<float> RoundToZeroScalar(Vector128<float> value);
++        public static Vector128<float> RoundToZeroScalar(Vector128<float> upper, Vector128<float> value);
++        public static bool TestAllOnes(Vector128<byte> value);
++        public static bool TestAllOnes(Vector128<short> value);
++        public static bool TestAllOnes(Vector128<int> value);
++        public static bool TestAllOnes(Vector128<long> value);
++        public static bool TestAllOnes(Vector128<sbyte> value);
++        public static bool TestAllOnes(Vector128<ushort> value);
++        public static bool TestAllOnes(Vector128<uint> value);
++        public static bool TestAllOnes(Vector128<ulong> value);
++        public static bool TestAllZeros(Vector128<byte> left, Vector128<byte> right);
++        public static bool TestAllZeros(Vector128<short> left, Vector128<short> right);
++        public static bool TestAllZeros(Vector128<int> left, Vector128<int> right);
++        public static bool TestAllZeros(Vector128<long> left, Vector128<long> right);
++        public static bool TestAllZeros(Vector128<sbyte> left, Vector128<sbyte> right);
++        public static bool TestAllZeros(Vector128<ushort> left, Vector128<ushort> right);
++        public static bool TestAllZeros(Vector128<uint> left, Vector128<uint> right);
++        public static bool TestAllZeros(Vector128<ulong> left, Vector128<ulong> right);
++        public static bool TestC(Vector128<byte> left, Vector128<byte> right);
++        public static bool TestC(Vector128<short> left, Vector128<short> right);
++        public static bool TestC(Vector128<int> left, Vector128<int> right);
++        public static bool TestC(Vector128<long> left, Vector128<long> right);
++        public static bool TestC(Vector128<sbyte> left, Vector128<sbyte> right);
++        public static bool TestC(Vector128<ushort> left, Vector128<ushort> right);
++        public static bool TestC(Vector128<uint> left, Vector128<uint> right);
++        public static bool TestC(Vector128<ulong> left, Vector128<ulong> right);
++        public static bool TestMixOnesZeros(Vector128<byte> left, Vector128<byte> right);
++        public static bool TestMixOnesZeros(Vector128<short> left, Vector128<short> right);
++        public static bool TestMixOnesZeros(Vector128<int> left, Vector128<int> right);
++        public static bool TestMixOnesZeros(Vector128<long> left, Vector128<long> right);
++        public static bool TestMixOnesZeros(Vector128<sbyte> left, Vector128<sbyte> right);
++        public static bool TestMixOnesZeros(Vector128<ushort> left, Vector128<ushort> right);
++        public static bool TestMixOnesZeros(Vector128<uint> left, Vector128<uint> right);
++        public static bool TestMixOnesZeros(Vector128<ulong> left, Vector128<ulong> right);
++        public static bool TestNotZAndNotC(Vector128<byte> left, Vector128<byte> right);
++        public static bool TestNotZAndNotC(Vector128<short> left, Vector128<short> right);
++        public static bool TestNotZAndNotC(Vector128<int> left, Vector128<int> right);
++        public static bool TestNotZAndNotC(Vector128<long> left, Vector128<long> right);
++        public static bool TestNotZAndNotC(Vector128<sbyte> left, Vector128<sbyte> right);
++        public static bool TestNotZAndNotC(Vector128<ushort> left, Vector128<ushort> right);
++        public static bool TestNotZAndNotC(Vector128<uint> left, Vector128<uint> right);
++        public static bool TestNotZAndNotC(Vector128<ulong> left, Vector128<ulong> right);
++        public static bool TestZ(Vector128<byte> left, Vector128<byte> right);
++        public static bool TestZ(Vector128<short> left, Vector128<short> right);
++        public static bool TestZ(Vector128<int> left, Vector128<int> right);
++        public static bool TestZ(Vector128<long> left, Vector128<long> right);
++        public static bool TestZ(Vector128<sbyte> left, Vector128<sbyte> right);
++        public static bool TestZ(Vector128<ushort> left, Vector128<ushort> right);
++        public static bool TestZ(Vector128<uint> left, Vector128<uint> right);
++        public static bool TestZ(Vector128<ulong> left, Vector128<ulong> right);
++        public abstract class X64 : Sse2.X64 {
++            public static new bool IsSupported { get; }
++            public static long Extract(Vector128<long> value, byte index);
++            public static ulong Extract(Vector128<ulong> value, byte index);
++            public static Vector128<long> Insert(Vector128<long> value, long data, byte index);
++            public static Vector128<ulong> Insert(Vector128<ulong> value, ulong data, byte index);
++        }
++    }
++    public abstract class Sse42 : Sse41 {
++        public static new bool IsSupported { get; }
++        public static Vector128<long> CompareGreaterThan(Vector128<long> left, Vector128<long> right);
++        public static uint Crc32(uint crc, byte data);
++        public static uint Crc32(uint crc, ushort data);
++        public static uint Crc32(uint crc, uint data);
++        public static ulong Crc32(ulong crc, ulong data);
++        public abstract class X64 : Sse41.X64 {
++            public static new bool IsSupported { get; }
++            public static ulong Crc32(ulong crc, ulong data);
++        }
++    }
++    public abstract class Ssse3 : Sse3 {
++        public static new bool IsSupported { get; }
++        public static Vector128<ushort> Abs(Vector128<short> value);
++        public static Vector128<uint> Abs(Vector128<int> value);
++        public static Vector128<byte> Abs(Vector128<sbyte> value);
++        public static Vector128<byte> AlignRight(Vector128<byte> left, Vector128<byte> right, byte mask);
++        public static Vector128<short> AlignRight(Vector128<short> left, Vector128<short> right, byte mask);
++        public static Vector128<int> AlignRight(Vector128<int> left, Vector128<int> right, byte mask);
++        public static Vector128<long> AlignRight(Vector128<long> left, Vector128<long> right, byte mask);
++        public static Vector128<sbyte> AlignRight(Vector128<sbyte> left, Vector128<sbyte> right, byte mask);
++        public static Vector128<ushort> AlignRight(Vector128<ushort> left, Vector128<ushort> right, byte mask);
++        public static Vector128<uint> AlignRight(Vector128<uint> left, Vector128<uint> right, byte mask);
++        public static Vector128<ulong> AlignRight(Vector128<ulong> left, Vector128<ulong> right, byte mask);
++        public static Vector128<short> HorizontalAdd(Vector128<short> left, Vector128<short> right);
++        public static Vector128<int> HorizontalAdd(Vector128<int> left, Vector128<int> right);
++        public static Vector128<short> HorizontalAddSaturate(Vector128<short> left, Vector128<short> right);
++        public static Vector128<short> HorizontalSubtract(Vector128<short> left, Vector128<short> right);
++        public static Vector128<int> HorizontalSubtract(Vector128<int> left, Vector128<int> right);
++        public static Vector128<short> HorizontalSubtractSaturate(Vector128<short> left, Vector128<short> right);
++        public static Vector128<short> MultiplyAddAdjacent(Vector128<byte> left, Vector128<sbyte> right);
++        public static Vector128<short> MultiplyHighRoundScale(Vector128<short> left, Vector128<short> right);
++        public static Vector128<byte> Shuffle(Vector128<byte> value, Vector128<byte> mask);
++        public static Vector128<sbyte> Shuffle(Vector128<sbyte> value, Vector128<sbyte> mask);
++        public static Vector128<short> Sign(Vector128<short> left, Vector128<short> right);
++        public static Vector128<int> Sign(Vector128<int> left, Vector128<int> right);
++        public static Vector128<sbyte> Sign(Vector128<sbyte> left, Vector128<sbyte> right);
++    }
++}
+```
+
diff --git a/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Runtime.Intrinsics.md b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Runtime.Intrinsics.md
new file mode 100644
index 00000000..24978aee
--- /dev/null
+++ b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Runtime.Intrinsics.md
@@ -0,0 +1,207 @@
+# System.Runtime.Intrinsics
+
+``` diff
++namespace System.Runtime.Intrinsics {
++    public static class Vector128 {
++        public static Vector128<Byte> Create(byte value);
++        public static Vector128<Byte> Create(byte e0, byte e1, byte e2, byte e3, byte e4, byte e5, byte e6, byte e7, byte e8, byte e9, byte e10, byte e11, byte e12, byte e13, byte e14, byte e15);
++        public static Vector128<Double> Create(double value);
++        public static Vector128<Double> Create(double e0, double e1);
++        public static Vector128<Int16> Create(short value);
++        public static Vector128<Int16> Create(short e0, short e1, short e2, short e3, short e4, short e5, short e6, short e7);
++        public static Vector128<Int32> Create(int value);
++        public static Vector128<Int32> Create(int e0, int e1, int e2, int e3);
++        public static Vector128<Int64> Create(long value);
++        public static Vector128<Int64> Create(long e0, long e1);
++        public static Vector128<Byte> Create(Vector64<byte> lower, Vector64<byte> upper);
++        public static Vector128<Double> Create(Vector64<double> lower, Vector64<double> upper);
++        public static Vector128<Int16> Create(Vector64<short> lower, Vector64<short> upper);
++        public static Vector128<Int32> Create(Vector64<int> lower, Vector64<int> upper);
++        public static Vector128<Int64> Create(Vector64<long> lower, Vector64<long> upper);
++        public static Vector128<SByte> Create(Vector64<sbyte> lower, Vector64<sbyte> upper);
++        public static Vector128<Single> Create(Vector64<float> lower, Vector64<float> upper);
++        public static Vector128<UInt16> Create(Vector64<ushort> lower, Vector64<ushort> upper);
++        public static Vector128<UInt32> Create(Vector64<uint> lower, Vector64<uint> upper);
++        public static Vector128<UInt64> Create(Vector64<ulong> lower, Vector64<ulong> upper);
++        public static Vector128<SByte> Create(sbyte value);
++        public static Vector128<SByte> Create(sbyte e0, sbyte e1, sbyte e2, sbyte e3, sbyte e4, sbyte e5, sbyte e6, sbyte e7, sbyte e8, sbyte e9, sbyte e10, sbyte e11, sbyte e12, sbyte e13, sbyte e14, sbyte e15);
++        public static Vector128<Single> Create(float value);
++        public static Vector128<Single> Create(float e0, float e1, float e2, float e3);
++        public static Vector128<UInt16> Create(ushort value);
++        public static Vector128<UInt16> Create(ushort e0, ushort e1, ushort e2, ushort e3, ushort e4, ushort e5, ushort e6, ushort e7);
++        public static Vector128<UInt32> Create(uint value);
++        public static Vector128<UInt32> Create(uint e0, uint e1, uint e2, uint e3);
++        public static Vector128<UInt64> Create(ulong value);
++        public static Vector128<UInt64> Create(ulong e0, ulong e1);
++        public static Vector128<Byte> CreateScalar(byte value);
++        public static Vector128<Double> CreateScalar(double value);
++        public static Vector128<Int16> CreateScalar(short value);
++        public static Vector128<Int32> CreateScalar(int value);
++        public static Vector128<Int64> CreateScalar(long value);
++        public static Vector128<SByte> CreateScalar(sbyte value);
++        public static Vector128<Single> CreateScalar(float value);
++        public static Vector128<UInt16> CreateScalar(ushort value);
++        public static Vector128<UInt32> CreateScalar(uint value);
++        public static Vector128<UInt64> CreateScalar(ulong value);
++        public static Vector128<Byte> CreateScalarUnsafe(byte value);
++        public static Vector128<Double> CreateScalarUnsafe(double value);
++        public static Vector128<Int16> CreateScalarUnsafe(short value);
++        public static Vector128<Int32> CreateScalarUnsafe(int value);
++        public static Vector128<Int64> CreateScalarUnsafe(long value);
++        public static Vector128<SByte> CreateScalarUnsafe(sbyte value);
++        public static Vector128<Single> CreateScalarUnsafe(float value);
++        public static Vector128<UInt16> CreateScalarUnsafe(ushort value);
++        public static Vector128<UInt32> CreateScalarUnsafe(uint value);
++        public static Vector128<UInt64> CreateScalarUnsafe(ulong value);
++    }
++    public readonly struct Vector128<T> where T : struct {
++        public static Vector128<T> Zero { get; }
++        public Vector128<U> As<U>() where U : struct;
++        public Vector128<Byte> AsByte();
++        public Vector128<Double> AsDouble();
++        public Vector128<Int16> AsInt16();
++        public Vector128<Int32> AsInt32();
++        public Vector128<Int64> AsInt64();
++        public Vector128<SByte> AsSByte();
++        public Vector128<Single> AsSingle();
++        public Vector128<UInt16> AsUInt16();
++        public Vector128<UInt32> AsUInt32();
++        public Vector128<UInt64> AsUInt64();
++        public T GetElement(int index);
++        public Vector64<T> GetLower();
++        public Vector64<T> GetUpper();
++        public T ToScalar();
++        public Vector256<T> ToVector256();
++        public Vector256<T> ToVector256Unsafe();
++        public Vector128<T> WithElement(int index, T value);
++        public Vector128<T> WithLower(Vector64<T> value);
++        public Vector128<T> WithUpper(Vector64<T> value);
++    }
++    public static class Vector256 {
++        public static Vector256<Byte> Create(byte value);
++        public static Vector256<Byte> Create(byte e0, byte e1, byte e2, byte e3, byte e4, byte e5, byte e6, byte e7, byte e8, byte e9, byte e10, byte e11, byte e12, byte e13, byte e14, byte e15, byte e16, byte e17, byte e18, byte e19, byte e20, byte e21, byte e22, byte e23, byte e24, byte e25, byte e26, byte e27, byte e28, byte e29, byte e30, byte e31);
++        public static Vector256<Double> Create(double value);
++        public static Vector256<Double> Create(double e0, double e1, double e2, double e3);
++        public static Vector256<Int16> Create(short value);
++        public static Vector256<Int16> Create(short e0, short e1, short e2, short e3, short e4, short e5, short e6, short e7, short e8, short e9, short e10, short e11, short e12, short e13, short e14, short e15);
++        public static Vector256<Int32> Create(int value);
++        public static Vector256<Int32> Create(int e0, int e1, int e2, int e3, int e4, int e5, int e6, int e7);
++        public static Vector256<Int64> Create(long value);
++        public static Vector256<Int64> Create(long e0, long e1, long e2, long e3);
++        public static Vector256<Byte> Create(Vector128<byte> lower, Vector128<byte> upper);
++        public static Vector256<Double> Create(Vector128<double> lower, Vector128<double> upper);
++        public static Vector256<Int16> Create(Vector128<short> lower, Vector128<short> upper);
++        public static Vector256<Int32> Create(Vector128<int> lower, Vector128<int> upper);
++        public static Vector256<Int64> Create(Vector128<long> lower, Vector128<long> upper);
++        public static Vector256<SByte> Create(Vector128<sbyte> lower, Vector128<sbyte> upper);
++        public static Vector256<Single> Create(Vector128<float> lower, Vector128<float> upper);
++        public static Vector256<UInt16> Create(Vector128<ushort> lower, Vector128<ushort> upper);
++        public static Vector256<UInt32> Create(Vector128<uint> lower, Vector128<uint> upper);
++        public static Vector256<UInt64> Create(Vector128<ulong> lower, Vector128<ulong> upper);
++        public static Vector256<SByte> Create(sbyte value);
++        public static Vector256<SByte> Create(sbyte e0, sbyte e1, sbyte e2, sbyte e3, sbyte e4, sbyte e5, sbyte e6, sbyte e7, sbyte e8, sbyte e9, sbyte e10, sbyte e11, sbyte e12, sbyte e13, sbyte e14, sbyte e15, sbyte e16, sbyte e17, sbyte e18, sbyte e19, sbyte e20, sbyte e21, sbyte e22, sbyte e23, sbyte e24, sbyte e25, sbyte e26, sbyte e27, sbyte e28, sbyte e29, sbyte e30, sbyte e31);
++        public static Vector256<Single> Create(float value);
++        public static Vector256<Single> Create(float e0, float e1, float e2, float e3, float e4, float e5, float e6, float e7);
++        public static Vector256<UInt16> Create(ushort value);
++        public static Vector256<UInt16> Create(ushort e0, ushort e1, ushort e2, ushort e3, ushort e4, ushort e5, ushort e6, ushort e7, ushort e8, ushort e9, ushort e10, ushort e11, ushort e12, ushort e13, ushort e14, ushort e15);
++        public static Vector256<UInt32> Create(uint value);
++        public static Vector256<UInt32> Create(uint e0, uint e1, uint e2, uint e3, uint e4, uint e5, uint e6, uint e7);
++        public static Vector256<UInt64> Create(ulong value);
++        public static Vector256<UInt64> Create(ulong e0, ulong e1, ulong e2, ulong e3);
++        public static Vector256<Byte> CreateScalar(byte value);
++        public static Vector256<Double> CreateScalar(double value);
++        public static Vector256<Int16> CreateScalar(short value);
++        public static Vector256<Int32> CreateScalar(int value);
++        public static Vector256<Int64> CreateScalar(long value);
++        public static Vector256<SByte> CreateScalar(sbyte value);
++        public static Vector256<Single> CreateScalar(float value);
++        public static Vector256<UInt16> CreateScalar(ushort value);
++        public static Vector256<UInt32> CreateScalar(uint value);
++        public static Vector256<UInt64> CreateScalar(ulong value);
++        public static Vector256<Byte> CreateScalarUnsafe(byte value);
++        public static Vector256<Double> CreateScalarUnsafe(double value);
++        public static Vector256<Int16> CreateScalarUnsafe(short value);
++        public static Vector256<Int32> CreateScalarUnsafe(int value);
++        public static Vector256<Int64> CreateScalarUnsafe(long value);
++        public static Vector256<SByte> CreateScalarUnsafe(sbyte value);
++        public static Vector256<Single> CreateScalarUnsafe(float value);
++        public static Vector256<UInt16> CreateScalarUnsafe(ushort value);
++        public static Vector256<UInt32> CreateScalarUnsafe(uint value);
++        public static Vector256<UInt64> CreateScalarUnsafe(ulong value);
++    }
++    public readonly struct Vector256<T> where T : struct {
++        public static Vector256<T> Zero { get; }
++        public Vector256<U> As<U>() where U : struct;
++        public Vector256<Byte> AsByte();
++        public Vector256<Double> AsDouble();
++        public Vector256<Int16> AsInt16();
++        public Vector256<Int32> AsInt32();
++        public Vector256<Int64> AsInt64();
++        public Vector256<SByte> AsSByte();
++        public Vector256<Single> AsSingle();
++        public Vector256<UInt16> AsUInt16();
++        public Vector256<UInt32> AsUInt32();
++        public Vector256<UInt64> AsUInt64();
++        public T GetElement(int index);
++        public Vector128<T> GetLower();
++        public Vector128<T> GetUpper();
++        public T ToScalar();
++        public Vector256<T> WithElement(int index, T value);
++        public Vector256<T> WithLower(Vector128<T> value);
++        public Vector256<T> WithUpper(Vector128<T> value);
++    }
++    public static class Vector64 {
++        public static Vector64<Byte> Create(byte value);
++        public static Vector64<Byte> Create(byte e0, byte e1, byte e2, byte e3, byte e4, byte e5, byte e6, byte e7);
++        public static Vector64<Double> Create(double value);
++        public static Vector64<Int16> Create(short value);
++        public static Vector64<Int16> Create(short e0, short e1, short e2, short e3);
++        public static Vector64<Int32> Create(int value);
++        public static Vector64<Int32> Create(int e0, int e1);
++        public static Vector64<Int64> Create(long value);
++        public static Vector64<SByte> Create(sbyte value);
++        public static Vector64<SByte> Create(sbyte e0, sbyte e1, sbyte e2, sbyte e3, sbyte e4, sbyte e5, sbyte e6, sbyte e7);
++        public static Vector64<Single> Create(float value);
++        public static Vector64<Single> Create(float e0, float e1);
++        public static Vector64<UInt16> Create(ushort value);
++        public static Vector64<UInt16> Create(ushort e0, ushort e1, ushort e2, ushort e3);
++        public static Vector64<UInt32> Create(uint value);
++        public static Vector64<UInt32> Create(uint e0, uint e1);
++        public static Vector64<UInt64> Create(ulong value);
++        public static Vector64<Byte> CreateScalar(byte value);
++        public static Vector64<Int16> CreateScalar(short value);
++        public static Vector64<Int32> CreateScalar(int value);
++        public static Vector64<SByte> CreateScalar(sbyte value);
++        public static Vector64<Single> CreateScalar(float value);
++        public static Vector64<UInt16> CreateScalar(ushort value);
++        public static Vector64<UInt32> CreateScalar(uint value);
++        public static Vector64<Byte> CreateScalarUnsafe(byte value);
++        public static Vector64<Int16> CreateScalarUnsafe(short value);
++        public static Vector64<Int32> CreateScalarUnsafe(int value);
++        public static Vector64<SByte> CreateScalarUnsafe(sbyte value);
++        public static Vector64<Single> CreateScalarUnsafe(float value);
++        public static Vector64<UInt16> CreateScalarUnsafe(ushort value);
++        public static Vector64<UInt32> CreateScalarUnsafe(uint value);
++    }
++    public readonly struct Vector64<T> where T : struct {
++        public static Vector64<T> Zero { get; }
++        public Vector64<U> As<U>() where U : struct;
++        public Vector64<Byte> AsByte();
++        public Vector64<Double> AsDouble();
++        public Vector64<Int16> AsInt16();
++        public Vector64<Int32> AsInt32();
++        public Vector64<Int64> AsInt64();
++        public Vector64<SByte> AsSByte();
++        public Vector64<Single> AsSingle();
++        public Vector64<UInt16> AsUInt16();
++        public Vector64<UInt32> AsUInt32();
++        public Vector64<UInt64> AsUInt64();
++        public T GetElement(int index);
++        public T ToScalar();
++        public Vector128<T> ToVector128();
++        public Vector128<T> ToVector128Unsafe();
++        public Vector64<T> WithElement(int index, T value);
++    }
++}
+```
+
diff --git a/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Runtime.Loader.md b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Runtime.Loader.md
new file mode 100644
index 00000000..fb0aaf39
--- /dev/null
+++ b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Runtime.Loader.md
@@ -0,0 +1,12 @@
+# System.Runtime.Loader
+
+``` diff
+ namespace System.Runtime.Loader {
+     public abstract class AssemblyLoadContext {
++        protected AssemblyLoadContext(bool isCollectible);
++        public bool IsCollectible { get; }
++        public void Unload();
+     }
+ }
+```
+
diff --git a/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Runtime.Remoting.md b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Runtime.Remoting.md
new file mode 100644
index 00000000..a5440d34
--- /dev/null
+++ b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Runtime.Remoting.md
@@ -0,0 +1,11 @@
+# System.Runtime.Remoting
+
+``` diff
++namespace System.Runtime.Remoting {
++    public class ObjectHandle : MarshalByRefObject {
++        public ObjectHandle(object o);
++        public object Unwrap();
++    }
++}
+```
+
diff --git a/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Runtime.Serialization.md b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Runtime.Serialization.md
new file mode 100644
index 00000000..9ead0c8d
--- /dev/null
+++ b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Runtime.Serialization.md
@@ -0,0 +1,9 @@
+# System.Runtime.Serialization
+
+``` diff
+ namespace System.Runtime.Serialization {
+-    public struct SerializationEntry
++    public readonly struct SerializationEntry
+ }
+```
+
diff --git a/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Runtime.md b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Runtime.md
new file mode 100644
index 00000000..ddf2677a
--- /dev/null
+++ b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Runtime.md
@@ -0,0 +1,11 @@
+# System.Runtime
+
+``` diff
+ namespace System.Runtime {
++    public static class ProfileOptimization {
++        public static void SetProfileRoot(string directoryPath);
++        public static void StartProfile(string profile);
++    }
+ }
+```
+
diff --git a/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Security.Authentication.md b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Security.Authentication.md
new file mode 100644
index 00000000..46b40d76
--- /dev/null
+++ b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Security.Authentication.md
@@ -0,0 +1,10 @@
+# System.Security.Authentication
+
+``` diff
+ namespace System.Security.Authentication {
+     public enum SslProtocols {
++        Tls13 = 12288,
+     }
+ }
+```
+
diff --git a/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Security.Cryptography.md b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Security.Cryptography.md
new file mode 100644
index 00000000..0199757c
--- /dev/null
+++ b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Security.Cryptography.md
@@ -0,0 +1,116 @@
+# System.Security.Cryptography
+
+``` diff
+ namespace System.Security.Cryptography {
++    public sealed class AesCcm : IDisposable {
++        public AesCcm(byte[] key);
++        public AesCcm(ReadOnlySpan<byte> key);
++        public static KeySizes NonceByteSizes { get; }
++        public static KeySizes TagByteSizes { get; }
++        public void Decrypt(byte[] nonce, byte[] ciphertext, byte[] tag, byte[] plaintext, byte[] associatedData = null);
++        public void Decrypt(ReadOnlySpan<byte> nonce, ReadOnlySpan<byte> ciphertext, ReadOnlySpan<byte> tag, Span<byte> plaintext, ReadOnlySpan<byte> associatedData = default(ReadOnlySpan<byte>));
++        public void Dispose();
++        public void Encrypt(byte[] nonce, byte[] plaintext, byte[] ciphertext, byte[] tag, byte[] associatedData = null);
++        public void Encrypt(ReadOnlySpan<byte> nonce, ReadOnlySpan<byte> plaintext, Span<byte> ciphertext, Span<byte> tag, ReadOnlySpan<byte> associatedData = default(ReadOnlySpan<byte>));
++    }
++    public sealed class AesGcm : IDisposable {
++        public AesGcm(byte[] key);
++        public AesGcm(ReadOnlySpan<byte> key);
++        public static KeySizes NonceByteSizes { get; }
++        public static KeySizes TagByteSizes { get; }
++        public void Decrypt(byte[] nonce, byte[] ciphertext, byte[] tag, byte[] plaintext, byte[] associatedData = null);
++        public void Decrypt(ReadOnlySpan<byte> nonce, ReadOnlySpan<byte> ciphertext, ReadOnlySpan<byte> tag, Span<byte> plaintext, ReadOnlySpan<byte> associatedData = default(ReadOnlySpan<byte>));
++        public void Dispose();
++        public void Encrypt(byte[] nonce, byte[] plaintext, byte[] ciphertext, byte[] tag, byte[] associatedData = null);
++        public void Encrypt(ReadOnlySpan<byte> nonce, ReadOnlySpan<byte> plaintext, Span<byte> ciphertext, Span<byte> tag, ReadOnlySpan<byte> associatedData = default(ReadOnlySpan<byte>));
++    }
+     public abstract class AsymmetricAlgorithm : IDisposable {
++        public virtual byte[] ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<byte> passwordBytes, PbeParameters pbeParameters);
++        public virtual byte[] ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<char> password, PbeParameters pbeParameters);
++        public virtual byte[] ExportPkcs8PrivateKey();
++        public virtual byte[] ExportSubjectPublicKeyInfo();
++        public virtual void ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<byte> passwordBytes, ReadOnlySpan<byte> source, out int bytesRead);
++        public virtual void ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<char> password, ReadOnlySpan<byte> source, out int bytesRead);
++        public virtual void ImportPkcs8PrivateKey(ReadOnlySpan<byte> source, out int bytesRead);
++        public virtual void ImportSubjectPublicKeyInfo(ReadOnlySpan<byte> source, out int bytesRead);
++        public virtual bool TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<byte> passwordBytes, PbeParameters pbeParameters, Span<byte> destination, out int bytesWritten);
++        public virtual bool TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<char> password, PbeParameters pbeParameters, Span<byte> destination, out int bytesWritten);
++        public virtual bool TryExportPkcs8PrivateKey(Span<byte> destination, out int bytesWritten);
++        public virtual bool TryExportSubjectPublicKeyInfo(Span<byte> destination, out int bytesWritten);
+     }
+     public class CryptoStream : Stream, IDisposable {
++        public override ValueTask DisposeAsync();
+     }
+     public abstract class ECDiffieHellman : AsymmetricAlgorithm {
++        public virtual byte[] ExportECPrivateKey();
++        public virtual void ImportECPrivateKey(ReadOnlySpan<byte> source, out int bytesRead);
++        public virtual bool TryExportECPrivateKey(Span<byte> destination, out int bytesWritten);
+     }
+     public abstract class ECDsa : AsymmetricAlgorithm {
++        public virtual byte[] ExportECPrivateKey();
++        public virtual void ImportECPrivateKey(ReadOnlySpan<byte> source, out int bytesRead);
++        public virtual bool TryExportECPrivateKey(Span<byte> destination, out int bytesWritten);
+     }
+     public sealed class MD5CryptoServiceProvider : MD5 {
+-        protected sealed override void Dispose(bool disposing);
++        protected override void Dispose(bool disposing);
++        protected override void HashCore(ReadOnlySpan<byte> source);
++        protected override bool TryHashFinal(Span<byte> destination, out int bytesWritten);
+     }
++    public enum PbeEncryptionAlgorithm {
++        Aes128Cbc = 1,
++        Aes192Cbc = 2,
++        Aes256Cbc = 3,
++        TripleDes3KeyPkcs12 = 4,
++        Unknown = 0,
++    }
++    public sealed class PbeParameters {
++        public PbeParameters(PbeEncryptionAlgorithm encryptionAlgorithm, HashAlgorithmName hashAlgorithm, int iterationCount);
++        public PbeEncryptionAlgorithm EncryptionAlgorithm { get; }
++        public HashAlgorithmName HashAlgorithm { get; }
++        public int IterationCount { get; }
++    }
+     public abstract class RandomNumberGenerator : IDisposable {
++        public static int GetInt32(int toExclusive);
++        public static int GetInt32(int fromInclusive, int toExclusive);
+     }
+     public sealed class RNGCryptoServiceProvider : RandomNumberGenerator {
++        public override void GetBytes(byte[] data, int offset, int count);
++        public override void GetBytes(Span<byte> data);
++        public override void GetNonZeroBytes(Span<byte> data);
+     }
+     public abstract class RSA : AsymmetricAlgorithm {
++        public virtual byte[] ExportRSAPrivateKey();
++        public virtual byte[] ExportRSAPublicKey();
++        public virtual void ImportRSAPrivateKey(ReadOnlySpan<byte> source, out int bytesRead);
++        public virtual void ImportRSAPublicKey(ReadOnlySpan<byte> source, out int bytesRead);
++        public virtual bool TryExportRSAPrivateKey(Span<byte> destination, out int bytesWritten);
++        public virtual bool TryExportRSAPublicKey(Span<byte> destination, out int bytesWritten);
+     }
+     public sealed class SHA1CryptoServiceProvider : SHA1 {
+-        protected sealed override void Dispose(bool disposing);
++        protected override void Dispose(bool disposing);
++        protected override void HashCore(ReadOnlySpan<byte> source);
++        protected override bool TryHashFinal(Span<byte> destination, out int bytesWritten);
+     }
+     public sealed class SHA256CryptoServiceProvider : SHA256 {
+-        protected sealed override void Dispose(bool disposing);
++        protected override void Dispose(bool disposing);
++        protected override void HashCore(ReadOnlySpan<byte> source);
++        protected override bool TryHashFinal(Span<byte> destination, out int bytesWritten);
+     }
+     public sealed class SHA384CryptoServiceProvider : SHA384 {
+-        protected sealed override void Dispose(bool disposing);
++        protected override void Dispose(bool disposing);
++        protected override void HashCore(ReadOnlySpan<byte> source);
++        protected override bool TryHashFinal(Span<byte> destination, out int bytesWritten);
+     }
+     public sealed class SHA512CryptoServiceProvider : SHA512 {
+-        protected sealed override void Dispose(bool disposing);
++        protected override void Dispose(bool disposing);
++        protected override void HashCore(ReadOnlySpan<byte> source);
++        protected override bool TryHashFinal(Span<byte> destination, out int bytesWritten);
+     }
+ }
+```
+
diff --git a/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Text.Json.md b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Text.Json.md
new file mode 100644
index 00000000..87f9b67a
--- /dev/null
+++ b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Text.Json.md
@@ -0,0 +1,62 @@
+# System.Text.Json
+
+``` diff
++namespace System.Text.Json {
++    public enum JsonCommentHandling : byte {
++        Allow = (byte)1,
++        Disallow = (byte)0,
++        Skip = (byte)2,
++    }
++    public sealed class JsonReaderException : Exception {
++        public JsonReaderException(string message, long lineNumber, long bytePositionInLine);
++        public long BytePositionInLine { get; }
++        public long LineNumber { get; }
++        public override void GetObjectData(SerializationInfo info, StreamingContext context);
++    }
++    public struct JsonReaderOptions {
++        public JsonCommentHandling CommentHandling { get; set; }
++    }
++    public struct JsonReaderState {
++        public JsonReaderState(int maxDepth = 64, JsonReaderOptions options = default(JsonReaderOptions));
++        public long BytesConsumed { get; }
++        public int MaxDepth { get; }
++        public JsonReaderOptions Options { get; }
++        public SequencePosition Position { get; }
++    }
++    public enum JsonTokenType : byte {
++        Comment = (byte)11,
++        EndArray = (byte)4,
++        EndObject = (byte)2,
++        False = (byte)9,
++        None = (byte)0,
++        Null = (byte)10,
++        Number = (byte)7,
++        PropertyName = (byte)5,
++        StartArray = (byte)3,
++        StartObject = (byte)1,
++        String = (byte)6,
++        True = (byte)8,
++    }
++    public ref struct Utf8JsonReader {
++        public Utf8JsonReader(in ReadOnlySequence<byte> jsonData, bool isFinalBlock, JsonReaderState state);
++        public Utf8JsonReader(ReadOnlySpan<byte> jsonData, bool isFinalBlock, JsonReaderState state);
++        public long BytesConsumed { get; }
++        public int CurrentDepth { get; }
++        public JsonReaderState CurrentState { get; }
++        public bool HasValueSequence { get; }
++        public SequencePosition Position { get; }
++        public JsonTokenType TokenType { get; }
++        public ReadOnlySequence<byte> ValueSequence { get; }
++        public ReadOnlySpan<byte> ValueSpan { get; }
++        public bool GetBooleanValue();
++        public string GetStringValue();
++        public bool Read();
++        public bool TryGetDecimalValue(out decimal value);
++        public bool TryGetDoubleValue(out double value);
++        public bool TryGetInt32Value(out int value);
++        public bool TryGetInt64Value(out long value);
++        public bool TryGetSingleValue(out float value);
++    }
++}
+```
+
diff --git a/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Text.RegularExpressions.md b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Text.RegularExpressions.md
new file mode 100644
index 00000000..4b34e3eb
--- /dev/null
+++ b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Text.RegularExpressions.md
@@ -0,0 +1,15 @@
+# System.Text.RegularExpressions
+
+``` diff
+ namespace System.Text.RegularExpressions {
+-    public class GroupCollection : ICollection, ICollection<Group>, IEnumerable, IEnumerable<Group>, IList, IList<Group>, IReadOnlyCollection<Group>, IReadOnlyList<Group> {
++    public class GroupCollection : ICollection, ICollection<Group>, IEnumerable, IEnumerable<Group>, IEnumerable<KeyValuePair<string, Group>>, IList, IList<Group>, IReadOnlyCollection<Group>, IReadOnlyCollection<KeyValuePair<string, Group>>, IReadOnlyDictionary<string, Group>, IReadOnlyList<Group> {
++        public IEnumerable<string> Keys { get; }
++        public IEnumerable<Group> Values { get; }
++        public bool ContainsKey(string key);
++        IEnumerator<KeyValuePair<string, Group>> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<System.String,System.Text.RegularExpressions.Group>>.GetEnumerator();
++        public bool TryGetValue(string key, out Group value);
+     }
+ }
+```
+
diff --git a/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Text.md b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Text.md
new file mode 100644
index 00000000..7a92b0a1
--- /dev/null
+++ b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Text.md
@@ -0,0 +1,82 @@
+# System.Text
+
+``` diff
+ namespace System.Text {
++    public readonly struct Rune : IComparable<Rune>, IEquatable<Rune> {
++        public Rune(char ch);
++        public Rune(int value);
++        public Rune(uint value);
++        public bool IsAscii { get; }
++        public bool IsBmp { get; }
++        public int Plane { get; }
++        public static Rune ReplacementChar { get; }
++        public int Utf16SequenceLength { get; }
++        public int Utf8SequenceLength { get; }
++        public int Value { get; }
++        public int CompareTo(Rune other);
++        public override bool Equals(object obj);
++        public bool Equals(Rune other);
++        public override int GetHashCode();
++        public static double GetNumericValue(Rune value);
++        public static Rune GetRuneAt(string input, int index);
++        public static UnicodeCategory GetUnicodeCategory(Rune value);
++        public static bool IsControl(Rune value);
++        public static bool IsDigit(Rune value);
++        public static bool IsLetter(Rune value);
++        public static bool IsLetterOrDigit(Rune value);
++        public static bool IsLower(Rune value);
++        public static bool IsNumber(Rune value);
++        public static bool IsPunctuation(Rune value);
++        public static bool IsSeparator(Rune value);
++        public static bool IsSymbol(Rune value);
++        public static bool IsUpper(Rune value);
++        public static bool IsValid(int value);
++        public static bool IsValid(uint value);
++        public static bool IsWhiteSpace(Rune value);
++        public static bool operator ==(Rune left, Rune right);
++        public static explicit operator Rune (char ch);
++        public static explicit operator Rune (int value);
++        public static explicit operator Rune (uint value);
++        public static bool operator >(Rune left, Rune right);
++        public static bool operator >=(Rune left, Rune right);
++        public static bool operator !=(Rune left, Rune right);
++        public static bool operator <(Rune left, Rune right);
++        public static bool operator <=(Rune left, Rune right);
++        public static Rune ToLower(Rune value, CultureInfo culture);
++        public static Rune ToLowerInvariant(Rune value);
++        public override string ToString();
++        public static Rune ToUpper(Rune value, CultureInfo culture);
++        public static Rune ToUpperInvariant(Rune value);
++        public static bool TryCreate(char ch, out Rune result);
++        public static bool TryCreate(int value, out Rune result);
++        public static bool TryCreate(uint value, out Rune result);
++        public bool TryEncode(Span<char> destination, out int charsWritten);
++        public static bool TryGetRuneAt(string input, int index, out Rune value);
++    }
++    public ref struct SpanRuneEnumerator {
++        public Rune Current { get; }
++        public SpanRuneEnumerator GetEnumerator();
++        public bool MoveNext();
++    }
+     public sealed class StringBuilder : ISerializable {
++        public StringBuilder Append(ReadOnlyMemory<char> value);
++        public StringBuilder.ChunkEnumerator GetChunks();
++        public struct ChunkEnumerator {
++            public ReadOnlyMemory<char> Current { get; }
++            public StringBuilder.ChunkEnumerator GetEnumerator();
++            public bool MoveNext();
++        }
+     }
++    public struct StringRuneEnumerator : IDisposable, IEnumerable, IEnumerable<Rune>, IEnumerator, IEnumerator<Rune> {
++        public Rune Current { get; }
++        object System.Collections.IEnumerator.Current { get; }
++        public StringRuneEnumerator GetEnumerator();
++        public bool MoveNext();
++        IEnumerator<Rune> System.Collections.Generic.IEnumerable<System.Text.Rune>.GetEnumerator();
++        IEnumerator System.Collections.IEnumerable.GetEnumerator();
++        void System.Collections.IEnumerator.Reset();
++        void System.IDisposable.Dispose();
++    }
+ }
+```
+
diff --git a/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Threading.Tasks.Sources.md b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Threading.Tasks.Sources.md
new file mode 100644
index 00000000..e7bbaf4f
--- /dev/null
+++ b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Threading.Tasks.Sources.md
@@ -0,0 +1,17 @@
+# System.Threading.Tasks.Sources
+
+``` diff
+ namespace System.Threading.Tasks.Sources {
++    public struct ManualResetValueTaskSourceCore<TResult> {
++        public bool RunContinuationsAsynchronously { get; set; }
++        public short Version { get; }
++        public TResult GetResult(short token);
++        public ValueTaskSourceStatus GetStatus(short token);
++        public void OnCompleted(Action<object> continuation, object state, short token, ValueTaskSourceOnCompletedFlags flags);
++        public void Reset();
++        public void SetException(Exception error);
++        public void SetResult(TResult result);
++    }
+ }
+```
+
diff --git a/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Threading.Tasks.md b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Threading.Tasks.md
new file mode 100644
index 00000000..baedb556
--- /dev/null
+++ b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Threading.Tasks.md
@@ -0,0 +1,10 @@
+# System.Threading.Tasks
+
+``` diff
+ namespace System.Threading.Tasks {
+     public static class TaskExtensions {
++        public static ConfiguredAsyncEnumerable<T> ConfigureAwait<T>(this IAsyncEnumerable<T> source, bool continueOnCapturedContext);
+     }
+ }
+```
+
diff --git a/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Threading.md b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Threading.md
new file mode 100644
index 00000000..8db64d7a
--- /dev/null
+++ b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Threading.md
@@ -0,0 +1,28 @@
+# System.Threading
+
+``` diff
+ namespace System.Threading {
+-    public struct AsyncLocalValueChangedArgs<T>
++    public readonly struct AsyncLocalValueChangedArgs<T>
+     public readonly struct CancellationToken {
++        public CancellationTokenRegistration UnsafeRegister(Action<object> callback, object state);
+     }
+     public readonly struct CancellationTokenRegistration : IDisposable, IEquatable<CancellationTokenRegistration> {
++        public ValueTask DisposeAsync();
++        public bool Unregister();
+     }
++    public interface IThreadPoolWorkItem {
++        void Execute();
++    }
+     public struct SpinWait {
++        public void SpinOnce(int sleep1Threshold);
+     }
+     public static class ThreadPool {
++        public static bool UnsafeQueueUserWorkItem(IThreadPoolWorkItem callBack, bool preferLocal);
+     }
+     public sealed class Timer : MarshalByRefObject, IDisposable {
++        public ValueTask DisposeAsync();
+     }
+ }
+```
+
diff --git a/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Windows.Markup.md b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Windows.Markup.md
new file mode 100644
index 00000000..44229a26
--- /dev/null
+++ b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Windows.Markup.md
@@ -0,0 +1,13 @@
+# System.Windows.Markup
+
+``` diff
++namespace System.Windows.Markup {
++    public sealed class ValueSerializerAttribute : Attribute {
++        public ValueSerializerAttribute(string valueSerializerTypeName);
++        public ValueSerializerAttribute(Type valueSerializerType);
++        public Type ValueSerializerType { get; }
++        public string ValueSerializerTypeName { get; }
++    }
++}
+```
+
diff --git a/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Xml.md b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Xml.md
new file mode 100644
index 00000000..86264bc2
--- /dev/null
+++ b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.Xml.md
@@ -0,0 +1,24 @@
+# System.Xml
+
+``` diff
+ namespace System.Xml {
++    public class XmlDataDocument : XmlDocument {
++        public XmlDataDocument();
++        public XmlDataDocument(DataSet dataset);
++        public DataSet DataSet { get; }
++        public override XmlNode CloneNode(bool deep);
++        public override XmlElement CreateElement(string prefix, string localName, string namespaceURI);
++        public override XmlEntityReference CreateEntityReference(string name);
++        protected override XPathNavigator CreateNavigator(XmlNode node);
++        public override XmlElement GetElementById(string elemId);
++        public XmlElement GetElementFromRow(DataRow r);
++        public override XmlNodeList GetElementsByTagName(string name);
++        public DataRow GetRowFromElement(XmlElement e);
++        public override void Load(Stream inStream);
++        public override void Load(TextReader txtReader);
++        public override void Load(string filename);
++        public override void Load(XmlReader reader);
++    }
+ }
+```
+
diff --git a/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.md b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.md
new file mode 100644
index 00000000..1340f954
--- /dev/null
+++ b/release-notes/3.0/preview/api-diff/preview1/3.0-preview1_System.md
@@ -0,0 +1,157 @@
+# System
+
+``` diff
+ namespace System {
+     public static class Activator {
++        public static ObjectHandle CreateInstance(string assemblyName, string typeName);
++        public static ObjectHandle CreateInstance(string assemblyName, string typeName, bool ignoreCase, BindingFlags bindingAttr, Binder binder, object[] args, CultureInfo culture, object[] activationAttributes);
++        public static ObjectHandle CreateInstance(string assemblyName, string typeName, object[] activationAttributes);
++        public static ObjectHandle CreateInstanceFrom(string assemblyFile, string typeName);
++        public static ObjectHandle CreateInstanceFrom(string assemblyFile, string typeName, bool ignoreCase, BindingFlags bindingAttr, Binder binder, object[] args, CultureInfo culture, object[] activationAttributes);
++        public static ObjectHandle CreateInstanceFrom(string assemblyFile, string typeName, object[] activationAttributes);
+     }
+-    public class AppDomain : MarshalByRefObject {
++    public sealed class AppDomain : MarshalByRefObject {
++        public AppDomainSetup SetupInformation { get; }
++        public ObjectHandle CreateInstance(string assemblyName, string typeName);
++        public ObjectHandle CreateInstance(string assemblyName, string typeName, bool ignoreCase, BindingFlags bindingAttr, Binder binder, object[] args, CultureInfo culture, object[] activationAttributes);
++        public ObjectHandle CreateInstance(string assemblyName, string typeName, object[] activationAttributes);
++        public object CreateInstanceAndUnwrap(string assemblyName, string typeName);
++        public object CreateInstanceAndUnwrap(string assemblyName, string typeName, bool ignoreCase, BindingFlags bindingAttr, Binder binder, object[] args, CultureInfo culture, object[] activationAttributes);
++        public object CreateInstanceAndUnwrap(string assemblyName, string typeName, object[] activationAttributes);
++        public ObjectHandle CreateInstanceFrom(string assemblyFile, string typeName);
++        public ObjectHandle CreateInstanceFrom(string assemblyFile, string typeName, bool ignoreCase, BindingFlags bindingAttr, Binder binder, object[] args, CultureInfo culture, object[] activationAttributes);
++        public ObjectHandle CreateInstanceFrom(string assemblyFile, string typeName, object[] activationAttributes);
++        public object CreateInstanceFromAndUnwrap(string assemblyFile, string typeName);
++        public object CreateInstanceFromAndUnwrap(string assemblyFile, string typeName, bool ignoreCase, BindingFlags bindingAttr, Binder binder, object[] args, CultureInfo culture, object[] activationAttributes);
++        public object CreateInstanceFromAndUnwrap(string assemblyFile, string typeName, object[] activationAttributes);
+     }
++    public sealed class AppDomainSetup {
++        public string ApplicationBase { get; }
++        public string TargetFrameworkName { get; }
++    }
++    public ref struct ArgIterator {
++        public ArgIterator(RuntimeArgumentHandle arglist);
++        public unsafe ArgIterator(RuntimeArgumentHandle arglist, void* ptr);
++        public void End();
++        public override bool Equals(object o);
++        public override int GetHashCode();
++        public TypedReference GetNextArg();
++        public TypedReference GetNextArg(RuntimeTypeHandle rth);
++        public RuntimeTypeHandle GetNextArgType();
++        public int GetRemainingCount();
++    }
+-    public struct Boolean : IComparable, IComparable<bool>, IConvertible, IEquatable<bool>
++    public readonly struct Boolean : IComparable, IComparable<bool>, IConvertible, IEquatable<bool>
+-    public struct Byte : IComparable, IComparable<byte>, IConvertible, IEquatable<byte>, IFormattable
++    public readonly struct Byte : IComparable, IComparable<byte>, IConvertible, IEquatable<byte>, IFormattable
+-    public struct Char : IComparable, IComparable<char>, IConvertible, IEquatable<char>
++    public readonly struct Char : IComparable, IComparable<char>, IConvertible, IEquatable<char>
+-    public struct DateTimeOffset : IComparable, IComparable<DateTimeOffset>, IDeserializationCallback, IEquatable<DateTimeOffset>, IFormattable, ISerializable
++    public readonly struct DateTimeOffset : IComparable, IComparable<DateTimeOffset>, IDeserializationCallback, IEquatable<DateTimeOffset>, IFormattable, ISerializable
+-    public struct Decimal : IComparable, IComparable<decimal>, IConvertible, IDeserializationCallback, IEquatable<decimal>, IFormattable
++    public readonly struct Decimal : IComparable, IComparable<decimal>, IConvertible, IDeserializationCallback, IEquatable<decimal>, IFormattable
+-    public struct Double : IComparable, IComparable<double>, IConvertible, IEquatable<double>, IFormattable
++    public readonly struct Double : IComparable, IComparable<double>, IConvertible, IEquatable<double>, IFormattable
+     public class Exception : ISerializable {
+-        public int HResult { get; protected set; }
++        public int HResult { get; set; }
+     }
+     public abstract class FormattableString : IFormattable {
++        public static string CurrentCulture(FormattableString formattable);
+     }
++    public interface IAsyncDisposable {
++        ValueTask DisposeAsync();
++    }
++    public readonly struct Index : IEquatable<Index> {
++        public Index(int value, bool fromEnd);
++        public bool FromEnd { get; }
++        public int Value { get; }
++        public bool Equals(Index other);
++        public override bool Equals(object value);
++        public override int GetHashCode();
++        public static implicit operator Index (int value);
++        public override string ToString();
++    }
+-    public struct Int16 : IComparable, IComparable<short>, IConvertible, IEquatable<short>, IFormattable
++    public readonly struct Int16 : IComparable, IComparable<short>, IConvertible, IEquatable<short>, IFormattable
+-    public struct Int32 : IComparable, IComparable<int>, IConvertible, IEquatable<int>, IFormattable
++    public readonly struct Int32 : IComparable, IComparable<int>, IConvertible, IEquatable<int>, IFormattable
+-    public struct Int64 : IComparable, IComparable<long>, IConvertible, IEquatable<long>, IFormattable
++    public readonly struct Int64 : IComparable, IComparable<long>, IConvertible, IEquatable<long>, IFormattable
+-    public struct IntPtr : IEquatable<IntPtr>, ISerializable
++    public readonly struct IntPtr : IEquatable<IntPtr>, ISerializable
+     public static class Math {
++        public static double BitDecrement(double x);
++        public static double BitIncrement(double x);
++        public static double CopySign(double x, double y);
++        public static double FusedMultiplyAdd(double x, double y, double z);
++        public static int ILogB(double x);
++        public static double Log2(double x);
++        public static double MaxMagnitude(double x, double y);
++        public static double MinMagnitude(double x, double y);
++        public static double ScaleB(double x, int n);
+     }
+     public static class MathF {
++        public static float BitDecrement(float x);
++        public static float BitIncrement(float x);
++        public static float CopySign(float x, float y);
++        public static float FusedMultiplyAdd(float x, float y, float z);
++        public static int ILogB(float x);
++        public static float Log2(float x);
++        public static float MaxMagnitude(float x, float y);
++        public static float MinMagnitude(float x, float y);
++        public static float ScaleB(float x, int n);
+     }
+     public static class MemoryExtensions {
++        public static bool Contains<T>(this ReadOnlySpan<T> span, T value) where T : IEquatable<T>;
++        public static bool Contains<T>(this Span<T> span, T value) where T : IEquatable<T>;
++        public static SpanRuneEnumerator EnumerateRunes(this ReadOnlySpan<char> span);
++        public static SpanRuneEnumerator EnumerateRunes(this Span<char> span);
++        public static int LastIndexOf(this ReadOnlySpan<char> span, ReadOnlySpan<char> value, StringComparison comparisonType);
+     }
++    public readonly struct Range : IEquatable<Range> {
++        public Index End { get; }
++        public Index Start { get; }
++        public static Range All();
++        public static Range Create(Index start, Index end);
++        public override bool Equals(object value);
++        public bool Equals(Range other);
++        public static Range FromStart(Index start);
++        public override int GetHashCode();
++        public static Range ToEnd(Index end);
++        public override string ToString();
++    }
+     public readonly ref struct ReadOnlySpan<T> {
++        public ref readonly T this[Index index] { get; }
++        public ReadOnlySpan<T> this[Range range] { get; }
+     }
+-    public struct SByte : IComparable, IComparable<sbyte>, IConvertible, IEquatable<sbyte>, IFormattable
++    public readonly struct SByte : IComparable, IComparable<sbyte>, IConvertible, IEquatable<sbyte>, IFormattable
+-    public struct Single : IComparable, IComparable<float>, IConvertible, IEquatable<float>, IFormattable
++    public readonly struct Single : IComparable, IComparable<float>, IConvertible, IEquatable<float>, IFormattable
+     public readonly ref struct Span<T> {
++        public ref T this[Index index] { get; }
++        public Span<T> this[Range range] { get; }
+     }
+     public sealed class String : ICloneable, IComparable, IComparable<string>, IConvertible, IEnumerable, IEnumerable<char>, IEquatable<string> {
++        public StringRuneEnumerator EnumerateRunes();
++        public static int GetHashCode(ReadOnlySpan<char> value);
++        public static int GetHashCode(ReadOnlySpan<char> value, StringComparison comparisonType);
+     }
+-    public struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IFormattable
++    public readonly struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IFormattable
+     public abstract class Type : MemberInfo, IReflect {
++        public static Type MakeGenericSignatureType(Type genericTypeDefinition, params Type[] typeArguments);
+     }
+-    public struct UInt16 : IComparable, IComparable<ushort>, IConvertible, IEquatable<ushort>, IFormattable
++    public readonly struct UInt16 : IComparable, IComparable<ushort>, IConvertible, IEquatable<ushort>, IFormattable
+-    public struct UInt32 : IComparable, IComparable<uint>, IConvertible, IEquatable<uint>, IFormattable
++    public readonly struct UInt32 : IComparable, IComparable<uint>, IConvertible, IEquatable<uint>, IFormattable
+-    public struct UInt64 : IComparable, IComparable<ulong>, IConvertible, IEquatable<ulong>, IFormattable
++    public readonly struct UInt64 : IComparable, IComparable<ulong>, IConvertible, IEquatable<ulong>, IFormattable
+-    public struct UIntPtr : IEquatable<UIntPtr>, ISerializable
++    public readonly struct UIntPtr : IEquatable<UIntPtr>, ISerializable
+ }
+```
+