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 <iostream>
#include <vector>
#include <string>
#include <cmath>
#include <set>
#include <algorithm>
#include <array>
#include <complex>
#include <string>
#include <utility>
#include <map>
#include <queue>
#include <list>
#include <functional>
#include <numeric>
#include <stack>
#include <tuple>

using namespace std;
int dx[4] = { -1,0,1,0 };
int dy[4] = { 0,1,0,-1 };
const int INF = 100000000;
const long long LINF = 1000000000000000000;
const int MOD = (int)1e9 + 7;
const double EPS = 1e-6;
using pii = std::pair<int, int>;
using ll = long long;
using pLL = std::pair<ll, ll>;
#define SORT(v) std::sort(v.begin(), v.end())
#define RSORT(v) std::sort(v.rbegin(), v.rend())
using Point = complex<double>; //点
using Line = pair<Point, Point>; //直線
using Poly = vector<Point>;
#define X real() //実部
#define Y imag() //虚部
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;
}
Point Projection(Line s, Point p) { //点から直線への射影
    Point vase = s.second - s.first;
    p -= s.first;
    return s.first + dot(p, vase) / norm(vase) * vase;
}
Point Reflection(Line s, Point p) { //直線に対して線対称な点
    return p + (Projection(s, p) - p) * 2.0;
}
int ccw(Point a, Point b, Point c) { //直線に対する点の位置
    if (cross(b - a, c - a) > EPS)return 1;
    if (cross(b - a, c - a) < -EPS)return -1;
    if (dot(b - a, c - a) < -EPS)return 2;
    if (abs(b - a) + EPS < abs(c - a))return -2;
    return 0;
}
bool isOrthogonal(Line a, Line b) { //直行判定
    return dot(a.second - a.first, b.second - b.first) ? 0 : 1;
}
bool isParallel(Line a, Line b) { //平行判定
    return cross(a.second - a.first, b.second - b.first) ? 0 : 1;
}
bool isCross(Line a, Line b) { //交差判定
    if (ccw(a.first, a.second, b.first) * ccw(a.first, a.second, b.second) <= 0 and
        ccw(b.first, b.second, a.first) * ccw(b.first, b.second, a.second) <= 0) {
        return true;
    }
    return false;
}
Point CrossPoint(Line a, Line b) { //直線の交点
    double x, d;
    Point p1, p2, p3, p4;
    p1 = a.first;
    p2 = a.second;
    p3 = b.first;
    p4 = b.second;
    x = (p4.Y - p3.Y) * (p4.X - p1.X) - (p4.X - p3.X) * (p4.Y - p1.Y);
    d = (p4.Y - p3.Y) * (p2.X - p1.X) - (p4.X - p3.X) * (p2.Y - p1.Y);
    return p1 + x / d * (p2 - p1);
}
double PointLineDis(Line l, Point p) {
    Point a = l.first, b = l.second, c = p;
    return abs(cross(c - a, b - a)) / abs(b - a);
}
double PointSegDis(Line a, Point p) {
    Point p1 = a.first, p2 = a.second;
    if (dot(p2 - p1, p - p1) < EPS)return abs(p - p1);
    if (dot(p1 - p2, p - p2) < EPS)return abs(p - p2);
    return PointLineDis(a, p);
}
double SegSegDis(Line a, Line b) {
    if (isCross(a, b)) return 0;
    double res = PointSegDis(a, b.first);
    res = min(res, PointSegDis(a, b.second));
    res = min(res, PointSegDis(b, a.first));
    res = min(res, PointSegDis(b, a.second));
    return res;
}
double PolyArea(const Poly &p) {
    if (p.size() < 3)return 0;
    double res = cross(p[p.size() - 1], p[0]);
    for (size_t i = 0; i < p.size()-1; ++i) {
        res += cross(p[i], p[i + 1]);
    }
    return res / 2.0;
}
bool isConvex(const Poly &p) {
    for (size_t i = 0; i < p.size(); ++i) {
        if (ccw(p[i],p[(i+1)%p.size()], p[(i + 2) % p.size()]) ==-1)return false;
    }
    return true;
}
int main() {
    cin.tie(0);
    ios::sync_with_stdio(false);
    Point p1, p2, p3, p4;
    int q;
    cin >> q;
    Poly p;
    for (int i = 0; i < q; ++i) {
        double x1,y1;
        cin >> x1 >> y1;
        p1 = Point(x1, y1);
        p.push_back(p1);
    }

    if (isConvex(p))cout << 1 << endl;
    else cout << 0 << endl;
    return 0;

}
