#include<iostream>

#include<string.h>

#include<iostream>

#include<queue>

#include<cmath>

#include<unordered_map>

#include<unordered_set>

#include<string>

#include<vector>

#include<algorithm>

using namespace std;

const int inf = 1 << 29;

const int kMax = 200005;

unordered_map<int, int> discrete_map; //海报所贴的端点到线段树区间端点的映射

int gPost[kMax >> 1][2]; //海报的左右边界

vector<int> gPoints;	//存放海报的端点

unordered_set<int> uncovered_post; //没有被遮盖的海报序号

struct Node{

	int beg;

	int end;

	int post;

	bool single_post;

	Node(){

		beg = end = 0;

		single_post = true;

		post = -1;

	}

};

Node gNodes[kMax << 2];

//连续型的区间 线段树

void BuildTree(int node, int beg, int end){

	gNodes[node].beg = beg;

	gNodes[node].end = end;

	if (beg + 1 == end){

		//连续型的区间，线段树的叶子节点表示一个单位长度[i, i+1]，而不是一个点[i, i].

		return;

	}

	int mid = (beg + end) >> 1;

	int left = 2 * node + 1, right = 2 * node + 2;

	BuildTree(left, beg, mid);

	BuildTree(right, mid, end);

	//连续型的区间，[beg, mid] & [mid, end]; 而离散型的区间[beg, mid]&[mid + 1, end]

}

void PushDown(int node){

	if (gNodes[node].beg + 1 == gNodes[node].end)

		return;

	if (gNodes[node].single_post){

		int left = 2 * node + 1, right = 2 * node + 2;

		gNodes[left].post = gNodes[right].post = gNodes[node].post;

		gNodes[left].single_post = gNodes[right].single_post = true;

		gNodes[node].single_post = false;

	}

}

void Post(int node, int beg, int end, int post){

	if (gNodes[node].beg == beg && gNodes[node].end == end){

		gNodes[node].single_post = true;

		gNodes[node].post = post;

		return;

	}

	PushDown(node);

	int left = 2 * node + 1, right = 2 * node + 2;

	int mid = (gNodes[node].beg + gNodes[node].end) / 2;

	if (beg >= mid){

		Post(right, beg, end, post);

	}

	else if (end <= mid){

		Post(left, beg, end, post);

	}

	else{

		Post(left, beg, mid, post);

		Post(right, mid, end, post);

	}

}

void Query(int node){

	if (gNodes[node].single_post && gNodes[node].post != -1){

		uncovered_post.insert(gNodes[node].post);

		return;

	}

	if (gNodes[node].beg + 1 == gNodes[node].end){

		return;

	}

	int left = 2 * node + 1, right = 2 * node + 2;

	Query(left);

	Query(right);

}

int main(){

	int N, L;

	scanf("%d %d", &N, &L);

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

		scanf("%d %d", &gPost[i][0], &gPost[i][1]);

		//将各个离散点加入vector

		gPoints.push_back(gPost[i][0]);

		gPoints.push_back(gPost[i][1]);

	}

	//先排序

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

	//对vector去重

	gPoints.resize(std::distance(gPoints.begin(), unique(gPoints.begin(), gPoints.end())));

	BuildTree(0, 0, gPoints.size() - 1);

	//将离散化的点，按照大小映射到一个连续的区间，缩小数据规模

	for (int i = 0; i < gPoints.size(); i++){

		discrete_map[gPoints[i]] = i;

	}

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

		Post(0, discrete_map[gPost[i][0]], discrete_map[gPost[i][1]], i);

	}

	Query(0);

	int result = uncovered_post.size();

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

	return 0;

}