#include <bits/stdc++.h>

#define lsb(x) (x & (-x))

using ull = unsigned long long;
using ll = long long;

using namespace std;

constexpr int MOD1 = (int) 1e9 + 7;
constexpr int MOD2 = (int) 1e9 + 9;
constexpr int B = 37;

inline void add(int& x, int y, int md) {
    x += y;
    if (x >= md)
        x -= md;
}

inline void mul(int& x, int y, int md) {
    x = (1LL * x * y) % md;
}

struct Hash {
    Hash() {
        val1 = val2 = 0;
    }

    Hash(int val) {
        val1 = val;
        val2 = val;
    }

    Hash(const Hash& rhs) {
        val1 = rhs.val1;
        val2 = rhs.val2;
    }

    Hash operator+(int x) {
        Hash res = *this;
        add(res.val1, x, MOD1);
        add(res.val2, x, MOD2);
        return res;
    }

    Hash operator-(const Hash& rhs) {
        Hash res = *this;
        add(res.val1, MOD1 - rhs.val1, MOD1);
        add(res.val2, MOD2 - rhs.val2, MOD2);
        return res;
    }

    Hash operator*(int x) {
        Hash res = *this;
        mul(res.val1, x, MOD1);
        mul(res.val2, x, MOD2);
        return res;
    }

    Hash& operator=(const Hash& rhs) {
        val1 = rhs.val1;
        val2 = rhs.val2;
        return *this;
    }

    Hash operator*(const Hash& rhs) {
        Hash res = *this;
        mul(res.val1, rhs.val1, MOD1);
        mul(res.val2, rhs.val2, MOD2);
        return res;
    }

    bool operator==(const Hash& rhs) const {
        return val1 == rhs.val1 && val2 == rhs.val2;
    }

    int val1, val2;
};

constexpr int MOD = 998244353;
constexpr int MAXN = (int) 1e6 + 5;

Hash pref_t[MAXN + 1], pref_s[MAXN + 1];
Hash power[MAXN + 1];

char S[MAXN + 1];
char T[MAXN + 1];

// template<size_t N>
// struct Fenwick {
// public:
//     inline void update(int pos, int val) {
//         pos++;
//         for (int i = pos; i <= N; i += lsb(i)) {
//             add(fen[i], val, MOD);
//         }
//     }

//     inline int query(int pos) {
//         pos++;
//         int answer = 0;
//         for (int i = pos; i > 0; i -= lsb(i)) {
//             add(answer, fen[i], MOD);
//         }
//         return answer;
//     }

// private:
//     int fen[N + 1];  
// };

// Fenwick<MAXN + 5> s2, dp, cnt;

int s2[MAXN + 1], dp[MAXN + 1], cnt[MAXN + 1];

int main() {
#ifdef HOME
    ifstream cin("input.in");
    ofstream cout("output.out");
#endif
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);

    cin >> (S + 1);
    cin >> (T + 1);

    int ns = strlen(S + 1);
    for (int i = 1; i <= ns; i++) {
        pref_s[i] = pref_s[i - 1] * B + S[i] - 'a' + 1;
    }

    int nt = strlen(T + 1);
    power[0] = 1;
    for (int i = 1; i <= nt; i++) {
        power[i] = power[i - 1] * B;
        pref_t[i] = pref_t[i - 1] * B + T[i] - 'a' + 1;
    }

    add(s2[0], 1, MOD);
    add(s2[1], MOD - 1, MOD);

    add(cnt[0], 1, MOD);
    add(cnt[1], MOD - 1, MOD);

    auto Ok = [&](int ls, int rs, int lt) {
        int rt = lt + (rs - ls);
        if (rt > nt) {
            return false;
        }

        Hash hsh_s = pref_s[rs] - pref_s[ls - 1] * power[rs - ls + 1];
        Hash hsh_t = pref_t[rt] - pref_t[lt - 1] * power[rt - lt + 1];
        return hsh_s == hsh_t;
    };

    // cerr << Ok(3, 5, 1) << "\n";

    for (int i = 0; i < ns; i++) {
        int res = 0;
        for (int step = 1 << 19; step; step >>= 1) {
            int rs = i + res + step;
            if (rs <= ns && Ok(i + 1, rs, 1)) {
                res += step;
            }
        }

        if (i + res < ns && res < nt) {
            res++;
            int ls = i + res + 1;
            for (int step = 1 << 19; step; step >>= 1) {
                int rs = i + res + step;
                if (rs <= ns && Ok(ls, rs, ls - i)) {
                    res += step;
                }
            }
        }

        int r = i + res;

        int curr = dp[i];
        add(curr, s2[i], MOD);
        add(dp[i + 1], curr, MOD);
        add(dp[r + 1], MOD - curr, MOD);
        
        add(cnt[i + 1], cnt[i], MOD);
        add(cnt[r + 1], MOD - cnt[i], MOD);

        curr = s2[i];
        add(curr, cnt[i], MOD);
        add(curr, cnt[i], MOD);
        add(s2[i + 1], curr, MOD);
        add(s2[r + 1], MOD - curr, MOD);

        add(s2[i + 1], s2[i], MOD);
        add(dp[i + 1], dp[i], MOD);
        add(cnt[i + 1], cnt[i], MOD);
    }

    cout << dp[ns];

    return 0;
}