63return (TResult)(object)SumSignedIntegersVectorized(Unsafe.BitCast<ReadOnlySpan<T>, ReadOnlySpan<long>>(span)); 67return (TResult)(object)SumSignedIntegersVectorized(Unsafe.BitCast<ReadOnlySpan<T>, ReadOnlySpan<int>>(span));

390public static float Invoke(short x) => (float)Unsafe.BitCast<short, Half>(x); 571public static ushort Invoke(float x) => Unsafe.BitCast<Half, ushort>((Half)x);

52return Unsafe.BitCast<Span<TFrom>, Span<TTo>>(span); 68return Unsafe.BitCast<ReadOnlySpan<TFrom>, ReadOnlySpan<TTo>>(span);

209EncodeTo_Vector128(source, Unsafe.BitCast<Span<char>, Span<ushort>>(destination), casing); 292return TryDecodeFrom_Vector128(Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<ushort>>(source), destination, out charsProcessed); 441fallbackResult = TryDecodeFromUtf8_Scalar(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(source.Slice((int)offset)), destination.Slice((int)(offset / 2)), out elementsProcessed); 446fallbackResult = TryDecodeFromUtf16_Scalar(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(source.Slice((int)offset)), destination.Slice((int)(offset / 2)), out elementsProcessed);

1908Unsafe.BitCast<T, byte>(value), 1916Unsafe.BitCast<T, short>(value), 1924Unsafe.BitCast<T, int>(value), 1932Unsafe.BitCast<T, long>(value), 2153Unsafe.BitCast<T, byte>(value), 2163Unsafe.BitCast<T, short>(value), 2173Unsafe.BitCast<T, int>(value), 2183Unsafe.BitCast<T, long>(value),

962public static long DoubleToInt64Bits(double value) => Unsafe.BitCast<double, long>(value); 970public static double Int64BitsToDouble(long value) => Unsafe.BitCast<long, double>(value); 978public static int SingleToInt32Bits(float value) => Unsafe.BitCast<float, int>(value); 986public static float Int32BitsToSingle(int value) => Unsafe.BitCast<int, float>(value); 1027public static ulong DoubleToUInt64Bits(double value) => Unsafe.BitCast<double, ulong>(value); 1036public static double UInt64BitsToDouble(ulong value) => Unsafe.BitCast<ulong, double>(value); 1045public static uint SingleToUInt32Bits(float value) => Unsafe.BitCast<float, uint>(value); 1054public static float UInt32BitsToSingle(uint value) => Unsafe.BitCast<uint, float>(value);

1477return result ?? Unsafe.BitCast<TStorage, TUnderlying>(value).ToString()!; 1515result = Unsafe.BitCast<TStorage, TUnderlying>(value).ToString()!; 1867if (GetNameInlined(enumInfo, Unsafe.BitCast<TUnderlying, TStorage>(value)) is string enumName) 1882if (TryFormatFlagNames(enumInfo, Unsafe.BitCast<TUnderlying, TStorage>(value), destination, out charsWritten, ref destinationIsTooSmall) || destinationIsTooSmall) 1915if (TryFormatFlagNames(GetEnumInfo<TStorage>(enumType), Unsafe.BitCast<TUnderlying, TStorage>(value), destination, out charsWritten, ref destinationIsTooSmall) ||

766result.Append(Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(s)); 771Encoding.UTF8.GetBytes(s, Unsafe.BitCast<Span<TChar>, Span<byte>>(result.AppendSpan(Encoding.UTF8.GetByteCount(s)))); 780fraction.TryFormat(Unsafe.BitCast<Span<TChar>, Span<char>>(chars), out charCount, fractionFormat, CultureInfo.InvariantCulture) : 781fraction.TryFormat(Unsafe.BitCast<Span<TChar>, Span<byte>>(chars), out charCount, fractionFormat, CultureInfo.InvariantCulture);

366Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(AMDesignator) : 367Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(amDesignatorUtf8 ??= Encoding.UTF8.GetBytes(AMDesignator)); 615Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(DateSeparator) : 616Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(dateSeparatorUtf8 ??= Encoding.UTF8.GetBytes(DateSeparator)); 818Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(PMDesignator) : 819Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(pmDesignatorUtf8 ??= Encoding.UTF8.GetBytes(PMDesignator)); 1000Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(TimeSeparator) : 1001Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(timeSeparatorUtf8 ??= Encoding.UTF8.GetBytes(TimeSeparator)); 1700Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(DecimalSeparator) : 1701Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_decimalSeparatorUtf8 ??= Encoding.UTF8.GetBytes(DecimalSeparator));

271Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_currencyDecimalSeparator) : 272Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_currencyDecimalSeparatorUtf8 ??= Encoding.UTF8.GetBytes(_currencyDecimalSeparator)); 363Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_currencyGroupSeparator) : 364Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_currencyGroupSeparatorUtf8 ??= Encoding.UTF8.GetBytes(_currencyGroupSeparator)); 385Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_currencySymbol) : 386Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_currencySymbolUtf8 ??= Encoding.UTF8.GetBytes(_currencySymbol)); 431Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_nanSymbol) : 432Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_nanSymbolUtf8 ??= Encoding.UTF8.GetBytes(_nanSymbol)); 516Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_negativeInfinitySymbol) : 517Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_negativeInfinitySymbolUtf8 ??= Encoding.UTF8.GetBytes(_negativeInfinitySymbol)); 539Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_negativeSign) : 540Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_negativeSignUtf8 ??= Encoding.UTF8.GetBytes(_negativeSign)); 575Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_numberDecimalSeparator) : 576Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_numberDecimalSeparatorUtf8 ??= Encoding.UTF8.GetBytes(_numberDecimalSeparator)); 596Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_numberGroupSeparator) : 597Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_numberGroupSeparatorUtf8 ??= Encoding.UTF8.GetBytes(_numberGroupSeparator)); 633Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_positiveInfinitySymbol) : 634Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_positiveInfinitySymbolUtf8 ??= Encoding.UTF8.GetBytes(_positiveInfinitySymbol)); 656Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_positiveSign) : 657Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_positiveSignUtf8 ??= Encoding.UTF8.GetBytes(_positiveSign)); 692Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_percentDecimalSeparator) : 693Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_percentDecimalSeparatorUtf8 ??= Encoding.UTF8.GetBytes(_percentDecimalSeparator)); 713Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_percentGroupSeparator) : 714Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_percentGroupSeparatorUtf8 ??= Encoding.UTF8.GetBytes(_percentGroupSeparator)); 734Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_percentSymbol) : 735Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_percentSymbolUtf8 ??= Encoding.UTF8.GetBytes(_percentSymbol)); 756Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_perMilleSymbol) : 757Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_perMilleSymbolUtf8 ??= Encoding.UTF8.GetBytes(_perMilleSymbol));

901ReadOnlySpan<char> charSpan = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(str); 930return Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(new ReadOnlySpan<char>(chArr, 0, newLength)); 936ReadOnlySpan<byte> srcUtf8Span = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(str); 989return Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(destUtf8Span.Slice(0, newLength)); 1093return Unsafe.BitCast<Guid, Vector128<byte>>(left) == Unsafe.BitCast<Guid, Vector128<byte>>(right); 1529Vector128<byte> srcVec = Unsafe.BitCast<Guid, Vector128<byte>>(value);

