package main

import (
	"bufio"
	"fmt"
	"os"
)

type Point struct {
	x int64
	y int64
}

const INF int64 = 1<<62

func dist2(a, b Point) int64 {
	dx := a.x - b.x
	dy := a.y - b.y
	return dx*dx + dy*dy
}

func min(a, b int64) int64 {
	if a < b {
		return a
	}
	return b
}

func rec(pts []Point, tmp []Point, l, r int) int64 {
	if r-l <= 3 {
		best := INF
		for i := l; i < r; i++ {
			for j := i + 1; j < r; j++ {
				d := dist2(pts[i], pts[j])
				if d < best {
					best = d
				}
			}
		}
		// sort pts[l:r] by y (small segment)
		for i := l; i < r; i++ {
			for j := i + 1; j < r; j++ {
				if pts[j].y < pts[i].y {
					pts[i], pts[j] = pts[j], pts[i]
				}
			}
		}
		return best
	}

	mid := (l + r) / 2
	midx := pts[mid].x

	dl := rec(pts, tmp, l, mid)
	dr := rec(pts, tmp, mid, r)
	d := min(dl, dr)

	// merge by y
	i, j, k := l, mid, l
	for i < mid && j < r {
		if pts[i].y <= pts[j].y {
			tmp[k] = pts[i]
			i++
		} else {
			tmp[k] = pts[j]
			j++
		}
		k++
	}
	for i < mid {
		tmp[k] = pts[i]
		i++
		k++
	}
	for j < r {
		tmp[k] = pts[j]
		j++
		k++
	}
	copy(pts[l:r], tmp[l:k])

	// build strip
	strip := make([]Point, 0, r-l)
	for i = l; i < r; i++ {
		dx := pts[i].x - midx
		if dx*dx < d {
			strip = append(strip, pts[i])
		}
	}

	// check up to neighbors with y difference constraint
	for i = 0; i < len(strip); i++ {
		for j = i + 1; j < len(strip); j++ {
			dy := strip[j].y - strip[i].y
			if dy*dy >= d {
				break
			}
			dd := dist2(strip[i], strip[j])
			if dd < d {
				d = dd
			}
		}
	}

	return d
}

func nextInt(reader *bufio.Reader) (int64, error) {
	var sign int64 = 1
	var val int64 = 0
	// skip non-digit
	b, err := reader.ReadByte()
	for err == nil && (b == ' ' || b == '\n' || b == '\r' || b == '\t') {
		b, err = reader.ReadByte()
	}
	if err != nil {
		return 0, err
	}
	if b == '-' {
		sign = -1
		b, err = reader.ReadByte()
		if err != nil {
			return 0, err
		}
	}
	for b >= '0' && b <= '9' {
		val = val*10 + int64(b-'0')
		b, err = reader.ReadByte()
		if err != nil {
			break
		}
	}
	if err == nil {
		// put back last read non-digit byte
		reader.UnreadByte()
	}
	return sign * val, nil
}

func main() {
	in := bufio.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	n64, err := nextInt(in)
	if err != nil {
		return
	}
	n := int(n64)
	pts := make([]Point, n)
	for i := 0; i < n; i++ {
		v, _ := nextInt(in)
		pts[i] = Point{x: int64(i + 1), y: v}
	}

	tmp := make([]Point, n)
	ans := rec(pts, tmp, 0, n)
	fmt.Fprintln(out, ans)
}