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 Pi = acos(-1.0);
const long double eps = 1e-10;
const double inf = 10e30;
double R_to_Angle(double rad) { return 180 / Pi * rad; }
double Angle_to_R(double angle) { return Pi / 180 * angle; }
int sgn(long double x) {
  if (fabs(x) < eps) return 0;
  if (x < 0) return -1;
  return 1;
}
struct Point {
  double x, y;
  Point(double x = 0, double y = 0) : x(x), y(y) {}
};
Point operator+(Point A, Point B) { return Point(A.x + B.x, A.y + B.y); }
Point operator-(Point A, Point B) { return Point(A.x - B.x, A.y - B.y); }
Point operator*(Point A, double p) { return Point(A.x * p, A.y * p); }
Point operator*(double p, Point A) { return Point(p * A.x, p * A.y); }
Point operator/(Point A, double p) { return Point(A.x / p, A.y / p); }
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 - B.x * A.y; }
double distance(Point A) { return sqrt(Dot(A, A)); }
double dis(Point A, Point B) {
  return sqrt((A.x - B.x) * (A.x - B.x) + (A.y - B.y) * (A.y - B.y));
}
Point Format(Point A) {
  double L = distance(A);
  return Point(A.x / L, A.y / L);
}
Point Normal(Point A) {
  double L = distance(A);
  return Point(-A.y / L, A.x / L);
}
struct Line {
  Point v;
  Point p;
  Point p2;
  double A, B, C;
  double deg;
  Point get_point_in_line(double t) { return p + v * t; }
  Line() {}
  Line(Point p, Point v) : p(p), v(v) { deg = atan2(v.y, v.x); }
  bool operator<(const Line &L) const { return deg < L.deg; }
};
bool ToLeftTest(Point A, Point B, Point C) { return Cross(B - A, C - B) > 0; }
double Area(Point A, Point B, Point C) { return Cross(B - A, C - A) / 2.0; }
Point Rotate(Point A, double rad) {
  return Point(A.x * cos(rad) - A.y * sin(rad),
               A.x * sin(rad) + A.y * cos(rad));
}
Point B_dis_A(Point A, Point B) {
  Point S;
  S.x = 2 * A.x - B.x;
  S.y = 2 * A.y - B.y;
  return S;
}
Line getLineABC(Point P1, Point P2) {
  Line L;
  L.A = P2.y - P1.y;
  L.B = P1.x - P2.x;
  L.C = P2.x * P1.y - P1.x * P2.y;
  return L;
}
int relation(Point A, Point B, Point P) {
  int c = sgn(Cross((B - A), (P - A)));
  if (c < 0)
    return 1;
  else if (c > 0)
    return -1;
  return 0;
}
double Distance_point_to_line(Point A, Point B, Point P) {
  Point v1 = B - A, v2 = P - A;
  return fabs(Cross(v1, v2) / distance(v1));
}
bool OnSegment(Point A, Point B, Point P) {
  return sgn(Cross(A - P, B - P)) == 0 && sgn(Dot(A - P, B - P)) < 0;
}
double Distance_point_to_segment(Point A, Point B, Point P) {
  if (sgn(A.x - B.x) == 0 && sgn(A.y - B.y)) return distance(P - A);
  Point v1 = B - A, v2 = P - A, v3 = P - B;
  if (sgn(Dot(v1, v2)) < 0) return distance(v2);
  if (sgn(Dot(v1, v3)) > 0) return distance(v3);
  return fabs(Cross(v1, v2) / distance(v1));
}
Point FootPoint(Point A, Point B, Point P) {
  Point x = P - A, y = P - B, z = B - A;
  double len1 = Dot(x, z) / distance(z), len2 = -1.0 * Dot(y, z) / distance(z);
  return A + z * (len1 / (len1 + len2));
}
Point Symmetry_PL(Point A, Point B, Point P) {
  return P + (FootPoint(A, B, P) - P) * 2;
}
Point Get_line_intersection(Point A, Point v, Point B, Point w) {
  Point u = A - B;
  double t = Cross(w, u) / Cross(v, w);
  return A + v * t;
}
Point Get_intersection(Line a, Line b) {
  Point u = a.p - b.p;
  double t = Cross(b.v, u) / Cross(a.v, b.v);
  return a.p + a.v * t;
}
bool seg_cross_seg(Point a1, Point a2, Point b1, Point b2) {
  double c1 = Cross(a2 - a1, b1 - a1), c2 = Cross(a2 - a1, b2 - a1);
  double c3 = Cross(b2 - b1, a1 - b1), c4 = Cross(b2 - b1, a2 - b1);
  return (sgn(c1) * sgn(c2) < 0) && (sgn(c3) * sgn(c4) < 0) &&
         min(a1.x, a2.x) <= max(b1.x, b2.x) &&
         min(b1.x, b2.x) <= max(a1.x, a2.x) &&
         min(a1.x, a2.x) <= max(b1.x, b2.x) &&
         min(b1.x, b2.x) <= max(a1.x, a2.x);
}
Point triangle_gravity(Point A, Point B, Point C) { return (A + B + C) / 3.0; }
struct Circle {
  Point c;
  double r;
  Circle(Point c = Point(), double r = 0) : c(c), r(r) {}
  inline Point point(double rad) {
    return Point(c.x + cos(rad) * r, c.y + sin(rad) * r);
  }
};
Circle getcircle(Point A, Point B, Point C) {
  Point P1 = (A + B) * 0.5, P2 = (A + C) * 0.5;
  Point O = Get_line_intersection(P1, Normal(B - A), P2, Normal(C - A));
  return Circle(O, distance(A - O));
}
int intersection_line_circle(Line L, Circle C, vector<Point> &sol) {
  double t1, t2;
  double a = L.v.x, b = L.p.x - C.c.x, c = L.v.y, d = L.p.y - C.c.y;
  double e = a * a + c * c, f = 2 * (a * b + c * d),
         g = b * b + d * d - C.r * C.r;
  double delta = f * f - 4 * e * g;
  if (sgn(delta) < 0) return 0;
  if (sgn(delta) == 0) {
    t1 = -f / (2 * e);
    t2 = -f / (2 * e);
    sol.push_back(L.get_point_in_line(t1));
    return 1;
  }
  t1 = (-f - sqrt(delta)) / (2 * e);
  sol.push_back(L.get_point_in_line(t1));
  t2 = (-f + sqrt(delta)) / (2 * e);
  sol.push_back(L.get_point_in_line(t2));
  cout << t1 << " " << t2 << endl;
  return 2;
}
int get_circle_circle_intersection(Circle C1, Circle C2, vector<Point> &sol) {
  double d = distance(C1.c - C2.c);
  if (sgn(d) == 0) {
    if (sgn(C1.r - C2.r) == 0) return -1;
    return 0;
  }
  if (sgn(C1.r + C2.r - d) < 0) return 0;
  if (sgn(fabs(C1.r - C2.r) - d) > 0) return 0;
  double a = atan2(C2.c.y - C1.c.y, C2.c.x - C1.c.x);
  double da = acos((C1.r * C1.r + d * d - C2.r * C2.r) / (2 * C1.r * d));
  Point p1 = C1.point(a - da), p2 = C1.point(a + da);
  sol.push_back(p1);
  if (sgn(p1.x - p2.x) == 0 && sgn(p1.y - p2.y) == 0) return 1;
  sol.push_back(p2);
  return 2;
}
Point P[100005], G[100005];
int n, tot, m, T;
struct cmp {
  Point p;
  cmp(const Point &p0) { p = p0; }
  bool operator()(Point &p1, Point &p2) {
    double tmp = Cross(p1 - p, p2 - p);
    if (tmp > 0) return 1;
    if (tmp == 0 && dis(p, p1) < dis(p, p2)) return 1;
    return 0;
  }
};
void Graham(int n) {
  int k = 0;
  for (int i = 0; i < n; i++) {
    if (P[i].x < P[k].x || (P[i].x == P[k].x && P[i].y < P[k].y)) k = i;
  }
  swap(P[0], P[k]);
  sort(P + 1, P + n, cmp(P[0]));
  tot = 2, G[0] = P[0], G[1] = P[1];
  for (int i = 2; i < n; i++) {
    while (tot > 1 && sgn(Cross(G[tot - 2] - P[i], G[tot - 1] - P[i])) <= 0)
      tot--;
    G[tot++] = P[i];
  }
  G[tot] = G[0];
}
int IsPointInPolygon(Point P, Point *G) {
  int l = 1, r = tot - 2, mid;
  while (l <= r) {
    mid = (l + r) >> 1;
    int t1 = sgn(Cross(G[mid] - G[0], P - G[0]));
    int t2 = sgn(Cross(G[mid + 1] - G[0], P - G[0]));
    if (t1 >= 0 && t2 <= 0) {
      int t3 = sgn(Cross(G[mid] - P, G[mid + 1] - P));
      if (t3 < 0)
        return 0;
      else if ((t1 == 0 && mid == 1) || (t2 == 0 && mid + 1 == n - 1) ||
               t3 == 0)
        return -1;
      return 1;
    } else if (t1 < 0)
      r = mid - 1;
    else
      l = mid + 1;
  }
  return 0;
}
double RotateCalipers(int n) {
  int q = 1;
  double ans = 0;
  G[tot] = G[0];
  for (int i = 0; i < tot; i++) {
    while (Cross(G[i] - G[q + 1], G[i + 1] - G[q + 1]) >
           Cross(G[i] - G[q], G[i + 1] - G[q]))
      q = (q + 1) % tot;
    ans =
        max(ans, max(dis(G[i], G[q]), dis(G[(i + 1) % tot], G[(q + 1) % tot])));
  }
  return ans;
}
bool cmpxy(Point A, Point B) {
  if (A.x != B.x) return A.x < B.x;
  return A.y < B.y;
}
bool mpt_cmpy(const int &a, const int &b) { return P[a].y < P[b].y; }
int mpt[200005];
double Closest_Pair(int l, int r) {
  double d = inf;
  if (l == r) return d;
  if (l + 1 == r) return d;
  int mid = (l + r) >> 1;
  double d1 = Closest_Pair(l, mid);
  double d2 = Closest_Pair(mid + 1, r);
  d = min(d1, d2);
  int cnt = 0;
  for (int i = l; i <= r; i++) {
    if (fabs(P[mid].x - P[i].x) <= d) mpt[cnt++] = i;
  }
  sort(mpt, mpt + cnt, mpt_cmpy);
  for (int i = 0; i < cnt; i++) {
    for (int j = i + 1; j < cnt && P[mpt[j]].y - P[mpt[i]].y < d; j++) {
      double d3 = dis(P[mpt[i]], P[mpt[j]]);
      if (d > d3) d = d3;
    }
  }
  return d;
}
Line L[100005];
int cnt = 0;
bool on_left(Line L, Point P) { return Cross(L.v, P - L.p) > 0; }
int half_plane_intersection(int n) {
  sort(L, L + n);
  int first = 0, last = 0;
  Point *p = new Point[n];
  Line *q = new Line[n];
  q[0] = L[0];
  for (int i = 1; i < n; ++i) {
    while (first < last && !on_left(L[i], p[last - 1])) last--;
    while (first < last && !on_left(L[i], p[first])) first++;
    q[++last] = L[i];
    if (fabs(Cross(q[last].v, q[last - 1].v)) < eps) {
      last--;
      if (on_left(q[last], L[i].p)) q[last] = L[i];
    }
    if (first < last) p[last - 1] = Get_intersection(q[last - 1], q[last]);
  }
  while (first < last && !on_left(q[first], p[last - 1])) last--;
  if (last - first <= 1) return 0;
  p[last] = Get_intersection(q[last], q[first]);
  for (int i = first; i <= last; i++) G[cnt++] = p[i];
  return cnt;
}
int p3;
bool flag;
void check(int a, int b, int c) {
  int d = -1;
  int sum = 0;
  for (int i = 2; i < n; i++) {
    if (i == p3) continue;
    if (relation(P[a], P[b], P[i]) == 0) {
      sum++;
    } else {
      if (d == -1) d = i;
      if (relation(P[c], P[d], P[i]) == 0) {
        sum++;
      }
    }
  }
  if (sum == n - 3) flag = 1;
}
int main() {
  scanf("%d", &n);
  if (n <= 4) {
    printf("YES\n");
    return 0;
  }
  for (int i = 0; i < n; i++) {
    scanf("%lf%lf", &P[i].x, &P[i].y);
  }
  int k = 0;
  for (int i = 0; i < n; i++) {
    if (P[i].x < P[k].x || (P[i].x == P[k].x && P[i].y < P[k].y)) k = i;
  }
  swap(P[0], P[k]);
  sort(P + 1, P + n, cmp(P[0]));
  for (int i = 2; i < n; i++) {
    if (relation(P[0], P[1], P[i]) != 0) {
      p3 = i;
      break;
    }
  }
  if (p3 == 0) {
    printf("YES\n");
    return 0;
  }
  check(0, 1, p3);
  check(0, p3, 1);
  check(1, p3, 0);
  if (flag == 1) {
    printf("YES\n");
  } else {
    printf("NO\n");
  }
  return 0;
}
