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.
class PriorityQueue:
    class Reverse:
        def __init__(self, val):
            self.val = val

        def __lt__(self, other):
            return self.val > other.val

        def __repr__(self):
            return repr(self.val)

    def __init__(self, a=None, desc=False):
        import heapq
        self.heapq = heapq
        self.__container = []
        if a:
            self.__container = a[:]

        if desc:
            for i in range(len(self.__container)):
                self.__container[i] = self.Reverse(self.__container[i])
            self.pop = self.__pop_desc
            self.push = self.__push_desc
            self.top = self.__top_desc
            self.pushpop = self.__pushpop_desc
            self.poppush = self.__poppush_desc
        else:
            self.pop = self.__pop_asc
            self.push = self.__push_asc
            self.top = self.__top_asc
            self.pushpop = self.__pushpop_asc
            self.poppush = self.__poppush_asc

        self.heapq.heapify(self.__container)

    @property
    def is_empty(self):
        return not self.__container

    def __pop_asc(self):
        return self.heapq.heappop(self.__container)

    def __pop_desc(self):
        return self.heapq.heappop(self.__container).val

    def __push_asc(self, item):
        self.heapq.heappush(self.__container, item)

    def __push_desc(self, item):
        self.heapq.heappush(self.__container, self.Reverse(item))

    def __top_asc(self):
        return self.__container[0]

    def __top_desc(self):
        return self.__container[0].val

    def __pushpop_asc(self, item):
        return self.heapq.heappushpop(self.__container, item)

    def __pushpop_desc(self, item):
        return self.heapq.heappushpop(self.__container, self.Reverse(item)).val

    def __poppush_asc(self, item):
        return self.heapq.heapreplace(self.__container, item)

    def __poppush_desc(self, item):
        return self.heapq.heapreplace(self.__container, self.Reverse(item)).val

    def sum(self):
        return sum(self.__container)

    def __len__(self):
        return len(self.__container)

    def __str__(self):
        return str(sorted(self.__container))

    def __repr__(self):
        return self.__str__()


def main():
    import sys
    read = sys.stdin.read
    readline = sys.stdin.readline
    INF = float('INF')
    # INF = (1 << 62) - (1 << 31)
    MOD = 10 ** 9 + 7
    sys.setrecursionlimit(10 ** 5)
    """+:-:+:-:+:-:+:-:+:-:+:-:+:-:+:-:+:-:+:-:+:-:+:-:+:-:+:-+:-"""
    N = int(readline())
    A = list(map(int, readline().split()))

    P = [i for i in range(N) if A[i] == 1]
    Q = [i for i in range(N) if A[i] == 0]
    ans = 0

    L = PriorityQueue(desc=True)
    R = PriorityQueue(Q)

    for x in P:
        while R and R.top() < x:
            L.push(R.pop())
        l = 10 ** 8
        r = 10 ** 8
        if L:
            l = abs(x - L.top())
        if R:
            r = abs(x - R.top())
        if l < r:
            ans += l
            L.pop()
        else:
            ans += r
            R.pop()

    print(ans)

if __name__ == '__main__':
    main()
