#include <bits/stdc++.h>

#define multi_test 0
#define DEBUG 0
#define MEAD_IN_HEAVEN

#ifdef MEAD_IN_HEAVEN
#pragma GCC optimize(3)
#pragma GCC target("avx")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
#pragma GCC optimize(2)
#endif

using LL = long long;
using PII = std::pair<int, int>;
using ULL = unsigned long long;
using constStrRef = const std::string &;

constexpr int N = 5e3 + 10, base = 1331;
ULL p[N];
bool added;

struct hash_handler {
  std::vector<ULL> h;

  hash_handler(int n) : h(n + 1, 0) {}

  void init(constStrRef s) {
    h[0] = 0;
    for (int i = 1; i <= s.size(); ++i) {
      h[i] = h[i - 1] * base + s[i - 1];
    }
  }

  ULL get(int l, int r) { return h[r] - h[l - 1] * p[r - l + 1]; }
};

void pre_work() {
  p[0] = 1;
  for (int i = 1; i < N; ++i) {
    p[i] = p[i - 1] * base;
  }
}

LL solve(constStrRef s, constStrRef t) {
  int n = s.size(), m = t.size();
  int N = n + 10;
  hash_handler sh(n), th(m);
  sh.init(s);
  th.init(t);

  std::unordered_map<ULL, int> cnts;
  for (int i = 1; i <= n; ++i) {
    for (int j = i; j <= n; ++j) {
      cnts[sh.get(i, j)]++;
    }
  }

  std::unordered_map<ULL, int> cntt;
  for (int i = 1; i <= m; ++i) {
    for (int j = i; j <= m; ++j) {
      cntt[th.get(i, j)]++;
    }
  }

  LL ans = 0;
  if (not added) {
    for (auto &[key, val] : cnts) {
      if (cntt.count(key)) {
        ans += 1LL * val * cntt[key];
      }
    }
    added = true;
  }

  auto f = std::vector(N, std::vector<int>(N, 0));
  for (int i = n; i >= 1; --i) {
    for (int j = n; j >= i; --j) {
      if (s[i - 1] == s[j - 1]) {
        f[i][j] = f[i + 1][j + 1] + 1;
      } else {
        f[i][j] = 0;
      }
    }
  }

  auto g = std::vector(N, std::vector(N, 0ll));
  // g[i][j] 表示 s[i,j] 的所有后缀在 t 中出现的次数
  for (int j = n; j >= 1; --j) {
    for (int i = j; i >= 1; --i) {
      if (i == j) {
        g[i][j] = cntt[sh.get(i, j)];
      } else {
        g[i][j] = g[i + 1][j] + cntt[sh.get(i, j)];
      }
    }
  }

  for (int i = 1; i <= n; ++i) {
    for (int j = i + 2; j <= n; ++j) {
      if (not f[i][j])
        continue;
      int pos = i + f[i][j];
      ans += g[i + 1][j - 1];
      if (pos + 1 < j) {
        ans -= g[pos + 1][j - 1];
      }
    }
  }

  return ans;
}

void solve() {
  std::string s, t;
  std::cin >> s >> t;

  std::cout << solve(s, t) +
                   solve({t.rbegin(), t.rend()}, {s.rbegin(), s.rend()})
            << '\n';
}

int main() {
  std::cin.tie(nullptr)->sync_with_stdio(false);
  if constexpr (DEBUG) {
    std::cerr.tie(nullptr);
    freopen("data.in", "r", stdin);
  }

  pre_work();

  int T = 1;
  if constexpr (multi_test) {
    std::cin >> T;
  }

  while (T--) {
    solve();
  }
}