Problem:
Score : 500 points

Problem Statement

You are given a string S consisting of 0 and 1.
Find the maximum integer K not greater than |S| such that we can turn all the characters of S into 0 by repeating the following operation some number of times.

Choose a contiguous segment [l,r] in S whose length is at least K (that is, r-l+1\geq K must be satisfied). For each integer i such that l\leq i\leq r, do the following: if S_i is 0, replace it with 1; if S_i is 1, replace it with 0.

Constraints

1\leq |S|\leq 10^5

S_i(1\leq i\leq N) is either 0 or 1.

Input

Input is given from Standard Input in the following format:

S

Output

Print the maximum integer K such that we can turn all the characters of S into 0 by repeating the operation some number of times.

Sample Input 1

010

Sample Output 1

2

We can turn all the characters of S into 0 by the following operations:

Perform the operation on the segment S[1,3] with length 3. S is now 101.

Perform the operation on the segment S[1,2] with length 2. S is now 011.

Perform the operation on the segment S[2,3] with length 2. S is now 000.

Sample Input 2

100000000

Sample Output 2

8

Sample Input 3

00001111

Sample Output 3

4

Solution in C++14 (GCC 5.4.1) (judge verdict: Wrong Answer)

#include <bits/stdc++.h>
using namespace std;
struct Solution {
    static float getTime() {
        unsigned long long timelo, timehi;
        __asm__ volatile ("rdtsc" : "=a" (timelo), "=d" (timehi));
        return ((timehi << 32) + timelo) / 2.8E9F;
    }
    struct XorShift {
        unsigned int x, y, z, w;
        XorShift(unsigned int seed) {
            unsigned int t = seed != 0 ? seed : 0xFFFFFFFF;
            x = 123456789;
            y = 362436069;
            z = 521288629;
            w = 88675123;
            x = y;
            y = z;
            z = w;
            w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));
        }
        unsigned int nextUInt() {
            unsigned int t = x ^ (x << 11);
            x = y;
            y = z;
            z = w;
            return w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));
        }
    };
    void solve(std::istream& in, std::ostream& out) {
        string s;
        in >> s;
        int ma = s.size();
        int ans = 1;
        bitset<100000> curr(s), next;
        XorShift rand(20171223);
        int cycle = 0;
        bool isTimeOut = false;
        double endTime = getTime() + 0.95;
        while (!isTimeOut) {
            next = curr;
            int d = rand.nextUInt() % ma;
            for (int i = 0; i < ma; i++) {
                int l = rand.nextUInt() % ma;
                int r = rand.nextUInt() % (ma - d);
                if (r >= l) r += d;
                if ((++cycle & 0xFFFF) == 0) {
                    isTimeOut = endTime < getTime();
                }
                for (int j = l; j <= r; ++j) {
                    next.flip(j);
                }
                if (!next.any()) {
                    ans = max(ans, d + 1);
                    break;
                }
            }
        }
        out << ans << '\n';
    }
};
void solve(std::istream& in, std::ostream& out) {
    out << std::setprecision(12);
    Solution solution;
    solution.solve(in, out);
}
#include <fstream>
#include <iostream>
int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    istream& in = cin;
    ostream& out = cout;
    solve(in, out);
    return 0;
}