#include <stdio.h>
#include <malloc.h>

const char *fin="gutui.in";
const char *fout="gutui.out";

int N,H,U,GG,indice;

// Functie pentru citire si validare numarului de gutui N

void readn()
{
     FILE *f;
     f=fopen(fin,"r");
     fscanf(f,"%d %d %d",&N,&H,&U);
     fclose(f);
     
     }

// Functie pentru citirea din fisierul gutui.in a vectorilor inaltimilor si
// greutatilor 

void readf(int *pg, int *ph)
{
     FILE *f;
     int i,j;
     f=fopen(fin,"r");
     fscanf(f,"%d %d %d",&N,&i,&j);
     for(i=0;i<N;i++)
     fscanf(f,"%d %d",ph+i,pg+i);
     fclose(f);
     }

  
  // Functie pentru determinarea gutuii care urmeaza a fi culeasa
// exist = 1 daca inaltimea la care se va afla gutuia i depaseste pe H

int maxim(int *p, int h[], int g[])
{
    int i,max,exist;
    for(exist=0,i=0;i<N;i++)
    if(h[i]+U>H)
    exist=1;
    if(exist)
    {
    i=0;
    while(*(p+i) == -1)  //actualizare vector culese
    i++;
    max=g[i]; //prima val diferita de -1 din culese
    indice=i;
    for(i=0;i<N;i++)
    if(max<g[i] && h[i]+U>H && *(p+i)!=-1)
    {
    max=g[i];
    indice=i;
    }
    }
    else
    {
    i=0;
    while(*(p+i) == -1)
    i++;
    max=h[i];
    //max=h[0];
    //indice=0;
    indice=i;
    for(i=0;i<N;i++) //gasim maximul dintre inaltimi
    {
    if(max<=h[i] && *(p+i)!=-1)
    {
    max=h[i];
    indice=i;
    }
    }
    max=g[indice]; 
}
    return max;
}

// Functie pentu initializare cu 0 a vectorului culese
void init(int  *p)
{
     int i;
     for(i=0;i<N;i++)
     *(p+i)=0;
     }

// Functie pentru actualizarea vectorului culese
void ramase(int *p, int x[])
{
     int i;
     for(i=0;i<N;i++)
     if(x[i]>H)
     *(p+i)=-1;
     }

// Functie pentru determinarea numarului de gutui care pot fi culese
int testculese(int *p)
{
     int i,decules=0;
     for(i=0;i<N;i++)
     if(*(p+i)!= -1)
     decules++;
     return decules;
     }

// Functie pentru actualizarea vectorului culese
void update(int *p)
{
     *(p+indice)=-1;
     }
    
// Functie pentru actualizarea inaltimilor 
void updateh(int *p, int x[])
{
     int i;
     for(i=0;i<N;i++)
     if(*(p+i)!=-1)
     x[i]+=U;
     }
           

   
// Functie pentru rezolvarea problemei gutuilor
// hg este vectorul inaltimilor
// mg este vectorul maselor
// masa = masa curenta a gutuilor culese
// cules = vectorul care are pe pozitia i valoarea 0 daca gutuia i poate 
//          fi culeasa ( se afla la o inaltime mai mica decat H)
//          si are valoarea -1 daca gutuia de pe pozitia i ori se afla la
//          o inaltime mai mare decat H, ori a fost culeasa 
int gutui(int *mg, int *hg)
{
    
    int *cules;
    GG=0;
    cules=(int *)malloc(N*sizeof(int));
    init(cules);
    ramase(cules,hg);//cate gutui mai pot fi culese  
    while(testculese(cules))
    {
    GG+= maxim(cules,hg,mg); //gutuia cea mai buna
    update(cules);
    updateh(cules,hg);
    ramase(cules,hg);
        }
return GG;
}

// Functie pentru scrierea solutiei in fisierul gutui.out
 
void writef()
{
     FILE *f;
     f=fopen(fout,"w");
     fprintf(f,"%d",GG);
     fclose(f);
     } 
     
// n = numar de gutui din copac
// H = inaltimea la care poate ajunge culegatorul
// U = inaltimea cu care se ridica crengile dupa culegerea unei gutui
// pg = pointer catre vectorul maselor gutuilor
// ph = pointer catre vectorul inaltimilor la care se afla initial gutuile
// GG = masa totala a gutuilor culese
      
int main()
{
    int *pg,*ph;
    readn();
    if(N>=1 && N<=100000)
    {
    pg=(int *)malloc(N*sizeof(int));
    ph=(int *)malloc(N*sizeof(int));
    readf(pg,ph);
    GG=gutui(pg,ph);
    writef();
    }
}