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 org.omg.CORBA.INTERNAL;

import java.io.*;
import java.lang.reflect.Array;
import java.util.*;

import static java.lang.Math.*;

public class E {
    public static void main(String[] args) throws Exception {
        Scanner in = new Scanner(System.in);
        PrintWriter pw = new PrintWriter(System.out);
        int n = in.nextInt();
        char[] a = in.next().toCharArray();
        char[] b = in.next().toCharArray();
        pw.println(solve(n, a, b));

        pw.close();
    }


    static int solve(int n, char[] a, char[] b) {
        n = a.length;
        int[] c = new int[n];
        int m = 0;
        int ones = 0, zeros = 0;
        int af[] = new int[2];
        int bf[] = new int[2];
        for (int i = 0; i < n; i++) {
            if (a[i] != b[i]) {
                c[m] = a[i] - '0';
                if (c[m] == 0) zeros++;
                else ones++;
                m++;
            }
            af[a[i] - '0']++;
            bf[b[i] - '0']++;
        }
        if (!Arrays.equals(af, bf)) return -1;
        if (ones != zeros) return -1;
        n = m;
        c = Arrays.copyOf(c, m);
        return solve2(c);
    }

    static int solve2(int[] c) {
        if (c.length == 0) return 0;
        int n = c.length;
        TreeSet<Integer> one = new TreeSet<>();
        TreeSet<Integer> zero = new TreeSet<>();
        for (int i = 0; i < n; i++) {
            if (c[i] == 0) zero.add(i);
            else one.add(i);
        }
        return solve(zero, one);
    }

    static int solve(TreeSet<Integer> zero, TreeSet<Integer> one) {
        if (zero.isEmpty() && one.isEmpty()) return 0;
        int res = 1, k = 1;
        Integer next = -1;
        if (zero.first() < one.first()) k = 0;
        while (true) {
            if (k == 1) {
                Integer a = null, b = null;
                a = one.higher(next);
                if (a != null) b = zero.higher(a);
                next = b;
                if (a != null && b != null) {
                    one.remove(a);
                    zero.remove(b);
                } else {
                    break;
                }
            } else {
                Integer a = null, b = null;
                a = zero.higher(next);
                if (a != null) b = one.higher(a);
                next = b;
                if (a != null && b != null) {
                    zero.remove(a);
                    one.remove(b);
                } else {
                    break;
                }
            }
        }

        return res + solve(zero, one);
    }


    static void debug(Object... obj) {
        System.err.println(Arrays.deepToString(obj));
    }
}