361variant = Unsafe.BitCast<ComVariant, VariantStructure>(tmp);

62return (TResult)(object)SumSignedIntegersVectorized(Unsafe.BitCast<ReadOnlySpan<T>, ReadOnlySpan<long>>(span)); 66return (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);

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

1920Unsafe.BitCast<T, byte>(value), 1928Unsafe.BitCast<T, short>(value), 1936Unsafe.BitCast<T, int>(value), 1944Unsafe.BitCast<T, long>(value), 2165Unsafe.BitCast<T, byte>(value), 2175Unsafe.BitCast<T, short>(value), 2185Unsafe.BitCast<T, int>(value), 2195Unsafe.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));

289Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_currencyDecimalSeparator) : 290Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(GetUtf8Span(ref _currencyDecimalSeparatorUtf8, _currencyDecimalSeparator)); 381Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_currencyGroupSeparator) : 382Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(GetUtf8Span(ref _currencyGroupSeparatorUtf8, _currencyGroupSeparator)); 403Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_currencySymbol) : 404Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(GetUtf8Span(ref _currencySymbolUtf8, _currencySymbol)); 447Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_nanSymbol) : 448Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(GetUtf8Span(ref _nanSymbolUtf8, _nanSymbol)); 532Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_negativeInfinitySymbol) : 533Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(GetUtf8Span(ref _negativeInfinitySymbolUtf8, _negativeInfinitySymbol)); 555Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_negativeSign) : 556Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(GetUtf8Span(ref _negativeSignUtf8, _negativeSign)); 591Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_numberDecimalSeparator) : 592Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(GetUtf8Span(ref _numberDecimalSeparatorUtf8, _numberDecimalSeparator)); 612Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_numberGroupSeparator) : 613Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(GetUtf8Span(ref _numberGroupSeparatorUtf8, _numberGroupSeparator)); 649Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_positiveInfinitySymbol) : 650Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(GetUtf8Span(ref _positiveInfinitySymbolUtf8, _positiveInfinitySymbol)); 672Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_positiveSign) : 673Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(GetUtf8Span(ref _positiveSignUtf8, _positiveSign)); 708Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_percentDecimalSeparator) : 709Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(GetUtf8Span(ref _percentDecimalSeparatorUtf8, _percentDecimalSeparator)); 729Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_percentGroupSeparator) : 730Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(GetUtf8Span(ref _percentGroupSeparatorUtf8, _percentGroupSeparator)); 750Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_percentSymbol) : 751Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(GetUtf8Span(ref _percentSymbolUtf8, _percentSymbol)); 772Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_perMilleSymbol) : 773Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(GetUtf8Span(ref _perMilleSymbolUtf8, _perMilleSymbol));

902ReadOnlySpan<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); 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), 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), 5434Unsafe.BitCast<T, byte>(value), 5441Unsafe.BitCast<T, short>(value), 5448Unsafe.BitCast<T, int>(value), 5455Unsafe.BitCast<T, long>(value), 5483Unsafe.BitCast<T, byte>(value), 5490Unsafe.BitCast<T, short>(value), 5497Unsafe.BitCast<T, int>(value), 5504Unsafe.BitCast<T, long>(value),

227Unsafe.BitCast<TInner, TOuter>(MinMaxInteger<TInner, TMinMax>(Unsafe.BitCast<ReadOnlySpan<TOuter>, ReadOnlySpan<TInner>>(span)));

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

1107ReadOnlySpan<char> typedSpan = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(span); 1108ReadOnlySpan<char> typedValue = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(value); 1115ReadOnlySpan<byte> typedSpan = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(span); 1116ReadOnlySpan<byte> typedValue = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(value); 1126ReadOnlySpan<char> typedSpan = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(span); 1127ReadOnlySpan<char> typedValue = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(value); 1134ReadOnlySpan<byte> typedSpan = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(span); 1135ReadOnlySpan<byte> typedValue = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(value); 1146return Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(span).Trim()); 1152return Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(span).TrimUtf8()); 1162return Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(span).TrimStart()); 1168return Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(span).TrimStartUtf8()); 1720ReadOnlySpan<byte> bytes = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(value);

