using System.Diagnostics.CodeAnalysis;
using System.Numerics;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using static Tmpl;
using System.Globalization;
using System.Diagnostics;

StreamWriter writer = new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false };
Console.SetOut(writer);

Solver.Solve();

Console.Out.Flush();

public static class Solver
{
    private static readonly AtCoderIO cin = new AtCoderIO();

    public static unsafe void Solve()
    {
        int N = cin.Int();
        long[] A = cin.LongArray(N);
        ModInt<Mod998244353>[] invA = new ModInt<Mod998244353>[N];
        for (int i = 0; i < N; i++)
        {
            invA[i] = ((ModInt<Mod998244353>)A[i]).Inv();
        }

        Ensure(1 <= N && N <= 1500);

        Array.Sort(A);
        for (int i = 0; i < N; i++)
        {
            if (i < N - 1)
            {
                Ensure(A[i] != A[i + 1]);
            }
        }

        ModInt<Mod998244353> ans = 0L;
        for (int i = 0; i < N; i++)
        {
            ans += (A[i] + 1) / (ModInt<Mod998244353>)2L;
        }

        if ((long)A[0] <= N + 2)
        {
            print(SolveNaive(N, A, invA));
            return;
        }
        
        ModInt<Mod998244353>[] F = new ModInt<Mod998244353>[N + 3];

        for (int x = 1; x <= N + 2; x++)
        {
            ModInt<Mod998244353> left = 1L;
            ModInt<Mod998244353> right = 1L;
            for (int i = 1; i < N; i++)
            {
                right *= (A[i] - x) * invA[i];
            }

            for (int k = 0; k < N; k++)
            {
                F[x] += (A[k] - x) * left * right * invA[k];
                left *= (A[k] - x + 1) * invA[k];
                if (k < N - 1)
                {
                    right /= (ModInt<Mod998244353>)(A[k + 1] - x) * invA[k + 1];
                }
            }
        }
        
        for (int j = 2; j <= N + 2; j++)
        {
            F[j] += F[j - 1];
        }

        ModCache<Mod998244353> cache = new(N + 100);

        ModInt<Mod998244353>[] prefix = new ModInt<Mod998244353>[N + 3];
        ModInt<Mod998244353>[] suffix = new ModInt<Mod998244353>[N + 3];

        prefix[0] = 1L;
        suffix[N + 2] = 1L;
        for (int i = 1; i <= N + 2; i++)
        {
            prefix[i] = prefix[i - 1] * (A[0] - i);
        }

        for (int i = N + 1; i >= 0; i--)
        {
            suffix[i] = suffix[i + 1] * (A[0] - i - 1);
        }

        for (int i = 1; i <= N + 2; i++)
        {
            long sign = (i - N + 2) % 2 == 0 ? 1 : -1;
            ans += F[i] * (prefix[i - 1] * suffix[i]) * (cache.InverseFactorial(i - 1) * sign * cache.InverseFactorial(N + 2 - i));
        }

        print(ans);
    }

    private static ModInt<Mod998244353> SolveNaive(int N, long[] A, ModInt<Mod998244353>[] invA)
    {
        ModInt<Mod998244353> ans = 0L;
        for (int i = 0; i < N; i++)
        {
            ans += (A[i] + 1) / (ModInt<Mod998244353>)2L;
        }

        for (int m = 1; m <= A[0]; m++)
        {
            ModInt<Mod998244353> left = 1L;
            ModInt<Mod998244353> right = 1L;
            for (int i = 1; i < N; i++)
            {
                right *= (A[i] - m) * invA[i];
            }

            for (int k = 0; k < N; k++)
            {
                ans += (A[k] - m) * left * right * invA[k];
                left *= (A[k] - m + 1) * invA[k];
                if (k < N - 1)
                {
                    right /= (ModInt<Mod998244353>)(A[k + 1] - m) * invA[k + 1];
                }
            }
        }

        return ans;
    }

    private static void Ensure(bool condition)
    {
        if (!condition)
        {
            throw new InvalidOperationException();
        }
    }
}

