#include<bits/stdc++.h>
#ifndef xxx
#define dbg(...) ;
#endif
using namespace std;
template<class T> ostream &operator<<(ostream &o, const vector <T> &v) { bool f=false; for(T i:v) { f?o<<' ':o; o<<(i); f=true; } return o; }
template<class T> void sort(T &v) { std::sort(v.begin(), v.end()); }
template<class T, class C> void sort(T &v, C c) { std::sort(v.begin(), v.end(), c); }
template<class T> void reverse(T &v) { std::reverse(v.begin(), v.end()); }
template<class T> bool is_sorted(T &v) { return std::is_sorted(v.begin(), v.end()); }
template<class T> inline void _min(T &x, const T &y) { x>y?x=y:x; }
template<class T> inline void _max(T &x, const T &y) { x<y?x=y:x; }
istream &operator>>(istream &i, __int128_t &x) { x=0; short f=1; char c=0; while(!isdigit(c)) { if(c=='-')f=-1; c=i.get(); } while(isdigit(c))x=x*10+c-'0', c=i.get(); x*=f; return i; }
ostream &operator<<(ostream &o, __int128_t x) { if(x==0) { o<<0; return o; } bool f=false; string s; if(x<0)f=true, x=-x; while(x)s+=x%10+'0', x/=10; reverse(s); if(f)o<<'-'; o<<s; return o; }
mt19937 mt(time(0));
typedef double db;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
constexpr int maxn=1e6+5;
constexpr int mod=998244353;
constexpr int inf=0x3f3f3f3f;
constexpr ll INF=0x3f3f3f3f3f3f3f3fll;
constexpr double pi=acos(-1.0);
constexpr double eps=1e-9;
template <int m>
struct static_modint
{
	using mint=static_modint;

public:
	static_modint() : v(0) {}
	template <class T>
	static_modint(T x)
	{
		x=(x%(ll)(umod()));
		if(x<0)x+=umod();
		v=(unsigned int)(x);
	}

	static_modint(bool x) { v=((unsigned int)(x)%umod()); }

	unsigned int val() const { return v; }

	mint &operator++()
	{
		v++;
		if(v==umod()) v=0;
		return *this;
	}

	mint &operator--()
	{
		if(v==0) v=umod();
		v--;
		return *this;
	}

	mint operator++(int)
	{
		mint result=*this;
		++*this;
		return result;
	}

	mint operator--(int)
	{
		mint result=*this;
		--*this;
		return result;
	}

	mint &operator+=(const mint &rs)
	{
		v+=rs.v;
		if(v>=umod()) v-=umod();
		return *this;
	}

	mint &operator-=(const mint &rs)
	{
		if(v<rs.v) v+=umod();
		v-=rs.v;
		return *this;
	}

	mint &operator*=(const mint &rs)
	{
		ull z=v;
		z*=rs.v;
		v=(unsigned int)(z%umod());
		return *this;
	}

	mint &operator/=(const mint &rs) { return *this=*this*rs.inv(); }

	mint operator+() const { return *this; }
	mint operator-() const { return mint()-*this; }

	mint pow(ll n) const
	{
		assert(n>=0);
		mint x=*this, r=1;
		while(n)
		{
			if(n&1) r*=x;
			x*=x;
			n>>=1;
		}
		return r;
	}

	mint inv() const
	{
		//assert(v);
		return pow(umod()-2);
	}

	istream &operator>>(istream &in)
	{
		in>>v;
		*this=static_modint(v);
		return in;
	}

	ostream &operator<<(ostream &o)const
	{
		o<<v;
		return o;
	}

	friend mint operator+(const mint &l, const mint &r)
	{
		return mint(l)+=r;
	}

	friend mint operator-(const mint &l, const mint &r)
	{
		return mint(l)-=r;
	}

	friend mint operator*(const mint &l, const mint &r)
	{
		return mint(l)*=r;
	}

