#include <bits/stdc++.h>
#define IOS1 std::ios::sync_with_stdio(false)
#define IOS2 std::cin.tie(nullptr)
#define mode1 1
#define mode2 1

using i64 = long long;
using ui64 = unsigned long long;

constexpr i64 INF = 0x3f3f3f3f3f3f3f3f;
constexpr int inf = 1e9;
constexpr int mod = 1e9 + 7;

template<class T1, class T2> std::istream& operator>>(std::istream& cin, std::pair<T1, T2>& a) { return cin >> a.first >> a.second; };
template<class T1, class T2> std::ostream& operator<<(std::ostream& cout, std::pair<T1, T2>& a) { return cout << a.first << ' ' << a.second; };
template<class T> std::ostream& operator<<(std::ostream& cout, std::vector<T>& a)
{
    for (int i = 0; i < a.size(); ++i)
        cout << a[i] << " \n"[i == a.size() - 1];
    return cout;
}

inline int read()
{
    int x = 0, f = 1;
    char ch = getchar();
    while (ch < '0' || ch>'9')
    {
        if (ch == '-')
            f = -1;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9')
        x = x * 10 + ch - '0', ch = getchar();
    return x * f;
}

inline void write(int x)
{
    if (x < 0)
        putchar('-'), x = -x;
    if (x > 9)
        write(x / 10);
    putchar(x % 10 + '0');
    return;
}

using Info = std::pair<int, int>;
using T = std::pair<int, int>;

// template<class Info>
class SegmentTree
{
public:
	int n;
	std::vector<Info> info;
    std::vector<int> lazy;
	SegmentTree() : n(0) {}
	// template<class T>
	SegmentTree(std::vector<T> init_)
	{
		init(init_);
	}
	SegmentTree(int n_, Info v_ = Info())
	{
		init(n_, v_);
	}
	void init(int n_, Info v_ = Info())
	{
		std::vector<Info> x(n_, v_);
		init(x);
	}
	// template<class T>
	void init(std::vector<T>& init_)
	{
		n = init_.size();
		info.assign((i64)4 << (i64)std::log2(n), Info());
		lazy.assign((i64)4 << (i64)std::log2(n), 0);
		build(1, 0, n, init_);
	}
	void build(int p, int l, int r, std::vector<Info>& init_)
	{
		if (r - l == 1)
		{
			info[p] = { 0, l };
			return;
		}
		int mid = (l + r) / 2;
		build(2 * p, l, mid, init_);
		build(2 * p + 1, mid, r, init_);
		pull(p);
	}
	//  Value from sons
	void pull(int p)
	{
		info[p] = std::min(info[2 * p], info[2 * p + 1]);
	}
	void push(int p, int l, int r)
	{
		if (lazy[p] != 0)
		{
			info[p] = { info[p].first + lazy[p], info[p].second }; // Change this if operation is not addition
			if (r - l > 1)
			{
				lazy[2 * p] = lazy[2 * p] + lazy[p];
				lazy[2 * p + 1] = lazy[2 * p + 1] + lazy[p];
			}
			lazy[p] = 0;
		}
	}
	void modify(int p, int l, int r, int x, int y, const int& v)
	{
		push(p, l, r);
		if (l >= y || r <= x)
		{
			return;
		}
		if (l >= x && r <= y)
		{
			lazy[p] = lazy[p] + v;
			push(p, l, r);
			return;
		}
		int mid = (l + r) / 2;
		modify(2 * p, l, mid, x, y, v);
		modify(2 * p + 1, mid, r, x, y, v);
		pull(p);
	}
	void modify(int x, int y, const int& v)
	{
		modify(1, 0, n, x, y, v);
	}
	Info rangeQuery(int p, int l, int r, int x, int y)
	{
		push(p, l, r);
		if (l >= y || r <= x)
		{
			return Info();
		}
		if (l >= x && r <= y)
		{
			return info[p];
		}
		int mid = (l + r) / 2;
		return std::min(rangeQuery(p * 2, l, mid, x, y), rangeQuery(p * 2 + 1, mid, r, x, y));
	}
	Info rangeQuery(int x, int y)
	{
		return rangeQuery(1, 0, n, x, y);
	}
};

class Solution
{
public:
    void solve()
    {
        int n;
        std::cin >> n;
        SegmentTree seg(n);
        std::set<std::pair<int, int>> st;
        for (int i = 0; i < n; ++i)
        {
            int l, r;
            std::cin >> l >> r;
            --l, --r;
            st.insert({ l, r });
            seg.modify(l, r + 1, 1);
        }
        int cnt = 0;
        while (1)
        {
            auto [v, id] = seg.rangeQuery(0, n);
            if (v != 1) break;
            ++cnt;
            seg.modify(id, id + 1, inf);
            auto it = st.lower_bound({ v + 1, 0 });
            --it;
            seg.modify(it->first, it->second + 1, -1);
            st.erase(it);
        }
        std::cout << (cnt == n ? 1 : 0) << "\n";
    }
};

int main()
{
    IOS1;
    IOS2;

#if mode1
    int t;
    std::cin >> t;
    while (t--)
    {
        Solution().solve();
    }
#elif mode2
    Solution().solve();
#endif

    return 0;
}