// Original C++ solution (slower):
#include <cstdio>

#include <algorithm>

#include <iostream>

#include <cstring>

#include <string>

#include <sstream>

#include <queue>

#include <vector>

#include <set>

#include <map>

#include <functional>

#include <bitset>

#include <deque>

#include <cmath>

 

using namespace std;

 

typedef long long LL;

typedef unsigned long long ULL;

typedef long double LD;

 

#define rep(i, a, b) for(int i = a; i <= b; ++i)

#define dow(i, a, b) for(int i = a; i >= b; --i)

#define mem(a) memset(a, 0, sizeof(a))

#define mst(a, b) memset(a, b, sizeof(a))

#define sfi(a) scanf("%d", &a)

#define sfl(a) scanf("%lld", &a)

#define sfd(a) scanf("%lf", &a)

#define sfs(a) scanf("%s", a)

#define pb(a) push_back(a)

#define sync ios::sync_with_stdio(0); cin.tie(0);

 

const int MAXN = 1000 + 5;

const double EPS = 1e-6;

const double PI = acos(-1.0);

 

typedef struct Point Point;

typedef struct Line Line;

typedef struct Polygon Polygon;

typedef struct Polygon_convex Polygon_convex;

 

int cmp(double x);

double sqr(double x);

double det(Point a, Point b);

double dot(Point a, Point b);

double dist(Point a, Point b);

Point rotate_point(Point p, double A);

bool parallel(Line a, Line b);

bool orthogonal(Line a, Line b);

Point PointProjLine(Point p, Line l, Point &ans);

Point reflect(Line l, Point p);

double dis_point_segment(Point p, Line l);

double dis_segment_segment(Line a, Line b);

Line point_make_line(Point a, Point b);

bool in_segment(Line l, Point p);

int dcmp(double k);

double mysqrt(double n);

Point rotate(Point p, double cost, double sint);

pair<Point, Point> crosspoint(Point ap, double ar, Point bp, double br);

bool PointOnSegment(Point p, Point s, Point t);

bool comp_less(Point a, Point b);

void convex_hull(vector<Point> a);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   

struct Point

{

    double x, y;

    Point() {}

    Point(double a, double b): x(a), y(b) {}

 

    friend Point operator -(Point a, Point b)

    {

        return Point(a.x-b.x,a.y-b.y);

    }

    friend Point operator +(Point a, Point b)

    {

        return Point(a.x+b.x,a.y+b.y);

    }

    friend bool operator ==(Point a, Point b)

    {

        return cmp(a.x-b.x)==0 && cmp(a.y-b.y)==0;

    }

    friend Point operator *(Point a, double b)

    {

        return Point(a.x*b,a.y*b);

    }

    friend Point operator *(double a, Point b)

    {

        return Point(a*b.x,a*b.y);

    }

    friend Point operator /(Point a, double b)

    {

        return Point(a.x/b,a.y/b);

    }

    double norm()

    {

        return sqrt(sqr(x)+sqr(y));

    }

};

 

struct Line

{

    Point a, b;

    Line() {}

    Line(Point x, Point y): a(x), b(y) {}

};

 

struct Polygon

{

    int n;

    Point a[MAXN];

    Polygon() {}

    int Point_In(Point t)

    {

        int num = 0;

        a[n] = a[0];

        rep(i, 0, n - 1)

        {

            if(PointOnSegment(t, a[i], a[i + 1]))

                return 2;

            int k = cmp(det(a[i + 1] - a[i], t - a[i]));

            int d1 = cmp(a[i].y - t.y);

            int d2 = cmp(a[i + 1].y - t.y);

            if(k > 0 && d1 <= 0 && d2 > 0)

                num++;

            if(k < 0 && d2 <= 0 && d1 > 0)

                num--;

        }

        return num != 0;

    }

};

 

struct Polygon_convex

{

    vector<Point> P;

    Polygon_convex(int Size = 0)

    {

        P.resize(Size);

    }

} res(2*100000 + 50);

 

bool comp_less(Point a, Point b)

{

    return cmp(a.x-b.x)<0 || cmp(a.x-b.x)==0 && cmp(a.y-b.y)<0;

}

 

void convex_hull(vector<Point> a)

{

    sort(a.begin(), a.end(), comp_less);

    a.erase(unique(a.begin(), a.end()), a.end());

    int m = 0;

    int len = a.size();

    rep(i, 0, len - 1)

    {

        while(m>1&&cmp(det(res.P[m-1]-res.P[m-2],a[i]-res.P[m-2]))<0)

            --m;

        res.P[m++] = a[i];

    }

    int k = m;

    len = a.size();

    dow(i, len - 2, 0)

    {

        while(m>k && cmp(det(res.P[m-1]-res.P[m-2],a[i]-res.P[m-2]))<0)

            --m;

        res.P[m++] = a[i];

    }

    res.P.resize(m);

    if(a.size()>1)

        res.P.resize(m-1);

}

 