/// <summary>
/// ModIntの階乗、階乗の逆元、逆元を前計算。
/// </summary>
public sealed class ModCache<T> where T : struct, IMod
{
    private ModInt<T>[] _factorial;
    private ModInt<T>[] _inverseFactorial;
    private ModInt<T>[] _inverse;

    // 階乗(&階乗逆元)と逆元を前計算する.
    // O(max)
    public ModCache(long max)
    {
        _factorial = new ModInt<T>[max + 1];
        _inverseFactorial = new ModInt<T>[max + 1];

        _factorial[0] = 1;
        _inverseFactorial[0] = ModInt<T>.One;

        _inverse = new ModInt<T>[max + 1];
        _inverse[1] = ModInt<T>.CreateFast(1);

        for (long p = 1; p <= max; p++)
        {
            _factorial[p] = _factorial[p - 1] * p;
            if (p > 1)
            {
                _inverse[p] = -(ModInt<T>.Mod / p) * _inverse[ModInt<T>.Mod % p];
            }
            _inverseFactorial[p] = _inverseFactorial[p - 1] * _inverse[p];
        }
    }

    /// <summary>
    /// binom(n, r)を返す。r<0またはr>nのとき0を返す。計算量: O(1)
    /// </summary>
    /// <param name="n"></param>
    /// <param name="r"></param>
    /// <returns></returns>
    public ModInt<T> Combination(long n, long r)
    {
        if (r < 0 || r > n) return 0;
        return _factorial[n] * (_inverseFactorial[n - r] * _inverseFactorial[r]);
    }

    /// <summary>
    /// nPrを返す。r<0またはr>nのとき0を返す。計算量: O(1)
    /// </summary>
    /// <param name="n"></param>
    /// <param name="r"></param>
    /// <returns></returns>
    public ModInt<T> Permutation(long n, long r)
    {
        if (r < 0 || r > n) return 1;
        return _factorial[n] * _inverseFactorial[n - r];
    }

    /// <summary>
    /// n!の値を返す。計算量: O(1)
    /// </summary>
    /// <param name="n"></param>
    /// <returns></returns>
    /// <exception cref="InvalidOperationException"></exception>
    public ModInt<T> Factorial(long n)
    {
        Debug.Assert(0 <= n && n < _factorial.Length);
        return _factorial[n];
    }

    /// <summary>
    /// n!の乗法逆元(n!)^{-1}の値を返す。計算量: O(1)
    /// </summary>
    /// <param name="n"></param>
    /// <returns></returns>
    /// <exception cref="InvalidOperationException"></exception>
    public ModInt<T> InverseFactorial(int n)
    {
        Debug.Assert(0 <= n && n < _inverseFactorial.Length);
        return _inverseFactorial[n];
    }

    /// <summary>
    /// nの乗法逆元n^{-1}を返す。計算量: O(1)
    /// </summary>
    /// <param name="n"></param>
    /// <returns></returns>
    /// <exception cref="InvalidOperationException"></exception>
    public ModInt<T> Inverse(long n)
    {
        Debug.Assert(0 <= n && n < _inverse.Length);
        return _inverse[n];
    }
}

public sealed class AtCoderIO
{
    Queue<string> _readQueue = new Queue<string>();

    private void LoadQueue()
    {
        if (_readQueue.Count > 0) return;
        string line = Console.ReadLine();
        string[] split = line.Split(' ', StringSplitOptions.RemoveEmptyEntries);
        for (int i = 0; i < split.Length; i++) _readQueue.Enqueue(split[i]);
    }

    private void Guard()
    {
        if (_readQueue.Count == 0)
        {
            throw new Exception("NO DATA TO READ");
        }
    }

    public int Int()
    {
        LoadQueue();
        Guard();
        return int.Parse(_readQueue.Dequeue());
    }

    public long Long()
    {
        LoadQueue();
        Guard();
        return long.Parse(_readQueue.Dequeue());
    }

    public string String()
    {
        LoadQueue();
        Guard();
        return _readQueue.Dequeue();
    }

    public short Short()
    {
        LoadQueue();
        Guard();
        return short.Parse(_readQueue.Dequeue());
    }

