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;
struct Point {
  double x, y;
  Point(double x = 0, double y = 0) : x(x), y(y) {}
  Point operator+(const Point& o) const { return Point(x + o.x, y + o.y); }
  Point operator-(const Point& o) const { return Point(x - o.x, y - o.y); }
  Point operator*(const double m) const { return Point(x * m, y * m); }
  Point operator/(const double d) const { return Point(x / d, y / d); }
  bool operator<(const Point& o) const { return x != o.x ? x < o.x : y < o.y; }
  bool operator==(const Point& o) const {
    return fabs(x - o.x) < 1e-8 && fabs(y - o.y) < 1e-8;
  }
};
ostream& operator<<(ostream& os, const Point& p) {
  os << "(" << p.x << ", " << p.y << ")";
  return os;
}
double dot(Point a, Point b) { return a.x * b.x + a.y * b.y; }
double cross(Point a, Point b) { return a.x * b.y - a.y * b.x; }
double atan(Point p) { return atan2(p.y, p.x); }
double norm(Point p) { return p.x * p.x + p.y * p.y; }
double abs(Point p) { return sqrt(norm(p)); }
double distancePP(Point p, Point o) { return sqrt(norm(o - p)); }
int ccw(Point a, Point b, Point c) {
  b = b - a;
  c = c - a;
  if (cross(b, c) > 0.0) return +1;
  if (cross(b, c) < 0.0) return -1;
  if (dot(b, c) < 0.0) return +2;
  if (norm(b) < norm(c)) return -2;
  return 0;
}
double polygonArea(const vector<Point>& p) {
  int n = p.size();
  double ret = 0.0;
  for (int i = 0; i < n; ++i) {
    ret += cross(p[i], p[(i + 1) % n]);
  }
  return abs(ret) / 2.0;
}
bool isConvex(const vector<Point>& p) {
  int n = p.size();
  bool flag = true;
  for (int i = 0; i < n; i++) {
    if (ccw(p[i], p[(i + 1) % n], p[(i + 2) % n]) == +1) continue;
    flag = false;
  }
  if (flag) return true;
  flag = true;
  for (int i = 0; i < n; i++) {
    if (ccw(p[i], p[(i + 1) % n], p[(i + 2) % n]) == -1) continue;
    flag = false;
  }
  if (flag) return true;
  return false;
}
struct Line {
  Point a, b;
  Line() : a(Point(0, 0)), b(Point(0, 0)) {}
  Line(Point a, Point b) : a(a), b(b) {}
};
ostream& operator<<(ostream& os, const Line& l) {
  os << "(" << l.a.x << ", " << l.a.y << ")-(" << l.b.x << "," << l.b.y << ")";
  return os;
}
struct Seg {
  Point a, b;
  Seg() : a(Point(0, 0)), b(Point(0, 0)) {}
  Seg(Point a, Point b) : a(a), b(b) {}
};
ostream& operator<<(ostream& os, const Seg& s) {
  os << "(" << s.a.x << ", " << s.a.y << ")-(" << s.b.x << "," << s.b.y << ")";
  return os;
}
bool isOrthogonal(Line l1, Line l2) {
  return fabs((dot((l1.b - l1.a), (l2.b - l2.a))) - (0.0)) < 1e-8;
}
bool isParallel(Line l1, Line l2) {
  return fabs((cross((l1.b - l1.a), (l2.b - l2.a))) - (0.0)) < 1e-8;
}
bool sameLine(Line l1, Line l2) {
  return abs(cross(l1.b - l1.a, l2.b - l1.a)) < 1e-8;
}
bool isIntersectLL(Line l1, Line l2) {
  return !isParallel(l1, l2) || sameLine(l1, l2);
}
bool isIntersectLS(Line l, Seg s) {
  return cross(l.b - l.a, s.a - l.a) * cross(l.b - l.a, s.b - l.a) < 0;
}
bool isIntersectSS(Seg s1, Seg s2) {
  return ccw(s1.a, s1.b, s2.a) * ccw(s1.a, s1.b, s2.b) <= 0 &&
         ccw(s2.a, s2.b, s1.a) * ccw(s2.a, s2.b, s1.b) <= 0;
}
double distanceLP(Line l, Point p) {
  return abs(cross(l.b - l.a, p - l.a)) / abs(l.b - l.a);
}
double distanceLS(Line l, Seg s) {
  if (isIntersectLS(l, s)) return 0.0;
  return min(distanceLP(l, s.a), distanceLP(l, s.b));
}
double distanceSP(Seg s, Point p) {
  if (dot(s.b - s.a, p - s.a) < 0.0) return abs(p - s.a);
  if (dot(s.a - s.b, p - s.b) < 0.0) return abs(p - s.b);
  return distanceLP(Line(s.a, s.b), p);
}
double distanceSS(Seg s1, Seg s2) {
  if (isIntersectSS(s1, s2)) return 0.0;
  return min(min(distanceSP(s1, s2.a), distanceSP(s1, s2.b)),
             min(distanceSP(s2, s1.a), distanceSP(s2, s1.b)));
}
Point crossPointLL(Line l1, Line l2) {
  Point base = l2.b - l2.a;
  double d = abs(cross(base, l1.a - l2.a));
  double d2 = abs(cross(base, l1.b - l2.a));
  double t = d / (d + d2);
  return l1.a + (l1.b - l1.a) * t;
}
Point crossPointLS(Line l, Seg s) { return crossPointLL(l, Line(s.a, s.b)); }
Point crossPointSS(Seg s1, Seg s2) {
  return crossPointLL(Line(s1.a, s1.b), Line(s2.a, s2.b));
}
Point project(Line l, Point p) {
  Point base = l.b - l.a;
  double t = dot(base, p - l.a) / dot(base, base);
  return l.a + base * t;
}
Point reflect(Line l, Point p) { return p + (project(l, p) - p) * 2.0; }
int main() {
  int n;
  cin >> n;
  vector<Point> v(n);
  for (int i = 0; i < n; i++) cin >> v[i].x >> v[i].y;
  if (isConvex(v)) {
    cout << 1 << endl;
  } else {
    cout << 0 << endl;
  }
  return 0;
}
