#include<iostream>
#include<cstdio>
#include<vector>
#include<set>
#include<unordered_map>
#define N 2000000
#define M 4194303
using namespace std;
const long long inf=(long long)(1e18);
const int INF=(int)(1e9);
char buf[N+1],*p1,*p2;
#define gc() (p1==p2&&(p2=(p1=buf)+fread(buf,1,N,stdin),p1==p2)?0:*p1++)
int read()
{
    char c=0;
    int sum=0,f=1;
    while (c!='-'&&(c<'0'||c>'9')) c=gc();
    if (c=='-') c=gc(),f=-1;
    while ('0'<=c&&c<='9') sum=sum*10+c-'0',c=gc();
    return sum*f;
}
void Adder(long long &x,long long d)
{
    x=(x<d)?x:d;
    return;
}
struct reads
{
    long long t,x;
};
reads st[N+1];
struct node
{
    int l,r,d;
    bool operator < (const node &t)const
	{
		return r<t.r;
	}
};
struct rds
{
    int num,data;
};
struct ed
{
	int num,data,nxt;
};
ed edge[M+1];
int n,len,L[N+1],lst[N+1],nt[N+1],head[M+1];
long long dp[N+1][2];
set<node>s;
vector<rds>v[N+1];
void adder(int l,int r,int d)
{
    if (l>r) return;
    node top;
    for (auto it=s.lower_bound((node){0,l});(*it).l<=r&&it!=s.end();it=s.lower_bound((node){0,l}))
    {
		top=(*it),s.erase(it);
		if (top.l<=l-1) s.insert((node){top.l,l-1,top.d});
		if (r+1<=top.r) s.insert((node){r+1,top.r,top.d});
    }
    s.insert((node){l,r,d});
    return;
}
int query(int x)
{
    auto it=s.lower_bound((node){0,x,0});
    return (*it).d;
}
void adder2(int x,int d)
{
	int ds=(x+INF)&M;
	for (int i=head[ds];i>0;i=edge[i].nxt)
		if (edge[i].num==x)
		{
			edge[i].data=max(edge[i].data,d);
			return;
		}
	edge[++len]=(ed){x,d,head[ds]},head[ds]=len;
	return;
}
int query2(int x)
{
	int ds=(x+INF)&M;
	for (int i=head[ds];i>0;i=edge[i].nxt)
		if (edge[i].num==x)
			return edge[i].data;
	return 0;
}
int main()
{
    long long d;
	int l,r,sl,sr,ps,ps2;
    n=read(),s.insert((node){-INF,INF,0});
    for (int i=1;i<=n;++i) st[i].t=read(),st[i].x=read(),L[i]=1;
    for (int i=0;i<=n;++i) dp[i][0]=dp[i][1]=inf;
    for (int i=1;i<=n;++i)
    {
		if (st[i].x==st[i-1].x) lst[i]=lst[i-1];
		else lst[i]=i-1;
    }
    nt[n+1]=n+1;
    for (int i=n;i>=1;--i)
    {
		if (st[i+1].x==st[i].x) nt[i]=nt[i+1];
		else nt[i]=i+1;
    }
    for (int i=2;i<=n;++i)
    {
		L[i]=max(max(L[i],query(st[i].x)),query2(st[i].x));
		if (lst[i-1]&&st[i-1].x!=st[i].x&&st[lst[i-1]].x!=st[i-1].x&&abs(st[i].x-st[lst[i-1]].x)>st[i].t-st[lst[i-1]].t) adder2(st[i-1].x,lst[i-1]+1);
		if (abs(st[i-1].x-st[i].x)>st[i].t-st[i-1].t) adder(-INF,min(st[i-1].x,st[i].x)-1,i),adder(min(st[i-1].x,st[i].x)+1,max(st[i-1].x,st[i].x)-1,i),adder(max(st[i-1].x,st[i].x)+1,INF,i);
    }
	for (int i=0;i<M;++i) head[i]=0;
    s.clear(),s.insert((node){-INF,INF,0}),dp[0][0]=0;
    for (int i=0;i<=n;++i)
    {
		for (int j=0;j<v[i].size();++j) adder2(v[i][j].num,v[i][j].data);
		if (dp[lst[i]][0]+abs(st[lst[i]].x-st[i].x)<=st[lst[i]+1].t) Adder(dp[i][0],max(dp[lst[i]][0]+abs(st[lst[i]].x-st[i].x),st[lst[i]].t));
		if (dp[lst[i]][1]+abs(st[lst[lst[i]]].x-st[i].x)<=st[lst[i]+1].t) Adder(dp[i][0],max(dp[lst[i]][1]+abs(st[lst[lst[i]]].x-st[i].x),st[lst[i]].t));
		if (max(query(st[i].x),query2(st[i].x))>=L[i]) dp[i][1]=st[lst[i]].t;
		//0
		if (i+1<=n)
		{
			ps=i+1,l=st[ps].x-(st[ps].t-st[i].t),r=st[ps].x+(st[ps].t-st[i].t);
			if (dp[i][0]+abs(st[i].x-st[ps].x)<=st[ps].t)
			{
				d=(st[ps].t-abs(st[i].x-st[ps].x)-dp[i][0])>>1,sl=max(min(st[i].x,st[ps].x)-d,(long long)(l)),sr=min(max(st[i].x,st[ps].x)+d,(long long)(r));
				if (sl<=sr)
				{
					if (st[ps].x<sl||st[ps].x>sr) adder(sl,sr,i+1);
					else adder(sl,st[ps].x-1,i+1),adder(st[ps].x+1,sr,i+1);
				}
			}
			if (dp[i][1]+abs(st[lst[i]].x-st[ps].x)<=st[ps].t)
			{
				d=(st[ps].t-abs(st[lst[i]].x-st[ps].x)-dp[i][1])>>1,sl=max(min(st[lst[i]].x,st[ps].x)-d,(long long)(l)),sr=min(max(st[lst[i]].x,st[ps].x)+d,(long long)(r));
				if (sl<=sr)
				{
					if (st[ps].x<sl||st[ps].x>sr) adder(sl,sr,i+1);
					else adder(sl,st[ps].x-1,i+1),adder(st[ps].x+1,sr,i+1);
				}
			}
		}
		//1
		if (nt[i+1]<=n)
		{
			ps=nt[i+1],ps2=i+1;
			if (dp[i][0]+abs(st[i].x-st[ps2].x)<=st[ps2].t&&max(dp[i][0]+abs(st[i].x-st[ps2].x),st[i].t)+abs(st[ps2].x-st[ps].x)<=st[ps].t) v[ps+1].push_back((rds){st[ps2].x,i+1});
			else if (dp[i][1]+abs(st[lst[i]].x-st[ps2].x)<=st[ps2].t&&max(dp[i][1]+abs(st[lst[i]].x-st[ps2].x),st[i].t)+abs(st[ps2].x-st[ps].x)<=st[ps].t) v[ps+1].push_back((rds){st[ps2].x,i+1});
		}
    }
    puts((dp[n][0]!=inf||dp[n][1]!=inf)?"YES":"NO");
    return 0;
}