Problem:
Score : 700 points

Problem Statement

Aoki is playing with a sequence of numbers a_{1}, a_{2}, ..., a_{N}. Every second, he performs the following operation :

Choose a positive integer k. For each element of the sequence v, Aoki may choose to replace v with its remainder when divided by k, or do nothing with v. The cost of this operation is 2^{k} (regardless of how many elements he changes).

Aoki wants to turn the sequence into b_{1}, b_{2}, ..., b_{N} (the order of the elements is important). Determine if it is possible for Aoki to perform this task and if yes, find the minimum cost required.

Constraints

1 \leq N \leq 50

0 \leq a_{i}, b_{i} \leq 50

All values in the input are integers.

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

Print the minimum cost required to turn the original sequence into b_{1}, b_{2}, ..., b_{N}. If the task is impossible, output -1 instead.

Sample Input 1

3
19 10 14
0 3 4

Sample Output 1

160

Here's a possible sequence of operations :

Choose k = 7. Replace 19 with 5, 10 with 3 and do nothing to 14. The sequence is now 5, 3, 14.

Choose k = 5. Replace 5 with 0, do nothing to 3 and replace 14 with 4. The sequence is now 0, 3, 4.

The total cost is 2^{7} + 2^{5} = 160.

Sample Input 2

3
19 15 14
0 0 0

Sample Output 2

2

Aoki can just choose k = 1 and turn everything into 0. The cost is 2^{1} = 2.

Sample Input 3

2
8 13
5 13

Sample Output 3

-1

The task is impossible because we can never turn 8 into 5 using the given operation.

Sample Input 4

4
2 0 1 8
2 0 1 8

Sample Output 4

0

Aoki doesn't need to do anything here. The cost is 0.

Sample Input 5

1
50
13

Sample Output 5

137438953472

Beware of overflow issues.

Solution in Java8 (OpenJDK 1.8.0) (judge verdict: Accepted)

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Queue;
import java.util.Scanner;
import java.util.Set;

public class Main {
	static int n;
	static int[] a, b;

	public static void main(String[] args) throws Exception {
		Scanner sc = new Scanner(System.in);
		n = sc.nextInt();
		a = new int[n];
		for (int i = 0; i < n; i++) {
			a[i] = sc.nextInt();
		}
		b = new int[n];
		for (int i = 0; i < n; i++) {
			b[i] = sc.nextInt();
		}
		sc.close();

		boolean[] use = new boolean[52];
		Arrays.fill(use, true);
		for (int i = 51; i > 0; i--) {
			use[i] = false;
			if (!judge(use)) {
				if (i == 51) {
					System.out.println(-1);
					return;
				}
				use[i] = true;
			}
		}

		long ans = 0;
		for (int i = 1; i < 51; i++) {
			if (use[i]) {
				ans += 1L << i;
			}
		}
		System.out.println(ans);
	}

	static boolean judge(boolean[] use) {
		List<Set<Integer>> list = new ArrayList<>(51);
		for (int i = 0; i < 51; i++) {
			list.add(new HashSet<>());
		}
		for (int i = 1; i < 51; i++) {
			for (int j = 1; j <= i; j++) {
				if (use[j]) {
					list.get(i).add(i % j);
				}
			}
		}

		for (int i = 0; i < n; i++) {
			boolean[] visit = new boolean[51];
			Queue<Integer> que = new ArrayDeque<>();
			que.add(a[i]);
			visit[a[i]] = true;
			while (!que.isEmpty()) {
				int cur = que.poll();
				for (int next : list.get(cur)) {
					if (next >= b[i] && !visit[next]) {
						que.add(next);
						visit[next] = true;
					}
				}
			}
			if (!visit[b[i]]) {
				return false;
			}
		}
		return true;
	}
}