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;

const double eps = 1e-10;
bool dless(double d1, double d2) { return d1 < d2 + eps; }
bool dcmp(double d, double d2 = 0) { return abs(d - d2) < eps; }
double sgn(double d) {
  if (dcmp(d))
    return 0;
  if (d > 0)
    return 1;
  return -1;
}

struct vec {
  double x, y;
  vec(double x, double y) : x(x), y(y) {}
  vec() : x(0), y(0) {}
  const bool operator==(const vec &v) const {
    return dcmp(x, v.x) && dcmp(y, v.y);
  }
  const bool operator!=(const vec &v) const { return !(*this == v); }
  const vec operator+(const vec &v) const { return vec(x + v.x, y + v.y); }
  const vec operator-() const { return vec(-x, -y); }
  const vec operator-(const vec &v) const { return *this + (-v); }
  const vec operator*(const double d) const { return vec(x * d, y * d); }
  const vec operator/(const double d) const { return *this * (1 / d); }
  const vec unit() const { return *this / len(); }
  const double len() const { return sqrt(x * x + y * y); }
  const double dot(const vec &v) const { return x * v.x + y * v.y; }
  const double cross(const vec &v) const { return x * v.y - y * v.x; }
  const bool parallel(const vec &v) const { return dcmp(cross(v)); }
  const bool perpendicular(const vec &v) const { return dcmp(dot(v)); }
};

typedef vec point;

template <class T> struct optional {
  bool has;
  T val;
  optional() : has(false) {}
  optional(T t) : has(true), val(t) {}
};

struct line {
  double a, b, c;
  line(point p1, point p2) {
    a = p1.y - p2.y;
    b = p2.x - p1.x;
    c = (p1.x - p2.x) * p1.y + (p2.y - p1.y) * p1.x;
    double m1 = a * p1.x + b * p1.y + c;
    double m2 = a * p2.x + b * p2.y + c;
  }
  bool parallel(line l) { return dcmp(a * l.b, b * l.a); }
  optional<point> intersect(line l) {
    if (parallel(l))
      return optional<point>();
    return point(-(c * l.b - b * l.c) / (a * l.b - b * l.a),
                 (c * l.a - a * l.c) / (a * l.b - b * l.a));
  }
  bool contains(point p) { return dcmp(a * p.x + b * p.y + c); }
  point project(point p) {
    double t = -(a * p.x + b * p.y + c) / (a * a + b * b);
    return point(p.x + a * t, p.y + b * t);
  }
};

struct segment {
  point p1, p2;
  segment(point p1, point p2) : p1(p1), p2(p2) {}
  line sline() { return line(p1, p2); }
  bool contains(point p) {
    double x1 = min(p1.x, p2.x), x2 = max(p1.x, p2.x);
    double y1 = min(p1.y, p2.y), y2 = max(p1.y, p2.y);
    bool ok = sline().contains(p) && (dless(x1, p.x) && dless(p.x, x2)) &&
              (dless(y1, p.y) && dless(p.y, y2));
    return ok;
  }
  bool intersect(segment s) {
    vec v0 = p2 - p1;
    vec v1 = s.p2 - s.p1;
    if (v0.parallel(v1)) {
      return (contains(s.p1) || contains(s.p2)) ||
             (s.contains(p1) || s.contains(p2));
    }
    point a = p1, b = p2, c = s.p1, d = s.p2;
    return sgn((a - b).cross(b - c)) != sgn((a - b).cross(b - d)) &&
           sgn((c - d).cross(d - a)) != sgn((c - d).cross(d - b));
  }
  double distance(point p) {
    point p0 = sline().project(p);
    if (contains(p0)) {
      return (p0 - p).len();
    } else {
      return min((p1 - p).len(), (p2 - p).len());
    }
  }
  double distance(segment s) {
    if (intersect(s))
      return 0.0;
    return min(min(distance(s.p1), distance(s.p2)),
               min(s.distance(p1), s.distance(p2)));
  }
};

point p[105];

int main() {
  int n;
  cin >> n;
  for (int i = 0; i < n; i++)
    cin >> p[i].x >> p[i].y;
  p[n] = p[0];
  int f[3] = {0, 0, 0};
  for (int i = 0; i < n; i++) {
    int d = sgn((p[i + 2] - p[i + 1]).cross(p[i + 1] - p[i]));
    f[d + 1]++;
  }
  cout << (f[0] == 0 || f[2] == 0) << endl;
}
