// cf bits/extc++.h nonsense
#ifdef ONLINE_JUDGE
#define _EXT_CODECVT_SPECIALIZATIONS_H 1
#define _EXT_ENC_FILEBUF_H 1
#endif
#include "bits/extc++.h"

using namespace std;

template <typename T, typename... U>
void dbgh(const T& t, const U&... u) {
    cerr << t;
    ((cerr << " | " << u), ...);
    cerr << endl;
}

#ifdef DEBUG
#define dbg(...)                                              \
    cerr << "L" << __LINE__ << " [" << #__VA_ARGS__ << "]: "; \
    dbgh(__VA_ARGS__)
#else
#define dbg(...)
#define cerr   \
    if (false) \
    cerr
#endif

using u64 = uint64_t;
using ll = long long;
using ld = long double;

template <typename T>
using min_pq = priority_queue<T, vector<T>, greater<T>>;

#define endl "\n"
#define long int64_t
#define sz(x) int(std::size(x))

inline void init_io() {
    cin.tie(nullptr);
    cin.exceptions(ios::failbit);
    ios_base::sync_with_stdio(false);
}

template <typename T>
vector<T> iota(int n, const T& init) {
    vector<T> arr(n);

    iota(begin(arr), end(arr), init);

    return arr;
}

template <typename T>
vector<vector<T>> transposed(const vector<vector<T>>& arr) {
    int n = sz(arr), m = sz(arr[0]);

    vector ans(m, vector<T>(n));

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            ans[j][i] = arr[i][j];
        }
    }

    return ans;
}

template <typename T>
bool on(const T& mask, int bit) {
    return (mask >> bit) & 1;
}

template <typename T>
ostream& operator<<(ostream& out, const vector<T>& arr) {
    out << "[";
    for (int i = 0; i < sz(arr); i++) {
        if (i) {
            out << ", ";
        }
        out << arr[i];
    }
    return out << "]";
}

template <typename A, typename B>
ostream& operator<<(ostream& out, const pair<A, B>& p) {
    return out << "(" << p.first << ", " << p.second << ")";
}

template <typename A, typename T>
int lbs(const A& arr, const T& x) {
    return int(lower_bound(begin(arr), end(arr), x) - begin(arr));
}

inline vector<bool>::reference& operator&=(vector<bool>::reference&& a, bool b) {
    return a = a & b;
}

template <typename T>
T reversed(T arr) {
    reverse(begin(arr), end(arr));
    return arr;
}

constexpr int IINF = 1e9 + 10;

struct DS1 {
    map<int, int> active, copt, v_id;
    set<pair<int, int>> crash;

    DS1() {}
    DS1(vector<array<int, 3>> arr) {
        sort(begin(arr), end(arr));

        for (auto& [x, ty, id] : arr) {
            active[x] = ty;
            v_id[x] = id;
        }
        active[-IINF] = active[IINF] = -100;

        for (auto& [x, ty, _id] : arr) {
            if (ty == +1) {
                copt[x] = -1;
            }
        }
        for (auto& [x, ty, _id] : arr) {
            if (ty == +1) {
                upd(x);
            }
        }
    }

    void upd(int x) {
        if (x == -IINF || x == IINF) {
            return;
        }

        assert(active[x] == +1);
        int& co = copt[x];
        if (co != -1) {
            crash.erase({co, x});
        }

        auto it = active.upper_bound(x);
        if (it->second == -1) {
            crash.emplace(co = it->first - x, x);
        } else {
            co = -1;
        }
    }

    void erase(int x) {
        int co = copt[x];

        if (co != -1) {
            crash.erase({co, x});
        }

        active.erase(x);
        copt.erase(x);
        upd((--active.lower_bound(x))->first);
    }

    int query_time() const {
        if (sz(crash)) {
            dbg(begin(crash)->first);
        }
        return sz(crash) ? begin(crash)->first : IINF;
    }

    template <typename Cb>
    void all_crashes(int t, const Cb& cb) {
        for (auto it = begin(crash); it != end(crash) && it->first == t; ++it) {
            cb(v_id[it->second]);

            auto it2 = active.upper_bound(it->second);
            cb(v_id[it2->first]);
        }
    }
};

struct DS2 {
    vector<array<int, 3>> arr;
    map<int, DS1> dsv;
    set<pair<int, int>> opt_time;

    DS2(const vector<array<int, 3>>& arr) : arr(arr) {
        map<int, vector<array<int, 3>>> mp;
        for (int i = 0; i < sz(arr); i++) {
            auto& [x, y, ty] = arr[i];
            if (!ty) {
                continue;
            }
            mp[x].push_back({y, ty, i});
        }

        for (auto& [k, v] : mp) {
            auto& cds = dsv[k] = DS1(v);
            opt_time.emplace(cds.query_time(), k);
        }
    }

    void erase(int ind) {
        auto& [x, y, ty] = arr[ind];
        if (!ty) {
            return;
        }
        auto& cds = dsv[x];

        opt_time.erase({cds.query_time(), x});
        cds.erase(y);
        opt_time.emplace(cds.query_time(), x);
    }

    int query_time() const {
        return sz(opt_time) ? begin(opt_time)->first : IINF;
    }

    template <typename Cb>
    void all_crashes(int t, const Cb& cb) {
        for (auto it = begin(opt_time); it != end(opt_time) && it->first == t;
             ++it) {
            dsv[it->second].all_crashes(t, cb);
        }
    }
};

void solve() {
    int n;
    cin >> n;
    vector<tuple<int, int, char>> arr(n);
    for (auto& [x, y, dir] : arr) {
        cin >> x >> y >> dir;
        if (dir == 'N' || dir == 'S') {
            dir = 'N' ^ 'S' ^ dir;
        }
    }

    vector<DS2> dss;
    auto go = [&](auto cb) -> void {
        vector<array<int, 3>> ans;

        for (auto& [x, y, dir] : arr) {
            ans.push_back(cb(x, y, dir));
        }

        dss.emplace_back(ans);
    };
    auto go2 = [&](auto cb1, char p1, char m1) -> void {
        auto cb2 = [&](char dir) -> int {
            if (dir == p1) {
                return +1;
            } else if (dir == m1) {
                return -1;
            } else {
                return 0;
            }
        };

        go([&](int x, int y, char dir) -> array<int, 3> {
            return {cb1(x, y), x, cb2(dir)};
        });
    };

    auto diag1 = [&](int x, int y) -> int {
        return x + y;
    };
    auto diag2 = [&](int x, int y) -> int {
        return x - y;
    };

    go2(diag1, 'E', 'N');
    go2(diag1, 'S', 'W');
    go2(diag2, 'N', 'W');
    go2(diag2, 'E', 'S');
    go2([&](int x, int) -> int {
        return x;
    }, 'N', 'S');
    go2([&](int, int y) -> int {
        return y;
    }, 'E', 'W');

    vector ans(n, true);

    while (true) {
        int opt_time = IINF;

        for (auto& a : dss) {
            opt_time = min(opt_time, a.query_time());
            dbg(opt_time);
        }

        if (opt_time == IINF) {
            break;
        }

        dbg(opt_time);
        set<int> death;
        for (auto& a : dss) {
            a.all_crashes(opt_time, [&](int ind) -> void {
                death.insert(ind);
            });
        }

        for (auto& a : death) {
            dbg(a);
            ans[a] = false;
            for (auto& b : dss) {
                b.erase(a);
            }
        }
    }

    for (int i = 0; i < n; i++) {
        if (ans[i]) {
            dbg(i);
            cout << i + 1 << endl;
        }
    }
}

int main() {
    init_io();
    solve();
}