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