diff --git a/AssetRipper.TextureDecoder.ColorGenerator/NumericConversionGenerator.cs b/AssetRipper.TextureDecoder.ColorGenerator/NumericConversionGenerator.cs
index d01141b..0a980a5 100644
--- a/AssetRipper.TextureDecoder.ColorGenerator/NumericConversionGenerator.cs
+++ b/AssetRipper.TextureDecoder.ColorGenerator/NumericConversionGenerator.cs
@@ -82,14 +82,14 @@ internal static class NumericConversionGenerator
 			writer.WriteLine("if (typeof(TFrom) == typeof(TTo))");
 			using (new CurlyBrackets(writer))
 			{
-				writer.WriteLine("return Unsafe.As<TFrom, TTo>(ref value);");
+				writer.WriteLine("return Unsafe.BitCast<TFrom, TTo>(value);");
 			}
 			foreach (CSharpPrimitives.Data from in CSharpPrimitives.List)
 			{
 				writer.WriteLine($"else if (typeof(TFrom) == typeof({from.LangName}))");
 				using (new CurlyBrackets(writer))
 				{
-					writer.WriteLine($"return {ConvertMethodName(from.Type)}<TTo>(Unsafe.As<TFrom, {from.LangName}>(ref value));");
+					writer.WriteLine($"return {ConvertMethodName(from.Type)}<TTo>(Unsafe.BitCast<TFrom, {from.LangName}>(value));");
 				}
 			}
 			writer.WriteLine("else");
@@ -133,32 +133,32 @@ internal static class NumericConversionGenerator
 					{
 						if (from == to)
 						{
-							writer.WriteLine($"return Unsafe.As<{to.LangName}, TTo>(ref value);");
+							writer.WriteLine($"return Unsafe.BitCast<{to.LangName}, TTo>(value);");
 						}
 						else if (to.HasPointerSize(out CSharpPrimitives.Data? bit32To, out CSharpPrimitives.Data? bit64To))
 						{
 							using (new If(writer, "IntPtr.Size == sizeof(int)"))
 							{
 								writer.WriteLine($"{to.LangName} converted = ({to.LangName}){methodName}<{bit32To.LangName}>(value);");
-								writer.WriteLine($"return Unsafe.As<{to.LangName}, TTo>(ref converted);");
+								writer.WriteLine($"return Unsafe.BitCast<{to.LangName}, TTo>(converted);");
 							}
 							using (new Else(writer))
 							{
 								writer.WriteLine($"{to.LangName} converted = ({to.LangName}){methodName}<{bit64To.LangName}>(value);");
-								writer.WriteLine($"return Unsafe.As<{to.LangName}, TTo>(ref converted);");
+								writer.WriteLine($"return Unsafe.BitCast<{to.LangName}, TTo>(converted);");
 							}
 						}
 						else if (to.IsSignedInteger(out CSharpPrimitives.Data? unsignedTo))
 						{
 							writer.WriteLine($"{to.LangName} converted = {ChangeSign}({methodName}<{unsignedTo.LangName}>(value));");
-							writer.WriteLine($"return Unsafe.As<{to.LangName}, TTo>(ref converted);");
+							writer.WriteLine($"return Unsafe.BitCast<{to.LangName}, TTo>(converted);");
 						}
 						else if (from.IsFloatingPoint)
 						{
 							if (to.IsFloatingPoint)
 							{
 								writer.WriteLine($"{to.LangName} converted = ({to.LangName})value;");
-								writer.WriteLine($"return Unsafe.As<{to.LangName}, TTo>(ref converted);");
+								writer.WriteLine($"return Unsafe.BitCast<{to.LangName}, TTo>(converted);");
 							}
 							else
 							{
@@ -176,7 +176,7 @@ internal static class NumericConversionGenerator
 									string maxValue = to.MaxValue;
 									writer.WriteLine($"{from.LangName} x = value * ({from.LangName}){maxValue};");
 									writer.WriteLine($"{to.LangName} converted = ({from.LangName}){maxValue} < x ? {maxValue} : (x > ({from.LangName}){minValue} ? ({to.LangName})x : {minValue});");
-									writer.WriteLine($"return Unsafe.As<{to.LangName}, TTo>(ref converted);");
+									writer.WriteLine($"return Unsafe.BitCast<{to.LangName}, TTo>(converted);");
 								}
 							}
 						}
@@ -191,12 +191,12 @@ internal static class NumericConversionGenerator
 									writer.WriteComment($"There isn't enough precision to convert from {from.LangName} to {to.LangName}, so we convert to {conversionType.LangName} first.");
 									writer.WriteLine($"{conversionType.LangName} x = {methodName}<{conversionType.LangName}>(value);");
 									writer.WriteLine($"{to.LangName} converted = ({to.LangName})x;");
-									writer.WriteLine($"return Unsafe.As<{to.LangName}, TTo>(ref converted);");
+									writer.WriteLine($"return Unsafe.BitCast<{to.LangName}, TTo>(converted);");
 								}
 								else
 								{
 									writer.WriteLine($"{to.LangName} converted = ({to.LangName})value / ({to.LangName}){from.MaxValue};");
-									writer.WriteLine($"return Unsafe.As<{to.LangName}, TTo>(ref converted);");
+									writer.WriteLine($"return Unsafe.BitCast<{to.LangName}, TTo>(converted);");
 								}
 							}
 							else
@@ -216,7 +216,7 @@ internal static class NumericConversionGenerator
 											writer.Write($"(({conversionType})value << {i * from.Size * 8}) | ");
 										}
 										writer.WriteLine("value);");
-										writer.WriteLine($"return Unsafe.As<{to.LangName}, TTo>(ref converted);");
+										writer.WriteLine($"return Unsafe.BitCast<{to.LangName}, TTo>(converted);");
 									}
 								}
 								else
@@ -227,14 +227,14 @@ internal static class NumericConversionGenerator
 										writer.WriteComment("This is a special case where we already know an optimal algorithm.");
 										writer.WriteLine("uint x = (value * 255u + 32895u) >> 16;");
 										writer.WriteLine("byte converted = unchecked((byte)x);");
-										writer.WriteLine("return Unsafe.As<byte, TTo>(ref converted);");
+										writer.WriteLine("return Unsafe.BitCast<byte, TTo>(converted);");
 									}
 									else if (from.Size < sizeof(double) && to.Size < sizeof(double))
 									{
 										writer.WriteLine($"double interpolated = (double)value / (double){from.MaxValue};");
 										writer.WriteLine($"double exact = interpolated * (double){to.MaxValue};");
 										writer.WriteLine($"{to.LangName} converted = ({to.LangName})double.Round(exact, MidpointRounding.AwayFromZero);");
-										writer.WriteLine($"return Unsafe.As<{to.LangName}, TTo>(ref converted);");
+										writer.WriteLine($"return Unsafe.BitCast<{to.LangName}, TTo>(converted);");
 									}
 									else
 									{
@@ -245,7 +245,7 @@ internal static class NumericConversionGenerator
 										{
 											int offset = (from.Size / to.Size - 1) * to.Size * 8;
 											writer.WriteLine($"{to.LangName} converted = ({to.LangName})(({conversionType})value >> {offset});");
-											writer.WriteLine($"return Unsafe.As<{to.LangName}, TTo>(ref converted);");
+											writer.WriteLine($"return Unsafe.BitCast<{to.LangName}, TTo>(converted);");
 										}
 									}
 								}
@@ -276,7 +276,7 @@ internal static class NumericConversionGenerator
 				using (new CurlyBrackets(writer))
 				{
 					writer.WriteLine($"{from.LangName} value = {methodName}Safe<{from.LangName}>();");
-					writer.WriteLine($"return Unsafe.As<{from.LangName}, T>(ref value);");
+					writer.WriteLine($"return Unsafe.BitCast<{from.LangName}, T>(value);");
 				}
 			}
 			writer.WriteLine("else");
diff --git a/AssetRipper.TextureDecoder/Exr/BinaryWriterExtensions.cs b/AssetRipper.TextureDecoder/Exr/BinaryWriterExtensions.cs
index 8b1d150..2a1283c 100644
--- a/AssetRipper.TextureDecoder/Exr/BinaryWriterExtensions.cs
+++ b/AssetRipper.TextureDecoder/Exr/BinaryWriterExtensions.cs
@@ -76,16 +76,16 @@ internal static class BinaryWriterExtensions
 		switch (Unsafe.SizeOf<T>())
 		{
 			case sizeof(byte):
-				writer.Write(Unsafe.As<T, byte>(ref value));
+				writer.Write(Unsafe.BitCast<T, byte>(value));
 				break;
 			case sizeof(ushort):
-				writer.Write(Unsafe.As<T, ushort>(ref value));
+				writer.Write(Unsafe.BitCast<T, ushort>(value));
 				break;
 			case sizeof(uint):
-				writer.Write(Unsafe.As<T, uint>(ref value));
+				writer.Write(Unsafe.BitCast<T, uint>(value));
 				break;
 			case sizeof(ulong):
-				writer.Write(Unsafe.As<T, ulong>(ref value));
+				writer.Write(Unsafe.BitCast<T, ulong>(value));
 				break;
 		}
 	}
