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.

from sys import maxsize, stdout, stdin,stderr
mod = int(1e9 + 7)

def I(): return int(stdin.readline())
def lint(): return [int(x) for x in stdin.readline().split()]
def S(): return input().strip()
def grid(r, c): return [lint() for i in range(r)]
from collections import defaultdict, Counter
import math
import bisect
from itertools import groupby
def gcd(a,b): 
    while b:
        a %= b
        tmp = a
        a = b
        b = tmp
    
    return a

def lcm(a,b): 
    return a / gcd(a, b) * b

def check_prime(n):
    for i in range(2, int(n ** (1 / 2)) + 1):
        if not n % i:
            return False
    return True
def Bs(a, x):
    i=0
    j=0
    left = 0
    right = len(a)
    flag=False
    while left<right:
        
        mi = (left+right)//2
        #print(mi,a[mi],x)
        
        if a[mi]<=x:
            left = mi+1
            i+=1
            
        else:

            right = mi
            j+=1
        #print(left,right,"----")
    #print(i-1,j)
    if left>0 and a[left-1]==x:
        return i-1, j
    else:
        return -1, -1
def func(ans,i,z,o):
    if i==len(o):
        return ans
    val =o[i]
    c=bisect.bisect(z, val)
    if c==len(z):
    
        ans+=abs(z[-1]-val)
        z.pop(-1)
        return func(ans,i+1,z,o)
    elif c==0:
    
        ans+=abs(z[c]-val)
    
        z.pop(0)
        return func(ans,i+1,z,o)
    else:
        a=z.copy()
        b=z.copy()
        a.pop(c)
        b.pop(c-1)
        return min(func(ans+abs(z[c-1]-val),i+1,b,o),func(ans+abs(z[c]-val),i+1,a,o))
        
        
    
    
n = I()
s = lint()
tmp=1000000000001
o=[-1]
z=[-1]
for i in range(n):
    if s[i]==1:
        o.append(i)
    else:
        z.append(i)
        
dp=[]
a=len(o)-1
b=len(z)-1
if a==0:
    print(0)
else:
    for i in range(a+1):
        dp.append([tmp]*(b+1))

    for i in range(b+1):
        dp[0][i]=0
    for i in range(1,a+1):
        for j in range(1,b+1):
            dp[i][j]=min(dp[i][j],dp[i-1][j-1]+abs(o[i]-z[j]))
            dp[i][j]=min(dp[i][j],dp[i][j-1])
    ans=tmp
    for i in range(b+1):
        ans=min(ans,dp[a][i])
    print(ans)


