#include<bits/stdc++.h>
using namespace std;
using ll=long long;
using vl=vector<ll>;
using vvl=vector<vl>;
using P=pair<ll,ll>;
using vp=vector<P>;
using vvp=vector<vp>;
const ll inf=LLONG_MAX/4;
#define rep2(i,j,k) for(ll i=ll(j);i<ll(k);i++)
#define rep(i,k) rep2(i,0,k)
#define rrep2(i,j,k) for(ll i=ll(j)-1;i>=ll(k);i--)
#define rrep(i,k) rrep2(i,k,0)
#define SZ(a) ll(a.size())
#define eb emplace_back
#define all(a) a.begin(),a.end()
template<class T>
bool chmin(T& a, T b){return a>b ? a=b,1:0;}
template<class T>
bool chmax(T& a, T b){return a<b ? a=b,1:0;}

using T = tuple<ll, ll, ll, ll>;
vector<T> inc_seq(const deque<P> &v) {
	int n = SZ(v);
	assert(n);
	vector<T> res;
	res.eb(v[0].first, v[0].second, v[0].first, v[0].second);
	rep(i, n-1) {
		ll mx = get<3>(res.back());
		auto [l, lv] = v[i];
		auto [r, rv] = v[i+1];
		assert(l < r);
		assert((rv-lv) % (r-l) == 0);
		assert(lv <= mx);
		if(rv <= mx) continue;
		ll step = (rv-lv) / (r-l);
		assert(step > 0);
		ll l2 = (mx+1-lv+step-1)/step + l;
		assert(l2 <= r);
		ll l2v = lv + step * (l2 - l);
		assert(l2v > mx);
		res.eb(l2, l2v, r, rv);
	}
	return res;
}

