#include "bits/extc++.h"
using namespace std;


// Source: ecnerwala
// Templates for Policy Based Data Structures
struct splitmix64_hash {
  static uint64_t splitmix64(uint64_t x) {
    // http://xorshift.di.unimi.it/splitmix64.c
    x += 0x9e3779b97f4a7c15;
    x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
    x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
    return x ^ (x >> 31);
  }

  size_t operator()(uint64_t x) const {
    static const uint64_t FIXED_RANDOM =
        std::chrono::steady_clock::now().time_since_epoch().count();
    return splitmix64(x + FIXED_RANDOM);
  }
};

using namespace __gnu_pbds;
template <typename K, typename V, typename Hash = splitmix64_hash>
using hash_map = gp_hash_table<K, V, Hash>;

template <typename K, typename Hash = splitmix64_hash>
using hash_set = hash_map<K, null_type, Hash>;

template <class T, class Compare = less<>>
using ordered_set =
    tree<T, null_type, Compare, rb_tree_tag, tree_order_statistics_node_update>;

int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);

  int tt;
  cin >> tt;
  while(tt--) {
    int n, y0;
    cin >> n >> y0;
    vector<int> x(n), y(n), t(n);
    vector<int> xs = {0};
    xs.reserve(3*n+1);
    // At key, these points become active.
    hash_map<int, vector<int>> events;
    for (int i = 0; i < n; i++) {
      cin >> x[i] >> y[i];
      t[i] = abs(y[i] - y0);
      xs.push_back(x[i]);
      xs.push_back(x[i]-1);
      xs.push_back(x[i]+1);
      events[x[i]].push_back(i);
    }
    sort(xs.begin(), xs.end());
    xs.erase(unique(xs.begin(), xs.end()), xs.end());
    vector<int> from_left(xs.size()), from_right(xs.size());

    // go from left
    {
      hash_set<int> vals;
      int active = 0;
      for (int i =0; i < xs.size(); i++) {
        int X = xs[i];
        from_left[i] = active;

        // at the end, add the points that become active here
        auto it = events.find(X);
        if (it == events.end()) continue;
        active += it->second.size();
        hash_set<int> already_broken;
        for (auto& j : it->second) {
          int val = x[j] - t[j];
          auto it = vals.find(val);
          if (it == vals.end()) {
            auto it = already_broken.find(val);
            if (it != already_broken.end()) {
              // This is being destroyed in the same point.
              active--;
            } else {
              vals.insert(val);
            }
          } else {
            already_broken.insert(val);
            vals.erase(*it);
            active -= 2;
          }
        }
      }
    }

    // go from right
    {
      hash_set<int> vals;
      int active = 0;
      for (int i = (int)xs.size() - 1; i >=0; i--) {
        int X = xs[i];
        from_right[i] = active;

        // at the end, add the points that become active here
        auto it = events.find(X);
        if (it == events.end()) continue;
        active += it->second.size();
        hash_set<int> already_broken;
        for (auto& j : it->second) {
          int val = x[j] + t[j];
          auto it = vals.find(val);
          if (it == vals.end()) {
            auto it = already_broken.find(val);
            if (it != already_broken.end()) {
              // This is being destroyed in the same point.
              active--;
            } else {
              vals.insert(val);
            }
          } else {
            already_broken.insert(val);
            vals.erase(*it);
            active -= 2;
          }
        }
      }
    }
    /* for (auto& x : xs) cout << x << " "; */
    /* cout << '\n'; */
    /* for (auto& x : xs) cout << x << " "; */
    /* cout << '\n'; */

    int minans = 1e9, maxans =0;
    for (int i = 0; i < xs.size(); i++) {
      minans = min(minans, (int)events[xs[i]].size() + from_left[i] + from_right[i]);
      maxans = max(maxans, (int)events[xs[i]].size() + from_left[i] + from_right[i]);
    }
    cout << minans << " " << maxans << '\n';
  }
}
// Iterate from left to right, then right to left
// for l2r, keep track of x[i] - t[i]
// for r2l, keep track of x[i] + t[i];
// Consider x = 0, x = x[i] - 1, x = x[i], x = x[i]+1