import Data.Array
import Data.List
--インデックス、最大l,参照配列、
j_able_l::Int -> Int -> Array Int Int -> Array (Int,Int) Bool
j_able_l i max_k ar = let n = snd (bounds ar) in
                  listArray ((0,0),(n,max_k)) [if j == 0 then (l == 0)
                                                     else (rec (j-1) l)||(rec (j-1) (l-(if(expt ar j)<=l then (expt ar j) else 0 )))|j<-[0..n],l<-[0..max_k]]
                  where expt ar j = if j == i then 0 else (ar!j)
                        rec a b = (j_able_l i max_k ar)!(a,b)

--インデックス、k、参照配列
is_need::Int -> Int -> Array Int Int -> Bool
is_need i k ar = let table = j_able_l i k ar in
                 or [table!((fst.snd.bounds) table,t)|t<-[(k-(ar!i))..(k-1)],t>=((snd.fst.bounds) table),t<=((snd.snd.bounds) table)]

--で、あるiがneedなときそれより大きいやつもneedになる。つまり、ソートして、ここからはneedであるというのを見つければいい。
--これを二分探索で行う。

--ソート済み配列を受けて、その要素に対する達成条件にたいして、それが必要になる最小インデックスを返す。
bin_ser::Array Int Int -> (Int -> Bool) -> Int
bin_ser ar judge = rec ((fst.bounds) ar) ((snd.bounds) ar)
              where rec a b = if b == a+1 then b
                                          else let mid = div (a+b) 2 in
                                               if judge (ar!mid) then rec a mid else rec mid b

solver::Array Int Int -> Array Int Int -> Int->Int
solver ar stdar k = (bin_ser stdar (\ i -> is_need i k ar)) - 1


solver1::Array Int Int -> Int-> Int
solver1 ar k = let n = (snd.bounds) ar in
               n-(length (filter (\i->is_need i k ar) [1..n]))

main::IO()
main=do
  nkc<-getLine
  let n:k:[]=map read (words nkc)
  dat<-getLine
  let ar = listArray (1,n) (map read (words dat))
--  let stdar = listArray (1,n) (sort (map read (words dat)))
  print (solver1 ar k)