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

#define all(x) begin(x), end(x)
#ifdef CKISEKI
#define safe cerr << __PRETTY_FUNCTION__ << " line " << __LINE__ << " safe\n"
#define debug(a...) debug_(#a, a)
#define orange(a...) orange_(#a, a)
void debug_(auto s, auto ...a) {
  cerr << "\e[1;32m(" << s << ") = (";
  int f = 0;
  (..., (cerr << (f++ ? ", " : "") << a));
  cerr << ")\e[0m\n";
}
#include <experimental/iterator>
void orange_(auto s, auto L, auto R) {
  cerr << "\e[1;33m[ " << s << " ] = [ ";
  using namespace experimental;
  copy(L, R, make_ostream_joiner(cerr, ", "));
  cerr << " ]\e[0m\n";
}
#else
#define safe ((void)0)
#define orange(...) safe
#define debug(...) safe
#endif

vector<int> Zalgo(const string &s) {
  vector<int> z(s.size(), s.size());
  for (int i = 1, l = 0, r = 0; i < z[0]; ++i) {
    int j = clamp(r - i, 0, z[i - l]);
    for (; i + j < z[0] and s[i + j] == s[j]; ++j);
    if (i + (z[i] = j) > r) r = i + z[l = i];
  }
  return z;
}

int64_t solve(const string &s1, const string &s2) {
  vector<vector<int>> suf(s2.size(), vector(s2.size() + 1, 0));
  for (int i = 0; i < ssize(s2); ++i) {
    vector<int> pre(s2.size() + 2);
    auto z = Zalgo(s2.substr(i));
    for (int j = i + 1; j < ssize(s2); ++j) {
      int lcp = min(z[j - i], j - i);
      // s2[i, i+lcp) == s2[j, j+lcp)
      // s2[k, j) ok
      // k in [i+1, min(i+lcp-1, j-1)]
      suf[j][i + 1]++;
      suf[j][min(i + lcp, j) + 1]--;
    }
  }
  int64_t ret = 0;
  for (int i = 1; i < ssize(s2); ++i) {
    for (int j = 1; j < i; ++j) {
      suf[i][j] += suf[i][j - 1];
    }
    vector<int> tot(s2.size() + 2);
    auto s = s1 + s2.substr(0, i);
    ranges::reverse(s);
    auto z = Zalgo(s);
    for (int j = 0; j < ssize(s1); ++j) {
      int lcp = min(z[i + j], i);
      tot[1]++, tot[lcp + 1]--;
    }
    for (int j = 1; j <= ssize(s2); ++j) {
      tot[j] += tot[j - 1];
      if (i - j >= 0)
        ret += int64_t(tot[j]) * suf[i][i - j];
    }
  }
  return ret;
}

int64_t solve_same(const string &s1, const string &s2) {
  int64_t ret = 0;
  for (int i = 0; i < ssize(s1); ++i) {
    auto z = Zalgo(s1.substr(i) + s2);
    for (int p = 0; p < ssize(s2); ++p) {
      ret += min(int(s1.size()) - i, z[p + ssize(s1) - i]);
    }
  }
  return ret;
}

int main() {
  cin.tie(nullptr)->sync_with_stdio(false);
  string s1, s2;
  cin >> s1 >> s2;
  cout << solve(s1, s2) + solve(s2, s1) + solve_same(s1, s2) << '\n';
  return 0;
}

/*
abab
ab
Checking a and b
pre[1, 0]++
pre2[1, 2]++
pre2[1, 0]++
pre2[1, 2]++
pre2[1, 0]++
>>>> abab, ab: 0
pre2[1, 0]++
pre2[1, 1]++
pre2[1, 0]++
pre2[1, 1]++
>>>> abab, b: 0
Checking a and bab
pre[1, 0]++
Checking ab and ab
pre[1, 2]++
Checking aba and b
pre[1, 0]++
pre2[1, 2]++
pre2[1, 0]++
>>>> ab, abab: 2
Checking b and ab
pre[1, 0]++
Checking ba and b
pre[1, 1]++
pre2[1, 0]++
pre2[1, 1]++
>>>> ab, bab: 1
Checking a and b
pre[1, 0]++
pre2[1, 2]++
pre2[1, 0]++
>>>> ab, ab: 0
pre2[1, 0]++
pre2[1, 1]++
>>>> ab, b: 0
9
*/