Problem: Today Pari and Arya are playing a game called Remainders.

Pari chooses two positive integer x and k, and tells Arya k but not x. Arya have to find the value <image>. There are n ancient numbers c1, c2, ..., cn and Pari has to tell Arya <image> if Arya wants. Given k and the ancient values, tell us if Arya has a winning strategy independent of value of x or not. Formally, is it true that Arya can understand the value <image> for any positive integer x?

Note, that <image> means the remainder of x after dividing it by y.

Input

The first line of the input contains two integers n and k (1 ≤ n, k ≤ 1 000 000) — the number of ancient integers and value k that is chosen by Pari.

The second line contains n integers c1, c2, ..., cn (1 ≤ ci ≤ 1 000 000).

Output

Print "Yes" (without quotes) if Arya has a winning strategy independent of value of x, or "No" (without quotes) otherwise.

Examples

Input

4 5
2 3 5 12


Output

Yes


Input

2 7
2 3


Output

No

Note

In the first sample, Arya can understand <image> because 5 is one of the ancient numbers.

In the second sample, Arya can't be sure what <image> is. For example 1 and 7 have the same remainders after dividing by 2 and 3, but they differ in remainders after dividing by 7.

Solution (in JAVA):

Solution:
import java.io.BufferedReader;
import java.io.Closeable;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.Map;

public class I {
	private static final int MAX = 1000_001;

	public static void main(String[] args) throws IOException {
		try (FastScanner s = new FastScanner()) {
			final int n = s.nextInt();
			final int k = s.nextInt();
			final int[] c = new int[n];
			for (int i = 0; i < n; ++i) {
				c[i] = s.nextInt();
			}
			int[] sieve = new int[MAX];
			for (int i = 2; i < MAX; ++i) {
				if (sieve[i] == 0) {
					for (int j = i; j < MAX; j += i) {
						sieve[j] = i;
					}
				}
			}
			Map<Integer, Integer> lcm = new HashMap<>();
			for (int i = 0; i < n; ++i) {
				int t = c[i];
				while(sieve[t] > 0) {
					int p = sieve[t];
					int count = 0;
					while(t%p == 0) {
						t /= p;
						count += 1;
					}
					max(lcm, p, count);
				}
			}
			boolean res = true;
			int t = k;
			while (sieve[t] > 0) {
				int p = sieve[t];
				int count = 0;
				while(t%p == 0) {
					t /= p;
					count += 1;
				}
				Integer l = lcm.get(p);
				if (l == null || l < count) {
					res = false;
					break;
				}
			}
			System.out.println(res ? "Yes" : "No");
		}
	}

	private static Map<Integer, Integer> max(Map<Integer, Integer> map, int key, int value) {
		if (map.containsKey(key)) {
			map.put(key, Math.max(map.get(key), value));
		} else {
			map.put(key, value);
		}
		return map;
	}

	private static final class FastScanner implements Closeable {
		private final BufferedReader reader;
		private String[] tokens;
		private int next;
		
		FastScanner() {
			reader = new BufferedReader(new InputStreamReader(System.in));
		}
		
		String next() throws IOException {
			if (tokens == null || next == tokens.length) {
				tokens = reader.readLine().split(" ");
				next = 0;
			}
			return tokens[next++];
		}
		
		int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		public void close() throws IOException {
			reader.close();
		}
	}
}