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_0 {
    public static void main(String[] args)throws Exception {
        FastReader in = new FastReader(System.in);
        PrintWriter pw = new PrintWriter(System.out);
        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{
            TreeMap<Rational, List<Integer>> map = new TreeMap<>();
            int s = 0;
            for(int i = 0; i < n; i++){
                if(s == i) continue;
                Rational r = new Rational(y[s] - y[i], x[s] - x[i]);
                map.putIfAbsent(r, new ArrayList<>());
                map.get(r).add(i);
            }

            if(map.size() <= 1) pw.println("YES");
            else{
                boolean ok = solve(n, x, y, 0);
                int count = 0;
                for(Map.Entry<Rational, List<Integer>> entry : map.entrySet()){
                    ok |= solve(n, x, y, entry.getValue().get(0));
                    count++;
                    if(ok || count >= 4) break;
                }
                if(ok) pw.println("YES");
                else pw.println("NO");
            }
        }


        pw.close();
    }

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

        boolean foundOneLine = false;
        boolean [] b = new boolean[n];
        for(Map.Entry<Rational, List<Integer>> entry: map.entrySet()){
            if(entry.getValue().size() >= 2){
                foundOneLine = true;
                b[s] = true;
                for(int k : entry.getValue()){
                    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;
                }
            }

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

            // debug(s, set);
            if(set.size() <= 1) return true;
            else return false;

        }
    }

    static class Rational implements Comparable<Rational> {
        private static Rational zero = new Rational(0, 1);

        private int num;   // the numerator
        private int den;   // the denominator

        // create and initialize a new Rational object
        public Rational(int numerator, int denominator) {


            // reduce fraction
            int g = gcd(numerator, denominator);
            num = numerator / g;
            den = denominator / g;



            // needed only for negative numbers
            if (den < 0) {
                den = -den;
                num = -num;
            }
        }

        // return the numerator and denominator of (this)
        public int numerator() {
            return num;
        }

        public int denominator() {
            return den;
        }

        // return double precision representation of (this)
        public double toDouble() {
            return (double) num / den;
        }

        // return string representation of (this)
        public String toString() {
            if (den == 1) return num + "";
            else return num + "/" + den;
        }

        // return { -1, 0, +1 } if a < b, a = b, or a > b
        public int compareTo(Rational b) {
            Rational a = this;
            long lhs = (long)a.num * (long)b.den;
            long rhs = (long)a.den * (long)b.num;
            if (lhs < rhs) return -1;
            if (lhs > rhs) return +1;
            return 0;
        }

        // is this Rational object equal to y?
        public boolean equals(Object y) {
            if (y == null) return false;
            if (y.getClass() != this.getClass()) return false;
            Rational b = (Rational) y;
            return compareTo(b) == 0;
        }

        // hashCode consistent with equals() and compareTo()
        // (better to hash the numerator and denominator and combine)
        public int hashCode() {
            return this.toString().hashCode();
        }


        // create and return a new rational (r.num + s.num) / (r.den + s.den)
        public static Rational mediant(Rational r, Rational s) {
            return new Rational(r.num + s.num, r.den + s.den);
        }

        // return gcd(|m|, |n|)
        private static int gcd(int m, int n) {
            if (m < 0) m = -m;
            if (n < 0) n = -n;
            if (0 == n) return m;
            else return gcd(n, m % n);
        }

        // return lcm(|m|, |n|)
        private static int lcm(int m, int n) {
            if (m < 0) m = -m;
            if (n < 0) n = -n;
            return m * (n / gcd(m, n));    // parentheses important to avoid overflow
        }

        // return a * b, staving off overflow as much as possible by cross-cancellation
        public Rational times(Rational b) {
            Rational a = this;

            // reduce p1/q2 and p2/q1, then multiply, where a = p1/q1 and b = p2/q2
            Rational c = new Rational(a.num, b.den);
            Rational d = new Rational(b.num, a.den);
            return new Rational(c.num * d.num, c.den * d.den);
        }


        // return a + b, staving off overflow
        public Rational plus(Rational b) {
            Rational a = this;

            // special cases
            if (a.compareTo(zero) == 0) return b;
            if (b.compareTo(zero) == 0) return a;

            // Find gcd of numerators and denominators
            int f = gcd(a.num, b.num);
            int g = gcd(a.den, b.den);

            // add cross-product terms for numerator
            Rational s = new Rational((a.num / f) * (b.den / g) + (b.num / f) * (a.den / g),
                    lcm(a.den, b.den));

            // multiply back in
            s.num *= f;
            return s;
        }

        // return -a
        public Rational negate() {
            return new Rational(-num, den);
        }

        // return |a|
        public Rational abs() {
            if (num >= 0) return this;
            else return negate();
        }

        // return a - b
        public Rational minus(Rational b) {
            Rational a = this;
            return a.plus(b.negate());
        }


        public Rational reciprocal() {
            return new Rational(den, num);
        }

        // return a / b
        public Rational divides(Rational b) {
            Rational a = this;
            return a.times(b.reciprocal());
        }
    }


    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);
        }*/
    }
}