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 java.io.*;
	import java.util.*;
	import java.math.*;
	
	 
	 public class Main	{
	   static class Pair implements Comparable<Pair>{
	   int a;
	   int b;
	   public Pair(int x,int y){a=Math.min(x, y);b=Math.max(x, y);}
	   public Pair(){}
	   public int compareTo(Pair p){
		 if(a == p.a) {
			 return b - p.b;
		 }
		 return a - p.a;
	   }
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + a;
		result = prime * result + b;
	//	out.println("hashcode = "+result);
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		Pair cur = (Pair)obj;
		if((a==cur.a && b==cur.b) || (a==cur.b && b==cur.a))return true;
		return false;
	}
	 }
	   static class cell implements Comparable<cell>{
		   int a,b;
		   long dis;
		   public cell(int x,int y,long z) {a=x;b=y;dis=z;}
		   public int compareTo(cell c) {
			   return Long.compare(dis,c.dis);
		   }
	   }
	static class TrieNode{
		TrieNode left;
		TrieNode right;
		int op;
		int data;
		public TrieNode() {}
	}
	  public static int gcd(int a,int b)
	  {
	    if(a<b)
	
	      return gcd(b,a);
	    if(b==0)
	      return a;
	    return gcd(b,a%b);
	    
	  }
	  static int lcm(int a,int b) {
		  return  a*b / gcd(a,b);
	  }
	  //static long ans = 0;
	  static long mod = 998244353;//(long)(1e9+7);//
	   
	    public static void main(String[] args) throws Exception {
	       new Thread(null, null, "Anshum Gupta", 99999999) {
	            public void run() {
	                try {
	                    solve();
	                } catch(Exception e) {
	                    e.printStackTrace();
	                    System.exit(1);
	                }
	            }
	        }.start();
	    }
	
	static long pow(long x,long y){
	    if(y == 0)return 1;
	    if(y==1)return x;
	    long a = pow(x,y/2);
	    a = (a*a)%mod;
	    if(y%2==0){
	        return a;
	    }
	    return (a*x)%mod;
	}
	
	static long mxx;
	static int mxN = (int)(1e7);
	static long[]fact,inv_fact;
	static long my_inv(long a) {
		return pow(a,mod-2);
	}
	static long bin(int a,int b) {
		if(a < b || a<0 || b<0)return 0;
	    return ((fact[a]*inv_fact[a-b])%mod * inv_fact[b])%mod;
	}
	static ArrayList<ArrayList<Integer>>adj;
	static boolean[]vis;
	static void make_facts() {
	  fact=new long[mxN];
	  inv_fact = new long[mxN];
	  fact[0]=inv_fact[0]=1L;
	  for(int i=1;i<mxN;i++) {
		   fact[i] = (i*fact[i-1])%mod;
		   inv_fact[i] = my_inv(fact[i]);
	  }
	}
	//static int[]bfs(int a){
	//	Queue<Integer> q = new  LinkedList<Integer>();
	//	
	//	vis = new boolean[n+1];
	//	int[]dis = new int[n+1];
	//	q.add(a);
	//	dis[a] = 0;
	//	vis[a] = true;
	//	while(!q.isEmpty()) {
	//		int cur = q.poll();
	//	//	vis[cur] = true;
	//	//	if(cur == b)break;
	//		for(int x : adj.get(cur)) {
	//			if(vis[x])continue;
	//			q.add(x);
	//			dis[x] = dis[cur]+1;
	//			vis[x] = true;
	//		}
	//	}
	//	return dis;
	//}
	static int get(int[]a,int x) {
		int n = a.length;
		
		int sum = 0;
		int ans = 0;
		for(int i=0;i<n;i++) {
			a[i] *= x;
			sum += a[i];
			ans = Math.max(ans, sum);
			if(sum < 0)sum = 0;
			
		}
		return ans;
	}
	 public static void solve() throws Exception {
	   // solve the problem here
	   MyScanner s = new MyScanner();
	        out = new PrintWriter(new BufferedOutputStream(System.out), true);
	        int tc = 1;//s.nextInt();
	        mxx = (long)(1e18+5);
	//        make_facts();  
	       
	        while(tc-->0){
	        	int n = s.nextInt();
	        	String a = s.next();
	        	String b = s.next();
	        	int zc = 0;
	        	for(int i=0;i<n;i++) {
	        		if(a.charAt(i)=='0')zc++;
	        		if(b.charAt(i)=='0')zc--;
	        	}
	        	if(zc != 0) {
	        		out.println("-1");
	        		return;
	        	}
	        	int[]arr=new int[n];
	        	int ans = 0;
	        	for(int i=0;i<n;i++) {
	        		if(a.charAt(i) != b.charAt(i)) {
	        			arr[i] = (a.charAt(i) == '0' ? 1 : -1);
	        		}
	        	}
	        	ans = Math.max(get(arr,1),get(arr,-1));
	        	out.println(ans);
	        }
	        	
	           
	        out.flush();
	}
	 
	     
	 
	 
	 
	    //-----------PrintWriter for faster output---------------------------------
	    public static PrintWriter out;
	 
	    //-----------MyScanner class for faster input----------
	    public static class MyScanner {
	        BufferedReader br;
	        StringTokenizer st;
	 
	        public MyScanner() {
	            br = new BufferedReader(new InputStreamReader(System.in));
	        }
	 
	        String next() {
	            while (st == null || !st.hasMoreElements()) {
	                try {
	                    st = new StringTokenizer(br.readLine());
	                } catch (IOException e) {
	                    e.printStackTrace();
	                }
	            }
	            return st.nextToken();
	        }
	 
	        int nextInt() { return Integer.parseInt(next()); }
	        long nextLong() { return Long.parseLong(next()); }
	        double nextDouble() { return Double.parseDouble(next()); }
	         
	        String nextLine(){
	            String str = "";
	            try {
	                str = br.readLine();
	            } catch (IOException e) {
	                e.printStackTrace();
	            }
	            return str;
	        }
	    }
	    //--------------------------------------------------------
	}
