#pragma GCC optimize("Ofast", "inline", "unroll-loops")
#include <algorithm>
#include <chrono>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iostream>
#include <queue>
#include <random>
#include <vector>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/priority_queue.hpp>
using namespace __gnu_pbds;
using namespace std;
#define rep(i, a, n) for (int i = a; i <= n; i++)
#define per(i, a, n) for (int i = a; i >= n; i--)
#define pb push_back
#define eb emplace_back
#define all(x) (x).begin(), (x).end()
#define bit(x) (1ll << (x))
#define fi first
#define se second
#define SZ(x) ((int)(x).size())
using VI = vector<int>;
using PII = pair<int, int>;
using ll = long long;
using ull = unsigned long long;
using db = double;
using ldb = long double;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
// head

#ifdef DEBUG
#include "debug.cpp"
#else
#define debug(...) 42
#endif

static struct FastInput {
  static constexpr int BUF_SIZE = 1 << 20;
  char buf[BUF_SIZE];
  size_t chars_read = 0;
  size_t buf_pos = 0;
  FILE *in = stdin;
  char cur = 0;
 
  inline char get_char() {
    if (buf_pos >= chars_read) {
      chars_read = fread(buf, 1, BUF_SIZE, in);
      buf_pos = 0;
      buf[0] = (chars_read == 0 ? -1 : buf[0]);
    }
    return cur = buf[buf_pos++];
  }
  
  template <typename T>
  inline void tie(T) {}
 
  inline explicit operator bool() {
    return cur != -1;
  }
 
  inline static bool is_blank(char c) {
    return c <= ' ';
  }
 
  inline bool skip_blanks() {
    while (is_blank(cur) && cur != -1) {
      get_char();
    }
    return cur != -1;
  }
 
  inline FastInput& operator>>(char& c) {
    skip_blanks();
    c = cur;
    get_char();
    return *this;
  }
  
  inline FastInput& operator>>(string& s) {
    if (skip_blanks()) {
      s.clear();
      do {
        s += cur;
      } while (!is_blank(get_char()));
    }
    return *this;
  }
 
  template <typename T>
  inline FastInput& read_integer(T& n) {
    // unsafe, doesn't check that characters are actually digits
    n = 0;
    if (skip_blanks()) {
      int sign = +1;
      if (cur == '-') {
        sign = -1;
        get_char();
      }
      do {
        n += n + (n << 3) + cur - '0';
      } while (!is_blank(get_char()));
      n *= sign;
    }
    return *this;
  }
 
  template <typename T>
  inline typename enable_if<is_integral<T>::value, FastInput&>::type operator>>(T& n) {
    return read_integer(n);
  }
  
  #if !defined(_WIN32) || defined(_WIN64)
  inline FastInput& operator>>(__int128& n) {
    return read_integer(n);
  }
  #endif
 
  template <typename T>
  inline typename enable_if<is_floating_point<T>::value, FastInput&>::type operator>>(T& n) {
    // not sure if really fast, for compatibility only
    n = 0;
    if (skip_blanks()) {
      string s;
      (*this) >> s;
      sscanf(s.c_str(), "%lf", &n);
    }
    return *this;
  }
} fast_input;
 
#define cin fast_input
 
static struct FastOutput {
  static constexpr int BUF_SIZE = 1 << 20;
  char buf[BUF_SIZE];
  size_t buf_pos = 0;
  static constexpr int TMP_SIZE = 1 << 20;
  char tmp[TMP_SIZE];
  FILE *out = stdout;
 
  inline void put_char(char c) {
    buf[buf_pos++] = c;
    if (buf_pos == BUF_SIZE) {
      fwrite(buf, 1, buf_pos, out);
      buf_pos = 0;
    }
  }
 
  ~FastOutput() {
    fwrite(buf, 1, buf_pos, out);
  }
 
  inline FastOutput& operator<<(char c) {
    put_char(c);
    return *this;
  }
 
  inline FastOutput& operator<<(const char* s) {
    while (*s) {
      put_char(*s++);
    }
    return *this;
  }
 
  inline FastOutput& operator<<(const string& s) {
    for (int i = 0; i < (int) s.size(); i++) {
      put_char(s[i]);
    }
    return *this;
  }
 
