module Main where
import Control.Monad
import Control.Applicative
import Data.Maybe
import Data.List
import qualified Text.Printf
import qualified Data.ByteString.Char8 as BC
import qualified Data.ByteString as BC

------------------------------------------

main :: IO ()
main = do
  n <- readInt
  s <- getLine
  putStrLn $ solve n s
  return ()

solve :: Int -> String -> String
solve n s = let ans = filter (check n s) [genAns s (a,b) | [a,b] <- replicateM 2 "SW"]
            in if null ans then "-1" else head ans

trans :: Char -> Char
trans 'S' = 'W'
trans 'W' = 'S'
trans _ = error "rev"

genNext :: Char -> Char -> Char -> Char
genNext e0 'S' 'o' = e0
genNext e0 'S' 'x' = trans e0
genNext e0 'W' 'o' = trans e0
genNext e0 'W' 'x' = e0

genAns :: String -> (Char, Char) -> String
genAns (xo:xos) (e0, e1) = e0:e1:foo xos e0 e1
  where foo (xo:[]) _ _ = []
        foo (xo:xos) e0 e1 = let e2 = genNext e0 e1 xo
                             in e2 : foo xos e1 e2
        foo _ _ _ = error "po"

check :: Int -> String -> String -> Bool
check len (xo0:xos) es = genNext ea eb xon == e0 && genNext eb e0 xo0 == e1
  where xon = last xos
        [e0, e1] = take 2 es
        [ea,eb] = drop (len-2) es

        
------------------------------------------

{- Int input -}

parseInt :: BC.ByteString -> Int
parseInt = fst . fromJust . BC.readInt

parseInts :: BC.ByteString -> [Int]
parseInts = map parseInt <$> BC.words

readInt :: IO Int
readInt = parseInt <$> BC.getLine

readInts :: IO [Int]
readInts = parseInts <$> BC.getLine

{- Double Formatting -}

doubleFmt :: Double -> String
doubleFmt = Text.Printf.printf "%.12f"
