#include<iostream>
#include<cstring>
#include<vector>
#include<array>
#include<algorithm>
using namespace std;
using LL = long long;
const int maxn = 2e5 + 5, INF = 1e9;
int p[maxn], w[maxn], id[maxn];
int n, m, c;
vector<int> g[maxn];
array<int, 3> st[maxn];

struct Node{
    int l, r, v;

}tr[maxn * 32];
int root[maxn];
int idx;

void modify(int &now, int pre, int l, int r, int x, int v){
    tr[now = ++idx] = tr[pre];
    if (l == r){
        tr[now].v = v;
        return;
    }
    int mid = (l + r) / 2;
    if (x <= mid) modify(tr[now].l, tr[pre].l, l, mid, x, v);
    else modify(tr[now].r, tr[pre].r, mid + 1, r, x, v);
    tr[now].v = min(tr[tr[now].l].v, tr[tr[now].r].v);
}

// 找到第一个<= dep的位置
int find_first(int u, int l, int r, int v){
    if (tr[u].v >= v) return r + 1;
    if (l == r) return r;
    int mid = (l + r) / 2;
    if (tr[tr[u].l].v <= v) return find_first(tr[u].l, l, mid, v);
    return find_first(tr[u].r, mid + 1, r, v);
}

int query(int u, int l, int r, int L, int R){
    if (l > R or r < L) return INF;
    if (l >= L and r <= R) return tr[u].v;
    int mid = (l + r) / 2;
    return min(query(tr[u].l, l, mid, L, R), query(tr[u].r, mid + 1, r, L, R));
}

int dep[maxn], fa[20][maxn], f1[maxn], f2[maxn];
vector<int> query1[maxn], query2[maxn];

void dfs1(int u){
    if (fa[0][u]){
        g[u].erase(find(g[u].begin(), g[u].end(), fa[0][u]));
    }
    for(auto j : g[u]){
        if (j == fa[0][u]) continue;
        fa[0][j] = u;
        dep[j] = dep[u] + 1;
        dfs1(j);
    }
}

int lca(int x, int y){
    if (dep[x] < dep[y]) swap(x, y);
    for(int i = 19; i >= 0; i--){
        if (dep[fa[i][x]] >= dep[y]){
            x = fa[i][x];
        }
    }
    if (x == y) return x;
    for(int i = 19; i >= 0; i--){
        if (fa[i][x] != fa[i][y]){
            x = fa[i][x];
            y = fa[i][y];
        }
    }
    return fa[0][x];
}

vector<int> last[maxn];

void dfs2(int u){
    last[w[u]].push_back(u);
    if (id[w[u]] != 0){
        if (id[w[u]] == c){
            modify(root[u], 0, 1, c, id[w[u]], dep[u]);
        }
        else{
            int color = p[id[w[u]] + 1];
            int pre = 0;
            if (!last[color].empty()){
                pre = last[color].back();
            }
            modify(root[u], root[pre], 1, c, id[w[u]], dep[u]);
        }
    } 

    if (!last[p[1]].empty()){
        int t = last[p[1]].back();
        for(auto id : query1[u]){
            f1[id] = find_first(root[t], 1, c, dep[st[id][2]]) - 1;
        }
    }

    for(auto j : g[u]){
        dfs2(j);
    }
    last[w[u]].pop_back();
}

void dfs3(int u){
    last[w[u]].push_back(u);
    if (id[w[u]] != 0){
        if (id[w[u]] == 1){
            modify(root[u], 0, 1, c, id[w[u]], dep[u]);
        }
        else{
            int color = p[id[w[u]] - 1];
            int pre = 0;
            if (!last[color].empty()){
                pre = last[color].back();
            }
            modify(root[u], root[pre], 1, c, id[w[u]], dep[u]);
        }
    } 
    for(auto id : query2[u]){
        auto [a, b, anc] = st[id];
        if (b == anc){
            f2[id] = f1[id];
        }
        else{

            auto check = [&](int mid){
                if (last[p[mid]].empty()) return false;
                int t = last[p[mid]].back();
                return query(root[t], 1, c, f1[id] + 1, mid) > dep[anc];
            };

            int l = f1[id], r = c;
            while(l < r){
                int mid = (l + r + 1) / 2;
                if (check(mid)) l = mid;
                else r = mid - 1;
            }
            f2[id] = r;
        }
    }
    for(auto j : g[u]){
        dfs3(j);
    }
    last[w[u]].pop_back();
}

int main(){

#ifdef LOCAL
    freopen("data.in", "r", stdin);
    freopen("data.out", "w", stdout);
#endif

    cin.tie(0);
    cout.tie(0);
    ios::sync_with_stdio(0);

    cin >> n >> m >> c;
    for(int i = 1; i <= c; i++){
        cin >> p[i];
        id[p[i]] = i;
    }
    for(int i = 1; i <= n; i++) cin >> w[i];
    for(int i = 0; i < n - 1; i++){
        int a, b;
        cin >> a >> b;
        g[a].push_back(b);
        g[b].push_back(a);
    }
    dep[1] = 1;
    dfs1(1);
    for(int i = 1; i <= 19; i++){
        for(int j = 1; j <= n; j++){
            fa[i][j] = fa[i - 1][fa[i - 1][j]];
        }
    }
    int q;
    cin >> q;
    for(int i = 1; i <= q; i++){
        int s, t;
        cin >> s >> t;
        int anc = lca(s, t);
        st[i] = {s, t, anc};
        query1[s].push_back(i);
        query2[t].push_back(i);
    }
    dfs2(1);
    for(int i = 1; i <= idx; i++){
        tr[i] = Node();
    }
    idx = 0;
    dfs3(1);
    for(int i = 1; i <= q; i++){
        cout << f2[i] << '\n';
    }

}