#pragma GCC optimize("Ofast, inline")
#include <bits/stdc++.h>
using namespace std;
char BUFF[262144], *BB, *BE;
#define gc() (BB == BE ? (BE = (BB = BUFF) + fread(BUFF, 1, 262144, stdin), BB == BE ? EOF : *BB++) : *BB++)
void read() {}
template<class T, class...Ts>void read(T &x, Ts &...args) {
    x = 0;
    char c = 0, w = 0;

    while (c < 48 || c > 57)
        w |= c == '-', c = gc();

    while (c > 47 && c < 58)
        x = x * 10 + (c ^ 48), c = gc();

    if (w)
        x = -x;

    read(args...);
}
#define mod 998244353
int neg(int x) {
    return x ? mod - x : 0;
}
int quo2(int x) {
    return (x + (x & 1 ? mod : 0)) >> 1;
}
void add(int &x, int y) {
    if ((x += y - mod) < 0)
        x += mod;
}
void sub(int &x, int y) {
    if ((x -= y) < 0)
        x += mod;
}
int mpow(int a, int b) {
    int ret = 1;

    for (; b; b >>= 1) {
        if (b & 1)
            ret = (long long)ret * a % mod;

        a = (long long)a * a % mod;
    }

    return ret;
}

const int BRUTE_N2_LIMIT = 50;

struct NumberTheory {
    using pii = pair<int, int>;
    mt19937 rng;
    NumberTheory(): rng(chrono::steady_clock::now().time_since_epoch().count()) {}
    void exGcd(int a, int b, int &x, int &y) {
        if (!b) {
            x = 1, y = 0;
            return;
        }

        exGcd(b, a % b, y, x), y -= a / b * x;
    }
    int inv(int a, int p = mod) {
        int x, y;
        exGcd(a, p, x, y);

        if (x < 0)
            x += p;

        return x;
    }
} nt;

namespace Simple {
int n = 1;
vector<int> fac({1, 1}), ifac({1, 1}), inv({0, 1});
void build(int m) {
    n = m;
    fac.resize(n + 1), ifac.resize(n + 1), inv.resize(n + 1);
    inv[1] = 1;

    for (int i = 2; i <= n; ++i)
        inv[i] = (long long)(mod - mod / i) * inv[mod % i] % mod;

    fac[0] = ifac[0] = 1;

    for (int i = 1; i <= n; ++i)
        fac[i] = (long long)fac[i - 1] * i % mod, ifac[i] = (long long)ifac[i - 1] * inv[i] % mod;
}
void check(int k) {
    int m = n;

    if (k > m) {
        while (k > m)
            m <<= 1;

        build(m);
    }
}
int ginv(int k) {
    check(k);
    return inv[k];
}
}

struct SimpleSequence {
    function<int(int)> func;
    SimpleSequence(const function<int(int)> &func): func(func) {}
    int operator[](int k) const {
        return func(k);
    }
} ginv(Simple::ginv);

namespace NTT {
int L = -1;
vector<int> root;
void init(int l) {
    L = l;
    root.resize((1 << L) + 1);
    int n = 1 << L, *w = root.data();
    w[0] = 1, w[1 << L] = mpow(31, 1 << (21 - L));

    for (int i = L; i; --i)
        w[1 << (i - 1)] = (long long)w[1 << i] * w[1 << i] % mod;

    for (int i = 1; i < n; ++i)
        w[i] = (long long)w[i & (i - 1)] * w[i & -i] % mod;
}
void DIF(int *a, int l) {
    int n = 1 << l;

    for (int len = n >> 1; len; len >>= 1)
        for (int *j = a, *o = root.data(); j != a + n; j += len << 1, ++o)
            for (int *k = j; k != j + len; ++k) {
                int r = (long long) * o * k[len] % mod;
                k[len] = (*k - r < 0 ? *k - r + mod : *k - r), add(*k, r);
            }
}
void DIT(int *a, int l) {
    int n = 1 << l;

    for (int len = 1; len < n; len <<= 1)
        for (int *j = a, *o = root.data(); j != a + n; j += len << 1, ++o)
            for (int *k = j; k != j + len; ++k) {
                int r = *k + k[len] >= mod ? *k + k[len] - mod : *k + k[len];
                k[len] = (long long) * o * (*k - k[len] + mod) % mod, *k = r;
            }
}
void fft(int *a, int lgn, int d = 1) {
    if (L < lgn)
        init(lgn);

    int n = 1 << lgn;

    if (d == 1)
        DIF(a, lgn);
    else {
        DIT(a, lgn), reverse(a + 1, a + n);
        int nInv = mod - (mod - 1) / n;

        for (int i = 0; i < n; ++i)
            a[i] = (long long)a[i] * nInv % mod;
    }
}
}

