#include <bits/stdc++.h>
using namespace std;

int main() {
	ios_base::sync_with_stdio(false), cin.tie(nullptr);

	int N, M; cin >> N >> M;

	using C = array<int, 2>;
	vector<C> locs(N);
	for (auto& [x, y] : locs) cin >> x >> y;

	// NESW -- 0123

	auto get_dir_impl = [&](int x, int y, int ox, int oy) -> int {
		if (x == ox) {
			if (y < oy) return 0;
			else if (oy < y) return 2;
		} else if (y == oy) {
			if (x < ox) return 1;
			else if (ox < x) return 3;
		} else assert(false);
		assert(false);
	};
	auto get_dir = [&](C a, C b) -> int {
		return get_dir_impl(a[0], a[1], b[0], b[1]);
	};

	auto get_opposite = [&](int dir) -> int {
		static array<int, 4> op = {2, 3, 0, 1};
		return op[dir];
	};

	struct edge_t {
		int dest;
		int n;
	};
	vector<array<edge_t, 4>> adj(N);
	for (int i = 0; i < N; i++) {
		for (int dir = 0; dir < 4; dir++) {
			adj[i][dir] = edge_t{-1, 0};
		}
	}
	for (int e = 0; e < M; e++) {
		int i, j, k; cin >> i >> j >> k; i--, j--;
		int dir = get_dir(locs[i], locs[j]);
		int odir = get_opposite(dir);
		adj[i][dir] = edge_t{j, k};
		adj[j][odir] = edge_t{i, k};
	}

	int cur; cin >> cur; cur--;
	int cur_facing;
	{
		string z; cin >> z;
		if (z == "N") {
			cur_facing = 0;
		} else if (z == "E") {
			cur_facing = 1;
		} else if (z == "S") {
			cur_facing = 2;
		} else if (z == "W") {
			cur_facing = 3;
		} else assert(false);
	}

	auto update_edge = [&](int i, int dir, int x) -> void {
		int j = adj[i][dir].dest;
		int odir = get_opposite(dir);
		adj[i][dir].n -= x;
		adj[j][odir].n -= x;
	};

	bool first_step = true;

	// <= M iterations
	while (true) {
		vector<int> seen(4*N, 0);

		vector<pair<int, int>> path;
		bool cyc = false;

		while (true) {
			vector<int> cnds; cnds.reserve(3);
			if (first_step) {
				cnds.push_back(0);
				first_step = false;
			} else {
				for (int rel_dir : {3, 0, 1}) {
					int dir = (cur_facing + rel_dir) % 4;
					if (adj[cur][dir].n > 0) {
						cnds.push_back(rel_dir);
					}
				}
			}

			if (cnds.empty()) {
				// no outgoing edges
				break;
			}

			int e;
			auto do_move = [&](int rel_dir) -> void {
				int dir = (cur_facing + rel_dir) % 4;
				e = 4 * cur + dir;
				if (seen[e]) return;
				update_edge(cur, dir, 1);
				path.emplace_back(cur, dir);
				cur = adj[cur][dir].dest;
				cur_facing = dir;
			};
			if (cnds.size() == 3) {
				do_move(0);
			} else {
				do_move(cnds[0]);
			}

			if (seen[e]) {
				int f = 0;
				while (true) {
					auto [i, dir] = path[f];
					int pe = 4 * i + dir;
					if (e == pe) {
						break;
					}
					f++;
				}
				path = vector(path.begin() + f, path.end());

				cyc = true;
				break;
			}
			seen[e] = 1;
		}

		if (!cyc) {
			cout << locs[cur][0] << ' ' << locs[cur][1] << '\n';
			break;
		}

		static const int inf = 1e8;
		int x = inf;
		for (auto [i, dir] : path) {
			int j = adj[i][dir].dest;
			int odir = get_opposite(dir);
			int oe = 4 * j + odir;
			if (seen[oe]) {
				x = min(x, adj[i][dir].n/2);
			} else {
				x = min(x, adj[i][dir].n);
			}
		}
		for (auto [i, dir] : path) {
			update_edge(i, dir, x);
		}
	}

	return 0;
}