#include <bits/stdc++.h>
#define fr first
#define sc second
#define all(a) (a).begin(), (a).end()
#define unique(a) a.resize(unique(a.begin(), a.end()) - a.begin())

#define cerr if(0)cerr

using namespace std;

#ifdef ONPC
mt19937 rnd(223);
#else
mt19937 rnd(chrono::high_resolution_clock::now()
			.time_since_epoch().count());
#endif

#define TIME (clock() * 1.0 / CLOCKS_PER_SEC)

using ll = long long;
using ld = double;

const int maxn = 1e5 + 100, inf = 1e9 + 100;

// если модуль подается на вход, убрать все <> и раскомментировать нужные строки
using uint = unsigned int;
using ull = unsigned long long;
template <uint MD> struct ModInt {
    using M = ModInt;
    // static int MD;
    uint v;
    ModInt(ll _v = 0) { set_v(uint(_v % MD + MD)); }
    M& set_v(uint _v) {
        v = (_v < MD) ? _v : _v - MD;
        return *this;
    }
    explicit operator bool() const { return v != 0; }
    M operator-() const { return M() - *this; }
    M operator+(const M& r) const { return M().set_v(v + r.v); }
    M operator-(const M& r) const { return M().set_v(v + MD - r.v); }
    M operator*(const M& r) const { return M().set_v(uint((ull)v * r.v % MD)); }
    M operator/(const M& r) const { return *this * r.inv(); }
    M& operator+=(const M& r) { return *this = *this + r; }
    M& operator-=(const M& r) { return *this = *this - r; }
    M& operator*=(const M& r) { return *this = *this * r; }
    M& operator/=(const M& r) { return *this = *this / r; }
    bool operator==(const M& r) const { return v == r.v; }
    bool operator!=(const M& r) const { return v != r.v; }
    M inv() const;
    friend istream& operator>>(istream& is, M& r) { ll x; is >> x; r = M(x); return is; }
    friend ostream& operator<<(ostream& os, const M& r) { return os << r.v; }
};

template<uint MD>
ModInt<MD> pow(ModInt<MD> x, ll n) {
    ModInt<MD> r = 1;
    while (n) {
        if (n & 1) r *= x;
        x *= x;
        n >>= 1;
    }
    return r;
}

template<uint MD>
ModInt<MD> ModInt<MD>::inv() const { return pow(*this, MD - 2); }

using Mint = ModInt<int(1e9) + 7>;
// using Mint = double;

inline vector<Mint> multiply(const vector<Mint> &p,const vector<Mint> &q)  {
    vector<Mint> r(p.size() + q.size() - 1);
    for(int i = 0;i < p.size(); ++i) {
        for(int j = 0; j < q.size();j++) {
            r[i+j] += p[i] * q[j];
        }
    }
    return r;
}

struct poly : vector<Mint> {
    poly() {}
    poly(const vector<Mint> &a) : vector<Mint>(a) {}
    poly(int n) : vector<Mint>(n, 0) {}

    template <class It>
    poly(It left, It right) : vector<Mint>(left, right) {}

    inline void normalize() {
        while (size() > 1 && back() == 0) pop_back();
    }

    inline Mint& operator[](int pos) {
        if (pos >= (int)size()) resize(pos + 1);
        return vector<Mint>::operator[](pos);
    }

    inline Mint operator[](int pos) const {
        if (pos < (int)size()) return vector<Mint>::operator[](pos);
        return 0;
    }

    inline poly operator+(const poly &b) const {
        const poly &a = *this;
        poly ans(max((int)a.size(), (int)b.size()));
        for (int i = 0; i < ans.size(); i++) ans[i] = a[i] + b[i];
        return ans;
    }

    inline poly operator+=(const poly &p) {
        return *this = *this + p;
    }

    inline poly operator-(const poly &b) const {
        const poly &a = *this;
        poly ans(max((int)a.size(), (int)b.size()));
        for (int i = 0; i < ans.size(); i++) ans[i] = (a[i] - b[i]);
        return ans;
    }

    inline poly operator-=(const poly &p) {
        return *this = *this - p;
    }

    inline poly operator*(Mint d) const {
        poly ans = *this;
        for (int i = 0; i < (int)ans.size(); i++) ans[i] = ans[i] * d;
        return ans;
    }

    inline poly operator*=(Mint d) {
        return *this = *this * d;
    }

    inline poly operator/(Mint d) const {
        d = d.inv();
        poly ans = *this;
        for (int i = 0; i < (int)ans.size(); i++) ans[i] = ans[i] * d;
        return ans;
    }

    inline poly operator/=(Mint d) {
        return *this = *this / d;
    }



    inline poly operator*(const poly &p) const {
        return poly(multiply(*this, p));	  // here any multiply with fft should be used
    }

    inline poly operator*=(const poly &p) {
        return *this = *this * p;
    }

    inline poly cut(int n) const {
        poly a = (*this);
        a.resize(n);
        return a;
    }