struct poly {
    vector<int> a;
    poly(long long v = 0): a(1) {
        if ((v %= mod) < 0)
            v += mod;

        a[0] = v;
    }
    poly(const poly &o): a(o.a) {}
    poly(const vector<int> &o): a(o) {}
    poly(initializer_list<int> o): a(o) {}
    operator vector<int>() const {
        return a;
    }
    int operator[](int k) const {
        return k < a.size() ? a[k] : 0;
    }
    int &operator[](int k) {
        if (k >= a.size())
            a.resize(k + 1);

        return a[k];
    }
    int deg() const {
        return (int)a.size() - 1;
    }
    void redeg(int d) {
        a.resize(d + 1);
    }
    int size() const {
        return a.size();
    }
    void resize(int s) {
        a.resize(s);
    }
    poly slice(int d) const {
        if (d < a.size())
            return vector<int>(a.begin(), a.begin() + d + 1);

        vector<int> ret = a;
        ret.resize(d + 1);
        return ret;
    }
    poly shift(int k) const {
        if (size() + k <= 0)
            return 0;

        vector<int> ret(size() + k);

        for (int i = max(0, k); i < ret.size(); ++i)
            ret[i] = a[i - k];

        return ret;
    }
    bool operator<(const poly &o) const {
        for (int i = 0; i <= min(deg(), o.deg()); ++i)
            if (a[i] != o[i])
                return a[i] < o[i];

        return deg() < o.deg();
    }
    int *base() {
        return a.data();
    }
    const int *base() const {
        return a.data();
    }
    poly println(FILE *fp = stdout) const {
        for (int i = 0; i < a.size(); ++i)
            fprintf(fp, "%d%c", a[i], " \n"[i == a.size() - 1]);

        return *this;
    }

    poly &operator+=(const poly &o) {
        if (o.size() > a.size())
            a.resize(o.size());

        for (int i = 0; i < o.size(); ++i)
            add(a[i], o[i]);

        return *this;
    }
    poly operator+(const poly &o) const {
        poly ret(a);
        ret += o;
        return ret;
    }
    poly operator-() const {
        poly ret = a;

        for (int i = 0; i < a.size(); ++i)
            ret[i] = neg(ret[i]);

        return ret;
    }
    poly &operator-=(const poly &o) {
        return operator+=(-o);
    }
    poly operator-(const poly &o) {
        return operator+(-o);
    }
    poly operator*(const poly &) const;
    poly operator/(const poly &) const;
    poly operator%(const poly &) const;
    poly deriv()const;
    poly integ()const;
    poly inv()const;
    poly ln() const;
    poly quo(const poly &) const;
    pair<poly, poly> div(const poly &) const;
    poly pow(int k) const;
};

poly zeroes(int d) {
    return vector<int>(d + 1);
}

namespace NTT {
void fft(poly &a, int lgn, int d = 1) {
    fft(a.base(), lgn, d);
}
void fft(vector<int> &a, int lgn, int d = 1) {
    fft(a.data(), lgn, d);
}
}

