#include <bits/stdc++.h>

using namespace std;
using ll = long long;

set<array<int, 3>> best;

struct Struct {
    vector<int> x, type;
    vector<int> nxt, prv, in, id;
    set<pair<int, int>> st;
    map<int, int> pos;
    int n, coef, idi;

    void init(vector<array<int, 3>> a, int coef, int idi) {
        this->coef = coef, this->idi = idi;
        sort(a.begin(), a.end());
        n = a.size();
        nxt.assign(n, -1);
        prv.assign(n, -1);
        in.assign(n, -1);
        x.assign(n, 0);
        type.assign(n, 0);
        id.assign(n, 0);
        for (int i = 0; i < n; ++i) {
            nxt[i] = i + 1, prv[i] = i - 1;
            x[i] = a[i][0], type[i] = a[i][1];
            pos[a[i][2]] = i;
            id[i] = a[i][2];
        }
        for (int i = 0; i < n - 1; ++i) {
            if (type[i] == 1 && type[i + 1] == 2) {
                st.emplace(in[i] = x[i + 1] - x[i], i);
            }
        }
    }

    int top() {
        return st.empty() ? int(2e9) : st.begin()->first;
    }

    void modify(int mod) {
        if (mod == -1) {
            best.erase({top(), coef, idi});
        } else {
            best.insert({top(), coef, idi});
        }
    }

    void erase_(int i) {
        if (prv[i] == -1 && nxt[i] == -1) {
            return;
        }
        if (in[i] >= 0) {
            st.erase({in[i], i});
            in[i] = -1;
        }
        if (prv[i] >= 0 && in[prv[i]] >= 0) {
            st.erase({in[prv[i]], prv[i]});
            in[prv[i]] = -1;
        }
        int p = prv[i], nx = nxt[i];
        prv[i] = -1, nxt[i] = n;
        if (p != -1) {
            nxt[p] = nx;
        }
        if (nx != n) {
            prv[nx] = p;
            if (p != -1 && type[p] == 1 && type[nx] == 2) {
                st.emplace(in[p] = x[nx] - x[p], p);
            }
        }
        prv[i] = nxt[i] = -1;
    }

    void erase(int i) {
        modify(-1);
        if (pos.count(i)) {
            pos.erase(i);
            erase_(pos[i]);
        }
        modify(1);
    }

