public static void Solve()
{
var(N, K) = Scanner.Scan <long, long>();
mint answer = K;
if (N > 1)
{
answer *= K - 1;
}
if (N > 2)
{
answer *= mint.Power(K - 2, N - 2);
}
Console.WriteLine(answer);
}
public static void Solve()
{
var(N, K) = Scanner.Scan <int, int>();
mint answer = 0;
if (N <= K)
{
answer = ModuloMathematics.Combination(N, K % N);
}
else
{
answer = ModuloMathematics.Combination(N + K - 1, K);
}
Console.WriteLine(answer);
}
public static void Solve()
{
var(N, M, K, S, T, X) = Scanner.Scan <int, int, int, int, int, int>();
S--; T--; X--;
var G = new List <int> [N].Select(x => new List <int>()).ToArray();
for (var i = 0; i < M; i++)
{
var(u, v) = Scanner.Scan <int, int>();
u--; v--;
G[u].Add(v);
G[v].Add(u);
}
var dp = new mint[K + 1, N, 2];
dp[0, S, 0] = 1;
var used = new bool[K + 1, N, 2];
var queue = new Queue <(int U, int T, int X)>();
queue.Enqueue((S, 0, 0));
while (queue.Count > 0)
{
var(u, t, x) = queue.Dequeue();
if (t == K || used[t, u, x])
{
continue;
}
used[t, u, x] = true;
foreach (var v in G[u])
{
if (v == X)
{
dp[t + 1, v, x ^ 1] += dp[t, u, x];
queue.Enqueue((v, t + 1, x ^ 1));
}
else
{
dp[t + 1, v, x] += dp[t, u, x];
queue.Enqueue((v, t + 1, x));
}
}
}
var answer = dp[K, T, 0];
Console.WriteLine(answer);
}
public static void Solve()
{
var(N, K) = Scanner.Scan <int, int>();
var dp = new mint[N + 1, N * 2 + 1];
dp[1, 1] = 1;
for (var n = 2; n <= N; n++)
{
for (var k = n; k > 0; k--)
{
dp[n, k] = dp[n - 1, k - 1] + dp[n, k * 2];
}
}
Console.WriteLine(dp[N, K]);
}
public static void Solve()
{
var N = Scanner.Scan <int>();
var C = Scanner.ScanEnumerable <long>().ToArray();
Array.Sort(C);
mint answer = 1;
for (var i = 0; i < N; i++)
{
answer *= Math.Max(0, C[i] - i);
}
Console.WriteLine(answer);
}
public static void Solve()
{
var N = Scanner.Scan <int>();
var A = Scanner.ScanEnumerable <long>().Distinct().ToArray();
Array.Sort(A, (x, y) => x.CompareTo(y));
var prev = 0L;
mint answer = 1;
foreach (var a in A)
{
answer *= a - prev + 1;
prev = a;
}
Console.WriteLine(answer);
}
public static void Solve()
{
var(H, W) = Scanner.Scan <int, int>();
var G = new bool[H][];
for (var i = 0; i < H; i++)
{
var S = Scanner.Scan <string>();
G[i] = S.Select(x => x == '.').ToArray();
}
var dp = new mint[H, W];
var x = new mint[H, W];
var y = new mint[H, W];
var z = new mint[H, W];
dp[0, 0] = 1;
for (var i = 0; i < H; i++)
{
for (var j = 0; j < W; j++)
{
if (i == 0 && j == 0)
{
continue;
}
if (!G[i][j])
{
continue;
}
if (j > 0)
{
x[i, j] = x[i, j - 1] + dp[i, j - 1];
}
if (i > 0)
{
y[i, j] = y[i - 1, j] + dp[i - 1, j];
}
if (i > 0 && j > 0)
{
z[i, j] = z[i - 1, j - 1] + dp[i - 1, j - 1];
}
dp[i, j] = x[i, j] + y[i, j] + z[i, j];
}
}
Console.WriteLine(dp[H - 1, W - 1]);
}
public static void Solve()
{
var(N, M) = Scanner.Scan <int, int>();
if (M == 1)
{
Console.WriteLine(1); return;
}
mint answer = 1;
foreach (var v in Prime.GetFactors(M).Values)
{
answer *= EnumerationModulo.Combination(v + N - 1, N - 1);
}
Console.WriteLine(answer);
}
public static void Solve()
{
var(N, K) = Scanner.Scan <int, int>();
var G = new int[N][];
for (var i = 0; i < N; i++)
{
G[i] = Scanner.ScanEnumerable <int>().ToArray();
}
mint answer = 1;
var dsu1 = new DisjointSetUnion(N);
var dsu2 = new DisjointSetUnion(N);
for (var i = 0; i < N; i++)
{
for (var j = i + 1; j < N; j++)
{
var(ok1, ok2) = (true, true);
for (var k = 0; k < N; k++)
{
ok1 &= G[k][i] + G[k][j] <= K;
ok2 &= G[i][k] + G[j][k] <= K;
}
if (ok1)
{
dsu1.Merge(i, j);
}
if (ok2)
{
dsu2.Merge(i, j);
}
}
}
foreach (var group in dsu1.GetGroups())
{
answer *= EnumerationModulo.Factorial(group.Count());
}
foreach (var group in dsu2.GetGroups())
{
answer *= EnumerationModulo.Factorial(group.Count());
}
Console.WriteLine(answer);
}
public static void Solve()
{
var(H, W) = Scanner.Scan <int, int>();
var G = new char[H][];
for (var i = 0; i < H; i++)
{
G[i] = Scanner.Scan <string>().ToCharArray();
}
var HW = H + W - 2;
var rc = new int[HW + 1];
var bc = new int[HW + 1];
for (var i = 0; i < H; i++)
{
for (var j = 0; j < W; j++)
{
if (G[i][j] == 'R')
{
rc[i + j]++;
}
if (G[i][j] == 'B')
{
bc[i + j]++;
}
}
}
mint answer = 1;
for (var i = 0; i <= HW; i++)
{
if (rc[i] == 0 && bc[i] == 0)
{
answer *= 2;
}
if (rc[i] > 0 && bc[i] > 0)
{
answer = 0;
}
}
Console.WriteLine(answer);
}
public static void Solve()
{
var N = Scanner.Scan <int>();
var W = Scanner.ScanEnumerable <int>().ToArray();
var sum = W.Sum();
if (sum % 2 == 1)
{
Console.WriteLine(0); return;
}
var max = (N + 1) * 100;
var dp = new mint[N + 1, max + 1];
dp[0, 0] = 1;
for (var i = 0; i < N; i++)
{
for (var j = i; j >= 0; j--)
{
for (var k = 0; k <= sum; k++)
{
dp[j + 1, k + W[i]] += dp[j, k];
}
}
}
var fact = new mint[N + 1];
fact[0] = 1;
for (var i = 1; i <= N; i++)
{
fact[i] = fact[i - 1] * i;
}
var half = sum / 2;
mint answer = 0;
for (var i = 0; i <= N; i++)
{
answer += dp[i, half] * fact[i] * fact[N - i];
}
Console.WriteLine(answer);
}
public static void Solve()
{
var(N, M, K) = Scanner.Scan <int, int, int>();
var dp = new mint[N + 1, M + 10];
for (var j = 1; j <= M; j++)
{
dp[0, j] = 1;
}
for (var i = 0; i < N; i++)
{
var cum = new mint[M + 10];
for (var j = 1; j <= M; j++)
{
cum[j + 1] = cum[j] + dp[i, j];
}
for (var j = 1; j <= M; j++)
{
if (K > 0)
{
var l1 = 0;
var r1 = Math.Max(0, j - K) + 1;
var l2 = Math.Min(M + 1, j + K);
var r2 = M + 1;
dp[i + 1, j] += cum[r1] - cum[l1] + cum[r2] - cum[l2];
}
else
{
dp[i + 1, j] += cum[M + 1];
}
}
}
mint answer = 0;
for (var i = 1; i <= M; i++)
{
answer += dp[N - 1, i];
}
Console.WriteLine(answer);
}
public static void Solve()
{
var(N, L) = Scanner.Scan <int, int>();
var dp = new mint[N + 1];
dp[0] = 1;
for (var i = 1; i <= N; i++)
{
dp[i] += dp[i - 1];
if (i - L >= 0)
{
dp[i] += dp[i - L];
}
}
var answer = dp[N];
Console.WriteLine(answer);
}
public static void Solve()
{
var(N, K) = Scanner.Scan <int, int>();
var dp = new mint[K + 1];
mint answer = 0;
for (var k = K; k > 0; k--)
{
var sum = mint.Power(K / k, N);
for (var i = k + k; i <= K; i += k)
{
sum -= dp[i];
}
answer += sum * k;
dp[k] = sum;
}
Console.WriteLine(answer);
}
public static void Solve()
{
var(A, B, C, D) = Scanner.Scan <int, int, int, int>();
var dp = new mint[C + 1, D + 1];
dp[A, B] = 1;
for (var i = A; i <= C; i++)
{
for (var j = B; j <= D; j++)
{
dp[i, j] += dp[i - 1, j] * j;
dp[i, j] += dp[i, j - 1] * i;
dp[i, j] -= dp[i - 1, j - 1] * (i - 1) * (j - 1);
}
}
var answer = dp[C, D];
Console.WriteLine(answer);
}
public static void Solve()
{
var N = Scanner.Scan <long>();
var pow10 = new mint[N + 1];
for (var i = 0; i <= N; i++)
{
pow10[i] = mint.Power(i, 10);
}
mint answer = 0;
for (var p = 1; p <= N; p++)
{
var q = N / p;
answer += (pow10[p] - pow10[p - 1]) * pow10[q];
}
Console.WriteLine(answer);
}
public static void Solve()
{
var(N, M) = Scanner.Scan <int, int>();
var X = Scanner.ScanEnumerable <long>().Select(x => (mint)x).ToArray();
var Y = Scanner.ScanEnumerable <long>().Select(x => (mint)x).ToArray();
mint l = 0;
mint r = 0;
for (var k = 0; k < N; k++)
{
l += k * X[k] - (N - k - 1) * X[k];
}
for (var k = 0; k < M; k++)
{
r += k * Y[k] - (M - k - 1) * Y[k];
}
var answer = l * r;
Console.WriteLine(answer);
}
public static void Solve()
{
var(N, M) = Scanner.Scan <int, int>();
var A = Scanner.ScanEnumerable <int>().Distinct().ToArray();
var B = Scanner.ScanEnumerable <int>().Distinct().ToArray();
if (A.Length != N || B.Length != M)
{
Console.WriteLine(0); return;
}
Array.Sort(A);
Array.Sort(B);
mint answer = 1;
for (var x = N * M; x > 0; x--)
{
var(uba, ubb) = (LowerBound(A, x), LowerBound(B, x));
if (uba == N || ubb == M)
{
Console.WriteLine(0); return;
}
if (A[uba] == x && B[ubb] == x)
{
continue;
}
if (A[uba] == x)
{
answer *= M - ubb;
}
else if (B[ubb] == x)
{
answer *= N - uba;
}
else
{
answer *= (N - uba) * (M - ubb) - (N * M - x);
}
}
Console.WriteLine(answer);
}
public static void Solve()
{
var N = Scanner.Scan <int>();
var A = Scanner.ScanEnumerable <int>().ToArray();
var dp = new mint[N + 1, 10];
dp[1, A[0]] = 1;
for (var i = 1; i < N; i++)
{
for (var j = 0; j < 10; j++)
{
dp[i + 1, (j + A[i]) % 10] += dp[i, j];
dp[i + 1, (j * A[i]) % 10] += dp[i, j];
}
}
for (var i = 0; i < 10; i++)
{
Console.WriteLine(dp[N, i]);
}
}
public static void Solve()
{
var(N, K) = Scanner.Scan <int, int>();
var A = Scanner.ScanEnumerable <long>().ToArray();
var fact = new mint[K + 10];
var ifact = new mint[K + 10];
fact[0] = ifact[0] = 1;
for (var i = 1; i < K + 10; i++)
{
fact[i] = fact[i - 1] * i;
ifact[i] = 1 / fact[i];
}
mint Combination(long n, int k)
{
if (n < 0 || k < 0)
{
return(0);
}
mint result = ifact[k];
for (var i = 0; i < k; i++)
{
result *= n - i;
}
return(result);
}
mint answer = Combination(A[0] - A.Skip(1).Sum() - 1, K - 1);
foreach (var a in A.Skip(1))
{
answer *= Combination(a + K - 1, K - 1);
}
Console.WriteLine(answer);
}
public static void Solve()
{
var N = Scanner.Scan <int>();
var S = Scanner.Scan <string>();
var M = S.Length;
var T = new string[N].Select(_ => Scanner.Scan <string>()).ToArray();
var dp = new mint[M + 1];
dp[0] = 1;
for (var i = 0; i < M; i++)
{
foreach (var t in T)
{
if (i + t.Length <= M && string.Compare(S, i, t, 0, t.Length) == 0)
{
dp[i + t.Length] += dp[i];
}
}
}
Console.WriteLine(dp[M]);
}
public static void Solve()
{
var N = Scanner.Scan <int>();
var A = Scanner.ScanEnumerable <long>().ToArray();
var B = Scanner.ScanEnumerable <long>().ToArray();
var C = A.Zip(B).Select(x => (A: x.First, B: x.Second)).ToArray();
Array.Sort(C, (x, y) =>
{
var ret = x.A.CompareTo(y.A);
return(ret == 0 ? x.B.CompareTo(y.B) : ret);
});
var max = A.Max();
var dp = new mint[N + 1, max + 1];
dp[0, 0] = 1;
mint answer = 0;
for (var i = 0; i < N; i++)
{
var(a, b) = C[i];
for (var j = 0; j <= max; j++)
{
dp[i + 1, j] = dp[i, j];
if (j - b >= 0)
{
dp[i + 1, j] += dp[i, j - b];
}
if (a - b >= j)
{
answer += dp[i, j];
}
}
}
Console.WriteLine(answer);
}
public static void Solve()
{
var(N, K) = Scanner.Scan <int, int>();
var dp = new mint[N][].Select(_ => new mint[K]).ToArray();
Array.Fill(dp[0], 1);
var pv = Scanner.ScanEnumerable <int>().ToArray();
for (var i = 1; i < N; i++)
{
var v = Scanner.ScanEnumerable <int>().ToArray();
var ci = 0;
for (var j = 0; j < K; j++)
{
for (var k = ci; k < K; k++)
{
if (pv[j] <= v[k])
{
dp[i][k] += dp[i - 1][j];
ci = k;
break;
}
}
}
for (var j = 0; j < K - 1; j++)
{
dp[i][j + 1] += dp[i][j];
}
pv = v;
}
mint answer = 0;
for (var i = 0; i < K; i++)
{
answer += dp[N - 1][i];
}
Console.WriteLine(answer);
}
public static void Solve()
{
var(H, W, K) = Scanner.Scan <int, int, int>();
var(x1, y1, x2, y2) = Scanner.Scan <int, int, int, int>();
var dp = new mint[2, 2, 2];
dp[0, x1 == x2 ? 0 : 1, y1 == y2 ? 0 : 1] = 1;
var t = 1;
for (var i = 0; i < K; i++)
{
t ^= 1;
dp[t ^ 1, 0, 0] = dp[t, 0, 1] + dp[t, 1, 0];
dp[t ^ 1, 0, 1] = dp[t, 0, 0] * (W - 1) + dp[t, 0, 1] * (W - 2) + dp[t, 1, 1];
dp[t ^ 1, 1, 0] = dp[t, 0, 0] * (H - 1) + dp[t, 1, 0] * (H - 2) + dp[t, 1, 1];
dp[t ^ 1, 1, 1] = dp[t, 0, 1] * (H - 1) + dp[t, 1, 0] * (W - 1) + dp[t, 1, 1] * (H + W - 4);
}
var answer = dp[t ^ 1, 0, 0];
Console.WriteLine(answer);
}
public static void Solve()
{
var N = Scanner.Scan <int>();
var D = new long[N].Select(_ => Scanner.Scan <long>()).ToArray();
Array.Sort(D);
var dp = new mint[(int)1e5 + 1, 4];
for (var i = 0; i < N; i++)
{
dp[i + 1, 0] = dp[i, 0] + 1;
for (var j = 1; j < 4; j++)
{
var k = UpperBound(D, D[i] / 2);
dp[i + 1, j] = dp[i, j] + dp[k, j - 1];
}
}
var answer = dp[N, 3];
Console.WriteLine(answer);
}
public static void Solve()
{
var(N, M, K) = Scanner.Scan <int, int, int>();
var G = new List <int> [N].Select(x => new List <int>()).ToArray();
for (var i = 0; i < M; i++)
{
var(u, v) = Scanner.Scan <int, int>();
u--; v--;
G[u].Add(v);
G[v].Add(u);
}
var dp = new mint[K + 1, N];
dp[0, 0] = 1;
for (var k = 0; k < K; k++)
{
mint s = 0;
for (var u = 0; u < N; u++)
{
s += dp[k, u];
}
for (var u = 0; u < N; u++)
{
dp[k + 1, u] = s - dp[k, u];
foreach (var v in G[u])
{
dp[k + 1, u] -= dp[k, v];
}
}
}
var answer = dp[K, 0];
Console.WriteLine(answer);
}
public static void Solve()
{
var N = Scanner.Scan <long>();
// x^2 - y = z^2
// (x + z)(x - z) = y
// p = x + z
// q = x - z
// x = (p + q) / 2
// z = (p - q) / 2
// pq <= N
// p > 0 && q > 0 p >= q
mint answer = 0;
for (var q = 1L; q *q <= N; q++)
{
var p = N / q;
var z = (p - q) / 2;
answer += z + 1; // +0
}
Console.WriteLine(answer);
}
public static void Solve()
{
var N = Scanner.Scan <int>();
var S = Scanner.Scan <string>();
var count = new int[26];
Array.Fill(count, 1);
foreach (var c in S)
{
count[c - 'a']++;
}
mint answer = 1;
foreach (var c in count)
{
answer *= c;
}
answer--;
Console.WriteLine(answer);
}
public static void Solve()
{
var N = Scanner.Scan <int>();
var NN = N * N;
var fact = new mint[NN + 1];
var ifact = new mint[NN + 1];
fact[0] = ifact[0] = 1;
for (var i = 1; i <= NN; i++)
{
fact[i] = fact[i - 1] * i;
ifact[i] = 1 / fact[i];
}
mint Permutation(int n, int k)
{
if (n < k || n < 0 || k < 0)
{
return(0);
}
return(fact[n] * ifact[n - k]);
}
mint Combination(int n, int k)
{
if (n < k || n < 0 || k < 0)
{
return(0);
}
return(fact[n] * ifact[k] * ifact[n - k]);
}
var answer = fact[NN] - Combination(NN, 2 * N - 1) * fact[N - 1] * fact[N - 1] * fact[(N - 1) * (N - 1)] * NN;
Console.WriteLine(answer);
}
public static void Solve()
{
var N = Scanner.Scan <int>();
var A = Scanner.ScanEnumerable <int>().ToArray();
var p2 = new mint[N + 1];
p2[0] = 1;
for (var i = 0; i < N; i++)
{
p2[i + 1] = p2[i] * 2;
}
var pi2 = new mint[N + 1];
pi2[N] = p2[N].Inverse();
for (var i = N; i > 0; i--)
{
pi2[i - 1] = pi2[i] * 2;
}
var B = A.Distinct().ToArray();
Array.Sort(B);
var map = B.Select((x, i) => (x, i)).ToDictionary(k => k.x, k => k.i);
var M = map.Count;
var ft = new FenwickTree(M);
mint answer = 0;
for (var i = 0; i < N; i++)
{
var a = map[A[i]];
answer += ft.Sum(a + 1) * p2[i];
ft.Add(a, pi2[i + 1]);
}
Console.WriteLine(answer);
}
