#include <algorithm>
#include <iostream>
#include <unordered_map>
#include <vector>

using namespace std;

int fastPow(int x, int pw, int mod) {
  if (pw == 0)
    return 1;
  else if (pw % 2 == 0) {
    int tmp = fastPow(x, pw / 2, mod);
    return ((int64_t)tmp * tmp) % mod;
  } else
    return ((int64_t)x * fastPow(x, pw - 1, mod)) % mod;
}

struct rolling_hash {
  static const int BASE = 43;
  static const int MOD = 1e9 + 7;

  vector<int> multInvs;
  vector<int> sums;

  rolling_hash(const std::string &s) {
    int n = s.size();

    int currPw = 1;
    sums.resize(n);
    for (int i = 0; i < n; i++) {
      sums[i] = ((int64_t)(s[i] - 'a' + 1) * currPw) % MOD;
      if (i != 0)
        sums[i] = (sums[i] + sums[i - 1]) % MOD;

      multInvs.push_back(fastPow(currPw, MOD - 2, MOD));
      currPw = ((int64_t)currPw * BASE) % MOD;
    }
  }

  int getSubhash(int l, int r) {
    int h = sums[r] - (l == 0 ? 0 : sums[l - 1]);
    if (h < 0)
      h += MOD;
    return ((int64_t)h * multInvs[l]) % MOD;
  }
};

int64_t count(const string &s, bool countZeroGreen) {
  rolling_hash rh = rolling_hash(s);

  int n = s.size();
  int64_t ans = 0;
  unordered_map<int, int> cntWithHash;
  for (int lGreen = 0; lGreen < n; lGreen++) {
    for (int lRed = lGreen; lRed < n; lRed++) {
      for (int rRed = lRed; rRed < n; rRed++) {
        int lenGreen = lRed - lGreen;
        if (lenGreen != 0 && rRed + lenGreen < n &&
            rh.getSubhash(lGreen, lRed - 1) !=
                rh.getSubhash(rRed + 1, rRed + lenGreen))
          continue;

        if (rRed + lenGreen >= n)
          continue;

        if (lenGreen == 0 && !countZeroGreen)
          continue;

        ans += cntWithHash[rh.getSubhash(lRed, rRed)];
      }
    }

    for (int i = 0; i <= lGreen; i++) {
      cntWithHash[rh.getSubhash(i, lGreen)]++;
    }
  }

  return ans;
}

int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(nullptr);

  string s;
  cin >> s;

  int64_t ans = count(s, true);

  reverse(s.begin(), s.end());
  ans += count(s, false);

  cout << ans << endl;
}