#include <iostream>
#include <vector>
using namespace std;

#define int long long
#define pii pair<int, int>
#define ff first
#define ss second

const int MAXM = 6e6 + 5;
const int MAXN = 1e5 + 5;
const int INF = 1e9 + 7;

int n, m, q;
int tot = 0;

int root[MAXN];
vector<int> adj[MAXN];
pii edges[MAXN];
int sz[MAXN], sum[MAXN], lc[MAXN], rc[MAXN];
vector<int> need[MAXN];

int newnode(int u) {
    sz[++tot] = sz[u]; sum[tot] = sum[u]; lc[tot] = lc[u]; rc[tot] = rc[u];
    return tot;
}

void pull(int u) {
    sz[u] = sz[lc[u]] + sz[rc[u]];
    sum[u] = sum[lc[u]] + sum[rc[u]];
}

int upd(int node, int l, int r, int val) {
    int u = newnode(node);

    if(l == r) {
        ++sz[u]; sum[u] += l;
        return u;
    }

    int mid = (l + r) / 2;
    if(val <= mid) lc[u] = upd(lc[node], l, mid, val);
    else rc[u] = upd(rc[node], mid + 1, r, val);
    pull(u); return u;
}

int walk(int u, int v, int lca, int l, int r, int val) {    // binary search builtin to pst
    if(l == r) {
//        cout << "returning " << min(sz[u] + sz[v] - 2 * sz[lca], val / l) << endl;
//        return min(sz[u] + sz[v] - 2 * sz[lca], val / l);

        int ret = sz[u] + sz[v] - 2 * sz[lca];
        
        if(val / l < ret) ret = val / l;
        return ret;
    }

    int lsum = sum[lc[u]] + sum[lc[v]] - 2 * sum[lc[lca]];
    int lsz = sz[lc[u]] + sz[lc[v]] - 2 * sz[lc[lca]];

//    cout << lsum << ", " << lsz << endl;

    int mid = (l + r) / 2;
    if(lsum <= val) {
//        cout << "going into right child" << endl;
        return lsz + walk(rc[u], rc[v], rc[lca], mid + 1, r, val - lsum);
    }
//    cout << "going into left child" << endl;
    return walk(lc[u], lc[v], lc[lca], l, mid, val);
}

int heavy[MAXN], dep[MAXN], subsz[MAXN], par[MAXN];
int head[MAXN];
int timer = 0, tin[MAXN];

void dfssz(int u, int p) {
    dep[u] = dep[p] + 1;
    par[u] = p; subsz[u] = 1;
    for(auto v : adj[u]) {
        if(v == p) continue;
        dfssz(v, u);
        subsz[u] += subsz[v];
    }
}

void hld(int u, int p, int top) {
    // cout << u << " " << p << " " << top << endl;
    head[u] = top;

    int hchild = -1, hsz = -1;

    for(auto v : adj[u]) {
        if(v == p) continue;
        if(subsz[v] > hsz) {
            hsz = subsz[v];
            hchild = v;
        }
    }

    // cout << hchild << " " << hsz << endl;

    if(hchild == -1) return;

    hld(hchild, u, top);
    for(auto v : adj[u]) {
        if(v == p || v == hchild) continue;
        hld(v, u, v);
    }
}

int query(int u, int v) {
    while(head[u] != head[v]) {
        // cout << u << " " << v << endl;
        if(dep[head[u]] < dep[head[v]]) swap(u, v);
        u = par[head[u]];
    }

    if(dep[u] > dep[v]) swap(u, v);
    return u;
}

void dfs(int u, int p) {
//    cout << "node " << u << endl;
    for(auto val : need[u]) {
//        cout << "val: " << val << endl;
        root[u] = upd(root[u], 1, INF, val);
    }

    for(auto v : adj[u]) {
        if(v == p) continue;
        root[v] = root[u];
        dfs(v, u);
    }
}

signed main() {
    cin.tie(0)->sync_with_stdio(false);
    cin >> n >> m >> q;

    for(int i = 1; i < n; ++i) {
        cin >> edges[i].ff >> edges[i].ss;
        adj[edges[i].ff].push_back(edges[i].ss);
        adj[edges[i].ss].push_back(edges[i].ff);
    }

    dfssz(1, 1); hld(1, 1, 1);

    for(int i = 1; i <= m; ++i) {
        int a, b; cin >> a >> b;

        if(edges[a].ss == par[edges[a].ff]) need[edges[a].ff].push_back(b);
        need[edges[a].ss].push_back(b);
    }

    dfs(1, 1);

    while(q--) {
        int u, v, x, y; cin >> u >> v >> x >> y;

        int lca = query(u, v);

//        cout << "lca: " << lca << endl;

        int cost = (sz[root[u]] + sz[root[v]] - 2 * sz[root[lca]]) - walk(root[u], root[v], root[lca], 1, INF, y);
//        cout << "cost: " << cost << endl;
        if(cost > x) cout << -1 << endl;
        else cout << x - cost << endl;
    }
}