#include "bits/stdc++.h"

using namespace std;

using i64 = long long;

const i64 MOD = 1e9 + 7;
const i64 INF = i64(1e18) + 7;


template <typename T>
bool chmin(T& x, T y){
    if(x > y){
        x = y;
        return true;
    }
    return false;
}

template <typename T>
bool chmax(T& x, T y){
    if(x < y){
        x = y;
        return true;
    }
    return false;
}

vector<int> scc(vector<vector<int>>& edges){
    int n = edges.size();
    vector<vector<int>> rev(n);

    for(int i = 0; i < n; ++i)
        for(auto& x : edges[i])
            rev[x].emplace_back(i);

    vector<i64> dfs_num(n, -1);
    vector<i64> flag(n, 0);
    int num = 0;
    function<void(int)> dfs = [&](int pos){
        flag[pos] = 1;
        for(auto& xx : edges[pos])
            if(!flag[xx]){
                dfs(xx);
        }
        dfs_num[pos] = num++;
    };

    for(int i = 0; i < n; ++i)
        if(!flag[i])
            dfs(i);

    vector<int> dfs_inv(n);
    for(int i = 0; i < n; ++i)
        dfs_inv[n - 1 - dfs_num[i]] = i;

    num = 0;

    vector<int> scc_vec(n, -1);

    function<void(int)> rdfs = [&](int pos){
        scc_vec[pos] = num;
        for(auto t : rev[pos])
            if(scc_vec[t] == -1)
                rdfs(t);
    };

    for(int i = 0; i < n; ++i)
        if(scc_vec[dfs_inv[i]] == -1){
            rdfs(dfs_inv[i]);
            ++num;
        }

    return scc_vec;
}

struct Result{
    int dag_size;
    vector<vector<int>> dag_graph;
    // 元のグラフでi番目の頂点が何番目の強連結成分に含まれるか
    vector<int> elements;
    // i番目の強連結成分に含まれる頂点のリスト
    vector<vector<int>> tps_list;
    // トポソしてi番目にくる頂点のindex
    vector<int> tps_order;
    // DAGのi番目の頂点をトポソした時の番号
    vector<int> tps_index;
};

Result scc_dag(vector<vector<int>>& edges){
    int n = edges.size();
    vector<int> scc_vec = scc(edges);
    int m = *max_element(scc_vec.begin(), scc_vec.end()) + 1;
    vector<vector<int>> dag_graph(m);

    queue<int> tps_que;
    vector<int> in_count(m, 0);
    vector<int> tps(m, -1);
    vector<int> tps_idx(m);
    for(int i = 0; i < n; ++i){
        for(auto j : edges[i]){
            if(scc_vec[i] == scc_vec[j])
                continue;
            dag_graph[scc_vec[i]].push_back(scc_vec[j]);
            ++in_count[scc_vec[j]];
        }
    }
    for(int i = 0; i < m; ++i)
        if(in_count[i] == 0)
            tps_que.push(i);
    int cnt = 0;
    while(!tps_que.empty()){
        int x = tps_que.front();
        tps_idx[x] = cnt;
        tps[cnt++] = x;
        tps_que.pop();
        for(auto y : dag_graph[x])
            if(--in_count[y] == 0)
                tps_que.push(y);
    }
    assert(cnt == m);

    vector<vector<int>> tps_list(m);
    for(int i = 0; i < n; ++i)
        tps_list[scc_vec[i]].push_back(i);

    Result res;
    res.dag_size = m;
    res.elements = move(scc_vec);
    res.tps_index = move(tps_idx);
    res.tps_order = move(tps);
    res.tps_list = move(tps_list);
    res.dag_graph = move(dag_graph);
    return res;
}




signed main(){
    int n, m;
    cin >> n >> m;
    vector<int> x(n), y(n), z(n);
    vector<vector<int>> v(n, vector<int>(8, 0));
    for(int i = 0; i < n; ++i){
        cin >> x[i] >> y[i] >> z[i];
        for(int j = 0; j < 8; ++j){
            v[i][j] += x[i] * (j & 1 ? -1 : 1);
            v[i][j] += y[i] * (j & 2 ? -1 : 1);
            v[i][j] += z[i] * (j & 4 ? -1 : 1);
        }
    }
    vector<vector<int>> edges(n);
    for(int i = 0; i < m; ++i){
        int p, q;
        cin >> p >> q;
        --p, --q;
        edges[q].push_back(p);
    }
    Result res = scc_dag(edges);
    int k = res.dag_size;
    vector<vector<int>> dp(k, vector<int>(8, -MOD));
    for(int i = 0; i < n; ++i)
        for(int j = 0; j < 8; ++j)
            chmax(dp[res.elements[i]][j], v[i][j]);

    for(auto i : res.tps_order){
        for(int j = 0; j < 8; ++j){
            for(auto nex : res.dag_graph[i]){
                chmax(dp[nex][j], dp[i][j]);
            }
        }
    }

    for(int i = 0; i < n; ++i){
        int dist = 0;
        for(int j = 0; j < 8; ++j){
            chmax(dist, dp[res.elements[i]][j] - v[i][j]);
        }
        cout << dist << endl;
    }
}



Measured memory_bytes: 74776