#include <bits/stdc++.h>
#ifdef CKISEKI
#define safe cerr<<__PRETTY_FUNCTION__<<" line "<<__LINE__<<" safe\n"
#define debug(a...) qwe(#a, a)
#define orange(a...) dvo(#a, a)
using std::cerr;
template <typename ...T>
void qwe(const char *s, T...a) {
    cerr << "\e[1;32m(" << s << ") = (";
    int cnt = sizeof...(T);
    (..., (cerr << a << (--cnt ? ", " : ")\e[0m\n")));
}

template <typename Iter>
void dvo(const char *s, Iter L, Iter R) {
    cerr << "\e[1;32m[ " << s << " ] = [ ";
    for (int f = 0; L != R; ++L)
        cerr << (f++ ? ", " : "") << *L;
    cerr << " ]\e[0m\n";
}

#else
#define safe ((void)0)
#define debug(...) safe
#define orange(...) safe
#endif

using namespace std;

template <typename T>
using min_heap = priority_queue<T, vector<T>, greater<T>>;

template <typename T>
using max_heap = priority_queue<T, vector<T>, less<T>>;

class BIT {
    static int lowbit(int x) { return x & (-x); }
    vector<pair<int64_t, int64_t>> a;
public:
    BIT(int n) : a(n) {}
    void add(int p, int64_t x, int64_t v) {
        p += 1;
        while (p < a.size()) {
            a[p].first += x;
            a[p].second += v;
            p += lowbit(p);
        }
    }

    int64_t query(int K) {
        int p = 0;
        for (int s = 1 << 20; s; s >>= 1) {
            if (p + s < a.size() && a[p + s].first < K) {
                K -= a[p + s].first;
                p += s;
            }
        }
        ++p;
        assert (p != a.size());
        int64_t res = 0;
        while (p) {
            res += a[p].second;
            p -= lowbit(p);
        }
        return res;
    }
};

int main() {
    cin.tie(nullptr)->sync_with_stdio(false);
    int t; cin >> t;
    while (t--) {
        int n; int64_t lim;
        cin >> n >> lim;
        vector<pair<int, int>> z;
        vector<pair<int, pair<int, int>>> v;
        for (int i = 0; i < n; ++i) {
            int a, b; cin >> a >> b;
            z.emplace_back(a, i);
            v.emplace_back(b, z.back());
        }

        sort(z.begin(), z.end());
        for (auto &[_, p] : v) {
            p.second = lower_bound(z.begin(), z.end(), p) - z.begin();
        }

        sort(v.begin(), v.end());

        auto valid = [&](int x, bool construct = false) {
            debug(x);
            BIT sum(z.size() + 1);

            size_t it = 0;
            max_heap<pair<int,int>> pq;
            int64_t pqsum = 0;

            for (int i = 0; i < v.size(); i++) {
                sum.add(v[i].second.second, 1, v[i].second.first);
            }
            for (int k = 0; k <= n; k++) {
                while (it < v.size() && v[it].first <= k) {
                    pq.emplace(v[it].second.first, it);
                    debug("push", v[it].second.first);
                    pqsum += v[it].second.first;
                    sum.add(v[it].second.second, -1, -v[it].second.first);
                    ++it;
                }
                while (pq.size() > x) {
                    auto [_, i] = pq.top();
                    pq.pop();
                    pqsum -= _;
                    sum.add(v[i].second.second, 1, v[i].second.first);
                }
                debug(pq.size());
                if (pq.size() == x) {
                    int64_t total_time = pqsum;
                    if (k > pq.size()) {
                        total_time += sum.query(k - pq.size());
                    }
                    debug(pqsum);
                    debug(k, total_time, lim);
                    if (total_time <= lim) {
                        if (construct) {
                            vector<int> used(v.size());
                            vector<int> ans;
                            int M = pq.size();
                            while (pq.size()) {
                                auto [_, i] = pq.top();
                                pq.pop();
                                ans.push_back(i);
                                used[i] = true;
                                debug(_, i, "inpq");
                            }
                            vector<pair<int,int>> tmp;
                            for (int i = 0; i < v.size(); i++)
                                if (not used[i])
                                    tmp.emplace_back(v[i].second.first, i);
                            sort(tmp.begin(), tmp.end());
                            if (k > M) {
                                for (int j = 0; j < k - M; j++) {
                                    ans.push_back(tmp[j].second);
                                }
                            }
                            cout << x << '\n';
                            cout << ans.size() << '\n';
                            for (int i = 0; i < ans.size(); i++) {
                                int pos = ans[i];
                                int idx = z[v[pos].second.second].second;
                                ans[i] = idx + 1;
                            }
                            sort(ans.begin(), ans.end());
                            for (int i = 0; i < ans.size(); i++) {
                                cout << ans[i] << (i+1==ans.size() ? '\n' : ' ');
                            }
                        }

                        return true;
                    }
                }
            }
            return false;
        };

        int l = 0, r = n + 1;
        while (r - l > 1) {
            int m = (l + r) >> 1;
            if (valid(m)) l = m;
            else r = m;
        }
        valid(l, true);
    }
    return 0;
}