#define _CRT_SECURE_NO_WARNINGS

#include<stdio.h>

#include<vector>

#include<string.h>

#include<algorithm>

using namespace std;

#define MAX_POSTER_NUM 10001			 //海报最多张数

#define MAX_SEG_NUM 2*MAX_POSTER_NUM	 //由海报边缘确定的最多的分段数

#define MAX_NODE_NUM 4*MAX_SEG_NUM		 //线段树的节点最多

#define MIN(a, b) a < b? a : b

#define MAX(a, b) a > b? a : b

struct Node{

	int left;				//该节点代表的离散化之后区间的起始点序号

	int right;				//该节点代表的离散化之后区间的终止点序号

	int beg_byte;			//该节点代表离散化之后的区间起始点  代表的起始瓷砖号

	int end_byte;			//该节点代表离散化之后的区间终止点  代表的终止瓷砖号

	int top_cover_num;		//该节点代表的离散化之后区间被 那块海报完全覆盖，没被任何瓷砖完全覆盖则为-1

};

Node gNodes[MAX_NODE_NUM];

struct Poster{

	int left;			//海报占据瓷砖区间的开始

	int right;			//海报占据瓷砖区间的结束

};

struct SegUnit{

	int beg;			//离散化之后的区间 的起始瓷砖号

	int end;			//离散化之后的区间 的终止瓷砖号

};

SegUnit gSegUnit[MAX_SEG_NUM];

Poster gPosters[MAX_POSTER_NUM];

int gSegUnitNum;		//离散化之后的总区间数目

vector<int> gPartPoint;	//用于离散化区间

int gVisibleCount[MAX_POSTER_NUM];	//判断海报是否可见

//构建线段树， left, right 为离散化之后区间的起始和结束； index为线段树节点编号

void BuildSegTree(int left, int right, int index){

	gNodes[index].left = left;

	gNodes[index].right = right;

	gNodes[index].top_cover_num = -1;

	if (left == right){

		gNodes[index].beg_byte = gSegUnit[left].beg;

		gNodes[index].end_byte = gSegUnit[left].end;

		return;

	}

	int left_child = 2 * index + 1, right_child = 2 * index + 2;

	int mid = (left + right) / 2;

	BuildSegTree(left, mid, left_child);

	BuildSegTree(mid + 1, right, right_child);

	//父节点的起始和结束的瓷砖编号由 左右子节点决定

	gNodes[index].beg_byte = gNodes[left_child].beg_byte;

	gNodes[index].end_byte = gNodes[right_child].end_byte;

}

//离散化

void InitSegUnit(){

	gSegUnitNum = 0;

	for (int i = 0; i < gPartPoint.size() - 1; i++){

			gSegUnit[gSegUnitNum].beg = gPartPoint[i];

			gSegUnit[gSegUnitNum].end = gPartPoint[i + 1];

			gSegUnitNum++;

	}

}

//更新，节点index 之前被某张海报完全覆盖，现在又有新的海报完全或者部分覆盖index。则将index的top_cover_num 更新

void PushDown(int index){

	int left_child = 2 * index + 1;

	int right_child = 2 * index + 2;

	gNodes[left_child].top_cover_num = gNodes[index].top_cover_num;

	gNodes[right_child].top_cover_num = gNodes[index].top_cover_num;

}

//贴海报

void Post(int poster_num, int poster_beg, int poster_end, int index){

	if (gNodes[index].beg_byte >= poster_beg && gNodes[index].end_byte <= poster_end){

		gNodes[index].top_cover_num = poster_num;

		return;

	}

	else if (gNodes[index].beg_byte > poster_end || gNodes[index].end_byte < poster_beg){

		return;

	}

	if (poster_beg >= poster_end){

		return;

	}

	int left_child = 2 * index + 1, right_child = 2 * index + 2;

	int left_beg = gNodes[left_child].beg_byte, left_end = gNodes[left_child].end_byte,

		right_beg = gNodes[right_child].beg_byte, right_end = gNodes[right_child].end_byte;

	if (gNodes[index].top_cover_num != -1){

		PushDown(index);

		gNodes[index].top_cover_num = -1;

	}

	Post(poster_num, poster_beg, MIN(left_end, poster_end), left_child);

	Post(poster_num, MAX(right_beg, poster_beg), poster_end, right_child);

}

//统计有多少海报是可见的

void CalVisibleSeg(int index){

	if (gNodes[index].top_cover_num != -1){

		gVisibleCount[gNodes[index].top_cover_num] = 1;

		return;

	}

	if (gNodes[index].left == gNodes[index].right){

		return;

	}

	int left_child = 2 * index + 1;

	int right_child = 2 * index + 2;

	CalVisibleSeg(left_child);

	CalVisibleSeg(right_child);

}

void debug(int index){

	printf("index  = %d, left = %d, right = %d, beg_byte = %d, end_byte = %d, top_num = %d\n", index, gNodes[index].left,

		gNodes[index].right, gNodes[index].beg_byte, gNodes[index].end_byte, gNodes[index].top_cover_num);

	if (gNodes[index].left == gNodes[index].right){

		return;

	}

	int left = 2 * index + 1;

	int right = 2 * index + 2;

	debug(left);

	debug(right);

}

int main(){

	int cas, poster_num;

	scanf("%d", &cas);

	while (cas--){

		scanf("%d", &poster_num);

		gPartPoint.clear();

		gPartPoint.reserve(poster_num * 2);

		memset(gVisibleCount, 0, sizeof(gVisibleCount));

		for (int i = 0; i < poster_num; i++){

			scanf("%d %d", &gPosters[i].left, &gPosters[i].right);

			gPosters[i].right++;		// 将闭区间转换为开区间 [i, j] 覆盖i,i+1, ..j 瓷砖，

										//转换为 [i, j +1), 也表示覆盖 i,i+1, ..j 瓷砖

			gPartPoint.push_back(gPosters[i].left);

			gPartPoint.push_back(gPosters[i].right);

		}

		//离散化

		sort(gPartPoint.begin(), gPartPoint.end());

		vector<int>::iterator it = unique(gPartPoint.begin(), gPartPoint.end());

		gPartPoint.erase(it, gPartPoint.end());

		InitSegUnit();

		BuildSegTree(0, gSegUnitNum - 1, 0);

		for (int i = 0; i < poster_num; i++){

			Post(i, gPosters[i].left, gPosters[i].right, 0);

		}

		CalVisibleSeg(0);

		int result = 0;

		for (int i = 0; i < poster_num; i++){

			result += gVisibleCount[i];

		}

		printf("%d\n", result);

	}

	return 0;

}