#include <bits/stdc++.h>

constexpr std::string_view dir_ch = "ENWS";
constexpr std::array<std::pair<int, int>, 4> dlt = {{{1, 0}, {0, -1}, {-1, 0}, {0, 1}}};

struct Fuck {
    int x, y;
    int dir;
    int id;
};

int32_t main() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int n;
    std::cin >> n;
    std::vector<Fuck> input(n);
    // for (auto& i : input) {
    for (int i = 0; i < n; i++) {
        std::cin >> input[i].x >> input[i].y;
        // std::cin >> input[i].y >> input[i].x;

        char ch;
        std::cin >> ch;
        input[i].dir = dir_ch.find(ch);
        input[i].id = i;
    }

    std::vector<std::set<std::array<int, 3>>> set;
    std::vector<std::set<std::array<int, 3>>> set2;
    std::multiset<std::array<int, 3>> set3;

    auto get_min = [&](int i) {
        // auto &st = set[i];
        // auto &st2 = set2[i];

        // std::array<int, 3> min{(int)2.1e9, -1, -1};
        // if (st.empty())
        //     return min;
        // for (auto it = std::next(st.begin()); it != st.end(); it++) {
        //     auto [x1, d1, id1] = *std::prev(it);
        //     auto [x2, d2, id2] = *it;
        //     if (d1 == 1 && d2 == -1) {
        //         assert(x1 < x2);
        //         assert((x2 - x1) % 2 == 0);
        //         min = std::min(min, {(x2 - x1) / 2, id1, id2});
        //     }
        // }
        // return min;
        return set2[i].size() ? *set2[i].begin() : std::array<int, 3>{(int)2.1e9, -1, -1};
    };
    auto check = [&](int i, auto a, auto b, bool ers) {
        if (a[1] == 1 && b[1] == -1) {
            std::array<int, 3> ar = {(b[0] - a[0]) / 2, a[2], b[2]};
            ers ? set2[i].erase(ar) : (set2[i].insert(ar), 0);
        }
    };
    auto insert = [&](int i, int x, int dr, int id, bool ers = false) {
        if (i == -1) {
            return;
        }
        set3.extract(get_min(i));

        auto &st = set[i];
        {
            auto it = ers ? st.find({x, dr, id}) : st.insert({x, dr, id}).first;
            if (it != st.begin()) {
                check(i, *std::prev(it), *it, ers);
            }
            if (std::next(it) != st.end()) {
                check(i, *it, *std::next(it), ers);
            }
            if (it != st.begin() && std::next(it) != st.end()) {
                check(i, *std::prev(it), *std::next(it), !ers);
            }
            if (ers) {
                st.erase(it);
            }
        }

        set3.insert(get_min(i));
    };
    auto erase = [&](int i, int x, int dr, int id) {
        insert(i, x, dr, id, true);
        return;

        // if (i == -1) {
        //     return;
        // }
        // set3.extract(get_min(i));

        // auto &st = set[i];
        // auto &st2 = set2[i];
        // st.erase({x, dr, id});

        // set3.insert(get_min(i));
    };
    // auto get_global_min = [&]() {
    //     return *set3.begin();
    // };

    std::vector<std::vector<std::array<int, 3>>> vec;
    for (auto [i, f] : std::vector<std::pair<int, int (*)(const Fuck &)>>{
             {0, [](const Fuck &a) -> int { return a.y; }},
             {1, [](const Fuck &a) -> int { return a.x; }},
             {2, [](const Fuck &a) -> int { return a.x + a.y; }},
             {3, [](const Fuck &a) -> int { return a.x + a.y; }},
             {4, [](const Fuck &a) -> int { return a.x - a.y; }},
             {5, [](const Fuck &a) -> int { return a.x - a.y; }}}) {
        vec.emplace_back(n);

        auto cmp = [&](auto a, auto b) { return f(a) < f(b); };
        std::sort(input.begin(), input.end(), cmp);

        for (int it = 0; it < input.size();) {
            int it2 = std::upper_bound(input.begin() + it, input.end(), input[it], cmp) - input.begin();
            if (it + 1 == it2) {
                it++;
                continue;
            }
            int s = set.size();
            set.push_back({}), set2.push_back({});
            auto &st = set.back();
            auto &st2 = set2.back();

            for (; it < it2; it++) {
                auto [x, y, dr, id] = input[it];
                vec[i][id].fill(-1);
                auto check = [&](int d, char ch1, char ch2) {
                    return dir_ch[d] == ch1 || dir_ch[d] == ch2;
                };
                /*  */ if (i == 0 && check(dr, 'W', 'E')) {
                    vec[i][id] = {s, x, (dir_ch[dr] == 'E') * 2 - 1};
                } else if (i == 1 && check(dr, 'N', 'S')) {
                    vec[i][id] = {s, y, (dir_ch[dr] == 'S') * 2 - 1};
                } else if (i == 2 && check(dr, 'S', 'E')) {
                    vec[i][id] = {s, y - x, (dir_ch[dr] == 'S') * 2 - 1};
                } else if (i == 3 && check(dr, 'W', 'N')) {
                    vec[i][id] = {s, y - x, (dir_ch[dr] == 'W') * 2 - 1};
                } else if (i == 4 && check(dr, 'N', 'E')) {
                    vec[i][id] = {s, x + y, (dir_ch[dr] == 'E') * 2 - 1};
                } else if (i == 5 && check(dr, 'W', 'S')) {
                    vec[i][id] = {s, x + y, (dir_ch[dr] == 'S') * 2 - 1};
                }
                insert(vec[i][id][0], vec[i][id][1], vec[i][id][2], id);
            }
        }
    }

    std::sort(input.begin(), input.end(), [&](auto a, auto b) { return a.id < b.id; });
    std::map<std::pair<int, int>, int> map;
    for (auto f : input) {
        map[{f.x, f.y}] = f.id;
    }
    std::set<int> alive;
    for (int i = 0; i < n; i++) {
        alive.insert(i);
    }
    while (set3.size()) {
        auto [mn, id1, id2] = *set3.begin();
        if (id1 == -1) {
            break;
        }
        assert(mn >= 0);

        std::set<int> to_erase;  // = {id1, id2};
        std::pair<int, int> pos = {input[id1].x + dlt[input[id1].dir].first * mn, input[id1].y + dlt[input[id1].dir].second * mn};
        for (int d = 0; d < 4; d++) {
            std::pair<int, int> pos2(pos.first + dlt[d].first * mn, pos.second + dlt[d].second * mn);
            int id = map.contains(pos2) ? map[pos2] : -1;
            if (id != -1) {
                if (input[id].dir == (d + 2) % 4) {
                    to_erase.insert(id);
                }
            }
        }
        for (auto id : to_erase) {
            if (!alive.contains(id)) {
                continue;
            }
            alive.erase(id);
            for (int i = 0; i < vec.size(); i++) {
                erase(vec[i][id][0], vec[i][id][1], vec[i][id][2], id);
            }
        }
    }

    for (auto &i : alive) {
        std::cout << i + 1 << "\n";
    }

    return 0;
}