For given $n$ segments which are parallel to X-axis or Y-axis, find the number of intersections of them.

Constraints

* $1 \leq n \leq 100,000$
* $ -1,000,000,000 \leq x_1, y_1, x_2, y_2 \leq 1,000,000,000$
* Two parallel segments never overlap or touch.
* The number of intersections $\leq 1,000,000$

Input

In the first line, the number of segments $n$ is given. In the following $n$ lines, the $i$-th segment is given by coordinates of its end points in the following format:

$x_1 \; y_1 \; x_2 \; y_2$

The coordinates are given in integers.

Output

Print the number of intersections in a line.

Example

Input

6
2 2 2 5
1 3 5 3
4 1 4 4
5 2 7 2
6 1 6 3
6 5 6 7


Output

3

#include<bits/stdc++.h>
const double EPS =  1e-10;
#define equals(a, b) (fabs((a) - (b)) < EPS)

const static int BOTTOM = 0;
const static int LEFT = 1;
const static int RIGHT = 2;
const static int TOP = 3;


class Point{
    public:
    double x, y;

    Point(double x = 0, double y = 0): x(x), y(y){}

    Point operator + (Point p){
        return Point(x + p.x, y + p.y);
    }
    Point operator - (Point p){
        return Point(x - p.x, y - p.y);
    }
    Point operator * (Point p){
        return Point(x * p.x, y * p.y);
    }
    Point operator * (double r){
        return Point(x * r, y * r);
    }
    Point operator / (Point p){
        return Point(x / p.x, y / p.y);
    }
    Point operator / (double d){
        return Point(x / d, y / d);
    }

    double abs(){
        return sqrt(norm());
    }
    double norm(){
        return x * x + y * y;
    }

    bool operator < (const Point &p) const {
        return x != p.x ? x < p.x : y < p.y;
    }
    bool operator == (const Point &p) const {
        return fabs(x - p.x) < EPS && fabs(y - p.y) < EPS;
    }
    
    
};

typedef Point Vector;

class Segment : public Point{
    public:
    Point p1, p2;
    Segment(){}
    Segment(Point p1_, Point p2_){
        p1 = p1_;
        p2 = p2_;
    }
    Segment(double a, double b, double c, double d){
        p1 = Point(a, b);
        p2 = Point(c, d);
    }
    
};

typedef Segment Line;

typedef std::vector<Point> Polygon;

class Circle{
    public:
    Point c;
    double r;
    Circle(){}
    Circle(Point c_, double r_){
        c = c_;
        r = r_;
    }
};

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;
}
bool isOrthogonal(Point a, Point b){
    return equals(dot(a, b), 0.0);
}
bool isParallel(Point a, Point b){
    return equals(cross(a, b), 0.0);
}
bool isOrthogonal(Segment s1, Segment s2){
    return equals(dot(s1.p2 - s1.p1, s2.p2 - s1.p1), 0.0);
}
bool isParallel(Segment s1, Segment s2){
    return equals(cross(s1.p2 - s1.p1, s2.p2 - s1.p1), 0.0);
}

Point project(Segment s, Point p){
    Vector base = s.p2 - s.p1;
    double r = dot(p - s.p1, base) / base.norm();
    //Vector tmp = s.p1 + base * r;
    Vector tmp = base * r;
    return s.p1 + base * r;
}

Point reflect(Segment s, Point p){
    return p + (project(s, p) - p) * 2;
}

int ccw(Point p1, Point p2, Point p3){
    Vector a = p2 - p1;
    Vector b = p3 - p1;
    if( cross(a, b) > EPS ) return 1;
    else if( cross(a, b) < -EPS ) return -1;
    else if( dot(a, b) < -EPS ) return 2;
    else if( a.norm() < b.norm() ) return -2;
    //std::cout << std::fixed << std::setprecision(10) << ans.x << " " << ans.y << std::endl;
    else return 0;
}

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(Point a, Point b){
    return (a - b).abs();
}

double getDistanceLP(Line l, Point p){    
    return abs(cross(l.p2 - l.p1, p - l.p1)) / (l.p2 - l.p1).abs();
}

double getDistanceSP(Segment s, Point p){
    if(dot(s.p2 - s.p1, p - s.p1) < 0.0) return (p - s.p1).abs();
    if(dot(s.p1 - s.p2, p - s.p2) < 0.0) return (p - s.p2).abs();
    return getDistanceLP(s, p);
}

double getDistance(Segment s1, Segment s2){
    if( intersect(s1, s2) ) return 0.0;
    return std::min(std::min(getDistanceSP(s1, s2.p1), getDistanceSP(s1, s2.p2)), std::min(getDistanceSP(s2, s1.p1), getDistanceSP(s2, s1.p2)));
}

