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.
import sys,math
from collections import deque,defaultdict
import operator as op
from functools import reduce
from itertools import permutations
import heapq

# sys.setrecursionlimit(10**7) 
#OneDrive\Documents\codeforces

I=sys.stdin.readline

alpha="abcdefghijklmnopqrstuvwxyz"

mod=10**9 + 7

"""
x_move=[-1,0,1,0,-1,1,1,-1]
y_move=[0,1,0,-1,1,1,-1,-1]
"""
def ii():
	return int(I().strip())
def li():
	return list(map(int,I().strip().split()))
def mi():
	return map(int,I().strip().split())


def ncr(n, r):
    r = min(r, n-r)
    numer = reduce(op.mul, range(n, n-r, -1), 1)
    denom = reduce(op.mul, range(1, r+1), 1)
    return numer // denom 



def gcd(x, y):
    while y:
        x, y = y, x % y
    return x

def isPrime(n):
	if n<=1:
		return False
	elif n<=2:
		return True
	else:
		
		for i in range(2,int(n**.5)+1):
			if n%i==0:
				return False
		return True



#print("Case #"+str(_+1)+":",ans)
def cal(arr,n):
	tmp=[i for i in arr]
	cnt=0
	for i in range(n):
		if tmp[i]==1:
			idx1=-1
			for j in range(i-1,-1,-1):
				if tmp[j]==0:
					idx1=j
					break
			idx2=-1
			for j in range(i+1,n):
				if tmp[j]==0:
					idx2=j
					break
			if idx2==-1 and idx1==-1:
				cnt2=10**9
				break
			elif idx1!=-1 and idx2!=-1:
				if abs(i-idx1)>abs(idx2-i):
					tmp[idx2]=-1
					cnt+=abs(idx2-i)
				else:
					tmp[idx1]=-1
					cnt+=abs(idx1-i)
			elif idx2!=-1:
				tmp[idx2]=-1
				cnt+=abs(idx2-i)
			else:
				tmp[idx1]=-1
				cnt+=abs(idx1-i)

	cnt2=0
	for i in range(n-1,-1,-1):
		if tmp[i]==1:
			idx1=-1
			for j in range(i-1,-1,-1):
				if tmp[j]==0:
					idx1=j
					break
			idx2=-1
			for j in range(i+1,n):
				if tmp[j]==0:
					idx2=j
					break
			if idx2==-1 and idx1==-1:
				cnt2=10**9
				break
			elif idx1!=-1 and idx2!=-1:
				if abs(i-idx1)>abs(idx2-i):
					tmp[idx2]=-1
					cnt2+=abs(idx2-i)
				else:
					tmp[idx1]=-1
					cnt2+=abs(idx1-i)
			elif idx2!=-1:
				tmp[idx2]=-1
				cnt2+=abs(idx2-i)
			else:
				tmp[idx1]=-1
				cnt2+=abs(idx1-i)

	return cnt,cnt2


	
def main():
	ans=""
	
	n=ii()
	arr=li()

	cnt1,cnt2=cal(arr,n)

	ans=min(cnt2,cnt1)
	



		
	print(ans)
	




	


	




		
	












































					

if __name__ == '__main__':
	main()