diff --git a/eng/Build.props b/eng/Build.props
index f5d20fdaa0..2f0c4cbadc 100644
--- a/eng/Build.props
+++ b/eng/Build.props
@@ -38,6 +38,11 @@
     <DependencyPackageProjects Include="$(RepoRoot)src\referencePackages\src\**\NuGet.Packaging.6.12.1.csproj" />
     <DependencyPackageProjects Include="$(RepoRoot)src\referencePackages\src\**\NuGet.Protocol.6.12.1.csproj" />
     <DependencyPackageProjects Include="$(RepoRoot)src\referencePackages\src\**\NuGet.Credentials.6.12.1.csproj" />
+
+    <DependencyPackageProjects Include="$(RepoRoot)src\referencePackages\src\**\System.Runtime.CompilerServices.Unsafe.6.1.2.csproj" />
+    <DependencyPackageProjects Include="$(RepoRoot)src\referencePackages\src\**\System.Memory.4.6.3.csproj" />
+    <DependencyPackageProjects Include="$(RepoRoot)src\referencePackages\src\**\System.Threading.Tasks.Extensions.4.6.3.csproj" />
+    <DependencyPackageProjects Include="$(RepoRoot)src\referencePackages\src\**\System.Net.WebSockets.WebSocketProtocol.5.1.3.csproj" />
   </ItemGroup>
 
   <ItemGroup Condition="'$(BuildDependencyPackageProjects)' == 'true'">
