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>
using namespace std;

#define EPS (1e-10)
#define equals(a, b) (fabs((a) - (b)) < EPS)

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 * (double a) { return Point(a * x, a * y); }
    Point operator / (double a) { return Point(x / a, y / a); }

    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;

double dot(Vector a, Vector b) {
    return a.x * b.x + a.y * b.y;
}

double cross(Vector a, Vector b) {
    return a.x * b.y - a.y * b.x;
}

struct Segment {
    Point p1, p2;
};

typedef Segment Line;

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

typedef vector<Point> Polygon;

bool isParallel(Vector a, Vector b) {
    return equals(dot(a, b), 0.0);
}

bool isParallel(Point a1, Point a2, Point b1, Point b2) {
    return isParallel(a1 - a2, b1 - b2);
}

bool isParallel(Segment s1, Segment s2) {
    return equals(cross((s1.p2 - s1.p1), (s2.p2 - s2.p1)), 0.0);
}

bool isOrthogonal(Vector a, Vector b) {
    return equals(cross(a, b), 0.0);
}

bool isOrthogonal(Point a1, Point a2, Point b1, Point b2) {
    return isOrthogonal(a1 - a2, b1 - b2);
}

bool isOrthogonal(Segment s1, Segment s2) {
    return equals(dot((s1.p2 - s1.p1), (s2.p2 - s2.p1)), 0.0);
}

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

Point reflect(Segment s, Point p) {
    Point projection = project(s, p);
    Vector toReflection = (projection - p) * 2.0;
    return p + toReflection; 
}

int ccw(Point p0, Point p1, Point p2) {
    Vector v1 = p1 - p0;
    Vector v2 = p2 - p0;

    // 反時計
    if (cross(v1, v2) > 0.0) return 1;
    // 時計
    if (cross(v1, v2) < 0.0) return -1;

    // p1, p2 が逆方向
    if (dot(v1, v2) < 0.0) return 2;

    // p1, p2 が同方向
    if (v1.abs() < v2.abs()) return -2;
    return 0;
}

bool intersect(Segment s1, Segment s2) {
    return (ccw(s1.p1, s1.p2, s2.p1) * ccw(s1.p1, s1.p2, s2.p2) <= 0
            && ccw(s2.p1, s2.p2, s1.p1) * ccw(s2.p1, s2.p2, s1.p2) <= 0);
}

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) return (p - s.p1).abs();
    if (dot(s.p1 - s.p2, p - s.p2) < 0) return (p - s.p2).abs();

    return getDistanceLP(s, p);
}

double getDistanceSS(Segment s1, Segment s2) {
    if (intersect(s1, s2)) {
        return 0.0;
    }

    return min(
        min(getDistanceSP(s1, s2.p1), getDistanceSP(s1, s2.p2)),
        min(getDistanceSP(s2, s1.p1), getDistanceSP(s2, s1.p2))
    );
}

double getDistancePP(Point p1, Point p2) {
    return (p2 - p1).abs();
}

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));

    Vector hypo = s1.p2 - s1.p1;
    return s1.p1 + hypo * (d1 / (d1 + d2));
}

pair<Point, Point> getCircleSegmentCrossPoint(Circle c, Segment s) {
    Point projection = project(s, c.c);
    double dist = sqrt(c.r * c.r - (c.c - projection).norm());
    Vector base = s.p2 - s.p1;
    base = base / base.abs();
    Point a = projection + (base * dist);
    return make_pair(projection + (base * dist), projection - (base * dist));
}

pair<Point, Point> getCircleCrossPoint(Circle c1, Circle c2) {
    double d = (c2.c - c1.c).abs();
    double a = acos((d * d + c1.r * c1.r - c2.r * c2.r) / (2 * d * c1.r));
    double t = atan2((c2.c - c1.c).y, (c2.c - c1.c).x);
    Point crossPoint1 = {c1.c.x + c1.r * cos(a + t), c1.c.y + c1.r * sin(a + t)};
    Point crossPoint2 = {c1.c.x + c1.r * cos(t - a), c1.c.y + c1.r * sin(t - a)};
    return make_pair(crossPoint1, crossPoint2);
}

