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

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

53return Unsafe.BitCast<Span<TFrom>, Span<TTo>>(span); 69return Unsafe.BitCast<ReadOnlySpan<TFrom>, ReadOnlySpan<TTo>>(span);

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),

908public static long DoubleToInt64Bits(double value) => Unsafe.BitCast<double, long>(value); 916public static double Int64BitsToDouble(long value) => Unsafe.BitCast<long, double>(value); 924public static int SingleToInt32Bits(float value) => Unsafe.BitCast<float, int>(value); 932public static float Int32BitsToSingle(int value) => Unsafe.BitCast<int, float>(value); 957public static ulong DoubleToUInt64Bits(double value) => Unsafe.BitCast<double, ulong>(value); 966public static double UInt64BitsToDouble(ulong value) => Unsafe.BitCast<ulong, double>(value); 975public static uint SingleToUInt32Bits(float value) => Unsafe.BitCast<float, uint>(value); 984public 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);

372Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(AMDesignator) : 373Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(amDesignatorUtf8 ??= Encoding.UTF8.GetBytes(AMDesignator)); 621Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(DateSeparator) : 622Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(dateSeparatorUtf8 ??= Encoding.UTF8.GetBytes(DateSeparator)); 824Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(PMDesignator) : 825Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(pmDesignatorUtf8 ??= Encoding.UTF8.GetBytes(PMDesignator)); 1006Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(TimeSeparator) : 1007Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(timeSeparatorUtf8 ??= Encoding.UTF8.GetBytes(TimeSeparator)); 1706Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(DecimalSeparator) : 1707Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_decimalSeparatorUtf8 ??= Encoding.UTF8.GetBytes(DecimalSeparator));

272Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_currencyDecimalSeparator) : 273Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_currencyDecimalSeparatorUtf8 ??= Encoding.UTF8.GetBytes(_currencyDecimalSeparator)); 364Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_currencyGroupSeparator) : 365Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_currencyGroupSeparatorUtf8 ??= Encoding.UTF8.GetBytes(_currencyGroupSeparator)); 386Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_currencySymbol) : 387Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_currencySymbolUtf8 ??= Encoding.UTF8.GetBytes(_currencySymbol)); 432Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_nanSymbol) : 433Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_nanSymbolUtf8 ??= Encoding.UTF8.GetBytes(_nanSymbol)); 517Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_negativeInfinitySymbol) : 518Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_negativeInfinitySymbolUtf8 ??= Encoding.UTF8.GetBytes(_negativeInfinitySymbol)); 540Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_negativeSign) : 541Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_negativeSignUtf8 ??= Encoding.UTF8.GetBytes(_negativeSign)); 576Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_numberDecimalSeparator) : 577Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_numberDecimalSeparatorUtf8 ??= Encoding.UTF8.GetBytes(_numberDecimalSeparator)); 597Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_numberGroupSeparator) : 598Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_numberGroupSeparatorUtf8 ??= Encoding.UTF8.GetBytes(_numberGroupSeparator)); 634Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_positiveInfinitySymbol) : 635Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_positiveInfinitySymbolUtf8 ??= Encoding.UTF8.GetBytes(_positiveInfinitySymbol)); 657Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_positiveSign) : 658Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_positiveSignUtf8 ??= Encoding.UTF8.GetBytes(_positiveSign)); 693Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_percentDecimalSeparator) : 694Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_percentDecimalSeparatorUtf8 ??= Encoding.UTF8.GetBytes(_percentDecimalSeparator)); 714Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_percentGroupSeparator) : 715Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_percentGroupSeparatorUtf8 ??= Encoding.UTF8.GetBytes(_percentGroupSeparator)); 735Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_percentSymbol) : 736Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_percentSymbolUtf8 ??= Encoding.UTF8.GetBytes(_percentSymbol)); 757Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_perMilleSymbol) : 758Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_perMilleSymbolUtf8 ??= Encoding.UTF8.GetBytes(_perMilleSymbol));

