You are given n points on Cartesian plane. Every point is a lattice point (i. e. both of its coordinates are integers), and all points are distinct.

You may draw two straight lines (not necessarily distinct). Is it possible to do this in such a way that every point lies on at least one of these lines?

Input

The first line contains one integer n (1 ≤ n ≤ 105) — the number of points you are given.

Then n lines follow, each line containing two integers xi and yi (|xi|, |yi| ≤ 109)— coordinates of i-th point. All n points are distinct.

Output

If it is possible to draw two straight lines in such a way that each of given points belongs to at least one of these lines, print YES. Otherwise, print NO.

Examples

Input

5
0 0
0 1
1 1
1 -1
2 2


Output

YES


Input

5
0 0
1 0
2 1
1 1
2 3


Output

NO

Note

In the first example it is possible to draw two lines, the one containing the points 1, 3 and 5, and another one containing two remaining points.

<image>
import java.io.*;
import java.util.*;
import static java.lang.Math.*;

public class D_2 {
    public static void main(String[] args)throws Exception {
        FastReader in = new FastReader(System.in);
        PrintWriter pw = new PrintWriter(System.out);

        //long start = System.currentTimeMillis();
        //in = new FastReader(new FileInputStream("in.txt"));

        int n = in.nextInt();
        int x[] = new int[n];
        int y[]=  new int[n];
        for (int i = 0; i < n; i++) {
            x[i] = in.nextInt(); y[i] = in.nextInt();
        }

        if(n <= 4) pw.println("YES");

        else{
            HashMap<Long, List<Integer>> map = new HashMap<>();
            int s = 0;
            for(int i = 0; i < n; i++){
                if(s == i) continue;
                long r = getRationalHash(x[s], y[s], x[i], y[i]);
                map.putIfAbsent(r, new ArrayList<>());
                map.get(r).add(i);
            }

            if(map.size() <= 1) pw.println("YES");
            else{
                boolean ok = false;
                int count = 0;
                for(long r : map.keySet()){
                    List<Integer> l = map.get(r);
                    ok |= solve(n, x, y, l.get(0));
                    count++;
                    if(ok || count >= 3) break;
                }
                if(ok) pw.println("YES");
                else pw.println("NO");
            }
        }


        pw.close();
    }

    static boolean solve(int n, int x[], int y[], int s){
        HashMap<Long, List<Integer>> map = new HashMap<>();
        for(int i = 0; i < n; i++){
            if(s == i) continue;
            long r = getRationalHash(x[s], y[s], x[i], y[i]);
            map.putIfAbsent(r, new ArrayList<>());
            map.get(r).add(i);
        }

        boolean foundOneLine = false;
        boolean [] b = new boolean[n];
        for(long r : map.keySet()){
            List<Integer> l = map.get(r);
            if(l.size() >= 2){
                foundOneLine = true;
                b[s] = true;
                for(int k : l){
                    b[k] = true;
                }
                break;
            }
        }

        //debug(s, map);


        if(!foundOneLine){
            return false;
        }

        else{
            for (int i = 0; i < n; i++) {
                if(!b[i]){
                    s = i; break;
                }
            }

            HashSet<Long> set = new HashSet<>();
            for (int i = 0; i < n; i++) {
                if(s != i && !b[i]){
                    long r = getRationalHash(x[s], y[s], x[i], y[i]);
                    set.add(r);
                }
            }

            //debug(s, set);

            if(set.size() <= 1) return true;
            else return false;

        }
    }


    static long gcd_non_rec (long a, long b) {
        long r, i;
        while(b!=0){
            r = a % b;
            a = b;
            b = r;
        }
        return a;
    }

    static long gcd(long p, long q) {
        if (q == 0) return p;
        else return gcd(q, p % q);
    }


    static long getRationalHash(long x1, long y1, long x2, long y2){
        long y = y1 - y2, x = x1 - x2;
        if(x == 0){
            y = 1;
            return y << 31l;
        }
        if(y == 0){
            x = 1;
            return x;
        }
        long g = gcd_non_rec(abs(x), abs(y));
        x /= g; y /= g;

        if(x < 0 && y < 0){
             x *= -1; y *= -1;
        }
        else if(x < 0){
            x *= -1; y *= -1;
        }

        long h = (y << 31l) | x;
        return h;
    }


    static void debug(Object...obj) {
        System.err.println(Arrays.deepToString(obj));
    }

    static class FastReader {
        InputStream is;
        private byte[] inbuf = new byte[1024];
        private int lenbuf = 0, ptrbuf = 0;
        static final int ints[] = new int[128];

        public FastReader(InputStream is){
            for(int i='0';i<='9';i++) ints[i]=i-'0';
            this.is = is;
        }

        public int readByte(){
            if(lenbuf == -1)throw new InputMismatchException();
            if(ptrbuf >= lenbuf){
                ptrbuf = 0;
                try { lenbuf = is.read(inbuf); } catch (IOException e) { throw new InputMismatchException(); }
                if(lenbuf <= 0)return -1;
            }
            return inbuf[ptrbuf++];
        }

        public boolean isSpaceChar(int c) {
            return !(c >= 33 && c <= 126);
        }
        public int skip() {
            int b;
            while((b = readByte()) != -1 && isSpaceChar(b));
            return b;
        }

        public String next(){
            int b = skip();
            StringBuilder sb = new StringBuilder();
            while(!(isSpaceChar(b))){ // when nextLine, (isSpaceChar(b) && b != ' ')
                sb.appendCodePoint(b);
                b = readByte();
            }
            return sb.toString();
        }

        public int nextInt(){
            int num = 0, b;
            boolean minus = false;
            while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
            if(b == '-'){
                minus = true;
                b = readByte();
            }

            while(true){
                if(b >= '0' && b <= '9'){
                    num = (num<<3) + (num<<1) + ints[b];
                }else{
                    return minus ? -num : num;
                }
                b = readByte();
            }
        }

        public long nextLong() {
            long num = 0;
            int b;
            boolean minus = false;
            while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
            if(b == '-'){
                minus = true;
                b = readByte();
            }

            while(true){
                if(b >= '0' && b <= '9'){
                    num = (num<<3) + (num<<1) + ints[b];
                }else{
                    return minus ? -num : num;
                }
                b = readByte();
            }
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }
       /* public char nextChar() {
            return (char)skip();
        }*/

        public char[] next(int n){
            char[] buf = new char[n];
            int b = skip(), p = 0;
            while(p < n && !(isSpaceChar(b))){
                buf[p++] = (char)b;
                b = readByte();
            }
            return n == p ? buf : Arrays.copyOf(buf, p);
        }

        /*private char buff[] = new char[1005];
        public char[] nextCharArray(){
            int b = skip(), p = 0;
            while(!(isSpaceChar(b))){
                buff[p++] = (char)b;
                b = readByte();
            }
            return Arrays.copyOf(buff, p);
        }*/
    }
}