	friend mint operator/(const mint &l, const mint &r)
	{
		return mint(l)/=r;
	}

	friend bool operator==(const mint &l, const mint &r)
	{
		return l.v==r.v;
	}

	friend bool operator!=(const mint &l, const mint &r)
	{
		return l.v!=r.v;
	}

	friend bool operator<(const mint &l, const mint &r)
	{
		return l.v<r.v;
	}

	friend bool operator>(const mint &l, const mint &r)
	{
		return l.v>r.v;
	}

	friend bool operator<=(const mint &l, const mint &r)
	{
		return l.v<=r.v;
	}

	friend bool operator>=(const mint &l, const mint &r)
	{
		return l.v>=r.v;
	}

	friend ostream &operator<<(ostream &o, mint u)
	{
		u.operator<<(o);
		return o;
	}

	friend istream &operator>>(istream &in, mint &u)
	{
		u.operator>>(in);
		return in;
	}

private:
	unsigned int v;
	static constexpr unsigned int umod() { return m; }
};
typedef static_modint<mod> mint;
namespace customHash
{
	constexpr int mods[]={1'222'827'239, 1'610'612'741};
	typedef static_modint<mods[0]> mint0;
	typedef static_modint<mods[1]> mint1;
	typedef pair<mint0, mint1> pmm;

	template<class T, int b>
	struct Hash
	{
	public:
		//@note n = data.size()
		template<class S>
		Hash(const vector<S> &data) :n(data.size()) { init(data.data()-1); }
		//@param data: 1-based indexing
		template<class S>
		Hash(const S *data, int n):n(n) { init(data); }
		//@note n = s.size()
		Hash(const string &s) :n(s.size()) { init(s.data()-1); }
		Hash(int n) :n(n) { initBasePow(); }

		T getHash()const
		{
			return sum[n];
		}
		T getHash(int l, int r)const
		{
			if(l>r)return 0;
			assert(r<=n);
			return sum[r]-sum[l-1]*basePow[r-l+1];
		}

		static T getHash(const string &s)
		{
			T ans=0;
			for(char c:s)ans=ans*base+c;
			return ans;
		}

		template<class S>
		static T getHash(const vector<S> &vec)
		{
			T ans=0;
			for(T x:vec)ans=ans*base+x;
			return ans;
		}

		template<class S>
		static T getHash(const S *a, int n)
		{
			T ans=0;
			for(int i=1; i<=n; i++)
				ans=ans*base+a[i];
			return ans;
		}

		T merge(T x, T y, int lenY)const
		{
			return x*basePow[lenY]+y;
		}
		T merge(int l1, int r1, int l2, int r2)const
		{
			if(l1>r1)return getHash(l2, r2);
			if(l2>r2)return getHash(l1, r1);
			return getHash(l1, r1)*basePow[r2-l2+1]+getHash(l2, r2);
		}

		int getN() const { return n; }

		static constexpr int getBase() { return Hash<T, b>::base; }

		const vector<T> &getBasePow() const { return basePow; }

	private:
		const int n;
		static constexpr int base=b;
		vector<T>sum;
		vector<T>basePow;

		template<class S>
		void init(const S *data)
		{
			sum.resize(n+1);
			sum[0]=0;
			basePow.resize(n+1);
			basePow[0]=1;
			for(int i=1; i<=n; i++)
			{
				basePow[i]=basePow[i-1]*base;
				sum[i]=sum[i-1]*base+data[i];
			}
		}
		void initBasePow()
		{
			basePow.resize(n+1);
			for(int i=1; i<=n; i++)
				basePow[i]=basePow[i-1]*base;
		}
	};

