#include <bits/stdc++.h>

const int maxn = 1e6, mod = 998244353;

int n;
std::array<char, maxn + 2> s, t;

struct hash_t {
    static constexpr int mod = 998244353;
    int h1;
    unsigned long long h2;

    hash_t(int h = 0) { h1 = h2 = h; }
    hash_t(int _h1, unsigned long long _h2) {
        h1 = _h1;
        h2 = _h2;
    }

    bool operator==(const hash_t &rhs) const { return h1 == rhs.h1 && h2 == rhs.h2; }

    hash_t operator+(const hash_t &rhs) const { return { (h1 + rhs.h1) % mod, h2 + rhs.h2 }; }

    hash_t operator-(const hash_t &rhs) const { return { ((h1 - rhs.h1) % mod + mod) % mod, h2 - rhs.h2 }; }

    hash_t operator*(const hash_t &rhs) const { return { (int)((long long)h1 * rhs.h1 % mod), h2 * rhs.h2 }; }
} base(261, 233);
std::array<hash_t, maxn + 1> pw;

struct hash {
    hash_t h;
    int len;

    hash() { len = 0; }

    hash(hash_t _h, int _len) {
        h = _h;
        len = _len;
    }

    bool operator==(const hash &rhs) const { return h == rhs.h && len == rhs.len; }
    
    hash operator+(const hash &rhs) {
      return {h * pw[rhs.len] + rhs.h, len + rhs.len};
    }
    hash operator-(const hash &rhs) {
      return {h - rhs.h * pw[len - rhs.len], len - rhs.len};
    }
};
std::array<hash, maxn + 1> hs, ht;

class bit {
private:
  std::array<int, maxn + 1> t;

public:
  bit() { std::memset(t.data() + 1, 0, maxn * sizeof(int)); }

  void modify(int x, int v) {
    for (int i = x; i <= n; i += i & -i)
      t[i] = (t[i] + v) % mod;
  }

  int query(int x) {
    int ret = 0;
    for (int i = x; i > 0; i -= i & -i)
      ret = (ret + t[i]) % mod;
    return ret;
  }
} tf, tg, th;

int main() {
  std::cin.tie(nullptr)->sync_with_stdio(false);

  pw[0] = 1;
  for (int i = 1; i <= maxn; ++i)
    pw[i] = pw[i - 1] * base;
  std::cin >> std::next(s.data()) >> std::next(t.data());
  n = std::strlen(std::next(s.data()));
  for (int i = 1; i <= n; ++i)
    hs[i] = hs[i - 1] + hash(hash_t(s[i], s[i]), 1);
  int m = std::strlen(std::next(t.data()));
  for (int i = 1; i <= m; ++i)
    ht[i] = ht[i - 1] + hash(hash_t(t[i], t[i]), 1);
  auto geth = [&](std::array<hash, maxn + 1> &h, int l, int r) {
    return h[r] - h[l - 1];
  };

  auto getp = [&](int sl, int tl = 1) {
    int l = 1, r = std::min(n - sl + 1, m - tl + 1), p = l - 1;
    while (l <= r) {
      int mid = (l + r) / 2;
      if (geth(hs, sl, sl + mid - 1) == geth(ht, tl, tl + mid - 1))
        l = (p = mid) + 1;
      else
        r = mid - 1;
    }
    return p;
  };
  for (int i = 0, f, g, h, p; i < n; ++i) {
    if (i == 0) {
      f = 1;
      g = h = 0;
    }
    else {
      f = tf.query(i);
      g = tg.query(i);
      h = th.query(i);
    }

    p = getp(i + 1);
    p += 1 + getp(i + 1 + p + 1, 1 + p + 1);
    p = std::min(p, m);
    tf.modify(i + 1, f);
    tf.modify(i + 1 + p, -f);
    tg.modify(i + 1, (f + g) % mod);
    tg.modify(i + 1 + p, -(f + g) % mod);
    th.modify(i + 1, (h + 2ll * g + f) % mod);
    th.modify(i + 1 + p, -(h + 2ll * g + f) % mod);
  }

  std::cout << (th.query(n) + mod) % mod << '\n';
  return 0;
}