#include<bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3,unroll-loops")
#pragma GCC target("avx2,bmi,bmi2,popcnt,lzcnt")
#define fo(i,n) for(i=0;i<n;i++)
#define Fo(i,k,n) for(i=k;k<n?i<n:i>n;k<n?i+=1:i-=1)
#define ll long long
#define ld long double
#define ull unsigned long long
#define all(x) x.begin(), x.end()
#define sortall(x) sort(all(x))
#define rev(x) reverse(x.begin(), x.end())
#define fi first
#define se second
#define pb push_back
#define PI 3.14159265359
typedef pair<int, int>	pii;
typedef pair<ll, ll>	pl;
typedef vector<int>		vi;
typedef vector<ll>		vl;
typedef vector<pii>		vpii;
typedef vector<pl>		vpl;
typedef vector<vi>		vvi;
typedef vector<vl>		vvl;
bool sortbysec(const pair<int,int> &a,const pair<int,int> &b){return (a.second < b.second);}
#define sortpairbysec(x) sort(all(x), sortbysec)
bool sortcond(const pair<int,int> &a,const pair<int,int> &b){
    if (a.fi != b.fi){
        return a.fi < b.fi;
    } else {
        return a.se > b.se;
    }
}
struct myComp {
    constexpr bool operator()( pii const& a, pii const& b) const noexcept
    {
        if (a.first != b.first){
            return a.first < b.first;
        } else {
            return a.second > b.second;
        }
    }
};
mt19937_64 rang(chrono::high_resolution_clock::now().time_since_epoch().count());
ll rng(ll lim) {
    uniform_int_distribution<ll> uid(0,lim-1);
    return uid(rang);
}

const int mod = 998244353;
const int N = 3e5, M = N;
const ll inf = 1e18;
//=======================

int gcdExt(int a, int b, int *x, int *y) {
    if (a == 0){
        *x = 0, *y = 1;
        return b;
    }
    int x1, y1;
    int gcd = gcdExt(b%a, a, &x1, &y1);
    *x = y1 - (b/a) * x1;
    *y = x1;
    return gcd;
}

int modInverse(int b, int m) {
    int x, y; 
    int g = gcdExt(b, m, &x, &y);
    if (g != 1) return -1;
    return (x%m + m) % m;
}

int m_divide(long long a, long long b, long long md) {
    a = a % md;
    int inv = modInverse(b, md);
    if (inv == -1)
       return -1;
    else
       return (inv * a) % md;
}

struct poly_hash {
    const vector<ll> mods = {(ll)1e9+9, (ll)1e9+7};
    const vector<ll> p = {59, 61};
    vector<vector<ll>> pref_hash;
    vector<vector<ll>> powers;
    vector<vector<ll>> divs;
    vvi dp;

    void work(string &s){
        // precalc powers
        powers.clear();
        powers.resize(2);
        divs.clear();
        divs.resize(2);
        for (int i = 0; i < 2; i++){
            powers[i].push_back(1);
            divs[i].push_back(1);
            for (int j = 0; j < s.size(); j++){
                powers[i].push_back((powers[i].back()*p[i])%mods[i]);
                divs[i].push_back(m_divide(divs[i].back(), p[i], mods[i]));
            }
        }

        pref_hash.clear();
        pref_hash.resize(2);
        for (int i = 0; i < 2; i++){
            pref_hash[i].push_back(0);
            for (int j = 0; j < s.size(); j++){
                int val = s[j]-'a'+1; // a -> 1, b -> 2...
                pref_hash[i].push_back((pref_hash[i].back()+val*powers[i][j])%mods[i]);
            }
        }

        dp.clear();
        dp.resize(s.size()+1, vi(s.size()+1, -1));
        set<pair<ll, ll>> allz;
        map<pair<ll, ll>, int> transl;
        int i, j;
        fo(i, s.size()) Fo(j, i, s.size()){
            allz.insert(calc(i, j));
        }
        int c = 0;
        for (auto &i : allz){
            transl[i] = c;
            c++;
        }
        fo(i, s.size()) Fo(j, i, s.size()){
            dp[i][j] = transl[calc(i, j)];
            // cout << i << " " << j << " " << dp[i][j] << "\n";
        }
    }
    
    pair<ll, ll> calc(int l, int r){ // [l; r] inclusive!
        ll hash1 = ((pref_hash[0][r+1]-pref_hash[0][l]+mods[0])*divs[0][l])%mods[0];
        ll hash2 = ((pref_hash[1][r+1]-pref_hash[1][l]+mods[1])*divs[1][l])%mods[1];
        return {hash1, hash2};
    }

    int fnd(int l, int r){
        if (l > r) return -1;
        return dp[l][r];
    }
};

//=======================
// & - bitwise AND; | - bitwise OR; ^ - bitwise XOR
// cout.precision(7);
// next_permutation(arr.begin(), arr.end());
// long long long long long long long long long long long long long long long long long long long long long long long long long long long
// priority_queue<int, vector<int>, greater<int>> a; (min heap)
// ll hash1 = hash<string>{}(to_string(1));
// always lower_bound
// __builtin_clz(n) count leading zeros

vl a;
ll n, m, k, q;

ll calc(string &s, bool f){
    poly_hash ph;
    ph.work(s);
    ll ret = 0;
    // cout << ph.fnd(0, 1) << " ";
    
    // pl z = ph.calc(0, 2);
    // cout << z.fi << " " << z.se << "\n";
    // return 0;

    vi cnts(805*805, 0);
    int i, j;
    fo(i, n) Fo(j, i, n) cnts[ph.fnd(i, j)]++;

    for (int rb = 0; rb < n; rb++){
        Fo(i, rb, n) cnts[ph.fnd(rb, i)]--;
        for (int lb = 0; lb <= rb; lb++){
            for (int mid = lb; mid <= rb; mid++){
                if (f && mid == rb) continue;
                int totlen = rb-lb+1;
                int llen = mid-lb+1;
                int rlen = totlen-llen;
                if (rlen >= llen) continue;
                int missing = llen-rlen;
                int locked = llen - missing;
                if (ph.fnd(lb, lb+locked-1) != ph.fnd(mid+1, rb)) continue;
                int hsh = ph.fnd(mid-missing+1, mid);
                ret += cnts[hsh];
                // if (cnts[hsh] > 0) cout << lb << " " << mid << " " << rb << " " << cnts[hsh] << "\n";
            }
        }
    }

    return ret;
}

void solve(int tc) {
    int i, j;
    // cin >> n;
    string s;
    cin >> s;
    n = s.size();

    ll ans = 0;
    ans += calc(s, 0);
    rev(s);
    ans += calc(s, 1);

    cout << ans;
}
 
int main() {
    ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    srand(chrono::high_resolution_clock::now().time_since_epoch().count());

    int t = 1;
    // cin >> t;
    int i;
    fo(i, t) {
        solve(i+1);
    }
    return 0;
}