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: Wrong Answer)

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<_>>();
    if !s.iter().filter(|c| **c != 'x').zip(s.iter().filter(|c| **c != 'x').rev()).all(|(&x, &y)| x == y) {
        println!("-1");
        return;
    }
    let diff = {
        let only_not_xs = s.iter().filter(|c| **c != 'x').count();
        let mut head = 0;
        let mut tail = s.len() - 1;
        let mut head_cnt_x = 0isize;
        let mut tail_cnt_x = 0isize;
        let mut diff = 0;
        'outer: loop {
            if tail <= head {
                break;
            }
            loop {
                if s[head] == 'x' {
                    head_cnt_x += 1;
                } else {
                    head += 1;
                    break;
                }
                head += 1;
                if head == s.len() {
                    break;
                }
            }
            loop {
                if s[tail] == 'x' {
                    tail_cnt_x += 1;
                } else {
                    tail -= 1;
                    break;
                }
                tail -= 1;
                if tail == 0 {
                    break;
                }
            }
            diff += (head_cnt_x - tail_cnt_x).abs() as usize;
            head_cnt_x = 0;
            tail_cnt_x = 0;
        }
        diff
    };
    println!("{}", diff);
}