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 <numeric>
#include <string>
#include <complex>
#include <iomanip>
using namespace std;
typedef complex<double> P;
typedef vector<P> vec;
const double EPS = 1e-10;
//二つのスカラーが等しいか
#define EQ(a, b) (abs((a) - (b)) < EPS)
//二つのベクトルが等しいか
#define EQV(a, b) (EQ((a), real(), (b).real()) && EQ((a), imag(), (b).imag()))
#define curr(P, i) P[i]
#define next(P, i) P[(i + 1) % P.size()]
#define prev(P, i) P[(i - 1 + P.size()) % P.size()]

double dot(P a, P b)
{
    return real(a) * real(b) + imag(a) * imag(b);
}

double cross(P a, P b)
{
    return real(a) * imag(b) - imag(a) * real(b);
}

int is_orthogonal(P a1, P a2, P b1, P b2)
{
    return EQ(dot(a1 - a2, b1 - b2), 0.0);
}
int is_parallel(P a1, P a2, P b1, P b2)
{
    return EQ(cross(a1 - a2, b1 - b2), 0.0);
}

int ccw(P a, P b, P c)
{
    b -= a;
    c -= a;
    if (cross(b, c) > 0)
        return 1;
    if (cross(b, c) < 0)
        return -1;
    if (dot(b, c) < 0) // c--a--b on line
        return 2;
    if (norm(b) < norm(c)) //a--b--c on line or a==b
        return -2;
    return 0; // a--c--b on line a==c or b==c
}

int is_intersected_ls(P a1, P a2, P b1, P b2)
{
    return ccw(a1, a2, b1) * ccw(a1, a2, b2) <= 0 &&
           ccw(b1, b2, a1) * ccw(b1, b2, a2) <= 0;
}

double Area(vec &g)
{
    double A = 0;
    for (int i = 0; i < (int)g.size(); ++i)
    {
        A += cross(curr(g, i), next(g, i));
    }
    return A / 2.0;
}

bool is_Convex(const vec &g)
{
    for (int i = 0; i < (int)g.size(); ++i)
    {
        if (ccw(prev(g, i), curr(g, i), next(g, i)) == -1)
            return false;
    }
    return true;
}
int main(void)
{
    int N;
    cin >> N;
    vec v;
    for (int i = 0; i < N; ++i)
    {
        double x, y;
        cin >> x >> y;
        P c = {x, y};
        v.push_back(c);
    }
    if (is_Convex(v))
        cout << "1" << endl;
    else
        cout << "0" << endl;
}
