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:
/**
 * @author godmar
 */
import java.util.*;
import java.io.*;

public class Remainders
{
    static int gcd(int a, int b) { return b==0 ? a : gcd(b, a%b); }

    @SuppressWarnings("unchecked")
    public static void main(String []av) {
        Scanner s = new Scanner();
        int n = s.nextInt();
        int k = s.nextInt();
        int [] primes = generatePrimes(k);
        List<Integer> lpf = factor(primes, k);
        Map<Integer, Integer> pf = new HashMap<>();
        for (Integer p : lpf) {
            if (pf.containsKey(p)) {
                pf.put(p, pf.get(p) * p);
            } else {
                pf.put(p, p);
            }
        }
        //System.err.println(pf);
        List<Integer> pp = new ArrayList<>(pf.values());
        //System.err.println(pp);

        boolean [] figured = new boolean[pp.size()];
        int left = pp.size();
        for (int i = 0; i < n; i++) {
            int c = s.nextInt();
            if (c % k == 0) {
                System.out.println("Yes");
                return;
            }
            int g = gcd(c, k);
            if (g == 1) // no information
                continue;

            // if we ask for x mod c, we can compute x mod g
            // and are left with k/g choices.
            for (int j = 0; j < pp.size(); j++) {
                // do I have this pp figured out?
                int p = pp.get(j);
                if (g % p == 0) {
                    if (!figured[j]) {
                        figured[j] = true;
                        left--;
                        if (left == 0) {
                            System.out.println("Yes");
                            return;
                        }
                    }
                }
            }
        }
        System.out.println("No");
    }

    //-----------Scanner class for faster input----------
    /* Provides similar API as java.util.Scanner but does not
     * use regular expression engine.  
     */
    public static class Scanner {
        BufferedReader br;
        StringTokenizer st;

        public Scanner(Reader in) {
            br = new BufferedReader(in);
        }

        public Scanner() { this(new InputStreamReader(System.in)); }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() { return Integer.parseInt(next()); }
        long nextLong() { return Long.parseLong(next()); }
        double nextDouble() { return Double.parseDouble(next()); }

        // Slightly different from java.util.Scanner.nextLine(),
        // which returns any remaining characters in current line,
        // if any.  
        String readNextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }
    //--------------------------------------------------------    
    //
    /* returns boolean array a[] such that a[p] == true iff p is prime. */
    static boolean [] sieve(int N) {
        boolean [] a = new boolean[N+1];
        Arrays.fill(a, true);
        a[0] = a[1] = false;
        for (int p = 2; p * p <= N; p++) 
            if (a[p]) {
                // Iterate through all multiples m of the prime and mark 
                // them as not prime.
                for (int m = p * p; m <= N; m += p)
                    a[m] = false;
            }
        return a;
    }

    /* generate all prime numbers from 2..N, inclusive */
    static int [] generatePrimes(int N) {
        List<Integer> primes = new ArrayList<Integer>();
        boolean [] isPrime = sieve(N);
        for (int i = 0; i <= N; i++)
            if (isPrime[i])
                primes.add(i);
        int [] pa = new int[primes.size()];
        for (int i = 0; i < pa.length; i++)
            pa[i] = primes.get(i);
        return pa;
    }

    /*
     * P - list of primes
     * n - number to factor
     * @return list of prime factors, e.g. n = 100 returns [2, 2, 5, 5]
     */
    static List<Integer> factor(int []P, int n) {
        List<Integer> result = new ArrayList<Integer>();
        for (int i = 0; i < P.length; i++) {
            int p = P[i];
            if (p * p > n) break;
            while (n % p == 0) {
                result.add(p);
                n /= p;
            }
        }
        if (n != 1) // large prime remainder
            result.add(n);

        return result;
    }
}