4 2 12
10 16 22 28
 10 3 1
5 5 5 6 6 7 8 8 8 9
 8 7 13
52 85 14 52 92 33 80 85
 10 5 293149357
79072863 760382815 358896034 663269192 233367425 32795628 837363300 46932461 179556769 763342555
 10 3 0
1 1 2 2 2 2 2 2 2 2
 10 4 28
5 5 6 6 30 30 32 33 50 55
 6 2 1
1 1 2 3 4 5
 6 3 3
1 1 1 1 1 5
 4 2 1
1 1 2 3
 6 3 2
1 2 3 3 4 5
 5 2 3
8 9 11 12 16
 10 3 3
1 1 2 4 5 6 9 10 11 12
 6 3 3
2 2 2 4 7 7
 3 2 257816048
1 999999999 999999999
 6 3 2
1 2 2 3 4 5
 9 3 2
1 2 2 3 4 5 6 7 7
 4 2 100
1 2 3 200
 7 3 3
6 8 9 10 12 13 14
 10 3 3
1 2 3 3 3 3 3 3 3 5
 10 4 9
47 53 33 48 35 51 18 47 33 11
 13 2 86
841 525 918 536 874 186 708 553 770 268 138 529 183
 7 3 3
1 2 4 6 7 8 10
 10 3 3
1 1 1 2 2 5 6 7 8 9
 6 2 2
1 2 3 4 6 7
 9 3 3
1 2 3 4 5 6 7 8 9
 18 2 86
665 408 664 778 309 299 138 622 229 842 498 389 140 976 456 265 963 777
 10 4 1
2 2 2 3 3 10 10 10 11 11
 3 2 76
44 5 93
 6 3 3
1 2 3 4 5 6
 8 4 5
1 1 1 1 1 9 9 9
 12 3 2
1 2 3 9 10 11 12 13 14 15 15 15
 8 3 6
1 2 3 3 4 7 11 11
 6 3 3
1 2 3 4 7 8
 10 4 15
20 16 6 16 13 11 13 1 12 16
 4 2 3
1 2 3 6
 7 3 3
1 1 3 4 4 4 7
 6 3 3
1 1 4 3 3 6
 6 3 4
1 2 3 4 6 7
 8 2 3
1 2 3 4 10 11 12 13
 6 2 2
2 3 4 5 6 8
 8 3 3
1 1 1 2 2 3 3 5
 18 3 1
1 1 1 2 2 3 5 5 5 6 6 7 9 9 9 10 10 11
 1 1 1
1
 16 2 2
3 3 3 4 5 6 7 9 33 33 33 32 31 30 29 27
 4 2 4
9 1 2 3
 3 2 2
6 7 7
 5 2 7
1 3 4 5 10
 5 2 9
3 8 9 14 20
 3 2 15
1 18 19
 5 2 3
1 2 3 4 100
 14 2 75
105 300 444 610 238 62 767 462 17 728 371 578 179 166
 7 3 3
1 2 3 4 4 5 5
 10 4 7
4 3 6 5 4 3 1 8 10 5
 6 3 4
1 1 3 5 8 10
 7 2 2
1 2 3 4 5 6 7
 15 8 57
40 36 10 6 17 84 57 9 55 37 63 75 48 70 53
 11 3 4
1 1 1 5 5 5 10 12 14 16 18
 8 3 6
1 2 3 3 7 4 11 11
 6 4 0
1 3 2 4 2 1
 5 2 3
5 7 7 7 10
 9 3 1
1 2 2 2 2 3 4 4 5
 11 3 1
1 1 2 2 3 3 3 4 4 5 5

YES
 YES
 NO
 NO
 NO
 YES
 YES
 NO
 YES
 YES
 NO
 YES
 YES
 NO
 YES
 YES
 NO
 NO
 YES
 NO
 YES
 NO
 YES
 YES
 YES
 YES
 YES
 NO
 YES
 NO
 YES
 YES
 NO
 YES
 YES
 YES
 YES
 YES
 YES
 YES
 YES
 YES
 YES
 YES
 NO
 YES
 YES
 YES
 NO
 NO
 YES
 YES
 YES
 NO
 YES
 NO
 NO
 YES
 NO
 YES
 YES
 YES

import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
import java.util.InputMismatchException;

