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-9;
const double pi = acos(-1);
bool Equal(double x, double y) { return fabs(x - y) < eps; }
bool Greater(double x, double y) { return x - eps > y; }
bool Lesser(double x, double y) { return x + eps < y; }
struct point {
  double x, y;
  point() { x = y = 0.0; }
  point(double _x, double _y) {
    x = _x;
    y = _y;
  }
  bool operator<(point p) const {
    if (fabs(x - p.x) > eps)
      return x < p.x;
    else
      return y < p.y;
  }
};
double dist(point A, point B) {
  return sqrt((A.x - B.x) * (A.x - B.x) + (A.y - B.y) * (A.y - B.y));
}
point pointRotate(point P, double rad) {
  return point(P.x * cos(rad) - P.y * sin(rad),
               P.x * sin(rad) + P.y * cos(rad));
}
point pointRotatePoint(point P, point Q, double rad) {
  point A = pointRotate(point(P.x - Q.x, P.y - Q.y), rad);
  A.x = A.x + Q.x;
  A.y = A.y + Q.y;
  return A;
}
struct line {
  double a, b, c;
};
line pointsToLine(point A, point B) {
  line L;
  if (Equal(A.x, B.x)) {
    L.a = 1;
    L.b = 0.0;
    L.c = -A.x;
  } else {
    L.a = -(A.y - B.y) / (A.x - B.x);
    L.b = 1;
    L.c = -(L.a * A.x) - A.y;
  }
  return L;
}
bool areParallel(line L1, line L2) {
  return Equal(L1.a, L2.a) && Equal(L1.b, L2.b);
}
bool onSegment(point P, point A, point B) {
  return P.x >= min(A.x, B.x) && P.x <= max(A.x, B.x) && P.y >= min(A.y, B.y) &&
         P.y <= max(A.y, B.y);
}
bool doIntersect(point A, point B, point C, point D, point &P) {
  line L1 = pointsToLine(A, B);
  line L2 = pointsToLine(C, D);
  if (areParallel(L1, L2)) return false;
  P.x = (L2.b * L1.c - L1.b * L2.c) / (L2.a * L1.b - L1.a * L2.b);
  if (fabs(L1.b) > eps)
    P.y = -(L1.a * P.x + L1.c);
  else
    P.y = -(L2.a * P.x + L2.c);
  return true;
}
struct vec {
  double x, y;
  vec() { x = y = 0.0; }
  vec(double _x, double _y) {
    x = _x;
    y = _y;
  }
};
vec toVector(point A, point B) { return vec(B.x - A.x, B.y - A.y); }
vec scale(vec v, double s) { return vec(v.x * s, v.y * s); }
point translate(point P, vec v) { return point(P.x + v.x, P.y + v.y); }
double dotProduct(vec A, vec B) { return A.x * B.x + A.y * B.y; }
double crossProduct(vec A, vec B) { return A.x * B.y - A.y * B.x; }
double norm_sq(vec v) { return v.x * v.x + v.y * v.y; }
double distToLineOrSeg(point P, point A, point B, point &C, bool _segment) {
  vec AP = toVector(A, P), AB = toVector(A, B);
  double u = dotProduct(AP, AB) / norm_sq(AB);
  if (_segment) {
    if (u < 0.0)
      C = A;
    else if (u > 1.0)
      C = B;
    else
      C = translate(A, scale(AB, u));
  } else
    C = translate(A, scale(AB, u));
  return dist(C, P);
}
point mirrorPoint(point P, point A, point B) {
  point C, R;
  distToLineOrSeg(P, A, B, C, false);
  R = translate(P, scale(toVector(P, C), 2.0));
  return R;
}
double angle(point A, point O, point B) {
  vec OA = toVector(O, A), OB = toVector(O, B);
  return acos(dotProduct(OA, OB) / (sqrt(norm_sq(OA) * norm_sq(OB))));
}
double angleWRTx(vec v) {
  double rad = atan2(v.y, v.x);
  if (rad < 0.0) rad = 2.0 * pi + rad;
  return rad;
}
bool collinear(point P, point Q, point R) {
  return fabs(crossProduct(toVector(P, Q), toVector(P, Q))) < eps;
}
bool ccw(point P, point Q, point R) {
  if (collinear(P, Q, R))
    return crossProduct(toVector(P, Q), toVector(P, R)) >= 0;
  return crossProduct(toVector(P, Q), toVector(P, R)) > 0;
}
double angleFromLength(double A, double B, double C) {
  return acos((A * A + B * B - C * C) / (2.0 * A * B));
}
double areaFromLength(double A, double B, double C) {
  double s = (A + B + C) / 2.0;
  return sqrt(s * (s - A) * (s - B) * (s - C));
}
double rCircumCircle(double ab, double bc, double ca) {
  return ab * bc * ca / (4.0 * areaFromLength(ab, bc, ca));
}
double rCircumCircle(point A, point B, point C) {
  return rCircumCircle(dist(A, B), dist(B, C), dist(C, A));
}
double rInCircle(double ab, double bc, double ca) {
  return areaFromLength(ab, bc, ca) / (0.5 * (ab + bc + ca));
}
double rInCircle(point A, point B, point C) {
  return rInCircle(dist(A, B), dist(B, C), dist(C, A));
}
int inCircle(point p1, point p2, point p3, point &ctr, double &r) {
  r = rInCircle(p1, p2, p3);
  if (fabs(r) < eps) return 0;
  double ration = dist(p1, p2) / dist(p1, p3);
  point p = translate(p2, scale(toVector(p2, p3), ration / (1 + ration)));
  ration = dist(p2, p1) / dist(p2, p3);
  p = translate(p1, scale(toVector(p1, p3), ration / (1 + ration)));
  doIntersect(p1, p, p2, p, ctr);
  return 1;
}
double overlapCircleArea(point c1, double r1, point c2, double r2) {
  double d, rad1, rad2, area1, area2, chord;
  if (r1 > r2) {
    swap(c1, c2);
    swap(r1, r2);
  }
  d = dist(c1, c2);
  if (d >= r1 + r2) return 0;
  if (d <= r2 - r1) return pi * r1 * r1;
  rad1 = angleFromLength(r1, d, r2), rad2 = angleFromLength(r2, d, r1);
  chord = 2.0 * r1 * sin(rad1);
  area1 = (r1 * r1 * rad1) -
          ((2 * rad1 > pi) ? -1 : 1) * areaFromLength(r1, r1, chord);
  area2 = (r2 * r2 * rad2) - areaFromLength(r2, r2, chord);
  return area1 + area2;
}
bool inPolygon(point poly[], int n, point p) {
  int i, j, k;
  double totAngle = 0;
  for (i = 0; i < n; ++i)
    if (poly[i].x == p.x && poly[i].y == p.y) return true;
  for (i = 1; i < n; ++i)
    if (collinear(p, poly[i - 1], poly[i]) &&
        onSegment(p, poly[i - 1], poly[i]))
      return true;
  for (i = 1; i < n; ++i) {
    if (ccw(poly[i - 1], p, poly[i]))
      totAngle -= angle(poly[i - 1], p, poly[i]);
    else
      totAngle += angle(poly[i - 1], p, poly[i]);
  }
  return fabs(totAngle - 2.0 * pi) < eps;
}
double cross(point p1, point p2, point p3) {
  return (p2.x - p1.x) * (p3.y - p1.y) - (p2.y - p1.y) * (p3.x - p1.x);
}
vector<point> ConvexHull(int n, point ara[]) {
  int i, j, k;
  vector<point> cnvx(2 * n);
  sort(ara, ara + n);
  for (i = 0, k = 0; i < n; ++i) {
    while (k >= 2 && cross(cnvx[k - 2], cnvx[k - 1], ara[i]) <= 0) k--;
    cnvx[k++] = ara[i];
  }
  for (i = n - 2, j = k + 1; i >= 0; --i) {
    while (k >= j && cross(cnvx[k - 2], cnvx[k - 1], ara[i]) <= 0) k--;
    cnvx[k++] = ara[i];
  }
  cnvx.resize(k - 1);
  return cnvx;
}
bool check(point A, point B, int n, point p[]) {
  vector<point> baki;
  for (int i = 0; i < n; i++) {
    if (cross(A, B, p[i]) != 0) baki.push_back(p[i]);
  }
  bool flag = true;
  for (int i = 2; i < baki.size(); i++) {
    if (cross(baki[0], baki[1], baki[i]) != 0) flag = false;
  }
  if (flag) return true;
  return false;
}
int main() {
  int n;
  cin >> n;
  point p[n + 5];
  for (int i = 0; i < n; i++) cin >> p[i].x >> p[i].y;
  if (n <= 4)
    cout << "YES" << endl;
  else if (check(p[0], p[1], n, p))
    cout << "YES" << endl;
  else if (check(p[0], p[2], n, p))
    cout << "YES" << endl;
  else if (check(p[0], p[3], n, p))
    cout << "YES" << endl;
  else if (check(p[1], p[2], n, p))
    cout << "YES" << endl;
  else if (check(p[1], p[3], n, p))
    cout << "YES" << endl;
  else if (check(p[2], p[3], n, p))
    cout << "YES" << endl;
  else
    cout << "NO" << endl;
  return 0;
}
