import std.stdio;
import std.ascii;
import std.range;
import std.array;
import std.functional;
import std.algorithm;
import std.conv;
import std.container;
import std.math;
import std.numeric;
import std.string;
import std.c.string;
import std.random;
import std.regex;
import std.typecons;

int H, W; long L;
string[] F;
bool input() {
    scanf("%d %d %lld\n", &H, &W, &L);
    if (H == 0 && W == 0 && L == 0) return false;
    F = new string[H];
    foreach (i; 0 .. H) {
        F[i] = readln.chomp;
    }
    return true;
}

int[char] M;
static this() {
    M = [ 'N': 0, 'E': 1, 'S': 2, 'W': 3 ];
}

void getPos(out int y, out int x, out int dir) {
    foreach (int i; 0 .. H) {
        foreach (int j; 0 .. W) {
            if (F[i][j] in M) {
                y = i; x = j; dir = M[ F[i][j] ];
                return;
            }
        }
    }
    assert(0);
}

const dy = [-1, 0, 1, 0],
      dx = [0, 1, 0, -1];

void turn(int y, int x, ref int dir) {
    int ndir = dir;
    int ny = y + dy[ndir],
        nx = x + dx[ndir];
    while (ny < 0 || ny >= H || nx < 0 || nx >= W || F[ny][nx] == '#') {
        ndir = (ndir + 1) % 4;
        ny = y + dy[ndir];
        nx = x + dx[ndir];
    }
    dir = ndir;
}

void step(ref int y, ref int x, ref int dir) {
    int ndir = dir;
    int ny = y + dy[ndir],
        nx = x + dx[ndir];
    while (ny < 0 || ny >= H || nx < 0 || nx >= W || F[ny][nx] == '#') {
        ndir = (ndir + 1) % 4;
        ny = y + dy[ndir];
        nx = x + dx[ndir];
    }
    y = ny; x = nx; dir = ndir;
}

struct P {
    int y, x, dir;
    string toString() const {
        return format("%d %d %s", y + 1, x + 1, "NESW"[dir]);
    }
}

void solve1() {
    int y, x, dir; getPos(y, x, dir);
    foreach (i; 0 .. L) {
        step(y, x, dir);
    }
    writeln(P(y, x, dir));
}

void solve() {

    if (L <= H * W * 4) {
        solve1();
        return;
    }

    int y, x, dir; getPos(y, x, dir);

    auto U = new int[][][](H, W, 4);
    foreach (i; 0 .. H) foreach (j; 0 .. W) U[i][j][] = -1;
    P[long] X;
    int t = 0;
    int cycle;
    while (true) {
        if (U[y][x][dir] >= 0) {
            cycle = t - U[y][x][dir];
            t = U[y][x][dir];
            break;
        }
        U[y][x][dir] = t;
        X[t] = P(y, x, dir);
        turn(y, x, dir);
        step(y, x, dir);
        t++;
    }

    //writeln([t, cycle]);
    writeln(X[(L - t) % cycle + t]);
}

void main() {
    while (input) solve;
}