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

using namespace std;

const int BASE[] = {37, 43};
const int MOD = 1e9 + 7;

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 {
  vector<int> multInvs[2];
  vector<int> sums[2];

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

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

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

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

    int tmp = res[0] + res[1];
    if (tmp >= MOD)
      tmp -= MOD;

    return tmp;
  }
};

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;

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

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

  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;
}