#include <bits/stdc++.h>
using namespace std;

// ================================================================================ Base Function
vector<pair<int, int>> GetOutside(int L, vector<pair<int, int>> Range) {
	Range.push_back(make_pair(0, 0));
	Range.push_back(make_pair(L + 1, L + 1));
	sort(Range.begin(), Range.end());

	// Get Return
	vector<pair<int, int>> ret;
	for (int i = 1; i < (int)Range.size(); i++) {
		int cl = Range[i - 1].second + 1;
		int cr = Range[i - 0].first - 1;
		if (cl <= cr) ret.push_back(make_pair(cl, cr));
	}
	return ret;
}

bool CheckOverlap(vector<pair<int, int>> Range) {
	sort(Range.begin(), Range.end());
	int maxv = 0;
	for (int i = 0; i < (int)Range.size(); i++) {
		if (maxv >= Range[i].first) return false;
		maxv = max(maxv, Range[i].second);
	}
	return true;
}


// ================================================================================ Solve Function
string Solve(int N, int L, vector<pair<int, int>> Range) {
	// Step 1. First Check
	vector<pair<int, int>> Cand;
	vector<pair<int, int>> Cand2;
	int CountFree = 0;
	for (int i = 0; i < N; i++) {
		if (Range[i] == make_pair(-1, -1)) CountFree += 1;
		else if (Range[i].first  == -1) Cand.push_back(make_pair(Range[i].second, Range[i].second));
		else if (Range[i].second == -1) Cand.push_back(make_pair( Range[i].first,  Range[i].first));
		else {
			Cand.push_back(Range[i]);
			Cand2.push_back(Range[i]);
		}
	}
	if (CheckOverlap(Cand) == false) return "NIE";

	// Step 2. Get Ranges
	vector<pair<int, int>> Free = GetOutside(L, Cand2);
	vector<vector<pair<int, char>>> List(Free.size(), vector<pair<int, char>>(0));
	for (int i = 0; i < N; i++) {
		if (Range[i] == make_pair(-1, -1)) continue;
		if (Range[i].first == -1) {
			int pos = Range[i].second;
			int idx = lower_bound(Free.begin(), Free.end(), make_pair(pos, (1 << 30))) - Free.begin();
			idx--;
			List[idx].push_back(make_pair(pos, 'R'));
		}
		if (Range[i].second == -1) {
			int pos = Range[i].first;
			int idx = lower_bound(Free.begin(), Free.end(), make_pair(pos, (1 << 30))) - Free.begin();
			idx--;
			List[idx].push_back(make_pair(pos, 'L'));
		}
	}
	for (int i = 0; i < (int)Free.size(); i++) sort(List[i].begin(), List[i].end());

	// Step 3. Get Max
	int MaxVal = L;
	int MinVal = 0;
	for (int i = 0; i < (int)Cand.size(); i++) MaxVal -= (Cand[i].second - Cand[i].first + 1);
	for (int i = 0; i < (int)Free.size(); i++) {
		if (List[i].size() == 0) MinVal += 1;
		else {
			int cl = Free[i].first;
			int cr = Free[i].second;
			int x = (int)List[i].size() - 1;
			if (List[i][0].first != cl && List[i][0].second == 'L') MinVal += 1;
			if (List[i][x].first != cr && List[i][x].second == 'R') MinVal += 1;
		}
	}

	// Step 4. Final Check
	if (MinVal <= CountFree && CountFree <= MaxVal) return "TAK";
	return "NIE";
}


// ================================================================================ Solve Function
int main() {
	int T; cin >> T;
	for (int t = 1; t <= T; t++) {
		int N; scanf("%d", &N);
		int L; scanf("%d", &L);
		vector<pair<int, int>> Ranges(N, make_pair(0, 0));
		for (int i = 0; i < N; i++) scanf("%d%d", &Ranges[i].first, &Ranges[i].second);
		cout << Solve(N, L, Ranges) << endl;
	}
	return 0;
}