#include <bits/stdc++.h>
using ll = long long;
using ld = long double;
using ull = unsigned long long;
constexpr int N = 1e5 + 10;
constexpr int inf = 1e9 + 10;
constexpr ll llinf = 1e18 + 10;
constexpr int mod = 998244353;
void debug() {
    std::cerr << "\n";
}
template<typename T, typename... Args>
void debug(T val, const Args&... args) {
    std::cerr << val << " ";
    debug(args...);
}
template<typename T>
void debug(const std::vector<T>& vec) {
    for (const T& x : vec) std::cerr << x << ' ';std::cerr << "\n";
}
template <int sz>//sz为模数的数量
struct str_hash
{
    static constexpr int base[] = { 131, 131,13331,13331 };
    static constexpr int mod[] = { (int)(1e9 + 7), (int)(1e9 + 9),(int)(1e9 + 7), (int)(1e9 + 9) };
    int n;
    std::string s;
    std::vector<std::array<int, sz>> p, h, rh;
    str_hash() = default;
    str_hash(std::string _s) : n(_s.size()), s(' ' + _s), p(_s.size() + 1), h(_s.size() + 1), rh(_s.size() + 2)
    {
        assert(_s[0] != ' ');
        for (int i = 0; i < sz; i++)
            p[0][i] = 1;
        for (int i = 1; i <= n; i++)
            for (int j = 0; j < sz; j++)
                p[i][j] = 1ll * p[i - 1][j] * base[j] % mod[j];
        for (int i = 1; i <= n; i++)
            for (int j = 0; j < sz; j++)
                h[i][j] = (1ll * h[i - 1][j] * base[j] + s[i]) % mod[j];
        for (int i = n; i; i--)
            for (int j = 0; j < sz; j++)
                rh[i][j] = (1ll * rh[i + 1][j] * base[j] + s[i]) % mod[j];
    }
    std::array<int, sz> query(int l, int r, int op = 0)
    {
        if (l == r + 1) return std::array<int, sz>{};
        // debug(l, r);
        assert(1 <= l && r <= n);
        std::array<int, sz> ans;
        if (l > r)
            return ans;
        if (!op)
        {
            for (int i = 0; i < sz; i++)
                ans[i] = (h[r][i] - 1ll * h[l - 1][i] * p[r - l + 1][i] % mod[i] + mod[i]) % mod[i];
            return ans;
        }
        else
        {
            for (int i = 0; i < sz; i++)
                ans[i] = (rh[l][i] - 1ll * rh[r + 1][i] * p[r - l + 1][i] % mod[i] + mod[i]) % mod[i];
            return ans;
        }
    }
    bool is_pali(int l, int r)
    {
        return query(l, r, 0) == query(l, r, 1);
    }
};
template <typename T>
T power(T a, int b) {
    T ans = 1;
    while (b) {
        if (b & 1) ans *= a;
        a *= a;
        b >>= 1;
    }
    return ans;
}
template <int M>
struct modint {
    modint() : x(0) {}
    template <typename T> modint(T n) { n %= M; if (n < 0) n += M; this->x = n; }

    modint& operator+=(const modint& r) { x += r.x; if (x >= M) x -= M; return *this; }
    modint& operator-=(const modint& r) { x -= r.x; if (x < 0) x += M; return *this; }
    modint& operator*=(const modint& r) { x = (int)((long long)x * r.x % M); return *this; }
    modint inv(long long k = M - 2) const { return power(*this, k); }
    modint& operator/=(const modint& r) { return *this *= r.inv(); }

    modint& operator--() { if (--x == -1) x = M - 1; return *this; }
    modint& operator++() { if (++x == M) x = 0; return *this; }
    modint operator--(int) { modint t = *this; --*this; return t; }
    modint operator++(int) { modint t = *this; ++*this; return t; }

    modint operator-() const { return 0 - *this; }
    modint operator+() const { return *this; }
    constexpr int mod() const { return M; }

    friend modint operator+(modint l, const modint& r) { return l += r; }
    friend modint operator-(modint l, const modint& r) { return l -= r; }
    friend modint operator*(modint l, const modint& r) { return l *= r; }
    friend modint operator/(modint l, const modint& r) { return l /= r; }

    friend bool operator==(const modint& l, const modint& r) { return l.x == r.x; }
    friend bool operator!=(const modint& l, const modint& r) { return l.x != r.x; }
    friend std::istream& operator>>(std::istream& in, modint& r) { return in >> r.x; }
    friend std::ostream& operator<<(std::ostream& out, const modint& r) { return out << r.x; }

    int x;
};
using mint = modint<998244353>;

void ncl3() {
    std::string s, t;
    std::cin >> s >> t;
    int n = s.size(), m = t.size();
    str_hash<2> hs(s), ht(t);
    std::vector<int> R(n + 1);
    for (int i = 1; i <= n; i++) {
        int j = i;
        int l = 0, r = std::min(m, n - j + 1);
        while (l < r) {
            int mid = (l + r + 1) / 2;
            if (hs.query(j, j + mid - 1) == ht.query(1, mid))
                l = mid;
            else r = mid - 1;
        }
        if (l + 1 >= m || j + l >= n) {
            R[i] = std::min(n, i + m - 1);
            continue;
        }
        int l1 = l + 2;
        j = std::min(n, i + l + 1);
        l = 0, r = std::min(m - l1 + 1, n - j + 1);
        while (l < r) {
            int mid = (l + r + 1) / 2;
            if (hs.query(j, j + mid - 1) == ht.query(l1, l1 + mid - 1))
                l = mid;
            else r = mid - 1;
        }
        j = j + l - 1;
        R[i] = j;
    }
    std::vector<std::array<mint, 3>> dp(n + 2);
    dp[1][0] = 1;dp[2][0] = -1;
    for (int i = 1; i <= n; i++) {
        for (int j = 0; j < 3; j++) dp[i][j] += dp[i - 1][j];
        if (i + 1 <= n + 1)
            dp[i + 1][0] += dp[i][0];
        if (R[i] + 2 <= n + 1)
            dp[R[i] + 2][0] -= dp[i][0];
        if (i + 1 <= n + 1)
            dp[i + 1][1] += dp[i][1] + (1 * dp[i][0]);
        if (R[i] + 2 <= n + 1)
            dp[R[i] + 2][1] -= dp[i][1] + (1 * dp[i][0]);
        if (i + 1 <= n + 1)
            dp[i + 1][2] += dp[i][2] + 2 * dp[i][1] + (1 * dp[i][0]);
        if (R[i] + 2 <= n + 1)
            dp[R[i] + 2][2] -= dp[i][2] + 2 * dp[i][1] + (1 * dp[i][0]);
        // debug(R[i]);
        // debug(dp[i][0], dp[i][1], dp[i][2], R[i]);
    }
    for (int j = 0; j < 3; j++) dp[n + 1][j] += dp[n][j];
    // debug(dp[n + 1][0], dp[n + 1][1], dp[n + 1][2]);
    std::cout << dp[n + 1][2] << "\n";
}
/*
    预处理、找性质缩小范围、集合思想、正难则反、穷举
*/
int main() {
#ifdef LOCAL
    clock_t time = clock();
    freopen("in.txt", "r", stdin);
    freopen("out.txt", "w", stdout);
#endif
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    int t = 1;
    // std::cin >> t;
    while (t--) {
        ncl3();
    }
#ifdef LOCAL
    std::cout << "Time Used:" << clock() - time << "ms" << "\n";
#endif
    return 0;
}