P solve(int n, ll p, vl A, vl B, vl C, vl D) {
	vector<set<int>> solved(2);
	vector<map<int, ll>> pen(2);
	ll sum = 0;
	vp tmp;
	vl ts;
	rep(i, n) {
		ll a = A[i], b = B[i], c = C[i], d = D[i];
		--a;
		if(d) {
			if(solved[a].count(b)) continue;
			solved[a].insert(b);
			ll sc = c + pen[a][b];
			sum += (a ? sc : -sc);
			tmp.eb((a ? 1 : -1), c);
			ts.eb(c);
		} else {
			pen[a][b] += p;
		}
	}
	if(SZ(solved[0]) != SZ(solved[1]) or !SZ(solved[0])) {
		return {-1, -1};
	}
	sort(all(ts));
	ts.erase(unique(all(ts)), ts.end());
	int sz = SZ(ts);
	vl sa(sz);
	for(auto [a, c] : tmp) {
	       c = lower_bound(all(ts), c) - ts.begin();
	       sa[c] += a;
	}
	vl sum_sa(sz);
	rrep(i, sz) {
		sum_sa[i] = sa[i];
		if(i+1 < sz) sum_sa[i] += sum_sa[i+1];
	}	
	P ans = {inf, -inf};
	auto solve = [&](auto &solve, int l, int r) -> void {
		assert(0 <= l and l <= r and r < sz);
		if(l == r) return;
		if(l+1 == r) {
			ll nd = (sum >= 0 ? sum+1 : -sum);
			ll now = sum_sa[r];
			if(sum < 0) now *= -1;
			// now * len >= nd
			if(now * (ts[r] - ts[l]) < nd) return;
			assert(now > 0);
			ll k = (nd + now - 1) / now;
			chmin(ans, P(k, ts[l]));
			return;
		}
		int m = (l+r)/2;
		solve(solve, l, m);
		solve(solve, m, r);
		deque<P> L, R;
		{
			ll now = 0, all = sum_sa[m];
			rep2(i, m, r+1) {
				all -= sa[i];
				now += sa[i] * (-ts[i]);
				R.eb(ts[i] - ts[m], now + all * (-ts[i]));
			}
		}
		{
			ll now = 0, all = sum_sa[m];
			rrep2(i, m+1, l) {
				if(i < m) {
					all += sa[i];
					now += sa[i] * (-ts[i]);
				}
				L.eb(ts[m] - ts[i], now + all * ts[i]);
			}
		}
		if(sum >= 0) {
			rep(i, SZ(L)) L[i].second *= -1;
			rep(i, SZ(R)) R[i].second *= -1;
		}
		ll nd = (sum >= 0 ? sum+1 : -sum);
		assert(L[0].second + R[0].second == 0);
		assert(nd > 0);
		auto v = inc_seq(R);
		rep(_, 0) {
		cerr << l << ' ' << r << endl;
		cerr << ts[l] << ' ' << ts[m] << ' ' << ts[r] << endl;
		cerr << "nd: " << nd << endl;
		rep(i, SZ(L)) cerr << '{' << L[i].first << ", " << L[i].second << "}" << " \n"[i == SZ(L)-1];
		rep(i, SZ(R)) cerr << '{' << R[i].first << ", " << R[i].second << "}" << " \n"[i == SZ(R)-1];
		rep(i, SZ(v)) cerr << '{' << get<0>(v[i]) << ", " << get<1>(v[i]) << ',' << get<2>(v[i]) << ',' << get<3>(v[i])<< "}" << " \n"[i == SZ(v)-1];
		}
		ll mn = inf;
		rep(_, 2) {
			auto v = inc_seq(R);
			for(auto [x, y] : L) {
				if(y + R[0].second >= nd) {
					ll nl, nr;
					if(!_) {
						nl = ts[m] - x;
						nr = ts[m];
					} else {
						nl = ts[m];
						nr = ts[m] + x;
					}
					chmin(mn, x);
					continue;
				}
				if(y + get<3>(v.back()) < nd) continue;
				int ok = SZ(v)-1, ng = -1;
				while(ok - ng > 1) {
					int mid = (ok + ng) / 2;
					if(y + get<3>(v[mid]) >= nd) ok = mid;
					else ng = mid;
				}
				auto [lx, ly, rx, ry] = v[ok];
				assert(y + ry >= nd);
				ll nx;
				if(y + ly >= nd) {
					nx = lx;
				} else {
					assert(ry > ly and rx > lx and (ry-ly) % (rx-lx) == 0);
					ll step = (ry-ly) / (rx-lx);
					nx = lx + (nd-y-ly+step-1)/step;
				}
				assert(nx <= rx);
				ll nl, nr;
				if(!_) {
					nl = ts[m] - x;
					nr = ts[m] + nx;
				} else {
					nl = ts[m] - nx;
					nr = ts[m] + x;
				}
				chmin(mn, x+nx);
			}
			swap(L, R);
		}
		if(ans <= P(mn, ts[l])) return;
		auto inter = [&](ll lx, ll ly, ll rx, ll ry, ll x) -> ll {
			assert(lx <= x and x <= rx and lx < rx);
			assert((ry-ly) % (rx-lx) == 0);
			return ly + (ry-ly)/(rx-lx)*(x-lx);
		};
		rep(_, 2) {
			while(L.back().first > mn) {
				if(L[SZ(L)-2].first >= mn) {
					L.pop_back();
					continue;
				}
				L.back().second = inter(L[SZ(L)-2].first, L[SZ(L)-2].second, L.back().first, L.back().second, mn);
				L.back().first = mn;
			}
			ll lb = mn - R.back().first;
			while(L[0].first < lb) {
				if(L[1].first <= lb) {
					L.pop_front();
					continue;
				}
				L[0].second = inter(L[0].first, L[0].second, L[1].first, L[1].second, lb);
				L[0].first = lb;
			}
			swap(L, R);
		}
		assert(L[0].first + R.back().first == mn);
		assert(R[0].first + L.back().first == mn);
		ll opt_l = -1;
		while(SZ(L) > 1) {
			assert(SZ(R) > 1);
			auto [l1, v1] = L[0];
			ll w1 = R.back().second;
			ll l2 = min(L[1].first, mn - R[SZ(R)-2].first);
			ll v2 = inter(L[0].first, L[0].second, L[1].first, L[1].second, l2);
			ll w2 = inter(R[SZ(R)-2].first, R[SZ(R)-2].second, R.back().first, R.back().second, mn-l2);
			if(l2 == L[1].first) L.pop_front();
			else L[0] = {l2, v2};
			if(mn-l2 == R[SZ(R)-2].first) R.pop_back();
			else R.back() = {mn-l2, w2};
			v1 += w1, v2 += w2;
			if(v2 >= nd) {
				opt_l = l2;
			} else if(v1 >= nd) {
				assert(l1 < l2 and (v1-v2) % (l2-l1) == 0);
				ll step = (v1-v2) / (l2-l1);
				opt_l = l1 + (v1-nd) / step;
			}
		}
		assert(SZ(L) == 1 and SZ(R) == 1);
		if (L[0].second + R[0].second >= nd) {
			opt_l = L[0].first;
		}
		assert(opt_l != -1);
		chmin(ans, P(mn, ts[m] - opt_l));
	};
	solve(solve, 0, sz-1);
	if(ans.first == inf) return {-1, -1};
	else return {ans.second, ans.first + ans.second};
}

