Problem:
Score : 400 points

Problem Statement

We have a string s consisting of lowercase English letters.
Snuke can perform the following operation repeatedly:

Insert a letter x to any position in s of his choice, including the beginning and end of s.

Snuke's objective is to turn s into a palindrome.
Determine whether the objective is achievable. If it is achievable, find the minimum number of operations required.

Notes

A palindrome is a string that reads the same forward and backward.
For example, a, aa, abba and abcba are palindromes, while ab, abab and abcda are not.

Constraints

1 \leq |s| \leq 10^5

s consists of lowercase English letters.

Input

Input is given from Standard Input in the following format:

s

Output

If the objective is achievable, print the number of operations required.
If it is not, print -1 instead.

Sample Input 1

xabxa

Sample Output 1

2

One solution is as follows (newly inserted x are shown in bold):

xabxa → xaxbxa → xaxbxax

Sample Input 2

ab

Sample Output 2

-1

No sequence of operations can turn s into a palindrome.

Sample Input 3

a

Sample Output 3

0

s is a palindrome already at the beginning.

Sample Input 4

oxxx

Sample Output 4

3

One solution is as follows:

oxxx → xoxxx → xxoxxx → xxxoxxx

Solution in Rust (1.15.1) (judge verdict: Accepted)

macro_rules! get {
    ($t:ty) => {
        {
            let mut line: String = String::new();
            std::io::stdin().read_line(&mut line).unwrap();
            line.trim().parse::<$t>().unwrap()
        }
    };
    ($($t:ty),*) => {
        {
            let mut line: String = String::new();
            std::io::stdin().read_line(&mut line).unwrap();
            let mut iter = line.split_whitespace();
            (
                $(iter.next().unwrap().parse::<$t>().unwrap(),)*
            )
        }
    };
    ($t:ty; $n:expr) => {
        (0..$n).map(|_|
                    get!($t)
        ).collect::<Vec<_>>()
    };
    ($($t:ty),*; $n:expr) => {
        (0..$n).map(|_|
                    get!($($t),*)
        ).collect::<Vec<_>>()
    };
    ($t:ty |) => {
        {
            let mut line: String = String::new();
            std::io::stdin().read_line(&mut line).unwrap();
            line.split_whitespace()
                .map(|t| t.parse::<$t>().unwrap())
                .collect::<Vec<_>>()
        }
    };
    ($t:ty | $n:expr) => {
        (0..$n).map(|_| get!($t |)).collect::<Vec<_>>()
    };
}
macro_rules! tern {
    ($condition: expr, $_true: expr, $_false: expr) => {
        if $condition {
            $_true
        } else {
            $_false
        }
    };
}
fn main() {
    let s = get!(String).chars().collect::<Vec<_>>();
    let diff = {
        let mut head: isize = 0;
        let mut tail: isize = s.len() as isize - 1;
        let mut head_cnt_x = 0isize;
        let mut tail_cnt_x = 0isize;
        let mut diff = 0;
        'outer: loop {
            if tail <= head {
                break;
            }
            while s[head as usize] == 'x' {
                head_cnt_x += 1;
                head += 1;
                if head == s.len() as isize {
                    break;
                }
            }
            while s[tail as usize] == 'x' {
                tail_cnt_x += 1;
                tail -= 1;
                if tail == -1 {
                    break;
                }
            }
            diff += (head_cnt_x - tail_cnt_x).abs() as usize;
            if head == s.len() as isize && tail == -1 {
            } else if head == s.len() as isize || tail == -1 {
                println!("{}", -1);
                return;
            } else if s[head as usize] != s[tail as usize] {
                println!("{}", -1);
                return;
            } else {
            }
            head += 1;
            tail -= 1;
            head_cnt_x = 0;
            tail_cnt_x = 0;
        }
        diff
    };
    println!("{}", diff);
}