Naman has two binary strings s and t of length n (a binary string is a string which only consists of the characters "0" and "1"). He wants to convert s into t using the following operation as few times as possible.

In one operation, he can choose any subsequence of s and rotate it clockwise once.

For example, if s = 1110100, he can choose a subsequence corresponding to indices (1-based) \{2, 6, 7 \} and rotate them clockwise. The resulting string would then be s = 1010110.

A string a is said to be a subsequence of string b if a can be obtained from b by deleting some characters without changing the ordering of the remaining characters.

To perform a clockwise rotation on a sequence c of size k is to perform an operation which sets c_1:=c_k, c_2:=c_1, c_3:=c_2, …, c_k:=c_{k-1} simultaneously.

Determine the minimum number of operations Naman has to perform to convert s into t or say that it is impossible. 

Input

The first line contains a single integer n (1 ≤ n ≤ 10^6) — the length of the strings.

The second line contains the binary string s of length n.

The third line contains the binary string t of length n.

Output

If it is impossible to convert s to t after any number of operations, print -1.

Otherwise, print the minimum number of operations required.

Examples

Input


6
010000
000001


Output


1

Input


10
1111100000
0000011111


Output


5

Input


8
10101010
01010101


Output


1

Input


10
1111100000
1111100001


Output


-1

Note

In the first test, Naman can choose the subsequence corresponding to indices \{2, 6\} and rotate it once to convert s into t.

In the second test, he can rotate the subsequence corresponding to all indices 5 times. It can be proved, that it is the minimum required number of operations.

In the last test, it is impossible to convert s into t.
import sys
import math 
from decimal import *
def I(): return int(sys.stdin.readline())
def IL(): return list(map(int,sys.stdin.readline().strip().split()))
def ILS(): return list(map(str,sys.stdin.readline().strip().split()))

def check(flip):
	cnt = 0
	f = flip.copy()
	while(True):
		xx = 0
		turn = None
		for i in range(len(f)) :
			x = f[i]
			if x == None : continue
			if turn == None : 
				f[i] = None
				xx+=1
				turn = x^1
			else :
				if turn == x : 
					xx+=1
					turn = x^1
					f[i] = None
		if xx > 0 : 
			cnt+=1
		else : 
			break
	return cnt

class Node :
	def __init__(self,x):
		self.x = x
		self.next = None 
		self.prev = None

	def delete(self):
		nxt = self.next
		if self.prev != None:
			self.prev.next = self.next
		if self.next != None:
			self.next.prev = self.prev
		return nxt

def solve():
	n = I()
	s = input()
	t = input()
	# t = [str(int(x)^1) for x in t]
	# print(n,s,t)
	sze = sum([1 for x in s if x == '0'])
	son = sum([1 for x in s if x == '1'])
	tze = sum([1 for x in t if x == '0'])
	ton = sum([1 for x in t if x == '1'])
	if sze != tze or son != ton : 
		print(-1)
		return 
	flip = [int(s[i]) for i in range(len(s)) if s[i]!= t[i]]
	# print(flip)
	ans = 0
	ones = 0
	ze = 0 
	for x in flip :
		# print(ones,ze,x,ans)
		if x == 1 : 
			if ze <= 0 : 
				ans+=1 
			else : ze -= 1
			ones+=1
		else : 
			if ones <= 0 :
				ans+=1
			else : ones-=1
			ze +=1
	print(ans)
	# print(flip)
	# head = Node(-1)
	# cur = head
	# for x in flip :
	# 	cur.next = Node(x)
	# 	cur.next.prev = cur
	# 	cur = cur.next

	# cnt = 0
	# while True :
	# 	turn = None
	# 	cur = head.next
	# 	while cur != None : 
	# 		# print(cnt,cur.x,turn)
	# 		x = cur.x
	# 		if turn == None : turn = x^1; cur = cur.delete()
	# 		else : 
	# 			if x == turn : turn = x^1; cur = cur.delete();
	# 			else : cur = cur.next
	# 	if turn == None : break
	# 	else : cnt +=1
	# print(cnt)
	# ans = 0
	# prev = None
	# cnt = 0
	# for x in flip :
	# 	if prev == None :
	# 		cnt = 1
	# 		prev = x
	# 	else : 
	# 		if x == prev : cnt+=1
	# 		else : 
	# 			ans = max(ans,cnt)
	# 			cnt = 1
	# 			prev = x
	# ans = max(ans,cnt)
	# print(ans)

solve()