889ReadOnlySpan<char> charSpan = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(str); 918return Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(new ReadOnlySpan<char>(chArr, 0, newLength)); 924ReadOnlySpan<byte> srcUtf8Span = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(str); 977return Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(destUtf8Span.Slice(0, newLength)); 1081return Unsafe.BitCast<Guid, Vector128<byte>>(left) == Unsafe.BitCast<Guid, Vector128<byte>>(right); 1517Vector128<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), 815Unsafe.BitCast<T, byte>(value), 822Unsafe.BitCast<T, short>(value), 829Unsafe.BitCast<T, int>(value), 836Unsafe.BitCast<T, long>(value), 864Unsafe.BitCast<T, byte>(value), 871Unsafe.BitCast<T, short>(value), 878Unsafe.BitCast<T, int>(value), 885Unsafe.BitCast<T, long>(value), 942Unsafe.BitCast<T, byte>(value0), 943Unsafe.BitCast<T, byte>(value1), 950Unsafe.BitCast<T, short>(value0), 951Unsafe.BitCast<T, short>(value1), 980Unsafe.BitCast<T, byte>(value0), 981Unsafe.BitCast<T, byte>(value1), 988Unsafe.BitCast<T, short>(value0), 989Unsafe.BitCast<T, short>(value1), 1049Unsafe.BitCast<T, byte>(value0), 1050Unsafe.BitCast<T, byte>(value1), 1051Unsafe.BitCast<T, byte>(value2), 1058Unsafe.BitCast<T, short>(value0), 1059Unsafe.BitCast<T, short>(value1), 1060Unsafe.BitCast<T, short>(value2), 1090Unsafe.BitCast<T, byte>(value0), 1091Unsafe.BitCast<T, byte>(value1), 1092Unsafe.BitCast<T, byte>(value2), 1099Unsafe.BitCast<T, short>(value0), 1100Unsafe.BitCast<T, short>(value1), 1101Unsafe.BitCast<T, short>(value2), 1152Unsafe.BitCast<T, byte>(value0), 1153Unsafe.BitCast<T, byte>(value1), 1154Unsafe.BitCast<T, byte>(value2), 1155Unsafe.BitCast<T, byte>(value3), 1162Unsafe.BitCast<T, short>(value0), 1163Unsafe.BitCast<T, short>(value1), 1164Unsafe.BitCast<T, short>(value2), 1165Unsafe.BitCast<T, short>(value3), 1393Unsafe.BitCast<T, byte>(value), 1400Unsafe.BitCast<T, short>(value), 1407Unsafe.BitCast<T, int>(value), 1414Unsafe.BitCast<T, long>(value), 1442Unsafe.BitCast<T, byte>(value), 1449Unsafe.BitCast<T, short>(value), 1456Unsafe.BitCast<T, int>(value), 1463Unsafe.BitCast<T, long>(value), 1520Unsafe.BitCast<T, byte>(value0), 1521Unsafe.BitCast<T, byte>(value1), 1528Unsafe.BitCast<T, short>(value0), 1529Unsafe.BitCast<T, short>(value1), 1558Unsafe.BitCast<T, byte>(value0), 1559Unsafe.BitCast<T, byte>(value1), 1566Unsafe.BitCast<T, short>(value0), 1567Unsafe.BitCast<T, short>(value1), 1627Unsafe.BitCast<T, byte>(value0), 1628Unsafe.BitCast<T, byte>(value1), 1629Unsafe.BitCast<T, byte>(value2), 1636Unsafe.BitCast<T, short>(value0), 1637Unsafe.BitCast<T, short>(value1), 1638Unsafe.BitCast<T, short>(value2), 1668Unsafe.BitCast<T, byte>(value0), 1669Unsafe.BitCast<T, byte>(value1), 1670Unsafe.BitCast<T, byte>(value2), 1677Unsafe.BitCast<T, short>(value0), 1678Unsafe.BitCast<T, short>(value1), 1679Unsafe.BitCast<T, short>(value2), 1731Unsafe.BitCast<T, byte>(value0), 1732Unsafe.BitCast<T, byte>(value1), 1733Unsafe.BitCast<T, byte>(value2), 1734Unsafe.BitCast<T, byte>(value3), 1741Unsafe.BitCast<T, short>(value0), 1742Unsafe.BitCast<T, short>(value1), 1743Unsafe.BitCast<T, short>(value2), 1744Unsafe.BitCast<T, short>(value3), 1921Unsafe.BitCast<T, byte>(lowInclusive), 1922Unsafe.BitCast<T, byte>(highInclusive), 1930Unsafe.BitCast<T, ushort>(lowInclusive), 1931Unsafe.BitCast<T, ushort>(highInclusive), 1939Unsafe.BitCast<T, uint>(lowInclusive), 1940Unsafe.BitCast<T, uint>(highInclusive), 1948Unsafe.BitCast<T, ulong>(lowInclusive), 1949Unsafe.BitCast<T, ulong>(highInclusive), 1986Unsafe.BitCast<T, byte>(lowInclusive), 1987Unsafe.BitCast<T, byte>(highInclusive), 1995Unsafe.BitCast<T, ushort>(lowInclusive), 1996Unsafe.BitCast<T, ushort>(highInclusive), 2004Unsafe.BitCast<T, uint>(lowInclusive), 2005Unsafe.BitCast<T, uint>(highInclusive), 2013Unsafe.BitCast<T, ulong>(lowInclusive), 2014Unsafe.BitCast<T, ulong>(highInclusive), 2051Unsafe.BitCast<T, byte>(lowInclusive), 2052Unsafe.BitCast<T, byte>(highInclusive), 2060Unsafe.BitCast<T, ushort>(lowInclusive), 2061Unsafe.BitCast<T, ushort>(highInclusive), 2069Unsafe.BitCast<T, uint>(lowInclusive), 2070Unsafe.BitCast<T, uint>(highInclusive), 2078Unsafe.BitCast<T, ulong>(lowInclusive), 2079Unsafe.BitCast<T, ulong>(highInclusive), 2116Unsafe.BitCast<T, byte>(lowInclusive), 2117Unsafe.BitCast<T, byte>(highInclusive), 2125Unsafe.BitCast<T, ushort>(lowInclusive), 2126Unsafe.BitCast<T, ushort>(highInclusive), 2134Unsafe.BitCast<T, uint>(lowInclusive), 2135Unsafe.BitCast<T, uint>(highInclusive), 2143Unsafe.BitCast<T, ulong>(lowInclusive), 2144Unsafe.BitCast<T, ulong>(highInclusive), 2189Unsafe.BitCast<T, byte>(value), 2195Unsafe.BitCast<T, short>(value), 2201Unsafe.BitCast<T, int>(value), 2207Unsafe.BitCast<T, long>(value), 2230Unsafe.BitCast<T, byte>(value), 2236Unsafe.BitCast<T, short>(value), 2242Unsafe.BitCast<T, int>(value), 2248Unsafe.BitCast<T, long>(value), 2385Unsafe.BitCast<T, byte>(value), 2392Unsafe.BitCast<T, short>(value), 2399Unsafe.BitCast<T, int>(value), 2406Unsafe.BitCast<T, long>(value), 2431Unsafe.BitCast<T, byte>(value), 2438Unsafe.BitCast<T, short>(value), 2445Unsafe.BitCast<T, int>(value), 2452Unsafe.BitCast<T, long>(value), 2648Unsafe.BitCast<T, byte>(value0), 2649Unsafe.BitCast<T, byte>(value1), 2656Unsafe.BitCast<T, short>(value0), 2657Unsafe.BitCast<T, short>(value1), 2683Unsafe.BitCast<T, byte>(value0), 2684Unsafe.BitCast<T, byte>(value1), 2691Unsafe.BitCast<T, short>(value0), 2692Unsafe.BitCast<T, short>(value1), 2748Unsafe.BitCast<T, byte>(value0), 2749Unsafe.BitCast<T, byte>(value1), 2750Unsafe.BitCast<T, byte>(value2), 2757Unsafe.BitCast<T, short>(value0), 2758Unsafe.BitCast<T, short>(value1), 2759Unsafe.BitCast<T, short>(value2), 2786Unsafe.BitCast<T, byte>(value0), 2787Unsafe.BitCast<T, byte>(value1), 2788Unsafe.BitCast<T, byte>(value2), 2795Unsafe.BitCast<T, short>(value0), 2796Unsafe.BitCast<T, short>(value1), 2797Unsafe.BitCast<T, short>(value2), 3068Unsafe.BitCast<T, byte>(value0), 3069Unsafe.BitCast<T, byte>(value1), 3076Unsafe.BitCast<T, short>(value0), 3077Unsafe.BitCast<T, short>(value1), 3103Unsafe.BitCast<T, byte>(value0), 3104Unsafe.BitCast<T, byte>(value1), 3111Unsafe.BitCast<T, short>(value0), 3112Unsafe.BitCast<T, short>(value1), 3169Unsafe.BitCast<T, byte>(value0), 3170Unsafe.BitCast<T, byte>(value1), 3171Unsafe.BitCast<T, byte>(value2), 3178Unsafe.BitCast<T, short>(value0), 3179Unsafe.BitCast<T, short>(value1), 3180Unsafe.BitCast<T, short>(value2), 3207Unsafe.BitCast<T, byte>(value0), 3208Unsafe.BitCast<T, byte>(value1), 3209Unsafe.BitCast<T, byte>(value2), 3216Unsafe.BitCast<T, short>(value0), 3217Unsafe.BitCast<T, short>(value1), 3218Unsafe.BitCast<T, short>(value2), 4433Unsafe.BitCast<T, byte>(oldValue), 4434Unsafe.BitCast<T, byte>(newValue), 4445Unsafe.BitCast<T, ushort>(oldValue), 4446Unsafe.BitCast<T, ushort>(newValue), 4456Unsafe.BitCast<T, int>(oldValue), 4457Unsafe.BitCast<T, int>(newValue), 4467Unsafe.BitCast<T, long>(oldValue), 4468Unsafe.BitCast<T, long>(newValue), 4499Unsafe.BitCast<T, byte>(oldValue), 4500Unsafe.BitCast<T, byte>(newValue), 4511Unsafe.BitCast<T, ushort>(oldValue), 4512Unsafe.BitCast<T, ushort>(newValue), 4522Unsafe.BitCast<T, int>(oldValue), 4523Unsafe.BitCast<T, int>(newValue), 4533Unsafe.BitCast<T, long>(oldValue), 4534Unsafe.BitCast<T, long>(newValue), 4611Unsafe.BitCast<T, byte>(oldValue), 4612Unsafe.BitCast<T, byte>(newValue), 4622Unsafe.BitCast<T, ushort>(oldValue), 4623Unsafe.BitCast<T, ushort>(newValue), 4632Unsafe.BitCast<T, int>(oldValue), 4633Unsafe.BitCast<T, int>(newValue), 4642Unsafe.BitCast<T, long>(oldValue), 4643Unsafe.BitCast<T, long>(newValue), 4697Unsafe.BitCast<T, byte>(oldValue), 4698Unsafe.BitCast<T, byte>(newValue), 4708Unsafe.BitCast<T, ushort>(oldValue), 4709Unsafe.BitCast<T, ushort>(newValue), 4718Unsafe.BitCast<T, int>(oldValue), 4719Unsafe.BitCast<T, int>(newValue), 4728Unsafe.BitCast<T, long>(oldValue), 4729Unsafe.BitCast<T, long>(newValue), 5383Unsafe.BitCast<T, byte>(value), 5390Unsafe.BitCast<T, short>(value), 5397Unsafe.BitCast<T, int>(value), 5404Unsafe.BitCast<T, long>(value), 5432Unsafe.BitCast<T, byte>(value), 5439Unsafe.BitCast<T, short>(value), 5446Unsafe.BitCast<T, int>(value), 5453Unsafe.BitCast<T, long>(value),

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

