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
#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <algorithm>
#include <utility>
#include <functional>
#include <cstring>
#include <queue>
#include <stack>
#include <math.h>
#include <iterator>
#include <vector>
#include <string>
#include <set>
#include <math.h>
#include <iostream>
#include <random>
#include<map>
#include <iomanip>
#include <time.h>
#include <stdlib.h>
#include <list>
#include <typeinfo>
#include <list>
#include <set>
#include <cassert>
#include<fstream>
#include <unordered_map>
#include <cstdlib>
#include <complex>
#include <cctype>
using namespace std;
typedef string::const_iterator State;
#define Ma_PI 3.141592653589793
#define eps 0.00000001
#define LONG_INF 1e18
#define GOLD 1.61803398874989484820458
#define MAX_MOD 1000000007
#define MOD 998244353
#define seg_size 262144
#define REP(i,n) for(long long i = 0;i < n;++i)
long long pan[300000];
long long azi[300000];
long long value[300000];
vector<pair<long long,long long>> vertexs[200000];
long long dist[300000] = {};
int visited[300000];
long long dp[300000] = {};
long long ans[300000];
int main() {
#define int long long
	int n, m, k;
	cin >> n >> m >> k;
	REP(i, n) {
		cin >> pan[i];
	}
	REP(i, n) {
		cin >> azi[i];
		azi[i]--;
	}
	REP(i, n) {
		cin >> value[i];
		dist[i] = LONG_INF;
	}
	REP(i, k) {
		ans[i] = -LONG_INF;
	}
	dist[0] = 0;
	REP(i, m) {
		int a, b, c;
		cin >> a >> b >> c;
		a--;
		b--;
		vertexs[a].push_back(make_pair(b, c));
		vertexs[b].push_back(make_pair(a, c));
	}
	priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> first_next;
	first_next.push(make_pair(0, 0));
	while (first_next.empty() == false) {
		int now = first_next.top().second;
		first_next.pop();
		if (visited[now] == 1) continue;
		visited[now] = 1;
		for (int q = 0; q < vertexs[now].size(); ++q) {
			int cost = dist[now] + vertexs[now][q].second;
			if (dist[vertexs[now][q].first] > cost) {
				dist[vertexs[now][q].first] = cost;
				first_next.push(make_pair(cost, vertexs[now][q].first));
			}
		}
	}
	priority_queue<pair<int, int>> next;
	REP(i, n) {
		visited[i] = 0;
		dp[i] = pan[i] - dist[i];
		next.push(make_pair(dp[i], i));
	}
	while (next.empty() == false) {
		int now = next.top().second;
		next.pop();
		if (visited[now] == 1) continue;
		visited[now] = 1;
		for (int q = 0; q < vertexs[now].size(); ++q) {
			int cost = dp[now] - vertexs[now][q].second;
			if (dp[vertexs[now][q].first] < cost) {
				dp[vertexs[now][q].first] = cost;
				next.push(make_pair(cost, vertexs[now][q].first));
			}
		}
	}
	REP(i, n) {
		ans[azi[i]] = max(ans[azi[i]],dp[i] + value[i] - dist[i]);
	}
	REP(i, k) {
		cout << ans[i] << endl;
	}
}
