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.beans.PropertyEditorManager;
import java.io.*;
import java.util.*;

public class Main {

    private static List<Integer> prime;

    public static void main(String[] args) throws IOException {
        Reader in = new Reader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

//        init();

        int n, k;
        n = in.nextInt();
        k = in.nextInt();
        int[] a = new int[n];
        for (int i = 0; i < n; i++) {
            int now = in.nextInt();
            a[i] = gcd(k, now);
        }

        int lcm = a[0];
        for (int i = 1; i < n; i++) {
            int g = gcd(lcm, a[i]);
            lcm *= a[i] / g;

            if (lcm >= k) break;
        }

        out.println((lcm >= k) ? "Yes" : "No");

        out.flush();
        in.close();
        out.close();
    }

    private static int gcd(int a, int b) {
        int c = a % b;
        while (c != 0) {
            a = b;
            b = c;
            c = a % b;
        }
        return b;
    }

    private static Set<Integer> getPrime(int x) {
        Set<Integer> result = new HashSet<>();
        for (int now : prime) {
            if (x % now == 0) {
                result.add(now);
            }
        }
        return result;
    }

    private static void init() {
        prime = new ArrayList<>();
        boolean[] notPrime = new boolean[1000000];
        for (int i = 2; i < 1000000; i++) {
            if (notPrime[i]) continue;

            prime.add(i);

            if (i >= 1000) continue;
            for (int j = i * i; j < 1000000; j += i) {
                notPrime[j] = true;
            }
        }
    }

    static class Reader {
        BufferedReader reader;
        StringTokenizer st;

        Reader(InputStreamReader stream) {
            reader = new BufferedReader(stream);
            st = null;
        }

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

        String next() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return st.nextToken();
        }

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

        String nextLine() throws IOException {
            return reader.readLine();
        }

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

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

    }
}