#include <cstdint>
#include <vector>
#include <string>
#include <iostream>


#include <algorithm>
#include <cassert>
#include <iostream>
#include <vector>


#ifdef _MSC_VER
#include <intrin.h>
#endif

namespace atcoder {

namespace internal {

int ceil_pow2(int n) {
    int x = 0;
    while ((1U << x) < (unsigned int)(n)) x++;
    return x;
}

int bsf(unsigned int n) {
#ifdef _MSC_VER
    unsigned long index;
    _BitScanForward(&index, n);
    return index;
#else
    return __builtin_ctz(n);
#endif
}

}  // namespace internal

}  // namespace atcoder


namespace atcoder {

template <class S,
          S (*op)(S, S),
          S (*e)(),
          class F,
          S (*mapping)(F, S),
          F (*composition)(F, F),
          F (*id)()>
struct lazy_segtree {
  public:
    lazy_segtree() : lazy_segtree(0) {}
    explicit lazy_segtree(int n) : lazy_segtree(std::vector<S>(n, e())) {}
    explicit lazy_segtree(const std::vector<S>& v) : _n(int(v.size())) {
        log = internal::ceil_pow2(_n);
        size = 1 << log;
        d = std::vector<S>(2 * size, e());
        lz = std::vector<F>(size, id());
        for (int i = 0; i < _n; i++) d[size + i] = v[i];
        for (int i = size - 1; i >= 1; i--) {
            update(i);
        }
    }

    void set(int p, S x) {
        assert(0 <= p && p < _n);
        p += size;
        for (int i = log; i >= 1; i--) push(p >> i);
        d[p] = x;
        for (int i = 1; i <= log; i++) update(p >> i);
    }

    S get(int p) const {
        assert(0 <= p && p < _n);
        p += size;
        for (int i = log; i >= 1; i--) push(p >> i);
        return d[p];
    }

    S prod(int l, int r) const {
        assert(0 <= l && l <= r && r <= _n);
        if (l == r) return e();

        l += size;
        r += size;

        for (int i = log; i >= 1; i--) {
            if (((l >> i) << i) != l) push(l >> i);
            if (((r >> i) << i) != r) push((r - 1) >> i);
        }

        S sml = e(), smr = e();
        while (l < r) {
            if (l & 1) sml = op(sml, d[l++]);
            if (r & 1) smr = op(d[--r], smr);
            l >>= 1;
            r >>= 1;
        }

        return op(sml, smr);
    }

    S all_prod() const { return d[1]; }

    void apply(int p, F f) {
        assert(0 <= p && p < _n);
        p += size;
        for (int i = log; i >= 1; i--) push(p >> i);
        d[p] = mapping(f, d[p]);
        for (int i = 1; i <= log; i++) update(p >> i);
    }
    void apply(int l, int r, F f) {
        assert(0 <= l && l <= r && r <= _n);
        if (l == r) return;

        l += size;
        r += size;

        for (int i = log; i >= 1; i--) {
            if (((l >> i) << i) != l) push(l >> i);
            if (((r >> i) << i) != r) push((r - 1) >> i);
        }

        {
            int l2 = l, r2 = r;
            while (l < r) {
                if (l & 1) all_apply(l++, f);
                if (r & 1) all_apply(--r, f);
                l >>= 1;
                r >>= 1;
            }
            l = l2;
            r = r2;
        }

        for (int i = 1; i <= log; i++) {
            if (((l >> i) << i) != l) update(l >> i);
            if (((r >> i) << i) != r) update((r - 1) >> i);
        }
    }

    template <bool (*g)(S)> int max_right(int l) const {
        return max_right(l, [](S x) { return g(x); });
    }
    template <class G> int max_right(int l, G g) const {
        assert(0 <= l && l <= _n);
        assert(g(e()));
        if (l == _n) return _n;
        l += size;
        for (int i = log; i >= 1; i--) push(l >> i);
        S sm = e();
        do {
            while (l % 2 == 0) l >>= 1;
            if (!g(op(sm, d[l]))) {
                while (l < size) {
                    push(l);
                    l = (2 * l);
                    if (g(op(sm, d[l]))) {
                        sm = op(sm, d[l]);
                        l++;
                    }
                }
                return l - size;
            }
            sm = op(sm, d[l]);
            l++;
        } while ((l & -l) != l);
        return _n;
    }

