#include "bits/extc++.h"

using namespace std;

template <typename T, typename... U>
void dbgh(const T& t, const U&... u) {
    cerr << t;
    ((cerr << " | " << u), ...);
    cerr << endl;
}

#ifdef DEBUG
#define dbg(...)                                           \
    cerr << "L" << __LINE__ << " [" << #__VA_ARGS__ << "]" \
         << ": ";                                          \
    dbgh(__VA_ARGS__)
#else
#define cerr   \
    if (false) \
    cerr
#define dbg(...)
#endif

#define endl "\n"
#define long int64_t
#define sz(x) int(std::size(x))

namespace kactl {
#define rep(i, a, b) for (int i = a; i < (b); ++i)
#define all(x) begin(x), end(x)
using ll = long;

// Arithmetic mod 2^64-1. 2x slower than mod 2^64 and more
// code, but works on evil test data (e.g. Thue-Morse, where
// ABBA... and BAAB... of length 2^10 hash the same mod 2^64).
// "typedef ull H;" instead if you think test data is random,
// or work mod 10^9+7 if the Birthday paradox is not a problem.
typedef uint64_t ull;
struct H {
    ull x; H(ull x=0) : x(x) {}
    H operator+(H o) { return x + o.x + (x + o.x < x); }
    H operator-(H o) { return *this + ~o.x; }
    H operator*(H o) { auto m = (__uint128_t)x * o.x;
        return H((ull)m) + (ull)(m >> 64); }
    ull get() const { return x + !~x; }
    bool operator==(H o) const { return get() == o.get(); }
    bool operator<(H o) const { return get() < o.get(); }
};
static const H C = (ll)1e11+3; // (order ~ 3e9; random also ok)

struct HashInterval {
    vector<H> ha, pw;
    HashInterval(string& str) : ha(sz(str)+1), pw(ha) {
        pw[0] = 1;
        rep(i,0,sz(str))
            ha[i+1] = ha[i] * C + str[i],
            pw[i+1] = pw[i] * C;
    }
    H hashInterval(int a, int b) { // hash [a, b)
        return ha[b] - ha[a] * pw[b - a];
    }
};

vector<H> getHashes(string& str, int length) {
    if (sz(str) < length) return {};
    H h = 0, pw = 1;
    rep(i,0,length)
        h = h * C + str[i], pw = pw * C;
    vector<H> ret = {h};
    rep(i,length,sz(str)) {
        ret.push_back(h = h * C + str[i] - pw * str[i-length]);
    }
    return ret;
}

H hashString(string& s){H h{}; for(char c:s) h=h*C+c;return h;}

#undef rep
#undef all
}  // namespace kactl

void solve() {
    string s;
    cin >> s;
    int n = sz(s);

    vector<int> hsh[n + 1];
    for (int len = 1; len <= n; len++) {
        auto ch = kactl::getHashes(s, len);

        auto sch = ch;
        sort(begin(sch), end(sch));
        sch.erase(unique(begin(sch), end(sch)), end(sch));

        auto comp = [&](const kactl::H& h) -> int {
            return int(lower_bound(begin(sch), end(sch), h) - begin(sch));
        };

        for (auto& a : ch) {
            hsh[len].push_back(comp(a));
        }
    }

    long ans = 0;

    auto go2 = [&]() -> void {
        for (int l1 = 1; l1 <= n; l1++) {
            for (int l2 = 1; l1 + l1 + l2 + l2 <= n; l2++) {
                int cnt[n] {};

                for (int i = 0; i + l1 + l1 + l2 <= n; i++) {
                    if (i >= l2) {
                        cnt[hsh[l2][i - l2]]++;
                    }

                    if (hsh[l1][i] == hsh[l1][i + l1 + l2]) {
                        ans += cnt[hsh[l2][i + l1]];
                    }
                }
            }
        }
    };

    go2();
    for (auto& a : hsh) {
        reverse(begin(a), end(a));
    }
    go2();

    dbg(ans);
    for (int len = 1; len <= n; len++) {
        int cnt[n] {};

        for (int i = 0; i + len <= n; i++) {
            if (i >= len) {
                cnt[hsh[len][i - len]]++;
            }
            ans += cnt[hsh[len][i]];
        }
    }

    cout << ans << endl;
}

int main() {
    cin.tie(nullptr);
    cin.exceptions(ios::failbit);
    ios_base::sync_with_stdio(false);
    solve();
}