#pragma GCC optimize ("O3")
#pragma GCC target ("avx")
#include "bits/stdc++.h" // define macro "/D__MAI"

using namespace std;
typedef long long int ll;

#define xprintf(fmt,...) fprintf(stderr,fmt,__VA_ARGS__)
#define debugv(v) {printf("L%d %s > ",__LINE__,#v);for(auto e:v){cout<<e<<" ";}cout<<endl;}
#define debuga(m,w) {printf("L%d %s > ",__LINE__,#m);for(int x=0;x<(w);x++){cout<<(m)[x]<<" ";}cout<<endl;}
#define debugaa(m,h,w) {printf("L%d %s >\n",__LINE__,#m);for(int y=0;y<(h);y++){for(int x=0;x<(w);x++){cout<<(m)[y][x]<<" ";}cout<<endl;}}
#define ALL(v) (v).begin(),(v).end()
#define repeat(cnt,l) for(auto cnt=0ll;(cnt)<(l);++(cnt))
#define iterate(cnt,b,e) for(auto cnt=(b);(cnt)!=(e);++(cnt))
#define MD 1000000007ll
#define PI 3.1415926535897932384626433832795
#define EPS 1e-12
template<typename T1, typename T2> ostream& operator <<(ostream &o, const pair<T1, T2> p) { o << "(" << p.first << ":" << p.second << ")"; return o; }
template<typename iterator> inline size_t argmin(iterator begin, iterator end) { return distance(begin, min_element(begin, end)); }
template<typename iterator> inline size_t argmax(iterator begin, iterator end) { return distance(begin, max_element(begin, end)); }
template<typename T> T& maxset(T& to, const T& val) { return to = max(to, val); }
template<typename T> T& minset(T& to, const T& val) { return to = min(to, val); }
void bye(string s, int code = 0) { cout << s << endl; exit(0); }
mt19937_64 randdev(8901016);
inline ll rand_range(ll l, ll h) {
    return uniform_int_distribution<ll>(l, h)(randdev);
}

#ifdef __MAI
#define getchar_unlocked getchar
#define putchar_unlocked putchar
#endif
#ifdef __VSCC
#define getchar_unlocked _getchar_nolock
#define putchar_unlocked _putchar_nolock
#endif
namespace {
#define isvisiblechar(c) (0x21<=(c)&&(c)<=0x7E)
    class MaiScanner {
    public:
        template<typename T> void input_integer(T& var) {
            var = 0;
            T sign = 1;
            int cc = getchar_unlocked();
            for (; cc<'0' || '9'<cc; cc = getchar_unlocked())
                if (cc == '-') sign = -1;
            for (; '0' <= cc&&cc <= '9'; cc = getchar_unlocked())
                var = (var << 3) + (var << 1) + cc - '0';
            var = var*sign;
        }
        inline int c() { return getchar_unlocked(); }
        inline MaiScanner& operator>>(int& var) {
            input_integer<int>(var);
            return *this;
        }
        inline MaiScanner& operator>>(long long& var) {
            input_integer<long long>(var);
            return *this;
        }
        inline MaiScanner& operator>>(string& var) {
            int cc = getchar_unlocked();
            for (; !isvisiblechar(cc); cc = getchar_unlocked());
            for (; isvisiblechar(cc); cc = getchar_unlocked())
                var.push_back(cc);
            return *this;
        }
        template<typename IT> void in(IT begin, IT end) {
            for (auto it = begin; it != end; ++it) *this >> *it;
        }
    };
}
MaiScanner scanner;



namespace std {
    template<typename T1, typename T2>
    class hash<pair<T1, T2>> {
    public:
        size_t operator()(const pair<T1, T2>& x) const {
            return hash<T1>()(x.first) ^ hash<T2>()(x.second);
        }
    };
}

class rollinghash {
    typedef unsigned long long rh_t;
    static const rh_t MD_1 = (rh_t)(1e9 + 21);
    static const rh_t PW = (rh_t)(1e9 + 7);
    static vector<rh_t> pow_table[2];
public:
    vector<rh_t> hashes[2];

    rollinghash() {}
    rollinghash(const string& s) {
        build(s);
    }

    inline pair<rh_t, rh_t> operator()(int begin, int end) {
        return pair<rh_t, rh_t>(
            (hashes[0][end] - hashes[0][begin] * pow_table[0][end - begin]),
            (hashes[1][end] - (hashes[1][begin] * pow_table[1][end - begin]) % MD_1 + MD_1) % MD_1
            );
    }

    void build_pow(size_t size) {
        ++size;
        if (pow_table[0].size() < size) {
            pow_table[0].reserve(size);
            pow_table[1].reserve(size);
            if (pow_table[0].empty())
                pow_table[0].push_back(1),
                pow_table[1].push_back(1);
            for (size_t i = pow_table[0].size(); i < size; ++i) {
                pow_table[0].push_back(pow_table[0].back() * PW);
                pow_table[1].push_back(pow_table[1].back() * PW%MD_1);
            }
        }
    }
    void build(const string& src) {
        size_t m = src.size() + 1;
        build_pow(m);
        hashes[0].resize(m);
        hashes[1].resize(m);
        hashes[0][0] = hashes[1][0] = 0;
        for (size_t i = 1; i < m; ++i) {
            rh_t c = src[i - 1];
            hashes[0][i] = hashes[0][i - 1] * PW + c;
            hashes[1][i] = (hashes[1][i - 1] * PW + c)%MD_1;
        }
    }
};
vector<rollinghash::rh_t> rollinghash::pow_table[2];


ll m, n, kei;
string str;
rollinghash rh;
unordered_map<pair<int, int>, int> memo;


inline bool my_same(int left, int right, int k) {
    return rh(left,left+k) == rh(right,right+k);
}

ll dfs(int left, int right) {
    //cout << make_pair(left,right) << endl;
    if (right - left <= 1) return 1;
    if (memo.count(make_pair(right, left)))
        return memo[make_pair(right, left)];
    // + [left,right]を1つのブロック
    // + [left,left+k],[right-k,right] で1つのpair
    ll ans = 1;
    for (int k = 1; left + k <= right - k; ++k) {
        //cout << " " << make_pair(left + k, right - k) << endl;
        if (my_same(left, right, k))
            ans = (ans + dfs(left + k, right - k)) % MD;
    }
    //cout << make_pair(left,right)<<ans << endl;
    return memo[make_pair(right, left)] = ans;
}


int main() {
    scanner >> str;
    n = str.size();
    rh.build(str);


    ll ans = dfs(0, n);

    cout << ans << endl;

    return 0;
}