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>
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-10;
struct Point {
  double x, y;
  Point() {}
  Point(double _x, double _y) : x(_x), y(_y) {}
  Point operator+(const Point &p) { return Point(x + p.x, y + p.y); }
  Point operator-(const Point &p) { return Point(x - p.x, y - p.y); }
  Point operator*(const double k) { return Point(x * k, y * k); }
  double abs() { return sqrt(norm()); }
  double norm() { return x * x + y * y; }
  bool operator<(const Point &p) const {
    return !(fabs((x) - (p.x)) < EPS) ? x < p.x : y < p.y;
  }
  bool operator==(const Point &p) const {
    return (fabs((x) - (p.x)) < EPS) && (fabs((y) - (p.y)) < EPS);
  }
};
struct Segment {
  Point p1, p2;
  Segment() {}
  Segment(Point _p1, Point _p2) : p1(_p1), p2(_p2) {}
};
double norm(Point a) { return a.x * a.x + a.y * a.y; }
double abs(Point a) { return sqrt(norm(a)); }
double dot(Point a, Point b) { return a.x * b.x + a.y * b.y; }
double cross(Point a, Point b) { return a.x * b.y - a.y * b.x; }
bool isOrthogonal(Point a, Point b) {
  return (fabs((dot(a, b)) - (0.0)) < EPS);
}
bool isOrthogonal(Point a1, Point a2, Point b1, Point b2) {
  return isOrthogonal(a1 - a2, b1 - b2);
}
bool isOrthogonal(Segment s1, Segment s2) {
  return (fabs((dot(s1.p2 - s1.p1, s2.p2 - s2.p1)) - (0.0)) < EPS);
}
bool isParallel(Point a, Point b) {
  return (fabs((cross(a, b)) - (0.0)) < EPS);
}
bool isParallel(Point a1, Point a2, Point b1, Point b2) {
  return isParallel(a1 - a2, b1 - b2);
}
bool isParallel(Segment s1, Segment s2) {
  return (fabs((cross(s1.p2 - s1.p1, s2.p2 - s2.p1)) - (0.0)) < EPS);
}
Point project(Segment s, Point p) {
  Point base = s.p2 - s.p1;
  double r = dot(p - s.p1, base) / norm(base);
  return s.p1 + base * r;
}
Point reflect(Segment s, Point p) { return p + (project(s, p) - p) * 2.0; }
double getDistance(Point a, Point b) { return abs(a - b); }
double getDistanceLP(Segment l, Point p) {
  return abs(cross(l.p2 - l.p1, p - l.p1) / abs(l.p2 - l.p1));
}
double getDistanceSP(Segment s, Point p) {
  if (dot(s.p2 - s.p1, p - s.p1) < 0.0) return abs(p - s.p1);
  if (dot(s.p1 - s.p1, p - s.p2) < 0.0) return abs(p - s.p2);
  return getDistanceLP(s, p);
}
int n;
double x, y;
vector<Point> v;
void solve() {
  if (v.size() <= 3) {
    printf("YES\n");
    return;
  }
  Point v1 = v[0];
  Point v2 = v[1];
  Point v3 = v[2];
  Segment l1 = Segment(v1, v2);
  Segment l2 = Segment(v1, v3);
  Segment l3 = Segment(v2, v3);
  if ((fabs((getDistanceLP(l1, v3)) - (0.0)) < EPS)) {
    bool flag = true;
    for (int i = 3; i < v.size(); i++) {
      if (!(fabs((getDistanceLP(l1, v[i])) - (0.0)) < EPS)) {
        flag = false;
        break;
      }
    }
    if (flag) {
      printf("YES\n");
      return;
    }
  }
  vector<Point> tmp;
  for (int i = 0; i < v.size(); i++) {
    if (!(fabs((getDistanceLP(l1, v[i])) - (0.0)) < EPS)) {
      tmp.push_back(v[i]);
    }
  }
  if (tmp.size() <= 2) {
    printf("YES\n");
    return;
  } else {
    Point p1 = tmp[0];
    Point p2 = tmp[1];
    Segment l2 = Segment(p1, p2);
    bool flag = true;
    for (int i = 0; i < tmp.size(); i++) {
      if (!(fabs((getDistanceLP(l2, tmp[i])) - (0.0)) < EPS)) {
        flag = false;
        break;
      }
    }
    if (flag) {
      printf("YES\n");
      return;
    }
  }
  tmp.clear();
  for (int i = 0; i < v.size(); i++) {
    if (!(fabs((getDistanceLP(l2, v[i])) - (0.0)) < EPS)) {
      tmp.push_back(v[i]);
    }
  }
  if (tmp.size() <= 2) {
    printf("YES\n");
    return;
  } else {
    Point p1 = tmp[0];
    Point p2 = tmp[1];
    Segment l2 = Segment(p1, p2);
    bool flag = true;
    for (int i = 0; i < tmp.size(); i++) {
      if (!(fabs((getDistanceLP(l2, tmp[i])) - (0.0)) < EPS)) {
        flag = false;
        break;
      }
    }
    if (flag) {
      printf("YES\n");
      return;
    }
  }
  tmp.clear();
  for (int i = 0; i < v.size(); i++) {
    if (!(fabs((getDistanceLP(l3, v[i])) - (0.0)) < EPS)) {
      tmp.push_back(v[i]);
    }
  }
  if (tmp.size() <= 2) {
    printf("YES\n");
    return;
  } else {
    Point p1 = tmp[0];
    Point p2 = tmp[1];
    Segment l2 = Segment(p1, p2);
    bool flag = true;
    for (int i = 0; i < tmp.size(); i++) {
      if (!(fabs((getDistanceLP(l2, tmp[i])) - (0.0)) < EPS)) {
        flag = false;
        break;
      }
    }
    if (flag) {
      printf("YES\n");
      return;
    }
  }
  printf("NO\n");
}
int main() {
  while (~scanf("%d", &n)) {
    v.clear();
    for (int i = 0; i < n; i++) {
      scanf("%lf %lf", &x, &y);
      v.push_back(Point(x, y));
    }
    solve();
  }
  return 0;
}