diff --git a/AssetRipper.TextureDecoder/Rgb/Color.cs b/AssetRipper.TextureDecoder/Rgb/Color.cs
index a4fc41b..dfd871a 100644
--- a/AssetRipper.TextureDecoder/Rgb/Color.cs
+++ b/AssetRipper.TextureDecoder/Rgb/Color.cs
@@ -82,7 +82,7 @@ public static class Color
 	{
 		if (typeof(TThis) == typeof(TTarget))
 		{
-			return Unsafe.As<TThis, TTarget>(ref color);
+			return Unsafe.BitCast<TThis, TTarget>(color);
 		}
 		else
 		{
diff --git a/AssetRipper.TextureDecoder/Rgb/NumericConversion.cs b/AssetRipper.TextureDecoder/Rgb/NumericConversion.cs
index 1116afd..e60a3ac 100644
--- a/AssetRipper.TextureDecoder/Rgb/NumericConversion.cs
+++ b/AssetRipper.TextureDecoder/Rgb/NumericConversion.cs
@@ -42,7 +42,7 @@ public static partial class NumericConversion
 
 		TFrom SignBit = TFrom.One << (Unsafe.SizeOf<TFrom>() * 8 - 1);
 		TFrom converted = (SignBit ^ value);
-		return Unsafe.As<TFrom, TTo>(ref converted);
+		return Unsafe.BitCast<TFrom, TTo>(converted);
 	}
 
 	[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
@@ -56,6 +56,6 @@ public static partial class NumericConversion
 		}
 
 		TTo SignBit = TTo.One << (Unsafe.SizeOf<TTo>() * 8 - 1);
-		return SignBit ^ Unsafe.As<TFrom, TTo>(ref value);
+		return SignBit ^ Unsafe.BitCast<TFrom, TTo>(value);
 	}
 }
diff --git a/AssetRipper.TextureDecoder/Rgb/NumericConversion.g.cs b/AssetRipper.TextureDecoder/Rgb/NumericConversion.g.cs
index 99c734c..599b473 100644
--- a/AssetRipper.TextureDecoder/Rgb/NumericConversion.g.cs
+++ b/AssetRipper.TextureDecoder/Rgb/NumericConversion.g.cs
@@ -9,75 +9,75 @@ static partial class NumericConversion
 	{
 		if (typeof(TFrom) == typeof(TTo))
 		{
-			return Unsafe.As<TFrom, TTo>(ref value);
+			return Unsafe.BitCast<TFrom, TTo>(value);
 		}
 		else if (typeof(TFrom) == typeof(sbyte))
 		{
-			return ConvertSByte<TTo>(Unsafe.As<TFrom, sbyte>(ref value));
+			return ConvertSByte<TTo>(Unsafe.BitCast<TFrom, sbyte>(value));
 		}
 		else if (typeof(TFrom) == typeof(byte))
 		{
-			return ConvertByte<TTo>(Unsafe.As<TFrom, byte>(ref value));
+			return ConvertByte<TTo>(Unsafe.BitCast<TFrom, byte>(value));
 		}
 		else if (typeof(TFrom) == typeof(short))
 		{
-			return ConvertInt16<TTo>(Unsafe.As<TFrom, short>(ref value));
+			return ConvertInt16<TTo>(Unsafe.BitCast<TFrom, short>(value));
 		}
 		else if (typeof(TFrom) == typeof(ushort))
 		{
-			return ConvertUInt16<TTo>(Unsafe.As<TFrom, ushort>(ref value));
+			return ConvertUInt16<TTo>(Unsafe.BitCast<TFrom, ushort>(value));
 		}
 		else if (typeof(TFrom) == typeof(int))
 		{
-			return ConvertInt32<TTo>(Unsafe.As<TFrom, int>(ref value));
+			return ConvertInt32<TTo>(Unsafe.BitCast<TFrom, int>(value));
 		}
 		else if (typeof(TFrom) == typeof(uint))
 		{
-			return ConvertUInt32<TTo>(Unsafe.As<TFrom, uint>(ref value));
+			return ConvertUInt32<TTo>(Unsafe.BitCast<TFrom, uint>(value));
 		}
 		else if (typeof(TFrom) == typeof(nint))
 		{
-			return ConvertIntPtr<TTo>(Unsafe.As<TFrom, nint>(ref value));
+			return ConvertIntPtr<TTo>(Unsafe.BitCast<TFrom, nint>(value));
 		}
 		else if (typeof(TFrom) == typeof(nuint))
 		{
-			return ConvertUIntPtr<TTo>(Unsafe.As<TFrom, nuint>(ref value));
+			return ConvertUIntPtr<TTo>(Unsafe.BitCast<TFrom, nuint>(value));
 		}
 		else if (typeof(TFrom) == typeof(long))
 		{
-			return ConvertInt64<TTo>(Unsafe.As<TFrom, long>(ref value));
+			return ConvertInt64<TTo>(Unsafe.BitCast<TFrom, long>(value));
 		}
 		else if (typeof(TFrom) == typeof(ulong))
 		{
-			return ConvertUInt64<TTo>(Unsafe.As<TFrom, ulong>(ref value));
+			return ConvertUInt64<TTo>(Unsafe.BitCast<TFrom, ulong>(value));
 		}
 		else if (typeof(TFrom) == typeof(Int128))
 		{
-			return ConvertInt128<TTo>(Unsafe.As<TFrom, Int128>(ref value));
+			return ConvertInt128<TTo>(Unsafe.BitCast<TFrom, Int128>(value));
 		}
 		else if (typeof(TFrom) == typeof(UInt128))
 		{
-			return ConvertUInt128<TTo>(Unsafe.As<TFrom, UInt128>(ref value));
+			return ConvertUInt128<TTo>(Unsafe.BitCast<TFrom, UInt128>(value));
 		}
 		else if (typeof(TFrom) == typeof(Half))
 		{
-			return ConvertHalf<TTo>(Unsafe.As<TFrom, Half>(ref value));
+			return ConvertHalf<TTo>(Unsafe.BitCast<TFrom, Half>(value));
 		}
 		else if (typeof(TFrom) == typeof(float))
 		{
-			return ConvertSingle<TTo>(Unsafe.As<TFrom, float>(ref value));
+			return ConvertSingle<TTo>(Unsafe.BitCast<TFrom, float>(value));
 		}
 		else if (typeof(TFrom) == typeof(NFloat))
 		{
-			return ConvertNFloat<TTo>(Unsafe.As<TFrom, NFloat>(ref value));
+			return ConvertNFloat<TTo>(Unsafe.BitCast<TFrom, NFloat>(value));
 		}
 		else if (typeof(TFrom) == typeof(double))
 		{
-			return ConvertDouble<TTo>(Unsafe.As<TFrom, double>(ref value));
+			return ConvertDouble<TTo>(Unsafe.BitCast<TFrom, double>(value));
 		}
 		else if (typeof(TFrom) == typeof(decimal))
 		{
-			return ConvertDecimal<TTo>(Unsafe.As<TFrom, decimal>(ref value));
+			return ConvertDecimal<TTo>(Unsafe.BitCast<TFrom, decimal>(value));
 		}
 		else
 		{
@@ -97,16 +97,16 @@ static partial class NumericConversion
 		if (typeof(TTo) == typeof(sbyte))
 		{
 			sbyte converted = ChangeSign(ConvertByte<byte>(value));
-			return Unsafe.As<sbyte, TTo>(ref converted);
+			return Unsafe.BitCast<sbyte, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(byte))
 		{
-			return Unsafe.As<byte, TTo>(ref value);
+			return Unsafe.BitCast<byte, TTo>(value);
 		}
 		else if (typeof(TTo) == typeof(short))
 		{
 			short converted = ChangeSign(ConvertByte<ushort>(value));
-			return Unsafe.As<short, TTo>(ref converted);
+			return Unsafe.BitCast<short, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(ushort))
 		{
@@ -114,13 +114,13 @@ static partial class NumericConversion
 			unchecked
 			{
 				ushort converted = (ushort)(((uint)value << 8) | value);
-				return Unsafe.As<ushort, TTo>(ref converted);
+				return Unsafe.BitCast<ushort, TTo>(converted);
 			}
 		}
 		else if (typeof(TTo) == typeof(int))
 		{
 			int converted = ChangeSign(ConvertByte<uint>(value));
-			return Unsafe.As<int, TTo>(ref converted);
+			return Unsafe.BitCast<int, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(uint))
 		{
@@ -128,7 +128,7 @@ static partial class NumericConversion
 			unchecked
 			{
 				uint converted = (uint)(((uint)value << 24) | ((uint)value << 16) | ((uint)value << 8) | value);
-				return Unsafe.As<uint, TTo>(ref converted);
+				return Unsafe.BitCast<uint, TTo>(converted);
 			}
 		}
 		else if (typeof(TTo) == typeof(nint))
@@ -136,12 +136,12 @@ static partial class NumericConversion
 			if (IntPtr.Size == sizeof(int))
 			{
 				nint converted = (nint)ConvertByte<int>(value);
-				return Unsafe.As<nint, TTo>(ref converted);
+				return Unsafe.BitCast<nint, TTo>(converted);
 			}
 			else
 			{
 				nint converted = (nint)ConvertByte<long>(value);
-				return Unsafe.As<nint, TTo>(ref converted);
+				return Unsafe.BitCast<nint, TTo>(converted);
 			}
 		}
 		else if (typeof(TTo) == typeof(nuint))
@@ -149,18 +149,18 @@ static partial class NumericConversion
 			if (IntPtr.Size == sizeof(int))
 			{
 				nuint converted = (nuint)ConvertByte<uint>(value);
-				return Unsafe.As<nuint, TTo>(ref converted);
+				return Unsafe.BitCast<nuint, TTo>(converted);
 			}
 			else
 			{
 				nuint converted = (nuint)ConvertByte<ulong>(value);
-				return Unsafe.As<nuint, TTo>(ref converted);
+				return Unsafe.BitCast<nuint, TTo>(converted);
 			}
 		}
 		else if (typeof(TTo) == typeof(long))
 		{
 			long converted = ChangeSign(ConvertByte<ulong>(value));
-			return Unsafe.As<long, TTo>(ref converted);
+			return Unsafe.BitCast<long, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(ulong))
 		{
@@ -168,13 +168,13 @@ static partial class NumericConversion
 			unchecked
 			{
 				ulong converted = (ulong)(((ulong)value << 56) | ((ulong)value << 48) | ((ulong)value << 40) | ((ulong)value << 32) | ((ulong)value << 24) | ((ulong)value << 16) | ((ulong)value << 8) | value);
-				return Unsafe.As<ulong, TTo>(ref converted);
+				return Unsafe.BitCast<ulong, TTo>(converted);
 			}
 		}
 		else if (typeof(TTo) == typeof(Int128))
 		{
 			Int128 converted = ChangeSign(ConvertByte<UInt128>(value));
-			return Unsafe.As<Int128, TTo>(ref converted);
+			return Unsafe.BitCast<Int128, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(UInt128))
 		{
@@ -182,7 +182,7 @@ static partial class NumericConversion
 			unchecked
 			{
 				UInt128 converted = (UInt128)(((UInt128)value << 120) | ((UInt128)value << 112) | ((UInt128)value << 104) | ((UInt128)value << 96) | ((UInt128)value << 88) | ((UInt128)value << 80) | ((UInt128)value << 72) | ((UInt128)value << 64) | ((UInt128)value << 56) | ((UInt128)value << 48) | ((UInt128)value << 40) | ((UInt128)value << 32) | ((UInt128)value << 24) | ((UInt128)value << 16) | ((UInt128)value << 8) | value);
-				return Unsafe.As<UInt128, TTo>(ref converted);
+				return Unsafe.BitCast<UInt128, TTo>(converted);
 			}
 		}
 		else if (typeof(TTo) == typeof(Half))
