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;
#define rep(i,n) for(int i = 0; i < (int)n; i++)

const double eps = 1e-10;

struct Point {
  double x, y;
  Point(double x = 0.0, double y = 0.0) : x(x), y(y) {}  
  double norm() {return sqrt(x*x + y*y);}
};

Point operator + (const Point &p, const Point &q) {return Point(p.x + q.x, p.y + q.y);}
Point operator - (const Point &p, const Point &q) {return Point(p.x - q.x, p.y - q.y);}
double operator * (const Point &p, const Point q) {return p.x * q.x + p.y * q.y;}
bool operator == (const Point &p, const Point &q) {return (abs(p.x - q.x) < eps && abs(p.y - q.y) < eps);}
bool operator != (const Point &p, const Point &q) {return !(p == q);}
double cross(const Point &p, const Point &q) {return p.x*q.y - p.y*q.x;}
double dist(const Point &p, const Point &q) {return (p-q).norm();}

struct Segment {
  Point p , q;
  Segment(Point p = Point(0.0,0.0), Point q = Point(0.0,0.0)) : p(p), q(q) {}
};

struct Line {
  double a, b, c;
  Line(double a, double b, double c) : a(a), b(b), c(c) {}
  Line(Point p, Point q) {
    a = q.y - p.y;
    b = p.x - q.x;
    c = q.x * p.y - p.x * q.y;
  }
};

struct Circle {
  double r;
  Point p;
  Circle(Point p = Point(0.0, 0.0), double r = 0.0) : p(p), r(r) {}
};

// 点の直線への射影
Point projection (Point p, Line l) {
  double x = p.x - l.a * (l.a*p.x + l.b*p.y + l.c) / (l.a*l.a + l.b*l.b);
  double y = p.y - l.b * (l.a*p.x + l.b*p.y + l.c) / (l.a*l.a + l.b*l.b);
  return Point(x,y);
}

// 線対称な点
Point reflection(Point p, Line l) {
  double x = p.x - 2.0 * l.a * (l.a*p.x + l.b*p.y + l.c) / (l.a*l.a + l.b*l.b);
  double y = p.y - 2.0 * l.b * (l.a*p.x + l.b*p.y + l.c) / (l.a*l.a + l.b*l.b);
  return Point(x,y);
}

// 点の線分からの回転方向
int ccw(Point p, Point p1, Point p2) {
  p1 = p1 - p; p2 = p2 - p;
  if(cross(p1,p2) > eps) return 1; 
  if(cross(p1,p2) < -eps) return -1; 
  if(p1 * p2 < 0) return 2; 
  if(p1.norm() < p2.norm()) return -2; 
  return 0; 
}

// 点が線分上にあるか判定
bool on_segment(Point p, Segment s) {
  return (ccw(s.p,s.q,p) == 0 ? true : false);
}

// 線分の交差判定
bool segment_segment_cross(const Segment l, const Segment s) {
  return ccw(l.p,l.q,s.p) * ccw(l.p,l.q,s.q) <= 0 && ccw(s.p,s.q,l.p) * ccw(s.p,s.q,l.q) <= 0;
}

// 直線の平行・直交判定 (平行:2 直交:1 その他:0)
int line_parallel_orthogonal(Line l, Line s) {
  if(abs(l.a*s.a + l.b*s.b) < eps) return 1;
  else if(abs(l.a*s.b - l.b*s.a) < eps) return 2;
  else return 0;
}

// 直線と直線の交点 
vector<Point> line_line_cross(Line l, Line s) {
  vector<Point> vp;
  if(line_parallel_orthogonal(l,s) != 2) {
    Point p;
    p.x = (l.b*s.c - s.b*l.c) / (l.a*s.b - s.a*l.b);
    p.y = (-l.a*s.c + s.a*l.c) / (l.a*s.b - s.a*l.b);
    vp.push_back(p);
  }
  return vp;
}

// 点と直線の距離
double point_line_dist(Point p, Line l) {
  return abs(l.a*p.x + l.b*p.y + l.c) / sqrt(l.a*l.a + l.b*l.b);
}

