// Tree Training
// Solution by Jacob Plachta

#include <algorithm>
#include <functional>
#include <numeric>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <complex>
#include <cstdlib>
#include <ctime>
#include <cstring>
#include <cassert>
#include <string>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <sstream>
using namespace std;

#define LL long long
#define LD long double
#define PR pair<int,int>

#define Fox(i,n) for (i=0; i<n; i++)
#define Fox1(i,n) for (i=1; i<=n; i++)
#define FoxI(i,a,b) for (i=a; i<=b; i++)
#define FoxR(i,n) for (i=(n)-1; i>=0; i--)
#define FoxR1(i,n) for (i=n; i>0; i--)
#define FoxRI(i,a,b) for (i=b; i>=a; i--)
#define Foxen(i,s) for (i=s.begin(); i!=s.end(); i++)
#define Min(a,b) a=min(a,b)
#define Max(a,b) a=max(a,b)
#define Sz(s) int((s).size())
#define All(s) (s).begin(),(s).end()
#define Fill(s,v) memset(s,v,sizeof(s))
#define pb push_back
#define mp make_pair
#define x first
#define y second

template<typename T> T Abs(T x) { return(x < 0 ? -x : x); }
template<typename T> T Sqr(T x) { return(x * x); }
string plural(string s) { return(Sz(s) && s[Sz(s) - 1] == 'x' ? s + "en" : s + "s"); }

const int INF = (int)1e9;
const LD EPS = 1e-12;
const LD PI = acos(-1.0);

#define GETCHAR getchar_unlocked

bool Read(int& x) {
  char c, r = 0, n = 0;
  x = 0;
  for (;;) {
    c = GETCHAR();
    if ((c < 0) && (!r))
      return(0);
    if ((c == '-') && (!r))
      n = 1;
    else if ((c >= '0') && (c <= '9'))
      x = x * 10 + c - '0', r = 1;
    else if (r)
      break;
  }
  if (n)
    x = -x;
  return(1);
}

#define MOD 1000000007
#define LIM 1000005
#define LOG 20

int N, M;
char S[LIM];
int Z[LIM];
int DS[LIM];

int TreeCnt(int h) // # of nodes in binary tree with height h
{
  return((1 << (h + 1)) - 1);
}

// E(z, s, h) = max. *s which can fit alongside z 0s (with s *s before the 1st 0) in a tree of height at most h (only relevant for z > 0)
int E(int z, int s, int h)
{
  if (h >= LOG)
    return(N);
  int left = min(s, h + 1 - z); // *s at root and along leftmost branch
  int cnt = TreeCnt(h); // full tree
  cnt -= TreeCnt(h - left); // subtract subtree of 1st 0
  if (cnt >= s)
    cnt += TreeCnt(h - left - 1); // add back right subtree of 1st 0
  return(cnt);
}

// F(p, z, s) = min. tree height for p *s, z 0s, and s *s before 1st 0 (s ignored if z = 0)
int F(int p, int z, int s)
{
  int r1 = z ? (s > 0 ? z : z - 1) : 0;
  int r2 = max(r1, min(LOG, p + z - 1));
  while (r1 < r2)
  {
    int m = (r1 + r2) >> 1;
    if ((z ? E(z, s, m) : TreeCnt(m)) >= p)
      r2 = m;
    else
      r1 = m + 1;
  }
  return(r1);
}

int ProcessCase()
{
  int i, j, z;
  // input
  scanf("%s", &S);
  N = strlen(S);
  // find 0s
  M = 0;
  Z[M++] = -1;
  Fox(i, N)
    if (S[i] == '0')
      Z[M++] = i;
  Z[M++] = N;
  // A) z = 0
  int ans = 0;
  int v = 0, s = 0;
  Fill(DS, 0);
  Fox1(i, M - 1)
  {
    int x = Z[i] - Z[i - 1] - 1; // sequence of x *s before ith 0
    v += x;
    DS[2]--, DS[x + 2]++;
  }
  Fox1(i, N)
  {
    s += DS[i];
    v += s;
    ans = (ans + (LL)v * F(i, 0, 0)) % MOD;
  }
  // B) 1 <= z <= LOG
  Fox1(z, LOG) // z 0s
  {
    Fox1(i, M - z - 1) // ith 0 as the leftmost 0
    {
      int j = i + z - 1;
      int c1 = Z[i] - Z[i - 1] - 1; // c1 *s to the left
      int c2 = Z[j + 1] - Z[j] - 1; // c2 *s to the right
      int m = Z[j] - Z[i] + 1 - z; // m *s in between
      Fox(s, c1 + 1) // use s *s to the left
      {
        int p = s + m, mp = s + m + c2;
        int h = F(p, z, s);
        while (p <= mp)
        {
          int p2 = min(mp, E(z, s, h));
          ans = (ans + (LL)(p2 - p + 1) * h) % MOD;
          p = p2 + 1, h++;
        }
      }
    }
  }
  // C) z > LOG
  Fox1(i, M - 2) // count contribution of the ith 0
  {
    // add # of intervals containing it
    ans = (ans + (LL)(Z[i] + 1) * (N - Z[i])) % MOD;
    // subtract # of intervals containing it, with <= LOG 0s
    FoxI(j, max(1, i - LOG + 1), i) // jth 0 as the leftmost 0
    {
      int k = min(M - 1, j + LOG); // first disallowed 0
      int c = (LL)(Z[j] - Z[j - 1]) * (Z[k] - Z[i]) % MOD;
      ans = (ans + MOD - c) % MOD;
    }
    // subtract # of intervals starting with it, with > LOG 0s
    int j = i + LOG;
    if (j < M)
      ans = (ans + MOD - (N - Z[j])) % MOD;
  }
  return(ans);
}

int main()
{
  int T, t;
  Read(T);
  Fox1(t, T)
    printf("Case #%d: %d\n", t, ProcessCase());
  return(0);
}