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

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

    std::vector<std::map<int, std::set<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].insert({cost, v});
        G[v][c].insert({cost, u});
    }

    auto del = [&](int u, int v,int c, int cost){
        G[u][c].erase({cost, c});
        if(G[u][c].size() == 0){
            G[u].erase(c);
        }
    };

    std::vector<std::map<int, std::set<int>>>SG(m + 1);
    {
        //  初始化边集
        std::vector<std::array<int, 4>>dell;
        for(auto& [c, E] : G[1]){
            for(auto& [cost, v] : E){
                SG[c][cost].insert(v);
                dell.push_back({1, v, c, cost});
            }
        }  

        for(auto [u, v, c, cost] : dell){
            del(u, v, c, cost);
            del(v, u, c, cost);
        }
    }

    const int inf = 2E18;
    std::vector<int>vis(n + 1);
    std::vector<int>dis(n + 1, inf);
    dis[1] = 0;
    vis[1] = 1;

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

        for(auto [cost, u] : dl){
            SG[c][cost].erase(u);
            if(SG[c][cost].size() == 0){
                SG[c].erase(cost);
            }
        }

        while(Q.size()){
            auto [d, u] = Q.top();
            Q.pop();
            
            if(dis[u] < d || G[u].count(c) == 0){
                continue ;
            }

            auto& E = G[u][c];
            for(auto [cost, v] : E){
                if(cost + d > U) break;
                if(vis[v] == 0 && dis[v] > cost + d){
                    Q.push({dis[v] = cost + d, v});
                    nw.insert(v);
                }
            }
        }

        //  加入新的点, 删除外点与内部点的边
        std::vector<std::array<int, 4>>dell;
        for(auto u : nw){
            vis[u] = 1;
        }
        for(auto u : nw){
            for(auto& [c, E] : G[u]){
                for(auto& [cost, v] : E){
                    if(vis[v] == 0){
                        dell.push_back({u, v, c, cost});
                        SG[c][cost].insert(v);
                    }
                }
            }
        }

        for(auto [u, v, c, cost] : dell){
            del(u, v, c, cost);
            del(v, u, c, 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;
}