int win(ll p, vl A, vl B, vl C, vl D) {
	int n = A.size();
	vector<set<int>> solved(2);
	vector<map<int, ll>> pen(2);
	ll pa = 0, pb = 0;
	rep(i, n) {
		ll a = A[i], b = B[i], c = C[i], d = D[i];
		--a;
		if(d) {
			if(solved[a].count(b)) continue;
			solved[a].insert(b);
			ll sc = c + pen[a][b];
			if(!a) pa += sc;
			else pb += sc;
		} else {
			pen[a][b] += p;
		}
	}
	if(SZ(solved[0]) != SZ(solved[1])) return SZ(solved[0]) < SZ(solved[1]);
	return pb < pa;
}

P ref(int n, ll p, vl A, vl B, vl C, vl D) {
	ll mn = *min_element(all(C));
	ll mx = *max_element(all(C));
	int ori = win(p, A, B, C, D);
	ll ans = inf;
	ll opt_l, opt_r;
	rep2(l, mn, mx) rep2(r, l+1, mx+1) {
		vl a, b, c, d;
		rep(i, n) {
			a.eb(A[i]);
			b.eb(B[i]);
			if(C[i] < l) c.eb(C[i]);
			else if(C[i] <= r) c.eb(l);
			else c.eb(C[i] - r + l);
			d.eb(D[i]);
		}
		if(win(p, a, b, c, d) != ori) {
			if(chmin(ans, r-l) or (ans == r-l and l < opt_l)) {
				opt_l = l;
				opt_r = r;
			}
		}
	}
	if(ans == inf) return {-1, -1};
	else return {opt_l, opt_r};
}

random_device seed_gen;
mt19937 mt(seed_gen());

// [l, r)
int rnd(int l, int r) {
	assert(l < r);
	return mt() % (r-l) + l;
}

int main(){
	cin.tie(0)->sync_with_stdio(0);
	int t = 0;
	cin >> t;
	rep(_, t) {
		int n;
		ll p;
		cin >> n >> p;
		vl a(n), b(n), c(n), d(n);
		rep(i, n) cin >> a[i] >> b[i] >> c[i] >> d[i];
		P ans = solve(n, p, a, b, c, d);
		if(ans.first == -1) cout << -1 << '\n';
		else cout << ans.first << ' ' << ans.second << '\n';
	}
	return 0;
	int n;
	cin >> n;
	rep(_, 10000) {
		vl a(n), b(n), c(n), d(n);
		int m = rnd(1, n+10);
		rep(i, n) {
			a[i] = rnd(1, 3);
			b[i] = rnd(1, m+1);
			c[i] = rnd(1, 50);
			d[i] = rnd(1, 2);
		}
		sort(all(c));
		ll p = rnd(1, 50);
		P slv = solve(n, p, a, b, c, d);
		P rf = ref(n, p, a, b, c, d);
		if(slv != rf) {
			cout << n << ' ' << p << endl;
			rep(i, n) cout << a[i] << ' ' << b[i] << ' ' << c[i] << ' ' << d[i] << endl;
			cout << "solve: " << slv.first << ' ' << slv.second << endl;
			cout << "ref: " << rf.first << ' ' << rf.second << endl;
			return 0;
		}
	}
}