// Phức tạp O(N^2), chỉ phù hợp N nhỏ
#include <bits/stdc++.h>
using namespace std;

int main() {
    int n; long long T;
    cin >> n >> T;
    vector<long long> x(n), t(n);
    for(int i=0; i<n; i++) cin >> x[i] >> t[i];

    // dp[i][j]: j=0 (không ăn i), j=1 (ăn i và quay về 0), j=2 (ăn i và đứng lại)
    // ... (chi tiết quá dài, đây là minh họa ý tưởng)
    // Giải pháp này O(N^2) hoặc O(N*K) không khả thi.
    cout << 0;
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n; long long T;
    cin >> n >> T;
    vector<long long> x(n), t(n);
    for (int i = 0; i < n; i++) cin >> x[i] >> t[i];

    vector<int> id(n);
    iota(id.begin(), id.end(), 0);
    sort(id.begin(), id.end(), [&](int a, int b){ return x[a] < x[b]; });

    multiset<long long> S;
    long long sumT = 0;
    int ans = 0;
    int L = 0;

    for (int R = 0; R < n; R++) {
        S.insert(t[id[R]]);
        sumT += t[id[R]];

        while (L <= R) {
            long long xmin = x[id[L]], xmax = x[id[R]];
            // Công thức thời gian: Di chuyển liên tục từ L sang R, rồi về 0
            // Hoặc từ 0 -> min -> max -> 0 (hoặc ngược lại).
            // Công thức tối ưu: (xmax - xmin) + min(abs(xmin), abs(xmax))
            long long travel = (xmax - xmin) + min(abs(xmin), abs(xmax));
            long long need = travel + sumT;
            if (need <= T) break;
            // Nếu quá thời gian, loại bỏ bánh có t_i lớn nhất
            auto it = prev(S.end());
            sumT -= *it;
            S.erase(it);
            // Nếu loại bỏ hết bánh ở L, tăng L
            if (S.empty()) {
                L = R + 1;
                break;
            }
            // Kiểm tra xem có nên loại bỏ bánh ở L không?
            // Trong solution code, họ chỉ loại bỏ max t_i.
            // Tuy nhiên, nếu sau khi loại max t_i vẫn quá, ta cần loại thêm.
            // Hoặc nếu L không còn trong S (do bị xóa), ta phải tăng L.
        }
        // Cập nhật L: Nếu L không nằm trong S, ta phải tìm L mới.
        // Code mẫu: while (L <= R && S.find(t[id[L]]) == S.end()) L++;
        // Tuy nhiên, code mẫu dùng multiset và xóa max.
        // Nếu xóa max mà vẫn quá, vòng while bên trong tiếp tục.
        // Nếu xóa hết, vòng while bên trong break (do S.empty).
        // Vòng lặp ngoài chỉ cập nhật ans = max(ans, S.size())
        ans = max(ans, (int)S.size());
    }
    cout << ans;
}

#include <bits/stdc++.h>
using namespace std;
using ll = long long;

int main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int N;
    ll T;
    cin >> N >> T;
    vector<pair<ll,ll>> A(N);
    for(int i = 0; i < N; i++){
        cin >> A[i].first >> A[i].second;
    }

    ll time_spent = 0;
    ll pos_prev = 0;
    priority_queue<ll> pq; // Max-heap
    int best = 0;

    for (int i = 0; i < N; i++) {
        ll x = A[i].first;
        ll t = A[i].second;

        // Di chuyển từ vị trí trước đó đến x
        time_spent += abs(x - pos_prev);
        pos_prev = x;

        // Thêm bánh hiện tại
        time_spent += t;
        pq.push(t);

        // Nếu vượt quá T, loại bỏ bánh ăn lâu nhất
        while (!pq.empty() && time_spent > T) {
            ll bad = pq.top(); pq.pop();
            time_spent -= bad;
        }

        // Cập nhật kết quả
        best = max(best, (int)pq.size());
    }
    cout << best;
    return 0;
}