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.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.BitSet;
import java.util.List;

public class Solution {

    public static void main(String[] args) throws IOException {
        try (BufferedReader br = new BufferedReader(new InputStreamReader(System.in))) {
            String l1 = br.readLine();
            int n = Integer.parseInt(l1.trim());

            Point[] points = new Point[n];

            for (int i = 0; i < n; i++) {
                String l = br.readLine();
                String[] parts = l.split("\\s");
                points[i] = new Point(Integer.parseInt(parts[0].trim()), Integer.parseInt(parts[1].trim()));
            }

            if (n <= 4) {
                System.out.println("YES");
                return;
            }

            List<Ray> rays1 = new ArrayList<>();

            int initialPointsIdx;
            for (initialPointsIdx = 1; initialPointsIdx < n; initialPointsIdx++) {
                Point pt = points[initialPointsIdx];
                Ratio r = new Ratio(points[0], pt);
                boolean found = false;
                for (Ray ray : rays1) {
                    if (ray.r.equals(r)) {
                        ray.pts.add(pt);
                        found = true;
                        break;
                    }
                }
                if (!found) {
                    rays1.add(new Ray(r, pt));
                }
                if (rays1.size() == 3) {
                    break;
                }
            }
            if (rays1.size() == 3) {
                for (int rayIdx = 0; rayIdx < rays1.size(); rayIdx++) {
                    Ray ray = rays1.get(rayIdx);
                    if (ray.pts.size() > 1) {
                        // other 2 rays should have 1 point each
                        Ray ray1 = null;
                        Ray ray2 = null;
                        for (int otherRayIdx = 0; otherRayIdx < rays1.size(); otherRayIdx++) {
                            if (otherRayIdx == rayIdx) {
                                continue;
                            }
                            Ray otherRay = rays1.get(otherRayIdx);
                            if (otherRay.pts.size() > 1) {
                                System.out.println("NO");
                                return;
                            }
                            if (ray1 == null) {
                                ray1 = otherRay;
                            } else {
                                ray2 = otherRay;
                            }
                        }
                        Point pt2 = ray1.pts.get(0);
                        Point pt3 = ray2.pts.get(0);
                        Ray ray23 = new Ray(new Ratio(pt2, pt3), pt3);
                        // all should be on r and r23
                        for (int i = initialPointsIdx + 1; i < n; i++) {
                            Ratio r1i = new Ratio(points[0], points[i]);
                            if (r1i.equals(ray.r)) {
                                continue;
                            }
                            Ratio r2i = new Ratio(pt2, points[i]);
                            if (r2i.equals(ray23.r)) {
                                continue;
                            }
                            System.out.println("NO");
                            return;
                        }
                        System.out.println("YES");
                        return;
                    }
                }
                // all rays have 1 pt each
                Ray ray1 = rays1.get(0);
                Ray ray2 = rays1.get(1);
                Ray ray3 = rays1.get(2);
                Point p1 = ray1.pts.get(0);
                Point p2 = ray2.pts.get(0);
                Ray ray12 = new Ray(new Ratio(p1, p2), p2);
                // is the third point on the same ray?
                Point p3 = ray3.pts.get(0);
                Ratio ratio13 = new Ratio(p1, p3);
                if (ratio13.equals(ray12.r)) {
                    // find all points on this ray, then check that all other are on 1 ray too
                    BitSet excl = new BitSet(n);
                    excl.set(1);
                    excl.set(2);
                    excl.set(3);
                    for (int i = initialPointsIdx + 1; i < n; i++) {
                        Ratio r1i = new Ratio(p1, points[i]);
                        if (r1i.equals(ray12.r)) {
                            excl.set(i);
                        }
                    }
                    // now we should only have those not on ray12 (including p0)
                    int next = excl.nextClearBit(1);
                    if (next < 0 || next >= n) { // just one point not on ray12
                        System.out.println("YES");
                        return;
                    }
                    Ratio r0n = new Ratio(points[0], points[next]);
                    for (int i = next + 1; i < n; i++) {
                        if (!excl.get(i)) {
                            Ratio r0i = new Ratio(points[0], points[i]);
                            if (!r0i.equals(r0n)) {
                                System.out.println("NO");
                                return;
                            }
                        }
                    }
                    System.out.println("YES");
                    return;
                } else {
                    // one of the rays is correct, find the other one
                    { // ray1 and pt2->pt3 ?
                        Ratio r01 = ray1.r;
                        Ratio r23 = new Ratio(p2, p3);
                        boolean notThis = false;
                        for (int i = initialPointsIdx + 1; i < n; i++) {
                            Ratio r0i = new Ratio(points[0], points[i]);
                            if (r0i.equals(r01)) {
                                continue;
                            }
                            Ratio r2i = new Ratio(p2, points[i]);
                            if (r2i.equals(r23)) {
                                continue;
                            }
                            notThis = true;
                            break;
                        }
                        if (!notThis) {
                            System.out.println("YES");
                            return;
                        }
                    }
                    { // ray2 and pt1->pt3 ?
                        Ratio r02 = ray2.r;
                        Ratio r13 = new Ratio(p1, p3);
                        boolean notThis = false;
                        for (int i = initialPointsIdx + 1; i < n; i++) {
                            Ratio r0i = new Ratio(points[0], points[i]);
                            if (r0i.equals(r02)) {
                                continue;
                            }
                            Ratio r1i = new Ratio(p1, points[i]);
                            if (r1i.equals(r13)) {
                                continue;
                            }
                            notThis = true;
                            break;
                        }
                        if (!notThis) {
                            System.out.println("YES");
                            return;
                        }
                    }
                    { // ray3 and pt1->pt2 ?
                        Ratio r03 = ray3.r;
                        Ratio r12 = new Ratio(p1, p2);
                        boolean notThis = false;
                        for (int i = initialPointsIdx + 1; i < n; i++) {
                            Ratio r0i = new Ratio(points[0], points[i]);
                            if (r0i.equals(r03)) {
                                continue;
                            }
                            Ratio r1i = new Ratio(p1, points[i]);
                            if (r1i.equals(r12)) {
                                continue;
                            }
                            notThis = true;
                            break;
                        }
                        if (!notThis) {
                            System.out.println("YES");
                            return;
                        }
                    }
                    System.out.println("NO");
                    return;
                }
            } else { // all in 1 or 2 rays -- ok
                System.out.println("YES");
                return;
            }
        }
    }

   private static class Ray {
        Ratio r;
        List<Point> pts = new ArrayList<>(1);

        public Ray(Ratio r, Point pt) {
            this.r = r;
            pts.add(pt);
        }
    }

    private static class Point {
        int x, y;

        public Point(int x, int y) {
            this.x = x;
            this.y = y;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;

            Point point = (Point) o;

            if (x != point.x) return false;
            return y == point.y;
        }

        @Override
        public int hashCode() {
            int result = x;
            result = 31 * result + y;
            return result;
        }
    }

    private static class Ratio {
        int dx, dy;

        public Ratio(Point pt1, Point pt2) {
            dx = pt1.x - pt2.x;
            dy = pt1.y - pt2.y;

        }

        @Override
        public boolean equals(Object obj) {
            if (this == obj) {
                return true;
            }
            if (obj == null || obj.getClass() != Ratio.class) {
                return false;
            }
            Ratio that = (Ratio) obj;
            return ((long)dy) * that.dx == ((long)dx) * that.dy;
        }
    }
}