    vector<int> norm() {
        modify(-1);
//        if (coef == -2 && idi == 1) {
//            cout << "here!" << endl;
//        }
        int t = top();
        vector<int> dead;
        while (!st.empty() && st.begin()->first == t) {
            dead.push_back(st.begin()->second);
            dead.push_back(nxt[dead.back()]);
            st.erase(st.begin());
        }
        for (int i : dead) {
            erase_(i);
        }
        vector<int> ids;
        for (int i : dead) {
            ids.push_back(id[i]);
        }
        modify(1);
        return ids;
    }
};

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

    int n;
    cin >> n;
    vector<pair<int, int>> p(n);
    vector<int> type(n);
    map<int, vector<int>> SW, SE, NE, NW, X, Y;
    for (int i = 0; i < n; ++i) {
        int x, y;
        cin >> x >> y;
        y = 8 - y;
        p[i] = {x, y};
        char c;
        cin >> c;
        if (c == 'N') {
            NE[x + y].push_back(i);
            NW[x - y].push_back(i);
            X[x].push_back(i);
            type[i] = 0;
        } else if (c == 'E') {
            NE[x + y].push_back(i);
            SE[x - y].push_back(i);
            Y[y].push_back(i);
            type[i] = 1;
        } else if (c == 'S') {
            SE[x - y].push_back(i);
            SW[x + y].push_back(i);
            X[x].push_back(i);
            type[i] = 2;
        } else {
            NW[x - y].push_back(i);
            SW[x + y].push_back(i);
            Y[y].push_back(i);
            type[i] = 3;
        }
    }

    auto makeStruct = [&](vector<int> id, vector<int> y, vector<int> type, int coef, int idi) {
        Struct s;
        vector<array<int, 3>> a(id.size());
        for (int i = 0; i < a.size(); ++i) {
            a[i][0] = y[i], a[i][1] = type[i], a[i][2] = id[i];
        }
        s.init(a, coef, idi);
        return s;
    };

    vector<pair<int, Struct>> s[6];

    for (auto [coef, a] : SW) {
        vector<int> id, y, tp;
        for (int i : a) {
            id.push_back(i);
            y.push_back(p[i].first);
            tp.push_back(type[i] == 2 ? 1 : 2);
        }
        s[0].push_back({coef, makeStruct(id, y, tp, coef, 0)});
    }
    for (auto [coef, a] : SE) {
        vector<int> id, y, tp;
        for (int i : a) {
            id.push_back(i);
            y.push_back(p[i].first);
            tp.push_back(type[i] == 2 ? 2 : 1);
        }
        s[1].push_back({coef, makeStruct(id, y, tp, coef, 1)});
    }

    for (auto [coef, a] : NE) {
        vector<int> id, y, tp;
        for (int i : a) {
            id.push_back(i);
            y.push_back(p[i].first);
            tp.push_back(type[i] == 0 ? 2 : 1);
        }
        s[2].push_back({coef, makeStruct(id, y, tp, coef, 2)});
    }
    for (auto [coef, a] : NW) {
        vector<int> id, y, tp;
        for (int i : a) {
            id.push_back(i);
            y.push_back(p[i].first);
            tp.push_back(type[i] == 0 ? 1 : 2);
        }
        s[3].push_back({coef, makeStruct(id, y, tp, coef, 3)});
    }

    for (auto [coef, a] : X) {
        vector<int> id, y, tp;
        for (int i : a) {
            id.push_back(i);
            y.push_back(p[i].second / 2);
            tp.push_back(type[i] == 0 ? 2 : 1);
        }
        s[4].push_back({coef, makeStruct(id, y, tp, coef, 4)});
    }
    for (auto [coef, a] : X) {
        vector<int> id, y, tp;
        for (int i : a) {
            id.push_back(i);
            y.push_back(p[i].first / 2);
            tp.push_back(type[i] == 1 ? 1 : 2);
        }
        s[5].push_back({coef, makeStruct(id, y, tp, coef, 5)});
    }

    for (int i = 0; i < 6; ++i) {
        for (auto &[coef, str] : s[i]) {
            best.insert({str.top(), coef, i});
        }
    }

    vector<int> del(n);

    auto find = [&](int i, int coef) {
        int lo = 0, hi = s[i].size();
        while (lo + 1 < hi) {
            int mid = lo + hi >> 1;
            if (s[i][mid].first > coef) {
                hi = mid;
            } else {
                lo = mid;
            }
        }
        return lo;
    };

    while (!best.empty()) {
        int t = best.begin()->begin()[0];
        if (t >= 1.5e9) {
            break;
        }
        vector<array<int, 3>> cur;
        while (!best.empty() && best.begin()->begin()[0] == t) {
            cur.push_back(*best.begin());
            best.erase(best.begin());
        }
        vector<int> died;
        for (auto [val, coef, i] : cur) {
            int pos = find(i, coef);
            auto now = s[i][pos].second.norm();
            died.insert(died.end(), now.begin(), now.end());
        }
        sort(died.begin(), died.end());
        died.resize(unique(died.begin(), died.end()) - died.begin());
        for (int i : died) {
            del[i] = true;
            auto [x, y] = p[i];
            if (type[i] == 0) {
                s[2][find(2, x + y)].second.erase(i);
                s[3][find(3, x - y)].second.erase(i);
                s[4][find(4, x)].second.erase(i);
            } else if (type[i] == 1) {
                s[2][find(2, x + y)].second.erase(i);
                s[1][find(1, x - y)].second.erase(i);
                s[5][find(5, y)].second.erase(i);
            } else if (type[i] == 2) {
                s[1][find(1, x - y)].second.erase(i);
                s[0][find(0, x + y)].second.erase(i);
                s[4][find(4, x)].second.erase(i);
            } else {
                s[3][find(3, x - y)].second.erase(i);
                s[0][find(0, x + y)].second.erase(i);
                s[5][find(5, y)].second.erase(i);
            }
        }
    }

    for (int i = 0; i < n; ++i) {
        if (!del[i]) {
            cout << i + 1 << '\n';
        }
    }

    return 0;
}