There is a toy building consisting of n towers. Each tower consists of several cubes standing on each other. The i-th tower consists of h_i cubes, so it has height h_i.

Let's define operation slice on some height H as following: for each tower i, if its height is greater than H, then remove some top cubes to make tower's height equal to H. Cost of one "slice" equals to the total number of removed cubes from all towers.

Let's name slice as good one if its cost is lower or equal to k (k ≥ n).

<image>

Calculate the minimum number of good slices you have to do to make all towers have the same height. Of course, it is always possible to make it so.

Input

The first line contains two integers n and k (1 ≤ n ≤ 2 ⋅ 10^5, n ≤ k ≤ 10^9) — the number of towers and the restriction on slices, respectively.

The second line contains n space separated integers h_1, h_2, ..., h_n (1 ≤ h_i ≤ 2 ⋅ 10^5) — the initial heights of towers.

Output

Print one integer — the minimum number of good slices you have to do to make all towers have the same heigth.

Examples

Input

5 5
3 1 2 2 4


Output

2


Input

4 5
2 3 4 5


Output

2

Note

In the first example it's optimal to make 2 slices. The first slice is on height 2 (its cost is 3), and the second one is on height 1 (its cost is 4).
//package sept;

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

public class TimePass implements Runnable {
    InputStream is;
    PrintWriter out;
    String INPUT = "";
    //boolean codechef=false;
    boolean codechef=true;
    
	void solve()
	{
		int n=ni(),k=ni();
		int[] h=na(n);
		int[] c=Arrays.copyOf(h,n);
		long[] cnt=new long[200005];
		//Arrays.sort(c);
		int min=c[0];
		int eq=1;
		for(int i=n-1;i>=0;i--)
		{
			cnt[c[i]]++;
			min=Math.min(min, c[i]);
			if(i>0 && c[i]!=c[i-1])eq=0;
		}
		if(eq==1)
		{
			out.println(0);
			return;
		}
		long sum=0;
		int ans=0;
		int f=0;
		long curr=0;
		
		for(int i=200000;i>=min;i--)
		{
			if(cnt[i]==0)cnt[i]=cnt[i+1];
			else
			{
				cnt[i]+=cnt[i+1];
			}
			sum+=cnt[i];
			if(i==min)
			{
				ans++;
				break;
			}
			if(sum>k)
			{
				ans++;
				sum=cnt[i];
			}
		}
		//System.out.println(Arrays.toString(cnt));
		
		
		
		out.println(ans);
	}
	
	static TreeSet<Integer> set;
	
	static int[][] ans;
	
	static boolean comp(int[] a,int i,int p)
	{
		//System.out.println(a[i]+" "+p);
		if(ans[i][p]==1)return true;
		if(ans[i][p]==0)return false;
		int n=a.length;
		
		int curr=a[i];
		for(int j=i-curr;j>=0;j-=curr)
		{
			if(a[j]>a[i] && !comp(a, j, p^1))
			{
				if(p==0)set.remove(i);
				ans[i][p]=1;
				return true;
			}
		}
		for(int j=i+curr;j<n;j+=curr)
		{
			//System.out.println("as:"+a[j]);
			if(a[j]>a[i] && !comp(a, j, p^1))
			{
				if(p==0)set.remove(i);
				ans[i][p]=1;
				return true;
			}
		}
		if(p==0)set.remove(i);
		ans[i][p]=0;
		return false;
	}
	
	static ArrayList<int[]> list;
	
	static void permute(int[] arr, int l, int r)
    {
       int i;
       if (l == r)
       {
    	   HashSet<Integer> set=new HashSet<>();
    	   for(int j=1;j<=arr.length;j++)
    	   {
    		   set.add(j);
    	   }
    	   int[] tmp=new int[arr.length];
    	   for(int j=0;j<arr.length;j++)
    	   {
    		   int g=0;
    		   for(int k:set)
    		   {
    			   g=(int) gcd(g,k);
    		   }
    		   tmp[j]=g;
    		   set.remove(arr[j]);
    	   }
    	   list.add(Arrays.copyOf(tmp,arr.length));
       }
       else
       {
           for (i = l; i <= r; i++)
           {
              swap(arr,l,i);
              permute(arr, l+1, r);
              swap(arr,l,i);
           }
       }
    }
	
	static void swap(int[] arr,int i1,int i2)
	 {
		 int tmp=arr[i1];
	   	arr[i1]=arr[i2];
	   	arr[i2]=tmp;
	 }

	static int MAX=1500;
	
	static int prime[], countdiv[]; 
	  
	// Simple sieve to find smallest prime factors of numbers 
	// smaller than MAX 
	void SieveOfEratosthenes() 
	{ 
	    for (int i = 2; i * i < MAX; ++i) 
	    { 
	        if (prime[i]==0) 
	            for (int j = i * i; j < MAX; j += i) 
	                prime[j] = i; 
	    } 
	  
	    // Prime number will have same divisor 
	    for (int i = 1; i < MAX; ++i) 
	        if (prime[i]==0) 
	            prime[i] = i; 
	} 
	  
