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.BigDecimal;
import java.math.BigInteger;
import java.math.MathContext;
import java.util.*;

public class Template implements Runnable {

    BufferedReader in;
    PrintWriter out;
    StringTokenizer tok = new StringTokenizer("");

    void init() throws FileNotFoundException {
        try {
            in = new BufferedReader(new FileReader("input.txt"));
            out = new PrintWriter("output.txt");
        } catch (Exception e) {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
        }
    }

    String readString() throws IOException {
        while (!tok.hasMoreTokens()) {
            try {
                tok = new StringTokenizer(in.readLine(), " :");
            } catch (Exception e) {
                return null;
            }
        }
        return tok.nextToken();
    }

    int readInt() throws IOException {
        return Integer.parseInt(readString());
    }

    int[] readIntArray(int size) throws IOException {
        int[] res = new int[size];
        for (int i = 0; i < size; i++) {
            res[i] = readInt();
        }
        return res;
    }

    long readLong() throws IOException {
        return Long.parseLong(readString());
    }

    double readDouble() throws IOException {
        return Double.parseDouble(readString());
    }

    <T> List<T>[] createGraphList(int size) {
        List<T>[] list = new List[size];
        for (int i = 0; i < size; i++) {
            list[i] = new ArrayList<>();
        }
        return list;
    }

    public static void main(String[] args) {
        new Thread(null, new Template(), "", 1l * 200 * 1024 * 1024).start();
    }

    long timeBegin, timeEnd;

    void time() {
        timeEnd = System.currentTimeMillis();
        System.err.println("Time = " + (timeEnd - timeBegin));
    }

    long memoryTotal, memoryFree;

    void memory() {
        memoryFree = Runtime.getRuntime().freeMemory();
        System.err.println("Memory = " + ((memoryTotal - memoryFree) >> 10)
                + " KB");
    }

    public void run() {
        try {
            timeBegin = System.currentTimeMillis();
            memoryTotal = Runtime.getRuntime().freeMemory();
            init();
            solve();
            out.close();
            if (System.getProperty("ONLINE_JUDGE") == null) {
                time();
                memory();
            }
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(-1);
        }
    }

    long gcd(long x, long y) {
        if (x == 0) return y;
        return gcd(y % x, x);
    }

    void solve() throws IOException {
        int n = readInt();
        int k = readInt();

        int[] a = readIntArray(n);

        long lcm = 1;


        for (int x : a) {
            if (x % k == 0) {
                out.println("Yes");
                return;
            }

            long g = gcd(x, lcm);
            lcm = ((lcm * x) / g);
            lcm = gcd(lcm, k);
        }

        if (lcm % k == 0) {
            out.println("Yes");
        } else {
            out.println("No");
        }

    }

    static final class LongIntHashMap {
        final static class Entry {
            final long key;
            int value;
            Entry next;

            Entry(long key, int value, Entry next) {
                this.key = key;
                this.value = value;
                this.next = next;
            }
        }

        private Entry[] table;
        private int capacity;
        private int threshold;
        private int size;

        public LongIntHashMap() {
            this(16);
        }

        @SuppressWarnings("unchecked")
        public LongIntHashMap(int capacity) {
            this.capacity = capacity;
            this.threshold = capacity * 4 / 3;
            this.table = new Entry[capacity];
        }

        public boolean containsKey(long key) {
            final int index = ((((int) (key >>> 32)) ^ ((int) (key))) & 0x7fffffff) % capacity;

            for (Entry entry = table[index]; entry != null; entry = entry.next) {
                if (entry.key == key) {
                    return true;
                }
            }
            return false;
        }

        public int get(long key) {
            final int index = ((((int) (key >>> 32)) ^ ((int) (key))) & 0x7fffffff) % capacity;
            for (Entry entry = table[index]; entry != null; entry = entry.next) {
                if (entry.key == key) {
                    return entry.value;
                }
            }
            return 0;
        }

        public int put(long key, int value) {
            final int index = ((((int) (key >>> 32)) ^ ((int) (key))) & 0x7fffffff) % capacity;
            final Entry entryOriginal = table[index];
            for (Entry entry = entryOriginal; entry != null; entry = entry.next) {
                if (entry.key == key) {
                    int oldValue = entry.value;
                    entry.value = value;
                    return oldValue;
                }
            }
            table[index] = new Entry(key, value, entryOriginal);
            size++;
            if (size > threshold) {
                setCapacity(2 * capacity);
            }
            return 0;
        }

        public int remove(long key) {
            int index = ((((int) (key >>> 32)) ^ ((int) (key))) & 0x7fffffff) % capacity;
            Entry previous = null;
            Entry entry = table[index];
            while (entry != null) {
                Entry next = entry.next;
                if (entry.key == key) {
                    if (previous == null) {
                        table[index] = next;
                    } else {
                        previous.next = next;
                    }
                    size--;
                    return entry.value;
                }
                previous = entry;
                entry = next;
            }
            return 0;
        }

        long[] getKeys() {
            long[] arr = new long[size()];
            int index = 0;
            for (int i = 0; i < table.length; i++) {
                Entry e = table[i];
                while (e != null) {
                    arr[index++] = e.key;
                    e = e.next;
                }
            }
            return arr;
        }

        public void clear() {
            size = 0;
            Arrays.fill(table, null);
        }

        public int size() {
            return size;
        }

        public void setCapacity(int newCapacity) {
            @SuppressWarnings("unchecked")
            Entry[] newTable = new Entry[newCapacity];
            int length = table.length;
            for (int i = 0; i < length; i++) {
                Entry entry = table[i];
                while (entry != null) {
                    long key = entry.key;
                    int index = ((((int) (key >>> 32)) ^ ((int) (key))) & 0x7fffffff) % newCapacity;

                    Entry originalNext = entry.next;
                    entry.next = newTable[index];
                    newTable[index] = entry;
                    entry = originalNext;
                }
            }
            table = newTable;
            capacity = newCapacity;
            threshold = newCapacity * 4 / 3;
        }

        /**
         * Target load: 0,6
         */
        public void reserveRoom(int entryCount) {
            setCapacity(entryCount * 5 / 3);
        }

    }

}