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 equals(double a, double b) { return a > b ? a - b < EPS : b - a < EPS; }
class Point {
 public:
  double x;
  double y;
  Point(double inx = 0.0, double iny = 0.0) : x(inx), y(iny) {}
  Point operator+(const Point &p) { return Point(x + p.x, y + p.y); }
  Point operator-(const Point &p) { return Point(x - p.x, y - p.y); }
  Point operator*(const double k) { return Point(x * k, y * k); }
  Point operator/(const double k) { return Point(x / k, y / k); }
  Point operator=(const Point &p) {
    x = p.x;
    y = p.y;
    return *this;
  }
  bool operator<(const Point &p) const { return x != p.x ? x < p.x : y < p.y; }
  bool operator==(const Point &p) const {
    return equals(x, p.x) && equals(y, p.y);
  }
  double norm() { return x * x + y * y; }
  double abs() { return sqrt(norm()); }
};
class Segment {
 public:
  Point p1;
  Point p2;
  Point getvector() { return p2 - p1; }
};
class Circle {
 public:
  Point c;
  double r;
  Circle(Point inc = Point(), double inr = 0.0) : c(inc), r(inr) {}
};
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; }
const int counter_clockwise = 1;
const int clockwise = -1;
const int on_segment = 0;
const int online_back = 2;
const int online_front = -2;
double norm(Point a) { return a.x * a.x + a.y * a.y; }
double abs(Point a) { return sqrt(norm(a)); }
bool isorthogonal(Point a, Point b) { return equals(dot(a, b), 0.0); }
bool isorthogonal(Point a1, Point a2, Point b1, Point b2) {
  return isorthogonal(a1 - a2, b1 - b2);
}
bool isorthogonal(Segment s1, Segment s2) {
  return equals(dot(s1.getvector(), s2.getvector()), 0.0);
}
bool isparallel(Point a, Point b) { return equals(cross(a, b), 0.0); }
bool isparallel(Point a1, Point a2, Point b1, Point b2) {
  return isparallel(a1 - a2, b1 - b2);
}
bool isparallel(Segment s1, Segment s2) {
  return equals(cross(s1.getvector(), s2.getvector()), 0.0);
}
Point project(Segment s, Point p) {
  Point base = s.getvector();
  double r = dot(p - s.p1, base) / norm(base);
  return s.p1 + base * r;
}
Point reflect(Segment s, Point p) { return project(s, p) * 2.0 - p; }
double getdistance(Point a, Point b) { return abs(a - b); }
double getdistancelp(Segment l, Point p) {
  double s = abs(cross(l.p2 - l.p1, p - l.p1));
  return s / abs(l.getvector());
}
double getdistancesp(Segment s, Point p) {
  if (dot(s.getvector(), p - s.p1) < 0.0)
    return abs(p - s.p1);
  else if (dot(s.p1 - s.p2, p - s.p2) < 0.0)
    return abs(p - s.p2);
  else
    return getdistancelp(s, p);
}
int ccw(Point p0, Point p1, Point p2) {
  Point a = p1 - p0;
  Point b = p2 - p0;
  if (cross(a, b) > EPS)
    return counter_clockwise;
  else if (cross(a, b) < -EPS)
    return clockwise;
  else if (dot(a, b) < -EPS)
    return online_back;
  else if (a.norm() < b.norm())
    return online_front;
  else
    return on_segment;
}
bool intersect(Point p1, Point p2, Point p3, Point p4) {
  return ccw(p1, p2, p3) * ccw(p1, p2, p4) <= 0 &&
         ccw(p3, p4, p1) * ccw(p3, p4, p2) <= 0;
}
bool intersect(Segment s1, Segment s2) {
  return intersect(s1.p1, s1.p2, s2.p1, s2.p2);
}
double getdistance(Segment s1, Segment s2) {
  if (intersect(s1, s2))
    return 0.0;
  else
    return min(min(getdistancesp(s1, s2.p1), getdistancesp(s1, s2.p2)),
               min(getdistancesp(s2, s1.p1), getdistancesp(s2, s1.p2)));
}
Point getcrosspoint(Segment s1, Segment s2) {
  Point base = s2.getvector();
  double d1 = abs(cross(base, s1.p1 - s2.p1));
  double d2 = abs(cross(base, s1.p2 - s2.p1));
  double t = d1 / (d1 + d2);
  return s1.p1 + s1.getvector() * t;
}
pair<Point, Point> getcrosspoint(Circle c, Segment l) {
  Point pr = project(l, c.c);
  Point e = l.getvector() / abs(l.getvector());
  double base = sqrt(c.r * c.r - norm(pr - c.c));
  return make_pair(pr + e * base, pr - e * base);
}
double arg(Point p) { return atan2(p.y, p.x); }
Point polar(double r, double theta) {
  return Point(r * cos(theta), r * sin(theta));
}
pair<Point, Point> getcrosspoint(Circle c1, Circle c2) {
  double d = abs(c2.c - c1.c);
  double a = acos((c1.r * c1.r + d * d - c2.r * c2.r) / (2.0 * c1.r * d));
  double t = arg(c2.c - c1.c);
  return make_pair(c1.c + polar(c1.r, t + a), c1.c + polar(c1.r, t - a));
}
vector<Point> andrewscan(vector<Point> s) {
  vector<Point> u, l;
  if (s.size() <= 2) return s;
  sort(s.begin(), s.end(), [](const Point &p1, const Point &p2) {
    return p1.y == p2.y ? p1.x < p2.x : p1.y < p2.y;
  });
  u.push_back(s[0]);
  u.push_back(s[1]);
  l.push_back(s[s.size() - 1]);
  l.push_back(s[s.size() - 2]);
  for (int i = 2; i < s.size(); i++) {
    for (int n = u.size();
         n >= 2 && ccw(u[n - 2], u[n - 1], s[i]) != clockwise &&
         ccw(u[n - 2], u[n - 1], s[i]) != online_front;
         n--) {
      u.pop_back();
    }
    u.push_back(s[i]);
  }
  for (int i = s.size() - 3; i >= 0; i--) {
    for (int n = l.size();
         n >= 2 && ccw(l[n - 2], l[n - 1], s[i]) != clockwise &&
         ccw(l[n - 2], l[n - 1], s[i]) != online_front;
         n--) {
      l.pop_back();
    }
    l.push_back(s[i]);
  }
  reverse(l.begin(), l.end());
  for (int i = u.size() - 2; i >= 1; i--) l.push_back(u[i]);
  return l;
}
const int in = 2;
const int on = 1;
const int out = 0;
int contain(vector<Point> g, Point p) {
  int n = g.size();
  bool x = false;
  Point a, b, sto;
  for (int i = 0; i < n; i++) {
    a = g[i] - p;
    b = g[(i + 1) % n] - p;
    if (abs(cross(a, b)) < EPS && dot(a, b) < EPS) return on;
    if (a.y > b.y) {
      sto = a;
      a = b;
      b = sto;
    }
    if (a.y < EPS && EPS < b.y && cross(a, b) > EPS) x = !x;
  }
  return x ? in : out;
}
bool isconvex(vector<Point> p) {
  int n = p.size(), now;
  for (int i = 0; i < n; i++) {
    now = ccw(p[i], p[(i + 1) % n], p[(i + 2) % n]);
    if (now != counter_clockwise && now != online_front) return false;
  }
  return true;
}
int main() {
  vector<Point> p;
  int n;
  cin >> n;
  Point a;
  for (int i = 0; i < n; i++) {
    cin >> a.x >> a.y;
    p.push_back(a);
  }
  if (isconvex(p))
    cout << 1 << endl;
  else
    cout << 0 << endl;
  return 0;
}
