There are n armchairs, numbered from 1 to n from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than n/2.

For some reason, you would like to tell people to move from their armchairs to some other ones. If the i-th armchair is occupied by someone and the j-th armchair is not, you can tell the person sitting in the i-th armchair to move to the j-th armchair. The time it takes a person to move from the i-th armchair to the j-th one is |i - j| minutes. You may perform this operation any number of times, but these operations must be done sequentially, i. e. you cannot tell a person to move until the person you asked to move in the last operation has finished moving to their destination armchair.

You want to achieve the following situation: every seat that was initially occupied must be free. What is the minimum time you need to do it?

Input

The first line contains one integer n (2 ≤ n ≤ 5000) — the number of armchairs.

The second line contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 1). a_i = 1 means that the i-th armchair is initially occupied, a_i = 0 means that it is initially free. The number of occupied armchairs is at most n/2.

Output

Print one integer — the minimum number of minutes you have to spend to achieve the following situation: every seat that was initially occupied must be free.

Examples

Input


7
1 0 0 1 0 0 1


Output


3


Input


6
1 1 1 0 0 0


Output


9


Input


5
0 0 0 0 0


Output


0

Note

In the first test, you can perform the following sequence:

  1. ask a person to move from armchair 1 to armchair 2, it takes 1 minute; 
  2. ask a person to move from armchair 7 to armchair 6, it takes 1 minute; 
  3. ask a person to move from armchair 4 to armchair 5, it takes 1 minute. 



In the second test, you can perform the following sequence:

  1. ask a person to move from armchair 1 to armchair 4, it takes 3 minutes; 
  2. ask a person to move from armchair 2 to armchair 6, it takes 4 minutes; 
  3. ask a person to move from armchair 4 to armchair 5, it takes 1 minute; 
  4. ask a person to move from armchair 3 to armchair 4, it takes 1 minute. 



In the third test, no seat is occupied so your goal is achieved instantly.
#include <bits/stdc++.h>
using i32 = int;
template <class Cap, class Cost>
struct MinCostMaxFlow {
  i32 size() { return adj.size(); }
  explicit MinCostMaxFlow(i32 n) : adj(n) {}
  void add_edge(i32 from, i32 to, Cap capacity, Cost cost) {
    i32 from_id = adj[from].size(), to_id = adj[to].size();
    adj[from].push_back({to, to_id, capacity, cost});
    adj[to].push_back({from, from_id, 0, -cost});
  }
  std::pair<Cap, Cost> flow(i32 s, i32 t) {
    std::vector<Cost> dist(size()), dual(size());
    std::vector<std::pair<i32, i32>> prev(size());
    struct HeapEntity {
      Cost key;
      i32 value;
      bool operator<(const HeapEntity& other) const { return other.key < key; }
    };
    auto dijkstra = [this, &dist, &dual, &prev](i32 s, i32 t) {
      std::fill(dist.begin(), dist.end(), std::numeric_limits<Cost>::max());
      std::vector<HeapEntity> heap({{dist[s] = 0, s}});
      std::vector<bool> vis(size());
      auto push_heap = [&](Cost key, i32 value) {
        heap.push_back({key, value});
        std::push_heap(heap.begin(), heap.end());
      };
      auto pop_heap = [&]() {
        i32 top = heap.front().value;
        std::pop_heap(heap.begin(), heap.end());
        heap.pop_back();
        return top;
      };
      while (not heap.empty()) {
        i32 u = pop_heap();
        if (vis[u]) continue;
        vis[u] = true;
        if (u == t) break;
        for (i32 it = 0; it < adj[u].size(); it++) {
          const auto& e = adj[u][it];
          if (vis[e.to] || e.capacity == 0) continue;
          Cost cost = e.cost - dual[e.to] + dual[u];
          if (cost < dist[e.to] - dist[u]) {
            dist[e.to] = dist[u] + cost;
            prev[e.to] = {u, it};
            push_heap(dist[e.to], e.to);
          }
        }
      }
      if (not vis[t]) {
        return false;
      }
      for (i32 i = 0; i < size(); i++) {
        if (not vis[i]) continue;
        dual[i] -= dist[t] - dist[i];
      }
      return true;
    };
    Cap flow = 0;
    Cost cost = 0;
    int TLE = 0;
    while (++TLE < 100 && dijkstra(s, t)) {
      Cap c = std::numeric_limits<Cap>::max();
      for (i32 it = t, x, y; it != s; it = x) {
        std::tie(x, y) = prev[it];
        c = std::min(c, adj[x][y].capacity);
      }
      for (i32 it = t, x, y; it != s; it = x) {
        std::tie(x, y) = prev[it];
        auto& e = adj[x][y];
        e.capacity -= c;
        adj[e.to][e.reverse].capacity += c;
      }
      Cost d = -dual[s];
      flow += c;
      cost += c * d;
    }
    return {flow, cost};
  }

 private:
  struct Edge {
    i32 to, reverse;
    Cap capacity;
    Cost cost;
  };
  std::vector<std::vector<Edge>> adj;
};
const int M = (int)5e3;
bool a[M + 5];
i32 main() {
  i32 n, m, s, t;
  scanf("%d", &n);
  n += 2;
  s = 1, t = n;
  for (int i = 2; i <= n - 1; ++i) scanf("%d", &a[i]);
  MinCostMaxFlow<i32, i32> solver(n);
  for (int i = 2; i <= n - 1; ++i) {
    if (a[i]) {
      solver.add_edge(s - 1, i - 1, 1, 0);
      for (int j = 2; j <= n - 1; ++j) {
        if (!a[j]) solver.add_edge(i - 1, j - 1, 1, i < j ? j - i : i - j);
      }
    } else {
      solver.add_edge(i - 1, t - 1, 1, 0);
    }
  }
  i32 flow, cost;
  std::tie(flow, cost) = solver.flow(s - 1, t - 1);
  printf("%d\n", cost);
  return 0;
}
