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 Main
{
    static class FastReader 
    { 
        BufferedReader br; 
        StringTokenizer st; 
  
        public FastReader() 
        { 
            br = new BufferedReader(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()); 
        } 
  
        String nextLine() 
        { 
            String str = ""; 
            try
            { 
                str = br.readLine(); 
            } 
            catch (IOException e) 
            { 
                e.printStackTrace(); 
            } 
            return str; 
        } 
    }
    static class DSU
    {
        HashMap<Integer,HashMap<Integer,Integer>> c=new HashMap<>();
        int par[],rank[];
        DSU(int n,int clas[])
        {
            par=new int[n];
            rank=new int[n];
            for(int i=1;i<n;i++)
            par[i]=i;
            for(int i=1;i<n;i++)
            {
                HashMap<Integer,Integer> hmap=new HashMap<>();
                hmap.put(clas[i],1);
                c.put(i,hmap);
                //c.put(i,new HashMap<Integer,Integer>());
                //c.get(i).put(clas[i],c.get(i).getOrDefault(clas[i],0)+1);
            }
        }
        public int find(int p)
        {
            if(par[p]==p)
            return p;
            return par[p]=find(par[p]);
        }
        public void union(int a,int b)
        {
            if(a>b)
            {
                int temp=a;
                a=b;
                b=temp;
            }
            int x=find(a);
            int y=find(b);
            if(x==y)
            return;
            if(rank[x]<rank[y])
            {
                par[x]=y;
                HashMap<Integer,Integer> hmap=c.get(y);
                for(Map.Entry<Integer,Integer> me:c.get(x).entrySet())
                {
                    if(hmap.containsKey(me.getKey()))
                    hmap.put(me.getKey(),hmap.getOrDefault(me.getKey(),0)+me.getValue());
                    else
                    hmap.put(me.getKey(),me.getValue());
                    //hmap.put(me.getKey(),hmap.getOrDefault(me.getKey(),0)+me.getValue());
                }
                c.put(y,hmap);
                c.remove(x);
            }
            else
            {
                par[y]=x;
                rank[x]++;
                HashMap<Integer,Integer> hmap=c.get(x);
                for(Map.Entry<Integer,Integer> me:c.get(y).entrySet())
                {
                    if(hmap.containsKey(me.getKey()))
                    hmap.put(me.getKey(),hmap.getOrDefault(me.getKey(),0)+me.getValue());
                    else
                    hmap.put(me.getKey(),me.getValue());
                }
                c.put(x,hmap);
                c.remove(y);
            }
        }
        public int query(int x,int y)
        {
            int p=find(x);
            return c.get(p).getOrDefault(y,0);
        }
    }
    public static void main(String args[])
    {
        FastReader fs=new FastReader();
        PrintWriter pw=new PrintWriter(System.out);
        int t=1;//fs.nextInt();
        int mx=(int)1e6+1;
        while(t-->0)
        {
            int n=fs.nextInt();
            int k=fs.nextInt();
            int cnt[]=new int[mx];
            int gp[]=new int[mx];
            for(int i=2;i<mx;i++)
            {
                if(gp[i]==0)
                {
                    for(int j=i;j<mx;j+=i)
                    gp[j]=i;
                }
            }
            boolean yes=false;
            for(int i=0;i<n;i++)
            {
                int temp=fs.nextInt();
                while(temp>1)
                {
                    int g=gp[temp],c=0;
                    while(temp%g==0)
                    {
                        c++;
                        temp/=g;
                    }
                    cnt[g]=Math.max(cnt[g],c);
                }
            }
            boolean ok=true;
            while(k>1)
            {
                int g=gp[k],c=0;
                while(k%g==0)
                {
                    c++;
                    k/=g;
                }
                if(c>cnt[g])
                ok=false;
            }
            pw.println(ok?"Yes":"No");
        }
        pw.flush();
        pw.close();
    }
}