Anton goes to school, his favorite lessons are arraystudying. He usually solves all the tasks pretty fast, but this time the teacher gave him a complicated one: given two arrays b and c of length n, find array a, such that:

<image>

where a and b means bitwise AND, while a or b means bitwise OR.

Usually Anton is good in arraystudying, but this problem is too hard, so Anton asks you to help.

Input

The first line of the input contains a single integers n (1 ≤ n ≤ 200 000) — the size of arrays b and c.

The second line contains n integers bi (0 ≤ bi ≤ 109) — elements of the array b.

Third line contains n integers ci (0 ≤ ci ≤ 109) — elements of the array c.

Output

If there is no solution, print  - 1.

Otherwise, the only line of the output should contain n non-negative integers ai — elements of the array a. If there are multiple possible solutions, you may print any of them.

Examples

Input

4
6 8 4 4
16 22 10 10


Output

3 5 1 1 


Input

5
8 25 14 7 16
19 6 9 4 25


Output

-1
import java.io.*;
import java.util.*;
import java.util.List;

public class Template implements Runnable {

    BufferedReader in;
    PrintWriter out;
    StringTokenizer tok = new StringTokenizer("");

    void init() throws FileNotFoundException {
        try {
            in = new BufferedReader(new FileReader("input.txt"));
            out = new PrintWriter("output.txt");
        } catch (Exception e) {
            String filename = "";
            if (filename.isEmpty()) {
                in = new BufferedReader(new InputStreamReader(System.in));
                out = new PrintWriter(System.out);
            } else {
                in = new BufferedReader(new FileReader(filename + ".in"));
                out = new PrintWriter(filename + ".out");
            }
        }
    }

    String readString() throws IOException {
        while (!tok.hasMoreTokens()) {
            try {
                tok = new StringTokenizer(in.readLine());
            } catch (Exception e) {
                return null;
            }
        }
        return tok.nextToken();
    }

    int readInt() throws IOException {
        return Integer.parseInt(readString());
    }

    int[] readIntArray(int size) throws IOException {
        int[] res = new int[size];
        for (int i = 0; i < size; i++) {
            res[i] = readInt();
        }
        return res;
    }

    long readLong() throws IOException {
        return Long.parseLong(readString());
    }

    double readDouble() throws IOException {
        return Double.parseDouble(readString());
    }


    <T> List<T>[] createGraphList(int size) {
        List<T>[] list = new List[size];
        for (int i = 0; i < size; i++) {
            list[i] = new ArrayList<>();
        }
        return list;
    }

    public static void main(String[] args) {
        new Thread(null, new Template(), "", 1l * 200 * 1024 * 1024).start();
    }

    long timeBegin, timeEnd;

    void time() {
        timeEnd = System.currentTimeMillis();
        System.err.println("Time = " + (timeEnd - timeBegin));
    }

    long memoryTotal, memoryFree;

    void memory() {
        memoryFree = Runtime.getRuntime().freeMemory();
        System.err.println("Memory = " + ((memoryTotal - memoryFree) >> 10)
                + " KB");
    }

    public void run() {
        try {
            timeBegin = System.currentTimeMillis();
            memoryTotal = Runtime.getRuntime().freeMemory();
            init();
            solve();
            out.close();
            if (System.getProperty("ONLINE_JUDGE") == null) {
                time();
                memory();
            }
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(-1);
        }
    }

    void solve() throws IOException {
        int n = readInt();
        int[] b = readIntArray(n);
        int[] c = readIntArray(n);

        long sum = 0;
        for (int i = 0; i < n; i++) {
            sum += b[i] + c[i];
        }
        if (sum % (2 * n) != 0) {
            out.println(-1);
            return;
        }
        sum /= 2 * n;

        long[] a = new long[n];
        for (int i = 0; i < n; i++) {
            long x = b[i] + c[i] - sum;
            if (x >= 0 && x % n == 0) {
                a[i] = x / n;
            } else {
                out.println(-1);
                return;
            }
        }

        long[] checkB = new long[n];
        long[] checkC = new long[n];

        for (int bit = 31; bit >= 0; bit--) {
            int all = 0;
            for (int i = 0; i < n; i++) {
                if (has(a[i], bit)) all++;
            }

            for (int i = 0; i < n; i++) {
                if (has(a[i], bit)) {
                    checkC[i] += bit(bit) * n;
                    checkB[i] += bit(bit) * all;
                } else {
                    checkC[i] += bit(bit) * all;
                }
            }
        }

        for (int i = 0; i < n; i++) {
            if (checkB[i] != b[i] || checkC[i] != c[i]) {
                out.println(-1);
                return;
            }
        }

        for (long x : a) out.print(x + " ");

    }

    long bit(int bit) {
        return 1L << bit;
    }

    boolean has(long x, int bit) {
        return (x & (1 << bit)) != 0;
    }
}