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

struct info
{
    int mx;
    info(int a = 0) : mx(a) {}
    friend info operator+(const info &a, const info &b)
    {
        return info(max(a.mx, b.mx));
    }
};
struct sparse_table
{
    static constexpr int N = 5e5 + 7;
    static int lg[N];
    static void init()
    {
        for (int i = 2; i < N; i++)
            lg[i] = lg[i >> 1] + 1;
    }
    vector<array<info, 20>> val;
    sparse_table(int n = 0) : val(n) {}
    info &operator[](int x) { return val[x][0]; }
    const info operator[](int x) const { return val[x][0]; }
    void build()
    {
        const int n = val.size(), len = lg[n];
        for (int i = 1; i <= len; i++)
            for (int l = 0; l + (1 << i) - 1 < n; l++)
                val[l][i] = val[l][i - 1] + val[l + (1 << i - 1)][i - 1];
    }
    info query(int l, int r)
    {
        const int dep = lg[r - l + 1];
        return val[l][dep] + val[r - (1 << dep) + 1][dep];
    }
    int getpos(int p, int w)
    {
        int len = val.size();
        for (int i = 19; i >= 0 && p < len; i--)
            if ((p + (1 << i)) < len && val[p][i].mx < w)
                p = p + (1 << i);
        if (p < len && val[p][0].mx < w)
            p++;
        return p;
    }
};
int sparse_table::lg[N] = {0};

void solve()
{
    int n, m, k;
    cin >> n >> m >> k;
    using E = array<int, 3>;
    using W = pair<int, int>;
    vector g(n + 1, vector<E>());
    vector<sparse_table> S(m + 1);
    vector<W> tar(k);
    for (int i = 0; i < m; i++)
    {
        int u, v, c, l;
        cin >> u >> v >> c >> l;
        g[u].push_back({v, c, l});
        g[v].push_back({u, c, l});
    }
    vector pos(m + 1, vector<int>());
    for (int i = 0; i < k; i++)
    {
        auto &[c, l] = tar[i];
        cin >> c >> l;
        S[c].val.push_back({0});
        S[c].val.back()[0] = info(l);
        pos[c].push_back(i);
    }
    for (int i = 1; i <= m; i++)
    {
        pos[i].push_back(k);
    }
    for (int i = 1; i <= m; i++)
        S[i].build();
    vector<W> dis(n + 1, W(n + 1, 1e9));
    dis[1] = {0, 0};
    using NODE = pair<W, int>;
    priority_queue<NODE, vector<NODE>, greater<NODE>> q;
    q.push(NODE(W(0, 0), 1));
    vector<bool> vis(n + 1);

    while (!q.empty())
    {
        auto [D, u] = q.top();
        q.pop();
        if (vis[u])
            continue;
        vis[u] = 1;
        auto [no, disu] = D;
        for (auto [v, c, l] : g[u])
        {
            if (vis[v])
                continue;
            if (tar[no].first == c && disu + l <= tar[no].second)
            {
                dis[v] = min(dis[v], W(no, disu + l));
                q.push(NODE(dis[v], v));
            }
            else
            {
                auto p = upper_bound(pos[c].begin(), pos[c].end(), no);
                if (p == pos[c].end())
                    continue;
                auto np = S[c].getpos(p - pos[c].begin(), l);
                if (np < pos[c].size() - 1)
                {
                    assert(tar[pos[c][np]].second >= l);
                    dis[v] = min(dis[v], W(pos[c][np], l));
                    q.push(NODE(dis[v], v));
                }
            }
        }
    }

    for (int i = 1; i <= n; i++)
        cout << (dis[i].first < n ? 1 : 0);
    cout << '\n';
}

int main()
{
#ifdef LOCAL
    freopen("data.in", "r", stdin);
    freopen("data.out", "w", stdout);
    auto _ = clock();
#endif
    sparse_table::init();
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int T;
    cin >> T;
    while (T--)
        solve();
#ifdef LOCAL
    cerr << clock() - _ << '\n';
#endif
    return 0;
}