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: Time Limit Exceeded)

//Nipah!~☆
#include<bits/stdc++.h>
using namespace std;

const int maxn = 1e5 + 10;

int n;
int ans;
int a[maxn];
int b[maxn];
int P[maxn];
vector<int> bois;
set<int> badbois;
unordered_map<int, vector<int>> inds[2];

void in();
void solve();
void out();

int main(){
	ios::sync_with_stdio(false);
	cout.tie(0);
	cin.tie(0);
	in();
	solve();
	out();
}

void in(){
	cin >> n;
	for(int i = 0; i < n; i++)
		cin >> a[i];
	for(int i = 0; i < n; i++)
		cin >> b[i];
}

void solve(){
	int hold = 0;
	for(int i = 0; i < n; i++){
		hold ^= a[i];
		if(a[i] != b[i]){
			inds[0][a[i]].push_back(i);
			inds[1][b[i]].push_back(i);
			bois.push_back(b[i]);
		}
	}
	inds[0][hold].push_back(n);
	sort(bois.begin(), bois.end());
	bois.resize(unique(bois.begin(), bois.end()) - bois.begin());
	for(auto i: bois){
		if(inds[1][i].size() > inds[0][i].size()){
			ans = -1;
			return;
		}
		for(int j = 1; j <= inds[1][i].size(); j++){
			P[inds[0][i][inds[0][i].size() - j]] = inds[1][i][j - 1] + 1;
			badbois.insert(inds[0][i][inds[0][i].size() - j]);
		}
	}
	int now = n;
	while(badbois.size()){
		ans++;
		if(P[now]){
			badbois.erase(now);
			now = P[now] - 1;
		}
		else
			now = *badbois.begin();
	}
}

void out(){
	cout << ans;
}