import std.stdio, std.array, std.string, std.conv, std.algorithm;
import std.typecons, std.range, std.random, std.math, std.container;
import std.numeric, std.bigint, core.bitop;

void main() {
    auto S = readln.chomp;
    auto N = S.length.to!int;

    bool check1(int n) {
        BIT bit = new BIT(N+1);
        foreach (i; 0..N) {
            if (S[i] == '1') {
                bit.add(i, 1);
                bit.add(i+1, -1);
            }
        }

        foreach (i; 0..N-n+1) {
            if (bit.sum(i, i+1) % 2) {
                bit.add(i, 1);
                bit.add(i+n, -1);
            }
        }

        return N.iota.map!(i => bit.sum(0, i+1) % 2 == 0).all;
    }

    bool check2(int n) {
        BIT bit = new BIT(N+1);
        foreach (i; 0..N) {
            if (S[i] == '0') {
                bit.add(i, 1);
                bit.add(i+1, -1);
            }
        }

        foreach (i; 0..N-n+1) {
            if (bit.sum(i, i+1) % 2) {
                bit.add(i, 1);
                bit.add(i+n, -1);
            }
        }

        return N.iota.map!(i => bit.sum(0, i+1) % 2 == 0).all;
    }

    int hi = N+1;
    int lo = 1;
    while (hi - lo > 1) {
        writeln(lo, hi);
        int mid = (hi + lo) / 2;
        if (check1(mid) || check2(mid)) {
            lo = mid;
        } else {
            hi = mid;
        }
    }

    lo.writeln;
}

class BIT{
    int n;
    long[] table;

    this(int n){
        this.n = n;
        table = new long[](n+1);
    }

    void add(int i, long x){
        i++;
        while (i <= n){
            table[i] += x;
            i += i & -i;
        }
    }

    // [l, r)
    void add(int l, int r, long x) {
        add(l, x);
        add(r, -x);
    }

    // [0, i]
    long sum(int i){
        i++;
        long ret = 0;
        while (i > 0){
            ret += table[i];
            i -= i & -i;
        }
        return ret;
    }

    // [l, r)
    long sum(int l, int r){
        if (l >= r) return 0;
        return sum(r-1) - sum(l-1);
    }
}