#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <vector>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <queue>
#include <ctime>
#include <cassert>
#include <complex>
#include <string>
#include <cstring>
#include <chrono>
#include <random>
#include <queue>
#include <bitset>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define pb push_back
#define mp make_pair
#define all(a) begin(a),end(a)
#define FOR(x,val,to) for(int x=(val);x<int((to));++x)
#define FORE(x,val,to) for(auto x=(val);x<=(to);++x)
#define FORR(x,arr) for(auto &x: arr)
#define FORS(x,plus,arr) for(auto x = begin(arr)+(plus); x != end(arr); ++x)
#define FORREV(x,plus,arr) for(auto x = (arr).rbegin()+(plus); x !=(arr).rend(); ++x)
#define REE(s_) {cout<<s_<<'\n';exit(0);}
#define GET(arr) for(auto &i: (arr)) sc(i)
#define whatis(x) cerr << #x << " is " << x << endl;
#define e1 first
#define e2 second
#define INF 0x7f7f7f7f
typedef std::pair<int,int> pi;
typedef std::vector<int> vi;
typedef std::vector<std::string> vs;
typedef int64_t ll;
typedef uint64_t ull;
#define umap unordered_map
#define uset unordered_set
using namespace std;
using namespace __gnu_pbds;

#ifdef _WIN32
#define getchar_unlocked() _getchar_nolock()
#define _CRT_DISABLE_PERFCRIT_LOCKS
#endif
template<class T> ostream& operator<<(ostream &os, set<T> V) { os<<"[";for(auto const &vv:V)os<<vv<<","; os<<"]"; return os; }
template<class T> ostream& operator<<(ostream &os, vector<T> V) { os<<"[";for(auto const &vv:V)os<<vv<<","; os<<"]"; return os; }
template<class L, class R> ostream& operator<<(ostream &os, pair<L, R> P) { os<<"("<<P.first<<","<<P.second<<")"; return os; }
inline int fstoi(const string &str){auto it=str.begin();bool neg=0;int num=0;if(*it=='-')neg=1;else num=*it-'0';++it;while(it<str.end()) num=num*10+(*it++-'0');if(neg)num*=-1;return num;}
inline void getch(char &x){while(x = getchar_unlocked(), x < 33){;}}
inline void getstr(string &str){str.clear(); char cur;while(cur=getchar_unlocked(),cur<33){;}while(cur>32){str+=cur;cur=getchar_unlocked();}}
template<typename T> inline bool sc(T &num){ bool neg=0; int c; num=0; while(c=getchar_unlocked(),c<33){if(c == EOF) return false;} if(c=='-'){ neg=1; c=getchar_unlocked(); } for(;c>47;c=getchar_unlocked()) num=num*10+c-48; if(neg) num*=-1; return true;}template<typename T, typename ...Args> inline void sc(T &num, Args &...args){ bool neg=0; int c; num=0; while(c=getchar_unlocked(),c<33){;} if(c=='-'){ neg=1; c=getchar_unlocked(); } for(;c>47;c=getchar_unlocked()) num=num*10+c-48; if(neg) num*=-1; sc(args...); }
template<typename T> using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>; //s.find_by_order(), s.order_of_key() <- works like lower_bound
template<typename T> using ordered_map = tree<T, int, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

bool srt(pi a, pi b){
    return a.e1+a.e2 < b.e1+b.e2;
}

int main(){
    ios_base::sync_with_stdio(0);cin.tie(0);
    int n;
    sc(n);
    pi a[n];
    FORR(i,a)
        sc(i.e1,i.e2);
    sort(a,a+n,srt);
    ll dp[n+1];
    ll LINF = 1e18;
    FORR(i,dp)
        i = LINF;
    dp[0] = 0;
    FORR(i,a){
        /* whatis(i) */
        for(int x = n-1; x >= 0; --x){
            /* whatis(x) */
            /* whatis(dp[x]) */
            if(dp[x] == LINF) continue;
            if(dp[x] > i.e1) continue;
            /* if(dp[ */
            dp[x+1] = min(dp[x+1],dp[x]+i.e2);
        }
    }
    for(int i = n+1; --i;)
        if(dp[i] != LINF) REE(i)
}


#include <algorithm>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <utility>
#include <vector>

#define REP(i,s,n) for(int i=(int)(s);i<(int)(n);i++)

using namespace std;
typedef long long int ll;
typedef vector<int> VI;
typedef vector<ll> VL;
typedef pair<int, int> PI;
typedef pair<ll, ll> PL;

struct cmp {
  bool operator()(PL x, PL y) const {
    if (x.first <= y.first && x.second <= y.second) {
      return x != y;
    }
    if (x.first >= y.first && x.second >= y.second) {
      return false;
    }
    bool flip = false;
    if (x > y) {
      swap(x, y);
      flip = true;
    }
    bool ans = false;
    // x.0 <= y.0, x.1 >= y.1
    if (x.first >= y.second) {
      ans = false;
    } else {
      ans = true;
    }
    if (flip) ans = !ans;
    return ans;
  }
};

const ll inf = 1e16;

int main(void) {
  ios::sync_with_stdio(false);
  cin.tie(0);
  int n;
  cin >> n;
  VL h(n), p(n);
  vector<PL> pool;
  vector<VL> dp(n + 1, VL(n + 1, inf));
  REP(i, 0, n) {
    cin >> h[i] >> p[i];
    pool.push_back(PL(h[i]+p[i], p[i]));
  }
  sort(pool.begin(), pool.end());
  dp[0][0] = 0;
  REP(i, 0, n) {
    ll y = pool[i].second;
    ll x = pool[i].first - y;
    REP(j, 0, i + 2) {
      dp[i + 1][j] = dp[i][j];
      if (j >= 1 && dp[i][j - 1] <= x) {
	dp[i + 1][j] = min(dp[i + 1][j], dp[i][j - 1] + y);
      }
    }
  }
  int ma = 0;
  REP(i, 0, n + 1) {
    if (dp[n][i] < inf) {
      ma = max(ma, i);
    }
  }
  cout << ma << "\n";
}
