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

//  The 2024 ICPC Kunming Invitational Contest

/*
    Hint:
    1.维护一个集合S，S由已遍历过的点组成。
      维护S和非S点的边集{c, u, cost}，假如存在多个cost，取最小的cost.
    2.限制性最短路.
*/

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

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

    //  SG[c]:记录S的边集，c代表路的类型SG[c][v]:通过c路到达v的最低成本.
    std::vector<std::map<int, int>>SG(m + 1);
    std::vector<int>vis(n + 1);
    vis[1] = 1;

    {
        for(auto [c, V] : G[1]){
            for(auto [v, cost] : V){
                if(SG[c].count(v) == 0){
                    SG[c][v] = cost;
                }else{
                    SG[c][v] = std::min(SG[c][v], cost);
                }
            }
        }
    }

    const int inf = 1E18;
    std::vector<int>dis(n + 1, inf);

    auto calc = [&](int c, int U){
        std::set<int>newNode;
        std::priority_queue<std::array<int, 2>, std::vector<std::array<int, 2>>, std::greater<>>Q;
        for(auto [v, cost] : SG[c]){
            if(vis[v] == 0){
                if(cost <= U){
                    Q.push({dis[v] = cost, v});
                    newNode.insert(v);
                }
            }
        }

        //  不再使用S边集
        while(Q.size()){
            auto [cost, u] = Q.top();
            Q.pop();
            if(dis[u] < cost || G[u].count(c) == 0){
                continue ;
            }
            auto& E = G[u][c];
            for(auto [v, d] : E){
                if(vis[v] == 0){
                    if(cost + d < dis[v] && cost + d <= U){
                        Q.push({dis[v] = cost + d, v});
                        newNode.insert(v);
                    }
                }
            }
        }

        //  加入新的点
        for(auto v : newNode){
            vis[v] = 1;
            SG[c].erase(v);
        }

        //  拓展SG的边集
        for(auto u : newNode){
            for(auto& [cc, E] : G[u]){
                for(auto [v, cost] : E){
                    if(vis[v] == 0){
                        if(SG[cc].count(v) == 0){
                            SG[cc][v] = cost;
                        }else{
                            SG[cc][v] = std::min(SG[cc][v], cost);
                        }
                    }
                }
            }
        }
    };

    for(int i = 1;i <= k;i++){
        int c, U;
        std::cin>>c>>U;
        calc(c, U);
    }

    for(int i = 1;i <= n;i++){
        std::cout<<vis[i];
    }
    std::cout<<"\n";
}

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