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

// clang-format off

using ll = long long;
#define sz(x) (int)x.size()

#ifdef DEBUG
    #include "debug.hpp"
#else
    #define dbg(x...) 0
#endif

// clang-format on

int mod;
vector<int> pw10;
int add(ll a, ll b) { return (a + b) % mod; }
int mul(ll a, ll b) { return (a * b) % mod; }

int combine(int x, int y, int len) {
  x = mul(x, pw10[len]);
  x = add(x, y);
  return x;
}

using Graph = vector<vector<int>>;
class Lift {
  int max_pow;
  vector<int> depth;
  vector<vector<int>> up;
  vector<vector<int>> num_up;
  vector<vector<int>> num_down;

  void dfs(int cur_node, int par, vector<int> &val, Graph &adj) {
    up[0][cur_node] = par;
    num_up[0][cur_node] = val[cur_node];
    num_down[0][cur_node] = val[cur_node];

    for (auto child : adj[cur_node]) {
      if (child == par) continue;

      depth[child] = depth[cur_node] + 1;
      dfs(child, cur_node, val, adj);
    }
  }

 public:
  Lift(Graph &G, vector<int> &val)
      : max_pow(31 - __builtin_clz(G.size()) + 1),
        depth(G.size()),
        up(max_pow, vector<int>(G.size(), -1)),
        num_up(max_pow, vector<int>(G.size())),
        num_down(max_pow, vector<int>(G.size())) {
    dfs(0, -1, val, G);

    for (size_t x = 1; x < up.size(); x++) {
      for (size_t i = 0; i < G.size(); i++) {
        int mid = up[x - 1][i];

        if (mid != -1 && up[x - 1][mid] != -1) {
          up[x][i] = up[x - 1][mid];

          num_up[x][i] =
              combine(num_up[x - 1][i], num_up[x - 1][mid], (1 << (x - 1)));
          num_down[x][i] =
              combine(num_down[x - 1][mid], num_down[x - 1][i], (1 << (x - 1)));
        }
      }
    }
    num_up[0][0] = val[0];
    num_down[0][0] = val[0];
  }

  int walk(int node, int dist) const {
    for (int i = 0; i < max_pow && node != -1; i++) {
      if ((dist >> i) & 1) node = up[i][node];
    }
    return node;
  }

  int lca(int node1, int node2) const {
    if (depth[node1] < depth[node2]) swap(node1, node2);

    int diff = depth[node1] - depth[node2];
    node1 = walk(node1, diff);
    if (node1 == node2) return node1;

    for (int i = max_pow - 1; i >= 0; i--) {
      if (up[i][node1] != up[i][node2]) {
        node1 = up[i][node1];
        node2 = up[i][node2];
      }
    }
    return up[0][node1];
  }

  int query(int node1, int node2) {
    int l = lca(node1, node2);

    int ans = 0, len = 0;

    // 1. go up from a till the lca
    int dist = depth[node1] - depth[l];
    for (int i = 0; i < max_pow; i++) {
      if ((dist >> i) & 1) {
        ans = combine(ans, num_up[i][node1], (1 << i));
        node1 = up[i][node1];
      }
    }
    assert(node1 == l);

    // but we also need to include the value at the lca itself
    // so we need to go one above the lca also
    ans = add(mul(ans, 10), num_up[0][l]);

    // 2. down from lca to b
    int ans2 = 0;
    len = 0;
    dist = depth[node2] - depth[l];
    for (int i = 0; i < max_pow; i++) {
      if ((dist >> i) & 1) {
        ans2 = combine(num_down[i][node2], ans2, len);
        len += (1 << i);
        node2 = up[i][node2];
      }
    }
    assert(node2 == l);

    ans = combine(ans, ans2, len);
    return ans;
  }
};

void solve() {
  int n, q;
  cin >> n >> mod >> q;

  pw10.assign(n + 1, 0);
  pw10[0] = 1 % mod;
  for (int i = 1; i <= n; i++) {
    pw10[i] = mul(pw10[i - 1], 10);
  }

  Graph adj(n);
  for (int i = 1; i <= n - 1; i++) {
    int a, b;
    cin >> a >> b;
    a--, b--;
    adj[a].push_back(b);
    adj[b].push_back(a);
  }

  vector<int> val(n);
  for (auto &x : val) {
    cin >> x;
    x %= mod;
  }

  Lift l(adj, val);
  while (q--) {
    int u, v;
    cin >> u >> v;
    u--, v--;
    cout << l.query(u, v) << "\n";
  }
}

signed main() {
  cin.tie(nullptr)->sync_with_stdio(false);
  int T = 1;
  while (T--) solve();
  return 0;
}