import sys,random
random.seed(0)

F='NESW'
D=[(-1,0), (0,1), (1,0), (0,-1)]
add=lambda X, Y: (X[0] + Y[0], X[1] + Y[1])
sub=lambda X, Y: (X[0] - Y[0], X[1] - Y[1])
step=lambda X, i: add(X, D[i])
rev=lambda A:map(lambda x:(x+2)%4, A[::-1])

class State:
    def __init__(S):
        S.x = (0,0)
        S.path = []
        S.G = {S.x:'.'}
        S.trap = None
        S.seen = set([S.x])
        S.visited = set([S.x])

    def visit(S, U):
        S.visited.add(S.x)
        for i,v in enumerate(U):
            p = step(S.x, i)
            if not p in S.seen:
                S.seen.add(p)
                S.G[p] = v
        if S.G[S.x] == '.':
            S.G[S.x] = ":"

    def print_ans(S):
        r0 = r1 = c0 = c1 = 0
        for r,c in S.G.keys():
            c0 = min(c0, c)
            c1 = max(c1, c)
            r0 = min(r0, r)
            r1 = max(r1, r)
        M=dict(S.G)
        for rc,v in M.iteritems():
            if v == ':':
                M[rc] = '.'
        print("%d %d" %(r1-r0+1, c1-c0+1))
        for r in range(r0, r1+1):
            ln = [M.get((r,c), '#') for c in range(c0, c1+1)]
            print(''.join(ln))

    def search(S, nogo=set()):
        while True:
            s = None
            for i in range(4):
                p = step(S.x, i)
                if p not in nogo and p not in S.visited and S.G[p] != '#':
                    s = i
                    break
            if s is None:
                if not S.path:
                    break
                s = (S.path[-1]+2)%4
                del S.path[-1]
            else:
                S.path += [s]
            print F[s]
            S.x = step(S.x, s)
            ln=raw_input().split()
            S.visit(ln[0])
            if ln[1] == 'trap':
                S.trap = S.x
                succ = State()
                succ.visit(ln[2])
                return succ
        return None

    def walk(S, path):
        for s in path:
            p = step(S.x, s)
            if S.G.get(p, '#') == '#':
                return None
            S.path += [s]
            print F[s]
            S.x = step(S.x, s)
            ln=raw_input().split()
            S.visit(ln[0])
            if ln[1] == 'trap':
                S.trap = S.x
                succ = State()
                succ.visit(ln[2])
                return succ
        return None

def merge(A, B, off):
    for rc in B:
        A[add(rc, off)] = B[rc]

def solve(S, A, At0, atob, Bt0, btoa):
    At = [At0]
    Bt = [Bt0]
    Am = A.search(nogo=set(At))
    if Am:
        At += [A.trap]
        Am.search(nogo=set(At))
        Bm = Am.walk(atob)
    else:
        Am = A
        Bm = A.walk(atob)
    B = Bm.search(nogo=set(Bt))
    if B:
        Bt += [Bm.trap]
        Bm = B
        Bm.search(nogo=set(Bt))
    Bm.walk(btoa)
    if len(At) == 2:
        O = sub(At[1], Bt[0])
    else:
        Y = None
        for rc,v in Bm.G.iteritems():
            if v == '.':
                Y = rc
                break
        O = sub(At[0], Y)
    merge(Am.G, Bm.G, O)
    Am.G[add(O, Bt[0])] = 'A'
    Am.G[At[0]] = 'B'
    Am.G[(0,0)] = 'a'
    Am.G[O] = 'b'
    S0 = sub((0,0), S.trap)
    if len(At) > 1:
        S0 = add(At[1], S0)
    else:
        S0 = add(add(O, Bt[0]), S0)
    Am.G[S0] = 'S'
    print 'done'
    Am.print_ans()

S = State()
S.visit(raw_input().split()[0])
A = S.search()
if not A:
    print 'done'
    S.G[(0,0)] = 'S'
    S.print_ans()
else:
    B = A.search()
    C = B.walk(A.path)
    if C and B.path == A.path:
        wx = C.search(nogo=set([A.trap]))
        if not wx:
            tA = A.trap
            O = sub(tA, S.trap)
            merge(C.G, S.G, O)
            C.G[tA] = 'A'
            C.G[(0,0)] = 'a'
            C.G[O] = 'S'
            print 'done'
            C.print_ans()
        else:
            P = [A.path, C.path]
            At = [A.trap, C.trap]
            p0 = C.path
            while True:
                i = random.randint(0,1)
                wy = wx.walk(P[i])
                if not wy or wx.path != P[i]:
                    break
                wx = wy
            if not wy:
                disc = P[i]
                wy = wx.search()
                z = wy.walk(disc)
                if not z:
                    z = wy.search(nogo=set([wx.trap]))
                    w1 = z.walk(P[0])
                    w2 = w1.walk(disc)
                    if w2:
                        if disc == P[1]:
                            w2 = w2.walk(wy.path)
                        solve(S, w2, At[1], P[1], wy.trap, wy.path)
                    else:
                        z = w1.walk(rev(w1.path) + wy.path)
                        solve(S, z, At[0], P[0], wy.trap, wy.path)
                else:
                    w1 = z.walk(disc)
                    if w1:
                        solve(S, w1, At[1-i], P[1-i], wx.trap, wx.path)
                    else:
                        z = z.walk(rev(z.path) + wx.path)
                        solve(S, z, At[i], P[i], wx.trap, wx.path)
            elif wx.path != P[i]:
                disc = wx.path
                z = wy.walk(disc)
                if z:
                    b = z
                    a = b.search(nogo=set([wx.trap]))
                    ab = a.walk(P[0])
                    bx = ab.walk(disc)
                    if bx:
                        # miss
                        # P[0] = A->B
                        assert False
                        ax = bx.walk(b.path)
                        solve(S, ax, At[0], P[0], b.trap, b.path)
                    else:
                        ab.walk(rev(ab.path))
                        solve(S, ab, At[1], P[1], b.trap, b.path)
                else:
                    a = wy
                    a.walk(rev(a.path))
                    ab = a.walk(P[0])
                    ax = ab.walk(disc)
                    if not ax:
                        ab.walk(rev(ab.path))
                        solve(S, ab, At[1], P[1], wx.trap, wx.path)
                    else:
                        # miss
                        # P[0] = A->B
                        assert False
                        solve(S, ax, At[0], P[0], wx.trap, wx.path)
    else:
        if not C:
            C = B.search()
        wx = C.walk(A.path)
        if wx and A.path == C.path:
            wy = wx.search(nogo=set([B.trap]))
            if not wy:
                wy = wx
            z = wy.walk(B.path)
            solve(S, z, A.trap, A.path, B.trap, B.path)
        else:
            if wx:
                C = wx
            z = C.search(nogo=set([B.trap]))
            solve(S, z, A.trap, A.path, C.trap, C.path)