  template <typename T>
  inline char* integer_to_string(T n) {
    // beware of TMP_SIZE
    char* p = tmp + TMP_SIZE - 1;
    if (n == 0) {
      *--p = '0';
    } else {
      bool is_negative = false;
      if (n < 0) {
        is_negative = true;
        n = -n;
      }
      while (n > 0) {
        *--p = (char) ('0' + n % 10);
        n /= 10;
      }
      if (is_negative) {
        *--p = '-';
      }
    }
    return p;
  }
 
  template <typename T>
  inline typename enable_if<is_integral<T>::value, char*>::type stringify(T n) {
    return integer_to_string(n);
  }
 
  #if !defined(_WIN32) || defined(_WIN64)
  inline char* stringify(__int128 n) {
    return integer_to_string(n);
  }
  #endif
 
  template <typename T>
  inline typename enable_if<is_floating_point<T>::value, char*>::type stringify(T n) {
    sprintf(tmp, "%.17f", n);
    return tmp;
  }
 
  template <typename T>
  inline FastOutput& operator<<(const T& n) {
    auto p = stringify(n);
    for (; *p != 0; p++) {
      put_char(*p);
    }
    return *this;
  }
} fast_output;
 
#define cout fast_output


const int N = 1e6 + 10;
int n;
struct line {
  std::vector<int> v;
  int sz;
  void add(int x) {
    v.push_back(x);
    sz++;
  }
  void del(int x) {
    v.push_back(-x);
    sz--;
  }
  void make() {
    std::sort(v.begin(), v.end(), [](int x, int y) {
      int a = std::abs(x), b = std::abs(y);
      return a != b ? a < b : x > y;
    });
    std::vector<int> w;
    for (auto &x : v) {
      if (x > 0) {
        w.push_back(x);
      } else {
        w.pop_back();
      }
    }
    v.swap(w);
  }
} lst[N], rst[N];
struct node {
  int sz, id;
  bool operator<(const node &o) const { return sz < o.sz; }
};
__gnu_pbds::priority_queue<node> lp, rp;
void add(int l, int r) {
  lst[l].add(r);
  lp.push({lst[l].sz, l});
  rst[r].add(l);
  rp.push({rst[r].sz, r});
}
void del(int l, int r) {
  lst[l].del(r);
  lp.push({lst[l].sz, l});
  rst[r].del(l);
  rp.push({rst[r].sz, r});
}
int work() {
  while (true) {
    if (lp.top().sz >= rp.top().sz) {
      auto [sz, l] = lp.top();
      lp.pop();
      if (sz == 1) {
        return 1;
      }
      if (lst[l].sz != sz) {
        continue;
      }
      lst[l].make();
      auto tmp = lst[l].v;
      int pl = l;
      for (auto &r : tmp) {
        if (r < pl) {
          return 0;
        }
        del(l, r);
        add(pl, r);
        pl = r + 1;
      }
    } else {
      auto [sz, r] = rp.top();
      rp.pop();
      if (sz == 1) {
        return 1;
      }
      if (rst[r].sz != sz) {
        continue;
      }
      rst[r].make();
      auto tmp = rst[r].v;
      std::reverse(tmp.begin(), tmp.end());
      int pr = r;
      for (auto &l : tmp) {
        if (l > pr) {
          return 0;
        }
        del(l, r);
        add(l, pr);
        pr = l - 1;
      }
    }
  }
}
int main() {
  // cin.tie(nullptr)->sync_with_stdio(false);
  int t;
  cin >> t;
  while (t--) {
    // auto st = clock();
    cin >> n;
    // n = 1e6;
    // uniform_int_distribution<int> e(1, n);
    for (int i = 1; i <= n; i++) {
      lst[i].v.clear();
      lst[i].sz = 0;
      rst[i].v.clear();
      rst[i].sz = 0;
    }
    while (!lp.empty()) {
      lp.pop();
    }
    while (!rp.empty()) {
      rp.pop();
    }
    for (int i = 1; i <= n; i++) {
      int l, r;
      cin >> l >> r;
      // l = e(rng);
      // r = e(rng);
      // if (l > r) swap(l, r);
      add(l, r);
    }
    cout << work() << '\n';
    // auto ed = clock();
    // cout << "time: " << 1.0 * (ed - st) / CLOCKS_PER_SEC << '\n';
  }
  return 0;
}