For a given polygon g, print "1" if g is a convex polygon, "0" otherwise. Here, in a convex polygon, all interior angles are less than or equal to 180 degrees.

g is represented by a sequence of points p1, p2,..., pn where line segments connecting pi and pi+1 (1 ≤ i ≤ n-1) are sides of the polygon. The line segment connecting pn and p1 is also a side of the polygon.

Constraints

* 3 ≤ n ≤ 100
* -10000 ≤ xi, yi ≤ 10000
* No point of the polygon will occur more than once.
* Two sides of the polygon can intersect only at a common endpoint.

Input

g is given by coordinates of the points p1,..., pn in the following format:


n
x1 y1
x2 y2
:
xn yn


The first integer n is the number of points. The coordinate of a point pi is given by two integers xi and yi. The coordinates of points are given in the order of counter-clockwise visit of them.

Output

Print "1" or "0" in a line.

Examples

Input

4
0 0
3 1
2 3
0 3


Output

1


Input

5
0 0
2 0
1 1
2 2
0 2


Output

0
#include <bits/stdc++.h>
using namespace std;
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
constexpr ll TEN(int n) { return (n == 0) ? 1 : 10 * TEN(n - 1); }
template <class T>
using V = vector<T>;
template <class T>
using VV = V<V<T>>;
template <class T>
ostream &operator<<(ostream &os, const V<T> &v) {
  os << "[";
  for (auto p : v) os << p << ", ";
  os << "]";
  return os;
}
using D = double;
const D PI = acos(D(-1)), EPS = 1e-10;
int sgn(D a) { return (abs(a) <= EPS) ? 0 : (a < 0 ? -1 : 1); }
int sgn(D a, D b) { return sgn(a - b); }
struct Pt2 {
  D x, y;
  Pt2() {}
  Pt2(D _x, D _y) : x(_x), y(_y) {}
  Pt2 operator+(const Pt2 &r) const { return Pt2(x + r.x, y + r.y); }
  Pt2 operator-(const Pt2 &r) const { return Pt2(x - r.x, y - r.y); }
  Pt2 operator*(const Pt2 &r) const {
    return Pt2(x * r.x - y * r.y, x * r.y + y * r.x);
  }
  Pt2 operator*(const D &r) const { return Pt2(x * r, y * r); }
  Pt2 operator/(const D &r) const { return Pt2(x / r, y / r); }
  Pt2 &operator+=(const Pt2 &r) { return *this = *this + r; }
  Pt2 &operator-=(const Pt2 &r) { return *this = *this - r; }
  Pt2 &operator*=(const Pt2 &r) { return *this = *this * r; }
  Pt2 &operator*=(const D &r) { return *this = *this * r; }
  Pt2 &operator/=(const D &r) { return *this = *this / r; }
  Pt2 operator-() const { return Pt2(-x, -y); }
  bool operator<(const Pt2 &r) const {
    return 2 * sgn(x, r.x) + sgn(y, r.y) < 0;
  }
  bool operator==(const Pt2 &r) const { return sgn((*this - r).rabs()) == 0; }
  D norm() const { return x * x + y * y; }
  D abs() const { return sqrt(norm()); }
  D rabs() const { return max(std::abs(x), std::abs(y)); }
  D arg() const { return atan2(y, x); }
  pair<D, D> to_pair() const { return make_pair(x, y); }
  static Pt2 polar(D le, D th) { return Pt2(le * cos(th), le * sin(th)); }
};
ostream &operator<<(ostream &os, const Pt2 &p) {
  return os << "P(" << p.x << ", " << p.y << ")";
}
using P = Pt2;
struct L {
  P s, t;
  L() {}
  L(P _s, P _t) : s(_s), t(_t) {}
  P vec() const { return t - s; }
  D abs() const { return vec().abs(); }
  D arg() const { return vec().arg(); }
};
ostream &operator<<(ostream &os, const L &l) {
  return os << "L(" << l.s << ", " << l.t << ")";
}
D cross(P a, P b) { return a.x * b.y - a.y * b.x; }
D dot(P a, P b) { return a.x * b.x + a.y * b.y; }
int sgncrs(P a, P b) {
  D cr = cross(a, b);
  if (abs(cr) <= (a.rabs() + b.rabs()) * EPS) return 0;
  return (cr < 0) ? -1 : 1;
}
int ccw(P b, P c) {
  int s = sgncrs(b, c);
  if (s) return s;
  if (!sgn(c.rabs()) || !sgn((c - b).rabs())) return 0;
  if (dot(b, c) < 0) return 2;
  if (dot(-b, c - b) < 0) return -2;
  return 0;
}
int ccw(P a, P b, P c) { return ccw(b - a, c - a); }
int ccw(L l, P p) { return ccw(l.s, l.t, p); }
using Pol = V<P>;
D area2(const Pol &pol) {
  D u = 0;
  P a = pol.back();
  for (auto b : pol) u += cross(a, b), a = b;
  return u;
}
int contains(const Pol &pol, P p) {
  int in = -1;
  P _a, _b = pol.back();
  for (int i = 0; i < int(pol.size()); i++) {
    _a = _b;
    _b = pol[i];
    P a = _a, b = _b;
    if (ccw(a, b, p) == 0) return 1;
    if (a.y > b.y) swap(a, b);
    if (!(a.y <= p.y && p.y < b.y)) continue;
    if (sgn(a.y, p.y) ? (cross(a - p, b - p) > 0) : (a.x > p.x)) in *= -1;
  }
  return in + 1;
}
Pol convex(Pol p) {
  sort(begin(p), end(p));
  p.erase(unique(begin(p), end(p)), end(p));
  if (p.size() <= 1) return p;
  Pol up, dw;
  for (P d : p) {
    size_t n;
    while ((n = up.size()) > 1) {
      if (ccw(up[n - 2], up[n - 1], d) == -1) break;
      up.pop_back();
    }
    up.push_back(d);
  }
  reverse(begin(up), end(up));
  for (P d : p) {
    size_t n;
    while ((n = dw.size()) > 1) {
      if (ccw(dw[n - 2], dw[n - 1], d) == 1) break;
      dw.pop_back();
    }
    dw.push_back(d);
  }
  dw.insert(begin(dw), begin(up) + 1, end(up) - 1);
  return dw;
}
int main() {
  cin.tie(0);
  ios::sync_with_stdio(false);
  cout << setprecision(1) << fixed;
  int n;
  cin >> n;
  Pol g(n);
  for (int i = 0; i < n; i++) {
    D x, y;
    cin >> x >> y;
    g[i] = P(x, y);
  }
  if (g.size() == convex(g).size())
    cout << 1 << endl;
  else
    cout << 0 << endl;
  return 0;
}
