import qualified Data.Monoid as M
import qualified Data.DList as D

newtype Animal = Animal { getAnimal :: Int } deriving (Show, Eq)
sheep = Animal 0
wolf = Animal 1


newtype Answer = Answer { getAnswer :: Int } deriving Show
same = Answer 0
differ = Answer 1


next :: Animal -> Animal -> Answer -> Animal
next f s a = Animal $ (getAnimal f + getAnimal s + getAnswer a) `mod` 2


answerToChar :: Char -> Answer
answerToChar 'o' = same
answerToChar _ = differ


animals' :: Animal -> Animal -> [Answer] -> D.DList Animal -> Maybe [Animal]
animals' f s [a,b] d =
  let rs@(p:q:_) = D.toList d
  in if (next f s a == p) && (next s p b == q)
     then Just rs
     else Nothing
animals' f s (a:as) d =
  let f' = s
      s' = next f s a
  in animals' f' s' as (D.snoc d s')


animals :: [Answer] -> Maybe [Animal]
animals as = M.getFirst $
  M.First (animals' sheep sheep as (D.fromList [sheep, sheep])) `mappend`
  M.First (animals' sheep wolf as (D.fromList [sheep, wolf])) `mappend`
  M.First (animals' wolf sheep as (D.fromList [wolf, sheep])) `mappend`
  M.First (animals' wolf wolf as (D.fromList [wolf, wolf]))


animalToChar :: Animal -> Char
animalToChar s = if s == sheep then 'S' else 'W'

showAnimals :: Maybe [Animal] -> String
showAnimals Nothing = show (-1)
showAnimals (Just (a:as)) = (map animalToChar as) ++ [animalToChar a]

main :: IO ()
main = do
  n <- getLine
  line <- getLine
  let answers = map answerToChar line
  print $ showAnimals (animals answers)
