#include<bits/stdc++.h>
using namespace std;

using ll = long long;
#define f first
#define s second
template<class T> using V = vector<T>; 
using vi = V<int>;
using vpi = V<pair<int,int>>;
#define sz(x) int((x).size())
#define pb push_back
#define FOR(i,a,b) for (int i = (a); i < (b); ++i)
#define F0R(i,a) FOR(i,0,a)
#define each(a,x) for (auto& a: x)
#define all(x) begin(x), end(x)
template<class T> bool ckmin(T& a, const T& b) {
    return b < a ? a = b, 1 : 0; } // set $a = \min(a,b)$

mt19937 rng((uint64_t) chrono::duration_cast<chrono::
    nanoseconds>(chrono::high_resolution_clock::now()
        .time_since_epoch()).count());
constexpr uint64_t MOD = (1ull<<61) - 1; //1e9+7ll;
uint64_t modmul(uint64_t a, uint64_t b){ //solo con $2^{61}-1$
    uint64_t l1=(uint32_t)a,h1=a>>32,l2=(uint32_t)b,h2=b>>32;
    uint64_t l = l1*l2, m = l1*h2 + l2*h1, h = h1*h2;
    uint64_t ret=(l&MOD)+(l>>61)+(h<<3)+(m>>29)+(m<<35>>3)+1;
    ret = (ret & MOD) + (ret>>61);
    ret = (ret & MOD) + (ret>>61);
    return ret-1;
}
using H = array<long long,2>; //array<int,2>;
H makeH(char c) { return {c,c}; }
uniform_int_distribution<ll> BDIST(0.1*MOD,0.9*MOD);//<int>
const H base{BDIST(rng),BDIST(rng)};
H operator+(H l, H r) { 
    F0R(i,2) if ((l[i] += r[i]) >= MOD) l[i] -= MOD;
    return l; }
H operator-(H l, H r) { 
    F0R(i,2) if ((l[i] -= r[i]) < 0) l[i] += MOD;
    return l; }
H operator*(H l, H r) { 
    F0R(i,2) l[i] = modmul(l[i],r[i]);//(ll)l[i]*r[i]%MOD;
    return l; }
V<H> pows{{1,1}};
struct HashRange { // 0-based, estremi l e r sono inclusi
    string S; V<H> cum{{}};
    void add(char c){S+=c; cum.pb(base*cum.back()+makeH(c));}
    void add(string s) { each(c,s) add(c); }
    void extend(int len) { while (sz(pows) <= len) 
        pows.pb(base*pows.back()); }
    H hash(int l, int r) { int len = r+1-l; extend(len);
        return cum[r+1]-pows[len]*cum[l]; }
};

void solve(){
    string s,t;
    cin>>s>>t;
    
    HashRange ds1,ds2;
    ds1.add(s);
    ds2.add(t);
    
    const long long mod = 998'244'353;
    vector<array<long long,3>> dp(s.size()+1);
    
    auto get = [&](int l,int r,int mode)->long long{
        assert(l<=r);
        long long res = (dp[l][mode]-(r==s.size() ? 0 : dp[r+1][mode]));
        if(res>=mod)res-=mod;
        if(res<0)res+=mod;
        return res;
    };
    
    auto find = [&](int ind)->int{
        int low = ind-1, up = min(s.size(),ind+t.size());
        while(up-low>1){
            int mid = (up+low)/2;
            
            if(ds1.hash(ind,mid)==ds2.hash(0,mid-ind))low = mid;
            else up = mid;
        }
        if(up==min(s.size(),ind+t.size()))return up;
        
        int low2 = up, up2 = min(s.size(),ind+t.size());
        while(up2-low2>1){
            int mid = (up2+low2)/2;
            
            if(ds1.hash(up+1,mid)==ds2.hash(up-ind+1,mid-ind))low2 = mid;
            else up2 = mid;
        }
        return up2;
    };
    
    dp[s.size()]={1,0,0};
    for(int i=s.size()-1;i>=0;i--){
        int pos = find(i);
        
        dp[i][0]=get(i+1,pos,0);
        dp[i][1]=get(i+1,pos,1)+get(i+1,pos,0);
        dp[i][2]=get(i+1,pos,2)+2ll*get(i+1,pos,1)+get(i+1,pos,0);
        
        //cout<<pos<<" "<<dp[i][0]<<" "<<dp[i][1]<<" "<<dp[i][2]<<"\n";
        for(int j=0;j<3;j++){
            dp[i][j]+=dp[i+1][j];
            
            while(dp[i][j]>=mod)dp[i][j]-=mod;
            while(dp[i][j]<0)dp[i][j]+=mod;
        }
    }
    
    long long ans = get(0,0,2);
    cout<<ans<<"\n";
}

int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    
    int t=1;
    //cin>>t;
    for(int i=1;i<=t;i++)solve();
    
    return 0;
}