using NTT::fft;
struct Newton {
    void inv(const poly &f, const poly &dftf, poly &g, const poly &dftg, int t) {
        int n = 1 << t;
        poly prod = dftf;

        for (int i = 0; i < (n << 1); ++i)
            prod[i] = (long long)prod[i] * dftg[i] % mod;

        fft(prod, t + 1, -1);
        memset(prod.base(), 0, sizeof(int) << t);
        fft(prod, t + 1);

        for (int i = 0; i < (n << 1); ++i)
            prod[i] = (long long)prod[i] * dftg[i] % mod;

        fft(prod, t + 1, -1);

        for (int i = 0; i < n; ++i)
            prod[i] = 0;

        g -= prod;
    }
    void inv(const poly &f, const poly &dftf, poly &g, int t) {
        poly dftg(g);
        dftg.resize(2 << t);
        fft(dftg, t + 1);
        inv(f, dftf, g, dftg, t);
    }
    void inv(const poly &f, poly &g, int t) {
        poly dftf(f), dftg(g);
        dftf.resize(2 << t), dftg.resize(2 << t);
        fft(dftf, t + 1), fft(dftg, t + 1);
        inv(f, dftf, g, dftg, t);
    }
} nit;
poly poly::operator*(const poly &o) const {
    int n = deg(), m = o.deg();

    if (0 && (n <= 10 || m <= 10 || n + m <= BRUTE_N2_LIMIT)) {
        poly ret = zeroes(n + m);

        for (int i = 0; i <= n; ++i)
            for (int j = 0; j <= m; ++j)
                ret[i + j] = (ret[i + j] + (long long)a[i] * o[j]) % mod;

        return ret;
    }

    n += m;
    int l = 0;

    while ((1 << l) <= n)
        ++l;

    poly ret = a, tmp = o;
    ret.resize(1 << l), tmp.resize(1 << l);
    fft(ret, l), fft(tmp, l);

    for (int i = 0; i < (1 << l); ++i)
        ret[i] = (long long)ret[i] * tmp[i] % mod;

    fft(ret, l, -1);
    return ret.slice(n);
}
poly poly::inv() const {
    poly g = nt.inv(a[0]);

    for (int t = 0; (1 << t) <= deg(); ++t)
        nit.inv(slice((2 << t) - 1), g, t);

    g.redeg(deg());
    return g;
}
poly poly::pow(int k) const {
    if (k == 0)
        return 1;

    if (k == 1)
        return *this;

    int n = deg() * k;
    int l = 0;

    while ((1 << l) <= n)
        ++l;

    poly ret = a;
    ret.resize(1 << l), fft(ret, l);

    for (int i = 0; i < (1 << l); ++i)
        ret[i] = mpow(ret[i], k);

    fft(ret, -1);
    return ret.slice(n);
}
poly poly::deriv() const {
    if (deg() == 0)
        return 0;

    vector<int> ret(deg());

    for (int i = 0; i < deg(); ++i)
        ret[i] = (long long)a[i + 1] * (i + 1) % mod;

    return ret;
}
poly poly::integ() const {
    vector<int> ret(size() + 1);

    for (int i = 0; i <= deg(); ++i)
        ret[i + 1] = (long long)a[i] * ginv[i + 1] % mod;

    return ret;
}
poly poly::quo(const poly &o) const {
    if (o.deg() == 0)
        return (long long)a[0] * nt.inv(o[0]) % mod;

    poly g = nt.inv(o[0]);
    int t = 0, n;

    for (n = 1; (n << 1) <= o.deg(); ++t, n <<= 1)
        nit.inv(o.slice((n << 1) - 1), g, t);

    poly dftg = g;
    dftg.resize(n << 1), fft(dftg, t + 1);
    poly eps1 = o;
    eps1.resize(n << 1), fft(eps1, t + 1);

    for (int i = 0; i < (n << 1); ++i)
        eps1[i] = (long long)eps1[i] * dftg[i] % mod;

    fft(eps1, t + 1, -1);

    for (int i = 0; i < n; ++i)
        eps1[i] = eps1[i + n], eps1[i + n] = 0;

    fft(eps1, t + 1);
    poly h0 = slice(n - 1);
    h0.resize(n << 1), fft(h0, t + 1);
    poly h0g0 = zeroes((n << 1) - 1);

    for (int i = 0; i < (n << 1); ++i)
        h0g0[i] = (long long)h0[i] * dftg[i] % mod;

    fft(h0g0, t + 1, -1);
    poly h0eps1 = zeroes((n << 1) - 1);

    for (int i = 0; i < (n << 1); ++i)
        h0eps1[i] = (long long)h0[i] * eps1[i] % mod;

    fft(h0eps1, t + 1, -1);

    for (int i = 0; i < n; ++i)
        h0eps1[i] = (operator[](i + n) - h0eps1[i] < 0 ? operator[](i + n) - h0eps1[i] + mod : operator[](
                         i + n) - h0eps1[i]);

    memset(h0eps1.base() + n, 0, sizeof(int) << t);
    fft(h0eps1, t + 1);

    for (int i = 0; i < (n << 1); ++i)
        h0eps1[i] = (long long)h0eps1[i] * dftg[i] % mod;

    fft(h0eps1, t + 1, -1);

    for (int i = 0; i < n; ++i)
        h0eps1[i + n] = h0eps1[i], h0eps1[i] = 0;

    return (h0g0 + h0eps1).slice(o.deg());
}
poly poly::ln() const {
    if (deg() == 0)
        return 0;

    return deriv().quo(slice(deg() - 1)).integ();
}
poly poly::operator/(const poly &o) const {
    int n = deg(), m = o.deg();

    if (n < m)
        return 0;

    poly ta(vector<int>(a.rbegin(), a.rend())), tb(vector<int>(o.a.rbegin(), o.a.rend()));
    ta.redeg(n - m), tb.redeg(n - m);
    poly q = ta.quo(tb);
    return vector<int>(q.a.rbegin(), q.a.rend());
}
pair<poly, poly> poly::div(const poly &o) const {
    if (deg() < o.deg())
        return make_pair(0, *this);

    int n = deg(), m = o.deg();
    poly q = operator/(o), r;
    int l = 0;

    while ((1 << l) < o.deg())
        ++l;

    int t = (1 << l) - 1;
    poly tmp = zeroes(t);
    r = zeroes(t);

    for (int i = 0; i <= m; ++i)
        add(r[i & t], o[i]);

    for (int i = 0; i <= n - m; ++i)
        add(tmp[i & t], q[i]);

    fft(r, l), fft(tmp, l);

    for (int i = 0; i <= t; ++i)
        tmp[i] = (long long)tmp[i] * r[i] % mod;

    fft(tmp, l, -1);
    memset(r.base(), 0, sizeof(int) << l);

    for (int i = 0; i <= n; ++i)
        add(r[i & t], a[i]);

    for (int i = 0; i < m; ++i)
        sub(r[i], tmp[i]);

    return make_pair(q, r.slice(m - 1));
}
poly poly::operator%(const poly &o) const {
    return div(o).second;
}

