#include <iostream>
#include <vector>
#include <queue>
#include <fstream>

struct Varos {
    int db;
    std::vector<int> le;
    std::priority_queue<int> le_db;
};

using Graf = std::vector<Varos>;

void beolvas(int &k, int &c, Graf &g, std::istream &be = std::cin) {
    int n;
    be >> n >> k >> c;

    g.resize(n + 1);
    for (int i = 1; i <= n; i++) {
        int fel, db;

        be >> fel >> db;
        g[i].db = db;
        g[fel].le.push_back(i);
    }
}

int melysegi(int akt, int c, Graf &g) {
    if (g[akt].le.empty()) {
        g[akt].le_db.push(g[akt].db % c);
        return g[akt].db / c;
    }

    int tele = 0;
    for (const int le : g[akt].le) {
        tele += melysegi(le, c, g);
    }

    std::priority_queue<int> s;
    for (const int le : g[akt].le) {
        if (g[le].le_db.size() > s.size()) {
            g[le].le_db.swap(s);
        }

        while (!g[le].le_db.empty()) {
            s.push(g[le].le_db.top());
            g[le].le_db.pop();
        }
    }

    int akt_db = g[akt].db;
    while (!s.empty()) {
        const int le_db = s.top();
        s.pop();

        if (akt_db + le_db >= c) {
            tele++;
            akt_db -= c - le_db;
        } else {
            s.push(akt_db + le_db);
            akt_db = 0;
            break;
        }
    }

    tele += akt_db / c;
    akt_db %= c;
    if (akt_db > 0) {
        s.push(akt_db);
    }

    g[akt].le_db = std::move(s);

    return tele;
}

int max_szallithato(int k, int c, Graf &g) {
    const auto tele = melysegi(1, c, g);

    if (tele >= k) {
        return k * c;
    }

    int sz = tele * c;
    k -= tele;

    auto &le_db = g[1].le_db;
    while (k > 0 && !le_db.empty()) {
        sz += le_db.top();
        le_db.pop();
        k--;
    }

    return sz;
}

int main() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int k, c;
    Graf g;
    beolvas(k, c, g);

    std::cout << max_szallithato(k, c, g) << '\n';

    return 0;
}