336Unsafe.BitCast<T, byte>(value), 343Unsafe.BitCast<T, short>(value), 350Unsafe.BitCast<T, int>(value), 357Unsafe.BitCast<T, long>(value), 819Unsafe.BitCast<T, byte>(value), 826Unsafe.BitCast<T, short>(value), 833Unsafe.BitCast<T, int>(value), 840Unsafe.BitCast<T, long>(value), 868Unsafe.BitCast<T, byte>(value), 875Unsafe.BitCast<T, short>(value), 882Unsafe.BitCast<T, int>(value), 889Unsafe.BitCast<T, long>(value), 946Unsafe.BitCast<T, byte>(value0), 947Unsafe.BitCast<T, byte>(value1), 954Unsafe.BitCast<T, short>(value0), 955Unsafe.BitCast<T, short>(value1), 984Unsafe.BitCast<T, byte>(value0), 985Unsafe.BitCast<T, byte>(value1), 992Unsafe.BitCast<T, short>(value0), 993Unsafe.BitCast<T, short>(value1), 1053Unsafe.BitCast<T, byte>(value0), 1054Unsafe.BitCast<T, byte>(value1), 1055Unsafe.BitCast<T, byte>(value2), 1062Unsafe.BitCast<T, short>(value0), 1063Unsafe.BitCast<T, short>(value1), 1064Unsafe.BitCast<T, short>(value2), 1094Unsafe.BitCast<T, byte>(value0), 1095Unsafe.BitCast<T, byte>(value1), 1096Unsafe.BitCast<T, byte>(value2), 1103Unsafe.BitCast<T, short>(value0), 1104Unsafe.BitCast<T, short>(value1), 1105Unsafe.BitCast<T, short>(value2), 1156Unsafe.BitCast<T, byte>(value0), 1157Unsafe.BitCast<T, byte>(value1), 1158Unsafe.BitCast<T, byte>(value2), 1159Unsafe.BitCast<T, byte>(value3), 1166Unsafe.BitCast<T, short>(value0), 1167Unsafe.BitCast<T, short>(value1), 1168Unsafe.BitCast<T, short>(value2), 1169Unsafe.BitCast<T, short>(value3), 1397Unsafe.BitCast<T, byte>(value), 1404Unsafe.BitCast<T, short>(value), 1411Unsafe.BitCast<T, int>(value), 1418Unsafe.BitCast<T, long>(value), 1446Unsafe.BitCast<T, byte>(value), 1453Unsafe.BitCast<T, short>(value), 1460Unsafe.BitCast<T, int>(value), 1467Unsafe.BitCast<T, long>(value), 1524Unsafe.BitCast<T, byte>(value0), 1525Unsafe.BitCast<T, byte>(value1), 1532Unsafe.BitCast<T, short>(value0), 1533Unsafe.BitCast<T, short>(value1), 1562Unsafe.BitCast<T, byte>(value0), 1563Unsafe.BitCast<T, byte>(value1), 1570Unsafe.BitCast<T, short>(value0), 1571Unsafe.BitCast<T, short>(value1), 1631Unsafe.BitCast<T, byte>(value0), 1632Unsafe.BitCast<T, byte>(value1), 1633Unsafe.BitCast<T, byte>(value2), 1640Unsafe.BitCast<T, short>(value0), 1641Unsafe.BitCast<T, short>(value1), 1642Unsafe.BitCast<T, short>(value2), 1672Unsafe.BitCast<T, byte>(value0), 1673Unsafe.BitCast<T, byte>(value1), 1674Unsafe.BitCast<T, byte>(value2), 1681Unsafe.BitCast<T, short>(value0), 1682Unsafe.BitCast<T, short>(value1), 1683Unsafe.BitCast<T, short>(value2), 1735Unsafe.BitCast<T, byte>(value0), 1736Unsafe.BitCast<T, byte>(value1), 1737Unsafe.BitCast<T, byte>(value2), 1738Unsafe.BitCast<T, byte>(value3), 1745Unsafe.BitCast<T, short>(value0), 1746Unsafe.BitCast<T, short>(value1), 1747Unsafe.BitCast<T, short>(value2), 1748Unsafe.BitCast<T, short>(value3), 1931Unsafe.BitCast<T, byte>(lowInclusive), 1932Unsafe.BitCast<T, byte>(highInclusive), 1940Unsafe.BitCast<T, ushort>(lowInclusive), 1941Unsafe.BitCast<T, ushort>(highInclusive), 1949Unsafe.BitCast<T, uint>(lowInclusive), 1950Unsafe.BitCast<T, uint>(highInclusive), 1958Unsafe.BitCast<T, ulong>(lowInclusive), 1959Unsafe.BitCast<T, ulong>(highInclusive), 2002Unsafe.BitCast<T, byte>(lowInclusive), 2003Unsafe.BitCast<T, byte>(highInclusive), 2011Unsafe.BitCast<T, ushort>(lowInclusive), 2012Unsafe.BitCast<T, ushort>(highInclusive), 2020Unsafe.BitCast<T, uint>(lowInclusive), 2021Unsafe.BitCast<T, uint>(highInclusive), 2029Unsafe.BitCast<T, ulong>(lowInclusive), 2030Unsafe.BitCast<T, ulong>(highInclusive), 2073Unsafe.BitCast<T, byte>(lowInclusive), 2074Unsafe.BitCast<T, byte>(highInclusive), 2082Unsafe.BitCast<T, ushort>(lowInclusive), 2083Unsafe.BitCast<T, ushort>(highInclusive), 2091Unsafe.BitCast<T, uint>(lowInclusive), 2092Unsafe.BitCast<T, uint>(highInclusive), 2100Unsafe.BitCast<T, ulong>(lowInclusive), 2101Unsafe.BitCast<T, ulong>(highInclusive), 2144Unsafe.BitCast<T, byte>(lowInclusive), 2145Unsafe.BitCast<T, byte>(highInclusive), 2153Unsafe.BitCast<T, ushort>(lowInclusive), 2154Unsafe.BitCast<T, ushort>(highInclusive), 2162Unsafe.BitCast<T, uint>(lowInclusive), 2163Unsafe.BitCast<T, uint>(highInclusive), 2171Unsafe.BitCast<T, ulong>(lowInclusive), 2172Unsafe.BitCast<T, ulong>(highInclusive), 2217Unsafe.BitCast<T, byte>(value), 2223Unsafe.BitCast<T, short>(value), 2229Unsafe.BitCast<T, int>(value), 2235Unsafe.BitCast<T, long>(value), 2258Unsafe.BitCast<T, byte>(value), 2264Unsafe.BitCast<T, short>(value), 2270Unsafe.BitCast<T, int>(value), 2276Unsafe.BitCast<T, long>(value), 2413Unsafe.BitCast<T, byte>(value), 2420Unsafe.BitCast<T, short>(value), 2427Unsafe.BitCast<T, int>(value), 2434Unsafe.BitCast<T, long>(value), 2459Unsafe.BitCast<T, byte>(value), 2466Unsafe.BitCast<T, short>(value), 2473Unsafe.BitCast<T, int>(value), 2480Unsafe.BitCast<T, long>(value), 2676Unsafe.BitCast<T, byte>(value0), 2677Unsafe.BitCast<T, byte>(value1), 2684Unsafe.BitCast<T, short>(value0), 2685Unsafe.BitCast<T, short>(value1), 2711Unsafe.BitCast<T, byte>(value0), 2712Unsafe.BitCast<T, byte>(value1), 2719Unsafe.BitCast<T, short>(value0), 2720Unsafe.BitCast<T, short>(value1), 2776Unsafe.BitCast<T, byte>(value0), 2777Unsafe.BitCast<T, byte>(value1), 2778Unsafe.BitCast<T, byte>(value2), 2785Unsafe.BitCast<T, short>(value0), 2786Unsafe.BitCast<T, short>(value1), 2787Unsafe.BitCast<T, short>(value2), 2814Unsafe.BitCast<T, byte>(value0), 2815Unsafe.BitCast<T, byte>(value1), 2816Unsafe.BitCast<T, byte>(value2), 2823Unsafe.BitCast<T, short>(value0), 2824Unsafe.BitCast<T, short>(value1), 2825Unsafe.BitCast<T, short>(value2), 3096Unsafe.BitCast<T, byte>(value0), 3097Unsafe.BitCast<T, byte>(value1), 3104Unsafe.BitCast<T, short>(value0), 3105Unsafe.BitCast<T, short>(value1), 3131Unsafe.BitCast<T, byte>(value0), 3132Unsafe.BitCast<T, byte>(value1), 3139Unsafe.BitCast<T, short>(value0), 3140Unsafe.BitCast<T, short>(value1), 3197Unsafe.BitCast<T, byte>(value0), 3198Unsafe.BitCast<T, byte>(value1), 3199Unsafe.BitCast<T, byte>(value2), 3206Unsafe.BitCast<T, short>(value0), 3207Unsafe.BitCast<T, short>(value1), 3208Unsafe.BitCast<T, short>(value2), 3235Unsafe.BitCast<T, byte>(value0), 3236Unsafe.BitCast<T, byte>(value1), 3237Unsafe.BitCast<T, byte>(value2), 3244Unsafe.BitCast<T, short>(value0), 3245Unsafe.BitCast<T, short>(value1), 3246Unsafe.BitCast<T, short>(value2), 4483Unsafe.BitCast<T, byte>(oldValue), 4484Unsafe.BitCast<T, byte>(newValue), 4495Unsafe.BitCast<T, ushort>(oldValue), 4496Unsafe.BitCast<T, ushort>(newValue), 4506Unsafe.BitCast<T, int>(oldValue), 4507Unsafe.BitCast<T, int>(newValue), 4517Unsafe.BitCast<T, long>(oldValue), 4518Unsafe.BitCast<T, long>(newValue), 4549Unsafe.BitCast<T, byte>(oldValue), 4550Unsafe.BitCast<T, byte>(newValue), 4561Unsafe.BitCast<T, ushort>(oldValue), 4562Unsafe.BitCast<T, ushort>(newValue), 4572Unsafe.BitCast<T, int>(oldValue), 4573Unsafe.BitCast<T, int>(newValue), 4583Unsafe.BitCast<T, long>(oldValue), 4584Unsafe.BitCast<T, long>(newValue), 4661Unsafe.BitCast<T, byte>(oldValue), 4662Unsafe.BitCast<T, byte>(newValue), 4672Unsafe.BitCast<T, ushort>(oldValue), 4673Unsafe.BitCast<T, ushort>(newValue), 4682Unsafe.BitCast<T, int>(oldValue), 4683Unsafe.BitCast<T, int>(newValue), 4692Unsafe.BitCast<T, long>(oldValue), 4693Unsafe.BitCast<T, long>(newValue), 4747Unsafe.BitCast<T, byte>(oldValue), 4748Unsafe.BitCast<T, byte>(newValue), 4758Unsafe.BitCast<T, ushort>(oldValue), 4759Unsafe.BitCast<T, ushort>(newValue), 4768Unsafe.BitCast<T, int>(oldValue), 4769Unsafe.BitCast<T, int>(newValue), 4778Unsafe.BitCast<T, long>(oldValue), 4779Unsafe.BitCast<T, long>(newValue), 5437Unsafe.BitCast<T, byte>(value), 5444Unsafe.BitCast<T, short>(value), 5451Unsafe.BitCast<T, int>(value), 5458Unsafe.BitCast<T, long>(value), 5486Unsafe.BitCast<T, byte>(value), 5493Unsafe.BitCast<T, short>(value), 5500Unsafe.BitCast<T, int>(value), 5507Unsafe.BitCast<T, long>(value),

