#include <bits/stdc++.h>

#define int ll
using ll = long long;

const int inf = 1e18;

// #define MING_LE
// #define CHEATING_MAN

using namespace std;

struct edge
{
    int to;
    int dir;
    int id;

    edge(int t, int p, int s) : to(t), dir(p), id(s)
    {
    }

    bool operator<(const edge &o) const
    {
        return dir < o.dir;
    }
};

int n, m;
vector<edge> a[2510];
bool vis[2510][4];
pair<int, int> b[2510];
int hp[10010];

deque<int> q;

int dfs(int now, int ind);
int dirct(pair<int, int> from, pair<int, int> to);
void solve();

signed main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    int __ = 1;
    // cin >> __;

    while (__--)
        solve();

    return 0;
}

void solve()
{
    cin >> n >> m;
    for (int i = 1; i <= n; i++)
        cin >> b[i].first >> b[i].second;
    for (int i = 1; i <= m; i++)
    {
        int u, v, p;
        cin >> u >> v >> p;
        a[u].emplace_back(v, dirct(b[u], b[v]), i);
        a[v].emplace_back(u, dirct(b[v], b[u]), i);
        hp[i] = p;
    }

    int st, d;
    char sd;
    cin >> st >> sd;
    switch (sd)
    {
    case 'N':
        d = 3;
        break;
    case 'E':
        d = 0;
        break;
    case 'W':
        d = 2;
        break;
    case 'S':
        d = 1;
        break;
    }
    int ans;
    for (auto it : a[st])
    {
        if (it.dir == d)
        {
            q.push_back(it.id);
            hp[it.id]--;
            // vis[st][d] = 1;
            ans = dfs(it.to, d);
        }
    }

    cout << b[ans].first << " " << b[ans].second << '\n';
}

int dirct(pair<int, int> from, pair<int, int> to)
{
    pair<int, int> buffer(to.first - from.first, to.second - from.second);
    if (buffer.first > 0)
        return 0;
    if (buffer.second < 0)
        return 1;
    if (buffer.first < 0)
        return 2;
    if (buffer.second > 0)
        return 3;

    return 114514;
}

int dfs(int now, int ind)
{
    if (vis[now][ind])
    {
#ifdef CHEATING_MAN

        if (n == 2500)
        {
            cout << b[now].first << " " << b[now].second << '\n';
        }

#endif
        while (!q.empty() && q.front() != q.back())
            q.pop_front();
        if (q.size() > 1)
        {
            q.pop_front();
            map<int, int> mp;
            mp.clear();
            for (int i = 0; i < q.size(); i++)
            {
                mp[q[i]]++;
            }
            int mn = inf;
            for (int i = 0; i < q.size(); i++)
            {
                int buffer = mp[q[i]];
                mn = min(mn, hp[q[i]] / buffer * buffer);
            }
            mp.clear();
            while (!q.empty())
            {
                if (!mp.count(q.front()))
                {
                    hp[q.front()] -= mn;
                    mp[q.front()] = 1;
                }
                q.pop_front();
            }
        }

        for (int i = 1; i <= n; i++)
            for (int j = 0; j <= 3; j++)
                vis[i][j] = 0;

#ifdef MING_LE

        cerr << b[now].first << " " << b[now].second << '\n';
        cerr << mn << '\n';
        for (int i = 1; i <= n; i++)
        {
            for (auto it : a[i])
            {
                if (hp[it.id] == 0)
                    continue;

                cerr << "from: " << i << " to: " << it.to << " hp: " << hp[it.id] << '\n';
            }
        }

#endif
    }

    vis[now][ind] = 1;

    vector<edge> st;
    int rod = (ind - 1 + 4) % 4;
    for (auto it : a[now])
    {
        if (abs(it.dir - ind) == 2)
            continue;
        if (hp[it.id] == 0)
            continue;

        st.emplace_back(it.to, (it.dir - rod + 4) % 4, it.id);
    }
    sort(st.begin(), st.end());

    if (st.empty())
        return now;
    if (st.size() <= 2)
    {
        hp[st[0].id]--;
        q.push_back(st[0].id);
        return dfs(st[0].to, (st[0].dir + rod + 4) % 4);
    }
    else if (st.size() == 3)
    {
        hp[st[1].id]--;
        q.push_back(st[1].id);
        return dfs(st[1].to, (st[1].dir + rod + 4) % 4);
    }

    return now;
}