#pragma GCC optimize("Ofast,no-stack-protector,inline,fast-math,unroll-loops") #include <iostream> #include <vector> using namespace std; using i64 = long long; template <int mod> struct Modular { int val; Modular(i64 num = 0) : val(num % mod) { if (val < 0) val += mod; } friend Modular operator+(const Modular& lhs, const Modular& rhs) { return lhs.val + rhs.val; } friend Modular operator-(const Modular& lhs, const Modular& rhs) { return lhs.val - rhs.val; } Modular operator-() const { return -val; } friend Modular operator*(const Modular& lhs, const Modular& rhs) { return i64(lhs.val) * rhs.val; } friend Modular operator^(Modular base, Modular<mod - 1> power) { Modular res = 1; for (; power.val > 0; power.val >>= 1, base *= base) { if (power.val & 1) res *= base; } return res; } Modular operator~() const { int power = mod - 2; Modular res = 1, base = val; for (; power > 0; power >>= 1, base *= base) { if (power & 1) res *= base; } return res; } friend Modular operator/(const Modular& lhs, const Modular& rhs) { return lhs * ~rhs; } friend Modular& operator+=(Modular& lhs, const Modular& rhs) { return lhs = lhs + rhs; } friend Modular& operator-=(Modular& lhs, const Modular& rhs) { return lhs = lhs - rhs; } friend Modular& operator*=(Modular& lhs, const Modular& rhs) { return lhs = lhs * rhs; } friend Modular& operator/=(Modular& lhs, const Modular& rhs) { return lhs = lhs / rhs; } friend Modular& operator^=(Modular& lhs, const Modular<mod - 1>& rhs) { return lhs = lhs ^ rhs; } friend bool operator==(const Modular& lhs, const Modular& rhs) { return lhs.val == rhs.val; } friend bool operator!=(const Modular& lhs, const Modular& rhs) { return lhs.val != rhs.val; } friend istream& operator>>(istream& is, Modular& res) { char ch = is.get(); int sign = 1; res = 0; while (!isdigit(ch)) { ch = is.get(); if (ch == '-') sign = -sign; } res = ch - '0'; ch = is.get(); while (isdigit(ch)) { res = res * 10 + (ch - '0'); ch = is.get(); } return is; } friend ostream& operator<<(ostream& os, const Modular& res) { return os << res.val; } }; constexpr int N = 3000, MOD = 998244353; using mint = Modular<MOD>; template <class T, int deg> struct ModPoly { int align; ModPoly(int spacing = 1) : align(spacing) , terms(deg + 1) { } vector<T> get_coeff() const { return terms; } T& operator[](int power) { return terms[power]; } const T& operator[](int power) const { return terms[power]; } friend ModPoly operator+(ModPoly lhs, const ModPoly& rhs) { for (int i = 0; i <= deg; i += rhs.align) { if (rhs[i] != 0) lhs[i] += rhs[i]; } return lhs; } friend ModPoly operator-(ModPoly lhs, const ModPoly& rhs) { for (int i = 0; i <= deg; i += rhs.align) { if (rhs[i] != 0) lhs[i] -= rhs[i]; } return lhs; } ModPoly operator-() const { return ModPoly() - *this; } friend ModPoly operator*(const ModPoly& lhs, const ModPoly& rhs) { ModPoly res; for (int i = 0; i <= deg; i += lhs.align) { if (lhs[i] == 0) continue; for (int j = 0; i + j <= deg; j += rhs.align) { if (rhs[j] != 0) res[i + j] += lhs[i] * rhs[j]; } } return res; } friend ModPoly& operator+=(ModPoly& lhs, const ModPoly& rhs) { return lhs = lhs + rhs; } friend ModPoly& operator-=(ModPoly& lhs, const ModPoly& rhs) { return lhs = lhs - rhs; } friend ModPoly& operator*=(ModPoly& lhs, const ModPoly& rhs) { return lhs = lhs * rhs; } private: vector<T> terms; }; mint inv[N + 1], fact[N + 1], ifact[N + 1]; ModPoly<mint, N> g; void prepare() { inv[1] = fact[0] = fact[1] = ifact[0] = ifact[1] = 1; for (int i = 2; i <= N; ++i) { inv[i] = inv[MOD % i] * (-MOD / i); fact[i] = fact[i - 1] * i; ifact[i] = ifact[i - 1] * inv[i]; } } mint solve(int n, int k) { ModPoly<mint, N> f(k); for (int i = k; i <= n; i += k) f[i] = -(ifact[i] ^ n); ModPoly<mint, N> ans; auto pow_f = f; for (int i = 0; i < (n + k - 1) / k; ++i) { ans += pow_f; pow_f *= f; } ans *= g; return ((n + k - 1) / k & 1 ? 1 : -1) * (fact[n] ^ n) * ans[n]; } int main() { ios::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr); int n, l, r; cin >> n >> l >> r; prepare(); for (int i = 1; i <= n; ++i) g[i] = ifact[i] ^ n; for (int i = l; i <= r; ++i) cout << solve(n, i) << ' '; return 0; }