// 点と線分の距離
double point_segment_dist(Point p, Segment s) {
  Point h = projection(p,Line(s.p,s.q));
  if(on_segment(h,s)) return dist(p,h);
  else return min(dist(p,s.p),dist(p,s.q));
}

// 線分と線分の距離
double segment_segment_dist(Segment l, Segment s) {
  if(segment_segment_cross(l,s)) return 0.0;
  else return min({point_segment_dist(l.p,s),point_segment_dist(l.q,s),point_segment_dist(s.p,l),point_segment_dist(s.q,l)});
}

// 直線と直線の距離
double line_line_dist(Line l, Line s) {
  if(line_parallel_orthogonal(l,s) != 2) return 0.0;
  else if(abs(s.a) < eps) return point_line_dist(Point(0.0,-s.c/s.b),l);
  else return point_line_dist(Point(-s.c/s.a,0),l);
}

// 直線と線分の距離
double line_segment_dist(Line l, Segment s) {
  Point a, b;
  if(abs(l.a) < eps) a = Point(0.0,-l.c/l.b), b = Point(1.0,-l.c/l.b);
  else if(abs(l.b) < eps) a = Point(-l.c/l.a,0.0), b = Point(-l.c/l.a,0.0);
  else a = Point(0.0,-l.c/l.b), b = Point(-l.c/l.a,0);

  if(ccw(a,b,s.p) * ccw(a,b,s.q) <= 0) return 0.0;
  else return min(point_line_dist(s.p,l),point_line_dist(s.q,l));
}

// ★円と円の交差判定 (離れる:4 外接:3 交わる:2 内接:1 内包:0)
int circle_circle_pos(Circle c, Circle d) {
  if(dist(c.p,d.p) >= c.r + d.r + eps) return 4;
  else if(abs(dist(c.p,d.p) - c.r - d.r) < eps) return 3;
  else if(dist(c.p,d.p) >= abs(c.r-d.r) + eps) return 2;
  else if(abs(dist(c.p,d.p) - abs(c.r-d.r)) < eps) return 1;
  else return 0; 
}

// ★円と直線の交点
vector<Point> circle_line_cross(Circle c, Line l) {
  vector<Point> vp;
  Point h = projection(c.p,l);

  double d = l.a*c.p.x + l.b*c.p.y + l.c;
  double q = c.r*c.r - d*d / (l.a*l.a + l.b*l.b);
  if(q >= eps) {
    Point p1, p2;
    p1.x = h.x + sqrt(q) * l.b / sqrt(l.a*l.a + l.b*l.b);
    p1.y = h.y - sqrt(q) * l.a / sqrt(l.a*l.a + l.b*l.b);
    p2.x = h.x - sqrt(q) * l.b / sqrt(l.a*l.a + l.b*l.b);
    p2.y = h.y + sqrt(q) * l.a / sqrt(l.a*l.a + l.b*l.b);
    vp.push_back(p1);
    vp.push_back(p2);
  } else if(abs(q) < eps) {
    vp.push_back(h);
  }
  return vp;
} 

// ★円と円の交点
vector<Point> circle_circle_cross(Circle c, Circle d) {
  Line l(2.0*(c.p.x-d.p.x),2.0*(c.p.y-d.p.y),-c.p.x*c.p.x+d.p.x*d.p.x-c.p.y*c.p.y+d.p.y*d.p.y+c.r*c.r-d.r*d.r);
  return circle_line_cross(c,l);
}

// ★多角形の面積
double polygon_area(vector<Point>& v) {
  int l = v.size();
  double s = 0.0;
  for(int i = 0; i < l; i++) s += 1/2.0 * cross(v[i],v[(i+1)%l]);
  return s;
}

// ★多角形の凸性
bool polygon_convex(vector<Point>& v) {
  int l = v.size();
  for(int i = 0; i < l; i++) {
    if(cross(v[(i+1)%l]-v[i],v[(i+2)%l]-v[i]) < -eps) return false;
  }
  return true;
} 

int main() {
  int n;
  cin >> n;
  vector<Point> v(n);
  rep(i,n) cin >> v[i].x >> v[i].y;
  cout << (polygon_convex(v)? 1 : 0) << endl;
}


