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 JAVA):

Solution:
import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedList;
import java.util.ListIterator;
import java.util.PriorityQueue;
import java.util.Scanner;
    
public class Main {
        
    public static final int MAX = 20;
    public static final double INF = Double.MAX_VALUE;
        
        
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
            
        double[][] dp = new double[1 << MAX][MAX];
        long[][] points = new long[MAX][2];
        double[][] adj = new double[MAX][MAX];
            
        while(true){
            final int n = sc.nextInt();
                
            if(n == 0){
                break;
            }
                
            final long h_x = sc.nextInt();
            final long h_y = sc.nextInt();
            final long g_x = sc.nextInt();
            final long g_y = sc.nextInt();
                
            for(int i = 0; i < n; i++){
                for(int j = 0; j < 2; j++){
                    points[i][j] = sc.nextInt();
                }
            }
                
            final int size = n;
            final int limit = 1 << size;
                
            for(int i = 0; i < size; i++){
                for(int j = i + 1; j < size; j++){
                    long sum = 0;
                    for(int k = 0; k < 2; k++){
                        sum += (points[i][k] - points[j][k]) * (points[i][k] - points[j][k]);
                    }
                        
                    adj[i][j] = adj[j][i] = Math.sqrt(sum);
                    //System.out.println(adj[i][j]);
                }
            }
                
            for(int S = 0; S < limit; S++){
                for(int i = 0; i < size; i++){
                    dp[S][i] = INF;
                }
            }
            for(int i = 0; i < n; i++){
            	final double h_time = Math.sqrt(
                        (points[i][0] - h_x) * (points[i][0] - h_x) + 
                        (points[i][1] - h_y) * (points[i][1] - h_y));
            	
            	final double g_time = Math.sqrt(
                        (points[i][0] - g_x) * (points[i][0] - g_x) + 
                        (points[i][1] - g_y) * (points[i][1] - g_y));
                
                dp[1 << i][i] = h_time < g_time ? h_time : INF; 
            }
                
            for(int S = 0; S < limit; S++){
               LOOP: 
               for(int i = 0; i < size; i++){
                    if((S & (1 << i)) == 0){
                        continue;
                    }else if(dp[S][i] == INF){
                        continue;
                    }
                        
                    for(int j = 0; j < size; j++){
                        if((S & (1 << j)) != 0){
                            continue;
                        }
                           
                        final double time = Math.sqrt(
                                (points[j][0] - g_x) * (points[j][0] - g_x) + 
                                (points[j][1] - g_y) * (points[j][1] - g_y));
                        final double cost = dp[S][i] + adj[i][j];  
                            
                        if(time <= cost){
                           continue LOOP;
                        }
                    }
                       
                    for(int j = 0; j < size; j++){
                         if((S & (1 << j)) != 0){
                            continue;
                        }
                                
                        final double cost = dp[S][i] + adj[i][j];
                            
                        dp[S | (1 << j)][j] = Math.min(dp[S | (1 << j)][j], cost);
                    }
                }
            }
                
            double min = INF;
            for(int i = 0; i < size; i++){
                //System.out.print(dp[limit - 1][i] + " ");
                min = Math.min(min, dp[limit - 1][i]);
            }
                
            //System.out.println(min);
                
            System.out.println(min == INF ? "NO" : "YES");
        }
    }
    
}