    public byte Byte()
    {
        LoadQueue();
        Guard();
        return byte.Parse(_readQueue.Dequeue());
    }

    public char Char()
    {
        LoadQueue();
        Guard();
        return char.Parse(_readQueue.Dequeue());
    }

    public double Double()
    {
        LoadQueue();
        Guard();
        return double.Parse(_readQueue.Dequeue());
    }

    public float Float()
    {
        LoadQueue();
        Guard();
        return float.Parse(_readQueue.Dequeue());
    }

    public ModInt<T> ModInt<T>() where T : struct, IMod
    {
        return new ModInt<T>(Long());
    }

    public T Read<T>()
    {
        Type type = typeof(T);
        if (type == typeof(int)) return (T)(object)Int();
        else if (type == typeof(long)) return (T)(object)Long();
        else if (type == typeof(float)) return (T)(object)Float();
        else if (type == typeof(double)) return (T)(object)Double();
        else if (type == typeof(short)) return (T)(object)Short();
        else if (type == typeof(byte)) return (T)(object)Byte();
        else if (type == typeof(char)) return (T)(object)Char();
        else if (type == typeof(string)) return (T)(object)String();
        else return default(T);
    }

    public int[] IntArray(int n)
    {
        if (n == 0) return Array.Empty<int>();

        int[] arr = new int[n];
        for (int i = 0; i < n; i++)
        {
            arr[i] = Int();
        }

        return arr;
    }

    public int[] ZeroIndexedPermutation(int n)
    {
        if (n == 0) return Array.Empty<int>();

        int[] arr = new int[n];
        for (int i = 0; i < n; i++)
        {
            arr[i] = Int() - 1;
        }

        return arr;
    }

    public long[] LongArray(int n)
    {
        if (n == 0) return Array.Empty<long>();

        long[] arr = new long[n];
        for (int i = 0; i < n; i++)
        {
            arr[i] = Long();
        }

        return arr;
    }

    public double[] DoubleArray(int n)
    {
        if (n == 0) return Array.Empty<double>();

        double[] arr = new double[n];
        for (int i = 0; i < n; i++)
        {
            arr[i] = Double();
        }

        return arr;
    }

    public ModInt<T>[] ModIntArray<T>(int n) where T : struct, IMod
    {
        if (n == 0) return Array.Empty<ModInt<T>>();

        ModInt<T>[] arr = new ModInt<T>[n];
        for (int i = 0; i < n; i++)
        {
            arr[i] = (ModInt<T>)Long();
        }

        return arr;
    }

    public T[] ReadArray<T>(int n)
    {
        if (n == 0) return Array.Empty<T>();

        T[] arr = new T[n];
        for (int i = 0; i < n; i++)
        {
            arr[i] = Read<T>();
        }

        return arr;
    }
}

public static class Tmpl
{
    public static long pow(long b, long exp)
    {
        if (exp == 0) return 1;
        if (exp == 1) return b;

        long m = pow(b, exp / 2L);
        m *= m;
        if (exp % 2L == 1) m *= b;

        return m;
    }

    public static long modpow(long b, long exp, long mod)
    {
        if (exp == 0) return 1;
        if (exp == 1) return b % mod;

        long m = modpow(b, exp / 2L, mod);
        m *= m;
		m %= mod;
        if (exp % 2L == 1) m *= b % mod;
        m %= mod;

        return m;
    }

	static long modinv( long a, long mod )
	{
		long b = mod, u = 1, v = 0;
		while ( b > 0 )
		{
			long t = a / b;
			a -= t * b; swap( ref a, ref b );
			u -= t * v; swap( ref u, ref v );
		}
		u %= mod;
		if (u < 0) u += mod;
		return u;
	}

    public static long calcLcm(long a, long b)
    {
        return a * b / calcGcd(a, b);
    }

    public static long calcGcd(long a, long b)
    {
        if (a % b == 0) return b;
        return calcGcd(b, a % b);
    }

