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

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Numerics;
using System.Text;
using static System.Console;
using static System.Convert;
using static System.Math;
using static Extentions;

class IO
{
    int idx;
    string[] input = In.ReadToEnd().Split(new[] { " ", "\n", "\r" },
        StringSplitOptions.RemoveEmptyEntries);

    T Get<T>(Func<string, T> parser) => parser(input[idx++]);

    public string S => Get(s => s);
    public char C => Get(char.Parse);
    public int I => Get(int.Parse);
    public long L => Get(long.Parse);
    public double F => Get(double.Parse);
    public decimal D => Get(decimal.Parse);
    public BigInteger B => Get(BigInteger.Parse);

    T[] Gets<T>(int n, Func<string, T> parser)
        => input.Skip((idx += n) - n).Take(n).Select(parser).ToArray();

    public string[] Ss(int n) => Gets(n, s => s);
    public char[] Cs(int n) => Gets(n, char.Parse);
    public int[] Is(int n) => Gets(n, int.Parse);
    public long[] Ls(int n) => Gets(n, long.Parse);
    public double[] Fs(int n) => Gets(n, double.Parse);
    public decimal[] Ds(int n) => Gets(n, decimal.Parse);
    public BigInteger[] Bs(int n) => Gets(n, BigInteger.Parse);

    public void Write<T>(params T[] xs) => WriteLine(string.Join(" ", xs));
    public void Write(params object[] xs) => WriteLine(string.Join(" ", xs));
}

static class Extentions
{
}

static class Program
{
    public static void Main()
    {
        var sw = new StreamWriter(OpenStandardOutput()) { NewLine = "\n" };
#if DEBUG
        sw.AutoFlush = true;
#else
        sw.AutoFlush = false;
#endif
        SetOut(sw);
        Solve(new IO());
        Out.Flush();
    }

    static void Solve(IO io)
    {
        var s = io.S;

        if (s.All(c => c == 'x'))
        {
            io.Write(0);
            return;
        }

        var init = new Stack<char>();
        var tail = new Queue<char>(s.Where(c => c != 'x').Reverse());

        var initx = new Stack<char>();
        var tailx = new Queue<char>(s.Reverse());

        var initxc = new Stack<int>();
        var tailxc = new Queue<int>();

        {
            var tmp = 0;

            foreach (var c in s.Reverse())
            {
                if (c != 'x') { tailxc.Enqueue(tmp); tmp = 0; }
                else tmp++;
            }

            tailxc.Enqueue(tmp);
        }

        var ans = int.MaxValue;

        for (var i = 0; i < s.Length; i++)
        {
            var c = tailx.Dequeue();

            if (c == 'x')
            {
                initx.Push(c);
                continue;
            }

            var c0 = tail.Dequeue();
            initxc.Push(tailxc.Dequeue());

            if (init.Count == tail.Count && init.SequenceEqual(tail))
            {
                ans = Min(ans, initxc.Zip(tailxc, (x, y) => Abs(x - y)).Sum());
            }
            else if (Abs(init.Count - tail.Count) == 1 && tail.Any())
            {
                var c1 = tail.Dequeue();
                var x0 = tailxc.Dequeue();

                if (c0 == c1 && init.SequenceEqual(tail))
                    ans = Min(ans, initxc.Zip(tailxc, (x, y) => Abs(x - y)).Sum());

                tail.Enqueue(c1);
                tailxc.Enqueue(x0);
            }

            initx.Push(c);
            init.Push(c0);
        }

        io.Write(ans == int.MaxValue ? -1 : ans);
    }
}