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.util.List;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.ArrayList;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.math.BigInteger;
import java.util.Collections;
import java.util.Collection;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author AlexFetisov
 */
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);
		TaskF solver = new TaskF();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskF {
    public void solve(int testNumber, InputReader in, PrintWriter out) {
        int n = in.nextInt();
        int[] x = Utils.readIntArray(in, n);
        int[] y = Utils.readIntArray(in, n);

        List<Operation> operX = getOperations(x);
        List<Operation> operY = getOperations(y);
        Collections.reverse(operY);

        List<Operation> middle = doMagic(x, y);
        if (middle == null) {
            out.println(-1);
            return;
        }
        operX.addAll(middle);
        operX.addAll(operY);
        out.println(operX.size());
        for (Operation o : operX) {
            out.println((o.what + 1) + " " + (o.withWhat + 1));
        }
    }

    private List<Operation> doMagic(int[] x, int[] y) {
        int ptrX = 0;
        int ptrY = 0;
        List<Operation> operations = new ArrayList<Operation>();

        while (ptrY < y.length && y[ptrY] != 0) {
            int smallestBit = Integer.numberOfTrailingZeros(y[ptrY]);
            while (ptrX < x.length && Integer.numberOfTrailingZeros(x[ptrX]) != smallestBit) {
                ++ptrX;
            }
            if (ptrX == x.length) return null;
            if (ptrX > ptrY) {
                operations.add(new Operation(ptrX, ptrY));
                operations.add(new Operation(ptrY, ptrX));
                operations.add(new Operation(ptrX, ptrY));

                int temp = x[ptrX];
                x[ptrX] = x[ptrY];
                x[ptrY] = temp;
            }

            for (int i = ptrX + 1; i < x.length && x[i] != 0; ++i) {
                if (BitUtils.checkBit(y[ptrY], Integer.numberOfTrailingZeros(x[i]))) {
                    operations.add(new Operation(ptrY, i));
                    x[ptrY] ^= x[i];
                }
            }
            if (x[ptrY] != y[ptrY]) return null;
            ++ptrY;
        }

        for (int i = 0; i < x.length; ++i) {
            if (x[i] != 0 && y[i] == 0) {
                operations.add(new Operation(i, i));
                x[i] = 0;
            }
        }

        if (!Arrays.equals(x, y)) {
            return null;
            //throw new AssertionError("!");
        }
        return operations;
    }

    private List<Operation> getOperations(int[] x) {
        List<Operation> operations = new ArrayList<Operation>();

        int lines = 0;
        int n = x.length;
        for (int bit = 0; bit < 31; ++bit) {
            int j = lines;
            while (j < n && !BitUtils.checkBit(x[j], bit)) ++j;

            if (j == n) {
                continue;
            }

            if (lines != j) {
                operations.add(new Operation(lines, j));
                operations.add(new Operation(j, lines));
                operations.add(new Operation(lines, j));

                int temp = x[lines];
                x[lines] = x[j];
                x[j] = temp;
            }
            for (int k = 0; k < n; ++k) {
                if (k == lines) continue;
                if (BitUtils.checkBit(x[k], bit)) {
                    operations.add(new Operation(k, lines));
                    x[k] ^= x[lines];
                }
            }
            ++lines;
        }
        return operations;
    }

    class Operation {
        int what;
        int withWhat;

        Operation(int what, int withWhat) {
            this.what = what;
            this.withWhat = withWhat;
        }
    }
}

class InputReader {
    private BufferedReader reader;
    private StringTokenizer stt;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream));
    }

    public String nextLine() {
        try {
            return reader.readLine().trim();
        } catch (IOException e) {
            return null;
        }
    }

    public String nextString() {
        while (stt == null || !stt.hasMoreTokens()) {
            stt = new StringTokenizer(nextLine());
        }
        return stt.nextToken();
    }

    public int nextInt() {
        return Integer.parseInt(nextString());
    }

}

class Utils {
    public static int[] readIntArray(InputReader in, int n) {
        int[] a = new int[n];
        for (int i = 0; i < n; ++i) {
            a[i] = in.nextInt();
        }
        return a;
    }

}

class BitUtils {
    public static boolean checkBit(int mask, int bit) {
        return (mask & (1 << bit)) > 0;
    }

}