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.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.InputMismatchException;
import java.util.Map;
import java.util.TreeMap;
	public class Tester {

		public static void main(String[] args) {
			 final int mod = (int) (1e9 + 7);
			 final InputReader in = new InputReader(System.in);
			 final PrintWriter out = new PrintWriter(System.out);
			 final ArrayList<Integer> arr = new ArrayList<Integer>();
			 final int n = in.nextInt();
			 final int k = in.nextInt();
			 for(int i = 0; i < n; i++) {
			     arr.add(in.nextInt());
			 }
			 Collections.sort(arr);
			 int size = arr.size();
			 final TreeMap<Integer, Integer> hm = new TreeMap<Integer, Integer>();
			 for(int i = 0; i < arr.size(); i++) {
			     final int e = arr.get(i);
			     if(hm.containsKey(e)) {
			         hm.put(e, hm.get(e)+1);
			     } else {
                    hm.put(e, 1);
                }
			 }
			 int i = 0, previous = -1, sub = -1;
			 for(final Map.Entry<Integer,Integer> entry : hm.entrySet()) {
			     if(i==0) {
			         previous = entry.getKey();
			         sub = entry.getValue();
			     }
			     else {
			         final int curr = entry.getKey();

			         if(previous+k>=curr) {
                        size = size - sub;
                    }
			         previous = entry.getKey();
                     sub = entry.getValue();
			     }
			     i++;
			 }
			 out.println(size);
			 out.close();
		}

		static long fac(long a) {
			long k = a;
			for (long i = 2; i < a; i++) {
				k = k * i;
			}
			System.out.println(k + " " + a);

			return a;

		}

		static class Pair implements Comparable<Pair> {

			long x, y;
			int i;

			Pair(long x, long y) {
				this.x = x;
				this.y = y;
				//this.i = i;
			}

			@Override
			public int compareTo(Pair o) {
				if (this.x != o.x) {
					return Long.compare(this.x, o.x);
				} else {
					return Long.compare(this.y, o.y);
					// return 0;
				}
			}

			@Override
			public boolean equals(Object o) {
				if (o instanceof Pair) {
					 final Pair p = (Pair) o;
					return p.x == x && p.y == y && p.i == i;
				}
				return false;
			}
		}

		public static boolean isPal(String s) {
			for (int i = 0, j = s.length() - 1; i <= j; i++, j--) {
				if (s.charAt(i) != s.charAt(j)) {
					return false;
				}
			}
			return true;
		}

		public static String rev(String s) {
			 final StringBuilder sb = new StringBuilder(s);
			sb.reverse();
			return sb.toString();
		}

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

		public static int gcd(int x, int y) {
			if (x % y == 0) {
				return y;
			} else {
				return gcd(y, x % y);
			}
		}

		public static long gcdExtended(long a, long b, long[] x) {

			if (a == 0) {
				x[0] = 0;
				x[1] = 1;
				return b;
			}
			 final long[] y = new long[2];
			 final long gcd = gcdExtended(b % a, a, y);

			x[0] = y[1] - (b / a) * y[0];
			x[1] = y[0];

			return gcd;
		}

		public static int abs(int a, int b) {
			return Math.abs(a - b);
		}

		public static long abs(long a, long b) {
			return Math.abs(a - b);
		}

		public static int max(int a, int b) {
			if (a > b) {
				return a;
			} else {
				return b;
			}
		}

		public static int min(int a, int b) {
			if (a > b) {
				return b;
			} else {
				return a;
			}
		}

		public static long max(long a, long b) {
			if (a > b) {
				return a;
			} else {
				return b;
			}
		}

		public static long min(long a, long b) {
			if (a > b) {
				return b;
			} else {
				return a;
			}
		}

		public static long pow(long n, long p, long m) {
			long result = 1;
			if (p == 0) {
				return 1;
			}
			if (p == 1) {
				return n;
			}
			while (p != 0) {
				if (p % 2 == 1) {
					result *= n;
				}
				if (result >= m) {
					result %= m;
				}
				p >>= 1;
				n *= n;
				if (n >= m) {
					n %= m;
				}
			}
			return result;
		}

		public static long pow(long n, long p) {
			long result = 1;
			if (p == 0) {
				return 1;
			}
			if (p == 1) {
				return n;
			}
			while (p != 0) {
				if (p % 2 == 1) {
					result *= n;
				}
				p >>= 1;
				n *= n;
			}
			return result;
		}

		static class InputReader {

			private final  InputStream stream;
			private final  byte[] buf = new byte[8192];
			private int curChar, snumChars;
			private SpaceCharFilter filter;

			public InputReader(InputStream stream) {
				this.stream = stream;
			}

			public int snext() {
				if (snumChars == -1) {
					throw new InputMismatchException();
				}
				if (curChar >= snumChars) {
					curChar = 0;
					try {
						snumChars = stream.read(buf);
					} catch ( final IOException e) {
						throw new InputMismatchException();
					}
					if (snumChars <= 0) {
						return -1;
					}
				}
				return buf[curChar++];
			}

			public int nextInt() {
				int c = snext();
				while (isSpaceChar(c)) {
					c = snext();
				}
				int sgn = 1;
				if (c == '-') {
					sgn = -1;
					c = snext();
				}
				int res = 0;
				do {
					if (c < '0' || c > '9') {
						throw new InputMismatchException();
					}
					res *= 10;
					res += c - '0';
					c = snext();
				} while (!isSpaceChar(c));
				return res * sgn;
			}

			public long nextLong() {
				int c = snext();
				while (isSpaceChar(c)) {
					c = snext();
				}
				int sgn = 1;
				if (c == '-') {
					sgn = -1;
					c = snext();
				}
				long res = 0;
				do {
					if (c < '0' || c > '9') {
						throw new InputMismatchException();
					}
					res *= 10;
					res += c - '0';
					c = snext();
				} while (!isSpaceChar(c));
				return res * sgn;
			}

			public int[] nextIntArray(int n) {
				 final int a[] = new int[n];
				for (int i = 0; i < n; i++) {
					a[i] = nextInt();
				}
				return a;
			}

			public long[] nextLongArray(int n) {
				 final long a[] = new long[n];
				for (int i = 0; i < n; i++) {
					a[i] = nextLong();
				}
				return a;
			}

			public String readString() {
				int c = snext();
				while (isSpaceChar(c)) {
					c = snext();
				}
				 final StringBuilder res = new StringBuilder();
				do {
					res.appendCodePoint(c);
					c = snext();
				} while (!isSpaceChar(c));
				return res.toString();
			}

			public String nextLine() {
				int c = snext();
				while (isSpaceChar(c)) {
					c = snext();
				}
				 final StringBuilder res = new StringBuilder();
				do {
					res.appendCodePoint(c);
					c = snext();
				} while (!isEndOfLine(c));
				return res.toString();
			}

			public boolean isSpaceChar(int c) {
				if (filter != null) {
					return filter.isSpaceChar(c);
				}
				return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
			}

			private boolean isEndOfLine(int c) {
				return c == '\n' || c == '\r' || c == -1;
			}

			public interface SpaceCharFilter {
				public boolean isSpaceChar(int ch);
			}
		}
	}