We've got no test cases. A big olympiad is coming up. But the problemsetters' number one priority should be adding another problem to the round.

The diameter of a multiset of points on the line is the largest distance between two points from this set. For example, the diameter of the multiset {1, 3, 2, 1} is 2.

Diameter of multiset consisting of one point is 0.

You are given n points on the line. What is the minimum number of points you have to remove, so that the diameter of the multiset of the remaining points will not exceed d?

Input

The first line contains two integers n and d (1 ≤ n ≤ 100, 0 ≤ d ≤ 100) — the amount of points and the maximum allowed diameter respectively.

The second line contains n space separated integers (1 ≤ xi ≤ 100) — the coordinates of the points.

Output

Output a single integer — the minimum number of points you have to remove.

Examples

Input

3 1
2 1 4


Output

1


Input

3 0
7 7 7


Output

0


Input

6 3
1 3 4 6 9 10


Output

3

Note

In the first test case the optimal strategy is to remove the point with coordinate 4. The remaining points will have coordinates 1 and 2, so the diameter will be equal to 2 - 1 = 1.

In the second test case the diameter is equal to 0, so its is unnecessary to remove any points. 

In the third test case the optimal strategy is to remove points with coordinates 1, 9 and 10. The remaining points will have coordinates 3, 4 and 6, so the diameter will be equal to 6 - 3 = 3.
import java.util.*;
import java.io.*;

public class Sol2 {

	static final boolean stdin = true;
	static final String filename = "";
	static FastScanner br;
	static PrintWriter pw;

	public static void main(String[] args) throws IOException {

		if (stdin) {
			br = new FastScanner();
			pw = new PrintWriter(new OutputStreamWriter(System.out));
		} else {
			br = new FastScanner(filename + ".in");
			pw = new PrintWriter(new FileWriter(filename + ".out"));
		}

		Solver solver = new Solver();
		solver.solve(br, pw);
	}

	static class Solver {
		static long mod = 1000000000;
		static int d;

		public void solve(FastScanner br, PrintWriter pw) throws IOException {
			int n = br.nextInt();
			d = br.nextInt();
			Integer[] in = new Integer[n];
			for (int i = 0; i < n; i++) {
				in[i] = br.nextInt();
			}
			Arrays.sort(in);
			int mac = 1;
			for (int i = 0; i < n-1; i++) {
				for (int j = i + 1; j < n; j++) {
					if(in[j] - in[i] <= d){
						mac = Math.max(mac, j-i+1);
					}
				}
			}
			pw.println(n-mac);
			pw.close();
		}

		public static <K, V extends Comparable<V>> Map<K, V> sortByValues(final Map<K, V> map) {
			Comparator<K> valueComparator = new Comparator<K>() {
				public int compare(K k1, K k2) {
					int compare = map.get(k1).compareTo(map.get(k2));
					if (compare == 0)
						return 1;
					else
						return compare;
				}
			};

			Map<K, V> sortedByValues = new TreeMap<K, V>(valueComparator);
			sortedByValues.putAll(map);
			return sortedByValues;
		}

		static long gcd(long a, long b) {
			if (a > b)
				return gcd(b, a);
			if (a == 0)
				return b;
			return gcd(b % a, a);
		}

		static long pow(long a, long b) {
			if (b == 0)
				return 1L;
			long val = pow(a, b / 2);
			if (b % 2 == 0)
				return val * val % mod;
			else
				return val * val % mod * a % mod;
		}

	}

	static class Point1 implements Comparable<Point1> {
		int a;
		int b;

		Point1(int a, int b) {
			this.a = a;
			this.b = b;
		}

		@Override
		public int compareTo(Point1 o) {
			return (this.b - this.a) - (o.b - o.a);
		}

	}

	static class Point2 implements Comparable<Point2> {
		int a;
		int b;

		Point2(int a, int b) {
			this.a = a;
			this.b = b;
		}

		@Override
		public int compareTo(Point2 o) {
			return this.b - o.b;
		}

	}

	static class UnionFind {
		// The number of elements in this union find
		private int size;
		// Used to track the size of each of the component
		private int[] sz;
		// id[i] points to the parent of i, if id[i] = i then i is a root node
		private int[] id;
		// Tracks the number of components in the union find
		private int numComponents;

		public UnionFind(int size) {
			if (size <= 0)
				throw new IllegalArgumentException("Size <= 0 is not allowed");
			this.size = numComponents = size;
			sz = new int[size];
			id = new int[size];
			for (int i = 0; i < size; i++) {
				id[i] = i; // Link to itself (self root)
				sz[i] = 1; // Each component is originally of size one
			}
		}

		// Find which component/set 'p' belongs to in amortized constant time.
		public int find(int p) {
			// Find the root of the component/set
			int root = p;
			while (root != id[root])
				root = id[root];
			// Compress the path leading back to the root.
			// Doing this operation is called "path compression"
			// and is what gives us amortized time complexity.
			while (p != root) {
				int next = id[p];
				id[p] = root;
				p = next;
			}
			return root;
		}

		// This is an alternative recursive formulation for the find method
		// public int find(int p) {
		// if (p == id[p]) return p;
		// return id[p] = find(id[p]);
		// }

		// Return whether or not the elements 'p' and
		// 'q' are in the same components/set.
		public boolean connected(int p, int q) {
			return find(p) == find(q);
		}

		// Return the size of the components/set 'p' belongs to
		public int componentSize(int p) {
			return sz[find(p)];
		}

		// Return the number of elements in this UnionFind/Disjoint set
		public int size() {
			return size;
		}

		// Returns the number of remaining components/sets
		public int components() {
			return numComponents;
		}

		// Unify the components/sets containing elements 'p' and 'q'
		public void unify(int p, int q) {
			int root1 = find(p);
			int root2 = find(q);
			// These elements are already in the same group!
			if (root1 == root2)
				return;
			// Merge smaller component/set into the larger one.
			if (sz[root1] < sz[root2]) {
				sz[root2] += sz[root1];
				id[root1] = root2;
			} else {
				sz[root1] += sz[root2];
				id[root2] = root1;
			}
			// Since the roots found are different we know that the
			// number of components/sets has decreased by one
			numComponents--;
		}
	}

	public static class FastScanner {
		BufferedReader br;
		StringTokenizer st;

		public FastScanner(String s) {
			try {
				br = new BufferedReader(new FileReader(s));
			} catch (FileNotFoundException e) {
				e.printStackTrace();
			}
		}

		public FastScanner() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		String nextToken() {
			while (st == null || !st.hasMoreElements()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

		int nextInt() {
			return Integer.parseInt(nextToken());
		}

		long nextLong() {
			return Long.parseLong(nextToken());
		}

		double nextDouble() {
			return Double.parseDouble(nextToken());
		}

		ArrayList<Integer>[] nextGraph(int nodes, int edges) {
			ArrayList<Integer>[] adj = new ArrayList[nodes];
			for (int i = 0; i < nodes; i++) {
				adj[i] = new ArrayList<Integer>();
			}
			for (int i = 0; i < edges; i++) {
				int a = nextInt() - 1;
				int b = nextInt() - 1;
				adj[a].add(b);
				adj[b].add(a);
			}
			return adj;
		}
	}
}