結果

問題 No.2600 Avator Height
ユーザー crimsontea
提出日時 2024-01-12 21:37:51
言語 C#
(.NET 8.0.404)
結果
AC  
実行時間 165 ms / 2,000 ms
コード長 28,443 bytes
コンパイル時間 10,458 ms
コンパイル使用メモリ 171,036 KB
実行使用メモリ 218,456 KB
最終ジャッジ日時 2024-09-27 21:35:13
合計ジャッジ時間 17,158 ms
ジャッジサーバーID
（参考情報） 		judge2 / judge1
このコードへのチャレンジ
（要ログイン）
ファイルパターン 結果
sample AC * 1
other AC * 25
権限があれば一括ダウンロードができます
コンパイルメッセージ
  復元対象のプロジェクトを決定しています...
  /home/judge/data/code/main.csproj を復元しました (104 ms)。
MSBuild のバージョン 17.9.6+a4ecab324 (.NET)
/home/judge/data/code/Main.cs(55,32): warning CS8632: '#nullable' 注釈コンテキスト内のコードでのみ、Null 許容参照型の注釈を使用する必要があります。 [/home/judge/data/code/main.csproj]
/home/judge/data/code/Main.cs(56,30): warning CS8632: '#nullable' 注釈コンテキスト内のコードでのみ、Null 許容参照型の注釈を使用する必要があります。 [/home/judge/data/code/main.csproj]
  main -> /home/judge/data/code/bin/Release/net8.0/main.dll
  main -> /home/judge/data/code/bin/Release/net8.0/publish/

ソースコード

diff #
プレゼンテーションモードにする

