#include <cmath>
#include <vector>
#include <map>
#include <set>
#include <functional>
#include <queue>
#include <iostream>
#include <string.h>
#include <iomanip>
#include <algorithm>
#include <functional>
#include <cstdint>
#include <climits>
#include <unordered_set>
#include <sstream>

using namespace std;

#define ll long long int
#define pii pair<int,int>
#define ti3 tuple<ll,ll,ll>

struct BIT
{
    std::vector<int> bit;
    
    BIT(int size) : bit(size, 0){ }
    
    void add(int k, int x) {
        while (k < bit.size()) {
            bit[k] += x;
            k += k &-k;
        }
    }
    int sum(int k) {
        int res = 0;
        while (k > 0) {
            res += bit[k];
            k -= k&-k;
        }
        return res;
    }
};

struct UnionFind {
    vector<int> data;
    
    UnionFind(int size) : data(size, -1) { }
    
    bool unionSet(int x, int y) {
        x = root(x); y = root(y);
        if (x != y)
        {
            if (data[y] < data[x]) swap(x, y);
            data[x] += data[y]; data[y] = x;
        }
        return x != y;
    }
    bool findSet(int x, int y) {
        return root(x) == root(y);
    }
    int root(int x) {
        return data[x] < 0 ? x : data[x] = root(data[x]);
    }
    int size(int x) {
        return -data[root(x)];
    }
};

ll n;

int main(void)
{
    cin >> n;
    string v;
    cin >> v;
    vector<int> s(n);
    for(int i = 0;i < n;i++)
    {
        s[i] = v[i] == 'o';
    }
    
    vector<int> ans[4];
    bool t[4];
    for(int i = 0;i < 4;i++)
    {
        ans[i].resize(n);
        t[i] = true;
    }
    const int sheep = 1;
    const int wolf = 0;
    ans[0][0] = sheep; ans[0][1] = sheep;
    ans[1][0] = sheep; ans[1][1] = wolf;
    ans[2][0] = wolf; ans[2][1] = sheep;
    ans[3][0] = wolf; ans[3][1] = wolf;
    
    for(int i = 0;i < 4;i++)
    {
        for(int k = 2;k < n;k++)
        {
            auto s1 = ans[i][k-2];
            auto s0 = ans[i][k-1];
            auto ok0 = s[k-1];
            if(s0)
            {
                if(ok0)
                {
                    ans[i][k] = s1;
                }
                else
                {
                    ans[i][k] = !s1;
                }
            }
            else
            {
                if(ok0)
                {
                    ans[i][k] = !s1;
                }
                else
                {
                    ans[i][k] = s1;
                }
            }
        }
        {
            int f = ans[i][0];
            int ok = s[0];
            bool equ = ans[i][n-1] == ans[i][1];
            bool equals = !(f^ok);
            int xo = (equals) ^ (equ);
            if(xo)
            {
                t[i] = false;
            }
        }
        {
            int f = ans[i][n-1];
            int ok = s[n-1];
            bool equ = ans[i][n-2] == ans[i][0];
            bool equals = !(f^ok);
            int xo = (equals) ^ (equ);
            if(xo)
            {
                t[i] = false;
            }
        }
        if(t[i])
        {
            break;
        }
    }
    for(int i = 0;i < 4;i++)
    {
        if(t[i])
        {
            for(int k = 0;k < n;k++)
            {
                if(ans[i][k])
                {
                    cout << "S";
                }
                else
                {
                    cout << "W";
                }
            }
            cout << endl;
            return 0;
        }
    }
    cout << "-1" << endl;
    return 0;
}

Measured memory_bytes: 2560