// Words are flowing out like endless rain into a paper cup,
// They slither while they pass, they slip away across the universe
// Pools of sorrow, waves of joy are drifting through my opened mind,
// Possessing and caressing me.
// Jai guru de va om
// Nothing's gonna change my world,
// Nothing's gonna change my world,
//
// Nothing's gonna change my world,
// Nothing's gonna change my world,
//
// Images of broken light which dance before me like a million eyes,
// That call me on and on across the universe,
// Thoughts meander like a restless wind inside a letter box they
// Tumble blindly as they make their way
// Across the universe
// Jai guru de va om
// Nothing's gonna change my world,
// Nothing's gonna change my world,
//
// Nothing's gonna change my world,
// Nothing's gonna change my world,
//
// Sounds of laughter shades of earth are ringing
// Through my open views inciting and inviting me
// Limitless undying love which shines around me like a
// Million suns, it calls me on and on
// Across the universe
// Jai guru de va om
// Nothing's gonna change my world,
// Nothing's gonna change my world,
//
// Nothing's gonna change my world,
// Nothing's gonna change my world,
//
// Jai guru de va

#pragma GCC optimize(3)
#pragma GCC target("avx")
#pragma GCC target("avx,avx2")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("Ofast,fast-math")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
#pragma GCC optimize(2)
#include<bits/stdc++.h>
//#include<iostream>
//#include<string>
//#include<cmath>
//#include<cstdio>
//#include<cctype>
//#include<cstring>
//#include<iomanip>
//#include<cstdlib>
//#include<ctime>
//#include<set>
//#include<map>
//#include<utility>
//#include<queue>
//#include<vector>
//#include<stack>
//#include<sstream>
//#include<algorithm>
using namespace std;
/*=====================================================================*/
#define ll long long
//#define int ll
#define pii pair<int,int>
#define vi vector<int>
#define vii vector<pii>
#define pdd pair<double,double>
#define ull unsigned long long
#define pb push_back
#define rep(i,n) for(int i=0;i<(int)(n);++i)
#define all(s) (s).begin(),(s).end()
#define repd(i,n) for(int i=(int)(n)-1;i>=0;--i)
#define forr(i,a,b,c) for(int i=(int)(a);i<=(int)(b);i+=(int)(c))
#define forn(i,p,n) for(int i=(int)(p);i<=(int)(n);++i)
#define ford(i,p,n) for(int i=(int)(n);i>=(int)(p);--i)
#define foreach(i,c) for(__typeof(c.begin())i=(c.begin());i!=(c).end();++i)
#define INF 0x3f3f3f3f
#define PI acos(-1)
#define Endl(x) cout<<x<<endl;
#define Blank(x) cout<<x<<" ";
#define modcg(x) if(x>=mod)x-=mod;
#define modcl(x) if(x<0)x+=mod;
#define lowbit(x) x&(-x)
/*=====================================================================*/
string int_to_string(ll n)
{
	string s="";
	while(n)
	{
		ll now=n%10;
		s+=now+'0';
		n/=10;
	}
	reverse(s.begin(),s.end());
	return s;
}
ll string_to_int(string s)
{
	ll n=0;
	rep(i,s.size())
	{
		n*=10;
		n+=s[i]-'0';
	}
	return n;
}
mt19937 GeN(chrono::system_clock::now().time_since_epoch().count());
int Rand(int l,int r)
{
	uniform_int_distribution<>RAND1(l,r);
	return RAND1(GeN);
}
struct Fastmod
{
	int mod,b;
	typedef __int128 lll;
	void init(int m)
	{
		mod=m;
		b=((lll)1<<64)/mod;
	}
	int operator()(ull a)
	{
		int q=((lll)a*b)>>64,r=a-q*mod;
		modcg(r);
		return r;
	}
}MOD;
int mul(int a,int b)
{
	return MOD(a*b);
}
/*======================================================================*/
const int dx[]={-1,0,1,0};
const int dy[]={0,-1,0,1};
const int month[2][12]={{31,28,31,30,31,30,31,31,30,31,30,31},{31,29,31,30,31,30,31,31,30,31,30,31}};
//think twice,code once
//think once,debug forever
const int MAXN=1e4+10;
struct Flow
{
	int s,t;
	bitset<MAXN> v[MAXN];
	inline void add_edge(int x,int y)
	{
		v[x][y]=1;
	}
	int dist[MAXN];
	bool bfs()
	{
		forn(i,1,t)
		{
			dist[i]=-1;
		}
		dist[s]=0;
		queue<int> q;
		q.push(s);
		while(!q.empty())
		{
			int now=q.front();q.pop();
			for(int u=v[now]._Find_next(0);u!=v[now].size();u=v[now]._Find_next(u))
			{
				if(dist[u]==-1)
				{
					dist[u]=dist[now]+1;
					q.push(u);
				} 
			}
		}
//		cout<<t<<endl;
//		forn(i,1,t)
//		{
//			cout<<dist[i]<<" ";
//		}
//		cout<<endl; 
		return dist[t]!=-1;
	}
	int cur[MAXN];
	int dfs(int now,int flow)
	{
		if(now==t)
		{
			return flow;
		}
		int aint=flow;
//		cout<<cur[now]<<" "<<v[now]._Find_next(cur[now])<<endl;
//		cur[now]=v[now]._Find_next(cur[now]); 
		for(int u=v[now]._Find_next(0);u!=v[now].size();u=v[now]._Find_next(u))
		{
//			cout<<now<<" "<<u<<endl;
			if(dist[u]==dist[now]+1)
			{
				int del=dfs(u,1);
				if(del)
				{
					v[now][u]=0;
					v[u][now]=1;
					aint--;
				}
				if(aint==0)
				{
					break;
				}
			}
		}
//		cout<<now<<" "<<flow<<" "<<aint<<endl;
		return flow-aint;
	}
	int ans;
	void dinic()
	{
//		forn(i,1,t)
//		{
//			forn(j,1,t)
//			{
//				cout<<v[i][j]<<" ";
//			}
//			cout<<endl;
//		}
		ans=0;
		while(bfs())
		{
//			forn(i,1,t)
//			{
//				cur[i]=v[i]._Find_next(0);
//			}
			ans+=dfs(s,INF);
		}
	}
}F;
int n;
int l[MAXN],r[MAXN];
void solve()
{
	cin>>n;
	forn(i,1,n)
	{
		cin>>l[i]>>r[i];
	}
	F.s=(n+1)<<1;
	F.t=F.s+1;
	forn(i,1,n)
	{
		F.add_edge(F.s,i<<1);
		F.add_edge(i<<1|1,F.t);
		forn(j,1,n)
		{
			if(l[i]<l[j]&&l[j]<r[i]&&r[i]<r[j])
			{
//				cout<<i<<" "<<j<<endl;
				F.add_edge(i<<1,j<<1|1);
			}
		}
	}
	F.dinic();
//	cout<<F.ans<<endl;
	cout<<2*n-F.ans<<endl;
}
/*======================================================================*/
signed main()
{
    cin.tie(0);
    cout.tie(0);
	std::ios::sync_with_stdio(false);
//#define Hank2007
#ifdef Hank2007
	freopen("input.txt","r",stdin);
	freopen("output1.txt","w",stdout);
#endif
  	/*====================================================================*/
  	int TEST_CASE=1;
//	cin>>TEST_CASE;
  	while(TEST_CASE--)
  	{
  		solve();
  	}
  	return 0;
}