#include <cstdint>
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <numeric>
#include <unordered_map>
#include <string_view>
#include <functional>


std::string h_str;
struct count {

    std::uint32_t a{0};
    std::uint32_t b{0};
    std::uint32_t c{0};

    void add(char x)
    {
        if (x == 'a') {
            ++a;
        }
        if (x == 'b') {
            ++b;
        }
        if (x == 'c') {
            ++c;
        }
    }

    void print() {
        std::cout << "a:" << a << " b:" << b << " c:" << c << "; ";
    }

    std::size_t hash() {
        h_str = "a" + std::to_string(a) + "b" + std::to_string(b) + "c" + std::to_string(c);
        return std::hash<std::string>{}(h_str);
    }

    bool is_balanced() const
    {
        std::vector<char> to_comp;
        if(a != 0) {
            to_comp.push_back(a);
        }
        if(b != 0) {
            to_comp.push_back(b);
        }
        if(c != 0) {
            to_comp.push_back(c);
        }

        auto prev = to_comp.begin();
        bool ret = true;
        while(prev != to_comp.end()) {
            auto next = std::next(prev);
            if(next != to_comp.end()) {
                ret &= *prev == *next;
            }
            prev = next;
        }

        return ret;
    }
};

count operator-(const count& l, const count& r) {
    count ct;
    ct.a = l.a - r.a;
    ct.b = l.b - r.b;
    ct.c = l.c - r.c;

    return ct;
}

using type = long;

struct linear_ {} linear;
struct dp_ {} dp;
std::unordered_map<std::size_t, type> results;
std::vector<count> counts;
std::size_t wsize;
std::string word;
std::string_view sv;
std::size_t key;
int pos_a = 0;
int pos_b = 0;
int s;
count ct;
std::unordered_map<std::size_t, type>::iterator found;
type res = 0;

static type res_arr[300001];
type r_idx = 0;

template<typename It>
std::string_view make_sv(It begin, It end)
{
    return std::string_view(&(*begin), std::distance(begin, end));
}

type solution(const std::string& word, std::size_t idx_f, std::size_t idx_b) {
    if(idx_b > idx_f) {
        return 0;
    }

    auto sv = make_sv(word.begin()+idx_b, word.begin()+idx_f+1);
    auto key = std::hash<std::string_view>{}(sv);
    // static int a = 0;
    // if(a > 3000000) {
    //     a=0;
    // }
    // auto key = std::hash<int>{}(a++);


    if (auto found = results.find(key); found != results.end()) {
        return found->second;
    }

    type res = 0;
    // counts[idx_f+1].print();
    // std::cout << '\n';
    // counts[idx_b].print();
    // std::cout << '\n';

    ct = counts[idx_f+1] - counts[idx_b];
    // ct.print();
    // std::cout << idx_b << " " << idx_f << " " << sv << " ";
    if (ct.is_balanced()) {
        // std::cout << " YES\n";
        ++res;
    }

    res += solution(word, idx_f, ++idx_b);

    results[key] = res;
    return res;
}

type solution(const std::string& word)
{
    type res = 0;

    std::size_t idx_f = 0;

    auto w_size = word.size();
    while (idx_f < w_size) {
        res += solution(word, idx_f, 0);
        ++idx_f;
    }

    return res;
}

type solution()
{
    // std::cout << indent << pos_a << " " << pos_b << '\n';
    if(pos_a > wsize-1) {
        return 0;
    }
    if(pos_b > wsize-1) {
        return 0;
    }

    // std::cout << indent << "here" << '\n';

    s = (int)wsize - (pos_a + pos_b);
    if(s <= 0) {
        return 0;
    }

    sv = make_sv(word.begin()+pos_a, word.end()-pos_b);
    auto key = std::hash<std::string_view>{}(sv);
    ct = counts[wsize - pos_b] - counts[pos_a];
    // auto key = ct.hash();

    // std::cout << indent << sign << " " << pos_a << " " << pos_b << " " << sv << " h: " << key << '\n';

    // if(found = results.find(key); found != results.end()) {
    //     // std::cout << indent << found->second << '\n';
    //     return found->second;
    // }

    type res = 0;

    // if(s < 10000) {
    //     res = solution(word, linear);
    // } else {

    // if(s == 1) {
    //     res = 1;
        // res = solution(word, linear);
    // } else {

        // auto rhs = solution(word, pos_a, pos_b+1, 1);
        // auto lhs = solution(word, pos_a+1, pos_b);
        // auto sub = lhs.first;
        // res = rhs.first + lhs.first - lhs.second;

    if (ct.is_balanced()) {
        // ++res_arr[r_idx];
        ++res;
    }

    pos_b += 1;
    res += solution();
    // res_arr[r_idx++] += solution();
    // --r_idx;
    pos_b -= 1;

    pos_a += 1;
    res += solution();
    // res_arr[r_idx++] += solution();
    // --r_idx;
    pos_a -= 1;

    pos_a += 1;
    pos_b += 1;
    res -= solution();
    // res_arr[r_idx++] -= solution();
    // --r_idx;
    pos_a -= 1;
    pos_b -= 1;

    // std::cout << indent << "s: " << s << '\n';
    // std::cout << indent << "wsize - pos_b: " << wsize - pos_b << " pos_a: " << pos_a << '\n';

    // }

    // std::cout << indent << res << '\n';

    // results[key] = res;
    return res;
}


void make_test(std::size_t size) {
    for(int i=0; i<size; i+=3) {
        std::cout << "abc";
    }
}


void run_alg()
{
    std::cin >> word;

    counts.reserve(word.size()+1);

    count ct;
    counts.push_back(ct);

    for (auto x : word) {
        ct.add(x);
        counts.push_back(ct);
        // ct.print();
        // std::cout << '\n';
    }
    // std::cout << '\n';



    std::cout << solution(word) << '\n';
}

int main(int argc, char** argv)
{
    run_alg();
    // char mode = argv[1][0];

    // switch(mode) {
    //     case 't':
    //     {
    //         std::size_t size = static_cast<std::size_t>(std::atoi(argv[2]));
    //         make_test(size);
    //         break;
    //     }
    //     case 'a':
    //         run_alg();
    //         break;
    // }

    return 0;
}