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;
using ll = long long;
using ull = unsigned long long;
//#define ll long long
template<class T> bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T> bool chmin(T &a, const T &b) { if (a>b) { a=b; return 1; } return 0; }
#define rep(i, n) REP(i, 0, n)
#define rep_rev(i, n) for (int (i) = (int)(n) - 1 ; (i) >= 0 ; --(i))
#define ALL(v) v.begin(), v.end()
#define MSG(a) cout << #a << " " << a << endl;
#define REP(i, x, n) for(int i = x; i < n; i++)
#define all(x) (x).begin(),(x).end()
ll t1,t2;
const ll mod = 1000000007;
const int INF = 1e9;
const ll INFLONG = 1e18;

#define EPS (1e-10)
#define equals(a,b) (fabs((a) - (b)) < EPS)
static const int COUNTER_CLOCKWISE = 1;
static const int CLOCKWISE = -1;
static const int ONLINE_BACK = 2;
static const int ONLINE_FRONT = -2;
static const int ON_SEGMENT = 0;


class Point {
public:
    double x,y;
    Point(double x,double y):x(x),y(y){}
    Point():x(0),y(0){}

    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(x*a,y*a);}
    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;
    }

    void set(double x,double y) {
      this->x = x;
      this->y = y;
    }

    void rotateR(){
      double xt = x;
      double yt = y;
      x = yt;
      y = -xt;
    }
    void rotateL(){
      double xt = x;
      double yt = y;
      x = -yt;
      y = xt;
    }
};

struct Segment{
    Point p1,p2;
};

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



typedef Point Vector;
typedef Segment Line;
typedef vector<Point> Polygon;

double norm(Point a){
  return a.x * a.x + a.y * a.y;
}

double abs(Point a){
  return sqrt(norm(a));
}

//等しいか
bool eq(Point a,Point b){
  return abs(a-b) < EPS;
}

//内積
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;
}

