package main

import (
	"bufio"
	"io"
	"math/big"
	"math/bits"
	"os"
	"sort"
)

type Key struct {
	x, y int64
}

type Item struct {
	dx, dy int64
	sx, sy int64
}

type U128 struct {
	hi, lo uint64
}

func abs64(x int64) int64 {
	if x < 0 {
		return -x
	}
	return x
}

func gcd(a, b int64) int64 {
	for b != 0 {
		a, b = b, a%b
	}
	return a
}

func half(x, y int64) int {
	if y > 0 || (y == 0 && x > 0) {
		return 0
	}
	return 1
}

func inSemi(a, b Item) bool {
	c := a.dx*b.dy - a.dy*b.dx
	if c > 0 {
		return true
	}
	if c < 0 {
		return false
	}
	return a.dx*b.dx+a.dy*b.dy > 0
}

func sqNorm(x, y int64) U128 {
	ux := uint64(abs64(x))
	uy := uint64(abs64(y))
	h1, l1 := bits.Mul64(ux, ux)
	h2, l2 := bits.Mul64(uy, uy)
	lo, c := bits.Add64(l1, l2, 0)
	hi, _ := bits.Add64(h1, h2, c)
	return U128{hi, lo}
}

func greater(a, b U128) bool {
	return a.hi > b.hi || (a.hi == b.hi && a.lo > b.lo)
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	p := 0
	nextInt := func() int64 {
		for p < len(data) && (data[p] < '0' || data[p] > '9') && data[p] != '-' {
			p++
		}
		sign := int64(1)
		if data[p] == '-' {
			sign = -1
			p++
		}
		var v int64
		for p < len(data) && data[p] >= '0' && data[p] <= '9' {
			v = v*10 + int64(data[p]-'0')
			p++
		}
		return sign * v
	}

	n := int(nextInt())

	items := make([]Item, 0, n)
	pos := make(map[Key]int, n*2)

	for i := 0; i < n; i++ {
		a := nextInt()
		b := nextInt()
		c := nextInt()
		d := nextInt()

		x := a - b
		y := c - d

		if x == 0 && y == 0 {
			continue
		}

		g := gcd(abs64(x), abs64(y))
		k := Key{x / g, y / g}

		if idx, ok := pos[k]; ok {
			items[idx].sx += x
			items[idx].sy += y
		} else {
			pos[k] = len(items)
			items = append(items, Item{dx: k.x, dy: k.y, sx: x, sy: y})
		}
	}

	out := bufio.NewWriterSize(os.Stdout, 1<<20)
	defer out.Flush()

	if len(items) == 0 {
		out.WriteString("0\n")
		return
	}

	sort.Slice(items, func(i, j int) bool {
		hi := half(items[i].dx, items[i].dy)
		hj := half(items[j].dx, items[j].dy)
		if hi != hj {
			return hi < hj
		}
		return items[i].dx*items[j].dy-items[i].dy*items[j].dx > 0
	})

	m := len(items)
	arr := make([]Item, 2*m)
	copy(arr, items)
	copy(arr[m:], items)

	var sumX, sumY int64
	bestX, bestY := int64(0), int64(0)
	best := U128{0, 0}
	r := 0

	for l := 0; l < m; l++ {
		for r < l+m && inSemi(items[l], arr[r]) {
			sumX += arr[r].sx
			sumY += arr[r].sy
			r++
		}
		cur := sqNorm(sumX, sumY)
		if greater(cur, best) {
			best = cur
			bestX = sumX
			bestY = sumY
		}
		sumX -= arr[l].sx
		sumY -= arr[l].sy
	}

	ans := new(big.Int).SetInt64(bestX)
	ans.Abs(ans)
	ans.Mul(ans, ans)

	t := new(big.Int).SetInt64(bestY)
	t.Abs(t)
	t.Mul(t, t)

	ans.Add(ans, t)

	out.WriteString(ans.String())
	out.WriteByte('\n')
}