	// Returns length of the largest subsequence 
	// with GCD more than 1. 
	int largestGCDSubsequence(int arr[], int n) 
	{ 
	    int ans = 0; 
	    for (int i=0; i < n; ++i) 
	    { 
	        int element = arr[i]; 
	  
	        // Fetch total unique prime divisor of element 
	        while (element > 1) 
	        { 
	            int div = prime[element]; 
	  
	            // Increment count[] of Every unique divisor 
	            // we get till now 
	            ++countdiv[div]; 
	  
	            // Find maximum frequency of divisor 
	            ans = Math.max(ans, countdiv[div]); 
	  
	            while (element % div==0) 
	                element /= div; 
	        } 
	    } 
	  
	    return ans; 
	} 
	  
	
	static boolean check(int x)
	{
		char[] a=(""+x).toCharArray();
		int s=0;
		for(int i=0;i<a.length;i++)
		{
			s+=a[i]-'0';
			s%=3;
		}
		if(s==0)return true;
		return false;
	}

	static int[][] packD(int n,int[] from,int[] to)
	{
		int[][] g=new int[n][];
		int[] p=new int[n];
		for(int f:from)
		{
			p[f]++;
		}
		int m=from.length;
		for(int i=0;i<n;i++)
		{
			g[i]=new int[p[i]];
		}
		for(int i=0;i<m;i++)
		{
			g[from[i]][--p[from[i]]]=to[i];
		}
		return g;
	}
	    
    static class Pair
    {
        int a,b;
        public Pair(int a,int b)
        {
            this.a=a;
            this.b=b;
        }
    }
    
    static long lcm(int a,int b)
    {
        long val=a;
        val*=b;
        return (val/gcd(a,b));
    }
    
    static long gcd(long a,long b)
    {
        if(a==0)return b;
        return gcd(b%a,a);
    }
    
    static int pow(int a, int b, int p)
    {
        long ans = 1, base = a;
        while (b!=0)
        {
            if ((b & 1)!=0)
            {
                ans *= base;
                ans%= p;
            }
            base *= base;
            base%= p;
            b >>= 1;
        }
        return (int)ans;
    }

    static int inv(int x, int p)
    {
        return pow(x, p - 2, p);
    }

    
    public void run()
    {
        if(codechef)oj=true;
        is = oj ? System.in : new ByteArrayInputStream(INPUT.getBytes());
        out = new PrintWriter(System.out);
        
        long s = System.currentTimeMillis();
        solve();
        out.flush();
        tr(System.currentTimeMillis()-s+"ms");
    }
    
    public static void main(String[] args) throws Exception {new Thread(null,new TimePass(),"Main",1<<26).start();}
    
    private byte[] inbuf = new byte[1024];
    public int lenbuf = 0, ptrbuf = 0;
    
    private int readByte()
    {
        if(lenbuf == -1)throw new InputMismatchException();
        if(ptrbuf >= lenbuf){
            ptrbuf = 0;
            try { lenbuf = is.read(inbuf); } catch (IOException e) { throw new InputMismatchException(); }
            if(lenbuf <= 0)return -1;
        }
        return inbuf[ptrbuf++];
    }
    
    private boolean isSpaceChar(int c) { return !(c >= 33 && c <= 126); }
    private int skip() { int b; while((b = readByte()) != -1 && isSpaceChar(b)); return b; }
    
    private double nd() { return Double.parseDouble(ns()); }
    private char nc() { return (char)skip(); }
    
    private String ns()
    {
        int b = skip();
        StringBuilder sb = new StringBuilder();
        while(!(isSpaceChar(b))){ // when nextLine, (isSpaceChar(b) && b != ' ')
            sb.appendCodePoint(b);
            b = readByte();
        }
        return sb.toString();
    }
    
    private char[] ns(int n)
    {
        char[] buf = new char[n];
        int b = skip(), p = 0;
        while(p < n && !(isSpaceChar(b))){
            buf[p++] = (char)b;
            b = readByte();
        }
        return n == p ? buf : Arrays.copyOf(buf, p);
    }
    
    private char[][] nm(int n, int m)
    {
        char[][] map = new char[n][];
        for(int i = 0;i < n;i++)map[i] = ns(m);
        return map;
    }
    
    private int[] na(int n)
    {
        int[] a = new int[n];
        for(int i = 0;i < n;i++)a[i] = ni();
        return a;
    }
    
    private int ni()
    {
        int num = 0, b;
        boolean minus = false;
        while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
        if(b == '-'){
            minus = true;
            b = readByte();
        }
        
        while(true){
            if(b >= '0' && b <= '9'){
                num = num * 10 + (b - '0');
            }else{
                return minus ? -num : num;
            }
            b = readByte();
        }
    }
    
    private long nl()
    {
        long num = 0;
        int b;
        boolean minus = false;
        while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
        if(b == '-'){
            minus = true;
            b = readByte();
        }
        
        while(true){
            if(b >= '0' && b <= '9'){
                num = num * 10 + (b - '0');
            }else{
                return minus ? -num : num;
            }
            b = readByte();
        }
    }
    
    private boolean oj = System.getProperty("ONLINE_JUDGE") != null;
    private void tr(Object... o) { if(!oj)System.out.println(Arrays.deepToString(o)); }
}