#include <bits/stdc++.h>
using namespace std;
template <class TH>
void _dbg(const char *sdbg, TH h) {
  cerr << sdbg << '=' << h << endl;
}
template <class TH, class... TA>
void _dbg(const char *sdbg, TH h, TA... a) {
  while (*sdbg != ',') cerr << *sdbg++;
  cerr << '=' << h << ',';
  _dbg(sdbg + 1, a...);
}
template <class T>
ostream &operator<<(ostream &os, vector<T> V) {
  os << "[";
  for (auto vv : V) os << vv << ",";
  return os << "]";
}
template <class L, class R>
ostream &operator<<(ostream &os, pair<L, R> P) {
  return os << "(" << P.first << "," << P.second << ")";
}
template <class T>
using min_heap = priority_queue<T, vector<T>, greater<T>>;
template <class T>
using max_heap = priority_queue<T>;
const int mod = 998244353;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
struct PairHash {
  template <typename T1, typename T2>
  std::size_t operator()(const pair<T1, T2> &p) const {
    return hash<T1>()(p.first) ^ hash<T2>()(p.second);
  }
};
int n, m, n_sp;
vector<vector<pair<int, int>>> g;
vector<int> is_special;
vector<int> c;
vector<int> w;
vector<int> dfn;
vector<int> low;
vector<int> father;
int time_stamp;
set<pair<int, pair<int, int>>> bridge;
void tarjan_bridge_init() {
  dfn.assign(n + 1, -1);
  low.assign(n + 1, -1);
  father.assign(n + 1, -1);
  time_stamp = 0;
  bridge.clear();
}
void tarjan_bridge(int r, int pre) {
  father[r] = pre;
  dfn[r] = low[r] = time_stamp++;
  for (auto p : g[r]) {
    int u = p.first;
    int we = p.second;
    if (dfn[u] < 0) {
      tarjan_bridge(u, r);
      low[r] = min(low[r], low[u]);
      if (low[u] > dfn[r]) {
        bridge.emplace(u, pair<int, int>(father[u], we));
        bridge.emplace(father[u], pair<int, int>(u, we));
      }
    } else if (dfn[u] != dfn[r] && u != pre) {
      low[r] = min(low[r], dfn[u]);
    }
  }
}
vector<int> bcc;
int bcc_idx;
void dfs_bcc(int u) {
  bcc[u] = bcc_idx;
  for (auto &p : g[u]) {
    if (bcc[p.first] > 0 ||
        bridge.find(pair<int, pair<int, int>>(u, p)) != bridge.end())
      continue;
    dfs_bcc(p.first);
  }
}
void calc_bcc() {
  bcc_idx = 0;
  bcc.assign(n + 1, -1);
  for (int i = 1; i <= n; i++) {
    if (bcc[i] >= 0) continue;
    ++bcc_idx;
    dfs_bcc(i);
  }
}
vector<vector<pair<int, int>>> tree;
vector<long long> tree_c;
vector<int> tree_is_special;
int tree_n_sp;
int tn;
void to_tree() {
  tn = bcc_idx;
  tree.assign(tn + 1, vector<pair<int, int>>());
  for (auto &p : bridge) {
    tree[bcc[p.first]].emplace_back(bcc[p.second.first], p.second.second);
  }
  tree_c.assign(tn + 1, 0);
  for (int i = 1; i <= n; i++) {
    tree_c[bcc[i]] += c[i];
  }
  tree_is_special.assign(tn + 1, 0);
  for (int i = 1; i <= n; i++) {
    tree_is_special[bcc[i]] |= is_special[i];
  }
  tree_n_sp = 0;
  for (int i = 1; i <= tn; i++) {
    tree_n_sp += tree_is_special[i];
  }
}
vector<long long> dp;
vector<long long> f;
vector<int> cnt_sp;
inline long long calc_f(int u, int v, int we) {
  if (cnt_sp[v] == 0 || cnt_sp[v] == tree_n_sp) return dp[v];
  return max(0LL, dp[v] - we);
}
void dfs_init(int u, int pre) {
  cnt_sp[u] = tree_is_special[u];
  for (auto &p : tree[u]) {
    int v = p.first;
    if (v == pre) continue;
    dfs_init(v, u);
    cnt_sp[u] += cnt_sp[v];
  }
  for (auto &p : tree[u]) {
    int v = p.first;
    if (v == pre) continue;
    f[v] = calc_f(u, v, p.second);
    dp[u] += f[v];
  }
}
vector<long long> ans;
void dfs_reroot(int u, int pre) {
  ans[u] = dp[u];
  for (auto &p : tree[u]) {
    int v = p.first;
    int we = p.second;
    if (v == pre) continue;
    long long old_dp_u = dp[u];
    long long old_dp_v = dp[v];
    int old_cnt_sp_u = cnt_sp[u];
    int old_cnt_sp_v = cnt_sp[v];
    dp[u] -= calc_f(u, v, we);
    cnt_sp[u] -= cnt_sp[v];
    cnt_sp[v] += cnt_sp[u];
    dp[v] += calc_f(v, u, we);
    dfs_reroot(v, u);
    dp[u] = old_dp_u;
    dp[v] = old_dp_v;
    cnt_sp[u] = old_cnt_sp_u;
    cnt_sp[v] = old_cnt_sp_v;
  }
}
void solve(int ncase) {
  scanf("%d%d%d", &n, &m, &n_sp);
  is_special.assign(n + 1, 0);
  for (int i = 0; i < n_sp; i++) {
    int x;
    scanf("%d", &x);
    is_special[x] = 1;
  }
  c.assign(n + 1, 0);
  for (int i = 1; i <= n; i++) {
    scanf("%d", &c[i]);
  }
  w.assign(m, 0);
  for (int i = 0; i < m; i++) {
    scanf("%d", &w[i]);
  }
  g.assign(n + 1, vector<pair<int, int>>());
  for (int i = 0; i < m; i++) {
    int x, y;
    scanf("%d%d", &x, &y);
    g[x].emplace_back(y, w[i]);
    g[y].emplace_back(x, w[i]);
  }
  tarjan_bridge_init();
  tarjan_bridge(1, -1);
  calc_bcc();
  to_tree();
  dp.assign(tn + 1, 0);
  f.assign(tn + 1, 0);
  cnt_sp.assign(tn + 1, 0);
  for (int i = 1; i <= tn; i++) {
    dp[i] = tree_c[i];
  }
  dfs_init(1, -1);
  ans.assign(tn + 1, 0);
  dfs_reroot(1, -1);
  for (int i = 1; i <= n; i++) {
    printf("%lld%c", ans[bcc[i]], " \n"[i == n]);
  }
}
void solve_all_cases() {
  int T = 1;
  int ncase = 0;
  while (T--) {
    solve(++ncase);
  }
}
int main() {
  cout << std::fixed;
  cout << setprecision(9);
  solve_all_cases();
}
