#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAXN=400005;
const int MAXD=19;
const ll INF=(1LL<<60)-1;
struct SparseTable
{
    ll dp[MAXD][MAXN];
    void init(int n,ll a[])
    {
        for(int i=0; i<n; i++)
            dp[0][i]=a[i];
        for(int j=1; j<=__lg(n); j++)
            for(int i=0; i+(1<<j)-1<n; i++)
                dp[j][i]=max(dp[j-1][i],dp[j-1][i+(1<<(j-1))]);
    }
    ll query(int l,int r)
    {
        if(l>r)swap(l,r);
        int k=__lg(r-l+1);
        return max(dp[k][l],dp[k][r-(1<<k)+1]);
    }
} st_pos_max, st_neg_max;
int solve()
{
    int n;
    ll p;
    scanf("%d%lld",&n,&p);
    map<int,ll> ac[2],wa[2];
    ll tar=0;
    for(int i=1; i<=n; i++)
    {
        int a,b,d;
        ll c;
        scanf("%d%d%lld%d",&a,&b,&c,&d);
        --a;
        if(!ac[a].count(b))
        {
            if(d)
            {
                ac[a][b]=c;
                tar+=(!a ? 1 : -1)*(c+wa[a][b]*p);
            }
            else wa[a][b]++;
        }
    }
    if(tar<=0)tar=-tar+1;
    else swap(ac[0],ac[1]);
    if(ac[0].size()!=ac[1].size())
        return 0*printf("-1\n");
    vector<ll> can;
    can.push_back(0);
    for(int i=0; i<2; i++)
        for(auto& [_,t] : ac[i])
            can.push_back(t);
    sort(can.begin(),can.end());
    can.erase(unique(can.begin(),can.end()),can.end());
    vector<ll> sum(can.size()),cnt(can.size());
    for(int i=0; i<2; i++)
        for(auto& [_,t] : ac[i])
        {
            int j=lower_bound(can.begin(),can.end(),t)-can.begin();
            sum[j]+=(i ? 1 : -1)*t,cnt[j]+=(i ? 1 : -1);
        }
    for(int i=(int)can.size()-1; i>0; i--)
        sum[i-1]+=sum[i],cnt[i-1]+=cnt[i];
    vector<ll> g(can.size());
    for(int i=0; i<(int)can.size(); i++)
        g[i]=sum[i]-can[i]*cnt[i];
    st_pos_max.init(can.size(),g.data());
    for(auto& v : g)v*=-1;
    st_neg_max.init(can.size(),g.data());
    for(auto& v : g)v*=-1;
    ll resL=0,resR=INF;
    for(int u=0; u<(int)can.size(); u++)
    {
        int l=u+1,r=(int)can.size();
        while(l<r)
        {
            int m=(l+r)/2;
            if(g[u]+st_neg_max.query(u,m)>=tar)r=m;
            else l=m+1;
        }
        if(r<(int)can.size())
        {
            ll L=can[u],R=can[r],rem=g[u]-g[r]-tar;
            if(cnt[r]>0)
            {
                ll t=rem/cnt[r];
                R-=t,rem-=t*cnt[r];
            }
            if(u>0 && cnt[r]>cnt[u])
            {
                ll t=rem/(cnt[r]-cnt[u]);
                t=min(L-max(can[u-1],L-t),R-max(can[r-1],R-t));
                L-=t,R-=t,rem-=t*(cnt[r]-cnt[u]);
            }
            if(R-L<resR-resL || (R-L==resR-resL && L<resL))
                resL=L,resR=R;
        }
        l=-1,r=u-1;
        while(l<r)
        {
            int m=(l+r+1)/2;
            if(st_pos_max.query(m,u)-g[u]>=tar)l=m;
            else r=m-1;
        }
        if(l>=0)
        {
            ll L=can[l],R=can[u],rem=g[l]-g[u]-tar;
            if(cnt[l+1]>0)
            {
                ll t=rem/cnt[l+1];
                L+=t,rem-=t*cnt[l+1];
            }
            if(cnt[u]>cnt[l+1])
            {
                ll t=rem/(cnt[u]-cnt[l+1]);
                t=min(L-max(can[l],L-t),R-max(can[u-1],R-t));
                L-=t,R-=t,rem-=t*(cnt[u]-cnt[l+1]);
            }
            if(R-L<resR-resL || (R-L==resR-resL && L<resL))
                resL=L,resR=R;
        }
    }
    if(resR==INF)printf("-1\n");
    else printf("%lld %lld\n",resL,resR);
    return 0;
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)solve();
    return 0;
}