#include "bits/stdc++.h"
#define rep(i, a, n) for (auto i = a; i <= (n); ++i)
#define revrep(i, a, n) for (auto i = n; i >= (a); --i)
#define all(a) a.begin(), a.end()
#define sz(a) (int)(a).size()
template<class T> inline bool chmax(T &a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T &a, T b) { if (b < a) { a = b; return 1; } return 0; }
using namespace std;

template<class A, class B> string to_string(const pair<A, B> &p);
template<class A, class B, class C> string to_string(const tuple<A, B, C> &p);
template<class A, class B, class C, class D> string to_string(const tuple<A, B, C, D> &p);
string to_string(const string &s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string) s); }
string to_string(char c) { return "'" + string(1, c) + "'"; }
string to_string(bool x) { return x ? "true" : "false"; }
template<class A, class T = typename A::value_type> string to_string(const A &v) {
	bool first = 1;
	string res = "{";
	for (const auto &x: v) {
		if (!first) res += ", ";
		first = 0;
		res += to_string(x);
	}
	res += "}";
	return res;
}
template<class A, class B> string to_string(const pair<A, B> &p) {
	return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template<class A, class B, class C> string to_string(const tuple<A, B, C> &p) {
	return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ")";
}
template<class A, class B, class C, class D> string to_string(const tuple<A, B, C, D> &p) {
	return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}

void debug_out() { cerr << endl; }
template<class H, class... T> void debug_out(const H& h, const T&... t) {
	cerr << " " << to_string(h);
	debug_out(t...);
}
#ifndef ONLINE_JUDGE
	#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
	#define debug(...) if (0) puts("No effect.")
#endif

using ll = long long;
using pii = pair<int, int>;
using vi = vector<int>;
using vvi = vector<vi>;

/**
 * Author: Yuhao Yao
 * Date: 22-10-24
 * Description: Suffix Array for non-cyclic string $s = s_0...s_{n - 1}$. 
 *  $rank[i]$ records the rank of the $i$-th suffix $s_i...s_{n - 1}$.
 *  $sa[i]$ records the starting position of the $i$-th smallest suffix.
 *  $h[i]$ (also called height array or lcp array) records the lcp of the $sa[i]$-th suffix and the $sa[i + 1]$-th suffix in $s$.
 * Usage: SA suf(s); // $s$ can be string or vector.
 * Time: O(|s| \log |s|).
 * Status: tested on https://www.luogu.com.cn/record/87444853, https://www.luogu.com.cn/problem/P4094, https://ac.nowcoder.com/acm/contest/33186/B, https://codeforces.com/gym/102994/problem/D, https://ac.nowcoder.com/acm/contest/33195/D, https://www.luogu.com.cn/problem/P8023, https://www.luogu.com.cn/problem/P7769.
 */
struct SA {
	int n;
	vi str, sa, rank, h;

	template<class T> SA(const T &s): n(sz(s)), str(n + 1), sa(n + 1), rank(n + 1), h(n - 1) {
		auto vec = s;
		sort(all(vec)); vec.erase(unique(all(vec)), vec.end());
		rep(i, 0, n - 1) str[i] = rank[i] = lower_bound(all(vec), s[i]) - vec.begin() + 1;
		iota(all(sa), 0);
		n++;

		for (int len = 0; len < n; len = len ? len * 2 : 1) {
			vi cnt(n + 1);
			for (auto v : rank) cnt[v + 1]++;
			rep(i, 1, n - 1) cnt[i] += cnt[i - 1];

			vi nsa(n), nrank(n);
			
			for (auto pos: sa) {
				pos -= len;
				if (pos < 0) pos += n;
				nsa[cnt[rank[pos]]++] = pos;
			}
			swap(sa, nsa);

			int r = 0, oldp = -1;
			for (auto p: sa) {
				auto next = [&](int a, int b) { return a + b < n ? a + b : a + b - n; };
				if (~oldp) r += rank[p] != rank[oldp] || rank[next(p, len)] != rank[next(oldp, len)];
				nrank[p] = r;
				oldp = p;
			}
			swap(rank, nrank);
		}
		sa = vi(sa.begin() + 1, sa.end());
		rank.resize(--n);
		rep(i, 0, n - 1) rank[sa[i]] = i;

		// compute height array.
		int len = 0;
		rep(i, 0, n - 1) {
			if (len) len--;
			int rk = rank[i];
			if (rk == n - 1) continue;
			while (str[i + len] == str[sa[rk + 1] + len]) len++;
			h[rk] = len;
		}
	}
};

/**
 * Author: Yuhao Yao
 * Date: 22-10-24
 * Description: Suffix Array with sparse table answering lcp of suffices.
 * Usage: SA suf(s); // $s$ can be string or vector.
 * Time: O(|s| \log |s|) for construction. O(1) per query.
 * Status: tested on https://ac.nowcoder.com/acm/contest/33186/B, https://codeforces.com/gym/102994/problem/D, https://ac.nowcoder.com/acm/contest/33195/D, https://www.luogu.com.cn/problem/P4094, https://www.luogu.com.cn/problem/P7769.
 */

struct SA_lcp: SA {
	vector<vi> st;
	
	template<class T> SA_lcp(const T &s): SA(s) {
		assert(n > 0);
		st.assign(__lg(n) + 1, vi(n));
		st[0] = h;
		st[0].push_back(0); // just to make st[0] of size n.
		rep(i, 1, __lg(n)) rep(j, 0, n - (1 << i)) {
			st[i][j] = min(st[i - 1][j], st[i - 1][j + (1 << (i - 1))]);
		}
	}
	// return lcp(suff_i, suff_j) for i != j.
	int lcp(int i, int j) {
		if (i == n || j == n) return 0;
		assert(i != j);
		int l = rank[i], r = rank[j];
		if (l > r) swap(l, r);
		int k = __lg(r - l);
		return min(st[k][l], st[k][r - (1 << k)]);
	}
};

/**
 * Author: Yuhao Yao
 * Date: 24-01-07
 * Description: Fenwick Tree.
 */
template<class T>
struct Fenwick {
	int n;
	vector<T> as;

	Fenwick(int n): n(n), as(n + 1, 0) {}

	void add(int i, T x) { 
		for (i++; i <= n; i += i & -i) as[i] += x;
	}

	T ask(int i) {
		T ans{};
		for (i++; i; i -= i & -i) ans += as[i];
		return ans;
	}

	T range_ask(int l, int r) { return ask(r) - ask(l - 1); }

	// assuming prefix sums are non-decreasing, finds the first pos such that ask(pos) >= x.
	int lower_bound(T x) {
		assert(n > 0);
		int pos = 0;
		for (int h = 1 << __lg(n); h; h >>= 1) {
			if ((pos | h) <= n && as[pos | h] < x) {
				pos |= h;
				x -= as[pos];
			}
		}
		return pos;
	}
};

/**
 * Author: Yuhao Yao
 * Date: 23-05-11
 * Description: Modular integer with $mod \le 2^{31} - 1$. Note that there are several advantages to use this code:
   1. You do not need to keep writing $\%\, mod$;
   2. It is good to use this struct when doing Gaussian Elimination / Fast Walsh-Hadamard Transform;
   3. Sometimes the input number is greater than $mod$ and this code handles it.
  Do not write things like $mint\{1 / 3\}.pow(10)$ since $1 / 3$ simply equals $0$.
  Do not write things like $mint\{a * b\}$ where $a$ and $b$ are int since you might first have integer overflow.
 * Usage: Define the followings globally:
   const int mod = 998244353;
   using mint = MInt<mod>;
 * Status: tested on https://ac.nowcoder.com/acm/contest/33191/F.
 */
template<const unsigned &mod>
struct MInt {
	using Z = MInt;
	unsigned x; /// start-hash
	MInt(ll a = 0): x(a % mod + mod) { if (x >= mod) x -= mod; }
	explicit operator int() const { return x; }

	Z& operator +=(Z b) { x += b.x; if (x >= mod) x -= mod; return *this; }
	Z& operator -=(Z b) { x += mod - b.x; if (x >= mod) x -= mod; return *this; }
	Z& operator *=(Z b) { x = 1ll * x * b.x % mod; return *this; }
	friend Z operator +(Z a, Z b) { return a += b; }
	friend Z operator -(Z a, Z b) { return a -= b; }
	friend Z operator -(Z a) { return Z{} - a; }
	friend Z operator *(Z a, Z b) { return a *= b; }
	/// end-hash

	// the followings are for ntt and polynomials.
	Z pow(ll k) const { /// start-hash
		Z res = 1, a = *this;
		for (; k; k >>= 1, a = a * a) if (k & 1) res = res * a;
		return res;
	}
	Z& operator /=(Z b) {
		assert(b.x != 0);
		return *this *= b.pow(mod - 2);
	}
	friend Z operator /(Z a, Z b) { return a /= b; }
	friend bool operator ==(Z a, Z b) { return a.x == b.x; }
	friend bool operator !=(Z a, Z b) { return a.x != b.x; }
	friend bool operator <(Z a, Z b) { return a.x < b.x; }

	static unsigned getMod() { return mod; } // ntt need this.
	/// end-hash

	friend istream& operator >>(istream &is, Z &a) {
		ll v; is >> v;
		a = v;
		return is;
	}
	friend string to_string(Z a) { return to_string(a.x); }
};

int main() {
	ios::sync_with_stdio(0); cin.tie(0);
	
	string s, t; cin >> s >> t;
	int n = sz(s), m = sz(t);
	auto as = s + '#' + t;
	SA_lcp sa(as);
	vi nxt(n, n);
	rep(i, 0, n - 1) {
		int x = sa.lcp(i, n + 1);
		if (x >= m - 1) {
			nxt[i] = min(i + m, n);
		} else {
			int j = i + x + 1;
			int y = sa.lcp(j, n + 1 + x + 1);
			nxt[i] = min(i + x + 1 + y, n);
		}
	}

	const static unsigned mod = 998244353;
	using mint = MInt<mod>;	
	Fenwick<mint> bitOne(n + 1), bitLinear(n + 1), bitSquared(n + 1);
	bitOne.add(n, 1);
	revrep(i, 0, n - 1) {
		int l = i + 1, r = nxt[i];
		mint oneSum = bitOne.range_ask(l, r);
		mint linearSum = bitLinear.range_ask(l, r);
		mint SquaredSum = bitSquared.range_ask(l, r);
		bitOne.add(i, oneSum);
		bitLinear.add(i, linearSum + oneSum);
		bitSquared.add(i, SquaredSum + linearSum * 2 + oneSum);
	}
	mint ans = bitSquared.range_ask(0, 0);
	printf("%d\n", (int) ans);
	return 0;
}