#include <bits/stdc++.h>

typedef long long s64;

const int N = 5010;

int n, m;
char str1[N], str2[N];

int len;
char tmp[N];

int Z[N];

void Z_init() {
    Z[1] = 0;

    for (int i = 2, l = 0, r = 0; i <= len; i ++) {
        if (r < i)
            Z[i] = 0;
        else
            Z[i] = std::min(Z[i - l + 1], r - i + 1);
        
        while (i + Z[i] <= len && tmp[1 + Z[i]] == tmp[i + Z[i]]) Z[i] ++;

        if (i + Z[i] - 1 > r)
            l = i, r = i + Z[i] - 1;
    }
}

std::vector< std::pair<int, int> > buc[N];

int S[N];

namespace SAM {
    const int SZ = N * 2;

    int nClock = 1, Last = 1;
    struct node {
        int trans[26];
        int link, maxl;
    } t[SZ];

    int cnt[SZ];

    int tot, head[SZ], ver[SZ], Next[SZ];
    void add_edge(int u, int v) {
        ver[++ tot] = v;    Next[tot] = head[u];    head[u] = tot;
    }

    void init() {
        for (int i = 1; i <= nClock; i ++) {
            for (int c = 0; c < 26; c ++) t[i].trans[c] = 0;
            t[i].link = t[i].maxl = 0;
            cnt[i] = 0;
            head[i] = 0;
        }

        tot = 0;
        nClock = 1, Last = 1;
    }

    void extend(int c) {
        int p = Last,
            np = Last = ++ nClock;

        t[np].maxl = t[p].maxl + 1;

        for (; p && t[p].trans[c] == 0; p = t[p].link)
            t[p].trans[c] = np;
        
        if (!p) {
            t[np].link = 1;
        } else {
            int q = t[p].trans[c];

            if (t[q].maxl == t[p].maxl + 1) {
                t[np].link = q;
            } else {
                int nq = ++ nClock; t[nq] = t[q]; t[nq].maxl = t[p].maxl + 1;
                t[np].link = t[q].link = nq;
                for (; p && t[p].trans[c] == q; p = t[p].link) t[p].trans[c] = nq;
            }
        }

        cnt[np] ++;
    }

    void dfs(int u) {
        for (int i = head[u]; i; i = Next[i]) {
            int v = ver[i];
            dfs(v);
            cnt[u] += cnt[v];
        }
    }
}

s64 calc() {
    for (int i = 1; i <= n; i ++) buc[i].clear();

    for (int i = 1; i <= n; i ++) {
        len = 0;
        for (int x = i; x <= n; x ++) tmp[++ len] = str1[x];

        Z_init();

        for (int j = i + 2; j <= n; j ++) {
            int ni = i + std::min(j - i - 1, Z[j - i + 1]) - 1;
            buc[j].push_back(std::make_pair(i, ni));
        }
    }

    SAM::init();
    for (int i = m; i >= 1; i --) SAM::extend(str2[i] - 'a');
    for (int i = 2; i <= SAM::nClock; i ++) SAM::add_edge(SAM::t[i].link, i);
    SAM::dfs(1);
    
    s64 ans = 0;
    for (int j = 1; j <= n; j ++) {
        for (int x = 1; x <= j; x ++) S[x] = 0;

        for (auto u : buc[j]) S[u.first] ++, S[u.second + 1] --;

        for (int x = 1; x <= j; x ++) S[x] += S[x - 1];

        int p = 1;
        for (int i = j - 1; i >= 1; i --) {
            p = SAM::t[p].trans[str1[i] - 'a'];
            ans += 1ll * SAM::cnt[p] * S[i - 1];
        }
    }

    return ans;
}

int main() {
    scanf("%s", str1 + 1), n = strlen(str1 + 1);
    scanf("%s", str2 + 1), m = strlen(str2 + 1);

    s64 ans = 0;

    ans += calc();

    std::swap(n, m), std::swap(str1, str2);
    ans += calc();

    for (int i = 1; i <= n; i ++) {
        int p = 1;
        for (int j = i; j >= 1; j --) {
            p = SAM::t[p].trans[str1[j] - 'a'];
            ans += SAM::cnt[p];
        }
    }

    printf("%lld\n", ans);

    return 0;
}