#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

int readn(void)
{
     FILE *f;
     f=fopen(fin,"r");
     fscanf(f,"%d %d %d",&N,&H,&U);
     fclose(f);
     if(N>=1 && N<=100000)
     return 1;
     else
     return 0;
     }

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

int readf(int *pg, int *ph)
{
     FILE *f;
     int i,j;
     if((f=fopen(fin,"rb")) != NULL)
     {
     printf(" Fisierul %s a fost deschis \n",fin);
     fscanf(f,"%d %d %d",&N,&i,&j);
     for(i=0;i<N;i++)
     fscanf(f,"%d %d",ph+i,pg+i);
     fclose(f);
     }
     else
     printf(" Eroare deschidere %s \n",fin);
     }
  
  
  
  // Functie pentru determinarea gutuii care urmeaza a fi culeasa
// exist = 1 daca inaltimea la care se va afla gutuia i depaseste pe H

int max(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)
    i++;
    max=g[i];
    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];
    indice=i;
    for(i=0;i<N;i++)
    {
    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
int init(int  *p)
{
     int i;
     for(i=0;i<N;i++)
     *(p+i)=0;
     }

// Functie pentru actualizarea vectorului culese
int 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
int update(int *p)
{
     *(p+indice)=-1;
     }
    
// Functie pentru actualizarea inaltimilor 
int 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 i,*cules;
    GG=0;
    cules=(int *)malloc(N*sizeof(int));
    init(cules);
    ramase(cules,hg); 
    printf(" Mai sunt %d gutui \n",testculese(cules));
    while(testculese(cules))
    {
    GG+= max(cules,hg,mg);
    update(cules);
    updateh(cules,hg);
    ramase(cules,hg);
    printf(" Se culege gutuia %d \n Masa totala %d \n",indice,GG);
    printf(" Mai sunt %d gutui \n",testculese(cules));
    for(i=0;i<N;i++)
    printf(" cules[%d] = %d \n",i,*(cules+i));
        }
return GG;
}

// Functie pentru scrierea solutiei in fisierul gutui.out
 
int writef(void)
{
     FILE *f;
     int err;
     if((f=fopen(fout,"w")) != NULL)
     {
     fprintf(f,"%d",GG);
     err=0;
     fclose(f);
     }
     else
     err=1;
     return err;
     } 
     
// 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();
    pg=(int *)malloc(N*sizeof(int));
    ph=(int *)malloc(N*sizeof(int));
    readf(pg,ph);
    GG=gutui(pg,ph);
    writef();
}