#include <bits/stdc++.h>
using namespace std;

const int M = 201000;

// #define DEBUG(...) fprintf(stderr, __VA_ARGS__)
#define DEBUG(...) 0

int n, m, ans[M], c[M], t[M], s[M];
vector<int> nxt[M];

namespace DSU {
    int fa[M], sz[M];
    multiset<int, greater<>> val[M];
    pair<int, int> record[M];
    int cnt = 0;

    inline void debug() {
        return;
        for (int i = 1; i <= n; i++) {
            DEBUG("#%d : fa %d | sz %d\n|   ", i, fa[i], sz[i]);
            for (int j : val[i]) DEBUG("%d ", j);
            DEBUG("\n");
        }
    }

    inline void init() {
        cnt = 0, fill(sz, sz + M, 1), iota(fa, fa + M, 0);
        for (int i = 1; i <= n; i++) val[i].insert(ans[i]);
    }
    inline int getfa(int x) { return fa[x] == x ? x : getfa(fa[x]); }
    inline void merge(int u, int v) {
        u = getfa(u), v = getfa(v);
        if (u == v) return;
        DEBUG("merge %d %d\n", u, v);
        if (sz[u] > sz[v]) swap(u, v);
        fa[u] = v, val[v].insert(*val[u].begin()), sz[v] += sz[u];
        record[cnt++] = {u, v};
    }
    inline void erase(multiset<int, greater<>> &s, int x) {
        auto iter = s.find(x);
        s.erase(iter);
    }
    inline void revoke() {
        DEBUG("revoke\n");
        auto [u, v] = record[--cnt];
        fa[u] = u, erase(val[v], *val[u].begin());
        // val[v].erase(*val[u].begin());
        sz[v] -= sz[u];
    }
    inline void update(int x, int v) { // set x's val to v
        DEBUG("\nupdate %d : %d\n", x, v);
        if (v <= ans[x]) return;
        int p = ans[x], q = v; // p -> q
        for (int i = x;; i = fa[i]) {
            int before = *val[i].begin();
            // val[i].erase(p);
            erase(val[i], p);
            val[i].insert(q);
            DEBUG("modify %d : %d -> %d\n", i, p, q);
            int after = *val[i].begin();
            if (before == after || fa[i] == i) break;
            p = before, q = after;
        }
        DEBUG("result :\n");
        debug();
        DEBUG("\n");
    }
}

namespace SGT {
    using namespace DSU;
#define lc (n << 1)
#define rc (n << 1 | 1)
#define mid (l + r >> 1)
    vector<int> qry[M];
    vector<pair<int, int>> ins[M << 2];
    void insert(int n, int l, int r, int dl, int dr, pair<int, int> e) {
        if (l == dl && r == dr) return ins[n].push_back(e), void();
        if (dr <= mid) insert(lc, l, mid, dl, dr, e);
        else if (dl > mid) insert(rc, mid + 1, r, dl, dr, e);
        else insert(lc, l, mid, dl, mid, e), insert(rc, mid + 1, r, mid + 1, dr, e);
    }
    void solve(int n, int l, int r) {
        DEBUG("\nsolve %d %d\n", l, r);
        int state = cnt;
        for (auto [u, v] : ins[n]) {
            DEBUG("edge %d %d\n", u, v);
            merge(u, v);
        }

        if (l == r) {
            DEBUG("find ans for %d :\n", l);
            debug();
            DEBUG("\n");
            for (int x : qry[l]) {
                int v = *val[getfa(x)].begin();
                DEBUG("%d : result %d\n", x, v);
                update(x, v), ans[x] = max(ans[x], v);
                for (int y : nxt[x])
                    if (c[y] <= c[x] && ans[y] < ans[x]) update(y, ans[x]), ans[y] = ans[x];
            }
        } else solve(rc, mid + 1, r), solve(lc, l, mid);

        while (cnt != state) revoke();
    }
}
using namespace SGT;

int tmp[M << 1];

int main() {
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i++) scanf("%d%d%d", c + i, t + i, s + i), tmp[++tmp[0]] = c[i], tmp[++tmp[0]] = t[i];
    for (int i = 1, u, v; i <= m; i++) scanf("%d%d", &u, &v), nxt[u].push_back(v), nxt[v].push_back(u);
    sort(tmp + 1, tmp + tmp[0] + 1);
    int tp = unique(tmp + 1, tmp + tmp[0] + 1) - tmp;
    // for (int i = 1; i <= tp; i++) printf("!!! %d\n", tmp[i]);
    for (int i = 1; i <= n; i++)
        c[i] = lower_bound(tmp + 1, tmp + tp, c[i]) - tmp, t[i] = lower_bound(tmp + 1, tmp + tp, t[i]) - tmp,
        ans[i] = s[i];
    // for (int i = 1; i <= n; i++) printf("%d %d %d\n", c[i], t[i], s[i]);
    DSU::init();
    for (int i = 1; i <= n; i++) qry[c[i]].push_back(i);
    for (int u = 1; u <= n; u++)
        for (int v : nxt[u]) {
            if (u >= v) continue;
            int l = max(c[u], c[v]), r = min(t[u], t[v]);
            if (l > r) continue;
            insert(1, 1, tp - 1, l, r, {u, v});
        }
    solve(1, 1, tp - 1);
    for (int i = 1; i <= n; i++) printf("%d ", ans[i]);

    return 0;
}