Problem: Peace, which was supposed to last forever, suddenly ended. The Demon King, who had been sealed long ago, has finally revived. But when the world was about to be covered in darkness, a brave man appeared. The hero then set out on a journey to collect legendary crystals scattered around the world. Legend has it that if you can collect all the crystals, you can summon the legendary dragon god who can fulfill any wish. With the help of the dragon god, it should be possible to defeat the Demon King.

Crystals are scattered all over the world. The hero needs to collect them one by one by his own hands. This is because if someone other than the hero gets the crystal, it may be stolen by the Demon King's minions. A hero can travel only one Euclidean distance per day.

But there is one serious problem here. The Demon King constantly disperses the darkness of the miasma, and the place contaminated with the miasma turns into a land of death that no one can enter. Even a brave man cannot enter the place. Furthermore, since the miasma spreads concentrically with time, the area where the hero can move decreases with the passage of time. Miasma has been confirmed to spread by an Euclidean distance of 1 per day. And the hero cannot take the crystal on the boundary line. We also know that the newly resurrected Demon King will not move to store power.

The hero must get the crystal as soon as possible. But if it's not possible to get all the crystals, you'll have to think of another way. Therefore, I would like you to create a program to find out if you can get all the crystals from the initial position of the hero, the place where the demon king was resurrected, and the position where the crystals exist.

By the way, the brave does not get tired. And I don't sleep. Keep moving and collect crystals until you collect all the crystals and save the world! !!



Input

The input consists of multiple test cases. The first line of each test case gives the five integers n (0 <n <= 20), hx, hy, dx, and dy. n is the number of crystals, (hx, hy) is the position of the hero at the moment the Demon King was resurrected, and (dx, dy) is the position where the Demon King was resurrected. The n lines that follow are given the two integers cx, cy, that represent the position of each crystal. Input ends when n = hx = hy = dx = dy = 0, which is not included in the test case.

All coordinates given in the input are guaranteed to be integers with an absolute value of 1000 or less.

Output

For each test case, output "YES" if you can collect all the crystals, and "NO" if not.

Example

Input

2 0 0 10 10
1 1
4 4
2 0 0 10 10
1 1
6 6
2 0 0 10 10
1 1
5 5
0 0 0 0 0


Output

YES
NO
NO

Solution (in CPP):

Solution:
#include<iostream>
#include<cstdio>
#include<functional>
#include<cstdlib>
#include<stdexcept>
#include<numeric>
#include<cmath>
#include<fstream>
#include<memory>
#include<algorithm>
#include<cstring>
#include<ctime>
#include<deque>
#include<sstream>
#include<iomanip>
#include<sstream>
#include<vector>
#include<queue>
#include<stack>
#include<string>
#include<climits>
#include<map>
#include<set>
#include<list>
#include<cassert>
#include<deque>
#define REP(i,s,n) for(int i=s;i<n;i++)
#define rep(i,n) REP(i,0,n)
#define INF 1<<27
#define all(n) n.begin(),n.end()
#define insert(a,b,c,d) PP(P(a,b),P(c,d))
#define F first
#define iter(c) __typeof__((c).begin())
#define foreach(i,c) for(iter(c) i=(c).begin();i!=(c).end();++i)
#define S second
#define ppins(a,b,c,d) PP(P(a,b),P(c,d))
#define pb push_back
#define pf push_front
using namespace std;
typedef pair<int,int> P;
typedef pair<P,P> PP;
typedef long long ll;
typedef unsigned long long ull;
int n,hx,hy,dx,dy;
vector<P> vec;
int LIM;
bool Found;
const double EPS = 1e-10;

void print(int used)
{
  rep(i,n)
	{
	  if(used>>i&1)
	    cout << "1";
	  else
	    cout << "0";
	}
      cout << endl;
}

bool Input()
{
  cin >> n >> hx >> hy >> dx >> dy;
  if(n+hx+hy+dx+dy == 0)
    return true;
  
  vec.clear(),LIM = 0,Found = false;
  rep(i,n)
    {
      int X,Y;
      cin >> X >> Y;
      vec.pb(P(X,Y));
      LIM = LIM|(1<<i);
    }
  return false;
}

bool isCan(P my,double ene,P p,int used)
{

  double cost = sqrt(pow(p.F-my.F,2)+pow(p.S-my.S,2));
 
  rep(i,n)
    {
      if((used>>i)&1)
	continue;

      double dist = sqrt(pow(vec[i].F-dx,2)+pow(vec[i].S-dy,2));

      //cout << "circle : " << ene+cost << " , dist : " << dist << endl;
      if(ene+cost >= dist)
	return false;
    }
  return true;
}

bool check(int used,P my,double cost)
{
  rep(i,n)
    {
      if(used>>i&1)
	continue;
      if(hypot(vec[i].F-dx,vec[i].S-dy) - (hypot(vec[i].F-my.F,vec[i].S-my.S)+cost) < EPS)
	{
	  return false;
	}
    }
  return true;
}

void rec(P my,double cir,int used)
{
  if(Found)
    return;

  if(used == LIM)
    {
      Found = true;
      return;
    }
 
  if(!check(used,my,cir))
    return;

  rep(i,n)
    {
      if((used>>i)&1)
	continue;
      rec(vec[i],cir+hypot(vec[i].F-my.F,vec[i].S-my.S),used|(1<<i));
    }

}

int main(){
  while(true)
    {
      if(Input())
	break;
    
 
      rec(P(hx,hy),0,0);
      Found?cout << "YES" << endl:cout << "NO" << endl;
    }
return 0;
}