666if (source.TryCopyTo(Unsafe.BitCast<Span<TChar>, Span<char>>(destination))) 677return Encoding.UTF8.TryGetBytes(source, Unsafe.BitCast<Span<TChar>, Span<byte>>(destination), out charsWritten);

932ReadOnlySpan<char> typedSpan = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(span); 933ReadOnlySpan<char> typedValue = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(value); 940ReadOnlySpan<byte> typedSpan = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(span); 941ReadOnlySpan<byte> typedValue = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(value); 952return Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(span).Trim()); 958return Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(span).TrimUtf8()); 968ReadOnlySpan<char> typedSpan = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(span); 969ReadOnlySpan<char> typedValue = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(value); 976ReadOnlySpan<byte> typedSpan = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(span); 977ReadOnlySpan<byte> typedValue = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(value); 1090ReadOnlySpan<byte> bytes = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(value);

14public static Vector4 AsVector4(this Plane value) => Unsafe.BitCast<Plane, Vector4>(value);

14public static Vector4 AsVector4(this Quaternion value) => Unsafe.BitCast<Quaternion, Vector4>(value);

230return Unsafe.BitCast<Vector<TFrom>, Vector<TTo>>(vector);

15public static Plane AsPlane(this Vector4 value) => Unsafe.BitCast<Vector4, Plane>(value); 20public static Quaternion AsQuaternion(this Vector4 value) => Unsafe.BitCast<Vector4, Quaternion>(value);

267return Unsafe.BitCast<Vector128<TFrom>, Vector128<TTo>>(vector);

56public static Plane AsPlane(this Vector128<float> value) => Unsafe.BitCast<Vector128<float>, Plane>(value); 62public static Quaternion AsQuaternion(this Vector128<float> value) => Unsafe.BitCast<Vector128<float>, Quaternion>(value); 68public static Vector128<float> AsVector128(this Plane value) => Unsafe.BitCast<Plane, Vector128<float>>(value); 74public static Vector128<float> AsVector128(this Quaternion value) => Unsafe.BitCast<Quaternion, Vector128<float>>(value); 92public static Vector128<float> AsVector128(this Vector4 value) => Unsafe.BitCast<Vector4, Vector128<float>>(value); 164public static Vector4 AsVector4(this Vector128<float> value) => Unsafe.BitCast<Vector128<float>, Vector4>(value);

252return Unsafe.BitCast<Vector256<TFrom>, Vector256<TTo>>(vector);

251return Unsafe.BitCast<Vector512<TFrom>, Vector512<TTo>>(vector);

251return Unsafe.BitCast<Vector64<TFrom>, Vector64<TTo>>(vector);