@@ -190,35 +190,35 @@ static partial class NumericConversion
 			// There isn't enough precision to convert from byte to Half, so we convert to float first.
 			float x = ConvertByte<float>(value);
 			Half converted = (Half)x;
-			return Unsafe.As<Half, TTo>(ref converted);
+			return Unsafe.BitCast<Half, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(float))
 		{
 			float converted = (float)value / (float)byte.MaxValue;
-			return Unsafe.As<float, TTo>(ref converted);
+			return Unsafe.BitCast<float, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(NFloat))
 		{
 			if (IntPtr.Size == sizeof(int))
 			{
 				NFloat converted = (NFloat)ConvertByte<float>(value);
-				return Unsafe.As<NFloat, TTo>(ref converted);
+				return Unsafe.BitCast<NFloat, TTo>(converted);
 			}
 			else
 			{
 				NFloat converted = (NFloat)ConvertByte<double>(value);
-				return Unsafe.As<NFloat, TTo>(ref converted);
+				return Unsafe.BitCast<NFloat, TTo>(converted);
 			}
 		}
 		else if (typeof(TTo) == typeof(double))
 		{
 			double converted = (double)value / (double)byte.MaxValue;
-			return Unsafe.As<double, TTo>(ref converted);
+			return Unsafe.BitCast<double, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(decimal))
 		{
 			decimal converted = (decimal)value / (decimal)byte.MaxValue;
-			return Unsafe.As<decimal, TTo>(ref converted);
+			return Unsafe.BitCast<decimal, TTo>(converted);
 		}
 		else
 		{
@@ -238,7 +238,7 @@ static partial class NumericConversion
 		if (typeof(TTo) == typeof(sbyte))
 		{
 			sbyte converted = ChangeSign(ConvertUInt16<byte>(value));
-			return Unsafe.As<sbyte, TTo>(ref converted);
+			return Unsafe.BitCast<sbyte, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(byte))
 		{
@@ -246,21 +246,21 @@ static partial class NumericConversion
 			// This is a special case where we already know an optimal algorithm.
 			uint x = (value * 255u + 32895u) >> 16;
 			byte converted = unchecked((byte)x);
-			return Unsafe.As<byte, TTo>(ref converted);
+			return Unsafe.BitCast<byte, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(short))
 		{
 			short converted = ChangeSign(ConvertUInt16<ushort>(value));
-			return Unsafe.As<short, TTo>(ref converted);
+			return Unsafe.BitCast<short, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(ushort))
 		{
-			return Unsafe.As<ushort, TTo>(ref value);
+			return Unsafe.BitCast<ushort, TTo>(value);
 		}
 		else if (typeof(TTo) == typeof(int))
 		{
 			int converted = ChangeSign(ConvertUInt16<uint>(value));
-			return Unsafe.As<int, TTo>(ref converted);
+			return Unsafe.BitCast<int, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(uint))
 		{
@@ -268,7 +268,7 @@ static partial class NumericConversion
 			unchecked
 			{
 				uint converted = (uint)(((uint)value << 16) | value);
-				return Unsafe.As<uint, TTo>(ref converted);
+				return Unsafe.BitCast<uint, TTo>(converted);
 			}
 		}
 		else if (typeof(TTo) == typeof(nint))
@@ -276,12 +276,12 @@ static partial class NumericConversion
 			if (IntPtr.Size == sizeof(int))
 			{
 				nint converted = (nint)ConvertUInt16<int>(value);
-				return Unsafe.As<nint, TTo>(ref converted);
+				return Unsafe.BitCast<nint, TTo>(converted);
 			}
 			else
 			{
 				nint converted = (nint)ConvertUInt16<long>(value);
-				return Unsafe.As<nint, TTo>(ref converted);
+				return Unsafe.BitCast<nint, TTo>(converted);
 			}
 		}
 		else if (typeof(TTo) == typeof(nuint))
@@ -289,18 +289,18 @@ static partial class NumericConversion
 			if (IntPtr.Size == sizeof(int))
 			{
 				nuint converted = (nuint)ConvertUInt16<uint>(value);
-				return Unsafe.As<nuint, TTo>(ref converted);
+				return Unsafe.BitCast<nuint, TTo>(converted);
 			}
 			else
 			{
 				nuint converted = (nuint)ConvertUInt16<ulong>(value);
-				return Unsafe.As<nuint, TTo>(ref converted);
+				return Unsafe.BitCast<nuint, TTo>(converted);
 			}
 		}
 		else if (typeof(TTo) == typeof(long))
 		{
 			long converted = ChangeSign(ConvertUInt16<ulong>(value));
-			return Unsafe.As<long, TTo>(ref converted);
+			return Unsafe.BitCast<long, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(ulong))
 		{
@@ -308,13 +308,13 @@ static partial class NumericConversion
 			unchecked
 			{
 				ulong converted = (ulong)(((ulong)value << 48) | ((ulong)value << 32) | ((ulong)value << 16) | value);
-				return Unsafe.As<ulong, TTo>(ref converted);
+				return Unsafe.BitCast<ulong, TTo>(converted);
 			}
 		}
 		else if (typeof(TTo) == typeof(Int128))
 		{
 			Int128 converted = ChangeSign(ConvertUInt16<UInt128>(value));
-			return Unsafe.As<Int128, TTo>(ref converted);
+			return Unsafe.BitCast<Int128, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(UInt128))
 		{
@@ -322,7 +322,7 @@ static partial class NumericConversion
 			unchecked
 			{
 				UInt128 converted = (UInt128)(((UInt128)value << 112) | ((UInt128)value << 96) | ((UInt128)value << 80) | ((UInt128)value << 64) | ((UInt128)value << 48) | ((UInt128)value << 32) | ((UInt128)value << 16) | value);
-				return Unsafe.As<UInt128, TTo>(ref converted);
+				return Unsafe.BitCast<UInt128, TTo>(converted);
 			}
 		}
 		else if (typeof(TTo) == typeof(Half))
@@ -330,35 +330,35 @@ static partial class NumericConversion
 			// There isn't enough precision to convert from ushort to Half, so we convert to float first.
 			float x = ConvertUInt16<float>(value);
 			Half converted = (Half)x;