diff --git a/src/referencePackages/src/system.memory/4.6.3/System.Memory.4.6.3.csproj b/src/referencePackages/src/system.memory/4.6.3/System.Memory.4.6.3.csproj
new file mode 100644
index 0000000000..fd1ae3142a
--- /dev/null
+++ b/src/referencePackages/src/system.memory/4.6.3/System.Memory.4.6.3.csproj
@@ -0,0 +1,15 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>netstandard2.0</TargetFrameworks>
+    <AssemblyName>System.Memory</AssemblyName>
+    <StrongNameKeyId>Open</StrongNameKeyId>
+  </PropertyGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
+    <PackageReference Include="System.Buffers" Version="4.6.1" />
+    <PackageReference Include="System.Numerics.Vectors" Version="4.6.1" />
+    <PackageReference Include="System.Runtime.CompilerServices.Unsafe" Version="6.1.2" />
+  </ItemGroup>
+
+</Project>
diff --git a/src/referencePackages/src/system.memory/4.6.3/lib/netstandard2.0/System.Memory.cs b/src/referencePackages/src/system.memory/4.6.3/lib/netstandard2.0/System.Memory.cs
new file mode 100644
index 0000000000..7868a23f4b
--- /dev/null
+++ b/src/referencePackages/src/system.memory/4.6.3/lib/netstandard2.0/System.Memory.cs
@@ -0,0 +1,941 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+// ------------------------------------------------------------------------------
+// Changes to this file must follow the http://aka.ms/api-review process.
+// ------------------------------------------------------------------------------
+[assembly: System.Runtime.CompilerServices.CompilationRelaxations(8)]
+[assembly: System.Runtime.CompilerServices.RuntimeCompatibility(WrapNonExceptionThrows = true)]
+[assembly: System.Diagnostics.Debuggable(System.Diagnostics.DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
+[assembly: System.Runtime.Versioning.TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
+[assembly: System.CLSCompliant(true)]
+[assembly: System.Reflection.AssemblyDefaultAlias("System.Memory")]
+[assembly: System.Resources.NeutralResourcesLanguage("en-US")]
+[assembly: System.Runtime.InteropServices.DefaultDllImportSearchPaths(System.Runtime.InteropServices.DllImportSearchPath.AssemblyDirectory | System.Runtime.InteropServices.DllImportSearchPath.System32)]
+[assembly: System.Reflection.AssemblyCompany("Microsoft Corporation")]
+[assembly: System.Reflection.AssemblyCopyright("© Microsoft Corporation. All rights reserved.")]
+[assembly: System.Reflection.AssemblyDescription("System.Memory")]
+[assembly: System.Reflection.AssemblyFileVersion("4.600.325.20307")]
+[assembly: System.Reflection.AssemblyInformationalVersion("4.6.3+f62ca0009b038cab4725a720f386623a969d73ad")]
+[assembly: System.Reflection.AssemblyProduct("Microsoft® .NET")]
+[assembly: System.Reflection.AssemblyTitle("System.Memory")]
+[assembly: System.Reflection.AssemblyMetadata("RepositoryUrl", "https://github.com/dotnet/maintenance-packages")]
+[assembly: System.Reflection.AssemblyMetadata("PreferInbox", "True")]
+[assembly: System.Reflection.AssemblyMetadata("Serviceable", "True")]
+[assembly: System.Reflection.AssemblyVersionAttribute("4.0.2.0")]
+[assembly: System.Runtime.CompilerServices.ReferenceAssembly]
+[assembly: System.Reflection.AssemblyFlagsAttribute((System.Reflection.AssemblyNameFlags)0x70)]
+namespace System
+{
+    public static partial class MemoryExtensions
+    {
+        public static ReadOnlyMemory<char> AsMemory(this string text, int start, int length) { throw null; }
+
+        public static ReadOnlyMemory<char> AsMemory(this string text, int start) { throw null; }
+
+        public static ReadOnlyMemory<char> AsMemory(this string text) { throw null; }
+
+        public static Memory<T> AsMemory<T>(this T[] array, int start, int length) { throw null; }
+
+        public static Memory<T> AsMemory<T>(this T[] array, int start) { throw null; }
+
+        public static Memory<T> AsMemory<T>(this T[] array) { throw null; }
+
+        public static Memory<T> AsMemory<T>(this ArraySegment<T> segment, int start, int length) { throw null; }
+
+        public static Memory<T> AsMemory<T>(this ArraySegment<T> segment, int start) { throw null; }
+
+        public static Memory<T> AsMemory<T>(this ArraySegment<T> segment) { throw null; }
+
+        public static ReadOnlySpan<char> AsSpan(this string text, int start, int length) { throw null; }
+
+        public static ReadOnlySpan<char> AsSpan(this string text, int start) { throw null; }
+
+        public static ReadOnlySpan<char> AsSpan(this string text) { throw null; }
+
+        public static Span<T> AsSpan<T>(this T[] array, int start, int length) { throw null; }
+
+        public static Span<T> AsSpan<T>(this T[] array, int start) { throw null; }
+
+        public static Span<T> AsSpan<T>(this T[] array) { throw null; }
+
+        public static Span<T> AsSpan<T>(this ArraySegment<T> segment, int start, int length) { throw null; }
+
+        public static Span<T> AsSpan<T>(this ArraySegment<T> segment, int start) { throw null; }
+
+        public static Span<T> AsSpan<T>(this ArraySegment<T> segment) { throw null; }
+
+        public static int BinarySearch<T>(this ReadOnlySpan<T> span, IComparable<T> comparable) { throw null; }
+
+        public static int BinarySearch<T>(this Span<T> span, IComparable<T> comparable) { throw null; }
+
+        public static int BinarySearch<T, TComparer>(this ReadOnlySpan<T> span, T value, TComparer comparer)
+            where TComparer : Collections.Generic.IComparer<T> { throw null; }
+
+        public static int BinarySearch<T, TComparable>(this ReadOnlySpan<T> span, TComparable comparable)
+            where TComparable : IComparable<T> { throw null; }
+
+        public static int BinarySearch<T, TComparer>(this Span<T> span, T value, TComparer comparer)
+            where TComparer : Collections.Generic.IComparer<T> { throw null; }
+
+        public static int BinarySearch<T, TComparable>(this Span<T> span, TComparable comparable)
+            where TComparable : IComparable<T> { throw null; }
+
+        public static int CompareTo(this ReadOnlySpan<char> span, ReadOnlySpan<char> other, StringComparison comparisonType) { throw null; }
+
+        public static bool Contains(this ReadOnlySpan<char> span, ReadOnlySpan<char> value, StringComparison comparisonType) { throw null; }
+
+        public static void CopyTo<T>(this T[] source, Memory<T> destination) { }
+
+        public static void CopyTo<T>(this T[] source, Span<T> destination) { }
+
+        public static bool EndsWith(this ReadOnlySpan<char> span, ReadOnlySpan<char> value, StringComparison comparisonType) { throw null; }
+
+        public static bool EndsWith<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> value)
+            where T : IEquatable<T> { throw null; }
+
+        public static bool EndsWith<T>(this Span<T> span, ReadOnlySpan<T> value)
+            where T : IEquatable<T> { throw null; }
+
+        public static bool Equals(this ReadOnlySpan<char> span, ReadOnlySpan<char> other, StringComparison comparisonType) { throw null; }
+
+        public static int IndexOf(this ReadOnlySpan<char> span, ReadOnlySpan<char> value, StringComparison comparisonType) { throw null; }
+
+        public static int IndexOf<T>(this ReadOnlySpan<T> span, T value)
+            where T : IEquatable<T> { throw null; }
+
+        public static int IndexOf<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> value)
+            where T : IEquatable<T> { throw null; }
+
+        public static int IndexOf<T>(this Span<T> span, T value)
+            where T : IEquatable<T> { throw null; }
+
+        public static int IndexOf<T>(this Span<T> span, ReadOnlySpan<T> value)
+            where T : IEquatable<T> { throw null; }
+
+        public static int IndexOfAny<T>(this ReadOnlySpan<T> span, T value0, T value1, T value2)
+            where T : IEquatable<T> { throw null; }
+
+        public static int IndexOfAny<T>(this ReadOnlySpan<T> span, T value0, T value1)
+            where T : IEquatable<T> { throw null; }
+
+        public static int IndexOfAny<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> values)
+            where T : IEquatable<T> { throw null; }
+
+        public static int IndexOfAny<T>(this Span<T> span, T value0, T value1, T value2)
+            where T : IEquatable<T> { throw null; }
+
+        public static int IndexOfAny<T>(this Span<T> span, T value0, T value1)
+            where T : IEquatable<T> { throw null; }
+
+        public static int IndexOfAny<T>(this Span<T> span, ReadOnlySpan<T> values)
+            where T : IEquatable<T> { throw null; }
+
+        public static bool IsWhiteSpace(this ReadOnlySpan<char> span) { throw null; }
+
+        public static int LastIndexOf<T>(this ReadOnlySpan<T> span, T value)
+            where T : IEquatable<T> { throw null; }
+
+        public static int LastIndexOf<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> value)
+            where T : IEquatable<T> { throw null; }
+
+        public static int LastIndexOf<T>(this Span<T> span, T value)
+            where T : IEquatable<T> { throw null; }
+
+        public static int LastIndexOf<T>(this Span<T> span, ReadOnlySpan<T> value)
+            where T : IEquatable<T> { throw null; }
+
+        public static int LastIndexOfAny<T>(this ReadOnlySpan<T> span, T value0, T value1, T value2)
+            where T : IEquatable<T> { throw null; }
+
+        public static int LastIndexOfAny<T>(this ReadOnlySpan<T> span, T value0, T value1)
+            where T : IEquatable<T> { throw null; }
+
+        public static int LastIndexOfAny<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> values)
+            where T : IEquatable<T> { throw null; }
+
+        public static int LastIndexOfAny<T>(this Span<T> span, T value0, T value1, T value2)
+            where T : IEquatable<T> { throw null; }
+
+        public static int LastIndexOfAny<T>(this Span<T> span, T value0, T value1)
+            where T : IEquatable<T> { throw null; }
+
+        public static int LastIndexOfAny<T>(this Span<T> span, ReadOnlySpan<T> values)
+            where T : IEquatable<T> { throw null; }
+
+        public static bool Overlaps<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> other, out int elementOffset) { throw null; }
+
+        public static bool Overlaps<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> other) { throw null; }
+
+        public static bool Overlaps<T>(this Span<T> span, ReadOnlySpan<T> other, out int elementOffset) { throw null; }
+
+        public static bool Overlaps<T>(this Span<T> span, ReadOnlySpan<T> other) { throw null; }
+
+        public static void Reverse<T>(this Span<T> span) { }
+
+        public static int SequenceCompareTo<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> other)
+            where T : IComparable<T> { throw null; }
+
+        public static int SequenceCompareTo<T>(this Span<T> span, ReadOnlySpan<T> other)
+            where T : IComparable<T> { throw null; }
+
+        public static bool SequenceEqual<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> other)
+            where T : IEquatable<T> { throw null; }
+
+        public static bool SequenceEqual<T>(this Span<T> span, ReadOnlySpan<T> other)
+            where T : IEquatable<T> { throw null; }
+
+        public static bool StartsWith(this ReadOnlySpan<char> span, ReadOnlySpan<char> value, StringComparison comparisonType) { throw null; }
+
+        public static bool StartsWith<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> value)
+            where T : IEquatable<T> { throw null; }
+
+        public static bool StartsWith<T>(this Span<T> span, ReadOnlySpan<T> value)
+            where T : IEquatable<T> { throw null; }
+
+        public static int ToLower(this ReadOnlySpan<char> source, Span<char> destination, Globalization.CultureInfo culture) { throw null; }
+
+        public static int ToLowerInvariant(this ReadOnlySpan<char> source, Span<char> destination) { throw null; }
+
+        public static int ToUpper(this ReadOnlySpan<char> source, Span<char> destination, Globalization.CultureInfo culture) { throw null; }
+
+        public static int ToUpperInvariant(this ReadOnlySpan<char> source, Span<char> destination) { throw null; }
+
+        public static ReadOnlySpan<char> Trim(this ReadOnlySpan<char> span, char trimChar) { throw null; }
+
+        public static ReadOnlySpan<char> Trim(this ReadOnlySpan<char> span, ReadOnlySpan<char> trimChars) { throw null; }
+
+        public static ReadOnlySpan<char> Trim(this ReadOnlySpan<char> span) { throw null; }
+
+        public static ReadOnlySpan<char> TrimEnd(this ReadOnlySpan<char> span, char trimChar) { throw null; }
+
+        public static ReadOnlySpan<char> TrimEnd(this ReadOnlySpan<char> span, ReadOnlySpan<char> trimChars) { throw null; }
+
+        public static ReadOnlySpan<char> TrimEnd(this ReadOnlySpan<char> span) { throw null; }
+
+        public static ReadOnlySpan<char> TrimStart(this ReadOnlySpan<char> span, char trimChar) { throw null; }
+
+        public static ReadOnlySpan<char> TrimStart(this ReadOnlySpan<char> span, ReadOnlySpan<char> trimChars) { throw null; }
+
+        public static ReadOnlySpan<char> TrimStart(this ReadOnlySpan<char> span) { throw null; }
+    }
+
+    public readonly partial struct Memory<T>
+    {
+        private readonly object _dummy;
+        private readonly int _dummyPrimitive;
+        public Memory(T[] array, int start, int length) { }
+
+        public Memory(T[] array) { }
+
+        public static Memory<T> Empty { get { throw null; } }
+
+        public bool IsEmpty { get { throw null; } }
+
+        public int Length { get { throw null; } }
+
+        public Span<T> Span { get { throw null; } }
+
+        public readonly void CopyTo(Memory<T> destination) { }
+
+        public readonly bool Equals(Memory<T> other) { throw null; }
+
+        public override readonly bool Equals(object obj) { throw null; }
+
+        public override readonly int GetHashCode() { throw null; }
+
+        public static implicit operator Memory<T>(T[] array) { throw null; }
+
+        public static implicit operator Memory<T>(ArraySegment<T> segment) { throw null; }
+
+        public static implicit operator ReadOnlyMemory<T>(Memory<T> memory) { throw null; }
+
+        public readonly Buffers.MemoryHandle Pin() { throw null; }
+
+        public readonly Memory<T> Slice(int start, int length) { throw null; }
+
+        public readonly Memory<T> Slice(int start) { throw null; }
+
+        public readonly T[] ToArray() { throw null; }
+
+        public override readonly string ToString() { throw null; }
+
+        public readonly bool TryCopyTo(Memory<T> destination) { throw null; }
+    }
+
+    public readonly partial struct ReadOnlyMemory<T>
+    {
+        private readonly object _dummy;
+        private readonly int _dummyPrimitive;
+        public ReadOnlyMemory(T[] array, int start, int length) { }
+
+        public ReadOnlyMemory(T[] array) { }
+
+        public static ReadOnlyMemory<T> Empty { get { throw null; } }
+
+        public bool IsEmpty { get { throw null; } }
+
+        public int Length { get { throw null; } }
+
+        public ReadOnlySpan<T> Span { get { throw null; } }
+
+        public readonly void CopyTo(Memory<T> destination) { }
+
+        public override readonly bool Equals(object obj) { throw null; }
+
+        public readonly bool Equals(ReadOnlyMemory<T> other) { throw null; }
+
+        public override readonly int GetHashCode() { throw null; }
+
+        public static implicit operator ReadOnlyMemory<T>(T[] array) { throw null; }
+
+        public static implicit operator ReadOnlyMemory<T>(ArraySegment<T> segment) { throw null; }
+
+        public readonly Buffers.MemoryHandle Pin() { throw null; }
+
+        public readonly ReadOnlyMemory<T> Slice(int start, int length) { throw null; }
+
+        public readonly ReadOnlyMemory<T> Slice(int start) { throw null; }
+
+        public readonly T[] ToArray() { throw null; }
+
+        public override readonly string ToString() { throw null; }
+
+        public readonly bool TryCopyTo(Memory<T> destination) { throw null; }
+    }
+
+    public readonly ref partial struct ReadOnlySpan<T>
+    {
+        private readonly object _dummy;
+        private readonly int _dummyPrimitive;
+        public ReadOnlySpan(T[] array, int start, int length) { }
+
+        public ReadOnlySpan(T[] array) { }
+
+        [CLSCompliant(false)]
+        public unsafe ReadOnlySpan(void* pointer, int length) { }
+
+        public static ReadOnlySpan<T> Empty { get { throw null; } }
+
+        public bool IsEmpty { get { throw null; } }
+
+        public ref readonly T this[int index] { get { throw null; } }
+
+        public int Length { get { throw null; } }
+
+        public readonly void CopyTo(Span<T> destination) { }
+
+        [Obsolete("Equals() on ReadOnlySpan will always throw an exception. Use == instead.")]
+        public override readonly bool Equals(object obj) { throw null; }
+
+        public readonly Enumerator GetEnumerator() { throw null; }
+
+        [Obsolete("GetHashCode() on ReadOnlySpan will always throw an exception.")]
+        public override readonly int GetHashCode() { throw null; }
+
+        public readonly ref readonly T GetPinnableReference() { throw null; }
+
+        public static bool operator ==(ReadOnlySpan<T> left, ReadOnlySpan<T> right) { throw null; }
+
+        public static implicit operator ReadOnlySpan<T>(T[] array) { throw null; }
+
+        public static implicit operator ReadOnlySpan<T>(ArraySegment<T> segment) { throw null; }
+
+        public static bool operator !=(ReadOnlySpan<T> left, ReadOnlySpan<T> right) { throw null; }
+
+        public readonly ReadOnlySpan<T> Slice(int start, int length) { throw null; }
+
+        public readonly ReadOnlySpan<T> Slice(int start) { throw null; }
+
+        public readonly T[] ToArray() { throw null; }
+
+        public override readonly string ToString() { throw null; }
+
+        public readonly bool TryCopyTo(Span<T> destination) { throw null; }
+
+        public ref partial struct Enumerator
+        {
+            private ReadOnlySpan<T> _span;
+            private object _dummy;
+            private int _dummyPrimitive;
+            public ref readonly T Current { get { throw null; } }
+
+            public bool MoveNext() { throw null; }
+        }
+    }
+
+    public readonly partial struct SequencePosition : IEquatable<SequencePosition>
+    {
+        private readonly object _dummy;
+        private readonly int _dummyPrimitive;
+        public SequencePosition(object @object, int integer) { }
+
+        public override readonly bool Equals(object obj) { throw null; }
+
+        public readonly bool Equals(SequencePosition other) { throw null; }
+
+        public override readonly int GetHashCode() { throw null; }
+
+        public readonly int GetInteger() { throw null; }
+
+        public readonly object GetObject() { throw null; }
+    }
+
+    public readonly ref partial struct Span<T>
+    {
+        private readonly object _dummy;
+        private readonly int _dummyPrimitive;
+        public Span(T[] array, int start, int length) { }
+
+        public Span(T[] array) { }
+
+        [CLSCompliant(false)]
+        public unsafe Span(void* pointer, int length) { }
+
+        public static Span<T> Empty { get { throw null; } }
+
+        public bool IsEmpty { get { throw null; } }
+
+        public ref T this[int index] { get { throw null; } }
+
+        public int Length { get { throw null; } }
+
+        public readonly void Clear() { }
+
+        public readonly void CopyTo(Span<T> destination) { }
+
+        [Obsolete("Equals() on Span will always throw an exception. Use == instead.")]
+        public override readonly bool Equals(object obj) { throw null; }
+
+        public readonly void Fill(T value) { }
+
+        public readonly Enumerator GetEnumerator() { throw null; }
+
+        [Obsolete("GetHashCode() on Span will always throw an exception.")]
+        public override readonly int GetHashCode() { throw null; }
+
+        public readonly ref T GetPinnableReference() { throw null; }
+
+        public static bool operator ==(Span<T> left, Span<T> right) { throw null; }
+
+        public static implicit operator Span<T>(T[] array) { throw null; }
+
+        public static implicit operator Span<T>(ArraySegment<T> segment) { throw null; }
+
+        public static implicit operator ReadOnlySpan<T>(Span<T> span) { throw null; }
+
+        public static bool operator !=(Span<T> left, Span<T> right) { throw null; }
+
+        public readonly Span<T> Slice(int start, int length) { throw null; }
+
+        public readonly Span<T> Slice(int start) { throw null; }
+
+        public readonly T[] ToArray() { throw null; }
+
+        public override readonly string ToString() { throw null; }
+
+        public readonly bool TryCopyTo(Span<T> destination) { throw null; }
+
+        public ref partial struct Enumerator
+        {
+            private Span<T> _span;
+            private object _dummy;
+            private int _dummyPrimitive;
+            public ref T Current { get { throw null; } }
+
+            public bool MoveNext() { throw null; }
+        }
+    }
+}
+
+namespace System.Buffers
+{
+    public static partial class BuffersExtensions
+    {
+        public static void CopyTo<T>(this in ReadOnlySequence<T> source, Span<T> destination) { }
+
+        public static SequencePosition? PositionOf<T>(this in ReadOnlySequence<T> source, T value)
+            where T : IEquatable<T> { throw null; }
+
+        public static T[] ToArray<T>(this in ReadOnlySequence<T> sequence) { throw null; }
+
+        public static void Write<T>(this IBufferWriter<T> writer, ReadOnlySpan<T> value) { }
+    }
+
+    public partial interface IBufferWriter<T>
+    {
+        void Advance(int count);
+        Memory<T> GetMemory(int sizeHint = 0);
+        Span<T> GetSpan(int sizeHint = 0);
+    }
+
+    public partial interface IMemoryOwner<T> : IDisposable
+    {
+        Memory<T> Memory { get; }
+    }
+
+    public partial interface IPinnable
+    {
+        MemoryHandle Pin(int elementIndex);
+        void Unpin();
+    }
+
+    public partial struct MemoryHandle : IDisposable
+    {
+        private object _dummy;
+        private int _dummyPrimitive;
+        [CLSCompliant(false)]
+        public unsafe MemoryHandle(void* pointer, Runtime.InteropServices.GCHandle handle = default, IPinnable pinnable = null) { }
+
+        [CLSCompliant(false)]
+        public unsafe void* Pointer { get { throw null; } }
+
+        public void Dispose() { }
+    }
+
+    public abstract partial class MemoryManager<T> : IMemoryOwner<T>, IDisposable, IPinnable
+    {
+        public virtual Memory<T> Memory { get { throw null; } }
+
+        protected Memory<T> CreateMemory(int start, int length) { throw null; }
+
+        protected Memory<T> CreateMemory(int length) { throw null; }
+
+        protected abstract void Dispose(bool disposing);
+        public abstract Span<T> GetSpan();
+        public abstract MemoryHandle Pin(int elementIndex = 0);
+        void IDisposable.Dispose() { }
+
+        protected internal virtual bool TryGetArray(out ArraySegment<T> segment) { throw null; }
+
+        public abstract void Unpin();
+    }
+
+    public abstract partial class MemoryPool<T> : IDisposable
+    {
+        public abstract int MaxBufferSize { get; }
+
+        public static MemoryPool<T> Shared { get { throw null; } }
+
+        public void Dispose() { }
+
+        protected abstract void Dispose(bool disposing);
+        public abstract IMemoryOwner<T> Rent(int minBufferSize = -1);
+    }
+
+    public enum OperationStatus
+    {
+        Done = 0,
+        DestinationTooSmall = 1,
+        NeedMoreData = 2,
+        InvalidData = 3
+    }
+
+    public abstract partial class ReadOnlySequenceSegment<T>
+    {
+        public ReadOnlyMemory<T> Memory { get { throw null; } protected set { } }
+
+        public ReadOnlySequenceSegment<T> Next { get { throw null; } protected set { } }
+
+        public long RunningIndex { get { throw null; } protected set { } }
+    }
+
+    public readonly partial struct ReadOnlySequence<T>
+    {
+        public static readonly ReadOnlySequence<T> Empty;
+        public ReadOnlySequence(T[] array, int start, int length) { }
+
+        public ReadOnlySequence(T[] array) { }
+
+        public ReadOnlySequence(ReadOnlySequenceSegment<T> startSegment, int startIndex, ReadOnlySequenceSegment<T> endSegment, int endIndex) { }
+
+        public ReadOnlySequence(ReadOnlyMemory<T> memory) { }
+
+        public SequencePosition End { get { throw null; } }
+
+        public ReadOnlyMemory<T> First { get { throw null; } }
+
+        public bool IsEmpty { get { throw null; } }
+
+        public bool IsSingleSegment { get { throw null; } }
+
+        public long Length { get { throw null; } }
+
+        public SequencePosition Start { get { throw null; } }
+
+        public readonly Enumerator GetEnumerator() { throw null; }
+
+        public readonly SequencePosition GetPosition(long offset, SequencePosition origin) { throw null; }
+
+        public readonly SequencePosition GetPosition(long offset) { throw null; }
+
+        public readonly ReadOnlySequence<T> Slice(int start, int length) { throw null; }
+
+        public readonly ReadOnlySequence<T> Slice(int start, SequencePosition end) { throw null; }
+
+        public readonly ReadOnlySequence<T> Slice(long start, long length) { throw null; }
+
+        public readonly ReadOnlySequence<T> Slice(long start, SequencePosition end) { throw null; }
+
+        public readonly ReadOnlySequence<T> Slice(long start) { throw null; }
+
+        public readonly ReadOnlySequence<T> Slice(SequencePosition start, int length) { throw null; }
+
+        public readonly ReadOnlySequence<T> Slice(SequencePosition start, long length) { throw null; }
+
+        public readonly ReadOnlySequence<T> Slice(SequencePosition start, SequencePosition end) { throw null; }
+
+        public readonly ReadOnlySequence<T> Slice(SequencePosition start) { throw null; }
+
+        public override readonly string ToString() { throw null; }
+
+        public readonly bool TryGet(ref SequencePosition position, out ReadOnlyMemory<T> memory, bool advance = true) { throw null; }
+
+        public partial struct Enumerator
+        {
+            private ReadOnlySequence<T> _sequence;
+            private ReadOnlyMemory<T> _currentMemory;
+            private int _dummyPrimitive;
+            public Enumerator(in ReadOnlySequence<T> sequence) { }
+
+            public ReadOnlyMemory<T> Current { get { throw null; } }
+
+            public bool MoveNext() { throw null; }
+        }
+    }
+
+    public readonly partial struct StandardFormat : IEquatable<StandardFormat>
+    {
+        private readonly int _dummyPrimitive;
+        public const byte MaxPrecision = 99;
+        public const byte NoPrecision = 255;
+        public StandardFormat(char symbol, byte precision = 255) { }
+
+        public bool HasPrecision { get { throw null; } }
+
+        public bool IsDefault { get { throw null; } }
+
+        public byte Precision { get { throw null; } }
+
+        public char Symbol { get { throw null; } }
+
+        public readonly bool Equals(StandardFormat other) { throw null; }
+
+        public override readonly bool Equals(object obj) { throw null; }
+
+        public override readonly int GetHashCode() { throw null; }
+
+        public static bool operator ==(StandardFormat left, StandardFormat right) { throw null; }
+
+        public static implicit operator StandardFormat(char symbol) { throw null; }
+
+        public static bool operator !=(StandardFormat left, StandardFormat right) { throw null; }
+
+        public static StandardFormat Parse(ReadOnlySpan<char> format) { throw null; }
+
+        public static StandardFormat Parse(string format) { throw null; }
+
+        public override readonly string ToString() { throw null; }
+    }
+}
+
+namespace System.Buffers.Binary
+{
+    public static partial class BinaryPrimitives
+    {
+        public static short ReadInt16BigEndian(ReadOnlySpan<byte> source) { throw null; }
+
+        public static short ReadInt16LittleEndian(ReadOnlySpan<byte> source) { throw null; }
+
+        public static int ReadInt32BigEndian(ReadOnlySpan<byte> source) { throw null; }
+
+        public static int ReadInt32LittleEndian(ReadOnlySpan<byte> source) { throw null; }
+
+        public static long ReadInt64BigEndian(ReadOnlySpan<byte> source) { throw null; }
+
+        public static long ReadInt64LittleEndian(ReadOnlySpan<byte> source) { throw null; }
+
+        [CLSCompliant(false)]
+        public static ushort ReadUInt16BigEndian(ReadOnlySpan<byte> source) { throw null; }
+
+        [CLSCompliant(false)]
+        public static ushort ReadUInt16LittleEndian(ReadOnlySpan<byte> source) { throw null; }
+
+        [CLSCompliant(false)]
+        public static uint ReadUInt32BigEndian(ReadOnlySpan<byte> source) { throw null; }
+
+        [CLSCompliant(false)]
+        public static uint ReadUInt32LittleEndian(ReadOnlySpan<byte> source) { throw null; }
+
+        [CLSCompliant(false)]
+        public static ulong ReadUInt64BigEndian(ReadOnlySpan<byte> source) { throw null; }
+
+        [CLSCompliant(false)]
+        public static ulong ReadUInt64LittleEndian(ReadOnlySpan<byte> source) { throw null; }
+
+        public static byte ReverseEndianness(byte value) { throw null; }
+
+        public static short ReverseEndianness(short value) { throw null; }
+
+        public static int ReverseEndianness(int value) { throw null; }
+
+        public static long ReverseEndianness(long value) { throw null; }
+
+        [CLSCompliant(false)]
+        public static sbyte ReverseEndianness(sbyte value) { throw null; }
+
+        [CLSCompliant(false)]
+        public static ushort ReverseEndianness(ushort value) { throw null; }
+
+        [CLSCompliant(false)]
+        public static uint ReverseEndianness(uint value) { throw null; }
+
+        [CLSCompliant(false)]
+        public static ulong ReverseEndianness(ulong value) { throw null; }
+
+        public static bool TryReadInt16BigEndian(ReadOnlySpan<byte> source, out short value) { throw null; }
+
+        public static bool TryReadInt16LittleEndian(ReadOnlySpan<byte> source, out short value) { throw null; }
+
+        public static bool TryReadInt32BigEndian(ReadOnlySpan<byte> source, out int value) { throw null; }
+
+        public static bool TryReadInt32LittleEndian(ReadOnlySpan<byte> source, out int value) { throw null; }
+
+        public static bool TryReadInt64BigEndian(ReadOnlySpan<byte> source, out long value) { throw null; }
+
+        public static bool TryReadInt64LittleEndian(ReadOnlySpan<byte> source, out long value) { throw null; }
+
+        [CLSCompliant(false)]
+        public static bool TryReadUInt16BigEndian(ReadOnlySpan<byte> source, out ushort value) { throw null; }
+
+        [CLSCompliant(false)]
+        public static bool TryReadUInt16LittleEndian(ReadOnlySpan<byte> source, out ushort value) { throw null; }
+
+        [CLSCompliant(false)]
+        public static bool TryReadUInt32BigEndian(ReadOnlySpan<byte> source, out uint value) { throw null; }
+
+        [CLSCompliant(false)]
+        public static bool TryReadUInt32LittleEndian(ReadOnlySpan<byte> source, out uint value) { throw null; }
+
+        [CLSCompliant(false)]
+        public static bool TryReadUInt64BigEndian(ReadOnlySpan<byte> source, out ulong value) { throw null; }
+
+        [CLSCompliant(false)]
+        public static bool TryReadUInt64LittleEndian(ReadOnlySpan<byte> source, out ulong value) { throw null; }
+
+        public static bool TryWriteInt16BigEndian(Span<byte> destination, short value) { throw null; }
+
+        public static bool TryWriteInt16LittleEndian(Span<byte> destination, short value) { throw null; }
+
+        public static bool TryWriteInt32BigEndian(Span<byte> destination, int value) { throw null; }
+
+        public static bool TryWriteInt32LittleEndian(Span<byte> destination, int value) { throw null; }
+
+        public static bool TryWriteInt64BigEndian(Span<byte> destination, long value) { throw null; }
+
+        public static bool TryWriteInt64LittleEndian(Span<byte> destination, long value) { throw null; }
+
+        [CLSCompliant(false)]
+        public static bool TryWriteUInt16BigEndian(Span<byte> destination, ushort value) { throw null; }
+
+        [CLSCompliant(false)]
+        public static bool TryWriteUInt16LittleEndian(Span<byte> destination, ushort value) { throw null; }
+
+        [CLSCompliant(false)]
+        public static bool TryWriteUInt32BigEndian(Span<byte> destination, uint value) { throw null; }
+
+        [CLSCompliant(false)]
+        public static bool TryWriteUInt32LittleEndian(Span<byte> destination, uint value) { throw null; }
+
+        [CLSCompliant(false)]
+        public static bool TryWriteUInt64BigEndian(Span<byte> destination, ulong value) { throw null; }
+
+        [CLSCompliant(false)]
+        public static bool TryWriteUInt64LittleEndian(Span<byte> destination, ulong value) { throw null; }
+
+        public static void WriteInt16BigEndian(Span<byte> destination, short value) { }
+
+        public static void WriteInt16LittleEndian(Span<byte> destination, short value) { }
+
+        public static void WriteInt32BigEndian(Span<byte> destination, int value) { }
+
+        public static void WriteInt32LittleEndian(Span<byte> destination, int value) { }
+
+        public static void WriteInt64BigEndian(Span<byte> destination, long value) { }
+
+        public static void WriteInt64LittleEndian(Span<byte> destination, long value) { }
+
+        [CLSCompliant(false)]
+        public static void WriteUInt16BigEndian(Span<byte> destination, ushort value) { }
+
+        [CLSCompliant(false)]
+        public static void WriteUInt16LittleEndian(Span<byte> destination, ushort value) { }
+
+        [CLSCompliant(false)]
+        public static void WriteUInt32BigEndian(Span<byte> destination, uint value) { }
+
+        [CLSCompliant(false)]
+        public static void WriteUInt32LittleEndian(Span<byte> destination, uint value) { }
+
+        [CLSCompliant(false)]
+        public static void WriteUInt64BigEndian(Span<byte> destination, ulong value) { }
+
+        [CLSCompliant(false)]
+        public static void WriteUInt64LittleEndian(Span<byte> destination, ulong value) { }
+    }
+}
+
+namespace System.Buffers.Text
+{
+    public static partial class Base64
+    {
+        public static OperationStatus DecodeFromUtf8(ReadOnlySpan<byte> utf8, Span<byte> bytes, out int bytesConsumed, out int bytesWritten, bool isFinalBlock = true) { throw null; }
+
+        public static OperationStatus DecodeFromUtf8InPlace(Span<byte> buffer, out int bytesWritten) { throw null; }
+
+        public static OperationStatus EncodeToUtf8(ReadOnlySpan<byte> bytes, Span<byte> utf8, out int bytesConsumed, out int bytesWritten, bool isFinalBlock = true) { throw null; }
+
+        public static OperationStatus EncodeToUtf8InPlace(Span<byte> buffer, int dataLength, out int bytesWritten) { throw null; }
+
+        public static int GetMaxDecodedFromUtf8Length(int length) { throw null; }
+
+        public static int GetMaxEncodedToUtf8Length(int length) { throw null; }
+    }
+
+    public static partial class Utf8Formatter
+    {
+        public static bool TryFormat(bool value, Span<byte> destination, out int bytesWritten, StandardFormat format = default) { throw null; }
+
+        public static bool TryFormat(byte value, Span<byte> destination, out int bytesWritten, StandardFormat format = default) { throw null; }
+
+        public static bool TryFormat(DateTime value, Span<byte> destination, out int bytesWritten, StandardFormat format = default) { throw null; }
+
+        public static bool TryFormat(DateTimeOffset value, Span<byte> destination, out int bytesWritten, StandardFormat format = default) { throw null; }
+
+        public static bool TryFormat(decimal value, Span<byte> destination, out int bytesWritten, StandardFormat format = default) { throw null; }
+
+        public static bool TryFormat(double value, Span<byte> destination, out int bytesWritten, StandardFormat format = default) { throw null; }
+
+        public static bool TryFormat(Guid value, Span<byte> destination, out int bytesWritten, StandardFormat format = default) { throw null; }
+
+        public static bool TryFormat(short value, Span<byte> destination, out int bytesWritten, StandardFormat format = default) { throw null; }
+
+        public static bool TryFormat(int value, Span<byte> destination, out int bytesWritten, StandardFormat format = default) { throw null; }
+
+        public static bool TryFormat(long value, Span<byte> destination, out int bytesWritten, StandardFormat format = default) { throw null; }
+
+        [CLSCompliant(false)]
+        public static bool TryFormat(sbyte value, Span<byte> destination, out int bytesWritten, StandardFormat format = default) { throw null; }
+
+        public static bool TryFormat(float value, Span<byte> destination, out int bytesWritten, StandardFormat format = default) { throw null; }
+
+        public static bool TryFormat(TimeSpan value, Span<byte> destination, out int bytesWritten, StandardFormat format = default) { throw null; }
+
+        [CLSCompliant(false)]
+        public static bool TryFormat(ushort value, Span<byte> destination, out int bytesWritten, StandardFormat format = default) { throw null; }
+
+        [CLSCompliant(false)]
+        public static bool TryFormat(uint value, Span<byte> destination, out int bytesWritten, StandardFormat format = default) { throw null; }
+
+        [CLSCompliant(false)]
+        public static bool TryFormat(ulong value, Span<byte> destination, out int bytesWritten, StandardFormat format = default) { throw null; }
+    }
+
+    public static partial class Utf8Parser
+    {
+        public static bool TryParse(ReadOnlySpan<byte> source, out bool value, out int bytesConsumed, char standardFormat = '\0') { throw null; }
+
+        public static bool TryParse(ReadOnlySpan<byte> source, out byte value, out int bytesConsumed, char standardFormat = '\0') { throw null; }
+
+        public static bool TryParse(ReadOnlySpan<byte> source, out DateTime value, out int bytesConsumed, char standardFormat = '\0') { throw null; }
+
+        public static bool TryParse(ReadOnlySpan<byte> source, out DateTimeOffset value, out int bytesConsumed, char standardFormat = '\0') { throw null; }
+
+        public static bool TryParse(ReadOnlySpan<byte> source, out decimal value, out int bytesConsumed, char standardFormat = '\0') { throw null; }
+
+        public static bool TryParse(ReadOnlySpan<byte> source, out double value, out int bytesConsumed, char standardFormat = '\0') { throw null; }
+
+        public static bool TryParse(ReadOnlySpan<byte> source, out Guid value, out int bytesConsumed, char standardFormat = '\0') { throw null; }
+
+        public static bool TryParse(ReadOnlySpan<byte> source, out short value, out int bytesConsumed, char standardFormat = '\0') { throw null; }
+
+        public static bool TryParse(ReadOnlySpan<byte> source, out int value, out int bytesConsumed, char standardFormat = '\0') { throw null; }
+
+        public static bool TryParse(ReadOnlySpan<byte> source, out long value, out int bytesConsumed, char standardFormat = '\0') { throw null; }
+
+        [CLSCompliant(false)]
+        public static bool TryParse(ReadOnlySpan<byte> source, out sbyte value, out int bytesConsumed, char standardFormat = '\0') { throw null; }
+
+        public static bool TryParse(ReadOnlySpan<byte> source, out float value, out int bytesConsumed, char standardFormat = '\0') { throw null; }
+
+        public static bool TryParse(ReadOnlySpan<byte> source, out TimeSpan value, out int bytesConsumed, char standardFormat = '\0') { throw null; }
+
+        [CLSCompliant(false)]
+        public static bool TryParse(ReadOnlySpan<byte> source, out ushort value, out int bytesConsumed, char standardFormat = '\0') { throw null; }
+
+        [CLSCompliant(false)]
+        public static bool TryParse(ReadOnlySpan<byte> source, out uint value, out int bytesConsumed, char standardFormat = '\0') { throw null; }
+
+        [CLSCompliant(false)]
+        public static bool TryParse(ReadOnlySpan<byte> source, out ulong value, out int bytesConsumed, char standardFormat = '\0') { throw null; }
+    }
+}
+
+namespace System.Runtime.InteropServices
+{
+    public static partial class MemoryMarshal
+    {
+        public static ReadOnlySpan<byte> AsBytes<T>(ReadOnlySpan<T> span)
+            where T : struct { throw null; }
+
+        public static Span<byte> AsBytes<T>(Span<T> span)
+            where T : struct { throw null; }
+
+        public static Memory<T> AsMemory<T>(ReadOnlyMemory<T> memory) { throw null; }
+
+        public static ReadOnlySpan<TTo> Cast<TFrom, TTo>(ReadOnlySpan<TFrom> span)
+            where TFrom : struct where TTo : struct { throw null; }
+
+        public static Span<TTo> Cast<TFrom, TTo>(Span<TFrom> span)
+            where TFrom : struct where TTo : struct { throw null; }
+
+        public static Memory<T> CreateFromPinnedArray<T>(T[] array, int start, int length) { throw null; }
+
+        public static ref T GetReference<T>(ReadOnlySpan<T> span) { throw null; }
+
+        public static ref T GetReference<T>(Span<T> span) { throw null; }
+
+        public static T Read<T>(ReadOnlySpan<byte> source)
+            where T : struct { throw null; }
+
+        public static Collections.Generic.IEnumerable<T> ToEnumerable<T>(ReadOnlyMemory<T> memory) { throw null; }
+
+        public static bool TryGetArray<T>(ReadOnlyMemory<T> memory, out ArraySegment<T> segment) { throw null; }
+
+        public static bool TryGetMemoryManager<T, TManager>(ReadOnlyMemory<T> memory, out TManager manager, out int start, out int length)
+            where TManager : Buffers.MemoryManager<T> { throw null; }
+
+        public static bool TryGetMemoryManager<T, TManager>(ReadOnlyMemory<T> memory, out TManager manager)
+            where TManager : Buffers.MemoryManager<T> { throw null; }
+
+        public static bool TryGetString(ReadOnlyMemory<char> memory, out string text, out int start, out int length) { throw null; }
+
+        public static bool TryRead<T>(ReadOnlySpan<byte> source, out T value)
+            where T : struct { throw null; }
+
+        public static bool TryWrite<T>(Span<byte> destination, ref T value)
+            where T : struct { throw null; }
+
+        public static void Write<T>(Span<byte> destination, ref T value)
+            where T : struct { }
+    }
+
+    public static partial class SequenceMarshal
+    {
+        public static bool TryGetArray<T>(Buffers.ReadOnlySequence<T> sequence, out ArraySegment<T> segment) { throw null; }
+
+        public static bool TryGetReadOnlyMemory<T>(Buffers.ReadOnlySequence<T> sequence, out ReadOnlyMemory<T> memory) { throw null; }
+
+        public static bool TryGetReadOnlySequenceSegment<T>(Buffers.ReadOnlySequence<T> sequence, out Buffers.ReadOnlySequenceSegment<T> startSegment, out int startIndex, out Buffers.ReadOnlySequenceSegment<T> endSegment, out int endIndex) { throw null; }
+    }
+}
\ No newline at end of file
diff --git a/src/referencePackages/src/system.memory/4.6.3/lib/netstandard2.1/_._ b/src/referencePackages/src/system.memory/4.6.3/lib/netstandard2.1/_._
new file mode 100755
index 0000000000..e69de29bb2
diff --git a/src/referencePackages/src/system.memory/4.6.3/system.memory.nuspec b/src/referencePackages/src/system.memory/4.6.3/system.memory.nuspec
new file mode 100644
index 0000000000..93adfce685
--- /dev/null
+++ b/src/referencePackages/src/system.memory/4.6.3/system.memory.nuspec
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<package xmlns="http://schemas.microsoft.com/packaging/2013/05/nuspec.xsd">
+  <metadata>
+    <id>System.Memory</id>
+    <version>4.6.3</version>
+    <authors>Microsoft</authors>
+    <requireLicenseAcceptance>true</requireLicenseAcceptance>
+    <license type="expression">MIT</license>
+    <licenseUrl>https://licenses.nuget.org/MIT</licenseUrl>
+    <projectUrl>https://github.com/dotnet/maintenance-packages</projectUrl>
+    <description>System.Memory</description>
+    <copyright>© Microsoft Corporation. All rights reserved.</copyright>
+    <serviceable>true</serviceable>
+    <repository type="git" url="https://github.com/dotnet/maintenance-packages" commit="f62ca0009b038cab4725a720f386623a969d73ad" />
+    <dependencies>
+      <group targetFramework=".NETStandard2.0">
+        <dependency id="System.Buffers" version="4.6.1" exclude="Build,Analyzers" />
+        <dependency id="System.Numerics.Vectors" version="4.6.1" exclude="Build,Analyzers" />
+        <dependency id="System.Runtime.CompilerServices.Unsafe" version="6.1.2" exclude="Build,Analyzers" />
+      </group>
+      <group targetFramework=".NETStandard2.1" />
+    </dependencies>
+  </metadata>
+</package>
\ No newline at end of file
diff --git a/src/referencePackages/src/system.net.websockets.websocketprotocol/5.1.3/System.Net.WebSockets.WebSocketProtocol.5.1.3.csproj b/src/referencePackages/src/system.net.websockets.websocketprotocol/5.1.3/System.Net.WebSockets.WebSocketProtocol.5.1.3.csproj
new file mode 100644
index 0000000000..2059c7cfdf
--- /dev/null
+++ b/src/referencePackages/src/system.net.websockets.websocketprotocol/5.1.3/System.Net.WebSockets.WebSocketProtocol.5.1.3.csproj
@@ -0,0 +1,17 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>net6.0;netstandard2.0</TargetFrameworks>
+    <AssemblyName>System.Net.WebSockets.WebSocketProtocol</AssemblyName>
+    <StrongNameKeyId>Open</StrongNameKeyId>
+  </PropertyGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
+    <PackageReference Include="System.Buffers" Version="4.6.1" />
+    <PackageReference Include="System.Memory" Version="4.6.3" />
+    <PackageReference Include="System.Numerics.Vectors" Version="4.6.1" />
+    <PackageReference Include="System.Runtime.CompilerServices.Unsafe" Version="6.1.2" />
+    <PackageReference Include="System.Threading.Tasks.Extensions" Version="4.6.3" />
+  </ItemGroup>
+
+</Project>
diff --git a/src/referencePackages/src/system.net.websockets.websocketprotocol/5.1.3/lib/net6.0/System.Net.WebSockets.WebSocketProtocol.cs b/src/referencePackages/src/system.net.websockets.websocketprotocol/5.1.3/lib/net6.0/System.Net.WebSockets.WebSocketProtocol.cs
new file mode 100644
index 0000000000..66b1d1f977
--- /dev/null
+++ b/src/referencePackages/src/system.net.websockets.websocketprotocol/5.1.3/lib/net6.0/System.Net.WebSockets.WebSocketProtocol.cs
@@ -0,0 +1,34 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+// ------------------------------------------------------------------------------
+// Changes to this file must follow the http://aka.ms/api-review process.
+// ------------------------------------------------------------------------------
+[assembly: System.Runtime.CompilerServices.CompilationRelaxations(8)]
+[assembly: System.Runtime.CompilerServices.RuntimeCompatibility(WrapNonExceptionThrows = true)]
+[assembly: System.Diagnostics.Debuggable(System.Diagnostics.DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
+[assembly: System.Runtime.Versioning.TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
+[assembly: System.CLSCompliant(true)]
+[assembly: System.Reflection.AssemblyDefaultAlias("System.Net.WebSockets.WebSocketProtocol")]
+[assembly: System.Resources.NeutralResourcesLanguage("en-US")]
+[assembly: System.Runtime.InteropServices.DefaultDllImportSearchPaths(System.Runtime.InteropServices.DllImportSearchPath.AssemblyDirectory | System.Runtime.InteropServices.DllImportSearchPath.System32)]
+[assembly: System.Reflection.AssemblyCompany("Microsoft Corporation")]
+[assembly: System.Reflection.AssemblyCopyright("© Microsoft Corporation. All rights reserved.")]
+[assembly: System.Reflection.AssemblyDescription("System.Net.WebSockets.WebSocketProtocol")]
+[assembly: System.Reflection.AssemblyFileVersion("5.100.325.20307")]
+[assembly: System.Reflection.AssemblyInformationalVersion("5.1.3+f62ca0009b038cab4725a720f386623a969d73ad")]
+[assembly: System.Reflection.AssemblyProduct("Microsoft® .NET")]
+[assembly: System.Reflection.AssemblyTitle("System.Net.WebSockets.WebSocketProtocol")]
+[assembly: System.Reflection.AssemblyMetadata("RepositoryUrl", "https://github.com/dotnet/maintenance-packages")]
+[assembly: System.Reflection.AssemblyMetadata("PreferInbox", "True")]
+[assembly: System.Reflection.AssemblyMetadata("Serviceable", "True")]
+[assembly: System.Reflection.AssemblyVersionAttribute("5.1.3.0")]
+[assembly: System.Runtime.CompilerServices.ReferenceAssembly]
+[assembly: System.Reflection.AssemblyFlagsAttribute((System.Reflection.AssemblyNameFlags)0x70)]
+namespace System.Net.WebSockets
+{
+    public static partial class WebSocketProtocol
+    {
+        public static WebSocket CreateFromStream(IO.Stream stream, bool isServer, string? subProtocol, TimeSpan keepAliveInterval) { throw null; }
+    }
+}
\ No newline at end of file
diff --git a/src/referencePackages/src/system.net.websockets.websocketprotocol/5.1.3/lib/netstandard2.0/System.Net.WebSockets.WebSocketProtocol.cs b/src/referencePackages/src/system.net.websockets.websocketprotocol/5.1.3/lib/netstandard2.0/System.Net.WebSockets.WebSocketProtocol.cs
new file mode 100644
index 0000000000..e41950a26e
--- /dev/null
+++ b/src/referencePackages/src/system.net.websockets.websocketprotocol/5.1.3/lib/netstandard2.0/System.Net.WebSockets.WebSocketProtocol.cs
@@ -0,0 +1,34 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+// ------------------------------------------------------------------------------
+// Changes to this file must follow the http://aka.ms/api-review process.
+// ------------------------------------------------------------------------------
+[assembly: System.Runtime.CompilerServices.CompilationRelaxations(8)]
+[assembly: System.Runtime.CompilerServices.RuntimeCompatibility(WrapNonExceptionThrows = true)]
+[assembly: System.Diagnostics.Debuggable(System.Diagnostics.DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
+[assembly: System.Runtime.Versioning.TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
+[assembly: System.CLSCompliant(true)]
+[assembly: System.Reflection.AssemblyDefaultAlias("System.Net.WebSockets.WebSocketProtocol")]
+[assembly: System.Resources.NeutralResourcesLanguage("en-US")]
+[assembly: System.Runtime.InteropServices.DefaultDllImportSearchPaths(System.Runtime.InteropServices.DllImportSearchPath.AssemblyDirectory | System.Runtime.InteropServices.DllImportSearchPath.System32)]
+[assembly: System.Reflection.AssemblyCompany("Microsoft Corporation")]
+[assembly: System.Reflection.AssemblyCopyright("© Microsoft Corporation. All rights reserved.")]
+[assembly: System.Reflection.AssemblyDescription("System.Net.WebSockets.WebSocketProtocol")]
+[assembly: System.Reflection.AssemblyFileVersion("5.100.325.20307")]
+[assembly: System.Reflection.AssemblyInformationalVersion("5.1.3+f62ca0009b038cab4725a720f386623a969d73ad")]
+[assembly: System.Reflection.AssemblyProduct("Microsoft® .NET")]
+[assembly: System.Reflection.AssemblyTitle("System.Net.WebSockets.WebSocketProtocol")]
+[assembly: System.Reflection.AssemblyMetadata("RepositoryUrl", "https://github.com/dotnet/maintenance-packages")]
+[assembly: System.Reflection.AssemblyMetadata("PreferInbox", "True")]
+[assembly: System.Reflection.AssemblyMetadata("Serviceable", "True")]
+[assembly: System.Reflection.AssemblyVersionAttribute("5.1.3.0")]
+[assembly: System.Runtime.CompilerServices.ReferenceAssembly]
+[assembly: System.Reflection.AssemblyFlagsAttribute((System.Reflection.AssemblyNameFlags)0x70)]
+namespace System.Net.WebSockets
+{
+    public static partial class WebSocketProtocol
+    {
+        public static WebSocket CreateFromStream(IO.Stream stream, bool isServer, string? subProtocol, TimeSpan keepAliveInterval) { throw null; }
+    }
+}
\ No newline at end of file
diff --git a/src/referencePackages/src/system.net.websockets.websocketprotocol/5.1.3/system.net.websockets.websocketprotocol.nuspec b/src/referencePackages/src/system.net.websockets.websocketprotocol/5.1.3/system.net.websockets.websocketprotocol.nuspec
new file mode 100644
index 0000000000..e6c2a26a15
--- /dev/null
+++ b/src/referencePackages/src/system.net.websockets.websocketprotocol/5.1.3/system.net.websockets.websocketprotocol.nuspec
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="utf-8"?>
+<package xmlns="http://schemas.microsoft.com/packaging/2013/05/nuspec.xsd">
+  <metadata>
+    <id>System.Net.WebSockets.WebSocketProtocol</id>
+    <version>5.1.3</version>
+    <authors>Microsoft</authors>
+    <requireLicenseAcceptance>true</requireLicenseAcceptance>
+    <license type="expression">MIT</license>
+    <licenseUrl>https://licenses.nuget.org/MIT</licenseUrl>
+    <projectUrl>https://github.com/dotnet/maintenance-packages</projectUrl>
+    <description>System.Net.WebSockets.WebSocketProtocol</description>
+    <copyright>© Microsoft Corporation. All rights reserved.</copyright>
+    <serviceable>true</serviceable>
+    <repository type="git" url="https://github.com/dotnet/maintenance-packages" commit="f62ca0009b038cab4725a720f386623a969d73ad" />
+    <dependencies>
+      <group targetFramework="net6.0" />
+      <group targetFramework=".NETStandard2.0">
+        <dependency id="System.Buffers" version="4.6.1" exclude="Build,Analyzers" />
+        <dependency id="System.Memory" version="4.6.3" exclude="Build,Analyzers" />
+        <dependency id="System.Numerics.Vectors" version="4.6.1" exclude="Build,Analyzers" />
+        <dependency id="System.Runtime.CompilerServices.Unsafe" version="6.1.2" exclude="Build,Analyzers" />
+        <dependency id="System.Threading.Tasks.Extensions" version="4.6.3" exclude="Build,Analyzers" />
+      </group>
+    </dependencies>
+  </metadata>
+</package>
\ No newline at end of file
diff --git a/src/referencePackages/src/system.runtime.compilerservices.unsafe/6.1.2/System.Runtime.CompilerServices.Unsafe.6.1.2.csproj b/src/referencePackages/src/system.runtime.compilerservices.unsafe/6.1.2/System.Runtime.CompilerServices.Unsafe.6.1.2.csproj
new file mode 100644
index 0000000000..c45c68f5c6
--- /dev/null
+++ b/src/referencePackages/src/system.runtime.compilerservices.unsafe/6.1.2/System.Runtime.CompilerServices.Unsafe.6.1.2.csproj
@@ -0,0 +1,8 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>net6.0;netstandard2.0</TargetFrameworks>
+    <AssemblyName>System.Runtime.CompilerServices.Unsafe</AssemblyName>
+  </PropertyGroup>
+
+</Project>
diff --git a/src/referencePackages/src/system.runtime.compilerservices.unsafe/6.1.2/lib/net6.0/System.Runtime.CompilerServices.Unsafe.cs b/src/referencePackages/src/system.runtime.compilerservices.unsafe/6.1.2/lib/net6.0/System.Runtime.CompilerServices.Unsafe.cs
new file mode 100644
index 0000000000..317c96d524
--- /dev/null
+++ b/src/referencePackages/src/system.runtime.compilerservices.unsafe/6.1.2/lib/net6.0/System.Runtime.CompilerServices.Unsafe.cs
@@ -0,0 +1,114 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+// ------------------------------------------------------------------------------
+// Changes to this file must follow the http://aka.ms/api-review process.
+// ------------------------------------------------------------------------------
+[assembly: System.Reflection.AssemblyProduct("Microsoft® .NET Framework")]
+[assembly: System.CLSCompliant(false)]
+[assembly: System.Reflection.AssemblyMetadata(".NETFrameworkAssembly", "")]
+[assembly: System.Diagnostics.Debuggable(System.Diagnostics.DebuggableAttribute.DebuggingModes.Default | System.Diagnostics.DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
+[assembly: System.Runtime.CompilerServices.CompilationRelaxations(8)]
+[assembly: System.Reflection.AssemblyDescription("System.Runtime.CompilerServices.Unsafe")]
+[assembly: System.Reflection.AssemblyFileVersion("6.100.225.20307")]
+[assembly: System.Reflection.AssemblyInformationalVersion("6.1.2")]
+[assembly: System.Reflection.AssemblyTitle("System.Runtime.CompilerServices.Unsafe")]
+[assembly: System.Reflection.AssemblyMetadata("Serviceable", "True")]
+[assembly: System.Runtime.CompilerServices.RuntimeCompatibility(WrapNonExceptionThrows = true)]
+[assembly: System.Reflection.AssemblyMetadata("IsTrimmable", "True")]
+[assembly: System.Reflection.AssemblyCopyright("© Microsoft Corporation.  All rights reserved.")]
+[assembly: System.Reflection.AssemblyCompany("Microsoft Corporation")]
+[assembly: System.Reflection.AssemblyVersionAttribute("6.0.0.0")]
+[assembly: System.Runtime.CompilerServices.ReferenceAssembly]
+[assembly: System.Reflection.AssemblyFlagsAttribute((System.Reflection.AssemblyNameFlags)0x70)]
+namespace System.Runtime.CompilerServices
+{
+    public static partial class Unsafe
+    {
+        public static ref T Add<T>(ref T source, int elementOffset) { throw null; }
+
+        public static ref T Add<T>(ref T source, IntPtr elementOffset) { throw null; }
+
+        public static ref T Add<T>(ref T source, nuint elementOffset) { throw null; }
+
+        public static unsafe void* Add<T>(void* source, int elementOffset) { throw null; }
+
+        public static ref T AddByteOffset<T>(ref T source, IntPtr byteOffset) { throw null; }
+
+        public static ref T AddByteOffset<T>(ref T source, nuint byteOffset) { throw null; }
+
+        public static bool AreSame<T>(ref T left, ref T right) { throw null; }
+
+        public static T As<T>(object o)
+            where T : class { throw null; }
+
+        public static ref TTo As<TFrom, TTo>(ref TFrom source) { throw null; }
+
+        public static unsafe void* AsPointer<T>(ref T value) { throw null; }
+
+        public static ref T AsRef<T>(in T source) { throw null; }
+
+        public static unsafe ref T AsRef<T>(void* source) { throw null; }
+
+        public static IntPtr ByteOffset<T>(ref T origin, ref T target) { throw null; }
+
+        public static unsafe void Copy<T>(ref T destination, void* source) { }
+
+        public static unsafe void Copy<T>(void* destination, ref T source) { }
+
+        public static void CopyBlock(ref byte destination, ref byte source, uint byteCount) { }
+
+        public static unsafe void CopyBlock(void* destination, void* source, uint byteCount) { }
+
+        public static void CopyBlockUnaligned(ref byte destination, ref byte source, uint byteCount) { }
+
+        public static unsafe void CopyBlockUnaligned(void* destination, void* source, uint byteCount) { }
+
+        public static void InitBlock(ref byte startAddress, byte value, uint byteCount) { }
+
+        public static unsafe void InitBlock(void* startAddress, byte value, uint byteCount) { }
+
+        public static void InitBlockUnaligned(ref byte startAddress, byte value, uint byteCount) { }
+
+        public static unsafe void InitBlockUnaligned(void* startAddress, byte value, uint byteCount) { }
+
+        public static bool IsAddressGreaterThan<T>(ref T left, ref T right) { throw null; }
+
+        public static bool IsAddressLessThan<T>(ref T left, ref T right) { throw null; }
+
+        public static bool IsNullRef<T>(ref T source) { throw null; }
+
+        public static ref T NullRef<T>() { throw null; }
+
+        public static unsafe T Read<T>(void* source) { throw null; }
+
+        public static T ReadUnaligned<T>(ref byte source) { throw null; }
+
+        public static unsafe T ReadUnaligned<T>(void* source) { throw null; }
+
+        public static int SizeOf<T>() { throw null; }
+
+        public static void SkipInit<T>(out T value) { throw null; }
+
+        public static ref T Subtract<T>(ref T source, int elementOffset) { throw null; }
+
+        public static ref T Subtract<T>(ref T source, IntPtr elementOffset) { throw null; }
+
+        public static ref T Subtract<T>(ref T source, nuint elementOffset) { throw null; }
+
+        public static unsafe void* Subtract<T>(void* source, int elementOffset) { throw null; }
+
+        public static ref T SubtractByteOffset<T>(ref T source, IntPtr byteOffset) { throw null; }
+
+        public static ref T SubtractByteOffset<T>(ref T source, nuint byteOffset) { throw null; }
+
+        public static ref T Unbox<T>(object box)
+            where T : struct { throw null; }
+
+        public static unsafe void Write<T>(void* destination, T value) { }
+
+        public static void WriteUnaligned<T>(ref byte destination, T value) { }
+
+        public static unsafe void WriteUnaligned<T>(void* destination, T value) { }
+    }
+}
\ No newline at end of file
diff --git a/src/referencePackages/src/system.runtime.compilerservices.unsafe/6.1.2/lib/net7.0/_._ b/src/referencePackages/src/system.runtime.compilerservices.unsafe/6.1.2/lib/net7.0/_._
new file mode 100755
index 0000000000..e69de29bb2
diff --git a/src/referencePackages/src/system.runtime.compilerservices.unsafe/6.1.2/lib/netstandard2.0/System.Runtime.CompilerServices.Unsafe.cs b/src/referencePackages/src/system.runtime.compilerservices.unsafe/6.1.2/lib/netstandard2.0/System.Runtime.CompilerServices.Unsafe.cs
new file mode 100644
index 0000000000..317c96d524
--- /dev/null
+++ b/src/referencePackages/src/system.runtime.compilerservices.unsafe/6.1.2/lib/netstandard2.0/System.Runtime.CompilerServices.Unsafe.cs
@@ -0,0 +1,114 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+// ------------------------------------------------------------------------------
+// Changes to this file must follow the http://aka.ms/api-review process.
+// ------------------------------------------------------------------------------
+[assembly: System.Reflection.AssemblyProduct("Microsoft® .NET Framework")]
+[assembly: System.CLSCompliant(false)]
+[assembly: System.Reflection.AssemblyMetadata(".NETFrameworkAssembly", "")]
+[assembly: System.Diagnostics.Debuggable(System.Diagnostics.DebuggableAttribute.DebuggingModes.Default | System.Diagnostics.DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
+[assembly: System.Runtime.CompilerServices.CompilationRelaxations(8)]
+[assembly: System.Reflection.AssemblyDescription("System.Runtime.CompilerServices.Unsafe")]
+[assembly: System.Reflection.AssemblyFileVersion("6.100.225.20307")]
+[assembly: System.Reflection.AssemblyInformationalVersion("6.1.2")]
+[assembly: System.Reflection.AssemblyTitle("System.Runtime.CompilerServices.Unsafe")]
+[assembly: System.Reflection.AssemblyMetadata("Serviceable", "True")]
+[assembly: System.Runtime.CompilerServices.RuntimeCompatibility(WrapNonExceptionThrows = true)]
+[assembly: System.Reflection.AssemblyMetadata("IsTrimmable", "True")]
+[assembly: System.Reflection.AssemblyCopyright("© Microsoft Corporation.  All rights reserved.")]
+[assembly: System.Reflection.AssemblyCompany("Microsoft Corporation")]
+[assembly: System.Reflection.AssemblyVersionAttribute("6.0.0.0")]
+[assembly: System.Runtime.CompilerServices.ReferenceAssembly]
+[assembly: System.Reflection.AssemblyFlagsAttribute((System.Reflection.AssemblyNameFlags)0x70)]
+namespace System.Runtime.CompilerServices
+{
+    public static partial class Unsafe
+    {
+        public static ref T Add<T>(ref T source, int elementOffset) { throw null; }
+
+        public static ref T Add<T>(ref T source, IntPtr elementOffset) { throw null; }
+
+        public static ref T Add<T>(ref T source, nuint elementOffset) { throw null; }
+
+        public static unsafe void* Add<T>(void* source, int elementOffset) { throw null; }
+
+        public static ref T AddByteOffset<T>(ref T source, IntPtr byteOffset) { throw null; }
+
+        public static ref T AddByteOffset<T>(ref T source, nuint byteOffset) { throw null; }
+
+        public static bool AreSame<T>(ref T left, ref T right) { throw null; }
+
+        public static T As<T>(object o)
+            where T : class { throw null; }
+
+        public static ref TTo As<TFrom, TTo>(ref TFrom source) { throw null; }
+
+        public static unsafe void* AsPointer<T>(ref T value) { throw null; }
+
+        public static ref T AsRef<T>(in T source) { throw null; }
+
+        public static unsafe ref T AsRef<T>(void* source) { throw null; }
+
+        public static IntPtr ByteOffset<T>(ref T origin, ref T target) { throw null; }
+
+        public static unsafe void Copy<T>(ref T destination, void* source) { }
+
+        public static unsafe void Copy<T>(void* destination, ref T source) { }
+
+        public static void CopyBlock(ref byte destination, ref byte source, uint byteCount) { }
+
+        public static unsafe void CopyBlock(void* destination, void* source, uint byteCount) { }
+
+        public static void CopyBlockUnaligned(ref byte destination, ref byte source, uint byteCount) { }
+
+        public static unsafe void CopyBlockUnaligned(void* destination, void* source, uint byteCount) { }
+
+        public static void InitBlock(ref byte startAddress, byte value, uint byteCount) { }
+
+        public static unsafe void InitBlock(void* startAddress, byte value, uint byteCount) { }
+
+        public static void InitBlockUnaligned(ref byte startAddress, byte value, uint byteCount) { }
+
+        public static unsafe void InitBlockUnaligned(void* startAddress, byte value, uint byteCount) { }
+
+        public static bool IsAddressGreaterThan<T>(ref T left, ref T right) { throw null; }
+
+        public static bool IsAddressLessThan<T>(ref T left, ref T right) { throw null; }
+
+        public static bool IsNullRef<T>(ref T source) { throw null; }
+
+        public static ref T NullRef<T>() { throw null; }
+
+        public static unsafe T Read<T>(void* source) { throw null; }
+
+        public static T ReadUnaligned<T>(ref byte source) { throw null; }
+
+        public static unsafe T ReadUnaligned<T>(void* source) { throw null; }
+
+        public static int SizeOf<T>() { throw null; }
+
+        public static void SkipInit<T>(out T value) { throw null; }
+
+        public static ref T Subtract<T>(ref T source, int elementOffset) { throw null; }
+
+        public static ref T Subtract<T>(ref T source, IntPtr elementOffset) { throw null; }
+
+        public static ref T Subtract<T>(ref T source, nuint elementOffset) { throw null; }
+
+        public static unsafe void* Subtract<T>(void* source, int elementOffset) { throw null; }
+
+        public static ref T SubtractByteOffset<T>(ref T source, IntPtr byteOffset) { throw null; }
+
+        public static ref T SubtractByteOffset<T>(ref T source, nuint byteOffset) { throw null; }
+
+        public static ref T Unbox<T>(object box)
+            where T : struct { throw null; }
+
+        public static unsafe void Write<T>(void* destination, T value) { }
+
+        public static void WriteUnaligned<T>(ref byte destination, T value) { }
+
+        public static unsafe void WriteUnaligned<T>(void* destination, T value) { }
+    }
+}
\ No newline at end of file
diff --git a/src/referencePackages/src/system.runtime.compilerservices.unsafe/6.1.2/system.runtime.compilerservices.unsafe.nuspec b/src/referencePackages/src/system.runtime.compilerservices.unsafe/6.1.2/system.runtime.compilerservices.unsafe.nuspec
new file mode 100644
index 0000000000..8fb3f09f60
--- /dev/null
+++ b/src/referencePackages/src/system.runtime.compilerservices.unsafe/6.1.2/system.runtime.compilerservices.unsafe.nuspec
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
+  <metadata>
+    <id>System.Runtime.CompilerServices.Unsafe</id>
+    <version>6.1.2</version>
+    <authors>Microsoft</authors>
+    <requireLicenseAcceptance>true</requireLicenseAcceptance>
+    <license type="expression">MIT</license>
+    <licenseUrl>https://licenses.nuget.org/MIT</licenseUrl>
+    <projectUrl>https://github.com/dotnet/maintenance-packages</projectUrl>
+    <description>Provides the System.Runtime.CompilerServices.Unsafe class, which provides generic, low-level functionality for manipulating pointers.</description>
+    <copyright>© Microsoft Corporation. All rights reserved.</copyright>
+    <serviceable>true</serviceable>
+    <repository type="git" url="https://github.com/dotnet/maintenance-packages" commit="f62ca0009b038cab4725a720f386623a969d73ad" />
+    <dependencies>
+      <group targetFramework="net6.0" />
+      <group targetFramework="net7.0" />
+      <group targetFramework=".NETStandard2.0" />
+    </dependencies>
+  </metadata>
+</package>
\ No newline at end of file
diff --git a/src/referencePackages/src/system.threading.tasks.extensions/4.6.3/System.Threading.Tasks.Extensions.4.6.3.csproj b/src/referencePackages/src/system.threading.tasks.extensions/4.6.3/System.Threading.Tasks.Extensions.4.6.3.csproj
new file mode 100644
index 0000000000..233e2f25cd
--- /dev/null
+++ b/src/referencePackages/src/system.threading.tasks.extensions/4.6.3/System.Threading.Tasks.Extensions.4.6.3.csproj
@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>netstandard2.0</TargetFrameworks>
+    <AssemblyName>System.Threading.Tasks.Extensions</AssemblyName>
+    <StrongNameKeyId>Open</StrongNameKeyId>
+  </PropertyGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
+    <PackageReference Include="System.Runtime.CompilerServices.Unsafe" Version="6.1.2" />
+  </ItemGroup>
+
+</Project>
diff --git a/src/referencePackages/src/system.threading.tasks.extensions/4.6.3/lib/netstandard2.0/System.Threading.Tasks.Extensions.cs b/src/referencePackages/src/system.threading.tasks.extensions/4.6.3/lib/netstandard2.0/System.Threading.Tasks.Extensions.cs
new file mode 100644
index 0000000000..c9672ba947
--- /dev/null
+++ b/src/referencePackages/src/system.threading.tasks.extensions/4.6.3/lib/netstandard2.0/System.Threading.Tasks.Extensions.cs
@@ -0,0 +1,268 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+// ------------------------------------------------------------------------------
+// Changes to this file must follow the http://aka.ms/api-review process.
+// ------------------------------------------------------------------------------
+[assembly: System.Runtime.CompilerServices.CompilationRelaxations(8)]
+[assembly: System.Runtime.CompilerServices.RuntimeCompatibility(WrapNonExceptionThrows = true)]
+[assembly: System.Diagnostics.Debuggable(System.Diagnostics.DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
+[assembly: System.Runtime.Versioning.TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
+[assembly: System.CLSCompliant(true)]
+[assembly: System.Reflection.AssemblyDefaultAlias("System.Threading.Tasks.Extensions")]
+[assembly: System.Runtime.InteropServices.DefaultDllImportSearchPaths(System.Runtime.InteropServices.DllImportSearchPath.AssemblyDirectory | System.Runtime.InteropServices.DllImportSearchPath.System32)]
+[assembly: System.Reflection.AssemblyCompany("Microsoft Corporation")]
+[assembly: System.Reflection.AssemblyCopyright("© Microsoft Corporation. All rights reserved.")]
+[assembly: System.Reflection.AssemblyDescription("System.Threading.Tasks.Extensions")]
+[assembly: System.Reflection.AssemblyFileVersion("4.600.325.20307")]
+[assembly: System.Reflection.AssemblyInformationalVersion("4.6.3+f62ca0009b038cab4725a720f386623a969d73ad")]
+[assembly: System.Reflection.AssemblyProduct("Microsoft® .NET")]
+[assembly: System.Reflection.AssemblyTitle("System.Threading.Tasks.Extensions")]
+[assembly: System.Reflection.AssemblyMetadata("RepositoryUrl", "https://github.com/dotnet/maintenance-packages")]
+[assembly: System.Reflection.AssemblyMetadata("PreferInbox", "True")]
+[assembly: System.Reflection.AssemblyMetadata("Serviceable", "True")]
+[assembly: System.Reflection.AssemblyVersionAttribute("4.2.1.0")]
+[assembly: System.Runtime.CompilerServices.ReferenceAssembly]
+[assembly: System.Reflection.AssemblyFlagsAttribute((System.Reflection.AssemblyNameFlags)0x70)]
+namespace System.Runtime.CompilerServices
+{
+    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false, AllowMultiple = false)]
+    public sealed partial class AsyncMethodBuilderAttribute : Attribute
+    {
+        public AsyncMethodBuilderAttribute(Type builderType) { }
+
+        public Type BuilderType { get { throw null; } }
+    }
+
+    public partial struct AsyncValueTaskMethodBuilder
+    {
+        private int _dummyPrimitive;
+        public Threading.Tasks.ValueTask Task { get { throw null; } }
+
+        public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine)
+            where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine { }
+
+        public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine)
+            where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine { }
+
+        public static AsyncValueTaskMethodBuilder Create() { throw null; }
+
+        public void SetException(Exception exception) { }
+
+        public void SetResult() { }
+
+        public void SetStateMachine(IAsyncStateMachine stateMachine) { }
+
+        public void Start<TStateMachine>(ref TStateMachine stateMachine)
+            where TStateMachine : IAsyncStateMachine { }
+    }
+
+    public partial struct AsyncValueTaskMethodBuilder<TResult>
+    {
+        private AsyncTaskMethodBuilder<TResult> _methodBuilder;
+        private TResult _result;
+        private int _dummyPrimitive;
+        public Threading.Tasks.ValueTask<TResult> Task { get { throw null; } }
+
+        public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine)
+            where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine { }
+
+        public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine)
+            where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine { }
+
+        public static AsyncValueTaskMethodBuilder<TResult> Create() { throw null; }
+
+        public void SetException(Exception exception) { }
+
+        public void SetResult(TResult result) { }
+
+        public void SetStateMachine(IAsyncStateMachine stateMachine) { }
+
+        public void Start<TStateMachine>(ref TStateMachine stateMachine)
+            where TStateMachine : IAsyncStateMachine { }
+    }
+
+    public readonly partial struct ConfiguredValueTaskAwaitable
+    {
+        private readonly object _dummy;
+        private readonly int _dummyPrimitive;
+        public readonly ConfiguredValueTaskAwaiter GetAwaiter() { throw null; }
+
+        public readonly partial struct ConfiguredValueTaskAwaiter : ICriticalNotifyCompletion, INotifyCompletion
+        {
+            private readonly object _dummy;
+            private readonly int _dummyPrimitive;
+            public bool IsCompleted { get { throw null; } }
+
+            public readonly void GetResult() { }
+
+            public readonly void OnCompleted(Action continuation) { }
+
+            public readonly void UnsafeOnCompleted(Action continuation) { }
+        }
+    }
+
+    public readonly partial struct ConfiguredValueTaskAwaitable<TResult>
+    {
+        private readonly Threading.Tasks.ValueTask<TResult> _value;
+        private readonly object _dummy;
+        private readonly int _dummyPrimitive;
+        public readonly ConfiguredValueTaskAwaiter GetAwaiter() { throw null; }
+
+        public readonly partial struct ConfiguredValueTaskAwaiter : ICriticalNotifyCompletion, INotifyCompletion
+        {
+            private readonly Threading.Tasks.ValueTask<TResult> _value;
+            private readonly object _dummy;
+            private readonly int _dummyPrimitive;
+            public bool IsCompleted { get { throw null; } }
+
+            public readonly TResult GetResult() { throw null; }
+
+            public readonly void OnCompleted(Action continuation) { }
+
+            public readonly void UnsafeOnCompleted(Action continuation) { }
+        }
+    }
+
+    public readonly partial struct ValueTaskAwaiter : ICriticalNotifyCompletion, INotifyCompletion
+    {
+        private readonly object _dummy;
+        private readonly int _dummyPrimitive;
+        public bool IsCompleted { get { throw null; } }
+
+        public readonly void GetResult() { }
+
+        public readonly void OnCompleted(Action continuation) { }
+
+        public readonly void UnsafeOnCompleted(Action continuation) { }
+    }
+
+    public readonly partial struct ValueTaskAwaiter<TResult> : ICriticalNotifyCompletion, INotifyCompletion
+    {
+        private readonly Threading.Tasks.ValueTask<TResult> _value;
+        private readonly object _dummy;
+        private readonly int _dummyPrimitive;
+        public bool IsCompleted { get { throw null; } }
+
+        public readonly TResult GetResult() { throw null; }
+
+        public readonly void OnCompleted(Action continuation) { }
+
+        public readonly void UnsafeOnCompleted(Action continuation) { }
+    }
+}
+
+namespace System.Threading.Tasks
+{
+    [Runtime.CompilerServices.AsyncMethodBuilder(typeof(Runtime.CompilerServices.AsyncValueTaskMethodBuilder))]
+    public readonly partial struct ValueTask : IEquatable<ValueTask>
+    {
+        private readonly object _dummy;
+        private readonly int _dummyPrimitive;
+        public ValueTask(Sources.IValueTaskSource source, short token) { }
+
+        public ValueTask(Task task) { }
+
+        public bool IsCanceled { get { throw null; } }
+
+        public bool IsCompleted { get { throw null; } }
+
+        public bool IsCompletedSuccessfully { get { throw null; } }
+
+        public bool IsFaulted { get { throw null; } }
+
+        public readonly Task AsTask() { throw null; }
+
+        public readonly Runtime.CompilerServices.ConfiguredValueTaskAwaitable ConfigureAwait(bool continueOnCapturedContext) { throw null; }
+
+        public override readonly bool Equals(object obj) { throw null; }
+
+        public readonly bool Equals(ValueTask other) { throw null; }
+
+        public readonly Runtime.CompilerServices.ValueTaskAwaiter GetAwaiter() { throw null; }
+
+        public override readonly int GetHashCode() { throw null; }
+
+        public static bool operator ==(ValueTask left, ValueTask right) { throw null; }
+
+        public static bool operator !=(ValueTask left, ValueTask right) { throw null; }
+
+        public readonly ValueTask Preserve() { throw null; }
+    }
+
+    [Runtime.CompilerServices.AsyncMethodBuilder(typeof(Runtime.CompilerServices.AsyncValueTaskMethodBuilder<>))]
+    public readonly partial struct ValueTask<TResult> : IEquatable<ValueTask<TResult>>
+    {
+        private readonly TResult _result;
+        private readonly object _dummy;
+        private readonly int _dummyPrimitive;
+        public ValueTask(TResult result) { }
+
+        public ValueTask(Sources.IValueTaskSource<TResult> source, short token) { }
+
+        public ValueTask(Task<TResult> task) { }
+
+        public bool IsCanceled { get { throw null; } }
+
+        public bool IsCompleted { get { throw null; } }
+
+        public bool IsCompletedSuccessfully { get { throw null; } }
+
+        public bool IsFaulted { get { throw null; } }
+
+        public TResult Result { get { throw null; } }
+
+        public readonly Task<TResult> AsTask() { throw null; }
+
+        public readonly Runtime.CompilerServices.ConfiguredValueTaskAwaitable<TResult> ConfigureAwait(bool continueOnCapturedContext) { throw null; }
+
+        public override readonly bool Equals(object obj) { throw null; }
+
+        public readonly bool Equals(ValueTask<TResult> other) { throw null; }
+
+        public readonly Runtime.CompilerServices.ValueTaskAwaiter<TResult> GetAwaiter() { throw null; }
+
+        public override readonly int GetHashCode() { throw null; }
+
+        public static bool operator ==(ValueTask<TResult> left, ValueTask<TResult> right) { throw null; }
+
+        public static bool operator !=(ValueTask<TResult> left, ValueTask<TResult> right) { throw null; }
+
+        public readonly ValueTask<TResult> Preserve() { throw null; }
+
+        public override readonly string ToString() { throw null; }
+    }
+}
+
+namespace System.Threading.Tasks.Sources
+{
+    public partial interface IValueTaskSource
+    {
+        void GetResult(short token);
+        ValueTaskSourceStatus GetStatus(short token);
+        void OnCompleted(Action<object> continuation, object state, short token, ValueTaskSourceOnCompletedFlags flags);
+    }
+
+    public partial interface IValueTaskSource<out TResult>
+    {
+        TResult GetResult(short token);
+        ValueTaskSourceStatus GetStatus(short token);
+        void OnCompleted(Action<object> continuation, object state, short token, ValueTaskSourceOnCompletedFlags flags);
+    }
+
+    [Flags]
+    public enum ValueTaskSourceOnCompletedFlags
+    {
+        None = 0,
+        UseSchedulingContext = 1,
+        FlowExecutionContext = 2
+    }
+
+    public enum ValueTaskSourceStatus
+    {
+        Pending = 0,
+        Succeeded = 1,
+        Faulted = 2,
+        Canceled = 3
+    }
+}
\ No newline at end of file
diff --git a/src/referencePackages/src/system.threading.tasks.extensions/4.6.3/lib/netstandard2.1/_._ b/src/referencePackages/src/system.threading.tasks.extensions/4.6.3/lib/netstandard2.1/_._
new file mode 100755
index 0000000000..e69de29bb2
diff --git a/src/referencePackages/src/system.threading.tasks.extensions/4.6.3/system.threading.tasks.extensions.nuspec b/src/referencePackages/src/system.threading.tasks.extensions/4.6.3/system.threading.tasks.extensions.nuspec
new file mode 100644
index 0000000000..4cab61fc0c
--- /dev/null
+++ b/src/referencePackages/src/system.threading.tasks.extensions/4.6.3/system.threading.tasks.extensions.nuspec
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<package xmlns="http://schemas.microsoft.com/packaging/2013/05/nuspec.xsd">
+  <metadata>
+    <id>System.Threading.Tasks.Extensions</id>
+    <version>4.6.3</version>
+    <authors>Microsoft</authors>
+    <requireLicenseAcceptance>true</requireLicenseAcceptance>
+    <license type="expression">MIT</license>
+    <licenseUrl>https://licenses.nuget.org/MIT</licenseUrl>
+    <projectUrl>https://github.com/dotnet/maintenance-packages</projectUrl>
+    <description>System.Threading.Tasks.Extensions</description>
+    <copyright>© Microsoft Corporation. All rights reserved.</copyright>
+    <serviceable>true</serviceable>
+    <repository type="git" url="https://github.com/dotnet/maintenance-packages" commit="f62ca0009b038cab4725a720f386623a969d73ad" />
+    <dependencies>
+      <group targetFramework=".NETStandard2.0">
+        <dependency id="System.Runtime.CompilerServices.Unsafe" version="6.1.2" exclude="Build,Analyzers" />
+      </group>
+      <group targetFramework=".NETStandard2.1" />
+    </dependencies>
+  </metadata>
+</package>
\ No newline at end of file