package main

import (
	"io"
	"os"
)

type scanner struct {
	data []byte
	pos  int
}

func (s *scanner) nextInt() int {
	for s.pos < len(s.data) && (s.data[s.pos] < '0' || s.data[s.pos] > '9') {
		s.pos++
	}
	if s.pos >= len(s.data) {
		return 0
	}
	res := 0
	for s.pos < len(s.data) && s.data[s.pos] >= '0' && s.data[s.pos] <= '9' {
		res = res*10 + int(s.data[s.pos]-'0')
		s.pos++
	}
	return res
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	s := &scanner{data: data, pos: 0}

	for s.pos < len(s.data) && (s.data[s.pos] < '0' || s.data[s.pos] > '9') {
		s.pos++
	}
	if s.pos >= len(s.data) {
		return
	}

	t := s.nextInt()
	out := make([]byte, 0, 1024*1024)

	for tc := 0; tc < t; tc++ {
		n := s.nextInt()
		m := s.nextInt()
		l := s.nextInt()

		var totalSum int64 = 0
		minOdd := int64(1e18)

		for i := 0; i < l; i++ {
			a := int64(s.nextInt())
			totalSum += a
			if a%2 != 0 {
				if a < minOdd {
					minOdd = a
				}
			}
		}

		head := make([]int, n+1)
		for i := range head {
			head[i] = -1
		}
		next := make([]int, 2*m)
		to := make([]int, 2*m)

		for i := 0; i < m; i++ {
			u := s.nextInt()
			v := s.nextInt()

			to[2*i] = v
			next[2*i] = head[u]
			head[u] = 2*i

			to[2*i+1] = u
			next[2*i+1] = head[v]
			head[v] = 2*i + 1
		}

		var M0, M1 int64 = -1, -1
		if totalSum%2 == 0 {
			M0 = totalSum
			if minOdd != 1e18 {
				M1 = totalSum - minOdd
			}
		} else {
			M1 = totalSum
			if minOdd != 1e18 {
				M0 = totalSum - minOdd
			}
		}
		if M0 < 0 {
			M0 = 0
		}

		dist := make([]int32, 2*n+2)
		for i := 0; i < len(dist); i++ {
			dist[i] = -1
		}

		dist[1<<1|0] = 0
		queue := make([]int, 0, 2*n)
		queue = append(queue, 1<<1|0)

		for len(queue) > 0 {
			curr := queue[0]
			queue = queue[1:]

			u := curr >> 1
			p := curr & 1
			d := dist[curr]

			for e := head[u]; e != -1; e = next[e] {
				v := to[e]
				np := p ^ 1
				ncurr := v<<1 | np
				if dist[ncurr] == -1 {
					dist[ncurr] = d + 1
					queue = append(queue, ncurr)
				}
			}
		}

		for i := 1; i <= n; i++ {
			can := false
			d0 := dist[i<<1|0]
			d1 := dist[i<<1|1]

			if d0 != -1 && M0 >= int64(d0) {
				can = true
			}
			if d1 != -1 && M1 >= int64(d1) {
				can = true
			}
			if can {
				out = append(out, '1')
			} else {
				out = append(out, '0')
			}
		}
		out = append(out, '\n')
	}

	os.Stdout.Write(out)
}