#include<bits/stdc++.h>
using namespace std;

//  The 2024 ICPC Kunming Invitational Contest

struct STList{
    std::vector<int>pos, a;
    std::vector<std::vector<int>>ST;
    int n = 0, m = 0;

    STList() {
        pos.resize(1);
        a.resize(1);
    }

    void add(int id, int Val){
        pos.push_back(id);
        a.push_back(Val);
        n++;
    }

    void work(){
        if(n == 0) return ;
        m = std::__lg(n) + 1;
        ST.assign(n + 1, std::vector<int>(m));
        for(int i = 1;i <= n;i++){
            ST[i][0] = a[i];
        }
        for(int j = 1;j < m;j++){
            for(int i = 1;i + (1 << j) - 1 <= n;j++){
                ST[i][j] = std::max(ST[i][j - 1], ST[i + (1 << (j - 1))][j - 1]);
            }
        }
    }

    int ask(int l, int r){
        int K = std::__lg(r - l + 1);
        return std::max(ST[l][K], ST[r - (1 << K) + 1][K]);
    }

    //  r == 0 表示没找到.
    int binarySearch(int st, int Val){
        st = std::upper_bound(pos.begin(), pos.end(), st) - pos.begin();
        if(st == pos.size()) return 0;
        
        int l = st - 1, r = n + 1;
        while(l + 1 != r){
            int mid = l + r >> 1;
            if(ask(st, mid) < Val) l = mid; else r = mid;
        }
        if(r == n + 1) return 0;
        return pos[r];
    }
};

void sol(){
    int n, m, k;
    std::cin>>n>>m>>k;

    std::vector<STList>V(m + 1);
    std::vector<std::vector<std::array<int, 3>>>G(n + 1);

    for(int i = 1;i <= m;i++){
        int u, v, c, cost;
        std::cin>>u>>v>>c>>cost;
        G[u].push_back({v, c, cost});
        G[v].push_back({u, c, cost});
    }

    std::vector<int>type(k + 1), U(k + 1);
    for(int i = 1;i <= k;i++){
        std::cin>>type[i]>>U[i];
        V[type[i]].add(i, U[i]);
    }

    for(int i = 1;i <= m;i++){
        V[i].work();
    }

    typedef std::array<int, 3> info;
    std::vector<int>vis(n + 1);
    std::priority_queue<info, std::vector<info>, std::greater<>>q;
    q.push({1, 0, 1});

    while(q.size()){
        auto [p, t, x] = q.top();
        q.pop();

        if(vis[x] == 1){
            continue;
        }

        vis[x] = 1;
        for(auto [y, c, l] : G[x]){
            if(V[c].n == 0) continue ;

            if(c == type[p] && t + l <= U[p]){
                q.push({p, t + l, y});
                continue ;
            }

            int r = V[c].binarySearch(p, l);
            if(r == 0) continue;

            q.push({r, l, y});
        }
    }
    
    for(int i = 1;i <= n;i++){
        std::cout<<vis[i];
    }
    std::cout<<"\n";
}

int main(){
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int t = 1; std::cin>>t;
    while(t--) sol();  
    return 0;
}