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); 299return TryDecodeFrom_Vector128(Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<ushort>>(source), destination, out charsProcessed); 448fallbackResult = TryDecodeFromUtf8_Scalar(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(source.Slice((int)offset)), destination.Slice((int)(offset / 2)), out elementsProcessed); 453fallbackResult = TryDecodeFromUtf16_Scalar(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(source.Slice((int)offset)), destination.Slice((int)(offset / 2)), out elementsProcessed);

1903Unsafe.BitCast<T, byte>(value), 1911Unsafe.BitCast<T, short>(value), 1919Unsafe.BitCast<T, int>(value), 1927Unsafe.BitCast<T, long>(value), 2148Unsafe.BitCast<T, byte>(value), 2158Unsafe.BitCast<T, short>(value), 2168Unsafe.BitCast<T, int>(value), 2178Unsafe.BitCast<T, long>(value),

909public static long DoubleToInt64Bits(double value) => Unsafe.BitCast<double, long>(value); 917public static double Int64BitsToDouble(long value) => Unsafe.BitCast<long, double>(value); 925public static int SingleToInt32Bits(float value) => Unsafe.BitCast<float, int>(value); 933public static float Int32BitsToSingle(int value) => Unsafe.BitCast<int, float>(value); 962public static ulong DoubleToUInt64Bits(double value) => Unsafe.BitCast<double, ulong>(value); 971public static double UInt64BitsToDouble(ulong value) => Unsafe.BitCast<ulong, double>(value); 980public static uint SingleToUInt32Bits(float value) => Unsafe.BitCast<float, uint>(value); 989public static float UInt32BitsToSingle(uint value) => Unsafe.BitCast<uint, float>(value);

1476return result ?? Unsafe.BitCast<TStorage, TUnderlying>(value).ToString()!; 1514result = Unsafe.BitCast<TStorage, TUnderlying>(value).ToString()!; 1866if (GetNameInlined(enumInfo, Unsafe.BitCast<TUnderlying, TStorage>(value)) is string enumName) 1881if (TryFormatFlagNames(enumInfo, Unsafe.BitCast<TUnderlying, TStorage>(value), destination, out charsWritten, ref destinationIsTooSmall) || destinationIsTooSmall) 1914if (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));

