#include<bits/stdc++.h>
#include <bits/extc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
// add some black magic for faster hash sets
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;

const ll INF = 2e9+1;
int n; 
ll ans=0;
typedef array<int,4> twr;
typedef pair<int,int> pt;
vector<twr> towers;
ostream& operator<<(ostream &o,const pt &p) {
  return o<<"("<<p.first<<","<<p.second<<")"; }
ostream& operator<<(ostream &o,const twr &p) {
  return o<<"("<<p[0]<<","<<p[1]<<")->("<<p[2]<<","<<p[3]<<")"; }
vector<int> hor, ver; // horizontal and verticals

struct BITree { 
  int N = 0;
	vector<vector<int>> vals;
	vector<vector<int>> bit;
  gp_hash_table<int,int> ridx;

	/** @return the first index i such that v[i] <= x */
	int ind(const vector<int> &v, int x) {
		return upper_bound(begin(v), end(v), x) - begin(v) - 1;
	}

	BITree(vector<array<int, 2>> &todo) {
		sort(begin(todo), end(todo),
		     [](const array<int, 2> &a, const array<int, 2> &b) -> bool {
			     return a[1] < b[1];
		     });
    vector<int> coords;
		for (auto [r, c] : todo) {
      coords.push_back(r);
      coords.push_back(c);
    }
    coords.push_back(-INF-1);
    coords.push_back(INF+1);
    sort(coords.begin(), coords.end());
    for(int x: coords) {
      if (!coords.empty() && x==coords.back()) continue;
      ridx[x] = N++;
    }
    vals.resize(N + 1);
    bit.resize(N + 1);
		for (auto&[r, c] : todo) {
      r = ridx[r];
      c = ridx[c];
    }

		for (int i = 1; i <= N; i++) { vals[i].push_back(0); }
		for (auto [r, c] : todo) {
			r++, c++;
			for (; r <= N; r += r & -r) {
				if (vals[r].back() != c) { vals[r].push_back(c); }
			}
		}
		for (int i = 1; i <= N; i++) { bit[i].resize(vals[i].size()); }
	}

	void add(int r, int c, int val=1) {
    r = ridx[r], c = ridx[c];
		r++, c++;
		for (; r <= N; r += r & -r) {
			int i = ind(vals[r], c);
			for (; i < (int)bit[r].size(); i += i & -i) { bit[r][i] += val; }
		}
	}

	/** @returns sum of points with row in [0, r] and column in [0, c] */
	int query(int r, int c) {
		r++, c++;
		int sum = 0;
		for (; r > 0; r -= r & -r) {
			int i = ind(vals[r], c);
			for (; i > 0; i -= i & -i) { sum += bit[r][i]; }
		}
		return sum;
	}

  ll query_range(int xl, int xr, int yl, int yr) { return query(xr, yr) - query(xl-1, yr) - query (xr, yl-1) + query(xl-1, yl-1); }

  ll intersect(int l, int r) {
    l = ridx[l]; r = ridx[r];
    return query_range(1,l-1, l, N) + query_range(1, r, r+1, N) + query_range(l, r, l, r) - query_range(1, l-1, r+1, N);
  }

  ll noninter(int l, int r) {
    l = ridx[l]; r = ridx[r];
    return query_range(l+1, r, r+1, N);
  }
};

void solve_cross(vector<twr> fw) { // assume all are / <-
  ll k = fw.size();
  ll inter = 0;
  vector<ll> yinter(k);
  vector<array<int,2>> todo;
  for(int i=0;i<k;i++) {
    yinter[i] = (ll)fw[i][0] - fw[i][1];
    todo.push_back({fw[i][1], fw[i][3]});
  }
  BITree bt(todo);
  vector<int> id(k);
  iota(id.begin(), id.end(), 0);
  sort(id.begin(), id.end(), [&](int a, int b) {
        return yinter[a] < yinter[b];
      });
  auto flush = [&] (vector<int>& idx) {
    for(int i: idx) {
      //cerr << "flush " << fw[i][1] << " " << fw[i][3] <<endl;
      inter-=bt.noninter(fw[i][1], fw[i][3]);
    }
    for(int i: idx) {
      inter+=bt.intersect(fw[i][1], fw[i][3]);
      bt.add(fw[i][1], fw[i][3]);
    }
    idx.clear();
  };
  vector<int> cur;
  int last = -1;
  for(int i: id) {
    if (last != -1 && yinter[i] != yinter[last]) flush(cur);
    cur.push_back(i);
    last = i;
  }
  flush(cur);
  //cerr << "found inter " << inter <<endl;
  ans += inter;
}

// assume that: abs(x1-x2) < abs(y1-y2)
void solve(vector<int> &ids) {
  //cerr << "number of lines  " << ids.size() <<endl;
  vector<twr> fw, bk;
  vector<int> coords;
  vector<array<int,2>> qs;
  for(int i: ids) {
    int centerx = towers[i][0]/2 + towers[i][2]/2;
    int centery = towers[i][1]/2 + towers[i][3]/2;
    int dxdy = centerx - towers[i][0];
    coords.push_back(centery+dxdy);
    coords.push_back(centery-dxdy);
    if (towers[i][1] > towers[i][3]) {
      twr t{towers[i][0], centery-dxdy, towers[i][2], centery+dxdy};
      fw.push_back(t);
      qs.push_back({t[1], t[3]});
    }
    else if (towers[i][1] < towers[i][3]) {
      twr t{towers[i][0], -(centery+dxdy), towers[i][2], -(centery-dxdy)};
      bk.push_back(t);
      qs.push_back({-t[3], -t[1]});
    }
  }
  BITree bt(qs);
  for(const auto &t: fw) {
    //cerr << "add " <<t[1]<<", " <<t[3] << endl;
    bt.add(t[1],t[3]);
  }
  ll inter=0;
  for(const auto &t: bk) {
    //cerr << "oppo " <<-t[3]<<", " <<-t[1] << endl;
    inter += bt.intersect(-t[3], -t[1]);
  }
  //cerr << "Found cross " << inter <<endl;
  ans += inter;
  solve_cross(fw);
  solve_cross(bk);
}

int main(){
  cin.tie(0); ios_base::sync_with_stdio(0);
  cin >> n;
  // handle square case by deleting immediately
  int real_n = n;
  for(int i=0;i<n;i++) {
    int x1, y1, x2, y2;
    cin >> x1 >> y1 >> x2 >> y2;
    if (abs(x1-x2) == abs(y1-y2)) {
      ans += --real_n;
    }
    else { 
    // make sure that x1 < x2
      twr t{2*x1, 2*y1, 2*x2, 2*y2};
      if (t[0] > t[2]) {
        swap(t[0], t[2]);
        swap(t[1], t[3]);
      }
      towers.emplace_back(t);
      if (abs(x1-x2) > abs(y1-y2)) {
        ver.push_back(towers.size()-1);
      }
      if (abs(x1-x2) < abs(y1-y2)) {
        hor.push_back(towers.size()-1);
      }
    }
  }
  n = real_n;
  // handle horizontal vs vertical
  ans+=(ll)hor.size() * (ll)ver.size();
  // handle horizontal horizontal
  solve(hor);
  // handle vertical vertical 
  for(int i=0;i<n;i++){ // reflect about x=y
    twr t = towers[i];
    if (t[1] > t[3]) {
      towers[i] = {towers[i][3], towers[i][2], towers[i][1], towers[i][0]};
    }
    else {
      towers[i] = {towers[i][1], towers[i][0], towers[i][3], towers[i][2]};
    }
  }
  solve(ver);
  cout << ans <<endl;

}