#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

struct Interval {
    int l1, r1; // 第一个区间
    int l2, r2; // 第二个区间（可能不存在）

    Interval(int l = 0, int r = -1) : l1(l), r1(r), l2(0), r2(-1) {}

    // 判断在某一列是否有 1
    bool hasOne(int col) const {
        return (l1 <= col && col <= r1) || (l2 <= col && col <= r2);
    }

    // 计算当前行与另一行的对称差（模 2 加法）
    void xorWith(const Interval& other) {
        vector<pair<int, int>> events;

        // 当前行的区间事件
        events.push_back({l1, 1});
        events.push_back({r1 + 1, -1});
        if (l2 <= r2) {
            events.push_back({l2, 1});
            events.push_back({r2 + 1, -1});
        }

        // 另一行的区间事件
        events.push_back({other.l1, 1});
        events.push_back({other.r1 + 1, -1});
        if (other.l2 <= other.r2) {
            events.push_back({other.l2, 1});
            events.push_back({other.r2 + 1, -1});
        }

        // 按位置排序事件
        sort(events.begin(), events.end());

        vector<pair<int, int>> result_intervals;
        int count = 0;
        int start = -1;

        for (size_t i = 0; i < events.size(); ++i) {
            int pos = events[i].first;
            int delta = events[i].second;

            count += delta;

            // 跳过相同位置的事件，继续累加
            while (i + 1 < events.size() && events[i + 1].first == pos) {
                ++i;
                count += events[i].second;
            }

            if (count % 2 != 0 && start == -1) {
                // 开始新的区间
                start = pos;
            } else if (count % 2 == 0 && start != -1) {
                // 结束当前区间
                result_intervals.push_back({start, pos - 1});
                start = -1;
            }
        }

        // 更新当前行的区间
        if (result_intervals.size() == 0) {
            l1 = 0; r1 = -1;
            l2 = 0; r2 = -1;
        } else if (result_intervals.size() == 1) {
            l1 = result_intervals[0].first; r1 = result_intervals[0].second;
            l2 = 0; r2 = -1;
        } else {
            l1 = result_intervals[0].first; r1 = result_intervals[0].second;
            l2 = result_intervals[1].first; r2 = result_intervals[1].second;
        }
    }
};

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int t;
    cin >> t;
    while (t--) {
        int n;
        cin >> n;
        vector<Interval> rows(n);
        for (int i = 0; i < n; ++i) {
            int l, r;
            cin >> l >> r;
            rows[i] = Interval(l - 1, r - 1); // 调整为 0 索引
        }

        bool detZero = false;
        for (int i = 0; i < n; ++i) {
            // 找到当前行的最左侧的 1 的位置作为主元列
            int pivot_col = -1;
            if (rows[i].l1 <= rows[i].r1) {
                pivot_col = rows[i].l1;
            } else if (rows[i].l2 <= rows[i].r2) {
                pivot_col = rows[i].l2;
            } else {
                // 当前行全为 0，无法作为主元
                detZero = true;
                break;
            }

            // 如果当前行在主元列没有 1，尝试与下面的行交换
            if (!rows[i].hasOne(pivot_col)) {
                bool found = false;
                for (int j = i + 1; j < n; ++j) {
                    if (rows[j].hasOne(pivot_col)) {
                        swap(rows[i], rows[j]);
                        found = true;
                        break;
                    }
                }
                if (!found) {
                    detZero = true;
                    break;
                }
            }

            // 对下面的行进行消元
            for (int j = i + 1; j < n; ++j) {
                if (rows[j].hasOne(pivot_col)) {
                    rows[j].xorWith(rows[i]);
                }
            }
        }

        cout << (detZero ? 0 : 1) << '\n';
    }

    return 0;
}