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# (Mono 4.6.2.0) (judge verdict: Wrong Answer)

using System;
using System.Collections.Generic;
using System.Text;

namespace AtTest.D_Challenge
{
    class ABC_083
    {
        static void Main(string[] args)
        {
            Method(args);
            Console.ReadLine();
        }

        static void Method(string[] args)
        {
            string s = Read();
            var sequenceList = new List<int>();
            bool isZero = s[0] == '0';
            int nowCnt = 1;
            for (int i = 1; i < s.Length; i++)
            {
                if ((isZero && s[i] == '0')
                    || (!isZero && s[i] == '1'))
                {
                    nowCnt++;
                }
                else
                {
                    sequenceList.Add(nowCnt);
                    isZero = s[i] == '0';
                    nowCnt = 1;
                }
            }
            sequenceList.Add(nowCnt);
            for(int i = 0; i < sequenceList.Count; i++)
            {
                Console.WriteLine(sequenceList[i]);
            }
            int first = 0;
            int last = sequenceList.Count - 1;
            int head = sequenceList[first];
            int tail = sequenceList[last];
            int min = int.MaxValue;
            while (head + tail < s.Length)
            {
                if (head < tail)
                {
                    min = Math.Min(min, s.Length - head);
                    first++;
                    head += sequenceList[first];
                }
                else
                {
                    min = Math.Min(min, s.Length - tail);
                    last--;
                    tail += sequenceList[last];
                }
                //Console.WriteLine(head + " " + tail);
            }
            Console.WriteLine(Math.Max(head, tail));
        }

        private static string Read() { return Console.ReadLine(); }
        private static int ReadInt() { return int.Parse(Read()); }
        private static long ReadLong() { return long.Parse(Read()); }
        private static double ReadDouble() { return double.Parse(Read()); }
        private static int[] ReadInts() { return Array.ConvertAll(Read().Split(), int.Parse); }
        private static long[] ReadLongs() { return Array.ConvertAll(Read().Split(), long.Parse); }
        private static double[] ReadDoubles() { return Array.ConvertAll(Read().Split(), double.Parse); }
    }
}