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 namespace std;
const int inf = 0x3f3f3f3f;
const long long INF = 1e18;
const int maxn = 5000 + 7;
const long long mod = 1e9 + 7;
inline long long read() {
  long long x = 0;
  bool f = 0;
  char ch = getchar();
  while (ch < '0' || '9' < ch) f |= ch == '-', ch = getchar();
  while ('0' <= ch && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
  return f ? -x : x;
}
void out(long long x) {
  int stackk[20];
  if (x < 0) {
    putchar('-');
    x = -x;
  }
  if (!x) {
    putchar('0');
    return;
  }
  int top = 0;
  while (x) stackk[++top] = x % 10, x /= 10;
  while (top) putchar(stackk[top--] + '0');
}
long long qpow(long long a, long long b) {
  long long ans = 1;
  while (b) {
    if (b & 1) ans = ans * a % mod;
    a = a * a % mod;
    b >>= 1;
  }
  return ans;
}
int n, S, T, a[maxn];
int head[maxn * 2], cnt;
struct Node {
  int u, v, w1, w2, next;
} e[maxn * 2];
void add(int u, int v, int w1, int w2) {
  e[cnt].u = u, e[cnt].v = v, e[cnt].w1 = w1;
  e[cnt].w2 = w2, e[cnt].next = head[u], head[u] = cnt++;
}
int dist[maxn], vis[maxn];
int spfa(int S, int T) {
  memset(dist, inf, sizeof(dist)), memset(vis, 0, sizeof(vis));
  queue<int> q;
  q.push(S);
  dist[S] = 0, vis[S] = 1;
  while (q.size()) {
    int u = q.front();
    q.pop();
    vis[u] = 0;
    for (int i = head[u]; ~i; i = e[i].next) {
      int w1 = e[i].w1;
      int w2 = e[i].w2;
      int v = e[i].v;
      if (w1 && dist[v] > dist[u] + w2) {
        dist[v] = dist[u] + w2;
        if (vis[v] == 0) vis[v] = 1, q.push(v);
      }
    }
  }
  if (dist[T] >= inf) return 0;
  return 1;
}
int temp_p;
int dfs(int st, int en, int flow) {
  if (st == en) return flow;
  int rest = flow;
  vis[st] = 1;
  for (int i = head[st]; ~i; i = e[i].next) {
    int v = e[i].v;
    int w1 = e[i].w1;
    int w2 = e[i].w2;
    if (dist[v] == dist[st] + w2 && w1 && !vis[v]) {
      int up = dfs(v, en, min(rest, w1));
      rest -= up, e[i].w1 -= up, e[i ^ 1].w1 += up;
      temp_p += e[i].w2 * up;
      if (rest == 0) break;
    }
  }
  return flow - rest;
}
void Dinic(int S, int T) {
  int max_flow = 0, max_p = 0;
  while (spfa(S, T)) {
    max_flow += dfs(S, T, inf);
    max_p += temp_p;
    temp_p = 0;
  }
  out(max_p);
}
int main() {
  n = read(), memset(head, -1, sizeof(head));
  for (int i = (1); i <= (n); ++i) a[i] = read();
  S = 0, T = n + 1;
  for (int i = 1; i <= n; i++) {
    if (a[i])
      add(S, i, 1, 0), add(i, S, 0, 0);
    else
      add(i, T, 1, 0), add(T, i, 0, 0);
    if (i != n) add(i, i + 1, n, 1), add(i + 1, i, n, 1);
  }
  Dinic(S, T);
  return 0;
}