79TVectorInt64 ux = Unsafe.BitCast<TVectorDouble, TVectorInt64>(ax); 114Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(region & TVectorInt64.One, TVectorInt64.Zero)), 120Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals((region + TVectorInt64.One) & TVectorInt64.Create(2), TVectorInt64.Zero)), 131Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.GreaterThan(ux, TVectorInt64.Create(ARG_SMALLER - 1))), 217TVectorInt32 ux = Unsafe.BitCast<TVectorSingle, TVectorInt32>(ax); 274Unsafe.BitCast<TVectorInt32, TVectorSingle>(TVectorInt32.GreaterThan(ux, TVectorInt32.Create(ARG_SMALLER - 1))), 288Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(region & TVectorInt64.One, TVectorInt64.Zero)), 294Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals((region + TVectorInt64.One) & TVectorInt64.Create(2), TVectorInt64.Zero)), 412if (TVectorUInt64.LessThanOrEqualAll(Unsafe.BitCast<TVectorDouble, TVectorUInt64>(TVectorDouble.Abs(x)), TVectorUInt64.Create(V_ARG_MAX))) 418TVectorUInt64 n = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(dn); 455return poly * Unsafe.BitCast<TVectorUInt64, TVectorDouble>((n + TVectorUInt64.Create(V_DP64_BIAS)) << 52); 543if (TVectorUInt32.GreaterThanAny(Unsafe.BitCast<TVectorSingle, TVectorUInt32>(TVectorSingle.Abs(x)), TVectorUInt32.Create(V_ARG_MAX))) 570TVectorUInt64 n = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(dn); 589return Unsafe.BitCast<TVectorUInt64, TVectorDouble>(Unsafe.BitCast<TVectorDouble, TVectorUInt64>(poly) + (n << 52)); 609TVectorUInt64 xBits = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(ax); 610TVectorUInt64 yBits = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(ay); 619TVectorDouble insignificanMask = Unsafe.BitCast<TVectorUInt64, TVectorDouble>( 628TVectorDouble expFix = TVectorDouble.ConditionalSelect(Unsafe.BitCast<TVectorUInt64, TVectorDouble>(scaleDownMask), TVectorDouble.Create(4.149515568880993E+180), TVectorDouble.One); 634expFix = TVectorDouble.ConditionalSelect(Unsafe.BitCast<TVectorUInt64, TVectorDouble>(scaleUpMask), TVectorDouble.Create(2.409919865102884E-181), expFix); 649ax = Unsafe.BitCast<TVectorUInt64, TVectorDouble>(xBits); 650ax -= subnormalFix & Unsafe.BitCast<TVectorUInt64, TVectorDouble>(xSubnormalMask); 654ay = Unsafe.BitCast<TVectorUInt64, TVectorDouble>(yBits); 655ay -= subnormalFix & Unsafe.BitCast<TVectorUInt64, TVectorDouble>(ySubnormalMask); 657xBits = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(ax); 658yBits = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(ay); 668xBits = TVectorUInt64.ConditionalSelect(Unsafe.BitCast<TVectorDouble, TVectorUInt64>(lessThanMask), yBits, xBits); 669yBits = TVectorUInt64.ConditionalSelect(Unsafe.BitCast<TVectorDouble, TVectorUInt64>(lessThanMask), tmpBits, yBits); 676TVectorDouble xHead = Unsafe.BitCast<TVectorUInt64, TVectorDouble>(xBits & headMask); 677TVectorDouble yHead = Unsafe.BitCast<TVectorUInt64, TVectorDouble>(yBits & headMask); 699TVectorDouble equalExponentsMask = Unsafe.BitCast<TVectorUInt64, TVectorDouble>(TVectorUInt64.IsZero(expDiff)); 777TVectorUInt32 bits = Unsafe.BitCast<TVectorSingle, TVectorUInt32>(TVectorSingle.Abs(vector)); 794return Unsafe.BitCast<TVectorUInt32, TVectorSingle>(result); 802TVectorUInt64 bits = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(TVectorDouble.Abs(vector)); 819return Unsafe.BitCast<TVectorUInt64, TVectorDouble>(result); 827TVectorUInt32 bits = Unsafe.BitCast<TVectorSingle, TVectorUInt32>(TVectorSingle.Abs(vector)); 840return Unsafe.BitCast<TVectorUInt32, TVectorSingle>(result); 848TVectorUInt64 bits = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(TVectorDouble.Abs(vector)); 861return Unsafe.BitCast<TVectorUInt64, TVectorDouble>(result); 934TVectorUInt64 specialMask = TVectorUInt64.GreaterThanOrEqual(Unsafe.BitCast<TVectorDouble, TVectorUInt64>(x) - TVectorUInt64.Create(V_MIN), TVectorUInt64.Create(V_MAX - V_MIN)); 963TVectorDouble subnormalMask = TVectorDouble.AndNot(Unsafe.BitCast<TVectorUInt64, TVectorDouble>(specialMask), temp); 968Unsafe.BitCast<TVectorUInt64, TVectorDouble>(Unsafe.BitCast<TVectorDouble, TVectorUInt64>(x * 4503599627370496.0) - TVectorUInt64.Create(52ul << 52)), 972specialMask = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(temp); 976TVectorUInt64 vx = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(x) - TVectorUInt64.Create(V_OFF); 977TVectorDouble n = ConvertToDouble<TVectorInt64, TVectorDouble>(Unsafe.BitCast<TVectorUInt64, TVectorInt64>(vx) >> 52); 981TVectorDouble r = Unsafe.BitCast<TVectorUInt64, TVectorDouble>(vx) - TVectorDouble.One; 1028Unsafe.BitCast<TVectorUInt64, TVectorDouble>(specialMask), 1115TVectorUInt32 specialMask = TVectorUInt32.GreaterThanOrEqual(Unsafe.BitCast<TVectorSingle, TVectorUInt32>(x) - TVectorUInt32.Create(V_MIN), TVectorUInt32.Create(V_MAX - V_MIN)); 1144TVectorSingle subnormalMask = TVectorSingle.AndNot(Unsafe.BitCast<TVectorUInt32, TVectorSingle>(specialMask), temp); 1148Unsafe.BitCast<TVectorUInt32, TVectorSingle>(Unsafe.BitCast<TVectorSingle, TVectorUInt32>(x * 8388608.0f) - TVectorUInt32.Create(23u << 23)), 1152specialMask = Unsafe.BitCast<TVectorSingle, TVectorUInt32>(temp); 1155TVectorUInt32 vx = Unsafe.BitCast<TVectorSingle, TVectorUInt32>(x) - TVectorUInt32.Create(V_OFF); 1156TVectorSingle n = ConvertToSingle<TVectorInt32, TVectorSingle>(Unsafe.BitCast<TVectorUInt32, TVectorInt32>(vx) >> 23); 1160TVectorSingle r = Unsafe.BitCast<TVectorUInt32, TVectorSingle>(vx) - TVectorSingle.Create(1.0f); 1187Unsafe.BitCast<TVectorUInt32, TVectorSingle>(specialMask), 1254TVectorUInt64 specialMask = TVectorUInt64.GreaterThanOrEqual(Unsafe.BitCast<TVectorDouble, TVectorUInt64>(x) - TVectorUInt64.Create(V_MIN), TVectorUInt64.Create(V_MAX - V_MIN)); 1283TVectorDouble subnormalMask = TVectorDouble.AndNot(Unsafe.BitCast<TVectorUInt64, TVectorDouble>(specialMask), temp); 1288Unsafe.BitCast<TVectorUInt64, TVectorDouble>(Unsafe.BitCast<TVectorDouble, TVectorUInt64>(x * 4503599627370496.0) - TVectorUInt64.Create(52ul << 52)), 1292specialMask = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(temp); 1296TVectorUInt64 vx = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(x) - TVectorUInt64.Create(V_OFF); 1297TVectorDouble n = ConvertToDouble<TVectorInt64, TVectorDouble>(Unsafe.BitCast<TVectorUInt64, TVectorInt64>(vx) >> 52); 1301TVectorDouble r = Unsafe.BitCast<TVectorUInt64, TVectorDouble>(vx) - TVectorDouble.One; 1348Unsafe.BitCast<TVectorUInt64, TVectorDouble>(specialMask), 1431TVectorUInt32 specialMask = TVectorUInt32.GreaterThanOrEqual(Unsafe.BitCast<TVectorSingle, TVectorUInt32>(x) - TVectorUInt32.Create(V_MIN), TVectorUInt32.Create(V_MAX - V_MIN)); 1460TVectorSingle subnormalMask = TVectorSingle.AndNot(Unsafe.BitCast<TVectorUInt32, TVectorSingle>(specialMask), temp); 1465Unsafe.BitCast<TVectorUInt32, TVectorSingle>(Unsafe.BitCast<TVectorSingle, TVectorUInt32>(x * 8388608.0f) - TVectorUInt32.Create(23u << 23)), 1469specialMask = Unsafe.BitCast<TVectorSingle, TVectorUInt32>(temp); 1473TVectorUInt32 vx = Unsafe.BitCast<TVectorSingle, TVectorUInt32>(x) - TVectorUInt32.Create(V_OFF); 1474TVectorSingle n = ConvertToSingle<TVectorInt32, TVectorSingle>(Unsafe.BitCast<TVectorUInt32, TVectorInt32>(vx) >> 23); 1478TVectorSingle r = Unsafe.BitCast<TVectorUInt32, TVectorSingle>(vx) - TVectorSingle.One; 1505Unsafe.BitCast<TVectorUInt32, TVectorSingle>(specialMask), 1804TVectorInt64 ux = Unsafe.BitCast<TVectorDouble, TVectorInt64>(ax); 1843Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(region & TVectorInt64.One, TVectorInt64.Zero)), 1849Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(region & TVectorInt64.One, TVectorInt64.Zero)), 1854TVectorInt64 sign = Unsafe.BitCast<TVectorDouble, TVectorInt64>(x) >>> 63; 1857Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(((sign & (region >>> 1)) | (~sign & ~(region >>> 1))) & TVectorInt64.One, TVectorInt64.Zero)), 1863Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals((region + TVectorInt64.One) & TVectorInt64.Create(2), TVectorInt64.Zero)), 1874Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.GreaterThan(ux, TVectorInt64.Create(ARG_SMALLER - 1))), 1880Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.GreaterThan(ux, TVectorInt64.Create(ARG_SMALLER - 1))), 1923TVectorInt32 ux = Unsafe.BitCast<TVectorSingle, TVectorInt32>(ax); 1998Unsafe.BitCast<TVectorInt32, TVectorSingle>(TVectorInt32.GreaterThan(ux, TVectorInt32.Create(ARG_SMALLER - 1))), 2004Unsafe.BitCast<TVectorInt32, TVectorSingle>(TVectorInt32.GreaterThan(ux, TVectorInt32.Create(ARG_SMALLER - 1))), 2020Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(region & TVectorInt64.One, TVectorInt64.Zero)), 2026Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(region & TVectorInt64.One, TVectorInt64.Zero)), 2031TVectorInt64 sign = Unsafe.BitCast<TVectorDouble, TVectorInt64>(x) >>> 63; 2034Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(((sign & (region >>> 1)) | (~sign & ~(region >>> 1))) & TVectorInt64.One, TVectorInt64.Zero)), 2040Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals((region + TVectorInt64.One) & TVectorInt64.Create(2), TVectorInt64.Zero)), 2124TVectorInt64 ux = Unsafe.BitCast<TVectorDouble, TVectorInt64>(ax); 2154Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(region & TVectorInt64.One, TVectorInt64.Zero)), 2159TVectorInt64 sign = Unsafe.BitCast<TVectorDouble, TVectorInt64>(x) >>> 63; 2162Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(((sign & (region >>> 1)) | (~sign & ~(region >>> 1))) & TVectorInt64.One, TVectorInt64.Zero)), 2173Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.GreaterThan(ux, TVectorInt64.Create(ARG_SMALLER - 1))), 2254TVectorInt32 ux = Unsafe.BitCast<TVectorSingle, TVectorInt32>(ax); 2311Unsafe.BitCast<TVectorInt32, TVectorSingle>(TVectorInt32.GreaterThan(ux, TVectorInt32.Create(ARG_SMALLER - 1))), 2326Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(region & TVectorInt64.One, TVectorInt64.Zero)), 2331TVectorInt64 sign = Unsafe.BitCast<TVectorDouble, TVectorInt64>(x) >>> 63; 2334Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(((sign & (region >>> 1)) | (~sign & ~(region >>> 1))) & TVectorInt64.One, TVectorInt64.Zero)), 2885TVectorInt64 region = Unsafe.BitCast<TVectorDouble, TVectorInt64>(npi2);