const int N = 5e5;

int l, r, c;

poly f, g, h;
int a[N + 5], b[N + 5], da[N + 5], db[N + 5], tda[N + 5], tdb[N + 5];

int ans;

struct RelaxedConvolution {
    static const int LG = 19;
    static const int B = 16;
    void run(int *a, int *b, int *da, int *db, int n, const function<void(int)> &relax) {
        vector<vector<int>> savea(LG + 1), saveb(LG + 1), saveda(LG + 1), savedb(LG + 1);
        function<void(int, int)> divideConquer = [&](int l, int r) {
            if (r - l <= BRUTE_N2_LIMIT) {
                for (int i = l + 1; i <= r; ++i) {
                    for (int j = l; j < i; ++j)
                        a[i] = (a[i] + (long long)a[j] * da[i - j]) % mod,
                               b[i] = (b[i] + (long long)b[j] * db[i - j]) % mod;

                    if (l > 0)
                        for (int j = l; j < i; ++j)
                            a[i] = (a[i] + (long long)da[j] * a[i - j]) % mod,
                                   b[i] = (b[i] + (long long)db[j] * b[i - j]) % mod;

                    relax(i);
                }

                return ;
            }

            if (l == 0) {
                int mid = ((l + r) >> 1) + 5;
                divideConquer(l, mid);
                int lgd = 0;

                for (; (1 << lgd) <= r; ++lgd);

                vector<int> ta(1 << lgd), tb(1 << lgd), tda(1 << lgd), tdb(1 << lgd);

                for (int i = 0; i < mid; ++i)
                    ta[i] = a[i], tb[i] = b[i], tda[i] = da[i], tdb[i] = db[i];

                fft(ta, lgd), fft(tb, lgd), fft(tda, lgd), fft(tdb, lgd);

                for (int i = 0; i < (1 << lgd); ++i)
                    ta[i] = (long long)ta[i] * tda[i] % mod,
                            tb[i] = (long long)tb[i] * tdb[i] % mod;

                fft(ta, lgd, -1), fft(tb, lgd, -1);

                for (int i = mid + 1; i <= r; ++i)
                    add(a[i], ta[i]), add(b[i], tb[i]);

                divideConquer(mid, r);
                return ;
            }

            int d = (r - l) / B + 1, lgd = 0, lg;

            for (; (1 << lgd) <= d * 2; ++lgd);

            d = (1 << (lgd - 1)) - 1, lg = (r - l + d - 1) / d;

            auto dfta = savea[lgd], dftb = saveb[lgd], dftda = saveda[lgd], dftdb = savedb[lgd];
            dfta.resize(lg << (lgd + 1)), dftb.resize(lg << (lgd + 1)),
                        dftda.resize(lg << (lgd + 1)), dftdb.resize(lg << (lgd + 1));

            for (int i = lg << lgd; i < (lg << (lgd + 1)); ++i)
                dfta[i] = dftb[i] = dftda[i] = dftdb[i] = 0;

            int ef = lg;

            for (int i = 0; i < lg; ++i) {
                if ((i << lgd) < savea[lgd].size())
                    continue;

                if ((i + 2) * d >= l)
                    --ef;

                for (int j = 0; j <= min(d * 2, n - i * d); ++j)
                    dfta[(i << lgd) + j] = a[i * d + j],
                                           dftb[(i << lgd) + j] = b[i * d + j],
                                                   dftda[(i << lgd) + j] = da[i * d + j],
                                                           dftdb[(i << lgd) + j] = db[i * d + j];

                fft(dfta.data() + (i << lgd), lgd), fft(dftb.data() + (i << lgd), lgd),
                    fft(dftda.data() + (i << lgd), lgd), fft(dftdb.data() + (i << lgd), lgd);
            }

            if (savea[lgd].size() < (ef << lgd)) {
                savea[lgd] = vector<int>(dfta.begin(), dfta.begin() + (ef << lgd)),
                             saveb[lgd] = vector<int>(dftb.begin(), dftb.begin() + (ef << lgd)),
                                          saveda[lgd] = vector<int>(dftda.begin(), dftda.begin() + (ef << lgd)),
                                                        savedb[lgd] = vector<int>(dftdb.begin(), dftdb.begin() + (ef << lgd));
            }

            for (int i = 0; i < lg; ++i) {
                if (i)
                    fft(dfta.data() + ((lg + i) << lgd), lgd, -1), fft(dftb.data() + ((lg + i) << lgd), lgd, -1);

                for (int j = 1; j <= min(d, r - l - i * d); ++j)
                    add(a[l + i * d + j], dfta[((lg + i) << lgd) + d + j]),
                        add(b[l + i * d + j], dftb[((lg + i) << lgd) + d + j]);

                divideConquer(l + i * d, min(l + (i + 1) * d, r));

                if (i + 1 < lg) {
                    for (int j = 0; j < d; ++j)
                        dfta[((lg + i) << lgd) + j] = a[l + i * d + j],
                                                      dftb[((lg + i) << lgd) + j] = b[l + i * d + j],
                                                              dftda[((lg + i) << lgd) + j] = da[l + i * d + j],
                                                                      dftdb[((lg + i) << lgd) + j] = db[l + i * d + j];

                    for (int j = d; j < (1 << lgd); ++j)
                        dfta[((lg + i) << lgd) + j] = dftb[((lg + i) << lgd) + j] = 0;

                    fft(dfta.data() + ((lg + i) << lgd), lgd), fft(dftb.data() + ((lg + i) << lgd), lgd),
                    fft(dftda.data() + ((lg + i) << lgd), lgd), fft(dftdb.data() + ((lg + i) << lgd), lgd);
                }

                for (int j = i + 1; j < lg; ++j)
                    for (int k = 0; k < (1 << lgd); ++k)
                        dfta[((lg + j) << lgd) + k] = (dfta[((lg + j) << lgd) + k] +
                                                       (long long)dfta[((j - i - 1) << lgd) + k] * dftda[((lg + i) << lgd) + k] +
                                                       (long long)dftda[((j - i - 1) << lgd) + k] * dfta[((lg + i) << lgd) + k]
                                                      ) % mod,
                                                      dftb[((lg + j) << lgd) + k] = (dftb[((lg + j) << lgd) + k] +
                                                              (long long)dftb[((j - i - 1) << lgd) + k] * dftdb[((lg + i) << lgd) + k] +
                                                              (long long)dftdb[((j - i - 1) << lgd) + k] * dftb[((lg + i) << lgd) + k]
                                                                                    ) % mod;
            }
        };
        relax(0), divideConquer(0, n);
    }
} rc;