using A;
using AtCoder.Internal;
using ModInt = AtCoder.StaticModInt<AtCoder.Mod998244353>;
using System;
using System.Buffers;
using System.Collections;
using System.Diagnostics;
using System.Globalization;
using System.Numerics;
using System.Runtime.CompilerServices;
using System.Runtime.Intrinsics.X86;
using static A.InputUtility;
class Program
{
    static void Main()
    {
        SourceExpander.Expander.Expand();
        using Output output = new(false);
        ModInt[] r = new ModInt[200001];
        r[0] = 1;
        r[1] = 1;
        for (int i = 2; i < r.Length; i++)
        {
            r[i] = r[i - 1] + r[i - 2];
        }
        ModInt[] e = new ModInt[200001];
        e[0] = 1;
        e[1] = 3;
        for (int i = 2; i < e.Length; i++)
        {
            e[i] = e[i - 1] + e[i - 2];
        }
        InputNewLine();
        var q = NextInt32;
        for (int _ = 0; _ < q; _++)
        {
            InputNewLine();
            var n = NextInt32 - 1;
            var res = 5 * r[n] * r[n] - e[n] * e[n];
            Console.WriteLine(res);
        }
    }
}
namespace A
{
    public static class InputUtility
    {
        private static string[]? s_inputs;
        private static string? s_raw;
        private static int s_index = 0;
        private static void Init() => s_index = 0;
        public static int NextInt32 => int.Parse(s_inputs![s_index++]!);
        public static uint NextUInt32 => uint.Parse(s_inputs![s_index++]!);
        public static long NextInt64 => long.Parse(s_inputs![s_index++]!);
        public static string NextString => s_inputs![s_index++];
        public static char NextChar => s_inputs![s_index++][0];
        public static decimal NextDecimal => decimal.Parse(s_inputs![s_index++]!);
        public static BigInteger NextBigInteger => BigInteger.Parse(s_inputs![s_index++]!);
        public static int[] GetInt32Array() => s_inputs!.Select(int.Parse).ToArray();
        public static long[] GetInt64Array() => s_inputs!.Select(long.Parse).ToArray();
        public static string GetRawString() => s_raw!;
#if DEBUG
        private static TextReader? s_textReader;
        public static void SetSource(string path) => s_textReader = new StringReader(File.ReadAllText(path));
#endif
        public static bool InputNewLine()
        {
#if DEBUG
            if (s_textReader is TextReader sr)
            {
                Init();
                s_raw = sr.ReadLine()!;
                s_inputs = s_raw.Split(' ', StringSplitOptions.RemoveEmptyEntries);
                return true;
            }
#endif
            Init();
            s_raw = Console.ReadLine()!;
            s_inputs = s_raw.Split(' ', StringSplitOptions.RemoveEmptyEntries);
            return true;
        }
    }
    public static class CombinationFunction
    {
        public static void PartedRotate<T>(T[] a, int first1, int last1, int first2, int last2)
        {
            if (first1 == last1 || first2 == last2) return;
            int next = first2;
            while (first1 != next)
            {
                Swap(a, first1++, next++);
                if (first1 == last1) first1 = first2;
                if (next == last2)
                {
                    next = first2;
                }
                else if (first1 == first2)
                {
                    first2 = next;
                }
            }
        }
        public static bool NextCombinationImp<T>(T[] a, int first1, int last1, int first2, int last2) where T : IComparable<T>
        {
            if (first1 == last1 || first2 == last2) return false;
            int target = last1 - 1;
            int lastElem = last2 - 1;
            while (target != first1 && !(a[target].CompareTo(a[lastElem]) < 0)) target--;
            if (target == first1 && !(a[target].CompareTo(a[lastElem]) < 0))
            {
                PartedRotate(a, first1, last1, first2, last2);
                return false;
            }
            int next = first2;
            while (!(a[target].CompareTo(a[next]) < 0)) next++;
            Swap(a, target++, next++);
            PartedRotate(a, target, last1, next, last2);
            return true;
        }
        public static bool NextCombination<T>(T[] a, int first, int mid, int last) where T : IComparable<T>
            => NextCombinationImp(a, first, mid, mid, last);
        public static bool PrevCombination<T>(T[] a, int first, int mid, int last) where T : IComparable<T>
            => NextCombinationImp(a, mid, last, first, mid);
        public static void Swap<T>(T[] a, int i, int j) => (a[i], a[j]) = (a[j], a[i]);
    }
    public static class PermutationFunction
    {
        public static bool NextPermutation<T>(T[] a) where T : IComparable<T>
        {
            int n = a.Length;
            int i = n - 2;
            while (i >= 0 && a[i].CompareTo(a[i + 1]) >= 0) { i--; }
            if (i < 0) { return false; }
            int j = n - 1;
            while (a[j].CompareTo(a[i]) <= 0) { j--; }
            (a[i], a[j]) = (a[j], a[i]);
            Array.Reverse(a, i + 1, n - i - 1);
            return true;
        }
    }
    public readonly struct Output : IDisposable
    {
        private readonly StreamWriter _sw;
#if DEBUG
        public Output(string path)
        {
            var fs = new FileStream(path, FileMode.Create, FileAccess.Write);
            _sw = new StreamWriter(fs);
            Console.SetOut(_sw);
        }
#endif
        public Output(bool autoFlush)
        {
            _sw = new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = autoFlush };
            Console.SetOut(_sw);
        }
        public void Dispose()
        {
            _sw.Dispose();
        }
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        internal void Flush()
        {
            _sw.Flush();
        }
    }
    public static class ArrayExtensions
    {
        public static void Swap<T>(this T[] array, int i, int j) => (array[i], array[j]) = (array[j], array[i]);
        public static int LowerBound<T>(this T[] a, T target) where T : IComparable<T>
        {
            int ok = a.Length;
            int ng = -1;
            while (Math.Abs(ok - ng) > 1 && (ok + ng) / 2 is int mid)
                (ok, ng) = a[mid].CompareTo(target) >= 0 ? (mid, ng) : (ok, mid);
            return ok;
        }
        public static int UpperBound<T>(this T[] a, T target) where T : IComparable<T>
        {
            int ok = a.Length;
            int ng = -1;
            while (Math.Abs(ok - ng) > 1 && (ok + ng) / 2 is int mid)
                (ok, ng) = a[mid].CompareTo(target) > 0 ? (mid, ng) : (ok, mid);
            return ok;
        }
        public static ModInt Sum(this ModInt[] a)
        {
            long res = 0;
            foreach (var item in a)
                res += item.Value;
            return new ModInt(res);
        }
        public struct IndexedEnumerable<T> : IEnumerable<(T item, int index)>
        {
            private readonly T[] _a;
            private readonly int _startIndex;
            public IndexedEnumerable(T[] a, int startIndex = 0)
            {
                _a = a;
                _startIndex = startIndex;
            }
            public readonly IndexedEnumerator<T> GetEnumerator() => new IndexedEnumerator<T>(_a, _startIndex);
            IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
            IEnumerator<(T item, int index)> IEnumerable<(T item, int index)>.GetEnumerator() => GetEnumerator();
        }
        public struct IndexedEnumerator<T> : IEnumerator<(T item, int index)>
        {
            public readonly (T item, int index) Current => (_a[_index], _index + _startIndex);
            private int _index;
            private int _startIndex;
            private T[] _a;
            public IndexedEnumerator(T[] a, int startIndex)
            {
                _index = -1;
                _a = a;
                _startIndex = startIndex;
            }
            public bool MoveNext() => ++_index < _a.Length;
            readonly object IEnumerator.Current => Current;
            public readonly void Dispose() { }
            public void Reset() => _index = -1;
        }
        /// <returns>(T value, int index)</returns>
        public static IndexedEnumerable<T> Enumerate<T>(this T[] arr, int startIndex = 0) => new IndexedEnumerable<T>(arr, startIndex);
    }
    public static class IEnumerableExtensions
    {
        public static IEnumerable<TSource> Log<TSource>(this IEnumerable<TSource> source)
        {
            Console.WriteLine(string.Join(' ', source));
            return source;
        }
        public static ScanEnumerable<TSource, TAccumulate> Scan<TSource, TAccumulate>(
            this IEnumerable<TSource> source,
            TAccumulate seed,
        Func<TAccumulate, TSource, TAccumulate> accumulator) where TSource : struct where TAccumulate : struct
        {
            return new ScanEnumerable<TSource, TAccumulate>(source, accumulator, seed);
        }
        public static IEnumerable<TAccumulate> ScanExSeed<TSource, TAccumulate>(
            this IEnumerable<TSource> source,
            TAccumulate seed,
            Func<TAccumulate, TSource, TAccumulate> accumulator)
        {
            var accumulation = new List<TAccumulate>();
            var current = seed;
            foreach (var item in source)
            {
                current = accumulator(current, item);
                accumulation.Add(current);
            }
            return accumulation;
        }
        public readonly struct ScanEnumerable<TSource, TAccumulate> : IEnumerable<TAccumulate> where TSource : struct where TAccumulate : struct
        {
            private readonly IEnumerable<TSource> _source;
            private readonly Func<TAccumulate, TSource, TAccumulate> _accumulator;
            private readonly TAccumulate _seed;
            public ScanEnumerable(IEnumerable<TSource> source, Func<TAccumulate, TSource, TAccumulate> accumulator, TAccumulate seed)
            {
                _source = source;
                _accumulator = accumulator;
                _seed = seed;
            }
            public readonly ScanEnumerator<TSource, TAccumulate> GetEnumerator() => new(_source, _accumulator, _seed);
            readonly IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
            readonly IEnumerator<TAccumulate> IEnumerable<TAccumulate>.GetEnumerator() => GetEnumerator();
        }
        public struct ScanEnumerator<TSource, TAccumulate> : IEnumerator<TAccumulate> where TSource : struct where TAccumulate : struct
        {
            private readonly Func<TAccumulate, TSource, TAccumulate> _accumulator;
            private readonly IEnumerator<TSource> _enumerator;
            private TAccumulate _current;
            private bool _secondOrLaterElement = false;
            public ScanEnumerator(IEnumerable<TSource> source, Func<TAccumulate, TSource, TAccumulate> accumulator, TAccumulate seed)
            {
                _enumerator = source.GetEnumerator();
                _accumulator = accumulator;
                _current = seed;
            }
            public readonly TAccumulate Current => _current;
            readonly object IEnumerator.Current => Current;
            public readonly void Dispose() { }
            public bool MoveNext()
            {
                if (_secondOrLaterElement)
                {
                    if (_enumerator.MoveNext())
                    {
                        _current = _accumulator(_current, _enumerator.Current);
                        return true;
                    }
                    return false;
                }
                else
                {
                    _secondOrLaterElement = true;
                    return true;
                }
            }
            public void Reset()
            {
                throw new NotSupportedException();
            }
        }
        public static IEnumerable<TSource> Scan<TSource>(
            this IEnumerable<TSource> source,
            Func<TSource, TSource, TSource> accumulator)
        {
            if (source is null)
                throw new ArgumentNullException(paramName: nameof(source));
            if (accumulator is null)
                throw new ArgumentNullException(paramName: nameof(accumulator));
            var accumulation = new List<TSource>();
            if (source.Any() is false)
            {
                return accumulation;
            }
            var current = source.First();
            accumulation.Add(current);
            foreach (var item in source.Skip(1))
            {
                current = accumulator(current, item);
                accumulation.Add(current);
            }
            return accumulation;
        }
        public static CombinationEnumerable<T> Combination<T>(this T[] a, int k) where T : IComparable<T>
            => new(a, k);
        public readonly struct CombinationEnumerable<T> where T : IComparable<T>
        {
            private readonly T[] _a;
            private readonly int _k;
            public CombinationEnumerable(T[] a, int k)
            {
                _a = a;
                _k = k;
            }
            public readonly CombinationEnumerator<T> GetEnumerator() => new(_a, _k);
        }
        public struct CombinationEnumerator<T> : IEnumerator<ReadOnlyMemory<T>> where T : IComparable<T>
        {
            private readonly int _k;
            private readonly T[] _a;
            private readonly int _n;
            private bool _secondOrLaterElement = false;
            public CombinationEnumerator(T[] a, int k)
            {
                _a = a;
                _n = a.Length;
                _k = k;
            }
            public readonly ReadOnlyMemory<T> Current => _a.AsMemory()[.._k];
            readonly object IEnumerator.Current => Current;
            public readonly void Dispose() { }
            public bool MoveNext()
            {
                if (_secondOrLaterElement)
                {
                    return CombinationFunction.NextCombination(_a, 0, _k, _n);
                }
                else
                {
                    _secondOrLaterElement = true;
                    return true;
                }
            }
            public void Reset()
            {
                throw new NotSupportedException();
            }
        }
        public static PermutationEnumerable<T> Permutation<T>(this T[] a) where T : IComparable<T> => new(a);
        public readonly struct PermutationEnumerable<T> where T : IComparable<T>
        {
            private readonly T[] _a;
            public PermutationEnumerable(T[] a) => _a = a;
            public readonly PermutationEnumerator<T> GetEnumerator() => new(_a);
        }
        public struct PermutationEnumerator<T> : IEnumerator<ReadOnlyMemory<T>> where T : IComparable<T>
        {
            private readonly T[] _a;
            private readonly int _n;
            private bool _secondOrLaterElement = false;
            public PermutationEnumerator(T[] a)
            {
                _a = a;
                _n = a.Length;
            }
            public readonly ReadOnlyMemory<T> Current => _a.AsMemory()[..];
            readonly object IEnumerator.Current => Current;
            public readonly void Dispose() { }
            public bool MoveNext()
            {
                if (_secondOrLaterElement)
                {
                    return PermutationFunction.NextPermutation(_a);
                }
                else
                {
                    _secondOrLaterElement = true;
                    return true;
                }
            }
            public void Reset() => throw new NotSupportedException();
        }
    }
    public class MyMath
    {
        public static long Pow(long x, int y) => Enumerable.Repeat(x, y).Aggregate(1L, (acc, x) => acc * x);
        public static long Pow10(int y) => Pow(10, y);
        public static long Pow2(int y) => Pow(2, y);
    }
    public class MyMathBigInteger
    {
        public static BigInteger Pow(long x, int y) => Enumerable.Repeat(x, y).Aggregate(new BigInteger(1), (acc, x) => acc * x);
        public static BigInteger Pow10(int y) => Pow(10, y);
        public static BigInteger Pow2(int y) => Pow(2, y);
    }
}
#region Expanded by https://github.com/kzrnm/SourceExpander
namespace AtCoder.Internal{public class Barrett{public readonly uint Mod;public readonly ulong IM;public Barrett(uint m){Mod=m;IM=unchecked((ulong)-1
    )/m+1;}[MethodImpl(256)]public uint Mul(uint a,uint b)=>Reduce((ulong)a*b);[MethodImpl(256)]public uint Reduce(ulong z){var x=Mul128.Mul128Bit(z
    ,IM);var y=x*Mod;if(z<y)return(uint)(z-y+Mod);return(uint)(z-y);}[MethodImpl(256)]public uint Pow(long x,long n){return Pow(x,(ulong)n
    );}[MethodImpl(256)]public uint Pow(long x,ulong n){if(Mod==1)return 0;uint r=1,y=(uint)ModCalc.SafeMod(x,Mod);while(n>0){if((n&1)!=0)r=Mul(r,y
    );y=Mul(y,y);n>>=1;}return r;}}}
