#include <bits/stdc++.h>

using namespace std;
#define ll long long
#define pii pair<int, int>
#define ld long double
#define all(a) (a).begin(), (a).end()

const int MOD = 998244353;

int add(int a, int b) {
    if (a + b < MOD)
        return a + b;
    return a + b - MOD;
}

int sub(int a, int b) {
    if (a >= b)
        return a - b;
    return a + MOD - b;
}

int mul(int a, int b) {
    return a * 1ll * b % MOD;
}

struct fenwick{
    vector<int> vals;
    fenwick(int n): vals(n) {}
    void upd(int i, int x) {
        for (; i < vals.size(); i = (i | (i + 1)))
            vals[i] = add(vals[i], x);
    }
    int get(int i) {
        i = min(i, int(vals.size()) - 1);
        int ans = 0;
        for (; i >= 0; i = (i & (i + 1)) - 1)
            ans = add(ans, vals[i]);
        return ans;
    }
    int get(int l, int r) {
        return sub(get(r - 1), get(l - 1));
    }
};


const int MOD1 = 1e9 + 447;
const int BASE = 547;
const int MAXN = 1'000'100;

const int MOD2 = 1e9 + 1000-7;

int BASEPOW1[MAXN];

int mul1(int a, int b) {
    return a * 1ll * b % MOD1;
}

int add1(int a, int b) {
    if (a + b < MOD1)
        return a + b;
    return a + b - MOD1;
}

int sub1(int a, int b) {
    if (a >= b)
        return a - b;
    return a + MOD1 - b;
}

int get_hash1(vector<int>& hashes, int l, int r) {
    return sub1(hashes[r], mul1(hashes[l], BASEPOW1[r - l]));
}


int BASEPOW2[MAXN];

int mul2(int a, int b) {
    return a * 1ll * b % MOD2;
}

int add2(int a, int b) {
    if (a + b < MOD2)
        return a + b;
    return a + b - MOD2;
}

int sub2(int a, int b) {
    if (a >= b)
        return a - b;
    return a + MOD2 - b;
}

int get_hash2(vector<int>& hashes, int l, int r) {
    return sub2(hashes[r], mul2(hashes[l], BASEPOW2[r - l]));
}

signed main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    BASEPOW1[0] = 1;
    for (int i = 1; i < MAXN; ++i)
        BASEPOW1[i] = mul1(BASEPOW1[i - 1], BASE);

    BASEPOW2[0] = 1;
    for (int i = 1; i < MAXN; ++i)
        BASEPOW2[i] = mul2(BASEPOW2[i - 1], BASE);


    string s, t;
    cin >> s >> t;
    vector<int> hashes11(s.size() + 1);
    for (int i = 0; i < s.size(); ++i)
        hashes11[i + 1] = add1(mul1(hashes11[i], BASE), s[i]);
    vector<int> hashes12(s.size() + 1);
    for (int i = 0; i < s.size(); ++i)
        hashes12[i + 1] = add2(mul2(hashes12[i], BASE), s[i]);
    vector<int> hashes21(t.size() + 1);
    for (int i = 0; i < t.size(); ++i)
        hashes21[i + 1] = add1(mul1(hashes21[i], BASE), t[i]);
    vector<int> hashes22(t.size() + 1);
    for (int i = 0; i < t.size(); ++i)
        hashes22[i + 1] = add2(mul2(hashes22[i], BASE), t[i]);

    fenwick f_0(s.size() + 1);
    fenwick f_1(s.size() + 1);
    fenwick f_2(s.size() + 1);
    f_0.upd(s.size(), 1);
    for (int i = int(s.size()) - 1; i >= 0; --i) {
        int left = 0, right = int(s.size()) - i + 1;
        while (right - left > 1) {
            int mid = (left + right) / 2;
            if (mid <= t.size() && get_hash1(hashes11, i, i + mid) == get_hash1(hashes21, 0, mid) && 
                get_hash2(hashes12, i, i + mid) == get_hash2(hashes22, 0, mid))
                left = mid;
            else
                right = mid;
        }
        int same_cnt = left;
        if (same_cnt != int(s.size()) - i && same_cnt != t.size()) {
            left = 0, right = int(s.size()) - i - same_cnt;
            while (right - left > 1) {
                int mid = (left + right) / 2;
                if (same_cnt + 1 + mid <= t.size() && get_hash1(hashes11, i + same_cnt + 1, i + same_cnt + 1 + mid) == 
                    get_hash1(hashes21, same_cnt + 1, same_cnt + 1 + mid) && 
                    get_hash2(hashes12, i + same_cnt + 1, i + same_cnt + 1 + mid) == 
                    get_hash2(hashes22, same_cnt + 1, same_cnt + 1 + mid))
                    left = mid;
                else
                    right = mid;
            }
            same_cnt += 1 + left;
        }
        int val0 = f_0.get(i, i + same_cnt + 1);
        int val1 = f_1.get(i, i + same_cnt + 1);
        int val2 = f_2.get(i, i + same_cnt + 1);
        f_0.upd(i, val0);
        f_1.upd(i, add(val0, val1));
        f_2.upd(i, add(add(val0, val1), add(val1, val2)));
    }
    cout << f_2.get(0, 1) << '\n';
    return 0;
}