	constexpr int bases[]={181, 1231, 146'527, 19'260'817, 91'815'541};
	typedef Hash<mint0, bases[0]> Hash0;
	typedef Hash<mint1, bases[1]> Hash1;

	struct Dhash
	{
	public:
		//@note n = data.size()
		template<class S>
		Dhash(const vector<S> &data) :n(data.size()), h0(data), h1(data) {}
		//@param data: 1-based indexing
		template<class S>
		Dhash(const S *data, int n):n(n), h0(data, n), h1(data, n) {}
		//@note n = s.size()
		Dhash(const string &s) :n(s.size()), h0(s), h1(s) {}
		Dhash(int n) :n(n), h0(n), h1(n) {}

		pmm getHash()const
		{
			return make_pair(h0.getHash(), h1.getHash());
		}
		pmm getHash(int l, int r)const
		{
			return make_pair(h0.getHash(l, r), h1.getHash(l, r));
		}

		static pmm getHash(const string &s)
		{
			return make_pair(Hash0::getHash(s), Hash1::getHash(s));
		}

		template<class S>
		static pmm getHash(const vector<S> &vec)
		{
			return make_pair(Hash0::getHash(vec), Hash1::getHash(vec));
		}

		template<class S>
		static pmm getHash(const S *a, int n)
		{
			return make_pair(Hash0::getHash(a, n), Hash1::getHash(a, n));
		}

		pmm merge(pmm x, pmm y, int lenY)const
		{
			return make_pair(h0.merge(x.first, y.first, lenY), h1.merge(x.second, y.second, lenY));
		}
		pmm merge(int l1, int r1, int l2, int r2)const
		{
			if(l1>r1)return getHash(l2, r2);
			if(l2>r2)return getHash(l1, r1);
			return make_pair(h0.merge(l1, r1, l2, r2), h1.merge(l1, r1, l2, r2));
		}

		int getN() const { return n; }

		const Hash0 &getH0() const { return h0; }

		const Hash1 &getH1() const { return h1; }

	private:
		const int n;
		Hash0 h0;
		Hash1 h1;
	};
}
using namespace customHash;
int R[maxn];
mint f[maxn], g[maxn], h[maxn];
mint df[maxn], dg[maxn], dh[maxn];
int main()//MARK: main
{
#ifndef xxx
	ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
#endif
	cout<<fixed<<setprecision(10);
	string s, t;
	cin>>s>>t;
	const int n=s.length();
	const int m=t.length();
	Dhash DHs(s), DHt(t);
	auto calc=[&](const int i)->void
	{
		int l=1, r=min(m, n-i+1);
		int ans=0;
		while(l<=r)
		{
			int mid=l+r>>1;
			if(DHs.getHash(i, i+mid-1)==DHt.getHash(1, mid))
			{
				ans=mid;
				l=mid+1;
			}
			else r=mid-1;
		}
		if(i+ans-1<n&&ans<m)ans++;
		int ps=i+ans;
		int pt=ans+1;
		{
			int l=1, r=min(m-pt+1, n-ps+1);
			ans=0;
			while(l<=r)
			{
				int mid=l+r>>1;
				if(DHs.getHash(ps, ps+mid-1)==DHt.getHash(pt, pt+mid-1))
				{
					ans=mid;
					l=mid+1;
				}
				else r=mid-1;
			}
		}
		R[i]=ps+ans-1;
	};
	for(int i=1; i<=n; i++)
		calc(i);
	auto modify=[&](int l, int r, mint *d, mint val)->void
	{
		d[l]+=val;
		d[r+1]-=val;
	};
	f[0]=1;
	df[1]=-1;
	for(int i=0; i<=n; i++)
	{
		if(i)
		{
			f[i]=f[i-1]+df[i];
			g[i]=g[i-1]+dg[i];
			h[i]=h[i-1]+dh[i];
		}
		if(i<n)
		{
			modify(i+1, R[i+1], df, f[i]);
			modify(i+1, R[i+1], dg, g[i]+f[i]);
			modify(i+1, R[i+1], dh, h[i]+2*g[i]+f[i]);
		}
	}
	cout<<h[n]<<'\n';
	return 0;
}