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.

n_value = int(input())

list_with_values = list(map(int, input().split(" ")))

#def compute_unused_sits(list_with_values):
#print(list_with_values)
inv_list_with_values = [1 for cycle in range(len(list_with_values))]
for cycle in range(len(list_with_values)):
	if list_with_values[cycle] == 1:
		inv_list_with_values[cycle] = 0



def where_more_ones(list_with_values, index):
	if len(list_with_values[index:]) == 0:
		return -1
	elif len(list_with_values[:index]) == 0:
		return 1 
	
	
	forward_ones_zeros = [sum(list_with_values[index:]), len(list_with_values[index:])]
	backward_ones_zeros = [sum(list_with_values[:index]), len(list_with_values[:index])]
	
	forward_ones_zeros[1] = forward_ones_zeros[1] - forward_ones_zeros[0]
	backward_ones_zeros[1] = backward_ones_zeros[1] - backward_ones_zeros[0]
	if forward_ones_zeros[0] == 0:
		return 1
	elif backward_ones_zeros[0] == 0:
		return -1
	value_to_forward = None
	index_of_forward =forward_ones_zeros[1] / forward_ones_zeros[0]
	index_of_backward = backward_ones_zeros[1] / backward_ones_zeros[0]  
	if  index_of_forward > index_of_backward:
		value_to_forward = 1
	elif index_of_backward > index_of_forward:
		value_to_forward = -1 
	else:
		value_to_forward = 1
	
	return value_to_forward



def compute_nearest_index(inv_list_with_values, list_with_values, value_to_forward,  index):
	minimal_index = None
	how_much_move = 0
	if value_to_forward == 1:
		for cycle in range(index + 1, len(list_with_values)):
			how_much_move += 1
			if list_with_values[cycle] == 0:
				minimal_index = cycle
				break
			
	
	elif value_to_forward == -1:
		
		for cycle in range(index - 1, 0, -1):
			how_much_move += 1
			if list_with_values[cycle] == 0:
				minimal_index = cycle
				break
			
		#print(minimal_index)
	
			
	assert minimal_index != None
	
	list_with_values[minimal_index] = 1
	#print(list_with_values)
	#print(how_much_move)
	return list_with_values, how_much_move
	
	
#print(inv_list_with_values)
all_move = 0
for cycle in range(len(list_with_values)):
	if inv_list_with_values[cycle] == 0:
		index = cycle
	else:
		continue
	#print("Cycle - ", cycle)
	value_to_forward = where_more_ones(list_with_values, index)
	
	list_with_values, how_much_move = compute_nearest_index(inv_list_with_values, list_with_values, value_to_forward,  index)

	all_move += how_much_move
	
print(all_move)