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.util.*;
import java.io.*;
public class RemaindersGame
{

    
    /************************ SOLUTION STARTS HERE ***********************/

    static int bigPrime[];
    static final int MAX = (int)1e6;
    
    static {
	bigPrime = new int[MAX + 10];
	bigPrime[1] = 1;
	for (int i = 2; i <= MAX; i++) {
	    if (bigPrime[i] == 0) {
		bigPrime[i] = i;
		for (int j = 2 * i; j <= MAX; j += i)
		    bigPrime[j] = i;
	    }
	}
    }
    
    static HashMap<Integer, Integer> primeFactorize(int N) 
    {
	HashMap<Integer, Integer> mp = new HashMap<>();
	mp.put(1, 1);
	int ct, prime;
	while (N != 1) {
	    prime = bigPrime[N];
	    ct = 0;
	    while (N % prime == 0) {
		N /= prime;
		ct++;
	    }
	    mp.put(prime, ct);
	}
	return mp;
    }
    
    private static void solve(FastScanner s1, PrintWriter out){

	int N = s1.nextInt();
	int K = s1.nextInt();
	int arr[] = s1.nextIntArray(N);
	
	HashMap<Integer, Integer> LCM = new HashMap<>();
	for(int a:arr)
	{
	    if(LCM.size() == 0)
		LCM.putAll(primeFactorize(a));
	    else
	    {
		for (Map.Entry<Integer,Integer> e : primeFactorize(a).entrySet()) 
		{
		    int p = e.getKey();
		    int pow = e.getValue();
		    if(LCM.containsKey(p))
			LCM.replace(p, Math.max(pow,LCM.get(p)));
		    else
			LCM.put(p, pow);
		}
	    }
	}
	boolean flag = true;
	for (Map.Entry<Integer,Integer> e : primeFactorize(K).entrySet()) 
	    flag &= (LCM.containsKey(e.getKey()) && LCM.get(e.getKey()).intValue() >= e.getValue().intValue());
	
	out.println(flag ? "Yes" : "No");
    }


    
    /************************ SOLUTION ENDS HERE ************************/
    
    
    
    
    
    /************************ TEMPLATE STARTS HERE *********************/

    public static void main(String []args) throws IOException {
	FastScanner in  = new FastScanner(System.in);
	PrintWriter out = 
		new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)), false); 
	solve(in, out);
	in.close();
	out.close();
    }    

    static class FastScanner{
	BufferedReader reader;
	StringTokenizer st;
	FastScanner(InputStream stream){reader=new BufferedReader(new InputStreamReader(stream));st=null;}	
	String next()
	    {while(st == null || !st.hasMoreTokens()){try{String line = reader.readLine();if(line == null){return null;}		    
	     st = new StringTokenizer(line);}catch (Exception e){throw new RuntimeException();}}return st.nextToken();}
	String nextLine()  {String s=null;try{s=reader.readLine();}catch(IOException e){e.printStackTrace();}return s;}	    	  	
	int    nextInt()   {return Integer.parseInt(next());}
	long   nextLong()  {return Long.parseLong(next());}		
	double nextDouble(){return Double.parseDouble(next());}
	char   nextChar()  {return next().charAt(0);}
	int[]  nextIntArray(int n)         {int[] arr= new int[n];   int i=0;while(i<n){arr[i++]=nextInt();}  return arr;}
	long[] nextLongArray(int n)        {long[]arr= new long[n];  int i=0;while(i<n){arr[i++]=nextLong();} return arr;}	
	int[]  nextIntArrayOneBased(int n) {int[] arr= new int[n+1]; int i=1;while(i<=n){arr[i++]=nextInt();} return arr;}	    	
	long[] nextLongArrayOneBased(int n){long[]arr= new long[n+1];int i=1;while(i<=n){arr[i++]=nextLong();}return arr;}	    	
	void   close(){try{reader.close();}catch(IOException e){e.printStackTrace();}}				
    }

    /************************ TEMPLATE ENDS HERE ************************/
}