diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6.md
new file mode 100644
index 0000000000..2826817edd
--- /dev/null
+++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6.md
@@ -0,0 +1,16 @@
+# API Difference 9.0-preview5 vs 9.0-preview6
+
+API listing follows standard diff formatting.
+Lines preceded by a '+' are additions and a '-' indicates removal.
+
+* [Microsoft.AspNetCore.Authentication](9.0-preview6_Microsoft.AspNetCore.Authentication.md)
+* [Microsoft.AspNetCore.Builder](9.0-preview6_Microsoft.AspNetCore.Builder.md)
+* [Microsoft.AspNetCore.Components](9.0-preview6_Microsoft.AspNetCore.Components.md)
+* [Microsoft.AspNetCore.Components.HtmlRendering.Infrastructure](9.0-preview6_Microsoft.AspNetCore.Components.HtmlRendering.Infrastructure.md)
+* [Microsoft.AspNetCore.Components.RenderTree](9.0-preview6_Microsoft.AspNetCore.Components.RenderTree.md)
+* [Microsoft.AspNetCore.Cors.Infrastructure](9.0-preview6_Microsoft.AspNetCore.Cors.Infrastructure.md)
+* [Microsoft.AspNetCore.Mvc.TagHelpers](9.0-preview6_Microsoft.AspNetCore.Mvc.TagHelpers.md)
+* [Microsoft.AspNetCore.StaticAssets](9.0-preview6_Microsoft.AspNetCore.StaticAssets.md)
+* [Microsoft.AspNetCore.StaticAssets.Infrastructure](9.0-preview6_Microsoft.AspNetCore.StaticAssets.Infrastructure.md)
+* [Microsoft.AspNetCore.WebUtilities](9.0-preview6_Microsoft.AspNetCore.WebUtilities.md)
+
diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.Authentication.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.Authentication.md
new file mode 100644
index 0000000000..e44c521a81
--- /dev/null
+++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.Authentication.md
@@ -0,0 +1,11 @@
+# Microsoft.AspNetCore.Authentication
+
+``` diff
+ namespace Microsoft.AspNetCore.Authentication {
+     public abstract class ResultContext<TOptions> : BaseContext<TOptions> where TOptions : AuthenticationSchemeOptions {
+-        public AuthenticateResult Result { get; }
++        public AuthenticateResult? Result { get; }
+     }
+ }
+```
+
diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.Builder.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.Builder.md
new file mode 100644
index 0000000000..d9c40ef4ed
--- /dev/null
+++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.Builder.md
@@ -0,0 +1,16 @@
+# Microsoft.AspNetCore.Builder
+
+``` diff
+ namespace Microsoft.AspNetCore.Builder {
++    public static class ControllerActionEndpointConventionBuilderResourceCollectionExtensions {
++        public static ControllerActionEndpointConventionBuilder WithStaticAssets(this ControllerActionEndpointConventionBuilder builder, string manifestPath = null);
++    }
++    public static class PageActionEndpointConventionBuilderResourceCollectionExtensions {
++        public static PageActionEndpointConventionBuilder WithStaticAssets(this PageActionEndpointConventionBuilder builder, string? manifestPath = null);
++    }
+     public static class RazorComponentsEndpointConventionBuilderExtensions {
++        public static RazorComponentsEndpointConventionBuilder WithStaticAssets(this RazorComponentsEndpointConventionBuilder builder, string? manifestPath = null);
+     }
+ }
+```
+
diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.Components.HtmlRendering.Infrastructure.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.Components.HtmlRendering.Infrastructure.md
new file mode 100644
index 0000000000..a16ecc5853
--- /dev/null
+++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.Components.HtmlRendering.Infrastructure.md
@@ -0,0 +1,12 @@
+# Microsoft.AspNetCore.Components.HtmlRendering.Infrastructure
+
+``` diff
+ namespace Microsoft.AspNetCore.Components.HtmlRendering.Infrastructure {
+     public class StaticHtmlRenderer : Renderer {
+-        protected internal override ComponentPlatform ComponentPlatform { get; }
+
++        protected internal override RendererInfo RendererInfo { get; }
+     }
+ }
+```
+
diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.Components.RenderTree.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.Components.RenderTree.md
new file mode 100644
index 0000000000..a6a9706970
--- /dev/null
+++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.Components.RenderTree.md
@@ -0,0 +1,13 @@
+# Microsoft.AspNetCore.Components.RenderTree
+
+``` diff
+ namespace Microsoft.AspNetCore.Components.RenderTree {
+     public abstract class Renderer : IAsyncDisposable, IDisposable {
++        protected internal virtual ResourceAssetCollection Assets { get; }
+-        protected internal virtual ComponentPlatform ComponentPlatform { get; }
+
++        protected internal virtual RendererInfo RendererInfo { get; }
+     }
+ }
+```
+
diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.Components.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.Components.md
new file mode 100644
index 0000000000..ce4acd6fa9
--- /dev/null
+++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.Components.md
@@ -0,0 +1,69 @@
+# Microsoft.AspNetCore.Components
+
+``` diff
+ namespace Microsoft.AspNetCore.Components {
+     public abstract class ComponentBase : IComponent, IHandleAfterRender, IHandleEvent {
++        protected ResourceAssetCollection Assets { get; }
+-        protected ComponentPlatform Platform { get; }
+
++        protected RendererInfo RendererInfo { get; }
+     }
+-    public sealed class ComponentPlatform {
+ {
+-        public ComponentPlatform(string platformName, bool isInteractive);
+
+-        public bool IsInteractive { get; }
+
+-        public string Name { get; }
+
+-    }
++    public sealed class ImportMap : IComponent {
++        public ImportMap();
++        public HttpContext HttpContext { get; set; }
++        public ImportMapDefinition ImportMapDefinition { get; set; }
++        void IComponent.Attach(RenderHandle renderHandle);
++        Task IComponent.SetParametersAsync(ParameterView parameters);
++    }
++    public sealed class ImportMapDefinition {
++        public ImportMapDefinition(IReadOnlyDictionary<string, string>? imports, IReadOnlyDictionary<string, IReadOnlyDictionary<string, string>>? scopes, IReadOnlyDictionary<string, string>? integrity);
++        public IReadOnlyDictionary<string, string>? Imports { get; }
++        public IReadOnlyDictionary<string, string>? Integrity { get; }
++        public IReadOnlyDictionary<string, IReadOnlyDictionary<string, string>>? Scopes { get; }
++        public static ImportMapDefinition Combine(params ImportMapDefinition[] sources);
++        public static ImportMapDefinition FromResourceCollection(ResourceAssetCollection assets);
++        public override string ToString();
++    }
++    public sealed class RendererInfo {
++        public RendererInfo(string rendererName, bool isInteractive);
++        public bool IsInteractive { get; }
++        public string Name { get; }
++    }
+     public readonly struct RenderHandle {
++        public ResourceAssetCollection Assets { get; }
+-        public ComponentPlatform Platform { get; }
+
++        public RendererInfo RendererInfo { get; }
+     }
++    public sealed class ResourceAsset {
++        public ResourceAsset(string url, IReadOnlyList<ResourceAssetProperty>? properties);
++        public IReadOnlyList<ResourceAssetProperty>? Properties { get; }
++        public string Url { get; }
++    }
++    public sealed class ResourceAssetCollection : IEnumerable, IEnumerable<ResourceAsset>, IReadOnlyCollection<ResourceAsset>, IReadOnlyList<ResourceAsset> {
++        public static readonly ResourceAssetCollection Empty;
++        public ResourceAssetCollection(IReadOnlyList<ResourceAsset> resources);
++        int IReadOnlyCollection<ResourceAsset>.Count { get; }
++        ResourceAsset IReadOnlyList<ResourceAsset>.this[int index] { get; }
++        public string this[string key] { get; }
++        public bool IsContentSpecificUrl(string path);
++        IEnumerator<ResourceAsset> IEnumerable<ResourceAsset>.GetEnumerator();
++        IEnumerator IEnumerable.GetEnumerator();
++    }
++    public sealed class ResourceAssetProperty {
++        public ResourceAssetProperty(string name, string value);
++        public string Name { get; }
++        public string Value { get; }
++    }
+ }
+```
+
diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.Cors.Infrastructure.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.Cors.Infrastructure.md
new file mode 100644
index 0000000000..0559604347
--- /dev/null
+++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.Cors.Infrastructure.md
@@ -0,0 +1,11 @@
+# Microsoft.AspNetCore.Cors.Infrastructure
+
+``` diff
+ namespace Microsoft.AspNetCore.Cors.Infrastructure {
+     public static class CorsConstants {
++        public static readonly string AnyHeader;
++        public static readonly string AnyMethod;
+     }
+ }
+```
+
diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.Mvc.TagHelpers.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.Mvc.TagHelpers.md
new file mode 100644
index 0000000000..7a52694353
--- /dev/null
+++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.Mvc.TagHelpers.md
@@ -0,0 +1,11 @@
+# Microsoft.AspNetCore.Mvc.TagHelpers
+
+``` diff
+ namespace Microsoft.AspNetCore.Mvc.TagHelpers {
+     public class ScriptTagHelper : UrlResolutionTagHelper {
++        public ImportMapDefinition ImportMap { get; set; }
++        public string Type { get; set; }
+     }
+ }
+```
+
diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.StaticAssets.Infrastructure.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.StaticAssets.Infrastructure.md
new file mode 100644
index 0000000000..168286660f
--- /dev/null
+++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.StaticAssets.Infrastructure.md
@@ -0,0 +1,13 @@
+# Microsoft.AspNetCore.StaticAssets.Infrastructure
+
+``` diff
+ namespace Microsoft.AspNetCore.StaticAssets.Infrastructure {
+     public static class StaticAssetsEndpointDataSourceHelper {
++        public static bool HasStaticAssetsDataSource(IEndpointRouteBuilder builder, string? staticAssetsManifestPath = null);
+-        public static bool IsStaticAssetsDataSource(EndpointDataSource dataSource, string? staticAssetsManifestPath = null);
+
++        public static IReadOnlyList<StaticAssetDescriptor> ResolveStaticAssetDescriptors(IEndpointRouteBuilder endpointRouteBuilder, string? manifestPath);
+     }
+ }
+```
+
diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.StaticAssets.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.StaticAssets.md
new file mode 100644
index 0000000000..a80fc554c4
--- /dev/null
+++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.StaticAssets.md
@@ -0,0 +1,31 @@
+# Microsoft.AspNetCore.StaticAssets
+
+``` diff
+ namespace Microsoft.AspNetCore.StaticAssets {
++    public sealed class StaticAssetDescriptor {
++        public StaticAssetDescriptor();
++        public string AssetPath { get; set; }
++        public IReadOnlyList<StaticAssetProperty> Properties { get; set; }
++        public IReadOnlyList<StaticAssetResponseHeader> ResponseHeaders { get; set; }
++        public string Route { get; set; }
++        public IReadOnlyList<StaticAssetSelector> Selectors { get; set; }
++    }
++    public sealed class StaticAssetProperty {
++        public StaticAssetProperty(string name, string value);
++        public string Name { get; }
++        public string Value { get; }
++    }
++    public sealed class StaticAssetResponseHeader {
++        public StaticAssetResponseHeader(string name, string value);
++        public string Name { get; }
++        public string Value { get; }
++    }
++    public sealed class StaticAssetSelector {
++        public StaticAssetSelector(string name, string value, string quality);
++        public string Name { get; }
++        public string Quality { get; }
++        public string Value { get; }
++    }
+ }
+```
+
diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.WebUtilities.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.WebUtilities.md
new file mode 100644
index 0000000000..0a1863afc9
--- /dev/null
+++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.AspNetCore.App/9.0-preview6_Microsoft.AspNetCore.WebUtilities.md
@@ -0,0 +1,10 @@
+# Microsoft.AspNetCore.WebUtilities
+
+``` diff
+ namespace Microsoft.AspNetCore.WebUtilities {
+     public static class WebEncoders {
++        public static int Base64UrlEncode(ReadOnlySpan<byte> input, Span<char> output);
+     }
+ }
+```
+
diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6.md
new file mode 100644
index 0000000000..6f6dfe0dee
--- /dev/null
+++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6.md
@@ -0,0 +1,33 @@
+# API Difference 9.0-preview5 vs 9.0-preview6
+
+API listing follows standard diff formatting.
+Lines preceded by a '+' are additions and a '-' indicates removal.
+
+* [System](9.0-preview6_System.md)
+* [System.Buffers.Text](9.0-preview6_System.Buffers.Text.md)
+* [System.Collections.Concurrent](9.0-preview6_System.Collections.Concurrent.md)
+* [System.Collections.Frozen](9.0-preview6_System.Collections.Frozen.md)
+* [System.Collections.Generic](9.0-preview6_System.Collections.Generic.md)
+* [System.Collections.ObjectModel](9.0-preview6_System.Collections.ObjectModel.md)
+* [System.Diagnostics](9.0-preview6_System.Diagnostics.md)
+* [System.Diagnostics.Metrics](9.0-preview6_System.Diagnostics.Metrics.md)
+* [System.IO](9.0-preview6_System.IO.md)
+* [System.Net.Http](9.0-preview6_System.Net.Http.md)
+* [System.Net.Mime](9.0-preview6_System.Net.Mime.md)
+* [System.Net.Sockets](9.0-preview6_System.Net.Sockets.md)
+* [System.Numerics](9.0-preview6_System.Numerics.md)
+* [System.Reflection.Emit](9.0-preview6_System.Reflection.Emit.md)
+* [System.Runtime.InteropServices](9.0-preview6_System.Runtime.InteropServices.md)
+* [System.Runtime.InteropServices.Marshalling](9.0-preview6_System.Runtime.InteropServices.Marshalling.md)
+* [System.Runtime.InteropServices.Swift](9.0-preview6_System.Runtime.InteropServices.Swift.md)
+* [System.Runtime.Intrinsics](9.0-preview6_System.Runtime.Intrinsics.md)
+* [System.Runtime.Intrinsics.Arm](9.0-preview6_System.Runtime.Intrinsics.Arm.md)
+* [System.Runtime.Intrinsics.X86](9.0-preview6_System.Runtime.Intrinsics.X86.md)
+* [System.Security.Cryptography](9.0-preview6_System.Security.Cryptography.md)
+* [System.Text.Json](9.0-preview6_System.Text.Json.md)
+* [System.Text.Json.Nodes](9.0-preview6_System.Text.Json.Nodes.md)
+* [System.Text.Json.Schema](9.0-preview6_System.Text.Json.Schema.md)
+* [System.Text.Json.Serialization](9.0-preview6_System.Text.Json.Serialization.md)
+* [System.Text.Json.Serialization.Metadata](9.0-preview6_System.Text.Json.Serialization.Metadata.md)
+* [System.Text.RegularExpressions](9.0-preview6_System.Text.RegularExpressions.md)
+
diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Buffers.Text.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Buffers.Text.md
new file mode 100644
index 0000000000..7e3633f6cf
--- /dev/null
+++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Buffers.Text.md
@@ -0,0 +1,34 @@
+# System.Buffers.Text
+
+``` diff
+ namespace System.Buffers.Text {
++    public static class Base64Url {
++        public static byte[] DecodeFromChars(ReadOnlySpan<char> source);
++        public static int DecodeFromChars(ReadOnlySpan<char> source, Span<byte> destination);
++        public static OperationStatus DecodeFromChars(ReadOnlySpan<char> source, Span<byte> destination, out int charsConsumed, out int bytesWritten, bool isFinalBlock = true);
++        public static byte[] DecodeFromUtf8(ReadOnlySpan<byte> source);
++        public static int DecodeFromUtf8(ReadOnlySpan<byte> source, Span<byte> destination);
++        public static OperationStatus DecodeFromUtf8(ReadOnlySpan<byte> source, Span<byte> destination, out int bytesConsumed, out int bytesWritten, bool isFinalBlock = true);
++        public static int DecodeFromUtf8InPlace(Span<byte> buffer);
++        public static char[] EncodeToChars(ReadOnlySpan<byte> source);
++        public static int EncodeToChars(ReadOnlySpan<byte> source, Span<char> destination);
++        public static OperationStatus EncodeToChars(ReadOnlySpan<byte> source, Span<char> destination, out int bytesConsumed, out int charsWritten, bool isFinalBlock = true);
++        public static string EncodeToString(ReadOnlySpan<byte> source);
++        public static byte[] EncodeToUtf8(ReadOnlySpan<byte> source);
++        public static int EncodeToUtf8(ReadOnlySpan<byte> source, Span<byte> destination);
++        public static OperationStatus EncodeToUtf8(ReadOnlySpan<byte> source, Span<byte> destination, out int bytesConsumed, out int bytesWritten, bool isFinalBlock = true);
++        public static int GetEncodedLength(int bytesLength);
++        public static int GetMaxDecodedLength(int base64Length);
++        public static bool IsValid(ReadOnlySpan<byte> utf8Base64UrlText);
++        public static bool IsValid(ReadOnlySpan<byte> utf8Base64UrlText, out int decodedLength);
++        public static bool IsValid(ReadOnlySpan<char> base64UrlText);
++        public static bool IsValid(ReadOnlySpan<char> base64UrlText, out int decodedLength);
++        public static bool TryDecodeFromChars(ReadOnlySpan<char> source, Span<byte> destination, out int bytesWritten);
++        public static bool TryDecodeFromUtf8(ReadOnlySpan<byte> source, Span<byte> destination, out int bytesWritten);
++        public static bool TryEncodeToChars(ReadOnlySpan<byte> source, Span<char> destination, out int charsWritten);
++        public static bool TryEncodeToUtf8(ReadOnlySpan<byte> source, Span<byte> destination, out int bytesWritten);
++        public static bool TryEncodeToUtf8InPlace(Span<byte> buffer, int dataLength, out int bytesWritten);
++    }
+ }
+```
+
diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Collections.Concurrent.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Collections.Concurrent.md
new file mode 100644
index 0000000000..37c29ef172
--- /dev/null
+++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Collections.Concurrent.md
@@ -0,0 +1,21 @@
+# System.Collections.Concurrent
+
+``` diff
+ namespace System.Collections.Concurrent {
+     public class ConcurrentDictionary<TKey, TValue> : ICollection, ICollection<KeyValuePair<TKey, TValue>>, IDictionary, IDictionary<TKey, TValue>, IEnumerable, IEnumerable<KeyValuePair<TKey, TValue>>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, IReadOnlyDictionary<TKey, TValue> {
++        public ConcurrentDictionary.AlternateLookup<TAlternateKey> GetAlternateLookup<TAlternateKey>();
++        public bool TryGetAlternateLookup<TAlternateKey>(out ConcurrentDictionary.AlternateLookup<TAlternateKey> lookup);
++        public readonly struct AlternateLookup<TAlternateKey> {
++            public ConcurrentDictionary<TKey, TValue> Dictionary { get; }
++            public TValue this[TAlternateKey key] { get; set; }
++            public bool ContainsKey(TAlternateKey key);
++            public bool TryAdd(TAlternateKey key, TValue value);
++            public bool TryGetValue(TAlternateKey key, out TKey actualKey, out TValue value);
++            public bool TryGetValue(TAlternateKey key, out TValue value);
++            public bool TryRemove(TAlternateKey key, out TKey actualKey, out TValue value);
++            public bool TryRemove(TAlternateKey key, out TValue value);
++        }
+     }
+ }
+```
+
diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Collections.Frozen.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Collections.Frozen.md
new file mode 100644
index 0000000000..6a4a0b77e3
--- /dev/null
+++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Collections.Frozen.md
@@ -0,0 +1,26 @@
+# System.Collections.Frozen
+
+``` diff
+ namespace System.Collections.Frozen {
+     public abstract class FrozenDictionary<TKey, TValue> : ICollection, ICollection<KeyValuePair<TKey, TValue>>, IDictionary, IDictionary<TKey, TValue>, IEnumerable, IEnumerable<KeyValuePair<TKey, TValue>>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, IReadOnlyDictionary<TKey, TValue> {
++        public FrozenDictionary.AlternateLookup<TAlternateKey> GetAlternateLookup<TAlternateKey>();
++        public bool TryGetAlternateLookup<TAlternateKey>(out FrozenDictionary.AlternateLookup<TAlternateKey> lookup);
++        public readonly struct AlternateLookup<TAlternateKey> {
++            public FrozenDictionary<TKey, TValue> Dictionary { get; }
++            public TValue this[TAlternateKey key] { get; }
++            public bool ContainsKey(TAlternateKey key);
++            public bool TryGetValue(TAlternateKey key, out TValue value);
++        }
+     }
+     public abstract class FrozenSet<T> : ICollection, ICollection<T>, IEnumerable, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlySet<T>, ISet<T> {
++        public FrozenSet.AlternateLookup<TAlternate> GetAlternateLookup<TAlternate>();
++        public bool TryGetAlternateLookup<TAlternate>(out FrozenSet.AlternateLookup<TAlternate> lookup);
++        public readonly struct AlternateLookup<TAlternate> {
++            public FrozenSet<T> Set { get; }
++            public bool Contains(TAlternate item);
++            public bool TryGetValue(TAlternate equalValue, out T actualValue);
++        }
+     }
+ }
+```
+
diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Collections.Generic.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Collections.Generic.md
new file mode 100644
index 0000000000..b9728652b2
--- /dev/null
+++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Collections.Generic.md
@@ -0,0 +1,192 @@
+# System.Collections.Generic
+
+``` diff
+ namespace System.Collections.Generic {
+     public static class CollectionExtensions {
++        public static HashSet.AlternateLookup<TAlternate> GetAlternateLookup<T, TAlternate>(this HashSet<T> @set);
++        public static Dictionary.AlternateLookup<TAlternateKey> GetAlternateLookup<TKey, TValue, TAlternateKey>(this Dictionary<TKey, TValue> dictionary);
++        public static bool TryGetAlternateLookup<T, TAlternate>(this HashSet<T> @set, out HashSet.AlternateLookup<TAlternate> lookup);
++        public static bool TryGetAlternateLookup<TKey, TValue, TAlternateKey>(this Dictionary<TKey, TValue> dictionary, out Dictionary.AlternateLookup<TAlternateKey> lookup);
+     }
+     public class Dictionary<TKey, TValue> : ICollection, ICollection<KeyValuePair<TKey, TValue>>, IDeserializationCallback, IDictionary, IDictionary<TKey, TValue>, IEnumerable, IEnumerable<KeyValuePair<TKey, TValue>>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, IReadOnlyDictionary<TKey, TValue>, ISerializable {
++        public readonly struct AlternateLookup<TAlternateKey> {
++            public Dictionary<TKey, TValue> Dictionary { get; }
++            public TValue this[TAlternateKey key] { get; set; }
++            public bool ContainsKey(TAlternateKey key);
++            public bool Remove(TAlternateKey key);
++            public bool Remove(TAlternateKey key, out TKey actualKey, out TValue value);
++            public bool TryAdd(TAlternateKey key, TValue value);
++            public bool TryGetValue(TAlternateKey key, out TKey actualKey, out TValue value);
++            public bool TryGetValue(TAlternateKey key, out TValue value);
++        }
+     }
+     public class HashSet<T> : ICollection<T>, IDeserializationCallback, IEnumerable, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlySet<T>, ISerializable, ISet<T> {
++        public readonly struct AlternateLookup<TAlternate> {
++            public HashSet<T> Set { get; }
++            public bool Add(TAlternate item);
++            public bool Contains(TAlternate item);
++            public bool Remove(TAlternate item);
++            public bool TryGetValue(TAlternate equalValue, out T actualValue);
++        }
+     }
++    public interface IAlternateEqualityComparer<in TAlternate, T> {
++        T Create(TAlternate alternate);
++        bool Equals(TAlternate alternate, T other);
++        int GetHashCode(TAlternate alternate);
++    }
++    public class OrderedDictionary<TKey, TValue> : ICollection, ICollection<KeyValuePair<TKey, TValue>>, IDictionary, IDictionary<TKey, TValue>, IEnumerable, IEnumerable<KeyValuePair<TKey, TValue>>, IList, IList<KeyValuePair<TKey, TValue>>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, IReadOnlyDictionary<TKey, TValue>, IReadOnlyList<KeyValuePair<TKey, TValue>> {
++        public OrderedDictionary();
++        public OrderedDictionary(IDictionary<TKey, TValue> dictionary);
++        public OrderedDictionary(IDictionary<TKey, TValue> dictionary, IEqualityComparer<TKey>? comparer);
++        public OrderedDictionary(IEnumerable<KeyValuePair<TKey, TValue>> collection);
++        public OrderedDictionary(IEnumerable<KeyValuePair<TKey, TValue>> collection, IEqualityComparer<TKey>? comparer);
++        public OrderedDictionary(IEqualityComparer<TKey>? comparer);
++        public OrderedDictionary(int capacity);
++        public OrderedDictionary(int capacity, IEqualityComparer<TKey>? comparer);
++        public int Capacity { get; }
++        public IEqualityComparer<TKey> Comparer { get; }
++        public int Count { get; }
++        public OrderedDictionary<TKey, TValue>.KeyCollection Keys { get; }
++        bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly { get; }
++        ICollection<TKey> IDictionary<TKey, TValue>.Keys { get; }
++        ICollection<TValue> IDictionary<TKey, TValue>.Values { get; }
++        KeyValuePair<TKey, TValue> IList<KeyValuePair<TKey, TValue>>.this[int index] { get; set; }
++        IEnumerable<TKey> IReadOnlyDictionary<TKey, TValue>.Keys { get; }
++        IEnumerable<TValue> IReadOnlyDictionary<TKey, TValue>.Values { get; }
++        KeyValuePair<TKey, TValue> IReadOnlyList<KeyValuePair<TKey, TValue>>.this[int index] { get; }
++        bool ICollection.IsSynchronized { get; }
++        object ICollection.SyncRoot { get; }
++        bool IDictionary.IsFixedSize { get; }
++        bool IDictionary.IsReadOnly { get; }
++        object? IDictionary.this[object key] { get; set; }
++        ICollection IDictionary.Keys { get; }
++        ICollection IDictionary.Values { get; }
++        bool IList.IsFixedSize { get; }
++        bool IList.IsReadOnly { get; }
++        object? IList.this[int index] { get; set; }
++        public TValue this[TKey key] { get; set; }
++        public OrderedDictionary<TKey, TValue>.ValueCollection Values { get; }
++        public void Add(TKey key, TValue value);
++        public void Clear();
++        public bool ContainsKey(TKey key);
++        public bool ContainsValue(TValue value);
++        public int EnsureCapacity(int capacity);
++        public KeyValuePair<TKey, TValue> GetAt(int index);
++        public OrderedDictionary<TKey, TValue>.Enumerator GetEnumerator();
++        public int IndexOf(TKey key);
++        public void Insert(int index, TKey key, TValue value);
++        public bool Remove(TKey key);
++        public bool Remove(TKey key, out TValue value);
++        public void RemoveAt(int index);
++        public void SetAt(int index, TKey key, TValue value);
++        public void SetAt(int index, TValue value);
++        void ICollection<KeyValuePair<TKey, TValue>>.Add(KeyValuePair<TKey, TValue> item);
++        bool ICollection<KeyValuePair<TKey, TValue>>.Contains(KeyValuePair<TKey, TValue> item);
++        void ICollection<KeyValuePair<TKey, TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex);
++        bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> item);
++        IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator();
++        int IList<KeyValuePair<TKey, TValue>>.IndexOf(KeyValuePair<TKey, TValue> item);
++        void IList<KeyValuePair<TKey, TValue>>.Insert(int index, KeyValuePair<TKey, TValue> item);
++        void ICollection.CopyTo(Array array, int index);
++        void IDictionary.Add(object key, object value);
++        bool IDictionary.Contains(object key);
++        IDictionaryEnumerator IDictionary.GetEnumerator();
++        void IDictionary.Remove(object key);
++        IEnumerator IEnumerable.GetEnumerator();
++        int IList.Add(object value);
++        bool IList.Contains(object value);
++        int IList.IndexOf(object value);
++        void IList.Insert(int index, object value);
++        void IList.Remove(object value);
++        public void TrimExcess();
++        public void TrimExcess(int capacity);
++        public bool TryAdd(TKey key, TValue value);
++        public bool TryGetValue(TKey key, out TValue value);
++        public struct Enumerator : IDictionaryEnumerator, IDisposable, IEnumerator, IEnumerator<KeyValuePair<TKey, TValue>> {
++            public KeyValuePair<TKey, TValue> Current { get; }
++            DictionaryEntry System.Collections.IDictionaryEnumerator.Entry { get; }
++            object System.Collections.IDictionaryEnumerator.Key { get; }
++            object? System.Collections.IDictionaryEnumerator.Value { get; }
++            object System.Collections.IEnumerator.Current { get; }
++            public bool MoveNext();
++            void System.Collections.IEnumerator.Reset();
++            void System.IDisposable.Dispose();
++        }
++        public sealed class KeyCollection : ICollection, ICollection<TKey>, IEnumerable, IEnumerable<TKey>, IList, IList<TKey>, IReadOnlyCollection<TKey>, IReadOnlyList<TKey> {
++            public int Count { get; }
++            bool ICollection<TKey>.IsReadOnly { get; }
++            TKey IList<TKey>.this[int index] { get; set; }
++            TKey IReadOnlyList<TKey>.this[int index] { get; }
++            bool System.Collections.ICollection.IsSynchronized { get; }
++            object System.Collections.ICollection.SyncRoot { get; }
++            bool System.Collections.IList.IsFixedSize { get; }
++            bool System.Collections.IList.IsReadOnly { get; }
++            object? System.Collections.IList.this[int index] { get; set; }
++            public bool Contains(TKey key);
++            public void CopyTo(TKey[] array, int arrayIndex);
++            public OrderedDictionary<TKey, TValue>.KeyCollection.Enumerator GetEnumerator();
++            void ICollection<TKey>.Add(TKey item);
++            void ICollection<TKey>.Clear();
++            bool ICollection<TKey>.Remove(TKey item);
++            IEnumerator<TKey> IEnumerable<TKey>.GetEnumerator();
++            int IList<TKey>.IndexOf(TKey item);
++            void IList<TKey>.Insert(int index, TKey item);
++            void IList<TKey>.RemoveAt(int index);
++            void System.Collections.ICollection.CopyTo(Array array, int index);
++            IEnumerator System.Collections.IEnumerable.GetEnumerator();
++            int System.Collections.IList.Add(object value);
++            void System.Collections.IList.Clear();
++            bool System.Collections.IList.Contains(object value);
++            int System.Collections.IList.IndexOf(object value);
++            void System.Collections.IList.Insert(int index, object value);
++            void System.Collections.IList.Remove(object value);
++            void System.Collections.IList.RemoveAt(int index);
++            public struct Enumerator : IDisposable, IEnumerator, IEnumerator<TKey> {
++                public TKey Current { get; }
++                object System.Collections.IEnumerator.Current { get; }
++                public bool MoveNext();
++                void System.Collections.IEnumerator.Reset();
++                void System.IDisposable.Dispose();
++            }
++        }
++        public sealed class ValueCollection : ICollection, ICollection<TValue>, IEnumerable, IEnumerable<TValue>, IList, IList<TValue>, IReadOnlyCollection<TValue>, IReadOnlyList<TValue> {
++            public int Count { get; }
++            bool ICollection<TValue>.IsReadOnly { get; }
++            TValue IList<TValue>.this[int index] { get; set; }
++            TValue IReadOnlyList<TValue>.this[int index] { get; }
++            bool System.Collections.ICollection.IsSynchronized { get; }
++            object System.Collections.ICollection.SyncRoot { get; }
++            bool System.Collections.IList.IsFixedSize { get; }
++            bool System.Collections.IList.IsReadOnly { get; }
++            object? System.Collections.IList.this[int index] { get; set; }
++            public void CopyTo(TValue[] array, int arrayIndex);
++            public OrderedDictionary<TKey, TValue>.ValueCollection.Enumerator GetEnumerator();
++            void ICollection<TValue>.Add(TValue item);
++            void ICollection<TValue>.Clear();
++            bool ICollection<TValue>.Contains(TValue item);
++            bool ICollection<TValue>.Remove(TValue item);
++            IEnumerator<TValue> IEnumerable<TValue>.GetEnumerator();
++            int IList<TValue>.IndexOf(TValue item);
++            void IList<TValue>.Insert(int index, TValue item);
++            void IList<TValue>.RemoveAt(int index);
++            void System.Collections.ICollection.CopyTo(Array array, int index);
++            IEnumerator System.Collections.IEnumerable.GetEnumerator();
++            int System.Collections.IList.Add(object value);
++            void System.Collections.IList.Clear();
++            bool System.Collections.IList.Contains(object value);
++            int System.Collections.IList.IndexOf(object value);
++            void System.Collections.IList.Insert(int index, object value);
++            void System.Collections.IList.Remove(object value);
++            void System.Collections.IList.RemoveAt(int index);
++            public struct Enumerator : IDisposable, IEnumerator, IEnumerator<TValue> {
++                public TValue Current { get; }
++                object? System.Collections.IEnumerator.Current { get; }
++                public bool MoveNext();
++                void System.Collections.IEnumerator.Reset();
++                void System.IDisposable.Dispose();
++            }
++        }
++    }
+ }
+```
+
diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Collections.ObjectModel.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Collections.ObjectModel.md
new file mode 100644
index 0000000000..bf544ade42
--- /dev/null
+++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Collections.ObjectModel.md
@@ -0,0 +1,35 @@
+# System.Collections.ObjectModel
+
+``` diff
+ namespace System.Collections.ObjectModel {
++    public class ReadOnlySet<T> : ICollection, ICollection<T>, IEnumerable, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlySet<T>, ISet<T> {
++        public ReadOnlySet(ISet<T> @set);
++        public int Count { get; }
++        public static ReadOnlySet<T> Empty { get; }
++        protected ISet<T> Set { get; }
++        bool ICollection<T>.IsReadOnly { get; }
++        bool ICollection.IsSynchronized { get; }
++        object ICollection.SyncRoot { get; }
++        public bool Contains(T item);
++        public IEnumerator<T> GetEnumerator();
++        public bool IsProperSubsetOf(IEnumerable<T> other);
++        public bool IsProperSupersetOf(IEnumerable<T> other);
++        public bool IsSubsetOf(IEnumerable<T> other);
++        public bool IsSupersetOf(IEnumerable<T> other);
++        public bool Overlaps(IEnumerable<T> other);
++        public bool SetEquals(IEnumerable<T> other);
++        void ICollection<T>.Add(T item);
++        void ICollection<T>.Clear();
++        void ICollection<T>.CopyTo(T[] array, int arrayIndex);
++        bool ICollection<T>.Remove(T item);
++        bool ISet<T>.Add(T item);
++        void ISet<T>.ExceptWith(IEnumerable<T> other);
++        void ISet<T>.IntersectWith(IEnumerable<T> other);
++        void ISet<T>.SymmetricExceptWith(IEnumerable<T> other);
++        void ISet<T>.UnionWith(IEnumerable<T> other);
++        void ICollection.CopyTo(Array array, int index);
++        IEnumerator IEnumerable.GetEnumerator();
++    }
+ }
+```
+
diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Diagnostics.Metrics.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Diagnostics.Metrics.md
new file mode 100644
index 0000000000..3710f38ae1
--- /dev/null
+++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Diagnostics.Metrics.md
@@ -0,0 +1,40 @@
+# System.Diagnostics.Metrics
+
+``` diff
+ namespace System.Diagnostics.Metrics {
++    public sealed class Gauge<T> : Instrument<T> where T : struct {
++        public void Record(T value);
++        public void Record(T value, KeyValuePair<string, object?> tag);
++        public void Record(T value, KeyValuePair<string, object?> tag1, KeyValuePair<string, object?> tag2);
++        public void Record(T value, KeyValuePair<string, object?> tag1, KeyValuePair<string, object?> tag2, KeyValuePair<string, object?> tag3);
++        public void Record(T value, params KeyValuePair<string, object>[] tags);
++        public void Record(T value, in TagList tagList);
++        public void Record(T value, ReadOnlySpan<KeyValuePair<string, object?>> tags);
++    }
+     public abstract class Instrument {
++        protected Instrument(Meter meter, string name);
+-        protected Instrument(Meter meter, string name, string? unit, string? description, IEnumerable<KeyValuePair<string, object?>>? tags);
++        protected Instrument(Meter meter, string name, string? unit = null, string? description = null, IEnumerable<KeyValuePair<string, object?>>? tags = null);
+     }
+     public abstract class Instrument<T> : Instrument where T : struct {
++        protected Instrument(Meter meter, string name);
++        protected Instrument(Meter meter, string name, string? unit = null, string? description = null, IEnumerable<KeyValuePair<string, object?>>? tags = null, InstrumentAdvice<T>? advice = null);
++        public InstrumentAdvice<T>? Advice { get; }
+     }
++    public sealed class InstrumentAdvice<T> where T : struct {
++        public InstrumentAdvice();
++        public IReadOnlyList<T>? HistogramBucketBoundaries { get; set; }
++    }
+     public class Meter : IDisposable {
++        public Gauge<T> CreateGauge<T>(string name) where T : struct;
++        public Gauge<T> CreateGauge<T>(string name, string unit = null, string description = null, IEnumerable<KeyValuePair<string, object?>>? tags = null) where T : struct;
++        public Histogram<T> CreateHistogram<T>(string name) where T : struct;
+-        public Histogram<T> CreateHistogram<T>(string name, string unit = null, string description = null) where T : struct;
++        public Histogram<T> CreateHistogram<T>(string name, string unit, string description) where T : struct;
+-        public Histogram<T> CreateHistogram<T>(string name, string unit, string description, IEnumerable<KeyValuePair<string, object?>> tags) where T : struct;
++        public Histogram<T> CreateHistogram<T>(string name, string unit, string description, IEnumerable<KeyValuePair<string, object?>>? tags) where T : struct;
++        public Histogram<T> CreateHistogram<T>(string name, string unit = null, string description = null, IEnumerable<KeyValuePair<string, object?>>? tags = null, InstrumentAdvice<T>? advice = null) where T : struct;
+     }
+ }
+```
+
diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Diagnostics.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Diagnostics.md
new file mode 100644
index 0000000000..01222799f4
--- /dev/null
+++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Diagnostics.md
@@ -0,0 +1,26 @@
+# System.Diagnostics
+
+``` diff
+ namespace System.Diagnostics {
+     public class Activity : IDisposable {
++        public Activity AddException(Exception exception, in TagList tags = default(TagList), DateTimeOffset timestamp = default(DateTimeOffset));
+     }
+     public sealed class ActivityListener : IDisposable {
++        public ExceptionRecorder ExceptionRecorder { get; set; }
+     }
+     public sealed class ActivitySource : IDisposable {
++        public ActivitySource(string name);
++        public ActivitySource(string name, string? version = "", IEnumerable<KeyValuePair<string, object?>>? tags = null);
++        public IEnumerable<KeyValuePair<string, object?>>? Tags { get; }
+     }
++    public sealed class DiagnosticMethodInfo {
++        public string DeclaringAssemblyName { get; }
++        public string DeclaringTypeName { get; }
++        public string Name { get; }
++        public static DiagnosticMethodInfo? Create(Delegate @delegate);
++        public static DiagnosticMethodInfo? Create(StackFrame frame);
++    }
++    public delegate void ExceptionRecorder(Activity activity, Exception exception, ref TagList tags);
+ }
+```
+
diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.IO.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.IO.md
new file mode 100644
index 0000000000..f6da1cf817
--- /dev/null
+++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.IO.md
@@ -0,0 +1,21 @@
+# System.IO
+
+``` diff
+ namespace System.IO {
+     public static class File {
++        public static void AppendAllBytes(string path, ReadOnlySpan<byte> bytes);
++        public static Task AppendAllBytesAsync(string path, ReadOnlyMemory<byte> bytes, CancellationToken cancellationToken = default(CancellationToken));
++        public static void AppendAllText(string path, ReadOnlySpan<char> contents);
++        public static void AppendAllText(string path, ReadOnlySpan<char> contents, Encoding encoding);
++        public static Task AppendAllTextAsync(string path, ReadOnlyMemory<char> contents, Encoding encoding, CancellationToken cancellationToken = default(CancellationToken));
++        public static Task AppendAllTextAsync(string path, ReadOnlyMemory<char> contents, CancellationToken cancellationToken = default(CancellationToken));
++        public static void WriteAllBytes(string path, ReadOnlySpan<byte> bytes);
++        public static Task WriteAllBytesAsync(string path, ReadOnlyMemory<byte> bytes, CancellationToken cancellationToken = default(CancellationToken));
++        public static void WriteAllText(string path, ReadOnlySpan<char> contents);
++        public static void WriteAllText(string path, ReadOnlySpan<char> contents, Encoding encoding);
++        public static Task WriteAllTextAsync(string path, ReadOnlyMemory<char> contents, Encoding encoding, CancellationToken cancellationToken = default(CancellationToken));
++        public static Task WriteAllTextAsync(string path, ReadOnlyMemory<char> contents, CancellationToken cancellationToken = default(CancellationToken));
+     }
+ }
+```
+
diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Net.Http.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Net.Http.md
new file mode 100644
index 0000000000..d69f5a7718
--- /dev/null
+++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Net.Http.md
@@ -0,0 +1,15 @@
+# System.Net.Http
+
+``` diff
+ namespace System.Net.Http {
+     public class StringContent : ByteArrayContent {
+-        public StringContent(string content, MediaTypeHeaderValue mediaType);
++        public StringContent(string content, MediaTypeHeaderValue? mediaType);
+-        public StringContent(string content, Encoding? encoding, MediaTypeHeaderValue mediaType);
++        public StringContent(string content, Encoding? encoding, MediaTypeHeaderValue? mediaType);
+-        public StringContent(string content, Encoding? encoding, string mediaType);
++        public StringContent(string content, Encoding? encoding, string? mediaType);
+     }
+ }
+```
+
diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Net.Mime.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Net.Mime.md
new file mode 100644
index 0000000000..3984aa2032
--- /dev/null
+++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Net.Mime.md
@@ -0,0 +1,19 @@
+# System.Net.Mime
+
+``` diff
+ namespace System.Net.Mime {
+     public static class MediaTypeNames {
+         public static class Application {
++            public const string GZip = "application/gzip";
+         }
+         public static class Multipart {
++            public const string Mixed = "multipart/mixed";
++            public const string Related = "multipart/related";
+         }
+         public static class Text {
++            public const string EventStream = "text/event-stream";
+         }
+     }
+ }
+```
+
diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Net.Sockets.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Net.Sockets.md
new file mode 100644
index 0000000000..0cf49bec07
--- /dev/null
+++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Net.Sockets.md
@@ -0,0 +1,10 @@
+# System.Net.Sockets
+
+``` diff
+ namespace System.Net.Sockets {
+     public enum SocketOptionName {
++        FastOpen = 15,
+     }
+ }
+```
+
diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Numerics.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Numerics.md
new file mode 100644
index 0000000000..59d277c248
--- /dev/null
+++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Numerics.md
@@ -0,0 +1,39 @@
+# System.Numerics
+
+``` diff
+ namespace System.Numerics {
+     public static class Vector {
++        public static Plane AsPlane(this Vector4 value);
++        public static Quaternion AsQuaternion(this Vector4 value);
++        public static Vector2 AsVector2(this Vector4 value);
++        public static Vector3 AsVector3(this Vector4 value);
++        public static Vector4 AsVector4(this Plane value);
++        public static Vector4 AsVector4(this Quaternion value);
++        public static Vector4 AsVector4(this Vector2 value);
++        public static Vector4 AsVector4(this Vector3 value);
++        public static Vector4 AsVector4Unsafe(this Vector2 value);
++        public static Vector4 AsVector4Unsafe(this Vector3 value);
++        public static Vector<T> Create<T>(ReadOnlySpan<T> values);
++        public static Vector<T> Create<T>(T value);
+     }
+     public struct Vector2 : IEquatable<Vector2>, IFormattable {
++        public static Vector2 Create(ReadOnlySpan<float> values);
++        public static Vector2 Create(float value);
++        public static Vector2 Create(float x, float y);
+     }
+     public struct Vector3 : IEquatable<Vector3>, IFormattable {
++        public static Vector3 Create(Vector2 vector, float z);
++        public static Vector3 Create(ReadOnlySpan<float> values);
++        public static Vector3 Create(float value);
++        public static Vector3 Create(float x, float y, float z);
+     }
+     public struct Vector4 : IEquatable<Vector4>, IFormattable {
++        public static Vector4 Create(Vector2 vector, float z, float w);
++        public static Vector4 Create(Vector3 vector, float w);
++        public static Vector4 Create(ReadOnlySpan<float> values);
++        public static Vector4 Create(float value);
++        public static Vector4 Create(float x, float y, float z, float w);
+     }
+ }
+```
+
diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Reflection.Emit.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Reflection.Emit.md
new file mode 100644
index 0000000000..d7b746d1f4
--- /dev/null
+++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Reflection.Emit.md
@@ -0,0 +1,11 @@
+# System.Reflection.Emit
+
+``` diff
+ namespace System.Reflection.Emit {
+     public abstract class GenericTypeParameterBuilder : TypeInfo {
+-        public override Type GetElementType();
++        public override Type? GetElementType();
+     }
+ }
+```
+
diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Runtime.InteropServices.Marshalling.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Runtime.InteropServices.Marshalling.md
new file mode 100644
index 0000000000..2df7a2ed89
--- /dev/null
+++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Runtime.InteropServices.Marshalling.md
@@ -0,0 +1,16 @@
+# System.Runtime.InteropServices.Marshalling
+
+``` diff
+ namespace System.Runtime.InteropServices.Marshalling {
+     public static class ReadOnlySpanMarshaller<T, TUnmanagedElement> where TUnmanagedElement : struct {
++        public struct ManagedToUnmanagedOut {
++            public void Free();
++            public unsafe void FromUnmanaged(TUnmanagedElement* unmanaged);
++            public Span<T> GetManagedValuesDestination(int numElements);
++            public ReadOnlySpan<TUnmanagedElement> GetUnmanagedValuesSource(int numElements);
++            public ReadOnlySpan<T> ToManaged();
++        }
+     }
+ }
+```
+
diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Runtime.InteropServices.Swift.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Runtime.InteropServices.Swift.md
new file mode 100644
index 0000000000..6d02f09a3c
--- /dev/null
+++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Runtime.InteropServices.Swift.md
@@ -0,0 +1,15 @@
+# System.Runtime.InteropServices.Swift
+
+``` diff
+ namespace System.Runtime.InteropServices.Swift {
++    public readonly struct SwiftIndirectResult {
++        public unsafe SwiftIndirectResult(void* value);
++        public unsafe void* Value { get; }
++    }
++    public readonly struct SwiftSelf<T> where T : struct {
++        public SwiftSelf(T value);
++        public T Value { get; }
++    }
+ }
+```
+
diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Runtime.InteropServices.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Runtime.InteropServices.md
new file mode 100644
index 0000000000..7b9d23f41a
--- /dev/null
+++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Runtime.InteropServices.md
@@ -0,0 +1,11 @@
+# System.Runtime.InteropServices
+
+``` diff
+ namespace System.Runtime.InteropServices {
+     public static class CollectionsMarshal {
++        public static ref TValue? GetValueRefOrAddDefault<TKey, TValue, TAlternateKey>(Dictionary.AlternateLookup<TAlternateKey> dictionary, TAlternateKey key, out bool exists);
++        public static ref TValue GetValueRefOrNullRef<TKey, TValue, TAlternateKey>(Dictionary.AlternateLookup<TAlternateKey> dictionary, TAlternateKey key);
+     }
+ }
+```
+
diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Runtime.Intrinsics.Arm.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Runtime.Intrinsics.Arm.md
new file mode 100644
index 0000000000..88e375970c
--- /dev/null
+++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Runtime.Intrinsics.Arm.md
@@ -0,0 +1,1058 @@
+# System.Runtime.Intrinsics.Arm
+
+``` diff
+ namespace System.Runtime.Intrinsics.Arm {
+     public abstract class AdvSimd : ArmBase {
++        public unsafe static (Vector64<byte> Value1, Vector64<byte> Value2) Load2xVector64(byte* address);
++        public unsafe static (Vector64<short> Value1, Vector64<short> Value2) Load2xVector64(short* address);
++        public unsafe static (Vector64<int> Value1, Vector64<int> Value2) Load2xVector64(int* address);
++        public unsafe static (Vector64<sbyte> Value1, Vector64<sbyte> Value2) Load2xVector64(sbyte* address);
++        public unsafe static (Vector64<float> Value1, Vector64<float> Value2) Load2xVector64(float* address);
++        public unsafe static (Vector64<ushort> Value1, Vector64<ushort> Value2) Load2xVector64(ushort* address);
++        public unsafe static (Vector64<uint> Value1, Vector64<uint> Value2) Load2xVector64(uint* address);
++        public unsafe static (Vector64<byte> Value1, Vector64<byte> Value2) Load2xVector64AndUnzip(byte* address);
++        public unsafe static (Vector64<short> Value1, Vector64<short> Value2) Load2xVector64AndUnzip(short* address);
++        public unsafe static (Vector64<int> Value1, Vector64<int> Value2) Load2xVector64AndUnzip(int* address);
++        public unsafe static (Vector64<sbyte> Value1, Vector64<sbyte> Value2) Load2xVector64AndUnzip(sbyte* address);
++        public unsafe static (Vector64<float> Value1, Vector64<float> Value2) Load2xVector64AndUnzip(float* address);
++        public unsafe static (Vector64<ushort> Value1, Vector64<ushort> Value2) Load2xVector64AndUnzip(ushort* address);
++        public unsafe static (Vector64<uint> Value1, Vector64<uint> Value2) Load2xVector64AndUnzip(uint* address);
++        public unsafe static (Vector64<byte> Value1, Vector64<byte> Value2, Vector64<byte> Value3) Load3xVector64(byte* address);
++        public unsafe static (Vector64<short> Value1, Vector64<short> Value2, Vector64<short> Value3) Load3xVector64(short* address);
++        public unsafe static (Vector64<int> Value1, Vector64<int> Value2, Vector64<int> Value3) Load3xVector64(int* address);
++        public unsafe static (Vector64<sbyte> Value1, Vector64<sbyte> Value2, Vector64<sbyte> Value3) Load3xVector64(sbyte* address);
++        public unsafe static (Vector64<float> Value1, Vector64<float> Value2, Vector64<float> Value3) Load3xVector64(float* address);
++        public unsafe static (Vector64<ushort> Value1, Vector64<ushort> Value2, Vector64<ushort> Value3) Load3xVector64(ushort* address);
++        public unsafe static (Vector64<uint> Value1, Vector64<uint> Value2, Vector64<uint> Value3) Load3xVector64(uint* address);
++        public unsafe static (Vector64<byte> Value1, Vector64<byte> Value2, Vector64<byte> Value3) Load3xVector64AndUnzip(byte* address);
++        public unsafe static (Vector64<short> Value1, Vector64<short> Value2, Vector64<short> Value3) Load3xVector64AndUnzip(short* address);
++        public unsafe static (Vector64<int> Value1, Vector64<int> Value2, Vector64<int> Value3) Load3xVector64AndUnzip(int* address);
++        public unsafe static (Vector64<sbyte> Value1, Vector64<sbyte> Value2, Vector64<sbyte> Value3) Load3xVector64AndUnzip(sbyte* address);
++        public unsafe static (Vector64<float> Value1, Vector64<float> Value2, Vector64<float> Value3) Load3xVector64AndUnzip(float* address);
++        public unsafe static (Vector64<ushort> Value1, Vector64<ushort> Value2, Vector64<ushort> Value3) Load3xVector64AndUnzip(ushort* address);
++        public unsafe static (Vector64<uint> Value1, Vector64<uint> Value2, Vector64<uint> Value3) Load3xVector64AndUnzip(uint* address);
++        public unsafe static (Vector64<byte> Value1, Vector64<byte> Value2, Vector64<byte> Value3, Vector64<byte> Value4) Load4xVector64(byte* address);
++        public unsafe static (Vector64<short> Value1, Vector64<short> Value2, Vector64<short> Value3, Vector64<short> Value4) Load4xVector64(short* address);
++        public unsafe static (Vector64<int> Value1, Vector64<int> Value2, Vector64<int> Value3, Vector64<int> Value4) Load4xVector64(int* address);
++        public unsafe static (Vector64<sbyte> Value1, Vector64<sbyte> Value2, Vector64<sbyte> Value3, Vector64<sbyte> Value4) Load4xVector64(sbyte* address);
++        public unsafe static (Vector64<float> Value1, Vector64<float> Value2, Vector64<float> Value3, Vector64<float> Value4) Load4xVector64(float* address);
++        public unsafe static (Vector64<ushort> Value1, Vector64<ushort> Value2, Vector64<ushort> Value3, Vector64<ushort> Value4) Load4xVector64(ushort* address);
++        public unsafe static (Vector64<uint> Value1, Vector64<uint> Value2, Vector64<uint> Value3, Vector64<uint> Value4) Load4xVector64(uint* address);
++        public unsafe static (Vector64<byte> Value1, Vector64<byte> Value2, Vector64<byte> Value3, Vector64<byte> Value4) Load4xVector64AndUnzip(byte* address);
++        public unsafe static (Vector64<short> Value1, Vector64<short> Value2, Vector64<short> Value3, Vector64<short> Value4) Load4xVector64AndUnzip(short* address);
++        public unsafe static (Vector64<int> Value1, Vector64<int> Value2, Vector64<int> Value3, Vector64<int> Value4) Load4xVector64AndUnzip(int* address);
++        public unsafe static (Vector64<sbyte> Value1, Vector64<sbyte> Value2, Vector64<sbyte> Value3, Vector64<sbyte> Value4) Load4xVector64AndUnzip(sbyte* address);
++        public unsafe static (Vector64<float> Value1, Vector64<float> Value2, Vector64<float> Value3, Vector64<float> Value4) Load4xVector64AndUnzip(float* address);
++        public unsafe static (Vector64<ushort> Value1, Vector64<ushort> Value2, Vector64<ushort> Value3, Vector64<ushort> Value4) Load4xVector64AndUnzip(ushort* address);
++        public unsafe static (Vector64<uint> Value1, Vector64<uint> Value2, Vector64<uint> Value3, Vector64<uint> Value4) Load4xVector64AndUnzip(uint* address);
+-        public unsafe static (Vector64<byte> Value1, Vector64<byte> Value2) LoadVector64x2(byte* address);
+
+-        public unsafe static (Vector64<short> Value1, Vector64<short> Value2) LoadVector64x2(short* address);
+
+-        public unsafe static (Vector64<int> Value1, Vector64<int> Value2) LoadVector64x2(int* address);
+
+-        public unsafe static (Vector64<sbyte> Value1, Vector64<sbyte> Value2) LoadVector64x2(sbyte* address);
+
+-        public unsafe static (Vector64<float> Value1, Vector64<float> Value2) LoadVector64x2(float* address);
+
+-        public unsafe static (Vector64<ushort> Value1, Vector64<ushort> Value2) LoadVector64x2(ushort* address);
+
+-        public unsafe static (Vector64<uint> Value1, Vector64<uint> Value2) LoadVector64x2(uint* address);
+
+-        public unsafe static (Vector64<byte> Value1, Vector64<byte> Value2) LoadVector64x2AndUnzip(byte* address);
+
+-        public unsafe static (Vector64<short> Value1, Vector64<short> Value2) LoadVector64x2AndUnzip(short* address);
+
+-        public unsafe static (Vector64<int> Value1, Vector64<int> Value2) LoadVector64x2AndUnzip(int* address);
+
+-        public unsafe static (Vector64<sbyte> Value1, Vector64<sbyte> Value2) LoadVector64x2AndUnzip(sbyte* address);
+
+-        public unsafe static (Vector64<float> Value1, Vector64<float> Value2) LoadVector64x2AndUnzip(float* address);
+
+-        public unsafe static (Vector64<ushort> Value1, Vector64<ushort> Value2) LoadVector64x2AndUnzip(ushort* address);
+
+-        public unsafe static (Vector64<uint> Value1, Vector64<uint> Value2) LoadVector64x2AndUnzip(uint* address);
+
+-        public unsafe static (Vector64<byte> Value1, Vector64<byte> Value2, Vector64<byte> Value3) LoadVector64x3(byte* address);
+
+-        public unsafe static (Vector64<short> Value1, Vector64<short> Value2, Vector64<short> Value3) LoadVector64x3(short* address);
+
+-        public unsafe static (Vector64<int> Value1, Vector64<int> Value2, Vector64<int> Value3) LoadVector64x3(int* address);
+
+-        public unsafe static (Vector64<sbyte> Value1, Vector64<sbyte> Value2, Vector64<sbyte> Value3) LoadVector64x3(sbyte* address);
+
+-        public unsafe static (Vector64<float> Value1, Vector64<float> Value2, Vector64<float> Value3) LoadVector64x3(float* address);
+
+-        public unsafe static (Vector64<ushort> Value1, Vector64<ushort> Value2, Vector64<ushort> Value3) LoadVector64x3(ushort* address);
+
+-        public unsafe static (Vector64<uint> Value1, Vector64<uint> Value2, Vector64<uint> Value3) LoadVector64x3(uint* address);
+
+-        public unsafe static (Vector64<byte> Value1, Vector64<byte> Value2, Vector64<byte> Value3) LoadVector64x3AndUnzip(byte* address);
+
+-        public unsafe static (Vector64<short> Value1, Vector64<short> Value2, Vector64<short> Value3) LoadVector64x3AndUnzip(short* address);
+
+-        public unsafe static (Vector64<int> Value1, Vector64<int> Value2, Vector64<int> Value3) LoadVector64x3AndUnzip(int* address);
+
+-        public unsafe static (Vector64<sbyte> Value1, Vector64<sbyte> Value2, Vector64<sbyte> Value3) LoadVector64x3AndUnzip(sbyte* address);
+
+-        public unsafe static (Vector64<float> Value1, Vector64<float> Value2, Vector64<float> Value3) LoadVector64x3AndUnzip(float* address);
+
+-        public unsafe static (Vector64<ushort> Value1, Vector64<ushort> Value2, Vector64<ushort> Value3) LoadVector64x3AndUnzip(ushort* address);
+
+-        public unsafe static (Vector64<uint> Value1, Vector64<uint> Value2, Vector64<uint> Value3) LoadVector64x3AndUnzip(uint* address);
+
+-        public unsafe static (Vector64<byte> Value1, Vector64<byte> Value2, Vector64<byte> Value3, Vector64<byte> Value4) LoadVector64x4(byte* address);
+
+-        public unsafe static (Vector64<short> Value1, Vector64<short> Value2, Vector64<short> Value3, Vector64<short> Value4) LoadVector64x4(short* address);
+
+-        public unsafe static (Vector64<int> Value1, Vector64<int> Value2, Vector64<int> Value3, Vector64<int> Value4) LoadVector64x4(int* address);
+
+-        public unsafe static (Vector64<sbyte> Value1, Vector64<sbyte> Value2, Vector64<sbyte> Value3, Vector64<sbyte> Value4) LoadVector64x4(sbyte* address);
+
+-        public unsafe static (Vector64<float> Value1, Vector64<float> Value2, Vector64<float> Value3, Vector64<float> Value4) LoadVector64x4(float* address);
+
+-        public unsafe static (Vector64<ushort> Value1, Vector64<ushort> Value2, Vector64<ushort> Value3, Vector64<ushort> Value4) LoadVector64x4(ushort* address);
+
+-        public unsafe static (Vector64<uint> Value1, Vector64<uint> Value2, Vector64<uint> Value3, Vector64<uint> Value4) LoadVector64x4(uint* address);
+
+-        public unsafe static (Vector64<byte> Value1, Vector64<byte> Value2, Vector64<byte> Value3, Vector64<byte> Value4) LoadVector64x4AndUnzip(byte* address);
+
+-        public unsafe static (Vector64<short> Value1, Vector64<short> Value2, Vector64<short> Value3, Vector64<short> Value4) LoadVector64x4AndUnzip(short* address);
+
+-        public unsafe static (Vector64<int> Value1, Vector64<int> Value2, Vector64<int> Value3, Vector64<int> Value4) LoadVector64x4AndUnzip(int* address);
+
+-        public unsafe static (Vector64<sbyte> Value1, Vector64<sbyte> Value2, Vector64<sbyte> Value3, Vector64<sbyte> Value4) LoadVector64x4AndUnzip(sbyte* address);
+
+-        public unsafe static (Vector64<float> Value1, Vector64<float> Value2, Vector64<float> Value3, Vector64<float> Value4) LoadVector64x4AndUnzip(float* address);
+
+-        public unsafe static (Vector64<ushort> Value1, Vector64<ushort> Value2, Vector64<ushort> Value3, Vector64<ushort> Value4) LoadVector64x4AndUnzip(ushort* address);
+
+-        public unsafe static (Vector64<uint> Value1, Vector64<uint> Value2, Vector64<uint> Value3, Vector64<uint> Value4) LoadVector64x4AndUnzip(uint* address);
+
++        public unsafe static void Store(byte* address, (Vector64<byte> Value1, Vector64<byte> Value2, Vector64<byte> Value3, Vector64<byte> Value4) value);
++        public unsafe static void Store(byte* address, (Vector64<byte> Value1, Vector64<byte> Value2, Vector64<byte> Value3) value);
++        public unsafe static void Store(byte* address, (Vector64<byte> Value1, Vector64<byte> Value2) value);
++        public unsafe static void Store(short* address, (Vector64<short> Value1, Vector64<short> Value2, Vector64<short> Value3, Vector64<short> Value4) value);
++        public unsafe static void Store(short* address, (Vector64<short> Value1, Vector64<short> Value2, Vector64<short> Value3) value);
++        public unsafe static void Store(short* address, (Vector64<short> Value1, Vector64<short> Value2) value);
++        public unsafe static void Store(int* address, (Vector64<int> Value1, Vector64<int> Value2, Vector64<int> Value3, Vector64<int> Value4) value);
++        public unsafe static void Store(int* address, (Vector64<int> Value1, Vector64<int> Value2, Vector64<int> Value3) value);
++        public unsafe static void Store(int* address, (Vector64<int> Value1, Vector64<int> Value2) value);
++        public unsafe static void Store(sbyte* address, (Vector64<sbyte> Value1, Vector64<sbyte> Value2, Vector64<sbyte> Value3, Vector64<sbyte> Value4) value);
++        public unsafe static void Store(sbyte* address, (Vector64<sbyte> Value1, Vector64<sbyte> Value2, Vector64<sbyte> Value3) value);
++        public unsafe static void Store(sbyte* address, (Vector64<sbyte> Value1, Vector64<sbyte> Value2) value);
++        public unsafe static void Store(float* address, (Vector64<float> Value1, Vector64<float> Value2, Vector64<float> Value3, Vector64<float> Value4) value);
++        public unsafe static void Store(float* address, (Vector64<float> Value1, Vector64<float> Value2, Vector64<float> Value3) value);
++        public unsafe static void Store(float* address, (Vector64<float> Value1, Vector64<float> Value2) value);
++        public unsafe static void Store(ushort* address, (Vector64<ushort> Value1, Vector64<ushort> Value2, Vector64<ushort> Value3, Vector64<ushort> Value4) value);
++        public unsafe static void Store(ushort* address, (Vector64<ushort> Value1, Vector64<ushort> Value2, Vector64<ushort> Value3) value);
++        public unsafe static void Store(ushort* address, (Vector64<ushort> Value1, Vector64<ushort> Value2) value);
++        public unsafe static void Store(uint* address, (Vector64<uint> Value1, Vector64<uint> Value2, Vector64<uint> Value3, Vector64<uint> Value4) value);
++        public unsafe static void Store(uint* address, (Vector64<uint> Value1, Vector64<uint> Value2, Vector64<uint> Value3) value);
++        public unsafe static void Store(uint* address, (Vector64<uint> Value1, Vector64<uint> Value2) value);
+-        public unsafe static void StoreVector64x2(byte* address, (Vector64<byte> Value1, Vector64<byte> Value2) value);
+
+-        public unsafe static void StoreVector64x2(short* address, (Vector64<short> Value1, Vector64<short> Value2) value);
+
+-        public unsafe static void StoreVector64x2(int* address, (Vector64<int> Value1, Vector64<int> Value2) value);
+
+-        public unsafe static void StoreVector64x2(sbyte* address, (Vector64<sbyte> Value1, Vector64<sbyte> Value2) value);
+
+-        public unsafe static void StoreVector64x2(float* address, (Vector64<float> Value1, Vector64<float> Value2) value);
+
+-        public unsafe static void StoreVector64x2(ushort* address, (Vector64<ushort> Value1, Vector64<ushort> Value2) value);
+
+-        public unsafe static void StoreVector64x2(uint* address, (Vector64<uint> Value1, Vector64<uint> Value2) value);
+
+-        public unsafe static void StoreVector64x2AndZip(byte* address, (Vector64<byte> Value1, Vector64<byte> Value2) value);
+
+-        public unsafe static void StoreVector64x2AndZip(short* address, (Vector64<short> Value1, Vector64<short> Value2) value);
+
+-        public unsafe static void StoreVector64x2AndZip(int* address, (Vector64<int> Value1, Vector64<int> Value2) value);
+
+-        public unsafe static void StoreVector64x2AndZip(sbyte* address, (Vector64<sbyte> Value1, Vector64<sbyte> Value2) value);
+
+-        public unsafe static void StoreVector64x2AndZip(float* address, (Vector64<float> Value1, Vector64<float> Value2) value);
+
+-        public unsafe static void StoreVector64x2AndZip(ushort* address, (Vector64<ushort> Value1, Vector64<ushort> Value2) value);
+
+-        public unsafe static void StoreVector64x2AndZip(uint* address, (Vector64<uint> Value1, Vector64<uint> Value2) value);
+
+-        public unsafe static void StoreVector64x3(byte* address, (Vector64<byte> Value1, Vector64<byte> Value2, Vector64<byte> Value3) value);
+
+-        public unsafe static void StoreVector64x3(short* address, (Vector64<short> Value1, Vector64<short> Value2, Vector64<short> Value3) value);
+
+-        public unsafe static void StoreVector64x3(int* address, (Vector64<int> Value1, Vector64<int> Value2, Vector64<int> Value3) value);
+
+-        public unsafe static void StoreVector64x3(sbyte* address, (Vector64<sbyte> Value1, Vector64<sbyte> Value2, Vector64<sbyte> Value3) value);
+
+-        public unsafe static void StoreVector64x3(float* address, (Vector64<float> Value1, Vector64<float> Value2, Vector64<float> Value3) value);
+
+-        public unsafe static void StoreVector64x3(ushort* address, (Vector64<ushort> Value1, Vector64<ushort> Value2, Vector64<ushort> Value3) value);
+
+-        public unsafe static void StoreVector64x3(uint* address, (Vector64<uint> Value1, Vector64<uint> Value2, Vector64<uint> Value3) value);
+
+-        public unsafe static void StoreVector64x3AndZip(byte* address, (Vector64<byte> Value1, Vector64<byte> Value2, Vector64<byte> Value3) value);
+
+-        public unsafe static void StoreVector64x3AndZip(short* address, (Vector64<short> Value1, Vector64<short> Value2, Vector64<short> Value3) value);
+
+-        public unsafe static void StoreVector64x3AndZip(int* address, (Vector64<int> Value1, Vector64<int> Value2, Vector64<int> Value3) value);
+
+-        public unsafe static void StoreVector64x3AndZip(sbyte* address, (Vector64<sbyte> Value1, Vector64<sbyte> Value2, Vector64<sbyte> Value3) value);
+
+-        public unsafe static void StoreVector64x3AndZip(float* address, (Vector64<float> Value1, Vector64<float> Value2, Vector64<float> Value3) value);
+
+-        public unsafe static void StoreVector64x3AndZip(ushort* address, (Vector64<ushort> Value1, Vector64<ushort> Value2, Vector64<ushort> Value3) value);
+
+-        public unsafe static void StoreVector64x3AndZip(uint* address, (Vector64<uint> Value1, Vector64<uint> Value2, Vector64<uint> Value3) value);
+
+-        public unsafe static void StoreVector64x4(byte* address, (Vector64<byte> Value1, Vector64<byte> Value2, Vector64<byte> Value3, Vector64<byte> Value4) value);
+
+-        public unsafe static void StoreVector64x4(short* address, (Vector64<short> Value1, Vector64<short> Value2, Vector64<short> Value3, Vector64<short> Value4) value);
+
+-        public unsafe static void StoreVector64x4(int* address, (Vector64<int> Value1, Vector64<int> Value2, Vector64<int> Value3, Vector64<int> Value4) value);
+
+-        public unsafe static void StoreVector64x4(sbyte* address, (Vector64<sbyte> Value1, Vector64<sbyte> Value2, Vector64<sbyte> Value3, Vector64<sbyte> Value4) value);
+
+-        public unsafe static void StoreVector64x4(float* address, (Vector64<float> Value1, Vector64<float> Value2, Vector64<float> Value3, Vector64<float> Value4) value);
+
+-        public unsafe static void StoreVector64x4(ushort* address, (Vector64<ushort> Value1, Vector64<ushort> Value2, Vector64<ushort> Value3, Vector64<ushort> Value4) value);
+
+-        public unsafe static void StoreVector64x4(uint* address, (Vector64<uint> Value1, Vector64<uint> Value2, Vector64<uint> Value3, Vector64<uint> Value4) value);
+
+-        public unsafe static void StoreVector64x4AndZip(byte* address, (Vector64<byte> Value1, Vector64<byte> Value2, Vector64<byte> Value3, Vector64<byte> Value4) value);
+
+-        public unsafe static void StoreVector64x4AndZip(short* address, (Vector64<short> Value1, Vector64<short> Value2, Vector64<short> Value3, Vector64<short> Value4) value);
+
+-        public unsafe static void StoreVector64x4AndZip(int* address, (Vector64<int> Value1, Vector64<int> Value2, Vector64<int> Value3, Vector64<int> Value4) value);
+
+-        public unsafe static void StoreVector64x4AndZip(sbyte* address, (Vector64<sbyte> Value1, Vector64<sbyte> Value2, Vector64<sbyte> Value3, Vector64<sbyte> Value4) value);
+
+-        public unsafe static void StoreVector64x4AndZip(float* address, (Vector64<float> Value1, Vector64<float> Value2, Vector64<float> Value3, Vector64<float> Value4) value);
+
+-        public unsafe static void StoreVector64x4AndZip(ushort* address, (Vector64<ushort> Value1, Vector64<ushort> Value2, Vector64<ushort> Value3, Vector64<ushort> Value4) value);
+
+-        public unsafe static void StoreVector64x4AndZip(uint* address, (Vector64<uint> Value1, Vector64<uint> Value2, Vector64<uint> Value3, Vector64<uint> Value4) value);
+
++        public unsafe static void StoreVectorAndZip(byte* address, (Vector64<byte> Value1, Vector64<byte> Value2, Vector64<byte> Value3, Vector64<byte> Value4) value);
++        public unsafe static void StoreVectorAndZip(byte* address, (Vector64<byte> Value1, Vector64<byte> Value2, Vector64<byte> Value3) value);
++        public unsafe static void StoreVectorAndZip(byte* address, (Vector64<byte> Value1, Vector64<byte> Value2) value);
++        public unsafe static void StoreVectorAndZip(short* address, (Vector64<short> Value1, Vector64<short> Value2, Vector64<short> Value3, Vector64<short> Value4) value);
++        public unsafe static void StoreVectorAndZip(short* address, (Vector64<short> Value1, Vector64<short> Value2, Vector64<short> Value3) value);
++        public unsafe static void StoreVectorAndZip(short* address, (Vector64<short> Value1, Vector64<short> Value2) value);
++        public unsafe static void StoreVectorAndZip(int* address, (Vector64<int> Value1, Vector64<int> Value2, Vector64<int> Value3, Vector64<int> Value4) value);
++        public unsafe static void StoreVectorAndZip(int* address, (Vector64<int> Value1, Vector64<int> Value2, Vector64<int> Value3) value);
++        public unsafe static void StoreVectorAndZip(int* address, (Vector64<int> Value1, Vector64<int> Value2) value);
++        public unsafe static void StoreVectorAndZip(sbyte* address, (Vector64<sbyte> Value1, Vector64<sbyte> Value2, Vector64<sbyte> Value3, Vector64<sbyte> Value4) value);
++        public unsafe static void StoreVectorAndZip(sbyte* address, (Vector64<sbyte> Value1, Vector64<sbyte> Value2, Vector64<sbyte> Value3) value);
++        public unsafe static void StoreVectorAndZip(sbyte* address, (Vector64<sbyte> Value1, Vector64<sbyte> Value2) value);
++        public unsafe static void StoreVectorAndZip(float* address, (Vector64<float> Value1, Vector64<float> Value2, Vector64<float> Value3, Vector64<float> Value4) value);
++        public unsafe static void StoreVectorAndZip(float* address, (Vector64<float> Value1, Vector64<float> Value2, Vector64<float> Value3) value);
++        public unsafe static void StoreVectorAndZip(float* address, (Vector64<float> Value1, Vector64<float> Value2) value);
++        public unsafe static void StoreVectorAndZip(ushort* address, (Vector64<ushort> Value1, Vector64<ushort> Value2, Vector64<ushort> Value3, Vector64<ushort> Value4) value);
++        public unsafe static void StoreVectorAndZip(ushort* address, (Vector64<ushort> Value1, Vector64<ushort> Value2, Vector64<ushort> Value3) value);
++        public unsafe static void StoreVectorAndZip(ushort* address, (Vector64<ushort> Value1, Vector64<ushort> Value2) value);
++        public unsafe static void StoreVectorAndZip(uint* address, (Vector64<uint> Value1, Vector64<uint> Value2, Vector64<uint> Value3, Vector64<uint> Value4) value);
++        public unsafe static void StoreVectorAndZip(uint* address, (Vector64<uint> Value1, Vector64<uint> Value2, Vector64<uint> Value3) value);
++        public unsafe static void StoreVectorAndZip(uint* address, (Vector64<uint> Value1, Vector64<uint> Value2) value);
+         public new abstract class Arm64 : ArmBase.Arm64 {
++            public unsafe static (Vector128<byte> Value1, Vector128<byte> Value2) Load2xVector128(byte* address);
++            public unsafe static (Vector128<double> Value1, Vector128<double> Value2) Load2xVector128(double* address);
++            public unsafe static (Vector128<short> Value1, Vector128<short> Value2) Load2xVector128(short* address);
++            public unsafe static (Vector128<int> Value1, Vector128<int> Value2) Load2xVector128(int* address);
++            public unsafe static (Vector128<long> Value1, Vector128<long> Value2) Load2xVector128(long* address);
++            public unsafe static (Vector128<sbyte> Value1, Vector128<sbyte> Value2) Load2xVector128(sbyte* address);
++            public unsafe static (Vector128<float> Value1, Vector128<float> Value2) Load2xVector128(float* address);
++            public unsafe static (Vector128<ushort> Value1, Vector128<ushort> Value2) Load2xVector128(ushort* address);
++            public unsafe static (Vector128<uint> Value1, Vector128<uint> Value2) Load2xVector128(uint* address);
++            public unsafe static (Vector128<ulong> Value1, Vector128<ulong> Value2) Load2xVector128(ulong* address);
++            public unsafe static (Vector128<byte> Value1, Vector128<byte> Value2) Load2xVector128AndUnzip(byte* address);
++            public unsafe static (Vector128<double> Value1, Vector128<double> Value2) Load2xVector128AndUnzip(double* address);
++            public unsafe static (Vector128<short> Value1, Vector128<short> Value2) Load2xVector128AndUnzip(short* address);
++            public unsafe static (Vector128<int> Value1, Vector128<int> Value2) Load2xVector128AndUnzip(int* address);
++            public unsafe static (Vector128<long> Value1, Vector128<long> Value2) Load2xVector128AndUnzip(long* address);
++            public unsafe static (Vector128<sbyte> Value1, Vector128<sbyte> Value2) Load2xVector128AndUnzip(sbyte* address);
++            public unsafe static (Vector128<float> Value1, Vector128<float> Value2) Load2xVector128AndUnzip(float* address);
++            public unsafe static (Vector128<ushort> Value1, Vector128<ushort> Value2) Load2xVector128AndUnzip(ushort* address);
++            public unsafe static (Vector128<uint> Value1, Vector128<uint> Value2) Load2xVector128AndUnzip(uint* address);
++            public unsafe static (Vector128<ulong> Value1, Vector128<ulong> Value2) Load2xVector128AndUnzip(ulong* address);
++            public unsafe static (Vector128<byte> Value1, Vector128<byte> Value2, Vector128<byte> Value3) Load3xVector128(byte* address);
++            public unsafe static (Vector128<double> Value1, Vector128<double> Value2, Vector128<double> Value3) Load3xVector128(double* address);
++            public unsafe static (Vector128<short> Value1, Vector128<short> Value2, Vector128<short> Value3) Load3xVector128(short* address);
++            public unsafe static (Vector128<int> Value1, Vector128<int> Value2, Vector128<int> Value3) Load3xVector128(int* address);
++            public unsafe static (Vector128<long> Value1, Vector128<long> Value2, Vector128<long> Value3) Load3xVector128(long* address);
++            public unsafe static (Vector128<sbyte> Value1, Vector128<sbyte> Value2, Vector128<sbyte> Value3) Load3xVector128(sbyte* address);
++            public unsafe static (Vector128<float> Value1, Vector128<float> Value2, Vector128<float> Value3) Load3xVector128(float* address);
++            public unsafe static (Vector128<ushort> Value1, Vector128<ushort> Value2, Vector128<ushort> Value3) Load3xVector128(ushort* address);
++            public unsafe static (Vector128<uint> Value1, Vector128<uint> Value2, Vector128<uint> Value3) Load3xVector128(uint* address);
++            public unsafe static (Vector128<ulong> Value1, Vector128<ulong> Value2, Vector128<ulong> Value3) Load3xVector128(ulong* address);
++            public unsafe static (Vector128<byte> Value1, Vector128<byte> Value2, Vector128<byte> Value3) Load3xVector128AndUnzip(byte* address);
++            public unsafe static (Vector128<double> Value1, Vector128<double> Value2, Vector128<double> Value3) Load3xVector128AndUnzip(double* address);
++            public unsafe static (Vector128<short> Value1, Vector128<short> Value2, Vector128<short> Value3) Load3xVector128AndUnzip(short* address);
++            public unsafe static (Vector128<int> Value1, Vector128<int> Value2, Vector128<int> Value3) Load3xVector128AndUnzip(int* address);
++            public unsafe static (Vector128<long> Value1, Vector128<long> Value2, Vector128<long> Value3) Load3xVector128AndUnzip(long* address);
++            public unsafe static (Vector128<sbyte> Value1, Vector128<sbyte> Value2, Vector128<sbyte> Value3) Load3xVector128AndUnzip(sbyte* address);
++            public unsafe static (Vector128<float> Value1, Vector128<float> Value2, Vector128<float> Value3) Load3xVector128AndUnzip(float* address);
++            public unsafe static (Vector128<ushort> Value1, Vector128<ushort> Value2, Vector128<ushort> Value3) Load3xVector128AndUnzip(ushort* address);
++            public unsafe static (Vector128<uint> Value1, Vector128<uint> Value2, Vector128<uint> Value3) Load3xVector128AndUnzip(uint* address);
++            public unsafe static (Vector128<ulong> Value1, Vector128<ulong> Value2, Vector128<ulong> Value3) Load3xVector128AndUnzip(ulong* address);
++            public unsafe static (Vector128<byte> Value1, Vector128<byte> Value2, Vector128<byte> Value3, Vector128<byte> Value4) Load4xVector128(byte* address);
++            public unsafe static (Vector128<double> Value1, Vector128<double> Value2, Vector128<double> Value3, Vector128<double> Value4) Load4xVector128(double* address);
++            public unsafe static (Vector128<short> Value1, Vector128<short> Value2, Vector128<short> Value3, Vector128<short> Value4) Load4xVector128(short* address);
++            public unsafe static (Vector128<int> Value1, Vector128<int> Value2, Vector128<int> Value3, Vector128<int> Value4) Load4xVector128(int* address);
++            public unsafe static (Vector128<long> Value1, Vector128<long> Value2, Vector128<long> Value3, Vector128<long> Value4) Load4xVector128(long* address);
++            public unsafe static (Vector128<sbyte> Value1, Vector128<sbyte> Value2, Vector128<sbyte> Value3, Vector128<sbyte> Value4) Load4xVector128(sbyte* address);
++            public unsafe static (Vector128<float> Value1, Vector128<float> Value2, Vector128<float> Value3, Vector128<float> Value4) Load4xVector128(float* address);
++            public unsafe static (Vector128<ushort> Value1, Vector128<ushort> Value2, Vector128<ushort> Value3, Vector128<ushort> Value4) Load4xVector128(ushort* address);
++            public unsafe static (Vector128<uint> Value1, Vector128<uint> Value2, Vector128<uint> Value3, Vector128<uint> Value4) Load4xVector128(uint* address);
++            public unsafe static (Vector128<ulong> Value1, Vector128<ulong> Value2, Vector128<ulong> Value3, Vector128<ulong> Value4) Load4xVector128(ulong* address);
++            public unsafe static (Vector128<byte> Value1, Vector128<byte> Value2, Vector128<byte> Value3, Vector128<byte> Value4) Load4xVector128AndUnzip(byte* address);
++            public unsafe static (Vector128<double> Value1, Vector128<double> Value2, Vector128<double> Value3, Vector128<double> Value4) Load4xVector128AndUnzip(double* address);
++            public unsafe static (Vector128<short> Value1, Vector128<short> Value2, Vector128<short> Value3, Vector128<short> Value4) Load4xVector128AndUnzip(short* address);
++            public unsafe static (Vector128<int> Value1, Vector128<int> Value2, Vector128<int> Value3, Vector128<int> Value4) Load4xVector128AndUnzip(int* address);
++            public unsafe static (Vector128<long> Value1, Vector128<long> Value2, Vector128<long> Value3, Vector128<long> Value4) Load4xVector128AndUnzip(long* address);
++            public unsafe static (Vector128<sbyte> Value1, Vector128<sbyte> Value2, Vector128<sbyte> Value3, Vector128<sbyte> Value4) Load4xVector128AndUnzip(sbyte* address);
++            public unsafe static (Vector128<float> Value1, Vector128<float> Value2, Vector128<float> Value3, Vector128<float> Value4) Load4xVector128AndUnzip(float* address);
++            public unsafe static (Vector128<ushort> Value1, Vector128<ushort> Value2, Vector128<ushort> Value3, Vector128<ushort> Value4) Load4xVector128AndUnzip(ushort* address);
++            public unsafe static (Vector128<uint> Value1, Vector128<uint> Value2, Vector128<uint> Value3, Vector128<uint> Value4) Load4xVector128AndUnzip(uint* address);
++            public unsafe static (Vector128<ulong> Value1, Vector128<ulong> Value2, Vector128<ulong> Value3, Vector128<ulong> Value4) Load4xVector128AndUnzip(ulong* address);
+-            public unsafe static (Vector128<byte> Value1, Vector128<byte> Value2) LoadVector128x2(byte* address);
+
+-            public unsafe static (Vector128<double> Value1, Vector128<double> Value2) LoadVector128x2(double* address);
+
+-            public unsafe static (Vector128<short> Value1, Vector128<short> Value2) LoadVector128x2(short* address);
+
+-            public unsafe static (Vector128<int> Value1, Vector128<int> Value2) LoadVector128x2(int* address);
+
+-            public unsafe static (Vector128<long> Value1, Vector128<long> Value2) LoadVector128x2(long* address);
+
+-            public unsafe static (Vector128<sbyte> Value1, Vector128<sbyte> Value2) LoadVector128x2(sbyte* address);
+
+-            public unsafe static (Vector128<float> Value1, Vector128<float> Value2) LoadVector128x2(float* address);
+
+-            public unsafe static (Vector128<ushort> Value1, Vector128<ushort> Value2) LoadVector128x2(ushort* address);
+
+-            public unsafe static (Vector128<uint> Value1, Vector128<uint> Value2) LoadVector128x2(uint* address);
+
+-            public unsafe static (Vector128<ulong> Value1, Vector128<ulong> Value2) LoadVector128x2(ulong* address);
+
+-            public unsafe static (Vector128<byte> Value1, Vector128<byte> Value2) LoadVector128x2AndUnzip(byte* address);
+
+-            public unsafe static (Vector128<double> Value1, Vector128<double> Value2) LoadVector128x2AndUnzip(double* address);
+
+-            public unsafe static (Vector128<short> Value1, Vector128<short> Value2) LoadVector128x2AndUnzip(short* address);
+
+-            public unsafe static (Vector128<int> Value1, Vector128<int> Value2) LoadVector128x2AndUnzip(int* address);
+
+-            public unsafe static (Vector128<long> Value1, Vector128<long> Value2) LoadVector128x2AndUnzip(long* address);
+
+-            public unsafe static (Vector128<sbyte> Value1, Vector128<sbyte> Value2) LoadVector128x2AndUnzip(sbyte* address);
+
+-            public unsafe static (Vector128<float> Value1, Vector128<float> Value2) LoadVector128x2AndUnzip(float* address);
+
+-            public unsafe static (Vector128<ushort> Value1, Vector128<ushort> Value2) LoadVector128x2AndUnzip(ushort* address);
+
+-            public unsafe static (Vector128<uint> Value1, Vector128<uint> Value2) LoadVector128x2AndUnzip(uint* address);
+
+-            public unsafe static (Vector128<ulong> Value1, Vector128<ulong> Value2) LoadVector128x2AndUnzip(ulong* address);
+
+-            public unsafe static (Vector128<byte> Value1, Vector128<byte> Value2, Vector128<byte> Value3) LoadVector128x3(byte* address);
+
+-            public unsafe static (Vector128<double> Value1, Vector128<double> Value2, Vector128<double> Value3) LoadVector128x3(double* address);
+
+-            public unsafe static (Vector128<short> Value1, Vector128<short> Value2, Vector128<short> Value3) LoadVector128x3(short* address);
+
+-            public unsafe static (Vector128<int> Value1, Vector128<int> Value2, Vector128<int> Value3) LoadVector128x3(int* address);
+
+-            public unsafe static (Vector128<long> Value1, Vector128<long> Value2, Vector128<long> Value3) LoadVector128x3(long* address);
+
+-            public unsafe static (Vector128<sbyte> Value1, Vector128<sbyte> Value2, Vector128<sbyte> Value3) LoadVector128x3(sbyte* address);
+
+-            public unsafe static (Vector128<float> Value1, Vector128<float> Value2, Vector128<float> Value3) LoadVector128x3(float* address);
+
+-            public unsafe static (Vector128<ushort> Value1, Vector128<ushort> Value2, Vector128<ushort> Value3) LoadVector128x3(ushort* address);
+
+-            public unsafe static (Vector128<uint> Value1, Vector128<uint> Value2, Vector128<uint> Value3) LoadVector128x3(uint* address);
+
+-            public unsafe static (Vector128<ulong> Value1, Vector128<ulong> Value2, Vector128<ulong> Value3) LoadVector128x3(ulong* address);
+
+-            public unsafe static (Vector128<byte> Value1, Vector128<byte> Value2, Vector128<byte> Value3) LoadVector128x3AndUnzip(byte* address);
+
+-            public unsafe static (Vector128<double> Value1, Vector128<double> Value2, Vector128<double> Value3) LoadVector128x3AndUnzip(double* address);
+
+-            public unsafe static (Vector128<short> Value1, Vector128<short> Value2, Vector128<short> Value3) LoadVector128x3AndUnzip(short* address);
+
+-            public unsafe static (Vector128<int> Value1, Vector128<int> Value2, Vector128<int> Value3) LoadVector128x3AndUnzip(int* address);
+
+-            public unsafe static (Vector128<long> Value1, Vector128<long> Value2, Vector128<long> Value3) LoadVector128x3AndUnzip(long* address);
+
+-            public unsafe static (Vector128<sbyte> Value1, Vector128<sbyte> Value2, Vector128<sbyte> Value3) LoadVector128x3AndUnzip(sbyte* address);
+
+-            public unsafe static (Vector128<float> Value1, Vector128<float> Value2, Vector128<float> Value3) LoadVector128x3AndUnzip(float* address);
+
+-            public unsafe static (Vector128<ushort> Value1, Vector128<ushort> Value2, Vector128<ushort> Value3) LoadVector128x3AndUnzip(ushort* address);
+
+-            public unsafe static (Vector128<uint> Value1, Vector128<uint> Value2, Vector128<uint> Value3) LoadVector128x3AndUnzip(uint* address);
+
+-            public unsafe static (Vector128<ulong> Value1, Vector128<ulong> Value2, Vector128<ulong> Value3) LoadVector128x3AndUnzip(ulong* address);
+
+-            public unsafe static (Vector128<byte> Value1, Vector128<byte> Value2, Vector128<byte> Value3, Vector128<byte> Value4) LoadVector128x4(byte* address);
+
+-            public unsafe static (Vector128<double> Value1, Vector128<double> Value2, Vector128<double> Value3, Vector128<double> Value4) LoadVector128x4(double* address);
+
+-            public unsafe static (Vector128<short> Value1, Vector128<short> Value2, Vector128<short> Value3, Vector128<short> Value4) LoadVector128x4(short* address);
+
+-            public unsafe static (Vector128<int> Value1, Vector128<int> Value2, Vector128<int> Value3, Vector128<int> Value4) LoadVector128x4(int* address);
+
+-            public unsafe static (Vector128<long> Value1, Vector128<long> Value2, Vector128<long> Value3, Vector128<long> Value4) LoadVector128x4(long* address);
+
+-            public unsafe static (Vector128<sbyte> Value1, Vector128<sbyte> Value2, Vector128<sbyte> Value3, Vector128<sbyte> Value4) LoadVector128x4(sbyte* address);
+
+-            public unsafe static (Vector128<float> Value1, Vector128<float> Value2, Vector128<float> Value3, Vector128<float> Value4) LoadVector128x4(float* address);
+
+-            public unsafe static (Vector128<ushort> Value1, Vector128<ushort> Value2, Vector128<ushort> Value3, Vector128<ushort> Value4) LoadVector128x4(ushort* address);
+
+-            public unsafe static (Vector128<uint> Value1, Vector128<uint> Value2, Vector128<uint> Value3, Vector128<uint> Value4) LoadVector128x4(uint* address);
+
+-            public unsafe static (Vector128<ulong> Value1, Vector128<ulong> Value2, Vector128<ulong> Value3, Vector128<ulong> Value4) LoadVector128x4(ulong* address);
+
+-            public unsafe static (Vector128<byte> Value1, Vector128<byte> Value2, Vector128<byte> Value3, Vector128<byte> Value4) LoadVector128x4AndUnzip(byte* address);
+
+-            public unsafe static (Vector128<double> Value1, Vector128<double> Value2, Vector128<double> Value3, Vector128<double> Value4) LoadVector128x4AndUnzip(double* address);
+
+-            public unsafe static (Vector128<short> Value1, Vector128<short> Value2, Vector128<short> Value3, Vector128<short> Value4) LoadVector128x4AndUnzip(short* address);
+
+-            public unsafe static (Vector128<int> Value1, Vector128<int> Value2, Vector128<int> Value3, Vector128<int> Value4) LoadVector128x4AndUnzip(int* address);
+
+-            public unsafe static (Vector128<long> Value1, Vector128<long> Value2, Vector128<long> Value3, Vector128<long> Value4) LoadVector128x4AndUnzip(long* address);
+
+-            public unsafe static (Vector128<sbyte> Value1, Vector128<sbyte> Value2, Vector128<sbyte> Value3, Vector128<sbyte> Value4) LoadVector128x4AndUnzip(sbyte* address);
+
+-            public unsafe static (Vector128<float> Value1, Vector128<float> Value2, Vector128<float> Value3, Vector128<float> Value4) LoadVector128x4AndUnzip(float* address);
+
+-            public unsafe static (Vector128<ushort> Value1, Vector128<ushort> Value2, Vector128<ushort> Value3, Vector128<ushort> Value4) LoadVector128x4AndUnzip(ushort* address);
+
+-            public unsafe static (Vector128<uint> Value1, Vector128<uint> Value2, Vector128<uint> Value3, Vector128<uint> Value4) LoadVector128x4AndUnzip(uint* address);
+
+-            public unsafe static (Vector128<ulong> Value1, Vector128<ulong> Value2, Vector128<ulong> Value3, Vector128<ulong> Value4) LoadVector128x4AndUnzip(ulong* address);
+
++            public unsafe static void Store(byte* address, (Vector128<byte> Value1, Vector128<byte> Value2, Vector128<byte> Value3, Vector128<byte> Value4) value);
++            public unsafe static void Store(byte* address, (Vector128<byte> Value1, Vector128<byte> Value2, Vector128<byte> Value3) value);
++            public unsafe static void Store(byte* address, (Vector128<byte> Value1, Vector128<byte> Value2) value);
++            public unsafe static void Store(double* address, (Vector128<double> Value1, Vector128<double> Value2, Vector128<double> Value3, Vector128<double> Value4) value);
++            public unsafe static void Store(double* address, (Vector128<double> Value1, Vector128<double> Value2, Vector128<double> Value3) value);
++            public unsafe static void Store(double* address, (Vector128<double> Value1, Vector128<double> Value2) value);
++            public unsafe static void Store(short* address, (Vector128<short> Value1, Vector128<short> Value2, Vector128<short> Value3, Vector128<short> Value4) value);
++            public unsafe static void Store(short* address, (Vector128<short> Value1, Vector128<short> Value2, Vector128<short> Value3) value);
++            public unsafe static void Store(short* address, (Vector128<short> Value1, Vector128<short> Value2) value);
++            public unsafe static void Store(int* address, (Vector128<int> Value1, Vector128<int> Value2, Vector128<int> Value3, Vector128<int> Value4) value);
++            public unsafe static void Store(int* address, (Vector128<int> Value1, Vector128<int> Value2, Vector128<int> Value3) value);
++            public unsafe static void Store(int* address, (Vector128<int> Value1, Vector128<int> Value2) value);
++            public unsafe static void Store(long* address, (Vector128<long> Value1, Vector128<long> Value2, Vector128<long> Value3, Vector128<long> Value4) value);
++            public unsafe static void Store(long* address, (Vector128<long> Value1, Vector128<long> Value2, Vector128<long> Value3) value);
++            public unsafe static void Store(long* address, (Vector128<long> Value1, Vector128<long> Value2) value);
++            public unsafe static void Store(sbyte* address, (Vector128<sbyte> Value1, Vector128<sbyte> Value2, Vector128<sbyte> Value3, Vector128<sbyte> Value4) value);
++            public unsafe static void Store(sbyte* address, (Vector128<sbyte> Value1, Vector128<sbyte> Value2, Vector128<sbyte> Value3) value);
++            public unsafe static void Store(sbyte* address, (Vector128<sbyte> Value1, Vector128<sbyte> Value2) value);
++            public unsafe static void Store(float* address, (Vector128<float> Value1, Vector128<float> Value2, Vector128<float> Value3, Vector128<float> Value4) value);
++            public unsafe static void Store(float* address, (Vector128<float> Value1, Vector128<float> Value2, Vector128<float> Value3) value);
++            public unsafe static void Store(float* address, (Vector128<float> Value1, Vector128<float> Value2) value);
++            public unsafe static void Store(ushort* address, (Vector128<ushort> Value1, Vector128<ushort> Value2, Vector128<ushort> Value3, Vector128<ushort> Value4) value);
++            public unsafe static void Store(ushort* address, (Vector128<ushort> Value1, Vector128<ushort> Value2, Vector128<ushort> Value3) value);
++            public unsafe static void Store(ushort* address, (Vector128<ushort> Value1, Vector128<ushort> Value2) value);
++            public unsafe static void Store(uint* address, (Vector128<uint> Value1, Vector128<uint> Value2, Vector128<uint> Value3, Vector128<uint> Value4) value);
++            public unsafe static void Store(uint* address, (Vector128<uint> Value1, Vector128<uint> Value2, Vector128<uint> Value3) value);
++            public unsafe static void Store(uint* address, (Vector128<uint> Value1, Vector128<uint> Value2) value);
++            public unsafe static void Store(ulong* address, (Vector128<ulong> Value1, Vector128<ulong> Value2, Vector128<ulong> Value3, Vector128<ulong> Value4) value);
++            public unsafe static void Store(ulong* address, (Vector128<ulong> Value1, Vector128<ulong> Value2, Vector128<ulong> Value3) value);
++            public unsafe static void Store(ulong* address, (Vector128<ulong> Value1, Vector128<ulong> Value2) value);
+-            public unsafe static void StoreVector128x2(byte* address, (Vector128<byte> Value1, Vector128<byte> Value2) value);
+
+-            public unsafe static void StoreVector128x2(double* address, (Vector128<double> Value1, Vector128<double> Value2) value);
+
+-            public unsafe static void StoreVector128x2(short* address, (Vector128<short> Value1, Vector128<short> Value2) value);
+
+-            public unsafe static void StoreVector128x2(int* address, (Vector128<int> Value1, Vector128<int> Value2) value);
+
+-            public unsafe static void StoreVector128x2(long* address, (Vector128<long> Value1, Vector128<long> Value2) value);
+
+-            public unsafe static void StoreVector128x2(sbyte* address, (Vector128<sbyte> Value1, Vector128<sbyte> Value2) value);
+
+-            public unsafe static void StoreVector128x2(float* address, (Vector128<float> Value1, Vector128<float> Value2) value);
+
+-            public unsafe static void StoreVector128x2(ushort* address, (Vector128<ushort> Value1, Vector128<ushort> Value2) value);
+
+-            public unsafe static void StoreVector128x2(uint* address, (Vector128<uint> Value1, Vector128<uint> Value2) value);
+
+-            public unsafe static void StoreVector128x2(ulong* address, (Vector128<ulong> Value1, Vector128<ulong> Value2) value);
+
+-            public unsafe static void StoreVector128x2AndZip(byte* address, (Vector128<byte> Value1, Vector128<byte> Value2) value);
+
+-            public unsafe static void StoreVector128x2AndZip(double* address, (Vector128<double> Value1, Vector128<double> Value2) value);
+
+-            public unsafe static void StoreVector128x2AndZip(short* address, (Vector128<short> Value1, Vector128<short> Value2) value);
+
+-            public unsafe static void StoreVector128x2AndZip(int* address, (Vector128<int> Value1, Vector128<int> Value2) value);
+
+-            public unsafe static void StoreVector128x2AndZip(long* address, (Vector128<long> Value1, Vector128<long> Value2) value);
+
+-            public unsafe static void StoreVector128x2AndZip(sbyte* address, (Vector128<sbyte> Value1, Vector128<sbyte> Value2) value);
+
+-            public unsafe static void StoreVector128x2AndZip(float* address, (Vector128<float> Value1, Vector128<float> Value2) value);
+
+-            public unsafe static void StoreVector128x2AndZip(ushort* address, (Vector128<ushort> Value1, Vector128<ushort> Value2) value);
+
+-            public unsafe static void StoreVector128x2AndZip(uint* address, (Vector128<uint> Value1, Vector128<uint> Value2) value);
+
+-            public unsafe static void StoreVector128x2AndZip(ulong* address, (Vector128<ulong> Value1, Vector128<ulong> Value2) value);
+
+-            public unsafe static void StoreVector128x3(byte* address, (Vector128<byte> Value1, Vector128<byte> Value2, Vector128<byte> Value3) value);
+
+-            public unsafe static void StoreVector128x3(double* address, (Vector128<double> Value1, Vector128<double> Value2, Vector128<double> Value3) value);
+
+-            public unsafe static void StoreVector128x3(short* address, (Vector128<short> Value1, Vector128<short> Value2, Vector128<short> Value3) value);
+
+-            public unsafe static void StoreVector128x3(int* address, (Vector128<int> Value1, Vector128<int> Value2, Vector128<int> Value3) value);
+
+-            public unsafe static void StoreVector128x3(long* address, (Vector128<long> Value1, Vector128<long> Value2, Vector128<long> Value3) value);
+
+-            public unsafe static void StoreVector128x3(sbyte* address, (Vector128<sbyte> Value1, Vector128<sbyte> Value2, Vector128<sbyte> Value3) value);
+
+-            public unsafe static void StoreVector128x3(float* address, (Vector128<float> Value1, Vector128<float> Value2, Vector128<float> Value3) value);
+
+-            public unsafe static void StoreVector128x3(ushort* address, (Vector128<ushort> Value1, Vector128<ushort> Value2, Vector128<ushort> Value3) value);
+
+-            public unsafe static void StoreVector128x3(uint* address, (Vector128<uint> Value1, Vector128<uint> Value2, Vector128<uint> Value3) value);
+
+-            public unsafe static void StoreVector128x3(ulong* address, (Vector128<ulong> Value1, Vector128<ulong> Value2, Vector128<ulong> Value3) value);
+
+-            public unsafe static void StoreVector128x3AndZip(byte* address, (Vector128<byte> Value1, Vector128<byte> Value2, Vector128<byte> Value3) value);
+
+-            public unsafe static void StoreVector128x3AndZip(double* address, (Vector128<double> Value1, Vector128<double> Value2, Vector128<double> Value3) value);
+
+-            public unsafe static void StoreVector128x3AndZip(short* address, (Vector128<short> Value1, Vector128<short> Value2, Vector128<short> Value3) value);
+
+-            public unsafe static void StoreVector128x3AndZip(int* address, (Vector128<int> Value1, Vector128<int> Value2, Vector128<int> Value3) value);
+
+-            public unsafe static void StoreVector128x3AndZip(long* address, (Vector128<long> Value1, Vector128<long> Value2, Vector128<long> Value3) value);
+
+-            public unsafe static void StoreVector128x3AndZip(sbyte* address, (Vector128<sbyte> Value1, Vector128<sbyte> Value2, Vector128<sbyte> Value3) value);
+
+-            public unsafe static void StoreVector128x3AndZip(float* address, (Vector128<float> Value1, Vector128<float> Value2, Vector128<float> Value3) value);
+
+-            public unsafe static void StoreVector128x3AndZip(ushort* address, (Vector128<ushort> Value1, Vector128<ushort> Value2, Vector128<ushort> Value3) value);
+
+-            public unsafe static void StoreVector128x3AndZip(uint* address, (Vector128<uint> Value1, Vector128<uint> Value2, Vector128<uint> Value3) value);
+
+-            public unsafe static void StoreVector128x3AndZip(ulong* address, (Vector128<ulong> Value1, Vector128<ulong> Value2, Vector128<ulong> Value3) value);
+
+-            public unsafe static void StoreVector128x4(byte* address, (Vector128<byte> Value1, Vector128<byte> Value2, Vector128<byte> Value3, Vector128<byte> Value4) value);
+
+-            public unsafe static void StoreVector128x4(double* address, (Vector128<double> Value1, Vector128<double> Value2, Vector128<double> Value3, Vector128<double> Value4) value);
+
+-            public unsafe static void StoreVector128x4(short* address, (Vector128<short> Value1, Vector128<short> Value2, Vector128<short> Value3, Vector128<short> Value4) value);
+
+-            public unsafe static void StoreVector128x4(int* address, (Vector128<int> Value1, Vector128<int> Value2, Vector128<int> Value3, Vector128<int> Value4) value);
+
+-            public unsafe static void StoreVector128x4(long* address, (Vector128<long> Value1, Vector128<long> Value2, Vector128<long> Value3, Vector128<long> Value4) value);
+
+-            public unsafe static void StoreVector128x4(sbyte* address, (Vector128<sbyte> Value1, Vector128<sbyte> Value2, Vector128<sbyte> Value3, Vector128<sbyte> Value4) value);
+
+-            public unsafe static void StoreVector128x4(float* address, (Vector128<float> Value1, Vector128<float> Value2, Vector128<float> Value3, Vector128<float> Value4) value);
+
+-            public unsafe static void StoreVector128x4(ushort* address, (Vector128<ushort> Value1, Vector128<ushort> Value2, Vector128<ushort> Value3, Vector128<ushort> Value4) value);
+
+-            public unsafe static void StoreVector128x4(uint* address, (Vector128<uint> Value1, Vector128<uint> Value2, Vector128<uint> Value3, Vector128<uint> Value4) value);
+
+-            public unsafe static void StoreVector128x4(ulong* address, (Vector128<ulong> Value1, Vector128<ulong> Value2, Vector128<ulong> Value3, Vector128<ulong> Value4) value);
+
+-            public unsafe static void StoreVector128x4AndZip(byte* address, (Vector128<byte> Value1, Vector128<byte> Value2, Vector128<byte> Value3, Vector128<byte> Value4) value);
+
+-            public unsafe static void StoreVector128x4AndZip(double* address, (Vector128<double> Value1, Vector128<double> Value2, Vector128<double> Value3, Vector128<double> Value4) value);
+
+-            public unsafe static void StoreVector128x4AndZip(short* address, (Vector128<short> Value1, Vector128<short> Value2, Vector128<short> Value3, Vector128<short> Value4) value);
+
+-            public unsafe static void StoreVector128x4AndZip(int* address, (Vector128<int> Value1, Vector128<int> Value2, Vector128<int> Value3, Vector128<int> Value4) value);
+
+-            public unsafe static void StoreVector128x4AndZip(long* address, (Vector128<long> Value1, Vector128<long> Value2, Vector128<long> Value3, Vector128<long> Value4) value);
+
+-            public unsafe static void StoreVector128x4AndZip(sbyte* address, (Vector128<sbyte> Value1, Vector128<sbyte> Value2, Vector128<sbyte> Value3, Vector128<sbyte> Value4) value);
+
+-            public unsafe static void StoreVector128x4AndZip(float* address, (Vector128<float> Value1, Vector128<float> Value2, Vector128<float> Value3, Vector128<float> Value4) value);
+
+-            public unsafe static void StoreVector128x4AndZip(ushort* address, (Vector128<ushort> Value1, Vector128<ushort> Value2, Vector128<ushort> Value3, Vector128<ushort> Value4) value);
+
+-            public unsafe static void StoreVector128x4AndZip(uint* address, (Vector128<uint> Value1, Vector128<uint> Value2, Vector128<uint> Value3, Vector128<uint> Value4) value);
+
+-            public unsafe static void StoreVector128x4AndZip(ulong* address, (Vector128<ulong> Value1, Vector128<ulong> Value2, Vector128<ulong> Value3, Vector128<ulong> Value4) value);
+
++            public unsafe static void StoreVectorAndZip(byte* address, (Vector128<byte> Value1, Vector128<byte> Value2, Vector128<byte> Value3, Vector128<byte> Value4) value);
++            public unsafe static void StoreVectorAndZip(byte* address, (Vector128<byte> Value1, Vector128<byte> Value2, Vector128<byte> Value3) value);
++            public unsafe static void StoreVectorAndZip(byte* address, (Vector128<byte> Value1, Vector128<byte> Value2) value);
++            public unsafe static void StoreVectorAndZip(double* address, (Vector128<double> Value1, Vector128<double> Value2, Vector128<double> Value3, Vector128<double> Value4) value);
++            public unsafe static void StoreVectorAndZip(double* address, (Vector128<double> Value1, Vector128<double> Value2, Vector128<double> Value3) value);
++            public unsafe static void StoreVectorAndZip(double* address, (Vector128<double> Value1, Vector128<double> Value2) value);
++            public unsafe static void StoreVectorAndZip(short* address, (Vector128<short> Value1, Vector128<short> Value2, Vector128<short> Value3, Vector128<short> Value4) value);
++            public unsafe static void StoreVectorAndZip(short* address, (Vector128<short> Value1, Vector128<short> Value2, Vector128<short> Value3) value);
++            public unsafe static void StoreVectorAndZip(short* address, (Vector128<short> Value1, Vector128<short> Value2) value);
++            public unsafe static void StoreVectorAndZip(int* address, (Vector128<int> Value1, Vector128<int> Value2, Vector128<int> Value3, Vector128<int> Value4) value);
++            public unsafe static void StoreVectorAndZip(int* address, (Vector128<int> Value1, Vector128<int> Value2, Vector128<int> Value3) value);
++            public unsafe static void StoreVectorAndZip(int* address, (Vector128<int> Value1, Vector128<int> Value2) value);
++            public unsafe static void StoreVectorAndZip(long* address, (Vector128<long> Value1, Vector128<long> Value2, Vector128<long> Value3, Vector128<long> Value4) value);
++            public unsafe static void StoreVectorAndZip(long* address, (Vector128<long> Value1, Vector128<long> Value2, Vector128<long> Value3) value);
++            public unsafe static void StoreVectorAndZip(long* address, (Vector128<long> Value1, Vector128<long> Value2) value);
++            public unsafe static void StoreVectorAndZip(sbyte* address, (Vector128<sbyte> Value1, Vector128<sbyte> Value2, Vector128<sbyte> Value3, Vector128<sbyte> Value4) value);
++            public unsafe static void StoreVectorAndZip(sbyte* address, (Vector128<sbyte> Value1, Vector128<sbyte> Value2, Vector128<sbyte> Value3) value);
++            public unsafe static void StoreVectorAndZip(sbyte* address, (Vector128<sbyte> Value1, Vector128<sbyte> Value2) value);
++            public unsafe static void StoreVectorAndZip(float* address, (Vector128<float> Value1, Vector128<float> Value2, Vector128<float> Value3, Vector128<float> Value4) value);
++            public unsafe static void StoreVectorAndZip(float* address, (Vector128<float> Value1, Vector128<float> Value2, Vector128<float> Value3) value);
++            public unsafe static void StoreVectorAndZip(float* address, (Vector128<float> Value1, Vector128<float> Value2) value);
++            public unsafe static void StoreVectorAndZip(ushort* address, (Vector128<ushort> Value1, Vector128<ushort> Value2, Vector128<ushort> Value3, Vector128<ushort> Value4) value);
++            public unsafe static void StoreVectorAndZip(ushort* address, (Vector128<ushort> Value1, Vector128<ushort> Value2, Vector128<ushort> Value3) value);
++            public unsafe static void StoreVectorAndZip(ushort* address, (Vector128<ushort> Value1, Vector128<ushort> Value2) value);
++            public unsafe static void StoreVectorAndZip(uint* address, (Vector128<uint> Value1, Vector128<uint> Value2, Vector128<uint> Value3, Vector128<uint> Value4) value);
++            public unsafe static void StoreVectorAndZip(uint* address, (Vector128<uint> Value1, Vector128<uint> Value2, Vector128<uint> Value3) value);
++            public unsafe static void StoreVectorAndZip(uint* address, (Vector128<uint> Value1, Vector128<uint> Value2) value);
++            public unsafe static void StoreVectorAndZip(ulong* address, (Vector128<ulong> Value1, Vector128<ulong> Value2, Vector128<ulong> Value3, Vector128<ulong> Value4) value);
++            public unsafe static void StoreVectorAndZip(ulong* address, (Vector128<ulong> Value1, Vector128<ulong> Value2, Vector128<ulong> Value3) value);
++            public unsafe static void StoreVectorAndZip(ulong* address, (Vector128<ulong> Value1, Vector128<ulong> Value2) value);
+         }
+     }
+     public abstract class Sve : AdvSimd {
++        public static Vector<double> Compact(Vector<double> mask, Vector<double> value);
++        public static Vector<int> Compact(Vector<int> mask, Vector<int> value);
++        public static Vector<long> Compact(Vector<long> mask, Vector<long> value);
++        public static Vector<float> Compact(Vector<float> mask, Vector<float> value);
++        public static Vector<uint> Compact(Vector<uint> mask, Vector<uint> value);
++        public static Vector<ulong> Compact(Vector<ulong> mask, Vector<ulong> value);
++        public static Vector<uint> Compute16BitAddresses(Vector<uint> bases, Vector<int> indices);
++        public static Vector<uint> Compute16BitAddresses(Vector<uint> bases, Vector<uint> indices);
++        public static Vector<ulong> Compute16BitAddresses(Vector<ulong> bases, Vector<long> indices);
++        public static Vector<ulong> Compute16BitAddresses(Vector<ulong> bases, Vector<ulong> indices);
++        public static Vector<uint> Compute32BitAddresses(Vector<uint> bases, Vector<int> indices);
++        public static Vector<uint> Compute32BitAddresses(Vector<uint> bases, Vector<uint> indices);
++        public static Vector<ulong> Compute32BitAddresses(Vector<ulong> bases, Vector<long> indices);
++        public static Vector<ulong> Compute32BitAddresses(Vector<ulong> bases, Vector<ulong> indices);
++        public static Vector<uint> Compute64BitAddresses(Vector<uint> bases, Vector<int> indices);
++        public static Vector<uint> Compute64BitAddresses(Vector<uint> bases, Vector<uint> indices);
++        public static Vector<ulong> Compute64BitAddresses(Vector<ulong> bases, Vector<long> indices);
++        public static Vector<ulong> Compute64BitAddresses(Vector<ulong> bases, Vector<ulong> indices);
++        public static Vector<uint> Compute8BitAddresses(Vector<uint> bases, Vector<int> indices);
++        public static Vector<uint> Compute8BitAddresses(Vector<uint> bases, Vector<uint> indices);
++        public static Vector<ulong> Compute8BitAddresses(Vector<ulong> bases, Vector<long> indices);
++        public static Vector<ulong> Compute8BitAddresses(Vector<ulong> bases, Vector<ulong> indices);
++        public static Vector<int> ConvertToInt32(Vector<double> value);
++        public static Vector<int> ConvertToInt32(Vector<float> value);
++        public static Vector<uint> ConvertToUInt32(Vector<double> value);
++        public static Vector<uint> ConvertToUInt32(Vector<float> value);
++        public unsafe static Vector<double> GatherVector(Vector<double> mask, double* address, Vector<long> indices);
++        public unsafe static Vector<double> GatherVector(Vector<double> mask, double* address, Vector<ulong> indices);
++        public static Vector<double> GatherVector(Vector<double> mask, Vector<ulong> addresses);
++        public unsafe static Vector<int> GatherVector(Vector<int> mask, int* address, Vector<int> indices);
++        public unsafe static Vector<int> GatherVector(Vector<int> mask, int* address, Vector<uint> indices);
++        public unsafe static Vector<long> GatherVector(Vector<long> mask, long* address, Vector<long> indices);
++        public unsafe static Vector<long> GatherVector(Vector<long> mask, long* address, Vector<ulong> indices);
++        public static Vector<long> GatherVector(Vector<long> mask, Vector<ulong> addresses);
++        public unsafe static Vector<float> GatherVector(Vector<float> mask, float* address, Vector<int> indices);
++        public unsafe static Vector<float> GatherVector(Vector<float> mask, float* address, Vector<uint> indices);
++        public unsafe static Vector<uint> GatherVector(Vector<uint> mask, uint* address, Vector<int> indices);
++        public unsafe static Vector<uint> GatherVector(Vector<uint> mask, uint* address, Vector<uint> indices);
++        public static Vector<ulong> GatherVector(Vector<ulong> mask, Vector<ulong> addresses);
++        public unsafe static Vector<ulong> GatherVector(Vector<ulong> mask, ulong* address, Vector<long> indices);
++        public unsafe static Vector<ulong> GatherVector(Vector<ulong> mask, ulong* address, Vector<ulong> indices);
++        public unsafe static Vector<int> GatherVectorByteZeroExtend(Vector<int> mask, byte* address, Vector<int> indices);
++        public unsafe static Vector<int> GatherVectorByteZeroExtend(Vector<int> mask, byte* address, Vector<uint> indices);
++        public unsafe static Vector<long> GatherVectorByteZeroExtend(Vector<long> mask, byte* address, Vector<long> indices);
++        public unsafe static Vector<long> GatherVectorByteZeroExtend(Vector<long> mask, byte* address, Vector<ulong> indices);
++        public static Vector<long> GatherVectorByteZeroExtend(Vector<long> mask, Vector<ulong> addresses);
++        public unsafe static Vector<uint> GatherVectorByteZeroExtend(Vector<uint> mask, byte* address, Vector<int> indices);
++        public unsafe static Vector<uint> GatherVectorByteZeroExtend(Vector<uint> mask, byte* address, Vector<uint> indices);
++        public unsafe static Vector<ulong> GatherVectorByteZeroExtend(Vector<ulong> mask, byte* address, Vector<long> indices);
++        public unsafe static Vector<ulong> GatherVectorByteZeroExtend(Vector<ulong> mask, byte* address, Vector<ulong> indices);
++        public static Vector<ulong> GatherVectorByteZeroExtend(Vector<ulong> mask, Vector<ulong> addresses);
++        public unsafe static Vector<int> GatherVectorInt16SignExtend(Vector<int> mask, short* address, Vector<int> indices);
++        public unsafe static Vector<int> GatherVectorInt16SignExtend(Vector<int> mask, short* address, Vector<uint> indices);
++        public unsafe static Vector<long> GatherVectorInt16SignExtend(Vector<long> mask, short* address, Vector<long> indices);
++        public unsafe static Vector<long> GatherVectorInt16SignExtend(Vector<long> mask, short* address, Vector<ulong> indices);
++        public static Vector<long> GatherVectorInt16SignExtend(Vector<long> mask, Vector<ulong> addresses);
++        public unsafe static Vector<uint> GatherVectorInt16SignExtend(Vector<uint> mask, short* address, Vector<int> indices);
++        public unsafe static Vector<uint> GatherVectorInt16SignExtend(Vector<uint> mask, short* address, Vector<uint> indices);
++        public unsafe static Vector<ulong> GatherVectorInt16SignExtend(Vector<ulong> mask, short* address, Vector<long> indices);
++        public unsafe static Vector<ulong> GatherVectorInt16SignExtend(Vector<ulong> mask, short* address, Vector<ulong> indices);
++        public static Vector<ulong> GatherVectorInt16SignExtend(Vector<ulong> mask, Vector<ulong> addresses);
++        public unsafe static Vector<int> GatherVectorInt16WithByteOffsetsSignExtend(Vector<int> mask, short* address, Vector<int> offsets);
++        public unsafe static Vector<int> GatherVectorInt16WithByteOffsetsSignExtend(Vector<int> mask, short* address, Vector<uint> offsets);
++        public unsafe static Vector<long> GatherVectorInt16WithByteOffsetsSignExtend(Vector<long> mask, short* address, Vector<long> offsets);
++        public unsafe static Vector<long> GatherVectorInt16WithByteOffsetsSignExtend(Vector<long> mask, short* address, Vector<ulong> offsets);
++        public unsafe static Vector<uint> GatherVectorInt16WithByteOffsetsSignExtend(Vector<uint> mask, short* address, Vector<int> offsets);
++        public unsafe static Vector<uint> GatherVectorInt16WithByteOffsetsSignExtend(Vector<uint> mask, short* address, Vector<uint> offsets);
++        public unsafe static Vector<ulong> GatherVectorInt16WithByteOffsetsSignExtend(Vector<ulong> mask, short* address, Vector<long> offsets);
++        public unsafe static Vector<ulong> GatherVectorInt16WithByteOffsetsSignExtend(Vector<ulong> mask, short* address, Vector<ulong> offsets);
++        public unsafe static Vector<long> GatherVectorInt32SignExtend(Vector<long> mask, int* address, Vector<long> indices);
++        public unsafe static Vector<long> GatherVectorInt32SignExtend(Vector<long> mask, int* address, Vector<ulong> indices);
++        public static Vector<long> GatherVectorInt32SignExtend(Vector<long> mask, Vector<ulong> addresses);
++        public unsafe static Vector<ulong> GatherVectorInt32SignExtend(Vector<ulong> mask, int* address, Vector<long> indices);
++        public unsafe static Vector<ulong> GatherVectorInt32SignExtend(Vector<ulong> mask, int* address, Vector<ulong> indices);
++        public static Vector<ulong> GatherVectorInt32SignExtend(Vector<ulong> mask, Vector<ulong> addresses);
++        public unsafe static Vector<long> GatherVectorInt32WithByteOffsetsSignExtend(Vector<long> mask, int* address, Vector<long> offsets);
++        public unsafe static Vector<long> GatherVectorInt32WithByteOffsetsSignExtend(Vector<long> mask, int* address, Vector<ulong> offsets);
++        public unsafe static Vector<ulong> GatherVectorInt32WithByteOffsetsSignExtend(Vector<ulong> mask, int* address, Vector<long> offsets);
++        public unsafe static Vector<ulong> GatherVectorInt32WithByteOffsetsSignExtend(Vector<ulong> mask, int* address, Vector<ulong> offsets);
++        public unsafe static Vector<int> GatherVectorSByteSignExtend(Vector<int> mask, sbyte* address, Vector<int> indices);
++        public unsafe static Vector<int> GatherVectorSByteSignExtend(Vector<int> mask, sbyte* address, Vector<uint> indices);
++        public static Vector<long> GatherVectorSByteSignExtend(Vector<long> mask, Vector<ulong> addresses);
++        public unsafe static Vector<long> GatherVectorSByteSignExtend(Vector<long> mask, sbyte* address, Vector<long> indices);
++        public unsafe static Vector<long> GatherVectorSByteSignExtend(Vector<long> mask, sbyte* address, Vector<ulong> indices);
++        public unsafe static Vector<uint> GatherVectorSByteSignExtend(Vector<uint> mask, sbyte* address, Vector<int> indices);
++        public unsafe static Vector<uint> GatherVectorSByteSignExtend(Vector<uint> mask, sbyte* address, Vector<uint> indices);
++        public static Vector<ulong> GatherVectorSByteSignExtend(Vector<ulong> mask, Vector<ulong> addresses);
++        public unsafe static Vector<ulong> GatherVectorSByteSignExtend(Vector<ulong> mask, sbyte* address, Vector<long> indices);
++        public unsafe static Vector<ulong> GatherVectorSByteSignExtend(Vector<ulong> mask, sbyte* address, Vector<ulong> indices);
++        public unsafe static Vector<int> GatherVectorUInt16WithByteOffsetsZeroExtend(Vector<int> mask, ushort* address, Vector<int> offsets);
++        public unsafe static Vector<int> GatherVectorUInt16WithByteOffsetsZeroExtend(Vector<int> mask, ushort* address, Vector<uint> offsets);
++        public unsafe static Vector<long> GatherVectorUInt16WithByteOffsetsZeroExtend(Vector<long> mask, ushort* address, Vector<long> offsets);
++        public unsafe static Vector<long> GatherVectorUInt16WithByteOffsetsZeroExtend(Vector<long> mask, ushort* address, Vector<ulong> offsets);
++        public unsafe static Vector<uint> GatherVectorUInt16WithByteOffsetsZeroExtend(Vector<uint> mask, ushort* address, Vector<int> offsets);
++        public unsafe static Vector<uint> GatherVectorUInt16WithByteOffsetsZeroExtend(Vector<uint> mask, ushort* address, Vector<uint> offsets);
++        public unsafe static Vector<ulong> GatherVectorUInt16WithByteOffsetsZeroExtend(Vector<ulong> mask, ushort* address, Vector<long> offsets);
++        public unsafe static Vector<ulong> GatherVectorUInt16WithByteOffsetsZeroExtend(Vector<ulong> mask, ushort* address, Vector<ulong> offsets);
++        public unsafe static Vector<int> GatherVectorUInt16ZeroExtend(Vector<int> mask, ushort* address, Vector<int> indices);
++        public unsafe static Vector<int> GatherVectorUInt16ZeroExtend(Vector<int> mask, ushort* address, Vector<uint> indices);
++        public static Vector<long> GatherVectorUInt16ZeroExtend(Vector<long> mask, Vector<ulong> addresses);
++        public unsafe static Vector<long> GatherVectorUInt16ZeroExtend(Vector<long> mask, ushort* address, Vector<long> indices);
++        public unsafe static Vector<long> GatherVectorUInt16ZeroExtend(Vector<long> mask, ushort* address, Vector<ulong> indices);
++        public unsafe static Vector<uint> GatherVectorUInt16ZeroExtend(Vector<uint> mask, ushort* address, Vector<int> indices);
++        public unsafe static Vector<uint> GatherVectorUInt16ZeroExtend(Vector<uint> mask, ushort* address, Vector<uint> indices);
++        public static Vector<ulong> GatherVectorUInt16ZeroExtend(Vector<ulong> mask, Vector<ulong> addresses);
++        public unsafe static Vector<ulong> GatherVectorUInt16ZeroExtend(Vector<ulong> mask, ushort* address, Vector<long> indices);
++        public unsafe static Vector<ulong> GatherVectorUInt16ZeroExtend(Vector<ulong> mask, ushort* address, Vector<ulong> indices);
++        public unsafe static Vector<int> GatherVectorUInt32WithByteOffsetsZeroExtend(Vector<int> mask, uint* address, Vector<int> offsets);
++        public unsafe static Vector<int> GatherVectorUInt32WithByteOffsetsZeroExtend(Vector<int> mask, uint* address, Vector<uint> offsets);
++        public unsafe static Vector<long> GatherVectorUInt32WithByteOffsetsZeroExtend(Vector<long> mask, uint* address, Vector<long> offsets);
++        public unsafe static Vector<long> GatherVectorUInt32WithByteOffsetsZeroExtend(Vector<long> mask, uint* address, Vector<ulong> offsets);
++        public unsafe static Vector<uint> GatherVectorUInt32WithByteOffsetsZeroExtend(Vector<uint> mask, uint* address, Vector<int> offsets);
++        public unsafe static Vector<uint> GatherVectorUInt32WithByteOffsetsZeroExtend(Vector<uint> mask, uint* address, Vector<uint> offsets);
++        public unsafe static Vector<ulong> GatherVectorUInt32WithByteOffsetsZeroExtend(Vector<ulong> mask, uint* address, Vector<long> offsets);
++        public unsafe static Vector<ulong> GatherVectorUInt32WithByteOffsetsZeroExtend(Vector<ulong> mask, uint* address, Vector<ulong> offsets);
++        public unsafe static Vector<int> GatherVectorUInt32ZeroExtend(Vector<int> mask, uint* address, Vector<int> indices);
++        public unsafe static Vector<int> GatherVectorUInt32ZeroExtend(Vector<int> mask, uint* address, Vector<uint> indices);
++        public static Vector<long> GatherVectorUInt32ZeroExtend(Vector<long> mask, Vector<ulong> addresses);
++        public unsafe static Vector<long> GatherVectorUInt32ZeroExtend(Vector<long> mask, uint* address, Vector<long> indices);
++        public unsafe static Vector<long> GatherVectorUInt32ZeroExtend(Vector<long> mask, uint* address, Vector<ulong> indices);
++        public unsafe static Vector<uint> GatherVectorUInt32ZeroExtend(Vector<uint> mask, uint* address, Vector<int> indices);
++        public unsafe static Vector<uint> GatherVectorUInt32ZeroExtend(Vector<uint> mask, uint* address, Vector<uint> indices);
++        public static Vector<ulong> GatherVectorUInt32ZeroExtend(Vector<ulong> mask, Vector<ulong> addresses);
++        public unsafe static Vector<ulong> GatherVectorUInt32ZeroExtend(Vector<ulong> mask, uint* address, Vector<long> indices);
++        public unsafe static Vector<ulong> GatherVectorUInt32ZeroExtend(Vector<ulong> mask, uint* address, Vector<ulong> indices);
++        public unsafe static Vector<double> GatherVectorWithByteOffsets(Vector<double> mask, double* address, Vector<long> offsets);
++        public unsafe static Vector<double> GatherVectorWithByteOffsets(Vector<double> mask, double* address, Vector<ulong> offsets);
++        public unsafe static Vector<int> GatherVectorWithByteOffsets(Vector<int> mask, int* address, Vector<int> offsets);
++        public unsafe static Vector<int> GatherVectorWithByteOffsets(Vector<int> mask, int* address, Vector<uint> offsets);
++        public unsafe static Vector<long> GatherVectorWithByteOffsets(Vector<long> mask, long* address, Vector<long> offsets);
++        public unsafe static Vector<long> GatherVectorWithByteOffsets(Vector<long> mask, long* address, Vector<ulong> offsets);
++        public unsafe static Vector<float> GatherVectorWithByteOffsets(Vector<float> mask, float* address, Vector<int> offsets);
++        public unsafe static Vector<float> GatherVectorWithByteOffsets(Vector<float> mask, float* address, Vector<uint> offsets);
++        public unsafe static Vector<uint> GatherVectorWithByteOffsets(Vector<uint> mask, uint* address, Vector<int> offsets);
++        public unsafe static Vector<uint> GatherVectorWithByteOffsets(Vector<uint> mask, uint* address, Vector<uint> offsets);
++        public unsafe static Vector<ulong> GatherVectorWithByteOffsets(Vector<ulong> mask, ulong* address, Vector<long> offsets);
++        public unsafe static Vector<ulong> GatherVectorWithByteOffsets(Vector<ulong> mask, ulong* address, Vector<ulong> offsets);
++        public static ulong GetActiveElementCount(Vector<byte> mask, Vector<byte> from);
++        public static ulong GetActiveElementCount(Vector<double> mask, Vector<double> from);
++        public static ulong GetActiveElementCount(Vector<short> mask, Vector<short> from);
++        public static ulong GetActiveElementCount(Vector<int> mask, Vector<int> from);
++        public static ulong GetActiveElementCount(Vector<long> mask, Vector<long> from);
++        public static ulong GetActiveElementCount(Vector<sbyte> mask, Vector<sbyte> from);
++        public static ulong GetActiveElementCount(Vector<float> mask, Vector<float> from);
++        public static ulong GetActiveElementCount(Vector<ushort> mask, Vector<ushort> from);
++        public static ulong GetActiveElementCount(Vector<uint> mask, Vector<uint> from);
++        public static ulong GetActiveElementCount(Vector<ulong> mask, Vector<ulong> from);
++        public static Vector<ushort> LeadingSignCount(Vector<short> value);
++        public static Vector<uint> LeadingSignCount(Vector<int> value);
++        public static Vector<ulong> LeadingSignCount(Vector<long> value);
++        public static Vector<byte> LeadingSignCount(Vector<sbyte> value);
++        public static Vector<byte> LeadingZeroCount(Vector<byte> value);
++        public static Vector<ushort> LeadingZeroCount(Vector<short> value);
++        public static Vector<uint> LeadingZeroCount(Vector<int> value);
++        public static Vector<ulong> LeadingZeroCount(Vector<long> value);
++        public static Vector<byte> LeadingZeroCount(Vector<sbyte> value);
++        public static Vector<ushort> LeadingZeroCount(Vector<ushort> value);
++        public static Vector<uint> LeadingZeroCount(Vector<uint> value);
++        public static Vector<ulong> LeadingZeroCount(Vector<ulong> value);
++        public unsafe static (Vector<byte>, Vector<byte>) Load2xVectorAndUnzip(Vector<byte> mask, byte* address);
++        public unsafe static (Vector<double>, Vector<double>) Load2xVectorAndUnzip(Vector<double> mask, double* address);
++        public unsafe static (Vector<short>, Vector<short>) Load2xVectorAndUnzip(Vector<short> mask, short* address);
++        public unsafe static (Vector<int>, Vector<int>) Load2xVectorAndUnzip(Vector<int> mask, int* address);
++        public unsafe static (Vector<long>, Vector<long>) Load2xVectorAndUnzip(Vector<long> mask, long* address);
++        public unsafe static (Vector<sbyte>, Vector<sbyte>) Load2xVectorAndUnzip(Vector<sbyte> mask, sbyte* address);
++        public unsafe static (Vector<float>, Vector<float>) Load2xVectorAndUnzip(Vector<float> mask, float* address);
++        public unsafe static (Vector<ushort>, Vector<ushort>) Load2xVectorAndUnzip(Vector<ushort> mask, ushort* address);
++        public unsafe static (Vector<uint>, Vector<uint>) Load2xVectorAndUnzip(Vector<uint> mask, uint* address);
++        public unsafe static (Vector<ulong>, Vector<ulong>) Load2xVectorAndUnzip(Vector<ulong> mask, ulong* address);
++        public unsafe static (Vector<byte>, Vector<byte>, Vector<byte>) Load3xVectorAndUnzip(Vector<byte> mask, byte* address);
++        public unsafe static (Vector<double>, Vector<double>, Vector<double>) Load3xVectorAndUnzip(Vector<double> mask, double* address);
++        public unsafe static (Vector<short>, Vector<short>, Vector<short>) Load3xVectorAndUnzip(Vector<short> mask, short* address);
++        public unsafe static (Vector<int>, Vector<int>, Vector<int>) Load3xVectorAndUnzip(Vector<int> mask, int* address);
++        public unsafe static (Vector<long>, Vector<long>, Vector<long>) Load3xVectorAndUnzip(Vector<long> mask, long* address);
++        public unsafe static (Vector<sbyte>, Vector<sbyte>, Vector<sbyte>) Load3xVectorAndUnzip(Vector<sbyte> mask, sbyte* address);
++        public unsafe static (Vector<float>, Vector<float>, Vector<float>) Load3xVectorAndUnzip(Vector<float> mask, float* address);
++        public unsafe static (Vector<ushort>, Vector<ushort>, Vector<ushort>) Load3xVectorAndUnzip(Vector<ushort> mask, ushort* address);
++        public unsafe static (Vector<uint>, Vector<uint>, Vector<uint>) Load3xVectorAndUnzip(Vector<uint> mask, uint* address);
++        public unsafe static (Vector<ulong>, Vector<ulong>, Vector<ulong>) Load3xVectorAndUnzip(Vector<ulong> mask, ulong* address);
++        public unsafe static (Vector<byte>, Vector<byte>, Vector<byte>, Vector<byte>) Load4xVectorAndUnzip(Vector<byte> mask, byte* address);
++        public unsafe static (Vector<double>, Vector<double>, Vector<double>, Vector<double>) Load4xVectorAndUnzip(Vector<double> mask, double* address);
++        public unsafe static (Vector<short>, Vector<short>, Vector<short>, Vector<short>) Load4xVectorAndUnzip(Vector<short> mask, short* address);
++        public unsafe static (Vector<int>, Vector<int>, Vector<int>, Vector<int>) Load4xVectorAndUnzip(Vector<int> mask, int* address);
++        public unsafe static (Vector<long>, Vector<long>, Vector<long>, Vector<long>) Load4xVectorAndUnzip(Vector<long> mask, long* address);
++        public unsafe static (Vector<sbyte>, Vector<sbyte>, Vector<sbyte>, Vector<sbyte>) Load4xVectorAndUnzip(Vector<sbyte> mask, sbyte* address);
++        public unsafe static (Vector<float>, Vector<float>, Vector<float>, Vector<float>) Load4xVectorAndUnzip(Vector<float> mask, float* address);
++        public unsafe static (Vector<ushort>, Vector<ushort>, Vector<ushort>, Vector<ushort>) Load4xVectorAndUnzip(Vector<ushort> mask, ushort* address);
++        public unsafe static (Vector<uint>, Vector<uint>, Vector<uint>, Vector<uint>) Load4xVectorAndUnzip(Vector<uint> mask, uint* address);
++        public unsafe static (Vector<ulong>, Vector<ulong>, Vector<ulong>, Vector<ulong>) Load4xVectorAndUnzip(Vector<ulong> mask, ulong* address);
++        public unsafe static Vector<byte> LoadVector128AndReplicateToVector(Vector<byte> mask, byte* address);
++        public unsafe static Vector<double> LoadVector128AndReplicateToVector(Vector<double> mask, double* address);
++        public unsafe static Vector<short> LoadVector128AndReplicateToVector(Vector<short> mask, short* address);
++        public unsafe static Vector<int> LoadVector128AndReplicateToVector(Vector<int> mask, int* address);
++        public unsafe static Vector<long> LoadVector128AndReplicateToVector(Vector<long> mask, long* address);
++        public unsafe static Vector<sbyte> LoadVector128AndReplicateToVector(Vector<sbyte> mask, sbyte* address);
++        public unsafe static Vector<float> LoadVector128AndReplicateToVector(Vector<float> mask, float* address);
++        public unsafe static Vector<ushort> LoadVector128AndReplicateToVector(Vector<ushort> mask, ushort* address);
++        public unsafe static Vector<uint> LoadVector128AndReplicateToVector(Vector<uint> mask, uint* address);
++        public unsafe static Vector<ulong> LoadVector128AndReplicateToVector(Vector<ulong> mask, ulong* address);
++        public unsafe static Vector<short> LoadVectorByteNonFaultingZeroExtendToInt16(byte* address);
++        public unsafe static Vector<int> LoadVectorByteNonFaultingZeroExtendToInt32(byte* address);
++        public unsafe static Vector<long> LoadVectorByteNonFaultingZeroExtendToInt64(byte* address);
++        public unsafe static Vector<ushort> LoadVectorByteNonFaultingZeroExtendToUInt16(byte* address);
++        public unsafe static Vector<uint> LoadVectorByteNonFaultingZeroExtendToUInt32(byte* address);
++        public unsafe static Vector<ulong> LoadVectorByteNonFaultingZeroExtendToUInt64(byte* address);
++        public unsafe static Vector<int> LoadVectorInt16NonFaultingSignExtendToInt32(short* address);
++        public unsafe static Vector<long> LoadVectorInt16NonFaultingSignExtendToInt64(short* address);
++        public unsafe static Vector<uint> LoadVectorInt16NonFaultingSignExtendToUInt32(short* address);
++        public unsafe static Vector<ulong> LoadVectorInt16NonFaultingSignExtendToUInt64(short* address);
++        public unsafe static Vector<long> LoadVectorInt32NonFaultingSignExtendToInt64(int* address);
++        public unsafe static Vector<ulong> LoadVectorInt32NonFaultingSignExtendToUInt64(int* address);
++        public unsafe static Vector<byte> LoadVectorNonFaulting(byte* address);
++        public unsafe static Vector<double> LoadVectorNonFaulting(double* address);
++        public unsafe static Vector<short> LoadVectorNonFaulting(short* address);
++        public unsafe static Vector<int> LoadVectorNonFaulting(int* address);
++        public unsafe static Vector<long> LoadVectorNonFaulting(long* address);
++        public unsafe static Vector<sbyte> LoadVectorNonFaulting(sbyte* address);
++        public unsafe static Vector<float> LoadVectorNonFaulting(float* address);
++        public unsafe static Vector<ushort> LoadVectorNonFaulting(ushort* address);
++        public unsafe static Vector<uint> LoadVectorNonFaulting(uint* address);
++        public unsafe static Vector<ulong> LoadVectorNonFaulting(ulong* address);
++        public unsafe static Vector<byte> LoadVectorNonTemporal(Vector<byte> mask, byte* address);
++        public unsafe static Vector<double> LoadVectorNonTemporal(Vector<double> mask, double* address);
++        public unsafe static Vector<short> LoadVectorNonTemporal(Vector<short> mask, short* address);
++        public unsafe static Vector<int> LoadVectorNonTemporal(Vector<int> mask, int* address);
++        public unsafe static Vector<long> LoadVectorNonTemporal(Vector<long> mask, long* address);
++        public unsafe static Vector<sbyte> LoadVectorNonTemporal(Vector<sbyte> mask, sbyte* address);
++        public unsafe static Vector<float> LoadVectorNonTemporal(Vector<float> mask, float* address);
++        public unsafe static Vector<ushort> LoadVectorNonTemporal(Vector<ushort> mask, ushort* address);
++        public unsafe static Vector<uint> LoadVectorNonTemporal(Vector<uint> mask, uint* address);
++        public unsafe static Vector<ulong> LoadVectorNonTemporal(Vector<ulong> mask, ulong* address);
++        public unsafe static Vector<short> LoadVectorSByteNonFaultingSignExtendToInt16(sbyte* address);
++        public unsafe static Vector<int> LoadVectorSByteNonFaultingSignExtendToInt32(sbyte* address);
++        public unsafe static Vector<long> LoadVectorSByteNonFaultingSignExtendToInt64(sbyte* address);
++        public unsafe static Vector<ushort> LoadVectorSByteNonFaultingSignExtendToUInt16(sbyte* address);
++        public unsafe static Vector<uint> LoadVectorSByteNonFaultingSignExtendToUInt32(sbyte* address);
++        public unsafe static Vector<ulong> LoadVectorSByteNonFaultingSignExtendToUInt64(sbyte* address);
++        public unsafe static Vector<int> LoadVectorUInt16NonFaultingZeroExtendToInt32(ushort* address);
++        public unsafe static Vector<long> LoadVectorUInt16NonFaultingZeroExtendToInt64(ushort* address);
++        public unsafe static Vector<uint> LoadVectorUInt16NonFaultingZeroExtendToUInt32(ushort* address);
++        public unsafe static Vector<ulong> LoadVectorUInt16NonFaultingZeroExtendToUInt64(ushort* address);
++        public unsafe static Vector<long> LoadVectorUInt32NonFaultingZeroExtendToInt64(uint* address);
++        public unsafe static Vector<ulong> LoadVectorUInt32NonFaultingZeroExtendToUInt64(uint* address);
++        public static Vector<byte> PopCount(Vector<byte> value);
++        public static Vector<ulong> PopCount(Vector<double> value);
++        public static Vector<ushort> PopCount(Vector<short> value);
++        public static Vector<uint> PopCount(Vector<int> value);
++        public static Vector<ulong> PopCount(Vector<long> value);
++        public static Vector<byte> PopCount(Vector<sbyte> value);
++        public static Vector<uint> PopCount(Vector<float> value);
++        public static Vector<ushort> PopCount(Vector<ushort> value);
++        public static Vector<uint> PopCount(Vector<uint> value);
++        public static Vector<ulong> PopCount(Vector<ulong> value);
++        public unsafe static void PrefetchBytes(Vector<byte> mask, void* address, SvePrefetchType prefetchType);
++        public unsafe static void PrefetchInt16(Vector<ushort> mask, void* address, SvePrefetchType prefetchType);
++        public unsafe static void PrefetchInt32(Vector<uint> mask, void* address, SvePrefetchType prefetchType);
++        public unsafe static void PrefetchInt64(Vector<ulong> mask, void* address, SvePrefetchType prefetchType);
++        public static Vector<byte> ReverseElement(Vector<byte> value);
++        public static Vector<double> ReverseElement(Vector<double> value);
++        public static Vector<short> ReverseElement(Vector<short> value);
++        public static Vector<int> ReverseElement(Vector<int> value);
++        public static Vector<long> ReverseElement(Vector<long> value);
++        public static Vector<sbyte> ReverseElement(Vector<sbyte> value);
++        public static Vector<float> ReverseElement(Vector<float> value);
++        public static Vector<ushort> ReverseElement(Vector<ushort> value);
++        public static Vector<uint> ReverseElement(Vector<uint> value);
++        public static Vector<ulong> ReverseElement(Vector<ulong> value);
++        public static Vector<int> ReverseElement16(Vector<int> value);
++        public static Vector<long> ReverseElement16(Vector<long> value);
++        public static Vector<uint> ReverseElement16(Vector<uint> value);
++        public static Vector<ulong> ReverseElement16(Vector<ulong> value);
++        public static Vector<long> ReverseElement32(Vector<long> value);
++        public static Vector<ulong> ReverseElement32(Vector<ulong> value);
++        public static Vector<short> ReverseElement8(Vector<short> value);
++        public static Vector<int> ReverseElement8(Vector<int> value);
++        public static Vector<long> ReverseElement8(Vector<long> value);
++        public static Vector<ushort> ReverseElement8(Vector<ushort> value);
++        public static Vector<uint> ReverseElement8(Vector<uint> value);
++        public static Vector<ulong> ReverseElement8(Vector<ulong> value);
++        public static Vector<double> RoundAwayFromZero(Vector<double> value);
++        public static Vector<float> RoundAwayFromZero(Vector<float> value);
++        public static Vector<double> RoundToNearest(Vector<double> value);
++        public static Vector<float> RoundToNearest(Vector<float> value);
++        public static Vector<double> RoundToNegativeInfinity(Vector<double> value);
++        public static Vector<float> RoundToNegativeInfinity(Vector<float> value);
++        public static Vector<double> RoundToPositiveInfinity(Vector<double> value);
++        public static Vector<float> RoundToPositiveInfinity(Vector<float> value);
++        public static Vector<double> RoundToZero(Vector<double> value);
++        public static Vector<float> RoundToZero(Vector<float> value);
++        public static int SaturatingDecrementBy16BitElementCount(int value, byte scale, SveMaskPattern pattern = SveMaskPattern.All);
++        public static long SaturatingDecrementBy16BitElementCount(long value, byte scale, SveMaskPattern pattern = SveMaskPattern.All);
++        public static Vector<short> SaturatingDecrementBy16BitElementCount(Vector<short> value, byte scale, SveMaskPattern pattern = SveMaskPattern.All);
++        public static Vector<ushort> SaturatingDecrementBy16BitElementCount(Vector<ushort> value, byte scale, SveMaskPattern pattern = SveMaskPattern.All);
++        public static uint SaturatingDecrementBy16BitElementCount(uint value, byte scale, SveMaskPattern pattern = SveMaskPattern.All);
++        public static ulong SaturatingDecrementBy16BitElementCount(ulong value, byte scale, SveMaskPattern pattern = SveMaskPattern.All);
++        public static int SaturatingDecrementBy32BitElementCount(int value, byte scale, SveMaskPattern pattern = SveMaskPattern.All);
++        public static long SaturatingDecrementBy32BitElementCount(long value, byte scale, SveMaskPattern pattern = SveMaskPattern.All);
++        public static Vector<int> SaturatingDecrementBy32BitElementCount(Vector<int> value, byte scale, SveMaskPattern pattern = SveMaskPattern.All);
++        public static Vector<uint> SaturatingDecrementBy32BitElementCount(Vector<uint> value, byte scale, SveMaskPattern pattern = SveMaskPattern.All);
++        public static uint SaturatingDecrementBy32BitElementCount(uint value, byte scale, SveMaskPattern pattern = SveMaskPattern.All);
++        public static ulong SaturatingDecrementBy32BitElementCount(ulong value, byte scale, SveMaskPattern pattern = SveMaskPattern.All);
++        public static int SaturatingDecrementBy64BitElementCount(int value, byte scale, SveMaskPattern pattern = SveMaskPattern.All);
++        public static long SaturatingDecrementBy64BitElementCount(long value, byte scale, SveMaskPattern pattern = SveMaskPattern.All);
++        public static Vector<long> SaturatingDecrementBy64BitElementCount(Vector<long> value, byte scale, SveMaskPattern pattern = SveMaskPattern.All);
++        public static Vector<ulong> SaturatingDecrementBy64BitElementCount(Vector<ulong> value, byte scale, SveMaskPattern pattern = SveMaskPattern.All);
++        public static uint SaturatingDecrementBy64BitElementCount(uint value, byte scale, SveMaskPattern pattern = SveMaskPattern.All);
++        public static ulong SaturatingDecrementBy64BitElementCount(ulong value, byte scale, SveMaskPattern pattern = SveMaskPattern.All);
++        public static int SaturatingDecrementBy8BitElementCount(int value, byte scale, SveMaskPattern pattern = SveMaskPattern.All);
++        public static long SaturatingDecrementBy8BitElementCount(long value, byte scale, SveMaskPattern pattern = SveMaskPattern.All);
++        public static uint SaturatingDecrementBy8BitElementCount(uint value, byte scale, SveMaskPattern pattern = SveMaskPattern.All);
++        public static ulong SaturatingDecrementBy8BitElementCount(ulong value, byte scale, SveMaskPattern pattern = SveMaskPattern.All);
++        public static long SaturatingDecrementByActiveElementCount(int value, Vector<byte> from);
++        public static long SaturatingDecrementByActiveElementCount(int value, Vector<ushort> from);
++        public static long SaturatingDecrementByActiveElementCount(int value, Vector<uint> from);
++        public static long SaturatingDecrementByActiveElementCount(int value, Vector<ulong> from);
++        public static long SaturatingDecrementByActiveElementCount(long value, Vector<byte> from);
++        public static long SaturatingDecrementByActiveElementCount(long value, Vector<ushort> from);
++        public static long SaturatingDecrementByActiveElementCount(long value, Vector<uint> from);
++        public static long SaturatingDecrementByActiveElementCount(long value, Vector<ulong> from);
++        public static Vector<short> SaturatingDecrementByActiveElementCount(Vector<short> value, Vector<short> from);
++        public static Vector<int> SaturatingDecrementByActiveElementCount(Vector<int> value, Vector<int> from);
++        public static Vector<long> SaturatingDecrementByActiveElementCount(Vector<long> value, Vector<long> from);
++        public static Vector<ushort> SaturatingDecrementByActiveElementCount(Vector<ushort> value, Vector<ushort> from);
++        public static Vector<uint> SaturatingDecrementByActiveElementCount(Vector<uint> value, Vector<uint> from);
++        public static Vector<ulong> SaturatingDecrementByActiveElementCount(Vector<ulong> value, Vector<ulong> from);
++        public static ulong SaturatingDecrementByActiveElementCount(uint value, Vector<byte> from);
++        public static ulong SaturatingDecrementByActiveElementCount(uint value, Vector<ushort> from);
++        public static ulong SaturatingDecrementByActiveElementCount(uint value, Vector<uint> from);
++        public static ulong SaturatingDecrementByActiveElementCount(uint value, Vector<ulong> from);
++        public static ulong SaturatingDecrementByActiveElementCount(ulong value, Vector<byte> from);
++        public static ulong SaturatingDecrementByActiveElementCount(ulong value, Vector<ushort> from);
++        public static ulong SaturatingDecrementByActiveElementCount(ulong value, Vector<uint> from);
++        public static ulong SaturatingDecrementByActiveElementCount(ulong value, Vector<ulong> from);
++        public static int SaturatingIncrementBy16BitElementCount(int value, byte scale, SveMaskPattern pattern = SveMaskPattern.All);
++        public static long SaturatingIncrementBy16BitElementCount(long value, byte scale, SveMaskPattern pattern = SveMaskPattern.All);
++        public static Vector<short> SaturatingIncrementBy16BitElementCount(Vector<short> value, byte scale, SveMaskPattern pattern = SveMaskPattern.All);
++        public static Vector<ushort> SaturatingIncrementBy16BitElementCount(Vector<ushort> value, byte scale, SveMaskPattern pattern = SveMaskPattern.All);
++        public static uint SaturatingIncrementBy16BitElementCount(uint value, byte scale, SveMaskPattern pattern = SveMaskPattern.All);
++        public static ulong SaturatingIncrementBy16BitElementCount(ulong value, byte scale, SveMaskPattern pattern = SveMaskPattern.All);
++        public static int SaturatingIncrementBy32BitElementCount(int value, byte scale, SveMaskPattern pattern = SveMaskPattern.All);
++        public static long SaturatingIncrementBy32BitElementCount(long value, byte scale, SveMaskPattern pattern = SveMaskPattern.All);
++        public static Vector<int> SaturatingIncrementBy32BitElementCount(Vector<int> value, byte scale, SveMaskPattern pattern = SveMaskPattern.All);
++        public static Vector<uint> SaturatingIncrementBy32BitElementCount(Vector<uint> value, byte scale, SveMaskPattern pattern = SveMaskPattern.All);
++        public static uint SaturatingIncrementBy32BitElementCount(uint value, byte scale, SveMaskPattern pattern = SveMaskPattern.All);
++        public static ulong SaturatingIncrementBy32BitElementCount(ulong value, byte scale, SveMaskPattern pattern = SveMaskPattern.All);
++        public static int SaturatingIncrementBy64BitElementCount(int value, byte scale, SveMaskPattern pattern = SveMaskPattern.All);
++        public static long SaturatingIncrementBy64BitElementCount(long value, byte scale, SveMaskPattern pattern = SveMaskPattern.All);
++        public static Vector<long> SaturatingIncrementBy64BitElementCount(Vector<long> value, byte scale, SveMaskPattern pattern = SveMaskPattern.All);
++        public static Vector<ulong> SaturatingIncrementBy64BitElementCount(Vector<ulong> value, byte scale, SveMaskPattern pattern = SveMaskPattern.All);
++        public static uint SaturatingIncrementBy64BitElementCount(uint value, byte scale, SveMaskPattern pattern = SveMaskPattern.All);
++        public static ulong SaturatingIncrementBy64BitElementCount(ulong value, byte scale, SveMaskPattern pattern = SveMaskPattern.All);
++        public static int SaturatingIncrementBy8BitElementCount(int value, byte scale, SveMaskPattern pattern = SveMaskPattern.All);
++        public static long SaturatingIncrementBy8BitElementCount(long value, byte scale, SveMaskPattern pattern = SveMaskPattern.All);
++        public static uint SaturatingIncrementBy8BitElementCount(uint value, byte scale, SveMaskPattern pattern = SveMaskPattern.All);
++        public static ulong SaturatingIncrementBy8BitElementCount(ulong value, byte scale, SveMaskPattern pattern = SveMaskPattern.All);
++        public static long SaturatingIncrementByActiveElementCount(int value, Vector<byte> from);
++        public static long SaturatingIncrementByActiveElementCount(int value, Vector<ushort> from);
++        public static long SaturatingIncrementByActiveElementCount(int value, Vector<uint> from);
++        public static long SaturatingIncrementByActiveElementCount(int value, Vector<ulong> from);
++        public static long SaturatingIncrementByActiveElementCount(long value, Vector<byte> from);
++        public static long SaturatingIncrementByActiveElementCount(long value, Vector<ushort> from);
++        public static long SaturatingIncrementByActiveElementCount(long value, Vector<uint> from);
++        public static long SaturatingIncrementByActiveElementCount(long value, Vector<ulong> from);
++        public static Vector<short> SaturatingIncrementByActiveElementCount(Vector<short> value, Vector<short> from);
++        public static Vector<int> SaturatingIncrementByActiveElementCount(Vector<int> value, Vector<int> from);
++        public static Vector<long> SaturatingIncrementByActiveElementCount(Vector<long> value, Vector<long> from);
++        public static Vector<ushort> SaturatingIncrementByActiveElementCount(Vector<ushort> value, Vector<ushort> from);
++        public static Vector<uint> SaturatingIncrementByActiveElementCount(Vector<uint> value, Vector<uint> from);
++        public static Vector<ulong> SaturatingIncrementByActiveElementCount(Vector<ulong> value, Vector<ulong> from);
++        public static ulong SaturatingIncrementByActiveElementCount(uint value, Vector<byte> from);
++        public static ulong SaturatingIncrementByActiveElementCount(uint value, Vector<ushort> from);
++        public static ulong SaturatingIncrementByActiveElementCount(uint value, Vector<uint> from);
++        public static ulong SaturatingIncrementByActiveElementCount(uint value, Vector<ulong> from);
++        public static ulong SaturatingIncrementByActiveElementCount(ulong value, Vector<byte> from);
++        public static ulong SaturatingIncrementByActiveElementCount(ulong value, Vector<ushort> from);
++        public static ulong SaturatingIncrementByActiveElementCount(ulong value, Vector<uint> from);
++        public static ulong SaturatingIncrementByActiveElementCount(ulong value, Vector<ulong> from);
++        public unsafe static void StoreNarrowing(Vector<short> mask, sbyte* address, Vector<short> data);
++        public unsafe static void StoreNarrowing(Vector<int> mask, short* address, Vector<int> data);
++        public unsafe static void StoreNarrowing(Vector<int> mask, sbyte* address, Vector<int> data);
++        public unsafe static void StoreNarrowing(Vector<long> mask, short* address, Vector<long> data);
++        public unsafe static void StoreNarrowing(Vector<long> mask, int* address, Vector<long> data);
++        public unsafe static void StoreNarrowing(Vector<long> mask, sbyte* address, Vector<long> data);
++        public unsafe static void StoreNarrowing(Vector<ushort> mask, byte* address, Vector<ushort> data);
++        public unsafe static void StoreNarrowing(Vector<uint> mask, byte* address, Vector<uint> data);
++        public unsafe static void StoreNarrowing(Vector<uint> mask, ushort* address, Vector<uint> data);
++        public unsafe static void StoreNarrowing(Vector<ulong> mask, byte* address, Vector<ulong> data);
++        public unsafe static void StoreNarrowing(Vector<ulong> mask, ushort* address, Vector<ulong> data);
++        public unsafe static void StoreNarrowing(Vector<ulong> mask, uint* address, Vector<ulong> data);
++        public unsafe static void StoreNonTemporal(Vector<byte> mask, byte* address, Vector<byte> data);
++        public unsafe static void StoreNonTemporal(Vector<double> mask, double* address, Vector<double> data);
++        public unsafe static void StoreNonTemporal(Vector<short> mask, short* address, Vector<short> data);
++        public unsafe static void StoreNonTemporal(Vector<int> mask, int* address, Vector<int> data);
++        public unsafe static void StoreNonTemporal(Vector<long> mask, long* address, Vector<long> data);
++        public unsafe static void StoreNonTemporal(Vector<sbyte> mask, sbyte* address, Vector<sbyte> data);
++        public unsafe static void StoreNonTemporal(Vector<float> mask, float* address, Vector<float> data);
++        public unsafe static void StoreNonTemporal(Vector<ushort> mask, ushort* address, Vector<ushort> data);
++        public unsafe static void StoreNonTemporal(Vector<uint> mask, uint* address, Vector<uint> data);
++        public unsafe static void StoreNonTemporal(Vector<ulong> mask, ulong* address, Vector<ulong> data);
++        public static Vector<byte> TransposeEven(Vector<byte> left, Vector<byte> right);
++        public static Vector<double> TransposeEven(Vector<double> left, Vector<double> right);
++        public static Vector<short> TransposeEven(Vector<short> left, Vector<short> right);
++        public static Vector<int> TransposeEven(Vector<int> left, Vector<int> right);
++        public static Vector<long> TransposeEven(Vector<long> left, Vector<long> right);
++        public static Vector<sbyte> TransposeEven(Vector<sbyte> left, Vector<sbyte> right);
++        public static Vector<float> TransposeEven(Vector<float> left, Vector<float> right);
++        public static Vector<ushort> TransposeEven(Vector<ushort> left, Vector<ushort> right);
++        public static Vector<uint> TransposeEven(Vector<uint> left, Vector<uint> right);
++        public static Vector<ulong> TransposeEven(Vector<ulong> left, Vector<ulong> right);
++        public static Vector<byte> TransposeOdd(Vector<byte> left, Vector<byte> right);
++        public static Vector<double> TransposeOdd(Vector<double> left, Vector<double> right);
++        public static Vector<short> TransposeOdd(Vector<short> left, Vector<short> right);
++        public static Vector<int> TransposeOdd(Vector<int> left, Vector<int> right);
++        public static Vector<long> TransposeOdd(Vector<long> left, Vector<long> right);
++        public static Vector<sbyte> TransposeOdd(Vector<sbyte> left, Vector<sbyte> right);
++        public static Vector<float> TransposeOdd(Vector<float> left, Vector<float> right);
++        public static Vector<ushort> TransposeOdd(Vector<ushort> left, Vector<ushort> right);
++        public static Vector<uint> TransposeOdd(Vector<uint> left, Vector<uint> right);
++        public static Vector<ulong> TransposeOdd(Vector<ulong> left, Vector<ulong> right);
+     }
++    public enum SvePrefetchType : byte {
++        LoadL1NonTemporal = (byte)1,
++        LoadL1Temporal = (byte)0,
++        LoadL2NonTemporal = (byte)3,
++        LoadL2Temporal = (byte)2,
++        LoadL3NonTemporal = (byte)5,
++        LoadL3Temporal = (byte)4,
++        StoreL1NonTemporal = (byte)9,
++        StoreL1Temporal = (byte)8,
++        StoreL2NonTemporal = (byte)11,
++        StoreL2Temporal = (byte)10,
++        StoreL3NonTemporal = (byte)13,
++        StoreL3Temporal = (byte)12,
++    }
+ }
+```
+
diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Runtime.Intrinsics.X86.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Runtime.Intrinsics.X86.md
new file mode 100644
index 0000000000..6b776e21b9
--- /dev/null
+++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Runtime.Intrinsics.X86.md
@@ -0,0 +1,545 @@
+# System.Runtime.Intrinsics.X86
+
+``` diff
+ namespace System.Runtime.Intrinsics.X86 {
++    public abstract class Avx10v1 : Avx2 {
++        public static new bool IsSupported { get; }
++        public static Vector128<ulong> Abs(Vector128<long> value);
++        public static Vector256<ulong> Abs(Vector256<long> value);
++        public static Vector128<double> AddScalar(Vector128<double> left, Vector128<double> right, FloatRoundingMode mode);
++        public static Vector128<float> AddScalar(Vector128<float> left, Vector128<float> right, FloatRoundingMode mode);
++        public static Vector128<int> AlignRight32(Vector128<int> left, Vector128<int> right, byte mask);
++        public static Vector128<uint> AlignRight32(Vector128<uint> left, Vector128<uint> right, byte mask);
++        public static Vector256<int> AlignRight32(Vector256<int> left, Vector256<int> right, byte mask);
++        public static Vector256<uint> AlignRight32(Vector256<uint> left, Vector256<uint> right, byte mask);
++        public static Vector128<long> AlignRight64(Vector128<long> left, Vector128<long> right, byte mask);
++        public static Vector128<ulong> AlignRight64(Vector128<ulong> left, Vector128<ulong> right, byte mask);
++        public static Vector256<long> AlignRight64(Vector256<long> left, Vector256<long> right, byte mask);
++        public static Vector256<ulong> AlignRight64(Vector256<ulong> left, Vector256<ulong> right, byte mask);
++        public static Vector128<int> BroadcastPairScalarToVector128(Vector128<int> value);
++        public static Vector128<uint> BroadcastPairScalarToVector128(Vector128<uint> value);
++        public static Vector256<int> BroadcastPairScalarToVector256(Vector128<int> value);
++        public static Vector256<float> BroadcastPairScalarToVector256(Vector128<float> value);
++        public static Vector256<uint> BroadcastPairScalarToVector256(Vector128<uint> value);
++        public static Vector128<byte> CompareGreaterThan(Vector128<byte> left, Vector128<byte> right);
++        public static Vector128<ushort> CompareGreaterThan(Vector128<ushort> left, Vector128<ushort> right);
++        public static Vector128<uint> CompareGreaterThan(Vector128<uint> left, Vector128<uint> right);
++        public static Vector128<ulong> CompareGreaterThan(Vector128<ulong> left, Vector128<ulong> right);
++        public static Vector256<byte> CompareGreaterThan(Vector256<byte> left, Vector256<byte> right);
++        public static Vector256<ushort> CompareGreaterThan(Vector256<ushort> left, Vector256<ushort> right);
++        public static Vector256<uint> CompareGreaterThan(Vector256<uint> left, Vector256<uint> right);
++        public static Vector256<ulong> CompareGreaterThan(Vector256<ulong> left, Vector256<ulong> right);
++        public static Vector128<byte> CompareGreaterThanOrEqual(Vector128<byte> left, Vector128<byte> right);
++        public static Vector128<short> CompareGreaterThanOrEqual(Vector128<short> left, Vector128<short> right);
++        public static Vector128<int> CompareGreaterThanOrEqual(Vector128<int> left, Vector128<int> right);
++        public static Vector128<long> CompareGreaterThanOrEqual(Vector128<long> left, Vector128<long> right);
++        public static Vector128<sbyte> CompareGreaterThanOrEqual(Vector128<sbyte> left, Vector128<sbyte> right);
++        public static Vector128<ushort> CompareGreaterThanOrEqual(Vector128<ushort> left, Vector128<ushort> right);
++        public static Vector128<uint> CompareGreaterThanOrEqual(Vector128<uint> left, Vector128<uint> right);
++        public static Vector128<ulong> CompareGreaterThanOrEqual(Vector128<ulong> left, Vector128<ulong> right);
++        public static Vector256<byte> CompareGreaterThanOrEqual(Vector256<byte> left, Vector256<byte> right);
++        public static Vector256<short> CompareGreaterThanOrEqual(Vector256<short> left, Vector256<short> right);
++        public static Vector256<int> CompareGreaterThanOrEqual(Vector256<int> left, Vector256<int> right);
++        public static Vector256<long> CompareGreaterThanOrEqual(Vector256<long> left, Vector256<long> right);
++        public static Vector256<sbyte> CompareGreaterThanOrEqual(Vector256<sbyte> left, Vector256<sbyte> right);
++        public static Vector256<ushort> CompareGreaterThanOrEqual(Vector256<ushort> left, Vector256<ushort> right);
++        public static Vector256<uint> CompareGreaterThanOrEqual(Vector256<uint> left, Vector256<uint> right);
++        public static Vector256<ulong> CompareGreaterThanOrEqual(Vector256<ulong> left, Vector256<ulong> right);
++        public static Vector128<byte> CompareLessThan(Vector128<byte> left, Vector128<byte> right);
++        public static new Vector128<short> CompareLessThan(Vector128<short> left, Vector128<short> right);
++        public static new Vector128<int> CompareLessThan(Vector128<int> left, Vector128<int> right);
++        public static Vector128<long> CompareLessThan(Vector128<long> left, Vector128<long> right);
++        public static new Vector128<sbyte> CompareLessThan(Vector128<sbyte> left, Vector128<sbyte> right);
++        public static Vector128<ushort> CompareLessThan(Vector128<ushort> left, Vector128<ushort> right);
++        public static Vector128<uint> CompareLessThan(Vector128<uint> left, Vector128<uint> right);
++        public static Vector128<ulong> CompareLessThan(Vector128<ulong> left, Vector128<ulong> right);
++        public static Vector256<byte> CompareLessThan(Vector256<byte> left, Vector256<byte> right);
++        public static Vector256<short> CompareLessThan(Vector256<short> left, Vector256<short> right);
++        public static Vector256<int> CompareLessThan(Vector256<int> left, Vector256<int> right);
++        public static Vector256<long> CompareLessThan(Vector256<long> left, Vector256<long> right);
++        public static Vector256<sbyte> CompareLessThan(Vector256<sbyte> left, Vector256<sbyte> right);
++        public static Vector256<ushort> CompareLessThan(Vector256<ushort> left, Vector256<ushort> right);
++        public static Vector256<uint> CompareLessThan(Vector256<uint> left, Vector256<uint> right);
++        public static Vector256<ulong> CompareLessThan(Vector256<ulong> left, Vector256<ulong> right);
++        public static Vector128<byte> CompareLessThanOrEqual(Vector128<byte> left, Vector128<byte> right);
++        public static Vector128<short> CompareLessThanOrEqual(Vector128<short> left, Vector128<short> right);
++        public static Vector128<int> CompareLessThanOrEqual(Vector128<int> left, Vector128<int> right);
++        public static Vector128<long> CompareLessThanOrEqual(Vector128<long> left, Vector128<long> right);
++        public static Vector128<sbyte> CompareLessThanOrEqual(Vector128<sbyte> left, Vector128<sbyte> right);
++        public static Vector128<ushort> CompareLessThanOrEqual(Vector128<ushort> left, Vector128<ushort> right);
++        public static Vector128<uint> CompareLessThanOrEqual(Vector128<uint> left, Vector128<uint> right);
++        public static Vector128<ulong> CompareLessThanOrEqual(Vector128<ulong> left, Vector128<ulong> right);
++        public static Vector256<byte> CompareLessThanOrEqual(Vector256<byte> left, Vector256<byte> right);
++        public static Vector256<short> CompareLessThanOrEqual(Vector256<short> left, Vector256<short> right);
++        public static Vector256<int> CompareLessThanOrEqual(Vector256<int> left, Vector256<int> right);
++        public static Vector256<long> CompareLessThanOrEqual(Vector256<long> left, Vector256<long> right);
++        public static Vector256<sbyte> CompareLessThanOrEqual(Vector256<sbyte> left, Vector256<sbyte> right);
++        public static Vector256<ushort> CompareLessThanOrEqual(Vector256<ushort> left, Vector256<ushort> right);
++        public static Vector256<uint> CompareLessThanOrEqual(Vector256<uint> left, Vector256<uint> right);
++        public static Vector256<ulong> CompareLessThanOrEqual(Vector256<ulong> left, Vector256<ulong> right);
++        public static Vector128<byte> CompareNotEqual(Vector128<byte> left, Vector128<byte> right);
++        public static Vector128<short> CompareNotEqual(Vector128<short> left, Vector128<short> right);
++        public static Vector128<int> CompareNotEqual(Vector128<int> left, Vector128<int> right);
++        public static Vector128<long> CompareNotEqual(Vector128<long> left, Vector128<long> right);
++        public static Vector128<sbyte> CompareNotEqual(Vector128<sbyte> left, Vector128<sbyte> right);
++        public static Vector128<ushort> CompareNotEqual(Vector128<ushort> left, Vector128<ushort> right);
++        public static Vector128<uint> CompareNotEqual(Vector128<uint> left, Vector128<uint> right);
++        public static Vector128<ulong> CompareNotEqual(Vector128<ulong> left, Vector128<ulong> right);
++        public static Vector256<byte> CompareNotEqual(Vector256<byte> left, Vector256<byte> right);
++        public static Vector256<short> CompareNotEqual(Vector256<short> left, Vector256<short> right);
++        public static Vector256<int> CompareNotEqual(Vector256<int> left, Vector256<int> right);
++        public static Vector256<long> CompareNotEqual(Vector256<long> left, Vector256<long> right);
++        public static Vector256<sbyte> CompareNotEqual(Vector256<sbyte> left, Vector256<sbyte> right);
++        public static Vector256<ushort> CompareNotEqual(Vector256<ushort> left, Vector256<ushort> right);
++        public static Vector256<uint> CompareNotEqual(Vector256<uint> left, Vector256<uint> right);
++        public static Vector256<ulong> CompareNotEqual(Vector256<ulong> left, Vector256<ulong> right);
++        public static Vector128<double> ConvertScalarToVector128Double(Vector128<double> upper, uint value);
++        public static Vector128<float> ConvertScalarToVector128Single(Vector128<float> upper, int value, FloatRoundingMode mode);
++        public static Vector128<float> ConvertScalarToVector128Single(Vector128<float> upper, Vector128<double> value, FloatRoundingMode mode);
++        public static Vector128<float> ConvertScalarToVector128Single(Vector128<float> upper, uint value);
++        public static Vector128<float> ConvertScalarToVector128Single(Vector128<float> upper, uint value, FloatRoundingMode mode);
++        public static int ConvertToInt32(Vector128<double> value, FloatRoundingMode mode);
++        public static int ConvertToInt32(Vector128<float> value, FloatRoundingMode mode);
++        public static uint ConvertToUInt32(Vector128<double> value);
++        public static uint ConvertToUInt32(Vector128<double> value, FloatRoundingMode mode);
++        public static uint ConvertToUInt32(Vector128<float> value);
++        public static uint ConvertToUInt32(Vector128<float> value, FloatRoundingMode mode);
++        public static uint ConvertToUInt32WithTruncation(Vector128<double> value);
++        public static uint ConvertToUInt32WithTruncation(Vector128<float> value);
++        public static Vector128<byte> ConvertToVector128Byte(Vector128<short> value);
++        public static Vector128<byte> ConvertToVector128Byte(Vector128<int> value);
++        public static Vector128<byte> ConvertToVector128Byte(Vector128<long> value);
++        public static Vector128<byte> ConvertToVector128Byte(Vector128<ushort> value);
++        public static Vector128<byte> ConvertToVector128Byte(Vector128<uint> value);
++        public static Vector128<byte> ConvertToVector128Byte(Vector128<ulong> value);
++        public static Vector128<byte> ConvertToVector128Byte(Vector256<short> value);
++        public static Vector128<byte> ConvertToVector128Byte(Vector256<int> value);
++        public static Vector128<byte> ConvertToVector128Byte(Vector256<long> value);
++        public static Vector128<byte> ConvertToVector128Byte(Vector256<ushort> value);
++        public static Vector128<byte> ConvertToVector128Byte(Vector256<uint> value);
++        public static Vector128<byte> ConvertToVector128Byte(Vector256<ulong> value);
++        public static Vector128<byte> ConvertToVector128ByteWithSaturation(Vector128<ushort> value);
++        public static Vector128<byte> ConvertToVector128ByteWithSaturation(Vector128<uint> value);
++        public static Vector128<byte> ConvertToVector128ByteWithSaturation(Vector128<ulong> value);
++        public static Vector128<byte> ConvertToVector128ByteWithSaturation(Vector256<ushort> value);
++        public static Vector128<byte> ConvertToVector128ByteWithSaturation(Vector256<uint> value);
++        public static Vector128<byte> ConvertToVector128ByteWithSaturation(Vector256<ulong> value);
++        public static Vector128<double> ConvertToVector128Double(Vector128<long> value);
++        public static Vector128<double> ConvertToVector128Double(Vector128<uint> value);
++        public static Vector128<double> ConvertToVector128Double(Vector128<ulong> value);
++        public static Vector128<short> ConvertToVector128Int16(Vector128<int> value);
++        public static Vector128<short> ConvertToVector128Int16(Vector128<long> value);
++        public static Vector128<short> ConvertToVector128Int16(Vector128<uint> value);
++        public static Vector128<short> ConvertToVector128Int16(Vector128<ulong> value);
++        public static Vector128<short> ConvertToVector128Int16(Vector256<int> value);
++        public static Vector128<short> ConvertToVector128Int16(Vector256<long> value);
++        public static Vector128<short> ConvertToVector128Int16(Vector256<uint> value);
++        public static Vector128<short> ConvertToVector128Int16(Vector256<ulong> value);
++        public static Vector128<short> ConvertToVector128Int16WithSaturation(Vector128<int> value);
++        public static Vector128<short> ConvertToVector128Int16WithSaturation(Vector128<long> value);
++        public static Vector128<short> ConvertToVector128Int16WithSaturation(Vector256<int> value);
++        public static Vector128<short> ConvertToVector128Int16WithSaturation(Vector256<long> value);
++        public static Vector128<int> ConvertToVector128Int32(Vector128<long> value);
++        public static Vector128<int> ConvertToVector128Int32(Vector128<ulong> value);
++        public static Vector128<int> ConvertToVector128Int32(Vector256<long> value);
++        public static Vector128<int> ConvertToVector128Int32(Vector256<ulong> value);
++        public static Vector128<int> ConvertToVector128Int32WithSaturation(Vector128<long> value);
++        public static Vector128<int> ConvertToVector128Int32WithSaturation(Vector256<long> value);
++        public static Vector128<long> ConvertToVector128Int64(Vector128<double> value);
++        public static Vector128<long> ConvertToVector128Int64(Vector128<float> value);
++        public static Vector128<long> ConvertToVector128Int64WithTruncation(Vector128<double> value);
++        public static Vector128<long> ConvertToVector128Int64WithTruncation(Vector128<float> value);
++        public static Vector128<sbyte> ConvertToVector128SByte(Vector128<short> value);
++        public static Vector128<sbyte> ConvertToVector128SByte(Vector128<int> value);
++        public static Vector128<sbyte> ConvertToVector128SByte(Vector128<long> value);
++        public static Vector128<sbyte> ConvertToVector128SByte(Vector128<ushort> value);
++        public static Vector128<sbyte> ConvertToVector128SByte(Vector128<uint> value);
++        public static Vector128<sbyte> ConvertToVector128SByte(Vector128<ulong> value);
++        public static Vector128<sbyte> ConvertToVector128SByte(Vector256<short> value);
++        public static Vector128<sbyte> ConvertToVector128SByte(Vector256<int> value);
++        public static Vector128<sbyte> ConvertToVector128SByte(Vector256<long> value);
++        public static Vector128<sbyte> ConvertToVector128SByte(Vector256<ushort> value);
++        public static Vector128<sbyte> ConvertToVector128SByte(Vector256<uint> value);
++        public static Vector128<sbyte> ConvertToVector128SByte(Vector256<ulong> value);
++        public static Vector128<sbyte> ConvertToVector128SByteWithSaturation(Vector128<short> value);
++        public static Vector128<sbyte> ConvertToVector128SByteWithSaturation(Vector128<int> value);
++        public static Vector128<sbyte> ConvertToVector128SByteWithSaturation(Vector128<long> value);
++        public static Vector128<sbyte> ConvertToVector128SByteWithSaturation(Vector256<short> value);
++        public static Vector128<sbyte> ConvertToVector128SByteWithSaturation(Vector256<int> value);
++        public static Vector128<sbyte> ConvertToVector128SByteWithSaturation(Vector256<long> value);
++        public static Vector128<float> ConvertToVector128Single(Vector128<long> value);
++        public static Vector128<float> ConvertToVector128Single(Vector128<uint> value);
++        public static Vector128<float> ConvertToVector128Single(Vector128<ulong> value);
++        public static Vector128<float> ConvertToVector128Single(Vector256<long> value);
++        public static Vector128<float> ConvertToVector128Single(Vector256<ulong> value);
++        public static Vector128<ushort> ConvertToVector128UInt16(Vector128<int> value);
++        public static Vector128<ushort> ConvertToVector128UInt16(Vector128<long> value);
++        public static Vector128<ushort> ConvertToVector128UInt16(Vector128<uint> value);
++        public static Vector128<ushort> ConvertToVector128UInt16(Vector128<ulong> value);
++        public static Vector128<ushort> ConvertToVector128UInt16(Vector256<int> value);
++        public static Vector128<ushort> ConvertToVector128UInt16(Vector256<long> value);
++        public static Vector128<ushort> ConvertToVector128UInt16(Vector256<uint> value);
++        public static Vector128<ushort> ConvertToVector128UInt16(Vector256<ulong> value);
++        public static Vector128<ushort> ConvertToVector128UInt16WithSaturation(Vector128<uint> value);
++        public static Vector128<ushort> ConvertToVector128UInt16WithSaturation(Vector128<ulong> value);
++        public static Vector128<ushort> ConvertToVector128UInt16WithSaturation(Vector256<uint> value);
++        public static Vector128<ushort> ConvertToVector128UInt16WithSaturation(Vector256<ulong> value);
++        public static Vector128<uint> ConvertToVector128UInt32(Vector128<double> value);
++        public static Vector128<uint> ConvertToVector128UInt32(Vector128<long> value);
++        public static Vector128<uint> ConvertToVector128UInt32(Vector128<float> value);
++        public static Vector128<uint> ConvertToVector128UInt32(Vector128<ulong> value);
++        public static Vector128<uint> ConvertToVector128UInt32(Vector256<double> value);
++        public static Vector128<uint> ConvertToVector128UInt32(Vector256<long> value);
++        public static Vector128<uint> ConvertToVector128UInt32(Vector256<ulong> value);
++        public static Vector128<uint> ConvertToVector128UInt32WithSaturation(Vector128<ulong> value);
++        public static Vector128<uint> ConvertToVector128UInt32WithSaturation(Vector256<ulong> value);
++        public static Vector128<uint> ConvertToVector128UInt32WithTruncation(Vector128<double> value);
++        public static Vector128<uint> ConvertToVector128UInt32WithTruncation(Vector128<float> value);
++        public static Vector128<uint> ConvertToVector128UInt32WithTruncation(Vector256<double> value);
++        public static Vector128<ulong> ConvertToVector128UInt64(Vector128<double> value);
++        public static Vector128<ulong> ConvertToVector128UInt64(Vector128<float> value);
++        public static Vector128<ulong> ConvertToVector128UInt64WithTruncation(Vector128<double> value);
++        public static Vector128<ulong> ConvertToVector128UInt64WithTruncation(Vector128<float> value);
++        public static Vector256<double> ConvertToVector256Double(Vector128<uint> value);
++        public static Vector256<double> ConvertToVector256Double(Vector256<long> value);
++        public static Vector256<double> ConvertToVector256Double(Vector256<ulong> value);
++        public static Vector256<long> ConvertToVector256Int64(Vector128<float> value);
++        public static Vector256<long> ConvertToVector256Int64(Vector256<double> value);
++        public static Vector256<long> ConvertToVector256Int64WithTruncation(Vector128<float> value);
++        public static Vector256<long> ConvertToVector256Int64WithTruncation(Vector256<double> value);
++        public static Vector256<float> ConvertToVector256Single(Vector256<uint> value);
++        public static Vector256<uint> ConvertToVector256UInt32(Vector256<float> value);
++        public static Vector256<uint> ConvertToVector256UInt32WithTruncation(Vector256<float> value);
++        public static Vector256<ulong> ConvertToVector256UInt64(Vector128<float> value);
++        public static Vector256<ulong> ConvertToVector256UInt64(Vector256<double> value);
++        public static Vector256<ulong> ConvertToVector256UInt64WithTruncation(Vector128<float> value);
++        public static Vector256<ulong> ConvertToVector256UInt64WithTruncation(Vector256<double> value);
++        public static Vector128<int> DetectConflicts(Vector128<int> value);
++        public static Vector128<long> DetectConflicts(Vector128<long> value);
++        public static Vector128<uint> DetectConflicts(Vector128<uint> value);
++        public static Vector128<ulong> DetectConflicts(Vector128<ulong> value);
++        public static Vector256<int> DetectConflicts(Vector256<int> value);
++        public static Vector256<long> DetectConflicts(Vector256<long> value);
++        public static Vector256<uint> DetectConflicts(Vector256<uint> value);
++        public static Vector256<ulong> DetectConflicts(Vector256<ulong> value);
++        public static Vector128<double> DivideScalar(Vector128<double> left, Vector128<double> right, FloatRoundingMode mode);
++        public static Vector128<float> DivideScalar(Vector128<float> left, Vector128<float> right, FloatRoundingMode mode);
++        public static Vector128<double> Fixup(Vector128<double> left, Vector128<double> right, Vector128<long> table, byte control);
++        public static Vector128<float> Fixup(Vector128<float> left, Vector128<float> right, Vector128<int> table, byte control);
++        public static Vector256<double> Fixup(Vector256<double> left, Vector256<double> right, Vector256<long> table, byte control);
++        public static Vector256<float> Fixup(Vector256<float> left, Vector256<float> right, Vector256<int> table, byte control);
++        public static Vector128<double> FixupScalar(Vector128<double> left, Vector128<double> right, Vector128<long> table, byte control);
++        public static Vector128<float> FixupScalar(Vector128<float> left, Vector128<float> right, Vector128<int> table, byte control);
++        public static Vector128<double> FusedMultiplyAddNegatedScalar(Vector128<double> a, Vector128<double> b, Vector128<double> c, FloatRoundingMode mode);
++        public static Vector128<float> FusedMultiplyAddNegatedScalar(Vector128<float> a, Vector128<float> b, Vector128<float> c, FloatRoundingMode mode);
++        public static Vector128<double> FusedMultiplyAddScalar(Vector128<double> a, Vector128<double> b, Vector128<double> c, FloatRoundingMode mode);
++        public static Vector128<float> FusedMultiplyAddScalar(Vector128<float> a, Vector128<float> b, Vector128<float> c, FloatRoundingMode mode);
++        public static Vector128<double> FusedMultiplySubtractNegatedScalar(Vector128<double> a, Vector128<double> b, Vector128<double> c, FloatRoundingMode mode);
++        public static Vector128<float> FusedMultiplySubtractNegatedScalar(Vector128<float> a, Vector128<float> b, Vector128<float> c, FloatRoundingMode mode);
++        public static Vector128<double> FusedMultiplySubtractScalar(Vector128<double> a, Vector128<double> b, Vector128<double> c, FloatRoundingMode mode);
++        public static Vector128<float> FusedMultiplySubtractScalar(Vector128<float> a, Vector128<float> b, Vector128<float> c, FloatRoundingMode mode);
++        public static Vector128<double> GetExponent(Vector128<double> value);
++        public static Vector128<float> GetExponent(Vector128<float> value);
++        public static Vector256<double> GetExponent(Vector256<double> value);
++        public static Vector256<float> GetExponent(Vector256<float> value);
++        public static Vector128<double> GetExponentScalar(Vector128<double> value);
++        public static Vector128<double> GetExponentScalar(Vector128<double> upper, Vector128<double> value);
++        public static Vector128<float> GetExponentScalar(Vector128<float> value);
++        public static Vector128<float> GetExponentScalar(Vector128<float> upper, Vector128<float> value);
++        public static Vector128<double> GetMantissa(Vector128<double> value, byte control);
++        public static Vector128<float> GetMantissa(Vector128<float> value, byte control);
++        public static Vector256<double> GetMantissa(Vector256<double> value, byte control);
++        public static Vector256<float> GetMantissa(Vector256<float> value, byte control);
++        public static Vector128<double> GetMantissaScalar(Vector128<double> value, byte control);
++        public static Vector128<double> GetMantissaScalar(Vector128<double> upper, Vector128<double> value, byte control);
++        public static Vector128<float> GetMantissaScalar(Vector128<float> value, byte control);
++        public static Vector128<float> GetMantissaScalar(Vector128<float> upper, Vector128<float> value, byte control);
++        public static Vector128<int> LeadingZeroCount(Vector128<int> value);
++        public static Vector128<long> LeadingZeroCount(Vector128<long> value);
++        public static Vector128<uint> LeadingZeroCount(Vector128<uint> value);
++        public static Vector128<ulong> LeadingZeroCount(Vector128<ulong> value);
++        public static Vector256<int> LeadingZeroCount(Vector256<int> value);
++        public static Vector256<long> LeadingZeroCount(Vector256<long> value);
++        public static Vector256<uint> LeadingZeroCount(Vector256<uint> value);
++        public static Vector256<ulong> LeadingZeroCount(Vector256<ulong> value);
++        public static Vector128<long> Max(Vector128<long> left, Vector128<long> right);
++        public static Vector128<ulong> Max(Vector128<ulong> left, Vector128<ulong> right);
++        public static Vector256<long> Max(Vector256<long> left, Vector256<long> right);
++        public static Vector256<ulong> Max(Vector256<ulong> left, Vector256<ulong> right);
++        public static Vector128<long> Min(Vector128<long> left, Vector128<long> right);
++        public static Vector128<ulong> Min(Vector128<ulong> left, Vector128<ulong> right);
++        public static Vector256<long> Min(Vector256<long> left, Vector256<long> right);
++        public static Vector256<ulong> Min(Vector256<ulong> left, Vector256<ulong> right);
++        public static Vector128<long> MultiplyLow(Vector128<long> left, Vector128<long> right);
++        public static Vector128<ulong> MultiplyLow(Vector128<ulong> left, Vector128<ulong> right);
++        public static Vector256<long> MultiplyLow(Vector256<long> left, Vector256<long> right);
++        public static Vector256<ulong> MultiplyLow(Vector256<ulong> left, Vector256<ulong> right);
++        public static Vector128<double> MultiplyScalar(Vector128<double> left, Vector128<double> right, FloatRoundingMode mode);
++        public static Vector128<float> MultiplyScalar(Vector128<float> left, Vector128<float> right, FloatRoundingMode mode);
++        public static Vector128<byte> MultiShift(Vector128<byte> control, Vector128<ulong> value);
++        public static Vector128<sbyte> MultiShift(Vector128<sbyte> control, Vector128<long> value);
++        public static Vector256<byte> MultiShift(Vector256<byte> control, Vector256<ulong> value);
++        public static Vector256<sbyte> MultiShift(Vector256<sbyte> control, Vector256<long> value);
++        public static Vector256<short> PermuteVar16x16(Vector256<short> left, Vector256<short> control);
++        public static Vector256<ushort> PermuteVar16x16(Vector256<ushort> left, Vector256<ushort> control);
++        public static Vector256<short> PermuteVar16x16x2(Vector256<short> lower, Vector256<short> indices, Vector256<short> upper);
++        public static Vector256<ushort> PermuteVar16x16x2(Vector256<ushort> lower, Vector256<ushort> indices, Vector256<ushort> upper);
++        public static Vector128<byte> PermuteVar16x8(Vector128<byte> left, Vector128<byte> control);
++        public static Vector128<sbyte> PermuteVar16x8(Vector128<sbyte> left, Vector128<sbyte> control);
++        public static Vector128<byte> PermuteVar16x8x2(Vector128<byte> lower, Vector128<byte> indices, Vector128<byte> upper);
++        public static Vector128<sbyte> PermuteVar16x8x2(Vector128<sbyte> lower, Vector128<sbyte> indices, Vector128<sbyte> upper);
++        public static Vector128<double> PermuteVar2x64x2(Vector128<double> lower, Vector128<long> indices, Vector128<double> upper);
++        public static Vector128<long> PermuteVar2x64x2(Vector128<long> lower, Vector128<long> indices, Vector128<long> upper);
++        public static Vector128<ulong> PermuteVar2x64x2(Vector128<ulong> lower, Vector128<ulong> indices, Vector128<ulong> upper);
++        public static Vector256<byte> PermuteVar32x8(Vector256<byte> left, Vector256<byte> control);
++        public static Vector256<sbyte> PermuteVar32x8(Vector256<sbyte> left, Vector256<sbyte> control);
++        public static Vector256<byte> PermuteVar32x8x2(Vector256<byte> lower, Vector256<byte> indices, Vector256<byte> upper);
++        public static Vector256<sbyte> PermuteVar32x8x2(Vector256<sbyte> lower, Vector256<sbyte> indices, Vector256<sbyte> upper);
++        public static Vector128<int> PermuteVar4x32x2(Vector128<int> lower, Vector128<int> indices, Vector128<int> upper);
++        public static Vector128<float> PermuteVar4x32x2(Vector128<float> lower, Vector128<int> indices, Vector128<float> upper);
++        public static Vector128<uint> PermuteVar4x32x2(Vector128<uint> lower, Vector128<uint> indices, Vector128<uint> upper);
++        public static Vector256<double> PermuteVar4x64(Vector256<double> value, Vector256<long> control);
++        public static Vector256<long> PermuteVar4x64(Vector256<long> value, Vector256<long> control);
++        public static Vector256<ulong> PermuteVar4x64(Vector256<ulong> value, Vector256<ulong> control);
++        public static Vector256<double> PermuteVar4x64x2(Vector256<double> lower, Vector256<long> indices, Vector256<double> upper);
++        public static Vector256<long> PermuteVar4x64x2(Vector256<long> lower, Vector256<long> indices, Vector256<long> upper);
++        public static Vector256<ulong> PermuteVar4x64x2(Vector256<ulong> lower, Vector256<ulong> indices, Vector256<ulong> upper);
++        public static Vector128<short> PermuteVar8x16(Vector128<short> left, Vector128<short> control);
++        public static Vector128<ushort> PermuteVar8x16(Vector128<ushort> left, Vector128<ushort> control);
++        public static Vector128<short> PermuteVar8x16x2(Vector128<short> lower, Vector128<short> indices, Vector128<short> upper);
++        public static Vector128<ushort> PermuteVar8x16x2(Vector128<ushort> lower, Vector128<ushort> indices, Vector128<ushort> upper);
++        public static Vector256<int> PermuteVar8x32x2(Vector256<int> lower, Vector256<int> indices, Vector256<int> upper);
++        public static Vector256<float> PermuteVar8x32x2(Vector256<float> lower, Vector256<int> indices, Vector256<float> upper);
++        public static Vector256<uint> PermuteVar8x32x2(Vector256<uint> lower, Vector256<uint> indices, Vector256<uint> upper);
++        public static Vector128<double> Range(Vector128<double> left, Vector128<double> right, byte control);
++        public static Vector128<float> Range(Vector128<float> left, Vector128<float> right, byte control);
++        public static Vector256<double> Range(Vector256<double> left, Vector256<double> right, byte control);
++        public static Vector256<float> Range(Vector256<float> left, Vector256<float> right, byte control);
++        public static Vector128<double> RangeScalar(Vector128<double> left, Vector128<double> right, byte control);
++        public static Vector128<float> RangeScalar(Vector128<float> left, Vector128<float> right, byte control);
++        public static Vector128<double> Reciprocal14(Vector128<double> value);
++        public static Vector128<float> Reciprocal14(Vector128<float> value);
++        public static Vector256<double> Reciprocal14(Vector256<double> value);
++        public static Vector256<float> Reciprocal14(Vector256<float> value);
++        public static Vector128<double> Reciprocal14Scalar(Vector128<double> value);
++        public static Vector128<double> Reciprocal14Scalar(Vector128<double> upper, Vector128<double> value);
++        public static Vector128<float> Reciprocal14Scalar(Vector128<float> value);
++        public static Vector128<float> Reciprocal14Scalar(Vector128<float> upper, Vector128<float> value);
++        public static Vector128<double> ReciprocalSqrt14(Vector128<double> value);
++        public static Vector128<float> ReciprocalSqrt14(Vector128<float> value);
++        public static Vector256<double> ReciprocalSqrt14(Vector256<double> value);
++        public static Vector256<float> ReciprocalSqrt14(Vector256<float> value);
++        public static Vector128<double> ReciprocalSqrt14Scalar(Vector128<double> value);
++        public static Vector128<double> ReciprocalSqrt14Scalar(Vector128<double> upper, Vector128<double> value);
++        public static Vector128<float> ReciprocalSqrt14Scalar(Vector128<float> value);
++        public static Vector128<float> ReciprocalSqrt14Scalar(Vector128<float> upper, Vector128<float> value);
++        public static Vector128<double> Reduce(Vector128<double> value, byte control);
++        public static Vector128<float> Reduce(Vector128<float> value, byte control);
++        public static Vector256<double> Reduce(Vector256<double> value, byte control);
++        public static Vector256<float> Reduce(Vector256<float> value, byte control);
++        public static Vector128<double> ReduceScalar(Vector128<double> value, byte control);
++        public static Vector128<double> ReduceScalar(Vector128<double> upper, Vector128<double> value, byte control);
++        public static Vector128<float> ReduceScalar(Vector128<float> value, byte control);
++        public static Vector128<float> ReduceScalar(Vector128<float> upper, Vector128<float> value, byte control);
++        public static Vector128<int> RotateLeft(Vector128<int> value, byte count);
++        public static Vector128<long> RotateLeft(Vector128<long> value, byte count);
++        public static Vector128<uint> RotateLeft(Vector128<uint> value, byte count);
++        public static Vector128<ulong> RotateLeft(Vector128<ulong> value, byte count);
++        public static Vector256<int> RotateLeft(Vector256<int> value, byte count);
++        public static Vector256<long> RotateLeft(Vector256<long> value, byte count);
++        public static Vector256<uint> RotateLeft(Vector256<uint> value, byte count);
++        public static Vector256<ulong> RotateLeft(Vector256<ulong> value, byte count);
++        public static Vector128<int> RotateLeftVariable(Vector128<int> value, Vector128<uint> count);
++        public static Vector128<long> RotateLeftVariable(Vector128<long> value, Vector128<ulong> count);
++        public static Vector128<uint> RotateLeftVariable(Vector128<uint> value, Vector128<uint> count);
++        public static Vector128<ulong> RotateLeftVariable(Vector128<ulong> value, Vector128<ulong> count);
++        public static Vector256<int> RotateLeftVariable(Vector256<int> value, Vector256<uint> count);
++        public static Vector256<long> RotateLeftVariable(Vector256<long> value, Vector256<ulong> count);
++        public static Vector256<uint> RotateLeftVariable(Vector256<uint> value, Vector256<uint> count);
++        public static Vector256<ulong> RotateLeftVariable(Vector256<ulong> value, Vector256<ulong> count);
++        public static Vector128<int> RotateRight(Vector128<int> value, byte count);
++        public static Vector128<long> RotateRight(Vector128<long> value, byte count);
++        public static Vector128<uint> RotateRight(Vector128<uint> value, byte count);
++        public static Vector128<ulong> RotateRight(Vector128<ulong> value, byte count);
++        public static Vector256<int> RotateRight(Vector256<int> value, byte count);
++        public static Vector256<long> RotateRight(Vector256<long> value, byte count);
++        public static Vector256<uint> RotateRight(Vector256<uint> value, byte count);
++        public static Vector256<ulong> RotateRight(Vector256<ulong> value, byte count);
++        public static Vector128<int> RotateRightVariable(Vector128<int> value, Vector128<uint> count);
++        public static Vector128<long> RotateRightVariable(Vector128<long> value, Vector128<ulong> count);
++        public static Vector128<uint> RotateRightVariable(Vector128<uint> value, Vector128<uint> count);
++        public static Vector128<ulong> RotateRightVariable(Vector128<ulong> value, Vector128<ulong> count);
++        public static Vector256<int> RotateRightVariable(Vector256<int> value, Vector256<uint> count);
++        public static Vector256<long> RotateRightVariable(Vector256<long> value, Vector256<ulong> count);
++        public static Vector256<uint> RotateRightVariable(Vector256<uint> value, Vector256<uint> count);
++        public static Vector256<ulong> RotateRightVariable(Vector256<ulong> value, Vector256<ulong> count);
++        public static Vector128<double> RoundScale(Vector128<double> value, byte control);
++        public static Vector128<float> RoundScale(Vector128<float> value, byte control);
++        public static Vector256<double> RoundScale(Vector256<double> value, byte control);
++        public static Vector256<float> RoundScale(Vector256<float> value, byte control);
++        public static Vector128<double> RoundScaleScalar(Vector128<double> value, byte control);
++        public static Vector128<double> RoundScaleScalar(Vector128<double> upper, Vector128<double> value, byte control);
++        public static Vector128<float> RoundScaleScalar(Vector128<float> value, byte control);
++        public static Vector128<float> RoundScaleScalar(Vector128<float> upper, Vector128<float> value, byte control);
++        public static Vector128<double> Scale(Vector128<double> left, Vector128<double> right);
++        public static Vector128<float> Scale(Vector128<float> left, Vector128<float> right);
++        public static Vector256<double> Scale(Vector256<double> left, Vector256<double> right);
++        public static Vector256<float> Scale(Vector256<float> left, Vector256<float> right);
++        public static Vector128<double> ScaleScalar(Vector128<double> left, Vector128<double> right);
++        public static Vector128<double> ScaleScalar(Vector128<double> left, Vector128<double> right, FloatRoundingMode mode);
++        public static Vector128<float> ScaleScalar(Vector128<float> left, Vector128<float> right);
++        public static Vector128<float> ScaleScalar(Vector128<float> left, Vector128<float> right, FloatRoundingMode mode);
++        public static Vector128<short> ShiftLeftLogicalVariable(Vector128<short> value, Vector128<ushort> count);
++        public static Vector128<ushort> ShiftLeftLogicalVariable(Vector128<ushort> value, Vector128<ushort> count);
++        public static Vector256<short> ShiftLeftLogicalVariable(Vector256<short> value, Vector256<ushort> count);
++        public static Vector256<ushort> ShiftLeftLogicalVariable(Vector256<ushort> value, Vector256<ushort> count);
++        public static Vector128<long> ShiftRightArithmetic(Vector128<long> value, byte count);
++        public static Vector128<long> ShiftRightArithmetic(Vector128<long> value, Vector128<long> count);
++        public static Vector256<long> ShiftRightArithmetic(Vector256<long> value, byte count);
++        public static Vector256<long> ShiftRightArithmetic(Vector256<long> value, Vector128<long> count);
++        public static Vector128<short> ShiftRightArithmeticVariable(Vector128<short> value, Vector128<ushort> count);
++        public static Vector128<long> ShiftRightArithmeticVariable(Vector128<long> value, Vector128<ulong> count);
++        public static Vector256<short> ShiftRightArithmeticVariable(Vector256<short> value, Vector256<ushort> count);
++        public static Vector256<long> ShiftRightArithmeticVariable(Vector256<long> value, Vector256<ulong> count);
++        public static Vector128<short> ShiftRightLogicalVariable(Vector128<short> value, Vector128<ushort> count);
++        public static Vector128<ushort> ShiftRightLogicalVariable(Vector128<ushort> value, Vector128<ushort> count);
++        public static Vector256<short> ShiftRightLogicalVariable(Vector256<short> value, Vector256<ushort> count);
++        public static Vector256<ushort> ShiftRightLogicalVariable(Vector256<ushort> value, Vector256<ushort> count);
++        public static Vector256<double> Shuffle2x128(Vector256<double> left, Vector256<double> right, byte control);
++        public static Vector256<int> Shuffle2x128(Vector256<int> left, Vector256<int> right, byte control);
++        public static Vector256<long> Shuffle2x128(Vector256<long> left, Vector256<long> right, byte control);
++        public static Vector256<float> Shuffle2x128(Vector256<float> left, Vector256<float> right, byte control);
++        public static Vector256<uint> Shuffle2x128(Vector256<uint> left, Vector256<uint> right, byte control);
++        public static Vector256<ulong> Shuffle2x128(Vector256<ulong> left, Vector256<ulong> right, byte control);
++        public static Vector128<double> SqrtScalar(Vector128<double> upper, Vector128<double> value, FloatRoundingMode mode);
++        public static Vector128<float> SqrtScalar(Vector128<float> upper, Vector128<float> value, FloatRoundingMode mode);
++        public static Vector128<double> SubtractScalar(Vector128<double> left, Vector128<double> right, FloatRoundingMode mode);
++        public static Vector128<float> SubtractScalar(Vector128<float> left, Vector128<float> right, FloatRoundingMode mode);
++        public static Vector128<ushort> SumAbsoluteDifferencesInBlock32(Vector128<byte> left, Vector128<byte> right, byte control);
++        public static Vector256<ushort> SumAbsoluteDifferencesInBlock32(Vector256<byte> left, Vector256<byte> right, byte control);
++        public static Vector128<byte> TernaryLogic(Vector128<byte> a, Vector128<byte> b, Vector128<byte> c, byte control);
++        public static Vector128<double> TernaryLogic(Vector128<double> a, Vector128<double> b, Vector128<double> c, byte control);
++        public static Vector128<short> TernaryLogic(Vector128<short> a, Vector128<short> b, Vector128<short> c, byte control);
++        public static Vector128<int> TernaryLogic(Vector128<int> a, Vector128<int> b, Vector128<int> c, byte control);
++        public static Vector128<long> TernaryLogic(Vector128<long> a, Vector128<long> b, Vector128<long> c, byte control);
++        public static Vector128<sbyte> TernaryLogic(Vector128<sbyte> a, Vector128<sbyte> b, Vector128<sbyte> c, byte control);
++        public static Vector128<float> TernaryLogic(Vector128<float> a, Vector128<float> b, Vector128<float> c, byte control);
++        public static Vector128<ushort> TernaryLogic(Vector128<ushort> a, Vector128<ushort> b, Vector128<ushort> c, byte control);
++        public static Vector128<uint> TernaryLogic(Vector128<uint> a, Vector128<uint> b, Vector128<uint> c, byte control);
++        public static Vector128<ulong> TernaryLogic(Vector128<ulong> a, Vector128<ulong> b, Vector128<ulong> c, byte control);
++        public static Vector256<byte> TernaryLogic(Vector256<byte> a, Vector256<byte> b, Vector256<byte> c, byte control);
++        public static Vector256<double> TernaryLogic(Vector256<double> a, Vector256<double> b, Vector256<double> c, byte control);
++        public static Vector256<short> TernaryLogic(Vector256<short> a, Vector256<short> b, Vector256<short> c, byte control);
++        public static Vector256<int> TernaryLogic(Vector256<int> a, Vector256<int> b, Vector256<int> c, byte control);
++        public static Vector256<long> TernaryLogic(Vector256<long> a, Vector256<long> b, Vector256<long> c, byte control);
++        public static Vector256<sbyte> TernaryLogic(Vector256<sbyte> a, Vector256<sbyte> b, Vector256<sbyte> c, byte control);
++        public static Vector256<float> TernaryLogic(Vector256<float> a, Vector256<float> b, Vector256<float> c, byte control);
++        public static Vector256<ushort> TernaryLogic(Vector256<ushort> a, Vector256<ushort> b, Vector256<ushort> c, byte control);
++        public static Vector256<uint> TernaryLogic(Vector256<uint> a, Vector256<uint> b, Vector256<uint> c, byte control);
++        public static Vector256<ulong> TernaryLogic(Vector256<ulong> a, Vector256<ulong> b, Vector256<ulong> c, byte control);
++        public abstract class V512 : Avx512BW {
++            public static new bool IsSupported { get; }
++            public static Vector512<double> And(Vector512<double> left, Vector512<double> right);
++            public static Vector512<float> And(Vector512<float> left, Vector512<float> right);
++            public static Vector512<double> AndNot(Vector512<double> left, Vector512<double> right);
++            public static Vector512<float> AndNot(Vector512<float> left, Vector512<float> right);
++            public static Vector512<int> BroadcastPairScalarToVector512(Vector128<int> value);
++            public static Vector512<float> BroadcastPairScalarToVector512(Vector128<float> value);
++            public static Vector512<uint> BroadcastPairScalarToVector512(Vector128<uint> value);
++            public unsafe static Vector512<double> BroadcastVector128ToVector512(double* address);
++            public unsafe static Vector512<long> BroadcastVector128ToVector512(long* address);
++            public unsafe static Vector512<ulong> BroadcastVector128ToVector512(ulong* address);
++            public unsafe static Vector512<int> BroadcastVector256ToVector512(int* address);
++            public unsafe static Vector512<float> BroadcastVector256ToVector512(float* address);
++            public unsafe static Vector512<uint> BroadcastVector256ToVector512(uint* address);
++            public static Vector256<float> ConvertToVector256Single(Vector512<long> value);
++            public static Vector256<float> ConvertToVector256Single(Vector512<long> value, FloatRoundingMode mode);
++            public static Vector256<float> ConvertToVector256Single(Vector512<ulong> value);
++            public static Vector256<float> ConvertToVector256Single(Vector512<ulong> value, FloatRoundingMode mode);
++            public static Vector512<double> ConvertToVector512Double(Vector512<long> value);
++            public static Vector512<double> ConvertToVector512Double(Vector512<long> value, FloatRoundingMode mode);
++            public static Vector512<double> ConvertToVector512Double(Vector512<ulong> value);
++            public static Vector512<double> ConvertToVector512Double(Vector512<ulong> value, FloatRoundingMode mode);
++            public static Vector512<long> ConvertToVector512Int64(Vector256<float> value);
++            public static Vector512<long> ConvertToVector512Int64(Vector256<float> value, FloatRoundingMode mode);
++            public static Vector512<long> ConvertToVector512Int64(Vector512<double> value);
++            public static Vector512<long> ConvertToVector512Int64(Vector512<double> value, FloatRoundingMode mode);
++            public static Vector512<long> ConvertToVector512Int64WithTruncation(Vector256<float> value);
++            public static Vector512<long> ConvertToVector512Int64WithTruncation(Vector512<double> value);
++            public static Vector512<ulong> ConvertToVector512UInt64(Vector256<float> value);
++            public static Vector512<ulong> ConvertToVector512UInt64(Vector256<float> value, FloatRoundingMode mode);
++            public static Vector512<ulong> ConvertToVector512UInt64(Vector512<double> value);
++            public static Vector512<ulong> ConvertToVector512UInt64(Vector512<double> value, FloatRoundingMode mode);
++            public static Vector512<ulong> ConvertToVector512UInt64WithTruncation(Vector256<float> value);
++            public static Vector512<ulong> ConvertToVector512UInt64WithTruncation(Vector512<double> value);
++            public static Vector512<int> DetectConflicts(Vector512<int> value);
++            public static Vector512<long> DetectConflicts(Vector512<long> value);
++            public static Vector512<uint> DetectConflicts(Vector512<uint> value);
++            public static Vector512<ulong> DetectConflicts(Vector512<ulong> value);
++            public static new Vector128<double> ExtractVector128(Vector512<double> value, byte index);
++            public static new Vector128<long> ExtractVector128(Vector512<long> value, byte index);
++            public static new Vector128<ulong> ExtractVector128(Vector512<ulong> value, byte index);
++            public static new Vector256<int> ExtractVector256(Vector512<int> value, byte index);
++            public static new Vector256<float> ExtractVector256(Vector512<float> value, byte index);
++            public static new Vector256<uint> ExtractVector256(Vector512<uint> value, byte index);
++            public static new Vector512<double> InsertVector128(Vector512<double> value, Vector128<double> data, byte index);
++            public static new Vector512<long> InsertVector128(Vector512<long> value, Vector128<long> data, byte index);
++            public static new Vector512<ulong> InsertVector128(Vector512<ulong> value, Vector128<ulong> data, byte index);
++            public static new Vector512<int> InsertVector256(Vector512<int> value, Vector256<int> data, byte index);
++            public static new Vector512<float> InsertVector256(Vector512<float> value, Vector256<float> data, byte index);
++            public static new Vector512<uint> InsertVector256(Vector512<uint> value, Vector256<uint> data, byte index);
++            public static Vector512<int> LeadingZeroCount(Vector512<int> value);
++            public static Vector512<long> LeadingZeroCount(Vector512<long> value);
++            public static Vector512<uint> LeadingZeroCount(Vector512<uint> value);
++            public static Vector512<ulong> LeadingZeroCount(Vector512<ulong> value);
++            public static Vector512<long> MultiplyLow(Vector512<long> left, Vector512<long> right);
++            public static Vector512<ulong> MultiplyLow(Vector512<ulong> left, Vector512<ulong> right);
++            public static Vector512<byte> MultiShift(Vector512<byte> control, Vector512<ulong> value);
++            public static Vector512<sbyte> MultiShift(Vector512<sbyte> control, Vector512<long> value);
++            public static Vector512<double> Or(Vector512<double> left, Vector512<double> right);
++            public static Vector512<float> Or(Vector512<float> left, Vector512<float> right);
++            public static Vector512<byte> PermuteVar64x8(Vector512<byte> left, Vector512<byte> control);
++            public static Vector512<sbyte> PermuteVar64x8(Vector512<sbyte> left, Vector512<sbyte> control);
++            public static Vector512<byte> PermuteVar64x8x2(Vector512<byte> lower, Vector512<byte> indices, Vector512<byte> upper);
++            public static Vector512<sbyte> PermuteVar64x8x2(Vector512<sbyte> lower, Vector512<sbyte> indices, Vector512<sbyte> upper);
++            public static Vector512<double> Range(Vector512<double> left, Vector512<double> right, byte control);
++            public static Vector512<float> Range(Vector512<float> left, Vector512<float> right, byte control);
++            public static Vector512<double> Reduce(Vector512<double> value, byte control);
++            public static Vector512<float> Reduce(Vector512<float> value, byte control);
++            public static Vector512<double> Xor(Vector512<double> left, Vector512<double> right);
++            public static Vector512<float> Xor(Vector512<float> left, Vector512<float> right);
++            public new abstract class X64 : Avx512BW.X64 {
++                public static new bool IsSupported { get; }
++            }
++        }
++        public new abstract class X64 : Avx2.X64 {
++            public static new bool IsSupported { get; }
++            public static Vector128<double> ConvertScalarToVector128Double(Vector128<double> upper, long value, FloatRoundingMode mode);
++            public static Vector128<double> ConvertScalarToVector128Double(Vector128<double> upper, ulong value);
++            public static Vector128<double> ConvertScalarToVector128Double(Vector128<double> upper, ulong value, FloatRoundingMode mode);
++            public static Vector128<float> ConvertScalarToVector128Single(Vector128<float> upper, long value, FloatRoundingMode mode);
++            public static Vector128<float> ConvertScalarToVector128Single(Vector128<float> upper, ulong value);
++            public static Vector128<float> ConvertScalarToVector128Single(Vector128<float> upper, ulong value, FloatRoundingMode mode);
++            public static long ConvertToInt64(Vector128<double> value, FloatRoundingMode mode);
++            public static long ConvertToInt64(Vector128<float> value, FloatRoundingMode mode);
++            public static ulong ConvertToUInt64(Vector128<double> value);
++            public static ulong ConvertToUInt64(Vector128<double> value, FloatRoundingMode mode);
++            public static ulong ConvertToUInt64(Vector128<float> value);
++            public static ulong ConvertToUInt64(Vector128<float> value, FloatRoundingMode mode);
++            public static ulong ConvertToUInt64WithTruncation(Vector128<double> value);
++            public static ulong ConvertToUInt64WithTruncation(Vector128<float> value);
++        }
++    }
+     public abstract class Avx512Vbmi : Avx512BW {
++        public static Vector512<byte> MultiShift(Vector512<byte> control, Vector512<ulong> value);
++        public static Vector512<sbyte> MultiShift(Vector512<sbyte> control, Vector512<long> value);
+         public new abstract class VL : Avx512BW.VL {
++            public static Vector128<byte> MultiShift(Vector128<byte> control, Vector128<ulong> value);
++            public static Vector128<sbyte> MultiShift(Vector128<sbyte> control, Vector128<long> value);
++            public static Vector256<byte> MultiShift(Vector256<byte> control, Vector256<ulong> value);
++            public static Vector256<sbyte> MultiShift(Vector256<sbyte> control, Vector256<long> value);
+         }
+     }
+ }
+```
+
diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Runtime.Intrinsics.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Runtime.Intrinsics.md
new file mode 100644
index 0000000000..087b6388bb
--- /dev/null
+++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Runtime.Intrinsics.md
@@ -0,0 +1,21 @@
+# System.Runtime.Intrinsics
+
+``` diff
+ namespace System.Runtime.Intrinsics {
+     public static class Vector128 {
++        public static Vector128<Single> AsVector128Unsafe(this Vector2 value);
++        public static Vector128<Single> AsVector128Unsafe(this Vector3 value);
++        public static Vector128<T> Create<T>(Vector64<T> value);
+     }
+     public static class Vector256 {
++        public static Vector256<T> Create<T>(Vector128<T> value);
++        public static Vector256<T> Create<T>(Vector64<T> value);
+     }
+     public static class Vector512 {
++        public static Vector512<T> Create<T>(Vector128<T> value);
++        public static Vector512<T> Create<T>(Vector256<T> value);
++        public static Vector512<T> Create<T>(Vector64<T> value);
+     }
+ }
+```
+
diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Security.Cryptography.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Security.Cryptography.md
new file mode 100644
index 0000000000..7bfa867f2d
--- /dev/null
+++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Security.Cryptography.md
@@ -0,0 +1,22 @@
+# System.Security.Cryptography
+
+``` diff
+ namespace System.Security.Cryptography {
+     public sealed class IncrementalHash : IDisposable {
++        public IncrementalHash Clone();
+     }
+     public sealed class Kmac128 : IDisposable {
++        public Kmac128 Clone();
+     }
+     public sealed class Kmac256 : IDisposable {
++        public Kmac256 Clone();
+     }
+     public sealed class KmacXof128 : IDisposable {
++        public KmacXof128 Clone();
+     }
+     public sealed class KmacXof256 : IDisposable {
++        public KmacXof256 Clone();
+     }
+ }
+```
+
diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Text.Json.Nodes.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Text.Json.Nodes.md
new file mode 100644
index 0000000000..c1d9bee1f4
--- /dev/null
+++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Text.Json.Nodes.md
@@ -0,0 +1,20 @@
+# System.Text.Json.Nodes
+
+``` diff
+ namespace System.Text.Json.Nodes {
+-    public sealed class JsonObject : JsonNode, ICollection<KeyValuePair<string, JsonNode?>>, IDictionary<string, JsonNode?>, IEnumerable, IEnumerable<KeyValuePair<string, JsonNode?>> {
++    public sealed class JsonObject : JsonNode, ICollection<KeyValuePair<string, JsonNode?>>, IDictionary<string, JsonNode?>, IEnumerable, IEnumerable<KeyValuePair<string, JsonNode?>>, IList<KeyValuePair<string, JsonNode?>> {
++        KeyValuePair<string, JsonNode?> IList<KeyValuePair<string, JsonNode?>>.this[int index] { get; set; }
++        public KeyValuePair<string, JsonNode?> GetAt(int index);
++        public int IndexOf(string propertyName);
++        public void Insert(int index, string propertyName, JsonNode? value);
++        public void RemoveAt(int index);
++        public void SetAt(int index, string propertyName, JsonNode? value);
++        public void SetAt(int index, JsonNode? value);
++        int IList<KeyValuePair<string, JsonNode?>>.IndexOf(KeyValuePair<string, JsonNode> item);
++        void IList<KeyValuePair<string, JsonNode?>>.Insert(int index, KeyValuePair<string, JsonNode> item);
++        void IList<KeyValuePair<string, JsonNode?>>.RemoveAt(int index);
+     }
+ }
+```
+
diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Text.Json.Schema.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Text.Json.Schema.md
new file mode 100644
index 0000000000..e12ec24342
--- /dev/null
+++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Text.Json.Schema.md
@@ -0,0 +1,22 @@
+# System.Text.Json.Schema
+
+``` diff
++namespace System.Text.Json.Schema {
++    public static class JsonSchemaExporter {
++        public static JsonNode GetJsonSchemaAsNode(this JsonSerializerOptions options, Type type, JsonSchemaExporterOptions? exporterOptions = null);
++        public static JsonNode GetJsonSchemaAsNode(this JsonTypeInfo typeInfo, JsonSchemaExporterOptions? exporterOptions = null);
++    }
++    public readonly struct JsonSchemaExporterContext {
++        public ReadOnlySpan<string> Path { get; }
++        public JsonPropertyInfo? PropertyInfo { get; }
++        public JsonTypeInfo TypeInfo { get; }
++    }
++    public sealed class JsonSchemaExporterOptions {
++        public JsonSchemaExporterOptions();
++        public static JsonSchemaExporterOptions Default { get; }
++        public Func<JsonSchemaExporterContext, JsonNode, JsonNode>? TransformSchemaNode { get; set; }
++        public bool TreatNullObliviousAsNonNullable { get; set; }
++    }
++}
+```
+
diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Text.Json.Serialization.Metadata.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Text.Json.Serialization.Metadata.md
new file mode 100644
index 0000000000..2875751aba
--- /dev/null
+++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Text.Json.Serialization.Metadata.md
@@ -0,0 +1,36 @@
+# System.Text.Json.Serialization.Metadata
+
+``` diff
+ namespace System.Text.Json.Serialization.Metadata {
+     public sealed class JsonObjectInfoValues<T> {
++        public Func<ICustomAttributeProvider>? ConstructorAttributeProviderFactory { get; set; }
+     }
++    public abstract class JsonParameterInfo {
++        public ICustomAttributeProvider? AttributeProvider { get; }
++        public Type DeclaringType { get; }
++        public object? DefaultValue { get; }
++        public bool HasDefaultValue { get; }
++        public bool IsMemberInitializer { get; }
++        public bool IsNullable { get; }
++        public string Name { get; }
++        public Type ParameterType { get; }
++        public int Position { get; }
++    }
+     public sealed class JsonParameterInfoValues {
++        public bool IsMemberInitializer { get; set; }
+     }
+     public abstract class JsonPropertyInfo {
++        public JsonParameterInfo? AssociatedParameter { get; }
++        public Type DeclaringType { get; }
+     }
+     public sealed class JsonPropertyInfoValues<T> {
++        public Func<ICustomAttributeProvider>? AttributeProviderFactory { get; set; }
+     }
+     public abstract class JsonTypeInfo {
++        public ICustomAttributeProvider ConstructorAttributeProvider { get; }
++        public Type ElementType { get; }
++        public Type KeyType { get; }
+     }
+ }
+```
+
diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Text.Json.Serialization.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Text.Json.Serialization.md
new file mode 100644
index 0000000000..285162e0c4
--- /dev/null
+++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Text.Json.Serialization.md
@@ -0,0 +1,10 @@
+# System.Text.Json.Serialization
+
+``` diff
+ namespace System.Text.Json.Serialization {
+     public sealed class JsonSourceGenerationOptionsAttribute : JsonAttribute {
++        public bool RespectRequiredConstructorParameters { get; set; }
+     }
+ }
+```
+
diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Text.Json.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Text.Json.md
new file mode 100644
index 0000000000..2312acf0a5
--- /dev/null
+++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Text.Json.md
@@ -0,0 +1,10 @@
+# System.Text.Json
+
+``` diff
+ namespace System.Text.Json {
+     public sealed class JsonSerializerOptions {
++        public bool RespectRequiredConstructorParameters { get; set; }
+     }
+ }
+```
+
diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Text.RegularExpressions.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Text.RegularExpressions.md
new file mode 100644
index 0000000000..743954200a
--- /dev/null
+++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.Text.RegularExpressions.md
@@ -0,0 +1,20 @@
+# System.Text.RegularExpressions
+
+``` diff
+ namespace System.Text.RegularExpressions {
+     public class Regex : ISerializable {
++        public Regex.ValueSplitEnumerator EnumerateSplits(ReadOnlySpan<char> input);
++        public Regex.ValueSplitEnumerator EnumerateSplits(ReadOnlySpan<char> input, int count);
++        public Regex.ValueSplitEnumerator EnumerateSplits(ReadOnlySpan<char> input, int count, int startat);
++        public static Regex.ValueSplitEnumerator EnumerateSplits(ReadOnlySpan<char> input, string pattern);
++        public static Regex.ValueSplitEnumerator EnumerateSplits(ReadOnlySpan<char> input, string pattern, RegexOptions options);
++        public static Regex.ValueSplitEnumerator EnumerateSplits(ReadOnlySpan<char> input, string pattern, RegexOptions options, TimeSpan matchTimeout);
++        public ref struct ValueSplitEnumerator {
++            public Range Current { get; }
++            public Regex.ValueSplitEnumerator GetEnumerator();
++            public bool MoveNext();
++        }
+     }
+ }
+```
+
diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.md
new file mode 100644
index 0000000000..f937acb14f
--- /dev/null
+++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.NETCore.App/9.0-preview6_System.md
@@ -0,0 +1,32 @@
+# System
+
+``` diff
+ namespace System {
+     public readonly struct Int32 : IAdditionOperators<int, int, int>, IAdditiveIdentity<int, int>, IBinaryInteger<int>, IBinaryNumber<int>, IBitwiseOperators<int, int, int>, IComparable, IComparable<int>, IComparisonOperators<int, int, bool>, IConvertible, IDecrementOperators<int>, IDivisionOperators<int, int, int>, IEqualityOperators<int, int, bool>, IEquatable<int>, IFormattable, IIncrementOperators<int>, IMinMaxValue<int>, IModulusOperators<int, int, int>, IMultiplicativeIdentity<int, int>, IMultiplyOperators<int, int, int>, INumber<int>, INumberBase<int>, IParsable<int>, IShiftOperators<int, int, int>, ISignedNumber<int>, ISpanFormattable, ISpanParsable<int>, ISubtractionOperators<int, int, int>, IUnaryNegationOperators<int, int>, IUnaryPlusOperators<int, int>, IUtf8SpanFormattable, IUtf8SpanParsable<int> {
++        public static long BigMul(Int32 left, Int32 right);
+     }
+     public readonly struct Int64 : IAdditionOperators<long, long, long>, IAdditiveIdentity<long, long>, IBinaryInteger<long>, IBinaryNumber<long>, IBitwiseOperators<long, long, long>, IComparable, IComparable<long>, IComparisonOperators<long, long, bool>, IConvertible, IDecrementOperators<long>, IDivisionOperators<long, long, long>, IEqualityOperators<long, long, bool>, IEquatable<long>, IFormattable, IIncrementOperators<long>, IMinMaxValue<long>, IModulusOperators<long, long, long>, IMultiplicativeIdentity<long, long>, IMultiplyOperators<long, long, long>, INumber<long>, INumberBase<long>, IParsable<long>, IShiftOperators<long, int, long>, ISignedNumber<long>, ISpanFormattable, ISpanParsable<long>, ISubtractionOperators<long, long, long>, IUnaryNegationOperators<long, long>, IUnaryPlusOperators<long, long>, IUtf8SpanFormattable, IUtf8SpanParsable<long> {
++        public static Int128 BigMul(Int64 left, Int64 right);
+     }
+     public static class Math {
++        public static Int128 BigMul(long a, long b);
++        public static ulong BigMul(uint a, uint b);
++        public static UInt128 BigMul(ulong a, ulong b);
+     }
+     public static class MemoryExtensions {
++        public static bool EndsWith<T>(this ReadOnlySpan<T> span, T value) where T : IEquatable<T>?;
++        public static bool StartsWith<T>(this ReadOnlySpan<T> span, T value) where T : IEquatable<T>?;
+     }
+     public readonly struct UInt32 : IAdditionOperators<uint, uint, uint>, IAdditiveIdentity<uint, uint>, IBinaryInteger<uint>, IBinaryNumber<uint>, IBitwiseOperators<uint, uint, uint>, IComparable, IComparable<uint>, IComparisonOperators<uint, uint, bool>, IConvertible, IDecrementOperators<uint>, IDivisionOperators<uint, uint, uint>, IEqualityOperators<uint, uint, bool>, IEquatable<uint>, IFormattable, IIncrementOperators<uint>, IMinMaxValue<uint>, IModulusOperators<uint, uint, uint>, IMultiplicativeIdentity<uint, uint>, IMultiplyOperators<uint, uint, uint>, INumber<uint>, INumberBase<uint>, IParsable<uint>, IShiftOperators<uint, int, uint>, ISpanFormattable, ISpanParsable<uint>, ISubtractionOperators<uint, uint, uint>, IUnaryNegationOperators<uint, uint>, IUnaryPlusOperators<uint, uint>, IUnsignedNumber<uint>, IUtf8SpanFormattable, IUtf8SpanParsable<uint> {
++        public static ulong BigMul(UInt32 left, UInt32 right);
+     }
+     public readonly struct UInt64 : IAdditionOperators<ulong, ulong, ulong>, IAdditiveIdentity<ulong, ulong>, IBinaryInteger<ulong>, IBinaryNumber<ulong>, IBitwiseOperators<ulong, ulong, ulong>, IComparable, IComparable<ulong>, IComparisonOperators<ulong, ulong, bool>, IConvertible, IDecrementOperators<ulong>, IDivisionOperators<ulong, ulong, ulong>, IEqualityOperators<ulong, ulong, bool>, IEquatable<ulong>, IFormattable, IIncrementOperators<ulong>, IMinMaxValue<ulong>, IModulusOperators<ulong, ulong, ulong>, IMultiplicativeIdentity<ulong, ulong>, IMultiplyOperators<ulong, ulong, ulong>, INumber<ulong>, INumberBase<ulong>, IParsable<ulong>, IShiftOperators<ulong, int, ulong>, ISpanFormattable, ISpanParsable<ulong>, ISubtractionOperators<ulong, ulong, ulong>, IUnaryNegationOperators<ulong, ulong>, IUnaryPlusOperators<ulong, ulong>, IUnsignedNumber<ulong>, IUtf8SpanFormattable, IUtf8SpanParsable<ulong> {
++        public static UInt128 BigMul(UInt64 left, UInt64 right);
+     }
+-    public class Uri : IFormattable, ISerializable, ISpanFormattable {
++    public class Uri : IEquatable<Uri>, IFormattable, ISerializable, ISpanFormattable {
++        public bool Equals(Uri? other);
+     }
+ }
+```
+
diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.WindowsDesktop.App/9.0-preview6.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.WindowsDesktop.App/9.0-preview6.md
new file mode 100644
index 0000000000..3102900b0b
--- /dev/null
+++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.WindowsDesktop.App/9.0-preview6.md
@@ -0,0 +1,10 @@
+# API Difference 9.0-preview5 vs 9.0-preview6
+
+API listing follows standard diff formatting.
+Lines preceded by a '+' are additions and a '-' indicates removal.
+
+* [System.Drawing](9.0-preview6_System.Drawing.md)
+* [System.Drawing.Drawing2D](9.0-preview6_System.Drawing.Drawing2D.md)
+* [System.Formats.Nrbf](9.0-preview6_System.Formats.Nrbf.md)
+* [System.Windows.Forms.Design](9.0-preview6_System.Windows.Forms.Design.md)
+
diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.WindowsDesktop.App/9.0-preview6_System.Drawing.Drawing2D.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.WindowsDesktop.App/9.0-preview6_System.Drawing.Drawing2D.md
new file mode 100644
index 0000000000..8fbdbc9be1
--- /dev/null
+++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.WindowsDesktop.App/9.0-preview6_System.Drawing.Drawing2D.md
@@ -0,0 +1,46 @@
+# System.Drawing.Drawing2D
+
+``` diff
+ namespace System.Drawing.Drawing2D {
+     public sealed class GraphicsPath : MarshalByRefObject, ICloneable, IDisposable {
+-        public void AddPolygon(PointF[] points);
++        public void AddPolygon(params PointF[] points);
+-        public void AddPolygon(Point[] points);
++        public void AddPolygon(params Point[] points);
+-        public void AddRectangles(Rectangle[] rects);
++        public void AddRectangles(params Rectangle[] rects);
+     }
+     public sealed class Matrix : MarshalByRefObject, IDisposable {
+-        public Matrix(Rectangle rect, Point[] plgpts);
++        public Matrix(Rectangle rect, params Point[] plgpts);
+-        public Matrix(RectangleF rect, PointF[] plgpts);
++        public Matrix(RectangleF rect, params PointF[] plgpts);
+-        public void TransformPoints(PointF[] pts);
++        public void TransformPoints(params PointF[] pts);
+-        public void TransformPoints(Point[] pts);
++        public void TransformPoints(params Point[] pts);
++        public void TransformPoints(ReadOnlySpan<Point> pts);
++        public void TransformPoints(ReadOnlySpan<PointF> pts);
+-        public void TransformVectors(PointF[] pts);
++        public void TransformVectors(params PointF[] pts);
+-        public void TransformVectors(Point[] pts);
++        public void TransformVectors(params Point[] pts);
++        public void TransformVectors(ReadOnlySpan<Point> pts);
++        public void TransformVectors(ReadOnlySpan<PointF> pts);
+-        public void VectorTransformPoints(Point[] pts);
++        public void VectorTransformPoints(params Point[] pts);
++        public void VectorTransformPoints(ReadOnlySpan<Point> pts);
+     }
+     public sealed class PathGradientBrush : Brush {
++        public PathGradientBrush(WrapMode wrapMode, ReadOnlySpan<Point> points);
++        public PathGradientBrush(WrapMode wrapMode, ReadOnlySpan<PointF> points);
+-        public PathGradientBrush(PointF[] points);
++        public PathGradientBrush(params PointF[] points);
+-        public PathGradientBrush(Point[] points);
++        public PathGradientBrush(params Point[] points);
++        public PathGradientBrush(ReadOnlySpan<Point> points);
++        public PathGradientBrush(ReadOnlySpan<PointF> points);
+     }
+ }
+```
+
diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.WindowsDesktop.App/9.0-preview6_System.Drawing.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.WindowsDesktop.App/9.0-preview6_System.Drawing.md
new file mode 100644
index 0000000000..109f484cac
--- /dev/null
+++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.WindowsDesktop.App/9.0-preview6_System.Drawing.md
@@ -0,0 +1,19 @@
+# System.Drawing
+
+``` diff
+ namespace System.Drawing {
+     public sealed class Graphics : MarshalByRefObject, IDeviceContext, IDisposable, IGraphics, IGraphicsContextInfo, IHdcContext, IPointer<GpGraphics> {
+-        public void DrawClosedCurve(Pen pen, Point[] points);
++        public void DrawClosedCurve(Pen pen, params Point[] points);
+-        public void DrawLines(Pen pen, PointF[] points);
++        public void DrawLines(Pen pen, params PointF[] points);
+-        public void TransformPoints(CoordinateSpace destSpace, CoordinateSpace srcSpace, PointF[] pts);
++        public void TransformPoints(CoordinateSpace destSpace, CoordinateSpace srcSpace, params PointF[] pts);
+-        public void TransformPoints(CoordinateSpace destSpace, CoordinateSpace srcSpace, Point[] pts);
++        public void TransformPoints(CoordinateSpace destSpace, CoordinateSpace srcSpace, params Point[] pts);
++        public void TransformPoints(CoordinateSpace destSpace, CoordinateSpace srcSpace, ReadOnlySpan<Point> pts);
++        public void TransformPoints(CoordinateSpace destSpace, CoordinateSpace srcSpace, ReadOnlySpan<PointF> pts);
+     }
+ }
+```
+
diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.WindowsDesktop.App/9.0-preview6_System.Formats.Nrbf.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.WindowsDesktop.App/9.0-preview6_System.Formats.Nrbf.md
new file mode 100644
index 0000000000..62e56357e2
--- /dev/null
+++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.WindowsDesktop.App/9.0-preview6_System.Formats.Nrbf.md
@@ -0,0 +1,96 @@
+# System.Formats.Nrbf
+
+``` diff
++namespace System.Formats.Nrbf {
++    public abstract class ArrayRecord : SerializationRecord {
++        public override SerializationRecordId Id { get; }
++        public abstract ReadOnlySpan<int> Lengths { get; }
++        public int Rank { get; }
++        public Array GetArray(Type expectedArrayType, bool allowNulls = true);
++    }
++    public abstract class ClassRecord : SerializationRecord {
++        public override SerializationRecordId Id { get; }
++        public IEnumerable<string> MemberNames { get; }
++        public override TypeName TypeName { get; }
++        public ArrayRecord? GetArrayRecord(string memberName);
++        public bool GetBoolean(string memberName);
++        public byte GetByte(string memberName);
++        public char GetChar(string memberName);
++        public ClassRecord? GetClassRecord(string memberName);
++        public DateTime GetDateTime(string memberName);
++        public decimal GetDecimal(string memberName);
++        public double GetDouble(string memberName);
++        public short GetInt16(string memberName);
++        public int GetInt32(string memberName);
++        public long GetInt64(string memberName);
++        public object? GetRawValue(string memberName);
++        public sbyte GetSByte(string memberName);
++        public SerializationRecord? GetSerializationRecord(string memberName);
++        public float GetSingle(string memberName);
++        public string? GetString(string memberName);
++        public TimeSpan GetTimeSpan(string memberName);
++        public ushort GetUInt16(string memberName);
++        public uint GetUInt32(string memberName);
++        public ulong GetUInt64(string memberName);
++        public bool HasMember(string memberName);
++    }
++    public static class NrbfDecoder {
++        public static SerializationRecord Decode(Stream payload, out IReadOnlyDictionary<SerializationRecordId, SerializationRecord> recordMap, PayloadOptions options = null, bool leaveOpen = false);
++        public static SerializationRecord Decode(Stream payload, PayloadOptions? options = null, bool leaveOpen = false);
++        public static ClassRecord DecodeClassRecord(Stream payload, PayloadOptions? options = null, bool leaveOpen = false);
++        public static bool StartsWithPayloadHeader(byte[] bytes);
++        public static bool StartsWithPayloadHeader(Stream stream);
++    }
++    public sealed class PayloadOptions {
++        public PayloadOptions();
++        public TypeNameParseOptions TypeNameParseOptions { get; set; }
++        public bool UndoTruncatedTypeNames { get; set; }
++    }
++    public abstract class PrimitiveTypeRecord : SerializationRecord {
++        public object Value { get; }
++    }
++    public abstract class PrimitiveTypeRecord<T> : PrimitiveTypeRecord {
++        public override TypeName TypeName { get; }
++        public new T Value { get; }
++    }
++    public abstract class SerializationRecord {
++        public abstract SerializationRecordId Id { get; }
++        public abstract SerializationRecordType RecordType { get; }
++        public abstract TypeName TypeName { get; }
++        public bool TypeNameMatches(Type type);
++    }
++    public struct SerializationRecordId : IEquatable<SerializationRecordId> {
++        public bool Equals(SerializationRecordId other);
++        public override bool Equals(object? obj);
++        public override int GetHashCode();
++    }
++    public enum SerializationRecordType {
++        ArraySingleObject = 16,
++        ArraySinglePrimitive = 15,
++        ArraySingleString = 17,
++        BinaryArray = 7,
++        BinaryLibrary = 12,
++        BinaryObjectString = 6,
++        ClassWithId = 1,
++        ClassWithMembers = 3,
++        ClassWithMembersAndTypes = 5,
++        MemberPrimitiveTyped = 8,
++        MemberReference = 9,
++        MessageEnd = 11,
++        MethodCall = 21,
++        MethodReturn = 22,
++        ObjectNull = 10,
++        ObjectNullMultiple = 14,
++        ObjectNullMultiple256 = 13,
++        SerializedStreamHeader = 0,
++        SystemClassWithMembers = 2,
++        SystemClassWithMembersAndTypes = 4,
++    }
++    public abstract class SZArrayRecord<T> : ArrayRecord {
++        public int Length { get; }
++        public override ReadOnlySpan<int> Lengths { get; }
++        public abstract T?[] GetArray(bool allowNulls = true);
++    }
++}
+```
+
diff --git a/release-notes/9.0/preview/preview6/api-diff/Microsoft.WindowsDesktop.App/9.0-preview6_System.Windows.Forms.Design.md b/release-notes/9.0/preview/preview6/api-diff/Microsoft.WindowsDesktop.App/9.0-preview6_System.Windows.Forms.Design.md
new file mode 100644
index 0000000000..db1400421f
--- /dev/null
+++ b/release-notes/9.0/preview/preview6/api-diff/Microsoft.WindowsDesktop.App/9.0-preview6_System.Windows.Forms.Design.md
@@ -0,0 +1,13 @@
+# System.Windows.Forms.Design
+
+``` diff
+ namespace System.Windows.Forms.Design {
+     public class ControlDesigner : ComponentDesigner {
+-        public override void InitializeExistingComponent(IDictionary defaultValues);
++        public override void InitializeExistingComponent(IDictionary? defaultValues);
+-        public override void InitializeNewComponent(IDictionary defaultValues);
++        public override void InitializeNewComponent(IDictionary? defaultValues);
+     }
+ }
+```
+
diff --git a/release-notes/9.0/preview/preview6/api-diff/README.md b/release-notes/9.0/preview/preview6/api-diff/README.md
new file mode 100644
index 0000000000..da11f72f6f
--- /dev/null
+++ b/release-notes/9.0/preview/preview6/api-diff/README.md
@@ -0,0 +1,7 @@
+# .NET 9.0 Preview 6 API Changes
+
+The following API changes were made in .NET 9.0 Preview 6:
+
+- [Microsoft.NETCore.App](./Microsoft.NETCore.App/9.0-preview6.md)
+- [Microsoft.AspNetCore.App](./Microsoft.AspNetCore.App/9.0-preview6.md)
+- [Microsoft.WindowsDesktop.App](./Microsoft.WindowsDesktop.App/9.0-preview6.md)