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.

Examples

Input

6
ooxoox


Output

SSSWWS


Input

3
oox


Output

-1


Input

10
oxooxoxoox


Output

SSWWSSSWWS
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.*;
import java.util.InputMismatchException;

public class Main {

	public static void main(String[] args) {
		InputReader in = new InputReader(System.in);
		PrintWriter out = new PrintWriter(System.out);

		int n=in.nextInt();
		String s =in.nextToken();
        char[][] c = new char[4][n];

        c[0][0] = 'S';
        c[0][1] = 'S';
        c[1][0] = 'S';
        c[1][1] = 'W';
        c[2][0] = 'W';
        c[2][1] = 'S';
        c[3][0] = 'W';
        c[3][1] = 'W';

        for(int i=1; i<n-1; i++) {
            for(int j=0; j<4; j++) {
                if(c[j][i] == 'S') {
                    if(s.charAt(i)=='o') {
                        c[j][i+1] = c[j][i-1];
                    } else {
                        c[j][i+1] = rev(c[j][i-1]);
                    }
                } else{
                    if(s.charAt(i)=='o') {
                        c[j][i+1] = rev(c[j][i-1]);
                    }else{
                        c[j][i+1] = c[j][i-1];
                    }
                }
            }
        }
        boolean ans = false;
        int ansN=0;
        for(int j=0; j<4; j++) {
            boolean a = check(c[j][n-1], s.charAt(n-1), c[j][n-2], c[j][0]);
            boolean b = check(c[j][0], s.charAt(0), c[j][n-1], c[j][1]);
            if(a && b) {
                ans = true;
                ansN = j;
                break;
            }
        }

        if(ans == false) {
            out.println(-1);
        }else {
            out.println(new String(c[ansN]));
        }
		out.flush();
	}

    public static boolean check(char Ani, char say, char n1, char n2) {
        if(Ani == 'S') {
            if(say=='o') {
                if(n1 == n2) {
                    return true;
                }
            } else {
                if(n1 != n2) {
                    return true;
                }
            }
        } else {
            if(say=='o') {
                if(n1 != n2) {
                    return true;
                }
            } else {
                if(n1 == n2) {
                    return true;
                }
            }
        }
        return false;
    }

    public static char rev(char c) {
        if(c == 'S') {
            return 'W';
        }else {
            return 'S';
        }
    }

	// ----------------------

	static class InputReader {
		private InputStream stream;
		private byte[] buf = new byte[1024];
		private int curChar;
		private int numChars;

		public InputReader(InputStream stream) {
			this.stream = stream;
		}

		private int next() {
			if (numChars == -1)
				throw new InputMismatchException();
			if (curChar >= numChars) {
				curChar = 0;
				try {
					numChars = stream.read(buf);
				} catch (IOException e) {
					throw new InputMismatchException();
				}
				if (numChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}

		public char nextChar() {
			int c = next();
			while (isSpaceChar(c))
				c = next();
			if (('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z')) {
				return (char) c;
			}
			throw new InputMismatchException();
		}

		public String nextToken() {
			int c = next();
			while (isSpaceChar(c))
				c = next();
			StringBuilder res = new StringBuilder();
			do {
				res.append((char) c);
				c = next();
			} while (!isSpaceChar(c));
			return res.toString();
		}

		public int nextInt() {
			int c = next();
			while (isSpaceChar(c))
				c = next();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = next();
			}
			int res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c-'0';
				c = next();
			} while (!isSpaceChar(c));
			return res*sgn;
		}

		public long nextLong() {
			int c = next();
			while (isSpaceChar(c))
				c = next();
			long sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = next();
			}
			long res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c-'0';
				c = next();
			} while (!isSpaceChar(c));
			return res*sgn;
		}

		public double nextDouble() {
			return Double.valueOf(nextToken());
		}

		public boolean isSpaceChar(int c) {
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		//public interface SpaceCharFilter {
		//	public boolean isSpaceChar(int ch);
		//}
	}
	// template
	static int gcd(int n, int r) { return r == 0 ? n : gcd(r, n%r);  }
	static long gcd(long n, long r) { return r == 0 ? n : gcd(r, n%r);  }

	static <T> void swap(T[] x, int i, int j) { T t = x[i]; x[i] = x[j]; x[j] = t;  }
	static void swap(int[] x, int i, int j) { int t = x[i]; x[i] = x[j]; x[j] = t;  }
}
