#include <bits/stdc++.h>
using namespace std;
using i64 = int64_t;
template <i64 p>
class fp {
 public:
  i64 x;
  fp() : x(0) {}
  fp(i64 x_) : x((x_ % p + p) % p) {}
  fp operator+() const { return fp(x); }
  fp operator-() const { return fp(-x); }
  fp& operator+=(const fp& y) {
    x += y.x;
    if (x >= p) x -= p;
    return *this;
  }
  fp& operator-=(const fp& y) { return *this += -y; }
  fp& operator*=(const fp& y) {
    x = x * y.x % p;
    return *this;
  }
  fp& operator/=(const fp& y) { return *this *= fp(inverse(y.x)); }
  fp operator+(const fp& y) const { return fp(x) += y; }
  fp operator-(const fp& y) const { return fp(x) -= y; }
  fp operator*(const fp& y) const { return fp(x) *= y; }
  fp operator/(const fp& y) const { return fp(x) /= y; }
  bool operator==(const fp& y) const { return x == y.x; }
  bool operator!=(const fp& y) const { return !(*this == y); }
  i64 extgcd(i64 a, i64 b, i64& x, i64& y) {
    i64 d = a;
    if (b != 0) {
      d = extgcd(b, a % b, y, x);
      y -= (a / b) * x;
    } else {
      x = 1;
      y = 0;
    }
    return d;
  }
  i64 inverse(i64 a) {
    i64 x, y;
    extgcd(a, p, x, y);
    return (x % p + p) % p;
  }
};
template <i64 p>
i64 abs(const fp<p>& x) {
  return x.x;
}
template <i64 p>
istream& operator>>(istream& is, fp<p>& x) {
  is >> x.x;
  return is;
}
template <i64 p>
ostream& operator<<(ostream& os, const fp<p>& x) {
  os << x.x;
  return os;
}
template <typename T, typename U>
ostream& operator<<(ostream& os, const pair<T, U>& p) {
  os << "(" << p.first << ", " << p.second << ")";
  return os;
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& vec) {
  os << "[";
  for (const auto& v : vec) {
    os << v << ",";
  }
  os << "]";
  return os;
}
template <typename T>
bool chmin(T& a, const T& b) {
  if (a > b) {
    a = b;
    return true;
  }
  return false;
}
template <typename T>
bool chmax(T& a, const T& b) {
  if (a < b) {
    a = b;
    return true;
  }
  return false;
}
template <typename A, typename T, size_t size>
void fill(A (&ary)[size], const T& val) {
  fill((T*)ary, (T*)(ary + size), val);
}
constexpr int inf = 1.01e9;
constexpr i64 inf64 = 4.01e18;
constexpr long double eps = 1e-9;
constexpr i64 max_loop = 100;
struct MinimumCostMaximumFlow {
  static const i64 InfCapacity = inf64;
  static const i64 InfCost = inf64;
  struct Edge {
    i64 to;
    i64 rev;
    i64 capacity;
    i64 cost;
  };
  vector<vector<Edge> > g;
  void init(i64 n) { g.assign(n, vector<Edge>()); }
  void add(i64 i, i64 j, i64 capacity = InfCapacity, i64 cost = i64()) {
    Edge e, f;
    e.to = j, f.to = i;
    e.capacity = capacity, f.capacity = 0;
    e.cost = cost, f.cost = -cost;
    g[i].push_back(e);
    g[j].push_back(f);
    g[i].back().rev = (i64)g[j].size() - 1;
    g[j].back().rev = (i64)g[i].size() - 1;
  }
  void addB(i64 i, i64 j, i64 capacity = InfCapacity, i64 cost = i64()) {
    add(i, j, capacity, cost);
    add(j, i, capacity, cost);
  }
  pair<i64, i64> minimumCostMaximumFlow(i64 s, i64 t, i64 f = InfCapacity,
                                        bool useSPFA = false) {
    int n = g.size();
    vector<i64> dist(n);
    vector<i64> prev(n);
    vector<i64> prevEdge(n);
    pair<i64, i64> total = make_pair(0, 0);
    vector<i64> potential(n);
    while (f > 0) {
      fill(dist.begin(), dist.end(), InfCost);
      if (useSPFA || total.second == 0) {
        deque<i64> q;
        q.push_back(s);
        dist[s] = 0;
        vector<bool> inqueue(n);
        while (!q.empty()) {
          i64 i = q.front();
          q.pop_front();
          inqueue[i] = false;
          for (i64 ei = 0; ei < g[i].size(); ei++) {
            const Edge& e = g[i][ei];
            i64 j = e.to;
            i64 d = dist[i] + e.cost;
            if (e.capacity > 0 && d < dist[j]) {
              if (!inqueue[j]) {
                inqueue[j] = true;
                q.push_back(j);
              }
              dist[j] = d;
              prev[j] = i;
              prevEdge[j] = ei;
            }
          }
        }
      } else {
        vector<bool> vis(n);
        priority_queue<pair<i64, i64> > q;
        q.push(make_pair(-0, s));
        dist[s] = 0;
        while (!q.empty()) {
          i64 i = q.top().second;
          q.pop();
          if (vis[i]) continue;
          vis[i] = true;
          for (i64 ei = 0; ei < (i64)g[i].size(); ei++) {
            const Edge& e = g[i][ei];
            if (e.capacity <= 0) continue;
            i64 j = e.to;
            i64 d = dist[i] + e.cost + potential[i] - potential[j];
            if (dist[j] > d) {
              dist[j] = d;
              prev[j] = i;
              prevEdge[j] = ei;
              q.push(make_pair(-d, j));
            }
          }
        }
      }
      if (dist[t] == InfCost) break;
      if (!useSPFA)
        for (i64 i = 0; i < n; i++) potential[i] += dist[i];
      i64 d = f;
      i64 distt = 0;
      for (i64 v = t; v != s;) {
        i64 u = prev[v];
        const Edge& e = g[u][prevEdge[v]];
        d = min(d, e.capacity);
        distt += e.cost;
        v = u;
      }
      f -= d;
      total.first += d * distt;
      total.second += d;
      for (i64 v = t; v != s; v = prev[v]) {
        Edge& e = g[prev[v]][prevEdge[v]];
        e.capacity -= d;
        g[e.to][e.rev].capacity += d;
      }
    }
    return total;
  }
};
void solve() {
  i64 N;
  cin >> N;
  vector<i64> A(N);
  for (i64 i = i64(0), i_max_for_repmacro = i64(N); i < i_max_for_repmacro; ++i)
    cin >> A[i];
  const i64 s = 2 * N, t = 2 * N + 1;
  MinimumCostMaximumFlow mcf;
  mcf.init(2 * N + 2);
  for (i64 i = i64(0), i_max_for_repmacro = i64(N); i < i_max_for_repmacro;
       ++i) {
    mcf.add(s, i, 1, 0);
    mcf.add(i + N, t, 1, 0);
  }
  for (i64 i = i64(0), i_max_for_repmacro = i64(N); i < i_max_for_repmacro;
       ++i) {
    for (i64 j = i64(0), j_max_for_repmacro = i64(N); j < j_max_for_repmacro;
         ++j) {
      mcf.add(i, j + N, 1, -A[i] * abs(i - j));
    }
  }
  cout << -mcf.minimumCostMaximumFlow(s, t, N, true).first << endl;
}
int main() {
  std::cin.tie(0);
  std::ios::sync_with_stdio(false);
  cout.setf(ios::fixed);
  cout.precision(16);
  solve();
  return 0;
}
