#include <bits/stdc++.h>
using namespace std;

typedef long long LL;
const int maxn = (int)1e6 + 1, maxm = maxn << 1 | 1, mod = 998244353;

struct ModHash {
    const int mod[2] = {(int)1e9 + 7, (int)1e9 + 9}, seed[2] = {29, 29};
    int len, mx;
    vector<int> pw[2], pre[2];
    void parse(int len, char buf[]) {
        this -> len = len;
        for(mx = 0; (1 << mx) <= len; ++mx);
        for(int i = 0; i < 2; ++i) {
            pw[i].resize(mx);
            pre[i].resize(len + 1);
        }
        pw[0][0] = seed[0];
        pw[1][0] = seed[1];
        for(int i = 1; i < mx; ++i) {
            pw[0][i] = (LL)pw[0][i - 1] * pw[0][i - 1] % mod[0];
            pw[1][i] = (LL)pw[1][i - 1] * pw[1][i - 1] % mod[1];
        }
        pre[0][0] = pre[1][0] = 0;
        for(int i = 1; i <= len; ++i) {
            int o = buf[i - 1] - 'a';
            pre[0][i] = ((LL)pre[0][i - 1] * seed[0] + o) % mod[0];
            pre[1][i] = ((LL)pre[1][i - 1] * seed[1] + o) % mod[1];
        }
    }
    int getHash(int i, int d, int L) {
        int h = (pre[i][L + (1 << d)] - (LL)pre[i][L] * pw[i][d]) % mod[i];
        return h < 0 ? h + mod[i] : h;
    }
    int getLCP(int i, int j) {
        int res = 0;
        if(i > j)
            swap(i, j);
        for(int d = mx - 1; d >= 0; --d) {
            if(j + (1 << d) > len)
                continue;
            if(getHash(0, d, i) != getHash(0, d, j))
                continue;
            if(getHash(1, d, i) != getHash(1, d, j))
                continue;
            i += 1 << d;
            j += 1 << d;
            res += 1 << d;
        }
        return res;
    }
} Hash;

char buf[maxm];
int n, m, len, f[3][maxn];

void solve() {
    scanf("%s", buf);
    n = strlen(buf);
    buf[n] = 'z' + 1;
    scanf("%s", buf + n + 1);
    m = strlen(buf + n + 1);
    len = n + m + 1;
    Hash.parse(len, buf);

    memset(f[0], 0, (n + 1) * sizeof(int));
    memset(f[1], 0, (n + 1) * sizeof(int));
    memset(f[2], 0, (n + 1) * sizeof(int));
    auto modInc = [&](int &x, int y) {
        (x += y) >= mod && (x -= mod);
    };
    auto modDec = [&](int &x, int y) {
        (x -= y) < 0 && (x += mod);
    };
    auto bulkInc = [&](int i, int L, int R, int v) {
        v >= mod && (v -= mod);
        if(!v || L > n)
            return;
        modInc(f[i][L], v);
        if(R >= n)
            return;
        modDec(f[i][R + 1], v);
    };
    bulkInc(0, 0, 0, 1);
    for(int i = 0; i < n; ++i) {
        int upp = min(n - i, m), cur = Hash.getLCP(i, n + 1);
        cur = min(cur + 1, upp);
        if(cur < upp)
            cur += Hash.getLCP(i + cur, n + 1 + cur);
        bulkInc(0, i + 1, i + cur, f[0][i]);
        bulkInc(1, i + 1, i + cur, f[0][i] + f[1][i]);
        bulkInc(2, i + 1, i + cur, f[1][i] + f[2][i]);
        modInc(f[0][i + 1], f[0][i]);
        modInc(f[1][i + 1], f[1][i]);
        modInc(f[2][i + 1], f[2][i]);
    }
    int ans = (2LL * f[2][n] + f[1][n]) % mod;
    printf("%d\n", ans);
}

int main() {
    int T = 1;
    // scanf("%d", &T);
    for(int Case = 1; Case <= T; ++Case) {
        // printf("Case #%d: ", Case);
        solve();
    }
    return 0;
}