Problem: There are some tasks which have the following structure: you are given a model, and you can do some operations, you should use these operations to achive the goal. One way to create a new task is to use the same model and same operations, but change the goal.

Let's have a try. I have created the following task for Topcoder SRM 557 Div1-Hard: you are given n integers x1, x2, ..., xn. You are allowed to perform the assignments (as many as you want) of the following form xi ^= xj (in the original task i and j must be different, but in this task we allow i to equal j). The goal is to maximize the sum of all xi.

Now we just change the goal. You are also given n integers y1, y2, ..., yn. You should make x1, x2, ..., xn exactly equal to y1, y2, ..., yn. In other words, for each i number xi should be equal to yi.

Input

The first line contains an integer n (1 ≤ n ≤ 10000). The second line contains n integers: x1 to xn (0 ≤ xi ≤ 109). The third line contains n integers: y1 to yn (0 ≤ yi ≤ 109).

Output

If there is no solution, output -1.

If there is a solution, then in the first line output an integer m (0 ≤ m ≤ 1000000) – the number of assignments you need to perform. Then print m lines, each line should contain two integers i and j (1 ≤ i, j ≤ n), which denote assignment xi ^= xj.

If there are multiple solutions you can print any of them. We can prove that under these constraints if there exists a solution then there always exists a solution with no more than 106 operations.

Examples

Input

2
3 5
6 0


Output

2
1 2
2 2


Input

5
0 0 0 0 0
1 2 3 4 5


Output

-1


Input

3
4 5 6
1 2 3


Output

5
3 1
1 2
2 2
2 3
3 1


Input

3
1 2 3
4 5 6


Output

-1

Note

Assignment a ^= b denotes assignment a = a ^ b, where operation "^" is bitwise XOR of two integers.

Solution (in JAVA):

Solution:
import java.io.*;
import java.util.*;
import java.math.*;

public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		new Task().solve(1,in,out);
		out.close();
	}
}

class Task {
	void solve(int ca,InputReader in,PrintWriter out) {
		int n = in.nextInt();
		int[] A = new int[n];
		for (int i = 0; i < n; ++ i) {
			A[i] = in.nextInt();
		}
		ArrayList<Pair> listA = new ArrayList<Pair>();
		gauss(A,listA);
		int[] B = new int[n];
		for (int i = 0; i < n; ++ i) {
			B[i] = in.nextInt();
		}
		ArrayList<Pair> listB = new ArrayList<Pair>();
		gauss(B,listB);
		int na = 0;
		for ( ; na<n && A[na]>0; ++ na);
		int nb = 0;
		for ( ; nb<n && B[nb]>0; ++ nb);
		for (int i = 0,r = 0; i < nb; ++ i) {
			int value = B[i];
			int p = -1;
			for ( ; r < na; ++ r) {
				if ((A[r]&-A[r]) == (value&-value)) {
					p = r ++;
					break;
				}
			}
			if (p == -1) {
				out.println(-1);
				return ;
			}
			value ^= A[p];
			for (int j = p+1; j<na && value>0; ++ j) {
				if ((value&-value) == (A[j]&-A[j])) {
					value ^= A[j];
					listA.add(new Pair(p,j));
				}
			}
			if (value != 0) {
				out.println(-1);
				return ;
			}
			A[p] = B[i];
		}
		for (int i = 0; i < nb; ++ i) {
			for (int j = 0; j < na; ++ j) {
				if (B[i] == A[j]) {
					if (i != j) {
						A[i] ^= A[j]; A[j] ^= A[i]; A[i] ^= A[j];
						listA.add(new Pair(i,j));
						listA.add(new Pair(j,i));
						listA.add(new Pair(i,j));
					}
					break;
				}
			}
		}
		for (int i = nb; i < na; ++ i) {
			A[i] ^= A[i];
			listA.add(new Pair(i,i));
		}
		out.println((listA.size() + listB.size()));
		for (Pair t : listA) {
			t.a ++; t.b ++;
			out.println(t.a + " " + t.b);
		}
		for (int i = listB.size()-1; i >= 0; -- i) {
			Pair t = listB.get(i);
			t.a ++; t.b ++;
			out.println(t.a + " " + t.b);
		}
	}

	void gauss(int[] A,ArrayList<Pair> list) {
		int row = 0;
		int n = A.length;
		while (row<n) {
			int mx = (1<<31)-1,p = -1;
			for (int i = row; i < n; ++ i) {
				int t = A[i]&-A[i];
				if (t>0 && t<mx) {
					mx = t;
					p = i;
				}
			}
			if (p == -1) break;
			if (row != p) {
				A[p] ^= A[row]; A[row] ^= A[p]; A[p] ^= A[row];
				list.add(new Pair(p,row));
				list.add(new Pair(row,p));
				list.add(new Pair(p,row));
			}
			for (int i = row+1; i < n; ++ i) {
				if ((A[i]&-A[i]) == mx) {
					A[i] ^= A[row];
					list.add(new Pair(i,row));
				}
			}
			++ row;
		}
	}

	class Pair {
		int a,b;
		Pair(int a,int b) {
			this.a = a;
			this.b = b;
		}
	}
}

class InputReader {
	public BufferedReader reader;
	public StringTokenizer tokenizer;
	public InputReader(InputStream stream) {
		reader = new BufferedReader(new InputStreamReader(stream),32768);
		tokenizer = null;
	}
	public String next() {
		while (tokenizer==null || !tokenizer.hasMoreTokens()) {
			try {
				tokenizer = new StringTokenizer(reader.readLine());
			} catch(IOException e) {
				throw new RuntimeException(e);
			}
		}
		return tokenizer.nextToken();
	}
	public int nextInt() {
		return Integer.parseInt(next());
	}
}