#include <bits/stdc++.h>
using namespace std;

long long sqr(long long x) {
	return x * x;
}

struct pairsum {
	long long sum, sqrsum;
	bool operator<(const pairsum &p) const {
		return sqr(sum) - sqrsum < sqr(p.sum) - p.sqrsum;
	}
	pairsum operator+(const pairsum &p) const {
		return pairsum{sum + p.sum, sqrsum + p.sqrsum};
	}
};

pairsum maxres;

vector<pairsum> largestValue(vector<long long> &A, int l, int r) {
	if (l > r) {
		return {{0, 0}, {0, 0}, {0, 0}};
	}
	else if (l == r) {
		return {{A[l], sqr(A[l])}, {A[l],  sqr(A[l])}, {A[l], sqr(A[l])}};
	}
	int mid = (l + r) >> 1;
	auto leftres = largestValue(A, l, mid);
	auto rightres = largestValue(A, mid + 1, r);
	pairsum prefix = leftres[0], suffix = rightres[1], all = leftres[2] + rightres[2];
	prefix = max(prefix, leftres[2] + rightres[1]);
	prefix = max(prefix, all);
	suffix = max(suffix, leftres[1] + rightres[2]);
	suffix = max(suffix, all);

	maxres = max(maxres, leftres[1] + rightres[0]);
	maxres = max(maxres, leftres[2] + rightres[0]);
	maxres = max(maxres, leftres[1] + rightres[2]);
	maxres = max(maxres, leftres[1]);
	maxres = max(maxres, rightres[0]);
	maxres = max(maxres, leftres[2]);
	maxres = max(maxres, rightres[2]);
	maxres = max(maxres, leftres[2] + rightres[2]);

	return {prefix, suffix, all};
}

long long largestValue(vector <long long> A) {
    // Return the largest value of any of A's nonempty subarrays.
	long long sum = 0, sqrsum = 0, maxsum = 0;
	for (int l = 0, r = 0; l < A.size(); ) {
		if (r < A.size() && (r == l || sum >= 0)) {
			sum += A[r];
			sqrsum += sqr(A[r]);
			r++;
		}
		else {
			sum -= A[l];
			sqrsum -= sqr(A[l]);
			l++;
		}
		maxsum = max(maxsum, (sqr(sum) - sqrsum) / 2);
	}
	return maxsum;
}

long long largestValue2(vector <long long> A) {
    // Return the largest value of any of A's nonempty subarrays.
	long long maxsum = 0;
	for (int l = 0; l < A.size(); l++) {
		long long sum = 0, sqrsum = 0;
		for (int r = l; r < A.size(); r++) {
			sum += A[r];
			sqrsum += sqr(A[r]);
			maxsum = max(maxsum, (sqr(sum) - sqrsum) / 2);
		}
	}
	return maxsum;
}

int main() {
    int n;
    cin >> n;
    vector<long long> A(n);
    for(int A_i = 0; A_i < n; A_i++){
       cin >> A[A_i];
    }
    long long result = (n >= 10000) ? largestValue(A) : largestValue2(A);
	// auto res = largestValue(A, 0, A.size() - 1);
	// maxres = max(maxres, max(res[0], max(res[1], res[2])));
    cout << result << endl;
    return 0;
}