#include <bits/stdc++.h>

#define int int64_t

using pii = std::pair<int, int>;

const int kMaxN = 4e5 + 5;

struct Node {
  int t, id, op;
  Node(int _t = 0, int _id = 0, int _op = 0) : t(_t), id(_id), op(_op) {}
  friend bool operator <(const Node &n1, const Node &n2) {
    if (n1.t != n2.t) return n1.t < n2.t;
    else return n1.op > n2.op;
  }
};

int n, m, p, d;
int cs, fir;
int cnt[2], now[2], unq[kMaxN];
pii seg[kMaxN], mx[kMaxN], mi[kMaxN];
std::vector<int> v[2], sum[2];
std::vector<Node> vec[2];

struct SGT {
  int N;
  pii mx[kMaxN * 4], mi[kMaxN * 4];
  void pushup(int x) {
    mx[x] = std::max(mx[x << 1], mx[x << 1 | 1]);
    mi[x] = std::min(mi[x << 1], mi[x << 1 | 1]);
  }
  void build(int n) {
    for (N = 1; N <= n + 1; N <<= 1) {}
    for (int i = N; i <= N + n; ++i) mx[i] = ::mx[i - N], mi[i] = ::mi[i - N];
    for (int i = N - 1; ~i; --i) pushup(i);
  }
  pii querymax(int l, int r) {
    if (l > r) return {-1e18, 0};
    pii ret = {-1e18, 0};
    for (l += N - 1, r += N + 1; l ^ r ^ 1; l >>= 1, r >>= 1) {
      if (~l & 1) ret = std::max(ret, mx[l ^ 1]);
      if (r & 1) ret = std::max(ret, mx[r ^ 1]);
    }
    return ret;
  }
  pii querymin(int l, int r) {
    if (l > r) return {1e18, 0};
    pii ret = {1e18, 0};
    for (l += N - 1, r += N + 1; l ^ r ^ 1; l >>= 1, r >>= 1) {
      if (~l & 1) ret = std::min(ret, mi[l ^ 1]);
      if (r & 1) ret = std::min(ret, mi[r ^ 1]);
    }
    return ret;
  }
} sgt;

void prework() {
  cnt[0] = cnt[1] = now[0] = now[1] = 0;
  for (int o = 0; o < 2; ++o) {
    std::set<int> st;
    v[o].clear();
    // std::sort(vec[o].begin(), vec[o].end());
    for (auto [t, id, op] : vec[o])
      if (op == 1)
        st.emplace(id);
    cnt[o] = st.size();
    for (auto [t, id, op] : vec[o]) {
      if (!st.count(id)) continue;
      if (!op) now[o] += p;
      else now[o] += t, st.erase(id), v[o].emplace_back(t);
    }
  }
}

void discrete() {
  m = 0;
  for (auto x : v[0]) unq[++m] = x;
  for (auto x : v[1]) unq[++m] = x;
  unq[++m] = 0; unq[++m] = 1e13;
  std::sort(unq + 1, unq + 1 + m);
  m = std::unique(unq + 1, unq + 1 + m) - (unq + 1);
  unq[m + 1] = 1e14;
}

int getsum(int o, int x) {
  if (x < 0) return 0;
  else return sum[o][x];
}

pii getfunc(int x, int p) {
  return {p * seg[x].first + seg[x].second, p};
}

pii getmi(int x, int l, int r) {
  l = std::max<int>(l, 0);
  if (l > r) return {1e18, 0};
  return std::min(getfunc(x, l), getfunc(x, r));
}

pii getmx(int x, int l, int r) {
  l = std::max<int>(l, 0);
  if (l > r) return {-1e18, 0};
  return std::max(getfunc(x, l), getfunc(x, r));
}

int getfunc(int x) {
  int i = std::lower_bound(unq + 1, unq + 1 + m, x) - unq - 1;
  if (!i) ++i;
  // std::cerr << x << ' ' << unq[i] << ' ' << unq[i + 1] << '\n';
  assert(i < m);
  assert(unq[i] <= x && x <= unq[i + 1]);
  return x * seg[i].first + seg[i].second;
}