28return Unsafe.BitCast<T, ushort>(value) - 1u < 254u;

50vector = new Vector<byte>(Unsafe.BitCast<T, byte>(value)); 54vector = (Vector<byte>)new Vector<ushort>(Unsafe.BitCast<T, ushort>(value)); 60? (Vector<byte>)new Vector<float>(Unsafe.BitCast<T, float>(value)) 61: (Vector<byte>)new Vector<uint>(Unsafe.BitCast<T, uint>(value)); 67? (Vector<byte>)new Vector<double>(Unsafe.BitCast<T, double>(value)) 68: (Vector<byte>)new Vector<ulong>(Unsafe.BitCast<T, ulong>(value)); 72vector = Unsafe.BitCast<T, Vector<byte>>(value); 78vector = Vector256.Create(Unsafe.BitCast<T, Vector128<byte>>(value)).AsVector(); 82vector = Vector512.Create(Unsafe.BitCast<T, Vector128<byte>>(value)).AsVector(); 94vector = Vector512.Create(Unsafe.BitCast<T, Vector256<byte>>(value)).AsVector(); 1466return PackedSpanHelpers.Contains(ref Unsafe.As<T, short>(ref searchSpace), Unsafe.BitCast<T, short>(value), length); 1650? PackedSpanHelpers.IndexOf(ref Unsafe.As<TValue, char>(ref searchSpace), Unsafe.BitCast<TValue, char>(value), length) 1651: PackedSpanHelpers.IndexOfAnyExcept(ref Unsafe.As<TValue, char>(ref searchSpace), Unsafe.BitCast<TValue, char>(value), length); 1864char char0 = Unsafe.BitCast<TValue, char>(value0); 1865char char1 = Unsafe.BitCast<TValue, char>(value1); 2125? PackedSpanHelpers.IndexOfAny(ref Unsafe.As<TValue, char>(ref searchSpace), Unsafe.BitCast<TValue, char>(value0), Unsafe.BitCast<TValue, char>(value1), Unsafe.BitCast<TValue, char>(value2), length) 2126: PackedSpanHelpers.IndexOfAnyExcept(ref Unsafe.As<TValue, char>(ref searchSpace), Unsafe.BitCast<TValue, char>(value0), Unsafe.BitCast<TValue, char>(value1), Unsafe.BitCast<TValue, char>(value2), length); 3872char charLowInclusive = Unsafe.BitCast<T, char>(lowInclusive); 3873char charRange = (char)(Unsafe.BitCast<T, char>(highInclusive) - charLowInclusive);

