2 1
1 1
 4 1
2 2 1 1
 10 1
2 6 3 4 2 4 4 3 2 1
 2 1
999152 999153
 8 1000000
1 1 5 1000000 1000000 2 2 2
 9 2
1 6 1 5 5 8 6 8 7
 15 1
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
 1 4
8
 10 1
6 3 1 3 6 4 1 3 6 4
 10 1
1 2 3 5 6 8 10 11 9 4
 7 2
1 5 5 8 9 8 8
 2 1000000
1 1000000
 8 2
3 13 9 8 3 13 9 14
 1 1
1
 2 1
1 2

2
 2
 4
 1
 2
 4
 15
 1
 7
 2
 4
 1
 5
 1
 1

import java.io.*;
import java.util.*;

import javafx.util.Pair;
 
public class Solution {
	public final static int MOD = 1000000007;
	public static int count = 0;
	public static int dx[] = {0,0,1,-1};
	public static int dy[] = {1,-1,0,0};
	public static int max = 0;
	public static boolean flag;
	public static int m,n,h,k,cost[][];
	public static char arr[][];
	public static LinkedList<Integer> adj[];
	@SuppressWarnings({ "unchecked", "resource" })
	public static void main(String[] args) throws IOException {
		InputReader scan = new InputReader(System.in);
	   	OutputStream outputStream = System.out;
	   	PrintWriter pw = new PrintWriter(outputStream);
	   	StringBuilder sb = new StringBuilder();
	   	int n = scan.nextInt();
	   	int k = scan.nextInt();
	   	ArrayList<Integer> arr = new ArrayList<>();
	   	for(int i=0;i<n;i++)
	   		arr.add(scan.nextInt());
	   	Collections.sort(arr);
	   	int count = n;
	   	int dup = 1;
	   	for(int i=1;i<n;i++)
	   	{
	   		if(arr.get(i)>arr.get(i-1) && arr.get(i)<=(arr.get(i-1)+k)){
	   			count-=dup;
	   			dup = 1;	
	   		}
	   		else if(arr.get(i)==arr.get(i-1))
	   			dup++;
	   	}
	   	pw.println(count);
	   	pw.close(); 
	}
	public static int[][] graph(int from[],int to[],int m,int n)
	{
		int[][] g = new int[n+1][];
		int count[] = new int[n+1];
		Arrays.fill(count, 0);
		for(int i=0;i<m;i++)
		{
			count[from[i]]++;
			count[to[i]]++;
		}
		for(int i=0;i<n+1;i++)
			g[i] = new int[count[i]];
		Arrays.fill(count, 0);
		for(int i=0;i<m;i++)
		{
			g[from[i]][count[from[i]]++] = to[i];
			g[to[i]][count[to[i]]++] = from[i];
		}
		return g;
	}
	public static int binarySearch(ArrayList<Integer> arr,int key)
	{
		int l = 0, r = arr.size()-1;
		while(l<=r)
		{
			int mid = (l+r)/2;
			if(arr.get(mid)==key)
			{
				r = mid;
				break;
			}
			if(arr.get(mid)>key)
				r = mid-1; 
			else
				l = mid+1;
		}
		return r;
	}
	public static void inOrder(int i,int arr[],int n,ArrayList<Integer> ans)
	{
		if(i<n)
		{
			inOrder(2*i+1,arr,n,ans);
			ans.add(arr[i]);
			inOrder(2*i+2,arr,n,ans);
		}
	}
	public static int find(int x,int parent[])
	{
		if(parent[x]!=x)
			parent[x] = find(parent[x],parent);
		return parent[x];
	}
	public static void union(int parent[],int x,int y)
	{
		int xParent = find(x,parent);
		int yParent = find(y,parent);
		parent[xParent] = yParent;
	}
	public static int dfs(int x,int parent,int[][] g)
	{
		int count = 1;
		for(int i=0;i<g[x].length;i++)
		{
			int temp = g[x][i];
			if(temp!=parent){
				int t = dfs(temp,x,g);
				count+=t;
				if(t%2==0)
					max++;
			}
		}
		return count;
	}
	public static void buildTree(int arr[],int tree[],int node,int start,int end)
	{
		if(start==end)
		{
			tree[node] = arr[start];
			return;
		}
		int mid = (start+end)/2;
		buildTree(arr,tree,2*node,start,mid);
		buildTree(arr,tree,2*node+1,mid+1,end);
		tree[node] = tree[2*node]+tree[2*node+1];
	}
	public static void update(int arr[],int tree[],int node,int inx,int val,int start,int end)
	{ 
		if(start==end)
		{
			tree[node] = val;
			arr[inx] = val;
			return;
		}
		int mid = (start+end)/2;
		if(inx<=mid)
			update(arr,tree,2*node,inx,val,start,mid);
		else
			update(arr,tree,2*node+1,inx,val,mid+1,end);
		tree[node] = tree[2*node]+tree[2*node+1];
	}
	public static int query(int tree[],int node,int l,int r,int start,int end)
	{
		if(r<start || l>end)
			return 0;
		if(l<=start && end<=r)
			return tree[node];
		int mid = (start+end)/2;
		int ans1 = query(tree,2*node,l,r,start,mid);
		int ans2 = query(tree,2*node+1,l,r,mid+1,end);
		return ans1+ans2;
	}
	public static void merge(int arr[],int start,int mid,int end)
	{
		int l = start, r = mid+1;
		int temp[] = new int[end-start+1];
		int k = 0;
		for(int i=start;i<=end;i++)
		{
			if(l>mid)
				temp[k++] = arr[r++];
			else if(r>end)
				temp[k++] = arr[l++];
			else if(arr[l]<=arr[r])
				temp[k++] = arr[l++];
			else{
				temp[k++] = arr[r++];
				count+=(mid-l+1);
			}
		}
		for(int i=0;i<k;i++)
			arr[start++] = temp[i];
	}
	public static void mergeSort(int arr[],int l,int r)
	{
		if(l<r){
			int mid = (l+r)/2;
			mergeSort(arr,l,mid);
			mergeSort(arr,mid+1,r);
			merge(arr,l,mid,r);
		}
	}
	public static void sieve(int spf[],int n)
	{
		for(int i=1;i<=n;i++)
			spf[i] = i;
		for(int i=2;i*i<=n;i++)
		{
			if(spf[i]==i)
			{
				for(int j=i;j<=n;j+=i)
					if(spf[j]==j)
						spf[j] = i;
			}
		}
	}
	public static void factors(int n,int spf[],ArrayList<Integer> factors)
	{
		int pre = 0;
		while(n!=1)
		{
			int temp = spf[n];
			if(temp!=pre)
			{
				factors.add(temp);
				pre = temp;
			}
			n/=temp;
		}
	}
	public static boolean isPrime(int n)
	{
		if(n==0 || n==1)
			return false;
		int limit = (int)Math.sqrt(n);
		for(int i=2;i<=limit;i++)
		{
			if(n%i==0)
				return false;
		}
		return true;
	}
	public static long pow(long a,long b,int m)
	{
		long result = 1;
		while(b>0)
		{
			if(b%2==1)
				result = ((result%m)*(a%m))%m;
			a = ((a%m)*(a%m))%m;
			b/=2;
		}
		return result;
	}
	public static long mulinv(long a,long m)
	{
		long arr[] = new long[2];
		long gcd = gcdExtended(a,m,arr);
		if(gcd==1)
			return (arr[0]%m+m)%m;
		else
			return Integer.MAX_VALUE;
	}
	public static long gcdExtended(long a,long b,long arr[])
	{
		if (a == 0)
	    {
	        arr[0] = 0;
	        arr[1] = 1;
	        return b;
	    }
	    long gcd = gcdExtended(b%a, a, arr);
	    long temp = arr[0];
	    arr[0] = arr[1] - (b/a) * arr[0];
	    arr[1] = temp;
	    return gcd;
	}
	public static long kadane(int items[])
	{
		int n = items.length;
		long max = (long)items[0];
		long curr_max = (long)items[0];
		for(int i=1;i<n;i++)
		{
			curr_max = Math.max((long)curr_max+items[i], items[i]);
			max = Math.max(max, curr_max);
		}
		return max;
	}
	public static int gcd(int a,int b)
	{
		if(b==0)
			return a;
		return gcd(b,a%b);
	}
	public static int LCS(String s1,String s2) //Longest common subsequence
		{
			int n = s1.length();
			int m = s2.length();
			int lcs[][] = new int[n+1][m+1];
			for(int i=0;i<=n;i++)
			{
				for(int j=0;j<=m;j++)
				{
					if(i==0 || j==0)
						lcs[i][j] = 0;
					else if(s1.charAt(i-1)==s2.charAt(j-1))
						lcs[i][j] = lcs[i-1][j-1] + 1;
					else
						lcs[i][j] = Math.max(lcs[i][j-1], lcs[i-1][j]);
				}
			}
			return lcs[n][m];
		}
		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;
	        }
	    }
	}
class InputReader {
    public BufferedReader reader;
	public StringTokenizer tokenizer;
    public InputReader(InputStream inputstream) {
        reader = new BufferedReader(new InputStreamReader(inputstream));
		tokenizer = null;
	}
    public String nextLine(){
        String fullLine=null;
		while (tokenizer == null || !tokenizer.hasMoreTokens()) {
		    try {
		        fullLine=reader.readLine();
		    } catch (IOException e) {
    			throw new RuntimeException(e);
    			}
        		return fullLine;
        }
		return fullLine;
	}
    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
    			tokenizer = new StringTokenizer(reader.readLine());
    		} catch (IOException e) {
        		throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }
    public long nextLong() {
        return Long.parseLong(next());
	}
	public int nextInt() {
		return Integer.parseInt(next());
	}
}
class pair extends Pair<Integer,Integer>{
	int cost;
	public pair(int key, int value,int c) {
		super(key, value);
		cost = c;
		// TODO Auto-generated constructor stub
	}
}

class pairComparator implements Comparator<pair>{

	@Override
	public int compare(pair arg0, pair arg1) {
		return Integer.compare(arg0.cost, arg1.cost);
	}
	
}