    inline poly invp() const {
        poly a(1);
        a[0] = 1;
        if ((*this)[0] != 1) a[0] = (*this)[0].inv();
        for (int n = 1; n < (int)size(); n <<= 1) {
            poly ca = cut(n + n);
            poly ra = (a * a);
            ra.cut(n + n);
            ra = (ra * ca);
            ra.cut(n + n);
            a += a;
            a -= ra;
            a = a.cut(n + n);
        }
        a.resize(size());
        return a;
    }

    inline poly rev() const {
        poly a = (*this);
        reverse(a.begin(), a.end());
        return a;
    }

    inline poly getdiv(poly b) const { // use it only to divide polynomials
        poly a = (*this);
        a.normalize();
        b.normalize();
        if (a.size() < b.size()) return poly(1);
        int k = (int)a.size() - (int)b.size() + 1;
        if (b.back() != 1) b /= b.back();
        poly rb = b.rev().cut(k);
        return (rb.invp() * a.rev()).cut(k).rev();
    }

    inline poly operator/(const poly &b) const { // use it only to divide polynomials
        return getdiv(b);
    }

    inline poly operator/=(const poly &b) { // use it only to divide polynomials
        return *this = *this / b;
    }

    inline poly operator%(const poly &b) const { // use it only to divide polynomials
        poly a = (*this);
        poly d = (a / b);
        if (d.size() == 1 && d[0] == 0) return a;
        poly r = (a - d * b);
        r.normalize();
        return r;
    }

    inline poly operator%=(const poly &b) {
        return *this = *this % b;
    }

    inline poly der() const {
        const poly& a = (*this);
        vector<Mint> ans;
        for (int i = 1; i < size(); i++) {
            ans.emplace_back(a[i] * i);
        }
        return ans;
    }

    inline poly integral() const {
        const poly& a = (*this);
        vector<Mint> ans;
        ans.emplace_back(0);
        for (int i = 0; i < size(); i++) {
            ans.push_back(a[i] / (i + 1));
        }
        return ans;
    }
};
// n=500k, inv: 300ms, log: 500ms, exp: 1100ms; n=2^17, multipoint: 1500ms
// Newton: solving f(x) = 0, make iterations x = x - f(x)/f'(x)
// be careful with length of a, make 0 at the end to get the longer result

poly polypow(poly P, ll k, int n) {
    P.resize(n);
    poly ans = poly(n,0);
    ans[0] = 1;
    for(;k;k>>=1,P*=P,P.resize(n)) {
        if(k&1)ans*=P,ans.resize(n);
    }
    return ans;
}

poly F(poly Q, int deg) {
    poly one = poly(deg,0);
    one[0]=1;
    poly Q2 = Q*Q;
    Q2.resize(deg);
    poly xQ4 = Q2*Q2;
    xQ4.insert(xQ4.begin(), 0);
    xQ4.resize(deg);
    return one - Q + xQ4*Mint(3);
}

poly dF(poly Q, int deg) {
    poly mone = poly(deg,0);
    mone[0]=-1;
    poly Q2 = Q*Q;
    Q2.resize(deg);
    poly Q3 = Q2*Q;
    Q3.resize(deg);
    Q3.insert(Q3.begin(),0);
    return mone + Q3*Mint(12);
}

void solve() {
    string s;
    cin >> s;
    vector<int> v;
    for(int i = 0; i < s.size(); i++) {
        v.push_back((s[i]-i)&3);
        while(v.size()>=4&&v[v.size()-4]==v.back()&&v[v.size()-3]==v.back()&&v[v.size()-2]==v.back()) {
            for(int j=0;j<4;j++)v.pop_back();
        }
    }
    int n = (s.size() - v.size()) / 4;
    int k = v.size();
//    cerr << n << " " << k << endl;
    poly Q = poly(1,1);
    while(Q.size()<n+1) {
        cerr << "Q: " << Q.size() << endl;
        int deg = Q.size();
        poly FQ = F(Q,deg*2);
        poly dFQ = dF(Q,deg*2);
        cerr << FQ[0] << " " << FQ[1] << endl;
        cerr << dFQ[0] << " " << dFQ[1] << endl;
//        cerr << "FQ: " << FQ.size() << endl;
        poly quo = FQ * dFQ.invp();
        cerr << quo[0] << " " << quo[1] << endl;
        Q = Q - quo;
        Q.resize(deg*2);
    }
    Q.resize(n+1);
    cerr << "Final Q:" << endl;
    cerr << Q[0] << " " <<Q[1] << endl;

    poly den = Q*Q*Q*Mint(-4);
    den.insert(den.begin(),1);
    poly P = den.invp();
    P.resize(n+1);

    poly ans = P*polypow(Q,k,n+1);
    cout << ans[n];
}

int main() {
#ifdef ONPC
    freopen("../a.in", "r", stdin);
//    freopen("../a.out", "w", stdout);
#endif
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout << fixed;
    cout.precision(20);
    solve();
    cerr << "\n\nConsumed " << TIME << endl;
}