#include <algorithm>
#include <iostream>
#include <map>
#include <unordered_map>
#include <vector>
#include <bits/extc++.h>

using namespace std;
using namespace __gnu_pbds;

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

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

void add(int& a, int b) {
	a += b;
	if (a >= MOD) {
		a -= MOD;
	}
}

struct rolling_hash {
  vector<int> multInvs[2];
  vector<int> sums[2];

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

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

		multInvs[0].push_back(fastPow(currPw1, MOD - 2, MOD));
		multInvs[1].push_back(fastPow(currPw2, MOD - 2, MOD));
		currPw1 = ((int64_t)currPw1 * BASE[0]) % MOD;
		currPw2 = ((int64_t)currPw2 * BASE[1]) % MOD;
	}
  }

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

	int tmp2 = sums[1][r] - (l == 0 ? 0 : sums[1][l - 1]);
	if (tmp2 < 0)
	  tmp2 += MOD;
	tmp2 = ((int64_t)tmp2 * multInvs[1][l]) % MOD;

    return {tmp1, tmp2};
  }
};


int64_t toValue(pair<int, int> p) {
	return (int64_t) p.first * (int64_t) MOD + (int64_t)p.second;
}

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

  int n = s.size();
  int64_t ans = 0;
  gp_hash_table<int64_t, int> cntWithHash;
  for (int lGreen = 0; lGreen < n; lGreen++) {
    for (int lRed = lGreen + (1 - countZeroGreen); 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;

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

    for (int i = 0; i <= lGreen; i++) {
      auto h = rh.getSubhash(i, lGreen);
      cntWithHash[toValue(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;
}