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.


def closest(array, x, first, second, third):
    index_set = {first, second, third}
    first_index = index_set.pop()
    second_index = index_set.pop()
    first_value = array[first_index]
    second_value = array[second_index]
    first_diff = abs(x - first_value)
    second_diff = abs(x - second_value)
    
    if first_diff > second_diff:
        return second_index
    elif first_diff < second_diff:
        return first_index
    if first_diff == second_diff:
        if first_value > second_value:
            return second_index
        else:
            return first_index
        
        
def binary_search(array, x):
    n = len(array)
    left = 0
    right = len(array) - 1
    if x <= array[0]:
        return array[0]
    if x >= array[n - 1]:
        return array[n - 1]
    mid = (left + right) // 2
    while right - left > 1 :
        mid = (left + right) // 2
        value = array[mid]
        if value == x:
            return array[mid]
        if value < x:
            left = mid
        elif value > x:
            right = mid
            
    closest_index = closest(array, x, left, mid, right)
    return array[closest_index]


input()
ar = list(map(int, input().split()))

ar = [2] + ar

zero_stack = []
ones_stack = []

busy = [0 for i in range(len(ar))]

for i in range(len(ar)):
    if ar[i] == 0:
        zero_stack.append(i)
    if ar[i] == 1:
        ones_stack.append(i)
         

total = 0
for ones in ones_stack:
    
    elem = binary_search(zero_stack, ones)
    total += abs(ones-elem)
    
    busy[elem] = ones
    del zero_stack[zero_stack.index(elem)]
    #print(total, zero_stack)
    
    
    
temp = [(idx, x) for idx, x in enumerate(busy) if x != 0]
nonzero_idxs = sorted([idx for idx, x in enumerate(busy) if x != 0])
temp = sorted(temp, key=lambda x: x[1])

true = [(x, y[1]) for x, y in zip(nonzero_idxs, temp)]
total = 0

for el in true:
    total += abs(el[0] - el[1])

    
print(total)