28return Unsafe.BitCast<uint, Argb<byte>>(color); 46return Unsafe.BitCast<uint, Argb<byte>>(color); 59uint bits = Unsafe.BitCast<Argb<byte>, uint>(color); 74uint bits = Unsafe.BitCast<Argb<byte>, uint>(color);

28return Unsafe.BitCast<uint, Rgba<byte>>(color); 46return Unsafe.BitCast<uint, Rgba<byte>>(color); 59uint bits = Unsafe.BitCast<Rgba<byte>, uint>(color); 74uint bits = Unsafe.BitCast<Rgba<byte>, uint>(color);

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

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

68return CompareIntegerSemantic(Unsafe.BitCast<BFloat16, short>((BFloat16)(object)x!), Unsafe.BitCast<BFloat16, short>((BFloat16)(object)y!)); 72return CompareIntegerSemantic(Unsafe.BitCast<NFloat, nint>((NFloat)(object)x!), Unsafe.BitCast<NFloat, nint>((NFloat)(object)y!));

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

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

273return 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);

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

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

257return 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)), 360resolved = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(TVectorDouble.Equals(result, product + (sum + bound))); 383TVectorDouble valueHi = Unsafe.BitCast<TVectorUInt64, TVectorDouble>( 384Unsafe.BitCast<TVectorDouble, TVectorUInt64>(value) & TVectorUInt64.Create(double.ConversionSplitMask) 407TVectorUInt64 ux = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(TVectorDouble.Abs(degrees)) 523if (TVectorUInt64.LessThanOrEqualAll(Unsafe.BitCast<TVectorDouble, TVectorUInt64>(TVectorDouble.Abs(x)), TVectorUInt64.Create(V_ARG_MAX))) 529TVectorUInt64 n = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(dn); 566return poly * Unsafe.BitCast<TVectorUInt64, TVectorDouble>((n + TVectorUInt64.Create(V_DP64_BIAS)) << 52); 654if (TVectorUInt32.GreaterThanAny(Unsafe.BitCast<TVectorSingle, TVectorUInt32>(TVectorSingle.Abs(x)), TVectorUInt32.Create(V_ARG_MAX))) 681TVectorUInt64 n = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(dn); 700return Unsafe.BitCast<TVectorUInt64, TVectorDouble>(Unsafe.BitCast<TVectorDouble, TVectorUInt64>(poly) + (n << 52)); 720TVectorUInt64 xBits = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(ax); 721TVectorUInt64 yBits = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(ay); 730TVectorDouble insignificanMask = Unsafe.BitCast<TVectorUInt64, TVectorDouble>( 739TVectorDouble expFix = TVectorDouble.ConditionalSelect(Unsafe.BitCast<TVectorUInt64, TVectorDouble>(scaleDownMask), TVectorDouble.Create(4.149515568880993E+180), TVectorDouble.One); 745expFix = TVectorDouble.ConditionalSelect(Unsafe.BitCast<TVectorUInt64, TVectorDouble>(scaleUpMask), TVectorDouble.Create(2.409919865102884E-181), expFix); 760ax = Unsafe.BitCast<TVectorUInt64, TVectorDouble>(xBits); 761ax -= subnormalFix & Unsafe.BitCast<TVectorUInt64, TVectorDouble>(xSubnormalMask); 765ay = Unsafe.BitCast<TVectorUInt64, TVectorDouble>(yBits); 766ay -= subnormalFix & Unsafe.BitCast<TVectorUInt64, TVectorDouble>(ySubnormalMask); 768xBits = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(ax); 769yBits = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(ay); 779xBits = TVectorUInt64.ConditionalSelect(Unsafe.BitCast<TVectorDouble, TVectorUInt64>(lessThanMask), yBits, xBits); 780yBits = TVectorUInt64.ConditionalSelect(Unsafe.BitCast<TVectorDouble, TVectorUInt64>(lessThanMask), tmpBits, yBits); 787TVectorDouble xHead = Unsafe.BitCast<TVectorUInt64, TVectorDouble>(xBits & headMask); 788TVectorDouble yHead = Unsafe.BitCast<TVectorUInt64, TVectorDouble>(yBits & headMask); 810TVectorDouble equalExponentsMask = Unsafe.BitCast<TVectorUInt64, TVectorDouble>(TVectorUInt64.IsZero(expDiff)); 888TVectorUInt32 bits = Unsafe.BitCast<TVectorSingle, TVectorUInt32>(TVectorSingle.Abs(vector)); 905return Unsafe.BitCast<TVectorUInt32, TVectorSingle>(result); 913TVectorUInt64 bits = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(TVectorDouble.Abs(vector)); 930return Unsafe.BitCast<TVectorUInt64, TVectorDouble>(result); 938TVectorUInt32 bits = Unsafe.BitCast<TVectorSingle, TVectorUInt32>(TVectorSingle.Abs(vector)); 951return Unsafe.BitCast<TVectorUInt32, TVectorSingle>(result); 959TVectorUInt64 bits = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(TVectorDouble.Abs(vector)); 972return Unsafe.BitCast<TVectorUInt64, TVectorDouble>(result); 1045TVectorUInt64 specialMask = TVectorUInt64.GreaterThanOrEqual(Unsafe.BitCast<TVectorDouble, TVectorUInt64>(x) - TVectorUInt64.Create(V_MIN), TVectorUInt64.Create(V_MAX - V_MIN)); 1074TVectorDouble subnormalMask = TVectorDouble.AndNot(Unsafe.BitCast<TVectorUInt64, TVectorDouble>(specialMask), temp); 1079Unsafe.BitCast<TVectorUInt64, TVectorDouble>(Unsafe.BitCast<TVectorDouble, TVectorUInt64>(x * 4503599627370496.0) - TVectorUInt64.Create(52ul << 52)), 1083specialMask = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(temp); 1087TVectorUInt64 vx = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(x) - TVectorUInt64.Create(V_OFF); 1088TVectorDouble n = ConvertToDouble<TVectorInt64, TVectorDouble>(Unsafe.BitCast<TVectorUInt64, TVectorInt64>(vx) >> 52); 1092TVectorDouble r = Unsafe.BitCast<TVectorUInt64, TVectorDouble>(vx) - TVectorDouble.One; 1139Unsafe.BitCast<TVectorUInt64, TVectorDouble>(specialMask), 1226TVectorUInt32 specialMask = TVectorUInt32.GreaterThanOrEqual(Unsafe.BitCast<TVectorSingle, TVectorUInt32>(x) - TVectorUInt32.Create(V_MIN), TVectorUInt32.Create(V_MAX - V_MIN)); 1255TVectorSingle subnormalMask = TVectorSingle.AndNot(Unsafe.BitCast<TVectorUInt32, TVectorSingle>(specialMask), temp); 1259Unsafe.BitCast<TVectorUInt32, TVectorSingle>(Unsafe.BitCast<TVectorSingle, TVectorUInt32>(x * 8388608.0f) - TVectorUInt32.Create(23u << 23)), 1263specialMask = Unsafe.BitCast<TVectorSingle, TVectorUInt32>(temp); 1266TVectorUInt32 vx = Unsafe.BitCast<TVectorSingle, TVectorUInt32>(x) - TVectorUInt32.Create(V_OFF); 1267TVectorSingle n = ConvertToSingle<TVectorInt32, TVectorSingle>(Unsafe.BitCast<TVectorUInt32, TVectorInt32>(vx) >> 23); 1271TVectorSingle r = Unsafe.BitCast<TVectorUInt32, TVectorSingle>(vx) - TVectorSingle.Create(1.0f); 1298Unsafe.BitCast<TVectorUInt32, TVectorSingle>(specialMask), 1365TVectorUInt64 specialMask = TVectorUInt64.GreaterThanOrEqual(Unsafe.BitCast<TVectorDouble, TVectorUInt64>(x) - TVectorUInt64.Create(V_MIN), TVectorUInt64.Create(V_MAX - V_MIN)); 1394TVectorDouble subnormalMask = TVectorDouble.AndNot(Unsafe.BitCast<TVectorUInt64, TVectorDouble>(specialMask), temp); 1399Unsafe.BitCast<TVectorUInt64, TVectorDouble>(Unsafe.BitCast<TVectorDouble, TVectorUInt64>(x * 4503599627370496.0) - TVectorUInt64.Create(52ul << 52)), 1403specialMask = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(temp); 1407TVectorUInt64 vx = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(x) - TVectorUInt64.Create(V_OFF); 1408TVectorDouble n = ConvertToDouble<TVectorInt64, TVectorDouble>(Unsafe.BitCast<TVectorUInt64, TVectorInt64>(vx) >> 52); 1412TVectorDouble r = Unsafe.BitCast<TVectorUInt64, TVectorDouble>(vx) - TVectorDouble.One; 1459Unsafe.BitCast<TVectorUInt64, TVectorDouble>(specialMask), 1542TVectorUInt32 specialMask = TVectorUInt32.GreaterThanOrEqual(Unsafe.BitCast<TVectorSingle, TVectorUInt32>(x) - TVectorUInt32.Create(V_MIN), TVectorUInt32.Create(V_MAX - V_MIN)); 1571TVectorSingle subnormalMask = TVectorSingle.AndNot(Unsafe.BitCast<TVectorUInt32, TVectorSingle>(specialMask), temp); 1576Unsafe.BitCast<TVectorUInt32, TVectorSingle>(Unsafe.BitCast<TVectorSingle, TVectorUInt32>(x * 8388608.0f) - TVectorUInt32.Create(23u << 23)), 1580specialMask = Unsafe.BitCast<TVectorSingle, TVectorUInt32>(temp); 1584TVectorUInt32 vx = Unsafe.BitCast<TVectorSingle, TVectorUInt32>(x) - TVectorUInt32.Create(V_OFF); 1585TVectorSingle n = ConvertToSingle<TVectorInt32, TVectorSingle>(Unsafe.BitCast<TVectorUInt32, TVectorInt32>(vx) >> 23); 1589TVectorSingle r = Unsafe.BitCast<TVectorUInt32, TVectorSingle>(vx) - TVectorSingle.One; 1616Unsafe.BitCast<TVectorUInt32, TVectorSingle>(specialMask), 1801TVectorUInt64 ux = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(TVectorDouble.Abs(radians)) 1967TVectorInt64 ux = Unsafe.BitCast<TVectorDouble, TVectorInt64>(ax); 2006Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(region & TVectorInt64.One, TVectorInt64.Zero)), 2012Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(region & TVectorInt64.One, TVectorInt64.Zero)), 2017TVectorInt64 sign = Unsafe.BitCast<TVectorDouble, TVectorInt64>(x) >>> 63; 2020Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(((sign & (region >>> 1)) | (~sign & ~(region >>> 1))) & TVectorInt64.One, TVectorInt64.Zero)), 2026Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals((region + TVectorInt64.One) & TVectorInt64.Create(2), TVectorInt64.Zero)), 2037Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.GreaterThan(ux, TVectorInt64.Create(ARG_SMALLER - 1))), 2043Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.GreaterThan(ux, TVectorInt64.Create(ARG_SMALLER - 1))), 2086TVectorInt32 ux = Unsafe.BitCast<TVectorSingle, TVectorInt32>(ax); 2161Unsafe.BitCast<TVectorInt32, TVectorSingle>(TVectorInt32.GreaterThan(ux, TVectorInt32.Create(ARG_SMALLER - 1))), 2167Unsafe.BitCast<TVectorInt32, TVectorSingle>(TVectorInt32.GreaterThan(ux, TVectorInt32.Create(ARG_SMALLER - 1))), 2183Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(region & TVectorInt64.One, TVectorInt64.Zero)), 2189Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(region & TVectorInt64.One, TVectorInt64.Zero)), 2194TVectorInt64 sign = Unsafe.BitCast<TVectorDouble, TVectorInt64>(x) >>> 63; 2197Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(((sign & (region >>> 1)) | (~sign & ~(region >>> 1))) & TVectorInt64.One, TVectorInt64.Zero)), 2203Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals((region + TVectorInt64.One) & TVectorInt64.Create(2), TVectorInt64.Zero)), 2287TVectorInt64 ux = Unsafe.BitCast<TVectorDouble, TVectorInt64>(ax); 2317Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(region & TVectorInt64.One, TVectorInt64.Zero)), 2322TVectorInt64 sign = Unsafe.BitCast<TVectorDouble, TVectorInt64>(x) >>> 63; 2325Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(((sign & (region >>> 1)) | (~sign & ~(region >>> 1))) & TVectorInt64.One, TVectorInt64.Zero)), 2336Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.GreaterThan(ux, TVectorInt64.Create(ARG_SMALLER - 1))), 2417TVectorInt32 ux = Unsafe.BitCast<TVectorSingle, TVectorInt32>(ax); 2474Unsafe.BitCast<TVectorInt32, TVectorSingle>(TVectorInt32.GreaterThan(ux, TVectorInt32.Create(ARG_SMALLER - 1))), 2489Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(region & TVectorInt64.One, TVectorInt64.Zero)), 2494TVectorInt64 sign = Unsafe.BitCast<TVectorDouble, TVectorInt64>(x) >>> 63; 2497Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(((sign & (region >>> 1)) | (~sign & ~(region >>> 1))) & TVectorInt64.One, TVectorInt64.Zero)), 3082TVectorInt64 region = Unsafe.BitCast<TVectorDouble, TVectorInt64>(npi2); 3324TVectorDouble s1 = Unsafe.BitCast<TVectorUInt64, TVectorDouble>(Unsafe.BitCast<TVectorDouble, TVectorUInt64>(s) & TVectorUInt64.Create(0xFFFFFFFF00000000));

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();

