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 Rust (1.15.1) (judge verdict: Accepted)

use std::io;

// read a line(without line feed)
fn read_line() -> String {
    let mut in_str = String::new();
    io::stdin().read_line(&mut in_str).unwrap();
    return in_str.trim().to_string();
}

fn read_words_in_line() -> Vec<String> {
    let s = read_line();
    return s.split_whitespace().map(|x| x.to_string()).collect::<Vec<String>>()
}

fn read_t_in_line<T : std::str::FromStr>() -> Vec<T> {
    let mut v : Vec<T> = Vec::new();
    for e in read_words_in_line().iter().map(|x| x.parse::<T>()) {
        if let Ok(r) = e {
            v.push(r);
        }
        else{
            return Vec::new();
        }
    }
    return v;
}

// fn div_ceil<T : std::ops::Add<Output = T> + std::ops::Sub<Output = T> + std::ops::Add<Output = T>>(x : T, y : T) -> T {
//     return (x + y - 1) / y;
// }

fn main(){
    let s = read_line();
    let s_bytes = s.as_bytes();
    let cc = s_bytes[s.len() / 2];

    // let cc = s.chars().nth(s.len() / 2).unwrap();

    for i in 0..(s.len() / 2) {
        let j1 = s.len() / 2 - 1 - i;
        let j2 = s.len() - 1 - j1;
        let c1 = s_bytes[j1];
        let c2 = s_bytes[j2];
        if !(c1 == c2 && c1 == cc) {
            println!("{}", s.len() - j1 - 1);
            return;
        }
    }
    println!("{}", s.len());
}