/**
 *
 * Nume: Valentin GOSU
 * Grupa: 322CA 
 * Email: [email protected]
 * 
 */

 
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>

typedef void *T;

/* Structura heap-ului */ 
struct heap_s {
    int size;
    int capacity;
    T *data;
};

typedef struct heap_s *Heap;

/*
 * Functia H_New creaza un heap nou cu capacitatea 'max'
 *  aloca memorie pentru el, si returneaza adresa lui
 */
Heap H_New(int max)
{
    Heap heap;
    assert(max > 0);
    heap = (struct heap_s *) malloc(sizeof(struct heap_s));
    heap->size = 0;
    heap->capacity = max;
    heap->data = (T*)malloc((heap->capacity) * sizeof(T));
    return heap;
}

/*
 * Functia elibereaza memoria folosita de heap.
 */
void H_Delete(Heap heap)
{
    assert(heap);
    heap->capacity = 0;
    heap->size = 0;
    if (heap->data) /* este posibil ca vectorul sa nu fie alocat */
        free(heap->data); 
    free(heap);
}

/* Returneaza 1 daca heapul este gol si 0 daca contine elemente */
int H_Empty(Heap heap)
{
    assert(heap);
    return heap->size == 0;
}

/* Returneaza 1 daca heapul a atins capacitatea maxima */
int H_Full(Heap heap)
{
    assert(heap);
    return heap->size == heap->capacity;
}

/* Returneaza primul element din heap */
T H_FindMin(Heap heap)
{
    assert(heap);
    assert(heap->size > 0);
    return heap->data[0];
}

static void H_Down(Heap h, int p, int (*compare) (T x, T y));
static void H_Up(Heap h, int p, int (*compare) (T x, T y));

/* Sterge primul element din heap si actualizeaza heapul */
void H_RemoveMin(Heap heap, int compare(T x, T y))
{
    T x;
    assert(heap);
    assert(heap->size > 0);
    assert(compare);
    x = heap->data[0];
    heap->data[0] = heap->data[--heap->size];
    H_Down(heap, 0, compare);
}

/* Insereaza un element in heap */
void H_Insert(Heap * heap, T key, int compare(T x, T y))
{
    int i, capacity;
    assert(heap);
    assert(*heap);
    assert((*heap)->size >= 0);
    if ((*heap)->size == (*heap)->capacity) {

        T *data;
        capacity = (*heap)->capacity;
        data = (*heap)->data;
        (*heap)->data = NULL;
        H_Delete(*heap);
        *heap = H_New(capacity*2);
        (*heap)->size = capacity;
        for (i = 0; i < (*heap)->size; i++)
            (*heap)->data[i] = data[i];
        assert(data);
        free(data);

    }
    (*heap)->data[(*heap)->size++] = key;
    H_Up(*heap, (*heap)->size - 1, compare);
}

/* Returneaza numarul de elemente din heap */
int H_Size(Heap heap)
{
    assert(heap);
    return heap->size;
}

/* Returneaza capacitatea heapului */
int H_Capacity(Heap heap)
{
    assert(heap);
    return heap->capacity;
}

/* Functia Coboara elementul din pozitia p si actualizeaza heapul */
static void H_Down(Heap h, int p, int (*compare) (T x, T y))
{
    int fiu;
    T t;
    while (2 * p + 1 < h->size) {
        fiu = 2 * p + 1;
        if (fiu + 1 < h->size && compare(h->data[fiu], h->data[fiu
                                                               + 1]) > 0) {
            fiu++;
        }
        if (compare(h->data[fiu], h->data[p]) < 0) {
            t = h->data[p];
            h->data[p] = h->data[fiu];
            h->data[fiu] = t;
            p = fiu;
        } else {
            break;
        }
    }
}

/* Functia Urca elementul din pozitia p si actualizeaza heapul */
static void H_Up(Heap h, int p, int (*compare) (T x, T y))
{
    T aux;

    if (p == 0)
        return;

    while (p > 0
           && (compare(h->data[p], h->data[(p - 1) / 2]) <
               0)) {
        aux = h->data[p];
        h->data[p] = h->data[(p - 1) / 2];
        h->data[(p - 1) / 2] = aux;

        p = (p - 1) / 2;
    }
}


 int N,H,U; 
 
 /* Structura ce memoreaza inaltimea si greutatea unei gutui */
 typedef struct {
 	int h;
 	int g;
 	} gutuie;
 

