#[allow(unused_imports)]
use std::cmp::{max, min, Ordering};
#[allow(unused_imports)]
use std::collections::{HashMap, HashSet};

mod util {
    use std::io::stdin;
    use std::str::FromStr;
    use std::fmt::Debug;

    #[allow(dead_code)]
    pub fn line() -> String {
        let mut line: String = String::new();
        stdin().read_line(&mut line).unwrap();
        line.trim().to_string()
    }

    #[allow(dead_code)]
    pub fn get<T: FromStr>() -> T
    where
        <T as FromStr>::Err: Debug,
    {
        let mut line: String = String::new();
        stdin().read_line(&mut line).unwrap();
        line.trim().parse().unwrap()
    }

    #[allow(dead_code)]
    pub fn gets<T: FromStr>() -> Vec<T>
    where
        <T as FromStr>::Err: Debug,
    {
        let mut line: String = String::new();
        stdin().read_line(&mut line).unwrap();
        line.split_whitespace()
            .map(|t| t.parse().unwrap())
            .collect()
    }

    #[allow(dead_code)]
    pub fn get2<T: FromStr, U: FromStr>() -> (T, U)
    where
        <T as FromStr>::Err: Debug,
        <U as FromStr>::Err: Debug,
    {
        let mut line: String = String::new();
        stdin().read_line(&mut line).unwrap();
        let mut iter = line.split_whitespace();
        (
            iter.next().unwrap().parse().unwrap(),
            iter.next().unwrap().parse().unwrap(),
        )
    }

    #[allow(dead_code)]
    pub fn get3<S: FromStr, T: FromStr, U: FromStr>() -> (S, T, U)
    where
        <S as FromStr>::Err: Debug,
        <T as FromStr>::Err: Debug,
        <U as FromStr>::Err: Debug,
    {
        let mut line: String = String::new();
        stdin().read_line(&mut line).unwrap();
        let mut iter = line.split_whitespace();
        (
            iter.next().unwrap().parse().unwrap(),
            iter.next().unwrap().parse().unwrap(),
            iter.next().unwrap().parse().unwrap(),
        )
    }
}

#[allow(unused_macros)]
macro_rules! debug {
    ($x: expr) => {
        println!("{}: {:?}", stringify!($x), $x)
    }
}

fn main() {
    let _n: usize = util::get();
    let s: Vec<bool> = util::line().chars().map(|c| c == 'o').collect();

    // true -> S, false -> W
    let ans = vec![
        vec![true, true],
        vec![true, false],
        vec![false, true],
        vec![false, false],
    ].into_iter()
        .map(|mut v| {
            for &b in &s[..s.len() - 2] {
                let cur = v[v.len() - 1];
                let left = v[v.len() - 2];

                if b {
                    if cur {
                        v.push(left);
                    } else {
                        v.push(!left);
                    }
                } else {
                    if cur {
                        v.push(!left);
                    } else {
                        v.push(left);
                    }
                }
            }
            v
        })
        .find(|v| {
            s[s.len() - 2] == (v[v.len() - 1] == (v[v.len() - 2] == v[0])) &&
                s[s.len() - 1] == (v[0] == (v[1] == v[v.len() - 1]))
        });

    if let Some(mut v) = ans {
        let first = v[0];
        v.remove(0);
        v.push(first);
        println!(
            "{}",
            v.iter()
                .map(|&b| if b { "S" } else { "W" })
                .collect::<String>()
        );
    } else {
        println!("-1");
    }
}


Measured memory_bytes: 4352