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.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

/**
 * @author Don Li
 */
public class AntonSchool {
    void solve() {
        int n = in.nextInt();
        long[] b = new long[n], c = new long[n];
        for (int i = 0; i < n; i++) b[i] = in.nextInt();
        for (int i = 0; i < n; i++) c[i] = in.nextInt();
        
        long[] d = new long[n];
        for (int i = 0; i < n; i++) d[i] = b[i] + c[i];
        
        long sum = 0;
        for (int i = 0; i < n; i++) sum += d[i];
        sum /= 2 * n;
        
        long[] a = new long[n];
        for (int i = 0; i < n; i++) a[i] = (d[i] - sum) / n;
        
        int[] bc = new int[31];
        int[][] bit = new int[31][n];
        for (int i = 0; i < 31; i++) {
            for (int j = 0; j < n; j++) {
                if (a[j] < 0) {
                    out.println(-1);
                    return;
                }
                if ((a[j] & (1 << i)) > 0) {
                    bc[i]++;
                    bit[i][j] = 1;
                }
            }
        }
        
        long[] b1 = new long[n], c1 = new long[n];
        for (int i = 0; i < 31; i++) {
            for (int j = 0; j < n; j++) {
                if (bit[i][j] == 0) {
                    c1[j] += bc[i] << i;
                } else {
                    b1[j] += bc[i] << i;
                    c1[j] += n << i;
                }
            }
        }
        
        for (int i = 0; i < n; i++) {
            if (b[i] != b1[i] || c[i] != c1[i]) {
                out.println(-1);
                return;
            }
        }
        
        for (int i = 0; i < n; i++) {
            if (i > 0) out.print(' ');
            out.print(a[i]);
        }
    }
    
    public static void main(String[] args) {
        in = new FastScanner(new BufferedReader(new InputStreamReader(System.in)));
        out = new PrintWriter(System.out);
        new AntonSchool().solve();
        out.close();
    }
    
    static FastScanner in;
    static PrintWriter out;
    
    static class FastScanner {
        BufferedReader in;
        StringTokenizer st;
        
        public FastScanner(BufferedReader in) {
            this.in = in;
        }
        
        public String nextToken() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(in.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }
        
        public int nextInt() {
            return Integer.parseInt(nextToken());
        }
        
        public long nextLong() {
            return Long.parseLong(nextToken());
        }
        
        public double nextDouble() {
            return Double.parseDouble(nextToken());
        }
    }
}
