#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

// A maximális városok száma a korlátok alapján 20000 [cite: 11]
const int MAXN = 20005;

int W[MAXN];                // W[i]: Az i. városban aktuálisan lévő alkatrészek száma
vector<int> adj[MAXN];      // Szomszédsági lista (szülő -> gyermekek)
int P[MAXN];                // P[i]: A maximálisan elhozható alkatrészek száma az i. csomópont alatti legjobb úton
int best_child[MAXN];       // best_child[i]: Melyik gyermek felé vezet a legértékesebb ág

int main() {
    // Gyorsított I/O a szigorú 0.2 mp-es időlimit miatt [cite: 41]
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);

    int N, K, C;
    if (!(cin >> N >> K >> C)) return 0;

    for (int i = 1; i <= N; ++i) {
        int parent, parts;
        cin >> parent >> parts;
        W[i] = parts; // i. városból elszállítandó alkatrészek [cite: 14]
        
        // Az 1-es város a központi raktár, a 0 0 bemenetet nem fűzzük a fába 
        if (parent != 0) {
            adj[parent].push_back(i);
        }
    }

    // Topologikus sorrend (alulról felfelé) építése BFS-szerűen,
    // hogy elkerüljük a rekurziót és biztonságosan a 32 MB alatt maradjunk [cite: 42]
    vector<int> q;
    q.reserve(N);
    q.push_back(1);
    int head = 0;
    while (head < (int)q.size()) {
        int u = q[head++];
        for (int v : adj[u]) {
            q.push_back(v);
        }
    }

    // Megfordítjuk a sorrendet: így biztosan a leveleket (gyermekeket) 
    // dolgozzuk fel hamarabb, mint a szülőket
    vector<int> order = q;
    reverse(order.begin(), order.end());

    long long total_collected = 0;

    // A folyamatot legfeljebb K kamionnal tudjuk elvégezni [cite: 17]
    for (int k = 0; k < K; ++k) {
        
        // 1. LÉPÉS: A legjobb aktuális út kiszámítása alulról felfelé
        for (int u : order) {
            int mx = 0;
            int bc = 0;
            for (int v : adj[u]) {
                if (P[v] > mx) {
                    mx = P[v];
                    bc = v;
                }
            }
            P[u] = W[u] + mx;
            best_child[u] = bc;
        }

        // A fa gyökerében lévő P[1] érték mutatja a legjobb utat.
        // A kamion azonban legfeljebb C kapacitásnyit vihet el.
        int collected_this_truck = min(C, P[1]);
        if (collected_this_truck == 0) {
            break; // Nincs több maradék elszállítható alkatrész a fában
        }
        
        total_collected += collected_this_truck;

        // 2. LÉPÉS: Visszakövetjük a legjövedelmezőbb utat a levelek felé
        int curr = 1;
        vector<int> path;
        while (curr != 0) {
            path.push_back(curr);
            curr = best_child[curr];
        }

        // 3. LÉPÉS: Kapacitás kitöltése LENTRŐL FELFELÉ
        // Ha mélyről szedjük fel először, a magasabban lévő kapacitások 
        // a többi ágról érkező kamionnak is megmaradnak.
        int needed = C;
        for (int i = (int)path.size() - 1; i >= 0; --i) {
            int u = path[i];
            int take = min(needed, W[u]);
            W[u] -= take;
            needed -= take;
            if (needed == 0) break;
        }
    }

    // A legjobb esetben összesen elszállítható mennyiség [cite: 9]
    cout << total_collected << "\n";

    return 0;
}