Int64.cs

Go to the documentation of this file.

using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Numerics;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
 
namespace System;
 
[Serializable]
[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
public readonly struct Int64 : IComparable, IConvertible, ISpanFormattable, IFormattable, IComparable<long>, IEquatable<long>, IBinaryInteger<long>, IBinaryNumber<long>, IBitwiseOperators<long, long, long>, INumber<long>, IAdditionOperators<long, long, long>, IAdditiveIdentity<long, long>, IComparisonOperators<long, long>, IEqualityOperators<long, long>, IDecrementOperators<long>, IDivisionOperators<long, long, long>, IIncrementOperators<long>, IModulusOperators<long, long, long>, IMultiplicativeIdentity<long, long>, IMultiplyOperators<long, long, long>, ISpanParseable<long>, IParseable<long>, ISubtractionOperators<long, long, long>, IUnaryNegationOperators<long, long>, IUnaryPlusOperators<long, long>, IShiftOperators<long, long>, IMinMaxValue<long>, ISignedNumber<long>
{
    private readonly long m_value;
 
    public const long MaxValue = 9223372036854775807L;
 
    public const long MinValue = -9223372036854775808L;
 
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static long IAdditiveIdentity<long, long>.AdditiveIdentity => 0L;
 
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static long IMinMaxValue<long>.MinValue => long.MinValue;
 
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static long IMinMaxValue<long>.MaxValue => long.MaxValue;
 
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static long IMultiplicativeIdentity<long, long>.MultiplicativeIdentity => 1L;
 
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static long INumber<long>.One => 1L;
 
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static long INumber<long>.Zero => 0L;
 
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static long ISignedNumber<long>.NegativeOne => -1L;
 
    public int CompareTo(object? value)
    {
        if (value == null)
        {
            return 1;
        }
        if (value is long num)
        {
            if (this < num)
            {
                return -1;
            }
            if (this > num)
            {
                return 1;
            }
            return 0;
        }
        throw new ArgumentException(SR.Arg_MustBeInt64);
    }
 
    public int CompareTo(long value)
    {
        if (this < value)
        {
            return -1;
        }
        if (this > value)
        {
            return 1;
        }
        return 0;
    }
 
    public override bool Equals([NotNullWhen(true)] object? obj)
    {
        if (!(obj is long))
        {
            return false;
        }
        return this == (long)obj;
    }
 
    [NonVersionable]
    public bool Equals(long obj)
    {
        return this == obj;
    }
 
    public override int GetHashCode()
    {
        return (int)this ^ (int)(this >> 32);
    }
 
    public override string ToString()
    {
        return Number.Int64ToDecStr(this);
    }
 
    public string ToString(IFormatProvider? provider)
    {
        return Number.FormatInt64(this, null, provider);
    }
 
    public string ToString(string? format)
    {
        return Number.FormatInt64(this, format, null);
    }
 
    public string ToString(string? format, IFormatProvider? provider)
    {
        return Number.FormatInt64(this, format, provider);
    }
 
    public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default(ReadOnlySpan<char>), IFormatProvider? provider = null)
    {
        return Number.TryFormatInt64(this, format, provider, destination, out charsWritten);
    }
 
    public static long Parse(string s)
    {
        if (s == null)
        {
            ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
        }
        return Number.ParseInt64(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo);
    }
 
    public static long Parse(string s, NumberStyles style)
    {
        NumberFormatInfo.ValidateParseStyleInteger(style);
        if (s == null)
        {
            ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
        }
        return Number.ParseInt64(s, style, NumberFormatInfo.CurrentInfo);
    }
 
    public static long Parse(string s, IFormatProvider? provider)
    {
        if (s == null)
        {
            ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
        }
        return Number.ParseInt64(s, NumberStyles.Integer, NumberFormatInfo.GetInstance(provider));
    }
 
    public static long Parse(string s, NumberStyles style, IFormatProvider? provider)
    {
        NumberFormatInfo.ValidateParseStyleInteger(style);
        if (s == null)
        {
            ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
        }
        return Number.ParseInt64(s, style, NumberFormatInfo.GetInstance(provider));
    }
 
    public static long Parse(ReadOnlySpan<char> s, NumberStyles style = NumberStyles.Integer, IFormatProvider? provider = null)
    {
        NumberFormatInfo.ValidateParseStyleInteger(style);
        return Number.ParseInt64(s, style, NumberFormatInfo.GetInstance(provider));
    }
 
    public static bool TryParse([NotNullWhen(true)] string? s, out long result)
    {
        if (s == null)
        {
            result = 0L;
            return false;
        }
        return Number.TryParseInt64IntegerStyle(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo, out result) == Number.ParsingStatus.OK;
    }
 
    public static bool TryParse(ReadOnlySpan<char> s, out long result)
    {
        return Number.TryParseInt64IntegerStyle(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo, out result) == Number.ParsingStatus.OK;
    }
 
    public static bool TryParse([NotNullWhen(true)] string? s, NumberStyles style, IFormatProvider? provider, out long result)
    {
        NumberFormatInfo.ValidateParseStyleInteger(style);
        if (s == null)
        {
            result = 0L;
            return false;
        }
        return Number.TryParseInt64(s, style, NumberFormatInfo.GetInstance(provider), out result) == Number.ParsingStatus.OK;
    }
 
    public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider, out long result)
    {
        NumberFormatInfo.ValidateParseStyleInteger(style);
        return Number.TryParseInt64(s, style, NumberFormatInfo.GetInstance(provider), out result) == Number.ParsingStatus.OK;
    }
 
    public TypeCode GetTypeCode()
    {
        return TypeCode.Int64;
    }
 
    bool IConvertible.ToBoolean(IFormatProvider provider)
    {
        return Convert.ToBoolean(this);
    }
 
    char IConvertible.ToChar(IFormatProvider provider)
    {
        return Convert.ToChar(this);
    }
 
    sbyte IConvertible.ToSByte(IFormatProvider provider)
    {
        return Convert.ToSByte(this);
    }
 
    byte IConvertible.ToByte(IFormatProvider provider)
    {
        return Convert.ToByte(this);
    }
 
    short IConvertible.ToInt16(IFormatProvider provider)
    {
        return Convert.ToInt16(this);
    }
 
    ushort IConvertible.ToUInt16(IFormatProvider provider)
    {
        return Convert.ToUInt16(this);
    }
 
    int IConvertible.ToInt32(IFormatProvider provider)
    {
        return Convert.ToInt32(this);
    }
 
    uint IConvertible.ToUInt32(IFormatProvider provider)
    {
        return Convert.ToUInt32(this);
    }
 
    long IConvertible.ToInt64(IFormatProvider provider)
    {
        return this;
    }
 
    ulong IConvertible.ToUInt64(IFormatProvider provider)
    {
        return Convert.ToUInt64(this);
    }
 
    float IConvertible.ToSingle(IFormatProvider provider)
    {
        return Convert.ToSingle(this);
    }
 
    double IConvertible.ToDouble(IFormatProvider provider)
    {
        return Convert.ToDouble(this);
    }
 
    decimal IConvertible.ToDecimal(IFormatProvider provider)
    {
        return Convert.ToDecimal(this);
    }
 
    DateTime IConvertible.ToDateTime(IFormatProvider provider)
    {
        throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, "Int64", "DateTime"));
    }
 
    object IConvertible.ToType(Type type, IFormatProvider provider)
    {
        return Convert.DefaultToType(this, type, provider);
    }
 
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static long IAdditionOperators<long, long, long>.operator +(long left, long right)
    {
        return left + right;
    }
 
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static long IBinaryInteger<long>.LeadingZeroCount(long value)
    {
        return BitOperations.LeadingZeroCount((ulong)value);
    }
 
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static long IBinaryInteger<long>.PopCount(long value)
    {
        return BitOperations.PopCount((ulong)value);
    }
 
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static long IBinaryInteger<long>.RotateLeft(long value, int rotateAmount)
    {
        return (long)BitOperations.RotateLeft((ulong)value, rotateAmount);
    }
 
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static long IBinaryInteger<long>.RotateRight(long value, int rotateAmount)
    {
        return (long)BitOperations.RotateRight((ulong)value, rotateAmount);
    }
 
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static long IBinaryInteger<long>.TrailingZeroCount(long value)
    {
        return BitOperations.TrailingZeroCount(value);
    }
 
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static bool IBinaryNumber<long>.IsPow2(long value)
    {
        return BitOperations.IsPow2(value);
    }
 
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static long IBinaryNumber<long>.Log2(long value)
    {
        if (value < 0)
        {
            ThrowHelper.ThrowValueArgumentOutOfRange_NeedNonNegNumException();
        }
        return BitOperations.Log2((ulong)value);
    }
 
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static long IBitwiseOperators<long, long, long>.operator &(long left, long right)
    {
        return left & right;
    }
 
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static long IBitwiseOperators<long, long, long>.operator |(long left, long right)
    {
        return left | right;
    }
 
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static long IBitwiseOperators<long, long, long>.operator ^(long left, long right)
    {
        return left ^ right;
    }
 
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static long IBitwiseOperators<long, long, long>.operator ~(long value)
    {
        return ~value;
    }
 
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static bool IComparisonOperators<long, long>.operator <(long left, long right)
    {
        return left < right;
    }
 
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static bool IComparisonOperators<long, long>.operator <=(long left, long right)
    {
        return left <= right;
    }
 
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static bool IComparisonOperators<long, long>.operator >(long left, long right)
    {
        return left > right;
    }
 
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static bool IComparisonOperators<long, long>.operator >=(long left, long right)
    {
        return left >= right;
    }
 
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static long IDecrementOperators<long>.operator --(long value)
    {
        return --value;
    }
 
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static long IDivisionOperators<long, long, long>.operator /(long left, long right)
    {
        return left / right;
    }
 
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static bool IEqualityOperators<long, long>.operator ==(long left, long right)
    {
        return left == right;
    }
 
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static bool IEqualityOperators<long, long>.operator !=(long left, long right)
    {
        return left != right;
    }
 
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static long IIncrementOperators<long>.operator ++(long value)
    {
        return ++value;
    }
 
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static long IModulusOperators<long, long, long>.operator %(long left, long right)
    {
        return left % right;
    }
 
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static long IMultiplyOperators<long, long, long>.operator *(long left, long right)
    {
        return left * right;
    }
 
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static long INumber<long>.Abs(long value)
    {
        return Math.Abs(value);
    }
 
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static long INumber<long>.Clamp(long value, long min, long max)
    {
        return Math.Clamp(value, min, max);
    }
 
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static long INumber<long>.Create<TOther>(TOther value)
    {
        if (typeof(TOther) == typeof(byte))
        {
            return (byte)(object)value;
        }
        if (typeof(TOther) == typeof(char))
        {
            return (char)(object)value;
        }
        if (typeof(TOther) == typeof(decimal))
        {
            return (long)(decimal)(object)value;
        }
        if (typeof(TOther) == typeof(double))
        {
            return checked((long)(double)(object)value);
        }
        if (typeof(TOther) == typeof(short))
        {
            return (short)(object)value;
        }
        if (typeof(TOther) == typeof(int))
        {
            return (int)(object)value;
        }
        if (typeof(TOther) == typeof(long))
        {
            return (long)(object)value;
        }
        if (typeof(TOther) == typeof(IntPtr))
        {
            return (long)(IntPtr)(object)value;
        }
        if (typeof(TOther) == typeof(sbyte))
        {
            return (sbyte)(object)value;
        }
        checked
        {
            if (typeof(TOther) == typeof(float))
            {
                return (long)(float)(object)value;
            }
            if (typeof(TOther) == typeof(ushort))
            {
                return (ushort)(object)value;
            }
            if (typeof(TOther) == typeof(uint))
            {
                return (uint)(object)value;
            }
            if (typeof(TOther) == typeof(ulong))
            {
                return (long)(ulong)(object)value;
            }
            if (typeof(TOther) == typeof(UIntPtr))
            {
                return (long)(nuint)(UIntPtr)(object)value;
            }
            ThrowHelper.ThrowNotSupportedException();
            return 0L;
        }
    }
 
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static long INumber<long>.CreateSaturating<TOther>(TOther value)
    {
        if (typeof(TOther) == typeof(byte))
        {
            return (byte)(object)value;
        }
        if (typeof(TOther) == typeof(char))
        {
            return (char)(object)value;
        }
        if (typeof(TOther) == typeof(decimal))
        {
            decimal num = (decimal)(object)value;
            if (!(num > 9223372036854775807m))
            {
                if (!(num < -9223372036854775808m))
                {
                    return (long)num;
                }
                return long.MinValue;
            }
            return long.MaxValue;
        }
        if (typeof(TOther) == typeof(double))
        {
            double num2 = (double)(object)value;
            if (!(num2 > 9.223372036854776E+18))
            {
                if (!(num2 < -9.223372036854776E+18))
                {
                    return (long)num2;
                }
                return long.MinValue;
            }
            return long.MaxValue;
        }
        if (typeof(TOther) == typeof(short))
        {
            return (short)(object)value;
        }
        if (typeof(TOther) == typeof(int))
        {
            return (int)(object)value;
        }
        if (typeof(TOther) == typeof(long))
        {
            return (long)(object)value;
        }
        if (typeof(TOther) == typeof(IntPtr))
        {
            return (long)(IntPtr)(object)value;
        }
        if (typeof(TOther) == typeof(sbyte))
        {
            return (sbyte)(object)value;
        }
        if (typeof(TOther) == typeof(float))
        {
            float num3 = (float)(object)value;
            if (!(num3 > 9.223372E+18f))
            {
                if (!(num3 < -9.223372E+18f))
                {
                    return (long)num3;
                }
                return long.MinValue;
            }
            return long.MaxValue;
        }
        if (typeof(TOther) == typeof(ushort))
        {
            return (ushort)(object)value;
        }
        if (typeof(TOther) == typeof(uint))
        {
            return (uint)(object)value;
        }
        if (typeof(TOther) == typeof(ulong))
        {
            ulong num4 = (ulong)(object)value;
            if (num4 <= long.MaxValue)
            {
                return (long)num4;
            }
            return long.MaxValue;
        }
        if (typeof(TOther) == typeof(UIntPtr))
        {
            UIntPtr uIntPtr = (UIntPtr)(object)value;
            if ((ulong)(nuint)uIntPtr <= 9223372036854775807uL)
            {
                return (long)(nuint)uIntPtr;
            }
            return long.MaxValue;
        }
        ThrowHelper.ThrowNotSupportedException();
        return 0L;
    }
 
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static long INumber<long>.CreateTruncating<TOther>(TOther value)
    {
        if (typeof(TOther) == typeof(byte))
        {
            return (byte)(object)value;
        }
        if (typeof(TOther) == typeof(char))
        {
            return (char)(object)value;
        }
        if (typeof(TOther) == typeof(decimal))
        {
            return (long)(decimal)(object)value;
        }
        if (typeof(TOther) == typeof(double))
        {
            return (long)(double)(object)value;
        }
        if (typeof(TOther) == typeof(short))
        {
            return (short)(object)value;
        }
        if (typeof(TOther) == typeof(int))
        {
            return (int)(object)value;
        }
        if (typeof(TOther) == typeof(long))
        {
            return (long)(object)value;
        }
        if (typeof(TOther) == typeof(IntPtr))
        {
            return (long)(IntPtr)(object)value;
        }
        if (typeof(TOther) == typeof(sbyte))
        {
            return (sbyte)(object)value;
        }
        if (typeof(TOther) == typeof(float))
        {
            return (long)(float)(object)value;
        }
        if (typeof(TOther) == typeof(ushort))
        {
            return (ushort)(object)value;
        }
        if (typeof(TOther) == typeof(uint))
        {
            return (uint)(object)value;
        }
        if (typeof(TOther) == typeof(ulong))
        {
            return (long)(ulong)(object)value;
        }
        if (typeof(TOther) == typeof(UIntPtr))
        {
            return (long)(nuint)(UIntPtr)(object)value;
        }
        ThrowHelper.ThrowNotSupportedException();
        return 0L;
    }
 
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static (long Quotient, long Remainder) INumber<long>.DivRem(long left, long right)
    {
        return Math.DivRem(left, right);
    }
 
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static long INumber<long>.Max(long x, long y)
    {
        return Math.Max(x, y);
    }
 
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static long INumber<long>.Min(long x, long y)
    {
        return Math.Min(x, y);
    }
 
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static long INumber<long>.Parse(string s, NumberStyles style, IFormatProvider provider)
    {
        return Parse(s, style, provider);
    }
 
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static long INumber<long>.Parse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider)
    {
        return Parse(s, style, provider);
    }
 
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static long INumber<long>.Sign(long value)
    {
        return Math.Sign(value);
    }
 
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static bool INumber<long>.TryCreate<TOther>(TOther value, out long result)
    {
        if (typeof(TOther) == typeof(byte))
        {
            result = (byte)(object)value;
            return true;
        }
        if (typeof(TOther) == typeof(char))
        {
            result = (char)(object)value;
            return true;
        }
        if (typeof(TOther) == typeof(decimal))
        {
            decimal num = (decimal)(object)value;
            if (num < -9223372036854775808m || num > 9223372036854775807m)
            {
                result = 0L;
                return false;
            }
            result = (long)num;
            return true;
        }
        if (typeof(TOther) == typeof(double))
        {
            double num2 = (double)(object)value;
            if (num2 < -9.223372036854776E+18 || num2 > 9.223372036854776E+18)
            {
                result = 0L;
                return false;
            }
            result = (long)num2;
            return true;
        }
        if (typeof(TOther) == typeof(short))
        {
            result = (short)(object)value;
            return true;
        }
        if (typeof(TOther) == typeof(int))
        {
            result = (int)(object)value;
            return true;
        }
        if (typeof(TOther) == typeof(long))
        {
            result = (long)(object)value;
            return true;
        }
        if (typeof(TOther) == typeof(IntPtr))
        {
            result = (long)(IntPtr)(object)value;
            return true;
        }
        if (typeof(TOther) == typeof(sbyte))
        {
            result = (sbyte)(object)value;
            return true;
        }
        if (typeof(TOther) == typeof(float))
        {
            float num3 = (float)(object)value;
            if (num3 < -9.223372E+18f || num3 > 9.223372E+18f)
            {
                result = 0L;
                return false;
            }
            result = (long)num3;
            return true;
        }
        if (typeof(TOther) == typeof(ushort))
        {
            result = (ushort)(object)value;
            return true;
        }
        if (typeof(TOther) == typeof(uint))
        {
            result = (uint)(object)value;
            return true;
        }
        if (typeof(TOther) == typeof(ulong))
        {
            ulong num4 = (ulong)(object)value;
            if (num4 > long.MaxValue)
            {
                result = 0L;
                return false;
            }
            result = (long)num4;
            return true;
        }
        if (typeof(TOther) == typeof(UIntPtr))
        {
            UIntPtr uIntPtr = (UIntPtr)(object)value;
            if ((ulong)(nuint)uIntPtr > 9223372036854775807uL)
            {
                result = 0L;
                return false;
            }
            result = (long)(nuint)uIntPtr;
            return true;
        }
        ThrowHelper.ThrowNotSupportedException();
        result = 0L;
        return false;
    }
 
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static bool INumber<long>.TryParse([NotNullWhen(true)] string s, NumberStyles style, IFormatProvider provider, out long result)
    {
        return TryParse(s, style, provider, out result);
    }
 
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static bool INumber<long>.TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider, out long result)
    {
        return TryParse(s, style, provider, out result);
    }
 
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static long IParseable<long>.Parse(string s, IFormatProvider provider)
    {
        return Parse(s, provider);
    }
 
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static bool IParseable<long>.TryParse([NotNullWhen(true)] string s, IFormatProvider provider, out long result)
    {
        return TryParse(s, NumberStyles.Integer, provider, out result);
    }
 
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static long IShiftOperators<long, long>.operator <<(long value, int shiftAmount)
    {
        return value << shiftAmount;
    }
 
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static long IShiftOperators<long, long>.operator >>(long value, int shiftAmount)
    {
        return value >> shiftAmount;
    }
 
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static long ISpanParseable<long>.Parse(ReadOnlySpan<char> s, IFormatProvider provider)
    {
        return Parse(s, NumberStyles.Integer, provider);
    }
 
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static bool ISpanParseable<long>.TryParse(ReadOnlySpan<char> s, IFormatProvider provider, out long result)
    {
        return TryParse(s, NumberStyles.Integer, provider, out result);
    }
 
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static long ISubtractionOperators<long, long, long>.operator -(long left, long right)
    {
        return left - right;
    }
 
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static long IUnaryNegationOperators<long, long>.operator -(long value)
    {
        return -value;
    }
 
    [RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
    static long IUnaryPlusOperators<long, long>.operator +(long value)
    {
        return value;
    }
}