int _getfunc(int x) {
  int ret = 0;
  for (int o = 0; o < 2; ++o) {
    int sum = 0;
    for (auto t : v[o]) sum += std::min(x, t);
    if (o == 0) ret += sum;
    else ret -= sum;
  }
  return ret; 
}

void getseg() {
  for (int o = 0; o < 2; ++o) {
    int s = 0;
    sum[o].clear();
    for (int i = 0; i < v[o].size(); ++i)
      sum[o].emplace_back(s += v[o][i]);
  }
  for (int i = 1; i < m; ++i) {
    int p1 = std::lower_bound(v[0].begin(), v[0].end(), unq[i + 1]) - v[0].begin();
    int p2 = std::lower_bound(v[1].begin(), v[1].end(), unq[i + 1]) - v[1].begin();
    seg[i] = {v[0].size() - p1 - (v[1].size() - p2), getsum(0, p1 - 1) - getsum(1, p2 - 1)};
    mi[i] = getmi(i, unq[i], unq[i + 1]);
    mx[i] = getmx(i, unq[i], unq[i + 1]);
  }
}

pii getpr(int x) {
  for (int i = 1, j = 1; i <= m - 1; ++i) {
    // int j = std::upper_bound(unq + 1, unq + 1 + m, unq[i] + x) - unq - 1;
    for (; unq[j] <= unq[i] + x; ++j) {}
    --j;
    int now = getfunc(unq[i]);
    auto p = sgt.querymax(i, j - 1);
    if (p.first - now >= d) return {unq[i], p.second};
    p = getmx(j, unq[j], unq[i] + x);
    if (p.first - now >= d) return {unq[i], p.second};
  }
  for (int i = m, j = m; i > 1; --i) {
    // int j = std::lower_bound(unq + 1, unq + 1 + m, std::max<int>(unq[i] - x, 0)) - unq;
    for (; j > 1 && unq[j - 1] >= std::max<int>(unq[i] - x, 0); --j) {}
    int now = getfunc(unq[i]);
    auto p = sgt.querymin(j, i - 1);
    if (now - p.first >= d) return {p.second, unq[i]};
    p = getmi(j - 1, std::max<int>(unq[i] - x, 0), unq[j]);
    if (now - p.first >= d) return {p.second, unq[i]};
  }
  return {-1, -1};
}

bool check(int x) {
  return getpr(x).first != -1;
}

int cei(int x, int y) {
  if (x < 0) return -((-x) / y);
  else return (x + y - 1) / y;
}

int flr(int x, int y) {
  if (x < 0) return -((-x + y - 1) / y);
  else return x / y;
}

pii getpp(pii p, int d) {
  // x * p.first + p.second >= d
  int tmp = d - p.second;
  // x * p.first >= tmp
  if (p.first == 0) return tmp <= 0 ? pii{0, 1e18} : pii{1e18, 1e18};
  else if (p.first > 0) return {cei(tmp, p.first), 1e18};
  else return {0, flr(-tmp, -p.first)};
}

pii calc(int i, int j, int len) {
  assert(j < m);
  int l = std::max(unq[j], unq[i - 1] + len), r = std::min(unq[j + 1], unq[i] + len);
  if (l > r) return {1e18, 1e18};
  pii p = {seg[j].first - seg[i - 1].first, seg[j].second - seg[i - 1].second + len * seg[i - 1].first};
  auto pp = getpp(p, d);
  if (std::max(l, pp.first) <= std::min(r, pp.second)) return {std::max(l, pp.first) - len, std::max(l, pp.first)};
  else return {1e18, 1e18};
  // for (int i = l; i <= r; ++i)
  //   if (i * p.first + p.second >= d)
  //     return {i - len, i};
}