70? (Unsafe.BitCast<T, byte>(Unsafe.Add(ref searchSpace, j)) > 127) 71: (Unsafe.BitCast<T, char>(Unsafe.Add(ref searchSpace, j)) > 127))

182=> Unsafe.BitCast<int, float>(Exchange(ref Unsafe.As<float, int>(ref location1), Unsafe.BitCast<float, int>(value))); 191=> Unsafe.BitCast<long, double>(Exchange(ref Unsafe.As<double, long>(ref location1), Unsafe.BitCast<double, long>(value))); 257return Unsafe.BitCast<byte, T>( 260Unsafe.BitCast<T, byte>(value))); 265return Unsafe.BitCast<ushort, T>( 268Unsafe.BitCast<T, ushort>(value))); 273return Unsafe.BitCast<int, T>( 276Unsafe.BitCast<T, int>(value))); 280return Unsafe.BitCast<long, T>( 283Unsafe.BitCast<T, long>(value))); 428=> Unsafe.BitCast<int, float>(CompareExchange(ref Unsafe.As<float, int>(ref location1), Unsafe.BitCast<float, int>(value), Unsafe.BitCast<float, int>(comparand))); 438=> Unsafe.BitCast<long, double>(CompareExchange(ref Unsafe.As<double, long>(ref location1), Unsafe.BitCast<double, long>(value), Unsafe.BitCast<double, long>(comparand))); 507return Unsafe.BitCast<byte, T>( 510Unsafe.BitCast<T, byte>(value), 511Unsafe.BitCast<T, byte>(comparand))); 516return Unsafe.BitCast<ushort, T>( 519Unsafe.BitCast<T, ushort>(value), 520Unsafe.BitCast<T, ushort>(comparand))); 525return Unsafe.BitCast<int, T>( 528Unsafe.BitCast<T, int>(value), 529Unsafe.BitCast<T, int>(comparand))); 533return Unsafe.BitCast<long, T>( 536Unsafe.BitCast<T, long>(value), 537Unsafe.BitCast<T, long>(comparand))); 666byte current = Unsafe.BitCast<T, byte>(location1); 669byte newValue = (byte)(current & Unsafe.BitCast<T, byte>(value)); 676return Unsafe.BitCast<byte, T>(oldValue); 684ushort current = Unsafe.BitCast<T, ushort>(location1); 687ushort newValue = (ushort)(current & Unsafe.BitCast<T, ushort>(value)); 694return Unsafe.BitCast<ushort, T>(oldValue); 702return Unsafe.BitCast<int, T>( 705Unsafe.BitCast<T, int>(value))); 709return Unsafe.BitCast<long, T>( 712Unsafe.BitCast<T, long>(value))); 809byte current = Unsafe.BitCast<T, byte>(location1); 812byte newValue = (byte)(current | Unsafe.BitCast<T, byte>(value)); 819return Unsafe.BitCast<byte, T>(oldValue); 827ushort current = Unsafe.BitCast<T, ushort>(location1); 830ushort newValue = (ushort)(current | Unsafe.BitCast<T, ushort>(value)); 837return Unsafe.BitCast<ushort, T>(oldValue); 845return Unsafe.BitCast<int, T>( 848Unsafe.BitCast<T, int>(value))); 852return Unsafe.BitCast<long, T>( 855Unsafe.BitCast<T, long>(value)));

