#include <stdio.h>
#include <string.h>

#include <algorithm>

#define LOG(FMT...) fprintf(stderr, FMT)

using namespace std;

typedef long long LL;
constexpr int N = 1000005;
constexpr int mod = 998244353;

constexpr int modx = 998244353, mody = 1004535809, modz = 1e9 + 7, P = 91853;

constexpr int reduce(int x) {
	return x >= mod ? x - mod : x;
}

constexpr int norm(int x) {
	return x < 0 ? x + mod : x;
}

constexpr int reducex(int x) {
	return x >= modx ? x - modx : x;
}

constexpr int reducey(int x) {
	return x >= mody ? x - mody : x;
}

constexpr int reducez(int x) {
	return x >= modz ? x - modz : x;
}

struct Hsv {
	int x, y, z;
	Hsv() {}
	Hsv(int _x) : x(_x), y(_x), z(_x) {}
	Hsv(int _x, int _y, int _z) : x(_x), y(_y), z(_z) {}
	Hsv operator * (int t) const {
		return (Hsv){x * (LL)t % modx, y * (LL)t % mody, z * (LL)t % modz};
	}
	Hsv operator + (const Hsv &t) const {
		return (Hsv){reducex(x + t.x), reducey(y + t.y), reducez(z + t.z)};
	}
	Hsv operator * (const Hsv &t) const {
		return (Hsv){x * (LL)t.x % modx, y * (LL)t.y % mody, z * (LL)t.z % modz};
	}
	bool operator == (const Hsv &t) const {
		return x == t.x && y == t.y && z == t.z;
	}
	bool operator != (const Hsv &t) const {
		return x != t.x || y != t.y || z != t.z;
	}
} w[N], ha[N], hb[N];

int n, m;
char a[N], b[N];
int f[N][3], sf[N][3];

Hsv h(Hsv *c, int l, int r) {
	return c[r] + c[l - 1] * w[r - l + 1];
}

int main() {
	scanf("%s%s", a + 1, b + 1);
	n = strlen(a + 1), m = strlen(b + 1);
	w[0] = (Hsv){modx - 1, mody - 1, modz - 1};
	for (int i = 1; i <= n; ++i) {
		w[i] = w[i - 1] * P;
		ha[i] = ha[i - 1] * P + (Hsv)a[i];
		hb[i] = hb[i - 1] * P + (Hsv)b[i];
	}
	f[n + 1][0] = 1;
	sf[n + 1][0] = 1;
	for (int i = n; i; --i) {
		int l = i, r = n, md;
		while (l < r) {
			md = l + r >> 1;
			if (h(ha, i, md) != h(hb, 1, md - i + 1)) {
				r = md;
			} else {
				l = md + 1;
			}
		}
		int curr = r + 1;
		l = curr, r = n + 1;
		while (l < r) {
			md = l + r >> 1;
			if (h(ha, curr, md) != h(hb, curr - i + 1, md - i + 1)) {
				r = md;
			} else {
				l = md + 1;
			}
		}
		curr = r;
		curr = min(curr, m + i);
		// printf("%d %d\n", i, curr);
		// f[curr] -> f[i]
		int v0 = norm(sf[i + 1][0] - sf[curr + 1][0]);
		int v1 = norm(sf[i + 1][1] - sf[curr + 1][1]);
		int v2 = norm(sf[i + 1][2] - sf[curr + 1][2]);
		f[i][0] = v0;
		f[i][1] = reduce(v0 + v1);
		f[i][2] = reduce(reduce(v2 + v0) + reduce(2 * v1));
		for (int j = 0; j < 3; ++j) {
			sf[i][j] = reduce(sf[i + 1][j] + f[i][j]);
		}
	}
	printf("%d\n", f[1][2]);
	return 0;
}