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 Haskell (GHC 7.10.3) (judge verdict: Wrong Answer)

import qualified Data.ByteString.Char8 as BC
import Data.Maybe (fromJust)
import Data.Char
import Data.List

main = do
  input <- BC.getLine
  let x = map digitToInt . BC.unpack $ input
      ans = solve x
  if (head x) == 0 && ans == (length x) then print 0
                                        else print ans

solve :: [Int] -> Int
solve x
  | mod (length x) 2 == 0 = let n = length x
                                mid = div n 2
                                left = reverse $ take mid x
                                right = drop mid x
                            in (div n 2) + (solve' (head left) left right)
  | length x == 1 = head x
  | otherwise    = let n = length x
                       mid = div n 2
                       left = reverse $ take mid x
                       right = drop (mid+1) x
                   in if (x !! mid) == (head left)
                        then 1 + (div n 2) + (solve' (x !! mid) left right)
                        else 1 + (div n 2)

solve' :: Int -> [Int] -> [Int] -> Int
solve' n []     []     = 0
solve' n (l:ls) (r:rs)
  | n == l && l == r = 1 + (solve' n ls rs)
  | otherwise        = 0