902ReadOnlySpan<char> charSpan = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(str); 931return Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(new ReadOnlySpan<char>(chArr, 0, newLength)); 937ReadOnlySpan<byte> srcUtf8Span = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(str); 990return Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(destUtf8Span.Slice(0, newLength)); 1094return Unsafe.BitCast<Guid, Vector128<byte>>(left) == Unsafe.BitCast<Guid, Vector128<byte>>(right); 1530Vector128<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), 1925Unsafe.BitCast<T, byte>(lowInclusive), 1926Unsafe.BitCast<T, byte>(highInclusive), 1934Unsafe.BitCast<T, ushort>(lowInclusive), 1935Unsafe.BitCast<T, ushort>(highInclusive), 1943Unsafe.BitCast<T, uint>(lowInclusive), 1944Unsafe.BitCast<T, uint>(highInclusive), 1952Unsafe.BitCast<T, ulong>(lowInclusive), 1953Unsafe.BitCast<T, ulong>(highInclusive), 1990Unsafe.BitCast<T, byte>(lowInclusive), 1991Unsafe.BitCast<T, byte>(highInclusive), 1999Unsafe.BitCast<T, ushort>(lowInclusive), 2000Unsafe.BitCast<T, ushort>(highInclusive), 2008Unsafe.BitCast<T, uint>(lowInclusive), 2009Unsafe.BitCast<T, uint>(highInclusive), 2017Unsafe.BitCast<T, ulong>(lowInclusive), 2018Unsafe.BitCast<T, ulong>(highInclusive), 2055Unsafe.BitCast<T, byte>(lowInclusive), 2056Unsafe.BitCast<T, byte>(highInclusive), 2064Unsafe.BitCast<T, ushort>(lowInclusive), 2065Unsafe.BitCast<T, ushort>(highInclusive), 2073Unsafe.BitCast<T, uint>(lowInclusive), 2074Unsafe.BitCast<T, uint>(highInclusive), 2082Unsafe.BitCast<T, ulong>(lowInclusive), 2083Unsafe.BitCast<T, ulong>(highInclusive), 2120Unsafe.BitCast<T, byte>(lowInclusive), 2121Unsafe.BitCast<T, byte>(highInclusive), 2129Unsafe.BitCast<T, ushort>(lowInclusive), 2130Unsafe.BitCast<T, ushort>(highInclusive), 2138Unsafe.BitCast<T, uint>(lowInclusive), 2139Unsafe.BitCast<T, uint>(highInclusive), 2147Unsafe.BitCast<T, ulong>(lowInclusive), 2148Unsafe.BitCast<T, ulong>(highInclusive), 2193Unsafe.BitCast<T, byte>(value), 2199Unsafe.BitCast<T, short>(value), 2205Unsafe.BitCast<T, int>(value), 2211Unsafe.BitCast<T, long>(value), 2234Unsafe.BitCast<T, byte>(value), 2240Unsafe.BitCast<T, short>(value), 2246Unsafe.BitCast<T, int>(value), 2252Unsafe.BitCast<T, long>(value), 2389Unsafe.BitCast<T, byte>(value), 2396Unsafe.BitCast<T, short>(value), 2403Unsafe.BitCast<T, int>(value), 2410Unsafe.BitCast<T, long>(value), 2435Unsafe.BitCast<T, byte>(value), 2442Unsafe.BitCast<T, short>(value), 2449Unsafe.BitCast<T, int>(value), 2456Unsafe.BitCast<T, long>(value), 2652Unsafe.BitCast<T, byte>(value0), 2653Unsafe.BitCast<T, byte>(value1), 2660Unsafe.BitCast<T, short>(value0), 2661Unsafe.BitCast<T, short>(value1), 2687Unsafe.BitCast<T, byte>(value0), 2688Unsafe.BitCast<T, byte>(value1), 2695Unsafe.BitCast<T, short>(value0), 2696Unsafe.BitCast<T, short>(value1), 2752Unsafe.BitCast<T, byte>(value0), 2753Unsafe.BitCast<T, byte>(value1), 2754Unsafe.BitCast<T, byte>(value2), 2761Unsafe.BitCast<T, short>(value0), 2762Unsafe.BitCast<T, short>(value1), 2763Unsafe.BitCast<T, short>(value2), 2790Unsafe.BitCast<T, byte>(value0), 2791Unsafe.BitCast<T, byte>(value1), 2792Unsafe.BitCast<T, byte>(value2), 2799Unsafe.BitCast<T, short>(value0), 2800Unsafe.BitCast<T, short>(value1), 2801Unsafe.BitCast<T, short>(value2), 3072Unsafe.BitCast<T, byte>(value0), 3073Unsafe.BitCast<T, byte>(value1), 3080Unsafe.BitCast<T, short>(value0), 3081Unsafe.BitCast<T, short>(value1), 3107Unsafe.BitCast<T, byte>(value0), 3108Unsafe.BitCast<T, byte>(value1), 3115Unsafe.BitCast<T, short>(value0), 3116Unsafe.BitCast<T, short>(value1), 3173Unsafe.BitCast<T, byte>(value0), 3174Unsafe.BitCast<T, byte>(value1), 3175Unsafe.BitCast<T, byte>(value2), 3182Unsafe.BitCast<T, short>(value0), 3183Unsafe.BitCast<T, short>(value1), 3184Unsafe.BitCast<T, short>(value2), 3211Unsafe.BitCast<T, byte>(value0), 3212Unsafe.BitCast<T, byte>(value1), 3213Unsafe.BitCast<T, byte>(value2), 3220Unsafe.BitCast<T, short>(value0), 3221Unsafe.BitCast<T, short>(value1), 3222Unsafe.BitCast<T, short>(value2), 4459Unsafe.BitCast<T, byte>(oldValue), 4460Unsafe.BitCast<T, byte>(newValue), 4471Unsafe.BitCast<T, ushort>(oldValue), 4472Unsafe.BitCast<T, ushort>(newValue), 4482Unsafe.BitCast<T, int>(oldValue), 4483Unsafe.BitCast<T, int>(newValue), 4493Unsafe.BitCast<T, long>(oldValue), 4494Unsafe.BitCast<T, long>(newValue), 4525Unsafe.BitCast<T, byte>(oldValue), 4526Unsafe.BitCast<T, byte>(newValue), 4537Unsafe.BitCast<T, ushort>(oldValue), 4538Unsafe.BitCast<T, ushort>(newValue), 4548Unsafe.BitCast<T, int>(oldValue), 4549Unsafe.BitCast<T, int>(newValue), 4559Unsafe.BitCast<T, long>(oldValue), 4560Unsafe.BitCast<T, long>(newValue), 4637Unsafe.BitCast<T, byte>(oldValue), 4638Unsafe.BitCast<T, byte>(newValue), 4648Unsafe.BitCast<T, ushort>(oldValue), 4649Unsafe.BitCast<T, ushort>(newValue), 4658Unsafe.BitCast<T, int>(oldValue), 4659Unsafe.BitCast<T, int>(newValue), 4668Unsafe.BitCast<T, long>(oldValue), 4669Unsafe.BitCast<T, long>(newValue), 4723Unsafe.BitCast<T, byte>(oldValue), 4724Unsafe.BitCast<T, byte>(newValue), 4734Unsafe.BitCast<T, ushort>(oldValue), 4735Unsafe.BitCast<T, ushort>(newValue), 4744Unsafe.BitCast<T, int>(oldValue), 4745Unsafe.BitCast<T, int>(newValue), 4754Unsafe.BitCast<T, long>(oldValue), 4755Unsafe.BitCast<T, long>(newValue), 5409Unsafe.BitCast<T, byte>(value), 5416Unsafe.BitCast<T, short>(value), 5423Unsafe.BitCast<T, int>(value), 5430Unsafe.BitCast<T, long>(value), 5458Unsafe.BitCast<T, byte>(value), 5465Unsafe.BitCast<T, short>(value), 5472Unsafe.BitCast<T, int>(value), 5479Unsafe.BitCast<T, long>(value),

