#!/usr/bin/env python3

import sys
from bisect import bisect_left

def compress(data):
    return sorted(set(data))

def lookup(data, val):
    return bisect_left(data, val)

class BIT:
    """0-indexed Fenwick tree storing sums (UNIT=0)."""
    __slots__ = ("n", "tree")

    UNIT = 0

    def __init__(self, n):
        self.n = n
        self.tree = [self.UNIT] * (n + 1)

    def update(self, x, v):
        """data[x] += v"""
        x += 1
        n = self.n
        tree = self.tree
        while x <= n:
            tree[x] += v
            x += x & -x

    def query(self, x):
        """sum over [0, x)"""
        res = self.UNIT
        tree = self.tree
        while x > 0:
            res += tree[x]
            x -= x & -x
        return res

class BIT2:
    """
    First dimension Fenwick tree (over idx), each node holds another
    Fenwick tree over 'v' values (compressed per node).
    """
    __slots__ = ("n", "f_tree", "vals")

    def __init__(self, n):
        self.n = n
        self.f_tree = [None] * (n + 1)
        self.vals = [[] for _ in range(n + 1)]

    def insert(self, idx, v):
        """Collect values for compression (offline)."""
        i = idx + 1
        n = self.n
        vals = self.vals
        while i <= n:
            vals[i].append(v)
            i += i & -i

    def finalize(self):
        """Compress collected values and build BITs."""
        for i in range(1, self.n + 1):
            xs = compress(self.vals[i])
            self.vals[i] = xs
            self.f_tree[i] = BIT(len(xs))

    def update(self, idx, v, d):
        """Add d to position (idx, v)."""
        i = idx + 1
        n = self.n
        while i <= n:
            xs = self.vals[i]
            j = lookup(xs, v)  # index within compressed second dimension
            # j must be within 0..len(xs)-1
            self.f_tree[i].update(j, d)
            i += i & -i

    def query(self, idx, v):
        """
        Return sum over all entries with first index in [0, idx)
        and second value < v (strict).
        """
        res = 0
        i = idx
        while i > 0:
            xs = self.vals[i]
            j = lookup(xs, v)  # count values strictly less than v
            res += self.f_tree[i].query(j)
            i -= i & -i
        return res

# Wiggle: [L, R, INTERCEPT, TYPE]
def solve(wiggles):
    xs = []
    for l, r, i, t in wiggles:
        xs.append(l)
        xs.append(r)
    xs = compress(xs)
    m = len(xs)

    ds = [BIT2(m), BIT2(m)]

    # events[pos] each contains (op, ridx, i, t)
    all_events = [[] for _ in xs] 

    for l, r, i, t in wiggles:
        lidx = lookup(xs, l)
        ridx = lookup(xs, r)

        all_events[lidx].append((+1, ridx, i, t))
        all_events[ridx].append((-1, ridx, i, t))

        ds[0].insert(ridx, i)
        ds[1].insert(ridx, i)

    ds[0].finalize()
    ds[1].finalize()

    ans = 0
    passed = 0  # number of segments that have been removed so far
    for events in all_events:
        # do all queries before all updates
        for op, ridx, i, t in events:
            if op == 1:
                ans += passed + ds[t].query(ridx, i)
        for op, ridx, i, t in events:
            passed += int(op == -1)
            ds[t].update(ridx, i, op)

    return ans

def main():
    data = list(map(int, sys.stdin.buffer.read().split()))
    it = iter(data)

    n = next(it)
    horizs = []
    verts = []

    for _ in range(n):
        x1 = next(it); y1 = next(it); x2 = next(it); y2 = next(it)
        x1 *= 2; y1 *= 2; x2 *= 2; y2 *= 2

        dx = abs(x2 - x1)
        dy = abs(y2 - y1)

        if dx == dy:
            continue
        elif dx < dy:
            cy = (y1 + y2) // 2
            l = cy - (dx // 2)
            r = cy + (dx // 2)

            if x1 > x2:
                x1, x2 = x2, x1
                y1, y2 = y2, y1

            if y1 > y2:
                horizs.append([l, r, l - x1, 0])
            else:
                horizs.append([l, r, x2 + l, 1])
        else:
            cx = (x1 + x2) // 2
            l = cx - (dy // 2)
            r = cx + (dy // 2)

            if y1 > y2:
                x1, x2 = x2, x1
                y1, y2 = y2, y1

            if x1 > x2:
                verts.append([l, r, l - y1, 0])
            else:
                verts.append([l, r, y2 + l, 1])

    ans = solve(horizs) + solve(verts)
    total = n * (n - 1) // 2
    print(total - ans)

if __name__ == "__main__":
    main()