#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;
}
