package main

import (
	"bufio"
	"io"
	"os"
	"sort"
	"strconv"
)

type Line struct {
	m int64
	b int64
}

const INF int64 = 1 << 62

var xs []int64
var tree []Line

func (ln Line) val(x int64) int64 {
	return ln.m*x + ln.b
}

func add(node, l, r int, nw Line) {
	if tree[node].b == INF {
		tree[node] = nw
		return
	}
	cur := tree[node]
	mid := (l + r) >> 1
	xl := xs[l]
	xm := xs[mid]

	left := nw.val(xl) < cur.val(xl)
	midBetter := nw.val(xm) < cur.val(xm)

	if midBetter {
		tree[node], nw = nw, tree[node]
		cur = tree[node]
	}

	if l == r {
		return
	}

	if left != midBetter {
		add(node<<1, l, mid, nw)
	} else {
		add(node<<1|1, mid+1, r, nw)
	}
}

func query(node, l, r, idx int, x int64) int64 {
	res := tree[node].val(x)
	if l == r {
		return res
	}
	mid := (l + r) >> 1
	var v int64
	if idx <= mid {
		v = query(node<<1, l, mid, idx, x)
	} else {
		v = query(node<<1|1, mid+1, r, idx, x)
	}
	if v < res {
		res = v
	}
	return res
}

func nextInt(data []byte, p *int) int64 {
	n := len(data)
	i := *p
	for i < n {
		c := data[i]
		if c != ' ' && c != '\n' && c != '\r' && c != '\t' {
			break
		}
		i++
	}
	sign := int64(1)
	if data[i] == '-' {
		sign = -1
		i++
	}
	var val int64
	for i < n {
		c := data[i]
		if c < '0' || c > '9' {
			break
		}
		val = val*10 + int64(c-'0')
		i++
	}
	*p = i
	return val * sign
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	ptr := 0
	n := int(nextInt(data, &ptr))

	pref := make([]int64, n+1)
	weighted := make([]int64, n+1)

	for i := 1; i <= n; i++ {
		a := nextInt(data, &ptr)
		pref[i] = pref[i-1] + a
		weighted[i] = weighted[i-1] + int64(i)*a
	}

	xs = make([]int64, n+1)
	copy(xs, pref)
	sort.Slice(xs, func(i, j int) bool { return xs[i] < xs[j] })
	k := 0
	for i := 0; i < len(xs); i++ {
		if k == 0 || xs[i] != xs[k-1] {
			xs[k] = xs[i]
			k++
		}
	}
	xs = xs[:k]

	pos := make(map[int64]int, k)
	for i, v := range xs {
		pos[v] = i
	}

	tree = make([]Line, 4*k+5)
	for i := range tree {
		tree[i].b = INF
	}

	add(1, 0, k-1, Line{0, 0})

	var ans int64
	for r := 1; r <= n; r++ {
		idx := pos[pref[r]]
		mn := query(1, 0, k-1, idx, pref[r])
		cur := weighted[r] - mn
		if cur > ans {
			ans = cur
		}
		x := int64(r)
		add(1, 0, k-1, Line{x, weighted[r] - x*pref[r]})
	}

	out := bufio.NewWriter(os.Stdout)
	out.WriteString(strconv.FormatInt(ans, 10))
	out.Flush()
}