-			return Unsafe.As<Half, TTo>(ref converted);
+			return Unsafe.BitCast<Half, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(float))
 		{
 			float converted = (float)value / (float)ushort.MaxValue;
-			return Unsafe.As<float, TTo>(ref converted);
+			return Unsafe.BitCast<float, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(NFloat))
 		{
 			if (IntPtr.Size == sizeof(int))
 			{
 				NFloat converted = (NFloat)ConvertUInt16<float>(value);
-				return Unsafe.As<NFloat, TTo>(ref converted);
+				return Unsafe.BitCast<NFloat, TTo>(converted);
 			}
 			else
 			{
 				NFloat converted = (NFloat)ConvertUInt16<double>(value);
-				return Unsafe.As<NFloat, TTo>(ref converted);
+				return Unsafe.BitCast<NFloat, TTo>(converted);
 			}
 		}
 		else if (typeof(TTo) == typeof(double))
 		{
 			double converted = (double)value / (double)ushort.MaxValue;
-			return Unsafe.As<double, TTo>(ref converted);
+			return Unsafe.BitCast<double, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(decimal))
 		{
 			decimal converted = (decimal)value / (decimal)ushort.MaxValue;
-			return Unsafe.As<decimal, TTo>(ref converted);
+			return Unsafe.BitCast<decimal, TTo>(converted);
 		}
 		else
 		{
@@ -378,7 +378,7 @@ static partial class NumericConversion
 		if (typeof(TTo) == typeof(sbyte))
 		{
 			sbyte converted = ChangeSign(ConvertUInt32<byte>(value));
-			return Unsafe.As<sbyte, TTo>(ref converted);
+			return Unsafe.BitCast<sbyte, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(byte))
 		{
@@ -386,12 +386,12 @@ static partial class NumericConversion
 			double interpolated = (double)value / (double)uint.MaxValue;
 			double exact = interpolated * (double)byte.MaxValue;
 			byte converted = (byte)double.Round(exact, MidpointRounding.AwayFromZero);
-			return Unsafe.As<byte, TTo>(ref converted);
+			return Unsafe.BitCast<byte, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(short))
 		{
 			short converted = ChangeSign(ConvertUInt32<ushort>(value));
-			return Unsafe.As<short, TTo>(ref converted);
+			return Unsafe.BitCast<short, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(ushort))
 		{
@@ -399,28 +399,28 @@ static partial class NumericConversion
 			double interpolated = (double)value / (double)uint.MaxValue;
 			double exact = interpolated * (double)ushort.MaxValue;
 			ushort converted = (ushort)double.Round(exact, MidpointRounding.AwayFromZero);
-			return Unsafe.As<ushort, TTo>(ref converted);
+			return Unsafe.BitCast<ushort, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(int))
 		{
 			int converted = ChangeSign(ConvertUInt32<uint>(value));
-			return Unsafe.As<int, TTo>(ref converted);
+			return Unsafe.BitCast<int, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(uint))
 		{
-			return Unsafe.As<uint, TTo>(ref value);
+			return Unsafe.BitCast<uint, TTo>(value);
 		}
 		else if (typeof(TTo) == typeof(nint))
 		{
 			if (IntPtr.Size == sizeof(int))
 			{
 				nint converted = (nint)ConvertUInt32<int>(value);
-				return Unsafe.As<nint, TTo>(ref converted);
+				return Unsafe.BitCast<nint, TTo>(converted);
 			}
 			else
 			{
 				nint converted = (nint)ConvertUInt32<long>(value);
-				return Unsafe.As<nint, TTo>(ref converted);
+				return Unsafe.BitCast<nint, TTo>(converted);
 			}
 		}
 		else if (typeof(TTo) == typeof(nuint))
@@ -428,18 +428,18 @@ static partial class NumericConversion
 			if (IntPtr.Size == sizeof(int))
 			{
 				nuint converted = (nuint)ConvertUInt32<uint>(value);
-				return Unsafe.As<nuint, TTo>(ref converted);
+				return Unsafe.BitCast<nuint, TTo>(converted);
 			}
 			else
 			{
 				nuint converted = (nuint)ConvertUInt32<ulong>(value);
-				return Unsafe.As<nuint, TTo>(ref converted);
+				return Unsafe.BitCast<nuint, TTo>(converted);
 			}
 		}
 		else if (typeof(TTo) == typeof(long))
 		{
 			long converted = ChangeSign(ConvertUInt32<ulong>(value));
-			return Unsafe.As<long, TTo>(ref converted);
+			return Unsafe.BitCast<long, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(ulong))
 		{
@@ -447,13 +447,13 @@ static partial class NumericConversion
 			unchecked
 			{
 				ulong converted = (ulong)(((ulong)value << 32) | value);
-				return Unsafe.As<ulong, TTo>(ref converted);
+				return Unsafe.BitCast<ulong, TTo>(converted);
 			}
 		}
 		else if (typeof(TTo) == typeof(Int128))
 		{
 			Int128 converted = ChangeSign(ConvertUInt32<UInt128>(value));
-			return Unsafe.As<Int128, TTo>(ref converted);
+			return Unsafe.BitCast<Int128, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(UInt128))
 		{
@@ -461,7 +461,7 @@ static partial class NumericConversion
 			unchecked
 			{
 				UInt128 converted = (UInt128)(((UInt128)value << 96) | ((UInt128)value << 64) | ((UInt128)value << 32) | value);
-				return Unsafe.As<UInt128, TTo>(ref converted);
+				return Unsafe.BitCast<UInt128, TTo>(converted);
 			}
 		}
 		else if (typeof(TTo) == typeof(Half))
@@ -469,37 +469,37 @@ static partial class NumericConversion
 			// There isn't enough precision to convert from uint to Half, so we convert to double first.
 			double x = ConvertUInt32<double>(value);
 			Half converted = (Half)x;
-			return Unsafe.As<Half, TTo>(ref converted);
+			return Unsafe.BitCast<Half, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(float))
 		{
 			// There isn't enough precision to convert from uint to float, so we convert to double first.
 			double x = ConvertUInt32<double>(value);
 			float converted = (float)x;
-			return Unsafe.As<float, TTo>(ref converted);
+			return Unsafe.BitCast<float, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(NFloat))
 		{
 			if (IntPtr.Size == sizeof(int))
 			{
 				NFloat converted = (NFloat)ConvertUInt32<float>(value);
-				return Unsafe.As<NFloat, TTo>(ref converted);
+				return Unsafe.BitCast<NFloat, TTo>(converted);
 			}
 			else
 			{
 				NFloat converted = (NFloat)ConvertUInt32<double>(value);
-				return Unsafe.As<NFloat, TTo>(ref converted);
+				return Unsafe.BitCast<NFloat, TTo>(converted);
 			}
 		}
 		else if (typeof(TTo) == typeof(double))
 		{
 			double converted = (double)value / (double)uint.MaxValue;
-			return Unsafe.As<double, TTo>(ref converted);
+			return Unsafe.BitCast<double, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(decimal))
 		{
 			decimal converted = (decimal)value / (decimal)uint.MaxValue;
-			return Unsafe.As<decimal, TTo>(ref converted);
+			return Unsafe.BitCast<decimal, TTo>(converted);
 		}
 		else
 		{
@@ -545,7 +545,7 @@ static partial class NumericConversion
 		if (typeof(TTo) == typeof(sbyte))
 		{
 			sbyte converted = ChangeSign(ConvertUInt64<byte>(value));
-			return Unsafe.As<sbyte, TTo>(ref converted);
+			return Unsafe.BitCast<sbyte, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(byte))
 		{
@@ -554,13 +554,13 @@ static partial class NumericConversion
 			unchecked
 			{
 				byte converted = (byte)((ulong)value >> 56);
-				return Unsafe.As<byte, TTo>(ref converted);
+				return Unsafe.BitCast<byte, TTo>(converted);
 			}
 		}
 		else if (typeof(TTo) == typeof(short))
 		{
 			short converted = ChangeSign(ConvertUInt64<ushort>(value));
-			return Unsafe.As<short, TTo>(ref converted);
+			return Unsafe.BitCast<short, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(ushort))
 		{
@@ -569,13 +569,13 @@ static partial class NumericConversion
 			unchecked
 			{
 				ushort converted = (ushort)((ulong)value >> 48);
-				return Unsafe.As<ushort, TTo>(ref converted);
+				return Unsafe.BitCast<ushort, TTo>(converted);
 			}
 		}
 		else if (typeof(TTo) == typeof(int))
 		{
 			int converted = ChangeSign(ConvertUInt64<uint>(value));
-			return Unsafe.As<int, TTo>(ref converted);
+			return Unsafe.BitCast<int, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(uint))
 		{
@@ -584,7 +584,7 @@ static partial class NumericConversion
 			unchecked
 			{
 				uint converted = (uint)((ulong)value >> 32);
-				return Unsafe.As<uint, TTo>(ref converted);
+				return Unsafe.BitCast<uint, TTo>(converted);
 			}
 		}
 		else if (typeof(TTo) == typeof(nint))
@@ -592,12 +592,12 @@ static partial class NumericConversion
 			if (IntPtr.Size == sizeof(int))
 			{
 				nint converted = (nint)ConvertUInt64<int>(value);
-				return Unsafe.As<nint, TTo>(ref converted);
+				return Unsafe.BitCast<nint, TTo>(converted);
 			}
 			else
 			{
 				nint converted = (nint)ConvertUInt64<long>(value);
-				return Unsafe.As<nint, TTo>(ref converted);
+				return Unsafe.BitCast<nint, TTo>(converted);
 			}
 		}
 		else if (typeof(TTo) == typeof(nuint))
