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 <algorithm>
#include <iterator>
#include <iomanip>
#include <cmath>
#include <vector>
#include <numeric>
#include <cstdio>
#include <bitset>
#include <map>
#include <string>
#include <valarray>
#include <queue>
#include <utility>
#include <functional>
#include <list>
#include <cmath>


using namespace std;

const double ESP = 1E-8;

struct Point
{
    //friends
    friend Point operator*(double c, const Point & p);
    friend ostream & operator<<(ostream & os, const Point & p);
    friend istream & operator>>(istream & is, Point & p);
    friend double cross(const Point & p1, const Point & p2);

  
    //data members
    double x, y;

    //function members
    Point() {};
    Point(double x, double y): x(x), y(y) {};
    Point operator-(const Point & p) const {return Point(x - p.x, y - p.y);}
    double operator*(const Point & p) const {return x*p.x + y*p.y;}
    Point operator*(double c) const {return Point(c*x, c*y);}
    Point operator+(const Point & p) const {return Point(x+p.x, y+p.y);}
    Point projection(const Point & p1, const Point & p2) const {Point a(*this-p1), b(p2-p1); return (a*b)/(b*b)*b+p1;}
    Point reflection(const Point & p1, const Point & p2) const {return this->projection(p1, p2)*2 - *this;}

};


struct Line
{
    Line() = default;
    Line(const Point & p1, const Point & p2): 
        direction(p1-p2), point_online(p1) {}; 
    Point direction, point_online;
    Point get_normal() const {return Point(direction.y, -direction.x);}

};


class Polygon
{
    friend istream & operator>>(istream & is, Polygon & p);

    public:
        double area();
        bool is_convex();

        
    private:
        vector<Point> Vertices;
};



int main()
{
    Polygon polygon;
    cin >> polygon;
    cout << polygon.is_convex() << endl;
}



//function members and friend functions of Point
Point operator*(double c, const Point & p)
{
    return p*c;
}

ostream & operator<<(ostream & os, const Point & p) 
{
    os << setprecision(8) << fixed << p.x << ' ' << p.y << endl;
    return os;
}

istream & operator>>(istream & is, Point & p)
{
    is >> p.x >> p.y;
    return is;
}

double cross(const Point & p1, const Point & p2)
{
    return p1.x*p2.y-p1.y*p2.x;
}




//function members and friend functions of Polygon
istream & operator>>(istream & is, Polygon & p)
{
    int q;
    is >> q;
    
    p.Vertices.resize(q);
    for (int i = 0; i < q; ++i)
    {
        cin >> p.Vertices[i];
    }

    return is;
}

double Polygon::area()
{
    double a = 0;
    for (int i = 0; i < Vertices.size(); ++i)
    {
        a += cross(Vertices[i], Vertices[(i+1)%Vertices.size()]);
    }

    return fabs(a/2);
}

bool Polygon::is_convex()
{
    int ans = 0;
    
    for (int i = 0; i < Vertices.size()-1; ++i)
    {
        double tmp = cross(Vertices[(i+1)%Vertices.size()]-Vertices[i], Vertices[(i+2)%Vertices.size()]-Vertices[i]);

        if (tmp == 0)
            continue;

        if (ans == 0)
        {
            if (tmp < 0)
                ans = -1;
            else
                ans = 1;
            
            continue;
        }

        if (ans * tmp < 0)
            return false;
    }
    return true;
}