848spanSuccess = value._sign.TryFormat(Unsafe.BitCast<Span<TChar>, Span<byte>>(destination), out charsWritten, formatSpan, info); 853spanSuccess = value._sign.TryFormat(Unsafe.BitCast<Span<TChar>, Span<char>>(destination), out charsWritten, formatSpan, info); 935sNegative = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(sNegative), 987strResult = Encoding.UTF8.GetString(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(vlb.AsSpan())); 992strResult = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(vlb.AsSpan()).ToString(); 1589return nuint.TryParse(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(input), TParser.BlockNumberStyle, null, out result); 1594return nuint.TryParse(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(input), TParser.BlockNumberStyle, null, out result); 1636? (Convert.FromHexString(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(input), MemoryMarshal.AsBytes(destination), out _, out _) != OperationStatus.Done) 1637: (Convert.FromHexString(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(input), MemoryMarshal.AsBytes(destination), out _, out _) != OperationStatus.Done))

115? Rune.DecodeFromUtf8(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(span), out result, out elemsConsumed) 116: Rune.DecodeFromUtf16(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(span), out result, out elemsConsumed); 125return Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(Encoding.UTF8.GetBytes(value)); 130return Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(value);

882? m_real.TryFormat(Unsafe.BitCast<Span<TChar>, Span<byte>>(destination.Slice(1)), out int realChars, format, provider) 883: m_real.TryFormat(Unsafe.BitCast<Span<TChar>, Span<char>>(destination.Slice(1)), out realChars, format, provider)) 892? m_imaginary.TryFormat(Unsafe.BitCast<Span<TChar>, Span<byte>>(destination.Slice(2)), out int imaginaryChars, format, provider) 893: m_imaginary.TryFormat(Unsafe.BitCast<Span<TChar>, Span<char>>(destination.Slice(2)), out imaginaryChars, format, provider))

1962? !T.TryParse(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(slice), componentStyle, provider, out T? real) 1963: !T.TryParse(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(slice), componentStyle, provider, out real)) 1983? !T.TryParse(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(slice), componentStyle, provider, out T? imaginary) 1984: !T.TryParse(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(slice), componentStyle, provider, out imaginary)) 2088? m_real.TryFormat(Unsafe.BitCast<Span<TChar>, Span<byte>>(destination.Slice(1)), out int realChars, format, provider) 2089: m_real.TryFormat(Unsafe.BitCast<Span<TChar>, Span<char>>(destination.Slice(1)), out realChars, format, provider)) 2098? m_imaginary.TryFormat(Unsafe.BitCast<Span<TChar>, Span<byte>>(destination.Slice(2)), out int imaginaryChars, format, provider) 2099: 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)));