#include <iostream>
#include <vector>
#include <map>
#include <unordered_map>
#include <set>
#include <algorithm>
#include <cmath>
#include <fstream>
#include <ctime>
#include <stdio.h>      /* printf */
#include <stdlib.h>
#include <queue>

#ifdef SHOW_DEBUG
#define dbg(a, ...) printf("DEBUG: " a "\n", ##__VA_ARGS__)
#else
#define dbg(...) ((void*)(0))
#endif

using namespace std;
typedef long long ll;
template<typename A, typename B>
using hmap = unordered_map<A, B>;
typedef tuple<int, int> ii;
typedef tuple<ll, ll> lii;
#define PI 3.14159265358979323846
#define inf 0x3f3f3f3f
#define infl 0x3f3f3f3f3f3f3f3fL

void step(vector<vector<ll>>& edges, set<ll> nodes, vector<vector<ll>>& dist, ll running_dist){
    set<ll> new_nodes;
    ll new_dist = running_dist + 1;
    for (ll node : nodes){
        for (ll j = 0; j < edges[node].size(); j++){
            ll p = (new_dist) % 2;
            ll neighbor = edges[node][j];
            if (dist[neighbor][p] == -1 || new_dist < dist[neighbor][p] ){
                dist[neighbor][p] = new_dist;
                new_nodes.insert(neighbor);
            }
        }
    }
    if (!new_nodes.empty()){
        step(edges, new_nodes, dist, running_dist + 1);
    }
}

void bfs(vector<vector<ll>>& edges, ll start, vector<vector<ll>>& dist){
    set<ll> nodes;
    nodes.insert(start);
    step(edges, nodes, dist, 0);
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    ll tt;
    cin >> tt;
    for (ll t = 0; t < tt; t++){
        ll n, m, l;
        cin >> n >> m >> l;
        vector<ll> A(l);
        for (ll i = 0; i < l; i++){
            cin >> A[i];
        }
        vector<vector<ll>> edges(n);
        for (ll i = 0; i < m; i++){
            ll u, v;
            cin >> u >> v;
            u--;
            v--;
            edges[u].push_back(v);
            edges[v].push_back(u);
        }
        for (ll i = 0; i < n; i++){
            sort(edges[i].begin(), edges[i].end());
        }

        vector<vector<ll>> dist(n, vector<ll>(2, -1));
        dist[0][0] = 0;
        dist[0][1] = -1;
        bfs(edges, 0, dist);

        sort(A.begin(), A.end());
        ll min_odd = -1;
        for (ll i = 0; i < A.size(); i++){
            if (A[i] % 2 == 1){
                min_odd = A[i];
                break;
            }
        }
        ll sum = 0;
        for (ll i = 0; i < A.size(); i++){
            sum += A[i];
        }
        ll even_sum = -1;
        ll odd_sum = -1;
        if (sum % 2 == 0){
            even_sum = sum;
            if (min_odd != -1){
                odd_sum = sum - min_odd;
            }
        } else {
            odd_sum = sum;
            if (min_odd != -1){
                even_sum = sum - min_odd;
            }
        }

        vector<ll> ans(n);
        for (ll i = 0; i < ans.size(); i++){
            if ((dist[i][0] > -1 && dist[i][0] <= even_sum) || (dist[i][1] > -1 && dist[i][1] <= odd_sum)){
                ans[i] = 1;
            }
        }
        for (ll i = 0; i < ans.size(); i++){
            cout << ans[i];
        }
        cout << endl;

    }

    return 0;
}