@@ -605,27 +605,27 @@ static partial class NumericConversion
 			if (IntPtr.Size == sizeof(int))
 			{
 				nuint converted = (nuint)ConvertUInt64<uint>(value);
-				return Unsafe.As<nuint, TTo>(ref converted);
+				return Unsafe.BitCast<nuint, TTo>(converted);
 			}
 			else
 			{
 				nuint converted = (nuint)ConvertUInt64<ulong>(value);
-				return Unsafe.As<nuint, TTo>(ref converted);
+				return Unsafe.BitCast<nuint, TTo>(converted);
 			}
 		}
 		else if (typeof(TTo) == typeof(long))
 		{
 			long converted = ChangeSign(ConvertUInt64<ulong>(value));
-			return Unsafe.As<long, TTo>(ref converted);
+			return Unsafe.BitCast<long, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(ulong))
 		{
-			return Unsafe.As<ulong, TTo>(ref value);
+			return Unsafe.BitCast<ulong, TTo>(value);
 		}
 		else if (typeof(TTo) == typeof(Int128))
 		{
 			Int128 converted = ChangeSign(ConvertUInt64<UInt128>(value));
-			return Unsafe.As<Int128, TTo>(ref converted);
+			return Unsafe.BitCast<Int128, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(UInt128))
 		{
@@ -633,7 +633,7 @@ static partial class NumericConversion
 			unchecked
 			{
 				UInt128 converted = (UInt128)(((UInt128)value << 64) | value);
-				return Unsafe.As<UInt128, TTo>(ref converted);
+				return Unsafe.BitCast<UInt128, TTo>(converted);
 			}
 		}
 		else if (typeof(TTo) == typeof(Half))
@@ -641,37 +641,37 @@ static partial class NumericConversion
 			// There isn't enough precision to convert from ulong to Half, so we convert to double first.
 			double x = ConvertUInt64<double>(value);
 			Half converted = (Half)x;
-			return Unsafe.As<Half, TTo>(ref converted);
+			return Unsafe.BitCast<Half, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(float))
 		{
 			// There isn't enough precision to convert from ulong to float, so we convert to double first.
 			double x = ConvertUInt64<double>(value);
 			float converted = (float)x;
-			return Unsafe.As<float, TTo>(ref converted);
+			return Unsafe.BitCast<float, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(NFloat))
 		{
 			if (IntPtr.Size == sizeof(int))
 			{
 				NFloat converted = (NFloat)ConvertUInt64<float>(value);
-				return Unsafe.As<NFloat, TTo>(ref converted);
+				return Unsafe.BitCast<NFloat, TTo>(converted);
 			}
 			else
 			{
 				NFloat converted = (NFloat)ConvertUInt64<double>(value);
-				return Unsafe.As<NFloat, TTo>(ref converted);
+				return Unsafe.BitCast<NFloat, TTo>(converted);
 			}
 		}
 		else if (typeof(TTo) == typeof(double))
 		{
 			double converted = (double)value / (double)ulong.MaxValue;
-			return Unsafe.As<double, TTo>(ref converted);
+			return Unsafe.BitCast<double, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(decimal))
 		{
 			decimal converted = (decimal)value / (decimal)ulong.MaxValue;
-			return Unsafe.As<decimal, TTo>(ref converted);
+			return Unsafe.BitCast<decimal, TTo>(converted);
 		}
 		else
 		{
@@ -691,7 +691,7 @@ static partial class NumericConversion
 		if (typeof(TTo) == typeof(sbyte))
 		{
 			sbyte converted = ChangeSign(ConvertUInt128<byte>(value));
-			return Unsafe.As<sbyte, TTo>(ref converted);
+			return Unsafe.BitCast<sbyte, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(byte))
 		{
@@ -700,13 +700,13 @@ static partial class NumericConversion
 			unchecked
 			{
 				byte converted = (byte)((UInt128)value >> 120);
-				return Unsafe.As<byte, TTo>(ref converted);
+				return Unsafe.BitCast<byte, TTo>(converted);
 			}
 		}
 		else if (typeof(TTo) == typeof(short))
 		{
 			short converted = ChangeSign(ConvertUInt128<ushort>(value));
-			return Unsafe.As<short, TTo>(ref converted);
+			return Unsafe.BitCast<short, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(ushort))
 		{
@@ -715,13 +715,13 @@ static partial class NumericConversion
 			unchecked
 			{
 				ushort converted = (ushort)((UInt128)value >> 112);
-				return Unsafe.As<ushort, TTo>(ref converted);
+				return Unsafe.BitCast<ushort, TTo>(converted);
 			}
 		}
 		else if (typeof(TTo) == typeof(int))
 		{
 			int converted = ChangeSign(ConvertUInt128<uint>(value));
-			return Unsafe.As<int, TTo>(ref converted);
+			return Unsafe.BitCast<int, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(uint))
 		{
@@ -730,7 +730,7 @@ static partial class NumericConversion
 			unchecked
 			{
 				uint converted = (uint)((UInt128)value >> 96);
-				return Unsafe.As<uint, TTo>(ref converted);
+				return Unsafe.BitCast<uint, TTo>(converted);
 			}
 		}
 		else if (typeof(TTo) == typeof(nint))
@@ -738,12 +738,12 @@ static partial class NumericConversion
 			if (IntPtr.Size == sizeof(int))
 			{
 				nint converted = (nint)ConvertUInt128<int>(value);
-				return Unsafe.As<nint, TTo>(ref converted);
+				return Unsafe.BitCast<nint, TTo>(converted);
 			}
 			else
 			{
 				nint converted = (nint)ConvertUInt128<long>(value);
-				return Unsafe.As<nint, TTo>(ref converted);
+				return Unsafe.BitCast<nint, TTo>(converted);
 			}
 		}
 		else if (typeof(TTo) == typeof(nuint))
