#include <vector>
#include <string>
#include <algorithm>
using namespace std;

int k;
vector<string> first;
long long slen[700];

struct Dat {
    long long max, maxLeft, maxRight;
    bool allOne;
    Dat() : max(0), maxLeft(0), maxRight(0), allOne(false) {
    }
};

Dat cache[700];
bool visit[700];

Dat go(int n, long long lo, long long hi) {
    if (lo == 0 && hi == slen[n] - 1 && visit[n]) {
        return cache[n];
    }

    if (n < k) {
        Dat ret;
        for (int i = lo; i <= hi && first[n][i] == '1'; ++i) {
            ret.maxLeft++;
        }
        for (int i = hi; i >= lo && first[n][i] == '1'; --i) {
            ret.maxRight++;
        }
        long long cnt = 0;
        for (int i = lo; i <= hi; ++i) {
            if (first[n][i] == '1') ++cnt;
            else cnt = 0;
            ret.max = max(ret.max, cnt);
        }
        ret.allOne = (ret.maxLeft == hi - lo + 1);

        if (lo == 0 && hi == slen[n] - 1) {
            cache[n] = ret;
            visit[n] = true;
        }
        return ret;
    }

    vector<Dat> subs;
    long long prefixLen = 0;
    for (int i = n - 1; i >= 0; i -= k) {
        if (lo < prefixLen + slen[i]) {
            Dat sub = go(i, max(lo - prefixLen, 0ll), min(hi - prefixLen, slen[i] - 1));
            subs.push_back(sub);
        }
        prefixLen += slen[i];
        if (hi < prefixLen) break;
    }

    Dat ret;
    for (int i = 0; i < subs.size(); ++i) {
        ret.maxLeft += subs[i].maxLeft;
        ret.max = max(ret.max, ret.maxLeft);
        if (!subs[i].allOne) break;
    }
    for (int i = subs.size() - 1; i >= 0; --i) {
        ret.maxRight += subs[i].maxRight;
        ret.max = max(ret.max, ret.maxRight);
        if (!subs[i].allOne) break;
    }
    long long val = 0;
    for (int i = 0; i < subs.size(); ++i) {
        val += subs[i].maxLeft;
        ret.max = max(ret.max, val);
        ret.max = max(ret.max, subs[i].max);
        if (!subs[i].allOne) val = subs[i].maxRight;
    }
    ret.allOne = (ret.maxLeft == hi - lo + 1);

    if (lo == 0 && hi == slen[n] - 1) {
        cache[n] = ret;
        visit[n] = true;
    }
    return ret;
}

class MagicalGirlLevelThreeDivOne {
public:
    long long theMaxPower(vector<string> _first, int n, long long lo, long long hi) {
        first = _first;
        k = first.size();

        int limit = 0;
        for (int i = 0; i <= n; ++i) {
            if (i < k) {
                slen[i] = first[i].length();
            }
            else {
                for (int j = i - 1; j >= 0; j -= k) {
                    slen[i] += slen[j];
                }
            }

            if (i >= k && hi < slen[i]) break;
            ++limit;
        }

        return go(min(n, limit), lo, hi).max;
    }
};