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.*;
    import java.math.BigInteger;
    import java.util.HashMap;
    import java.util.Map;
    import java.util.StringTokenizer;

    public class RemaindersGame {
        public static class FastScanner {

            BufferedReader br;
            StringTokenizer st;

            public FastScanner(String s) {
                try {
                    br = new BufferedReader(new FileReader(s));
                } catch (FileNotFoundException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }

            public FastScanner() {
                br = new BufferedReader(new InputStreamReader(System.in));
            }

            String nextToken() {
                while (st == null || !st.hasMoreElements()) {
                    try {
                        st = new StringTokenizer(br.readLine());
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                return st.nextToken();
            }

            int nextInt() {
                return Integer.parseInt(nextToken());
            }

            long nextLong() {
                return Long.parseLong(nextToken());
            }

            double nextDouble() {
                return Double.parseDouble(nextToken());
            }
        }

        private static BigInteger gcd(BigInteger a, BigInteger b) {
            if (a.equals(BigInteger.ZERO)) {
                return b;
            }
            else {
                return gcd(b.mod(a), a);
            }
        }

        private static BigInteger lcm(BigInteger a, BigInteger b) {
            return (a.multiply(b).divide(a.gcd(b)));
        }

        private static Map<Integer, Integer> getPrimeFactorization(int number, int[] gpd) {
            Map<Integer, Integer> map = new HashMap<>();

            while (number != 1) {
                int prime = gpd[number];
                if (!map.containsKey(prime)) {
                    map.put(prime, 1);
                }
                else {
                    map.put(prime, map.get(prime) + 1);
                }

                number = number / prime;
            }

            return map;
        }

        public static void main(String[] args) {

            int maxC = 1000 * 1000 + 1;
            int[] gpd = new int[maxC];
            for (int i = 2; i < maxC; ++i) {
                if (gpd[i] == 0) {
                    gpd[i] = i;
                    for (int l = 2 * i; l < maxC; l += i) {
                        gpd[l] = i;
                    }
                }
            }


            FastScanner fs = new FastScanner();
            int n = fs.nextInt();
            int k = fs.nextInt();

            int[] a = new int[n];
            int[] primes = new int[1000 * 1000 + 1];
            for (int i = 0; i < n; ++i) {
                a[i] = fs.nextInt();

                while (a[i] != 1) {
                    int prime = gpd[a[i]];

                    int cnt = 0;
                    while (a[i] % prime == 0) {
                        a[i] /= prime;
                        cnt++;
                    }

                    primes[prime] = Math.max(primes[prime], cnt);
                }
            }

            boolean finalResult = true;
            while (k != 1) {
                int prime = gpd[k];

                int cnt = 0;
                while (k % prime == 0) {
                    k /= prime;
                    cnt++;
                }

                if (cnt > primes[prime]) {
                    finalResult = false;
                    break;
                }
            }

            System.out.println(finalResult? "Yes": "No");
        }
    }