bool PointOnSegment(Point p, Point s, Point t)

{

    return cmp(det(p-s,t-s)) == 0 && cmp(dot(p-s,p-t))<=0;

}

 

bool parallel(Line a, Line b)

{

    return !cmp(det(a.a-a.b,b.a-b.b));

}

     

bool orthogonal(Line a, Line b)

{

    return !cmp(dot(a.a - a.b, b.a - b.b));

}

 

Point PointProjLine(Point p, Line l)

{

    Point ans;

    double r = dot((l.b-l.a),(p-l.a))/dot(l.b-l.a,l.b-l.a);

    ans = l.a + r*(l.b-l.a);

    return ans;

}

 

int cmp(double x)

{

    if(abs(x) < EPS)

        return 0;

    if(x > 0)

        return 1;

    return -1;

}

 

double dis_point_segment(Point p, Line l)

{

    if(cmp(dot(p-l.a,l.b-l.a))<0)

        return (p-l.a).norm();

    if(cmp(dot(p-l.b,l.a-l.b))<0)

        return (p-l.b).norm();

    return abs(det(l.a-p,l.b-p))/dist(l.a,l.b);

}

 

bool line_make_point(Line a, Line b, Point &res)

{

    if(parallel(a,b))

        return false;

    double s1 = det(a.a-b.a,b.b-b.a);

    double s2 = det(a.b-b.a,b.b-b.a);

    res = (s1*a.b-s2*a.a)/(s1-s2);

    return true;

}

 

double dis_segment_segment(Line a, Line b)

{

    Point res;

    if(line_make_point(a, b, res) && in_segment(a, res) && in_segment(b, res))

        return 0.;

    return min(min(dis_point_segment(b.a, a), dis_point_segment(b.b, a)), min(dis_point_segment(a.a, b), dis_point_segment(a.b, b)));

}

 

double sqr(double x)

{

    return x * x;

}

 

double det(Point a, Point b)

{

    return a.x*b.y-a.y*b.x;

}

 

double dot(Point a, Point b)

{

    return a.x*b.x+a.y*b.y;

}

double dist(Point a, Point b)

{

    return (a-b).norm();

}

 

Point rotate_point(Point p, double A)

{

    double tx = p.x, ty = p.y;

    return Point(tx*cos(A)-ty*sin(A),tx*sin(A)+ty*cos(A));

}

 

Point reflect(Line l, Point p)

{

    return p + ((PointProjLine(p, l) - p) * 2.0);

}

 

bool in_segment(Line l, Point p)

{

    bool fa = false, fb = false;

    if((cmp(p.x-l.a.x) != -1 && cmp(p.x-l.b.x) != 1) || (cmp(p.x-l.a.x) != 1 && cmp(p.x-l.b.x) != -1))

        fa = true;

    if((cmp(p.y-l.a.y) != -1 && cmp(p.y-l.b.y) != 1) || (cmp(p.y-l.a.y) != 1 && cmp(p.y-l.b.y) != -1))

        fb = true;

    return fa && fb;

}

 

int dcmp(double k)

{

    return k < -EPS ? -1 : k > EPS ? 1 : 0;

}

 

double mysqrt(double n)

{

    return sqrt(max(0.0, n));

}

 

void circle_cross_line(Point a, Point b, Point o, double r, Point ret[], int &num)

{

    double x0 = o.x, y0 = o.y;

    double x1 = a.x, y1 = a.y;

    double x2 = b.x, y2 = b.y;

    double dx = x2 - x1, dy = y2 - y1;

    double A = dx*dx+dy*dy;

    double B = 2*dx*(x1-x0)+2*dy*(y1-y0);

    double C = sqr(x1-x0)+sqr(y1-y0)-sqr(r);

    double delta = B*B-4*A*C;

    num = 0;

    if(dcmp(delta) >= 0)

    {

        double t1 = (-B - mysqrt(delta)) / (2*A);

        double t2 = (-B + mysqrt(delta)) / (2*A);

        ret[num++] = Point(x1 + t1*dx, y1 + t1*dy);

        ret[num++] = Point(x1 + t2*dx, y1 + t2*dy);

    }

     

}

 

Point rotate(Point p, double cost, double sint)