    // ax ≡ b (mod m)なる最小のxを求める
    public static bool solveModLinear(long a, long b, long m, out long minSolution)
    {
        long gcd = calcGcd(calcGcd(a, b), m);
        a /= gcd;
        b /= gcd;
        m /= gcd;
        if (calcGcd(a, m) == 1)
        {
            long inv = modinv(a, m);
            minSolution = (b * inv) % m;
            return true;
        }
        minSolution = 0;
        return false;
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void YesNo(bool t)
    {
        Console.WriteLine(t ? "Yes" : "No");
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void YESNO(bool t)
    {
        Console.WriteLine(t ? "YES" : "NO");
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void yesno(bool t)
    {
        Console.WriteLine(t ? "yes" : "no");
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static bool checkBit(int bit, int n)
    {
        return ((1 << n) & bit) != 0;
    }

    public static bool nextSubset(ref int set, int super)
    {
        set = (set - 1) & super;
        return set != 0;
    }

    public static bool nextCombination(int n, int r, int[] array)
    {
        int i = array.Length - 1;
        while (i >= 0 && array[i] == i + n - r)
        {
            i--;
        }

        if (i < 0) return false;

        array[i]++;
        for (int j = i + 1; j < r; j++)
        {
            array[j] = array[j - 1] + 1;
        }

        return true;
    }

    public static bool nextPermutation<T>(T[] array, int start, int length) where T : IComparable<T>
    {
        int end = start + length - 1;

        if (end <= start) return false;

        int last = end;
        while (true)
        {
            int pos = last--;
            
            if (array[last].CompareTo(array[pos]) < 0)
            {
                int i;
                for (i = end + 1; array[last].CompareTo(array[--i]) >= 0; ) { }
                T tmp = array[last]; array[last] = array[i]; array[i] = tmp;
                Array.Reverse(array, pos, end - pos + 1);
                return true;
            }
            if (last == start)
            {
                Array.Reverse(array, start, end - start);
                return false;
            }
        }

        throw new Exception("NextPermutation: Fatal error");
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static bool chmax<T> (ref T target, T value) where T : struct, IComparisonOperators<T, T, bool>
    {
        if (value > target)
        {
            target = value;
            return true;
        }
        return false;
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static bool chmin<T>(ref T target, T value) where T : struct, IComparisonOperators<T, T, bool>
    {
        if (value < target)
        {
            target = value;
            return true;
        }
        return false;
    }

    public static ReadOnlySpan<T> spanOf<T>(List<T> list)
    {
        return CollectionsMarshal.AsSpan(list);
    }

    public static int lowerBound<T>(T[] array, int start, int end, T value) where T : struct, IComparisonOperators<T, T, bool>
    { 
        int low = start;
        int high = end;
        int mid;
        while (low < high)
        {
            mid = ((high - low) >> 1) + low;
            if (array[mid] < value)
                low = mid + 1;
            else
                high = mid;
        }

        if (low == array.Length - 1 && array[low] < value)
        {
            return array.Length;
        }
        return low;
    }

    public static int lowerBound<T>(List<T> array, int start, int end, T value) where T : struct, IComparisonOperators<T, T, bool>
    { 
        int low = start;
        int high = end;
        int mid;
        while (low < high)
        {
            mid = ((high - low) >> 1) + low;
            if (array[mid] < value)
                low = mid + 1;
            else
                high = mid;
        }

        if (low == array.Count - 1 && array[low] < value)
        {
            return array.Count;
        }
        return low;
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void swap<T>(ref T a, ref T b) where T : struct
    {
        T temp = a;
        a = b;
        b = temp;
    }

    public static int[] compressCoords<T>(T[] a) where T : struct, IComparisonOperators<T, T, bool>
    {
        T[] b = a.OrderBy(x => x).Distinct().ToArray();
        int[] result = new int[a.Length];

        for (int i = 0; i < a.Length; i++)
        {
            result[i] = lowerBound(b, 0, b.Length - 1, a[i]);
        }

        return result;
    }

    public static List<RunLengthElement<T>> compressRunLength<T>(T[] array) where T : struct, IEquatable<T>
    {
        List<RunLengthElement<T>> list = new List<RunLengthElement<T>>();

        int count = 1;
        int start = 0;
        T prev = array[0];

        for (int i = 1; i < array.Length; i++)
        {
            if (prev.Equals(array[i]))
            {
                count++;
            }
            else
            {
                list.Add(new RunLengthElement<T>(start, count, prev));
                start = i;
                count = 1;
            }

            prev = array[i];
        }

        list.Add(new RunLengthElement<T>(start, count, prev));

        return list;
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void print<T>(IEnumerable<T> array, char delimiter = ' ')
    {
        Console.WriteLine(string.Join(delimiter, array));
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void fprint<T>(IEnumerable<T> array, char delimiter = ' ')
    {
        print(array);
        Console.Out.Flush();
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void print(string msg)
    {
        Console.WriteLine(msg);
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void fprint(string msg)
    {
        Console.WriteLine(msg);
        Console.Out.Flush();
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void print(int val)
    {
        print(val.ToString());
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void print(long val)
    {
        print(val.ToString());
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void print<T>(ModInt<T> val) where T : struct, IMod
    {
        print(val.ToString());
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void fprint(int val)
    {
        print(val.ToString());
        Console.Out.Flush();
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void fprint(long val)
    {
        print(val.ToString());
        Console.Out.Flush();
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void fprint<T>(ModInt<T> val) where T : struct, IMod
    {
        fprint(val.ToString());
        Console.Out.Flush();
    }

    public static void print<T>(T[,] grid)
    {
        for (int y = 0; y < grid.GetLength(0); y++)
        {
            for (int x = 0; x < grid.GetLength(1); x++)
            {
                Console.Write(grid[y, x] + "\t");
            }
            Console.WriteLine();
        }
    }

    public static void print01(bool t)
    {
        Console.WriteLine(t ? "1" : "0");
    }

    public static TSrc lowerBoundKth<TSrc, TCnt>(TSrc min, TSrc max, Func<TSrc, TCnt> f, TCnt bound)
        where TSrc: struct, INumber<TSrc> where TCnt: struct, INumber<TCnt>
    {
        TSrc left = min;
        TSrc right = max;
        TSrc two = TSrc.CreateChecked(2);
        TSrc one = TSrc.CreateChecked(1);
        while (right > left)
        {
            TSrc mid = left + (right - left) / two;
            TCnt c = f(mid);
            if (c < bound)
            {
                left = mid + one;
            }
            else
            {
                right = mid;
            }
        }

        return left;
    }

    public static bool isSquareNumber(long n)
    {
        long q = (long)Math.Floor(Math.Sqrt(n));
        return q * q == n;
    }

    public static T[][] makeDPTable2D<T>(int length1, int length2, T value)
    {
        bool fill = !default(T).Equals(value);
        T[][] table = new T[length1][];
        for (int i = 0; i < length1; i++)
        {
            table[i] = new T[length2];
            if (fill)
            {
                Array.Fill(table[i], value);
            }
        }

        return table;
    }

    public static T[][][] makeDPTable3D<T>(int length1, int length2, int length3, T value)
    {
        bool fill = !default(T).Equals(value);
        T[][][] table = new T[length1][][];
        for (int i = 0; i < length1; i++)
        {
            table[i] = new T[length2][];
            for (int j = 0; j < length2; j++)
            {
                table[i][j] = new T[length3];
                if (fill)
                {
                    Array.Fill(table[i][j], value);
                }
            }
        }

        return table;
    }
}

public readonly struct RunLengthElement<T> where T : struct
{
    public readonly int Count;
    public readonly int StartIndex;
    public readonly T Value;

    public RunLengthElement(int startIndex, int count, T value)
    {
        this.StartIndex = startIndex;
        this.Count = count;
        this.Value = value;
    }
}

/// <summary>
/// 自動でmodをとる整数。必要ないならあんまり使いすぎないように。
/// パフォーマンスはあまり良くないかもしれない。
/// </summary>
/// <typeparam name="T"></typeparam>
public readonly struct ModInt<T> : INumber<ModInt<T>>
                                    where T : struct, IMod
{
    public static long Mod => _mod.Mod;

    private static readonly T _mod = default;

    public readonly long Value;

    /// <summary>
    /// 1を返す。計算量: O(1)
    /// </summary>
    public static ModInt<T> One { get; } = CreateFast(1L);

    /// <summary>
    /// 0を返す。計算量: O(1)
    /// </summary>
    public static ModInt<T> Zero { get; } = CreateFast(0L);

    public static int Radix => 10;
    public static ModInt<T> MinValue => CreateFast(0L);
    public static ModInt<T> MaxValue => CreateFast(_mod.Mod - 1);

    /// <summary>
    /// 加法単位元つまり0を返す。計算量: O(1)
    /// </summary>
    public static ModInt<T> AdditiveIdentity { get; } = CreateFast(0L);
    public static ModInt<T> MultiplicativeIdentity { get; } = CreateFast(1L);

    public ModInt(long value)
    {
        Value = SafeMod(value);
    }

    private ModInt(long value, bool dummy)
    {
        Value = value;
    }

    /// <summary>
    /// modintを構築する。0 <= value < MODのとき限定。速いはず。計算量: O(1)
    /// </summary>
    /// <param name="value"></param>
    /// <returns></returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static ModInt<T> CreateFast(long value)
    {
        return new ModInt<T>(value, false);
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private static long SafeMod(long a)
    {
        return a % _mod.Mod + ((a >> 63) & _mod.Mod);
    }

    /// <summary>
    /// exp乗を計算する。計算量: O(log(exp))
    /// </summary>
    /// <param name="exp"></param>
    /// <returns></returns>
    public readonly ModInt<T> Power(long exp)
    {
        if (exp < 0)
        {
            return Power(-exp).Inv();
        }
        else
        {
            long res = 1L;
            long b = Value;
            while (exp > 0)
            {
                if ((exp & 1) == 1) res = res * b % _mod.Mod;
                b = b * b % _mod.Mod;
                exp >>= 1;
            }

            return CreateFast(res);
        }
    }

    /// <summary>
    /// 乗法逆元を返す。0は渡さない。計算量: O(logN)
    /// </summary>
    /// <returns></returns>
    public readonly ModInt<T> Inv()
    {
        long x = 1, y = 0;
        long x1 = 0, y1 = 1;
        long b = _mod.Mod;
        long a = Value;

        while (b != 0)
        {
            long q = a / b;
            long t = a % b;
            a = b;
            b = t;

            long tx = x - q * x1;
            long ty = y - q * y1;
            x = x1;
            y = y1;
            x1 = tx;
            y1 = ty;
        }

        return new(x);
    }

    [MethodImpl(256)]
    public static ModInt<T> operator +(ModInt<T> left, ModInt<T> right) => CreateFast((left.Value + right.Value) % _mod.Mod);

    [MethodImpl(256)]
    public static ModInt<T> operator +(ModInt<T> self) => self;

    [MethodImpl(256)]
    public static ModInt<T> operator -(ModInt<T> left, ModInt<T> right) => CreateFast((left.Value - right.Value + _mod.Mod) % _mod.Mod);

    [MethodImpl(256)]
    public static ModInt<T> operator -(ModInt<T> self) => CreateFast(_mod.Mod - self.Value);

    [MethodImpl(256)]
    public static ModInt<T> operator *(ModInt<T> left, ModInt<T> right) => CreateFast(left.Value * right.Value % _mod.Mod);

    [MethodImpl(256)]
    public static ModInt<T> operator /(ModInt<T> left, ModInt<T> right)
    {
        if (right.Value == 0L)
        {
            throw new DivideByZeroException();
        }

        ModInt<T> inv = right.Inv();
        return CreateFast(left.Value * inv.Value % _mod.Mod);
    }

    public static ModInt<T> operator %(ModInt<T> left, ModInt<T> right)
    {
        throw new NotImplementedException();
    }

    public static bool operator <(ModInt<T> left, ModInt<T> right)
    {
        throw new NotImplementedException();
    }

    public static bool operator >(ModInt<T> left, ModInt<T> right)
    {
        throw new NotImplementedException();
    }

    public static bool operator <=(ModInt<T> left, ModInt<T> right)
    {
        throw new NotImplementedException();
    }

    public static bool operator >=(ModInt<T> left, ModInt<T> right)
    {
        throw new NotImplementedException();
    }

    [MethodImpl(256)]
    public static bool operator ==(ModInt<T> left, ModInt<T> right) => left.Value == right.Value;

    [MethodImpl(256)]
    public static bool operator !=(ModInt<T> left, ModInt<T> right) => !(left == right);

    [MethodImpl(256)]
    public static ModInt<T> operator ++(ModInt<T> self) => CreateFast((self.Value + 1) % _mod.Mod);

    [MethodImpl(256)]
    public static ModInt<T> operator --(ModInt<T> self) => CreateFast((self.Value - 1 + _mod.Mod) % _mod.Mod);

    [MethodImpl(256)]
    public bool Equals(ModInt<T> other) => Value == other.Value;

    [MethodImpl(256)]
    public override bool Equals(object other)
    {
        if (other is ModInt<T> m)
        {
            return this == m;
        }
        else return false;
    }

    [MethodImpl(256)]
    public override int GetHashCode() => Value.GetHashCode();

    [MethodImpl(256)]
    public static implicit operator ModInt<T>(long v) => new ModInt<T>(v);

    [MethodImpl(256)]
    public static implicit operator ModInt<T>(int v) => new ModInt<T>(v);

    [MethodImpl(256)]
    public static implicit operator long(in ModInt<T> m) => m.Value;

    [MethodImpl(256)]
    public static implicit operator int(in ModInt<T> m) => (int)m.Value;

    public override string ToString() => Value.ToString();

    public string ToString(string format, IFormatProvider provider) => Value.ToString(format, provider);

    #region INumberBase<TSelf> Implementation

    public static ModInt<T> Abs(ModInt<T> value) => value;
    public static bool IsCanonical(ModInt<T> value) => true;
    public static bool IsComplexNumber(ModInt<T> value) => false;
    public static bool IsFinite(ModInt<T> value) => true;
    public static bool IsImaginaryNumber(ModInt<T> value) => false;
    public static bool IsInfinity(ModInt<T> value) => false;
    public static bool IsInteger(ModInt<T> value) => true;
    public static bool IsNaN(ModInt<T> value) => false;
    public static bool IsNegative(ModInt<T> value) => false;
    public static bool IsPositive(ModInt<T> value) => value.Value != 0L;
    public static bool IsRealNumber(ModInt<T> value) => true;
    public static bool IsZero(ModInt<T> value) => value.Value == 0L;
    public static bool IsEvenInteger(ModInt<T> value) => (value.Value & 1) == 0;
    public static bool IsOddInteger(ModInt<T> value) => (value.Value & 1) == 1;
    public static bool IsPositiveInfinity(ModInt<T> value) => false;
    public static bool IsNegativeInfinity(ModInt<T> value) => false;
    public static bool IsNormal(ModInt<T> value) => false;
    public static bool IsSubnormal(ModInt<T> value) => false;


    public static ModInt<T> MaxMagnitude(ModInt<T> x, ModInt<T> y)
    {
        if (x.Value > y.Value) return x;
        else return y;
    }
    public static ModInt<T> MaxMagnitudeNumber(ModInt<T> x, ModInt<T> y) => MaxMagnitude(x, y);
    public static ModInt<T> MinMagnitude(ModInt<T> x, ModInt<T> y)
    {
        if (x.Value < y.Value) return x;
        else return y;
    }
    public static ModInt<T> MinMagnitudeNumber(ModInt<T> x, ModInt<T> y) => MinMagnitude(x, y);

    public static ModInt<T> CreateChecked<TOther>(TOther value) where TOther : INumberBase<TOther>
        => new(long.CreateChecked(value));
    public static ModInt<T> CreateSaturating<TOther>(TOther value) where TOther : INumberBase<TOther>
        => new(long.CreateSaturating(value));
    public static ModInt<T> CreateTruncating<TOther>(TOther value) where TOther : INumberBase<TOther>
        => new(long.CreateTruncating(value));

    public static ModInt<T> Parse(string s, NumberStyles style, IFormatProvider provider) => Parse(s.AsSpan(), style, provider);

    public static ModInt<T> Parse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider) => new(long.Parse(s, style, provider));

#if NET8_0_OR_GREATER
    public static ModInt<T> Parse(ReadOnlySpan<byte> s, NumberStyles style, IFormatProvider provider) => new(long.Parse(s, style, provider));
#endif

    public static ModInt<T> Parse(string s, IFormatProvider provider) => new(long.Parse(s, provider));

    public static ModInt<T> Parse(ReadOnlySpan<char> s, IFormatProvider provider) => new(long.Parse(s, provider));

#if NET8_0_OR_GREATER
    public bool TryFormat(Span<byte> dest, out int bytesWritten, ReadOnlySpan<char> format, IFormatProvider provider)
    {
        return Value.TryFormat(dest, out bytesWritten, format, provider);
    }
#endif

    public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider provider)
    {
        return Value.TryFormat(destination, out charsWritten, format, provider);
    }

    public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider, out ModInt<T> result)
    {
        if (long.TryParse(s, style, provider, out long inner))
        {
            result = new(inner);
            return true;
        }
        else
        {
            result = Zero;
            return false;
        }

    }

    public static bool TryParse(string s, NumberStyles style, IFormatProvider provider, out ModInt<T> result)
    {
        if (long.TryParse(s, style, provider, out long inner))
        {
            result = new(inner);
            return true;
        }
        else
        {
            result = Zero;
            return false;
        }
    }



    public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider provider, out ModInt<T> result)
    {
        if (long.TryParse(s, provider, out long inner))
        {
            result = new(inner);
            return true;
        }
        else
        {
            result = Zero;
            return false;
        }
    }

    public static bool TryParse(string s, IFormatProvider provider, out ModInt<T> result)
    {
        if (long.TryParse(s, provider, out long inner))
        {
            result = new(inner);
            return true;
        }
        else
        {
            result = Zero;
            return false;
        }
    }

    public static bool TryConvertFromChecked<TOther>(TOther value, out ModInt<T> result) where TOther : INumberBase<TOther>
    {
        throw new NotImplementedException();
    }

    public static bool TryConvertFromSaturating<TOther>(TOther value, out ModInt<T> result) where TOther : INumberBase<TOther>
    {
        throw new NotImplementedException();
    }

    public static bool TryConvertFromTruncating<TOther>(TOther value, [MaybeNullWhen(false)] out ModInt<T> result) where TOther : INumberBase<TOther>
    {
        throw new NotImplementedException();
    }

    public static bool TryConvertToChecked<TOther>(ModInt<T> value, [MaybeNullWhen(false)] out TOther result) where TOther : INumberBase<TOther>
    {
        throw new NotImplementedException();
    }

    public static bool TryConvertToSaturating<TOther>(ModInt<T> value, [MaybeNullWhen(false)] out TOther result) where TOther : INumberBase<TOther>
    {
        throw new NotImplementedException();
    }

    public static bool TryConvertToTruncating<TOther>(ModInt<T> value, [MaybeNullWhen(false)] out TOther result) where TOther : INumberBase<TOther>
    {
        throw new NotImplementedException();
    }


    #endregion

    #region INumber<TSelf> Implementation

    public int CompareTo(ModInt<T> other) => Value.CompareTo(other.Value);
    public int CompareTo(object other) => Value.CompareTo(other);
    

    #endregion
}

/// <summary>
/// 法を指定するやつ。
/// </summary>
public interface IMod
{
    public long Mod { get; }
}

public readonly struct Mod998244353 : IMod { public long Mod => 998244353L; }
public readonly struct Mod1000000007 : IMod { public long Mod => 1000000007L; }
public readonly struct Mod897581057 : IMod { public long Mod => 897581057; }
public readonly struct Mod880803841 : IMod { public long Mod => 880803841; }