void merge(int, int, int, gutuie*);
void msort(int, int, gutuie*);
void mergesort(int n, gutuie *x){ msort(0, n-1, x); }

void msort(int i, int j, gutuie *x){
   if(i<j){
      int k=(i+j)/2;
      msort(i, k, x);
      msort(k+1, j, x);
      merge(i, k+1, j, x);
   }
}
void merge(int p, int q, int r, gutuie *x){
   int i=p, j=q, k=0;
   gutuie *y = (gutuie*)malloc((r-p+1)*sizeof(gutuie));
   while(i<q && j<=r)
	  /* Se sorteaza elementele dupa nivelul pe care se afla (H-v[i].h)/U
	     iar pe fiecare nivel gutuile sunt sortate dupa descrescator dupa greutate */
      if((H-x[i].h)/U < (H-x[j].h)/U  || ((H-x[i].h)/U == (H-x[j].h)/U && x[i].g>x[j].g ))
         y[k++] = x[i++];
      else
         y[k++] =x[j++];
   while(i < q)
      y[k++] = x[i++];
   while(j <= r)
      y[k++] = x[j++] ;
   for(i=p; i<=r; i++)
      x[i] = y[i-p];
   free(y);
}

 /* Functia de comparatie */
 int comp(T a, T b) {
 	return *(int*)a - *(int*)b;
 	}
 
 
 int main() {
 	FILE * f;
 	FILE * g;
 	f=fopen( "gutui.in","r"); /* Fisierul de intrare */
 	g=fopen("gutui.out","w"); /* Fisierul de iesire */
	
	/* Se citesc valorile N, H si U din fisier */
 	fscanf(f,"%d %d %d",&N,&H,&U);
 	int i;
 	gutuie v[N]; /* Vectorul de valori */
 	
	/* Se citesc valorile din fisier */
	for (i=0;i<N;i++) {
 		int a,b;
 		fscanf(f,"%d %d",&a,&b);
		/* Se ignora gutuile ce depasesc valoarea H */
 		if (a<=H) {
 			v[i].h=a;
 			v[i].g=b;
 		} else {
 			N--;
 			i--;
 			continue;
 			}
 		}
 	
 	/* Se sorteaza elementele dupa nivelul pe care se afla (H-v[i].h)/U
	iar pe fiecare nivel gutuile sunt sortate dupa descrescator dupa greutate */
    mergesort(N,v);
 	
	/* Se foloseste un heap, de dimensiune maxima N, pentru a sorta
	   gutuile culese dupa greutate */
 	Heap heap = H_New(N);
 	
	/* niv reprezinta nivelul curent in cadrul parcurgerii,
	   iar count reprezinta numarul de gutui care mai trebuie culese
	   de pe nivelul respectiv */
 	int niv=(H-v[0].h)/U; 
	int count=niv; /* De pe fiecare nivel se culeg maxim niv gutui */
	
 	for (i=0;i<N;i++) 
 		if ( (H-v[i].h)/U == niv ) {
			/* Se introduc elemente in heap */
 			if ( H_Size(heap) < niv+1 ) {
 				H_Insert(&heap,&v[i].g,comp);
 				count--;
 				continue;
 				}
			/* Daca heapul a atins dimensiunea maxima pentru nivelul respectiv
			   atunci se verifica elementul cu cea mai mica greutate din heap.
			   Daca elementul din heap este mai mic, este inlocuit de v[i].g */
 			if ( H_Size(heap)==niv+1 && count>=0)
 				if (*(int*)H_FindMin(heap)<v[i].g) {
 					H_RemoveMin(heap,comp);
 					H_Insert(&heap,&v[i].g,comp);
 					count--;
 					continue;
 					}
			/* Daca nu mai pot fi culese gutui de pe nivelul respectiv, 
			   se incrementeaza niv */
 			if (count<0) {
 				niv++;
 				count=niv;
 				}
 			} else if ( (H-v[i].h)/U > niv ) {
				/* Daca nivelul elementului curent este mai mare decat 'niv',
				   'niv' este actualizat, si se verifica din nou v[i] */
 				niv = (H-v[i].h)/U;
 				count=niv;
 				i--;
 				continue;
 				}
	
	/* Se extrag elemente din heap si se adauga la suma */
 	int suma=0;			 				
 	while ( H_Size(heap)>0) {
 		suma+=*((int*)H_FindMin(heap));
 		H_RemoveMin(heap,comp);
 		}
	/* Se scrie suma in fisier */
 	fprintf(g,"%d\n",suma);
 	fclose(g);
 	return 0;
 	}