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

using i64 = long long;

struct HLD {
    int n, cur = 0;
    vector<int> sz, top, dep, par, tin, tout, seq;
    vector<vector<int>> adj;
    HLD(int n) : n(n), sz(n, 1), top(n), dep(n), par(n), tin(n), tout(n), seq(n), adj(n) {}
    void addEdge(int u, int v) { adj[u].push_back(v), adj[v].push_back(u); }
    void build(int root = 0) {
        top[root] = root, dep[root] = 0, par[root] = -1;
        dfs1(root), dfs2(root);
    }
    void dfs1(int u) {
        if (auto it = find(adj[u].begin(), adj[u].end(), par[u]); it != adj[u].end()) {
            adj[u].erase(it);
        }
        for (auto &v : adj[u]) {
            par[v] = u;
            dep[v] = dep[u] + 1;
            dfs1(v);
            sz[u] += sz[v];
            if (sz[v] > sz[adj[u][0]]) { swap(v, adj[u][0]); }
        }
    }
    void dfs2(int u) {
        tin[u] = cur++;
        seq[tin[u]] = u;
        for (auto v : adj[u]) {
            top[v] = v == adj[u][0] ? top[u] : v;
            dfs2(v);
        }
        tout[u] = cur - 1;
    }
    int lca(int u, int v) {
        while (top[u] != top[v]) {
            if (dep[top[u]] > dep[top[v]]) {
                u = par[top[u]];
            } else {
                v = par[top[v]];
            }
        }
        return dep[u] < dep[v] ? u : v;
    }
    int dist(int u, int v) { return dep[u] + dep[v] - 2 * dep[lca(u, v)]; }
    int jump(int u, int k) {
        if (dep[u] < k) { return -1; }
        int d = dep[u] - k;
        while (dep[top[u]] > d) { u = par[top[u]]; }
        return seq[tin[u] - dep[u] + d];
    }
    // u is v's ancestor
    bool isAncestor(int u, int v) { return tin[u] <= tin[v] && tin[v] <= tout[u]; }
    // root's parent is itself
    int rootedParent(int r, int u) {
        if (r == u) { return u; }
        if (isAncestor(r, u)) { return par[u]; }
        auto it = upper_bound(adj[u].begin(), adj[u].end(), r, [&](int x, int y) {
            return tin[x] < tin[y];
        }) - 1;
        return *it;
    }
    // rooted at u, v's subtree size
    int rootedSize(int r, int u) {
        if (r == u) { return n; }
        if (isAncestor(u, r)) { return sz[u]; }
        return n - sz[rootedParent(r, u)];
    }
    int rootedLca(int r, int a, int b) { return lca(a, b) ^ lca(a, r) ^ lca(b, r); }
};

template <typename T>
struct Fenwick {
    int n;
    vector<T> a;
    Fenwick(int n = 0) : n(n), a(n) {}
    void add(int p, T v) {
        while (p < n) {
            a[p] += v;
            p |= p + 1;
        }
    }
    T sum(int p) {
        T res = {};
        while (p >= 0) {
            res += a[p];
            p = (p & p + 1) - 1;
        }
        return res;
    }
};

int main() {
    cin.tie(nullptr)->sync_with_stdio(false);
    
    auto solve = [&]() {
        int n, m, q;
        cin >> n >> m >> q;

        vector<array<int, 2>> e(n - 1);
        HLD g(n);
        for (auto &[u, v] : e) {
            cin >> u >> v;
            u--, v--;
            g.addEdge(u, v);
        }

        g.build();
        for (auto &[u, v] : e) {
            if (g.dep[u] < g.dep[v]) {
                swap(u, v);
            }
        }

        vector<array<int, 2>> points(m);
        for (auto &[c, u] : points) {
            cin >> u >> c;
            u--;
            u = e[u][0];
        }
        sort(points.begin(), points.end());

        vector<array<int, 4>> qs(q);
        for (auto &[s, t, x, y] : qs) {
            cin >> s >> t >> x >> y;
            s--, t--;
        }

        vector<int> low(q), high(q, m);

        auto dist = [&](int u, int v, auto &f) {
            return f.sum(g.tin[u]) + f.sum(g.tin[v]) - 2 * f.sum(g.tin[g.lca(u, v)]);
        };

        while (true) {
            bool done = true;
            vector<array<int, 2>> ord;

            for (int i = 0; i < q; i++) {
                if (low[i] < high[i]) {
                    done = false;
                    int mid = (low[i] + high[i] + 1) / 2;
                    ord.push_back({mid, i}); 
                }
            }

            if (done) {
                break;
            }

            sort(ord.begin(), ord.end());
            Fenwick<i64> f(n);
            
            for (int j = 0; auto [mid, i] : ord) {
                while (j < mid) {
                    auto [c, u] = points[j];
                    f.add(g.tin[u], c);
                    f.add(g.tout[u] + 1, -c);
                    j++;
                }
                auto [s, t, x, y] = qs[i];
                if (dist(s, t, f) <= y) {
                    low[i] = mid;
                } else {
                    high[i] = mid - 1;
                }
            }
        }

        vector<int> ord(q);
        iota(ord.begin(), ord.end(), 0);
        sort(ord.begin(), ord.end(), [&](auto i, auto j) { return low[i] < low[j]; });

        vector<int> ans(q);
        Fenwick<int> f(n);

        int j = 0;

        for (auto i : ord) {
            while (j < low[i]) {
                auto [c, u] = points[j];
                f.add(g.tin[u], 1);
                f.add(g.tout[u] + 1, -1);
                j++;
            }
            auto [s, t, x, y] = qs[i];
            ans[i] -= dist(s, t, f);
        }

        while (j < m) {
            auto [c, u] = points[j];
            f.add(g.tin[u], 1);
            f.add(g.tout[u] + 1, -1);
            j++;
        }

        for (int i = 0; i < q; i++) {
            auto [s, t, x, y] = qs[i];
            ans[i] += dist(s, t, f);
            ans[i] = max(-1, x - ans[i]);
        }
        
        for (int i = 0; i < q; i++) {
            cout << ans[i] << '\n';
        }
    };

    solve();

    return 0;
}