898ReadOnlySpan<char> typedSpan = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(span); 899ReadOnlySpan<char> typedValue = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(value); 906ReadOnlySpan<byte> typedSpan = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(span); 907ReadOnlySpan<byte> typedValue = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(value); 918return Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(span).Trim()); 924return Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(span).TrimUtf8()); 934ReadOnlySpan<char> typedSpan = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(span); 935ReadOnlySpan<char> typedValue = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(value); 942ReadOnlySpan<byte> typedSpan = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(span); 943ReadOnlySpan<byte> typedValue = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(value); 1056ReadOnlySpan<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);

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

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

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

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

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

78TVectorInt64 ux = Unsafe.BitCast<TVectorDouble, TVectorInt64>(ax); 113Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(region & TVectorInt64.One, TVectorInt64.Zero)), 119Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals((region + TVectorInt64.One) & TVectorInt64.Create(2), TVectorInt64.Zero)), 130Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.GreaterThan(ux, TVectorInt64.Create(ARG_SMALLER - 1))), 216TVectorInt32 ux = Unsafe.BitCast<TVectorSingle, TVectorInt32>(ax); 273Unsafe.BitCast<TVectorInt32, TVectorSingle>(TVectorInt32.GreaterThan(ux, TVectorInt32.Create(ARG_SMALLER - 1))), 287Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(region & TVectorInt64.One, TVectorInt64.Zero)), 293Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals((region + TVectorInt64.One) & TVectorInt64.Create(2), TVectorInt64.Zero)), 411if (TVectorUInt64.LessThanOrEqualAll(Unsafe.BitCast<TVectorDouble, TVectorUInt64>(TVectorDouble.Abs(x)), TVectorUInt64.Create(V_ARG_MAX))) 417TVectorUInt64 n = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(dn); 454return poly * Unsafe.BitCast<TVectorUInt64, TVectorDouble>((n + TVectorUInt64.Create(V_DP64_BIAS)) << 52); 542if (TVectorUInt32.GreaterThanAny(Unsafe.BitCast<TVectorSingle, TVectorUInt32>(TVectorSingle.Abs(x)), TVectorUInt32.Create(V_ARG_MAX))) 569TVectorUInt64 n = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(dn); 588return Unsafe.BitCast<TVectorUInt64, TVectorDouble>(Unsafe.BitCast<TVectorDouble, TVectorUInt64>(poly) + (n << 52)); 608TVectorUInt64 xBits = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(ax); 609TVectorUInt64 yBits = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(ay); 618TVectorDouble insignificanMask = Unsafe.BitCast<TVectorUInt64, TVectorDouble>( 627TVectorDouble expFix = TVectorDouble.ConditionalSelect(Unsafe.BitCast<TVectorUInt64, TVectorDouble>(scaleDownMask), TVectorDouble.Create(4.149515568880993E+180), TVectorDouble.One); 633expFix = TVectorDouble.ConditionalSelect(Unsafe.BitCast<TVectorUInt64, TVectorDouble>(scaleUpMask), TVectorDouble.Create(2.409919865102884E-181), expFix); 648ax = Unsafe.BitCast<TVectorUInt64, TVectorDouble>(xBits); 649ax -= subnormalFix & Unsafe.BitCast<TVectorUInt64, TVectorDouble>(xSubnormalMask); 653ay = Unsafe.BitCast<TVectorUInt64, TVectorDouble>(yBits); 654ay -= subnormalFix & Unsafe.BitCast<TVectorUInt64, TVectorDouble>(ySubnormalMask); 656xBits = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(ax); 657yBits = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(ay); 667xBits = TVectorUInt64.ConditionalSelect(Unsafe.BitCast<TVectorDouble, TVectorUInt64>(lessThanMask), yBits, xBits); 668yBits = TVectorUInt64.ConditionalSelect(Unsafe.BitCast<TVectorDouble, TVectorUInt64>(lessThanMask), tmpBits, yBits); 675TVectorDouble xHead = Unsafe.BitCast<TVectorUInt64, TVectorDouble>(xBits & headMask); 676TVectorDouble yHead = Unsafe.BitCast<TVectorUInt64, TVectorDouble>(yBits & headMask); 698TVectorDouble equalExponentsMask = Unsafe.BitCast<TVectorUInt64, TVectorDouble>(TVectorUInt64.IsZero(expDiff)); 776TVectorUInt32 bits = Unsafe.BitCast<TVectorSingle, TVectorUInt32>(TVectorSingle.Abs(vector)); 793return Unsafe.BitCast<TVectorUInt32, TVectorSingle>(result); 801TVectorUInt64 bits = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(TVectorDouble.Abs(vector)); 818return Unsafe.BitCast<TVectorUInt64, TVectorDouble>(result); 826TVectorUInt32 bits = Unsafe.BitCast<TVectorSingle, TVectorUInt32>(TVectorSingle.Abs(vector)); 839return Unsafe.BitCast<TVectorUInt32, TVectorSingle>(result); 847TVectorUInt64 bits = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(TVectorDouble.Abs(vector)); 860return Unsafe.BitCast<TVectorUInt64, TVectorDouble>(result); 933TVectorUInt64 specialMask = TVectorUInt64.GreaterThanOrEqual(Unsafe.BitCast<TVectorDouble, TVectorUInt64>(x) - TVectorUInt64.Create(V_MIN), TVectorUInt64.Create(V_MAX - V_MIN)); 962TVectorDouble subnormalMask = TVectorDouble.AndNot(Unsafe.BitCast<TVectorUInt64, TVectorDouble>(specialMask), temp); 967Unsafe.BitCast<TVectorUInt64, TVectorDouble>(Unsafe.BitCast<TVectorDouble, TVectorUInt64>(x * 4503599627370496.0) - TVectorUInt64.Create(52ul << 52)), 971specialMask = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(temp); 975TVectorUInt64 vx = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(x) - TVectorUInt64.Create(V_OFF); 976TVectorDouble n = ConvertToDouble<TVectorInt64, TVectorDouble>(Unsafe.BitCast<TVectorUInt64, TVectorInt64>(vx) >> 52); 980TVectorDouble r = Unsafe.BitCast<TVectorUInt64, TVectorDouble>(vx) - TVectorDouble.One; 1027Unsafe.BitCast<TVectorUInt64, TVectorDouble>(specialMask), 1114TVectorUInt32 specialMask = TVectorUInt32.GreaterThanOrEqual(Unsafe.BitCast<TVectorSingle, TVectorUInt32>(x) - TVectorUInt32.Create(V_MIN), TVectorUInt32.Create(V_MAX - V_MIN)); 1143TVectorSingle subnormalMask = TVectorSingle.AndNot(Unsafe.BitCast<TVectorUInt32, TVectorSingle>(specialMask), temp); 1147Unsafe.BitCast<TVectorUInt32, TVectorSingle>(Unsafe.BitCast<TVectorSingle, TVectorUInt32>(x * 8388608.0f) - TVectorUInt32.Create(23u << 23)), 1151specialMask = Unsafe.BitCast<TVectorSingle, TVectorUInt32>(temp); 1154TVectorUInt32 vx = Unsafe.BitCast<TVectorSingle, TVectorUInt32>(x) - TVectorUInt32.Create(V_OFF); 1155TVectorSingle n = ConvertToSingle<TVectorInt32, TVectorSingle>(Unsafe.BitCast<TVectorUInt32, TVectorInt32>(vx) >> 23); 1159TVectorSingle r = Unsafe.BitCast<TVectorUInt32, TVectorSingle>(vx) - TVectorSingle.Create(1.0f); 1186Unsafe.BitCast<TVectorUInt32, TVectorSingle>(specialMask), 1253TVectorUInt64 specialMask = TVectorUInt64.GreaterThanOrEqual(Unsafe.BitCast<TVectorDouble, TVectorUInt64>(x) - TVectorUInt64.Create(V_MIN), TVectorUInt64.Create(V_MAX - V_MIN)); 1282TVectorDouble subnormalMask = TVectorDouble.AndNot(Unsafe.BitCast<TVectorUInt64, TVectorDouble>(specialMask), temp); 1287Unsafe.BitCast<TVectorUInt64, TVectorDouble>(Unsafe.BitCast<TVectorDouble, TVectorUInt64>(x * 4503599627370496.0) - TVectorUInt64.Create(52ul << 52)), 1291specialMask = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(temp); 1295TVectorUInt64 vx = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(x) - TVectorUInt64.Create(V_OFF); 1296TVectorDouble n = ConvertToDouble<TVectorInt64, TVectorDouble>(Unsafe.BitCast<TVectorUInt64, TVectorInt64>(vx) >> 52); 1300TVectorDouble r = Unsafe.BitCast<TVectorUInt64, TVectorDouble>(vx) - TVectorDouble.One; 1347Unsafe.BitCast<TVectorUInt64, TVectorDouble>(specialMask), 1430TVectorUInt32 specialMask = TVectorUInt32.GreaterThanOrEqual(Unsafe.BitCast<TVectorSingle, TVectorUInt32>(x) - TVectorUInt32.Create(V_MIN), TVectorUInt32.Create(V_MAX - V_MIN)); 1459TVectorSingle subnormalMask = TVectorSingle.AndNot(Unsafe.BitCast<TVectorUInt32, TVectorSingle>(specialMask), temp); 1464Unsafe.BitCast<TVectorUInt32, TVectorSingle>(Unsafe.BitCast<TVectorSingle, TVectorUInt32>(x * 8388608.0f) - TVectorUInt32.Create(23u << 23)), 1468specialMask = Unsafe.BitCast<TVectorSingle, TVectorUInt32>(temp); 1472TVectorUInt32 vx = Unsafe.BitCast<TVectorSingle, TVectorUInt32>(x) - TVectorUInt32.Create(V_OFF); 1473TVectorSingle n = ConvertToSingle<TVectorInt32, TVectorSingle>(Unsafe.BitCast<TVectorUInt32, TVectorInt32>(vx) >> 23); 1477TVectorSingle r = Unsafe.BitCast<TVectorUInt32, TVectorSingle>(vx) - TVectorSingle.One; 1504Unsafe.BitCast<TVectorUInt32, TVectorSingle>(specialMask), 1803TVectorInt64 ux = Unsafe.BitCast<TVectorDouble, TVectorInt64>(ax); 1842Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(region & TVectorInt64.One, TVectorInt64.Zero)), 1848Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(region & TVectorInt64.One, TVectorInt64.Zero)), 1853TVectorInt64 sign = Unsafe.BitCast<TVectorDouble, TVectorInt64>(x) >>> 63; 1856Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(((sign & (region >>> 1)) | (~sign & ~(region >>> 1))) & TVectorInt64.One, TVectorInt64.Zero)), 1862Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals((region + TVectorInt64.One) & TVectorInt64.Create(2), TVectorInt64.Zero)), 1873Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.GreaterThan(ux, TVectorInt64.Create(ARG_SMALLER - 1))), 1879Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.GreaterThan(ux, TVectorInt64.Create(ARG_SMALLER - 1))), 1922TVectorInt32 ux = Unsafe.BitCast<TVectorSingle, TVectorInt32>(ax); 1997Unsafe.BitCast<TVectorInt32, TVectorSingle>(TVectorInt32.GreaterThan(ux, TVectorInt32.Create(ARG_SMALLER - 1))), 2003Unsafe.BitCast<TVectorInt32, TVectorSingle>(TVectorInt32.GreaterThan(ux, TVectorInt32.Create(ARG_SMALLER - 1))), 2019Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(region & TVectorInt64.One, TVectorInt64.Zero)), 2025Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(region & TVectorInt64.One, TVectorInt64.Zero)), 2030TVectorInt64 sign = Unsafe.BitCast<TVectorDouble, TVectorInt64>(x) >>> 63; 2033Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(((sign & (region >>> 1)) | (~sign & ~(region >>> 1))) & TVectorInt64.One, TVectorInt64.Zero)), 2039Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals((region + TVectorInt64.One) & TVectorInt64.Create(2), TVectorInt64.Zero)), 2123TVectorInt64 ux = Unsafe.BitCast<TVectorDouble, TVectorInt64>(ax); 2153Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(region & TVectorInt64.One, TVectorInt64.Zero)), 2158TVectorInt64 sign = Unsafe.BitCast<TVectorDouble, TVectorInt64>(x) >>> 63; 2161Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(((sign & (region >>> 1)) | (~sign & ~(region >>> 1))) & TVectorInt64.One, TVectorInt64.Zero)), 2172Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.GreaterThan(ux, TVectorInt64.Create(ARG_SMALLER - 1))), 2253TVectorInt32 ux = Unsafe.BitCast<TVectorSingle, TVectorInt32>(ax); 2310Unsafe.BitCast<TVectorInt32, TVectorSingle>(TVectorInt32.GreaterThan(ux, TVectorInt32.Create(ARG_SMALLER - 1))), 2325Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(region & TVectorInt64.One, TVectorInt64.Zero)), 2330TVectorInt64 sign = Unsafe.BitCast<TVectorDouble, TVectorInt64>(x) >>> 63; 2333Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(((sign & (region >>> 1)) | (~sign & ~(region >>> 1))) & TVectorInt64.One, TVectorInt64.Zero)), 2880TVectorInt64 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); 1487? PackedSpanHelpers.IndexOf(ref Unsafe.As<TValue, char>(ref searchSpace), Unsafe.BitCast<TValue, char>(value), length) 1488: PackedSpanHelpers.IndexOfAnyExcept(ref Unsafe.As<TValue, char>(ref searchSpace), Unsafe.BitCast<TValue, char>(value), length); 1673char char0 = Unsafe.BitCast<TValue, char>(value0); 1674char char1 = Unsafe.BitCast<TValue, char>(value1); 1900? 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) 1901: 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); 3484char charLowInclusive = Unsafe.BitCast<T, char>(lowInclusive); 3485char 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))

