#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();

    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)
		  add(sums[h][i], sums[h][i - 1]);

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

  pair<int, 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;
    }

    return {res[0], res[1]};
  }
};


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