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 long double pi = acosl(-1);
const long double radian = 180 / pi;
const long double eps = 1e-12;
inline int sgn(const long double &x) { return (x > eps) - (x < -eps); }
inline int sgn(const long long &x) {
  if (x == 0)
    return 0;
  else
    return x < 0 ? -1 : 1;
}
inline long long sqr(const long long &x) { return x * x; }
inline long double refresh(const long double &x) {
  if (x < -1 + eps)
    return -1;
  else if (x > 1 - eps)
    return 1;
  else
    return x;
}
class Point {
 public:
  long long x, y;
  Point(void) : x(0), y(0) {}
  Point(const long long &x, const long long &y) : x(x), y(y) {}
  long double length(void) const { return sqrtl(sqr(x) + sqr(y)); }
  long long length2(void) const { return sqr(x) + sqr(y); }
  long double distance(const Point &rhs) const {
    return sqrtl(sqr(rhs.x - x) + sqr(rhs.y - y));
  }
  long double distance2(const Point &rhs) const {
    return sqr(rhs.x - x) + sqr(rhs.y - y);
  }
  Point conjugate(void) const { return Point(x, -y); }
  Point normal(const bool &lft = true) const {
    return lft ? Point(-y, x) : Point(y, -x);
  }
  Point moderate(void) const {
    return *this * (this->quadrant() <= 4 ? -1 : 1);
  }
  long long vect(const Point &lhs, const Point &rhs) const {
    return (lhs - *this) * (rhs - *this);
  }
  long long scal(const Point &lhs, const Point &rhs) const {
    return (lhs - *this) & (rhs - *this);
  }
  long double distance_to_line(const Point &p, const Point &q) const {
    return fabsl(p.vect(q, *this) / p.distance(q));
  }
  long double distance_to_segment(const Point &p, const Point &q) const {
    if (p.scal(q, *this) < 0)
      return p.distance(*this);
    else if (q.scal(p, *this) < 0)
      return q.distance(*this);
    else
      return this->distance_to_line(p, q);
  }
  bool on_line(const Point &p, const Point &q) const {
    return sgn(p.vect(q, *this)) == 0;
  }
  bool on_segment(const Point &p, const Point &q) const {
    return on_line(p, q) && sgn((p.x - x) * (q.x - x)) <= 0 &&
           sgn((p.y - y) * (q.y - y)) <= 0;
  }
  Point operator+(const Point &rhs) const {
    return Point(x + rhs.x, y + rhs.y);
  }
  Point operator-(const Point &rhs) const {
    return Point(x - rhs.x, y - rhs.y);
  }
  Point operator*(const long long &rhs) const {
    return Point(x * rhs, y * rhs);
  }
  Point operator/(const long long &rhs) const {
    return Point(x / rhs, y / rhs);
  }
  long long operator*(const Point &rhs) const { return x * rhs.y - y * rhs.x; }
  long long operator&(const Point &rhs) const { return x * rhs.x + y * rhs.y; }
  Point operator<<(const Point &rhs) const {
    return Point(x * rhs.x - y * rhs.y, x * rhs.y + y * rhs.x);
  }
  long double operator^(const Point &rhs) const {
    int s = sgn(*this * rhs);
    long double a = acosl(
        refresh((long double)(*this & rhs) / this->length() / rhs.length()));
    return s < 0 ? -a : a;
  }
  bool operator==(const Point &rhs) const { return x == rhs.x && y == rhs.y; }
  inline int quadrant(void) const {
    if (x == 0 && y == 0)
      return 0;
    else if (x < 0 && y < 0)
      return 1;
    else if (x == 0 && y < 0)
      return 2;
    else if (x > 0 && y < 0)
      return 3;
    else if (x > 0 && y == 0)
      return 4;
    else if (x > 0 && y > 0)
      return 5;
    else if (x == 0 && y > 0)
      return 6;
    else if (x < 0 && y > 0)
      return 7;
    else
      return 8;
  }
  bool operator<(const Point &rhs) const {
    int lq = quadrant(), rq = rhs.quadrant();
    if (lq != rq)
      return lq < rq;
    else {
      int s = sgn(*this * rhs);
      return s != 0 ? s > 0 : sgn(length2() - rhs.length2()) < 0;
    }
  }
  bool on_left(const Point &rhs, const bool &inclusive = true) const {
    long long s = *this * rhs, t = *this & rhs;
    return s == 0 ? t >= 0 || inclusive : s > 0;
  }
  bool on_right(const Point &rhs, const bool &inclusive = true) const {
    long long s = *this * rhs, t = *this & rhs;
    return s == 0 ? t >= 0 || inclusive : s < 0;
  }
};
const int maxn = 100000 + 10;
int n;
Point p[maxn];
bool answer() {
  if (n <= 4) return true;
  vector<pair<Point, Point> > vec;
  for (int i = 1; i < n; i++)
    vec.emplace_back((p[i] - p[0]).moderate(), p[i] - p[0]);
  sort(vec.begin(), vec.end());
  vector<Point> drv;
  multiset<Point> mts;
  for (int i = 0; i < vec.size() - 1; i++) {
    drv.push_back((vec[i + 1].second - vec[i].second));
    mts.insert((*drv.rbegin()).moderate());
  }
  for (int i = 0; i < vec.size();) {
    int k = i + 1;
    for (; k < vec.size() && vec[i].first * vec[k].first == 0; k++)
      ;
    for (int j = max(0, i - 1); j < drv.size() && j < k; j++)
      mts.erase(mts.find(drv[j].moderate()));
    if (0 < i && k < vec.size())
      mts.insert((vec[k].second - vec[i - 1].second).moderate());
    if (mts.empty() || *mts.begin() * *mts.rbegin() == 0) return true;
    for (int j = max(0, i - 1); j < drv.size() && j < k; j++)
      mts.insert(drv[j].moderate());
    if (0 < i && k < vec.size())
      mts.erase(mts.find((vec[k].second - vec[i - 1].second).moderate()));
    i = k;
  }
  return false;
}
int main() {
  ios::sync_with_stdio(false);
  cin >> n;
  for (int i = 0; i < n; i++) cin >> p[i].x >> p[i].y;
  cout << (answer() ? "YES" : "NO") << endl;
  return 0;
}