pii getans() {
  // if (fir == 202567778970ll) std::cout << m << ' ' << unq[2] << ' ' << _getfunc(879492417995ll) - _getfunc(202567778970ll) << ' ' << d << '\n';
  // int L = 0, R = 1e12 + 1, res = 0;
  // while (L + 1 < R) {
  //   int mid = (L + R) >> 1;
  //   if (check(mid)) R = res = mid;
  //   else L = mid;
  // }
  int res = 0;
  for (int i = 1; i <= m; ++i) {
    int L = i, R = m + 1, rr = m + 1;
    int now = getfunc(unq[i]);
    while (L + 1 < R) {
      int mid = (L + R) >> 1;
      if (sgt.querymax(i, mid - 1).first - now >= d) R = rr = mid;
      else L = mid;
    }
    if (rr != m + 1) {
      auto pp = getpp(seg[rr - 1], now + d);
      if (std::max(unq[rr - 1], pp.first) <= std::min(unq[rr], pp.second)) {
        int val = std::max(unq[rr - 1], pp.first);
        // std::cerr << val << '\n';
        if (!res) res = val - unq[i];
        else res = std::min(res, val - unq[i]);
      }
    }
  }
  for (int i = 1; i <= m; ++i) {
    int L = 0, R = i, rr = 0;
    int now = getfunc(unq[i]);
    while (L + 1 < R) {
      int mid = (L + R) >> 1;
      if (now - sgt.querymin(mid, i - 1).first >= d) L = rr = mid;
      else R = mid;
    }
    if (rr != 0) {
      auto pp = getpp(pii{-seg[rr].first, -seg[rr].second}, -(now - d));
      if (std::max(unq[rr], pp.first) <= std::min(unq[rr + 1], pp.second)) {
        int val = std::min(unq[rr + 1], pp.second);
        // std::cerr << val << '\n';
        if (!res) res = unq[i] - val;
        else res = std::min(res, unq[i] - val);
      }
    }
  }
  std::cerr << res << '\n';
  // if (p == 862246722332ll) std::cout << "heige " << 1.0 * clock() / CLOCKS_PER_SEC << "s\n";
  if (!res) return {-1, -1};
  pii ret = {1e18, 1e18};
  for (int i = 2; i < m; ++i) {
    int l, r;
    r = std::upper_bound(unq + 1, unq + 1 + m, unq[i] + res) - unq - 1;
    l = std::lower_bound(unq + 1, unq + 1 + m, unq[i - 1] + res) - unq - 1;
    l = std::max(l, i);
    for (int j = l; j <= r; ++j) ret = std::min(ret, calc(i, j, res));
  }
  return ret;
}

bool fl = 1;

void dickdreamer() {
  ++cs;
  std::cin >> n >> p;
  vec[0].clear(), vec[1].clear();
  for (int i = 1; i <= n; ++i) {
    int c, t, id, op;
    std::cin >> c >> id >> t >> op;
    vec[c - 1].emplace_back(t, id, op);
    if (i == 1) fir = t;
  }
  prework(), discrete();
  if (cnt[0] != cnt[1]) return void(std::cout << "-1\n");
  if (now[0] > now[1]) d = now[0] - now[1];
  else d = now[1] - now[0] + 1, std::swap(now[0], now[1]), v[0].swap(v[1]), vec[0].swap(vec[1]);
  getseg();
  // if (fl && cs == 6) assert(std::count(unq + 1, unq + 1 + m, 66660446969ll) || std::count(unq + 1, unq + 1 + m, 904724933033ll));
  sgt.build(m);
  auto res = getans();
  if (res.first == -1) std::cout << "-1\n";
  else std::cout << res.first << ' ' << res.second << '\n';
}

int32_t main() {
#ifdef ORZXKR
  freopen("in.txt", "r", stdin);
  freopen("out.txt", "w", stdout);
#endif
  std::ios::sync_with_stdio(0), std::cin.tie(0), std::cout.tie(0);
  int T = 1;
  std::cin >> T;
  fl &= (T == 10000);
  while (T--) dickdreamer();
  // std::cerr << 1.0 * clock() / CLOCKS_PER_SEC << "s\n";
  return 0;
}