package main

import (
	"bufio"
	"fmt"
	"io"
	"math"
	"math/bits"
	"os"
)

type FastScanner struct {
	data []byte
	idx  int
}

func (fs *FastScanner) NextInt64() int64 {
	for fs.idx < len(fs.data) && fs.data[fs.idx] <= ' ' {
		fs.idx++
	}
	var v int64
	for fs.idx < len(fs.data) {
		b := fs.data[fs.idx]
		if b <= ' ' {
			break
		}
		v = v*10 + int64(b-'0')
		fs.idx++
	}
	return v
}

func segCost(g, t int64) int64 {
	a := g / t
	r := g % t
	return (t-r)*a*a + r*(a+1)*(a+1)
}

func isqrt(x int64) int64 {
	r := int64(math.Sqrt(float64(x)))
	for (r+1)*(r+1) <= x {
		r++
	}
	for r*r > x {
		r--
	}
	return r
}

func consider(g, lam, t int64, bestT *int64, bestC *int64, bestHi *uint64, bestLo *uint64) {
	if t < 1 || t > g {
		return
	}
	c := segCost(g, t)
	hi, lo := bits.Mul64(uint64(lam), uint64(t-1))
	lo, carry := bits.Add64(lo, uint64(c), 0)
	hi += carry
	if hi < *bestHi || (hi == *bestHi && (lo < *bestLo || (lo == *bestLo && t > *bestT))) {
		*bestHi = hi
		*bestLo = lo
		*bestT = t
		*bestC = c
	}
}

func solveHigh(lam int64, gaps []int64) (int64, int64) {
	q := isqrt(lam)
	p := q
	if q*(q+1) > lam {
		p = q - 1
	}
	pp1 := p + 1
	var totalK, totalC int64
	for _, g := range gaps {
		bestHi, bestLo := ^uint64(0), ^uint64(0)
		var bestT, bestC int64

		c1 := g / pp1
		c2 := (g + p) / pp1
		var c3 int64
		if p > 0 {
			c3 = g / p
		}

		consider(g, lam, c1, &bestT, &bestC, &bestHi, &bestLo)
		if c2 != c1 {
			consider(g, lam, c2, &bestT, &bestC, &bestHi, &bestLo)
		}
		if p > 0 && c3 != c1 && c3 != c2 {
			consider(g, lam, c3, &bestT, &bestC, &bestHi, &bestLo)
		}

		totalK += bestT - 1
		totalC += bestC
	}
	return totalK, totalC
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	fs := FastScanner{data: data}

	n := int(fs.NextInt64())
	gaps := make([]int64, n)
	var prev int64
	for i := 0; i < n; i++ {
		x := fs.NextInt64()
		gaps[i] = x - prev
		prev = x
	}
	m := fs.NextInt64()

	var lo int64 = 1
	var hi int64 = 1000000000000000000

	for lo < hi {
		mid := lo + (hi-lo+1)/2
		_, c := solveHigh(mid, gaps)
		if c <= m {
			lo = mid
		} else {
			hi = mid - 1
		}
	}

	lam := lo
	k, c := solveHigh(lam, gaps)
	ans := k - (m-c)/lam
	if ans < 0 {
		ans = 0
	}

	out := bufio.NewWriter(os.Stdout)
	fmt.Fprint(out, ans)
	out.Flush()
}