#include <bits/stdc++.h>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/assoc_container.hpp>

#define el '\n'
#define Morsi ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
using namespace std;
using namespace __gnu_pbds;

template<typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
// order_of_key ------> return index
// find_by_order -----> use index


const int mod = 1e9 + 7, N = 1e5 + 10, SQ = 150;
int n, m, q, ancestor[N][20], sparseDown[N][20], sparseUp[N][20], in[N], out[N], timer = 0;
int pw[N];
vector<int> adj[N];

int mul(long long x, long long y){
    return (x * y) % m;
}

int add(long long x, long long y){
    return (x + y) % m;
}

int Concatenate(int x, int y, int length){
    x = mul(x , pw[length]);
    x = add(x , y);
    return x;
}

void dfs(int node, int parent){
    in[node] = timer++;
    ancestor[node][0] = parent;

    //compute ancestor and sparse
    for(int i = 1; i <= 18; i++){
        int prev = ancestor[node][i - 1];
        ancestor[node][i] = ancestor[prev][i - 1];
        sparseUp[node][i] = Concatenate(sparseUp[node][i - 1], sparseUp[prev][i - 1], (1 << (i - 1)));
        sparseDown[node][i] = Concatenate(sparseDown[prev][i - 1], sparseDown[node][i - 1], (1 << (i - 1)));
    }

    for(auto i : adj[node])
        if(i != parent)
            dfs(i, node);

    out[node] = timer++;
}

bool Subtree(int parent, int child){
    return in[parent] <= in[child] && out[parent] >= out[child];
}

int LCA(int u, int v){
    if(Subtree(u, v))
        return u;

    if(Subtree(v, u))
        return v;

    for(int i = 18; i >= 0; i--)
        if(!Subtree(ancestor[u][i], v))
            u = ancestor[u][i];
    
    return ancestor[u][0];
}

int Get(int a, int b){
    int lca = LCA(a, b);

    int ret = 0;

    for(int i = 18; i >= 0; i--)
        if(!Subtree(ancestor[a][i], lca)){
            ret = Concatenate(ret, sparseUp[a][i], (1 << i));
            a = ancestor[a][i];
        }
    if(a != lca)
      ret = Concatenate(ret, sparseUp[a][0], 1);

    stack<pair<int, int>> st;
    for(int i = 18; i >= 0; i--)
        if(!Subtree(ancestor[b][i], lca)){
            st.push({sparseDown[b][i], (1 << i)});
            b = ancestor[b][i];
        }
    if(b != lca)
        st.push({sparseDown[b][0], 1});

    ret = Concatenate(ret, sparseUp[lca][0], 1);
    
    while(!st.empty()){
        ret = Concatenate(ret, st.top().first, st.top().second);
        st.pop();
    }

    return ret;
}

void alg() {
    cin >> n >> m >> q;
    pw[0] = 1 % m;

    for(int i = 1; i < N; i++)
        pw[i] = mul(pw[i - 1], 10);

    for(int i = 0; i < n - 1; i++){
        int u, v;
        cin >> u >> v;
        adj[u].push_back(v);
        adj[v].push_back(u);
    }

    for(int i = 1; i <= n; i++){
        cin >> sparseDown[i][0];
        sparseUp[i][0] = sparseDown[i][0];
    }

    dfs(1, 1);
    while(q--){
        int a, b;
        cin >> a >> b;
        cout << Get(a, b) << el;
    }
}

int main()
{
    Morsi
    int t = 1;
    while(t--){
        alg();
    }
    return 0;
}