Language: C++

template< int MODULO > struct ModInt {
	using uint32 = uint_fast32_t;
	using uint64 = uint_fast64_t;
	uint64 x; ModInt() : x(0) {}
	ModInt(uint64 y) : x(set(y % MODULO + MODULO)) {}
	static uint64 set(const uint64 &y) { return (y < MODULO) ? y : y - MODULO; }
	static ModInt make(const uint64 &y) { ModInt ret = y; return ret; }
	ModInt operator+(const ModInt &m) const { return make(set(x + m.x)); }
	ModInt operator-(const ModInt &m) const { return make(set(x + MODULO - m.x)); }
	ModInt operator*(const ModInt &m) const { return make(x * m.x % MODULO); }
	ModInt operator/(const ModInt &m) const { return make(x) * ~make(m.x); }
	ModInt &operator+=(const ModInt &m) { return *this = *this + m; }
	ModInt &operator-=(const ModInt &m) { return *this = *this - m; }
	ModInt &operator*=(const ModInt &m) { return *this = *this * m; }
	ModInt &operator/=(const ModInt &m) { return *this = *this / m; }
	ModInt &operator^=(const uint64 &y) { return *this = *this ^ y; }
	ModInt operator~ () const { return *this ^ (MODULO - 2); }
	ModInt operator- () const { return make(set(MODULO - x)); }
	ModInt operator! () const { init(uint32(*this)); return fact[uint32(*this)]; }
	ModInt operator& () const { init(uint32(*this)); return finv[uint32(*this)]; }
	ModInt operator++() { return *this = make(set(x + 1)); }
	ModInt operator--() { return *this = make(set(x + MODULO - 1)); }
	bool operator==(const ModInt &m) const { return x == m.x; }
	bool operator!=(const ModInt &m) const { return x != m.x; }
	bool operator< (const ModInt &m) const { return x <  m.x; }
	bool operator<=(const ModInt &m) const { return x <= m.x; }
	bool operator> (const ModInt &m) const { return x >  m.x; }
	bool operator>=(const ModInt &m) const { return x >= m.x; }
	explicit operator   bool() const { return x; }
	explicit operator uint64() const { return x; }
	ModInt operator^(uint64 y) const {
		uint64 t = x, u = 1;
		while (y) { if (y & 1) (u *= t) %= MODULO; (t *= t) %= MODULO; y >>= 1; }
		return make(u);
	}
	friend ostream &operator<<(ostream &os, const ModInt< MODULO > &m) { return os << m.x; }
	friend istream &operator>>(istream &is, ModInt< MODULO > &m) { uint64 y; is >> y; m = make(y); return is; }
	static vector< ModInt > fact, finv, invs;
	static void init(uint32 n) {
		uint32 m = fact.size();
		if (n < m) return;
		fact.resize(n + 1, 1);
		finv.resize(n + 1, 1);
		invs.resize(n + 1, 1);
		if (m == 0) m = 1;
		for (uint32 i = m; i <= n; ++i) fact[i] = fact[i - 1] * ModInt(i);
		finv[n] = ModInt(1) / fact[n];
		for (uint32 i = n; i >= m; --i) finv[i - 1] = finv[i] * make(i);
		for (uint32 i = m; i <= n; ++i) invs[i] = finv[i] * fact[i - 1];
	}
	static ModInt C(uint64 n, uint64 r) {
		if (r == 0) return make(1);
		if (r <  0) return make(0);
		if (n <  0) return make(r & 1 ? MODULO - 1 : 1) * C(-n + r - 1, r);
		if (n == 0 || n < r) return make(0);
		init(n);
		return fact[n] * finv[n - r] * finv[r];
	}
	static ModInt P(uint64 n, uint64 r) {
		if (n < r || r < 0) return make(0);
		init(n);
		return fact[n] * finv[n - r];
	}
	static ModInt H(uint64 n, uint64 r) {
		if (n < 0 || r < 0) return make(0);
		if (!n && !r) return make(1);
		init(n + r - 1);
		return C(n + r - 1, r);
	}
	static ModInt montmort(uint32 n) {
		ModInt res;
		init(n);
		for (uint32 k = 2; k <= n; ++k) {
			if (k & 1) res -= finv[k];
			else res += finv[k];
		}
		return res *= fact[n];
	}
	static ModInt LagrangePolynomial(vector<ModInt> &y, ModInt t) {
		uint32 n = y.size() - 1;
		if (t.x <= n) return y[t.x];
		init(n + 1);
		ModInt res, num(1);
		for (uint32 i = 0; i <= n; ++i) num *= t - make(i);
		for (uint32 i = 0; i <= n; ++i) {
			ModInt tmp = y[i] * num / (t - make(i)) * finv[i] * finv[n - i];
			if ((n - i) & 1) res -= tmp;
			else res += tmp;
		}
		return res;
	}
};
template< int MODULO >
vector<ModInt< MODULO >> ModInt< MODULO >::fact = vector<ModInt< MODULO >>();
template< int MODULO >
vector<ModInt< MODULO >> ModInt< MODULO >::finv = vector<ModInt< MODULO >>();
template< int MODULO >
vector<ModInt< MODULO >> ModInt< MODULO >::invs = vector<ModInt< MODULO >>();
using modint = ModInt< MOD >;template< int MODULO > struct ModInt {
	using uint32 = uint_fast32_t;
	using uint64 = uint_fast64_t;
	uint64 x; ModInt() : x(0) {}
	ModInt(uint64 y) : x(set(y % MODULO + MODULO)) {}
	static uint64 set(const uint64 &y) { return (y < MODULO) ? y : y - MODULO; }
	static ModInt make(const uint64 &y) { ModInt ret = y; return ret; }
	ModInt operator+(const ModInt &m) const { return make(set(x + m.x)); }
	ModInt operator-(const ModInt &m) const { return make(set(x + MODULO - m.x)); }
	ModInt operator*(const ModInt &m) const { return make(x * m.x % MODULO); }
	ModInt operator/(const ModInt &m) const { return make(x) * ~make(m.x); }
	ModInt &operator+=(const ModInt &m) { return *this = *this + m; }
	ModInt &operator-=(const ModInt &m) { return *this = *this - m; }
	ModInt &operator*=(const ModInt &m) { return *this = *this * m; }
	ModInt &operator/=(const ModInt &m) { return *this = *this / m; }
	ModInt &operator^=(const uint64 &y) { return *this = *this ^ y; }
	ModInt operator~ () const { return *this ^ (MODULO - 2); }
	ModInt operator- () const { return make(set(MODULO - x)); }
	ModInt operator! () const { init(uint32(*this)); return fact[uint32(*this)]; }
	ModInt operator& () const { init(uint32(*this)); return finv[uint32(*this)]; }
	ModInt operator++() { return *this = make(set(x + 1)); }
	ModInt operator--() { return *this = make(set(x + MODULO - 1)); }
	bool operator==(const ModInt &m) const { return x == m.x; }
	bool operator!=(const ModInt &m) const { return x != m.x; }
	bool operator< (const ModInt &m) const { return x <  m.x; }
	bool operator<=(const ModInt &m) const { return x <= m.x; }
	bool operator> (const ModInt &m) const { return x >  m.x; }
	bool operator>=(const ModInt &m) const { return x >= m.x; }
	explicit operator   bool() const { return x; }
	explicit operator uint64() const { return x; }
	ModInt operator^(uint64 y) const {
		uint64 t = x, u = 1;
		while (y) { if (y & 1) (u *= t) %= MODULO; (t *= t) %= MODULO; y >>= 1; }
		return make(u);
	}
	friend ostream &operator<<(ostream &os, const ModInt< MODULO > &m) { return os << m.x; }
	friend istream &operator>>(istream &is, ModInt< MODULO > &m) { uint64 y; is >> y; m = make(y); return is; }
	static vector< ModInt > fact, finv, invs;
	static void init(uint32 n) {
		uint32 m = fact.size();
		if (n < m) return;
		fact.resize(n + 1, 1);
		finv.resize(n + 1, 1);
		invs.resize(n + 1, 1);
		if (m == 0) m = 1;
		for (uint32 i = m; i <= n; ++i) fact[i] = fact[i - 1] * ModInt(i);
		finv[n] = ModInt(1) / fact[n];
		for (uint32 i = n; i >= m; --i) finv[i - 1] = finv[i] * make(i);
		for (uint32 i = m; i <= n; ++i) invs[i] = finv[i] * fact[i - 1];
	}
	static ModInt C(uint64 n, uint64 r) {
		if (r == 0) return make(1);
		if (r <  0) return make(0);
		if (n <  0) return make(r & 1 ? MODULO - 1 : 1) * C(-n + r - 1, r);
		if (n == 0 || n < r) return make(0);
		init(n);
		return fact[n] * finv[n - r] * finv[r];
	}
	static ModInt P(uint64 n, uint64 r) {
		if (n < r || r < 0) return make(0);
		init(n);
		return fact[n] * finv[n - r];
	}
	static ModInt H(uint64 n, uint64 r) {
		if (n < 0 || r < 0) return make(0);
		if (!n && !r) return make(1);
		init(n + r - 1);
		return C(n + r - 1, r);
	}
	static ModInt montmort(uint32 n) {
		ModInt res;
		init(n);
		for (uint32 k = 2; k <= n; ++k) {
			if (k & 1) res -= finv[k];
			else res += finv[k];
		}
		return res *= fact[n];
	}
	static ModInt LagrangePolynomial(vector<ModInt> &y, ModInt t) {
		uint32 n = y.size() - 1;
		if (t.x <= n) return y[t.x];
		init(n + 1);
		ModInt res, num(1);
		for (uint32 i = 0; i <= n; ++i) num *= t - make(i);
		for (uint32 i = 0; i <= n; ++i) {
			ModInt tmp = y[i] * num / (t - make(i)) * finv[i] * finv[n - i];
			if ((n - i) & 1) res -= tmp;
			else res += tmp;
		}
		return res;
	}
};
template< int MODULO >
vector<ModInt< MODULO >> ModInt< MODULO >::fact = vector<ModInt< MODULO >>();
template< int MODULO >
vector<ModInt< MODULO >> ModInt< MODULO >::finv = vector<ModInt< MODULO >>();
template< int MODULO >
vector<ModInt< MODULO >> ModInt< MODULO >::invs = vector<ModInt< MODULO >>();
using modint = ModInt< MOD >;template< int MODULO > struct ModInt {
	using uint32 = uint_fast32_t;
	using uint64 = uint_fast64_t;
	uint64 x; ModInt() : x(0) {}
	ModInt(uint64 y) : x(set(y % MODULO + MODULO)) {}
	static uint64 set(const uint64 &y) { return (y < MODULO) ? y : y - MODULO; }
	static ModInt make(const uint64 &y) { ModInt ret = y; return ret; }
	ModInt operator+(const ModInt &m) const { return make(set(x + m.x)); }
	ModInt operator-(const ModInt &m) const { return make(set(x + MODULO - m.x)); }
	ModInt operator*(const ModInt &m) const { return make(x * m.x % MODULO); }
	ModInt operator/(const ModInt &m) const { return make(x) * ~make(m.x); }
	ModInt &operator+=(const ModInt &m) { return *this = *this + m; }
	ModInt &operator-=(const ModInt &m) { return *this = *this - m; }
	ModInt &operator*=(const ModInt &m) { return *this = *this * m; }
	ModInt &operator/=(const ModInt &m) { return *this = *this / m; }
	ModInt &operator^=(const uint64 &y) { return *this = *this ^ y; }
	ModInt operator~ () const { return *this ^ (MODULO - 2); }
	ModInt operator- () const { return make(set(MODULO - x)); }
	ModInt operator! () const { init(uint32(*this)); return fact[uint32(*this)]; }
	ModInt operator& () const { init(uint32(*this)); return finv[uint32(*this)]; }
	ModInt operator++() { return *this = make(set(x + 1)); }
	ModInt operator--() { return *this = make(set(x + MODULO - 1)); }
	bool operator==(const ModInt &m) const { return x == m.x; }
	bool operator!=(const ModInt &m) const { return x != m.x; }
	bool operator< (const ModInt &m) const { return x <  m.x; }
	bool operator<=(const ModInt &m) const { return x <= m.x; }
	bool operator> (const ModInt &m) const { return x >  m.x; }
	bool operator>=(const ModInt &m) const { return x >= m.x; }
	explicit operator   bool() const { return x; }
	explicit operator uint64() const { return x; }
	ModInt operator^(uint64 y) const {
		uint64 t = x, u = 1;
		while (y) { if (y & 1) (u *= t) %= MODULO; (t *= t) %= MODULO; y >>= 1; }
		return make(u);
	}
	friend ostream &operator<<(ostream &os, const ModInt< MODULO > &m) { return os << m.x; }
	friend istream &operator>>(istream &is, ModInt< MODULO > &m) { uint64 y; is >> y; m = make(y); return is; }
	static vector< ModInt > fact, finv, invs;
	static void init(uint32 n) {
		uint32 m = fact.size();
		if (n < m) return;
		fact.resize(n + 1, 1);
		finv.resize(n + 1, 1);
		invs.resize(n + 1, 1);
		if (m == 0) m = 1;
		for (uint32 i = m; i <= n; ++i) fact[i] = fact[i - 1] * ModInt(i);
		finv[n] = ModInt(1) / fact[n];
		for (uint32 i = n; i >= m; --i) finv[i - 1] = finv[i] * make(i);
		for (uint32 i = m; i <= n; ++i) invs[i] = finv[i] * fact[i - 1];
	}
	static ModInt C(uint64 n, uint64 r) {
		if (r == 0) return make(1);
		if (r <  0) return make(0);
		if (n <  0) return make(r & 1 ? MODULO - 1 : 1) * C(-n + r - 1, r);
		if (n == 0 || n < r) return make(0);
		init(n);
		return fact[n] * finv[n - r] * finv[r];
	}
	static ModInt P(uint64 n, uint64 r) {
		if (n < r || r < 0) return make(0);
		init(n);
		return fact[n] * finv[n - r];
	}
	static ModInt H(uint64 n, uint64 r) {
		if (n < 0 || r < 0) return make(0);
		if (!n && !r) return make(1);
		init(n + r - 1);
		return C(n + r - 1, r);
	}
	static ModInt montmort(uint32 n) {
		ModInt res;
		init(n);
		for (uint32 k = 2; k <= n; ++k) {
			if (k & 1) res -= finv[k];
			else res += finv[k];
		}
		return res *= fact[n];
	}
	static ModInt LagrangePolynomial(vector<ModInt> &y, ModInt t) {
		uint32 n = y.size() - 1;
		if (t.x <= n) return y[t.x];
		init(n + 1);
		ModInt res, num(1);
		for (uint32 i = 0; i <= n; ++i) num *= t - make(i);
		for (uint32 i = 0; i <= n; ++i) {
			ModInt tmp = y[i] * num / (t - make(i)) * finv[i] * finv[n - i];
			if ((n - i) & 1) res -= tmp;
			else res += tmp;
		}
		return res;
	}
};
template< int MODULO >
vector<ModInt< MODULO >> ModInt< MODULO >::fact = vector<ModInt< MODULO >>();
template< int MODULO >
vector<ModInt< MODULO >> ModInt< MODULO >::finv = vector<ModInt< MODULO >>();
template< int MODULO >
vector<ModInt< MODULO >> ModInt< MODULO >::invs = vector<ModInt< MODULO >>();
using modint = ModInt< MOD >;template< int MODULO > struct ModInt {
	using uint32 = uint_fast32_t;
	using uint64 = uint_fast64_t;
	uint64 x; ModInt() : x(0) {}
	ModInt(uint64 y) : x(set(y % MODULO + MODULO)) {}
	static uint64 set(const uint64 &y) { return (y < MODULO) ? y : y - MODULO; }
	static ModInt make(const uint64 &y) { ModInt ret = y; return ret; }
	ModInt operator+(const ModInt &m) const { return make(set(x + m.x)); }
	ModInt operator-(const ModInt &m) const { return make(set(x + MODULO - m.x)); }
	ModInt operator*(const ModInt &m) const { return make(x * m.x % MODULO); }
	ModInt operator/(const ModInt &m) const { return make(x) * ~make(m.x); }
	ModInt &operator+=(const ModInt &m) { return *this = *this + m; }
	ModInt &operator-=(const ModInt &m) { return *this = *this - m; }
	ModInt &operator*=(const ModInt &m) { return *this = *this * m; }
	ModInt &operator/=(const ModInt &m) { return *this = *this / m; }
	ModInt &operator^=(const uint64 &y) { return *this = *this ^ y; }
	ModInt operator~ () const { return *this ^ (MODULO - 2); }
	ModInt operator- () const { return make(set(MODULO - x)); }
	ModInt operator! () const { init(uint32(*this)); return fact[uint32(*this)]; }
	ModInt operator& () const { init(uint32(*this)); return finv[uint32(*this)]; }
	ModInt operator++() { return *this = make(set(x + 1)); }
	ModInt operator--() { return *this = make(set(x + MODULO - 1)); }
	bool operator==(const ModInt &m) const { return x == m.x; }
	bool operator!=(const ModInt &m) const { return x != m.x; }
	bool operator< (const ModInt &m) const { return x <  m.x; }
	bool operator<=(const ModInt &m) const { return x <= m.x; }
	bool operator> (const ModInt &m) const { return x >  m.x; }
	bool operator>=(const ModInt &m) const { return x >= m.x; }
	explicit operator   bool() const { return x; }
	explicit operator uint64() const { return x; }
	ModInt operator^(uint64 y) const {
		uint64 t = x, u = 1;
		while (y) { if (y & 1) (u *= t) %= MODULO; (t *= t) %= MODULO; y >>= 1; }
		return make(u);
	}
	friend ostream &operator<<(ostream &os, const ModInt< MODULO > &m) { return os << m.x; }
	friend istream &operator>>(istream &is, ModInt< MODULO > &m) { uint64 y; is >> y; m = make(y); return is; }
	static vector< ModInt > fact, finv, invs;
	static void init(uint32 n) {
		uint32 m = fact.size();
		if (n < m) return;
		fact.resize(n + 1, 1);
		finv.resize(n + 1, 1);
		invs.resize(n + 1, 1);
		if (m == 0) m = 1;
		for (uint32 i = m; i <= n; ++i) fact[i] = fact[i - 1] * ModInt(i);
		finv[n] = ModInt(1) / fact[n];
		for (uint32 i = n; i >= m; --i) finv[i - 1] = finv[i] * make(i);
		for (uint32 i = m; i <= n; ++i) invs[i] = finv[i] * fact[i - 1];
	}
	static ModInt C(uint64 n, uint64 r) {
		if (r == 0) return make(1);
		if (r <  0) return make(0);
		if (n <  0) return make(r & 1 ? MODULO - 1 : 1) * C(-n + r - 1, r);
		if (n == 0 || n < r) return make(0);
		init(n);
		return fact[n] * finv[n - r] * finv[r];
	}
	static ModInt P(uint64 n, uint64 r) {
		if (n < r || r < 0) return make(0);
		init(n);
		return fact[n] * finv[n - r];
	}
	static ModInt H(uint64 n, uint64 r) {
		if (n < 0 || r < 0) return make(0);
		if (!n && !r) return make(1);
		init(n + r - 1);
		return C(n + r - 1, r);
	}
	static ModInt montmort(uint32 n) {
		ModInt res;
		init(n);
		for (uint32 k = 2; k <= n; ++k) {
			if (k & 1) res -= finv[k];
			else res += finv[k];
		}
		return res *= fact[n];
	}
	static ModInt LagrangePolynomial(vector<ModInt> &y, ModInt t) {
		uint32 n = y.size() - 1;
		if (t.x <= n) return y[t.x];
		init(n + 1);
		ModInt res, num(1);
		for (uint32 i = 0; i <= n; ++i) num *= t - make(i);
		for (uint32 i = 0; i <= n; ++i) {
			ModInt tmp = y[i] * num / (t - make(i)) * finv[i] * finv[n - i];
			if ((n - i) & 1) res -= tmp;
			else res += tmp;
		}
		return res;
	}
};
template< int MODULO >
vector<ModInt< MODULO >> ModInt< MODULO >::fact = vector<ModInt< MODULO >>();
template< int MODULO >
vector<ModInt< MODULO >> ModInt< MODULO >::finv = vector<ModInt< MODULO >>();
template< int MODULO >
vector<ModInt< MODULO >> ModInt< MODULO >::invs = vector<ModInt< MODULO >>();
using modint = ModInt< MOD >;template< int MODULO > struct ModInt {
	using uint32 = uint_fast32_t;
	using uint64 = uint_fast64_t;
	uint64 x; ModInt() : x(0) {}
	ModInt(uint64 y) : x(set(y % MODULO + MODULO)) {}
	static uint64 set(const uint64 &y) { return (y < MODULO) ? y : y - MODULO; }
	static ModInt make(const uint64 &y) { ModInt ret = y; return ret; }
	ModInt operator+(const ModInt &m) const { return make(set(x + m.x)); }
	ModInt operator-(const ModInt &m) const { return make(set(x + MODULO - m.x)); }
	ModInt operator*(const ModInt &m) const { return make(x * m.x % MODULO); }
	ModInt operator/(const ModInt &m) const { return make(x) * ~make(m.x); }
	ModInt &operator+=(const ModInt &m) { return *this = *this + m; }
	ModInt &operator-=(const ModInt &m) { return *this = *this - m; }
	ModInt &operator*=(const ModInt &m) { return *this = *this * m; }
	ModInt &operator/=(const ModInt &m) { return *this = *this / m; }
	ModInt &operator^=(const uint64 &y) { return *this = *this ^ y; }
	ModInt operator~ () const { return *this ^ (MODULO - 2); }
	ModInt operator- () const { return make(set(MODULO - x)); }
	ModInt operator! () const { init(uint32(*this)); return fact[uint32(*this)]; }
	ModInt operator& () const { init(uint32(*this)); return finv[uint32(*this)]; }
	ModInt operator++() { return *this = make(set(x + 1)); }
	ModInt operator--() { return *this = make(set(x + MODULO - 1)); }
	bool operator==(const ModInt &m) const { return x == m.x; }
	bool operator!=(const ModInt &m) const { return x != m.x; }
	bool operator< (const ModInt &m) const { return x <  m.x; }
	bool operator<=(const ModInt &m) const { return x <= m.x; }
	bool operator> (const ModInt &m) const { return x >  m.x; }
	bool operator>=(const ModInt &m) const { return x >= m.x; }
	explicit operator   bool() const { return x; }
	explicit operator uint64() const { return x; }
	ModInt operator^(uint64 y) const {
		uint64 t = x, u = 1;
		while (y) { if (y & 1) (u *= t) %= MODULO; (t *= t) %= MODULO; y >>= 1; }
		return make(u);
	}
	friend ostream &operator<<(ostream &os, const ModInt< MODULO > &m) { return os << m.x; }
	friend istream &operator>>(istream &is, ModInt< MODULO > &m) { uint64 y; is >> y; m = make(y); return is; }
	static vector< ModInt > fact, finv, invs;
	static void init(uint32 n) {
		uint32 m = fact.size();
		if (n < m) return;
		fact.resize(n + 1, 1);
		finv.resize(n + 1, 1);
		invs.resize(n + 1, 1);
		if (m == 0) m = 1;
		for (uint32 i = m; i <= n; ++i) fact[i] = fact[i - 1] * ModInt(i);
		finv[n] = ModInt(1) / fact[n];
		for (uint32 i = n; i >= m; --i) finv[i - 1] = finv[i] * make(i);
		for (uint32 i = m; i <= n; ++i) invs[i] = finv[i] * fact[i - 1];
	}
	static ModInt C(uint64 n, uint64 r) {
		if (r == 0) return make(1);
		if (r <  0) return make(0);
		if (n <  0) return make(r & 1 ? MODULO - 1 : 1) * C(-n + r - 1, r);
		if (n == 0 || n < r) return make(0);
		init(n);
		return fact[n] * finv[n - r] * finv[r];
	}
	static ModInt P(uint64 n, uint64 r) {
		if (n < r || r < 0) return make(0);
		init(n);
		return fact[n] * finv[n - r];
	}
	static ModInt H(uint64 n, uint64 r) {
		if (n < 0 || r < 0) return make(0);
		if (!n && !r) return make(1);
		init(n + r - 1);
		return C(n + r - 1, r);
	}
	static ModInt montmort(uint32 n) {
		ModInt res;
		init(n);
		for (uint32 k = 2; k <= n; ++k) {
			if (k & 1) res -= finv[k];
			else res += finv[k];
		}
		return res *= fact[n];
	}
	static ModInt LagrangePolynomial(vector<ModInt> &y, ModInt t) {
		uint32 n = y.size() - 1;
		if (t.x <= n) return y[t.x];
		init(n + 1);
		ModInt res, num(1);
		for (uint32 i = 0; i <= n; ++i) num *= t - make(i);
		for (uint32 i = 0; i <= n; ++i) {
			ModInt tmp = y[i] * num / (t - make(i)) * finv[i] * finv[n - i];
			if ((n - i) & 1) res -= tmp;
			else res += tmp;
		}
		return res;
	}
};
template< int MODULO >
vector<ModInt< MODULO >> ModInt< MODULO >::fact = vector<ModInt< MODULO >>();
template< int MODULO >
vector<ModInt< MODULO >> ModInt< MODULO >::finv = vector<ModInt< MODULO >>();
template< int MODULO >
vector<ModInt< MODULO >> ModInt< MODULO >::invs = vector<ModInt< MODULO >>();
using modint = ModInt< MOD >;template< int MODULO > struct ModInt {
	using uint32 = uint_fast32_t;
	using uint64 = uint_fast64_t;
	uint64 x; ModInt() : x(0) {}
	ModInt(uint64 y) : x(set(y % MODULO + MODULO)) {}
	static uint64 set(const uint64 &y) { return (y < MODULO) ? y : y - MODULO; }
	static ModInt make(const uint64 &y) { ModInt ret = y; return ret; }
	ModInt operator+(const ModInt &m) const { return make(set(x + m.x)); }
	ModInt operator-(const ModInt &m) const { return make(set(x + MODULO - m.x)); }
	ModInt operator*(const ModInt &m) const { return make(x * m.x % MODULO); }
	ModInt operator/(const ModInt &m) const { return make(x) * ~make(m.x); }
	ModInt &operator+=(const ModInt &m) { return *this = *this + m; }
	ModInt &operator-=(const ModInt &m) { return *this = *this - m; }
	ModInt &operator*=(const ModInt &m) { return *this = *this * m; }
	ModInt &operator/=(const ModInt &m) { return *this = *this / m; }
	ModInt &operator^=(const uint64 &y) { return *this = *this ^ y; }
	ModInt operator~ () const { return *this ^ (MODULO - 2); }
	ModInt operator- () const { return make(set(MODULO - x)); }
	ModInt operator! () const { init(uint32(*this)); return fact[uint32(*this)]; }
	ModInt operator& () const { init(uint32(*this)); return finv[uint32(*this)]; }
	ModInt operator++() { return *this = make(set(x + 1)); }
	ModInt operator--() { return *this = make(set(x + MODULO - 1)); }
	bool operator==(const ModInt &m) const { return x == m.x; }
	bool operator!=(const ModInt &m) const { return x != m.x; }
	bool operator< (const ModInt &m) const { return x <  m.x; }
	bool operator<=(const ModInt &m) const { return x <= m.x; }
	bool operator> (const ModInt &m) const { return x >  m.x; }
	bool operator>=(const ModInt &m) const { return x >= m.x; }
	explicit operator   bool() const { return x; }
	explicit operator uint64() const { return x; }
	ModInt operator^(uint64 y) const {
		uint64 t = x, u = 1;
		while (y) { if (y & 1) (u *= t) %= MODULO; (t *= t) %= MODULO; y >>= 1; }
		return make(u);
	}
	friend ostream &operator<<(ostream &os, const ModInt< MODULO > &m) { return os << m.x; }
	friend istream &operator>>(istream &is, ModInt< MODULO > &m) { uint64 y; is >> y; m = make(y); return is; }
	static vector< ModInt > fact, finv, invs;
	static void init(uint32 n) {
		uint32 m = fact.size();
		if (n < m) return;
		fact.resize(n + 1, 1);
		finv.resize(n + 1, 1);
		invs.resize(n + 1, 1);
		if (m == 0) m = 1;
		for (uint32 i = m; i <= n; ++i) fact[i] = fact[i - 1] * ModInt(i);
		finv[n] = ModInt(1) / fact[n];
		for (uint32 i = n; i >= m; --i) finv[i - 1] = finv[i] * make(i);
		for (uint32 i = m; i <= n; ++i) invs[i] = finv[i] * fact[i - 1];
	}
	static ModInt C(uint64 n, uint64 r) {
		if (r == 0) return make(1);
		if (r <  0) return make(0);
		if (n <  0) return make(r & 1 ? MODULO - 1 : 1) * C(-n + r - 1, r);
		if (n == 0 || n < r) return make(0);
		init(n);
		return fact[n] * finv[n - r] * finv[r];
	}
	static ModInt P(uint64 n, uint64 r) {
		if (n < r || r < 0) return make(0);
		init(n);
		return fact[n] * finv[n - r];
	}
	static ModInt H(uint64 n, uint64 r) {
		if (n < 0 || r < 0) return make(0);
		if (!n && !r) return make(1);
		init(n + r - 1);
		return C(n + r - 1, r);
	}
	static ModInt montmort(uint32 n) {
		ModInt res;
		init(n);
		for (uint32 k = 2; k <= n; ++k) {
			if (k & 1) res -= finv[k];
			else res += finv[k];
		}
		return res *= fact[n];
	}
	static ModInt LagrangePolynomial(vector<ModInt> &y, ModInt t) {
		uint32 n = y.size() - 1;
		if (t.x <= n) return y[t.x];
		init(n + 1);
		ModInt res, num(1);
		for (uint32 i = 0; i <= n; ++i) num *= t - make(i);
		for (uint32 i = 0; i <= n; ++i) {
			ModInt tmp = y[i] * num / (t - make(i)) * finv[i] * finv[n - i];
			if ((n - i) & 1) res -= tmp;
			else res += tmp;
		}
		return res;
	}
};
template< int MODULO >
vector<ModInt< MODULO >> ModInt< MODULO >::fact = vector<ModInt< MODULO >>();
template< int MODULO >
vector<ModInt< MODULO >> ModInt< MODULO >::finv = vector<ModInt< MODULO >>();
template< int MODULO >
vector<ModInt< MODULO >> ModInt< MODULO >::invs = vector<ModInt< MODULO >>();
using modint = ModInt< MOD >;template< int MODULO > struct ModInt {
	using uint32 = uint_fast32_t;
	using uint64 = uint_fast64_t;
	uint64 x; ModInt() : x(0) {}
	ModInt(uint64 y) : x(set(y % MODULO + MODULO)) {}
	static uint64 set(const uint64 &y) { return (y < MODULO) ? y : y - MODULO; }
	static ModInt make(const uint64 &y) { ModInt ret = y; return ret; }
	ModInt operator+(const ModInt &m) const { return make(set(x + m.x)); }
	ModInt operator-(const ModInt &m) const { return make(set(x + MODULO - m.x)); }
	ModInt operator*(const ModInt &m) const { return make(x * m.x % MODULO); }
	ModInt operator/(const ModInt &m) const { return make(x) * ~make(m.x); }
	ModInt &operator+=(const ModInt &m) { return *this = *this + m; }
	ModInt &operator-=(const ModInt &m) { return *this = *this - m; }
	ModInt &operator*=(const ModInt &m) { return *this = *this * m; }
	ModInt &operator/=(const ModInt &m) { return *this = *this / m; }
	ModInt &operator^=(const uint64 &y) { return *this = *this ^ y; }
	ModInt operator~ () const { return *this ^ (MODULO - 2); }
	ModInt operator- () const { return make(set(MODULO - x)); }
	ModInt operator! () const { init(uint32(*this)); return fact[uint32(*this)]; }
	ModInt operator& () const { init(uint32(*this)); return finv[uint32(*this)]; }
	ModInt operator++() { return *this = make(set(x + 1)); }
	ModInt operator--() { return *this = make(set(x + MODULO - 1)); }
	bool operator==(const ModInt &m) const { return x == m.x; }
	bool operator!=(const ModInt &m) const { return x != m.x; }
	bool operator< (const ModInt &m) const { return x <  m.x; }
	bool operator<=(const ModInt &m) const { return x <= m.x; }
	bool operator> (const ModInt &m) const { return x >  m.x; }
	bool operator>=(const ModInt &m) const { return x >= m.x; }
	explicit operator   bool() const { return x; }
	explicit operator uint64() const { return x; }
	ModInt operator^(uint64 y) const {
		uint64 t = x, u = 1;
		while (y) { if (y & 1) (u *= t) %= MODULO; (t *= t) %= MODULO; y >>= 1; }
		return make(u);
	}
	friend ostream &operator<<(ostream &os, const ModInt< MODULO > &m) { return os << m.x; }
	friend istream &operator>>(istream &is, ModInt< MODULO > &m) { uint64 y; is >> y; m = make(y); return is; }
	static vector< ModInt > fact, finv, invs;
	static void init(uint32 n) {
		uint32 m = fact.size();
		if (n < m) return;
		fact.resize(n + 1, 1);
		finv.resize(n + 1, 1);
		invs.resize(n + 1, 1);
		if (m == 0) m = 1;
		for (uint32 i = m; i <= n; ++i) fact[i] = fact[i - 1] * ModInt(i);
		finv[n] = ModInt(1) / fact[n];
		for (uint32 i = n; i >= m; --i) finv[i - 1] = finv[i] * make(i);
		for (uint32 i = m; i <= n; ++i) invs[i] = finv[i] * fact[i - 1];
	}
	static ModInt C(uint64 n, uint64 r) {
		if (r == 0) return make(1);
		if (r <  0) return make(0);
		if (n <  0) return make(r & 1 ? MODULO - 1 : 1) * C(-n + r - 1, r);
		if (n == 0 || n < r) return make(0);
		init(n);
		return fact[n] * finv[n - r] * finv[r];
	}
	static ModInt P(uint64 n, uint64 r) {
		if (n < r || r < 0) return make(0);
		init(n);
		return fact[n] * finv[n - r];
	}
	static ModInt H(uint64 n, uint64 r) {
		if (n < 0 || r < 0) return make(0);
		if (!n && !r) return make(1);
		init(n + r - 1);
		return C(n + r - 1, r);
	}
	static ModInt montmort(uint32 n) {
		ModInt res;
		init(n);
		for (uint32 k = 2; k <= n; ++k) {
			if (k & 1) res -= finv[k];
			else res += finv[k];
		}
		return res *= fact[n];
	}
	static ModInt LagrangePolynomial(vector<ModInt> &y, ModInt t) {
		uint32 n = y.size() - 1;
		if (t.x <= n) return y[t.x];
		init(n + 1);
		ModInt res, num(1);
		for (uint32 i = 0; i <= n; ++i) num *= t - make(i);
		for (uint32 i = 0; i <= n; ++i) {
			ModInt tmp = y[i] * num / (t - make(i)) * finv[i] * finv[n - i];
			if ((n - i) & 1) res -= tmp;
			else res += tmp;
		}
		return res;
	}
};
template< int MODULO >
vector<ModInt< MODULO >> ModInt< MODULO >::fact = vector<ModInt< MODULO >>();
template< int MODULO >
vector<ModInt< MODULO >> ModInt< MODULO >::finv = vector<ModInt< MODULO >>();
template< int MODULO >
vector<ModInt< MODULO >> ModInt< MODULO >::invs = vector<ModInt< MODULO >>();
using modint = ModInt< MOD >;template< int MODULO > struct ModInt {
	using uint32 = uint_fast32_t;
	using uint64 = uint_fast64_t;
	uint64 x; ModInt() : x(0) {}
	ModInt(uint64 y) : x(set(y % MODULO + MODULO)) {}
	static uint64 set(const uint64 &y) { return (y < MODULO) ? y : y - MODULO; }
	static ModInt make(const uint64 &y) { ModInt ret = y; return ret; }
	ModInt operator+(const ModInt &m) const { return make(set(x + m.x)); }
	ModInt operator-(const ModInt &m) const { return make(set(x + MODULO - m.x)); }
	ModInt operator*(const ModInt &m) const { return make(x * m.x % MODULO); }
	ModInt operator/(const ModInt &m) const { return make(x) * ~make(m.x); }
	ModInt &operator+=(const ModInt &m) { return *this = *this + m; }
	ModInt &operator-=(const ModInt &m) { return *this = *this - m; }
	ModInt &operator*=(const ModInt &m) { return *this = *this * m; }
	ModInt &operator/=(const ModInt &m) { return *this = *this / m; }
	ModInt &operator^=(const uint64 &y) { return *this = *this ^ y; }
	ModInt operator~ () const { return *this ^ (MODULO - 2); }
	ModInt operator- () const { return make(set(MODULO - x)); }
	ModInt operator! () const { init(uint32(*this)); return fact[uint32(*this)]; }
	ModInt operator& () const { init(uint32(*this)); return finv[uint32(*this)]; }
	ModInt operator++() { return *this = make(set(x + 1)); }
	ModInt operator--() { return *this = make(set(x + MODULO - 1)); }
	bool operator==(const ModInt &m) const { return x == m.x; }
	bool operator!=(const ModInt &m) const { return x != m.x; }
	bool operator< (const ModInt &m) const { return x <  m.x; }
	bool operator<=(const ModInt &m) const { return x <= m.x; }
	bool operator> (const ModInt &m) const { return x >  m.x; }
	bool operator>=(const ModInt &m) const { return x >= m.x; }
	explicit operator   bool() const { return x; }
	explicit operator uint64() const { return x; }
	ModInt operator^(uint64 y) const {
		uint64 t = x, u = 1;
		while (y) { if (y & 1) (u *= t) %= MODULO; (t *= t) %= MODULO; y >>= 1; }
		return make(u);
	}
	friend ostream &operator<<(ostream &os, const ModInt< MODULO > &m) { return os << m.x; }
	friend istream &operator>>(istream &is, ModInt< MODULO > &m) { uint64 y; is >> y; m = make(y); return is; }
	static vector< ModInt > fact, finv, invs;
	static void init(uint32 n) {
		uint32 m = fact.size();
		if (n < m) return;
		fact.resize(n + 1, 1);
		finv.resize(n + 1, 1);
		invs.resize(n + 1, 1);
		if (m == 0) m = 1;
		for (uint32 i = m; i <= n; ++i) fact[i] = fact[i - 1] * ModInt(i);
		finv[n] = ModInt(1) / fact[n];
		for (uint32 i = n; i >= m; --i) finv[i - 1] = finv[i] * make(i);
		for (uint32 i = m; i <= n; ++i) invs[i] = finv[i] * fact[i - 1];
	}
	static ModInt C(uint64 n, uint64 r) {
		if (r == 0) return make(1);
		if (r <  0) return make(0);
		if (n <  0) return make(r & 1 ? MODULO - 1 : 1) * C(-n + r - 1, r);
		if (n == 0 || n < r) return make(0);
		init(n);
		return fact[n] * finv[n - r] * finv[r];
	}
	static ModInt P(uint64 n, uint64 r) {
		if (n < r || r < 0) return make(0);
		init(n);
		return fact[n] * finv[n - r];
	}
	static ModInt H(uint64 n, uint64 r) {
		if (n < 0 || r < 0) return make(0);
		if (!n && !r) return make(1);
		init(n + r - 1);
		return C(n + r - 1, r);
	}
	static ModInt montmort(uint32 n) {
		ModInt res;
		init(n);
		for (uint32 k = 2; k <= n; ++k) {
			if (k & 1) res -= finv[k];
			else res += finv[k];
		}
		return res *= fact[n];
	}
	static ModInt LagrangePolynomial(vector<ModInt> &y, ModInt t) {
		uint32 n = y.size() - 1;
		if (t.x <= n) return y[t.x];
		init(n + 1);
		ModInt res, num(1);
		for (uint32 i = 0; i <= n; ++i) num *= t - make(i);
		for (uint32 i = 0; i <= n; ++i) {
			ModInt tmp = y[i] * num / (t - make(i)) * finv[i] * finv[n - i];
			if ((n - i) & 1) res -= tmp;
			else res += tmp;
		}
		return res;
	}
};
template< int MODULO >
vector<ModInt< MODULO >> ModInt< MODULO >::fact = vector<ModInt< MODULO >>();
template< int MODULO >
vector<ModInt< MODULO >> ModInt< MODULO >::finv = vector<ModInt< MODULO >>();
template< int MODULO >
vector<ModInt< MODULO >> ModInt< MODULO >::invs = vector<ModInt< MODULO >>();
using modint = ModInt< MOD >;

