#include <iostream>
#include <iomanip>
#include <cmath>
using namespace std;

const int MAXD = 100;
const int INF = MAXD*MAXD+1;

struct sq
{
	int dr, dc;
	int lfrom, lto;	// length from start, length to destionation
	int pnum;		// path number - used to determine closed loop paths
} grid[MAXD][MAXD];

void printGrid(int n, int m)
{
	for(int i=0; i<n; i++) {
		for(int j=0; j<m; j++) {
			cout << '(' << setw(2) << grid[i][j].dr << ',' << setw(2) << grid[i][j].dc << ')';
			cout << setw(5) << grid[i][j].lfrom << setw(5) << grid[i][j].lto << setw(3) << grid[i][j].pnum << '|';
		}
		cout << "\n----" << endl;
	}
}

int findPath(int r, int c, int pnum, int nrows, int ncols)
{
//cout << "findPath r, c = " << r << ',' <<c << endl;
	int len = 0;
	int savr = r, savc = c;
	grid[r][c].lfrom = 0;
	bool found = false;
	while (true) {
		grid[r][c].pnum = pnum;
		if (r == nrows-1 && c == ncols-1) {
			found = true;
			break;
		}
		int tmp = r+grid[r][c].dr;
		c += grid[r][c].dc;
		r = tmp;
		if (r >= nrows || r < 0 || c >= ncols || c<0)
			break;
		if (grid[r][c].pnum != -1) {			// hit exisiting path
			if (grid[r][c].pnum == pnum)			// if same path, then have a loop
				len = INF;
			else
				len += grid[r][c].lto+1;
			found = true;
			break;
		}
		grid[r][c].lfrom = ++len;		// lfrom really only important on first path (from start)
	}
//cout << "findpath here1" << endl;
	if (!found)
		len = INF;
	int retval = len;
	r = savr, c = savc;
	while (grid[r][c].pnum == pnum && grid[r][c].lto == -1) {
		if (r == nrows-1 && c == ncols-1) {
			break;
		}
		grid[r][c].lto = len;
		if (len != INF)
			len--;
		int tmp = r+grid[r][c].dr;
		c += grid[r][c].dc;
		r = tmp;
//cout << "findPath r, c = " << r << ',' <<c << endl;
		if (r >= nrows || r < 0 || c >= ncols || c<0)
			break;
	}
	return retval;
}

int findBest(int r, int c, int n, int m, int& dr, int& dc)
{
	int bestlen = grid[r][c].lfrom + grid[r][c].lto;
	dr = dc = 0;
	int max = n;
	if (m > n)
		max = m;
	for(int i=1; i<max; i++) {
										// check E
		if (c+i < m && grid[r][c].lfrom + grid[r][c+i].lto + 1 < bestlen) {
			bestlen = grid[r][c].lfrom + grid[r][c+i].lto + 1;
			dr = 0;
			dc = i;
		}
										// check N
		if (r-i >= 0 && grid[r][c].lfrom + grid[r-i][c].lto + 1 < bestlen) {
			bestlen = grid[r][c].lfrom + grid[r-i][c].lto + 1;
			dr = -i;
			dc = 0;
		}
										// check S
		if (r+i < n && grid[r][c].lfrom + grid[r+i][c].lto + 1 < bestlen) {
			bestlen = grid[r][c].lfrom + grid[r+i][c].lto + 1;
			dr = i;
			dc = 0;
		}
										// check W
		if (c-i >= 0 && grid[r][c].lfrom + grid[r][c-i].lto + 1 < bestlen) {
			bestlen = grid[r][c].lfrom + grid[r][c-i].lto + 1;
			dr = 0;
			dc = -i;
		}
	}
	return bestlen;
}

int main()
{
	int n, m;
	int icase=0;

	cin >> n >> m;
	while (n != 0) {
		for(int i=0; i<n; i++) {
			for(int j=0; j<m; j++) {
				grid[i][j].pnum = -1;
				if (i==n-1 && j == m-1)
					break;
				grid[i][j].lto = grid[i][j].lfrom = -1;
				int move;
				cin >> move;
				char ch;
				cin >> ch;
				switch (ch) {
				case 'N': grid[i][j].dr=-move, grid[i][j].dc=0; break;
				case 'S': grid[i][j].dr=move, grid[i][j].dc=0; break;
				case 'E': grid[i][j].dr=0, grid[i][j].dc=move; break;
				case 'W': grid[i][j].dr=0, grid[i][j].dc=-move; break;
				default : cout << "ERROR: bad direction" << endl;
				}
//cout << move << ch << ' ';
			}
//cout << endl;
		}
		grid[n-1][m-1].lto = grid[n-1][m-1].lfrom = 0;
		int pathnum = 0;
		int initlen = findPath(0, 0,pathnum++, n, m);
		for(int i=0; i<n; i++) {
			for(int j=0; j<m; j++) {
				if (grid[i][j].pnum == -1)
					findPath(i, j,pathnum++, n, m);
			}
		}
//printGrid(n, m);

		int bestlen = initlen;
		int r=0, c=0;
		int bestr, bestc;
		int dr, dc, bestdr, bestdc;
		while(r != n-1 || c != m-1) {
//cout << r << ',' << c << endl;
			int currlen = findBest(r, c, n, m, dr, dc);
			if (currlen < bestlen) {
				bestlen = currlen;
				bestr = r, bestc = c;
				bestdr = dr, bestdc = dc;
			}
			else if (currlen == bestlen && (r < bestr || (r == bestr && c < bestc))) {
				bestr = r, bestc = c;
				bestdr = dr, bestdc = dc;
			}

			int nextr = r+grid[r][c].dr;
			int nextc = c+grid[r][c].dc;
			if (grid[nextr][nextc].lfrom < grid[r][c].lfrom)		// check if path loops on itself
				break;
			r = nextr;
			c = nextc;
			if (r >= n || r < 0 || c >= m || c<0)
				break;
		}
		cout << "Case " << ++icase << ": ";
		if (bestlen == INF)
			cout << "impossible" << endl;
		else if (bestlen == initlen)
			cout << "none " << initlen << endl;
		else {
			cout << bestr << ' ' << bestc << ' '<< abs(bestdr+bestdc);
			if (bestdr < 0)
				cout << 'N';
			else if (bestdr > 0)
				cout << 'S';
			else if (bestdc > 0)
				cout << 'E';
			else
				cout << 'W';
			cout << ' ' << bestlen << endl;;
		}

		cin >> n >> m;
	}
}