@@ -751,18 +751,18 @@ static partial class NumericConversion
 			if (IntPtr.Size == sizeof(int))
 			{
 				nuint converted = (nuint)ConvertUInt128<uint>(value);
-				return Unsafe.As<nuint, TTo>(ref converted);
+				return Unsafe.BitCast<nuint, TTo>(converted);
 			}
 			else
 			{
 				nuint converted = (nuint)ConvertUInt128<ulong>(value);
-				return Unsafe.As<nuint, TTo>(ref converted);
+				return Unsafe.BitCast<nuint, TTo>(converted);
 			}
 		}
 		else if (typeof(TTo) == typeof(long))
 		{
 			long converted = ChangeSign(ConvertUInt128<ulong>(value));
-			return Unsafe.As<long, TTo>(ref converted);
+			return Unsafe.BitCast<long, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(ulong))
 		{
@@ -771,54 +771,54 @@ static partial class NumericConversion
 			unchecked
 			{
 				ulong converted = (ulong)((UInt128)value >> 64);
-				return Unsafe.As<ulong, TTo>(ref converted);
+				return Unsafe.BitCast<ulong, TTo>(converted);
 			}
 		}
 		else if (typeof(TTo) == typeof(Int128))
 		{
 			Int128 converted = ChangeSign(ConvertUInt128<UInt128>(value));
-			return Unsafe.As<Int128, TTo>(ref converted);
+			return Unsafe.BitCast<Int128, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(UInt128))
 		{
-			return Unsafe.As<UInt128, TTo>(ref value);
+			return Unsafe.BitCast<UInt128, TTo>(value);
 		}
 		else if (typeof(TTo) == typeof(Half))
 		{
 			// There isn't enough precision to convert from UInt128 to Half, so we convert to double first.
 			double x = ConvertUInt128<double>(value);
 			Half converted = (Half)x;
-			return Unsafe.As<Half, TTo>(ref converted);
+			return Unsafe.BitCast<Half, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(float))
 		{
 			// There isn't enough precision to convert from UInt128 to float, so we convert to double first.
 			double x = ConvertUInt128<double>(value);
 			float converted = (float)x;
-			return Unsafe.As<float, TTo>(ref converted);
+			return Unsafe.BitCast<float, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(NFloat))
 		{
 			if (IntPtr.Size == sizeof(int))
 			{
 				NFloat converted = (NFloat)ConvertUInt128<float>(value);
-				return Unsafe.As<NFloat, TTo>(ref converted);
+				return Unsafe.BitCast<NFloat, TTo>(converted);
 			}
 			else
 			{
 				NFloat converted = (NFloat)ConvertUInt128<double>(value);
-				return Unsafe.As<NFloat, TTo>(ref converted);
+				return Unsafe.BitCast<NFloat, TTo>(converted);
 			}
 		}
 		else if (typeof(TTo) == typeof(double))
 		{
 			double converted = (double)value / (double)UInt128.MaxValue;
-			return Unsafe.As<double, TTo>(ref converted);
+			return Unsafe.BitCast<double, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(decimal))
 		{
 			decimal converted = (decimal)value / (decimal)UInt128.MaxValue;
-			return Unsafe.As<decimal, TTo>(ref converted);
+			return Unsafe.BitCast<decimal, TTo>(converted);
 		}
 		else
 		{
@@ -832,7 +832,7 @@ static partial class NumericConversion
 		if (typeof(TTo) == typeof(sbyte))
 		{
 			sbyte converted = ChangeSign(ConvertHalf<byte>(value));
-			return Unsafe.As<sbyte, TTo>(ref converted);
+			return Unsafe.BitCast<sbyte, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(byte))
 		{
@@ -842,7 +842,7 @@ static partial class NumericConversion
 		else if (typeof(TTo) == typeof(short))
 		{
 			short converted = ChangeSign(ConvertHalf<ushort>(value));
-			return Unsafe.As<short, TTo>(ref converted);
+			return Unsafe.BitCast<short, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(ushort))
 		{
@@ -852,7 +852,7 @@ static partial class NumericConversion
 		else if (typeof(TTo) == typeof(int))
 		{
 			int converted = ChangeSign(ConvertHalf<uint>(value));
-			return Unsafe.As<int, TTo>(ref converted);
+			return Unsafe.BitCast<int, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(uint))
 		{
@@ -864,12 +864,12 @@ static partial class NumericConversion
 			if (IntPtr.Size == sizeof(int))
 			{
 				nint converted = (nint)ConvertHalf<int>(value);
-				return Unsafe.As<nint, TTo>(ref converted);
+				return Unsafe.BitCast<nint, TTo>(converted);
 			}
 			else
 			{
 				nint converted = (nint)ConvertHalf<long>(value);
-				return Unsafe.As<nint, TTo>(ref converted);
+				return Unsafe.BitCast<nint, TTo>(converted);
 			}
 		}
 		else if (typeof(TTo) == typeof(nuint))
@@ -877,18 +877,18 @@ static partial class NumericConversion
 			if (IntPtr.Size == sizeof(int))
 			{
 				nuint converted = (nuint)ConvertHalf<uint>(value);
-				return Unsafe.As<nuint, TTo>(ref converted);
+				return Unsafe.BitCast<nuint, TTo>(converted);
 			}
 			else
 			{
 				nuint converted = (nuint)ConvertHalf<ulong>(value);
-				return Unsafe.As<nuint, TTo>(ref converted);
+				return Unsafe.BitCast<nuint, TTo>(converted);
 			}
 		}
 		else if (typeof(TTo) == typeof(long))
 		{
 			long converted = ChangeSign(ConvertHalf<ulong>(value));
-			return Unsafe.As<long, TTo>(ref converted);
+			return Unsafe.BitCast<long, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(ulong))
 		{
@@ -898,7 +898,7 @@ static partial class NumericConversion
 		else if (typeof(TTo) == typeof(Int128))
 		{
 			Int128 converted = ChangeSign(ConvertHalf<UInt128>(value));
-			return Unsafe.As<Int128, TTo>(ref converted);
+			return Unsafe.BitCast<Int128, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(UInt128))
 		{
@@ -907,35 +907,35 @@ static partial class NumericConversion
 		}
 		else if (typeof(TTo) == typeof(Half))
 		{
-			return Unsafe.As<Half, TTo>(ref value);
+			return Unsafe.BitCast<Half, TTo>(value);
 		}
 		else if (typeof(TTo) == typeof(float))
 		{
 			float converted = (float)value;
-			return Unsafe.As<float, TTo>(ref converted);
+			return Unsafe.BitCast<float, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(NFloat))
 		{
 			if (IntPtr.Size == sizeof(int))
 			{
 				NFloat converted = (NFloat)ConvertHalf<float>(value);
-				return Unsafe.As<NFloat, TTo>(ref converted);
+				return Unsafe.BitCast<NFloat, TTo>(converted);
 			}
 			else
 			{
 				NFloat converted = (NFloat)ConvertHalf<double>(value);
-				return Unsafe.As<NFloat, TTo>(ref converted);
+				return Unsafe.BitCast<NFloat, TTo>(converted);
 			}
 		}
 		else if (typeof(TTo) == typeof(double))
 		{
 			double converted = (double)value;
-			return Unsafe.As<double, TTo>(ref converted);
+			return Unsafe.BitCast<double, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(decimal))
 		{
 			decimal converted = (decimal)value;
-			return Unsafe.As<decimal, TTo>(ref converted);
+			return Unsafe.BitCast<decimal, TTo>(converted);
 		}
 		else
 		{
@@ -949,31 +949,31 @@ static partial class NumericConversion
 		if (typeof(TTo) == typeof(sbyte))
 		{
 			sbyte converted = ChangeSign(ConvertSingle<byte>(value));
-			return Unsafe.As<sbyte, TTo>(ref converted);
+			return Unsafe.BitCast<sbyte, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(byte))
 		{
 			// x must be clamped because of rounding errors.
 			float x = value * (float)byte.MaxValue;
 			byte converted = (float)byte.MaxValue < x ? byte.MaxValue : (x > (float)byte.MinValue ? (byte)x : byte.MinValue);
-			return Unsafe.As<byte, TTo>(ref converted);
+			return Unsafe.BitCast<byte, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(short))
 		{
 			short converted = ChangeSign(ConvertSingle<ushort>(value));
-			return Unsafe.As<short, TTo>(ref converted);
+			return Unsafe.BitCast<short, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(ushort))
 		{
 			// x must be clamped because of rounding errors.
 			float x = value * (float)ushort.MaxValue;
 			ushort converted = (float)ushort.MaxValue < x ? ushort.MaxValue : (x > (float)ushort.MinValue ? (ushort)x : ushort.MinValue);
-			return Unsafe.As<ushort, TTo>(ref converted);
+			return Unsafe.BitCast<ushort, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(int))
 		{
 			int converted = ChangeSign(ConvertSingle<uint>(value));
-			return Unsafe.As<int, TTo>(ref converted);
+			return Unsafe.BitCast<int, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(uint))
 		{
@@ -985,12 +985,12 @@ static partial class NumericConversion
 			if (IntPtr.Size == sizeof(int))
 			{
 				nint converted = (nint)ConvertSingle<int>(value);
-				return Unsafe.As<nint, TTo>(ref converted);
+				return Unsafe.BitCast<nint, TTo>(converted);
 			}
 			else
 			{
 				nint converted = (nint)ConvertSingle<long>(value);
-				return Unsafe.As<nint, TTo>(ref converted);
+				return Unsafe.BitCast<nint, TTo>(converted);
 			}
 		}
 		else if (typeof(TTo) == typeof(nuint))
@@ -998,18 +998,18 @@ static partial class NumericConversion
 			if (IntPtr.Size == sizeof(int))
 			{
 				nuint converted = (nuint)ConvertSingle<uint>(value);
-				return Unsafe.As<nuint, TTo>(ref converted);
+				return Unsafe.BitCast<nuint, TTo>(converted);
 			}
 			else
 			{
 				nuint converted = (nuint)ConvertSingle<ulong>(value);
-				return Unsafe.As<nuint, TTo>(ref converted);
+				return Unsafe.BitCast<nuint, TTo>(converted);
 			}
 		}
 		else if (typeof(TTo) == typeof(long))
 		{
 			long converted = ChangeSign(ConvertSingle<ulong>(value));
-			return Unsafe.As<long, TTo>(ref converted);
+			return Unsafe.BitCast<long, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(ulong))
 		{
@@ -1019,7 +1019,7 @@ static partial class NumericConversion
 		else if (typeof(TTo) == typeof(Int128))
 		{
 			Int128 converted = ChangeSign(ConvertSingle<UInt128>(value));
-			return Unsafe.As<Int128, TTo>(ref converted);
+			return Unsafe.BitCast<Int128, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(UInt128))
 		{
@@ -1029,34 +1029,34 @@ static partial class NumericConversion
 		else if (typeof(TTo) == typeof(Half))
 		{
 			Half converted = (Half)value;
-			return Unsafe.As<Half, TTo>(ref converted);
+			return Unsafe.BitCast<Half, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(float))
 		{
-			return Unsafe.As<float, TTo>(ref value);
+			return Unsafe.BitCast<float, TTo>(value);
 		}
 		else if (typeof(TTo) == typeof(NFloat))
 		{
 			if (IntPtr.Size == sizeof(int))
 			{
 				NFloat converted = (NFloat)ConvertSingle<float>(value);
-				return Unsafe.As<NFloat, TTo>(ref converted);
+				return Unsafe.BitCast<NFloat, TTo>(converted);
 			}
 			else
 			{
 				NFloat converted = (NFloat)ConvertSingle<double>(value);
-				return Unsafe.As<NFloat, TTo>(ref converted);
+				return Unsafe.BitCast<NFloat, TTo>(converted);
 			}
 		}
 		else if (typeof(TTo) == typeof(double))
 		{
 			double converted = (double)value;
-			return Unsafe.As<double, TTo>(ref converted);
+			return Unsafe.BitCast<double, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(decimal))
 		{
 			decimal converted = (decimal)value;
-			return Unsafe.As<decimal, TTo>(ref converted);
+			return Unsafe.BitCast<decimal, TTo>(converted);
 		}
 		else
 		{
@@ -1083,50 +1083,50 @@ static partial class NumericConversion
 		if (typeof(TTo) == typeof(sbyte))
 		{
 			sbyte converted = ChangeSign(ConvertDouble<byte>(value));
-			return Unsafe.As<sbyte, TTo>(ref converted);
+			return Unsafe.BitCast<sbyte, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(byte))
 		{
 			// x must be clamped because of rounding errors.
 			double x = value * (double)byte.MaxValue;
 			byte converted = (double)byte.MaxValue < x ? byte.MaxValue : (x > (double)byte.MinValue ? (byte)x : byte.MinValue);
-			return Unsafe.As<byte, TTo>(ref converted);
+			return Unsafe.BitCast<byte, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(short))
 		{
 			short converted = ChangeSign(ConvertDouble<ushort>(value));
-			return Unsafe.As<short, TTo>(ref converted);
+			return Unsafe.BitCast<short, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(ushort))
 		{
 			// x must be clamped because of rounding errors.
 			double x = value * (double)ushort.MaxValue;
 			ushort converted = (double)ushort.MaxValue < x ? ushort.MaxValue : (x > (double)ushort.MinValue ? (ushort)x : ushort.MinValue);
-			return Unsafe.As<ushort, TTo>(ref converted);
+			return Unsafe.BitCast<ushort, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(int))
 		{
 			int converted = ChangeSign(ConvertDouble<uint>(value));
-			return Unsafe.As<int, TTo>(ref converted);
+			return Unsafe.BitCast<int, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(uint))
 		{
 			// x must be clamped because of rounding errors.
 			double x = value * (double)uint.MaxValue;
 			uint converted = (double)uint.MaxValue < x ? uint.MaxValue : (x > (double)uint.MinValue ? (uint)x : uint.MinValue);
-			return Unsafe.As<uint, TTo>(ref converted);
+			return Unsafe.BitCast<uint, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(nint))
 		{
 			if (IntPtr.Size == sizeof(int))
 			{
 				nint converted = (nint)ConvertDouble<int>(value);
-				return Unsafe.As<nint, TTo>(ref converted);
+				return Unsafe.BitCast<nint, TTo>(converted);
 			}
 			else
 			{
 				nint converted = (nint)ConvertDouble<long>(value);
-				return Unsafe.As<nint, TTo>(ref converted);
+				return Unsafe.BitCast<nint, TTo>(converted);
 			}
 		}
 		else if (typeof(TTo) == typeof(nuint))
@@ -1134,69 +1134,69 @@ static partial class NumericConversion
 			if (IntPtr.Size == sizeof(int))
 			{
 				nuint converted = (nuint)ConvertDouble<uint>(value);
-				return Unsafe.As<nuint, TTo>(ref converted);
+				return Unsafe.BitCast<nuint, TTo>(converted);
 			}
 			else
 			{
 				nuint converted = (nuint)ConvertDouble<ulong>(value);
-				return Unsafe.As<nuint, TTo>(ref converted);
+				return Unsafe.BitCast<nuint, TTo>(converted);
 			}
 		}
 		else if (typeof(TTo) == typeof(long))
 		{
 			long converted = ChangeSign(ConvertDouble<ulong>(value));
-			return Unsafe.As<long, TTo>(ref converted);
+			return Unsafe.BitCast<long, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(ulong))
 		{
 			// x must be clamped because of rounding errors.
 			double x = value * (double)ulong.MaxValue;
 			ulong converted = (double)ulong.MaxValue < x ? ulong.MaxValue : (x > (double)ulong.MinValue ? (ulong)x : ulong.MinValue);
-			return Unsafe.As<ulong, TTo>(ref converted);
+			return Unsafe.BitCast<ulong, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(Int128))
 		{
 			Int128 converted = ChangeSign(ConvertDouble<UInt128>(value));
-			return Unsafe.As<Int128, TTo>(ref converted);
+			return Unsafe.BitCast<Int128, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(UInt128))
 		{
 			// x must be clamped because of rounding errors.
 			double x = value * (double)UInt128.MaxValue;
 			UInt128 converted = (double)UInt128.MaxValue < x ? UInt128.MaxValue : (x > (double)UInt128.MinValue ? (UInt128)x : UInt128.MinValue);
-			return Unsafe.As<UInt128, TTo>(ref converted);
+			return Unsafe.BitCast<UInt128, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(Half))
 		{
 			Half converted = (Half)value;
-			return Unsafe.As<Half, TTo>(ref converted);
+			return Unsafe.BitCast<Half, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(float))
 		{
 			float converted = (float)value;
-			return Unsafe.As<float, TTo>(ref converted);
+			return Unsafe.BitCast<float, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(NFloat))
 		{
 			if (IntPtr.Size == sizeof(int))
 			{
 				NFloat converted = (NFloat)ConvertDouble<float>(value);
-				return Unsafe.As<NFloat, TTo>(ref converted);
+				return Unsafe.BitCast<NFloat, TTo>(converted);
 			}
 			else
 			{
 				NFloat converted = (NFloat)ConvertDouble<double>(value);
-				return Unsafe.As<NFloat, TTo>(ref converted);
+				return Unsafe.BitCast<NFloat, TTo>(converted);
 			}
 		}
 		else if (typeof(TTo) == typeof(double))
 		{
-			return Unsafe.As<double, TTo>(ref value);
+			return Unsafe.BitCast<double, TTo>(value);
 		}
 		else if (typeof(TTo) == typeof(decimal))
 		{
 			decimal converted = (decimal)value;
-			return Unsafe.As<decimal, TTo>(ref converted);
+			return Unsafe.BitCast<decimal, TTo>(converted);
 		}
 		else
 		{
@@ -1210,50 +1210,50 @@ static partial class NumericConversion
 		if (typeof(TTo) == typeof(sbyte))
 		{
 			sbyte converted = ChangeSign(ConvertDecimal<byte>(value));
-			return Unsafe.As<sbyte, TTo>(ref converted);
+			return Unsafe.BitCast<sbyte, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(byte))
 		{
 			// x must be clamped because of rounding errors.
 			decimal x = value * (decimal)byte.MaxValue;
 			byte converted = (decimal)byte.MaxValue < x ? byte.MaxValue : (x > (decimal)byte.MinValue ? (byte)x : byte.MinValue);
-			return Unsafe.As<byte, TTo>(ref converted);
+			return Unsafe.BitCast<byte, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(short))
 		{
 			short converted = ChangeSign(ConvertDecimal<ushort>(value));
-			return Unsafe.As<short, TTo>(ref converted);
+			return Unsafe.BitCast<short, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(ushort))
 		{
 			// x must be clamped because of rounding errors.
 			decimal x = value * (decimal)ushort.MaxValue;
 			ushort converted = (decimal)ushort.MaxValue < x ? ushort.MaxValue : (x > (decimal)ushort.MinValue ? (ushort)x : ushort.MinValue);
-			return Unsafe.As<ushort, TTo>(ref converted);
+			return Unsafe.BitCast<ushort, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(int))
 		{
 			int converted = ChangeSign(ConvertDecimal<uint>(value));
-			return Unsafe.As<int, TTo>(ref converted);
+			return Unsafe.BitCast<int, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(uint))
 		{
 			// x must be clamped because of rounding errors.
 			decimal x = value * (decimal)uint.MaxValue;
 			uint converted = (decimal)uint.MaxValue < x ? uint.MaxValue : (x > (decimal)uint.MinValue ? (uint)x : uint.MinValue);
-			return Unsafe.As<uint, TTo>(ref converted);
+			return Unsafe.BitCast<uint, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(nint))
 		{
 			if (IntPtr.Size == sizeof(int))
 			{
 				nint converted = (nint)ConvertDecimal<int>(value);
-				return Unsafe.As<nint, TTo>(ref converted);
+				return Unsafe.BitCast<nint, TTo>(converted);
 			}
 			else
 			{
 				nint converted = (nint)ConvertDecimal<long>(value);
-				return Unsafe.As<nint, TTo>(ref converted);
+				return Unsafe.BitCast<nint, TTo>(converted);
 			}
 		}
 		else if (typeof(TTo) == typeof(nuint))
@@ -1261,69 +1261,69 @@ static partial class NumericConversion
 			if (IntPtr.Size == sizeof(int))
 			{
 				nuint converted = (nuint)ConvertDecimal<uint>(value);
-				return Unsafe.As<nuint, TTo>(ref converted);
+				return Unsafe.BitCast<nuint, TTo>(converted);
 			}
 			else
 			{
 				nuint converted = (nuint)ConvertDecimal<ulong>(value);
-				return Unsafe.As<nuint, TTo>(ref converted);
+				return Unsafe.BitCast<nuint, TTo>(converted);
 			}
 		}
 		else if (typeof(TTo) == typeof(long))
 		{
 			long converted = ChangeSign(ConvertDecimal<ulong>(value));
-			return Unsafe.As<long, TTo>(ref converted);
+			return Unsafe.BitCast<long, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(ulong))
 		{
 			// x must be clamped because of rounding errors.
 			decimal x = value * (decimal)ulong.MaxValue;
 			ulong converted = (decimal)ulong.MaxValue < x ? ulong.MaxValue : (x > (decimal)ulong.MinValue ? (ulong)x : ulong.MinValue);
-			return Unsafe.As<ulong, TTo>(ref converted);
+			return Unsafe.BitCast<ulong, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(Int128))
 		{
 			Int128 converted = ChangeSign(ConvertDecimal<UInt128>(value));
-			return Unsafe.As<Int128, TTo>(ref converted);
+			return Unsafe.BitCast<Int128, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(UInt128))
 		{
 			// x must be clamped because of rounding errors.
 			decimal x = value * (decimal)UInt128.MaxValue;
 			UInt128 converted = (decimal)UInt128.MaxValue < x ? UInt128.MaxValue : (x > (decimal)UInt128.MinValue ? (UInt128)x : UInt128.MinValue);
-			return Unsafe.As<UInt128, TTo>(ref converted);
+			return Unsafe.BitCast<UInt128, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(Half))
 		{
 			Half converted = (Half)value;
-			return Unsafe.As<Half, TTo>(ref converted);
+			return Unsafe.BitCast<Half, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(float))
 		{
 			float converted = (float)value;
-			return Unsafe.As<float, TTo>(ref converted);
+			return Unsafe.BitCast<float, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(NFloat))
 		{
 			if (IntPtr.Size == sizeof(int))
 			{
 				NFloat converted = (NFloat)ConvertDecimal<float>(value);
-				return Unsafe.As<NFloat, TTo>(ref converted);
+				return Unsafe.BitCast<NFloat, TTo>(converted);
 			}
 			else
 			{
 				NFloat converted = (NFloat)ConvertDecimal<double>(value);
-				return Unsafe.As<NFloat, TTo>(ref converted);
+				return Unsafe.BitCast<NFloat, TTo>(converted);
 			}
 		}
 		else if (typeof(TTo) == typeof(double))
 		{
 			double converted = (double)value;
-			return Unsafe.As<double, TTo>(ref converted);
+			return Unsafe.BitCast<double, TTo>(converted);
 		}
 		else if (typeof(TTo) == typeof(decimal))
 		{
-			return Unsafe.As<decimal, TTo>(ref value);
+			return Unsafe.BitCast<decimal, TTo>(value);
 		}
 		else
 		{
@@ -1337,87 +1337,87 @@ static partial class NumericConversion
 		if (typeof(T) == typeof(sbyte))
 		{
 			sbyte value = GetMinimumValueSafe<sbyte>();
-			return Unsafe.As<sbyte, T>(ref value);
+			return Unsafe.BitCast<sbyte, T>(value);
 		}
 		else if (typeof(T) == typeof(byte))
 		{
 			byte value = GetMinimumValueSafe<byte>();
-			return Unsafe.As<byte, T>(ref value);
+			return Unsafe.BitCast<byte, T>(value);
 		}
 		else if (typeof(T) == typeof(short))
 		{
 			short value = GetMinimumValueSafe<short>();
-			return Unsafe.As<short, T>(ref value);
+			return Unsafe.BitCast<short, T>(value);
 		}
 		else if (typeof(T) == typeof(ushort))
 		{
 			ushort value = GetMinimumValueSafe<ushort>();
-			return Unsafe.As<ushort, T>(ref value);
+			return Unsafe.BitCast<ushort, T>(value);
 		}
 		else if (typeof(T) == typeof(int))
 		{
 			int value = GetMinimumValueSafe<int>();
-			return Unsafe.As<int, T>(ref value);
+			return Unsafe.BitCast<int, T>(value);
 		}
 		else if (typeof(T) == typeof(uint))
 		{
 			uint value = GetMinimumValueSafe<uint>();
-			return Unsafe.As<uint, T>(ref value);
+			return Unsafe.BitCast<uint, T>(value);
 		}
 		else if (typeof(T) == typeof(nint))
 		{
 			nint value = GetMinimumValueSafe<nint>();
-			return Unsafe.As<nint, T>(ref value);
+			return Unsafe.BitCast<nint, T>(value);
 		}
 		else if (typeof(T) == typeof(nuint))
 		{
 			nuint value = GetMinimumValueSafe<nuint>();
-			return Unsafe.As<nuint, T>(ref value);
+			return Unsafe.BitCast<nuint, T>(value);
 		}
 		else if (typeof(T) == typeof(long))
 		{
 			long value = GetMinimumValueSafe<long>();
-			return Unsafe.As<long, T>(ref value);
+			return Unsafe.BitCast<long, T>(value);
 		}
 		else if (typeof(T) == typeof(ulong))
 		{
 			ulong value = GetMinimumValueSafe<ulong>();
-			return Unsafe.As<ulong, T>(ref value);
+			return Unsafe.BitCast<ulong, T>(value);
 		}
 		else if (typeof(T) == typeof(Int128))
 		{
 			Int128 value = GetMinimumValueSafe<Int128>();
-			return Unsafe.As<Int128, T>(ref value);
+			return Unsafe.BitCast<Int128, T>(value);
 		}
 		else if (typeof(T) == typeof(UInt128))
 		{
 			UInt128 value = GetMinimumValueSafe<UInt128>();
-			return Unsafe.As<UInt128, T>(ref value);
+			return Unsafe.BitCast<UInt128, T>(value);
 		}
 		else if (typeof(T) == typeof(Half))
 		{
 			Half value = GetMinimumValueSafe<Half>();
-			return Unsafe.As<Half, T>(ref value);
+			return Unsafe.BitCast<Half, T>(value);
 		}
 		else if (typeof(T) == typeof(float))
 		{
 			float value = GetMinimumValueSafe<float>();
-			return Unsafe.As<float, T>(ref value);
+			return Unsafe.BitCast<float, T>(value);
 		}
 		else if (typeof(T) == typeof(NFloat))
 		{
 			NFloat value = GetMinimumValueSafe<NFloat>();
-			return Unsafe.As<NFloat, T>(ref value);
+			return Unsafe.BitCast<NFloat, T>(value);
 		}
 		else if (typeof(T) == typeof(double))
 		{
 			double value = GetMinimumValueSafe<double>();
-			return Unsafe.As<double, T>(ref value);
+			return Unsafe.BitCast<double, T>(value);
 		}
 		else if (typeof(T) == typeof(decimal))
 		{
 			decimal value = GetMinimumValueSafe<decimal>();
-			return Unsafe.As<decimal, T>(ref value);
+			return Unsafe.BitCast<decimal, T>(value);
 		}
 		else
 		{
@@ -1431,87 +1431,87 @@ static partial class NumericConversion
 		if (typeof(T) == typeof(sbyte))
 		{
 			sbyte value = GetMaximumValueSafe<sbyte>();
-			return Unsafe.As<sbyte, T>(ref value);
+			return Unsafe.BitCast<sbyte, T>(value);
 		}
 		else if (typeof(T) == typeof(byte))
 		{
 			byte value = GetMaximumValueSafe<byte>();
-			return Unsafe.As<byte, T>(ref value);
+			return Unsafe.BitCast<byte, T>(value);
 		}
 		else if (typeof(T) == typeof(short))
 		{
 			short value = GetMaximumValueSafe<short>();
-			return Unsafe.As<short, T>(ref value);
+			return Unsafe.BitCast<short, T>(value);
 		}
 		else if (typeof(T) == typeof(ushort))
 		{
 			ushort value = GetMaximumValueSafe<ushort>();
-			return Unsafe.As<ushort, T>(ref value);
+			return Unsafe.BitCast<ushort, T>(value);
 		}
 		else if (typeof(T) == typeof(int))
 		{
 			int value = GetMaximumValueSafe<int>();
-			return Unsafe.As<int, T>(ref value);
+			return Unsafe.BitCast<int, T>(value);
 		}
 		else if (typeof(T) == typeof(uint))
 		{
 			uint value = GetMaximumValueSafe<uint>();
-			return Unsafe.As<uint, T>(ref value);
+			return Unsafe.BitCast<uint, T>(value);
 		}
 		else if (typeof(T) == typeof(nint))
 		{
 			nint value = GetMaximumValueSafe<nint>();
-			return Unsafe.As<nint, T>(ref value);
+			return Unsafe.BitCast<nint, T>(value);
 		}
 		else if (typeof(T) == typeof(nuint))
 		{
 			nuint value = GetMaximumValueSafe<nuint>();
-			return Unsafe.As<nuint, T>(ref value);
+			return Unsafe.BitCast<nuint, T>(value);
 		}
 		else if (typeof(T) == typeof(long))
 		{
 			long value = GetMaximumValueSafe<long>();
-			return Unsafe.As<long, T>(ref value);
+			return Unsafe.BitCast<long, T>(value);
 		}
 		else if (typeof(T) == typeof(ulong))
 		{
 			ulong value = GetMaximumValueSafe<ulong>();
-			return Unsafe.As<ulong, T>(ref value);
+			return Unsafe.BitCast<ulong, T>(value);
 		}
 		else if (typeof(T) == typeof(Int128))
 		{
 			Int128 value = GetMaximumValueSafe<Int128>();
-			return Unsafe.As<Int128, T>(ref value);
+			return Unsafe.BitCast<Int128, T>(value);
 		}
 		else if (typeof(T) == typeof(UInt128))
 		{
 			UInt128 value = GetMaximumValueSafe<UInt128>();
-			return Unsafe.As<UInt128, T>(ref value);
+			return Unsafe.BitCast<UInt128, T>(value);
 		}
 		else if (typeof(T) == typeof(Half))
 		{
 			Half value = GetMaximumValueSafe<Half>();
-			return Unsafe.As<Half, T>(ref value);
+			return Unsafe.BitCast<Half, T>(value);
 		}
 		else if (typeof(T) == typeof(float))
 		{
 			float value = GetMaximumValueSafe<float>();
-			return Unsafe.As<float, T>(ref value);
+			return Unsafe.BitCast<float, T>(value);
 		}
 		else if (typeof(T) == typeof(NFloat))
 		{
 			NFloat value = GetMaximumValueSafe<NFloat>();
-			return Unsafe.As<NFloat, T>(ref value);
+			return Unsafe.BitCast<NFloat, T>(value);
 		}
 		else if (typeof(T) == typeof(double))
 		{
 			double value = GetMaximumValueSafe<double>();
-			return Unsafe.As<double, T>(ref value);
+			return Unsafe.BitCast<double, T>(value);
 		}
 		else if (typeof(T) == typeof(decimal))
 		{
 			decimal value = GetMaximumValueSafe<decimal>();
-			return Unsafe.As<decimal, T>(ref value);
+			return Unsafe.BitCast<decimal, T>(value);
 		}
 		else
 		{