Compiler output:
a.cc:2:24: error: 'uint_fast32_t' does not name a type
    2 |         using uint32 = uint_fast32_t;
      |                        ^~~~~~~~~~~~~
a.cc:3:24: error: 'uint_fast64_t' does not name a type
    3 |         using uint64 = uint_fast64_t;
      |                        ^~~~~~~~~~~~~
a.cc:4:9: error: 'uint64' does not name a type
    4 |         uint64 x; ModInt() : x(0) {}
      |         ^~~~~~
a.cc:5:22: error: expected ')' before 'y'
    5 |         ModInt(uint64 y) : x(set(y % MODULO + MODULO)) {}
      |               ~      ^~
      |                      )
a.cc:6:16: error: 'uint64' does not name a type
    6 |         static uint64 set(const uint64 &y) { return (y < MODULO) ? y : y - MODULO; }
      |                ^~~~~~
a.cc:7:34: error: 'uint64' does not name a type
    7 |         static ModInt make(const uint64 &y) { ModInt ret = y; return ret; }
      |                                  ^~~~~~
a.cc:16:34: error: 'uint64' does not name a type
   16 |         ModInt &operator^=(const uint64 &y) { return *this = *this ^ y; }
      |                                  ^~~~~~
a.cc:30:27: error: expected type-specifier before 'uint64'
   30 |         explicit operator uint64() const { return x; }
      |                           ^~~~~~
