public static IEnumerable <MInt> Execute(IEnumerable <MInt> a, IEnumerable <MInt> b)
{
var(a1, b1) = (a.ToArray(), b.ToArray());
var(n, m) = (a1.Length, b1.Length);
var ret = new MInt[n + m - 1];
if (System.Math.Min(n, m) <= 60)
{
for (var i = 0; i < n; i++)
{
for (var j = 0; j < m; j++)
{
ret[i + j] += a1[i] * b1[j];
}
}
return(ret);
}
var z = 1 << CeilPower2(n + m - 1);
Array.Resize(ref a1, z);
Array.Resize(ref b1, z);
a1 = Butterfly(a1).ToArray();
b1 = Butterfly(b1).ToArray();
for (var i = 0; i < a1.Length; i++)
{
a1[i] *= b1[i];
}
ret = ButterflyInverse(a1).ToArray();
Array.Resize(ref ret, n + m - 1);
return(ret.Select(x => x / z));
}
public void TaskStack_TwoTasksThenOne()
{
var taskStack = new MTaskStack();
var num = new MInt(5);
var a = new MTask((t) => num.Value == 4);
var b = new MTask((t) => num.Value == 3);
var c = new MTask((t) => num.Value == 2);
c.OnComplete += () => num.Value = 0;
taskStack.PushQueue(a);
taskStack.PushQueue(b);
num.Value--;
taskStack.Evaluate();
Assert.AreSame(b, taskStack.Current);
num.Value--;
taskStack.Evaluate();
taskStack.Evaluate();
taskStack.PushQueue(c);
taskStack.Evaluate();
num.Value = 2;
taskStack.Evaluate();
Assert.AreEqual(0, num.Value);
Assert.AreEqual(0, taskStack.Count);
}
static void Main()
{
var n = int.Parse(Console.ReadLine());
var s = Console.ReadLine();
var c = new MInt[n + 1];
c[0] = 1;
for (int i = 1; i <= n; i++)
{
c[i] = c[i - 1] * 2 * (2 * i - 1) / (i + 1);
}
MInt r = 1;
for (int t = 0, i = 0; i < n; i++)
{
t++;
if (i == n - 1 || s[i] != s[i + 1])
{
r *= c[t];
t = 0;
}
}
Console.WriteLine(r.V);
}
static void Main()
{
var h = Read();
int n = h[0], m = h[1];
var dp = new MInt[m + 1, n + 1];
dp[0, 1] = 1;
for (int i = 0; i < m; i++)
{
for (int j = 1; j <= n; j++)
{
dp[i + 1, j] = dp[i + 1, j - 1] + dp[i, j];
}
}
var s = new MInt[n + 1];
for (int i = 0; i < n; i++)
{
s[i + 1] = s[i] + dp[m, i + 1];
}
Console.WriteLine(Enumerable.Range(1, n).Select(i => dp[m, i] * s[n + 1 - i]).Aggregate((x, y) => x + y));
}
private static IEnumerable <MInt> ButterflyInverse(IEnumerable <MInt> items)
{
var ret = items.ToArray();
var h = CeilPower2(ret.Length);
if (_sumIE == null)
{
Initialize();
}
for (var ph = h; ph >= 1; ph--)
{
var w = 1 << (ph - 1);
var p = 1 << (h - ph);
MInt inow = 1;
for (var s = 0; s < w; s++)
{
var offset = s << (h - ph + 1);
for (var i = 0; i < p; i++)
{
var l = ret[i + offset];
var r = ret[i + offset + p];
ret[i + offset] = l + r;
ret[i + offset + p] = (l - r) * inow;
}
inow *= _sumIE[BitScanForward(~s)];
}
}
return(ret);
}
static void Main()
{
var n = int.Parse(Console.ReadLine());
map = new int[n + 1].Select(_ => new List <int>()).ToArray();
foreach (var r in new int[n - 1].Select(_ => Console.ReadLine().Split().Select(int.Parse).ToArray()))
{
map[r[0]].Add(r[1]);
map[r[1]].Add(r[0]);
}
tour = new int[n + 1].Select(_ => new List <int>()).ToArray();
Dfs(1, 0);
MInt bSum = 0, m2 = 2, all = m2.Pow(n - 1);
foreach (var l in tour.Skip(1))
{
if (l.Count < 2)
{
bSum += all - 1;
}
else
{
foreach (var c in Subtrees(l, n - 1))
{
bSum += m2.Pow(c) - 1;
}
}
}
Console.WriteLine(((n - (n + bSum) / all) / 2).V);
}
static void Main()
{
var a = Array.ConvertAll(Console.ReadLine().Split(), int.Parse);
int h = a[0], w = a[1], k = a[2];
Func <MInt, MInt, MInt> c = (x, y) => x * (x * x - 1) / 6 * y * y;
Console.WriteLine(((c(h, w) + c(w, h)) * MInt.MNcr(h * w - 2, k - 2)).V);
}
public void Task_Cancelled()
{
var num = new MInt(5);
var a = new MTask((t) => num.Value == 4);
a.OnComplete += () => { num.Value = 2; };
a.OnEnd += () => { num.Value = 3; };
a.Cancel();
Assert.That(num.Value == 3);
}
static MInt[] MNcrs(int n)
{
var c = new MInt[n + 1];
c[0] = 1;
for (int i = 0; i < n; ++i)
{
c[i + 1] = c[i] * (n - i) / (i + 1);
}
return(c);
}
public static MInt[] MFactorials(int n)
{
var f = new MInt[n + 1];
f[0] = 1;
for (int i = 0; i < n; ++i)
{
f[i + 1] = f[i] * (i + 1);
}
return(f);
}
static MInt Sum(int r, int c)
{
MInt t = 1, v = 0;
for (int i = 1; i <= c + 1; i++)
{
t *= (r + i) * invs[i];
v += t;
}
return(v);
}
public void TaskStack_SingleCompleted()
{
var taskStack = new MTaskStack();
var num = new MInt(5);
var a = new MTask((t) => num.Value == 4);
a.OnComplete += () => num.Value = 0;
taskStack.PushQueue(a);
num.Value--;
taskStack.Evaluate();
Assert.That(num.Value == 0);
Assert.AreEqual(0, taskStack.Count);
}
public void Task_Completed()
{
var num = new MInt(5);
var a = new MTask((t) => num.Value == 4);
a.OnComplete += () => { num.Value = 2; };
a.Evaluate();
Assert.That(num.Value == 5);
num.Value--;
a.Evaluate();
Assert.That(num.Value == 2);
}
static void Main()
{
var(n, m, k) = Read3();
var ncrs = MNcrs(n - 1);
MInt r = 0;
for (int i = n - 1 - k; i < n; i++)
{
r += ncrs[i] * m *MInt.MPow(m - 1, i);
}
Console.WriteLine(r);
}
static void Main()
{
var(n, k) = Read2();
var ncrs = MNcrs(n);
var m_max = Math.Min(n - 1, k);
MInt r = 0;
for (int m = 0; m <= m_max; m++)
{
r += ncrs[m] * ncrs[m] * (n - m);
}
Console.WriteLine(r / n);
}
static void Main()
{
var h = Array.ConvertAll(Console.ReadLine().Split(), int.Parse);
int n = h[0], k = h[1];
MInt r = 0, c = 1;
for (int i = 0; i < k; i++)
{
r += c * MInt.MPow(k - i, n);
c *= -(k - i);
c /= i + 1;
}
Console.WriteLine(r);
}
static MInt Hole(List <int> l, int m)
{
if (l.Count < 2)
{
return(0);
}
MInt bSum = 0;
for (int i = 0; i < l.Count; i++)
{
var c = ((l[(i + 1) % l.Count] - l[i]) / 2 + m) % m;
bSum += ((MInt)2).Pow(c) - 1;
}
return(1 - (1 + bSum) / ((MInt)2).Pow(m));
}
static void Main()
{
var n = int.Parse(Console.ReadLine());
var a = new int[n].Select(_ => Console.ReadLine().Split().Skip(1).Select(int.Parse).ToArray()).ToArray();
var items_kids = a.SelectMany((g, i) => g.Select(x => (x: x, i: i))).GroupBy(_ => _.x, _ => _.i).ToDictionary(g => g.Key, g => g.ToArray());
var kids_inv = Array.ConvertAll(a, g => (MInt)1 / g.Length);
MInt t = 0;
foreach (var p in items_kids)
{
t += items_kids[p.Key].Select(i => kids_inv[i]).Aggregate((x, y) => x + y) * p.Value.Length;
}
Console.WriteLine(t / n / n);
}
public void TaskStack_ThreeQueuedThreeCapacity()
{
var taskStack = new MTaskStack(3);
var num = new MInt(5);
var a = new MTask((t) => num.Value == 4);
var b = new MTask((t) => num.Value == 3);
var c = new MTask((t) => num.Value == 2);
c.OnComplete += () => num.Value = 0;
taskStack.PushQueue(a);
taskStack.PushQueue(b);
taskStack.PushQueue(c);
Assert.AreSame(c, taskStack.Next);
Assert.AreEqual(3, taskStack.Count);
}
static void Main()
{
var n = int.Parse(Console.ReadLine());
var x = Console.ReadLine();
var r = n;
while (r % 2 == 0)
{
r /= 2;
}
var b = 2 * n / r;
var cycles = Enumerable.Range(1, r).Where(i => r % i == 0).Select(i => b * i).ToArray();
var counts = new MInt[cycles.Length];
for (int i = 0; i < cycles.Length; i++)
{
var t = cycles[i] / 2;
var sub = x.Substring(0, t);
MInt p = 1;
for (int j = t - 1; j >= 0; j--, p *= 2)
{
counts[i] += p * (sub[j] - '0');
}
var subs = new[] { sub, new string(sub.Select(c => c == '0' ? '1' : '0').ToArray()) };
var x2 = string.Join("", Enumerable.Range(0, n / t).Select(j => subs[j % 2]));
if (x2.CompareTo(x) <= 0)
{
counts[i] += 1;
}
}
for (int i = 0; i < cycles.Length; i++)
{
for (int j = i + 1; j < cycles.Length; j++)
{
if (cycles[j] % cycles[i] == 0)
{
counts[j] -= counts[i];
}
}
}
Console.WriteLine(cycles.Zip(counts, (t, c) => t * c).Aggregate((u, v) => u + v).V);
}
static void Main()
{
var A = 1000000;
Console.ReadLine();
var a = new int[A + 1];
foreach (var x in Console.ReadLine().Split().Select(int.Parse))
{
a[x]++;
}
var c = new MInt[A + 1];
for (var d = 1; d <= A; d++)
{
c[d] = new MInt(d).Inv();
}
for (var d = 1; d <= A / 2; d++)
{
for (var m = 2 * d; m <= A; m += d)
{
c[m] -= c[d];
}
}
var h = new MInt(2).Inv();
MInt s = 0;
for (var d = 1; d <= A; d++)
{
MInt si = 0, si2 = 0;
for (var m = d; m <= A; m += d)
{
if (a[m] == 0)
{
continue;
}
si += ((MInt)a[m]) * m;
si2 += ((MInt)a[m]) * m * m;
}
s += (si * si - si2) * h * c[d];
}
Console.WriteLine(s.V);
}
static void Main()
{
var h = Array.ConvertAll(Console.ReadLine().Split(), int.Parse);
int n = h[0], k = h[1];
MInt r = 0;
var dp = new MInt[k + 1];
for (int i = k; i > 0; i--)
{
dp[i] = ((MInt)(k / i)).Pow(n);
for (int j = 2 * i; j <= k; j += i)
{
dp[i] -= dp[j];
}
r += i * dp[i];
}
Console.WriteLine(r);
}
public static MInt Power(MInt x, long n)
{
if (n < 0)
{
throw new ArgumentException();
}
var r = new MInt(1);
while (n > 0)
{
if ((n & 1) > 0)
{
r *= x;
}
x *= x;
n >>= 1;
}
return(r);
}
static void Main()
{
var n = int.Parse(Console.ReadLine());
var x = Array.ConvertAll(Console.ReadLine().Split(), int.Parse);
MInt f = MInt.MFactorial(n - 1);
var dp = new MInt[n];
for (int i = 1; i < n; i++)
{
dp[i] = dp[i - 1] + f / i;
}
MInt r = 0;
for (int i = 1; i < n; i++)
{
r += dp[i] * (x[i] - x[i - 1]);
}
Console.WriteLine(r.V);
}
static void Main()
{
Func <int[]> read = () => Console.ReadLine().Split().Select(int.Parse).ToArray();
var h = read();
var a = read();
Array.Sort(a);
int n = h[0], k = h[1];
MInt M = 0, m = 0, c = 1;
for (int i = k; i <= n; i++)
{
M += c * a[i - 1];
m += c * a[n - i];
c *= i;
c /= i - k + 1;
}
Console.WriteLine((M - m).V);
}
public override int GetHashCode()
{
int hash = 1;
if (MInt != 0)
{
hash ^= MInt.GetHashCode();
}
if (MFloat != 0F)
{
hash ^= MFloat.GetHashCode();
}
if (MDouble != 0D)
{
hash ^= MDouble.GetHashCode();
}
if (MBool != false)
{
hash ^= MBool.GetHashCode();
}
if (MByte != 0)
{
hash ^= MByte.GetHashCode();
}
if (MShort != 0)
{
hash ^= MShort.GetHashCode();
}
if (MLong != 0L)
{
hash ^= MLong.GetHashCode();
}
if (MStr.Length != 0)
{
hash ^= MStr.GetHashCode();
}
return(hash);
}
public static void Solve()
{
var N = Scanner.Scan <int>();
var A = Scanner.ScanEnumerable <long>().ToArray();
MInt.SetMod1000000007();
var factors = new Dictionary <long, long>();
for (var i = 0; i < N; i++)
{
var prime = new Prime(A[i]);
foreach (var(key, value) in prime.Factors)
{
if (!factors.ContainsKey(key))
{
factors[key] = 0;
}
factors[key] = Math.Max(factors[key], value);
}
}
MInt lcm = 1;
foreach (var(key, value) in factors)
{
lcm *= MInt.Power(key, value);
}
MInt answer = 0;
for (var i = 0; i < N; i++)
{
answer += lcm / A[i];
}
Console.WriteLine(answer);
}
static void Main()
{
var(n, k) = Read2();
var a = Read();
var pa1 = Array.ConvertAll(a, _ => 1L);
var pa2 = Array.ConvertAll(a, _ => 1L);
var f = MInt.MFactorials(k);
var f_ = Array.ConvertAll(f, v => (1 / v).V);
var p = new long[k + 1];
for (int x = 0; x <= k; x++)
{
var sum = 0L;
for (int i = 0; i < n; i++)
{
sum += pa1[i] * f_[x] % M;
pa1[i] = pa1[i] * a[i] % M;
}
p[x] = sum % M;
}
for (int x = 1; x <= k; x++)
{
var sum = 0L;
for (int i = 0; i < n; i++)
{
pa2[i] = pa2[i] * (a[i] << 1) % M;
sum += pa2[i];
}
var r = f[x] * Enumerable.Range(0, x + 1).Sum(i => p[i] * p[x - i] % M);
Console.WriteLine((r - sum) / 2);
}
}
static void Main()
{
var h = Array.ConvertAll(Console.ReadLine().Split(), int.Parse);
int n = h[0], k = h[1];
var f = new MInt[k + 1];
var t = new MInt[k + 1];
f[0] = 1;
t[0] = 1;
for (int i = 1; i <= k; ++i)
{
f[i] = f[i - 1] / i;
t[i] = t[i - 1] + f[i] * (i % 2 == 0 ? 1 : -1);
}
MInt r = 0;
for (int i = 1; i <= k; ++i)
{
r += MInt.MPow(i, n) * f[i] * t[k - i];
}
Console.WriteLine(r);
}
private static void Initialize()
{
if (_sumE != null && _sumIE != null)
{
return;
}
var m = MInt.Mod;
_primitiveRoot = PrimitiveRoot(m);
_sumE = new MInt[30];
_sumIE = new MInt[30];
var es = new MInt[30];
var ies = new MInt[30];
var count2 = BitScanForward(m - 1);
var e = new MInt(_primitiveRoot).Power((m - 1) >> count2);
var ie = e.Inverse();
for (var i = count2; i >= 2; i--)
{
es[i - 2] = e;
ies[i - 2] = ie;
e *= e;
ie *= ie;
}
MInt now = 1;
MInt inow = 1;
for (var i = 0; i < count2 - 2; i++)
{
_sumE[i] = es[i] * now;
_sumIE[i] = ies[i] * inow;
now *= ies[i];
inow *= es[i];
}
}