{

    double x = p.x, y = p.y;

    return Point(x*cost - y*sint, x*sint + y*cost);

}

 

pair<Point, Point> crosspoint(Point ap, double ar, Point bp, double br)

{

    double d = (ap - bp).norm();

    double cost = (ar*ar + d*d - br*br) / (2*ar*d);

    double sint = sqrt(1. - cost*cost);

    Point v = (bp - ap) / (bp - ap).norm() * ar;

    return make_pair(ap+rotate(v,cost,-sint),ap+rotate(v,cost,sint));

}

 

const int L = 2;

const LL MOD = 100000 + 50;

const int MAX = 100000 + 50;

 

struct Node

{

    Point p;

    Point q;

    int id;

    Node(Point p_ = Point(0.,0.), Point q_ = Point(0., 0.), int id_ = 4):p(p_), q(q_), id(id_){}

    friend bool operator ==(Node a, Node b)

    {

        return cmp(a.p.x-b.p.x)==0 && cmp(a.p.y-b.p.y)==0;

    }

    friend bool operator <(Node a, Node b)

    {

        if(cmp(a.p.y-b.p.y)==0)

            return a.id < b.id;

        return a.p.y < b.p.y;

    }

} node[MAX * 2];

 

set<double> s;

 

int main()

{   

#ifdef LOCAL

    //~ freopen("in.txt", "r", stdin);

#endif

 

    int n;

    sfi(n);

    int cnt = 0;

    rep(i, 0, n - 1)

    {

        Point a, b;

        scanf("%lf%lf%lf%lf", &a.x, &a.y, &b.x, &b.y);

        if(cmp(a.x-b.x)==0)

        {

            if(a.y < b.y)

            {

                node[cnt++] = Node(a, Point(0., 0.), 1);

                node[cnt++] = Node(b, Point(0., 0.), 3);

            }

            else

            {

                node[cnt++] = Node(a, Point(0., 0.), 3);

                node[cnt++] = Node(b, Point(0., 0.), 1);

            }

        }

        else

        {

            if(a.x < b.x)

                node[cnt++] = Node(a, b, 2);

            else

                node[cnt++] = Node(b, a, 2);

        }

         

    }

    sort(node, node + cnt);

     

    int ans = 0;

    rep(i, 0, cnt - 1)

    {

        if(node[i].id == 3)

        {

            set<double>::iterator it = s.find(node[i].p.x);

            s.erase(*it);

        }

        else if(node[i].id == 1)

        {

            s.insert(node[i].p.x);

        }

        else if(node[i].id == 2)

        {

            set<double>::iterator it = s.lower_bound(node[i].p.x);

            for(; it != s.end() && (*it) <= node[i].q.x; it++)

                ans++;

        }

    }

    printf("%d\n", ans);

    return 0;

}




// Optimized solution to the same problem (faster):
#include<bits/stdc++.h>

#define ll long long

#define inf 0x3f3f3f3f

#define fi first

#define se second

#define pb push_back

#define mkp make_pair

#define pa pair<int,int>

const int N=1e6+10;

const int mod=1e9+7;

using namespace std;



struct Point{int x,y;};

struct segment{Point p1,p2;};

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 {return p.y==ep.p.y?type<ep.type:p.y<ep.p.y;}

};

int sweep(vector<segment> v)

{

   vector<endpoint> ep;

   for(int i=0,sz=v.size();i<sz;i++)

   {

      segment &e=v[i];

      if(e.p1.x==e.p2.x)

      {

         if(e.p1.y>e.p2.y) swap(e.p1,e.p2);

         ep.pb(endpoint(e.p1,i,0));

         ep.pb(endpoint(e.p2,i,3));

      }

      else 

      {

         if(e.p1.x>e.p2.x) swap(e.p1,e.p2);

         ep.pb(endpoint(e.p1,i,1));

         ep.pb(endpoint(e.p2,i,2));

      }

   }

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

   int ans=0; set<int> s; s.insert(inf);

   for(auto e: ep)

   {

      if(e.type==0) s.insert(e.p.x);

      else if(e.type==3) s.erase(e.p.x);

      else if(e.type==1) ans+=distance(s.lower_bound(v[e.id].p1.x),s.upper_bound(v[e.id].p2.x));

   }

 return ans;

}

int main()  

{  

     int n;  scanf("%d",&n);

     vector<segment> v; segment t;

     for(int i=1;i<=n;i++) scanf("%d%d%d%d",&t.p1.x,&t.p1.y,&t.p2.x,&t.p2.y),v.pb(t);

     printf("%d\n",sweep(v));

return 0;  

}  


// Fastest known solution for this problem: