type
  TNode = record
    key,value : longint;
  end;
const
  inputfile = 'coupons.in';
  outputfile = 'coupons.out';

var
  que : array [0..100000] of TNode;
  size : longint;
  n,k,i,ans : longint;
  m : int64;
  p,c : array [1..100000] of longint;


  procedure sort(l,r : longint);
  var
    i,j,x,y,tmp : longint;
  begin
    i:=l; j:=r; y:=p[l+random(r-l+1)]; x:=c[l+random(r-l+1)];
    repeat
      while (x>c[i]) or ((x=c[i]) and (y>p[i])) do inc(i);
      while (x<c[j]) or ((x=c[j]) and (y<p[j])) do dec(j);
      if (j<i) then break;
      tmp:=p[i]; p[i]:=p[j]; p[j]:=tmp;
      tmp:=c[i]; c[i]:=c[j]; c[j]:=tmp;
      inc(i); dec(j);
    until (j<i);
    if (l<j) then sort(l,j);
    if (i<r) then sort(i,r);
  end;

  procedure hswap(var x,y : TNode);
  var
    tmp : TNode;
  begin
    tmp:=x; x:=y; y:=tmp;
  end;

  procedure push(x,y : longint);
  begin
    inc(size);
    que[size].key:=x;
    que[size].value:=y;
    while (size>1) and (que[size div 2].key>que[size].key) do
      hswap(que[size div 2],que[size]);
  end;

  procedure pop;
  var
    cur : longint;
  begin
    que[1]:=que[size];
    dec(size);
    cur:=1;
    while (que[cur*2].key<que[cur].key) or
          (que[cur*2+1].key<que[cur].key) do begin
            if (que[cur*2].key<que[cur*2+1].key)
              then begin
                hswap(que[cur*2],que[cur]);
                cur:=cur*2;
              end
              else begin
                hswap(que[cur*2+1],que[cur]);
                cur:=cur*2+1;
              end;
          end;
  end;


begin
  assign(input,inputfile);
  reset(input);
  assign(output,outputfile);
  rewrite(output);
  readln(n,k,m);
  for i:=1 to n do readln(p[i],c[i]);
  fillchar(que,sizeof(que),$7f);
  sort(1,n);
  i:=1; ans:=0;
  while (k>0) and (m-c[i]>0) do begin
    push(p[i]-c[i],i);
    k:=k-1;
    m:=m-c[i];
    inc(ans);
    inc(i);
  end;
  while (i<=n) do begin
    if (p[i]<c[i]+que[1].key)
      then begin
        if (m-p[i]>0)
          then begin m:=m-p[i]; ans:=ans+1; end;
      end
      else begin
        if (m-c[i]-que[1].key>0)
          then begin
            m:=m-c[i]-que[1].key;
            pop;
            push(p[i]-c[i],i);
            ans:=ans+1;
          end;
      end;
    inc(i);
  end;
  writeln(ans);
  close(input);
  close(output);
end.