    template <bool (*g)(S)> int min_left(int r) const {
        return min_left(r, [](S x) { return g(x); });
    }
    template <class G> int min_left(int r, G g) const {
        assert(0 <= r && r <= _n);
        assert(g(e()));
        if (r == 0) return 0;
        r += size;
        for (int i = log; i >= 1; i--) push((r - 1) >> i);
        S sm = e();
        do {
            r--;
            while (r > 1 && (r % 2)) r >>= 1;
            if (!g(op(d[r], sm))) {
                while (r < size) {
                    push(r);
                    r = (2 * r + 1);
                    if (g(op(d[r], sm))) {
                        sm = op(d[r], sm);
                        r--;
                    }
                }
                return r + 1 - size;
            }
            sm = op(d[r], sm);
        } while ((r & -r) != r);
        return 0;
    }

  private:
    int _n, size, log;
    mutable std::vector<S> d;
    mutable std::vector<F> lz;

    void update(int k) { d[k] = op(d[2 * k], d[2 * k + 1]); }
    void all_apply(int k, F f) const {
        d[k] = mapping(f, d[k]);
        if (k < size) lz[k] = composition(f, lz[k]);
    }
    void push(int k) const {
        all_apply(2 * k, lz[k]);
        all_apply(2 * k + 1, lz[k]);
        lz[k] = id();
    }
};

}  // namespace atcoder


struct RollHash {
    constexpr static std::int64_t MOD_ = (1LL << 31) - 1;
    std::int64_t n, base;
    std::vector<std::int64_t> hash, pow;

    RollHash(const std::string& s, std::int64_t base) {
        n = s.size();
        this->base = base;
        hash.resize(s.size() + 1);
        pow.resize(s.size() + 1);
        hash[0] = 0;
        pow[0] = 1;
        for (int i = 0; i < s.size(); i++) {
            hash[i + 1] = (hash[i] * base + s[i]) % MOD_;
            pow[i + 1] = pow[i] * base % MOD_;
        }
    }

    std::int64_t operator()(int l, int r) {
        return (hash[l] * pow[r - l] - hash[r] + MOD_) % MOD_;
    }
};

struct RollHash2 {
    std::int64_t n;
    RollHash rh1, rh2;
    
    RollHash2(const std::string& s, std::int64_t base1, std::int64_t base2) : rh1(s, base1), rh2(s, base2) {
        n = s.size();
    }

    std::pair<std::int64_t, std::int64_t> operator()(int l, int r) {
        return {rh1(l, r), rh2(l, r)};
    }
};

int get_max_match(RollHash2& hs, RollHash2& ht, int x, int y) {
    int ok = 0;
    int ng = std::min(hs.n - x, ht.n - y) + 1;
    while (ng - ok > 1) {
        int mid = (ok + ng) / 2;
        if (hs(x, x + mid) == ht(y, y + mid)) {
            ok = mid;
        } else {
            ng = mid;
        }
    }
    return ok;
}


constexpr static std::int64_t MOD = 998244353;

struct S {
    std::int64_t zero_sum, one_sum, two_sum;
};

S op(S l, S r) {
    return {
        (l.zero_sum + r.zero_sum) % MOD,
        (l.one_sum + r.one_sum) % MOD,
        (l.two_sum + r.two_sum) % MOD
    };
}

S e() {
    return {0, 0};
}

S mapping(S f, S x) {
    return {
        (f.zero_sum + x.zero_sum) % MOD,
        (f.one_sum + x.one_sum) % MOD,
        (f.two_sum + x.two_sum) % MOD
    };
}

S composition(S f, S g) {
    return {
        (f.zero_sum + g.zero_sum) % MOD,
        (f.one_sum + g.one_sum) % MOD,
        (f.two_sum + g.two_sum) % MOD
    };
}

S id() {
    return {0, 0, 0};
}

int main() {
    std::string s, t;
    std::cin >> s >> t;
    RollHash2 hs(s, 1009, 1007), ht(t, 1009, 1007);

    std::vector<int> max_match(s.size() + 1);
    for (int i = 0; i <= s.size(); i++) {
        int res = get_max_match(hs, ht, i, 0);
        if (i + res == s.size() || res == t.size()) {
            max_match[i] = res;
            continue;
        }
        res = res + 1 + get_max_match(hs, ht, i + res + 1, res + 1);
        max_match[i] = res;
    }

    atcoder::lazy_segtree<S, op, e, S, mapping, composition, id> seg(s.size() + 1);
    seg.set(0, {1, 0, 0});

    for (int i = 0; i < s.size(); i++) {
        S now = seg.get(i);
        S next = {
            now.zero_sum,
            (now.one_sum + now.zero_sum) % MOD,
            (now.two_sum + 2 * now.one_sum + now.zero_sum) % MOD
        };
        seg.apply(i + 1, i + max_match[i] + 1, next);
    }

    std::cout << seg.get(s.size()).two_sum << std::endl;
}