Problem:
Score : 500 points

Problem Statement

Snuke, who loves animals, built a zoo.

There are N animals in this zoo. They are conveniently numbered 1 through N, and arranged in a circle.
The animal numbered i (2≤i≤N-1) is adjacent to the animals numbered i-1 and i+1. Also, the animal numbered 1 is adjacent to the animals numbered 2 and N, and the animal numbered N is adjacent to the animals numbered N-1 and 1.

There are two kinds of animals in this zoo: honest sheep that only speak the truth, and lying wolves that only tell lies.

Snuke cannot tell the difference between these two species, and asked each animal the following question: "Are your neighbors of the same species?" The animal numbered i answered s_i. Here, if s_i is o, the animal said that the two neighboring animals are of the same species, and if s_i is x, the animal said that the two neighboring animals are of different species.

More formally, a sheep answered o if the two neighboring animals are both sheep or both wolves, and answered x otherwise.
Similarly, a wolf answered x if the two neighboring animals are both sheep or both wolves, and answered o otherwise.

Snuke is wondering whether there is a valid assignment of species to the animals that is consistent with these responses. If there is such an assignment, show one such assignment. Otherwise, print -1.

Constraints

3 ≤ N ≤ 10^{5}

s is a string of length N consisting of o and x.

Input

The input is given from Standard Input in the following format:

N
s

Output

If there does not exist an valid assignment that is consistent with s, print -1.
Otherwise, print an string t in the following format. The output is considered correct if the assignment described by t is consistent with s.

t is a string of length N consisting of S and W.

If t_i is S, it indicates that the animal numbered i is a sheep. If t_i is W, it indicates that the animal numbered i is a wolf.

Sample Input 1

6
ooxoox

Sample Output 1

SSSWWS

For example, if the animals numbered 1, 2, 3, 4, 5 and 6 are respectively a sheep, sheep, sheep, wolf, wolf, and sheep, it is consistent with their responses. Besides, there is another valid assignment of species: a wolf, sheep, wolf, sheep, wolf and wolf.

Let us remind you: if the neiboring animals are of the same species, a sheep answers o and a wolf answers x. If the neiboring animals are of different species, a sheep answers x and a wolf answers o.

Sample Input 2

3
oox

Sample Output 2

-1

Print -1 if there is no valid assignment of species.

Sample Input 3

10
oxooxoxoox

Sample Output 3

SSWWSSSWWS

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.Text;
using System.Threading.Tasks;

public static class Quiz
{
    static IEnumerable<X[]> Iterator<X>(int i, X[] buffer, X[] all)
    {
        if (i == buffer.Length)
        {
            yield return buffer;
        }
        else
        {
            foreach (var x in all)
            {
                buffer[i] = x;

                foreach (var xs in Iterator(i + 1, buffer, all))
                {
                    yield return xs;
                }
            }
        }
    }

    public static IEnumerable<char[]> AllPropositions(int n)
    {
        return Iterator(0, new char[n], new char[] { 'o', 'x' });
    }

    public static IEnumerable<char[]> AllAnimals(int n)
    {
        return Iterator(0, new char[n], new char[] { 'S', 'W' });
    }
}

public sealed class BruteForceSolver
{
    public bool IsConsistent(int n, string s, char[] animals)
    {
        for (var i = 0; i < n; i++)
        {
            var isSame = animals[i] == 'S' ? (s[i] == 'o') : (s[i] == 'x');
            var previous = animals[(i - 1 + n) % n];
            var next = animals[(i + 1) % n];

            if (isSame && previous == next) continue;
            if (!isSame && previous != next) continue;

            return false;
        }

        return true;
    }

    public string Solve(int n, string s)
    {
        foreach (var animals in Quiz.AllAnimals(n))
        {
            if (IsConsistent(n, s, animals)) return new string(animals);
        }

        return null;
    }
}

public sealed class FastSolver
{
    char Inverse(char animal)
    {
        return animal == 'S' ? 'W' : 'S';
    }

    bool TryBuild(char first, char second, int n, string s, char[] animals)
    {
        animals[0] = first;
        animals[1] = second;

        for (var i = 1; i + 1 < n + 2; i++)
        {
            animals[(i + 1) % n] =
                ((s[i % n] == 'o') ^ (animals[i % n] == 'W'))
                    ? animals[(i - 1) % n]
                    : Inverse(animals[(i - 1) % n]);
        }

        return animals[0] == first && animals[1] == second;
    }

    public string Solve(int n, string s)
    {
        var pairs =
            new[]
            {
                Tuple.Create('S', 'S'),
                Tuple.Create('S', 'W'),
                Tuple.Create('W', 'S'),
                Tuple.Create('W', 'W'),
            };

        var animals = new char[n];

        foreach (var pair in pairs)
        {
            if (TryBuild(pair.Item1, pair.Item2, n, s, animals))
            {
                return new string(animals);
            }
        }

        return null;
    }
}

public sealed class Checker
{
    public void Run()
    {
        var bruteForce = new BruteForceSolver();
        var fast = new FastSolver();

        for (var n = 3; n < 10; n++)
        {
            foreach (var ps in Quiz.AllPropositions(n))
            {
                var s = new string(ps);
                var expected = bruteForce.Solve(n, s);
                var actual = fast.Solve(n, s);
                if (expected != actual)
                {
                    System.Diagnostics.Debug.Assert(false);
                }
            }
        }
    }
}

public class Program
{
    #region Standard I/O
    readonly TextReader input;
    readonly TextWriter output;

    X[] ReadLine<X>(Func<string, X> func)
    {
        return input.ReadLine().Split(' ').Select(func).ToArray();
    }

    void WriteLineOne(object obj)
    {
        output.WriteLine("{0}", obj);
    }

    void WriteLineMany(params object[] objects)
    {
        output.WriteLine(string.Join(" ", objects.Select(obj => obj.ToString())));
    }
    #endregion

    int n;
    string s;

    public void Run()
    {
        n = ReadLine(int.Parse)[0];
        s = input.ReadLine();
        var solution = new FastSolver().Solve(n, s);
        WriteLineOne(solution == null ? "-1" : solution);
    }

    public Program(TextReader input, TextWriter output)
    {
        this.input = input;
        this.output = output;
    }

    public static void Main(string[] args)
    {
        new Program(Console.In, Console.Out).Run();
    }
}