E: Jam

problem

There are N cities in a country, numbered 1, \ 2, \ ..., \ N. These cities are connected in both directions by M roads, and the i-th road allows you to travel between the cities u_i and v_i in time t_i. Also, any two cities can be reached by using several roads.

Bread is sold in each town, and the deliciousness of bread sold in town i is P_i.

In addition, there are K flavors of jam in this country, and in town i you can buy delicious J_i jams at taste c_i.

Homu-chan, who lives in Town 1, decided to go out to buy bread and jam one by one. Homu-chan travels through several cities, buys bread and jam, and returns to city 1. More precisely, go to city u to buy bread, select city v to buy jam, and return to city 1. At this time, u = v, u = 1, and v = 1 can be used.

The happiness of Homu-chan after shopping is "the total of the deliciousness of the bread and jam I bought"-"the time it took to move". For each of the K types of jam, calculate the maximum possible happiness when going to buy jam and bread of that taste.

Input format


NMK
P_1 P_2 ... P_N
c_1 c_2 ... c_N
J_1 J_2 ... J_N
u_1 v_1 t_1
u_2 v_2 t_2
::
u_M v_M t_M


Constraint

* 1 \ leq N \ leq 10 ^ 5
* 1 \ leq M \ leq 2 \ times 10 ^ 5
* 1 \ leq K \ leq N
* 1 \ leq P_i, J_i \ leq 10 ^ 9
* 1 \ leq c_i \ leq K
* 1 \ leq u_i, v_i \ leq N
* 1 \ leq t_i \ leq 10 ^ 9
* For all i \ (1 \ leq i \ leq K), there exists j \ (1 \ leq j \ leq N) such that c_j = i.
* Given graphs are concatenated graphs that do not include multiple edges or self-loops.
* All inputs are given as integers



Output format

Please output K line. On line i, print the maximum happiness when you go to buy bread and taste i jam.

Input example 1


4 4 3
3 6 1 6
1 1 2 3
6 1 5 5
1 2 1
2 3 1
1 3 1
1 4 1


Output example 1


Ten
8
9


* When buying taste 1 jam
* If you buy jam in city 1, move to city 2, buy bread, and come back to city 1, your happiness will be 6 + 6-2 = 10, which is optimal.
* When buying taste 2 jam
* If you move to City 2 to buy bread, move to City 3 to buy jam, and return to City 1, your happiness will be 6 + 5-3 = 8.
* When buying taste 3 jam
* If you go to City 4 and buy both bread and jam and come back to City 1, your happiness will be 6 + 5-2 = 9.



Input example 2


2 1 2
1 1
1 2
1 1
1 2 1000000000


Output example 2


2
-1999999998


* Homu-chan seems to be dissatisfied because the distance is too far compared to the deliciousness of bread and jam.



Input example 3


6 8 3
31 41 59 26 53 58
1 2 3 1 2 3
27 18 28 18 28 46
one two Three
2 3 7
2 4 8
3 6 9
3 5 3
4 5 3
1 5 15
4 6 7


Output example 3


66
61
68






Example

Input

4 4 3
3 6 1 6
1 1 2 3
6 1 5 5
1 2 1
2 3 1
1 3 1
1 4 1


Output

10
8
9
#include <bits/stdc++.h>
#pragma GCC Optimize("Ofast")

using namespace std;
#define int long long

#define impl(x, last) x == last ? 0 : 63 - __builtin_clz(x ^ last)
struct RadixHeap {
    int last, size_;
    vector<tuple<int, int, bool>> bucket_[64];
    RadixHeap() : last(0), size_(0){}
    void emplace(int x, int val, bool hoge){
        size_++, bucket_[impl(x, last)].emplace_back(x, val, hoge);
    }
    tuple<int, int, bool> pop(bool flag = true){
        if(bucket_[0].empty()){
            int id = 1;
            while(bucket_[id].empty()) id++;
            last = get<0>(*min_element(bucket_[id].begin(), bucket_[id].end()));
            for(auto val : bucket_[id]){
                bucket_[impl(get<0>(val), last)].push_back(val);
            }
            bucket_[id].clear();
        }
        auto res = bucket_[0].back();
        if(flag) size_--, bucket_[0].pop_back();
        return res;
    }
    tuple<int, int, bool> top(){
        return pop(false);
    }
    bool empty(){
        return !size_;
    }
};

int32_t main() {
    ios::sync_with_stdio(false);
    cin.tie(0);

    int n, m, k;
    cin >> n >> m >> k;
    vector<int> ps(n), cs(n), js(n);
    vector<vector<int>> kidx(k);
    for (int i = 0; i < n; i++) {
        cin >> ps[i];
    }
    for (int i = 0; i < n; i++) {
        int c;
        cin >> c;
        c--;
        cs[i] = c;
        kidx[c].push_back(i);
    }
    for (int i = 0; i < n; i++) {
        cin >> js[i];
    }

    vector<vector<pair<int, int>>> adj(n);
    for (int i = 0; i < m; i++) {
        int a, b, c;
        cin >> a >> b >> c;
        a--, b--;
        adj[a].emplace_back(b, c);
        adj[b].emplace_back(a, c);
    }

    vector<vector<int>> dp(n, vector<int>(2, 2e18));
    dp[0][0] = 0;
    dp[0][1] = -ps[0];
//    priority_queue<tuple<int, int, bool>, vector<tuple<int, int, bool>>, greater<>> que;
//    tuple<int, int, bool> : cost, v, bought
    RadixHeap que;

    que.emplace(0, 0, 0);
    que.emplace(-ps[0], 0, 1);

    while (!que.empty()) {
        auto top = que.pop();

        int cost = get<0>(top);
        int v = get<1>(top);
        bool bought = get<2>(top);

        if (cost > dp[v][bought]) continue;
        for (auto &e : adj[v]) {
            int to = e.first, dist = e.second;
            if (bought) {
                if (cost + dist < dp[to][bought]) {
                    dp[to][bought] = cost + dist;
                    que.emplace(dp[to][bought], to, bought);
                }
            } else {
                if (cost + dist < dp[to][bought]) {
                    dp[to][bought] = cost + dist;
                    que.emplace(dp[to][bought], to, bought);
                }
                if (cost + dist - ps[to] < dp[to][1]) {
                    dp[to][1] = cost + dist - ps[to];
                    que.emplace(dp[to][1], to, 1);
                }
            }
        }
    }

    for (int i = 0; i < k; i++) {
        int nin = 2e18;
        for (int v : kidx[i]) {
            if (dp[v][0] + dp[v][1] - js[v] < nin) {
                nin = dp[v][0] + dp[v][1] - js[v];
            }
        }
        cout << -nin << '\n';
    }
}
