/* université pierre et marie curie - christoph dürr et antoine roux - 2017
   http://www-desir.lip6.fr/~durrc/Iut/cpa/tme6-arbresegments/

   Arbre de Segments
*/

import java.util.Scanner;
import java.util.Arrays;

class SegmentTree {
    /* structure de donnée qui permet
       de maintenir un tableau de taille n pour
       demander en temps O(log n) le maximum entre t[left],...,t[right-1]
       et ajouter une valeur val à t[left],...,t[right-1].
    */

    int N;
    int lazyadd[], maxval[];

    SegmentTree(int n) {  // pour les indices de 0 à n-1
        N = 1;
        while (N <= n)    // trouver première puissance de n assez grande
            N *= 2;
        lazyadd = new int[2 * N];
        maxval  = new int[2 * N];
    }

    SegmentTree(int tab[]) { // initier avec un tableau de départ
        this(tab.length);    // complexité: O(N)
        int i;
        for (i = 0; i < tab.length; i++)    // recopier tableau
            maxval[N + i] = lazyadd[N + i] = tab[i];
        for(i = N - 1; i > 0; i--)          // établir l'invariant
            maxval[i] = Math.max(maxval[2*i], maxval[2*i + 1]);
    }

    void addval(int i, int left_i, int right_i, int left, int right, int val) {
        /* ajoute la valeur val aux indices dans l'intersection de
        [left_i, right_i) et de [left, right)
        */
        if (right <= left_i || right_i <= left)   // cas disjoint
            return;
        if (left <= left_i && right_i <= right) { // cas inclus
            lazyadd[i] += val;
            maxval[i]  += val;
        }
        else {
            int mid = (left_i + right_i) / 2;     // demander aux fils
            addval(2*i,     left_i, mid,     left, right, val);
            addval(2*i + 1, mid,    right_i, left, right, val);
            //                                    // maintenir invariant
            maxval[i] = Math.max(maxval[2*i], maxval[2*i + 1]) + lazyadd[i];
        }
    }

    void addval(int left, int right, int val) {
        addval(1, 0, N, left, right, val);        // initier appels récursifs
    }

    int getmax(int i, int left_i, int right_i, int left, int right) {
        /* retourne le maximum des valeurs aux indices dans l'intersection de
        [left_i, right_i) et de [left, right)
        */
        if (right_i <= left || right <= left_i )  // cas disjoint
            return Integer.MIN_VALUE;
        if (left <= left_i && right_i <= right)   // cas inclus
            return maxval[i];
        else {
            int mid = (left_i + right_i) / 2;     // demander aux fils
            int x = getmax(2*i,    left_i, mid,     left, right);
            int y = getmax(2*i+1,  mid,    right_i, left, right);
            return Math.max(x, y) + lazyadd[i];
        }
    }

    int getmax(int left, int right) {
        return getmax(1, 0, N, left, right);      // initier appels récursifs
    }

    public static void main(String[] args) {      // petite interface de test
        SegmentTree T = new SegmentTree(10);
        Scanner in = new Scanner(System.in);
        int left, right, val;
        while (true) {
            System.out.print(">");
            Scanner line = new Scanner(in.nextLine());
            switch(line.next()) {
            case "max":
                left = line.nextInt();
                right = line.nextInt();
                System.out.println(T.getmax(left, right));
                break;
            case "add":
                left = line.nextInt();
                right = line.nextInt();
                val = line.nextInt();
                T.addval(left, right, val);
                break;
            case "?":
                // for (int i = 0; i < T.N; i++)
                //     System.out.print(T.getmax(i, i+1) + " ");
                // System.out.println();
                System.out.println(Arrays.toString(T.lazyadd));
                System.out.println(Arrays.toString(T.maxval));
                break;
            default:
                System.out.println("Syntax error");
            }
        }
    }
}

/*
On maintient un tableau de réservations tab,
tel que tab[j]=nombre agents utilisés pendant le jour j.
Pour une demande (xi, wi, hi) on doit vérifier si
max(tab[xi],...,tab[xi+wi-1]) + hi <= H.
Dans le cas positif, on doit ajouter hi à
tab[xi],...,tab[xi+wi-1].

complexité: O(n log W)
*/
class Interim {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int reponse = 0;
        int n, width, height;
        n      = in.nextInt();
        width  = in.nextInt();
        height = in.nextInt();
        SegmentTree T = new SegmentTree(width + 1);
        while (n --> 0) {                               // complexité: n fois
            int xi, wi, hi;
            xi = in.nextInt();
            wi = in.nextInt();
            hi = in.nextInt();
            if (height - T.getmax(xi, xi + wi) >= hi) { // complexité: log(W)
                reponse++;                              // on peut réserver
                T.addval(xi, xi + wi, hi);              // complexité: log(W)
            }
        }
        System.out.println(reponse);
    }
}

/* Soit dispo[j] l'argent disponible à la fin du jour j.
Initialement dispo[j] = j * R
On on peut honorer une facture (di, fi) si min(dispo[di],...,dispo[T]) >= fi.
Dans le cas positif, on décrémente dispo[di],...,dispo[T] de fi.
On veut re-utiliser sans modification l'arbre de segment avec l'opération max.
Alors on introduit tab avec tab[j] = - dispo[j]. Et min devient max.

complexité: O(T + n log T).
*/
class Factures {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int reponse = 0;
        int n, T, R;
        n = in.nextInt();
        T = in.nextInt();
        R = in.nextInt();
        int tab[] = new int[T+1];
        for (int i = 0; i <= T; i++)     // tab[i] = - argent disponible jour i
            tab[i] = -i * R;
        SegmentTree A = new SegmentTree(tab); // complexité: O(T)
        while (n --> 0) {                     // complexité: n fois
            int di, fi;
            di = in.nextInt();
            fi = in.nextInt();
            if (A.getmax(di, T+1) <= - fi) {  // complexité: O(log T)
                reponse++;
                A.addval(di, T+1, fi);        // complexité: O(log T)
            }
        }
        System.out.println(reponse);
    }
}