#include <bits/stdc++.h>
#define endl '\n'
using namespace std;
using i64 = long long;
using a2 = array<int, 2>;

const int MAXN = 2505;
int n, m;
vector<a2> pos(MAXN);
vector<vector<a2>> edge(MAXN, vector<a2>(4));

// 0 N
// 1 E
// 2 S
// 3 W

void add_edge(int u, int v, int w) {
    if (pos[u][0] == pos[v][0]) {
        if (pos[u][1] > pos[v][1]) {
            edge[u][2] = { v, w };
            edge[v][0] = { u, w };
        } else {
            edge[u][0] = { v, w };
            edge[v][2] = { u, w };
        }
    } else {
        if (pos[u][0] > pos[v][0]) {
            edge[u][3] = { v, w };
            edge[v][1] = { u, w };
        } else {
            edge[u][1] = { v, w };
            edge[v][3] = { u, w };
        }
    }
}

inline int prv(int x) {
    return (x + 3) % 4;
}

inline int nxt(int x) {
    return (x + 1) % 4;
}

inline int get_dir(int now, int dir) {
    int cnt = 0;
    for (int i = prv(dir); i != (dir + 2) % 4; i = nxt(i)) {
        if (edge[now][i][1])
            cnt++;
    }

    if (cnt == 0) {
        cout << pos[now][0] << ' ' << pos[now][1] << endl;
        exit(0);
    }

    int go = -1;
    if (cnt <= 2) {
        for (int i = prv(dir); i != (dir + 2) % 4; i = nxt(i)) {
            if (edge[now][i][1]) {
                go = i;
                break;
            }
        }
    }

    if (cnt == 3) {
        for (int i = prv(dir); i != (dir + 2) % 4; i = nxt(i)) {
            if (edge[now][i][1])
                cnt--;
            if (cnt == 1) {
                go = i;
                break;
            }
        }
    }

    return go;
}

vector<vector<int>> vis_edge(MAXN, vector<int>(4));
vector<vector<bool>> vis(MAXN, vector<bool>(4)), vis_circle(MAXN, vector<bool>(4));

a2 find_circle(int now, int dir, int& minn) {
    // cout << now << ' ' << dir << ' ' << minn << endl;
    if (vis_circle[now][dir])
        return {now, dir};
    
    int go = get_dir(now, dir);

    vis_circle[now][dir] = true;
    vis_edge[now][go]++;
    vis_edge[edge[now][go][0]][(go + 2) % 4]++;
    edge[now][go][1]--;
    edge[edge[now][go][0]][(go + 2) % 4][1]--;
    minn = min(minn, edge[now][go][1] / vis_edge[now][go]);

    auto tmp = find_circle(edge[now][go][0], go, minn);

    vis_circle[now][dir] = false;
    edge[now][go][1] -= minn * vis_edge[now][go];
    edge[edge[now][go][0]][(go + 2) % 4][1] -= minn * vis_edge[now][go];
    vis_edge[now][go] = 0;
    vis_edge[edge[now][go][0]][(go + 2) % 4] = 0;

    return tmp;
}

void dfs(int now, int dir) {
    // cout << now << ' ' << dir << endl;
    if (vis[now][dir]) {
        int minn = 1 << 30;
        auto [x, y] = find_circle(now, dir, minn);
        vector<vector<bool>>(MAXN, vector<bool>(4)).swap(vis);
        dfs(x, y);
    }

    vis[now][dir] = true;
    int go = get_dir(now, dir);
    edge[now][go][1]--;
    edge[edge[now][go][0]][(go + 2) % 4][1]--;
    dfs(edge[now][go][0], go);
}

/*
1 2
   
3 4 5 6
       
    7 8

3-6-9
| | |
2-5-8
| | |
1-4-7

*/

void solve() {
    cin >> n >> m;
    for (int i = 1; i <= n; i++)
        cin >> pos[i][0] >> pos[i][1];
    for (int i = 1; i <= m; i++) {
        int u, v, w;
        cin >> u >> v >> w;
        // cout << u << ' ' << v << ' ' << w << endl;
        add_edge(u, v, w);
    }
    // cout << n << ' ' << m << endl;

    int now, go;
    char dir;
    cin >> now >> dir;
    if (dir == 'N')
        go = 0;
    if (dir == 'E')
        go = 1;
    if (dir == 'S')
        go = 2;
    if (dir == 'W')
        go = 3;
    // cout << now << ' ' << go << endl;

    vis[now][go] = true;
    edge[now][go][1]--;
    edge[edge[now][go][0]][(go + 2) % 4][1]--;
    // cout << edge[now][go][0] << endl;
    dfs(edge[now][go][0], go);
}

int main() {
    ios::sync_with_stdio(NULL);
    cin.tie(nullptr);

    int t = 1;
    // cin >> t;
    while (t--)
        solve();
    return 0;
}