program exer;
type c=record
     e:integer;
     c:integer;
     end;
var g,w,cp,min,ele:integer;
    a:array[1..1002] of c;
    b:array[1..1002] of c;

{----------------------------}
procedure load;
var i:integer;
    f:text;
begin
     assign(f,'energii.in');
     reset(f);
     readln(f,g);readln(f,w);
     for i:=1 to g do
                     begin
                          read(f,a[i].e,a[i].c);
                          readln(f);
                     end;
     close(f);
end;
{----------------------------}


{----------------------------}
procedure uick(s,d:integer);
var j,i,x:integer;
    q:c;
begin
     i:=s;j:=d;x:=a[(s+d) div 2].c;
     repeat
     while a[i].c<x do i:=i+1;
     while a[j].c>x do j:=j-1;
     if i<=j then
                 begin
                      q:=a[j];
                      a[j]:=a[i];
                      a[i]:=q;
                      i:=i+1;
                      j:=j-1;
                 end;
     until i>j;

     if s<j then uick(s,j);
     if d>i then uick(i,d);
end;
{----------------------------}


{----------------------------}
procedure generate;
var i:integer;
begin
     for i:=1 to g do b[i]:=a[i];
end;
{----------------------------}


{----------------------------}
procedure posibil(x:integer);
var i:integer;
begin
     for i:=x+1 to g do
         begin
              b[i].e:=b[i].e+a[x].e;
              b[i].c:=b[i].c+a[x].c;
         end;
end;
{----------------------------}


{----------------------------}
function verify(x:integer):boolean;
var i:integer;
    f:boolean;
begin
     f:=false;
     for i:=x+1 to g do
         if (b[i].e>=w) and (min>b[i].e) then
                                             begin
                                                  min:=b[i].e;
                                                  cp:=i;
                                                  f:=true;
                                             end;
     verify:=f;
end;
{----------------------------}


{----------------------------}
procedure solve;
var i:integer;
begin
     for i:=1 to g do
        begin
             posibil(i);
             if verify(i) then begin ele:=b[cp].c; break; end;
        end;
end;
{----------------------------}

{----------------------------}
procedure elementar;
var i:integer;
    f:text;
begin
     assign(f,'energii.out');
     rewrite(f);
     for i:=1 to g do
         if a[i].e=w then
                         begin
                              if a[i].c>ele then writeln(f,ele)
                                            else writeln(f,a[i].c);
                              close(f);
                              halt;
                         end;
end;
{----------------------------}


begin
     min:=MAXINT;
     load;
     uick(1,g);
     generate;
     solve;
     elementar;
end.