#define _CRT_SECURE_NO_WARNINGS
#pragma comment(linker, "/stack:16777216")
#include <string>
#include <vector>
#include <map>
#include <list>
#include <iterator>
#include <set>
#include <queue>
#include <iostream>
#include <sstream>
#include <stack>
#include <deque>
#include <cmath>
#include <memory.h>
#include <cstdlib>
#include <cstdio>
#include <cctype>
#include <algorithm>
#include <utility>
#include <time.h>
using namespace std;

#define FOR(i, a, b) for(int i = (a); i < (b); ++i)
#define RFOR(i, b, a) for(int i = (b) - 1; i >= (a); --i)
#define REP(i, N) FOR(i, 0, N)
#define RREP(i, N) RFOR(i, N, 0)
#define FILL(A,value) memset(A,value,sizeof(A))

#define ALL(V) V.begin(), V.end()
#define SZ(V) (int)V.size()
#define PB push_back
#define MP make_pair
#define Pi 3.14159265358979
#define nice sdagasdgadsg

typedef long long Int;
typedef unsigned long long UINT;
typedef vector <int> VI;
typedef pair <int, int> PII;

const int INF = 1000000000;
const int MAX = 300007;
const int MAX2 = 7000;
const int BASE = 1000000000;


int d[207][207];
bool canMove[207][207][4];

pair<int,int> q[207 * 207];

int main()
{
    #ifndef ONLINE_JUDGE
        //freopen("in.txt", "r", stdin);
    #endif

    //freopen("domino-on-torus.in" , "r", stdin);
    //freopen("domino-on-torus.out", "w",stdout);

    string s;
    cout << "N" << endl;
    cin >> s;

    int n = 10;

    int x = 0;
    int y = 0;

    FOR(i,0,207)
        FOR(j,0,207)
            FOR(k,0,4)
                canMove[i][j][k] = 1;

    int iter = 0;

    while (1)
    {
        ++iter;

        if (iter == 1307)throw -1;

        //cout << x << ' ' << y << ' ' << n << endl;

        int l = 0;
        int r = 1;

        FOR(i,0,n + 1)
        {
            FOR(j,0,n + 1)
            {
                d[i][j] = -1;
            }
        }

        d[n - 1][n - 1] = 0;
        q[0] = MP(n - 1,n - 1);
        while (l < r)
        {
            int X = q[l].first;
            int Y = q[l].second;
            ++l;
            if (canMove[X][Y][1] && X < n && d[X + 1][Y] == -1)
            {
                d[X + 1][Y] = d[X][Y] + 1;
                q[r++] = MP(X + 1, Y);
            }
            if (canMove[X][Y][0] && Y < n && d[X][Y + 1] == -1)
            {
                d[X][Y + 1] = d[X][Y] + 1;
                q[r++] = MP(X, Y + 1);
            }
            if (canMove[X][Y][3] && X > 0 && d[X - 1][Y] == -1)
            {
                d[X - 1][Y] = d[X][Y] + 1;
                q[r++] = MP(X - 1, Y);
            }

            if (canMove[X][Y][2] && Y > 0 && d[X][Y - 1] == -1)
            {
                d[X][Y - 1] = d[X][Y] + 1;
                q[r++] = MP(X, Y - 1);
            }
            if (d[x][y] != -1) break;
        }

        //if (d[x][y] == -1) throw -1;

        if (d[x][y] == 0)
        {
            cout << "N" << endl;
            cin >> s;
            if (s == "end")
            {
                return 0;
            }
            if (s == "ok")
            {
                ++x;
                ++n;
            }
            if (s == "no")
            {
                canMove[n - 1][n - 1][1] = false;
                canMove[n][n - 1][3] = false;
                ++n;
            }
        }
        else
        {
            if (x < n && canMove[x][y][1] && d[x + 1][y] == d[x][y] - 1)
            {
                cout << "N" << endl;
                cin >> s;
                if (s == "ok")
                {
                    ++x;
                    n = max(n , x + 1);
                }
                else
                {
                    canMove[x][y][1] = 0;
                    canMove[x + 1][y][3] = 0;
                }
                continue;
            }

            if (y < n && canMove[x][y][0] && d[x][y + 1] == d[x][y] - 1)
            {
                cout << "E" << endl;
                cin >> s;
                if (s == "ok")
                {
                    ++y;
                    n = max(n , y + 1);
                }
                else
                {
                    canMove[x][y][0] = 0;
                    canMove[x][ y + 1][2] = 0;
                }
                continue;
            }


            if (x > 0 && canMove[x][y][3] && d[x - 1][y] == d[x][y] - 1)
            {
                cout << "S" << endl;
                cin >> s;
                if (s == "ok")
                {
                    --x;
                    //n = max(n , x + 1);
                }
                else
                {
                    canMove[x][y][3] = 0;
                    canMove[x - 1][y][1] = 0;
                }
                continue;
            }

            if (y > 0 && canMove[x][y][2] && d[x][y - 1] == d[x][y] - 1)
            {
                cout << "W" << endl;
                cin >> s;
                if (s == "ok")
                {
                    --y;
                    //n = max(n , x + 1);
                }
                else
                {
                    canMove[x][y][2] = 0;
                    canMove[x][y - 1][0] = 0;
                }
                continue;
            }
        }

    }

    return 0;
}