#include <bits/stdc++.h>
using namespace std;
template <typename T>
T id(T b) {
  return b;
};
template <class It>
bool all(It f, It l) {
  return std::all_of(f, l, id<bool>);
}
template <class It>
bool any(It f, It l) {
  return std::any_of(f, l, id<bool>);
}
template <typename T>
void chmax(T &x, T y) {
  if (x < y) x = y;
}
template <typename T>
void chmin(T &x, T y) {
  if (x > y) x = y;
}
void fastio() {
  ios_base::sync_with_stdio(false);
  cin.tie(nullptr);
}
const int MAX_N = 5000, BIAS = 5001;
int n;
vector<tuple<int, int, int>> v;
vector<tuple<int, int, int>> h;
class bit {
  int n, bias;
  vector<int> b;
  long long _sum(int i) {
    long long s = 0;
    while (i > 0) {
      s += b[i];
      i -= i & -i;
    }
    return s;
  }
  long long _sum(int i, int j) {
    if (j < i) return 0;
    return _sum(j) - _sum(i - 1);
  }
  void _add(int i, int x) {
    while (i <= n) {
      b[i] += x;
      i += i & -i;
    }
  }

 public:
  bit(int n, int bias = 0) : n(n), b(n + 1), bias(bias) {}
  long long sum(int i) { return _sum(i + bias); }
  long long sum(int i, int j) { return _sum(i + bias, j + bias); }
  void add(int i, int x) { _add(i + bias, x); }
};
int main() {
  fastio();
  cin >> n;
  for (int i = 0; i < int(n); i++) {
    int a1, b1, a2, b2;
    cin >> a1 >> b1 >> a2 >> b2;
    if (a1 == a2) {
      if (b1 > b2) swap(b1, b2);
      v.emplace_back(a1, b1, b2);
    } else {
      if (a1 > a2) swap(a1, a2);
      h.emplace_back(a1, a2, b1);
    }
  }
  sort(v.begin(), v.end());
  long long res = 0;
  for (int i = 0; i < int(v.size()); i++) {
    auto [x, y1, y2] = v[i];
    multiset<pair<int, int>> by_r;
    bit bity(5000 + BIAS, BIAS);
    for (int j = 0; j < int(h.size()); j++) {
      auto [x1, x2, y] = h[j];
      if (x < x1) continue;
      by_r.insert(make_pair(x2, y));
      bity.add(y, 1);
    }
    for (int j = i + 1; j < v.size(); j++) {
      auto [a, b1, b2] = v[j];
      while (!by_r.empty() && by_r.begin()->first < a) {
        bity.add(by_r.begin()->second, -1);
        by_r.erase(by_r.begin());
      }
      int l = max(y1, b1), u = min(y2, b2);
      long long c = bity.sum(l, u);
      res += c * (c - 1) / 2;
    }
  }
  cout << res << endl;
  return 0;
}

### Prompt

Generate a CPP solution to the following problem:

There are n segments drawn on a plane; the i-th segment connects two points (x_{i, 1}, y_{i, 1}) and (x_{i, 2}, y_{i, 2}). Each segment is non-degenerate, and is either horizontal or vertical — formally, for every i ∈ [1, n] either x_{i, 1} = x_{i, 2} or y_{i, 1} = y_{i, 2} (but only one of these conditions holds). Only segments of different types may intersect: no pair of horizontal segments shares any common points, and no pair of vertical segments shares any common points.

We say that four segments having indices h_1, h_2, v_1 and v_2 such that h_1 < h_2 and v_1 < v_2 form a rectangle if the following conditions hold:

  * segments h_1 and h_2 are horizontal; 
  * segments v_1 and v_2 are vertical; 
  * segment h_1 intersects with segment v_1; 
  * segment h_2 intersects with segment v_1; 
  * segment h_1 intersects with segment v_2; 
  * segment h_2 intersects with segment v_2. 



Please calculate the number of ways to choose four segments so they form a rectangle. Note that the conditions h_1 < h_2 and v_1 < v_2 should hold.

Input

The first line contains one integer n (1 ≤ n ≤ 5000) — the number of segments.

Then n lines follow. The i-th line contains four integers x_{i, 1}, y_{i, 1}, x_{i, 2} and y_{i, 2} denoting the endpoints of the i-th segment. All coordinates of the endpoints are in the range [-5000, 5000].

It is guaranteed that each segment is non-degenerate and is either horizontal or vertical. Furthermore, if two segments share a common point, one of these segments is horizontal, and another one is vertical.

Output

Print one integer — the number of ways to choose four segments so they form a rectangle.

Examples

Input


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


Output


7


Input


5
1 5 1 0
0 1 5 1
5 4 0 4
4 2 4 0
4 3 4 5


Output


0

Note

The following pictures represent sample cases:

<image> <image>

### Response

```cpp
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T id(T b) {
  return b;
};
template <class It>
bool all(It f, It l) {
  return std::all_of(f, l, id<bool>);
}
template <class It>
bool any(It f, It l) {
  return std::any_of(f, l, id<bool>);
}
template <typename T>
void chmax(T &x, T y) {
  if (x < y) x = y;
}
template <typename T>
void chmin(T &x, T y) {
  if (x > y) x = y;
}
void fastio() {
  ios_base::sync_with_stdio(false);
  cin.tie(nullptr);
}
const int MAX_N = 5000, BIAS = 5001;
int n;
vector<tuple<int, int, int>> v;
vector<tuple<int, int, int>> h;
class bit {
  int n, bias;
  vector<int> b;
  long long _sum(int i) {
    long long s = 0;
    while (i > 0) {
      s += b[i];
      i -= i & -i;
    }
    return s;
  }
  long long _sum(int i, int j) {
    if (j < i) return 0;
    return _sum(j) - _sum(i - 1);
  }
  void _add(int i, int x) {
    while (i <= n) {
      b[i] += x;
      i += i & -i;
    }
  }

 public:
  bit(int n, int bias = 0) : n(n), b(n + 1), bias(bias) {}
  long long sum(int i) { return _sum(i + bias); }
  long long sum(int i, int j) { return _sum(i + bias, j + bias); }
  void add(int i, int x) { _add(i + bias, x); }
};
int main() {
  fastio();
  cin >> n;
  for (int i = 0; i < int(n); i++) {
    int a1, b1, a2, b2;
    cin >> a1 >> b1 >> a2 >> b2;
    if (a1 == a2) {
      if (b1 > b2) swap(b1, b2);
      v.emplace_back(a1, b1, b2);
    } else {
      if (a1 > a2) swap(a1, a2);
      h.emplace_back(a1, a2, b1);
    }
  }
  sort(v.begin(), v.end());
  long long res = 0;
  for (int i = 0; i < int(v.size()); i++) {
    auto [x, y1, y2] = v[i];
    multiset<pair<int, int>> by_r;
    bit bity(5000 + BIAS, BIAS);
    for (int j = 0; j < int(h.size()); j++) {
      auto [x1, x2, y] = h[j];
      if (x < x1) continue;
      by_r.insert(make_pair(x2, y));
      bity.add(y, 1);
    }
    for (int j = i + 1; j < v.size(); j++) {
      auto [a, b1, b2] = v[j];
      while (!by_r.empty() && by_r.begin()->first < a) {
        bity.add(by_r.begin()->second, -1);
        by_r.erase(by_r.begin());
      }
      int l = max(y1, b1), u = min(y2, b2);
      long long c = bity.sum(l, u);
      res += c * (c - 1) / 2;
    }
  }
  cout << res << endl;
  return 0;
}

```