#include <algorithm>
#include <iostream>
#include <vector>
#include <queue>

using namespace std;

const char UP = 'N';
const char DOWN = 'S';
const char LEFT = 'W';
const char RIGHT = 'E';

const int UP_IDX    = 0;
const int RIGHT_IDX = 1;
const int DOWN_IDX  = 2;
const int LEFT_IDX  = 3;

const int SIDE_SIZE = 20;
const int INF = SIDE_SIZE * SIDE_SIZE + 1;
const int START_I = SIDE_SIZE / 2;
const int START_J = SIDE_SIZE / 2;

struct Point {
    int i;
    int j;
};

struct DistAndMoves {
    DistAndMoves() : possible_moves(4, false), dist(INF) {}
    DistAndMoves(int dist) : possible_moves(4, false), dist(dist) {}

    vector<bool> possible_moves;
    int dist;
};

struct PointDist {
    int i;
    int j;
    int dist;
};

void Bfs(const vector<vector<bool>>& is_available, vector<vector<DistAndMoves>>& turns) {
    turns[START_I][START_J].dist = 0;

    queue<PointDist> q;
    q.push({ START_I, START_J, 0 });
    while (!q.empty()) {
        auto [i, j, dist] = q.front();
        q.pop();

        for (int di = -1; di <= 1; ++di) {
            for (int dj = -1; dj <= 1; ++dj) {
                if (di * di + dj * dj != 1) continue;

                int ni = i + di;
                int nj = j + dj;
                if (ni < 0 || is_available.size() <= ni ||
                    nj < 0 || is_available.front().size() <= nj) {
                    continue;
                }
                if (!is_available[ni][nj]) continue;
                if (turns[ni][nj].dist < dist) continue;
                if (turns[ni][nj].dist == INF) {
                    if (di == -1) {
                        turns[ni][nj].possible_moves[UP_IDX] = true;
                    } else if (di == 1) {
                        turns[ni][nj].possible_moves[DOWN_IDX] = true;
                    } else if (dj == -1) {
                        turns[ni][nj].possible_moves[LEFT_IDX] = true;
                    } else if (dj == 1) {
                        turns[ni][nj].possible_moves[RIGHT_IDX] = true;
                    }
                    turns[ni][nj].dist = dist + 1;
                    q.push({ ni, nj, turns[ni][nj].dist });
                    continue;
                }

                if (turns[ni][nj].dist == dist + 1) {
                    if (di == -1) {
                        turns[ni][nj].possible_moves[UP_IDX] = true;
                    }
                    else if (di == 1) {
                        turns[ni][nj].possible_moves[DOWN_IDX] = true;
                    }
                    else if (dj == -1) {
                        turns[ni][nj].possible_moves[LEFT_IDX] = true;
                    }
                    else if (dj == 1) {
                        turns[ni][nj].possible_moves[RIGHT_IDX] = true;
                    }
                }
            }
        }
    }
}

int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    vector<vector<bool>>is_available(SIDE_SIZE, vector<bool>(SIDE_SIZE, false));
    string path;
    cin >> path;
    is_available[START_I][START_J] = true;
    int i = START_I;
    int j = START_J;
    for (auto move : path) {
        if (move == RIGHT) {
            j += 1;
        }
        else if (move == LEFT) {
            j -= 1;
        }
        else if (move == UP) {
            i += 1;
        }
        else if (move == DOWN) {
            i -= 1;
        }
        is_available[i][j] = true;
    }

    for (int i = 0; i < SIDE_SIZE; ++i) {
        for (int j = 0; j < SIDE_SIZE; ++j) {
            if (i == START_I && j == START_J) {
                cout << 'S'; continue;
            }
            if (is_available[i][j]) {
                cout << 1;
            } else {
                cout << 0;
            }
        }
        cout << '\n';
    }


    DistAndMoves dam;
    vector<vector<DistAndMoves>> dist_and_moves(is_available.size(),
        vector<DistAndMoves>(is_available.size(), dam));

    Bfs(is_available, dist_and_moves);
    string shortest_way_out;

    /*
    moves priority
    N, E, S, W

    const char UP = 'N';
    const char DOWN = 'S';
    const char LEFT = 'W';
    const char RIGHT = 'E';
    */
    while (!(i == START_I && j == START_J)) {
        if (dist_and_moves[i][j].possible_moves[DOWN_IDX]) {
            ++i;
            shortest_way_out += UP;
        } else if (dist_and_moves[i][j].possible_moves[UP_IDX]) {
            --i;
            shortest_way_out += DOWN;
        } else if (dist_and_moves[i][j].possible_moves[RIGHT_IDX]) {
            --j;
            shortest_way_out += LEFT;
        } else /*if (dist_and_moves[i][j].possible_moves[LEFT_IDX])*/ {
            ++j;
            shortest_way_out += RIGHT;
        }
    }

    reverse(begin(shortest_way_out), end(shortest_way_out));
    cout << shortest_way_out;

    return 0;
}