#include <bits/stdc++.h>

#define rep(i,s,n) for(int i = int(s); i < int(n); i++)
#define rrep(i,s,n) for(int i = int(n) - 1; i >= int(s); i--)
#define all(v) (v).begin(), (v).end()

using ll = long long;
using ull = unsigned long long;
using ld = long double;

template<class T>
bool chmin(T &a, T b) {
    if(a <= b) return false;
    a = b;
    return true;
}

template<class T>
bool chmax(T &a, T b) {
    if(a >= b) return false;
    a = b;
    return true;
}

using namespace std;


vector<int> suffix_array(const string &s){
    int n = s.size();
    vector<int> rnk(n, -1), sa(n);
    iota(all(sa), 0);
    rep(i,0,n){
        rnk[i] = s[i];
    }
    int k = 1;
    auto compare = [&](int i, int j) -> bool {
        if (rnk[i] != rnk[j]) return rnk[i] < rnk[j];
        return (i+k < n ? rnk[i+k]: -1) < (j+k < n ? rnk[j+k]: -1);
    };
    while (k < n){
        sort(all(sa), compare);
        vector<int> tmp(n, 0);
        rep(i,1,n){
            tmp[sa[i]] = tmp[sa[i-1]] + int(compare(sa[i-1],sa[i]));
        }
        swap(rnk,tmp);
        k<<=1;
    }
    return sa;
}

vector<int> lcp_array(const string&s, const vector<int> &sa){
    int n = s.size();
    vector<int> rnk(n), lcp(n-1);
    rep(i,0,n) rnk[sa[i]] = i;
    int h = 0;
    rep(i,0,n){
        if (h>0) h--;
        if (rnk[i] == 0) continue;
        int j = sa[rnk[i] - 1];
        while(i+h<n && j+h<n && s[i+h]==s[j+h]){
            h++;
        }
        lcp[rnk[i]-1] = h;
    }
    return lcp;
}

template<class S, S(*op)(S, S)> struct SparseTable {
    vector<vector<S>> table;
    vector<int> clz;
    SparseTable(const vector<S> &vec){
        int n = vec.size(), n2 = 0;
        while((1<<n2)<n) n2++;
        table.resize(n2+1);
        rep(i,0,n2+1){
            table[i].resize(n);
            if(i==0){
                rep(j,0,n)table[i][j]=vec[j];
            }else{
                rep(j,0,n){
                    if(j+(1<<(i-1))<n){
                        table[i][j] = op(table[i-1][j], table[i-1][j+(1<<(i-1))]);
                    }else{
                        table[i][j] = table[i-1][j];
                    }
                }
            }
        }
        clz.resize(n+1);
        rep(i,0,n2+1){
            for(int j=(1<<i);j<(2<<i)&&j<=n;j++){
                clz[j]+=i;
            }
        }
    }
    
    S get(int l, int r){
        assert(r-l>0);
        int lgs = clz[r-l];
        return op(table[lgs][l], table[lgs][r-(1<<lgs)]);
    }
};

int op(int a, int b){
    return min(a,b);
}

int main() {
    std::cin.tie(nullptr);
    std::ios::sync_with_stdio(false);
    string s, t; cin >> s >> t;
    int n = s.size(), m = t.size();
    string st = s + t;
    vector<int> sa = suffix_array(st);
    vector<int> inv(n+m);
    rep(i,0,n+m) inv[sa[i]] = i;
    vector<int> lcp = lcp_array(st,sa);
    SparseTable<int,op> spt(lcp);
    auto get_lcp = [&](int sl, int tl){
        int l = inv[sl];
        int r = inv[n+tl];
        if (l > r) swap(l,r);
        int ans = spt.get(l,r);
        chmin(ans,n-sl);
        chmin(ans,m-tl);
        return ans;
    };
    auto s_get_lcp = [&](int sl1, int sl2){
        int l = inv[sl1];
        int r = inv[sl2];
        if (l > r) swap(l,r);
        int ans = spt.get(l,r);
        chmin(ans,n-sl1);
        chmin(ans,n-sl2);
        return ans;
    };
    auto t_get_lcp = [&](int tl1, int tl2){
        int l = inv[n+tl1];
        int r = inv[n+tl2];
        if (l > r) swap(l,r);
        int ans = spt.get(l,r);
        chmin(ans,m-tl1);
        chmin(ans,m-tl2);
        return ans;
    };
    ll ans = 0;
    // s == t;
    vector<vector<int>> sdp(n+1,vector<int>(n+2,0));
    vector<vector<int>> tdp(m+1,vector<int>(m+2,0));
    rep(sl,0,n) rep(tl,0,m){
        int len = get_lcp(sl,tl);
        ans += len;
        sdp[sl][sl]++;
        sdp[sl][sl+len+1]--;
        tdp[tl][tl]++;
        tdp[tl][tl+len+1]--;
    }
    // cout << ans << endl;
    rep(sl,0,n) rep(sr,0,n+1) sdp[sl][sr+1] += sdp[sl][sr];
    rep(tl,0,m) rep(tr,0,m+1) tdp[tl][tr+1] += tdp[tl][tr];
    // s > t
    rep(sl2,1,n){
        vector<ll> rui(sl2+1,0);
        rrep(sl1,0,sl2){
            rui[sl1] = rui[sl1+1] + sdp[sl1][sl2];
            int len = s_get_lcp(sl1,sl2);
            // cout << sl1 << ' ' << sl2 << ' ' << len << endl;
            chmin(len,sl2-sl1-1);
            if (len == 0) continue;
            ans += rui[sl1+1] - rui[sl1+len+1];
        }
        // cout << sl2 << ' ' << ans << endl;
    }
    // cout << ans << endl;
    // t > s
    rep(tl2,1,m){
        vector<ll> rui(tl2+1,0);
        rrep(tl1,0,tl2){
            rui[tl1] = rui[tl1+1] + tdp[tl1][tl2];
            int len = t_get_lcp(tl1,tl2);
            chmin(len,tl2-tl1-1);
            if (len == 0) continue;
            ans += rui[tl1+1] - rui[tl1+len+1];
        }
    }
    cout << ans << endl;
}