A k-multiple free set is a set of integers where there is no pair of integers where one is equal to another integer multiplied by k. That is, there are no two integers x and y (x < y) from the set, such that y = x·k.

You're given a set of n distinct positive integers. Your task is to find the size of it's largest k-multiple free subset.

Input

The first line of the input contains two integers n and k (1 ≤ n ≤ 105, 1 ≤ k ≤ 109). The next line contains a list of n distinct positive integers a1, a2, ..., an (1 ≤ ai ≤ 109).

All the numbers in the lines are separated by single spaces.

Output

On the only line of the output print the size of the largest k-multiple free subset of {a1, a2, ..., an}.

Examples

Input

6 2
2 3 6 5 4 10


Output

3

Note

In the sample input one of the possible maximum 2-multiple free subsets is {4, 5, 6}.
import java.io.*;
import java.util.*;
import java.util.Map.Entry;

public class Main {
	
	Scanner in;
	static PrintWriter out;
	
	
	static class Scanner {
		StreamTokenizer in;
		
		Scanner(InputStream is) {
			in = new StreamTokenizer(new BufferedReader(new InputStreamReader(is)));
			in.resetSyntax();
			in.whitespaceChars(0, 32);
			in.wordChars(33, 255);
		}
		
		String readLine() {
			try {
				in.nextToken();
				asserT(in.ttype == StreamTokenizer.TT_WORD);
				return in.sval;
			} catch (IOException e) {
				throw new Error();
			}
		}
		
		int nextInt() {
			return Integer.parseInt(readLine());			
		}
	}
	
	
	
	void solve() {
		int n = in.nextInt();
		long k = in.nextInt();
		int ar[] = new int[n];
		TreeMap <Integer, Integer> nums = new TreeMap<Integer, Integer>();
		for (int i = 0; i < n; i++) {
			ar[i] = in.nextInt();
			nums.put(ar[i], i);
		}
		
		if (k == 1) {
			out.println(n);
			return;
		}
		
		int next[] = new int[n];
		Arrays.fill(next, -1);
		
		int count = 0;
		
		for (int i = 0; i < n; i++) {
			long val = ar[i] * k;
			int intVal = (int)val;
			if (intVal == val) {
				if (nums.containsKey(intVal)) {
					int idx = nums.get(intVal);
					next[i] = idx;
					continue;
				}
			}
			
			if (ar[i] % k == 0) {
				intVal = ar[i] / (int)k;
				
				if (nums.containsKey(intVal)) {
					continue;
				}
			}
			
			
			count++;
		}
		
		for (int i = 0; i < n; i++) {
			int curr = nums.pollFirstEntry().getValue();
			boolean odd = false;
			while (next[curr] != -1) {
				if (!odd) {
					count++;
				}
				int to = next[curr];
				next[curr] = -1;
				curr = to;
				odd = !odd;
				
				if (next[curr] == -1) {
					if (!odd) {
						count++;
					}
				}
			}
		}
		out.println(count);
	}
	
	static void asserT(boolean e) {
		if (!e) {
			throw new Error();
		}
	}
	
	
	public void run() {
		in = new Scanner(System.in);
		out = new PrintWriter(System.out);
		
		try {
			solve();
		} finally {
			out.close();
		}
	}
	
	public static void main(String[] args) {
		new Main().run();
	}

} 