#include <bits/stdc++.h>

using i64 = long long;

inline void chkmax(i64 &x, i64 v) {
    x = std::max(x, v);
}

constexpr int N = 100005;

struct cluster {
    int u, v;
    i64 f[4];
};

cluster comp(const cluster& a, const cluster& b) {
    cluster c;
    c.u = a.u;
    c.v = b.v;
    c.f[0] = std::max({a.f[0], b.f[0], a.f[2] + b.f[1]});
    c.f[1] = std::max(a.f[1], a.f[3] + b.f[1]);
    c.f[2] = std::max(b.f[2], b.f[3] + a.f[2]);
    c.f[3] = a.f[3] + b.f[3];
    return c;
}

cluster rake(const cluster& a, const cluster& b) {
    cluster c;
    c.u = a.u;
    c.v = a.v;
    c.f[0] = std::max({a.f[0], b.f[0], a.f[1] + b.f[1]});
    c.f[1] = std::max(a.f[1], b.f[1]);
    c.f[2] = std::max(a.f[2], a.f[3] + b.f[1]);
    c.f[3] = a.f[3];
    return c;
}

struct node {
    int tp, ls, rs, fa, sz;
    cluster vl;
    node() : tp(-1), ls(0), rs(0), fa(0), sz(1) {}
}ttree[N << 1];

#define tp(p) ttree[p].tp
#define ls(p) ttree[p].ls
#define rs(p) ttree[p].rs
#define fa(p) ttree[p].fa
#define sz(p) ttree[p].sz
#define vl(p) ttree[p].vl

inline void pushup(int p) {
    // assert(~tp(p));
    if (tp(p)) 
        vl(p) = comp(vl(ls(p)), vl(rs(p)));
    else 
        vl(p) = rake(vl(ls(p)), vl(rs(p)));
}

int n, q, W, tot;
std::vector<int> t[N];

int siz[N], son[N], dep[N], fa[N];
void dfs(int u) {
    siz[u] = 1;
    for (int v : t[u]) {
        if (v == fa[u]) 
            continue;
        fa[v] = u;
        dep[v] = dep[u] + 1;
        dfs(v);
        siz[u] += siz[v];
        if (siz[v] > siz[son[u]]) 
            son[u] = v;
    }
}

int merge(std::vector<int> cid, int type) {
    if (cid.size() == 1u) 
        return *cid.begin();
    int sum = 0, csum = 0;
    for (const int i : cid) 
        sum += sz(i);
    csum = sz(cid[0]);
    auto mid = std::next(cid.begin());
    while (csum + sz(*mid) <= (sum >> 1))
        csum += sz(*mid++);
    int cur = ++tot;
    tp(cur) = type;
    fa(ls(cur) = merge(std::vector<int>(cid.begin(), mid), type)) = cur;
    fa(rs(cur) = merge(std::vector<int>(mid, cid.end()), type)) = cur;
    pushup(cur);
    return cur;
}

int _build(int u, int utp, std::vector<int> &vec) {
    if (!son[u]) return u;
    std::vector<int> cid;
    cid.push_back(son[u]);
    for (const int &v : t[u]) {
        if (v == fa[u] || v == son[u])
            continue;
        std::vector<int> tmp;
        tmp.push_back(v);
        cid.push_back(_build(v, v, tmp));
    }
    vec.push_back(merge(cid, 0));
    if (son[u]) _build(son[u], utp, vec);
    if (u == utp) 
        return merge(vec, 1);
    return 0;
}

int rt;

inline void build(int tree_rt) {
    dfs(tree_rt);
    std::vector<int> tmp;
    tot = n;
    rt = _build(tree_rt, tree_rt, tmp);
}

void update(int x) {
    assert(x <= tot);
    if (x != rt) {
        assert(x);
        pushup(fa(x)), update(fa(x));
    }
}

std::map<std::pair<int, int>, int> id;
int tid[N];
i64 w[N];

int main() {
    std::cin.tie(0)->sync_with_stdio(0);
    std::cin >> n >> q >> W;
    for (int i = 1, u, v; i <= n - 1; i++) {
        std::cin >> u >> v >> w[i];
        id[{u, v}] = id[{v, u}] = i;
        t[u].push_back(v), t[v].push_back(u);
    }
    build(1);
    assert(!fa(rt));
    // out(rt);
    for (int i = 2; i <= n; i++) {
        tid[id[{i, fa[i]}]] = i;
        std::fill(vl(i).f, vl(i).f + 4, w[id[{i, fa[i]}]]);
        update(i);
    }
    // std::cout << vl(rt).f[0] << '\n';
    int d;
    i64 las = 0, e;
    while (q--) {
        std::cin >> d >> e;
        d = (las + d) % (n - 1) + 1;
        e = (las + e) % W;
        d = tid[d];
        assert(d);
        std::fill(vl(d).f, vl(d).f + 4, e);
        update(d);
        std::cout << (las = vl(rt).f[0]) << '\n';
    }
}