652if (source.TryCopyTo(Unsafe.BitCast<Span<TChar>, Span<char>>(destination))) 663return 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;

36vector = new Vector<byte>(Unsafe.BitCast<T, byte>(value)); 40vector = (Vector<byte>)new Vector<ushort>(Unsafe.BitCast<T, ushort>(value)); 46? (Vector<byte>)new Vector<float>(Unsafe.BitCast<T, float>(value)) 47: (Vector<byte>)new Vector<uint>(Unsafe.BitCast<T, uint>(value)); 53? (Vector<byte>)new Vector<double>(Unsafe.BitCast<T, double>(value)) 54: (Vector<byte>)new Vector<ulong>(Unsafe.BitCast<T, ulong>(value)); 58vector = Unsafe.BitCast<T, Vector<byte>>(value); 64vector = Vector256.Create(Unsafe.BitCast<T, Vector128<byte>>(value)).AsVector(); 68vector = Vector512.Create(Unsafe.BitCast<T, Vector128<byte>>(value)).AsVector(); 80vector = Vector512.Create(Unsafe.BitCast<T, Vector256<byte>>(value)).AsVector(); 1310return PackedSpanHelpers.Contains(ref Unsafe.As<T, short>(ref searchSpace), Unsafe.BitCast<T, short>(value), length); 1491? PackedSpanHelpers.IndexOf(ref Unsafe.As<TValue, char>(ref searchSpace), Unsafe.BitCast<TValue, char>(value), length) 1492: PackedSpanHelpers.IndexOfAnyExcept(ref Unsafe.As<TValue, char>(ref searchSpace), Unsafe.BitCast<TValue, char>(value), length); 1681char char0 = Unsafe.BitCast<TValue, char>(value0); 1682char char1 = Unsafe.BitCast<TValue, char>(value1); 1908? 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) 1909: 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); 3492char charLowInclusive = Unsafe.BitCast<T, char>(lowInclusive); 3493char 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)));

252((uint)value).TryFormat(Unsafe.BitCast<Span<TChar>, Span<char>>(destination), out valueCharsWritten) : 253((uint)value).TryFormat(Unsafe.BitCast<Span<TChar>, Span<byte>>(destination), out valueCharsWritten, default, CultureInfo.InvariantCulture);

102result = Encoding.UTF8.GetString(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(slice)); 107result = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(slice).ToString();

783spanSuccess = value._sign.TryFormat(Unsafe.BitCast<Span<TChar>, Span<byte>>(destination), out charsWritten, formatSpan, info); 788spanSuccess = value._sign.TryFormat(Unsafe.BitCast<Span<TChar>, Span<char>>(destination), out charsWritten, formatSpan, info); 871sNegative = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(sNegative), 923strResult = Encoding.UTF8.GetString(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(vlb.AsSpan())); 928strResult = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(vlb.AsSpan()).ToString(); 1408return uint.TryParse(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(input), TParser.BlockNumberStyle, null, out result); 1413return uint.TryParse(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(input), TParser.BlockNumberStyle, null, out result); 1454? (Convert.FromHexString(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(input), MemoryMarshal.AsBytes(destination), out _, out _) != OperationStatus.Done) 1455: (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)));