253((uint)value).TryFormat(Unsafe.BitCast<Span<TChar>, Span<char>>(destination), out valueCharsWritten) : 254((uint)value).TryFormat(Unsafe.BitCast<Span<TChar>, Span<byte>>(destination), out valueCharsWritten, default, CultureInfo.InvariantCulture); 458Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(originalInput).ToString() : 459Encoding.UTF8.GetString(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(originalInput));

106return Encoding.UTF8.GetString(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(slice)); 111return Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(slice).ToString();

780spanSuccess = value._sign.TryFormat(Unsafe.BitCast<Span<TChar>, Span<byte>>(destination), out charsWritten, formatSpan, info); 785spanSuccess = value._sign.TryFormat(Unsafe.BitCast<Span<TChar>, Span<char>>(destination), out charsWritten, formatSpan, info); 868sNegative = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(sNegative), 920strResult = Encoding.UTF8.GetString(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(vlb.AsSpan())); 925strResult = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(vlb.AsSpan()).ToString(); 1400return uint.TryParse(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(input), TParser.BlockNumberStyle, null, out result); 1405return uint.TryParse(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(input), TParser.BlockNumberStyle, null, out result); 1446? (Convert.FromHexString(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(input), MemoryMarshal.AsBytes(destination), out _, out _) != OperationStatus.Done) 1447: (Convert.FromHexString(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(input), MemoryMarshal.AsBytes(destination), out _, out _) != OperationStatus.Done))

112? Rune.DecodeFromUtf8(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(span), out result, out elemsConsumed) 113: Rune.DecodeFromUtf16(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(span), out result, out elemsConsumed); 122return Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(Encoding.UTF8.GetBytes(value)); 127return Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(value);

2171? !double.TryParse(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(slice), style, provider, out double real) 2172: !double.TryParse(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(slice), style, provider, out real)) 2191? !double.TryParse(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(slice), style, provider, out double imaginary) 2192: !double.TryParse(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(slice), style, provider, out imaginary)) 2279? m_real.TryFormat(Unsafe.BitCast<Span<TChar>, Span<byte>>(destination.Slice(1)), out int realChars, format, provider) 2280: m_real.TryFormat(Unsafe.BitCast<Span<TChar>, Span<char>>(destination.Slice(1)), out realChars, format, provider)) 2289? m_imaginary.TryFormat(Unsafe.BitCast<Span<TChar>, Span<byte>>(destination.Slice(2)), out int imaginaryChars, format, provider) 2290: m_imaginary.TryFormat(Unsafe.BitCast<Span<TChar>, Span<char>>(destination.Slice(2)), out imaginaryChars, format, provider))

362return Unsafe.BitCast<int, TInt>(Volatile.Read(ref Unsafe.As<TInt, int>(ref _lowestBreakIteration))); 366return Unsafe.BitCast<long, TInt>(Volatile.Read(ref Unsafe.As<TInt, long>(ref _lowestBreakIteration)));