#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

const long long INF = 1e18;

struct Coin {
    int x, y;
    bool operator<(const Coin& other) const {
        return y < other.y;
    }
};

int main() {
    int N;
    cin >> N;
    vector<Coin> coins(N);
    for (int i = 0; i < N; i++) {
        cin >> coins[i].x >> coins[i].y;
    }
    // Thêm điểm bắt đầu ảo tại (0, 0)
    coins.insert(coins.begin(), {0, 0});

    // Sắp xếp các đồng xu theo tọa độ y tăng dần
    sort(coins.begin(), coins.end());

    // dp[i][j]: tốc độ K tại vị trí y của coins[i] sau khi đi qua j đồng xu
    // K là tốc độ ngang tại bước cuối cùng (tại y = coins[i].y)
    // Đây là ma trận DP tối ưu, lưu tốc độ K nhỏ nhất có thể đạt được
    // Tuy nhiên, trong giải pháp mẫu, ta thấy cách tiếp cận khác:
    // Dùng dp[i][c] là tốc độ K tại coin i khi đã thu c đồng xu.

    // Ta sẽ dùng ma trận dp[i][k] where i là index coin, k là index coin trước đó (hoặc tốc độ)
    // Đơn giản hóa: dp[i] là tốc độ K tối thiểu để đến coin i sau khi thu 1 số xu.

    // Code tham khảo từ giải pháp:
    // dp[i][c] là tốc độ K tại coin i khi đã thu c đồng xu.
    vector<vector<long long>> dp(N + 1, vector<long long>(N + 1, INF));
    dp[0][0] = 0;

    for (int i = 0; i <= N; i++) {
        for (int c = 0; c <= N; c++) {
            if (dp[i][c] == INF) continue;

            // Thử đi từ coin i đến coin j
            for (int j = 1; j <= N; j++) {
                if (coins[j].y <= coins[i].y) continue;

                long long dy = coins[j].y - coins[i].y;
                long long dx = coins[j].x - coins[i].x;

                // K_base là tốc độ tại bước y = coins[i].y
                long long K_base = dp[i][c];

                // Khoảng cách tối thiểu để đi qua các bước từ y_i đến y_j
                // Với tốc độ K_base, K_base+1, ..., K_base + dy - 1
                // Tổng quãng đường x = dy * K_base + (dy * (dy - 1)) / 2
                // Lưu ý: công thức trong code mẫu là d * dp[i][c] + d*(d+1)/2
                // Điều này có nghĩa là K_base là tốc độ tại bước đầu tiên SAU khi rời i?
                // Không, theo đề bài, K(i) là tốc độ tại bước i. 
                // Nếu tại i (y=yi) có tốc độ K, thì bước tiếp theo (y=yi+1) có tốc độ > K.
                // Vậy nếu tại y=yi có tốc độ K, thì các bước từ y=yi+1 đến y=yj có tốc độ K+1, K+2, ...
                // Nhưng code mẫu lại dùng dp[i][c] như là K_base cho bước đầu tiên.
                // Xem lại: "At step i, it moves from (x,y) to (x+Ki, y+1)".
                // Nếu tại (x_i, y_i) vừa đến, Barons đã dùng tốc độ K_i để đến đó.
                // Để đến (x_j, y_j), Barons cần di chuyển dy bước.
                // Các tốc độ sẽ là K_i + 1, K_i + 2, ..., K_i + dy.
                // Nếu dp[i][c] là K_i:
                // Min sum = (K_i + 1) + (K_i + 2) + ... + (K_i + dy)
                //         = dy * K_i + dy*(dy+1)/2
                // Code mẫu: minsum = d * dp[i][c] + d*(d+1)/2 -> đúng.

                long long minsum = dy * dp[i][c] + dy * (dy + 1) / 2;

                if (dx < minsum) continue;

                // Nếu đi được, ta có thể điều chỉnh tốc độ K mới tại j.
                // Slacks cho phép tăng tốc độ ở các bước trước (tăng K_i, K_i+1...)
                // để đến j sớm hơn, hoặc đơn giản là chọn K_j.
                // K_j = dp[i][c] + dy + slack_adjustment?
                // K_j là tốc độ tại bước cuối cùng (đến j).
                // K_j = K_i + dy + extra (nếu dùng slacks).
                // Nếu không dùng slacks (tức là đi đúng min path), K_j = K_i + dy.
                // Nếu dùng slacks, ta có thể có K_j lớn hơn.
                // Tuy nhiên, để tối ưu cho bước tiếp theo, ta cần K_j nhỏ nhất có thể.
                // Nhưng bài toán yêu cầu maximize số xu.
                // Ta chỉ cần kiểm tra xem có thể đến j không.
                // Nếu đến được, ta cập nhật K mới tại j.
                // K_j = dp[i][c] + dy (nếu dùng min path).
                // Nếu có slacks, ta có thể tăng K_j lên.
                // Nhưng tại sao lại muốn tăng K_j lên? Chỉ muốn nhỏ.
                // Vậy K_j tốt nhất là K_i + dy.
                // Tuy nhiên, ta có thể dùng slacks để bù vào chênh lệch x.
                // Slacks = dx - minsum.
                // Slacks này có thể được phân bổ để tăng các K ở các bước.
                // Khiến K_j tăng lên.
                // Vậy K_j = K_i + dy + (slack_used_for_last_step?)
                // Không, slacks có thể được dùng ở bất kỳ bước nào.
                // Nhưng để đơn giản, ta chỉ cần K_j để xét chuyển tiếp.
                // K_j tối thiểu để đến j là K_i + dy.
                // Nếu dx > minsum, ta có thể dùng slacks để "tăng tốc".
                // Tăng tốc ở bước nào thì K_j tăng ở bước đó.
                // Nếu ta muốn K_j nhỏ nhất, ta không dùng slacks (hoặc dùng 0).
                // Vậy K_j = K_i + dy.
                // Nhưng code mẫu có vẻ tính K_j khác.
                // long long add = (slack + d - 1) / d * d; ?
                // long long add = (slack + d - 1) / d; ?
                // Có lẽ họ đang tính K_j = K_i + dy + (slack / d)?
                // Hoặc họ đang tính "giá trị" mới.
                // Thôi, ta sẽ dùng logic đơn giản:
                // Nếu dx >= minsum, ta có thể đến j.
                // Tốc độ K tại j (bước cuối cùng) là K_i + dy.
                // Cập nhật dp[j][c+1] = min(dp[j][c+1], K_i + dy).

                long long next_K = dp[i][c] + dy;
                // Nếu có slack, ta có thể chọn K lớn hơn.
                // Nhưng K lớn hơn thì bất lợi cho sau này.
                // Vậy chỉ cần K nhỏ nhất.
                // Tuy nhiên, có một ràng buộc: K phải là số nguyên dương.
                // K_i đã dương, dy dương -> K_j dương.

                // Đôi khi, K_i + dy không đủ.
                // Nếu dx rất lớn, ta bắt buộc phải dùng slacks.
                // Slacks buộc ta phải tăng K ở các bước trước.
                // Gọi K_i thực tế là K_i' >= K_i.
                // K_j = K_i' + dy.
                // Điều kiện: dx >= dy * K_i' + dy*(dy+1)/2.
                // K_i' >= (dx - dy*(dy+1)/2) / dy.
                // K_i' = ceil((dx - dy*(dy+1)/2) / dy).
                // K_j = K_i' + dy.
                // Vậy:
                long long min_K_i = (dx - dy * (dy + 1) / 2 + dy - 1) / dy;
                if (dx - dy * (dy + 1) / 2 <= 0) min_K_i = 0; // Chú ý K phải dương, nhưng K_i là tốc độ trước đó.
                // K_i thực tế phải > K_{i-1}.
                // Trong dp[i][c], K_i là tốc độ tại i.
                // Vậy K_i thực tế >= dp[i][c].
                // Ta chọn K_i thực tế = max(dp[i][c], min_K_i).
                // K_j = K_i thực tế + dy.

                long long K_i_real = dp[i][c];
                if (min_K_i > K_i_real) K_i_real = min_K_i;

                long long final_K = K_i_real + dy;

                if (final_K > 0 && final_K < dp[j][c+1]) {
                    dp[j][c+1] = final_K;
                }
            }
        }
    }

    int ans = 0;
    for (int i = 0; i <= N; i++) {
        for (int c = 0; c <= N; c++) {
            if (dp[i][c] != INF) ans = max(ans, c);
        }
    }
    cout << ans << endl;
    return 0;
}

// Pseudocode ý tưởng đồ thị
#include <vector>
#include <algorithm>
#include <iostream>

using namespace std;

struct Coin { int x, y; };

int main() {
    int N; cin >> N;
    vector<Coin> coins(N);
    // Doc va sort
    // Them (0,0)
    // Xay dung do thi: Dinh la cac dong xu + (0,0)
    // Canh tu i sang j neu y_j > y_i va K thoa man.
    // K thoa man la K_phai_ton_tai.
    // K_phai_ton_tai la min K_i sao cho den duoc j.
    // De tim duong di qua nhieu dinh nhat, ta co the quy ve bai toan toi uu hoa.
    // Hoac suy nghi: Day la bai toan tim duong di dai nhat (Longest Path) trong do thi DAG.
    // Tuy nhien, can xet rang K phai tang dan.
    // Co the suy nghi: Neu ta co the di tu A sang B, va tu A sang C, thi co the di tu B sang C khong?
    // Kho khan trong viec ap dung DP don gian.

    // Cach tiep can DP 2 chieu tuong tu Solution 1 la pho bien nhat.
    return 0;
}