package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	reader := bufio.NewReader(os.Stdin)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	var n, m, k int
	if _, err := fmt.Fscanf(reader, "%d %d %d\n", &n, &m, &k); err != nil {
		return
	}

	special := make([]int, k)
	for i := 0; i < k; i++ {
		fmt.Fscanf(reader, "%d", &special[i])
	}
	fmt.Fscanf(reader, "\n")

	c := make([]int64, n+1)
	for i := 1; i <= n; i++ {
		fmt.Fscanf(reader, "%d", &c[i])
	}
	fmt.Fscanf(reader, "\n")

	w := make([]int64, m+1)
	for i := 1; i <= m; i++ {
		fmt.Fscanf(reader, "%d", &w[i])
	}
	fmt.Fscanf(reader, "\n")

	type Edge struct {
		to, id int
	}
	adj := make([][]Edge, n+1)
	for i := 1; i <= m; i++ {
		var u, v int
		fmt.Fscanf(reader, "%d %d\n", &u, &v)
		adj[u] = append(adj[u], Edge{v, i})
		adj[v] = append(adj[v], Edge{u, i})
	}

	dfn := make([]int, n+1)
	low := make([]int, n+1)
	st := make([]int, 0)
	inSt := make([]bool, n+1)
	timer := 0
	scc := make([]int, n+1)
	sccCnt := 0

	var tarjan func(u, p int)
	tarjan = func(u, p int) {
		timer++
		dfn[u] = timer
		low[u] = timer
		st = append(st, u)
		inSt[u] = true
		for _, e := range adj[u] {
			if e.to == p {
				continue
			}
			if dfn[e.to] != 0 {
				if inSt[e.to] && dfn[e.to] < low[u] {
					low[u] = dfn[e.to]
				}
			} else {
				tarjan(e.to, u)
				if low[e.to] < low[u] {
					low[u] = low[e.to]
				}
			}
		}
		if low[u] == dfn[u] {
			sccCnt++
			for {
				v := st[len(st)-1]
				st = st[:len(st)-1]
				inSt[v] = false
				scc[v] = sccCnt
				if v == u {
					break
				}
			}
		}
	}
	tarjan(1, 0)

	treeC := make([]int64, sccCnt+1)
	for i := 1; i <= n; i++ {
		treeC[scc[i]] += c[i]
	}

	type TreeEdge struct {
		to int
		w  int64
	}
	tree := make([][]TreeEdge, sccCnt+1)
	for u := 1; u <= n; u++ {
		for _, e := range adj[u] {
			if scc[u] != scc[e.to] {
				tree[scc[u]] = append(tree[scc[u]], TreeEdge{scc[e.to], w[e.id]})
			}
		}
	}

	dpDown := make([]int64, sccCnt+1)
	var dfsDown func(u, p int)
	dfsDown = func(u, p int) {
		dpDown[u] = treeC[u]
		for _, e := range tree[u] {
			if e.to == p {
				continue
			}
			dfsDown(e.to, u)
			val := dpDown[e.to] - e.w
			if val > 0 {
				dpDown[u] += val
			}
		}
	}
	dfsDown(1, 0)

	dpUp := make([]int64, sccCnt+1)
	var dfsUp func(u, p int, upVal int64)
	dfsUp = func(u, p int, upVal int64) {
		dpUp[u] = upVal
		for _, e := range tree[u] {
			if e.to == p {
				continue
			}
			curVal := dpDown[u]
			if dpDown[e.to]-e.w > 0 {
				curVal -= (dpDown[e.to] - e.w)
			}
			if upVal-0 > 0 {
				curVal += upVal
			}
			nextUp := curVal - e.w
			if nextUp < 0 {
				nextUp = 0
			}
			dfsUp(e.to, u, nextUp)
		}
	}
	dfsUp(1, 0, 0)

	ans := make([]int64, n+1)
	for i := 1; i <= n; i++ {
		u := scc[i]
		ans[i] = dpDown[u] + dpUp[u]
	}

	for i := 1; i <= n; i++ {
		if i > 1 {
			fmt.Fprint(writer, " ")
		}
		fmt.Fprint(writer, ans[i])
	}
	fmt.Fprintln(writer)
}