#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
int in() {
  int x;
  cin >> x;
  return x;
}
long long lin() {
  long long x;
  cin >> x;
  return x;
}
string stin() {
  string s;
  cin >> s;
  return s;
}
template <class T>
inline bool chmax(T& a, T b) {
  if (a < b) {
    a = b;
    return 1;
  }
  return 0;
}
template <class T>
inline bool chmin(T& a, T b) {
  if (a > b) {
    a = b;
    return 1;
  }
  return 0;
}
vector<int> iota(int n) {
  vector<int> a(n);
  iota(begin(a), end(a), 0);
  return a;
}
void print() { putchar(' '); }
void print(bool a) { cout << a; }
void print(int a) { cout << a; }
void print(long long a) { cout << a; }
void print(char a) { cout << a; }
void print(string& a) { cout << a; }
void print(double a) { cout << a; }
template <class T>
void print(const vector<T>&);
template <class T, size_t size>
void print(const array<T, size>&);
template <class T, class L>
void print(const pair<T, L>& p);
template <class T, size_t size>
void print(const T (&)[size]);
template <class T>
void print(const vector<T>& a) {
  if (a.empty()) return;
  print(a[0]);
  for (auto i = a.begin(); ++i != a.end();) {
    cout << " ";
    print(*i);
  }
  cout << endl;
}
template <class T>
void print(const deque<T>& a) {
  if (a.empty()) return;
  print(a[0]);
  for (auto i = a.begin(); ++i != a.end();) {
    cout << " ";
    print(*i);
  }
}
template <class T, size_t size>
void print(const array<T, size>& a) {
  print(a[0]);
  for (auto i = a.begin(); ++i != a.end();) {
    cout << " ";
    print(*i);
  }
}
template <class T, class L>
void print(const pair<T, L>& p) {
  cout << '(';
  print(p.first);
  cout << ",";
  print(p.second);
  cout << ')';
}
template <class T, size_t size>
void print(const T (&a)[size]) {
  print(a[0]);
  for (auto i = a; ++i != end(a);) {
    cout << " ";
    print(*i);
  }
}
template <class T>
void print(const T& a) {
  cout << a;
}
int out() {
  putchar('\n');
  return 0;
}
template <class T>
int out(const T& t) {
  print(t);
  putchar('\n');
  return 0;
}
template <class Head, class... Tail>
int out(const Head& head, const Tail&... tail) {
  print(head);
  putchar(' ');
  out(tail...);
  return 0;
}
long long gcd(long long a, long long b) {
  while (b) {
    long long c = b;
    b = a % b;
    a = c;
  }
  return a;
}
long long lcm(long long a, long long b) {
  if (!a || !b) return 0;
  return a * b / gcd(a, b);
}
vector<pair<long long, long long>> factor(long long x) {
  vector<pair<long long, long long>> ans;
  for (long long i = 2; i * i <= x; i++)
    if (x % i == 0) {
      ans.push_back({i, 1});
      while ((x /= i) % i == 0) ans.back().second++;
    }
  if (x != 1) ans.push_back({x, 1});
  return ans;
}
vector<int> divisor(int x) {
  vector<int> ans;
  for (int i = 1; i * i <= x; i++)
    if (x % i == 0) {
      ans.push_back(i);
      if (i * i != x) ans.push_back(x / i);
    }
  return ans;
}
int popcount(long long x) { return __builtin_popcountll(x); }
template <class... T>
void err(const T&...) {}
template <typename G>
struct DoublingLowestCommonAncestor {
  const int LOG;
  vector<int> dep;
  const G& g;
  vector<vector<int>> table;
  DoublingLowestCommonAncestor(const G& _g)
      : g(_g), dep(_g.size()), LOG(32 - __builtin_clz(_g.size())) {
    table.assign(LOG, vector<int>(_g.size(), -1));
  }
  void dfs(int idx, int par, int d) {
    table[0][idx] = par;
    dep[idx] = d;
    for (auto& to : g[idx]) {
      if (to != par) dfs(to, idx, d + 1);
    }
  }
  void build(int st) {
    dfs(st, -1, 0);
    for (int k = 0; k + 1 < LOG; k++) {
      for (int i = 0; i < table[k].size(); i++) {
        if (table[k][i] == -1)
          table[k + 1][i] = -1;
        else
          table[k + 1][i] = table[k][table[k][i]];
      }
    }
  }
  int query(int u, int v) {
    if (dep[u] > dep[v]) swap(u, v);
    for (int i = LOG - 1; i >= 0; i--) {
      if (((dep[v] - dep[u]) >> i) & 1) v = table[i][v];
    }
    if (u == v) return u;
    for (int i = LOG - 1; i >= 0; i--) {
      if (table[i][u] != table[i][v]) {
        u = table[i][u];
        v = table[i][v];
      }
    }
    return table[0][u];
  }
};
vector<vector<int>> g;
vector<int> c;
vector<long long> ans;
int st;
vector<int> pre, mem;
int dfs(int x, int p, vector<long long>& v,
        DoublingLowestCommonAncestor<vector<vector<int>>>& lca) {
  int res = 0;
  for (auto e : g[x]) {
    if (e == p) continue;
    int d = dfs(e, x, v, lca);
    ans[c[x]] += (long long)(d - v[c[x]]) * (d - v[c[x]] + 1) / 2;
    if (x == st) {
      for (long long i = 0; i < c.size(); i++) {
        if (i != c[x]) {
          ans[i] += (long long)(d + 1 - v[i]) * (d + 2 - v[i]) / 2;
        }
      }
    }
    res += d;
  }
  if (lca.query(pre[c[x]], x) == x) {
    v[c[x]] -= mem[c[x]];
    mem[c[x]] = 0;
  }
  v[c[x]] += res + 1;
  pre[c[x]] = x;
  mem[c[x]] += res + 1;
  return res + 1;
}
signed main() {
  ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
  cout << fixed << setprecision(15);
  int n = in();
  vector<long long> a;
  for (long long i = 0; i < n; i++) a.push_back(in());
  vector<int> id = iota(n);
  sort(begin(id), end(id), [&](int x, int y) { return a[x] > a[y]; });
  vector<long long> dp(n + 1, -1e15);
  dp[0] = 0;
  for (long long ii = 0; ii < n; ii++) {
    int i = id[ii];
    vector<long long> next(n + 1, -1e15);
    for (long long l = 0; l < n; l++) {
      int r = n - 1 - (ii - l);
      chmax(next[l + 1], dp[l] + abs(i - l) * a[i]);
      chmax(next[l], dp[l] + abs(i - r) * a[i]);
    }
    dp = next;
  }
  cout << *max_element(begin(dp), end(dp)) << '\n';
}
