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 Fi first
#define Se second
#define pb push_back
#define mp make_pair
#define rep(x, a, b) for(int x = (a); x <= (b); ++ x)
#define per(x, a, b) for(int x = (a); x >= (b); -- x)
#define rop(x, a, b) for(int x = (a); x < (b); ++ x)
#define por(x, a, b) for(int x = (a); x > (b); -- x) 

typedef long long LL;
typedef unsigned long long ULL;
typedef unsigned int unt;
typedef double db;
typedef pair <int, int> pii;
typedef vector <int> vi;

const db eps  = 1e-8;
const db _PI  = 3.1415926535897932384;
const db _E   = 2.7182818284590452354;
const int inf = 0x3f3f3f3f;
const LL INF  = 0x3f3f3f3f3f3f3f3fll;

int dcmp(db x) {
	if(x > eps) return 1;
	if(x < -eps) return -1;
	return 0;
}

int dcmp(db x, db y) {
	return dcmp(x - y);
}

struct Point {
	db x, y;
	Point(db _x = 0, db _y = 0) : x(_x), y(_y) {}
	void print() { printf("%.10f %.10f", x, y); }
};
struct Line {
	Point p1, p2;
	Line() {};
	Line(Point _p1, Point _p2) : p1(_p1), p2(_p2) {};
};

typedef Point Vector;
typedef Line Segment;
typedef vector<Point> Polygon;

// CCW
const int CCW_COUNTER_CLOCKWISE = 1;
const int CCW_CLOCKWISE = -1;
const int CCW_ONLINE_FRONT = -2;
const int CCW_ONLINE_BACK = 2;
const int CCW_ON_SEGMENT = 0;

Vector operator + (Vector a, Vector b) {
	return Vector(a.x + b.x, a.y + b.y);
}
Vector operator - (Vector a, Vector b) {
	return Vector(a.x - b.x, a.y - b.y);
}
Vector operator * (Vector a, db b) {
	return Vector(a.x * b, a.y * b);
}
Vector operator / (Vector a, db b) {
	return Vector(a.x / b, a.y / b);
}
db operator * (Vector a, Vector b) {
	return a.x * b.x + a.y * b.y;
}
db operator ^ (Vector a, Vector b) {
	return a.x * b.y - a.y * b.x;
}
db dis(Point a, Point b) {
	return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}
db dis2(Point a, Point b) {
	return (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
}
db dis(Vector a) {
	return sqrt(a.x * a.x + a.y * a.y);
}
db dis2(Vector a) {
	return a.x * a.x + a.y * a.y;
}
Point Project(Line L, Point p) {
	Vector Base = L.p2 - L.p1;
	db len = Base * (p - L.p1);
	return L.p1 + Base * (len / dis2(L.p1, L.p2));
}
Point Reflect(Line L, Point p) {
	return p + (Project(L, p) - p) * 2.0;
}

int ccw(Point p0, Point p1, Point p2) {
	Vector p01 = p1 - p0, p02 = p2 - p0;
	if(dcmp(p01 ^ p02) == 1) return CCW_COUNTER_CLOCKWISE; // 逆时针 
	if(dcmp(p01 ^ p02) == -1) return CCW_CLOCKWISE;        // 顺时针 
	if(dcmp(p01 * p02) == -1) return CCW_ONLINE_BACK;
	if(dcmp(dis2(p01), dis2(p02)) == -1) return CCW_ONLINE_FRONT;
	return CCW_ON_SEGMENT;
}

bool isOrthogonal(Vector a, Vector b) {
	return dcmp(a * b) == 0;
}
bool isOrthogonal(Point a1, Point a2, Point b1, Point b2) {
	return isOrthogonal(a2 - a1, b2 - b1);
}
bool isOrthogonal(Line a, Line b) {
	return isOrthogonal(a.p2 - a.p1, b.p2 - b.p1);
}
bool isParallel(Vector a, Vector b) {
	return dcmp(a ^ b) == 0;
}
bool isParallel(Point a1, Point a2, Point b1, Point b2) {
	return isParallel(a2 - a1, b2 - b1);
}
bool isParallel(Line a, Line b) {
	return isParallel(a.p2 - a.p1, b.p2 - b.p1);
}
bool IntersectSS(Point a1, Point a2, Point b1, Point b2) {
	return ccw(a1, a2, b1) * ccw(a1, a2, b2) <= 0 && ccw(b1, b2, a1) * ccw(b1, b2, a2) <= 0;
}
bool IntersectSS(Segment a, Segment b) {
	return IntersectSS(a.p1, a.p2, b.p1, b.p2);
}
Point getCrossPointSS(Segment a, Segment b) {
	Vector Base = b.p2 - b.p1;
	db S1 = fabs(Base ^ (a.p1 - b.p1));
	db S2 = fabs(Base ^ (a.p2 - b.p1));
	return a.p1 + (a.p2 - a.p1) * (S1 / (S1 + S2));
}
//Point getCrossPointLL(Line a, Line b) {
//	db S1 = (b.p2 - b.p1) ^ (a.p2 - a.p1);
//	db S2 = (b.p2 - b.p1) ^ (b.p2 - a.p1);
//	if(dcmp(S1) <= 0 && dcmp(S2) <= 0) return a.p1;
//	return a.p1 + (a.p2 - a.p1) * (S2 / S1); //抄的别人代码，然而并不懂为啥/kel 
//}
db disLP(Line a, Point p) {
	return fabs(((a.p2 - a.p1) ^ (p - a.p1)) / dis(a.p1, a.p2));
}
db disSP(Segment a, Point p) {
	if(dcmp((a.p2 - a.p1) * (p - a.p1)) == -1) return dis(a.p1, p);
	if(dcmp((a.p1 - a.p2) * (p - a.p2)) == -1) return dis(a.p2, p);
	return disLP(a, p);
}
db disSS(Segment a, Segment b) {
	if(IntersectSS(a, b)) return 0;
	return min({disSP(b, a.p1), disSP(b, a.p2), disSP(a, b.p1), disSP(a, b.p2)});
}
db Area(Polygon p) {
	db S = p.back() ^ p[0];
	rop(i, 0, (int) p.size() - 1) S += p[i] ^ p[i + 1];
	return fabs(S) / 2;
}
bool isConvex(Polygon p) {
	rop(i, 0, (int) p.size() - 2) if(ccw(p[i], p[i + 1], p[i + 2]) == CCW_CLOCKWISE) return 0;
	if(ccw(p.back(), p[0], p[1]) == CCW_CLOCKWISE) return 0;
	if(ccw(p[(int)p.size() - 2], p.back(), p[0]) == CCW_CLOCKWISE) return 0;
	return 1;
}

int main() {
	int n; scanf("%d", &n);
	Polygon p; p.resize(n);
	rop(i, 0, n) scanf("%lf%lf", &p[i].x, &p[i].y);
	printf("%d\n", (int) isConvex(p));
	return 0;
}
