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 typing import List
# import sys
# sys.setrecursionlimit(10000)

# Bottom-up DP
def solve(n: int, a: List[int]) -> int:
    zeroes = []
    ones = []
    for i in range(len(a)):
        if (a[i]):
            ones.append(i)
        else:
            zeroes.append(i)

    if (not ones):
        return 0

    memo = [[float("inf")] * len(zeroes) for i in range(len(ones))]

    memo[0][0] = abs(ones[0] - zeroes[0])

    for i in range(len(ones)):
        for j in range(i, len(zeroes)): # We can start at i since we can never reach a state such that j < i
            if (i or j):
                if (j - 1 >= 0):
                    if (i - 1 >= 0):
                        memo[i][j] = memo[i - 1][j - 1] + abs(ones[i] - zeroes[j])
                    else:
                        memo[i][j] = abs(ones[i] - zeroes[j])
                    memo[i][j] = min(memo[i][j], memo[i][j - 1])
    return memo[-1][-1]


# DP
# Got RE on Test 11. But we know that is because we exceeded the recursion depth. Thanks ABC 201 ;)
# And obviously increasing the recursion limit will eventually result in TLE. We need to do this bottom-up.
# MAX_I = 2500
# MAX_J = 5000
# def solve(n: int, a: List[int]) -> int:
#     # Upper bounds for DP-State: i = 2500, j = 2500
#     memo = [[0]*MAX_J for i in range(MAX_I)]
#
#     zeroes = []
#     ones = []
#     for i in range(len(a)):
#         if (a[i]):
#             ones.append(i)
#         else:
#             zeroes.append(i)
#
#     def helper(i: int, j: int) -> int:
#         if (i == len(ones)):
#             return 0
#         if (j == len(zeroes)):
#             return float("inf")
#         if (memo[i][j]):
#             return memo[i][j]
#
#         score1 = abs(ones[i] - zeroes[j]) + helper(i + 1, j + 1)
#         score2 = helper(i, j + 1)
#         ans = min(score1, score2)
#         memo[i][j] = ans
#         return ans
#
#     return helper(0, 0)

# UPSOLVING

# This greedy approach does not work. Ex. 0 0 1 1 1 0. Ans should be 5. Greedy returns 6.
# def solve(n: int, a: List[int]) -> int:
#     zeroes = []
#     ones = []
#     for i in range(len(a)):
#         if (a[i]):
#             ones.append(i)
#         else:
#             zeroes.append(i)
#
#     min_cost = float("inf")
#     for i in range(len(zeroes) - len(ones) + 1):
#         cost = 0
#         for j in range(len(ones)):
#             cost += abs(zeroes[i + j] - ones[j])
#         min_cost = min(min_cost, cost)
#     return min_cost

n = int(input())
a = list(map(int, input().split()))
print(solve(n, a))