Problem: Koa the Koala has a binary string s of length n. Koa can perform no more than n-1 (possibly zero) operations of the following form:

In one operation Koa selects positions i and i+1 for some i with 1 ≤ i < |s| and sets s_i to max(s_i, s_{i+1}). Then Koa deletes position i+1 from s (after the removal, the remaining parts are concatenated).

Note that after every operation the length of s decreases by 1.

How many different binary strings can Koa obtain by doing no more than n-1 (possibly zero) operations modulo 10^9+7 (1000000007)?

Input

The only line of input contains binary string s (1 ≤ |s| ≤ 10^6). For all i (1 ≤ i ≤ |s|) s_i = 0 or s_i = 1.

Output

On a single line print the answer to the problem modulo 10^9+7 (1000000007).

Examples

Input


000


Output


3


Input


0101


Output


6


Input


0001111


Output


16


Input


00101100011100


Output


477

Note

In the first sample Koa can obtain binary strings: 0, 00 and 000.

In the second sample Koa can obtain binary strings: 1, 01, 11, 011, 101 and 0101. For example:

  * to obtain 01 from 0101 Koa can operate as follows: 0101 → 0(10)1 → 011 → 0(11) → 01. 
  * to obtain 11 from 0101 Koa can operate as follows: 0101 → (01)01 → 101 → 1(01) → 11. 



Parentheses denote the two positions Koa selected in each operation.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
constexpr long long MODULO = (long long)1e9 + 7;
class TaskE {
 public:
  vector<int> add;
  vector<bool> subtreeClear;
  int treeTotal;
  void treeAdd(int root, int rl, int rr, int left, int right, int by) {
    if (left > right) return;
    subtreeClear[root] = false;
    if (left == rl && right == rr) {
      add[root] = (add[root] + by) % MODULO;
      treeTotal = (treeTotal + (right - left + 1) * (long long)by) % MODULO;
      return;
    }
    int rm = (rl + rr) >> 1;
    treeAdd(root * 2 + 1, rl, rm, left, min(rm, right), by);
    treeAdd(root * 2 + 2, rm + 1, rr, max(rm + 1, left), right, by);
  }
  void treeClear(int root, int rl, int rr, int left, int right) {
    if (left > right) return;
    if (subtreeClear[root]) return;
    if (left == rl && right == rr) {
      treeTotal =
          (treeTotal - add[root] * (long long)(right - left + 1)) % MODULO;
      if (treeTotal < 0) treeTotal += MODULO;
      add[root] = 0;
    }
    if (add[root] != 0) {
      add[root * 2 + 1] = (add[root * 2 + 1] + add[root]) % MODULO;
      add[root * 2 + 2] = (add[root * 2 + 2] + add[root]) % MODULO;
      subtreeClear[root * 2 + 1] = false;
      subtreeClear[root * 2 + 2] = false;
      add[root] = 0;
    }
    if (rl != rr) {
      int rm = (rl + rr) >> 1;
      treeClear(root * 2 + 1, rl, rm, left, min(rm, right));
      treeClear(root * 2 + 2, rm + 1, rr, max(rm + 1, left), right);
      subtreeClear[root] = subtreeClear[root * 2 + 1] &&
                           subtreeClear[root * 2 + 2] && add[root] == 0;
    } else {
      subtreeClear[root] = add[root] == 0;
    }
  }
  long long innerSolve(vector<int> zeros) {
    assert(zeros.size() > 0);
    if (zeros.size() == 1) {
      return zeros[0] % MODULO;
    }
    long long mult = (zeros[0] + 1) * (long long)(zeros.back() + 1) % MODULO;
    zeros.pop_back();
    zeros.erase(zeros.begin());
    int mx = 1;
    for (int x : zeros) mx = max(mx, x + 1);
    add = vector<int>(4 * mx + 10);
    subtreeClear = vector<bool>(4 * mx + 10, true);
    treeTotal = 0;
    treeAdd(0, 0, mx - 1, 0, 0, 1);
    for (int cur : zeros) {
      int total = treeTotal;
      treeClear(0, 0, mx - 1, 0, cur);
      treeAdd(0, 0, mx - 1, 0, cur, total);
      treeAdd(0, 0, mx - 1, 0, 0, 1);
    }
    return treeTotal * mult % MODULO;
  }
  void solveOne(istream &in, ostream &out) {
    string s;
    in >> s;
    s += "1";
    vector<int> zeros;
    int size = 0;
    for (int i = 0; i < s.size(); ++i) {
      if (s[i] == '0') {
        ++size;
      } else {
        zeros.push_back(size);
        size = 0;
      }
    }
    out << innerSolve(zeros) << "\n";
  }
  void solve(std::istream &in, std::ostream &out) {
    int nt = 1;
    for (int it = 0; it < nt; ++it) {
      solveOne(in, out);
    }
  }
};
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  TaskE solver;
  std::istream &in(std::cin);
  std::ostream &out(std::cout);
  solver.solve(in, out);
  return 0;
}