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

public class Remainders_Game {
    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        String[] temp = in.readLine().split(" ");
        int n = Integer.parseInt(temp[0]);
        int k = Integer.parseInt(temp[1]);

        int[] c = new int[n];
        int maxCoins = k;
        temp = in.readLine().split(" ");
        for (int i = 0; i < n; i++) {
            c[i] = Integer.parseInt(temp[i]);
            maxCoins = Math.max(maxCoins, c[i]);
        }

        boolean[] non_prime = new boolean[maxCoins + 1];
        int[] maxDivisiblePrime = new int[maxCoins + 1];
        non_prime[0] = true;
        non_prime[1] = true;
        for (long i = 2; i <= maxCoins; i++) {
            if (!non_prime[(int) i]) {
                for (long j = i * i; j <= maxCoins; j += i) {
                    non_prime[(int) j] = true;
                    maxDivisiblePrime[(int) j] = (int) i;
                }
                maxDivisiblePrime[(int) i] = (int) i;
            }
        }


        HashMap<Integer, Integer> primeFactors = new HashMap<>();
        int prime, primePower;
        for (int i = 0; i < n; i++) {
            while (c[i] > 1) {

                prime = maxDivisiblePrime[c[i]];
                primePower = 0;
                while (c[i] > 1 && c[i] % prime == 0) {
                    c[i] /= prime;
                    primePower++;
                }

                if (primeFactors.containsKey(prime)) {
                    primeFactors.put(prime, Math.max(primePower, primeFactors.get(prime)));
                } else {
                    primeFactors.put(prime, primePower);
                }
            }
        }

        boolean possible = true;
        while (k > 1) {

            prime = maxDivisiblePrime[k];
            primePower = 0;
            while (k > 1 && k % prime == 0) {
                k /= prime;
                primePower++;
            }

            if (primeFactors.containsKey(prime)) {
                if (primeFactors.get(prime) < primePower) {
                    possible = false;
                    break;
                }
            } else {
                possible = false;
                break;
            }

        }

        if (possible) {
            System.out.println("Yes");
        } else {
            System.out.println("No");
        }
    }
}