public class E {
    public static void main(String args[])
    {
        FastReader Reader=new FastReader(System.in);
        int N=Reader.nextInt();
        int K=Reader.nextInt();
        int D=Reader.nextInt();
        int arr[]=new int[N];
        for(int i=0;i<N;i++)
        {
            arr[i]=Reader.nextInt();
        }
        sorts(arr,N);
        int dp[]=new int[N+1];
        dp[0]=1;
        SegmentTree tree =new SegmentTree();
        tree.constructST(dp,N+1);
        //System.out.println(tree.st[0]+"yo");
        int index=0;
        for(int i=0;i<N;i++)
        {
            while(index<i && arr[i]-arr[index]>D)
                index++;
            int low=index;
            int high=i+1-K;
            if(low<=high)
            {
               int val= tree.RMQ(N+1,low,high);
                //System.out.println(val+"yo");
               if(val==1)
               {
                    tree.updateValue(dp,N+1,i+1,1);
               }
            }
        }
        /*for(int i=0;i<N+1;i++)
            System.out.println(dp[i]);*/
        if (dp[N]==1)
            System.out.println("YES");
        else
            System.out.println("NO");
        }


    public static void sorts(int arr[],int N)
    {
        Integer arr_obj[]=new Integer[N];
        for(int i=0; i<N; ++i){
            arr_obj[i] = new Integer(arr[i]);
        }
        Arrays.sort(arr_obj);
        for(int i=0; i<N; ++i){
            arr[i] = arr_obj[i];
        }
    }
}
class SegmentTree
{
    public int st[];
    public void constructST(int arr[],int N)
    {
        int x=(int)Math.ceil(Math.log(N)/Math.log(2));
        int max_size=(int)Math.pow(2,x+1) - 1;
        st=new int[max_size];
        constructSTUtil(arr,0,N-1,0);
    }
    public int constructSTUtil(int arr[],int ss,int se,int si)
    {
        if(ss==se)
        {
            st[si]=arr[ss];
            return arr[ss];
        }
        int mid=getMid(ss,se);
        st[si]=maxVal(constructSTUtil(arr,ss,mid,2*si+1),constructSTUtil(arr,mid+1,se,2*si+2));
        return st[si];
    }
    public int getMid(int s, int e) {
        return s + (e - s) / 2;
    }
    public int maxVal(int x, int y) {
        return (x > y) ? x : y;
    }
    // qs,qe are 0 indexed
    public int RMQ(int N,int qs,int qe)
    {
        if(qs<0 || qe > N-1 || qs>qe) {
            System.out.println("Invalid Input");
            return -1;
        }
        return RMQUtil(0, N- 1, qs, qe, 0);

    }
    public int RMQUtil(int ss, int se, int qs, int qe, int index)
    {
        if(qs<=ss && qe>=se)
            return st[index];
        if(se<qs || qe< ss)
            return Integer.MIN_VALUE;
        int mid = getMid(ss, se);
        return maxVal(RMQUtil(ss, mid, qs, qe, 2 * index + 1),
                RMQUtil(mid + 1, se, qs, qe, 2 * index + 2));
    }
    // i is 0 indexed
    public void updateValue(int arr[],int N,int i,int new_val)
    {
        if(i<0 || i>N-1)
        {
            System.out.println("Invalid Input");
            return;
        }
        arr[i] = new_val;
        updateValueUtil(0,N-1,i,new_val,0);
    }
    public int updateValueUtil(int ss,int se,int i,int new_val,int si)
    {
        if(i<ss || i>se)
            return -1;

        if(se==ss)
        {
            st[si]=new_val;
            return new_val;
        }
        int mid=getMid(ss,se);
        st[si]=maxVal(updateValueUtil(ss,mid,i,new_val,2*si+1),updateValueUtil(mid+1,se,i,new_val,2*si+2));
        return st[si];
    }
}
class FastReader {
    private InputStream stream;
    private byte[] buf = new byte[8192];
    private int curChar;
    private int pnumChars;
    private FastReader.SpaceCharFilter filter;

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

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

    public String next() {
        return nextString();
    }

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

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

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

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


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

    public boolean isSpaceChar(int c) {
        if (filter != null) {
            return filter.isSpaceChar(c);
        }
        return isWhitespace(c);
    }

    public static boolean isWhitespace(int c) {
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

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

    }

}