184=> Unsafe.BitCast<int, float>(Exchange(ref Unsafe.As<float, int>(ref location1), Unsafe.BitCast<float, int>(value))); 193=> Unsafe.BitCast<long, double>(Exchange(ref Unsafe.As<double, long>(ref location1), Unsafe.BitCast<double, long>(value))); 261return Unsafe.BitCast<byte, T>( 264Unsafe.BitCast<T, byte>(value))); 269return Unsafe.BitCast<ushort, T>( 272Unsafe.BitCast<T, ushort>(value))); 277return Unsafe.BitCast<int, T>( 280Unsafe.BitCast<T, int>(value))); 284return Unsafe.BitCast<long, T>( 287Unsafe.BitCast<T, long>(value))); 432=> Unsafe.BitCast<int, float>(CompareExchange(ref Unsafe.As<float, int>(ref location1), Unsafe.BitCast<float, int>(value), Unsafe.BitCast<float, int>(comparand))); 442=> Unsafe.BitCast<long, double>(CompareExchange(ref Unsafe.As<double, long>(ref location1), Unsafe.BitCast<double, long>(value), Unsafe.BitCast<double, long>(comparand))); 513return Unsafe.BitCast<byte, T>( 516Unsafe.BitCast<T, byte>(value), 517Unsafe.BitCast<T, byte>(comparand))); 522return Unsafe.BitCast<ushort, T>( 525Unsafe.BitCast<T, ushort>(value), 526Unsafe.BitCast<T, ushort>(comparand))); 531return Unsafe.BitCast<int, T>( 534Unsafe.BitCast<T, int>(value), 535Unsafe.BitCast<T, int>(comparand))); 539return Unsafe.BitCast<long, T>( 542Unsafe.BitCast<T, long>(value), 543Unsafe.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);

2216m_real.TryFormat(Unsafe.BitCast<Span<TChar>, Span<char>>(destination.Slice(1)), out realChars, format, provider) : 2217m_real.TryFormat(Unsafe.BitCast<Span<TChar>, Span<byte>>(destination.Slice(1)), out realChars, format, provider)) 2227m_imaginary.TryFormat(Unsafe.BitCast<Span<TChar>, Span<char>>(destination.Slice(2)), out imaginaryChars, format, provider) : 2228m_imaginary.TryFormat(Unsafe.BitCast<Span<TChar>, Span<byte>>(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)));