#include<bits/stdc++.h>
using namespace std;
#define rep(i,a,b) for(int i=a;i<b;i++)
#define all(p) p.begin(),p.end()
using ll =long long;
using ull = unsigned long long;
template<class T> bool chmax(T &a,T b){
    if(a<b){
        a=b;
        return true;
    }
    return false;
}

const int MOD=998244353;

const ull mod =(1ULL << 61) -1,base=1002;
struct RollingHash{
    vector<ull> hased,power;
    inline ull mul(ull a,ull b) const {
        auto ans=__uint128_t(a) * b;
        ans=(ans>>61)+(ans&mod);
        if(ans>=mod) ans-=mod;
        return ans;
    }
    RollingHash(string s){
        ll n=s.size();
        hased.assign(n+1,0);
        power.assign(n+1,0);
        power[0]=1;
        rep(i,0,n){
            power[i+1]=mul(power[i],base);
            hased[i+1]=mul(hased[i],base)+s[i];
            if(hased[i+1]>=mod) hased[i+1]-=mod;
        }
    }
    ull get(ll l,ll r) const {
        ull ret=hased[r]+mod-mul(hased[l],power[r-l]);
        if(ret>=mod) ret-=mod;
        return ret;
    }
    ll LCP(const RollingHash &b,ll l1,ll r1,ll l2,ll r2){
        ll len=min(r1-l1,r2-l2);
        ll low=-1,high=len+1;
        while(high-low>1){
            ll mid=(low+high)/2;
            if(get(l1,l1+mid)==b.get(l2,l2+mid)) low=mid;
            else high=mid;
        }
        return low;
    }
};

int main(){
    string S,T;
    cin>>S>>T;
    RollingHash RS(S),RT(T);
    int N=S.size();
    int M=T.size();
    vector<int> to(N);
    rep(i,0,N){
        int A=RS.LCP(RT,i,N,0,M);
        if(A==M){
            to[i]=i+M;
            continue;
        }
        if(A+i>=N-1) {
            to[i] = N;
            continue;
        }
        //int B=RS.LCP(RT,i+A+1,N,A,M);
        //chmax(to[i],i+A+1+B);
        int B=RS.LCP(RT,i+A+1,N,A+1,M);
        chmax(to[i],i+A+B+1);
        //B=RS.LCP(RT,i+A,N,A+1,M);
        //chmax(to[i],i+A+B);
    }
    vector<vector<ll>> dp(N+2,vector<ll>(3));
    dp[0][0]=1;
    dp[1][0]=-1;
    rep(i,0,N){
        auto tmp=dp[i];
        tmp[2]=(tmp[2]+tmp[1])%MOD;
        tmp[1]=(tmp[1]+tmp[0])%MOD;
        rep(j,0,3){
            dp[i+1][j]=(dp[i+1][j]+tmp[j]+dp[i][j])%MOD;
            dp[to[i]+1][j]=(dp[to[i]+1][j]-tmp[j])%MOD;
        }
    }
    /*
    rep(i,0,N){
        cout<<to[i];
        rep(j,0,3) cout<<" "<<dp[i][j];
        cout<<endl;
    }*/
    ll ans=(dp[N][1]+dp[N][2]*2ll)%MOD;
    cout<<(ans+MOD)%MOD<<"\n";
}