//直交か
bool isOrthogonal(Vector a,Vector b){
  return equals(dot(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);
}

//平行か
bool isParallel(Vector a, Vector b){
  return equals(cross(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);
}

//射影
Point project(Segment s,Point p){
  Point vec1,vec2;
  vec1 = s.p2 - s.p1;
  vec2 = p - s.p1;
  return s.p1 + vec1 * dot(vec1,vec2) / vec1.norm();
}

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

//位置関係(時計回りか,線分上かなど)
int ccw(Point p0,Point p1,Point p2){
  Vector a = p1 - p0;
  Vector b = p2 - p0;
  if(cross(a,b) > EPS)return COUNTER_CLOCKWISE;
  if(cross(a,b) < -EPS) return CLOCKWISE;
  if(dot(a,b) < -EPS)return ONLINE_BACK;
  if(a.norm() < b.norm())return ONLINE_FRONT;
  return ON_SEGMENT;
}

//交わるか
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 abs(a-b);
}

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

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


double getDistance(Segment s1,Segment s2){
  if(intersect(s1,s2)){
    return 0.0;
  }
  double ans = INF;
  chmin(ans,getDistanceSP(s1,s2.p1));
  chmin(ans,getDistanceSP(s1,s2.p2));
  chmin(ans,getDistanceSP(s2,s1.p1));
  chmin(ans,getDistanceSP(s2,s1.p2));
  return ans;
}

//交わるか
bool intersect(Circle c,Line l){
  return c.r - getDistanceLP(l,c.c) > -EPS;
}

//円と直線の交点
pair<Point,Point> getCrossPoint(Line l,Circle c){
  assert(intersect(c,l));
  Vector pr = project(l,c.c);
  Vector e = (l.p2 - l.p1) / abs(l.p2 - l.p1);
  if(e.x < 0 || (e.x < EPS && e.y < 0)){
    e = e * -1;
  }
  double base = sqrt(c.r * c.r - norm(pr - c.c));
  return make_pair(pr - e * base,pr + e * base);
}

//交わるか
bool intersect(Circle c1,Circle c2){
  double dis = getDistance(c1.c,c2.c);
  return c1.r + c2.r - dis > -EPS && abs(c1.r - c2.r) - dis < EPS;
}

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

//極座標から平面座標へ
Vector polar(double a,double r){
  return Point(cos(r) * a ,sin(r) * a);
}

//円と円の交点
pair<Point,Point> getCrossPoint(Circle c1,Circle c2){
  assert(intersect(c1,c2));
  double d = abs(c1.c-c2.c);
  double a = acos((c1.r * c1.r + d * d - c2.r * c2.r) / (2 * c1.r * d));
  double t = arg(c2.c - c1.c);
  //cout << d << a << t;
  return make_pair(c1.c + polar(c1.r, t+a), c1.c + polar(c1.r,t-a));
}



//内包
// IN:2,ON:1,OUT:0
int contains(Polygon g,Point p){
  ull n = g.size();
  bool x = false;
  rep(i,n){
    Point a = g[i] - p;
    Point b = g[(i+1) % n] - p;
    if(abs(cross(a,b)) < EPS && dot(a,b) < EPS) return 1; //線分上にある
    if(a.y > b.y) swap(a,b);
    if(a.y < EPS && EPS < b.y && cross(a,b) > EPS) x = !x; //3つ目の条件は、時計回りか半時計回りか
  }
  return (x ? 2 : 0);
}

//凸包:Convex Hull
//凸包の辺上の点を含む場合は、!= CLOCKWISE を == COUNTER_CLOCKWIS　に置き換える!
Polygon andrewScan(Polygon s){
  Polygon u,l;
  if(s.size() < 3){
    return s;
  }
  sort(all(s));//xの昇順にソート
  //xが小さいものから二つuに追加
  u.push_back(s[0]);
  u.push_back(s[1]);
  //xが大きいものから２つuに追加
  l.push_back(s[s.size() - 1]);
  l.push_back(s[s.size() - 2]);

  ull len = s.size();
  //凸包の上部を生成
  for(ll i = 2;i < len;i++){
    for(ull n = u.size();n >= 2 && ccw(u[n-2],u[n-1],s[i]) == COUNTER_CLOCKWISE;n--){
      u.pop_back();
    }
    u.push_back(s[i]);
  }
  //凸包の下部を生成
  for(ll i = len-3;i >= 0;i--){
    for(ull n = l.size();n >= 2 && ccw(l[n-2],l[n-1],s[i]) == COUNTER_CLOCKWISE;n--){
      l.pop_back();
    }
    l.push_back(s[i]);
  }
  //時計回りになる様に凸包の天の列の生成
  reverse(all(l));
  for(ull i = u.size()-2;i >= 1;i--){
    l.push_back(u[i]);
  }
  return l;
}

//端点の種類
#define BOTTOM 0
#define LEFT 1
#define RIGHT 2
#define TOP 3

class EndPoint{
public:
    Point p;
    ll seg,st; //入力線分のID,端点の種類
    EndPoint(){}
    EndPoint(Point p,ll seg,ll st):p(p),seg(seg),st(st){}

    bool operator <(const EndPoint &ep)const{
      //y座標が小さい順に整列
      if(p.y == ep.p.y){
        return st < ep.st;
      }else{
        return p.y < ep.p.y;
      }
    }
};

/*********************/
EndPoint EP[2 * 100000]; //端点のリスト

//線分交差問題: マンハッタン幾何
ll manhattanIntersection(vector<Segment> S){
  ull n = S.size();
  for(int i = 0,k=0;i < n;i++){
    //端点p1,p2が左下を基準に並ぶ様に調節
    if(S[i].p1.y == S[i].p2.y){
      if(S[i].p1.x > S[i].p2.x){
        swap(S[i].p1,S[i].p2);
      }
    }else if(S[i].p1.y > S[i].p2.y){
      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);
    }
  }
  sort(EP,EP + (2 * n)); // 端点のy座標に関して昇順に整列

  set<ll> BT; //二分探索木
  BT.insert(INF); //番兵を設置
  ll cnt = 0;

  for(ll i = 0;i < 2*n;i++){
    //cout << EP[i].p.x << " " << EP[i].p.y << endl;
    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){
      auto b = BT.lower_bound(S[EP[i].seg].p1.x); //O(log n)
      auto e = BT.upper_bound(S[EP[i].seg].p2.x); //O(log n)
      cnt += abs(distance(BT.begin(),b) - distance(BT.begin(),e)); //bとeの距離(点の数)を加算, O(k)
    }
  }

  return cnt;
}


int main() {
  ll n;
  cin >> n;
  double x1,x2,y1,y2;
  vector<Segment> s(n);
  rep(i,n){
    cin >> x1 >> y1 >> x2 >> y2;
    s[i].p1 = Point(x1,y1);
    s[i].p2 = Point(x2,y2);
  }
  cout << manhattanIntersection(s) << endl;
}