namespace AtCoder.Internal{public static class Mul128{[MethodImpl(256)]public static ulong Mul128Bit(ulong a,ulong b){if(Bmi2.X64.IsSupported)return 
    Bmi2.X64.MultiplyNoFlags(a,b);return Mul128BitLogic(a,b);}[MethodImpl(256)]internal static ulong Mul128BitLogic(ulong a,ulong b){var au=a>>32;var 
    ad=a&0xFFFFFFFF;var bu=b>>32;var bd=b&0xFFFFFFFF;var l=ad*bd;var m1=au*bd;var m2=ad*bu;var h=au*bu;var lu=l>>32;var m1d=m1&0xFFFFFFFF;var m2d
    =m2&0xFFFFFFFF;var c=m1d+m2d+lu;return h+(m1>>32)+(m2>>32)+(c>>32);}}}
namespace AtCoder.Internal{public static class ModCalc{[MethodImpl(256)]public static long InvMod(long x,long m){var(g,res)=InvGcd(x,m);return res
    ;}[MethodImpl(256)]public static(long,long)InvGcd(long a,long b){a=SafeMod(a,b);if(a==0)return(b,0);long s=b,t=a;long m0=0,m1=1;long u;while(true
    ){if(t==0){if(m0<0)m0+=b/s;return(s,m0);}u=s/t;s-=t*u;m0-=m1*u;if(s==0){if(m1<0)m1+=b/t;return(t,m1);}u=t/s;t-=s*u;m1-=m0*u;}}[MethodImpl(256
    )]public static long SafeMod(long x,long m){x%=m;if(x<0)x+=m;return x;}[MethodImpl(256)]public static uint PowMod(long x,long n,int m){if(m==1
    )return 0;return new Barrett((uint)m).Pow(x,n);}[MethodImpl(256)]public static(long y,long z)Crt(long[]r,long[]m){long r0=0,m0=1;for(int i=0;i<m
    .Length;i++){long r1=SafeMod(r[i],m[i]);long m1=m[i];if(m0<m1){(r0,r1)=(r1,r0);(m0,m1)=(m1,m0);}if(m0%m1==0){if(r0%m1!=r1)return(0,0);continue
    ;}var(g,im)=InvGcd(m0,m1);long u1=(m1/g);if((r1-r0)%g!=0)return(0,0);long x=(r1-r0)/g%u1*im%u1;r0+=x*m0;m0*=u1;if(r0<0)r0+=m0;}return(r0,m0);}}}
namespace AtCoder{public interface IModInt<T>:INumberBase<T>where T:INumberBase<T>{T Inv();T Pow(ulong n);int Value{get;}abstract static int Mod{get
    ;}}public interface IStaticMod{uint Mod{get;}bool IsPrime{get;}}public readonly struct Mod1000000007:IStaticMod{public uint Mod=>1000000007
    ;public bool IsPrime=>true;}public readonly struct Mod998244353:IStaticMod{public uint Mod=>998244353;public bool IsPrime=>true;}}
namespace AtCoder{public readonly struct StaticModInt<T>:IEquatable<StaticModInt<T>>,IFormattable,IModInt<StaticModInt<T>>where T:struct
    ,IStaticMod{internal readonly uint _v;private static readonly T op=default;public int Value=>(int)_v;public static int Mod=>(int)op.Mod;public 
    static StaticModInt<T>Zero=>default;public static StaticModInt<T>One=>new StaticModInt<T>(1u);[MethodImpl(256)]public static StaticModInt<T>Raw
    (int v){var u=unchecked((uint)v);return new StaticModInt<T>(u);}[MethodImpl(256)]public StaticModInt(long v):this((uint)ModCalc.SafeMod(v,op.Mod
    )){}[MethodImpl(256)]public StaticModInt(ulong v):this((uint)(v%op.Mod)){}[MethodImpl(256)]private StaticModInt(uint v)=>_v=v;[MethodImpl(256
    )]public static StaticModInt<T>operator ++(StaticModInt<T>v){var x=v._v+1;if(x==op.Mod){x=0;}return new StaticModInt<T>(x);}[MethodImpl(256
    )]public static StaticModInt<T>operator --(StaticModInt<T>v){var x=v._v;if(x==0){x=op.Mod;}return new StaticModInt<T>(x-1);}[MethodImpl(256
    )]public static StaticModInt<T>operator+(StaticModInt<T>lhs,StaticModInt<T>rhs){var v=lhs._v+rhs._v;if(v>=op.Mod){v-=op.Mod;}return new 
    StaticModInt<T>(v);}[MethodImpl(256)]public static StaticModInt<T>operator-(StaticModInt<T>lhs,StaticModInt<T>rhs){unchecked{var v=lhs._v-rhs._v
    ;if(v>=op.Mod){v+=op.Mod;}return new StaticModInt<T>(v);}}[MethodImpl(256)]public static StaticModInt<T>operator*(StaticModInt<T>lhs,StaticModInt
    <T>rhs)=>new StaticModInt<T>((uint)((ulong)lhs._v*rhs._v%op.Mod));[MethodImpl(256)]public static StaticModInt<T>operator/(StaticModInt<T>lhs
    ,StaticModInt<T>rhs)=>lhs*rhs.Inv();[MethodImpl(256)]public static StaticModInt<T>operator+(StaticModInt<T>v)=>v;[MethodImpl(256)]public static 
    StaticModInt<T>operator-(StaticModInt<T>v)=>new StaticModInt<T>(v._v==0?0:op.Mod-v._v);[MethodImpl(256)]public static bool operator
    ==(StaticModInt<T>lhs,StaticModInt<T>rhs)=>lhs._v==rhs._v;[MethodImpl(256)]public static bool operator!=(StaticModInt<T>lhs,StaticModInt<T>rhs
    )=>lhs._v!=rhs._v;[MethodImpl(256)]public static implicit operator StaticModInt<T>(int v)=>new StaticModInt<T>(v);[MethodImpl(256)]public static 
    implicit operator StaticModInt<T>(uint v)=>new StaticModInt<T>((ulong)v);[MethodImpl(256)]public static implicit operator StaticModInt<T>(long v
    )=>new StaticModInt<T>(v);[MethodImpl(256)]public static implicit operator StaticModInt<T>(ulong v)=>new StaticModInt<T>(v);[MethodImpl(256
    )]public StaticModInt<T>Pow(long n){return Pow((ulong)n);}[MethodImpl(256)]public StaticModInt<T>Pow(ulong n){var x=this;var r=new StaticModInt<T
    >(1U);while(n>0){if((n&1)>0){r*=x;}x*=x;n>>=1;}return r;}[MethodImpl(256)]public StaticModInt<T>Inv(){if(op.IsPrime){return Pow(op.Mod-2
    );}else{var(g,x)=ModCalc.InvGcd(_v,op.Mod);return new StaticModInt<T>(x);}}public override string ToString()=>_v.ToString();public string 
    ToString(string format,IFormatProvider formatProvider)=>_v.ToString(format,formatProvider);public override bool Equals(object obj)=>obj is 
    StaticModInt<T>m&&Equals(m);[MethodImpl(256)]public bool Equals(StaticModInt<T>other)=>_v==other._v;public override int GetHashCode()=>_v
    .GetHashCode();public static bool TryParse(ReadOnlySpan<char>s,out StaticModInt<T>result){result=Zero;StaticModInt<T>ten=10u;s=s.Trim();bool 
    minus=false;if(s.Length>0&&s[0]=='-'){minus=true;s=s.Slice(1);}for(int i=0;i<s.Length;i++){var d=(uint)(s[i]-'0');if(d>=10)return false;result
    =result*ten+d;}if(minus)result=-result;return true;}public static StaticModInt<T>Parse(ReadOnlySpan<char>s){if(!TryParse(s,out var r))Throw
    ();return r;void Throw()=>throw new FormatException();}static int INumberBase<StaticModInt<T>>.Radix=>2;static StaticModInt<T>IAdditiveIdentity
    <StaticModInt<T>,StaticModInt<T>>.AdditiveIdentity=>default;static StaticModInt<T>IMultiplicativeIdentity<StaticModInt<T>,StaticModInt<T
    >>.MultiplicativeIdentity=>new StaticModInt<T>(1u);static StaticModInt<T>INumberBase<StaticModInt<T>>.Abs(StaticModInt<T>v)=>v;static bool 
    INumberBase<StaticModInt<T>>.IsCanonical(StaticModInt<T>v)=>true;static bool INumberBase<StaticModInt<T>>.IsComplexNumber(StaticModInt<T>v
    )=>false;static bool INumberBase<StaticModInt<T>>.IsRealNumber(StaticModInt<T>v)=>true;static bool INumberBase<StaticModInt<T>>.IsImaginaryNumber
    (StaticModInt<T>v)=>false;static bool INumberBase<StaticModInt<T>>.IsEvenInteger(StaticModInt<T>v)=>uint.IsEvenInteger(v._v);static bool 
    INumberBase<StaticModInt<T>>.IsOddInteger(StaticModInt<T>v)=>uint.IsOddInteger(v._v);static bool INumberBase<StaticModInt<T>>.IsFinite
    (StaticModInt<T>v)=>true;static bool INumberBase<StaticModInt<T>>.IsInfinity(StaticModInt<T>v)=>false;static bool INumberBase<StaticModInt<T
    >>.IsInteger(StaticModInt<T>v)=>true;static bool INumberBase<StaticModInt<T>>.IsPositive(StaticModInt<T>v)=>true;static bool INumberBase
    <StaticModInt<T>>.IsNegative(StaticModInt<T>v)=>false;static bool INumberBase<StaticModInt<T>>.IsPositiveInfinity(StaticModInt<T>v)=>false;static 
    bool INumberBase<StaticModInt<T>>.IsNegativeInfinity(StaticModInt<T>v)=>false;static bool INumberBase<StaticModInt<T>>.IsNormal(StaticModInt<T>v
    )=>v._v!=0;static bool INumberBase<StaticModInt<T>>.IsSubnormal(StaticModInt<T>v)=>false;static bool INumberBase<StaticModInt<T>>.IsZero
    (StaticModInt<T>v)=>v._v==0;static bool INumberBase<StaticModInt<T>>.IsNaN(StaticModInt<T>v)=>false;static StaticModInt<T>INumberBase
    <StaticModInt<T>>.MaxMagnitude(StaticModInt<T>x,StaticModInt<T>y)=>new StaticModInt<T>(uint.Max(x._v,y._v));static StaticModInt<T>INumberBase
    <StaticModInt<T>>.MaxMagnitudeNumber(StaticModInt<T>x,StaticModInt<T>y)=>new StaticModInt<T>(uint.Max(x._v,y._v));static StaticModInt<T
    >INumberBase<StaticModInt<T>>.MinMagnitude(StaticModInt<T>x,StaticModInt<T>y)=>new StaticModInt<T>(uint.Min(x._v,y._v));static StaticModInt<T
    >INumberBase<StaticModInt<T>>.MinMagnitudeNumber(StaticModInt<T>x,StaticModInt<T>y)=>new StaticModInt<T>(uint.Min(x._v,y._v));static StaticModInt
    <T>INumberBase<StaticModInt<T>>.Parse(ReadOnlySpan<char>s,NumberStyles style,IFormatProvider provider)=>Parse(s);static StaticModInt<T
    >INumberBase<StaticModInt<T>>.Parse(string s,NumberStyles style,IFormatProvider provider)=>Parse(s);static StaticModInt<T>ISpanParsable
    <StaticModInt<T>>.Parse(ReadOnlySpan<char>s,IFormatProvider provider)=>Parse(s);static StaticModInt<T>IParsable<StaticModInt<T>>.Parse(string s
    ,IFormatProvider provider)=>Parse(s);static bool ISpanParsable<StaticModInt<T>>.TryParse(ReadOnlySpan<char>s,IFormatProvider provider,out 
    StaticModInt<T>result)=>TryParse(s,out result);static bool IParsable<StaticModInt<T>>.TryParse(string s,IFormatProvider provider,out StaticModInt
    <T>result)=>TryParse(s,out result);static bool INumberBase<StaticModInt<T>>.TryParse(ReadOnlySpan<char>s,NumberStyles style,IFormatProvider 
    provider,out StaticModInt<T>result)=>TryParse(s,out result);static bool INumberBase<StaticModInt<T>>.TryParse(string s,NumberStyles style
    ,IFormatProvider provider,out StaticModInt<T>result)=>TryParse(s,out result);bool ISpanFormattable.TryFormat(Span<char>destination,out int 
    charsWritten,ReadOnlySpan<char>format,IFormatProvider provider)=>_v.TryFormat(destination,out charsWritten,format,provider);static bool 
    INumberBase<StaticModInt<T>>.TryConvertFromChecked<TOther>(TOther v,out StaticModInt<T>r){if(WrapChecked(v,out long l)){r=l;return true;}if
    (WrapChecked(v,out ulong u)){r=u;return true;}r=default;return false;}static bool INumberBase<StaticModInt<T>>.TryConvertFromSaturating<TOther
    >(TOther v,out StaticModInt<T>r){if(WrapSaturating(v,out long l)){r=l;return true;}if(WrapSaturating(v,out ulong u)){r=u;return true;}r=default
    ;return false;}static bool INumberBase<StaticModInt<T>>.TryConvertFromTruncating<TOther>(TOther v,out StaticModInt<T>r){if(WrapTruncating(v,out 
    long l)){r=l;return true;}if(WrapTruncating(v,out ulong u)){r=u;return true;}r=default;return false;}static bool INumberBase<StaticModInt<T
    >>.TryConvertToChecked<TOther>(StaticModInt<T>v,out TOther r)where TOther:default=>WrapChecked(v._v,out r);static bool INumberBase<StaticModInt<T
    >>.TryConvertToSaturating<TOther>(StaticModInt<T>v,out TOther r)where TOther:default=>WrapSaturating(v._v,out r);static bool INumberBase
    <StaticModInt<T>>.TryConvertToTruncating<TOther>(StaticModInt<T>v,out TOther r)where TOther:default=>WrapTruncating(v._v,out r);[MethodImpl(256
    )]static bool WrapChecked<TFrom,TTo>(TFrom v,out TTo r)where TFrom:INumberBase<TFrom>where TTo:INumberBase<TTo> =>typeof(TFrom)==typeof(TTo)?(r
    =(TTo)(object)v)is{}:TTo.TryConvertFromChecked(v,out r)||TFrom.TryConvertToChecked(v,out r);[MethodImpl(256)]static bool WrapSaturating<TFrom,TTo
    >(TFrom v,out TTo r)where TFrom:INumberBase<TFrom>where TTo:INumberBase<TTo> =>typeof(TFrom)==typeof(TTo)?(r=(TTo)(object)v)is{}:TTo
    .TryConvertFromSaturating(v,out r)||TFrom.TryConvertToSaturating(v,out r);[MethodImpl(256)]static bool WrapTruncating<TFrom,TTo>(TFrom v,out TTo 
    r)where TFrom:INumberBase<TFrom>where TTo:INumberBase<TTo> =>typeof(TFrom)==typeof(TTo)?(r=(TTo)(object)v)is{}:TTo.TryConvertFromTruncating(v,out 
    r)||TFrom.TryConvertToTruncating(v,out r);}}
namespace SourceExpander{public class Expander{[Conditional("EXP")]public static void Expand(string inputFilePath=null,string outputFilePath=null
    ,bool ignoreAnyError=true){}public static string ExpandString(string inputFilePath=null,bool ignoreAnyError=true){return "";}}}
#endregion Expanded by https://github.com/kzrnm/SourceExpander
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
0