/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
import java.io.BufferedReader;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.TreeSet;
import static java.lang.System.out;
/**
 *
 * @author cteam059
 */
public class polygon {
    
    private static class Edge implements Comparable<Edge> {
        int x1;
        int y1;
        int x2;
        int y2;

        public Edge(int x1, int y1, int x2, int y2) {
            if(x1 < x2) {
            this.x1 = x1;
            this.y1 = y1;
            this.x2 = x2;
            this.y2 = y2;
            } else  {
            this.x2 = x1;
            this.y2 = y1;
            this.x1 = x2;
            this.y1 = y2;
            } 
                
        }

        public int compareTo(Edge e) {
            return x1 - e.x1;
        } 
        
    }
    
    private static boolean intersect(Edge e1, Edge e2)
    {
        return ((ccw(e1.x1, e1.y1, e1.x2, e1.y2, e2.x1, e2.y1)
                *ccw(e1.x1, e1.y1, e1.x2, e1.y2, e2.x2, e2.y2)) <= 0)
           && ((ccw(e2.x1, e2.y1, e2.x2, e2.y2, e1.x1, e1.y1)
                *ccw(e2.x1, e2.y1, e2.x2, e2.y2, e1.x2, e1.y2)) <= 0);
    }
    
    private static int ccw(int x0, int y0, int x1, int y1, int x2, int y2)
    {
        int dx1, dx2, dy1, dy2;
        
        dx1 = x1 - x0; dy1 = y1 - y0;
        dx2 = x2 - x0; dy2 = y2 - y0;
        
        if ( dx1*dy2 > dy1*dx2) return + 1;
        if ( dx1*dy2 < dy1*dx2) return - 1;
        
        if ( (dx1*dx2 < 0) || (dy1*dy2 < 0) ) return -1;
        if ( (dx1*dx1+dy1*dy1) < (dx2*dx2+dy2*dy2) ) return +1;
    
        return 0;
        
    }    
    
    
/*    private int ccw(int x1, int y1, int x2, int y2, int x3, int y3)
    {
        int dx1, dx2, dy1, dy2;
        
        dx1 = p1.x - p0.x; dy1 = p1.y - p0.y;
        dx2 = p2.x - p0.x; dy2 = p2.y - p0.y;
        
        if ( dx1*dy2 > dy1*dx2) return + 1
        if ( dx1*dy2 < dy1*dx2) return - 1;
        
        if ( (dx1*dx2 < 0) || (dy1*dy2 < 0) ) return -1;
        if ( (dx1*dx1+dy1*dy1) < (dx2*dx2+dy2*dy2) ) return +1;
    
        return 0;
        
    }*/
    
    public static void main(String args[]) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int count = Integer.parseInt(br.readLine());
        while(count != 0) {
            String line = br.readLine();
            StringTokenizer tokenizer = new StringTokenizer(line);
            int lastX = Integer.parseInt(tokenizer.nextToken());
            int lastY = Integer.parseInt(tokenizer.nextToken());
            
            //List<Edge> edges = new ArrayList(count);
            
            Set<Integer> xValues = new TreeSet<Integer>();
            Map<Integer, List<Edge>> start = new HashMap<Integer, List<Edge>>();
            Map<Integer, List<Edge>> end = new HashMap<Integer, List<Edge>>();
            xValues.add(lastX);
            start.put(lastX, new ArrayList<Edge>());
            end.put(lastX, new ArrayList<Edge>());
            //out.println("count" + count);
            for(int i = 1; i < count; i ++) {
                line = br.readLine();
                tokenizer = new StringTokenizer(line);
                int x = Integer.parseInt(tokenizer.nextToken());
                int y = Integer.parseInt(tokenizer.nextToken());
                xValues.add(x);
                start.put(x, new ArrayList<Edge>());
                end.put(x, new ArrayList<Edge>());
                Edge e = new Edge(x,y,lastX,lastY);
                start.get(e.x1).add(e);
                end.get(e.x2).add(e);
                lastX = x;
                lastY = y;
            }

            boolean simple = true;
            List<Edge> openEdges = new ArrayList(count);
            for(Integer xValue : xValues) {
                openEdges.removeAll(end.get(xValue));
                
                List<Edge> current = start.get(xValue);
                
                for(Edge e1 : current) {
                    for(Edge e2: openEdges) {
                        if( intersect(e1, e2) ) {
                            simple = false;
                            break;
                        }
                    }
                    if(!simple)
                        break;
                }
                if(!simple)
                        break;
                
                openEdges.addAll(current);
                openEdges.removeAll(end.get(xValue));
            }
            
            if(simple)
            {
              out.println("YES");
            }
            else
            {
              out.println("NO");
            }
            
            count = Integer.parseInt(br.readLine());
        }
    }

}