#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;
template <class flow_type, class cost_type>
struct min_cost_flow {
  struct edge {
    int to, from, rev;
    flow_type cap;
    cost_type cost;
    edge(int to, int from, int rev, flow_type cap, cost_type cost)
        : to(to), from(from), rev(rev), cap(cap), cost(cost) {}
  };
  const int size = 0;
  vector<vector<edge>> graph;
  min_cost_flow(int size_) : size(size_), graph(size_) {}
  void add_edge(int from, int to, flow_type cap, cost_type cost) {
    graph[from].push_back(edge(to, from, int(graph[to].size()), cap, cost));
    graph[to].push_back(edge(from, to, int(graph[from].size() - 1), 0, -cost));
  }
  cost_type min_path(int s, int t) {
    const cost_type inf = numeric_limits<cost_type>::max();
    vector<cost_type> dist(size, inf);
    vector<edge*> route(size);
    queue<int> que;
    vector<bool> inq(size);
    dist[s] = 0;
    que.push(s);
    inq[s] = true;
    while (!que.empty()) {
      int u = que.front();
      que.pop();
      inq[u] = false;
      for (edge& e : graph[u]) {
        if (e.cap == 0) continue;
        int v = e.to;
        if (dist[v] > dist[u] + e.cost) {
          dist[v] = dist[u] + e.cost;
          route[v] = &e;
          if (!inq[v]) {
            que.push(v);
            inq[v] = true;
          }
        }
      }
    }
    if (dist[t] == inf) return inf;
    flow_type flow = numeric_limits<flow_type>::max();
    {
      int v = t;
      while (v != s) {
        edge& e = *route[v];
        flow = min(flow, e.cap);
        v = e.from;
      }
    }
    cost_type c = 0;
    {
      int v = t;
      while (v != s) {
        edge& e = *route[v];
        e.cap -= flow;
        graph[e.to][e.rev].cap += flow;
        c += e.cost * flow;
        v = e.from;
      }
    }
    return dist[t];
  }
  cost_type calc_min_cost_flow(int s, int t, flow_type flow) {
    cost_type total_cost = 0;
    for (flow_type i = 0; i < flow; ++i) {
      cost_type c = min_path(s, t);
      if (c == numeric_limits<cost_type>::max()) return c;
      total_cost += c;
    }
    return total_cost;
  }
};
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;
  min_cost_flow<i64, i64> mcf(2 * N + 2);
  for (i64 i = i64(0), i_max_for_repmacro = i64(N); i < i_max_for_repmacro;
       ++i) {
    mcf.add_edge(s, i, 1, 0);
    mcf.add_edge(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_edge(i, j + N, 1, -A[i] * abs(i - j));
    }
  }
  cout << -mcf.calc_min_cost_flow(s, t, N) << endl;
}
int main() {
  std::cin.tie(0);
  std::ios::sync_with_stdio(false);
  cout.setf(ios::fixed);
  cout.precision(16);
  solve();
  return 0;
}