int isContainedInPolygon(Polygon polygon, Point target) {
    int n = polygon.size();
    bool contained = false;
    for (int i = 0; i < n; i++) {
        Point p1 = polygon.at(i);
        Point p2 = polygon.at((i + 1) % n);
        Vector a = p1 - target;
        Vector b = p2 - target;

        if (abs(cross(a, b)) < EPS && dot(a, b) < EPS) return 1;

        if (a.y > b.y) swap(a, b);

        if (a.y < EPS && b.y > EPS && cross(a, b) > 0) contained = !contained;
    }

    return contained ? 2 : 0;
}

Polygon getConvexHull(vector<Point> points) {
    vector<Point> upper, lower;
    sort(points.begin(), points.end());

    upper.push_back(points[0]);
    upper.push_back(points[1]);
    lower.push_back(points[points.size() - 1]);
    lower.push_back(points[points.size() - 2]);
    
    for (int i = 2; i < points.size(); i++) {
        Point a, b;
        int j = upper.size() - 1;
        while (j > 0) {
            Point a = upper[j];
            Point b = upper[j - 1];
            if (ccw(b, a, points[i]) != 1) {
                break;
            }
            upper.pop_back();
            j--;
        }
        upper.push_back(points[i]);
    }

    for (int i = points.size() - 3; i >= 0; i--) {
        Point a, b;
        int j = lower.size() - 1;
        while (j > 0) {
            Point a = lower[j];
            Point b = lower[j - 1];
            if (ccw(b, a, points[i]) != 1) {
                break;
            }
            lower.pop_back();
            j--;
        }
        lower.push_back(points[i]);
    }

    reverse(lower.begin(), lower.end());
    for (int i = upper.size() - 2; i >= 1; i--) lower.push_back(upper[i]);

    return lower;
}

struct EndPoint {
    Point p;
    int id, type;
    EndPoint() {}
    EndPoint(Point p, int id, int type): p(p), id(id), type(type) {}

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

int manhattanIntersection(vector<Segment> segments) {
    int n = segments.size();
    vector<EndPoint> eps;

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

        if (segments[i].p1.y == segments[i].p2.y) {
            // left = 1
            eps.push_back(EndPoint(segments[i].p1, i, 1));
            // right = 2
            eps.push_back(EndPoint(segments[i].p2, i, 2));
        } else {
            // bottom = 0
            eps.push_back(EndPoint(segments[i].p1, i, 0));
            // top = 3
            eps.push_back(EndPoint(segments[i].p2, i, 3));
        }
    }

    sort(eps.begin(), eps.end());

    set<int> BT;
    int count = 0;
    for (EndPoint ep : eps) {
        if (ep.type == 0) {
            BT.insert(ep.p.x);
        } else if (ep.type == 3) {
            BT.erase(ep.p.x);
        } else if (ep.type == 1) {
            set<int>::iterator left = lower_bound(BT.begin(), BT.end(), segments[ep.id].p1.x);
            set<int>::iterator right = upper_bound(BT.begin(), BT.end(), segments[ep.id].p2.x);
            count += distance(left, right);
        }
    }

    return count;
}

int main() {
    // cout << fixed << setprecision(11);

    int n;
    cin >> n;

    vector<Segment> segments;
    double x1, y1, x2, y2;
    for (int i = 0; i < n; i++) {
        cin >> x1 >> y1 >> x2 >> y2;
        Point p1 = {x1, y1};
        Point p2 = {x2, y2};

        Segment s = {p1, p2};
        segments.push_back(s);
    }

    cout << manhattanIntersection(segments) << endl;

    return 0;
}