a.cc:31:26: error: 'uint64' has not been declared
   31 |         ModInt operator^(uint64 y) const {
      |                          ^~~~~~
a.cc:36:16: error: 'ostream' does not name a type
   36 |         friend ostream &operator<<(ostream &os, const ModInt< MODULO > &m) { return os << m.x; }
      |                ^~~~~~~
a.cc:37:16: error: 'istream' does not name a type
   37 |         friend istream &operator>>(istream &is, ModInt< MODULO > &m) { uint64 y; is >> y; m = make(y); return is; }
      |                ^~~~~~~
a.cc:38:16: error: 'vector' does not name a type
   38 |         static vector< ModInt > fact, finv, invs;
      |                ^~~~~~
a.cc:39:26: error: 'uint32' has not been declared
   39 |         static void init(uint32 n) {
      |                          ^~~~~~
a.cc:51:25: error: 'uint64' has not been declared
   51 |         static ModInt C(uint64 n, uint64 r) {
      |                         ^~~~~~
a.cc:51:35: error: 'uint64' has not been declared
   51 |         static ModInt C(uint64 n, uint64 r) {
      |                                   ^~~~~~
a.cc:59:25: error: 'uint64' has not been declared
   59 |         static ModInt P(uint64 n, uint64 r) {
      |                         ^~~~~~
a.cc:59:35: error: 'uint64' has not been declared
   59 |         static ModInt P(uint64 n, uint64 r) {
      |                                   ^~~~~~
a.cc:64:25: error: 'uint64' has not been declared
   64 |         static ModInt H(uint64 n, uint64 r) {
      |                         ^~~~~~
a.cc:64:35: error: 'uint64' has not been declared
   64 |         static ModInt H(uint64 n, uint64 r) {
      |                                   ^~~~~~
a.cc:70:32: error: 'uint32' has not been declared
   70 |         static ModInt montmort(uint32 n) {
      |                                ^~~~~~
a.cc:79:42: error: 'vector' has not been declared
   79 |         static ModInt LagrangePolynomial(vector<ModInt> &y, ModInt t) {
      |                                          ^~~~~~
a.cc:79:48: error: expected ',' or '...' before '<' token
   79 |         static ModInt LagrangePolynomial(vector<ModInt> &y, ModInt t) {
      |                                                ^
a.cc: In constructor 'ModInt<MODULO>::ModInt()':
a.cc:4:30: error: class 'ModInt<MODULO>' does not have any field named 'x'
    4 |         uint64 x; ModInt() : x(0) {}
      |                              ^
a.cc: In member function 'ModInt<MODULO> ModInt<MODULO>::operator+(const ModInt<MODULO>&) const':
a.cc:8:67: error: 'x' was not declared in this scope
    8 |         ModInt operator+(const ModInt &m) const { return make(set(x + m.x)); }
      |                                                                   ^
a.cc: In member function 'ModInt<MODULO> ModInt<MODULO>::operator-(const ModInt<MODULO>&) const':
a.cc:9:67: error: 'x' was not declared in this scope
    9 |         ModInt operator-(const ModInt &m) const { return make(set(x + MODULO - m.x)); }
      |                                                                   ^
a.cc: In member function 'ModInt<MODULO> ModInt<MODULO>::operator*(const ModInt<MODULO>&) const':
a.cc:10:63: error: 'x' was not declared in this scope
   10 |         ModInt operator*(const ModInt &m) const { return make(x * m.x % MODULO); }
      |                                                               ^
a.cc: In member function 'ModInt<MODULO> ModInt<MODULO>::operator/(const ModInt<MODULO>&) const':
a.cc:11:63: error: 'x' was not declared in this scope
   11 |         ModInt operator/(const ModInt &m) const { return make(x) * ~make(m.x); }
      |                                                               ^
a.cc: In member function 'ModInt<MODULO> ModInt<MODULO>::operator-() const':
a.cc:18:62: error: 'x' was not declared in this scope
   18 |         ModInt operator- () const { return make(set(MODULO - x)); }
      |                                                              ^
a.cc:18:49: error: there are no arguments to 'set' that depend on a template parameter, so a declaration of 'set' must be available [-fpermissive]
   18 |         ModInt operator- () const { return make(set(MODULO - x)); }
      |                                                 ^~~
a.cc:18:49: note: (if you use '-fpermissive', G++ will accept your code, but allowing the use of an undeclared name is deprecated)
a.cc: In member function 'ModInt<MODULO> ModInt<MODULO>::operator!() const':
a.cc:19:65: error: 'fact' was not declared in this scope
   19 |         ModInt operator! () const { init(uint32(*this)); return fact[uint32(*this)]; }
      |                                                                 ^~~~
a.cc: In member function 'ModInt<MODULO> ModInt<MODULO>::operator&() const':
a.cc:20:65: error: 'finv' was not declared in this scope
   20 |         ModInt operator& () const { init(uint32(*this)); return finv[uint32(*this)]; }
      |                                                                 ^~~~
a.cc: In member function 'ModInt<MODULO> ModInt<MODULO>::operator++()':
a.cc:21:55: error: 'x' was not declared in this scope
   21 |         ModInt operator++() { return *this = make(set(x + 1)); }
      |                                                       ^
a.cc:21:51: error: there are no arguments to 'set' that depend on a template parameter, so a declaration of 'set' must be available [-fpermissive]
   21 |         ModInt operator++() { return *this = make(set(x + 1)); }
      |                                                   ^~~
a.cc: In member function 'ModInt<MODULO> ModInt<MODULO>::operator--()':
a.cc:22:55: error: 'x' was not declared in this scope
   22 |         ModInt operator--() { return *this = make(set(x + MODULO - 1)); }
      |                                                       ^
a.cc:22:51: error: there are no arguments to 'set' that depend on a template parameter, so a declaration of 'set' must be available [-fpermissive]
   22 |         ModInt operator--() { return *this = make(set(x + MODULO - 1)); }
      |                                                   ^~~
a.cc: In member function 'bool ModInt<MODULO>::operator==(const ModInt<MODULO>&) const':
a.cc:23:57: error: 'x' was not declared in this scope
   23 |         bool operator==(const ModInt &m) const { return x == m.x; }
      |                                                         ^
a.cc: In member function 'bool ModInt<MODULO>::operator!=(const ModInt<MODULO>&) const':
a.cc:24:57: error: 'x' was not declared in this scope
   24 |         bool operator!=(const ModInt &m) const { return x != m.x; }
      |                                                         ^
a.cc: In member function 'bool ModInt<MODULO>::operator<(const ModInt<MODULO>&) const':
a.cc:25:57: error: 'x' was not declared in this scope
   25 |         bool operator< (const ModInt &m) const { return x <  m.x; }
      |                                                         ^
a.cc: In member function 'bool ModInt<MODULO>::operator<=(const ModInt<MODULO>&) const':
a.cc:26:57: error: 'x' was not declared in this scope
   26 |         bool operator<=(const ModInt &m) const { return x <= m.x; }
      |                                                         ^
a.cc: In member function 'bool ModInt<MODULO>::operator>(const ModInt<MODULO>&) const':
a.cc:27:57: error: 'x' was not declared in this scope
   27 |         bool operator> (const ModInt &m) const { return x >  m.x; }
      |                                                         ^
a.cc: In member function 'bool ModInt<MODULO>::operator>=(const ModInt<MODULO>&) const':
a.cc:28:57: error: 'x' was not declared in this scope
   28 |         bool operator>=(const ModInt &m) const { return x >= m.x; }
      |                                                         ^
a.cc: In member function 'ModInt<MODULO>::operator bool() const':
a.cc:29:51: error: 'x' was not declared in this scope
   29 |         explicit operator   bool() const { return x; }
      |                                                   ^
a.cc: In member function 'ModInt<MODULO> ModInt<MODULO>::operator^(int) const':
a.cc:32:17: error: 'uint64' was not declared in this scope
   32 |                 uint64 t = x, u = 1;
      |                 ^~~~~~
a.cc:33:41: error: 'u' was not declared in this scope
   33 |                 while (y) { if (y & 1) (u *= t) %= MODULO; (t *= t) %= MODULO; y >>= 1; }
      |                                         ^
a.cc:33:46: error: 't' was not declared in this scope
   33 |                 while (y) { if (y & 1) (u *= t) %= MODULO; (t *= t) %= MODULO; y >>= 1; }
      |                                              ^
a.cc:33:61: error: 't' was not declared in this scope
   33 |                 while (y) { if (y & 1) (u *= t) %= MODULO; (t *= t) %= MODULO; y >>= 1; }
      |                                                             ^
a.cc:34:29: error: 'u' was not declared in this scope
   34 |