Problem:
Score : 1000 points

Problem Statement

There is a sequence of length N: a = (a_1, a_2, ..., a_N).
Here, each a_i is a non-negative integer.

Snuke can repeatedly perform the following operation:

Let the XOR of all the elements in a be x. Select an integer i (1 ≤ i ≤ N) and replace a_i with x.

Snuke's objective is to match a with another sequence b = (b_1, b_2, ..., b_N).
Here, each b_i is a non-negative integer.

Determine whether the objective is achievable, and find the minimum necessary number of operations if the answer is positive.

Constraints

2 ≤ N ≤ 10^5

a_i and b_i are integers.

0 ≤ a_i, b_i < 2^{30}

Input

Input is given from Standard Input in the following format:

N
a_1 a_2 ... a_N
b_1 b_2 ... b_N

Output

If the objective is achievable, print the minimum necessary number of operations.
Otherwise, print -1 instead.

Sample Input 1

3
0 1 2
3 1 0

Sample Output 1

2

At first, the XOR of all the elements of a is 3.
If we replace a_1 with 3, a becomes (3, 1, 2).

Now, the XOR of all the elements of a is 0.
If we replace a_3 with 0, a becomes (3, 1, 0), which matches b.

Sample Input 2

3
0 1 2
0 1 2

Sample Output 2

0

Sample Input 3

2
1 1
0 0

Sample Output 3

-1

Sample Input 4

4
0 1 2 3
1 0 3 2

Sample Output 4

5

Solution in C++ (GCC 9.2.1) (judge verdict: Accepted)

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <map>
using namespace std;
inline int read()
{
	int f = 1, x = 0;
	char ch;

	do{
		ch = getchar();
		if (ch == '-')
			f = -1;
	}while(ch < '0' || ch > '9');
	do{
		x = x * 10 + ch - '0';
		ch = getchar();
	}while(ch >= '0' && ch <= '9');
	return f * x;
}
const int N = 1e5;

int n, x, cnt;
map<int, int> p;
int a[N + 1], b[N + 1];
struct Edge {
	int to, next;
} edge[(N << 1) + 1];
int start[N + 1], tot;
int vis[N + 1];
int ans;

inline void addedge(int u, int v)
{
	edge[++tot] = Edge{ v, start[u] };
	start[u] = tot;
	edge[++tot] = Edge{ u, start[v] };
	start[v] = tot;
	ans++;
	return;
}
inline void dfs(int u)
{
	vis[u] = 1;
	for (int i = start[u]; i; i = edge[i].next) {
		int v = edge[i].to;
		if (!vis[v])
			dfs(v);
	}
	return;
}
int main()
{
	n = read();
	for (int i = 1; i <= n; i++) {
		a[i] = read();
		p[a[i]]++;
		x ^= a[i];
	}
	p[x]++;
	for (int i = 1; i <= n; i++) {
		b[i] = read();
		p[b[i]]--;
	}
	for (map<int, int>::iterator it = p.begin(); it != p.end(); it++) {
		if ((*it).second < 0) {
			printf("-1\n");
			return 0;
		}
		(*it).second = ++cnt;
	}
	for (int i = 1; i <= n; i++)
		if (a[i] != b[i])
			addedge(p[a[i]], p[b[i]]);

	for (int i = 1; i <= cnt; i++) {
		if (start[i] && !vis[i]) {
			ans++;
			dfs(i);
		}
	}

	if (start[p[x]])
		ans--;
	printf("%d\n", ans);
	return 0;
}