int main() {
    scanf("%d%d%d", &l, &r, &c);

    g.redeg(r), h.redeg(r), rc.run(a, b, da, db, r, [&](int k) {
        if (k == 0) {
            a[k] = b[k] = 1;
            return ;
        }

        a[k] = (long long)(a[k] + tda[k]) * ginv[k] % mod,
        b[k] = (long long)(b[k] + tdb[k]) * ginv[k] % mod,
        h[k] = (long long)a[k - 1] * c % mod, add(b[k], h[k]),
        g[k] = (long long)(b[k] - a[k] + mod) * c % mod, add(a[k], g[k]),
        add(b[k], g[k]);
        int v1 = (long long)g[k] * k % mod, v2 = (long long)(g[k] + h[k]) * k % mod;

        for (int i = k; i <= r; i += k)
            add(tda[i], v1), add(tdb[i], v2);

        da[k] = tda[k], db[k] = tdb[k];
    });

    f = -(g * g).slice(r) - (h * h).shift(-1).slice(r);

    for (int i = 1; i * 2 <= r; ++i)
        add(f[i * 2], g[i]);

    for (int i = 1; i * 2 - 1 <= r; ++i)
        add(f[i * 2 - 1], h[i]);

    for (int i = 1; i <= r; ++i)
        f[i] = quo2(f[i]);

    f += g + h - (g * h).slice(r);

    ans = accumulate(f.base() + l, f.base() + r + 1, 0LL) % mod;
    printf("%d", ans);
}