Merge branch 'main' into July22

55 files changed, 2825 insertions, 3 deletions

diff --git a/README.md b/README.md
index a200b2c5..a613a507 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 # .NET Release Notes
 
-The following [.NET releases](../releases.md) are currently supported:
+The following [.NET releases](releases.md) are currently supported:
 
 |  Version  | Release Date | Support | Latest Patch Version | End of Support |
 | :-- | :-- | :-- | :-- | :-- |
@@ -8,7 +8,8 @@ The following [.NET releases](../releases.md) are currently supported:
 | [.NET 6](6.0/README.md) | [November, 2021](https://devblogs.microsoft.com/dotnet/announcing-net-6/) | [LTS][policies] | [6.0.7][6.0.7]  | November 12, 2024 |
 | [.NET Core 3.1](3.1/README.md) | [December 3, 2019](https://devblogs.microsoft.com/dotnet/announcing-net-core-3-1/) | [LTS][policies] | [3.1.27][3.1.27] | December 13, 2022 |
 
-You can find release notes for all releases, including out-of-support releases, in the [release-notes](.) directory.
+
+You can find release notes for all releases, including out-of-support releases, in the [release-notes](release-notes) directory.
 
 [7.0 Preview 6]: release-notes/7.0/preview/7.0.0-preview.6.md
 [6.0.7]: release-notes/6.0/6.0.7/6.0.7.md
@@ -23,4 +24,4 @@ You can find release notes for all releases, including out-of-support releases,
 * [Installation docs](https://docs.microsoft.com/dotnet/core/install/)
 
 [releases-index.json]: https://dotnetcli.blob.core.windows.net/dotnet/release-metadata/releases-index.json
-[policies]: ../release-policies.md
+[policies]: release-policies.md
diff --git a/release-notes/6.0/known-issues.md b/release-notes/6.0/known-issues.md
index 0264f6a8..21301e18 100644
--- a/release-notes/6.0/known-issues.md
+++ b/release-notes/6.0/known-issues.md
@@ -59,6 +59,40 @@ The first time SPA apps are run, the authority for the spa proxy might be incorr
 
 When using localdb (default when creating projects in VS), the normal database apply migrations error page will not be displayed correctly due to the spa proxy. This will result in errors when going to the fetch data page. Apply the migrations via 'dotnet ef database update' to create the database.
 
+### SPA template issues with Individual authentication when running in production
+
+SPA apps on Azure App Service with all the following:
+* Individual authentication and requires login for every page.
+* A custom domain such as `https://MyDomain.com`:
+
+Sometimes return the following error `WWW-Authenticate: Bearer error="invalid_token", error_description="The issuer 'https://MyDomain.com' is invalid"`. If the app is accessed from the Azure DNS (MyDomain.azurewebsites.net), authentication is successful. Subsequent requests to `https://MyDomain.com` succeed.  Alternatively, stopping and starting the app, enables authentication to succeed. This error can occur with [`Always On`](/azure/app-service/configure-common) set to `true` or `false`.
+
+To prevent this problem without having to stop and restart the app:
+
+1. Add a new app setting which contains the target DNS address. For example, create `IdentityServer:IssuerUri` with value `https://MyDomain.com/`
+1. Add the following code to the app:
+```
+builder.Services.AddIdentityServer(options =>
+{
+    if (!string.IsNullOrEmpty(settings.IdentityServer.IssuerUri))
+    {
+        options.IssuerUri = settings.IdentityServer.IssuerUri;
+    }
+})
+```
+   Alternatively, add the following code:
+```
+builder.Services.AddDefaultIdentity<ApplicationUser>(options =>
+{
+    if (!string.IsNullOrEmpty(settings.IdentityServer.IssuerUri))
+    {
+        options.Tokens.AuthenticatorIssuer = settings.IdentityServer.IssuerUri;
+    }
+})
+```
+
+For more information, see [this GitHub issue](https://github.com/dotnet/aspnetcore/issues/42072)
+
 ## Windows Desktop (Windows Forms / WPF)
 
 ### Issues running applications with Windows Desktop 6.0.2
diff --git a/release-notes/7.0/known-issues.md b/release-notes/7.0/known-issues.md
index b38fd580..7a1c8fdf 100644
--- a/release-notes/7.0/known-issues.md
+++ b/release-notes/7.0/known-issues.md
@@ -54,6 +54,19 @@ More information and workaround can be found at https://github.com/dotnet/runtim
 
 ## .NET SDK
 
+### [Testhost.exe does not find '7.0.0-preview.6.22324.4' runtime when running tests](https://github.com/dotnet/sdk/issues/26462)
+A file-based install of the SDK, dotnet test on a .net 7 project will look in the global location rather than the local location and be unable to find .net 7.
+
+Workaround: Setting DOTNET_ROOT to point to the path to the local dotnet fixes the issue.
+
+### Blazor issues depending on whether you’re using .NET 6 installed by VS or stand-alone install of .NET 7
+
+If your app is targetting Blazor using the .net 7 included in VS, you can target net6.0 but not target net7.0 and you will see an error message 'The "ProcessFrameworkReferences" task faield unexpectedly.'
+
+Workaround:
+
+Install the stand-alone SDK for .NET 7.0 Preview 6
+
 ### MaxInteger[T]\(System.Collections.Generic.IEnumerable`1[T]\)' violates the constraint of type parameter 'T' exception
 
 We have discovered that AutoMapper library is impacted by a change in .NET 7 Preview 5 and this is tracked by [dotnet-sdk-7.0.100-preview.5.22257.3] MaxInteger[T]\(System.Collections.Generic.IEnumerable`1[T]\)' violates the constraint of type parameter 'T' exception · Issue #3988 · AutoMapper/AutoMapper (github.com). .NET team has submitted a PR to fix the bug in AutoMapper code and is working with AutoMapper library owners to determine options.
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5.md
new file mode 100644
index 00000000..015e5407
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5.md
@@ -0,0 +1,22 @@
+# API Difference 7.0-preview4 vs 7.0-preview5
+
+API listing follows standard diff formatting.
+Lines preceded by a '+' are additions and a '-' indicates removal.
+
+* [Microsoft.AspNetCore.Authentication](7.0-preview5_Microsoft.AspNetCore.Authentication.md)
+* [Microsoft.AspNetCore.Authorization.Infrastructure](7.0-preview5_Microsoft.AspNetCore.Authorization.Infrastructure.md)
+* [Microsoft.AspNetCore.Builder](7.0-preview5_Microsoft.AspNetCore.Builder.md)
+* [Microsoft.AspNetCore.DataProtection](7.0-preview5_Microsoft.AspNetCore.DataProtection.md)
+* [Microsoft.AspNetCore.DataProtection.AuthenticatedEncryption.ConfigurationModel](7.0-preview5_Microsoft.AspNetCore.DataProtection.AuthenticatedEncryption.ConfigurationModel.md)
+* [Microsoft.AspNetCore.DataProtection.Internal](7.0-preview5_Microsoft.AspNetCore.DataProtection.Internal.md)
+* [Microsoft.AspNetCore.DataProtection.KeyManagement](7.0-preview5_Microsoft.AspNetCore.DataProtection.KeyManagement.md)
+* [Microsoft.AspNetCore.DataProtection.KeyManagement.Internal](7.0-preview5_Microsoft.AspNetCore.DataProtection.KeyManagement.Internal.md)
+* [Microsoft.AspNetCore.Http](7.0-preview5_Microsoft.AspNetCore.Http.md)
+* [Microsoft.AspNetCore.Http.HttpResults](7.0-preview5_Microsoft.AspNetCore.Http.HttpResults.md)
+* [Microsoft.AspNetCore.Mvc](7.0-preview5_Microsoft.AspNetCore.Mvc.md)
+* [Microsoft.AspNetCore.ResponseCompression](7.0-preview5_Microsoft.AspNetCore.ResponseCompression.md)
+* [Microsoft.AspNetCore.SignalR](7.0-preview5_Microsoft.AspNetCore.SignalR.md)
+* [Microsoft.AspNetCore.WebUtilities](7.0-preview5_Microsoft.AspNetCore.WebUtilities.md)
+* [Microsoft.Extensions.Logging](7.0-preview5_Microsoft.Extensions.Logging.md)
+* [Microsoft.JSInterop.Infrastructure](7.0-preview5_Microsoft.JSInterop.Infrastructure.md)
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Authentication.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Authentication.md
new file mode 100644
index 00000000..bf591034
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Authentication.md
@@ -0,0 +1,10 @@
+# Microsoft.AspNetCore.Authentication
+
+``` diff
+ namespace Microsoft.AspNetCore.Authentication {
++    public interface IAuthenticationConfigurationProvider {
++        IConfiguration GetAuthenticationSchemeConfiguration(string authenticationScheme);
++    }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Authorization.Infrastructure.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Authorization.Infrastructure.md
new file mode 100644
index 00000000..1629ecc0
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Authorization.Infrastructure.md
@@ -0,0 +1,11 @@
+# Microsoft.AspNetCore.Authorization.Infrastructure
+
+``` diff
+ namespace Microsoft.AspNetCore.Authorization.Infrastructure {
+     public class PassThroughAuthorizationHandler : IAuthorizationHandler {
++        public PassThroughAuthorizationHandler(IOptions<AuthorizationOptions> options);
+         public Task HandleAsync(AuthorizationHandlerContext context);
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Builder.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Builder.md
new file mode 100644
index 00000000..686039f8
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Builder.md
@@ -0,0 +1,10 @@
+# Microsoft.AspNetCore.Builder
+
+``` diff
+ namespace Microsoft.AspNetCore.Builder {
+     public sealed class WebApplicationBuilder {
++        public AuthenticationBuilder Authentication { get; }
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.DataProtection.AuthenticatedEncryption.ConfigurationModel.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.DataProtection.AuthenticatedEncryption.ConfigurationModel.md
new file mode 100644
index 00000000..2a2ddb5d
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.DataProtection.AuthenticatedEncryption.ConfigurationModel.md
@@ -0,0 +1,27 @@
+# Microsoft.AspNetCore.DataProtection.AuthenticatedEncryption.ConfigurationModel
+
+``` diff
+ namespace Microsoft.AspNetCore.DataProtection.AuthenticatedEncryption.ConfigurationModel {
+-    [RequiresUnreferencedCode(TrimmerWarning.Message)]
+     public sealed class AuthenticatedEncryptorDescriptorDeserializer : IAuthenticatedEncryptorDescriptorDeserializer {
+         public IAuthenticatedEncryptorDescriptor ImportFromXml(XElement element);
+     }
+     public sealed class CngCbcAuthenticatedEncryptorDescriptorDeserializer : IAuthenticatedEncryptorDescriptorDeserializer {
+-        [RequiresUnreferencedCode(TrimmerWarning.Message)]
+         public IAuthenticatedEncryptorDescriptor ImportFromXml(XElement element);
+     }
+     public sealed class CngGcmAuthenticatedEncryptorDescriptorDeserializer : IAuthenticatedEncryptorDescriptorDeserializer {
+-        [RequiresUnreferencedCode(TrimmerWarning.Message)]
+         public IAuthenticatedEncryptorDescriptor ImportFromXml(XElement element);
+     }
+     public interface IAuthenticatedEncryptorDescriptorDeserializer {
+-        [RequiresUnreferencedCode(TrimmerWarning.Message)]
+         IAuthenticatedEncryptorDescriptor ImportFromXml(XElement element);
+     }
+     public sealed class ManagedAuthenticatedEncryptorDescriptorDeserializer : IAuthenticatedEncryptorDescriptorDeserializer {
+-        [RequiresUnreferencedCode(TrimmerWarning.Message)]
+         public IAuthenticatedEncryptorDescriptor ImportFromXml(XElement element);
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.DataProtection.Internal.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.DataProtection.Internal.md
new file mode 100644
index 00000000..75be7596
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.DataProtection.Internal.md
@@ -0,0 +1,12 @@
+# Microsoft.AspNetCore.DataProtection.Internal
+
+``` diff
+ namespace Microsoft.AspNetCore.DataProtection.Internal {
+     public interface IActivator {
+-        [RequiresUnreferencedCode(TrimmerWarning.Message)]
+-        object CreateInstance(Type expectedBaseType, string implementationTypeName);
++        object CreateInstance([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] Type expectedBaseType, string implementationTypeName);
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.DataProtection.KeyManagement.Internal.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.DataProtection.KeyManagement.Internal.md
new file mode 100644
index 00000000..21d38681
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.DataProtection.KeyManagement.Internal.md
@@ -0,0 +1,19 @@
+# Microsoft.AspNetCore.DataProtection.KeyManagement.Internal
+
+``` diff
+ namespace Microsoft.AspNetCore.DataProtection.KeyManagement.Internal {
+     public interface ICacheableKeyRingProvider {
+-        [RequiresUnreferencedCode(TrimmerWarning.Message)]
+         CacheableKeyRing GetCacheableKeyRing(DateTimeOffset now);
+     }
+     public interface IInternalXmlKeyManager {
+-        [RequiresUnreferencedCode(TrimmerWarning.Message)]
+         IAuthenticatedEncryptorDescriptor DeserializeDescriptorFromKeyElement(XElement keyElement);
+     }
+     public interface IKeyRingProvider {
+-        [RequiresUnreferencedCode(TrimmerWarning.Message)]
+         IKeyRing GetCurrentKeyRing();
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.DataProtection.KeyManagement.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.DataProtection.KeyManagement.md
new file mode 100644
index 00000000..6d7a711b
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.DataProtection.KeyManagement.md
@@ -0,0 +1,17 @@
+# Microsoft.AspNetCore.DataProtection.KeyManagement
+
+``` diff
+ namespace Microsoft.AspNetCore.DataProtection.KeyManagement {
+     public interface IKeyManager {
+-        [RequiresUnreferencedCode(TrimmerWarning.Message)]
+         IReadOnlyCollection<IKey> GetAllKeys();
+     }
+     public sealed class XmlKeyManager : IInternalXmlKeyManager, IKeyManager {
+-        [RequiresUnreferencedCode(TrimmerWarning.Message)]
+         public IReadOnlyCollection<IKey> GetAllKeys();
+-        [RequiresUnreferencedCode(TrimmerWarning.Message)]
+         IAuthenticatedEncryptorDescriptor IInternalXmlKeyManager.DeserializeDescriptorFromKeyElement(XElement keyElement);
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.DataProtection.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.DataProtection.md
new file mode 100644
index 00000000..203479c2
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.DataProtection.md
@@ -0,0 +1,39 @@
+# Microsoft.AspNetCore.DataProtection
+
+``` diff
+ namespace Microsoft.AspNetCore.DataProtection {
+     public static class DataProtectionAdvancedExtensions {
+-        [RequiresUnreferencedCode(TrimmerWarning.Message)]
+         public static byte[] Protect(this ITimeLimitedDataProtector protector, byte[] plaintext, TimeSpan lifetime);
+-        [RequiresUnreferencedCode(TrimmerWarning.Message)]
+         public static string Protect(this ITimeLimitedDataProtector protector, string plaintext, DateTimeOffset expiration);
+-        [RequiresUnreferencedCode(TrimmerWarning.Message)]
+         public static string Protect(this ITimeLimitedDataProtector protector, string plaintext, TimeSpan lifetime);
+-        [RequiresUnreferencedCode(TrimmerWarning.Message)]
+         public static string Unprotect(this ITimeLimitedDataProtector protector, string protectedData, out DateTimeOffset expiration);
+     }
+     public static class DataProtectionCommonExtensions {
+-        [RequiresUnreferencedCode(TrimmerWarning.Message)]
+         public static string Protect(this IDataProtector protector, string plaintext);
+-        [RequiresUnreferencedCode(TrimmerWarning.Message)]
+         public static string Unprotect(this IDataProtector protector, string protectedData);
+     }
+     public interface IDataProtector : IDataProtectionProvider {
+-        [RequiresUnreferencedCode(TrimmerWarning.Message)]
+         byte[] Protect(byte[] plaintext);
+-        [RequiresUnreferencedCode(TrimmerWarning.Message)]
+         byte[] Unprotect(byte[] protectedData);
+     }
+     public interface IPersistedDataProtector : IDataProtectionProvider, IDataProtector {
+-        [RequiresUnreferencedCode(TrimmerWarning.Message)]
+         byte[] DangerousUnprotect(byte[] protectedData, bool ignoreRevocationErrors, out bool requiresMigration, out bool wasRevoked);
+     }
+     public interface ITimeLimitedDataProtector : IDataProtectionProvider, IDataProtector {
+-        [RequiresUnreferencedCode(TrimmerWarning.Message)]
+         byte[] Protect(byte[] plaintext, DateTimeOffset expiration);
+-        [RequiresUnreferencedCode(TrimmerWarning.Message)]
+         byte[] Unprotect(byte[] protectedData, out DateTimeOffset expiration);
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Http.HttpResults.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Http.HttpResults.md
new file mode 100644
index 00000000..4dc03c2f
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Http.HttpResults.md
@@ -0,0 +1,17 @@
+# Microsoft.AspNetCore.Http.HttpResults
+
+``` diff
+- namespace Microsoft.AspNetCore.Http {
++ namespace Microsoft.AspNetCore.Http.HttpResults {
+     public sealed class ChallengeHttpResult : IResult {
+         public Task ExecuteAsync(HttpContext httpContext);
+     }
+     public sealed class ForbidHttpResult : IResult {
+         public Task ExecuteAsync(HttpContext httpContext);
+     }
+     public sealed class SignOutHttpResult : IResult {
+         public Task ExecuteAsync(HttpContext httpContext);
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Http.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Http.md
new file mode 100644
index 00000000..164dcd07
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Http.md
@@ -0,0 +1,92 @@
+# Microsoft.AspNetCore.Http
+
+``` diff
+ namespace Microsoft.AspNetCore.Http {
++    public sealed class AsParametersAttribute : Attribute {
++        public AsParametersAttribute();
++    }
++    public sealed class DefaultRouteHandlerInvocationContext : RouteHandlerInvocationContext {
++        public DefaultRouteHandlerInvocationContext(HttpContext httpContext, params object[] arguments);
++        public override IList<object?> Arguments { get; }
++        public override HttpContext HttpContext { get; }
++        public override T GetArgument<T>(int index);
++    }
+     public static class Results {
+-        public static IResult Content(string content, MediaTypeHeaderValue contentType);
++        public static IResult Content(string? content, MediaTypeHeaderValue contentType);
+-        public static IResult Content(string content, string? contentType = null, Encoding? contentEncoding = null);
++        public static IResult Content(string? content, string? contentType, Encoding? contentEncoding);
++        public static IResult Content(string? content, string? contentType = null, Encoding? contentEncoding = null, int? statusCode = default(int?));
+-        public static IResult Text(string content, string? contentType = null, Encoding? contentEncoding = null);
++        public static IResult Text(string? content, string? contentType, Encoding? contentEncoding);
++        public static IResult Text(string? content, string? contentType = null, Encoding? contentEncoding = null, int? statusCode = default(int?));
+     }
+-    public sealed class RouteHandlerInvocationContext {
++    public abstract class RouteHandlerInvocationContext {
++        protected RouteHandlerInvocationContext();
+-        public RouteHandlerInvocationContext(HttpContext httpContext, params object[] parameters);
++        public abstract IList<object?> Arguments { get; }
+-        public HttpContext HttpContext { get; }
++        public abstract HttpContext HttpContext { get; }
+-        public IList<object?> Parameters { get; }
++        public abstract T GetArgument<T>(int index);
+     }
+     public static class TypedResults {
+-        public static Accepted<TValue> Accepted<TValue>(string? uri, TValue? value);
++        public static Accepted<TValue> Accepted<TValue>(string uri, TValue value);
+-        public static AcceptedAtRoute AcceptedAtRoute(string? routeName = null, object? routeValues = null);
++        public static AcceptedAtRoute AcceptedAtRoute(string routeName = null, object routeValues = null);
+-        public static AcceptedAtRoute<TValue> AcceptedAtRoute<TValue>(TValue? value, string? routeName = null, object? routeValues = null);
++        public static AcceptedAtRoute<TValue> AcceptedAtRoute<TValue>(TValue value, string routeName = null, object routeValues = null);
+-        public static BadRequest<TValue> BadRequest<TValue>(TValue? error);
++        public static BadRequest<TValue> BadRequest<TValue>(TValue error);
+-        public static FileContentHttpResult Bytes(byte[] contents, string? contentType = null, string? fileDownloadName = null, bool enableRangeProcessing = false, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue? entityTag = null);
++        public static FileContentHttpResult Bytes(byte[] contents, string contentType = null, string fileDownloadName = null, bool enableRangeProcessing = false, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue entityTag = null);
+-        public static FileContentHttpResult Bytes(ReadOnlyMemory<byte> contents, string? contentType = null, string? fileDownloadName = null, bool enableRangeProcessing = false, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue? entityTag = null);
++        public static FileContentHttpResult Bytes(ReadOnlyMemory<byte> contents, string contentType = null, string fileDownloadName = null, bool enableRangeProcessing = false, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue entityTag = null);
+-        public static Conflict<TValue> Conflict<TValue>(TValue? error);
++        public static Conflict<TValue> Conflict<TValue>(TValue error);
+-        public static ContentHttpResult Content(string content, MediaTypeHeaderValue contentType);
++        public static ContentHttpResult Content(string? content, MediaTypeHeaderValue contentType);
+-        public static ContentHttpResult Content(string content, string? contentType = null, Encoding? contentEncoding = null);
++        public static ContentHttpResult Content(string content, string contentType, Encoding contentEncoding);
++        public static ContentHttpResult Content(string content, string contentType = null, Encoding contentEncoding = null, int? statusCode = default(int?));
+-        public static CreatedAtRoute CreatedAtRoute(string? routeName = null, object? routeValues = null);
++        public static CreatedAtRoute CreatedAtRoute(string routeName = null, object routeValues = null);
+-        public static CreatedAtRoute<TValue> CreatedAtRoute<TValue>(TValue? value, string? routeName = null, object? routeValues = null);
++        public static CreatedAtRoute<TValue> CreatedAtRoute<TValue>(TValue value, string routeName = null, object routeValues = null);
+-        public static FileContentHttpResult File(byte[] fileContents, string? contentType = null, string? fileDownloadName = null, bool enableRangeProcessing = false, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue? entityTag = null);
++        public static FileContentHttpResult File(byte[] fileContents, string contentType = null, string fileDownloadName = null, bool enableRangeProcessing = false, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue entityTag = null);
+-        public static FileStreamHttpResult File(Stream fileStream, string? contentType = null, string? fileDownloadName = null, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue? entityTag = null, bool enableRangeProcessing = false);
++        public static FileStreamHttpResult File(Stream fileStream, string contentType = null, string fileDownloadName = null, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue entityTag = null, bool enableRangeProcessing = false);
+-        public static JsonHttpResult<TValue> Json<TValue>(TValue? data, JsonSerializerOptions? options = null, string? contentType = null, int? statusCode = default(int?));
++        public static JsonHttpResult<TValue> Json<TValue>(TValue data, JsonSerializerOptions options = null, string contentType = null, int? statusCode = default(int?));
+-        public static NotFound<TValue> NotFound<TValue>(TValue? value);
++        public static NotFound<TValue> NotFound<TValue>(TValue value);
+-        public static Ok<TValue> Ok<TValue>(TValue? value);
++        public static Ok<TValue> Ok<TValue>(TValue value);
+-        public static PhysicalFileHttpResult PhysicalFile(string path, string? contentType = null, string? fileDownloadName = null, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue? entityTag = null, bool enableRangeProcessing = false);
++        public static PhysicalFileHttpResult PhysicalFile(string path, string contentType = null, string fileDownloadName = null, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue entityTag = null, bool enableRangeProcessing = false);
+-        public static ProblemHttpResult Problem(string? detail = null, string? instance = null, int? statusCode = default(int?), string? title = null, string? type = null, IDictionary<string, object?>? extensions = null);
++        public static ProblemHttpResult Problem(string detail = null, string instance = null, int? statusCode = default(int?), string title = null, string type = null, IDictionary<string, object?>? extensions = null);
+-        public static RedirectToRouteHttpResult RedirectToRoute(string? routeName = null, object? routeValues = null, bool permanent = false, bool preserveMethod = false, string? fragment = null);
++        public static RedirectToRouteHttpResult RedirectToRoute(string routeName = null, object routeValues = null, bool permanent = false, bool preserveMethod = false, string fragment = null);
+-        public static PushStreamHttpResult Stream(Func<Stream, Task> streamWriterCallback, string? contentType = null, string? fileDownloadName = null, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue? entityTag = null);
++        public static PushStreamHttpResult Stream(Func<Stream, Task> streamWriterCallback, string contentType = null, string fileDownloadName = null, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue entityTag = null);
+-        public static FileStreamHttpResult Stream(PipeReader pipeReader, string? contentType = null, string? fileDownloadName = null, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue? entityTag = null, bool enableRangeProcessing = false);
++        public static FileStreamHttpResult Stream(PipeReader pipeReader, string contentType = null, string fileDownloadName = null, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue entityTag = null, bool enableRangeProcessing = false);
+-        public static FileStreamHttpResult Stream(Stream stream, string? contentType = null, string? fileDownloadName = null, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue? entityTag = null, bool enableRangeProcessing = false);
++        public static FileStreamHttpResult Stream(Stream stream, string contentType = null, string fileDownloadName = null, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue entityTag = null, bool enableRangeProcessing = false);
+-        public static ContentHttpResult Text(string content, string? contentType = null, Encoding? contentEncoding = null);
++        public static ContentHttpResult Text(string content, string contentType, Encoding contentEncoding);
++        public static ContentHttpResult Text(string content, string contentType = null, Encoding contentEncoding = null, int? statusCode = default(int?));
+-        public static UnprocessableEntity<TValue> UnprocessableEntity<TValue>(TValue? error);
++        public static UnprocessableEntity<TValue> UnprocessableEntity<TValue>(TValue error);
+-        public static ValidationProblem ValidationProblem(IDictionary<string, string[]> errors, string? detail = null, string? instance = null, string? title = null, string? type = null, IDictionary<string, object?>? extensions = null);
++        public static ValidationProblem ValidationProblem(IDictionary<string, string[]> errors, string detail = null, string instance = null, string title = null, string type = null, IDictionary<string, object?>? extensions = null);
+-        public static VirtualFileHttpResult VirtualFile(string path, string? contentType = null, string? fileDownloadName = null, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue? entityTag = null, bool enableRangeProcessing = false);
++        public static VirtualFileHttpResult VirtualFile(string path, string contentType = null, string fileDownloadName = null, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue entityTag = null, bool enableRangeProcessing = false);
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Mvc.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Mvc.md
new file mode 100644
index 00000000..d7e1ebbf
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Mvc.md
@@ -0,0 +1,8 @@
+# Microsoft.AspNetCore.Mvc
+
+``` diff
+ namespace Microsoft.AspNetCore.Mvc {
+     public class FromServicesAttribute : Attribute, IBindingSourceMetadata, IFromServiceMetadata
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.ResponseCompression.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.ResponseCompression.md
new file mode 100644
index 00000000..1f058d5e
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.ResponseCompression.md
@@ -0,0 +1,11 @@
+# Microsoft.AspNetCore.ResponseCompression
+
+``` diff
+ namespace Microsoft.AspNetCore.ResponseCompression {
+     public class CompressionProviderCollection : Collection<ICompressionProvider> {
+-         public void Add(Type providerType);
++         public void Add([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] Type providerType);
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.SignalR.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.SignalR.md
new file mode 100644
index 00000000..8f5c5a29
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.SignalR.md
@@ -0,0 +1,10 @@
+# Microsoft.AspNetCore.SignalR
+
+``` diff
+ namespace Microsoft.AspNetCore.SignalR {
+     public interface IInvocationBinder {
++        string? GetTarget(ReadOnlySpan<byte> utf8Bytes);
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.WebUtilities.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.WebUtilities.md
new file mode 100644
index 00000000..4c703123
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.WebUtilities.md
@@ -0,0 +1,14 @@
+# Microsoft.AspNetCore.WebUtilities
+
+``` diff
+ namespace Microsoft.AspNetCore.WebUtilities {
+     public class FormMultipartSection {
++        public ValueTask<string> GetValueAsync(CancellationToken cancellationToken);
+     }
+     public static class MultipartSectionStreamExtensions {
+         public static Task<string> ReadAsStringAsync(this MultipartSection section);
++        public static ValueTask<string> ReadAsStringAsync(this MultipartSection section, CancellationToken cancellationToken);
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.Extensions.Logging.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.Extensions.Logging.md
new file mode 100644
index 00000000..21297253
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.Extensions.Logging.md
@@ -0,0 +1,12 @@
+# Microsoft.Extensions.Logging
+
+``` diff
+ namespace Microsoft.Extensions.Logging {
+     public class LoggerFactory : IDisposable, ILoggerFactory {
+-        public LoggerFactory(IEnumerable<ILoggerProvider> providers, IOptionsMonitor<LoggerFilterOptions> filterOption, IOptions<LoggerFactoryOptions>? options = null);
++        public LoggerFactory(IEnumerable<ILoggerProvider> providers, IOptionsMonitor<LoggerFilterOptions> filterOption, IOptions<LoggerFactoryOptions>? options);
++        public LoggerFactory(IEnumerable<ILoggerProvider> providers, IOptionsMonitor<LoggerFilterOptions> filterOption, IOptions<LoggerFactoryOptions>? options = null, IExternalScopeProvider? scopeProvider = null);
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.JSInterop.Infrastructure.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.JSInterop.Infrastructure.md
new file mode 100644
index 00000000..59d2a397
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.JSInterop.Infrastructure.md
@@ -0,0 +1,14 @@
+# Microsoft.JSInterop.Infrastructure
+
+``` diff
+ namespace Microsoft.JSInterop.Infrastructure {
+     public static class DotNetDispatcher
+     {
++        [System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute("Trimming", "IL2026", Justification = "We expect application code is configured to ensure return types of JSInvokable methods are retained.")]
+         public static string? Invoke(Microsoft.JSInterop.JSRuntime jsRuntime, in Microsoft.JSInterop.Infrastructure.DotNetInvocationInfo invocationInfo, string argsJson);
++        [System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute("Trimming", "IL2026", Justification = "We expect application code is configured to ensure return types of JSInvokable methods are retained.")]
+         public static void BeginInvokeDotNet(Microsoft.JSInterop.JSRuntime jsRuntime, Microsoft.JSInterop.Infrastructure.DotNetInvocationInfo invocationInfo, string argsJson);
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5.md
new file mode 100644
index 00000000..106f6383
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5.md
@@ -0,0 +1,33 @@
+# API Difference 7.0-preview4 vs 7.0-preview5
+
+API listing follows standard diff formatting.
+Lines preceded by a '+' are additions and a '-' indicates removal.
+
+* [Microsoft.VisualBasic.FileIO](7.0-preview5_Microsoft.VisualBasic.FileIO.md)
+* [System](7.0-preview5_System.md)
+* [System.Collections.Immutable](7.0-preview5_System.Collections.Immutable.md)
+* [System.ComponentModel](7.0-preview5_System.ComponentModel.md)
+* [System.Data](7.0-preview5_System.Data.md)
+* [System.Diagnostics](7.0-preview5_System.Diagnostics.md)
+* [System.IO](7.0-preview5_System.IO.md)
+* [System.Net](7.0-preview5_System.Net.md)
+* [System.Net.Http](7.0-preview5_System.Net.Http.md)
+* [System.Net.NetworkInformation](7.0-preview5_System.Net.NetworkInformation.md)
+* [System.Net.Security](7.0-preview5_System.Net.Security.md)
+* [System.Net.Sockets](7.0-preview5_System.Net.Sockets.md)
+* [System.Numerics](7.0-preview5_System.Numerics.md)
+* [System.Reflection.Emit](7.0-preview5_System.Reflection.Emit.md)
+* [System.Reflection.Metadata.Ecma335](7.0-preview5_System.Reflection.Metadata.Ecma335.md)
+* [System.Runtime.CompilerServices](7.0-preview5_System.Runtime.CompilerServices.md)
+* [System.Runtime.InteropServices](7.0-preview5_System.Runtime.InteropServices.md)
+* [System.Runtime.InteropServices.Marshalling](7.0-preview5_System.Runtime.InteropServices.Marshalling.md)
+* [System.Runtime.Intrinsics](7.0-preview5_System.Runtime.Intrinsics.md)
+* [System.Runtime.Intrinsics.X86](7.0-preview5_System.Runtime.Intrinsics.X86.md)
+* [System.Security.Cryptography](7.0-preview5_System.Security.Cryptography.md)
+* [System.Security.Cryptography.X509Certificates](7.0-preview5_System.Security.Cryptography.X509Certificates.md)
+* [System.Text.Json](7.0-preview5_System.Text.Json.md)
+* [System.Text.Json.Nodes](7.0-preview5_System.Text.Json.Nodes.md)
+* [System.Text.Json.Serialization](7.0-preview5_System.Text.Json.Serialization.md)
+* [System.Text.Json.Serialization.Metadata](7.0-preview5_System.Text.Json.Serialization.Metadata.md)
+* [System.Threading](7.0-preview5_System.Threading.md)
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_Microsoft.VisualBasic.FileIO.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_Microsoft.VisualBasic.FileIO.md
new file mode 100644
index 00000000..6481ee6c
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_Microsoft.VisualBasic.FileIO.md
@@ -0,0 +1,10 @@
+# Microsoft.VisualBasic.FileIO
+
+``` diff
+ namespace Microsoft.VisualBasic.FileIO {
+     public class TextFieldParser : IDisposable {
+         public string[]? CommentTokens { get; set; }
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Collections.Immutable.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Collections.Immutable.md
new file mode 100644
index 00000000..728b66b0
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Collections.Immutable.md
@@ -0,0 +1,42 @@
+# System.Collections.Immutable
+
+``` diff
+ namespace System.Collections.Immutable {
+     public readonly struct ImmutableArray<T> : ICollection, ICollection<T>, IEnumerable, IEnumerable<T>, IEquatable<ImmutableArray<T>>, IImmutableList<T>, IList, IList<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, IStructuralComparable, IStructuralEquatable {
++        public ImmutableArray<T> AddRange(ImmutableArray<T> items, int length);
++        public ImmutableArray<T> AddRange(T[] items, int length);
++        public ImmutableArray<T> AddRange<TDerived>(ImmutableArray<TDerived> items) where TDerived : T;
++        public ImmutableArray<T> AddRange<TDerived>(TDerived[] items) where TDerived : T;
+         public sealed class Builder : ICollection<T>, IEnumerable, IEnumerable<T>, IList<T>, IReadOnlyCollection<T>, IReadOnlyList<T> {
++            public void CopyTo(int sourceIndex, T[] destination, int destinationIndex, int length);
++            public void CopyTo(T[] destination);
++            public int IndexOf(T item, int startIndex, IEqualityComparer<T>? equalityComparer);
++            public void InsertRange(int index, IEnumerable<T> items);
++            public void InsertRange(int index, ImmutableArray<T> items);
++            public bool Remove(T element, IEqualityComparer<T>? equalityComparer);
++            public void RemoveAll(Predicate<T> match);
++            public void RemoveRange(IEnumerable<T> items);
++            public void RemoveRange(IEnumerable<T> items, IEqualityComparer<T>? equalityComparer);
++            public void RemoveRange(int index, int length);
++            public void Replace(T oldValue, T newValue);
++            public void Replace(T oldValue, T newValue, IEqualityComparer<T>? equalityComparer);
+         }
+     }
+     public sealed class ImmutableList<T> : ICollection, ICollection<T>, IEnumerable, IEnumerable<T>, IImmutableList<T>, IList, IList<T>, IReadOnlyCollection<T>, IReadOnlyList<T> {
+         public sealed class Builder : ICollection, ICollection<T>, IEnumerable, IEnumerable<T>, IList, IList<T>, IReadOnlyCollection<T>, IReadOnlyList<T> {
++            public bool Remove(T item, IEqualityComparer<T>? equalityComparer);
++            public void RemoveRange(IEnumerable<T> items);
++            public void RemoveRange(IEnumerable<T> items, IEqualityComparer<T>? equalityComparer);
++            public void RemoveRange(int index, int count);
++            public void Replace(T oldValue, T newValue);
++            public void Replace(T oldValue, T newValue, IEqualityComparer<T>? equalityComparer);
+         }
+     }
+     public sealed class ImmutableSortedSet<T> : ICollection, ICollection<T>, IEnumerable, IEnumerable<T>, IImmutableSet<T>, IList, IList<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, IReadOnlySet<T>, ISet<T> {
+         public sealed class Builder : ICollection, ICollection<T>, IEnumerable, IEnumerable<T>, IReadOnlyCollection<T>, ISet<T> {
++            public int IndexOf(T item);
+         }
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.ComponentModel.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.ComponentModel.md
new file mode 100644
index 00000000..67b6a2b5
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.ComponentModel.md
@@ -0,0 +1,13 @@
+# System.ComponentModel
+
+``` diff
+ namespace System.ComponentModel {
+     public sealed class TypeDescriptor {
++       [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)]
+         public static Type ComObjectType { get; }
++       [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)]
+         public static Type InterfaceType { get; }
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Data.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Data.md
new file mode 100644
index 00000000..5a554bc6
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Data.md
@@ -0,0 +1,13 @@
+# System.Data
+
+``` diff
+ namespace System.Data {
+     public class DataColumn : MarshalByValueComponent {
+         public Type DataType { get; set; }
+     }
+     public enum SerializationFormat {
+         Binary = 1,
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Diagnostics.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Diagnostics.md
new file mode 100644
index 00000000..1fefc80e
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Diagnostics.md
@@ -0,0 +1,17 @@
+# System.Diagnostics
+
+``` diff
+ namespace System.Diagnostics {
+     public readonly struct ActivityEvent {
++        public Activity.Enumerator<KeyValuePair<string, object?>> EnumerateTagObjects();
+     }
+     public readonly struct ActivityLink : IEquatable<ActivityLink> {
++        public Activity.Enumerator<KeyValuePair<string, object?>> EnumerateTagObjects();
+     }
+     public class Process : Component, IDisposable {
+         public TimeSpan PrivilegedProcessorTime { get; }
+         public DateTime StartTime { get; }
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.IO.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.IO.md
new file mode 100644
index 00000000..f177f46c
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.IO.md
@@ -0,0 +1,23 @@
+# System.IO
+
+``` diff
+ namespace System.IO {
+     public static class File {
++        public static IAsyncEnumerable<string> ReadLinesAsync(string path, Encoding encoding, CancellationToken cancellationToken = default(CancellationToken));
++        public static IAsyncEnumerable<string> ReadLinesAsync(string path, CancellationToken cancellationToken = default(CancellationToken));
+     }
+     public class FileStream : Stream {
+         public virtual void Lock(long position, long length);
+         public virtual void Unlock(long position, long length);
+     }
+     public abstract class Stream : MarshalByRefObject, IAsyncDisposable, IDisposable {
++        public int ReadAtLeast(Span<byte> buffer, int minimumBytes, bool throwOnEndOfStream = true);
++        public ValueTask<int> ReadAtLeastAsync(Memory<byte> buffer, int minimumBytes, bool throwOnEndOfStream = true, CancellationToken cancellationToken = default(CancellationToken));
++        public void ReadExactly(byte[] buffer, int offset, int count);
++        public void ReadExactly(Span<byte> buffer);
++        public ValueTask ReadExactlyAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken = default(CancellationToken));
++        public ValueTask ReadExactlyAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Net.Http.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Net.Http.md
new file mode 100644
index 00000000..8aedea8d
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Net.Http.md
@@ -0,0 +1,10 @@
+# System.Net.Http
+
+``` diff
+ namespace System.Net.Http {
+     public class HttpClientHandler : HttpMessageHandler {
+         public IWebProxy Proxy { get; set; }
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Net.NetworkInformation.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Net.NetworkInformation.md
new file mode 100644
index 00000000..329d97dc
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Net.NetworkInformation.md
@@ -0,0 +1,21 @@
+# System.Net.NetworkInformation
+
+``` diff
+ namespace System.Net.NetworkInformation {
+     public abstract class IPInterfaceStatistics {
+         public abstract long OutgoingPacketsDiscarded { get; }
+     }
+     public abstract class IPv4InterfaceStatistics {
+         public abstract long OutgoingPacketsDiscarded { get; }
+     }
+     public class NetworkChange {
+         public static event NetworkAddressChangedEventHandler NetworkAddressChanged;
+         public static event NetworkAvailabilityChangedEventHandler NetworkAvailabilityChanged;
+     }
+     public abstract class NetworkInterface {
+         public static int IPv6LoopbackInterfaceIndex { get; }
+         public static int LoopbackInterfaceIndex { get; }
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Net.Security.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Net.Security.md
new file mode 100644
index 00000000..0e2ee3c9
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Net.Security.md
@@ -0,0 +1,13 @@
+# System.Net.Security
+
+``` diff
+ namespace System.Net.Security {
+     public readonly struct SslClientHelloInfo {
+         public string ServerName { get; }
+         public SslProtocols SslProtocols { get; }
+     }
+-    public sealed class SslStreamCertificateContext
++    public class SslStreamCertificateContext
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Net.Sockets.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Net.Sockets.md
new file mode 100644
index 00000000..2c06f78f
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Net.Sockets.md
@@ -0,0 +1,16 @@
+# System.Net.Sockets
+
+``` diff
+ namespace System.Net.Sockets {
+     public sealed class SafeSocketHandle : SafeHandleMinusOneIsInvalid {
++        public override bool IsInvalid { get; }
+     }
+     public sealed class UnixDomainSocketEndPoint : EndPoint {
++        public override AddressFamily AddressFamily { get; }
++        public override EndPoint Create(SocketAddress socketAddress);
++        public override SocketAddress Serialize();
++        public override string ToString();
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Net.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Net.md
new file mode 100644
index 00000000..e0466298
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Net.md
@@ -0,0 +1,10 @@
+# System.Net
+
+``` diff
+ namespace System.Net {
+     public class IPAddress {
+         public long Address { get; set; }
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Numerics.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Numerics.md
new file mode 100644
index 00000000..1ef7bf18
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Numerics.md
@@ -0,0 +1,239 @@
+# System.Numerics
+
+``` diff
+ namespace System.Numerics {
+-    public readonly struct BigInteger : IComparable, IComparable<BigInteger>, IEquatable<BigInteger>, IFormattable, ISpanFormattable {
++    public readonly struct BigInteger : IAdditionOperators<BigInteger, BigInteger, BigInteger>, IAdditiveIdentity<BigInteger, BigInteger>, IBinaryInteger<BigInteger>, IBinaryNumber<BigInteger>, IBitwiseOperators<BigInteger, BigInteger, BigInteger>, IComparable, IComparable<BigInteger>, IComparisonOperators<BigInteger, BigInteger>, IDecrementOperators<BigInteger>, IDivisionOperators<BigInteger, BigInteger, BigInteger>, IEqualityOperators<BigInteger, BigInteger>, IEquatable<BigInteger>, IFormattable, IIncrementOperators<BigInteger>, IModulusOperators<BigInteger, BigInteger, BigInteger>, IMultiplicativeIdentity<BigInteger, BigInteger>, IMultiplyOperators<BigInteger, BigInteger, BigInteger>, INumber<BigInteger>, INumberBase<BigInteger>, IParsable<BigInteger>, IShiftOperators<BigInteger, BigInteger>, ISignedNumber<BigInteger>, ISpanFormattable, ISpanParsable<BigInteger>, ISubtractionOperators<BigInteger, BigInteger, BigInteger>, IUnaryNegationOperators<BigInteger, BigInteger>, IUnaryPlusOperators<BigInteger, BigInteger> {
++        static BigInteger System.Numerics.IAdditiveIdentity<System.Numerics.BigInteger,System.Numerics.BigInteger>.AdditiveIdentity { get; }
++        static BigInteger System.Numerics.IMultiplicativeIdentity<System.Numerics.BigInteger,System.Numerics.BigInteger>.MultiplicativeIdentity { get; }
++        static int System.Numerics.INumberBase<System.Numerics.BigInteger>.Radix { get; }
++        static BigInteger System.Numerics.ISignedNumber<System.Numerics.BigInteger>.NegativeOne { get; }
++        public static BigInteger Clamp(BigInteger value, BigInteger min, BigInteger max);
++        public static BigInteger CopySign(BigInteger value, BigInteger sign);
++        public static (BigInteger Quotient, BigInteger Remainder) DivRem(BigInteger left, BigInteger right);
++        public static bool IsEvenInteger(BigInteger value);
++        public static bool IsNegative(BigInteger value);
++        public static bool IsOddInteger(BigInteger value);
++        public static bool IsPositive(BigInteger value);
++        public static bool IsPow2(BigInteger value);
++        public static BigInteger LeadingZeroCount(BigInteger value);
++        public static BigInteger Log2(BigInteger value);
++        public static BigInteger MaxMagnitude(BigInteger x, BigInteger y);
++        public static BigInteger MinMagnitude(BigInteger x, BigInteger y);
++        public static explicit operator BigInteger (Half value);
++        public static explicit operator char (BigInteger value);
++        public static explicit operator Half (BigInteger value);
++        public static explicit operator Int128 (BigInteger value);
++        public static explicit operator nint (BigInteger value);
++        public static explicit operator UInt128 (BigInteger value);
++        public static explicit operator nuint (BigInteger value);
++        public static explicit operator BigInteger (Complex value);
++        public static implicit operator BigInteger (char value);
++        public static implicit operator BigInteger (Int128 value);
++        public static implicit operator BigInteger (IntPtr value);
++        public static implicit operator BigInteger (UInt128 value);
++        public static implicit operator BigInteger (UIntPtr value);
++        public static BigInteger operator >>>(BigInteger value, int shiftAmount);
++        public static BigInteger Parse(ReadOnlySpan<char> s, IFormatProvider? provider);
++        public static BigInteger PopCount(BigInteger value);
++        public static BigInteger RotateLeft(BigInteger value, int rotateAmount);
++        public static BigInteger RotateRight(BigInteger value, int rotateAmount);
++        static BigInteger IAdditionOperators<BigInteger, BigInteger, BigInteger>.operator checked +(BigInteger left, BigInteger right);
++        int IBinaryInteger<BigInteger>.GetByteCount();
++        int IBinaryInteger<BigInteger>.GetShortestBitLength();
++        bool IBinaryInteger<BigInteger>.TryWriteBigEndian(Span<byte> destination, out int bytesWritten);
++        bool IBinaryInteger<BigInteger>.TryWriteLittleEndian(Span<byte> destination, out int bytesWritten);
++        static BigInteger IDecrementOperators<BigInteger>.operator checked --(BigInteger value);
++        static BigInteger IDivisionOperators<BigInteger, BigInteger, BigInteger>.operator checked /(BigInteger left, BigInteger right);
++        static BigInteger IIncrementOperators<BigInteger>.operator checked ++(BigInteger value);
++        static BigInteger IMultiplyOperators<BigInteger, BigInteger, BigInteger>.operator checked *(BigInteger left, BigInteger right);
++        static BigInteger INumber<BigInteger>.MaxNumber(BigInteger x, BigInteger y);
++        static BigInteger INumber<BigInteger>.MinNumber(BigInteger x, BigInteger y);
++        static int INumber<BigInteger>.Sign(BigInteger value);
++        static bool INumberBase<BigInteger>.IsCanonical(BigInteger value);
++        static bool INumberBase<BigInteger>.IsComplexNumber(BigInteger value);
++        static bool INumberBase<BigInteger>.IsFinite(BigInteger value);
++        static bool INumberBase<BigInteger>.IsImaginaryNumber(BigInteger value);
++        static bool INumberBase<BigInteger>.IsInfinity(BigInteger value);
++        static bool INumberBase<BigInteger>.IsInteger(BigInteger value);
++        static bool INumberBase<BigInteger>.IsNaN(BigInteger value);
++        static bool INumberBase<BigInteger>.IsNegativeInfinity(BigInteger value);
++        static bool INumberBase<BigInteger>.IsNormal(BigInteger value);
++        static bool INumberBase<BigInteger>.IsPositiveInfinity(BigInteger value);
++        static bool INumberBase<BigInteger>.IsRealNumber(BigInteger value);
++        static bool INumberBase<BigInteger>.IsSubnormal(BigInteger value);
++        static bool INumberBase<BigInteger>.IsZero(BigInteger value);
++        static BigInteger INumberBase<BigInteger>.MaxMagnitudeNumber(BigInteger x, BigInteger y);
++        static BigInteger INumberBase<BigInteger>.MinMagnitudeNumber(BigInteger x, BigInteger y);
++        static bool INumberBase<BigInteger>.TryConvertFromChecked<TOther>(TOther value, out BigInteger result);
++        static bool INumberBase<BigInteger>.TryConvertFromSaturating<TOther>(TOther value, out BigInteger result);
++        static bool INumberBase<BigInteger>.TryConvertFromTruncating<TOther>(TOther value, out BigInteger result);
++        static bool INumberBase<BigInteger>.TryConvertToChecked<TOther>(BigInteger value, out TOther result);
++        static bool INumberBase<BigInteger>.TryConvertToSaturating<TOther>(BigInteger value, out TOther result);
++        static bool INumberBase<BigInteger>.TryConvertToTruncating<TOther>(BigInteger value, out TOther result);
++        static BigInteger ISubtractionOperators<BigInteger, BigInteger, BigInteger>.operator checked -(BigInteger left, BigInteger right);
++        static BigInteger IUnaryNegationOperators<BigInteger, BigInteger>.operator checked -(BigInteger value);
++        public static BigInteger TrailingZeroCount(BigInteger value);
++        public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, out BigInteger result);
++        public static bool TryParse(string? s, IFormatProvider? provider, out BigInteger result);
+     }
+-    public readonly struct Complex : IEquatable<Complex>, IFormattable {
++    public readonly struct Complex : IAdditionOperators<Complex, Complex, Complex>, IAdditiveIdentity<Complex, Complex>, IDecrementOperators<Complex>, IDivisionOperators<Complex, Complex, Complex>, IEqualityOperators<Complex, Complex>, IEquatable<Complex>, IFormattable, IIncrementOperators<Complex>, IMultiplicativeIdentity<Complex, Complex>, IMultiplyOperators<Complex, Complex, Complex>, INumberBase<Complex>, IParsable<Complex>, ISignedNumber<Complex>, ISpanFormattable, ISpanParsable<Complex>, ISubtractionOperators<Complex, Complex, Complex>, IUnaryNegationOperators<Complex, Complex>, IUnaryPlusOperators<Complex, Complex> {
++        static Complex System.Numerics.IAdditiveIdentity<System.Numerics.Complex,System.Numerics.Complex>.AdditiveIdentity { get; }
++        static Complex System.Numerics.IMultiplicativeIdentity<System.Numerics.Complex,System.Numerics.Complex>.MultiplicativeIdentity { get; }
++        static Complex System.Numerics.INumberBase<System.Numerics.Complex>.One { get; }
++        static int System.Numerics.INumberBase<System.Numerics.Complex>.Radix { get; }
++        static Complex System.Numerics.INumberBase<System.Numerics.Complex>.Zero { get; }
++        static Complex System.Numerics.ISignedNumber<System.Numerics.Complex>.NegativeOne { get; }
++        public static bool IsComplexNumber(Complex value);
++        public static bool IsEvenInteger(Complex value);
++        public static bool IsImaginaryNumber(Complex value);
++        public static bool IsInteger(Complex value);
++        public static bool IsNegative(Complex value);
++        public static bool IsNegativeInfinity(Complex value);
++        public static bool IsNormal(Complex value);
++        public static bool IsOddInteger(Complex value);
++        public static bool IsPositive(Complex value);
++        public static bool IsPositiveInfinity(Complex value);
++        public static bool IsRealNumber(Complex value);
++        public static bool IsSubnormal(Complex value);
++        public static Complex MaxMagnitude(Complex x, Complex y);
++        public static Complex MinMagnitude(Complex x, Complex y);
++        public static Complex operator --(Complex value);
++        public static explicit operator Complex (Int128 value);
++        public static explicit operator Complex (UInt128 value);
++        public static implicit operator Complex (char value);
++        public static implicit operator Complex (Half value);
++        public static implicit operator Complex (IntPtr value);
++        public static implicit operator Complex (UIntPtr value);
++        public static Complex operator ++(Complex value);
++        public static Complex operator +(Complex value);
++        public static Complex Parse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider);
++        public static Complex Parse(ReadOnlySpan<char> s, IFormatProvider? provider);
++        public static Complex Parse(string s, NumberStyles style, IFormatProvider? provider);
++        public static Complex Parse(string s, IFormatProvider? provider);
++        static Complex IAdditionOperators<Complex, Complex, Complex>.operator checked +(Complex left, Complex right);
++        static Complex IDecrementOperators<Complex>.operator checked --(Complex value);
++        static Complex IDivisionOperators<Complex, Complex, Complex>.operator checked /(Complex left, Complex right);
++        static Complex IIncrementOperators<Complex>.operator checked ++(Complex value);
++        static Complex IMultiplyOperators<Complex, Complex, Complex>.operator checked *(Complex left, Complex right);
++        static Complex INumberBase<Complex>.Abs(Complex value);
++        static bool INumberBase<Complex>.IsCanonical(Complex value);
++        static bool INumberBase<Complex>.IsZero(Complex value);
++        static Complex INumberBase<Complex>.MaxMagnitudeNumber(Complex x, Complex y);
++        static Complex INumberBase<Complex>.MinMagnitudeNumber(Complex x, Complex y);
++        static bool INumberBase<Complex>.TryConvertFromChecked<TOther>(TOther value, out Complex result);
++        static bool INumberBase<Complex>.TryConvertFromSaturating<TOther>(TOther value, out Complex result);
++        static bool INumberBase<Complex>.TryConvertFromTruncating<TOther>(TOther value, out Complex result);
++        static bool INumberBase<Complex>.TryConvertToChecked<TOther>(Complex value, out TOther result);
++        static bool INumberBase<Complex>.TryConvertToSaturating<TOther>(Complex value, out TOther result);
++        static bool INumberBase<Complex>.TryConvertToTruncating<TOther>(Complex value, out TOther result);
++        static Complex ISubtractionOperators<Complex, Complex, Complex>.operator checked -(Complex left, Complex right);
++        static Complex IUnaryNegationOperators<Complex, Complex>.operator checked -(Complex value);
++        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider? provider);
++        public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider, out Complex result);
++        public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, out Complex result);
++        public static bool TryParse(string? s, NumberStyles style, IFormatProvider? provider, out Complex result);
++        public static bool TryParse(string? s, IFormatProvider? provider, out Complex result);
+     }
+     public interface IBinaryInteger<TSelf> : IAdditionOperators<TSelf, TSelf, TSelf>, IAdditiveIdentity<TSelf, TSelf>, IBinaryNumber<TSelf>, IBitwiseOperators<TSelf, TSelf, TSelf>, IComparable, IComparable<TSelf>, IComparisonOperators<TSelf, TSelf>, IDecrementOperators<TSelf>, IDivisionOperators<TSelf, TSelf, TSelf>, IEqualityOperators<TSelf, TSelf>, IEquatable<TSelf>, IFormattable, IIncrementOperators<TSelf>, IModulusOperators<TSelf, TSelf, TSelf>, IMultiplicativeIdentity<TSelf, TSelf>, IMultiplyOperators<TSelf, TSelf, TSelf>, INumber<TSelf>, INumberBase<TSelf>, IParsable<TSelf>, IShiftOperators<TSelf, TSelf>, ISpanFormattable, ISpanParsable<TSelf>, ISubtractionOperators<TSelf, TSelf, TSelf>, IUnaryNegationOperators<TSelf, TSelf>, IUnaryPlusOperators<TSelf, TSelf> where TSelf : IBinaryInteger<TSelf> {
+-        long GetShortestBitLength();
++        int GetShortestBitLength();
++        bool TryWriteBigEndian(Span<byte> destination, out int bytesWritten);
++        int WriteBigEndian(byte[] destination);
++        int WriteBigEndian(byte[] destination, int startIndex);
++        int WriteBigEndian(Span<byte> destination);
+     }
+     public interface IExponentialFunctions<TSelf> where TSelf : IExponentialFunctions<TSelf> {
++        static abstract TSelf Exp10(TSelf x);
++        static abstract TSelf Exp10M1(TSelf x);
++        static abstract TSelf Exp2(TSelf x);
++        static abstract TSelf Exp2M1(TSelf x);
++        static abstract TSelf ExpM1(TSelf x);
+     }
+     public interface IFloatingPoint<TSelf> : IAdditionOperators<TSelf, TSelf, TSelf>, IAdditiveIdentity<TSelf, TSelf>, IComparable, IComparable<TSelf>, IComparisonOperators<TSelf, TSelf>, IDecrementOperators<TSelf>, IDivisionOperators<TSelf, TSelf, TSelf>, IEqualityOperators<TSelf, TSelf>, IEquatable<TSelf>, IFormattable, IIncrementOperators<TSelf>, IModulusOperators<TSelf, TSelf, TSelf>, IMultiplicativeIdentity<TSelf, TSelf>, IMultiplyOperators<TSelf, TSelf, TSelf>, INumber<TSelf>, INumberBase<TSelf>, IParsable<TSelf>, ISignedNumber<TSelf>, ISpanFormattable, ISpanParsable<TSelf>, ISubtractionOperators<TSelf, TSelf, TSelf>, IUnaryNegationOperators<TSelf, TSelf>, IUnaryPlusOperators<TSelf, TSelf> where TSelf : IFloatingPoint<TSelf> {
+-        long GetExponentShortestBitLength();
++        int GetExponentShortestBitLength();
+-        long GetSignificandBitLength();
++        int GetSignificandBitLength();
++        bool TryWriteExponentBigEndian(Span<byte> destination, out int bytesWritten);
++        bool TryWriteSignificandBigEndian(Span<byte> destination, out int bytesWritten);
++        int WriteExponentBigEndian(byte[] destination);
++        int WriteExponentBigEndian(byte[] destination, int startIndex);
++        int WriteExponentBigEndian(Span<byte> destination);
++        int WriteSignificandBigEndian(byte[] destination);
++        int WriteSignificandBigEndian(byte[] destination, int startIndex);
++        int WriteSignificandBigEndian(Span<byte> destination);
+     }
+     public interface IFloatingPointIeee754<TSelf> : IAdditionOperators<TSelf, TSelf, TSelf>, IAdditiveIdentity<TSelf, TSelf>, IComparable, IComparable<TSelf>, IComparisonOperators<TSelf, TSelf>, IDecrementOperators<TSelf>, IDivisionOperators<TSelf, TSelf, TSelf>, IEqualityOperators<TSelf, TSelf>, IEquatable<TSelf>, IExponentialFunctions<TSelf>, IFloatingPoint<TSelf>, IFormattable, IHyperbolicFunctions<TSelf>, IIncrementOperators<TSelf>, ILogarithmicFunctions<TSelf>, IModulusOperators<TSelf, TSelf, TSelf>, IMultiplicativeIdentity<TSelf, TSelf>, IMultiplyOperators<TSelf, TSelf, TSelf>, INumber<TSelf>, INumberBase<TSelf>, IParsable<TSelf>, IPowerFunctions<TSelf>, IRootFunctions<TSelf>, ISignedNumber<TSelf>, ISpanFormattable, ISpanParsable<TSelf>, ISubtractionOperators<TSelf, TSelf, TSelf>, ITrigonometricFunctions<TSelf>, IUnaryNegationOperators<TSelf, TSelf>, IUnaryPlusOperators<TSelf, TSelf> where TSelf : IFloatingPointIeee754<TSelf> {
+-        static abstract bool IsFinite(TSelf value);
+-        static abstract bool IsInfinity(TSelf value);
+-        static abstract bool IsNaN(TSelf value);
+-        static abstract bool IsNegativeInfinity(TSelf value);
+-        static abstract bool IsNormal(TSelf value);
+-        static abstract bool IsPositiveInfinity(TSelf value);
+-        static abstract bool IsSubnormal(TSelf value);
+     }
+     public interface ILogarithmicFunctions<TSelf> where TSelf : ILogarithmicFunctions<TSelf> {
++        static abstract TSelf Log10P1(TSelf x);
++        static abstract TSelf Log2P1(TSelf x);
++        static abstract TSelf LogP1(TSelf x);
+     }
+     public interface INumber<TSelf> : IAdditionOperators<TSelf, TSelf, TSelf>, IAdditiveIdentity<TSelf, TSelf>, IComparable, IComparable<TSelf>, IComparisonOperators<TSelf, TSelf>, IDecrementOperators<TSelf>, IDivisionOperators<TSelf, TSelf, TSelf>, IEqualityOperators<TSelf, TSelf>, IEquatable<TSelf>, IFormattable, IIncrementOperators<TSelf>, IModulusOperators<TSelf, TSelf, TSelf>, IMultiplicativeIdentity<TSelf, TSelf>, IMultiplyOperators<TSelf, TSelf, TSelf>, INumberBase<TSelf>, IParsable<TSelf>, ISpanFormattable, ISpanParsable<TSelf>, ISubtractionOperators<TSelf, TSelf, TSelf>, IUnaryNegationOperators<TSelf, TSelf>, IUnaryPlusOperators<TSelf, TSelf> where TSelf : INumber<TSelf> {
+-        static abstract TSelf Abs(TSelf value);
+-        static abstract TSelf CreateChecked<TOther>(TOther value);
+-        static abstract TSelf CreateSaturating<TOther>(TOther value);
+-        static abstract TSelf CreateTruncating<TOther>(TOther value);
+-        static abstract bool IsNegative(TSelf value);
+-        static abstract TSelf MaxMagnitude(TSelf x, TSelf y);
++        static abstract TSelf MaxNumber(TSelf x, TSelf y);
+-        static abstract TSelf MinMagnitude(TSelf x, TSelf y);
++        static abstract TSelf MinNumber(TSelf x, TSelf y);
+-        static abstract TSelf Parse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider);
+-        static abstract TSelf Parse(string s, NumberStyles style, IFormatProvider? provider);
+-        static abstract bool TryCreate<TOther>(TOther value, out TSelf result);
+-        static abstract bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider, out TSelf result);
+-        static abstract bool TryParse(string? s, NumberStyles style, IFormatProvider? provider, out TSelf result);
+     }
+-    public interface INumberBase<TSelf> : IAdditionOperators<TSelf, TSelf, TSelf>, IAdditiveIdentity<TSelf, TSelf>, IDecrementOperators<TSelf>, IDivisionOperators<TSelf, TSelf, TSelf>, IEqualityOperators<TSelf, TSelf>, IEquatable<TSelf>, IFormattable, IIncrementOperators<TSelf>, IMultiplicativeIdentity<TSelf, TSelf>, IMultiplyOperators<TSelf, TSelf, TSelf>, ISpanFormattable, ISubtractionOperators<TSelf, TSelf, TSelf>, IUnaryNegationOperators<TSelf, TSelf>, IUnaryPlusOperators<TSelf, TSelf> where TSelf : INumberBase<TSelf> {
++    public interface INumberBase<TSelf> : IAdditionOperators<TSelf, TSelf, TSelf>, IAdditiveIdentity<TSelf, TSelf>, IDecrementOperators<TSelf>, IDivisionOperators<TSelf, TSelf, TSelf>, IEqualityOperators<TSelf, TSelf>, IEquatable<TSelf>, IFormattable, IIncrementOperators<TSelf>, IMultiplicativeIdentity<TSelf, TSelf>, IMultiplyOperators<TSelf, TSelf, TSelf>, IParsable<TSelf>, ISpanFormattable, ISpanParsable<TSelf>, ISubtractionOperators<TSelf, TSelf, TSelf>, IUnaryNegationOperators<TSelf, TSelf>, IUnaryPlusOperators<TSelf, TSelf> where TSelf : INumberBase<TSelf> {
++        static abstract int Radix { get; }
++        static abstract TSelf Abs(TSelf value);
++        static TSelf CreateChecked<TOther>(TOther value);
++        static TSelf CreateSaturating<TOther>(TOther value);
++        static TSelf CreateTruncating<TOther>(TOther value);
++        static abstract bool IsCanonical(TSelf value);
++        static abstract bool IsComplexNumber(TSelf value);
++        static abstract bool IsEvenInteger(TSelf value);
++        static abstract bool IsFinite(TSelf value);
++        static abstract bool IsImaginaryNumber(TSelf value);
++        static abstract bool IsInfinity(TSelf value);
++        static abstract bool IsInteger(TSelf value);
++        static abstract bool IsNaN(TSelf value);
++        static abstract bool IsNegative(TSelf value);
++        static abstract bool IsNegativeInfinity(TSelf value);
++        static abstract bool IsNormal(TSelf value);
++        static abstract bool IsOddInteger(TSelf value);
++        static abstract bool IsPositive(TSelf value);
++        static abstract bool IsPositiveInfinity(TSelf value);
++        static abstract bool IsRealNumber(TSelf value);
++        static abstract bool IsSubnormal(TSelf value);
++        static abstract bool IsZero(TSelf value);
++        static abstract TSelf MaxMagnitude(TSelf x, TSelf y);
++        static abstract TSelf MaxMagnitudeNumber(TSelf x, TSelf y);
++        static abstract TSelf MinMagnitude(TSelf x, TSelf y);
++        static abstract TSelf MinMagnitudeNumber(TSelf x, TSelf y);
++        static abstract TSelf Parse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider);
++        static abstract TSelf Parse(string s, NumberStyles style, IFormatProvider? provider);
++        static abstract bool TryConvertFromChecked<TOther>(TOther value, out TSelf? result);
++        static abstract bool TryConvertFromSaturating<TOther>(TOther value, out TSelf? result);
++        static abstract bool TryConvertFromTruncating<TOther>(TOther value, out TSelf? result);
++        static abstract bool TryConvertToChecked<TOther>(TSelf value, out TOther? result);
++        static abstract bool TryConvertToSaturating<TOther>(TSelf value, out TOther? result);
++        static abstract bool TryConvertToTruncating<TOther>(TSelf value, out TOther? result);
++        static abstract bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider, out TSelf result);
++        static abstract bool TryParse(string? s, NumberStyles style, IFormatProvider? provider, out TSelf result);
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Reflection.Emit.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Reflection.Emit.md
new file mode 100644
index 00000000..7ae5d108
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Reflection.Emit.md
@@ -0,0 +1,14 @@
+# System.Reflection.Emit
+
+``` diff
+ namespace System.Reflection.Emit {
+     public sealed class AssemblyBuilder : Assembly {
+         public override string? CodeBase { get; }
+     }
+     public class ModuleBuilder : Module {
+         public override string FullyQualifiedName { get; }
+         public override string Name { get; }
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Reflection.Metadata.Ecma335.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Reflection.Metadata.Ecma335.md
new file mode 100644
index 00000000..12659e0c
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Reflection.Metadata.Ecma335.md
@@ -0,0 +1,17 @@
+# System.Reflection.Metadata.Ecma335
+
+``` diff
+ namespace System.Reflection.Metadata.Ecma335 {
+     public readonly struct BlobEncoder {
++        public FieldTypeEncoder Field();
+     }
++    public readonly struct FieldTypeEncoder {
++        public FieldTypeEncoder(BlobBuilder builder);
++        public BlobBuilder Builder { get; }
++        public CustomModifiersEncoder CustomModifiers();
++        public SignatureTypeEncoder Type(bool isByRef = false);
++        public void TypedReference();
++    }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Runtime.CompilerServices.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Runtime.CompilerServices.md
new file mode 100644
index 00000000..b0524c1f
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Runtime.CompilerServices.md
@@ -0,0 +1,10 @@
+# System.Runtime.CompilerServices
+
+``` diff
+ namespace System.Runtime.CompilerServices {
+     public static class RuntimeFeature {
++        public const string NumericIntPtr = "NumericIntPtr";
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Runtime.InteropServices.Marshalling.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Runtime.InteropServices.Marshalling.md
new file mode 100644
index 00000000..49642ce1
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Runtime.InteropServices.Marshalling.md
@@ -0,0 +1,104 @@
+# System.Runtime.InteropServices.Marshalling
+
+``` diff
++namespace System.Runtime.InteropServices.Marshalling {
++    public ref struct AnsiStringMarshaller {
++        public AnsiStringMarshaller(string? str);
++        public AnsiStringMarshaller(string? str, Span<byte> buffer);
++        public void FreeNative();
++        public unsafe void FromNativeValue(byte* value);
++        public string? ToManaged();
++        public unsafe byte* ToNativeValue();
++    }
++    public ref struct ArrayMarshaller<T> {
++        public ArrayMarshaller(int sizeOfNativeElement);
++        public ArrayMarshaller(T[]? array, int sizeOfNativeElement);
++        public ArrayMarshaller(T[]? array, Span<byte> buffer, int sizeOfNativeElement);
++        public void FreeNative();
++        public unsafe void FromNativeValue(byte* value);
++        public Span<T> GetManagedValuesDestination(int length);
++        public ReadOnlySpan<T> GetManagedValuesSource();
++        public Span<byte> GetNativeValuesDestination();
++        public ReadOnlySpan<byte> GetNativeValuesSource(int length);
++        public ref byte GetPinnableReference();
++        public T[]? ToManaged();
++        public unsafe byte* ToNativeValue();
++    }
++    public ref struct BStrStringMarshaller {
++        public BStrStringMarshaller(string? str);
++        public BStrStringMarshaller(string? str, Span<ushort> buffer);
++        public void FreeNative();
++        public unsafe void FromNativeValue(void* value);
++        public string? ToManaged();
++        public unsafe void* ToNativeValue();
++    }
++    public sealed class CustomTypeMarshallerAttribute : Attribute {
++        public CustomTypeMarshallerAttribute(Type managedType, CustomTypeMarshallerKind marshallerKind = CustomTypeMarshallerKind.Value);
++        public int BufferSize { get; set; }
++        public CustomTypeMarshallerDirection Direction { get; set; }
++        public CustomTypeMarshallerFeatures Features { get; set; }
++        public Type ManagedType { get; }
++        public CustomTypeMarshallerKind MarshallerKind { get; }
++        public struct GenericPlaceholder
++    }
++    public enum CustomTypeMarshallerDirection {
++        In = 1,
++        None = 0,
++        Out = 2,
++        Ref = 3,
++    }
++    public enum CustomTypeMarshallerFeatures {
++        CallerAllocatedBuffer = 2,
++        None = 0,
++        TwoStageMarshalling = 4,
++        UnmanagedResources = 1,
++    }
++    public enum CustomTypeMarshallerKind {
++        LinearCollection = 1,
++        Value = 0,
++    }
++    public sealed class MarshalUsingAttribute : Attribute {
++        public const string ReturnsCountValue = "return-value";
++        public MarshalUsingAttribute();
++        public MarshalUsingAttribute(Type nativeType);
++        public int ConstantElementCount { get; set; }
++        public string CountElementName { get; set; }
++        public int ElementIndirectionDepth { get; set; }
++        public Type? NativeType { get; }
++    }
++    public sealed class NativeMarshallingAttribute : Attribute {
++        public NativeMarshallingAttribute(Type nativeType);
++        public Type NativeType { get; }
++    }
++    public ref struct PointerArrayMarshaller<T> where T : struct {
++        public PointerArrayMarshaller(int sizeOfNativeElement);
++        public PointerArrayMarshaller(T*[]? array, int sizeOfNativeElement);
++        public PointerArrayMarshaller(T*[]? array, Span<byte> buffer, int sizeOfNativeElement);
++        public void FreeNative();
++        public unsafe void FromNativeValue(byte* value);
++        public Span<IntPtr> GetManagedValuesDestination(int length);
++        public ReadOnlySpan<IntPtr> GetManagedValuesSource();
++        public Span<byte> GetNativeValuesDestination();
++        public ReadOnlySpan<byte> GetNativeValuesSource(int length);
++        public ref byte GetPinnableReference();
++        public T*[]? ToManaged();
++        public unsafe byte* ToNativeValue();
++    }
++    public ref struct Utf16StringMarshaller {
++        public Utf16StringMarshaller(string? str);
++        public void FreeNative();
++        public unsafe void FromNativeValue(void* value);
++        public string? ToManaged();
++        public unsafe void* ToNativeValue();
++    }
++    public ref struct Utf8StringMarshaller {
++        public Utf8StringMarshaller(string? str);
++        public Utf8StringMarshaller(string? str, Span<byte> buffer);
++        public void FreeNative();
++        public unsafe void FromNativeValue(byte* value);
++        public string? ToManaged();
++        public unsafe byte* ToNativeValue();
++    }
++}
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Runtime.InteropServices.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Runtime.InteropServices.md
new file mode 100644
index 00000000..203cb608
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Runtime.InteropServices.md
@@ -0,0 +1,160 @@
+# System.Runtime.InteropServices
+
+``` diff
+ namespace System.Runtime.InteropServices {
+-    public ref struct AnsiStringMarshaller {
+-        public AnsiStringMarshaller(string? str);
+-        public AnsiStringMarshaller(string? str, Span<byte> buffer);
+-        public void FreeNative();
+-        public unsafe void FromNativeValue(byte* value);
+-        public string? ToManaged();
+-        public unsafe byte* ToNativeValue();
+-    }
+-    public ref struct ArrayMarshaller<T> {
+-        public ArrayMarshaller(int sizeOfNativeElement);
+-        public ArrayMarshaller(T[]? array, int sizeOfNativeElement);
+-        public ArrayMarshaller(T[]? array, Span<byte> buffer, int sizeOfNativeElement);
+-        public void FreeNative();
+-        public unsafe void FromNativeValue(byte* value);
+-        public Span<T> GetManagedValuesDestination(int length);
+-        public ReadOnlySpan<T> GetManagedValuesSource();
+-        public Span<byte> GetNativeValuesDestination();
+-        public ReadOnlySpan<byte> GetNativeValuesSource(int length);
+-        public ref byte GetPinnableReference();
+-        public T[]? ToManaged();
+-        public unsafe byte* ToNativeValue();
+-    }
+-    public sealed class CustomTypeMarshallerAttribute : Attribute {
+-        public CustomTypeMarshallerAttribute(Type managedType, CustomTypeMarshallerKind marshallerKind = CustomTypeMarshallerKind.Value);
+-        public int BufferSize { get; set; }
+-        public CustomTypeMarshallerDirection Direction { get; set; }
+-        public CustomTypeMarshallerFeatures Features { get; set; }
+-        public Type ManagedType { get; }
+-        public CustomTypeMarshallerKind MarshallerKind { get; }
+-        public struct GenericPlaceholder
+-    }
+-    public enum CustomTypeMarshallerDirection {
+-        In = 1,
+-        None = 0,
+-        Out = 2,
+-        Ref = 3,
+-    }
+-    public enum CustomTypeMarshallerFeatures {
+-        CallerAllocatedBuffer = 2,
+-        None = 0,
+-        TwoStageMarshalling = 4,
+-        UnmanagedResources = 1,
+-    }
+-    public enum CustomTypeMarshallerKind {
+-        LinearCollection = 1,
+-        Value = 0,
+-    }
+-    public sealed class MarshalUsingAttribute : Attribute {
+-        public const string ReturnsCountValue = "return-value";
+-        public MarshalUsingAttribute();
+-        public MarshalUsingAttribute(Type nativeType);
+-        public int ConstantElementCount { get; set; }
+-        public string CountElementName { get; set; }
+-        public int ElementIndirectionDepth { get; set; }
+-        public Type? NativeType { get; }
+-    }
+-    public sealed class NativeMarshallingAttribute : Attribute {
+-        public NativeMarshallingAttribute(Type nativeType);
+-        public Type NativeType { get; }
+-    }
+     public static class NativeMemory {
++        public unsafe static void ZeroMemory(void* ptr, UIntPtr byteCount);
+     }
+     public readonly struct NFloat : IAdditionOperators<NFloat, NFloat, NFloat>, IAdditiveIdentity<NFloat, NFloat>, IBinaryFloatingPointIeee754<NFloat>, IBinaryNumber<NFloat>, IBitwiseOperators<NFloat, NFloat, NFloat>, IComparable, IComparable<NFloat>, IComparisonOperators<NFloat, NFloat>, IDecrementOperators<NFloat>, IDivisionOperators<NFloat, NFloat, NFloat>, IEqualityOperators<NFloat, NFloat>, IEquatable<NFloat>, IExponentialFunctions<NFloat>, IFloatingPoint<NFloat>, IFloatingPointIeee754<NFloat>, IFormattable, IHyperbolicFunctions<NFloat>, IIncrementOperators<NFloat>, ILogarithmicFunctions<NFloat>, IMinMaxValue<NFloat>, IModulusOperators<NFloat, NFloat, NFloat>, IMultiplicativeIdentity<NFloat, NFloat>, IMultiplyOperators<NFloat, NFloat, NFloat>, INumber<NFloat>, INumberBase<NFloat>, IParsable<NFloat>, IPowerFunctions<NFloat>, IRootFunctions<NFloat>, ISignedNumber<NFloat>, ISpanFormattable, ISpanParsable<NFloat>, ISubtractionOperators<NFloat, NFloat, NFloat>, ITrigonometricFunctions<NFloat>, IUnaryNegationOperators<NFloat, NFloat>, IUnaryPlusOperators<NFloat, NFloat> {
++        static int System.Numerics.INumberBase<System.Runtime.InteropServices.NFloat>.Radix { get; }
+-        public static NFloat CreateChecked<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static NFloat CreateSaturating<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static NFloat CreateTruncating<TOther>(TOther value) where TOther : INumber<TOther>;
++        public static NFloat Exp10(NFloat x);
++        public static NFloat Exp10M1(NFloat x);
++        public static NFloat Exp2(NFloat x);
++        public static NFloat Exp2M1(NFloat x);
++        public static NFloat ExpM1(NFloat x);
++        public static bool IsEvenInteger(NFloat value);
++        public static bool IsInteger(NFloat value);
++        public static bool IsOddInteger(NFloat value);
++        public static bool IsPositive(NFloat value);
++        public static bool IsRealNumber(NFloat value);
++        public static NFloat Log10P1(NFloat x);
++        public static NFloat Log2P1(NFloat x);
++        public static NFloat LogP1(NFloat x);
++        public static NFloat MaxMagnitudeNumber(NFloat x, NFloat y);
++        public static NFloat MaxNumber(NFloat x, NFloat y);
++        public static NFloat MinMagnitudeNumber(NFloat x, NFloat y);
++        public static NFloat MinNumber(NFloat x, NFloat y);
++        public static explicit operator checked byte (NFloat value);
++        public static explicit operator checked char (NFloat value);
++        public static explicit operator checked short (NFloat value);
++        public static explicit operator checked int (NFloat value);
++        public static explicit operator checked long (NFloat value);
++        public static explicit operator checked Int128 (NFloat value);
++        public static explicit operator checked IntPtr (NFloat value);
++        public static explicit operator checked sbyte (NFloat value);
++        public static explicit operator checked ushort (NFloat value);
++        public static explicit operator checked uint (NFloat value);
++        public static explicit operator checked ulong (NFloat value);
++        public static explicit operator checked UInt128 (NFloat value);
++        public static explicit operator checked UIntPtr (NFloat value);
++        public static explicit operator NFloat (Int128 value);
++        public static explicit operator Half (NFloat value);
++        public static explicit operator Int128 (NFloat value);
++        public static explicit operator UInt128 (NFloat value);
++        public static explicit operator NFloat (UInt128 value);
++        public static implicit operator NFloat (Half value);
+-        long IFloatingPoint<NFloat>.GetExponentShortestBitLength();
++        int IFloatingPoint<NFloat>.GetExponentShortestBitLength();
+-        long IFloatingPoint<NFloat>.GetSignificandBitLength();
++        int IFloatingPoint<NFloat>.GetSignificandBitLength();
++        bool IFloatingPoint<NFloat>.TryWriteExponentBigEndian(Span<byte> destination, out int bytesWritten);
++        bool IFloatingPoint<NFloat>.TryWriteSignificandBigEndian(Span<byte> destination, out int bytesWritten);
++        static bool INumberBase<NFloat>.IsCanonical(NFloat value);
++        static bool INumberBase<NFloat>.IsComplexNumber(NFloat value);
++        static bool INumberBase<NFloat>.IsImaginaryNumber(NFloat value);
++        static bool INumberBase<NFloat>.IsZero(NFloat value);
++        static bool INumberBase<NFloat>.TryConvertFromChecked<TOther>(TOther value, out NFloat result);
++        static bool INumberBase<NFloat>.TryConvertFromSaturating<TOther>(TOther value, out NFloat result);
++        static bool INumberBase<NFloat>.TryConvertFromTruncating<TOther>(TOther value, out NFloat result);
++        static bool INumberBase<NFloat>.TryConvertToChecked<TOther>(NFloat value, out TOther result);
++        static bool INumberBase<NFloat>.TryConvertToSaturating<TOther>(NFloat value, out TOther result);
++        static bool INumberBase<NFloat>.TryConvertToTruncating<TOther>(NFloat value, out TOther result);
+-        public static bool TryCreate<TOther>(TOther value, out NFloat result) where TOther : INumber<TOther>;
+     }
+-    public ref struct PointerArrayMarshaller<T> where T : struct {
+-        public PointerArrayMarshaller(int sizeOfNativeElement);
+-        public PointerArrayMarshaller(T*[]? array, int sizeOfNativeElement);
+-        public PointerArrayMarshaller(T*[]? array, Span<byte> buffer, int sizeOfNativeElement);
+-        public void FreeNative();
+-        public unsafe void FromNativeValue(byte* value);
+-        public Span<IntPtr> GetManagedValuesDestination(int length);
+-        public ReadOnlySpan<IntPtr> GetManagedValuesSource();
+-        public Span<byte> GetNativeValuesDestination();
+-        public ReadOnlySpan<byte> GetNativeValuesSource(int length);
+-        public ref byte GetPinnableReference();
+-        public T*[]? ToManaged();
+-        public unsafe byte* ToNativeValue();
+-    }
+-    public ref struct Utf16StringMarshaller {
+-        public Utf16StringMarshaller(string? str);
+-        public Utf16StringMarshaller(string? str, Span<ushort> buffer);
+-        public void FreeNative();
+-        public unsafe void FromNativeValue(ushort* value);
+-        public ref ushort GetPinnableReference();
+-        public string? ToManaged();
+-        public unsafe ushort* ToNativeValue();
+-    }
+-    public ref struct Utf8StringMarshaller {
+-        public Utf8StringMarshaller(string? str);
+-        public Utf8StringMarshaller(string? str, Span<byte> buffer);
+-        public void FreeNative();
+-        public unsafe void FromNativeValue(byte* value);
+-        public string? ToManaged();
+-        public unsafe byte* ToNativeValue();
+-    }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Runtime.Intrinsics.X86.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Runtime.Intrinsics.X86.md
new file mode 100644
index 00000000..23a3cf0d
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Runtime.Intrinsics.X86.md
@@ -0,0 +1,14 @@
+# System.Runtime.Intrinsics.X86
+
+``` diff
+ namespace System.Runtime.Intrinsics.X86 {
++    public abstract class X86Serialize : X86Base {
++        public static new bool IsSupported { get; }
++        public static void Serialize();
++        public new abstract class X64 : X86Base.X64 {
++            public static new bool IsSupported { get; }
++        }
++    }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Runtime.Intrinsics.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Runtime.Intrinsics.md
new file mode 100644
index 00000000..33b6ee81
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Runtime.Intrinsics.md
@@ -0,0 +1,40 @@
+# System.Runtime.Intrinsics
+
+``` diff
+ namespace System.Runtime.Intrinsics {
+     public static class Vector128 {
++        public static Vector128<byte> Shuffle(Vector128<byte> vector, Vector128<byte> indices);
++        public static Vector128<double> Shuffle(Vector128<double> vector, Vector128<long> indices);
++        public static Vector128<short> Shuffle(Vector128<short> vector, Vector128<short> indices);
++        public static Vector128<int> Shuffle(Vector128<int> vector, Vector128<int> indices);
++        public static Vector128<long> Shuffle(Vector128<long> vector, Vector128<long> indices);
++        public static Vector128<sbyte> Shuffle(Vector128<sbyte> vector, Vector128<sbyte> indices);
++        public static Vector128<float> Shuffle(Vector128<float> vector, Vector128<int> indices);
++        public static Vector128<ushort> Shuffle(Vector128<ushort> vector, Vector128<ushort> indices);
++        public static Vector128<uint> Shuffle(Vector128<uint> vector, Vector128<uint> indices);
++        public static Vector128<ulong> Shuffle(Vector128<ulong> vector, Vector128<ulong> indices);
+     }
+     public static class Vector256 {
++        public static Vector256<byte> Shuffle(Vector256<byte> vector, Vector256<byte> indices);
++        public static Vector256<double> Shuffle(Vector256<double> vector, Vector256<long> indices);
++        public static Vector256<short> Shuffle(Vector256<short> vector, Vector256<short> indices);
++        public static Vector256<int> Shuffle(Vector256<int> vector, Vector256<int> indices);
++        public static Vector256<long> Shuffle(Vector256<long> vector, Vector256<long> indices);
++        public static Vector256<sbyte> Shuffle(Vector256<sbyte> vector, Vector256<sbyte> indices);
++        public static Vector256<float> Shuffle(Vector256<float> vector, Vector256<int> indices);
++        public static Vector256<ushort> Shuffle(Vector256<ushort> vector, Vector256<ushort> indices);
++        public static Vector256<uint> Shuffle(Vector256<uint> vector, Vector256<uint> indices);
++        public static Vector256<ulong> Shuffle(Vector256<ulong> vector, Vector256<ulong> indices);
+     }
+     public static class Vector64 {
++        public static Vector64<byte> Shuffle(Vector64<byte> vector, Vector64<byte> indices);
++        public static Vector64<short> Shuffle(Vector64<short> vector, Vector64<short> indices);
++        public static Vector64<int> Shuffle(Vector64<int> vector, Vector64<int> indices);
++        public static Vector64<sbyte> Shuffle(Vector64<sbyte> vector, Vector64<sbyte> indices);
++        public static Vector64<float> Shuffle(Vector64<float> vector, Vector64<int> indices);
++        public static Vector64<ushort> Shuffle(Vector64<ushort> vector, Vector64<ushort> indices);
++        public static Vector64<uint> Shuffle(Vector64<uint> vector, Vector64<uint> indices);
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Security.Cryptography.X509Certificates.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Security.Cryptography.X509Certificates.md
new file mode 100644
index 00000000..568c1008
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Security.Cryptography.X509Certificates.md
@@ -0,0 +1,18 @@
+# System.Security.Cryptography.X509Certificates
+
+``` diff
+ namespace System.Security.Cryptography.X509Certificates {
++    public sealed class X509AuthorityInformationAccessExtension : X509Extension {
++        public X509AuthorityInformationAccessExtension();
++        public X509AuthorityInformationAccessExtension(byte[] rawData, bool critical = false);
++        public X509AuthorityInformationAccessExtension(IEnumerable<string>? ocspUris, IEnumerable<string>? caIssuersUris, bool critical = false);
++        public X509AuthorityInformationAccessExtension(ReadOnlySpan<byte> rawData, bool critical = false);
++        public override void CopyFrom(AsnEncodedData asnEncodedData);
++        public IEnumerable<string> EnumerateCAIssuersUris();
++        public IEnumerable<string> EnumerateOcspUris();
++        public IEnumerable<string> EnumerateUris(Oid accessMethodOid);
++        public IEnumerable<string> EnumerateUris(string accessMethodOid);
++    }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Security.Cryptography.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Security.Cryptography.md
new file mode 100644
index 00000000..41feda09
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Security.Cryptography.md
@@ -0,0 +1,26 @@
+# System.Security.Cryptography
+
+``` diff
+ namespace System.Security.Cryptography {
+     public sealed class DSACng : DSA {
+-        protected override byte[] HashData(byte[] data, int offset, int count, HashAlgorithmName hashAlgorithm);
+-        protected override byte[] HashData(Stream data, HashAlgorithmName hashAlgorithm);
+-        protected override bool TryHashData(ReadOnlySpan<byte> source, Span<byte> destination, HashAlgorithmName hashAlgorithm, out int bytesWritten);
+     }
+     public sealed class ECDsaCng : ECDsa {
+-        protected override byte[] HashData(byte[] data, int offset, int count, HashAlgorithmName hashAlgorithm);
+-        protected override byte[] HashData(Stream data, HashAlgorithmName hashAlgorithm);
+-        protected override bool TryHashData(ReadOnlySpan<byte> source, Span<byte> destination, HashAlgorithmName hashAlgorithm, out int bytesWritten);
+     }
+     public sealed class RSACng : RSA {
+-        protected override byte[] HashData(byte[] data, int offset, int count, HashAlgorithmName hashAlgorithm);
+-        protected override byte[] HashData(Stream data, HashAlgorithmName hashAlgorithm);
+-        protected override bool TryHashData(ReadOnlySpan<byte> data, Span<byte> destination, HashAlgorithmName hashAlgorithm, out int bytesWritten);
+     }
+     public sealed class RSACryptoServiceProvider : RSA, ICspAsymmetricAlgorithm {
+-        protected override byte[] HashData(byte[] data, int offset, int count, HashAlgorithmName hashAlgorithm);
+-        protected override byte[] HashData(Stream data, HashAlgorithmName hashAlgorithm);
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Text.Json.Nodes.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Text.Json.Nodes.md
new file mode 100644
index 00000000..7951d35e
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Text.Json.Nodes.md
@@ -0,0 +1,13 @@
+# System.Text.Json.Nodes
+
+``` diff
+ namespace System.Text.Json.Nodes {
+     public sealed class JsonArray : JsonNode, ICollection<JsonNode?>, IEnumerable, IEnumerable<JsonNode?>, IList<JsonNode?> {
+         public void Add<T>(T value);
+     }
+     public abstract class JsonValue : JsonNode {
+         public static JsonValue Create<T>(T value, JsonNodeOptions? options = default(JsonNodeOptions?));
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Text.Json.Serialization.Metadata.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Text.Json.Serialization.Metadata.md
new file mode 100644
index 00000000..82147c0f
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Text.Json.Serialization.Metadata.md
@@ -0,0 +1,13 @@
+# System.Text.Json.Serialization.Metadata
+
+``` diff
+ namespace System.Text.Json.Serialization.Metadata {
+     public static class JsonMetadataServices {
++        public static JsonConverter<DateOnly> DateOnlyConverter { get; }
++        public static JsonConverter<JsonDocument> JsonDocumentConverter { get; }
++        public static JsonConverter<TimeOnly> TimeOnlyConverter { get; }
++        public static JsonTypeInfo<TCollection> CreateIAsyncEnumerableInfo<TCollection, TElement>(JsonSerializerOptions options, JsonCollectionInfoValues<TCollection> collectionInfo) where TCollection : IAsyncEnumerable<TElement>;
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Text.Json.Serialization.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Text.Json.Serialization.md
new file mode 100644
index 00000000..eec8017d
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Text.Json.Serialization.md
@@ -0,0 +1,56 @@
+# System.Text.Json.Serialization
+
+``` diff
+ namespace System.Text.Json.Serialization {
+     public class JsonDerivedTypeAttribute : JsonAttribute {
++        public JsonDerivedTypeAttribute(Type derivedType, int typeDiscriminator);
+-        public JsonDerivedTypeAttribute(Type derivedType, string typeDiscriminatorId);
++        public JsonDerivedTypeAttribute(Type derivedType, string typeDiscriminator);
++        public object? TypeDiscriminator { get; }
+-        public string? TypeDiscriminatorId { get; }
+     }
+     public sealed class JsonPolymorphicAttribute : JsonAttribute {
+-        public string CustomTypeDiscriminatorPropertyName { get; set; }
++        public string TypeDiscriminatorPropertyName { get; set; }
+     }
+-    public class JsonPolymorphicTypeConfiguration : ICollection<(Type, string?)>, IEnumerable, IEnumerable<(Type, string?)> {
++    public class JsonPolymorphicTypeConfiguration : ICollection<(Type, object?)>, IEnumerable, IEnumerable<(Type, object?)> {
+-        public string? CustomTypeDiscriminatorPropertyName { get; set; }
++        int ICollection<(Type, object?)>.Count { get; }
++        bool ICollection<(Type, object?)>.IsReadOnly { get; }
+-        int ICollection<(Type, string?)>.Count { get; }
+-        bool ICollection<(Type, string?)>.IsReadOnly { get; }
++        public string? TypeDiscriminatorPropertyName { get; set; }
++        void ICollection<(Type, object?)>.Add((Type DerivedType, object TypeDiscriminator) item);
++        void ICollection<(Type, object?)>.Clear();
++        bool ICollection<(Type, object?)>.Contains((Type DerivedType, object TypeDiscriminator) item);
++        void ICollection<(Type, object?)>.CopyTo((Type DerivedType, object TypeDiscriminator)[] array, int arrayIndex);
++        bool ICollection<(Type, object?)>.Remove((Type DerivedType, object TypeDiscriminator) item);
+-        void ICollection<(Type, string?)>.Add((Type DerivedType, string TypeDiscriminatorId) item);
+-        void ICollection<(Type, string?)>.Clear();
+-        bool ICollection<(Type, string?)>.Contains((Type DerivedType, string TypeDiscriminatorId) item);
+-        void ICollection<(Type, string?)>.CopyTo((Type DerivedType, string TypeDiscriminatorId)[] array, int arrayIndex);
+-        bool ICollection<(Type, string?)>.Remove((Type DerivedType, string TypeDiscriminatorId) item);
++        IEnumerator<(Type DerivedType, object TypeDiscriminator)> IEnumerable<(Type, object?)>.GetEnumerator();
+-        IEnumerator<(Type DerivedType, string TypeDiscriminatorId)> IEnumerable<(Type, string?)>.GetEnumerator();
++        public JsonPolymorphicTypeConfiguration WithDerivedType(Type derivedType);
++        public JsonPolymorphicTypeConfiguration WithDerivedType(Type derivedType, int typeDiscriminator);
+-        public JsonPolymorphicTypeConfiguration WithDerivedType(Type derivedType, string? typeDiscriminatorId = null);
++        public JsonPolymorphicTypeConfiguration WithDerivedType(Type derivedType, string typeDiscriminator);
+     }
+     public class JsonPolymorphicTypeConfiguration<TBaseType> : JsonPolymorphicTypeConfiguration where TBaseType : class {
++        public JsonPolymorphicTypeConfiguration<TBaseType> WithDerivedType<TDerivedType>() where TDerivedType : TBaseType;
++        public JsonPolymorphicTypeConfiguration<TBaseType> WithDerivedType<TDerivedType>(int typeDiscriminator) where TDerivedType : TBaseType;
+-        public JsonPolymorphicTypeConfiguration<TBaseType> WithDerivedType<TDerivedType>(string? typeDiscriminatorId = null) where TDerivedType : TBaseType;
++        public JsonPolymorphicTypeConfiguration<TBaseType> WithDerivedType<TDerivedType>(string typeDiscriminator) where TDerivedType : TBaseType;
+     }
+     public class JsonStringEnumConverter : JsonConverterFactory
+     public enum JsonUnknownDerivedTypeHandling {
+-        FallbackToBaseType = 1,
++        FallBackToBaseType = 1,
+-        FallbackToNearestAncestor = 2,
++        FallBackToNearestAncestor = 2,
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Text.Json.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Text.Json.md
new file mode 100644
index 00000000..d210642e
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Text.Json.md
@@ -0,0 +1,53 @@
+# System.Text.Json
+
+``` diff
+ namespace System.Text.Json {
+     public static class JsonSerializer {
+         public static object? Deserialize(Stream utf8Json, Type returnType, JsonSerializerOptions? options = null);
+         public static object? Deserialize(ReadOnlySpan<byte> utf8Json, Type returnType, JsonSerializerOptions? options = null);
+         public static object? Deserialize(ReadOnlySpan<char> json, Type returnType, JsonSerializerOptions? options = null);
+         public static object? Deserialize(string json, Type returnType, JsonSerializerOptions? options = null);
+         public static object? Deserialize(this JsonDocument document, Type returnType, JsonSerializerOptions? options = null);
+         public static object? Deserialize(this JsonElement element, Type returnType, JsonSerializerOptions? options = null);
+         public static object? Deserialize(this JsonNode? node, Type returnType, JsonSerializerOptions? options = null);
+         public static object? Deserialize(ref Utf8JsonReader reader, Type returnType, JsonSerializerOptions? options = null);
+         public static TValue? Deserialize<TValue>(Stream utf8Json, JsonSerializerOptions? options = null);
+         public static TValue? Deserialize<TValue>(ReadOnlySpan<byte> utf8Json, JsonSerializerOptions? options = null);
+         public static TValue? Deserialize<TValue>(ReadOnlySpan<char> json, JsonSerializerOptions? options = null);
+         public static TValue? Deserialize<TValue>(string json, JsonSerializerOptions? options = null);
+         public static TValue? Deserialize<TValue>(this JsonDocument document, JsonSerializerOptions? options = null);
+         public static TValue? Deserialize<TValue>(this JsonElement element, JsonSerializerOptions? options = null);
+         public static TValue? Deserialize<TValue>(this JsonNode? node, JsonSerializerOptions? options = null);
+         public static TValue? Deserialize<TValue>(ref Utf8JsonReader reader, JsonSerializerOptions? options = null);
+         public static ValueTask<object?> DeserializeAsync(Stream utf8Json, Type returnType, JsonSerializerOptions? options = null, CancellationToken cancellationToken = default(CancellationToken));
+         public static ValueTask<TValue?> DeserializeAsync<TValue>(Stream utf8Json, JsonSerializerOptions? options = null, CancellationToken cancellationToken = default(CancellationToken));
+         public static IAsyncEnumerable<TValue?> DeserializeAsyncEnumerable<TValue>(Stream utf8Json, JsonSerializerOptions? options = null, CancellationToken cancellationToken = default(CancellationToken));
++        public static IAsyncEnumerable<TValue?> DeserializeAsyncEnumerable<TValue>(Stream utf8Json, JsonTypeInfo<TValue> jsonTypeInfo, CancellationToken cancellationToken = default(CancellationToken));
+         public static void Serialize(Stream utf8Json, object? value, Type inputType, JsonSerializerOptions? options = null);
+         public static string Serialize(object? value, Type inputType, JsonSerializerOptions? options = null);
+         public static void Serialize(Utf8JsonWriter writer, object? value, Type inputType, JsonSerializerOptions? options = null);
+         public static void Serialize<TValue>(Stream utf8Json, TValue value, JsonSerializerOptions? options = null);
+         public static void Serialize<TValue>(Utf8JsonWriter writer, TValue value, JsonSerializerOptions? options = null);
+         public static string Serialize<TValue>(TValue value, JsonSerializerOptions? options = null);
+         public static Task SerializeAsync(Stream utf8Json, object? value, Type inputType, JsonSerializerOptions? options = null, CancellationToken cancellationToken = default(CancellationToken));
+         public static Task SerializeAsync<TValue>(Stream utf8Json, TValue value, JsonSerializerOptions? options = null, CancellationToken cancellationToken = default(CancellationToken));
+         public static JsonDocument SerializeToDocument(object? value, Type inputType, JsonSerializerOptions? options = null);
+         public static JsonDocument SerializeToDocument<TValue>(TValue value, JsonSerializerOptions? options = null);
+         public static JsonElement SerializeToElement(object? value, Type inputType, JsonSerializerOptions? options = null);
+         public static JsonElement SerializeToElement<TValue>(TValue value, JsonSerializerOptions? options = null);
+         public static JsonNode? SerializeToNode(object? value, Type inputType, JsonSerializerOptions? options = null);
+         public static JsonNode? SerializeToNode<TValue>(TValue value, JsonSerializerOptions? options = null);
+         public static byte[] SerializeToUtf8Bytes(object? value, Type inputType, JsonSerializerOptions? options = null);
+         public static byte[] SerializeToUtf8Bytes<TValue>(TValue value, JsonSerializerOptions? options = null);
+     }
+     public sealed class JsonSerializerOptions {
+         public JsonConverter GetConverter(Type typeToConvert);
+     }
+     public ref struct Utf8JsonReader {
++        public bool ValueIsEscaped { get; }
++        public int CopyString(Span<byte> utf8Destination);
++        public int CopyString(Span<char> destination);
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Threading.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Threading.md
new file mode 100644
index 00000000..bfbb8116
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Threading.md
@@ -0,0 +1,11 @@
+# System.Threading
+
+``` diff
+ namespace System.Threading {
+     public static class Interlocked {
++        public static UIntPtr CompareExchange(ref UIntPtr location1, UIntPtr value, UIntPtr comparand);
++        public static UIntPtr Exchange(ref UIntPtr location1, UIntPtr value);
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.md
new file mode 100644
index 00000000..be7ad90d
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.md
@@ -0,0 +1,1118 @@
+# System
+
+``` diff
+ namespace System {
+     public readonly struct Byte : IAdditionOperators<byte, byte, byte>, IAdditiveIdentity<byte, byte>, IBinaryInteger<byte>, IBinaryNumber<byte>, IBitwiseOperators<byte, byte, byte>, IComparable, IComparable<byte>, IComparisonOperators<byte, byte>, IConvertible, IDecrementOperators<byte>, IDivisionOperators<byte, byte, byte>, IEqualityOperators<byte, byte>, IEquatable<byte>, IFormattable, IIncrementOperators<byte>, IMinMaxValue<byte>, IModulusOperators<byte, byte, byte>, IMultiplicativeIdentity<byte, byte>, IMultiplyOperators<byte, byte, byte>, INumber<byte>, INumberBase<byte>, IParsable<byte>, IShiftOperators<byte, byte>, ISpanFormattable, ISpanParsable<byte>, ISubtractionOperators<byte, byte, byte>, IUnaryNegationOperators<byte, byte>, IUnaryPlusOperators<byte, byte>, IUnsignedNumber<byte> {
++        static int System.Numerics.INumberBase<System.Byte>.Radix { get; }
+-        public static byte CreateChecked<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static byte CreateSaturating<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static byte CreateTruncating<TOther>(TOther value) where TOther : INumber<TOther>;
++        public static bool IsEvenInteger(byte value);
++        public static bool IsOddInteger(byte value);
+-        long IBinaryInteger<byte>.GetShortestBitLength();
++        int IBinaryInteger<byte>.GetShortestBitLength();
++        bool IBinaryInteger<byte>.TryWriteBigEndian(Span<byte> destination, out int bytesWritten);
+-        static byte INumber<byte>.Abs(byte value);
+-        static bool INumber<byte>.IsNegative(byte value);
+-        static byte INumber<byte>.MaxMagnitude(byte x, byte y);
++        static byte INumber<byte>.MaxNumber(byte x, byte y);
+-        static byte INumber<byte>.MinMagnitude(byte x, byte y);
++        static byte INumber<byte>.MinNumber(byte x, byte y);
++        static byte INumberBase<byte>.Abs(byte value);
++        static bool INumberBase<byte>.IsCanonical(byte value);
++        static bool INumberBase<byte>.IsComplexNumber(byte value);
++        static bool INumberBase<byte>.IsFinite(byte value);
++        static bool INumberBase<byte>.IsImaginaryNumber(byte value);
++        static bool INumberBase<byte>.IsInfinity(byte value);
++        static bool INumberBase<byte>.IsInteger(byte value);
++        static bool INumberBase<byte>.IsNaN(byte value);
++        static bool INumberBase<byte>.IsNegative(byte value);
++        static bool INumberBase<byte>.IsNegativeInfinity(byte value);
++        static bool INumberBase<byte>.IsNormal(byte value);
++        static bool INumberBase<byte>.IsPositive(byte value);
++        static bool INumberBase<byte>.IsPositiveInfinity(byte value);
++        static bool INumberBase<byte>.IsRealNumber(byte value);
++        static bool INumberBase<byte>.IsSubnormal(byte value);
++        static bool INumberBase<byte>.IsZero(byte value);
++        static byte INumberBase<byte>.MaxMagnitude(byte x, byte y);
++        static byte INumberBase<byte>.MaxMagnitudeNumber(byte x, byte y);
++        static byte INumberBase<byte>.MinMagnitude(byte x, byte y);
++        static byte INumberBase<byte>.MinMagnitudeNumber(byte x, byte y);
++        static bool INumberBase<byte>.TryConvertFromChecked<TOther>(TOther value, out byte result);
++        static bool INumberBase<byte>.TryConvertFromSaturating<TOther>(TOther value, out byte result);
++        static bool INumberBase<byte>.TryConvertFromTruncating<TOther>(TOther value, out byte result);
++        static bool INumberBase<byte>.TryConvertToChecked<TOther>(byte value, out TOther result);
++        static bool INumberBase<byte>.TryConvertToSaturating<TOther>(byte value, out TOther result);
++        static bool INumberBase<byte>.TryConvertToTruncating<TOther>(byte value, out TOther result);
+-        public static bool TryCreate<TOther>(TOther value, out byte result) where TOther : INumber<TOther>;
+     }
+     public readonly struct Char : IAdditionOperators<char, char, char>, IAdditiveIdentity<char, char>, IBinaryInteger<char>, IBinaryNumber<char>, IBitwiseOperators<char, char, char>, IComparable, IComparable<char>, IComparisonOperators<char, char>, IConvertible, IDecrementOperators<char>, IDivisionOperators<char, char, char>, IEqualityOperators<char, char>, IEquatable<char>, IFormattable, IIncrementOperators<char>, IMinMaxValue<char>, IModulusOperators<char, char, char>, IMultiplicativeIdentity<char, char>, IMultiplyOperators<char, char, char>, INumber<char>, INumberBase<char>, IParsable<char>, IShiftOperators<char, char>, ISpanFormattable, ISpanParsable<char>, ISubtractionOperators<char, char, char>, IUnaryNegationOperators<char, char>, IUnaryPlusOperators<char, char>, IUnsignedNumber<char> {
++        static int System.Numerics.INumberBase<System.Char>.Radix { get; }
+-        public static char Clamp(char value, char min, char max);
+-        public static char CreateChecked<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static char CreateSaturating<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static char CreateTruncating<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static (char Quotient, char Remainder) DivRem(char left, char right);
++        public static bool IsAsciiDigit(char c);
++        public static bool IsAsciiHexDigit(char c);
++        public static bool IsAsciiHexDigitLower(char c);
++        public static bool IsAsciiHexDigitUpper(char c);
++        public static bool IsAsciiLetter(char c);
++        public static bool IsAsciiLetterLower(char c);
++        public static bool IsAsciiLetterOrDigit(char c);
++        public static bool IsAsciiLetterUpper(char c);
++        public static bool IsBetween(char c, char minInclusive, char maxInclusive);
+-        public static bool IsPow2(char value);
+-        public static char LeadingZeroCount(char value);
+-        public static char Log2(char value);
+-        public static char Max(char x, char y);
+-        public static char Min(char x, char y);
+-        public static char PopCount(char value);
+-        public static char RotateLeft(char value, int rotateAmount);
+-        public static char RotateRight(char value, int rotateAmount);
+-        public static int Sign(char value);
++        static (char Quotient, char Remainder) IBinaryInteger<char>.DivRem(char left, char right);
+-        long IBinaryInteger<char>.GetShortestBitLength();
++        int IBinaryInteger<char>.GetShortestBitLength();
++        static char IBinaryInteger<char>.LeadingZeroCount(char value);
++        static char IBinaryInteger<char>.PopCount(char value);
++        static char IBinaryInteger<char>.RotateLeft(char value, int rotateAmount);
++        static char IBinaryInteger<char>.RotateRight(char value, int rotateAmount);
++        static char IBinaryInteger<char>.TrailingZeroCount(char value);
++        bool IBinaryInteger<char>.TryWriteBigEndian(Span<byte> destination, out int bytesWritten);
++        static bool IBinaryNumber<char>.IsPow2(char value);
++        static char IBinaryNumber<char>.Log2(char value);
+-        static char INumber<char>.Abs(char value);
++        static char INumber<char>.Clamp(char value, char min, char max);
+-        static bool INumber<char>.IsNegative(char value);
++        static char INumber<char>.Max(char x, char y);
+-        static char INumber<char>.MaxMagnitude(char x, char y);
++        static char INumber<char>.MaxNumber(char x, char y);
++        static char INumber<char>.Min(char x, char y);
+-        static char INumber<char>.MinMagnitude(char x, char y);
++        static char INumber<char>.MinNumber(char x, char y);
+-        static char INumber<char>.Parse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider);
+-        static char INumber<char>.Parse(string s, NumberStyles style, IFormatProvider provider);
++        static int INumber<char>.Sign(char value);
+-        static bool INumber<char>.TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider, out char result);
+-        static bool INumber<char>.TryParse(string s, NumberStyles style, IFormatProvider provider, out char result);
++        static char INumberBase<char>.Abs(char value);
++        static bool INumberBase<char>.IsCanonical(char value);
++        static bool INumberBase<char>.IsComplexNumber(char value);
++        static bool INumberBase<char>.IsEvenInteger(char value);
++        static bool INumberBase<char>.IsFinite(char value);
++        static bool INumberBase<char>.IsImaginaryNumber(char value);
++        static bool INumberBase<char>.IsInfinity(char value);
++        static bool INumberBase<char>.IsInteger(char value);
++        static bool INumberBase<char>.IsNaN(char value);
++        static bool INumberBase<char>.IsNegative(char value);
++        static bool INumberBase<char>.IsNegativeInfinity(char value);
++        static bool INumberBase<char>.IsNormal(char value);
++        static bool INumberBase<char>.IsOddInteger(char value);
++        static bool INumberBase<char>.IsPositive(char value);
++        static bool INumberBase<char>.IsPositiveInfinity(char value);
++        static bool INumberBase<char>.IsRealNumber(char value);
++        static bool INumberBase<char>.IsSubnormal(char value);
++        static bool INumberBase<char>.IsZero(char value);
++        static char INumberBase<char>.MaxMagnitude(char x, char y);
++        static char INumberBase<char>.MaxMagnitudeNumber(char x, char y);
++        static char INumberBase<char>.MinMagnitude(char x, char y);
++        static char INumberBase<char>.MinMagnitudeNumber(char x, char y);
++        static char INumberBase<char>.Parse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider);
++        static char INumberBase<char>.Parse(string s, NumberStyles style, IFormatProvider provider);
++        static bool INumberBase<char>.TryConvertFromChecked<TOther>(TOther value, out char result);
++        static bool INumberBase<char>.TryConvertFromSaturating<TOther>(TOther value, out char result);
++        static bool INumberBase<char>.TryConvertFromTruncating<TOther>(TOther value, out char result);
++        static bool INumberBase<char>.TryConvertToChecked<TOther>(char value, out TOther result);
++        static bool INumberBase<char>.TryConvertToSaturating<TOther>(char value, out TOther result);
++        static bool INumberBase<char>.TryConvertToTruncating<TOther>(char value, out TOther result);
++        static bool INumberBase<char>.TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider, out char result);
++        static bool INumberBase<char>.TryParse(string s, NumberStyles style, IFormatProvider provider, out char result);
+-        public static char TrailingZeroCount(char value);
+-        public static bool TryCreate<TOther>(TOther value, out char result) where TOther : INumber<TOther>;
+     }
+-    public readonly struct DateOnly : IComparable, IComparable<DateOnly>, IComparisonOperators<DateOnly, DateOnly>, IEqualityOperators<DateOnly, DateOnly>, IEquatable<DateOnly>, IFormattable, IMinMaxValue<DateOnly>, IParsable<DateOnly>, ISpanFormattable, ISpanParsable<DateOnly>
++    public readonly struct DateOnly : IComparable, IComparable<DateOnly>, IEquatable<DateOnly>, IFormattable, IParsable<DateOnly>, ISpanFormattable, ISpanParsable<DateOnly>
+-    public readonly struct DateTime : IAdditionOperators<DateTime, TimeSpan, DateTime>, IAdditiveIdentity<DateTime, TimeSpan>, IComparable, IComparable<DateTime>, IComparisonOperators<DateTime, DateTime>, IConvertible, IEqualityOperators<DateTime, DateTime>, IEquatable<DateTime>, IFormattable, IMinMaxValue<DateTime>, IParsable<DateTime>, ISerializable, ISpanFormattable, ISpanParsable<DateTime>, ISubtractionOperators<DateTime, DateTime, TimeSpan>, ISubtractionOperators<DateTime, TimeSpan, DateTime> {
++    public readonly struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable, IParsable<DateTime>, ISerializable, ISpanFormattable, ISpanParsable<DateTime> {
+-        static TimeSpan System.Numerics.IAdditiveIdentity<System.DateTime,System.TimeSpan>.AdditiveIdentity { get; }
+-        static DateTime System.Numerics.IMinMaxValue<System.DateTime>.MaxValue { get; }
+-        static DateTime System.Numerics.IMinMaxValue<System.DateTime>.MinValue { get; }
+-        static DateTime IAdditionOperators<DateTime, TimeSpan, DateTime>.operator checked +(DateTime left, TimeSpan right);
+-        static TimeSpan ISubtractionOperators<DateTime, DateTime, TimeSpan>.operator checked -(DateTime left, DateTime right);
+-        static DateTime ISubtractionOperators<DateTime, TimeSpan, DateTime>.operator checked -(DateTime left, TimeSpan right);
+     }
+-    public readonly struct DateTimeOffset : IAdditionOperators<DateTimeOffset, TimeSpan, DateTimeOffset>, IAdditiveIdentity<DateTimeOffset, TimeSpan>, IComparable, IComparable<DateTimeOffset>, IComparisonOperators<DateTimeOffset, DateTimeOffset>, IDeserializationCallback, IEqualityOperators<DateTimeOffset, DateTimeOffset>, IEquatable<DateTimeOffset>, IFormattable, IMinMaxValue<DateTimeOffset>, IParsable<DateTimeOffset>, ISerializable, ISpanFormattable, ISpanParsable<DateTimeOffset>, ISubtractionOperators<DateTimeOffset, DateTimeOffset, TimeSpan>, ISubtractionOperators<DateTimeOffset, TimeSpan, DateTimeOffset> {
++    public readonly struct DateTimeOffset : IComparable, IComparable<DateTimeOffset>, IDeserializationCallback, IEquatable<DateTimeOffset>, IFormattable, IParsable<DateTimeOffset>, ISerializable, ISpanFormattable, ISpanParsable<DateTimeOffset> {
+-        static TimeSpan System.Numerics.IAdditiveIdentity<System.DateTimeOffset,System.TimeSpan>.AdditiveIdentity { get; }
+-        static DateTimeOffset System.Numerics.IMinMaxValue<System.DateTimeOffset>.MaxValue { get; }
+-        static DateTimeOffset System.Numerics.IMinMaxValue<System.DateTimeOffset>.MinValue { get; }
+-        static DateTimeOffset IAdditionOperators<DateTimeOffset, TimeSpan, DateTimeOffset>.operator checked +(DateTimeOffset left, TimeSpan right);
+-        static TimeSpan ISubtractionOperators<DateTimeOffset, DateTimeOffset, TimeSpan>.operator checked -(DateTimeOffset left, DateTimeOffset right);
+-        static DateTimeOffset ISubtractionOperators<DateTimeOffset, TimeSpan, DateTimeOffset>.operator checked -(DateTimeOffset left, TimeSpan right);
+     }
+     public readonly struct Decimal : IAdditionOperators<decimal, decimal, decimal>, IAdditiveIdentity<decimal, decimal>, IComparable, IComparable<decimal>, IComparisonOperators<decimal, decimal>, IConvertible, IDecrementOperators<decimal>, IDeserializationCallback, IDivisionOperators<decimal, decimal, decimal>, IEqualityOperators<decimal, decimal>, IEquatable<decimal>, IFloatingPoint<decimal>, IFormattable, IIncrementOperators<decimal>, IMinMaxValue<decimal>, IModulusOperators<decimal, decimal, decimal>, IMultiplicativeIdentity<decimal, decimal>, IMultiplyOperators<decimal, decimal, decimal>, INumber<decimal>, INumberBase<decimal>, IParsable<decimal>, ISerializable, ISignedNumber<decimal>, ISpanFormattable, ISpanParsable<decimal>, ISubtractionOperators<decimal, decimal, decimal>, IUnaryNegationOperators<decimal, decimal>, IUnaryPlusOperators<decimal, decimal> {
++        static int System.Numerics.INumberBase<System.Decimal>.Radix { get; }
+-        public static decimal CreateChecked<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static decimal CreateSaturating<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static decimal CreateTruncating<TOther>(TOther value) where TOther : INumber<TOther>;
++        public static bool IsCanonical(decimal value);
++        public static bool IsEvenInteger(decimal value);
++        public static bool IsInteger(decimal value);
++        public static bool IsOddInteger(decimal value);
++        public static bool IsPositive(decimal value);
+-        long IFloatingPoint<decimal>.GetExponentShortestBitLength();
++        int IFloatingPoint<decimal>.GetExponentShortestBitLength();
+-        long IFloatingPoint<decimal>.GetSignificandBitLength();
++        int IFloatingPoint<decimal>.GetSignificandBitLength();
++        bool IFloatingPoint<decimal>.TryWriteExponentBigEndian(Span<byte> destination, out int bytesWritten);
++        bool IFloatingPoint<decimal>.TryWriteSignificandBigEndian(Span<byte> destination, out int bytesWritten);
++        static decimal INumber<decimal>.MaxNumber(decimal x, decimal y);
++        static decimal INumber<decimal>.MinNumber(decimal x, decimal y);
++        static bool INumberBase<decimal>.IsComplexNumber(decimal value);
++        static bool INumberBase<decimal>.IsFinite(decimal value);
++        static bool INumberBase<decimal>.IsImaginaryNumber(decimal value);
++        static bool INumberBase<decimal>.IsInfinity(decimal value);
++        static bool INumberBase<decimal>.IsNaN(decimal value);
++        static bool INumberBase<decimal>.IsNegativeInfinity(decimal value);
++        static bool INumberBase<decimal>.IsNormal(decimal value);
++        static bool INumberBase<decimal>.IsPositiveInfinity(decimal value);
++        static bool INumberBase<decimal>.IsRealNumber(decimal value);
++        static bool INumberBase<decimal>.IsSubnormal(decimal value);
++        static bool INumberBase<decimal>.IsZero(decimal value);
++        static decimal INumberBase<decimal>.MaxMagnitudeNumber(decimal x, decimal y);
++        static decimal INumberBase<decimal>.MinMagnitudeNumber(decimal x, decimal y);
++        static bool INumberBase<decimal>.TryConvertFromChecked<TOther>(TOther value, out decimal result);
++        static bool INumberBase<decimal>.TryConvertFromSaturating<TOther>(TOther value, out decimal result);
++        static bool INumberBase<decimal>.TryConvertFromTruncating<TOther>(TOther value, out decimal result);
++        static bool INumberBase<decimal>.TryConvertToChecked<TOther>(decimal value, out TOther result);
++        static bool INumberBase<decimal>.TryConvertToSaturating<TOther>(decimal value, out TOther result);
++        static bool INumberBase<decimal>.TryConvertToTruncating<TOther>(decimal value, out TOther result);
+-        public static bool TryCreate<TOther>(TOther value, out decimal result) where TOther : INumber<TOther>;
+     }
+     public readonly struct Double : IAdditionOperators<double, double, double>, IAdditiveIdentity<double, double>, IBinaryFloatingPointIeee754<double>, IBinaryNumber<double>, IBitwiseOperators<double, double, double>, IComparable, IComparable<double>, IComparisonOperators<double, double>, IConvertible, IDecrementOperators<double>, IDivisionOperators<double, double, double>, IEqualityOperators<double, double>, IEquatable<double>, IExponentialFunctions<double>, IFloatingPoint<double>, IFloatingPointIeee754<double>, IFormattable, IHyperbolicFunctions<double>, IIncrementOperators<double>, ILogarithmicFunctions<double>, IMinMaxValue<double>, IModulusOperators<double, double, double>, IMultiplicativeIdentity<double, double>, IMultiplyOperators<double, double, double>, INumber<double>, INumberBase<double>, IParsable<double>, IPowerFunctions<double>, IRootFunctions<double>, ISignedNumber<double>, ISpanFormattable, ISpanParsable<double>, ISubtractionOperators<double, double, double>, ITrigonometricFunctions<double>, IUnaryNegationOperators<double, double>, IUnaryPlusOperators<double, double> {
++        static int System.Numerics.INumberBase<System.Double>.Radix { get; }
+-        public static double CreateChecked<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static double CreateSaturating<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static double CreateTruncating<TOther>(TOther value) where TOther : INumber<TOther>;
++        public static double Exp10(double x);
++        public static double Exp10M1(double x);
++        public static double Exp2(double x);
++        public static double Exp2M1(double x);
++        public static double ExpM1(double x);
++        public static bool IsEvenInteger(double value);
++        public static bool IsInteger(double value);
++        public static bool IsOddInteger(double value);
++        public static bool IsPositive(double value);
++        public static bool IsRealNumber(double value);
++        public static double Log10P1(double x);
++        public static double Log2P1(double x);
++        public static double LogP1(double x);
++        public static double MaxMagnitudeNumber(double x, double y);
++        public static double MaxNumber(double x, double y);
++        public static double MinMagnitudeNumber(double x, double y);
++        public static double MinNumber(double x, double y);
+-        long IFloatingPoint<double>.GetExponentShortestBitLength();
++        int IFloatingPoint<double>.GetExponentShortestBitLength();
+-        long IFloatingPoint<double>.GetSignificandBitLength();
++        int IFloatingPoint<double>.GetSignificandBitLength();
++        bool IFloatingPoint<double>.TryWriteExponentBigEndian(Span<byte> destination, out int bytesWritten);
++        bool IFloatingPoint<double>.TryWriteSignificandBigEndian(Span<byte> destination, out int bytesWritten);
++        static bool INumberBase<double>.IsCanonical(double value);
++        static bool INumberBase<double>.IsComplexNumber(double value);
++        static bool INumberBase<double>.IsImaginaryNumber(double value);
++        static bool INumberBase<double>.IsZero(double value);
++        static bool INumberBase<double>.TryConvertFromChecked<TOther>(TOther value, out double result);
++        static bool INumberBase<double>.TryConvertFromSaturating<TOther>(TOther value, out double result);
++        static bool INumberBase<double>.TryConvertFromTruncating<TOther>(TOther value, out double result);
++        static bool INumberBase<double>.TryConvertToChecked<TOther>(double value, out TOther result);
++        static bool INumberBase<double>.TryConvertToSaturating<TOther>(double value, out TOther result);
++        static bool INumberBase<double>.TryConvertToTruncating<TOther>(double value, out TOther result);
+-        public static bool TryCreate<TOther>(TOther value, out double result) where TOther : INumber<TOther>;
+     }
+     public static class GC {
++        public static TimeSpan GetTotalPauseDuration();
+     }
+-    public readonly struct Guid : IComparable, IComparable<Guid>, IComparisonOperators<Guid, Guid>, IEqualityOperators<Guid, Guid>, IEquatable<Guid>, IFormattable, IParsable<Guid>, ISpanFormattable, ISpanParsable<Guid>
++    public readonly struct Guid : IComparable, IComparable<Guid>, IEquatable<Guid>, IFormattable, IParsable<Guid>, ISpanFormattable, ISpanParsable<Guid>
+     public readonly struct Half : IAdditionOperators<Half, Half, Half>, IAdditiveIdentity<Half, Half>, IBinaryFloatingPointIeee754<Half>, IBinaryNumber<Half>, IBitwiseOperators<Half, Half, Half>, IComparable, IComparable<Half>, IComparisonOperators<Half, Half>, IDecrementOperators<Half>, IDivisionOperators<Half, Half, Half>, IEqualityOperators<Half, Half>, IEquatable<Half>, IExponentialFunctions<Half>, IFloatingPoint<Half>, IFloatingPointIeee754<Half>, IFormattable, IHyperbolicFunctions<Half>, IIncrementOperators<Half>, ILogarithmicFunctions<Half>, IMinMaxValue<Half>, IModulusOperators<Half, Half, Half>, IMultiplicativeIdentity<Half, Half>, IMultiplyOperators<Half, Half, Half>, INumber<Half>, INumberBase<Half>, IParsable<Half>, IPowerFunctions<Half>, IRootFunctions<Half>, ISignedNumber<Half>, ISpanFormattable, ISpanParsable<Half>, ISubtractionOperators<Half, Half, Half>, ITrigonometricFunctions<Half>, IUnaryNegationOperators<Half, Half>, IUnaryPlusOperators<Half, Half> {
++        public static Half NegativeOne { get; }
++        public static Half One { get; }
+-        static Half System.Numerics.INumberBase<System.Half>.One { get; }
++        static int System.Numerics.INumberBase<System.Half>.Radix { get; }
+-        static Half System.Numerics.INumberBase<System.Half>.Zero { get; }
+-        static Half System.Numerics.ISignedNumber<System.Half>.NegativeOne { get; }
++        public static Half Zero { get; }
+-        public static Half CreateChecked<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static Half CreateSaturating<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static Half CreateTruncating<TOther>(TOther value) where TOther : INumber<TOther>;
++        public static Half Exp10(Half x);
++        public static Half Exp10M1(Half x);
++        public static Half Exp2(Half x);
++        public static Half Exp2M1(Half x);
++        public static Half ExpM1(Half x);
++        public static bool IsEvenInteger(Half value);
++        public static bool IsInteger(Half value);
++        public static bool IsOddInteger(Half value);
++        public static bool IsPositive(Half value);
++        public static bool IsRealNumber(Half value);
++        public static Half Log10P1(Half x);
++        public static Half Log2P1(Half x);
++        public static Half LogP1(Half x);
++        public static Half MaxMagnitudeNumber(Half x, Half y);
++        public static Half MaxNumber(Half x, Half y);
++        public static Half MinMagnitudeNumber(Half x, Half y);
++        public static Half MinNumber(Half x, Half y);
++        public static explicit operator checked byte (Half value);
++        public static explicit operator checked char (Half value);
++        public static explicit operator checked short (Half value);
++        public static explicit operator checked int (Half value);
++        public static explicit operator checked long (Half value);
++        public static explicit operator checked Int128 (Half value);
++        public static explicit operator checked IntPtr (Half value);
++        public static explicit operator checked sbyte (Half value);
++        public static explicit operator checked ushort (Half value);
++        public static explicit operator checked uint (Half value);
++        public static explicit operator checked ulong (Half value);
++        public static explicit operator checked UInt128 (Half value);
++        public static explicit operator checked UIntPtr (Half value);
++        public static explicit operator Half (char value);
++        public static explicit operator Half (decimal value);
++        public static explicit operator byte (Half value);
++        public static explicit operator char (Half value);
++        public static explicit operator decimal (Half value);
++        public static explicit operator Int128 (Half value);
++        public static explicit operator short (Half value);
++        public static explicit operator int (Half value);
++        public static explicit operator long (Half value);
++        public static explicit operator IntPtr (Half value);
++        public static explicit operator sbyte (Half value);
++        public static explicit operator UInt128 (Half value);
++        public static explicit operator ushort (Half value);
++        public static explicit operator uint (Half value);
++        public static explicit operator ulong (Half value);
++        public static explicit operator UIntPtr (Half value);
++        public static explicit operator Half (short value);
++        public static explicit operator Half (int value);
++        public static explicit operator Half (long value);
++        public static explicit operator Half (IntPtr value);
++        public static explicit operator Half (ushort value);
++        public static explicit operator Half (uint value);
++        public static explicit operator Half (ulong value);
++        public static explicit operator Half (UIntPtr value);
++        public static implicit operator Half (byte value);
++        public static implicit operator Half (sbyte value);
+-        long IFloatingPoint<Half>.GetExponentShortestBitLength();
++        int IFloatingPoint<Half>.GetExponentShortestBitLength();
+-        long IFloatingPoint<Half>.GetSignificandBitLength();
++        int IFloatingPoint<Half>.GetSignificandBitLength();
++        bool IFloatingPoint<Half>.TryWriteExponentBigEndian(Span<byte> destination, out int bytesWritten);
++        bool IFloatingPoint<Half>.TryWriteSignificandBigEndian(Span<byte> destination, out int bytesWritten);
++        static bool INumberBase<Half>.IsCanonical(Half value);
++        static bool INumberBase<Half>.IsComplexNumber(Half value);
++        static bool INumberBase<Half>.IsImaginaryNumber(Half value);
++        static bool INumberBase<Half>.IsZero(Half value);
++        static bool INumberBase<Half>.TryConvertFromChecked<TOther>(TOther value, out Half result);
++        static bool INumberBase<Half>.TryConvertFromSaturating<TOther>(TOther value, out Half result);
++        static bool INumberBase<Half>.TryConvertFromTruncating<TOther>(TOther value, out Half result);
++        static bool INumberBase<Half>.TryConvertToChecked<TOther>(Half value, out TOther result);
++        static bool INumberBase<Half>.TryConvertToSaturating<TOther>(Half value, out TOther result);
++        static bool INumberBase<Half>.TryConvertToTruncating<TOther>(Half value, out TOther result);
+-        public static bool TryCreate<TOther>(TOther value, out Half result) where TOther : INumber<TOther>;
+     }
++    public readonly struct Int128 : IAdditionOperators<Int128, Int128, Int128>, IAdditiveIdentity<Int128, Int128>, IBinaryInteger<Int128>, IBinaryNumber<Int128>, IBitwiseOperators<Int128, Int128, Int128>, IComparable, IComparable<Int128>, IComparisonOperators<Int128, Int128>, IDecrementOperators<Int128>, IDivisionOperators<Int128, Int128, Int128>, IEqualityOperators<Int128, Int128>, IEquatable<Int128>, IFormattable, IIncrementOperators<Int128>, IMinMaxValue<Int128>, IModulusOperators<Int128, Int128, Int128>, IMultiplicativeIdentity<Int128, Int128>, IMultiplyOperators<Int128, Int128, Int128>, INumber<Int128>, INumberBase<Int128>, IParsable<Int128>, IShiftOperators<Int128, Int128>, ISignedNumber<Int128>, ISpanFormattable, ISpanParsable<Int128>, ISubtractionOperators<Int128, Int128, Int128>, IUnaryNegationOperators<Int128, Int128>, IUnaryPlusOperators<Int128, Int128> {
++        public Int128(ulong upper, ulong lower);
++        public static Int128 MaxValue { get; }
++        public static Int128 MinValue { get; }
++        public static Int128 NegativeOne { get; }
++        public static Int128 One { get; }
++        static Int128 System.Numerics.IAdditiveIdentity<System.Int128,System.Int128>.AdditiveIdentity { get; }
++        static Int128 System.Numerics.IMultiplicativeIdentity<System.Int128,System.Int128>.MultiplicativeIdentity { get; }
++        static int System.Numerics.INumberBase<System.Int128>.Radix { get; }
++        public static Int128 Zero { get; }
++        public static Int128 Abs(Int128 value);
++        public static Int128 Clamp(Int128 value, Int128 min, Int128 max);
++        public int CompareTo(Int128 value);
++        public int CompareTo(object? value);
++        public static Int128 CopySign(Int128 value, Int128 sign);
++        public static (Int128 Quotient, Int128 Remainder) DivRem(Int128 left, Int128 right);
++        public bool Equals(Int128 other);
++        public override bool Equals(object? obj);
++        public override int GetHashCode();
++        public static bool IsEvenInteger(Int128 value);
++        public static bool IsNegative(Int128 value);
++        public static bool IsOddInteger(Int128 value);
++        public static bool IsPositive(Int128 value);
++        public static bool IsPow2(Int128 value);
++        public static Int128 LeadingZeroCount(Int128 value);
++        public static Int128 Log2(Int128 value);
++        public static Int128 Max(Int128 x, Int128 y);
++        public static Int128 MaxMagnitude(Int128 x, Int128 y);
++        public static Int128 Min(Int128 x, Int128 y);
++        public static Int128 MinMagnitude(Int128 x, Int128 y);
++        public static Int128 operator +(Int128 left, Int128 right);
++        public static Int128 operator &(Int128 left, Int128 right);
++        public static Int128 operator |(Int128 left, Int128 right);
++        public static Int128 operator checked +(Int128 left, Int128 right);
++        public static Int128 operator checked --(Int128 value);
++        public static Int128 operator checked /(Int128 left, Int128 right);
++        public static explicit operator checked Int128 (double value);
++        public static explicit operator checked byte (Int128 value);
++        public static explicit operator checked char (Int128 value);
++        public static explicit operator checked short (Int128 value);
++        public static explicit operator checked int (Int128 value);
++        public static explicit operator checked long (Int128 value);
++        public static explicit operator checked nint (Int128 value);
++        public static explicit operator checked sbyte (Int128 value);
++        public static explicit operator checked ushort (Int128 value);
++        public static explicit operator checked uint (Int128 value);
++        public static explicit operator checked ulong (Int128 value);
++        public static explicit operator checked UInt128 (Int128 value);
++        public static explicit operator checked nuint (Int128 value);
++        public static explicit operator checked Int128 (float value);
++        public static Int128 operator checked ++(Int128 value);
++        public static Int128 operator checked *(Int128 left, Int128 right);
++        public static Int128 operator checked -(Int128 left, Int128 right);
++        public static Int128 operator checked -(Int128 value);
++        public static Int128 operator --(Int128 value);
++        public static Int128 operator /(Int128 left, Int128 right);
++        public static bool operator ==(Int128 left, Int128 right);
++        public static Int128 operator ^(Int128 left, Int128 right);
++        public static explicit operator Int128 (decimal value);
++        public static explicit operator Int128 (double value);
++        public static explicit operator byte (Int128 value);
++        public static explicit operator char (Int128 value);
++        public static explicit operator decimal (Int128 value);
++        public static explicit operator double (Int128 value);
++        public static explicit operator Half (Int128 value);
++        public static explicit operator short (Int128 value);
++        public static explicit operator int (Int128 value);
++        public static explicit operator long (Int128 value);
++        public static explicit operator nint (Int128 value);
++        public static explicit operator sbyte (Int128 value);
++        public static explicit operator float (Int128 value);
++        public static explicit operator UInt128 (Int128 value);
++        public static explicit operator ushort (Int128 value);
++        public static explicit operator uint (Int128 value);
++        public static explicit operator ulong (Int128 value);
++        public static explicit operator nuint (Int128 value);
++        public static explicit operator Int128 (float value);
++        public static bool operator >(Int128 left, Int128 right);
++        public static bool operator >=(Int128 left, Int128 right);
++        public static implicit operator Int128 (byte value);
++        public static implicit operator Int128 (char value);
++        public static implicit operator Int128 (short value);
++        public static implicit operator Int128 (int value);
++        public static implicit operator Int128 (long value);
++        public static implicit operator Int128 (nint value);
++        public static implicit operator Int128 (sbyte value);
++        public static implicit operator Int128 (ushort value);
++        public static implicit operator Int128 (uint value);
++        public static implicit operator Int128 (ulong value);
++        public static implicit operator Int128 (nuint value);
++        public static Int128 operator ++(Int128 value);
++        public static bool operator !=(Int128 left, Int128 right);
++        public static Int128 operator <<(Int128 value, int shiftAmount);
++        public static bool operator <(Int128 left, Int128 right);
++        public static bool operator <=(Int128 left, Int128 right);
++        public static Int128 operator %(Int128 left, Int128 right);
++        public static Int128 operator *(Int128 left, Int128 right);
++        public static Int128 operator ~(Int128 value);
++        public static Int128 operator >>(Int128 value, int shiftAmount);
++        public static Int128 operator -(Int128 left, Int128 right);
++        public static Int128 operator -(Int128 value);
++        public static Int128 operator +(Int128 value);
++        public static Int128 operator >>>(Int128 value, int shiftAmount);
++        public static Int128 Parse(ReadOnlySpan<char> s, NumberStyles style = NumberStyles.Integer, IFormatProvider? provider = null);
++        public static Int128 Parse(ReadOnlySpan<char> s, IFormatProvider? provider);
++        public static Int128 Parse(string s);
++        public static Int128 Parse(string s, NumberStyles style);
++        public static Int128 Parse(string s, NumberStyles style, IFormatProvider? provider);
++        public static Int128 Parse(string s, IFormatProvider? provider);
++        public static Int128 PopCount(Int128 value);
++        public static Int128 RotateLeft(Int128 value, int rotateAmount);
++        public static Int128 RotateRight(Int128 value, int rotateAmount);
++        public static int Sign(Int128 value);
++        int IBinaryInteger<Int128>.GetByteCount();
++        int IBinaryInteger<Int128>.GetShortestBitLength();
++        bool IBinaryInteger<Int128>.TryWriteBigEndian(Span<byte> destination, out int bytesWritten);
++        bool IBinaryInteger<Int128>.TryWriteLittleEndian(Span<byte> destination, out int bytesWritten);
++        static Int128 INumber<Int128>.MaxNumber(Int128 x, Int128 y);
++        static Int128 INumber<Int128>.MinNumber(Int128 x, Int128 y);
++        static bool INumberBase<Int128>.IsCanonical(Int128 value);
++        static bool INumberBase<Int128>.IsComplexNumber(Int128 value);
++        static bool INumberBase<Int128>.IsFinite(Int128 value);
++        static bool INumberBase<Int128>.IsImaginaryNumber(Int128 value);
++        static bool INumberBase<Int128>.IsInfinity(Int128 value);
++        static bool INumberBase<Int128>.IsInteger(Int128 value);
++        static bool INumberBase<Int128>.IsNaN(Int128 value);
++        static bool INumberBase<Int128>.IsNegativeInfinity(Int128 value);
++        static bool INumberBase<Int128>.IsNormal(Int128 value);
++        static bool INumberBase<Int128>.IsPositiveInfinity(Int128 value);
++        static bool INumberBase<Int128>.IsRealNumber(Int128 value);
++        static bool INumberBase<Int128>.IsSubnormal(Int128 value);
++        static bool INumberBase<Int128>.IsZero(Int128 value);
++        static Int128 INumberBase<Int128>.MaxMagnitudeNumber(Int128 x, Int128 y);
++        static Int128 INumberBase<Int128>.MinMagnitudeNumber(Int128 x, Int128 y);
++        static bool INumberBase<Int128>.TryConvertFromChecked<TOther>(TOther value, out Int128 result);
++        static bool INumberBase<Int128>.TryConvertFromSaturating<TOther>(TOther value, out Int128 result);
++        static bool INumberBase<Int128>.TryConvertFromTruncating<TOther>(TOther value, out Int128 result);
++        static bool INumberBase<Int128>.TryConvertToChecked<TOther>(Int128 value, out TOther result);
++        static bool INumberBase<Int128>.TryConvertToSaturating<TOther>(Int128 value, out TOther result);
++        static bool INumberBase<Int128>.TryConvertToTruncating<TOther>(Int128 value, out TOther result);
++        public override string ToString();
++        public string ToString(IFormatProvider? provider);
++        public string ToString(string? format);
++        public string ToString(string? format, IFormatProvider? provider);
++        public static Int128 TrailingZeroCount(Int128 value);
++        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default(ReadOnlySpan<char>), IFormatProvider? provider = null);
++        public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider, out Int128 result);
++        public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, out Int128 result);
++        public static bool TryParse(ReadOnlySpan<char> s, out Int128 result);
++        public static bool TryParse(string? s, NumberStyles style, IFormatProvider? provider, out Int128 result);
++        public static bool TryParse(string? s, IFormatProvider? provider, out Int128 result);
++        public static bool TryParse(string? s, out Int128 result);
++    }
+     public readonly struct Int16 : IAdditionOperators<short, short, short>, IAdditiveIdentity<short, short>, IBinaryInteger<short>, IBinaryNumber<short>, IBitwiseOperators<short, short, short>, IComparable, IComparable<short>, IComparisonOperators<short, short>, IConvertible, IDecrementOperators<short>, IDivisionOperators<short, short, short>, IEqualityOperators<short, short>, IEquatable<short>, IFormattable, IIncrementOperators<short>, IMinMaxValue<short>, IModulusOperators<short, short, short>, IMultiplicativeIdentity<short, short>, IMultiplyOperators<short, short, short>, INumber<short>, INumberBase<short>, IParsable<short>, IShiftOperators<short, short>, ISignedNumber<short>, ISpanFormattable, ISpanParsable<short>, ISubtractionOperators<short, short, short>, IUnaryNegationOperators<short, short>, IUnaryPlusOperators<short, short> {
++        static int System.Numerics.INumberBase<System.Int16>.Radix { get; }
+-        public static short CreateChecked<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static short CreateSaturating<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static short CreateTruncating<TOther>(TOther value) where TOther : INumber<TOther>;
++        public static bool IsEvenInteger(short value);
++        public static bool IsOddInteger(short value);
++        public static bool IsPositive(short value);
+-        long IBinaryInteger<short>.GetShortestBitLength();
++        int IBinaryInteger<short>.GetShortestBitLength();
++        bool IBinaryInteger<short>.TryWriteBigEndian(Span<byte> destination, out int bytesWritten);
++        static short INumber<short>.MaxNumber(short x, short y);
++        static short INumber<short>.MinNumber(short x, short y);
++        static bool INumberBase<short>.IsCanonical(short value);
++        static bool INumberBase<short>.IsComplexNumber(short value);
++        static bool INumberBase<short>.IsFinite(short value);
++        static bool INumberBase<short>.IsImaginaryNumber(short value);
++        static bool INumberBase<short>.IsInfinity(short value);
++        static bool INumberBase<short>.IsInteger(short value);
++        static bool INumberBase<short>.IsNaN(short value);
++        static bool INumberBase<short>.IsNegativeInfinity(short value);
++        static bool INumberBase<short>.IsNormal(short value);
++        static bool INumberBase<short>.IsPositiveInfinity(short value);
++        static bool INumberBase<short>.IsRealNumber(short value);
++        static bool INumberBase<short>.IsSubnormal(short value);
++        static bool INumberBase<short>.IsZero(short value);
++        static short INumberBase<short>.MaxMagnitudeNumber(short x, short y);
++        static short INumberBase<short>.MinMagnitudeNumber(short x, short y);
++        static bool INumberBase<short>.TryConvertFromChecked<TOther>(TOther value, out short result);
++        static bool INumberBase<short>.TryConvertFromSaturating<TOther>(TOther value, out short result);
++        static bool INumberBase<short>.TryConvertFromTruncating<TOther>(TOther value, out short result);
++        static bool INumberBase<short>.TryConvertToChecked<TOther>(short value, out TOther result);
++        static bool INumberBase<short>.TryConvertToSaturating<TOther>(short value, out TOther result);
++        static bool INumberBase<short>.TryConvertToTruncating<TOther>(short value, out TOther result);
+-        public static bool TryCreate<TOther>(TOther value, out short result) where TOther : INumber<TOther>;
+     }
+     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>, IConvertible, IDecrementOperators<int>, IDivisionOperators<int, int, int>, IEqualityOperators<int, int>, 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>, ISignedNumber<int>, ISpanFormattable, ISpanParsable<int>, ISubtractionOperators<int, int, int>, IUnaryNegationOperators<int, int>, IUnaryPlusOperators<int, int> {
++        static int System.Numerics.INumberBase<System.Int32>.Radix { get; }
+-        public static int CreateChecked<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static int CreateSaturating<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static int CreateTruncating<TOther>(TOther value) where TOther : INumber<TOther>;
++        public static bool IsEvenInteger(int value);
++        public static bool IsOddInteger(int value);
++        public static bool IsPositive(int value);
+-        long IBinaryInteger<int>.GetShortestBitLength();
++        int IBinaryInteger<int>.GetShortestBitLength();
++        bool IBinaryInteger<int>.TryWriteBigEndian(Span<byte> destination, out int bytesWritten);
++        static int INumber<int>.MaxNumber(int x, int y);
++        static int INumber<int>.MinNumber(int x, int y);
++        static bool INumberBase<int>.IsCanonical(int value);
++        static bool INumberBase<int>.IsComplexNumber(int value);
++        static bool INumberBase<int>.IsFinite(int value);
++        static bool INumberBase<int>.IsImaginaryNumber(int value);
++        static bool INumberBase<int>.IsInfinity(int value);
++        static bool INumberBase<int>.IsInteger(int value);
++        static bool INumberBase<int>.IsNaN(int value);
++        static bool INumberBase<int>.IsNegativeInfinity(int value);
++        static bool INumberBase<int>.IsNormal(int value);
++        static bool INumberBase<int>.IsPositiveInfinity(int value);
++        static bool INumberBase<int>.IsRealNumber(int value);
++        static bool INumberBase<int>.IsSubnormal(int value);
++        static bool INumberBase<int>.IsZero(int value);
++        static int INumberBase<int>.MaxMagnitudeNumber(int x, int y);
++        static int INumberBase<int>.MinMagnitudeNumber(int x, int y);
++        static bool INumberBase<int>.TryConvertFromChecked<TOther>(TOther value, out int result);
++        static bool INumberBase<int>.TryConvertFromSaturating<TOther>(TOther value, out int result);
++        static bool INumberBase<int>.TryConvertFromTruncating<TOther>(TOther value, out int result);
++        static bool INumberBase<int>.TryConvertToChecked<TOther>(int value, out TOther result);
++        static bool INumberBase<int>.TryConvertToSaturating<TOther>(int value, out TOther result);
++        static bool INumberBase<int>.TryConvertToTruncating<TOther>(int value, out TOther result);
+-        public static bool TryCreate<TOther>(TOther value, out int result) where TOther : INumber<TOther>;
+     }
+     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>, IConvertible, IDecrementOperators<long>, IDivisionOperators<long, long, long>, IEqualityOperators<long, long>, 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, long>, ISignedNumber<long>, ISpanFormattable, ISpanParsable<long>, ISubtractionOperators<long, long, long>, IUnaryNegationOperators<long, long>, IUnaryPlusOperators<long, long> {
++        static int System.Numerics.INumberBase<System.Int64>.Radix { get; }
+-        public static long CreateChecked<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static long CreateSaturating<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static long CreateTruncating<TOther>(TOther value) where TOther : INumber<TOther>;
++        public static bool IsEvenInteger(long value);
++        public static bool IsOddInteger(long value);
++        public static bool IsPositive(long value);
+-        long IBinaryInteger<long>.GetShortestBitLength();
++        int IBinaryInteger<long>.GetShortestBitLength();
++        bool IBinaryInteger<long>.TryWriteBigEndian(Span<byte> destination, out int bytesWritten);
++        static long INumber<long>.MaxNumber(long x, long y);
++        static long INumber<long>.MinNumber(long x, long y);
++        static bool INumberBase<long>.IsCanonical(long value);
++        static bool INumberBase<long>.IsComplexNumber(long value);
++        static bool INumberBase<long>.IsFinite(long value);
++        static bool INumberBase<long>.IsImaginaryNumber(long value);
++        static bool INumberBase<long>.IsInfinity(long value);
++        static bool INumberBase<long>.IsInteger(long value);
++        static bool INumberBase<long>.IsNaN(long value);
++        static bool INumberBase<long>.IsNegativeInfinity(long value);
++        static bool INumberBase<long>.IsNormal(long value);
++        static bool INumberBase<long>.IsPositiveInfinity(long value);
++        static bool INumberBase<long>.IsRealNumber(long value);
++        static bool INumberBase<long>.IsSubnormal(long value);
++        static bool INumberBase<long>.IsZero(long value);
++        static long INumberBase<long>.MaxMagnitudeNumber(long x, long y);
++        static long INumberBase<long>.MinMagnitudeNumber(long x, long y);
++        static bool INumberBase<long>.TryConvertFromChecked<TOther>(TOther value, out long result);
++        static bool INumberBase<long>.TryConvertFromSaturating<TOther>(TOther value, out long result);
++        static bool INumberBase<long>.TryConvertFromTruncating<TOther>(TOther value, out long result);
++        static bool INumberBase<long>.TryConvertToChecked<TOther>(long value, out TOther result);
++        static bool INumberBase<long>.TryConvertToSaturating<TOther>(long value, out TOther result);
++        static bool INumberBase<long>.TryConvertToTruncating<TOther>(long value, out TOther result);
+-        public static bool TryCreate<TOther>(TOther value, out long result) where TOther : INumber<TOther>;
+     }
+     public readonly struct IntPtr : IAdditionOperators<IntPtr, IntPtr, IntPtr>, IAdditiveIdentity<IntPtr, IntPtr>, IBinaryInteger<IntPtr>, IBinaryNumber<IntPtr>, IBitwiseOperators<IntPtr, IntPtr, IntPtr>, IComparable, IComparable<IntPtr>, IComparisonOperators<IntPtr, IntPtr>, IDecrementOperators<IntPtr>, IDivisionOperators<IntPtr, IntPtr, IntPtr>, IEqualityOperators<IntPtr, IntPtr>, IEquatable<IntPtr>, IFormattable, IIncrementOperators<IntPtr>, IMinMaxValue<IntPtr>, IModulusOperators<IntPtr, IntPtr, IntPtr>, IMultiplicativeIdentity<IntPtr, IntPtr>, IMultiplyOperators<IntPtr, IntPtr, IntPtr>, INumber<IntPtr>, INumberBase<IntPtr>, IParsable<IntPtr>, ISerializable, IShiftOperators<IntPtr, IntPtr>, ISignedNumber<IntPtr>, ISpanFormattable, ISpanParsable<IntPtr>, ISubtractionOperators<IntPtr, IntPtr, IntPtr>, IUnaryNegationOperators<IntPtr, IntPtr>, IUnaryPlusOperators<IntPtr, IntPtr> {
++        static int System.Numerics.INumberBase<nint>.Radix { get; }
++        public static IntPtr Abs(IntPtr value);
++        public static IntPtr Clamp(IntPtr value, IntPtr min, IntPtr max);
++        public static IntPtr CopySign(IntPtr value, IntPtr sign);
++        public static (IntPtr Quotient, IntPtr Remainder) DivRem(IntPtr left, IntPtr right);
++        public static bool IsEvenInteger(IntPtr value);
++        public static bool IsNegative(IntPtr value);
++        public static bool IsOddInteger(IntPtr value);
++        public static bool IsPositive(IntPtr value);
++        public static bool IsPow2(IntPtr value);
++        public static IntPtr LeadingZeroCount(IntPtr value);
++        public static IntPtr Log2(IntPtr value);
++        public static IntPtr Max(IntPtr x, IntPtr y);
++        public static IntPtr MaxMagnitude(IntPtr x, IntPtr y);
++        public static IntPtr Min(IntPtr x, IntPtr y);
++        public static IntPtr MinMagnitude(IntPtr x, IntPtr y);
++        public static IntPtr PopCount(IntPtr value);
++        public static IntPtr RotateLeft(IntPtr value, int rotateAmount);
++        public static IntPtr RotateRight(IntPtr value, int rotateAmount);
++        public static int Sign(IntPtr value);
+-        static (IntPtr Quotient, IntPtr Remainder) IBinaryInteger<IntPtr>.DivRem(IntPtr left, IntPtr right);
+-        long IBinaryInteger<IntPtr>.GetShortestBitLength();
++        int IBinaryInteger<IntPtr>.GetShortestBitLength();
+-        static IntPtr IBinaryInteger<IntPtr>.LeadingZeroCount(IntPtr value);
+-        static IntPtr IBinaryInteger<IntPtr>.PopCount(IntPtr value);
+-        static IntPtr IBinaryInteger<IntPtr>.RotateLeft(IntPtr value, int rotateAmount);
+-        static IntPtr IBinaryInteger<IntPtr>.RotateRight(IntPtr value, int rotateAmount);
+-        static IntPtr IBinaryInteger<IntPtr>.TrailingZeroCount(IntPtr value);
++        bool IBinaryInteger<IntPtr>.TryWriteBigEndian(Span<byte> destination, out int bytesWritten);
+-        static bool IBinaryNumber<IntPtr>.IsPow2(IntPtr value);
+-        static IntPtr IBinaryNumber<IntPtr>.Log2(IntPtr value);
+-        static IntPtr INumber<IntPtr>.Abs(IntPtr value);
+-        static IntPtr INumber<IntPtr>.Clamp(IntPtr value, IntPtr min, IntPtr max);
+-        static IntPtr INumber<IntPtr>.CopySign(IntPtr value, IntPtr sign);
+-        static IntPtr INumber<IntPtr>.CreateChecked<TOther>(TOther value);
+-        static IntPtr INumber<IntPtr>.CreateSaturating<TOther>(TOther value);
+-        static IntPtr INumber<IntPtr>.CreateTruncating<TOther>(TOther value);
+-        static bool INumber<IntPtr>.IsNegative(IntPtr value);
+-        static IntPtr INumber<IntPtr>.Max(IntPtr x, IntPtr y);
+-        static IntPtr INumber<IntPtr>.MaxMagnitude(IntPtr x, IntPtr y);
++        static IntPtr INumber<IntPtr>.MaxNumber(IntPtr x, IntPtr y);
+-        static IntPtr INumber<IntPtr>.Min(IntPtr x, IntPtr y);
+-        static IntPtr INumber<IntPtr>.MinMagnitude(IntPtr x, IntPtr y);
++        static IntPtr INumber<IntPtr>.MinNumber(IntPtr x, IntPtr y);
+-        static int INumber<IntPtr>.Sign(IntPtr value);
+-        static bool INumber<IntPtr>.TryCreate<TOther>(TOther value, out IntPtr result);
++        static bool INumberBase<IntPtr>.IsCanonical(IntPtr value);
++        static bool INumberBase<IntPtr>.IsComplexNumber(IntPtr value);
++        static bool INumberBase<IntPtr>.IsFinite(IntPtr value);
++        static bool INumberBase<IntPtr>.IsImaginaryNumber(IntPtr value);
++        static bool INumberBase<IntPtr>.IsInfinity(IntPtr value);
++        static bool INumberBase<IntPtr>.IsInteger(IntPtr value);
++        static bool INumberBase<IntPtr>.IsNaN(IntPtr value);
++        static bool INumberBase<IntPtr>.IsNegativeInfinity(IntPtr value);
++        static bool INumberBase<IntPtr>.IsNormal(IntPtr value);
++        static bool INumberBase<IntPtr>.IsPositiveInfinity(IntPtr value);
++        static bool INumberBase<IntPtr>.IsRealNumber(IntPtr value);
++        static bool INumberBase<IntPtr>.IsSubnormal(IntPtr value);
++        static bool INumberBase<IntPtr>.IsZero(IntPtr value);
++        static IntPtr INumberBase<IntPtr>.MaxMagnitudeNumber(IntPtr x, IntPtr y);
++        static IntPtr INumberBase<IntPtr>.MinMagnitudeNumber(IntPtr x, IntPtr y);
++        static bool INumberBase<IntPtr>.TryConvertFromChecked<TOther>(TOther value, out IntPtr result);
++        static bool INumberBase<IntPtr>.TryConvertFromSaturating<TOther>(TOther value, out IntPtr result);
++        static bool INumberBase<IntPtr>.TryConvertFromTruncating<TOther>(TOther value, out IntPtr result);
++        static bool INumberBase<IntPtr>.TryConvertToChecked<TOther>(IntPtr value, out TOther result);
++        static bool INumberBase<IntPtr>.TryConvertToSaturating<TOther>(IntPtr value, out TOther result);
++        static bool INumberBase<IntPtr>.TryConvertToTruncating<TOther>(IntPtr value, out TOther result);
++        public static IntPtr TrailingZeroCount(IntPtr value);
+     }
+     public struct RuntimeFieldHandle : IEquatable<RuntimeFieldHandle>, ISerializable {
++        public static RuntimeFieldHandle FromIntPtr(IntPtr value);
++        public static IntPtr ToIntPtr(RuntimeFieldHandle value);
+     }
+     public struct RuntimeMethodHandle : IEquatable<RuntimeMethodHandle>, ISerializable {
++        public static RuntimeMethodHandle FromIntPtr(IntPtr value);
++        public static IntPtr ToIntPtr(RuntimeMethodHandle value);
+     }
+     public struct RuntimeTypeHandle : IEquatable<RuntimeTypeHandle>, ISerializable {
++        public static RuntimeTypeHandle FromIntPtr(IntPtr value);
++        public static IntPtr ToIntPtr(RuntimeTypeHandle value);
+     }
+     public readonly struct SByte : IAdditionOperators<sbyte, sbyte, sbyte>, IAdditiveIdentity<sbyte, sbyte>, IBinaryInteger<sbyte>, IBinaryNumber<sbyte>, IBitwiseOperators<sbyte, sbyte, sbyte>, IComparable, IComparable<sbyte>, IComparisonOperators<sbyte, sbyte>, IConvertible, IDecrementOperators<sbyte>, IDivisionOperators<sbyte, sbyte, sbyte>, IEqualityOperators<sbyte, sbyte>, IEquatable<sbyte>, IFormattable, IIncrementOperators<sbyte>, IMinMaxValue<sbyte>, IModulusOperators<sbyte, sbyte, sbyte>, IMultiplicativeIdentity<sbyte, sbyte>, IMultiplyOperators<sbyte, sbyte, sbyte>, INumber<sbyte>, INumberBase<sbyte>, IParsable<sbyte>, IShiftOperators<sbyte, sbyte>, ISignedNumber<sbyte>, ISpanFormattable, ISpanParsable<sbyte>, ISubtractionOperators<sbyte, sbyte, sbyte>, IUnaryNegationOperators<sbyte, sbyte>, IUnaryPlusOperators<sbyte, sbyte> {
++        static int System.Numerics.INumberBase<System.SByte>.Radix { get; }
+-        public static sbyte CreateChecked<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static sbyte CreateSaturating<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static sbyte CreateTruncating<TOther>(TOther value) where TOther : INumber<TOther>;
++        public static bool IsEvenInteger(sbyte value);
++        public static bool IsOddInteger(sbyte value);
++        public static bool IsPositive(sbyte value);
+-        long IBinaryInteger<sbyte>.GetShortestBitLength();
++        int IBinaryInteger<sbyte>.GetShortestBitLength();
++        bool IBinaryInteger<sbyte>.TryWriteBigEndian(Span<byte> destination, out int bytesWritten);
++        static sbyte INumber<sbyte>.MaxNumber(sbyte x, sbyte y);
++        static sbyte INumber<sbyte>.MinNumber(sbyte x, sbyte y);
++        static bool INumberBase<sbyte>.IsCanonical(sbyte value);
++        static bool INumberBase<sbyte>.IsComplexNumber(sbyte value);
++        static bool INumberBase<sbyte>.IsFinite(sbyte value);
++        static bool INumberBase<sbyte>.IsImaginaryNumber(sbyte value);
++        static bool INumberBase<sbyte>.IsInfinity(sbyte value);
++        static bool INumberBase<sbyte>.IsInteger(sbyte value);
++        static bool INumberBase<sbyte>.IsNaN(sbyte value);
++        static bool INumberBase<sbyte>.IsNegativeInfinity(sbyte value);
++        static bool INumberBase<sbyte>.IsNormal(sbyte value);
++        static bool INumberBase<sbyte>.IsPositiveInfinity(sbyte value);
++        static bool INumberBase<sbyte>.IsRealNumber(sbyte value);
++        static bool INumberBase<sbyte>.IsSubnormal(sbyte value);
++        static bool INumberBase<sbyte>.IsZero(sbyte value);
++        static sbyte INumberBase<sbyte>.MaxMagnitudeNumber(sbyte x, sbyte y);
++        static sbyte INumberBase<sbyte>.MinMagnitudeNumber(sbyte x, sbyte y);
++        static bool INumberBase<sbyte>.TryConvertFromChecked<TOther>(TOther value, out sbyte result);
++        static bool INumberBase<sbyte>.TryConvertFromSaturating<TOther>(TOther value, out sbyte result);
++        static bool INumberBase<sbyte>.TryConvertFromTruncating<TOther>(TOther value, out sbyte result);
++        static bool INumberBase<sbyte>.TryConvertToChecked<TOther>(sbyte value, out TOther result);
++        static bool INumberBase<sbyte>.TryConvertToSaturating<TOther>(sbyte value, out TOther result);
++        static bool INumberBase<sbyte>.TryConvertToTruncating<TOther>(sbyte value, out TOther result);
+-        public static bool TryCreate<TOther>(TOther value, out sbyte result) where TOther : INumber<TOther>;
+     }
+     public readonly struct Single : IAdditionOperators<float, float, float>, IAdditiveIdentity<float, float>, IBinaryFloatingPointIeee754<float>, IBinaryNumber<float>, IBitwiseOperators<float, float, float>, IComparable, IComparable<float>, IComparisonOperators<float, float>, IConvertible, IDecrementOperators<float>, IDivisionOperators<float, float, float>, IEqualityOperators<float, float>, IEquatable<float>, IExponentialFunctions<float>, IFloatingPoint<float>, IFloatingPointIeee754<float>, IFormattable, IHyperbolicFunctions<float>, IIncrementOperators<float>, ILogarithmicFunctions<float>, IMinMaxValue<float>, IModulusOperators<float, float, float>, IMultiplicativeIdentity<float, float>, IMultiplyOperators<float, float, float>, INumber<float>, INumberBase<float>, IParsable<float>, IPowerFunctions<float>, IRootFunctions<float>, ISignedNumber<float>, ISpanFormattable, ISpanParsable<float>, ISubtractionOperators<float, float, float>, ITrigonometricFunctions<float>, IUnaryNegationOperators<float, float>, IUnaryPlusOperators<float, float> {
++        static int System.Numerics.INumberBase<System.Single>.Radix { get; }
+-        public static float CreateChecked<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static float CreateSaturating<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static float CreateTruncating<TOther>(TOther value) where TOther : INumber<TOther>;
++        public static float Exp10(float x);
++        public static float Exp10M1(float x);
++        public static float Exp2(float x);
++        public static float Exp2M1(float x);
++        public static float ExpM1(float x);
++        public static bool IsEvenInteger(float value);
++        public static bool IsInteger(float value);
++        public static bool IsOddInteger(float value);
++        public static bool IsPositive(float value);
++        public static bool IsRealNumber(float value);
++        public static float Log10P1(float x);
++        public static float Log2P1(float x);
++        public static float LogP1(float x);
++        public static float MaxMagnitudeNumber(float x, float y);
++        public static float MaxNumber(float x, float y);
++        public static float MinMagnitudeNumber(float x, float y);
++        public static float MinNumber(float x, float y);
+-        long IFloatingPoint<float>.GetExponentShortestBitLength();
++        int IFloatingPoint<float>.GetExponentShortestBitLength();
+-        long IFloatingPoint<float>.GetSignificandBitLength();
++        int IFloatingPoint<float>.GetSignificandBitLength();
++        bool IFloatingPoint<float>.TryWriteExponentBigEndian(Span<byte> destination, out int bytesWritten);
++        bool IFloatingPoint<float>.TryWriteSignificandBigEndian(Span<byte> destination, out int bytesWritten);
++        static bool INumberBase<float>.IsCanonical(float value);
++        static bool INumberBase<float>.IsComplexNumber(float value);
++        static bool INumberBase<float>.IsImaginaryNumber(float value);
++        static bool INumberBase<float>.IsZero(float value);
++        static bool INumberBase<float>.TryConvertFromChecked<TOther>(TOther value, out float result);
++        static bool INumberBase<float>.TryConvertFromSaturating<TOther>(TOther value, out float result);
++        static bool INumberBase<float>.TryConvertFromTruncating<TOther>(TOther value, out float result);
++        static bool INumberBase<float>.TryConvertToChecked<TOther>(float value, out TOther result);
++        static bool INumberBase<float>.TryConvertToSaturating<TOther>(float value, out TOther result);
++        static bool INumberBase<float>.TryConvertToTruncating<TOther>(float value, out TOther result);
+-        public static bool TryCreate<TOther>(TOther value, out float result) where TOther : INumber<TOther>;
+     }
+-    public readonly struct TimeOnly : IComparable, IComparable<TimeOnly>, IComparisonOperators<TimeOnly, TimeOnly>, IEqualityOperators<TimeOnly, TimeOnly>, IEquatable<TimeOnly>, IFormattable, IMinMaxValue<TimeOnly>, IParsable<TimeOnly>, ISpanFormattable, ISpanParsable<TimeOnly>, ISubtractionOperators<TimeOnly, TimeOnly, TimeSpan> {
++    public readonly struct TimeOnly : IComparable, IComparable<TimeOnly>, IEquatable<TimeOnly>, IFormattable, IParsable<TimeOnly>, ISpanFormattable, ISpanParsable<TimeOnly> {
+-        static TimeSpan ISubtractionOperators<TimeOnly, TimeOnly, TimeSpan>.operator checked -(TimeOnly left, TimeOnly right);
+     }
+-    public readonly struct TimeSpan : IAdditionOperators<TimeSpan, TimeSpan, TimeSpan>, IAdditiveIdentity<TimeSpan, TimeSpan>, IComparable, IComparable<TimeSpan>, IComparisonOperators<TimeSpan, TimeSpan>, IDivisionOperators<TimeSpan, double, TimeSpan>, IDivisionOperators<TimeSpan, TimeSpan, double>, IEqualityOperators<TimeSpan, TimeSpan>, IEquatable<TimeSpan>, IFormattable, IMinMaxValue<TimeSpan>, IMultiplicativeIdentity<TimeSpan, double>, IMultiplyOperators<TimeSpan, double, TimeSpan>, IParsable<TimeSpan>, ISpanFormattable, ISpanParsable<TimeSpan>, ISubtractionOperators<TimeSpan, TimeSpan, TimeSpan>, IUnaryNegationOperators<TimeSpan, TimeSpan>, IUnaryPlusOperators<TimeSpan, TimeSpan> {
++    public readonly struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IFormattable, IParsable<TimeSpan>, ISpanFormattable, ISpanParsable<TimeSpan> {
+-        static TimeSpan System.Numerics.IAdditiveIdentity<System.TimeSpan,System.TimeSpan>.AdditiveIdentity { get; }
+-        static TimeSpan System.Numerics.IMinMaxValue<System.TimeSpan>.MaxValue { get; }
+-        static TimeSpan System.Numerics.IMinMaxValue<System.TimeSpan>.MinValue { get; }
+-        static double System.Numerics.IMultiplicativeIdentity<System.TimeSpan,System.Double>.MultiplicativeIdentity { get; }
+-        static TimeSpan IAdditionOperators<TimeSpan, TimeSpan, TimeSpan>.operator checked +(TimeSpan left, TimeSpan right);
+-        static TimeSpan IDivisionOperators<TimeSpan, double, TimeSpan>.operator checked /(TimeSpan left, double right);
+-        static double IDivisionOperators<TimeSpan, TimeSpan, double>.operator checked /(TimeSpan left, TimeSpan right);
+-        static TimeSpan IMultiplyOperators<TimeSpan, double, TimeSpan>.operator checked *(TimeSpan left, double right);
+-        static TimeSpan ISubtractionOperators<TimeSpan, TimeSpan, TimeSpan>.operator checked -(TimeSpan left, TimeSpan right);
+-        static TimeSpan IUnaryNegationOperators<TimeSpan, TimeSpan>.operator checked -(TimeSpan value);
+     }
++    public readonly struct UInt128 : IAdditionOperators<UInt128, UInt128, UInt128>, IAdditiveIdentity<UInt128, UInt128>, IBinaryInteger<UInt128>, IBinaryNumber<UInt128>, IBitwiseOperators<UInt128, UInt128, UInt128>, IComparable, IComparable<UInt128>, IComparisonOperators<UInt128, UInt128>, IDecrementOperators<UInt128>, IDivisionOperators<UInt128, UInt128, UInt128>, IEqualityOperators<UInt128, UInt128>, IEquatable<UInt128>, IFormattable, IIncrementOperators<UInt128>, IMinMaxValue<UInt128>, IModulusOperators<UInt128, UInt128, UInt128>, IMultiplicativeIdentity<UInt128, UInt128>, IMultiplyOperators<UInt128, UInt128, UInt128>, INumber<UInt128>, INumberBase<UInt128>, IParsable<UInt128>, IShiftOperators<UInt128, UInt128>, ISpanFormattable, ISpanParsable<UInt128>, ISubtractionOperators<UInt128, UInt128, UInt128>, IUnaryNegationOperators<UInt128, UInt128>, IUnaryPlusOperators<UInt128, UInt128>, IUnsignedNumber<UInt128> {
++        public UInt128(ulong upper, ulong lower);
++        public static UInt128 MaxValue { get; }
++        public static UInt128 MinValue { get; }
++        public static UInt128 One { get; }
++        static UInt128 System.Numerics.IAdditiveIdentity<System.UInt128,System.UInt128>.AdditiveIdentity { get; }
++        static UInt128 System.Numerics.IMultiplicativeIdentity<System.UInt128,System.UInt128>.MultiplicativeIdentity { get; }
++        static int System.Numerics.INumberBase<System.UInt128>.Radix { get; }
++        public static UInt128 Zero { get; }
++        public static UInt128 Clamp(UInt128 value, UInt128 min, UInt128 max);
++        public int CompareTo(object? value);
++        public int CompareTo(UInt128 value);
++        public static (UInt128 Quotient, UInt128 Remainder) DivRem(UInt128 left, UInt128 right);
++        public override bool Equals(object? obj);
++        public bool Equals(UInt128 other);
++        public override int GetHashCode();
++        public static bool IsEvenInteger(UInt128 value);
++        public static bool IsOddInteger(UInt128 value);
++        public static bool IsPow2(UInt128 value);
++        public static UInt128 LeadingZeroCount(UInt128 value);
++        public static UInt128 Log2(UInt128 value);
++        public static UInt128 Max(UInt128 x, UInt128 y);
++        public static UInt128 Min(UInt128 x, UInt128 y);
++        public static UInt128 operator +(UInt128 left, UInt128 right);
++        public static UInt128 operator &(UInt128 left, UInt128 right);
++        public static UInt128 operator |(UInt128 left, UInt128 right);
++        public static UInt128 operator checked +(UInt128 left, UInt128 right);
++        public static UInt128 operator checked --(UInt128 value);
++        public static UInt128 operator checked /(UInt128 left, UInt128 right);
++        public static explicit operator checked UInt128 (double value);
++        public static explicit operator checked UInt128 (short value);
++        public static explicit operator checked UInt128 (int value);
++        public static explicit operator checked UInt128 (long value);
++        public static explicit operator checked UInt128 (nint value);
++        public static explicit operator checked UInt128 (sbyte value);
++        public static explicit operator checked UInt128 (float value);
++        public static explicit operator checked byte (UInt128 value);
++        public static explicit operator checked char (UInt128 value);
++        public static explicit operator checked short (UInt128 value);
++        public static explicit operator checked int (UInt128 value);
++        public static explicit operator checked long (UInt128 value);
++        public static explicit operator checked Int128 (UInt128 value);
++        public static explicit operator checked nint (UInt128 value);
++        public static explicit operator checked sbyte (UInt128 value);
++        public static explicit operator checked ushort (UInt128 value);
++        public static explicit operator checked uint (UInt128 value);
++        public static explicit operator checked ulong (UInt128 value);
++        public static explicit operator checked nuint (UInt128 value);
++        public static UInt128 operator checked ++(UInt128 value);
++        public static UInt128 operator checked *(UInt128 left, UInt128 right);
++        public static UInt128 operator checked -(UInt128 left, UInt128 right);
++        public static UInt128 operator checked -(UInt128 value);
++        public static UInt128 operator --(UInt128 value);
++        public static UInt128 operator /(UInt128 left, UInt128 right);
++        public static bool operator ==(UInt128 left, UInt128 right);
++        public static UInt128 operator ^(UInt128 left, UInt128 right);
++        public static explicit operator UInt128 (decimal value);
++        public static explicit operator UInt128 (double value);
++        public static explicit operator UInt128 (short value);
++        public static explicit operator UInt128 (int value);
++        public static explicit operator UInt128 (long value);
++        public static explicit operator UInt128 (nint value);
++        public static explicit operator UInt128 (sbyte value);
++        public static explicit operator UInt128 (float value);
++        public static explicit operator byte (UInt128 value);
++        public static explicit operator char (UInt128 value);
++        public static explicit operator decimal (UInt128 value);
++        public static explicit operator double (UInt128 value);
++        public static explicit operator Half (UInt128 value);
++        public static explicit operator Int128 (UInt128 value);
++        public static explicit operator short (UInt128 value);
++        public static explicit operator int (UInt128 value);
++        public static explicit operator long (UInt128 value);
++        public static explicit operator nint (UInt128 value);
++        public static explicit operator sbyte (UInt128 value);
++        public static explicit operator float (UInt128 value);
++        public static explicit operator ushort (UInt128 value);
++        public static explicit operator uint (UInt128 value);
++        public static explicit operator ulong (UInt128 value);
++        public static explicit operator nuint (UInt128 value);
++        public static bool operator >(UInt128 left, UInt128 right);
++        public static bool operator >=(UInt128 left, UInt128 right);
++        public static implicit operator UInt128 (byte value);
++        public static implicit operator UInt128 (char value);
++        public static implicit operator UInt128 (ushort value);
++        public static implicit operator UInt128 (uint value);
++        public static implicit operator UInt128 (ulong value);
++        public static implicit operator UInt128 (nuint value);
++        public static UInt128 operator ++(UInt128 value);
++        public static bool operator !=(UInt128 left, UInt128 right);
++        public static UInt128 operator <<(UInt128 value, int shiftAmount);
++        public static bool operator <(UInt128 left, UInt128 right);
++        public static bool operator <=(UInt128 left, UInt128 right);
++        public static UInt128 operator %(UInt128 left, UInt128 right);
++        public static UInt128 operator *(UInt128 left, UInt128 right);
++        public static UInt128 operator ~(UInt128 value);
++        public static UInt128 operator >>(UInt128 value, int shiftAmount);
++        public static UInt128 operator -(UInt128 left, UInt128 right);
++        public static UInt128 operator -(UInt128 value);
++        public static UInt128 operator +(UInt128 value);
++        public static UInt128 operator >>>(UInt128 value, int shiftAmount);
++        public static UInt128 Parse(ReadOnlySpan<char> s, NumberStyles style = NumberStyles.Integer, IFormatProvider? provider = null);
++        public static UInt128 Parse(ReadOnlySpan<char> s, IFormatProvider? provider);
++        public static UInt128 Parse(string s);
++        public static UInt128 Parse(string s, NumberStyles style);
++        public static UInt128 Parse(string s, NumberStyles style, IFormatProvider? provider);
++        public static UInt128 Parse(string s, IFormatProvider? provider);
++        public static UInt128 PopCount(UInt128 value);
++        public static UInt128 RotateLeft(UInt128 value, int rotateAmount);
++        public static UInt128 RotateRight(UInt128 value, int rotateAmount);
++        public static int Sign(UInt128 value);
++        int IBinaryInteger<UInt128>.GetByteCount();
++        int IBinaryInteger<UInt128>.GetShortestBitLength();
++        bool IBinaryInteger<UInt128>.TryWriteBigEndian(Span<byte> destination, out int bytesWritten);
++        bool IBinaryInteger<UInt128>.TryWriteLittleEndian(Span<byte> destination, out int bytesWritten);
++        static UInt128 INumber<UInt128>.CopySign(UInt128 value, UInt128 sign);
++        static UInt128 INumber<UInt128>.MaxNumber(UInt128 x, UInt128 y);
++        static UInt128 INumber<UInt128>.MinNumber(UInt128 x, UInt128 y);
++        static UInt128 INumberBase<UInt128>.Abs(UInt128 value);
++        static bool INumberBase<UInt128>.IsCanonical(UInt128 value);
++        static bool INumberBase<UInt128>.IsComplexNumber(UInt128 value);
++        static bool INumberBase<UInt128>.IsFinite(UInt128 value);
++        static bool INumberBase<UInt128>.IsImaginaryNumber(UInt128 value);
++        static bool INumberBase<UInt128>.IsInfinity(UInt128 value);
++        static bool INumberBase<UInt128>.IsInteger(UInt128 value);
++        static bool INumberBase<UInt128>.IsNaN(UInt128 value);
++        static bool INumberBase<UInt128>.IsNegative(UInt128 value);
++        static bool INumberBase<UInt128>.IsNegativeInfinity(UInt128 value);
++        static bool INumberBase<UInt128>.IsNormal(UInt128 value);
++        static bool INumberBase<UInt128>.IsPositive(UInt128 value);
++        static bool INumberBase<UInt128>.IsPositiveInfinity(UInt128 value);
++        static bool INumberBase<UInt128>.IsRealNumber(UInt128 value);
++        static bool INumberBase<UInt128>.IsSubnormal(UInt128 value);
++        static bool INumberBase<UInt128>.IsZero(UInt128 value);
++        static UInt128 INumberBase<UInt128>.MaxMagnitude(UInt128 x, UInt128 y);
++        static UInt128 INumberBase<UInt128>.MaxMagnitudeNumber(UInt128 x, UInt128 y);
++        static UInt128 INumberBase<UInt128>.MinMagnitude(UInt128 x, UInt128 y);
++        static UInt128 INumberBase<UInt128>.MinMagnitudeNumber(UInt128 x, UInt128 y);
++        static bool INumberBase<UInt128>.TryConvertFromChecked<TOther>(TOther value, out UInt128 result);
++        static bool INumberBase<UInt128>.TryConvertFromSaturating<TOther>(TOther value, out UInt128 result);
++        static bool INumberBase<UInt128>.TryConvertFromTruncating<TOther>(TOther value, out UInt128 result);
++        static bool INumberBase<UInt128>.TryConvertToChecked<TOther>(UInt128 value, out TOther result);
++        static bool INumberBase<UInt128>.TryConvertToSaturating<TOther>(UInt128 value, out TOther result);
++        static bool INumberBase<UInt128>.TryConvertToTruncating<TOther>(UInt128 value, out TOther result);
++        public override string ToString();
++        public string ToString(IFormatProvider? provider);
++        public string ToString(string? format);
++        public string ToString(string? format, IFormatProvider? provider);
++        public static UInt128 TrailingZeroCount(UInt128 value);
++        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default(ReadOnlySpan<char>), IFormatProvider? provider = null);
++        public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider, out UInt128 result);
++        public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, out UInt128 result);
++        public static bool TryParse(ReadOnlySpan<char> s, out UInt128 result);
++        public static bool TryParse(string? s, NumberStyles style, IFormatProvider? provider, out UInt128 result);
++        public static bool TryParse(string? s, IFormatProvider? provider, out UInt128 result);
++        public static bool TryParse(string? s, out UInt128 result);
++    }
+     public readonly struct UInt16 : IAdditionOperators<ushort, ushort, ushort>, IAdditiveIdentity<ushort, ushort>, IBinaryInteger<ushort>, IBinaryNumber<ushort>, IBitwiseOperators<ushort, ushort, ushort>, IComparable, IComparable<ushort>, IComparisonOperators<ushort, ushort>, IConvertible, IDecrementOperators<ushort>, IDivisionOperators<ushort, ushort, ushort>, IEqualityOperators<ushort, ushort>, IEquatable<ushort>, IFormattable, IIncrementOperators<ushort>, IMinMaxValue<ushort>, IModulusOperators<ushort, ushort, ushort>, IMultiplicativeIdentity<ushort, ushort>, IMultiplyOperators<ushort, ushort, ushort>, INumber<ushort>, INumberBase<ushort>, IParsable<ushort>, IShiftOperators<ushort, ushort>, ISpanFormattable, ISpanParsable<ushort>, ISubtractionOperators<ushort, ushort, ushort>, IUnaryNegationOperators<ushort, ushort>, IUnaryPlusOperators<ushort, ushort>, IUnsignedNumber<ushort> {
++        static int System.Numerics.INumberBase<System.UInt16>.Radix { get; }
+-        public static ushort CreateChecked<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static ushort CreateSaturating<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static ushort CreateTruncating<TOther>(TOther value) where TOther : INumber<TOther>;
++        public static bool IsEvenInteger(ushort value);
++        public static bool IsOddInteger(ushort value);
+-        long IBinaryInteger<ushort>.GetShortestBitLength();
++        int IBinaryInteger<ushort>.GetShortestBitLength();
++        bool IBinaryInteger<ushort>.TryWriteBigEndian(Span<byte> destination, out int bytesWritten);
+-        static ushort INumber<ushort>.Abs(ushort value);
+-        static bool INumber<ushort>.IsNegative(ushort value);
+-        static ushort INumber<ushort>.MaxMagnitude(ushort x, ushort y);
++        static ushort INumber<ushort>.MaxNumber(ushort x, ushort y);
+-        static ushort INumber<ushort>.MinMagnitude(ushort x, ushort y);
++        static ushort INumber<ushort>.MinNumber(ushort x, ushort y);
++        static ushort INumberBase<ushort>.Abs(ushort value);
++        static bool INumberBase<ushort>.IsCanonical(ushort value);
++        static bool INumberBase<ushort>.IsComplexNumber(ushort value);
++        static bool INumberBase<ushort>.IsFinite(ushort value);
++        static bool INumberBase<ushort>.IsImaginaryNumber(ushort value);
++        static bool INumberBase<ushort>.IsInfinity(ushort value);
++        static bool INumberBase<ushort>.IsInteger(ushort value);
++        static bool INumberBase<ushort>.IsNaN(ushort value);
++        static bool INumberBase<ushort>.IsNegative(ushort value);
++        static bool INumberBase<ushort>.IsNegativeInfinity(ushort value);
++        static bool INumberBase<ushort>.IsNormal(ushort value);
++        static bool INumberBase<ushort>.IsPositive(ushort value);
++        static bool INumberBase<ushort>.IsPositiveInfinity(ushort value);
++        static bool INumberBase<ushort>.IsRealNumber(ushort value);
++        static bool INumberBase<ushort>.IsSubnormal(ushort value);
++        static bool INumberBase<ushort>.IsZero(ushort value);
++        static ushort INumberBase<ushort>.MaxMagnitude(ushort x, ushort y);
++        static ushort INumberBase<ushort>.MaxMagnitudeNumber(ushort x, ushort y);
++        static ushort INumberBase<ushort>.MinMagnitude(ushort x, ushort y);
++        static ushort INumberBase<ushort>.MinMagnitudeNumber(ushort x, ushort y);
++        static bool INumberBase<ushort>.TryConvertFromChecked<TOther>(TOther value, out ushort result);
++        static bool INumberBase<ushort>.TryConvertFromSaturating<TOther>(TOther value, out ushort result);
++        static bool INumberBase<ushort>.TryConvertFromTruncating<TOther>(TOther value, out ushort result);
++        static bool INumberBase<ushort>.TryConvertToChecked<TOther>(ushort value, out TOther result);
++        static bool INumberBase<ushort>.TryConvertToSaturating<TOther>(ushort value, out TOther result);
++        static bool INumberBase<ushort>.TryConvertToTruncating<TOther>(ushort value, out TOther result);
+-        public static bool TryCreate<TOther>(TOther value, out ushort result) where TOther : INumber<TOther>;
+     }
+     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>, IConvertible, IDecrementOperators<uint>, IDivisionOperators<uint, uint, uint>, IEqualityOperators<uint, uint>, 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, uint>, ISpanFormattable, ISpanParsable<uint>, ISubtractionOperators<uint, uint, uint>, IUnaryNegationOperators<uint, uint>, IUnaryPlusOperators<uint, uint>, IUnsignedNumber<uint> {
++        static int System.Numerics.INumberBase<System.UInt32>.Radix { get; }
+-        public static uint CreateChecked<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static uint CreateSaturating<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static uint CreateTruncating<TOther>(TOther value) where TOther : INumber<TOther>;
++        public static bool IsEvenInteger(uint value);
++        public static bool IsOddInteger(uint value);
+-        long IBinaryInteger<uint>.GetShortestBitLength();
++        int IBinaryInteger<uint>.GetShortestBitLength();
++        bool IBinaryInteger<uint>.TryWriteBigEndian(Span<byte> destination, out int bytesWritten);
+-        static uint INumber<uint>.Abs(uint value);
+-        static bool INumber<uint>.IsNegative(uint value);
+-        static uint INumber<uint>.MaxMagnitude(uint x, uint y);
++        static uint INumber<uint>.MaxNumber(uint x, uint y);
+-        static uint INumber<uint>.MinMagnitude(uint x, uint y);
++        static uint INumber<uint>.MinNumber(uint x, uint y);
++        static uint INumberBase<uint>.Abs(uint value);
++        static bool INumberBase<uint>.IsCanonical(uint value);
++        static bool INumberBase<uint>.IsComplexNumber(uint value);
++        static bool INumberBase<uint>.IsFinite(uint value);
++        static bool INumberBase<uint>.IsImaginaryNumber(uint value);
++        static bool INumberBase<uint>.IsInfinity(uint value);
++        static bool INumberBase<uint>.IsInteger(uint value);
++        static bool INumberBase<uint>.IsNaN(uint value);
++        static bool INumberBase<uint>.IsNegative(uint value);
++        static bool INumberBase<uint>.IsNegativeInfinity(uint value);
++        static bool INumberBase<uint>.IsNormal(uint value);
++        static bool INumberBase<uint>.IsPositive(uint value);
++        static bool INumberBase<uint>.IsPositiveInfinity(uint value);
++        static bool INumberBase<uint>.IsRealNumber(uint value);
++        static bool INumberBase<uint>.IsSubnormal(uint value);
++        static bool INumberBase<uint>.IsZero(uint value);
++        static uint INumberBase<uint>.MaxMagnitude(uint x, uint y);
++        static uint INumberBase<uint>.MaxMagnitudeNumber(uint x, uint y);
++        static uint INumberBase<uint>.MinMagnitude(uint x, uint y);
++        static uint INumberBase<uint>.MinMagnitudeNumber(uint x, uint y);
++        static bool INumberBase<uint>.TryConvertFromChecked<TOther>(TOther value, out uint result);
++        static bool INumberBase<uint>.TryConvertFromSaturating<TOther>(TOther value, out uint result);
++        static bool INumberBase<uint>.TryConvertFromTruncating<TOther>(TOther value, out uint result);
++        static bool INumberBase<uint>.TryConvertToChecked<TOther>(uint value, out TOther result);
++        static bool INumberBase<uint>.TryConvertToSaturating<TOther>(uint value, out TOther result);
++        static bool INumberBase<uint>.TryConvertToTruncating<TOther>(uint value, out TOther result);
+-        public static bool TryCreate<TOther>(TOther value, out uint result) where TOther : INumber<TOther>;
+     }
+     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>, IConvertible, IDecrementOperators<ulong>, IDivisionOperators<ulong, ulong, ulong>, IEqualityOperators<ulong, ulong>, 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, ulong>, ISpanFormattable, ISpanParsable<ulong>, ISubtractionOperators<ulong, ulong, ulong>, IUnaryNegationOperators<ulong, ulong>, IUnaryPlusOperators<ulong, ulong>, IUnsignedNumber<ulong> {
++        static int System.Numerics.INumberBase<System.UInt64>.Radix { get; }
+-        public static ulong CreateChecked<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static ulong CreateSaturating<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static ulong CreateTruncating<TOther>(TOther value) where TOther : INumber<TOther>;
++        public static bool IsEvenInteger(ulong value);
++        public static bool IsOddInteger(ulong value);
+-        long IBinaryInteger<ulong>.GetShortestBitLength();
++        int IBinaryInteger<ulong>.GetShortestBitLength();
++        bool IBinaryInteger<ulong>.TryWriteBigEndian(Span<byte> destination, out int bytesWritten);
+-        static ulong INumber<ulong>.Abs(ulong value);
+-        static bool INumber<ulong>.IsNegative(ulong value);
+-        static ulong INumber<ulong>.MaxMagnitude(ulong x, ulong y);
++        static ulong INumber<ulong>.MaxNumber(ulong x, ulong y);
+-        static ulong INumber<ulong>.MinMagnitude(ulong x, ulong y);
++        static ulong INumber<ulong>.MinNumber(ulong x, ulong y);
++        static ulong INumberBase<ulong>.Abs(ulong value);
++        static bool INumberBase<ulong>.IsCanonical(ulong value);
++        static bool INumberBase<ulong>.IsComplexNumber(ulong value);
++        static bool INumberBase<ulong>.IsFinite(ulong value);
++        static bool INumberBase<ulong>.IsImaginaryNumber(ulong value);
++        static bool INumberBase<ulong>.IsInfinity(ulong value);
++        static bool INumberBase<ulong>.IsInteger(ulong value);
++        static bool INumberBase<ulong>.IsNaN(ulong value);
++        static bool INumberBase<ulong>.IsNegative(ulong value);
++        static bool INumberBase<ulong>.IsNegativeInfinity(ulong value);
++        static bool INumberBase<ulong>.IsNormal(ulong value);
++        static bool INumberBase<ulong>.IsPositive(ulong value);
++        static bool INumberBase<ulong>.IsPositiveInfinity(ulong value);
++        static bool INumberBase<ulong>.IsRealNumber(ulong value);
++        static bool INumberBase<ulong>.IsSubnormal(ulong value);
++        static bool INumberBase<ulong>.IsZero(ulong value);
++        static ulong INumberBase<ulong>.MaxMagnitude(ulong x, ulong y);
++        static ulong INumberBase<ulong>.MaxMagnitudeNumber(ulong x, ulong y);
++        static ulong INumberBase<ulong>.MinMagnitude(ulong x, ulong y);
++        static ulong INumberBase<ulong>.MinMagnitudeNumber(ulong x, ulong y);
++        static bool INumberBase<ulong>.TryConvertFromChecked<TOther>(TOther value, out ulong result);
++        static bool INumberBase<ulong>.TryConvertFromSaturating<TOther>(TOther value, out ulong result);
++        static bool INumberBase<ulong>.TryConvertFromTruncating<TOther>(TOther value, out ulong result);
++        static bool INumberBase<ulong>.TryConvertToChecked<TOther>(ulong value, out TOther result);
++        static bool INumberBase<ulong>.TryConvertToSaturating<TOther>(ulong value, out TOther result);
++        static bool INumberBase<ulong>.TryConvertToTruncating<TOther>(ulong value, out TOther result);
+-        public static bool TryCreate<TOther>(TOther value, out ulong result) where TOther : INumber<TOther>;
+     }
+     public readonly struct UIntPtr : IAdditionOperators<UIntPtr, UIntPtr, UIntPtr>, IAdditiveIdentity<UIntPtr, UIntPtr>, IBinaryInteger<UIntPtr>, IBinaryNumber<UIntPtr>, IBitwiseOperators<UIntPtr, UIntPtr, UIntPtr>, IComparable, IComparable<UIntPtr>, IComparisonOperators<UIntPtr, UIntPtr>, IDecrementOperators<UIntPtr>, IDivisionOperators<UIntPtr, UIntPtr, UIntPtr>, IEqualityOperators<UIntPtr, UIntPtr>, IEquatable<UIntPtr>, IFormattable, IIncrementOperators<UIntPtr>, IMinMaxValue<UIntPtr>, IModulusOperators<UIntPtr, UIntPtr, UIntPtr>, IMultiplicativeIdentity<UIntPtr, UIntPtr>, IMultiplyOperators<UIntPtr, UIntPtr, UIntPtr>, INumber<UIntPtr>, INumberBase<UIntPtr>, IParsable<UIntPtr>, ISerializable, IShiftOperators<UIntPtr, UIntPtr>, ISpanFormattable, ISpanParsable<UIntPtr>, ISubtractionOperators<UIntPtr, UIntPtr, UIntPtr>, IUnaryNegationOperators<UIntPtr, UIntPtr>, IUnaryPlusOperators<UIntPtr, UIntPtr>, IUnsignedNumber<UIntPtr> {
++        static int System.Numerics.INumberBase<nuint>.Radix { get; }
++        public static UIntPtr Clamp(UIntPtr value, UIntPtr min, UIntPtr max);
++        public static (UIntPtr Quotient, UIntPtr Remainder) DivRem(UIntPtr left, UIntPtr right);
++        public static bool IsEvenInteger(UIntPtr value);
++        public static bool IsOddInteger(UIntPtr value);
++        public static bool IsPow2(UIntPtr value);
++        public static UIntPtr LeadingZeroCount(UIntPtr value);
++        public static UIntPtr Log2(UIntPtr value);
++        public static UIntPtr Max(UIntPtr x, UIntPtr y);
++        public static UIntPtr Min(UIntPtr x, UIntPtr y);
++        public static UIntPtr PopCount(UIntPtr value);
++        public static UIntPtr RotateLeft(UIntPtr value, int rotateAmount);
++        public static UIntPtr RotateRight(UIntPtr value, int rotateAmount);
++        public static int Sign(UIntPtr value);
+-        static (UIntPtr Quotient, UIntPtr Remainder) IBinaryInteger<UIntPtr>.DivRem(UIntPtr left, UIntPtr right);
+-        long IBinaryInteger<UIntPtr>.GetShortestBitLength();
++        int IBinaryInteger<UIntPtr>.GetShortestBitLength();
+-        static UIntPtr IBinaryInteger<UIntPtr>.LeadingZeroCount(UIntPtr value);
+-        static UIntPtr IBinaryInteger<UIntPtr>.PopCount(UIntPtr value);
+-        static UIntPtr IBinaryInteger<UIntPtr>.RotateLeft(UIntPtr value, int rotateAmount);
+-        static UIntPtr IBinaryInteger<UIntPtr>.RotateRight(UIntPtr value, int rotateAmount);
+-        static UIntPtr IBinaryInteger<UIntPtr>.TrailingZeroCount(UIntPtr value);
++        bool IBinaryInteger<UIntPtr>.TryWriteBigEndian(Span<byte> destination, out int bytesWritten);
+-        static bool IBinaryNumber<UIntPtr>.IsPow2(UIntPtr value);
+-        static UIntPtr IBinaryNumber<UIntPtr>.Log2(UIntPtr value);
+-        static UIntPtr INumber<UIntPtr>.Abs(UIntPtr value);
+-        static UIntPtr INumber<UIntPtr>.Clamp(UIntPtr value, UIntPtr min, UIntPtr max);
+-        static UIntPtr INumber<UIntPtr>.CreateChecked<TOther>(TOther value);
+-        static UIntPtr INumber<UIntPtr>.CreateSaturating<TOther>(TOther value);
+-        static UIntPtr INumber<UIntPtr>.CreateTruncating<TOther>(TOther value);
+-        static bool INumber<UIntPtr>.IsNegative(UIntPtr value);
+-        static UIntPtr INumber<UIntPtr>.Max(UIntPtr x, UIntPtr y);
+-        static UIntPtr INumber<UIntPtr>.MaxMagnitude(UIntPtr x, UIntPtr y);
++        static UIntPtr INumber<UIntPtr>.MaxNumber(UIntPtr x, UIntPtr y);
+-        static UIntPtr INumber<UIntPtr>.Min(UIntPtr x, UIntPtr y);
+-        static UIntPtr INumber<UIntPtr>.MinMagnitude(UIntPtr x, UIntPtr y);
++        static UIntPtr INumber<UIntPtr>.MinNumber(UIntPtr x, UIntPtr y);
+-        static int INumber<UIntPtr>.Sign(UIntPtr value);
+-        static bool INumber<UIntPtr>.TryCreate<TOther>(TOther value, out UIntPtr result);
++        static UIntPtr INumberBase<UIntPtr>.Abs(UIntPtr value);
++        static bool INumberBase<UIntPtr>.IsCanonical(UIntPtr value);
++        static bool INumberBase<UIntPtr>.IsComplexNumber(UIntPtr value);
++        static bool INumberBase<UIntPtr>.IsFinite(UIntPtr value);
++        static bool INumberBase<UIntPtr>.IsImaginaryNumber(UIntPtr value);
++        static bool INumberBase<UIntPtr>.IsInfinity(UIntPtr value);
++        static bool INumberBase<UIntPtr>.IsInteger(UIntPtr value);
++        static bool INumberBase<UIntPtr>.IsNaN(UIntPtr value);
++        static bool INumberBase<UIntPtr>.IsNegative(UIntPtr value);
++        static bool INumberBase<UIntPtr>.IsNegativeInfinity(UIntPtr value);
++        static bool INumberBase<UIntPtr>.IsNormal(UIntPtr value);
++        static bool INumberBase<UIntPtr>.IsPositive(UIntPtr value);
++        static bool INumberBase<UIntPtr>.IsPositiveInfinity(UIntPtr value);
++        static bool INumberBase<UIntPtr>.IsRealNumber(UIntPtr value);
++        static bool INumberBase<UIntPtr>.IsSubnormal(UIntPtr value);
++        static bool INumberBase<UIntPtr>.IsZero(UIntPtr value);
++        static UIntPtr INumberBase<UIntPtr>.MaxMagnitude(UIntPtr x, UIntPtr y);
++        static UIntPtr INumberBase<UIntPtr>.MaxMagnitudeNumber(UIntPtr x, UIntPtr y);
++        static UIntPtr INumberBase<UIntPtr>.MinMagnitude(UIntPtr x, UIntPtr y);
++        static UIntPtr INumberBase<UIntPtr>.MinMagnitudeNumber(UIntPtr x, UIntPtr y);
++        static bool INumberBase<UIntPtr>.TryConvertFromChecked<TOther>(TOther value, out UIntPtr result);
++        static bool INumberBase<UIntPtr>.TryConvertFromSaturating<TOther>(TOther value, out UIntPtr result);
++        static bool INumberBase<UIntPtr>.TryConvertFromTruncating<TOther>(TOther value, out UIntPtr result);
++        static bool INumberBase<UIntPtr>.TryConvertToChecked<TOther>(UIntPtr value, out TOther result);
++        static bool INumberBase<UIntPtr>.TryConvertToSaturating<TOther>(UIntPtr value, out TOther result);
++        static bool INumberBase<UIntPtr>.TryConvertToTruncating<TOther>(UIntPtr value, out TOther result);
++        public static UIntPtr TrailingZeroCount(UIntPtr value);
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5.md
new file mode 100644
index 00000000..bc1b4c61
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5.md
@@ -0,0 +1,11 @@
+# API Difference 7.0-preview4 vs 7.0-preview5
+
+API listing follows standard diff formatting.
+Lines preceded by a '+' are additions and a '-' indicates removal.
+
+* [System.Diagnostics](7.0-preview5_System.Diagnostics.md)
+* [System.Security.Permissions](7.0-preview5_System.Security.Permissions.md)
+* [System.Windows.Forms](7.0-preview5_System.Windows.Forms.md)
+* [System.Windows.Forms.Design](7.0-preview5_System.Windows.Forms.Design.md)
+* [System.Windows.Forms.Layout](7.0-preview5_System.Windows.Forms.Layout.md)
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5_System.Diagnostics.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5_System.Diagnostics.md
new file mode 100644
index 00000000..68f7bc77
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5_System.Diagnostics.md
@@ -0,0 +1,10 @@
+# System.Diagnostics
+
+``` diff
+ namespace System.Diagnostics {
+     public sealed class PerformanceCounter : Component, ISupportInitialize {
+         public static int DefaultFileMappingSize;
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5_System.Security.Permissions.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5_System.Security.Permissions.md
new file mode 100644
index 00000000..d2590ff5
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5_System.Security.Permissions.md
@@ -0,0 +1,19 @@
+# System.Security.Permissions
+
+``` diff
+ namespace System.Security.Permissions {
+     public sealed class ReflectionPermissionAttribute : CodeAccessSecurityAttribute {
+         public bool ReflectionEmit { get; set; }
+         public bool TypeInformation { get; set; }
+     }
+     public enum ReflectionPermissionFlag {
+         AllFlags = 7,
+         ReflectionEmit = 4,
+         TypeInformation = 1,
+     }
+     public sealed class RegistryPermissionAttribute : CodeAccessSecurityAttribute {
+         public string All { get; set; }
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5_System.Windows.Forms.Design.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5_System.Windows.Forms.Design.md
new file mode 100644
index 00000000..23bf2411
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5_System.Windows.Forms.Design.md
@@ -0,0 +1,11 @@
+# System.Windows.Forms.Design
+
+``` diff
+ namespace System.Windows.Forms.Design {
+     public sealed class ToolStripItemDesignerAvailabilityAttribute : Attribute {
+-        public override bool Equals(object obj);
++        public override bool Equals(object? obj);
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5_System.Windows.Forms.Layout.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5_System.Windows.Forms.Layout.md
new file mode 100644
index 00000000..ac317ca9
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5_System.Windows.Forms.Layout.md
@@ -0,0 +1,17 @@
+# System.Windows.Forms.Layout
+
+``` diff
+ namespace System.Windows.Forms.Layout {
+     public class TableLayoutSettingsTypeConverter : TypeConverter {
+-        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType);
++        public override bool CanConvertFrom(ITypeDescriptorContext? context, Type sourceType);
+-        public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType);
++        public override bool CanConvertTo(ITypeDescriptorContext? context, Type? destinationType);
+-        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value);
++        public override object? ConvertFrom(ITypeDescriptorContext? context, CultureInfo? culture, object value);
+-        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType);
++        public override object? ConvertTo(ITypeDescriptorContext? context, CultureInfo? culture, object? value, Type destinationType);
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5_System.Windows.Forms.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5_System.Windows.Forms.md
new file mode 100644
index 00000000..79757bdf
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5_System.Windows.Forms.md
@@ -0,0 +1,227 @@
+# System.Windows.Forms
+
+``` diff
+ namespace System.Windows.Forms {
+     public abstract class AxHost : Control, ICustomTypeDescriptor, ISupportInitialize {
+         public class State : ISerializable {
+-            public State(Stream ms, int storageType, bool manualUpdate, string licKey);
++            public State(Stream ms, int storageType, bool manualUpdate, string? licKey);
+         }
+     }
+-    public struct BindingMemberInfo {
++    public struct BindingMemberInfo : IEquatable<BindingMemberInfo> {
++        public bool Equals(BindingMemberInfo other);
+     }
+     public class ContextMenuStrip : ToolStripDropDownMenu {
+-        public Control SourceControl { get; }
++        public Control? SourceControl { get; }
+     }
+     public class Control : Component, IArrangedElement, IBindableComponent, IComponent, IDisposable, IDropTarget, IHandle, IKeyboardToolTip, Interop.Ole32.IOleControl, Interop.Ole32.IOleInPlaceActiveObject, Interop.Ole32.IOleInPlaceObject, Interop.Ole32.IOleObject, Interop.Ole32.IOleWindow, Interop.Ole32.IPersist, Interop.Ole32.IPersistStorage, Interop.Ole32.IPersistStreamInit, Interop.Ole32.IQuickActivate, Interop.Ole32.IViewObject, Interop.Ole32.IViewObject2, Interop.Oleaut32.IPersistPropertyBag, ISupportOleDropSource, ISynchronizeInvoke, IWin32Window {
+-        public Control(string text);
++        public Control(string? text);
+-        public Control(string text, int left, int top, int width, int height);
++        public Control(string? text, int left, int top, int width, int height);
+-        public Control(Control parent, string text);
++        public Control(Control? parent, string? text);
+-        public Control(Control parent, string text, int left, int top, int width, int height);
++        public Control(Control? parent, string? text, int left, int top, int width, int height);
+-        public string AccessibleDefaultActionDescription { get; set; }
++        public string? AccessibleDefaultActionDescription { get; set; }
+-        public string AccessibleDescription { get; set; }
++        public string? AccessibleDescription { get; set; }
+-        public string AccessibleName { get; set; }
++        public string? AccessibleName { get; set; }
+-        public virtual Image BackgroundImage { get; set; }
++        public virtual Image? BackgroundImage { get; set; }
+-        public virtual BindingContext BindingContext { get; set; }
++        public virtual BindingContext? BindingContext { get; set; }
+-        public virtual ContextMenuStrip ContextMenuStrip { get; set; }
++        public virtual ContextMenuStrip? ContextMenuStrip { get; set; }
+         public virtual Cursor Cursor { get; set; }
+         public virtual Font Font { get; set; }
+-        public event EventHandler AutoSizeChanged;
++        public event EventHandler? AutoSizeChanged;
+-        public event EventHandler BackColorChanged;
++        public event EventHandler? BackColorChanged;
+-        public event EventHandler BackgroundImageChanged;
++        public event EventHandler? BackgroundImageChanged;
+-        public event EventHandler BackgroundImageLayoutChanged;
++        public event EventHandler? BackgroundImageLayoutChanged;
+-        public event EventHandler BindingContextChanged;
++        public event EventHandler? BindingContextChanged;
+-        public event EventHandler CausesValidationChanged;
++        public event EventHandler? CausesValidationChanged;
+-        public event EventHandler ClientSizeChanged;
++        public event EventHandler? ClientSizeChanged;
+-        public event EventHandler ContextMenuStripChanged;
++        public event EventHandler? ContextMenuStripChanged;
+-        public event EventHandler CursorChanged;
++        public event EventHandler? CursorChanged;
+-        public event EventHandler DockChanged;
++        public event EventHandler? DockChanged;
+-        public event EventHandler EnabledChanged;
++        public event EventHandler? EnabledChanged;
+-        public event EventHandler FontChanged;
++        public event EventHandler? FontChanged;
+-        public event EventHandler ForeColorChanged;
++        public event EventHandler? ForeColorChanged;
+-        protected virtual AccessibleObject GetAccessibilityObjectById(int objectId);
++        protected virtual AccessibleObject? GetAccessibilityObjectById(int objectId);
+-        public bool SelectNextControl(Control ctl, bool forward, bool tabStopOnly, bool nested, bool wrap);
++        public bool SelectNextControl(Control? ctl, bool forward, bool tabStopOnly, bool nested, bool wrap);
+     }
+     public sealed class DataGridViewAdvancedBorderStyle : ICloneable {
+-        public override bool Equals(object other);
++        public override bool Equals(object? other);
+     }
+     public class Form : ContainerControl {
++        protected override void OnGotFocus(EventArgs e);
+     }
+     public class Label : Control, IAutomationLiveRegion {
+         public override string Text { get; set; }
+     }
+-    public struct LinkArea {
++    public struct LinkArea : IEquatable<LinkArea> {
+-        public override bool Equals(object o);
++        public override bool Equals(object? o);
++        public bool Equals(LinkArea other);
+         public class LinkAreaConverter : TypeConverter {
+-            public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType);
++            public override bool CanConvertFrom(ITypeDescriptorContext? context, Type sourceType);
+-            public override object CreateInstance(ITypeDescriptorContext context, IDictionary propertyValues);
++            public override object CreateInstance(ITypeDescriptorContext? context, IDictionary propertyValues);
+-            public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value, Attribute[] attributes);
++            public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext? context, object value, Attribute[]? attributes);
+         }
+     }
+     public class ListBox : ListControl {
+         public override Font Font { get; set; }
+     }
+     public class ListView : Control {
+         public class CheckedListViewItemCollection : ICollection, IEnumerable, IList {
+-            bool System.Collections.ICollection.IsSynchronized { get; }
++            bool ICollection.IsSynchronized { get; }
+-            object System.Collections.ICollection.SyncRoot { get; }
++            object ICollection.SyncRoot { get; }
+-            bool System.Collections.IList.IsFixedSize { get; }
++            bool IList.IsFixedSize { get; }
+-            object System.Collections.IList.this[int index] { get; set; }
++            object IList.this[int index] { get; set; }
+         }
+         public class SelectedListViewItemCollection : ICollection, IEnumerable, IList {
+-            bool System.Collections.ICollection.IsSynchronized { get; }
++            bool ICollection.IsSynchronized { get; }
+-            object System.Collections.ICollection.SyncRoot { get; }
++            object ICollection.SyncRoot { get; }
+-            bool System.Collections.IList.IsFixedSize { get; }
++            bool IList.IsFixedSize { get; }
+-            object System.Collections.IList.this[int index] { get; set; }
++            object IList.this[int index] { get; set; }
+         }
+     }
+     public class ListViewHitTestInfo {
+         public ListViewItem Item { get; }
+         public ListViewHitTestLocations Location { get; }
+         public ListViewItem.ListViewSubItem SubItem { get; }
+     }
+-    public struct Message {
++    public struct Message : IEquatable<Message> {
++        public bool Equals(Message other);
+     }
+     public sealed class NotifyIcon : Component {
+         public string Text { get; set; }
+     }
+-    public struct Padding {
++    public struct Padding : IEquatable<Padding> {
++        public bool Equals(Padding other);
+     }
+     public class PrintPreviewDialog : Form {
+         public override Cursor Cursor { get; set; }
+         public override Font Font { get; set; }
+     }
+     public class ProgressBar : Control {
+         public override Font Font { get; set; }
+     }
+     public abstract class ScrollBar : Control {
+         public override Font Font { get; set; }
+     }
+     public class Splitter : Control {
+         public override Font Font { get; set; }
+     }
+     public class TabControl : Control {
+         public class TabPageCollection : ICollection, IEnumerable, IList {
+-            bool System.Collections.ICollection.IsSynchronized { get; }
++            bool ICollection.IsSynchronized { get; }
+-            object System.Collections.ICollection.SyncRoot { get; }
++            object ICollection.SyncRoot { get; }
+-            bool System.Collections.IList.IsFixedSize { get; }
++            bool IList.IsFixedSize { get; }
+-            object System.Collections.IList.this[int index] { get; set; }
++            object IList.this[int index] { get; set; }
+         }
+     }
+-    public struct TableLayoutPanelCellPosition {
++    public struct TableLayoutPanelCellPosition : IEquatable<TableLayoutPanelCellPosition> {
++        public bool Equals(TableLayoutPanelCellPosition other);
+     }
+     public class TabPage : Panel {
+         public string ImageKey { get; set; }
+         public override string Text { get; set; }
+         public string ToolTipText { get; set; }
+     }
+     public class ToolStripContentPanel : Panel {
+         public new string Name { get; set; }
+     }
+     public class ToolStripDropDownMenu : ToolStripDropDown {
++        protected override AccessibleObject CreateAccessibilityInstance();
+     }
+     public class TrackBar : Control, ISupportInitialize {
+         public override Font Font { get; set; }
+     }
+     public class TreeViewImageIndexConverter : ImageIndexConverter {
+-        public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context);
++        public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext? context);
+     }
+     public class TreeViewImageKeyConverter : ImageKeyConverter {
+-        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType);
++        public override object? ConvertTo(ITypeDescriptorContext? context, CultureInfo? culture, object? value, Type destinationType);
+     }
+     public abstract class UpDownBase : ContainerControl {
+-        public override Image BackgroundImage { get; set; }
++        public override Image? BackgroundImage { get; set; }
+-        public override ContextMenuStrip ContextMenuStrip { get; set; }
++        public override ContextMenuStrip? ContextMenuStrip { get; set; }
+         public override string Text { get; set; }
+-        public new event EventHandler AutoSizeChanged;
++        public new event EventHandler? AutoSizeChanged;
+-        public new event EventHandler BackgroundImageChanged;
++        public new event EventHandler? BackgroundImageChanged;
+-        public new event EventHandler BackgroundImageLayoutChanged;
++        public new event EventHandler? BackgroundImageLayoutChanged;
+-        public new event EventHandler MouseEnter;
++        public new event EventHandler? MouseEnter;
+-        public new event EventHandler MouseHover;
++        public new event EventHandler? MouseHover;
+-        public new event EventHandler MouseLeave;
++        public new event EventHandler? MouseLeave;
+-        public new event MouseEventHandler MouseMove;
++        public new event MouseEventHandler? MouseMove;
+-        protected virtual void OnChanged(object source, EventArgs e);
++        protected virtual void OnChanged(object? source, EventArgs e);
+-        protected virtual void OnTextBoxKeyDown(object source, KeyEventArgs e);
++        protected virtual void OnTextBoxKeyDown(object? source, KeyEventArgs e);
+-        protected virtual void OnTextBoxKeyPress(object source, KeyPressEventArgs e);
++        protected virtual void OnTextBoxKeyPress(object? source, KeyPressEventArgs e);
+-        protected virtual void OnTextBoxLostFocus(object source, EventArgs e);
++        protected virtual void OnTextBoxLostFocus(object? source, EventArgs e);
+-        protected virtual void OnTextBoxResize(object source, EventArgs e);
++        protected virtual void OnTextBoxResize(object? source, EventArgs e);
+-        protected virtual void OnTextBoxTextChanged(object source, EventArgs e);
++        protected virtual void OnTextBoxTextChanged(object? source, EventArgs e);
+     }
+     public class UserControl : ContainerControl {
+         public override string Text { get; set; }
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/README.md b/release-notes/7.0/preview/api-diff/preview5/README.md
new file mode 100644
index 00000000..e2087f33
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/README.md
@@ -0,0 +1,7 @@
+# .NET 7.0 Preview 5 API Changes
+
+The following API changes were made in .NET 7.0 Preview 5:
+
+- [Microsoft.NETCore.App](./Microsoft.NETCore.App/7.0-preview5.md)
+- [Microsoft.AspNetCore.App](./Microsoft.AspNetCore.App/7.0-preview5.md)
+- [Microsoft.WindowsDesktop.App](./Microsoft.WindowsDesktop.App/7.0-preview5.md)