#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <set>
#include <map>
#include <vector>
#include <string>

using namespace std;

#define LL long long

const int dx[4] = {1, -1, 0, 0};
const int dy[4] = {0, 0, 1, -1};

LL mod(LL x, LL md) {
	return ((x % md) + md) % md;
}

class Mint {
public:
	static LL md;
	LL x;
	Mint(LL _x) {
		x = mod(_x, md);
	}
	Mint(const Mint &y) {
		x = mod(y.x, md);
	}
};

void MintMyExgcd(LL a, LL b, LL &x, LL &y) {
	// solve equation ax + by = 1 (mod m)
	LL md = Mint::md;
	if (b == 0) {
		y = 0;
		x = 1;
		return ;
	}
	MintMyExgcd(b, a % b, x, y);
	LL t = y;
	y = mod(x - (a / b) * y, md);
	x = t;
}

LL MintNY(LL x) {
	if (x == 0) {
		return 1;
	}
	LL md = Mint::md;
	LL a, b;
	MintMyExgcd(x, md, a, b);
	while (a < 0) {
		a += md;
	}
	return a;
}

/* LL gcd(LL a, LL b) {
	if (b == 0) {
		return a;
	}
	return gcd(b, a % b);
} */

Mint operator+(Mint a, Mint b) {
	return Mint(mod(a.x + b.x, Mint::md));
}
Mint operator-(Mint a, Mint b) {
	return Mint(mod(a.x - b.x, Mint::md));
}
Mint operator*(Mint a, Mint b) {
	return Mint(mod(a.x * b.x, Mint::md));
}
Mint operator/(Mint a, Mint b) {
	Mint c = Mint(MintNY(b.x));
	return Mint(mod(a.x * c.x, Mint::md));
}

Mint operator-(Mint a) {
	return Mint(-a.x);
}
bool operator==(Mint a, Mint b) {
	return a.x == b.x;
}
bool operator!=(Mint a, Mint b) {
	return a.x != b.x;
}
bool operator>(Mint a, Mint b) {
	return a.x > b.x;
}
bool operator<(Mint a, Mint b) {
	return a.x < b.x;
}
bool operator>=(Mint a, Mint b) {
	return a.x >= b.x;
}
bool operator<=(Mint a, Mint b) {
	return a.x <= b.x;
}

void operator+=(Mint &a, Mint b) {
	a = a + b;
}
void operator-=(Mint &a, Mint b) {
	a = a - b;
}
void operator*=(Mint &a, Mint b) {
	a = a * b;
}
void operator/=(Mint &a, Mint b) {
	a = a / b;
}

ostream& operator<<(ostream &out, Mint a) {
	out << a.x;
	return out;
}

istream& operator>>(istream &in, Mint &a) {
	in >> a.x;
	return in;
}

Mint factorial(LL n) {
	if (n == 0) {
		return Mint(1);
	}
	Mint res = 1;
	for (LL i = 1; i <= n; ++i) {
		res *= i;
	}
	return res;
}
Mint multiRange(LL s, LL t) {
	Mint res = 1;
	for (LL i = s; i <= t; ++i) {
		res *= i;
	}
	return res;
}

Mint getC(LL n, LL k) {
	if (n - k < k) {
		return getC(n, n - k);
	}
	return multiRange(n - k + 1, n) / factorial(k);
}

Mint getA(LL n, LL k) {
	return multiRange(n - k + 1, n);
}

Mint countNonNegativeDivision(LL n, LL k) {
	return getC(n + k - 1, k - 1);
}
Mint countPositiveDivision(LL n, LL k) {
	if (n < k) {
		return 0;
	}
	if (k <= 0) {
		return 0;
	}
	return getC(n - 1, k - 1);
}
Mint quickMod(Mint a, LL b) {
	Mint res = 1;
	while (b > 0) {
		if (b % 2) {
			res *= a;
		}
		a *= a;
		b /= 2;
	}
	return res;
}

LL Mint::md = 1000000007;

int n;
LL *a;

class Child {
	public:
	int a, idx;
	Child(int _a, int _idx): a(_a), idx(_idx) {}
};

bool cmp(const Child &a, const Child &b) {
	return (a.a > b.a) || (a.a == b.a && a.idx < b.idx);
}
int main() {
	scanf("%d", &n);
	a = new LL[n];
	vector<Child> vc;
	vc.clear();
	for (int i = 0; i < n; ++i) {
		scanf("%lld", &a[i]);
		vc.push_back(Child(a[i], i));
	}
	sort(vc.begin(), vc.end(), cmp);
	int lc = 0, rc = n - 1;
	LL res = 0;
	/* for (int i = 0; i < n; ++i) {
		int ld = abs(vc[i].idx - lc), rd = abs(rc - vc[i].idx);
		int dest = -1;
		// int swapIdx = -1, maxD = max(ld, rd);
		// for (int j = i + 1; j < n; ++j) {
		// 	if (vc[j].a < vc[i].a) {
		// 		break;
		// 	}
		// 	int lld = abs(vc[j].idx - lc), rrd = abs(rc - vc[j].idx);
		// 	if (max(lld, rrd) > maxD) {
		// 		maxD = max(lld, rrd);
		// 		swapIdx = j;
		// 	}
		// }
		// printf("swapIdx = %d for i = %d\n", swapIdx, i);
		// if (swapIdx != -1) {
		// 	swap(vc[i].idx, vc[swapIdx].idx);
		// }
		// int dest = -1;
		// ld = abs(vc[i].idx - lc); rd = abs(rc - vc[i].idx);
		if (ld > rd) {
			res += (LL)(ld) * (LL)(vc[i].a);
			dest = lc;
			++lc;
		}
		else {
			res += (LL)(rd) * (LL)(vc[i].a);
			dest = rc;
			--rc;
		}
		// printf("put %d at %d with a = %d\n", vc[i].idx, dest, vc[i].a);
	} */

	LL **f = new LL*[n + 1];
	for (int i = 0; i <= n; ++i) {
		f[i] = new LL[n + 1];
		for (int j = 0; j <= n; ++j) {
			f[i][j] = 0;
		}
	}
	for (int i = 1; i < n; ++i) {
		int aa = vc[i - 1].a;
		int idx = vc[i - 1].idx;
		for (int j = 0; j < i; ++j) {
			int rightIdx = n - i + j;
			f[i][j] = f[i - 1][j] + (LL)(abs(rightIdx - idx)) * (LL)(aa);
			if (j > 0) {
				f[i][j] = max(f[i][j], f[i - 1][j - 1] + (LL)(abs(idx - (j - 1))) * (LL)(aa));
			}
		}
		f[i][i] = f[i - 1][i - 1] + (LL)(abs(idx - (i - 1))) * (LL)(aa);
		// f[i][i] = 0;
		// for (int j = 0; j < i; ++j) {
		// 	f[i][i] = max(f[i][i], f[i - 1][j] + (LL)(abs(idx - j)) * (LL)(aa));
		// }
	}
	res = 0;
	int aa = vc[n - 1].a;
	int idx = vc[n - 1].idx;
	for (int i = 0; i < n; ++i) {
		res = max(res, f[n - 1][i] + (LL)(abs(idx - i)) * (LL)(aa));
	}
	cout << res << endl;
	return 0;
}

Measured memory_bytes: 35000