Point getCrossPoint(Segment s1, Segment s2){
    Vector base = s2.p2 - s2.p1;
    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.p2 - s1.p1) * t;
}

std::pair<Point, Point> getCrossPoints(Circle c, Line l){
    //assert(intersect(c, l));
    Vector pr = project(l, c.c);
    Vector e = (l.p2 - l.p1) / (l.p2 - l.p1).abs();
    double base = sqrt(c.r * c.r - (pr - c.c).norm());
    return std::make_pair(pr + e * base, pr - e * base);

}

double arg(Vector p){
    return atan2(p.y, p.x);
}

Vector polar(double a, double r){
    return Point(cos(r) * a, sin(r) * a);
}

std::pair<Point, Point> getCrossPoints(Circle c1, Circle c2){
    double d = (c1.c - c2.c).abs();
    double a = acos((c1.r * c1.r + d * d - c2.r * c2.r) / (2 * c1.r * d));
    double t = arg(c2.c - c1.c);
    return std::make_pair(c1.c + polar(c1.r, t+ a), c1.c + polar(c1.r, t-a));
     
}

int contains(Polygon g, Point p){
    int n = g.size();
    bool x = false;
    for(int i = 0; i < n; i++){
        Point a = g[i] - p, b = g[(i+1) % n] - p;
        if( abs(cross(a, b) ) < EPS && dot(a, b) < EPS ) return 1;
        if( a.y > b.y ) std::swap(a, b);
        if( a.y < EPS && EPS < b.y && cross(a, b) > EPS) x = !x;
    }
    return( x ? 2 : 0);

}

Polygon andrewScan( Polygon s){
    Polygon u, l;
    
    std::sort(s.begin(), s.end());
    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]) > 0; 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]) > 0; n--){
            l.pop_back();
        }
        l.push_back(s[i]);
    }

    std::reverse(l.begin(), l.end());

    for ( int i = u.size() - 2; i >= 1; i-- ){
        l.push_back( u[i] );
    }

    return l;


}

class EndPoint{
public:
    Point p;
    int seg, st;
    EndPoint(){}
    EndPoint(Point p, int seg, int st): p(p), seg(seg), st(st){}

    bool operator < (const EndPoint &ep) const{
        if(p.y == ep.p.y){
            return st < ep.st;
        }else{
            return p.y < ep.p.y;
        }
    }
};

EndPoint EP[2 * 100000];

int manhattanIntersection(std::vector<Segment> S){
    int n = S.size();

    for(int i = 0, k = 0; i < n; i++){
        if(S[i].p1.y == S[i].p2.y){
            if(S[i].p1.x > S[i].p2.x){
                std::swap(S[i].p1, S[i].p2);
            }
        }else if(S[i].p1.y > S[i].p2.y){
            std::swap(S[i].p1, S[i].p2);
        }

        if ( S[i].p1.y == S[i].p2.y ) {
            EP[k++] = EndPoint(S[i].p1, i, LEFT);
            EP[k++] = EndPoint(S[i].p2, i, RIGHT);
        } else {
            EP[k++] = EndPoint(S[i].p1, i, BOTTOM);
            EP[k++] = EndPoint(S[i].p2, i, TOP);
        }
    }

    // std::cout << "EP iterator:" << EP.begin() << ":" << EP << std::endl;
    // std::cout << "EP iterator:" << EP.end() << ":" << EP << std::endl;

    std::sort( EP, EP + (2 * n) );

    std::set<int> BT;
    BT.insert(1000000001);
    int cnt = 0;

    for(int i = 0; i < 2 * n; i++){
        if(EP[i].st == TOP){
            BT.erase(EP[i].p.x);
        }else if(EP[i].st == BOTTOM){
            BT.insert(EP[i].p.x);
        }else if(EP[i].st == LEFT){
            std::set<int>::iterator b = BT.lower_bound(S[EP[i].seg].p1.x);
            std::set<int>::iterator d = BT.upper_bound(S[EP[i].seg].p2.x);
            cnt += std::distance(b, d);
        }
    }

    return cnt;
} 

int main(void){
    int n;
    std::cin >> n;
    std::vector<Segment> S(n);
    double x1, y1, x2, y2;
    for(int i = 0; i < n; i++){
        std::cin >> x1 >> y1 >> x2 >> y2;
        
        S[i] = Segment(x1, y1, x2, y2);
        
    }
    
    std::cout << manhattanIntersection(S) << std::endl;

    return 0;
}







