import java.util.Scanner;

public class KirillAndTheGame {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
//		if((double)(5/3) == (int)((double)(5/3))){
//			System.out.println((double) ((double)(5) / 3));
//		}
		int l = sc.nextInt();
		int r = sc.nextInt();
		int x = sc.nextInt();
		int y = sc.nextInt();
		int k = sc.nextInt();
		String out = "NO";
		for(int a = l; a <= r; a++){
			int b = a / k;
			if(a % k == 0 && x <= (a / k) && (a / k) <= y){
				out = "YES";
				break;
			}
		}
		System.out.println(out);
	}
}

//outerLoop:
//	for(int a = l; a <= r; a++){
//		for(int b = x; b <= y; b++){
//			if(a / b == k){
//				out = "YES";
//				break outerLoop;
//			}
//			else if(a / b > k){
//				if(a > l) a--;
//				else if(b < y) b++;
//				else break outerLoop;
//			}
//			else if(a / b < k){
//				if(a < r) a++;
//				else if(b > x) b--;
//				else break outerLoop;
//			}
//		}
//	}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Kunal Raj
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            String str = in.readLine();
            String arr[] = str.split(" ");
            long l = Integer.parseInt(arr[0]);
            long r = Integer.parseInt(arr[1]);
            long x = Integer.parseInt(arr[2]);
            long y = Integer.parseInt(arr[3]);
            long k = Integer.parseInt(arr[4]);
            int f = 0;
            for (long i = x; i <= y; i++) {
                long t = ((long) i * k);
                if (l <= t && r >= t) {
                    out.println("YES");
                    f = 1;
                    break;
                }
            }
            if (f == 0)
                out.println("NO");
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;

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

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

        private String readLine0() {
            StringBuilder buf = new StringBuilder();
            int c = read();
            while (c != '\n' && c != -1) {
                if (c != '\r') {
                    buf.appendCodePoint(c);
                }
                c = read();
            }
            return buf.toString();
        }

        public String readLine() {
            String s = readLine0();
            while (s.trim().length() == 0) {
                s = readLine0();
            }
            return s;
        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void print(Object... objects) {
            for (int i = 0; i < objects.length; i++) {
                if (i != 0) {
                    writer.print(' ');
                }
                writer.print(objects[i]);
            }
        }

        public void println(Object... objects) {
            print(objects);
            writer.println();
        }

        public void close() {
            writer.close();
        }

    }
}

import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Writer;
import java.util.NoSuchElementException;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        Task842A solver = new Task842A();
        solver.solve(1, in, out);
        out.close();
    }

    static class Task842A {
        private static final double EPS = 1e-9;

        public void solve(int testNumber, InputReader in, OutputWriter out) {
            int l = in.nextInt();
            int r = in.nextInt();
            int x = in.nextInt();
            int y = in.nextInt();
            int k = in.nextInt();

            for (int a = l; a <= r; ++a) {
                if (a % k > 0) {
                    continue;
                }
                double e = (1.0 * a) / k;

                if (e + EPS >= x && e - EPS <= y) {
                    out.println("YES");
                    return;
                }
            }

            out.println("NO");

        }

    }

    static class OutputWriter {
        private PrintWriter out;

        public OutputWriter(OutputStream stream) {
            out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(stream)));
        }

        public OutputWriter(Writer writer) {
            out = new PrintWriter(writer);
        }

        public void print(Object... objects) {
            for (int i = 0; i < objects.length; ++i) {
                if (i > 0) {
                    out.print(' ');
                }
                out.print(objects[i]);
            }
        }

        public void println(Object... objects) {
            print(objects);
            out.println();
        }

        public void close() {
            out.close();
        }

    }

    static class InputReader {
        private final byte[] buffer = new byte[8192];
        private InputStream in;
        private int pos = 0;
        private int len = 0;

        public InputReader(InputStream stream) {
            in = stream;
        }

        private static boolean isDigit(int c) {
            return c >= '0' && c <= '9';
        }

        private static boolean isPrintable(int c) {
            return c >= 33 && c <= 126;
        }

        public int nextInt() {
            return (int) nextLong();
        }

        public long nextLong() {
            if (!hasNext()) {
                throw new NoSuchElementException();
            }
            long num = 0;
            boolean neg = false;
            int b = readByte();
            if (!(isDigit(b) || b == '-')) {
                throw new NumberFormatException();
            } else {
                if (b == '-') {
                    neg = true;
                } else {
                    num += b - '0';
                }

                while ((b = readByte()) != -1 && isDigit(b)) {
                    num *= 10;
                    num += b - '0';
                }
            }
            return neg ? -num : num;
        }

        private boolean hasNext() {
            while (hasNextByte() && !isPrintable(buffer[pos])) {
                pos++;
            }
            return hasNextByte();
        }

        private boolean hasNextByte() {
            if (pos >= len) {
                pos = 0;
                try {
                    len = in.read(buffer);
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (len <= 0) {
                    return false;
                }
            }
            return true;
        }

        private int readByte() {
            if (hasNextByte()) {
                return buffer[pos++];
            } else {
                return -1;
            }
        }

    }
}

// Working program with FastReader
import static java.lang.System.out;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;
import java.util.*;
public class a{
    static class FastReader{
        BufferedReader br;
        StringTokenizer st;

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

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

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

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

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

        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
    }

    public static void main(String[] args)
    {
        FastReader s=new FastReader();
        int l = s.nextInt();
        int r = s.nextInt();
        int x = s.nextInt();
        int y= s.nextInt();
        int k = s.nextInt();
        int fl=0;

                for(int j=x; j<=y; j++){
                    long dd = (long)k*j;
                    if(dd >=(long) l && dd <=(long)r) {fl=1; break;}

                }

        if(fl==1) out.println("YES");
        else out.println("NO");
    } //main
} //contest

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

public class Main1{

	public static void main(String[] args) {
		MyScanner sc = new MyScanner();
		out = new PrintWriter(new BufferedOutputStream(System.out));

      // Start writing your solution here. -------------------------------------
		long l,r,x,y,k;
		l=sc.nextLong();
		r= sc.nextLong();
		x=sc.nextLong();
		y=sc.nextLong();
		k=sc.nextLong();
		//int div[] = new int[y-x+1];

		long i;
  //System.out.println(Arrays.toString(div));

    Boolean flag = false;
		for( i=x; i <= y;i++){
			if(l <= (i*k) && r >= (i*k))
        flag = true;

		}
		//out.println(i);
		//if(i==r-l+1)
		if(flag)
      out.println("YES");
      else
      out.println("NO");

      /*
      int n      = sc.nextInt();        // read input as integer
      long k     = sc.nextLong();       // read input as long
      double d   = sc.nextDouble();     // read input as double
      String str = sc.next();           // read input as Strigtgtgtgtgtgtgtng
      String s   = sc.nextLine();       // read whole line as String

      int result = 3*n;
      out.println(result);                    // print via PrintWriter;
      for(int i = 0; i lt N ; i++){
        for(int j = 0; j lt N; j++){
          System.out.print();
        }
        System.out.println();
      }
      */

      // Stop writing your solution here. -------------------------------------
      out.close();
  }

   //-----------PrintWriter for faster output---------------------------------
  public static PrintWriter out;

   //-----------MyScanner class for faster input----------
  public static class MyScanner {
  	BufferedReader br;
  	StringTokenizer st;

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

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

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

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

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

  	String nextLine(){
  		String str = "";
  		try {
  			str = br.readLine();
  		} catch (IOException e) {
  			e.printStackTrace();
  		}
  		return str;
  	}

  }
   //--------------------------------------------------------
}

import java.util.Scanner;
/**
 *
 * @author никитяночка
 */
public class Main {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code appl0ication logic here
        Scanner in = new Scanner(System.in);
        long l = in.nextLong();
        long r = in.nextLong();
        long x = in.nextLong();
        long y = in.nextLong();
        long k = in.nextLong();
        for (long i = x; i <= y; i++) {
            if (k * i >= l && k*i <= r) {
                System.out.println("YES");
                return;
            }
        }
        System.out.println("NO");
    }

}

import java.util.Scanner;

public class Main {

    public static void main(String[] args){

        Scanner in = new Scanner(System.in);
        long l = in.nextLong();
        long r = in.nextLong();
        long x = in.nextLong();
        long y = in.nextLong();
        long k = in.nextLong();

        for (long i = x; i <= y; i++){ ;
            if ((i * k >= l)&&(i * k <= r)){
                System.out.print("YES");
                return;
            }
        }
        System.out.print("NO");

    }

}

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

public class problem {
    private static FastScanner in = new FastScanner();
    private static void solve() {
        long l = in.nextLong();
        long r = in.nextLong();
        long x = in.nextLong();
        long y = in.nextLong();
        long k = in.nextLong();
        for (long i = x; i <= y; i++) {
            if (i * k >= l && i * k <= r) {
                System.out.println("YES");
                return;
            } else {
                if (i * k > r) break;
            }
        }
        System.out.println("NO");
    }

    public static void main(String[] args) throws IOException {
        new problem().solve();
    }
}

class FastScanner {
    public static String debug = null;

    private final InputStream in = System.in;
    private int ptr = 0;
    private int buflen = 0;
    private byte[] buffer = new byte[1024];
    private boolean eos = false;

    private boolean hasNextByte() {
        if (ptr < buflen) {
            return true;
        } else {
            ptr = 0;
            try {
                if (debug != null) {
                    buflen = debug.length();
                    buffer = debug.getBytes();
                    debug = "";
                    eos = true;
                } else {
                    buflen = in.read(buffer);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            if (buflen < 0) {
                eos = true;
                return false;
            } else if (buflen == 0) {
                return false;
            }
        }
        return true;
    }

    private int readByte() {
        if (hasNextByte())
            return buffer[ptr++];
        else
            return -1;
    }

    private static boolean isPrintableChar(int c) {
        return 33 <= c && c <= 126;
    }

    private void skipUnprintable() {
        while (hasNextByte() && !isPrintableChar(buffer[ptr]))
            ptr++;
    }

    public boolean isEOS() {
        return this.eos;
    }

    public boolean hasNext() {
        skipUnprintable();
        return hasNextByte();
    }

    public String next() {
        if (!hasNext())
            throw new NoSuchElementException();
        StringBuilder sb = new StringBuilder();
        int b = readByte();
        while (isPrintableChar(b)) {
            sb.appendCodePoint(b);
            b = readByte();
        }
        return sb.toString();
    }

    public long nextLong() {
        if (!hasNext())
            throw new NoSuchElementException();
        long n = 0;
        boolean minus = false;
        int b = readByte();
        if (b == '-') {
            minus = true;
            b = readByte();
        }
        if (b < '0' || '9' < b) {
            throw new NumberFormatException();
        }
        while (true) {
            if ('0' <= b && b <= '9') {
                n *= 10;
                n += b - '0';
            } else if (b == -1 || !isPrintableChar(b)) {
                return minus ? -n : n;
            } else {
                throw new NumberFormatException();
            }
            b = readByte();
        }
    }

    public int nextInt() {
        return (int) nextLong();
    }

    public long[] nextLongList(int n) {
        return nextLongTable(1, n)[0];
    }

    public int[] nextIntList(int n) {
        return nextIntTable(1, n)[0];
    }

    public long[][] nextLongTable(int n, int m) {
        long[][] ret = new long[n][m];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                ret[i][j] = nextLong();
            }
        }
        return ret;
    }

    public int[][] nextIntTable(int n, int m) {
        int[][] ret = new int[n][m];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                ret[i][j] = nextInt();
            }
        }
        return ret;
    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.util.StringTokenizer;
import java.io.Writer;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author zodiacLeo
 */
public class Main
{
    public static void main(String[] args)
    {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastScanner in = new FastScanner(inputStream);
        FastPrinter out = new FastPrinter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA
    {
        public void solve(int testNumber, FastScanner in, FastPrinter out)
        {
            long l = in.nextLong();
            long r = in.nextLong();
            long x = in.nextLong();
            long y = in.nextLong();
            long k = in.nextLong();
            for (long i = x; i <= y; i++)
            {
                long n = k * i;
                if (n >= l && n <= r)
                {
                    out.println("YES");
                    return;
                }
            }
            out.println("NO");
        }

    }

    static class FastScanner
    {
        public BufferedReader br;
        public StringTokenizer st;

        public FastScanner(InputStream is)
        {
            br = new BufferedReader(new InputStreamReader(is));
        }

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

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

        public long nextLong()
        {
            return Long.parseLong(next());
        }

    }

    static class FastPrinter extends PrintWriter
    {
        public FastPrinter(OutputStream out)
        {
            super(out);
        }

        public FastPrinter(Writer out)
        {
            super(out);
        }

    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.util.StringTokenizer;
import java.io.Writer;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author zodiacLeo
 */
public class Main
{
    public static void main(String[] args)
    {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastScanner in = new FastScanner(inputStream);
        FastPrinter out = new FastPrinter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA
    {
        public void solve(int testNumber, FastScanner in, FastPrinter out)
        {
            long l = in.nextLong();
            long r = in.nextLong();
            long x = in.nextLong();
            long y = in.nextLong();
            long k = in.nextLong();

            long low = l + k - 1;
            low /= k;
            long high = r / k;
            if (high < x || low > y || low > high)
            {
                out.println("NO");
                return;
            }
            out.println("YES");
        }

    }

    static class FastScanner
    {
        public BufferedReader br;
        public StringTokenizer st;

        public FastScanner(InputStream is)
        {
            br = new BufferedReader(new InputStreamReader(is));
        }

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

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

        public long nextLong()
        {
            return Long.parseLong(next());
        }

    }

    static class FastPrinter extends PrintWriter
    {
        public FastPrinter(OutputStream out)
        {
            super(out);
        }

        public FastPrinter(Writer out)
        {
            super(out);
        }

    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

/**
 * Created by z002rgw on 8/30/17.
 */
public class Task1Div430 {
    public static PrintWriter out;

    //-----------MyScanner class for faster input----------
    public static class MyScanner {
        // Start writing your solution here. -------------------------------------

        /*
            int n      = sc.nextInt();        // read input as integer
            long k     = sc.nextLong();       // read input as long
            double d   = sc.nextDouble();     // read input as double
            String str = sc.next();           // read input as String
            String s   = sc.nextLine();       // read whole line as String

            int result = 3*n;
            out.println(result);                    // print via PrintWriter
        */

        // Stop writing your solution here. -------------------------------------
        BufferedReader br;
        StringTokenizer st;

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

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

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

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

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

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

    }

    public static void main(String[] args) {
        Task1Div430.MyScanner in = new Task1Div430.MyScanner();
        //This is sparta
        int l = in.nextInt();
        int r = in.nextInt();
        int x = in.nextInt();
        int y = in.nextInt();
        long k = in.nextLong();
        long eff = 1;
        for(int j = x; j <= y; j++){
            eff = 1;
            eff = k * j;
            if(l <= eff && eff <= r){
                System.out.println("YES");
                return;
            }
        }
        System.out.println("NO");
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.HashMap;
import java.util.StringTokenizer;

public class Solution {

	static class FastReader {
		BufferedReader br;
		StringTokenizer st;

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

		String next() {
			while (st == null || !st.hasMoreTokens()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

		String nextLine() {
			String str = "";
			try {
				str = br.readLine();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			return str;
		}

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

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

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

	public static void main(String[] args) {
		FastReader sc = new FastReader();
		String[] ss = sc.nextLine().split(" ");
		int l = Integer.parseInt(ss[0]);
		int r = Integer.parseInt(ss[1]);
		int x = Integer.parseInt(ss[2]);
		int y = Integer.parseInt(ss[3]);
		double k = Double.parseDouble(ss[4]);
		for(int i=x;i<=y;i++){
			int xx = (int) (i*k);
		if (xx>=l && xx<=r){
				System.out.println("YES");
				return;}

	}
		System.out.println("NO");
	}

}

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

public class TestClass {
	static BufferedReader br;
	static StringTokenizer st;
	static PrintWriter out;

	public static void main(String[] args) {
		br = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(new OutputStreamWriter(System.out));
		solve();
		out.close();
	}

	public static void solve() {
		int l = nextInt();
		int r = nextInt();
		int x = nextInt();
		int y = nextInt();
		int k = nextInt();
		int firstMultipleOfK = (int) Math.ceil(l / (1.0 * k));
		int lastMultipleOfK = (int) Math.floor(r / (1.0 * k));
		// out.println(firstMultipleOfK + " " + lastMultipleOfK);
		if(firstMultipleOfK > lastMultipleOfK) {
			out.println("NO");
			return;
		}
		if(firstMultipleOfK <= y && x <= lastMultipleOfK) {
			out.println("YES");
		} else {
			out.println("NO");
		}
	}

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

	static int nextInt() {
		return Integer.parseInt(next());
	}

	static long nextLong() {
		return Long.parseLong(next());
	}

	static String nextLine() {
		String str = "";
		try {
			str = br.readLine();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return str;
	}
}

//AMBIKESH JHA (jhaambikesh)
//MNNIT,ALLAHABAD-
import java.util.*;
import java.io.*;
import java.math.*;
public class QuestionA {
	public static void main(String[] args)throws IOException{
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      String[] strArray=br.readLine().split(" ");
      int l=Integer.parseInt(strArray[0]);
      int r=Integer.parseInt(strArray[1]);
      int x=Integer.parseInt(strArray[2]);
      int y=Integer.parseInt(strArray[3]);
      double k=Double.parseDouble(strArray[4]);
      double high=0.0,low=0.0;
      boolean brokeLoop=false;
      for(int i=x;i<=y;i++){
    	  double t=i*k;
    	  if(t==(int)t)
    		  if(t>=l && t<=r)
    			  {System.out.println("YES");
    			  brokeLoop=true;
    	          break;}
    	  }
      if(!brokeLoop)
      System.out.println("NO");
}
}

import java.util.*;
public class KirillAndTheGame {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int l, r, x, y, k;
		Scanner sc= new Scanner(System.in);
		l=sc.nextInt();
		r=sc.nextInt();
		x=sc.nextInt();
		y=sc.nextInt();
		k=sc.nextInt();
		boolean cd =false;
		for(int i=x;i<=y;i++){
			long j=(long)k*i;
			if(j<=r && j>=l){
				cd =true;
				break;
			}
		}
		if(cd){
			System.out.println("YES");
		}
		else{
			System.out.println("NO");
		}
		sc.close();
	}

}

import java.util.Scanner;

public class Solution {

	public static void main(String[] args) {

		Scanner s=new Scanner(System.in);

		long l=s.nextInt();
		long r=s.nextInt();
		long x=s.nextInt();
		long y=s.nextInt();
		long k=s.nextInt();

		for(long i=x;i<=y;i++){

			if((i*k)>=l && (i*k)<=r){
				System.out.println("YES");
				return;
			}

		}
		System.out.println("NO");
	}

}

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

/**
 *
 * @author dipankar12
 */
import java.io.*;
import java.util.*;
public class r842a {
    public static void main(String args[])
    {
        fastio in=new fastio(System.in);
        PrintWriter pw=new PrintWriter(System.out);

        int l=in.nextInt();
        int r=in.nextInt();
        int x=in.nextInt();
        int y=in.nextInt();
        int k=in.nextInt();

        int flag=0;
        for(int i=l;i<=r;i++)
        {
            if((i/k)>=x&&(i/k)<=y)
            {
                if((int)Math.ceil((double)i/(double)k)==i/k)
                {
                    //System.out.println("k "+k+" i "+i+" x "+ k/i);
                    pw.println("Yes");
                    flag=-1;
                    break;
                }
            }
        }
        if(flag==0)
            pw.println("NO");

        pw.close();
    }

    static class fastio {

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

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

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

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

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

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

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

            public String nextLine() {
                int c = nxt();
                while (isSpaceChar(c))
                    c = nxt();
                StringBuilder res = new StringBuilder();
                do {
                    res.appendCodePoint(c);
                    c = nxt();
                } 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);
            }
        }

}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.PrintStream;
import java.util.Scanner;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author useless_fellow
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        Scanner in = new Scanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, Scanner in, PrintWriter out) {
            long l = in.nextInt();
            long r = in.nextInt();
            long x = in.nextInt();
            long y = in.nextInt();
            long k = in.nextInt();
            boolean found = false;
            for (long i = x * k; i <= y * k; i += k) {
                if (i >= l && i <= r) {
                    found = true;
                    break;
                }
            }
            if (found) System.out.println("YES");
            else System.out.println("NO");
        }

    }
}

import java.io.BufferedReader;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;
public class round4q1 {

	public static void main(String[] args) throws IOException
    {
		BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(bf.readLine(), " ");
         int l=Integer.parseInt(st.nextToken());
         int r=Integer.parseInt(st.nextToken());
         int x=Integer.parseInt(st.nextToken());
         int y=Integer.parseInt(st.nextToken());
         int k=Integer.parseInt(st.nextToken());

         for(int i=l;i<=r;i++){
        	 if(i%k==0&&i/k>=x&&i/k<=y)
        	 {System.out.println("YES");
        	  return;
        	 }
         }
         System.out.println("NO");
		//		int x[]=new int[];
//		Integer.parseInt(st.nextToken());

    }
 }

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

public class Kirill_And_The_Game {
	public static void main(String[] args) throws IOException {
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));

		StringTokenizer st = new StringTokenizer(in.readLine());
		double l = Double.parseDouble(st.nextToken());
		double r = Double.parseDouble(st.nextToken());
		double x = Double.parseDouble(st.nextToken());
		double y = Double.parseDouble(st.nextToken());
		double k = Double.parseDouble(st.nextToken());

		boolean found = false;
		for (double i = x; i <= y; i++) {
			if (l <= i * k && i * k <= r) {
				found = true;
			}
		}

		if (found) {
			System.out.println("YES");
		}
		else {
			System.out.println("NO");
		}

		in.close();
	}
}

import java.util.Scanner;

/**
 * Created by phuoc on 8/29/17.
 */
public class A_430 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int l = in.nextInt();
        int r = in.nextInt();
        int x = in.nextInt();
        int y = in.nextInt();
        float k = in.nextFloat();
        boolean check = false;
        for (int i = x; i <= y; i++) {
            if (k * i <= r && k * i >= l) {
                check = true;
            }
        }
        if (check) System.out.println("Yes");
        else System.out.println("No");
    }
}

import java.util.Scanner;

/**
 * Created by phuoc on 8/29/17.
 */
public class A_430 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int l = in.nextInt();
        int r = in.nextInt();
        int x = in.nextInt();
        int y = in.nextInt();
        float k = in.nextFloat();
        boolean check = false;
        for (int i = x; i <= y; i++) {
            if (k * i <= r && k * i >= l) {
                check = true;
                break;
            }
        }
        if (check) System.out.println("Yes");
        else System.out.println("No");
    }
}

import java.util.Scanner;

public class aug_29_p1 {

	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int l = scan.nextInt(),r = scan.nextInt(),x = scan.nextInt(),y = scan.nextInt();
		double k = scan.nextInt();

		for (int i = l; i <= r; i++){
			 if (i%k==0&&i/k>=x&&i/k<=y){
				 System.out.println("YES");
				 return;
			 }

		}
		//
		System.out.println("NO");
	}

}

import java.util.ArrayList;
import java.util.Scanner;

public class Main {

	public static void main(String[] args) {

		Scanner in = new Scanner(System.in);

		//inputs
		int l = in.nextInt();
		int r = in.nextInt();
		int x = in.nextInt();
		int y = in.nextInt();
		double k = in.nextDouble();

	  for(int i=x ; i<=y ; i++)
		  if(k * i >= l && k * i <= r){
			  System.out.println("YES");
			  System.exit(0);
		  }

	  System.out.println("NO");

	}

}

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int l = in.nextInt(), r = in.nextInt(), x = in.nextInt(), y = in.nextInt(), k = in.nextInt();
		for (int i = l; i <= r; i++) {
			if (i % k == 0) {
				double c = i*1.0 / k;
				if (c >= x && c <= y) {
					System.out.println("YES");
					return;
				}
			}
		}
		System.out.println("NO");
	}
}

/* package whatever; // don't place package name! */

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

/* Name of the class has to be "Main" only if the class is public. */
public class Ideone
{
	public static void main (String[] args) throws java.lang.Exception
	{
		// your code goes here
		Scanner sc = new Scanner(System.in);
		long l = sc.nextLong();
		long r = sc.nextLong();
		long x = sc.nextLong();
		long y = sc.nextLong();
		long k = sc.nextLong();
		for(long i=x;i<=y;i++){
			long t = i * k;
			if(t>=l&&t<=r){
				System.out.println("YES");
				return;
			}
		}
		System.out.println("NO");
	}
}

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

public class Main {

    public static void main(String[] args) throws Exception {
        FastReader fr = new FastReader();
        long l = fr.nextInt(), r = fr.nextInt(), x = fr.nextInt(), y = fr.nextInt(), k = fr.nextInt();
        int ans = 0;
        for (long i = x; i <= y; i++) {
            if (l <= i * k && i * k <= r) {
                ans = 1;
            }
        }
        if (ans>0) {
            System.out.println("YES");
        } else {
            System.out.println("NO");
        }
    }

}

class FastReader {

    BufferedReader br;
    StringTokenizer st;

    public FastReader() throws FileNotFoundException {
        br = new BufferedReader(new InputStreamReader(System.in));
    }

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

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

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

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

    String nextLine() {
        String str = "";
        try {
            str = br.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return str;
    }
}

import java.util.*;

public class Main
{

	public static void main(String[] args)
	{

		Scanner sc = new Scanner(System.in);
		long l = sc.nextInt();
		long r = sc.nextInt();
		long x = sc.nextInt();
		long y = sc.nextInt();

		long k = sc.nextInt();

		long min = k*y - l;
		long max = r - k*x;

		if(min>=0 && max>=0)
		{
			boolean check = false;

			for(long i=x;i<=y && k*i<=r && !check;i++)
			{
				if(k*i<=r && k*i>=l)
					check = true;
			}

			if(check)
				System.out.println("YES");
			else
				System.out.println("NO");
		}
		else
			System.out.println("NO");
	}
}

 import java.util.*;
import java.io.*;
public class Code{
    //experience=k*cost
    public static void main(String [] Args){
        Scanner scan=new Scanner(System.in);
        long l=scan.nextInt();
        long r=scan.nextInt();
        long x=scan.nextInt();
        long y=scan.nextInt();
        long k=scan.nextInt();
        boolean flag=false;
        for(long i=x;i<=y;i++){
                if(((i*k)>=l) && ((i*k)<=r)){
                    flag=true;
                    break;
                }
        }
        if(flag){
            System.out.println("YES");
        }else{
            System.out.println("NO");
        }

    }
}

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

public class Tester
{
	InputStream is;
	PrintWriter out;
	String INPUT = "";

	void solve()
	{
	    int l=ni();
	    int r=ni();
	    int x=ni();
	    int y=ni();
	    double k=nd();
	    for(int i=x;i<=y;i++)
	    {
	    	if(i*k>=l&&i*k<=r)
	    	{
	    		out.println("YES");
	    		return;
	    	}
	    }
	    out.println("NO");
	}

	void run() throws Exception
	{
		is = INPUT.isEmpty() ? System.in : new ByteArrayInputStream(INPUT.getBytes());
		out = new PrintWriter(System.out);

		long s = System.currentTimeMillis();
		solve();
		out.flush();
		if(!INPUT.isEmpty())tr(System.currentTimeMillis()-s+"ms");
	}

	public static void main(String[] args) throws Exception
	{ new Tester().run(); }

	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 static void tr(Object... o)
	{ System.out.println(Arrays.deepToString(o)); }
}

import java.util.Scanner;

public class Krill {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		int l = sc.nextInt();
		int r = sc.nextInt();
		int x = sc.nextInt();
		int y = sc.nextInt();
		double k = sc.nextDouble();
		sc.close();

		if (l < 1 || l > r || l > 10000000 || r > 10000000) {
			System.out.println("NO");
		} else if (x < 1 || x > y || x > 10000000 || y > 10000000) {
			System.out.println("NO");
		} else if (k < 1.0 || k > 10000000.0) {
			System.out.println("NO");
		} else {
			boolean found = false;
			for (int b = x; b <= y; b++) {
				int a = (int) (k * b);
				if (a >= l && a <= r) {
					found = true;
					System.out.println("YES");
					break;
				}
				found = false;
			}
			if (found == false) {
				System.out.println("NO");
			}
		}
	}

}

import java.util.Scanner;

public class Main {

	@SuppressWarnings("resource")
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		while (sc.hasNext()) {
			long l = sc.nextLong();
			long r = sc.nextLong();
			long x = sc.nextLong();
			long y = sc.nextLong();
			long k = sc.nextLong();
			long ans = 0;
			for (long i = x; i <= y; i++) {
				if (i * k >= l && i * k <= r) {
					ans++;
					break;
				}
			}
			if (ans > 0) {
				System.out.println("YES");
			} else {
				System.out.println("NO");
			}
		}

	}

}

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

public class Main {
    public static void main (String[] args) throws java.lang.Exception {
        Output out = new Output();
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;
        st = new StringTokenizer(br.readLine());
        int l = Integer.parseInt(st.nextToken()),
            r = Integer.parseInt(st.nextToken()),
            x = Integer.parseInt(st.nextToken()),
            y = Integer.parseInt(st.nextToken()),
            k = Integer.parseInt(st.nextToken());
        int a = (int)Math.ceil((double)l/k);
        int b = (int)Math.floor((double)r/k);
        if (a<=b && b>=x && a<=y) out.println("YES");
        else out.println("NO");
        out.flush();

    }

}

class Output {
    private BufferedWriter out;

    Output() {
        this.out = new BufferedWriter(new OutputStreamWriter(System.out));
    }

    void print(String s) throws IOException {this.out.write(s);}
    void println(String s) throws IOException {this.out.write(s + "\n");}
    void println(long n) throws IOException {this.out.write(n + "\n");}
    void println(int n) throws IOException {this.out.write(n + "\n");}
    void flush () throws IOException {this.out.flush();}
}

import java.util.*;

public class Main {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int l = in.nextInt();
        int r = in.nextInt();
        int x = in.nextInt();
        int y = in.nextInt();
        int k = in.nextInt();

        if (k <= r / x && k >= l / y) {
            for (int i = x; i <= y; i++) {
                int k1 = k * i;
                if(k1 >= l && k1 <= r){
                    p("YES");
                    return;
                }
            }
        }
        p("NO");
    }

    public static void p(Object str) {
        System.out.println(str);
    }

    public static void pa(List<Object> objs) {
        String str = "";
        for (Object obj : objs) {
            str += obj.toString() + " ";
        }
    }
}

import java.util.Scanner;

public class CodeForces430 {
	public static void main(String argv[]) {
		Scanner stdin = new Scanner(System.in);

		boolean ans = false;
		final int EXP_LO  = stdin.nextInt(),
			  	  EXP_HI  = stdin.nextInt(),
			  	  COST_LO = stdin.nextInt(),
			   	  COST_HI = stdin.nextInt();
		final double EFFICIENCY = stdin.nextDouble();

		for(int i = COST_LO; i <= COST_HI; ++i) {
			if((i * EFFICIENCY >= EXP_LO) && (i * EFFICIENCY <= EXP_HI)) {
				ans = true;
				break;
			}
		}

		if(ans) System.out.println("YES");
		else System.out.println("NO");
	}
}

import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.BigDecimal;

public class R430B {
    public static void main (String[] args) throws java.lang.Exception {
        Scanner in = new Scanner(System.in);
        PrintWriter w = new PrintWriter(System.out);
        long l = in.nextLong(), r = in.nextLong(), x = in.nextLong(), y = in.nextLong(), k = in.nextLong();

        for (long i = l; i <= r; i++) {
            if (i / (k * 1.0) == 1.0 * (i / k) && ((i / k) >= x && (i / k) <= y)) {
                w.println("YES");
                w.close();
                return;
            }
        }
        w.println("NO");
        w.close();

    }

}

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

public class Main {

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

        new Main().go();
    }

    PrintWriter out;
    Reader in;
    BufferedReader br;

    Main() throws IOException {

        try {

            //br = new BufferedReader( new FileReader("input.txt") );
            in = new Reader("input.txt");
            out = new PrintWriter( new BufferedWriter(new FileWriter("output.txt")) );
        }
        catch (Exception e) {

            //br = new BufferedReader( new InputStreamReader( System.in ) );
            in = new Reader();
            out = new PrintWriter( new BufferedWriter(new OutputStreamWriter(System.out)) );
        }
    }

    void go() throws IOException {

        int t = 1;
        while (t > 0) {
            solve();
            //out.println();
            t--;
        }

        out.flush();
        out.close();
    }

    int inf = 2000000000;
    int mod = 1000000007;
    double eps = 0.00000001;

    int n;
    int m;

    ArrayList<Integer>[] g = new ArrayList[200000];
    HashMap<Integer, HashMap<Integer, Boolean>> map = new HashMap<>();

    void solve() throws IOException {

        int l = in.nextInt();
        int r = in.nextInt();

        int x = in.nextInt();
        int y = in.nextInt();

        int k = in.nextInt();

        for (int i = x; i <= y; i++) if (1l*k*i >= l && 1l*k*i <= r) { out.println("YES"); return; } out.println("NO");

    }

    class Pair implements Comparable<Pair>{

        int a;
        int b;

        Pair(int a, int b) {

            this.a = a;
            this.b = b;
        }

        public int compareTo(Pair p) {

            if (a > p.a) return 1;
            if (a < p.a) return -1;
            if (b > p.b) return 1;
            if (b < p.b) return -1;
            return 0;
        }
    }

    class Item {

        int a;
        int b;
        int c;

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

    }

    class Reader {

        BufferedReader  br;
        StringTokenizer tok;

        Reader(String file) throws IOException {
            br = new BufferedReader( new FileReader(file) );
        }

        Reader() throws IOException {
            br = new BufferedReader( new InputStreamReader(System.in) );
        }

        String next() throws IOException {

            while (tok == null || !tok.hasMoreElements())
                tok = new StringTokenizer(br.readLine());
            return tok.nextToken();
        }

        int nextInt() throws NumberFormatException, IOException {
            return Integer.valueOf(next());
        }

        long nextLong() throws NumberFormatException, IOException {
            return Long.valueOf(next());
        }

        double nextDouble() throws NumberFormatException, IOException {
            return Double.valueOf(next());
        }

        String nextLine() throws IOException {
            return br.readLine();
        }

    }

}

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        Scanner in = new Scanner(System.in);
        int l,r,x,y;
        long k;
        l = in.nextInt();
        r = in.nextInt();
        x = in.nextInt();
        y = in.nextInt();
        k = in.nextLong();

        long tmp;
        for(long i=x ; i<=y ; i++) {
            tmp = i*k;
            if(tmp >= l && tmp <= r) {
                System.out.println("YES");
                return;
            }
        }

        System.out.println("NO");
    }
}

import java.util.*;
public class Potion {

    public static void main(String args[])
    {
    	Scanner in=new Scanner(System.in);
    	long l=in.nextLong();
    	long r=in.nextLong();
    	long x=in.nextLong();
    	long y=in.nextLong();
    	double k=in.nextDouble();

    	double ans[]=new double[(int)(y-x+1)];
    	int c=0;
    	for(long i=x;i<=y;i++)
    		ans[c++]=(double)k*i;
    	double a[]=new double[(int)(r-l+1)];
    	c=0;
    	for(long i=l;i<=r;i++)
    		a[c++]=(double)i;

    	/*for(int i=0;i<ans.length;i++)
    		System.out.print(ans[i] +" ");
    	System.out.println();*/
    /*	for(int i=0;i<a.length;i++)
    		System.out.print(a[i] +" ");
    	System.out.println();
    	*/
    	for(long i=0;i<ans.length;i++)
    	{
    		/*System.out.println(Arrays.binarySearch(a,ans[(int)i]));*/
    		 if(Arrays.binarySearch(a,ans[(int)i])>=0)
    			 {System.out.println("YES");System.exit(0);}
    	}
    	System.out.println("NO");
    }
}

import java.util.Scanner;

public class kirillAndTheGame {
	public static void main(String[] args) {

		Scanner kbd = new Scanner(System.in);

		long l = 0;
		long r = 0;
		long x = 0;
		long y = 0;
		long k = 0;

		l = kbd.nextInt();
		r = kbd.nextInt();
		x = kbd.nextInt();
		y = kbd.nextInt();
		k = kbd.nextInt();

		boolean found = false ;

		for (long b = x; b <= y; ++b) {
			long a = k * b;
			if (a >= l && a <= r) {
				found = true ;
				break;
			}
			}

			if(found) {
				System.out.print("Yes");
			}else
				System.out.println("No");

			return;
		}

	}

import java.math.BigDecimal;
import java.util.Scanner;

/**
 *
 * @author mou1609
 */
public class g {

     public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        long l = sc.nextInt();
        long r = sc.nextInt();
        long x = sc.nextInt();
        long y = sc.nextInt();
        long k = sc.nextInt();

        for (long i = x; i <= y; ++i) {
            if (k * i >= l && k * i <= r) {
                System.out.println("YES");
                return ;
            }
        }
        System.out.println("NO");

        return ;
    }

}

import java.util.Scanner;

public class a2 {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
	    int a=scan.nextInt(), b=scan.nextInt(), x=scan.nextInt(), y=scan.nextInt();
	    double k=scan.nextDouble();
	    for(int i=x; i<=y; i++) {
	        if(i*k>=a&&i*k<=b) {System.out.println("YES"); return;}
	    }
	    System.out.println("NO");
	}
}

import java.util.*;

public class GFG {
	public static Scanner in = new Scanner(System.in);

	public static void main(String[] args) {
		// code
		long l = in.nextLong();
		long r = in.nextLong();
		long x = in.nextLong();
		long y = in.nextLong();
		long k = in.nextLong();

		for (long i = x; i <= y; i++) {
			if (k * i <= r && k * i >= l) {
				System.out.println("YES");
				return;
			}
		}

		System.out.println("NO");
	}

}

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

public class R430A {
    public static void main(String[] args) {
        new R430A().run();
    }

    //Scanner sc;
    private FastScanner sc;
    private PrintWriter out;

    int l, r; // a, количество опыта
    int x, y; // b, стоимость
    double need; // need = a/b

    public void solve() {
        //sc = new Scanner(System.in);

        l = sc.nextInt();
        r = sc.nextInt();
        x = sc.nextInt();
        y = sc.nextInt();
        need = sc.nextDouble();

        for (int i=x; i<=y; i++) {
            double cur = need*i;
            if (cur >= l && cur <= r) {
                System.out.println("YES");
                return;
            }
        }

        System.out.println("NO");

    }

    private void run() {
        /*try {
            sc = new FastScanner(new File("input.txt"));
            out = new PrintWriter(new File("output.txt"));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }*/

        sc = new FastScanner(System.in);
        out = new PrintWriter(System.out);

        solve();

        out.close();

    }

    private class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        FastScanner(File f) {
            try {
                br = new BufferedReader(new FileReader(f));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }

        FastScanner(InputStream f) {
            br = new BufferedReader(new InputStreamReader(f));
        }

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

        boolean hasMoreTokens() {
            while (st == null || !st.hasMoreTokens()) {
                String s = null;
                try {
                    s = br.readLine();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (s == null)
                    return false;
                st = new StringTokenizer(s);
            }
            return true;
        }

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

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

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

}

/*
1 10
1 10
1

1 5
6 10
1

NO

*/

import java.util.*;
import java.math.*;
import java.io.*;
import java.text.*;

public class A {
    static class Node implements Comparable<Node>{
        int from;
        int to;
        int w;

        public Node(int from ,int to ,int w){
           this.from=from;
           this.to=to;
           this.w=w;
        }
        public int compareTo(Node c){
            int i=0;

          return i;

        }
        @Override
        public boolean equals(Object o){
            if(o instanceof Node){
                Node c = (Node)o;
                return true;
            }
            return false;
        }
    }

    //public static PrintWriter pw;
    public static PrintWriter pw = new PrintWriter(System.out);

    public static void solve() throws IOException {
//	pw=new PrintWriter(new FileWriter("C:\\Users\\shree\\Downloads\\small_output_in"));
        FastReader sc = new FastReader();
       long l=sc.I();
       long r=sc.I();
       long x=sc.I();
       long y=sc.L();
       long k=sc.L();
       for(long i=l;i<=r;i++){
          if(i%k==0){
              long b=i/k;
              if(b>=x && b<=y){
                  pw.println("YES");
                  pw.close();
                  return;
              }
          }
       }

       pw.println("NO");
        pw.close();

    }

    public static void main(String[] args) {
        new Thread(null, new Runnable() {
            public void run() {
                try {

                    solve();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }, "1", 1 << 26).start();

    }

    static BufferedReader br;
    static long M = (long) 1e9 + 7;

    static class FastReader {

        StringTokenizer st;

        public FastReader() throws FileNotFoundException {
            //br=new BufferedReader(new FileReader("C:\\Users\\shree\\Downloads\\B-small-practice.in"));
            br = new BufferedReader(new InputStreamReader(System.in));

        }

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

        int I() {
            return Integer.parseInt(next());
        }

        long L() {
            return Long.parseLong(next());
        }

        double D() {
            return Double.parseDouble(next());
        }

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

        public boolean hasNext() throws IOException {
            while (st == null || !st.hasMoreTokens()) {
                String s = br.readLine();
                if (s == null) {
                    return false;
                }
                st = new StringTokenizer(s);
            }
            return true;
        }

    }
}

import java.util.Scanner;
public class A {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);

		long L = in.nextLong();
		long R = in.nextLong();
		long X = in.nextLong();
		long Y = in.nextLong();
		long K = in.nextLong();

		if(K*Y<L || K*X>R) System.out.println("NO");
		else {
			int flag=0;
			for(long i=X; i<=Y; i++) {
				if(i*K>=L&&i*K<=R) {
					flag=1;
					break;
				}
			}
			if(flag==1) System.out.println("YES");
			else System.out.println("NO");
		}

		in.close();
	}
}

import java.util.*;

public class A842 {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int l = in.nextInt();
		int r = in.nextInt();
		int x = in.nextInt();
		int y = in.nextInt();
		int k = in.nextInt();

		String ans = "NO";
		for( int i = x; i <= y; i++ ) {
			if( (float)k*i >= (float)l && (float)k*i <= (float)r ) {
				ans = "YES";
				break;
			}
		}

		System.out.println(ans);
	}
}

import java.util.*;
public final class code{
	public static void main(String[] arg){
		Scanner in=new Scanner(System.in);
		double l=in.nextDouble();
		double r=in.nextDouble();
		double x=in.nextDouble();
		double y=in.nextDouble();
		double k=in.nextDouble();
		boolean flag=false;
		if(k>r/x || k<l/y){
			System.out.println("NO");
		}else{
			double i=l;
			double j=x;
			while(i<=r && j<=y){
				if((i/j)>k){
					j++;
				}else if((i/j)<k){
					i++;
				}else{
					flag=true;
					break;
				}
			}
		if(flag==true){
			System.out.println("YES");
		}else{
			System.out.println("NO");
		}
	}
	}
}

import java.util.*;
import java.io.*;
public class A {

    public static void main(String[] args) {
        new A();
    }
    Scanner s = new Scanner();
    public A() {
        long a = s.nextInt();
        long b = s.nextInt();
        long x = s.nextInt();
        long y = s.nextInt();
        long k = s.nextInt();

        boolean good = false;

        for (long i = x; i <= y; i++) {
            if (k*i >= a && k*i <= b)
                good = true;
        }

        if (good) {
            System.out.println("YES");
        }
        else{
            System.out.println("NO");
        }
    }

    public static class Scanner {
        BufferedReader br;
        StringTokenizer st;

        public Scanner(Reader in) {
            br = new BufferedReader(in);
        }

        public Scanner() {
            this(new InputStreamReader(System.in));
        }

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

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

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

        double nextDouble() {
            return Double.parseDouble(next());
        }
        String readNextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }

}

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

public class A842 {

	public static void main(String[] args) throws IOException {
		IO io = new IO(System.in);

		long l = io.nextInt();
		long r = io.nextInt();
		long x = io.nextInt();
		long y = io.nextInt();
		long k = io.nextInt();

		long b = x;
		long tar = 0;

		while (tar <= r) {
			tar = k*b;
			if (tar >= l && tar <= r) {
				io.println("YES");
				io.close();
				System.exit(0);
			}
			b++;
			if (b>y) break;
		}

		io.println("NO");

		io.close();
	}

	static class IO extends PrintWriter {
		static BufferedReader r;
		static StringTokenizer t;

		public IO(InputStream i) {
			super(new BufferedOutputStream(System.out));
			r = new BufferedReader(new InputStreamReader(i));
			t = new StringTokenizer("");
		}

		public String next() throws IOException {
			while (!t.hasMoreTokens()) {
				t = new StringTokenizer(r.readLine());
			}
			return t.nextToken();
		}

		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}

		public double nextDouble() throws IOException {
			return Double.parseDouble(next());
		}
	}
}

import java.util.Scanner;

public class numbajuan {

	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
			int b = scan.nextInt();
			int c = scan.nextInt();
			int d = scan.nextInt();
			int e = scan.nextInt();
			int f = scan.nextInt();
			for(int i = b;i<=c;i++){
				int g = i/f;
				if(i%f == 0 && g >= d && g <= e){
					System.out.println("YES");
					return;
				}
			}
			System.out.println("NO");
		}

	}

import java.io.BufferedReader;
import java.io.Closeable;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class Main {

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

        FastScan sc = new FastScan(new BufferedReader(new InputStreamReader(System.in)));
        PrintWriter pw = new PrintWriter(System.out);
        long l = sc.ln();
        long r = sc.ln();
        long x = sc.ln();
        long y = sc.ln();
        long k = sc.ln();

        long small;
        long big;

        small = k*x;
        big = k*y;
        for (long i = x; i <= y; i++) {
            long p = i * k;
            if (p >= l && p <= r) {
                pw.print("YES");
                pw.close();
                sc.close();
                return;
            }
        }
        pw.print("NO");

        /*if ((small < l && big < l) || (small > r && big > r)) {
            pw.print("NO");
        } else {
            pw.print("YES");
        }
*/
        sc.close();
        pw.close();
        System.exit(0);
    }

    static class FastScan implements Closeable {
        private BufferedReader br;
        private StringTokenizer tk;

        public FastScan(BufferedReader br) {
            this.br = br;
        }

        public int in() throws NumberFormatException, IOException {
            return Integer.parseInt(next());
        }

        public long ln() throws NumberFormatException, IOException {
            return Long.parseLong(next());
        }

        public double db() throws NumberFormatException, IOException {
            return Double.parseDouble(next());
        }

        @Override
        public void close() throws IOException {
            tk = null;
            br.close();
        }

        public String next() throws IOException {
            while (tk == null || !tk.hasMoreTokens()) {
                String line = br.readLine();
                if (line == null)
                    return null;
                tk = new StringTokenizer(line);
            }
            return tk.nextToken();
        }
    }
}

//package round430;

import java.util.Scanner;

/**
 * Created by nikitos on 30.08.17.
 */

public class A {

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int l = scan.nextInt();
        int r = scan.nextInt();
        int x = scan.nextInt();
        int y = scan.nextInt();
        double k = scan.nextInt();
        boolean f = false;
        for (int i = x; i <= y; i++) {
            if (k * i >= l && k * i <= r) {
                f = true;
                break;
            }
        }
        if (!f) {
            System.out.println("NO");
        } else {
            System.out.println("YES");
        }
    }

}

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;

public class A {
	static FastReader scan;
	static PrintWriter out;

	public static void main(String[] args) throws FileNotFoundException {
		Solver solver = new Solver();
		scan = new FastReader();
		out = new PrintWriter(System.out);
		int testCases = 1;
		for(int i = 1; i <= testCases; i++) {
//			out.print("Case #" + i + ": ");
			solver.solve();
		}
		out.close();
	}

	static class Solver {

		void solve() {
			long l = scan.nextLong(), r = scan.nextLong(), x = scan.nextLong(), y = scan.nextLong(), k = scan.nextLong();
			for(long i = x; i <= y; i++) {
				if(k*i >= l && k*i <= r) {
					out.println("YES");
					return;
				}
			}
			out.println("NO");
		}

	}

	// Sathvik's Template Stuff BELOW!!!!!!!!!!!!!!!!!!!!!!

	static class DSU {
		int[] root, size;
		int n;

		DSU(int n) {
			this.n = n;
			root = new int[n];
			size = new int[n];
			for (int i = 0; i < n; i++) {
				root[i] = i;
				size[i] = 1;
			}
		}

		int findParent(int idx) {
			while (root[idx] != idx) {
				root[idx] = root[root[idx]];
				idx = root[idx];
			}
			return idx;
		}

		boolean union(int x, int y) {
			int parX = findParent(x);
			int parY = findParent(y);
			if (parX == parY)
				return false;
			if (size[parX] < size[parY]) {
				root[parY] = parX;
				size[parX] += size[parY];
			} else {
				root[parX] = parY;
				size[parY] += size[parX];
			}
			return true;
		}
	}

	static class Extra {
		static void sort(int[] a) {
			Integer[] aa = new Integer[a.length];
			for (int i = 0; i < aa.length; i++)
				aa[i] = a[i];
			Arrays.sort(aa);
			for (int i = 0; i < aa.length; i++)
				a[i] = aa[i];
		}

		static void sort(long[] a) {
			Long[] aa = new Long[a.length];
			for (int i = 0; i < aa.length; i++)
				aa[i] = a[i];
			Arrays.sort(aa);
			for (int i = 0; i < aa.length; i++)
				a[i] = aa[i];
		}

		static void sort(double[] a) {
			Double[] aa = new Double[a.length];
			for (int i = 0; i < aa.length; i++)
				aa[i] = a[i];
			Arrays.sort(aa);
			for (int i = 0; i < aa.length; i++)
				a[i] = aa[i];
		}

		static void sort(char[] a) {
			Character[] aa = new Character[a.length];
			for (int i = 0; i < aa.length; i++)
				aa[i] = a[i];
			Arrays.sort(aa);
			for (int i = 0; i < aa.length; i++)
				a[i] = aa[i];
		}

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

		static long lcm(long a, long b) {
			return a * (b / gcd(a, b));
		}

		static boolean isPrime(long n) {
			if (n <= 1)
				return false;
			if (n <= 3)
				return true;
			if (n % 2 == 0 || n % 3 == 0)
				return false;
			for (long i = 5; i * i <= n; i = i + 6) {
				if (n % i == 0 || n % (i + 2) == 0)
					return false;
			}
			return true;
		}
	}

	static class FastReader {
		BufferedReader br;
		StringTokenizer st;

		public FastReader() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}
		public FastReader(String s) throws FileNotFoundException {
			br = new BufferedReader(new FileReader(new File(s)));
		}

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

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

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

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

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

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

		double[] nextDoubleArray(int n) {
			double[] a = new double[n];
			for (int i = 0; i < n; i++)
				a[i] = nextDouble();
			return a;
		}

		String nextLine() {
			String str = "";
			try {
				str = br.readLine();
			} catch (IOException e) {
				e.printStackTrace();
			}
			return str;
		}
	}

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;

public class Main {

	static Scanner in = new Scanner(System.in);

	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());
		int x = Integer.valueOf(st.nextToken());
		int y = Integer.valueOf(st.nextToken());
		int l = Integer.valueOf(st.nextToken());
		int r = Integer.valueOf(st.nextToken());
		int k = Integer.valueOf(st.nextToken());

		long ls = (long)k * l;
		long rs = (long)k * r;
		//System.out.println(Long.MAX_VALUE);
//		System.out.println("ls==" + ls);
//		System.out.println("rs==" + rs);
//		System.out.println("y==" + y);
//		System.out.println("x==" + x);
		if (ls > y || rs < x) {
			System.out.println("NO");
		} else {
			//System.out.println("second");
			boolean find = false;
			for (long i = ls; i <= rs; i += k) {
				if (i >= x && i <= y) {
					find = true;
					break;
				}
			}
			if (find)
				System.out.println("YES");
			else {
				System.out.println("NO");
			}
		}
	}

}

import java.util.Scanner;

public class kirillAndGame {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Scanner scn = new Scanner(System.in);

		long l=scn.nextLong();
		long r=scn.nextLong();
		long x=scn.nextLong();
		long y=scn.nextLong();
		long k=scn.nextLong();

		int flag=0;

		for(long i=x;i<=y;i++)
		{
			if((long)i*k<=r&&(long)i*k>=l)
			{
				flag=1;
				break;
			}
		}
		if(flag==0)
			System.out.println("NO");
		else
			System.out.println("YES");

	}

}

// package cf842;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.InputMismatchException;

public class CFA {
    private static final String INPUT = "4 4 1 2 3";
    private static final int MOD = 1_000_000_007;

    private PrintWriter out;
    private FastScanner sc;

    public static void main(String[] args) {
        new CFA().run();
    }

    public void run() {
        sc = new FastScanner(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 void solve() {
        long l = sc.nextInt();
        long r = sc.nextInt();
        long x = sc.nextInt();
        long y = sc.nextInt();
        long k = sc.nextInt();

        long b = x;
        while (b*k < l) {
            if (b == y) break;
            b++;
        }
        long mul = b*k;
        if (mul >= l && mul <= r) {
            System.out.println("YES");
        } else {
            System.out.println("NO");
        }
    }

    //********************************************************************************************
    //********************************************************************************************
    //********************************************************************************************

    /**
     * If searched element doesn't exist, returns index of first element which is bigger than searched value.

     * If searched element is bigger than any array element function returns first index after last element.

     * If searched element is lower than any array element function returns index of first element.

     * If there are many values equals searched value function returns first occurrence.

     */
    private static int lowerBound(long[] arr, long key) {
        int lo = 0;
        int hi = arr.length - 1;
        while (lo < hi) {
            int mid = (lo + hi) / 2;
            if (key <= arr[mid]) {
                hi = mid - 1;
            } else {
                lo = mid + 1;
            }
        }
        return arr[lo] < key ? lo + 1 : lo;
    }

    /**
     * Returns index of first element which is grater than searched value.
     * If searched element is bigger than any array element, returns first index after last element.
     */
    private static int upperBound(long[] arr, long key) {
        int lo = 0;
        int hi = arr.length - 1;
        while (lo < hi) {
            int mid = (lo + hi) / 2;
            if (key >= arr[mid]) {
                lo = mid + 1;
            } else {
                hi = mid;
            }
        }
        return arr[lo] <= key ? lo + 1 : lo;
    }

    private static int ceil(double d) {
        int ret = (int) d;
        return ret == d ? ret : ret + 1;
    }

    private static int round(double d) {
        return (int) (d + 0.5);
    }

    private static int gcd(int a, int b) {
        BigInteger b1 = BigInteger.valueOf(a);
        BigInteger b2 = BigInteger.valueOf(b);
        BigInteger gcd = b1.gcd(b2);
        return gcd.intValue();
    }

    private static long gcd(long a, long b) {
        BigInteger b1 = BigInteger.valueOf(a);
        BigInteger b2 = BigInteger.valueOf(b);
        BigInteger gcd = b1.gcd(b2);
        return gcd.longValue();
    }

    private int[] readIntArray(int n) {
        int[] res = new int[n];
        for (int i = 0; i < n; i++) {
            res[i] = sc.nextInt();
        }
        return res;
    }

    private long[] readLongArray(int n) {
        long[] res = new long[n];
        for (int i = 0; i < n; i++) {
            res[i] = sc.nextLong();
        }
        return res;
    }

    @SuppressWarnings("unused")
    static class FastScanner {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;

        FastScanner(InputStream stream) {
            this.stream = stream;
        }

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

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

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

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }

        public String next() {
            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 (isEndline(c))
                c = read();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isEndline(c));
            return res.toString();
        }

    }

    private boolean oj = System.getProperty("ONLINE_JUDGE") != null;

    private void tr(Object... o) {
        if (!oj) System.out.println(Arrays.deepToString(o));
    }
}

import java.util.Scanner;

public class Beginer {

	public static void main(String[] args) {

		long  l , r ,  x , y ,  k ;

		Scanner reader = new Scanner(System.in);
		l = reader.nextInt();
		r = reader.nextInt();
		x = reader.nextInt();
		y = reader.nextInt();
		k = reader.nextInt();

		for (long i = x  ;i <= y ; i++)
		{
			if ((i*k)>=l && (i*k)<=r)
			{
				System.out.println("YES");
				return ;
			}
		}

		System.out.println("NO");

	}

}

import java.util.Scanner;

public class scratch_36 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        long l = scanner.nextInt();
        long r = scanner.nextInt();
        long x = scanner.nextInt();
        long y = scanner.nextInt();
        long k = scanner.nextInt();

        long aMin = x * k;
        long aMax = y * k;

        for (long i = Math.max(aMin, l); i <= Math.min(aMax, r); i++) {
            if (i % k == 0 ) {
                System.out.println("YES");
                return;
            }
        }

        System.out.println("NO");

    }
}

import java.util.*;
import java.io.*;
import java.math.*;
import java.util.regex.*;

public class Main {

    static Scanner input = new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    static Reader fastInput = new Reader();

    public static void main(String[] args) throws IOException {
        int l = input.nextInt();
        int r = input.nextInt();
        int x = input.nextInt();
        int y = input.nextInt();
        int k = input.nextInt();

        for (int i = x; i <= y; i++) {
            long a = ((long) i) * k;
            if (a >= l && a <= r) {
                System.out.println("YES");
                return;
            }
        }
        System.out.println("NO");
    }

    static class Reader {

        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;

        public Reader() {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public Reader(String file_name) throws IOException {
            din = new DataInputStream(new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public String readLine() throws IOException {
            byte[] buf = new byte[64]; // line length
            int cnt = 0, c;
            while ((c = read()) != -1) {
                if (c == '\n') {
                    break;
                }
                buf[cnt++] = (byte) c;
            }
            return new String(buf, 0, cnt);
        }

        public int nextInt() throws IOException {
            int ret = 0;
            byte c = read();
            while (c <= ' ') {
                c = read();
            }
            boolean neg = (c == '-');
            if (neg) {
                c = read();
            }
            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');

            if (neg) {
                return -ret;
            }
            return ret;
        }

        public long nextLong() throws IOException {
            long ret = 0;
            byte c = read();
            while (c <= ' ') {
                c = read();
            }
            boolean neg = (c == '-');
            if (neg) {
                c = read();
            }
            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');
            if (neg) {
                return -ret;
            }
            return ret;
        }

        public double nextDouble() throws IOException {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ') {
                c = read();
            }
            boolean neg = (c == '-');
            if (neg) {
                c = read();
            }

            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');

            if (c == '.') {
                while ((c = read()) >= '0' && c <= '9') {
                    ret += (c - '0') / (div *= 10);
                }
            }

            if (neg) {
                return -ret;
            }
            return ret;
        }

        private void fillBuffer() throws IOException {
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            if (bytesRead == -1) {
                buffer[0] = -1;
            }
        }

        private byte read() throws IOException {
            if (bufferPointer == bytesRead) {
                fillBuffer();
            }
            return buffer[bufferPointer++];
        }

        public void close() throws IOException {
            if (din == null) {
                return;
            }
            din.close();
        }
    }
}

//package codeforces;

import java.util.*;
public class solution
{
    public static void main(String args[])
    {
        Scanner in=new Scanner(System.in);
        long a11=in.nextLong();
        long a2=in.nextLong();
        long b1=in.nextLong();
        long b2=in.nextLong();
        double k=in.nextLong();
        int f=0;
        for(long i=b1;i<=b2;i++)
        {
            double r=i*k;
           // System.out.println(r);
            if(r>=a11 && r<=a2)
            {
                f=1;
                break;
            }
        }
        if(f==0)
        {
            System.out.println("NO");
        }
        else
        {
            System.out.println("YES");
        }
    }
}

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

public class KirillGame {
	static class InputReader {
		private BufferedReader br;
		private StringTokenizer st;
		InputReader ( InputStream in ) {
			br = new BufferedReader ( new InputStreamReader ( in ) );
			st = null;
		}
		public String next() {
			while ( st == null || !st.hasMoreTokens() ) {
				try {
					st = new StringTokenizer ( br.readLine() );
				}	catch ( Exception e ) {
					throw new RuntimeException ( e );
				}
			}
			return st.nextToken();
		}
		public int nextInt() {
			return Integer.parseInt ( next() );
		}
	}
	static class Task implements Runnable {
		private void solve ( InputReader in, PrintWriter out ) {
			int l = in.nextInt(), r = in.nextInt(), x = in.nextInt(), y = in.nextInt(), k = in.nextInt();
			boolean flag = false;
			long temp = 0;
			for ( int i = x; i <= y; ++i ) {
				if ( ( temp = ( ( long ) k ) * i ) >= l && temp <= r ) {
					flag = true;
					break;
				}
			}
			out.println ( flag ? "YES" : "NO" );
		}
		@Override
		public void run() {
			InputReader in = new InputReader ( System.in );
			PrintWriter out = new PrintWriter ( System.out );
			solve ( in, out );
			out.close();
		}
	}
	public static void main ( String[] args ) {
		// new Thread ( null, new Task(), "Solution", ( 1 << 26 ) ).start();
		new Task().run();
	}
}

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

public class A {
    FScanner in = new FScanner();
    PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out), true);

    boolean binSearch (int i, int x, int y, int k) {
        double kk = k;
        while (y > x) {
            int m = x + ((y - x) >> 1);
            if ((double) i / m == kk)
                return true;
            else if ((double) i / m < kk)
                y = m;
            else
                x = m + 1;
        }
        return (double) i / y == kk;
    }

    void run() {
        int l = in.nextInt();
        int r = in.nextInt();
        int x = in.nextInt();
        int y = in.nextInt();
        int k = in.nextInt();
        boolean ok = false;
        for (int i = l; i <= r; i++) {
            if (binSearch(i, x, y, k)) {
                ok = true;
                break;
            }
        }
        out.print(ok ? "YES" : "NO");
        out.close();
    }

    public static void main(String[] args){
        new A().run();
    }

    static class FScanner {
        BufferedReader br;
        StringTokenizer st;

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

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

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

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

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

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

        char[][] nextCharArray(int n, int m){
            char[][] g = new char[n][m];
            for(int i = 0; i < n; i++)
                g[i] = next().toCharArray();
            return g;
        }

        double[] nextDoubleArray(int n){
            double[] a = new double[n];
            for(int i = 0; i < n; i++)
                a[i] = nextDouble();
            return a;
        }

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

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

import java.util.Scanner;

public class KiriilTheGame {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Scanner input = new Scanner(System.in);
		int l = input.nextInt();
		int r = input.nextInt();
		int a = input.nextInt();
		int b = input.nextInt();
		int temp  = input.nextInt();
		for(int i=a; i<=b;i++){
			long z = ((long)temp*i);
			if(z>=l && z<=r){
				System.out.println("YES");
				//System.out.println(z);
				return;
			}
		}
		System.out.println("NO");

	}

}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.FileNotFoundException;
import java.util.StringTokenizer;
import java.io.Writer;
import java.io.BufferedReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author AsgarJ
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        FastWriter out = new FastWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, InputReader in, FastWriter out) {
            int l = in.nextInt();
            int r = in.nextInt();
            int x = in.nextInt();
            int y = in.nextInt();
            int k = in.nextInt();

            long a = 0L;
            for (int b = x; a < l && b <= y; ++b) {
                a = b * (long) k;
            }

            if (a >= l && a <= r) {
                out.println("YES");
            } else {
                out.println("NO");
            }
        }

    }

    static class InputReader extends BufferedReader {
        StringTokenizer tokenizer;

        public InputReader(InputStream inputStream) {
            super(new InputStreamReader(inputStream), 32768);
        }

        public InputReader(String filename) {
            super(new InputStreamReader(Thread.currentThread().getContextClassLoader().getResourceAsStream(filename)));
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(readLine());
                } catch (IOException e) {
                    throw new RuntimeException();
                }
            }
            return tokenizer.nextToken();
        }

        public Integer nextInt() {
            return Integer.valueOf(next());
        }

    }

    static class FastWriter extends PrintWriter {
        public FastWriter(OutputStream outputStream) {
            super(outputStream);
        }

        public FastWriter(Writer writer) {
            super(writer);
        }

        public FastWriter(String filename) throws FileNotFoundException {
            super(filename);
        }

    }
}

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

public class Kiril_And_The_Game {

	static class FastReader {
		BufferedReader br;
		StringTokenizer st;

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

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

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

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

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

		String nextLine() {
			String str = "";
			try {
				str = br.readLine();
			} catch (IOException e) {
				e.printStackTrace();
			}
			return str;
		}

	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		FastReader t = new FastReader();
		PrintWriter o = new PrintWriter(System.out);
		long l = t.nextLong();
		long r = t.nextLong();
		long x = t.nextLong();
		long y = t.nextLong();
		long k = t.nextLong();
		boolean ans = false;
		long i = x;

		while (i <= y) {
			if (k * i >= l && k * i <= r) {
				ans = true;
				break;
			}
//
//			if (k * i > y)
//				break;

			i++;
		}

		if (ans)
			o.println("YES");
		else
			o.println("NO");

		o.flush();
		o.close();
	}
}

//package Array;

import java.util.Scanner;

public class RubyNumber {
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);

        long l = in.nextInt();
        long r = in.nextInt();
        long x = in.nextInt();
        long y = in.nextInt();
        long k = in.nextInt();

        System.out.println(theGame(l, r, x, y, k));
    }

    private static String theGame(long l , long r , long x , long y , long k) {
        if (k*x > r){
            return "NO";
        }
        long exp = 0;
        for (long i = x; i <= y ; i++) {
            exp = k * i;

            if (exp >= l && exp <= r){
                return "YES";
            }
        }
        return "NO";
    }
}

import java.util.Scanner;

public class codeforces_842A {
    public static void main(String[] args) {
        Scanner  sc= new Scanner(System.in);
        long l,r,x,y,k;
        l=sc.nextLong();
        r=sc.nextLong();
        x=sc.nextLong();
        y=sc.nextLong();
        k=sc.nextLong();
        for(long i=x;i<=y;i++)
        {
            if(i*k>=l && i*k<=r)
            {
                System.out.println("YES");
                return;
            }
        }
        System.out.println("NO");
    }
}

import java.util.Scanner;
public class Task {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        long l = input.nextLong();
        long r = input.nextLong();
        long x = input.nextLong();
        long y = input.nextLong();
        long k = input.nextLong();
        boolean flag = false;
        for(long i = x; i <= y; i++){
            if(l <= i * k && i * k <= r)
                flag = true;
        }
        if(flag)
            System.out.println("YES");
        else System.out.println("NO");
    }

    }

import java.util.Scanner;

public class contestone {
	public static void main(String[] args) {
		Scanner scanny = new Scanner(System.in);
		double expMin = scanny.nextDouble();
		double expMax = scanny.nextDouble();
		double costMin = scanny.nextDouble();
		double costMax = scanny.nextDouble();
		double goal = scanny.nextDouble();
		String print = "NO";
		for (double i = costMin; i <= costMax; i++) {
		    if (goal*i >= expMin && goal*i <= expMax) print = "YES";
		}
	System.out.println(print);
	}
}

//AMBIKESH JHA (jhaambikesh)
//MNNIT,ALLAHABAD
import java.util.*;
import java.io.*;
import java.math.*;
public class QuestionA {
	public static void main(String[] args)throws IOException{
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
      String[] strArray=br.readLine().split(" ");
      int l=Integer.parseInt(strArray[0]);
      int r=Integer.parseInt(strArray[1]);
      int x=Integer.parseInt(strArray[2]);
      int y=Integer.parseInt(strArray[3]);
      double k=Double.parseDouble(strArray[4]);
      double high=0.0,low=0.0;
      high=r/x;
      low=l/y;
      if(k>=low && k<=high && k>=1)
    	  System.out.println("YES");
      else{
    		  System.out.println("NO");
      }
}
}

import java.util.*;
public class KirillAndTheGame {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int l, r, x, y, k;
		Scanner sc= new Scanner(System.in);
		l=sc.nextInt();
		r=sc.nextInt();
		x=sc.nextInt();
		y=sc.nextInt();
		k=sc.nextInt();
		boolean cd =false;
		for(int i=x;i<=y && k*i<=r;i++){
			int j=k*i;
			if(j>=l){
				cd =true;
				break;
			}
		}
		if(cd){
			System.out.println("YES");
		}
		else{
			System.out.println("NO");
		}
		sc.close();
	}

}

import java.util.Scanner;

public class R430A {

	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int l = scan.nextInt(), r = scan.nextInt(), x = scan.nextInt(), y = scan.nextInt(), k = scan.nextInt();
		for(int i = l; i <= r; ++i) {
			int a = i, b = x;
			if(k / x >= i && k /y <= r) {
				System.out.println("YES");
				return;
			}
		}
		System.out.println("NO");
	}
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.HashSet;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            int l = in.nextInt();
            int r = in.nextInt();
            int x = in.nextInt();
            int y = in.nextInt();
            double k = in.nextDouble();
            HashSet<Double> h1 = new HashSet<>();
            HashSet<Double> h2 = new HashSet<>();
            for (double i = l; i <= r; i++) {
                h1.add(i);
            }
            for (double i = x; i <= y; i++) {
                h2.add(i);
            }
            int flag = 0;
            for (double p : h1) {
                if (h2.contains((k * p))) {
                    flag = 1;
                    break;
                }
            }
            if (flag == 1) {
                out.print("YES");
            } else out.print("NO");
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

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

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

        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 < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        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 double nextDouble() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            double res = 0;
            while (!isSpaceChar(c) && c != '.') {
                if (c == 'e' || c == 'E') {
                    return res * Math.pow(10, nextInt());
                }
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            }
            if (c == '.') {
                c = read();
                double m = 1;
                while (!isSpaceChar(c)) {
                    if (c == 'e' || c == 'E') {
                        return res * Math.pow(10, nextInt());
                    }
                    if (c < '0' || c > '9') {
                        throw new InputMismatchException();
                    }
                    m /= 10;
                    res += (c - '0') * m;
                    c = read();
                }
            }
            return res * sgn;
        }

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

        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void print(Object... objects) {
            for (int i = 0; i < objects.length; i++) {
                if (i != 0) {
                    writer.print(' ');
                }
                writer.print(objects[i]);
            }
        }

        public void close() {
            writer.close();
        }

    }
}

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

public class a {

	public static void main(String[] args) {
		FastReader scan = new FastReader();
		PrintWriter out = new PrintWriter(System.out);
		Task solver = new Task();
		//int t = scan.nextInt();
		int t = 1;
		for(int i = 1; i <= t; i++) solver.solve(i, scan, out);
		out.close();
	}

	static class Task {

		public void solve(int testNumber, FastReader sc, PrintWriter pw) {
			int l = sc.nextInt();
			int r = sc.nextInt();
			int a = sc.nextInt();
			int b = sc.nextInt();
			int k = sc.nextInt();
			for(int i=a;i<=b;i++){
				if(i*k<=r&&i*k>=l){
					pw.println("YES");
					return;
				}
			}
			pw.println("NO");
		}
	}

	static void shuffle(int[] a) {
		Random get = new Random();
		for (int i = 0; i < a.length; i++) {
			int r = get.nextInt(a.length);
			int temp = a[i];
			a[i] = a[r];
			a[r] = temp;
		}
	}

	static void shuffle(long[] a) {
		Random get = new Random();
		for (int i = 0; i < a.length; i++) {
			int r = get.nextInt(a.length);
			long temp = a[i];
			a[i] = a[r];
			a[r] = temp;
		}
	}

	static class FastReader {
		BufferedReader br;
		StringTokenizer st;

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

		public FastReader(String s) throws FileNotFoundException {
			br = new BufferedReader(new FileReader(new File(s)));
		}

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

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

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

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

		String nextLine() {
			String str = "";
			try {
				str = br.readLine();
			} catch (IOException e) {
				e.printStackTrace();
			}
			return str;
		}
	}

}

import java.util.Scanner;

public class Main {

	@SuppressWarnings("resource")
	public static void main(String[] args) {

		Scanner sc = new Scanner(System.in);
		while (sc.hasNext()) {
			int l = sc.nextInt();
			int r = sc.nextInt();
			int x = sc.nextInt();
			int y = sc.nextInt();
			int k = sc.nextInt();
			if ((r - l + 1) * (y - x + 1) == 0) {
				System.out.println("NO");
			}
			if (r / x >= k) {
				System.out.println("YES");
			} else {
				System.out.println("NO");
			}
		}
	}
}

import java.util.Scanner;

public class R430A {

	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int l = scan.nextInt(), r = scan.nextInt(), x = scan.nextInt(), y = scan.nextInt(), k = scan.nextInt();
		for(int i = l; i < r; ++i) {
			for(int j = x; j < r; j++) {
				if(i/j == k) {
					System.out.println("YES");
					return;
				}
			}
		}
		System.out.println("NO");
	}

}

import java.io.*;
import java.text.*;
import java.util.*;
public class template {
	public static void main(String[] args) throws Exception {
		new template().run();
	}
	public void run() throws Exception {
		BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(f.readLine());
		int l = Integer.parseInt(st.nextToken()),
				r = Integer.parseInt(st.nextToken()),
						x = Integer.parseInt(st.nextToken()),
								y = Integer.parseInt(st.nextToken());
		double k = Double.parseDouble(st.nextToken());
		int i;
		for(i = l; i <= r; i++) {
			double d = k*i;
			if(d != (int) d) continue;
			if(d <= y && d >= x) {
				System.out.println("YES");
				break;
			}
		}
		if(i == r+1) System.out.println("NO");
	}
}

public class kirillAndTheGame {

public static void main(String[] args) {

	int l = 1;
	int r = 5;
	int x = 6;
	int y = 10;
	int k = 1;

	for (int b = x; b <= y; ++b) {
		int a = k * b;
		    if (a >= l && a <= r) {
		  		    System.out.println("Yes");
		  	} else
		  			 System.out.println("no");
	}
 }

}

import java.util.Scanner;

public class contestone {
	public static void main(String[] args) {
		Scanner scanny = new Scanner(System.in);
		double expMin = scanny.nextDouble();
		double expMax = scanny.nextDouble();
		double costMin = scanny.nextDouble();
		double costMax = scanny.nextDouble();
		double goal = scanny.nextDouble();
		String print = "NO";
		for (double i = expMin; i <= expMax; i++) {
			for (double j = costMin; j <= costMax; j++) {
				if (i/j == goal) print = "YES";
				break;
			}
		}
		System.out.println(print);
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;

public class Main {

	static Scanner in = new Scanner(System.in);

	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());
		int x = Integer.valueOf(st.nextToken());
		int y = Integer.valueOf(st.nextToken());
		int l = Integer.valueOf(st.nextToken());
		int r = Integer.valueOf(st.nextToken());
		int k = Integer.valueOf(st.nextToken());

		int ls = k * l;
		int rs = k * r;

		if (ls > y || rs < x)
		{
			System.out.println("NO");
		}else {
			System.out.println("YES");
		}
	}

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.HashMap;
import java.util.StringTokenizer;

public class Solution {

	static class FastReader {
		BufferedReader br;
		StringTokenizer st;

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

		String next() {
			while (st == null || !st.hasMoreTokens()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

		String nextLine() {
			String str = "";
			try {
				str = br.readLine();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			return str;
		}

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

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

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

	public static void main(String[] args) {
		FastReader sc= new FastReader();
		String[] ss = sc.nextLine().split(" ");
		int l = Integer.parseInt(ss[0]);
		int r = Integer.parseInt(ss[1]);
		int x = Integer.parseInt(ss[2]);
		int y = Integer.parseInt(ss[3]);
		int k = Integer.parseInt(ss[4]);
		int a1 = l-1;
		int a2 = r-l+1;
		int b1 = x-1;
		int b2 = y-l+1;
		if((k>=a1 && k<=a2) && (k>=b1 && k<=b2))
			System.out.println("YES");
		else
			System.out.println("NO");
	}

}

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

import static java.lang.Math.*;

// http://codeforces.com/contest/842/problem/A
// http://codeforces.com/blog/entry/54179
public class CF842A_KirillAndTheGame extends PrintWriter {
    public void solve() throws IOException {
        int l = readInt(); // min xp
        int r = readInt(); // max xp
        int x = readInt(); // min cost
        int y = readInt(); // max cost
        int k = readInt();

        // We want to know if there is a potion such that
        // exp and cost meet the following condition: exp / cost == k
        // We can iterate on cost from x to y and check
        // that exp = k·cost is not less than l and not greater than r
        while (x <= y) {
            if (k * x >= l && k * x <= r) {
                println("YES");
                return;
            }
            x++;
        }

        println("NO");
    }

    BufferedReader in;
    StringTokenizer stok;

    public void run() {
        try {
            solve();
            close();
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(abs(-1));
        }
    }

    CF842A_KirillAndTheGame() {
        super(System.out);
        in = new BufferedReader(new InputStreamReader(System.in));
    }

    public static void main(String[] args) {
        try {
            Locale.setDefault(Locale.US);
        } catch (Exception ignored) {
        }
        new CF842A_KirillAndTheGame().run();
    }

    String read() throws IOException {
        while (stok == null || !stok.hasMoreTokens()) {
            String s = in.readLine();
            if (s == null) {
                return null;
            }
            stok = new StringTokenizer(s);
        }
        return stok.nextToken();
    }

    int readInt() throws IOException {
        return Integer.parseInt(read());
    }

    long readLong() throws IOException {
        return Long.parseLong(read());
    }

    double readDouble() throws IOException {
        return Double.parseDouble(read());
    }

    int[] readIntArray(int len) throws IOException {
        int[] a = new int[len];
        for (int i = 0; i < len; i++) {
            a[i] = readInt();
        }
        return a;
    }

    <T> List<T>[] createAdjacencyList(int countVertex) {
        List<T>[] res = new List[countVertex];
        for (int i = 0; i < countVertex; i++) {
            res[i] = new ArrayList<T>();
        }
        return res;
    }
}

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

public class A {
  public static void main(String[] args) {
    Inputter in = new Inputter(new BufferedReader(new InputStreamReader(System.in)));
    PrintWriter out = new PrintWriter(System.out);

    int l, r, x, y;
    double k;

    l = in.nextInt();
    r = in.nextInt();
    x = in.nextInt();
    y = in.nextInt();
    k = in.nextInt();
    in.close();

    boolean answer = false;
    for (int i = l; i <= r; i++) {
      if (inMiddle(i * k, x, y)) {
        answer = true;
      }
    }

    out.println(answer ? "YES" : "NO");
    out.flush();
    out.close();
  }

  private static boolean inMiddle(double value, double left, double right) {
    return value >= left && value <= right;
  }
}

class Inputter {
  BufferedReader reader;
  StringTokenizer tokenizer;

  Inputter(BufferedReader reader) {
    this.reader = reader;
  }

  String nextString() {
    if (tokenizer == null || !tokenizer.hasMoreTokens()) {
      tokenizer = new StringTokenizer(readLine(), " ");
    }
    return tokenizer.nextToken();
  }

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

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

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

  int[] nextIntArray(int n) {
    int[] a = new int[n];
    tokenizer = new StringTokenizer(readLine(), " ");
    int i = 0;
    while (i < n && tokenizer.hasMoreTokens()) {
      a[i++] = Integer.parseInt(tokenizer.nextToken());
    }
    return a;
  }

  private String readLine() {
    try {
      return reader.readLine();
    } catch (IOException e) {
      throw new RuntimeException(e);
    }
  }

  void close() {
    try {
      reader.close();
    } catch (IOException e) {
      throw new RuntimeException(e);
    }
  }
}

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

public class Main{

	public static Boolean binary_search(double arr[], double key){
		int high = arr.length-1;
		int low = 0;
	  double TOLERANCE = 1E-7;
		//System.out.println("==========");
		// THIS ARRAY IS IN DESCENDING ORDER
		while(low<=high){//
			int mid = (high + low )/2;
			//System.out.print(mid + " ");
			if(Math.abs(arr[mid]- key)<TOLERANCE )
				return true;
			else if(arr[mid] < key)
			{
				low=mid+1;
			}
			else
				high = mid-1;
		}
		return false;
	}

	public static void main(String[] args) {
		MyScanner sc = new MyScanner();
		out = new PrintWriter(new BufferedOutputStream(System.out));

      // Start writing your solution here. -------------------------------------
		int l,r,x,y,k;
		l=sc.nextInt();
		r= sc.nextInt();
		x=sc.nextInt();
		y=sc.nextInt();
		k=sc.nextInt();
		double div[] = new double[y-x+1];
		for(int i=0; i < div.length;i++){
			div[i] = k * x;
			x++;
		}
		int i =0;
 //   System.out.println(Arrays.toString(div));
		double key;
    key = l;
		for( i=0; i < r-l+1;i++){

			//out.println(" key ="+key);
			if(binary_search(div,key)){
				out.println("YES");
				break;
			}key++;
		}
		//out.println(i);
		if(i==r-l+1)
			out.println("NO");

      /*
      int n      = sc.nextInt();        // read input as integer
      long k     = sc.nextLong();       // read input as long
      double d   = sc.nextDouble();     // read input as double
      String str = sc.next();           // read input as Strigtgtgtgtgtgtgtng
      String s   = sc.nextLine();       // read whole line as String

      int result = 3*n;
      out.println(result);                    // print via PrintWriter;
      for(int i = 0; i lt N ; i++){
        for(int j = 0; j lt N; j++){
          System.out.print();
        }
        System.out.println();
      }
      */

      // Stop writing your solution here. -------------------------------------
      out.close();
  }

   //-----------PrintWriter for faster output---------------------------------
  public static PrintWriter out;

   //-----------MyScanner class for faster input----------
  public static class MyScanner {
  	BufferedReader br;
  	StringTokenizer st;

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

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

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

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

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

  	String nextLine(){
  		String str = "";
  		try {
  			str = br.readLine();
  		} catch (IOException e) {
  			e.printStackTrace();
  		}
  		return str;
  	}

  }
   //--------------------------------------------------------
}

import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.BigDecimal;

public class R430B {
    public static void main (String[] args) throws java.lang.Exception {
        Scanner in = new Scanner(System.in);
        PrintWriter w = new PrintWriter(System.out);
        long l = in.nextLong(), r = in.nextLong(), x = in.nextLong(), y = in.nextLong(), k = in.nextLong();

        long op1 = k * x, op2 = k * y;
        if (r<op1 || l>op2)
            w.println("NO");
        else
            w.println("YES");
        w.close();

    }

}

import java.util.Scanner;

public class Solution2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner in = new Scanner(System.in);
		int l = in.nextInt();
		int r = in.nextInt();
		int x = in.nextInt();
		int y = in.nextInt();
		int k = in.nextInt();
		long cases = (r-l+1) * (y-x+1);
		long cnt = 1;
		boolean flag = false;
		for(int i = x; i <= y; i++) {
			if(cnt > cases) break;
			long mul = i*k;
			if(mul >= l && mul <= r)  {
				flag = true;
				break;
			}
			if(mul > r) break;
			cnt++;
		}
		if(flag) System.out.println("YES");
		else System.out.println("NO");
		in.close();
	}

}

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

public class R430A {
    public static void main(String[] args) {
        new R430A().run();
    }

    //Scanner sc;
    private FastScanner sc;
    private PrintWriter out;

    int l, r; // a, количество опыта
    int x, y; // b, стоимость
    double need; // need = a/b

    public void solve() {
        //sc = new Scanner(System.in);

        l = sc.nextInt();
        r = sc.nextInt();
        x = sc.nextInt();
        y = sc.nextInt();
        need = sc.nextDouble();

        ArrayList<Double> arr = new ArrayList<Double>();
        for (int i=l; i<=r; i++) {
            double cur = need*i;
            arr.add(cur);
        }

        for (double i=x; i<=y; i++) {
            int cur = Collections.binarySearch(arr, i);
            if (cur > 0 ) {
                System.out.println("YES");
                return;
            }
        }

        System.out.println("NO");

    }

    private void run() {
        /*try {
            sc = new FastScanner(new File("input.txt"));
            out = new PrintWriter(new File("output.txt"));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }*/

        sc = new FastScanner(System.in);
        out = new PrintWriter(System.out);

        solve();

        out.close();

    }

    private class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        FastScanner(File f) {
            try {
                br = new BufferedReader(new FileReader(f));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }

        FastScanner(InputStream f) {
            br = new BufferedReader(new InputStreamReader(f));
        }

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

        boolean hasMoreTokens() {
            while (st == null || !st.hasMoreTokens()) {
                String s = null;
                try {
                    s = br.readLine();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (s == null)
                    return false;
                st = new StringTokenizer(s);
            }
            return true;
        }

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

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

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

}

/*
1 10
1 10
1

1 5
6 10
1

NO

*/

import java.util.*;
public final class code{
	public static void main(String[] arg){
		Scanner in=new Scanner(System.in);
		double l=in.nextDouble();
		double r=in.nextDouble();
		double x=in.nextDouble();
		double y=in.nextDouble();
		double k=in.nextDouble();
		boolean flag=false;
		if(k>r/x || k<l/y){
			System.out.println("NO");
		}else{
			double i=l;
			double j=x;
			while(i<=r && j<=y){
				if((i/j)>k){
					j++;
				}if((i/j)<k){
					i++;
				}if((i/j)==k){
					flag=true;
					break;
				}
			}
		if(flag==true){
			System.out.println("YES");
		}else{
			System.out.println("NO");
		}
	}
	}
}

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

public class File {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        int l = sc.nextInt();
        int r = sc.nextInt();
        int x = sc.nextInt();
        int y = sc.nextInt();
        int k = sc.nextInt();

        // Min ratio is l / y
        // Max ratio is r / x

        // 1 30 (l, r)
        // 3 8  (x, y)
        // 7    (k)
        //  [1, 10]
        int min = (int) Math.ceil((double)l / (double)y);
        int max = (int) Math.floor((double)r / (double)x);

        if (min <= k && k <= max) {
            System.out.println("YES");
        }
        else {
            System.out.println("NO");
        }
    }
}

import java.util.Scanner;

public class question1 {

	public static void main(String[] args) {

		Scanner s = new Scanner(System.in);

		int l=s.nextInt();
		int r=s.nextInt();
		int x=s.nextInt();
		int y=s.nextInt();
		double k=s.nextInt();

		double first=(double)l/x;
		double second=(double)r/y;

		if(k>=first && k<=second){
			System.out.println("YES");
		}else{
			System.out.println("NO");
		}
}
}

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

public class KirillGame {
	static class InputReader {
		private BufferedReader br;
		private StringTokenizer st;
		InputReader ( InputStream in ) {
			br = new BufferedReader ( new InputStreamReader ( in ) );
			st = null;
		}
		public String next() {
			while ( st == null || !st.hasMoreTokens() ) {
				try {
					st = new StringTokenizer ( br.readLine() );
				}	catch ( Exception e ) {
					throw new RuntimeException ( e );
				}
			}
			return st.nextToken();
		}
		public int nextInt() {
			return Integer.parseInt ( next() );
		}
	}
	static class Task implements Runnable {
		private void solve ( InputReader in, PrintWriter out ) {
			int l = in.nextInt(), r = in.nextInt(), x = in.nextInt(), y = in.nextInt(), k = in.nextInt();
			boolean flag = false;
			for ( int i = x; i <= y; ++i ) {
				int temp = 0;
				if ( ( temp = k * i ) >= l && temp <= r ) {
					flag = true;
					break;
				}
			}
			out.println ( flag ? "YES" : "NO" );
		}
		@Override
		public void run() {
			InputReader in = new InputReader ( System.in );
			PrintWriter out = new PrintWriter ( System.out );
			solve ( in, out );
			out.close();
		}
	}
	public static void main ( String[] args ) {
		// new Thread ( null, new Task(), "Solution", ( 1 << 26 ) ).start();
		new Task().run();
	}
}

import java.util.Scanner;

public class A {

	private static Scanner input= new Scanner(System.in);

	public static void main(String[] args) {
		long expMin = input.nextLong();
		long expMax = input.nextLong();
		long costMin = input.nextLong();
		long costMax = input.nextLong();
		long target = input.nextLong();

		if ((double)expMax/costMin >= target && (double)expMin/costMax <= target)
			System.out.println("YES");
		else
			System.out.println("NO");
	}
}

/* package codechef; // don't place package name! */

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

/* Name of the class has to be "Main" only if the class is public. */
public class Codechef
{
	public static void main (String[] args) throws java.lang.Exception
	{
		// your code goes here
		Scanner s=new Scanner(System.in);
		int l=s.nextInt();
		int r=s.nextInt();
		int x=s.nextInt();
		int y=s.nextInt();
		int k=s.nextInt();
		int flag=1;
		for(int i=x;i<=y;i++)
		{
		    if(k*i>=l&&k*i<=r)
		    {flag=0;
		    break;
		    }

		}
		 if(flag==1)
		    {
		        System.out.println("NO");
		    }else
		    {
		        System.out.println("YES");
		    }

		}

	}

import java.util.Scanner;

public class ProbA {

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int l = in.nextInt(), r = in.nextInt(), x = in.nextInt(), y=in.nextInt();
		double k=in.nextDouble();
		int a;
		int b;
		boolean tf = false;
		for(a = l; a<r; a++){
			if(a%k==0){
				b=(int)(a/k);
				if(b>=x &&b<=y){
					System.out.println("YES");
					return;
				}
			}

		}

		System.out.println("NO");

	}

}

import java.util.Scanner;
/**
 *
 * @author никитяночка
 */
public class Main {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code appl0ication logic here
        Scanner in = new Scanner(System.in);
        int l = in.nextInt();
        int r = in.nextInt();
        int x = in.nextInt();
        int y = in.nextInt();
        int k = in.nextInt();
        for (int i = x; i <= y; i++) {
            if (k * y >= l && k * y <= r) {
                System.out.println("YES");
                return;
            }
        }
        System.out.println("NO");
    }

}

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

/**
 *
 * @author dipankar12
 */
import java.io.*;
import java.util.*;
public class r842a {
    public static void main(String args[])
    {
        fastio in=new fastio(System.in);
        PrintWriter pw=new PrintWriter(System.out);

        int l=in.nextInt();
        int r=in.nextInt();
        int x=in.nextInt();
        int y=in.nextInt();
        int k=in.nextInt();

        int flag=0;
        for(int i=l;i<=r;i++)
        {
            if((k/i)>=x&&(k/i)<=y)
            {
                if((int)Math.ceil((double)k/(double)i)==k/i)
                {
                    pw.println("Yes");
                    flag=-1;
                    break;
                }
            }
        }
        if(flag==0)
            pw.println("NO");

        pw.close();
    }

    static class fastio {

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

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

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

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

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

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

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

            public String nextLine() {
                int c = nxt();
                while (isSpaceChar(c))
                    c = nxt();
                StringBuilder res = new StringBuilder();
                do {
                    res.appendCodePoint(c);
                    c = nxt();
                } 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);
            }
        }

}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.FileNotFoundException;
import java.util.StringTokenizer;
import java.io.Writer;
import java.io.BufferedReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author AsgarJ
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        FastWriter out = new FastWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, InputReader in, FastWriter out) {
            int l = in.nextInt();
            int r = in.nextInt();
            int x = in.nextInt();
            int y = in.nextInt();
            int k = in.nextInt();

            MathUtils.Rational left = new MathUtils.Rational(l, y);
            MathUtils.Rational right = new MathUtils.Rational(r, x);

            MathUtils.Rational q = new MathUtils.Rational(k, 1);

            if (left.compareTo(q) <= 0 && right.compareTo(q) >= 0) {
                out.println("YES");
            } else {
                out.println("NO");
            }

        }

    }

    static class InputReader extends BufferedReader {
        StringTokenizer tokenizer;

        public InputReader(InputStream inputStream) {
            super(new InputStreamReader(inputStream), 32768);
        }

        public InputReader(String filename) {
            super(new InputStreamReader(Thread.currentThread().getContextClassLoader().getResourceAsStream(filename)));
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(readLine());
                } catch (IOException e) {
                    throw new RuntimeException();
                }
            }
            return tokenizer.nextToken();
        }

        public Integer nextInt() {
            return Integer.valueOf(next());
        }

    }

    static class FastWriter extends PrintWriter {
        public FastWriter(OutputStream outputStream) {
            super(outputStream);
        }

        public FastWriter(Writer writer) {
            super(writer);
        }

        public FastWriter(String filename) throws FileNotFoundException {
            super(filename);
        }

    }

    static class MathUtils {
        public static class Rational implements Comparable<MathUtils.Rational> {
            int up;
            int down;

            public Rational(int up, int down) {
                if (down == 0)
                    throw new IllegalArgumentException("denominator can't be zero.");
                this.up = up;
                this.down = down;
                if (down < 0) {
                    this.up = -up;
                    this.down = -down;
                }
            }

            public int compareTo(MathUtils.Rational o) {
                return Long.compare(this.up * (long) o.down, this.down * (long) o.up);
            }

            public boolean equals(Object o) {
                if (this == o) return true;
                if (!(o instanceof MathUtils.Rational)) return false;

                MathUtils.Rational rational = (MathUtils.Rational) o;
                return this.compareTo(rational) == 0;
            }

            public int hashCode() {
                int result = up;
                result = 31 * result + down;
                return result;
            }

        }

    }
}

import java.util.Scanner;
import java.io.*;
import java.lang.Math;

public class A {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        long l = scanner.nextLong();
        long r = scanner.nextLong();
        long x = scanner.nextLong();
        long y = scanner.nextLong();
        long k = scanner.nextLong();

        for (long i = r; i >= l; i--) {
            if ((k % i) == 0) {
                for (long j = y; j >= x; j--) {
                    if ((k % j) == i) {
                        System.out.println("YES");
                        return;
                    }
                }
            }
        }

        System.out.println("NO");
    }
}

import java.util.Scanner;
public class cf842 {

	public static void main(String[] args){

		Scanner sc = new Scanner (System.in);
		int x = sc.nextInt();
		int y = sc.nextInt();
		int u = sc.nextInt();
		int v = sc.nextInt();
		int k = sc.nextInt();
		for(int a=x; a<=y; a++){
			for(int b=u; b<=v; b++){

				if(a/b==k){
					System.out.print("YES");
					break;
				}
				else{
					System.out.print("NO");
					break;
				}

			}
			break;

		}
	}
}

import java.util.Scanner;

public class Beginer {

	public static void main(String[] args) {

		int l , r ,  x , y ,  k ;

		Scanner reader = new Scanner(System.in);
		l = reader.nextInt();
		r = reader.nextInt();
		x = reader.nextInt();
		y = reader.nextInt();
		k = reader.nextInt();

		for (int i = x  ;i <= y ; i++)
		{
			if ((i*k)>=l && (i*k)<=r)
			{
				System.out.println("YES");
				return ;
			}
		}

		System.out.println("NO");

	}

}

import java.util.*;

public class GFG {
	public static Scanner in = new Scanner(System.in);

	public static void main(String[] args) {
		// code
		int l = in.nextInt();
		int r = in.nextInt();
		int x = in.nextInt();
		int y = in.nextInt();
		int k = in.nextInt();

		if (k > r) {
			System.out.println("NO");
			return;
		}

		for (int i = l; i <= r; i++) {
			for (int j = x; j <= y; j++) {
				if ((i / j) == k) {
					System.out.println("YES");
					return;
				} else if ((i / j) <= k)
					break;
			}
		}
		System.out.println("NO");
	}

}

import java.util.Scanner;
import java.io.*;
import java.lang.Math;

public class A {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        long l = scanner.nextLong();
        long r = scanner.nextLong();
        long x = scanner.nextLong();
        long y = scanner.nextLong();
        double k = scanner.nextDouble();

        if ((((k / l) >= x) && ((k / l) <= y)) ||  (((k / r) >= x) && ((k / r) <= y))
            || (((k / y) >= l) && ((k / y) <= r)) || (((k / x) <= r) && ((k / x) >= l)))
        {
            System.out.println("YES");
        } else {
            System.out.println("NO");
        }
    }
}

import java.util.Scanner;

public class ProbA {

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int l = in.nextInt(), r = in.nextInt(), x = in.nextInt(), y=in.nextInt();
		double k=in.nextDouble();
		double a = r-l+1;
		double b = y-x+1;
		double efficiency = a/b;
		if(efficiency == k)System.out.println("YES");
		else System.out.println("NO");

	}

}

import java.util.Scanner;

public class KirillAndTheGame {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
//		if((double)(5/3) == (int)((double)(5/3))){
//			System.out.println((double) ((double)(5) / 3));
//		}
		int l = sc.nextInt();
		int r = sc.nextInt();
		int x = sc.nextInt();
		int y = sc.nextInt();
		int k = sc.nextInt();
		String out = "NO";
		for(int a = l; l <= r; l++){
			int b = a / k;
			if(a % k == 0 && x <= b && b <= y){
				out = "YES";
				break;
			}
		}
		System.out.println(out);
	}
}

//outerLoop:
//	for(int a = l; a <= r; a++){
//		for(int b = x; b <= y; b++){
//			if(a / b == k){
//				out = "YES";
//				break outerLoop;
//			}
//			else if(a / b > k){
//				if(a > l) a--;
//				else if(b < y) b++;
//				else break outerLoop;
//			}
//			else if(a / b < k){
//				if(a < r) a++;
//				else if(b > x) b--;
//				else break outerLoop;
//			}
//		}
//	}

import java.util.Scanner;
import java.io.*;
import java.lang.Math;

public class A {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        long l = scanner.nextLong();
        long r = scanner.nextLong();
        long x = scanner.nextLong();
        long y = scanner.nextLong();
        long k = scanner.nextLong();

        for (long i = l; i < r; i++) {
            for (long j = x; j < y; j++) {
                if ((i * j) == k) {
                    System.out.println("YES");
                    return;
                }
            }
        }

        System.out.println("NO");
    }
}

import java.util.*;
import java.io.*;
public class Code{
    //experience=k*cost
    public static void main(String [] Args){
        Scanner scan=new Scanner(System.in);
        int l=scan.nextInt();
        int r=scan.nextInt();
        int x=scan.nextInt();
        int y=scan.nextInt();
        int k=scan.nextInt();
        boolean flag=false;
        for(int i=y;i>=x;i--){
            for(int j=l;j<=r;j++){
                if(i<j*k){
                    flag=false;
                    break;
                }
                if(i==j*k){
                    flag=true;
                    break;
                }
            }
        }
        if(flag){
            System.out.println("YES");
        }else{
            System.out.println("NO");
        }

    }
}

/* package codechef; // don't place package name! */

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

/* Name of the class has to be "Main" only if the class is public. */
public class Codechef
{
	public static void main (String[] args) throws java.lang.Exception
	{
		// your code goes here
		Scanner s=new Scanner(System.in);
		int x=s.nextInt();
		int y=s.nextInt();
		int l=s.nextInt();
		int r=s.nextInt();
		int k=s.nextInt();
		int flag=1;
		for(int i=x;i<=y;i++)
		{
		    if(k*i>=l&&k*i<=r)
		    {flag=0;
		    break;
		    }

		}
		 if(flag==1)
		    {
		        System.out.println("NO");
		    }else
		    {
		        System.out.println("YES");
		    }

		}

	}

import java.util.*;
public class MyClass {
    public static void main(String args[]) {
        Scanner sc = new Scanner(System.in);
        int l=sc.nextInt();
        int r=sc.nextInt();
        int x=sc.nextInt();
        int y=sc.nextInt();
        int k=sc.nextInt();
        int flag=0;
        int exp;
        outer:
       for(int i=x;i<=y;i++)
       {
           exp = k*x;
           if(exp>=l && exp<=r)
           {
               flag=1;
               System.out.println("YES");
               break;
           }
       }

       if(flag==0)
       {
           System.out.println("NO");
       }

    }
}

import java.util.Scanner;

public class contestone {
	public static void main(String[] args) {
		Scanner scanny = new Scanner(System.in);
		double expMin = scanny.nextInt();
		double expMax = scanny.nextInt();
		double costMin = scanny.nextInt();
		double costMax = scanny.nextInt();
		double goal = scanny.nextInt();
		String print = "NO";
		for (double i = expMin; i < expMax; i++) {
			for (double j = costMin; j < costMax; j++) {
				if (i/j == goal) print = "YES";
			}
		}
		System.out.println(print);
	}
}

import java.util.Scanner;

public class Beginer {

	public static void main(String[] args) {

		int l , r ,  x , y ,  k , a, b;
		Scanner reader = new Scanner(System.in);
		l = reader.nextInt();
		r = reader.nextInt();
		x = reader.nextInt();
		y = reader.nextInt();
		k = reader.nextInt();
		a = r / x ;
		b = r / y ;

		if (k<=a && k >= b) System.out.println("YES");
		else System.out.println("NO");

	}

}

import java.util.Scanner;
public class Task {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int l = input.nextInt();
        int r = input.nextInt();
        int x = input.nextInt();
        int y = input.nextInt();
        int k = input.nextInt();
        boolean flag = false;
        for(int i = x; i <= y; i++){
            if(l <= i * k && i * k <= r)
                flag = true;
        }
        if(flag)
            System.out.println("YES");
        else System.out.println("NO");
    }

    }

import java.util.Scanner;

public class A {

	private static Scanner input= new Scanner(System.in);

	public static void main(String[] args) {
		long expMin = input.nextLong();
		long expMax = input.nextLong();
		long costMin = input.nextLong();
		long costMax = input.nextLong();
		long target = input.nextLong();

		if ((double)expMax/costMin >= target && (double)expMin/costMax <= target)
			System.out.println("YES");
		else
			System.out.println("NO");
	}
}

import java.util.Scanner;
import java.io.*;
import java.lang.Math;

public class A {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        long l = scanner.nextLong();
        long r = scanner.nextLong();
        long x = scanner.nextLong();
        long y = scanner.nextLong();
        double k = scanner.nextDouble();

        if ((k >= Math.min(l, x)) && (k <= Math.max(r, y))) {
            System.out.println("YES");
        } else {
            System.out.println("NO");
        }
    }
}

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

public class Main1{

	public static void main(String[] args) {
		MyScanner sc = new MyScanner();
		out = new PrintWriter(new BufferedOutputStream(System.out));

      // Start writing your solution here. -------------------------------------
		int l,r,x,y,k;
		l=sc.nextInt();
		r= sc.nextInt();
		x=sc.nextInt();
		y=sc.nextInt();
		k=sc.nextInt();
		//int div[] = new int[y-x+1];

		int i;
  //System.out.println(Arrays.toString(div));

    Boolean flag = false;
		for( i=x; i < y+1;i++){
			if(l<= (i*k)&&(i*k)<=r)
        flag = true;

			//out.println(" key ="+key);
			// if(binary_search(div,key)){
			// 	out.println("YES");
			// 	break;
			//}

		}
		//out.println(i);
		//if(i==r-l+1)
		if(flag)
      out.println("YES");
      else
      out.println("NO");

      /*
      int n      = sc.nextInt();        // read input as integer
      long k     = sc.nextLong();       // read input as long
      double d   = sc.nextDouble();     // read input as double
      String str = sc.next();           // read input as Strigtgtgtgtgtgtgtng
      String s   = sc.nextLine();       // read whole line as String

      int result = 3*n;
      out.println(result);                    // print via PrintWriter;
      for(int i = 0; i lt N ; i++){
        for(int j = 0; j lt N; j++){
          System.out.print();
        }
        System.out.println();
      }
      */

      // Stop writing your solution here. -------------------------------------
      out.close();
  }

   //-----------PrintWriter for faster output---------------------------------
  public static PrintWriter out;

   //-----------MyScanner class for faster input----------
  public static class MyScanner {
  	BufferedReader br;
  	StringTokenizer st;

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

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

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

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

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

  	String nextLine(){
  		String str = "";
  		try {
  			str = br.readLine();
  		} catch (IOException e) {
  			e.printStackTrace();
  		}
  		return str;
  	}

  }
   //--------------------------------------------------------
}

import java.util.*;

public class bucky{

public static int result;

public static ArrayList<Integer> [] graph;

public static int[]cats;

public static boolean vizitat[];

public static void main (String args[]) {

Scanner input=new Scanner(System.in);

HashMap<String, Integer> deschidere= new HashMap<String, Integer>();
HashMap<String, Integer> inchidere= new HashMap<String, Integer>();

	Long l,r,x,y,k;
	l=input.nextLong();
	r=input.nextLong();
	x=input.nextLong();
	y=input.nextLong();
	k=input.nextLong();

	Long unu=l/k;

	if(unu*k<l) unu++;

	Long doi=r/k;
	if(doi*k<r) doi++;

//	System.out.println(unu+" "+doi);

if(doi==unu){

    if(unu>=x && doi<=y) System.out.println("YES");
    else System.out.println("NO");

}

    else if((unu>=x && unu<=y) || (doi>=x && doi<=y) ||(unu<=x && doi>=y))
    System.out.println("YES");
    else System.out.println("NO");

}

			}

import java.util.Scanner;

public class ProbA {

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int l = in.nextInt(), r = in.nextInt(), x = in.nextInt(), y=in.nextInt();
		double k=in.nextDouble();
		int a=l;
		int b=x;
		boolean tf = false;
		for(int i = l; i<r; i++){

			for(int j = x; j<y;j++){
				if((double)(a/b)==k){
					tf=true;
					break;
				}
				if(j==y/x){
					b=j;
				}

			}
			if(i==r/l){
				a = i;
			}

		}

		if(tf==true)System.out.println("YES");
		else System.out.println("NO");

	}

}

import java.util.*;
import java.math.*;
import java.io.*;
import java.text.*;

public class A {
    static class Node implements Comparable<Node>{
        int from;
        int to;
        int w;

        public Node(int from ,int to ,int w){
           this.from=from;
           this.to=to;
           this.w=w;
        }
        public int compareTo(Node c){
            int i=0;
          return i;

        }
        @Override
        public boolean equals(Object o){
            if(o instanceof Node){
                Node c = (Node)o;
                return true;
            }
            return false;
        }
    }

    //public static PrintWriter pw;
    public static PrintWriter pw = new PrintWriter(System.out);

    public static void solve() throws IOException {
//	pw=new PrintWriter(new FileWriter("C:\\Users\\shree\\Downloads\\small_output_in"));
        FastReader sc = new FastReader();
       long l=sc.I();
       long r=sc.I();
       long x=sc.I();
       long y=sc.L();
       long k=sc.L();
       for(long i=l;i<=r;i++){
           long ll=x,h=y;
           while(ll<h){
               long mid=(ll+h)/2;
               if(i<k*mid) {
                    h=mid;
               }else if(i>k*mid){
                   l=mid+1;
               }else {
                   pw.println("YES");
                   pw.close();
                   return;
               }
           }
       }
       pw.println("NO");
        pw.close();

    }

    public static void main(String[] args) {
        new Thread(null, new Runnable() {
            public void run() {
                try {

                    solve();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }, "1", 1 << 26).start();

    }

    static BufferedReader br;
    static long M = (long) 1e9 + 7;

    static class FastReader {

        StringTokenizer st;

        public FastReader() throws FileNotFoundException {
            //br=new BufferedReader(new FileReader("C:\\Users\\shree\\Downloads\\B-small-practice.in"));
            br = new BufferedReader(new InputStreamReader(System.in));

        }

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

        int I() {
            return Integer.parseInt(next());
        }

        long L() {
            return Long.parseLong(next());
        }

        double D() {
            return Double.parseDouble(next());
        }

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

        public boolean hasNext() throws IOException {
            while (st == null || !st.hasMoreTokens()) {
                String s = br.readLine();
                if (s == null) {
                    return false;
                }
                st = new StringTokenizer(s);
            }
            return true;
        }

    }
}

import java.util.Scanner;

public class kirillAndGame {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Scanner scn = new Scanner(System.in);

		int l=scn.nextInt();
		int r=scn.nextInt();
		int x=scn.nextInt();
		int y=scn.nextInt();
		int k=scn.nextInt();

		int flag=0;

		for(int i=x;i<=y;i++)
		{
			if(i*k<=r&&i*k>=l)
			{
				flag=1;
				break;
			}
		}
		if(flag==0)
			System.out.println("NO");
		else
			System.out.println("YES");

	}

}

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        Scanner in = new Scanner(System.in);
        int l,r,x,y,k;
        l = in.nextInt();
        r = in.nextInt();
        x = in.nextInt();
        y = in.nextInt();
        k = in.nextInt();

        int tmp;
        for(int i=x ; i<=y ; i++) {
            tmp = i*k;
            if(tmp >= l && tmp <= r) {
                System.out.println("YES");
                return;
            }
        }

        System.out.println("NO");
    }
}

import java.util.Scanner;

public class question1 {

	public static void main(String[] args) {

		Scanner s = new Scanner(System.in);

		long l=s.nextInt();
		long r=s.nextInt();
		long x=s.nextInt();
		long y=s.nextInt();
		long k=s.nextInt();

		  long minLimit=Math.min(Math.min(l/x,l/y),Math.min(r/x,r/y));
		  long maxLimit=Math.max(Math.max(r/x, r/y),Math.max(l/x,l/y));

		  if(k>=minLimit && k<=maxLimit){
			  System.out.println("YES");
		  }else{
			  System.out.println("NO");
		  }
}
}

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

public class R430A {
    public static void main(String[] args) {
        new R430A().run();
    }

    //Scanner sc;
    private FastScanner sc;
    private PrintWriter out;

    int l, r; // a, количество опыта
    int x, y; // b, стоимость
    double need; // need = a/b

    public void solve() {
        //sc = new Scanner(System.in);

        l = sc.nextInt();
        r = sc.nextInt();
        x = sc.nextInt();
        y = sc.nextInt();
        need = sc.nextDouble();

        int all = (r-l+1)*(y-x+1);
        if (all < 1) {
            System.out.println("NO");
        }

        Map<Integer, Integer> map = new HashMap<>();
        for (int i=l; i<=r; i++) {
            map.put(i, i);
        }

        for (int i=x; i<=y; i++) {
            double cur = need*i;
            if (map.containsKey(cur)) {
                System.out.println("YES");
                return;
            }
        }

        System.out.println("NO");

    }

    private void run() {
        /*try {
            sc = new FastScanner(new File("input.txt"));
            out = new PrintWriter(new File("output.txt"));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }*/

        sc = new FastScanner(System.in);
        out = new PrintWriter(System.out);

        solve();

        out.close();

    }

    private class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        FastScanner(File f) {
            try {
                br = new BufferedReader(new FileReader(f));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }

        FastScanner(InputStream f) {
            br = new BufferedReader(new InputStreamReader(f));
        }

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

        boolean hasMoreTokens() {
            while (st == null || !st.hasMoreTokens()) {
                String s = null;
                try {
                    s = br.readLine();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (s == null)
                    return false;
                st = new StringTokenizer(s);
            }
            return true;
        }

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

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

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

}

/*
1 10
1 10
1

1 5
6 10
1

NO

*/

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastInput in = new FastInput(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, FastInput in, PrintWriter out) {
            int l = in.nextInt();
            int r = in.nextInt();
            int x = in.nextInt();
            int y = in.nextInt();
            int k = in.nextInt();

            if (k == 1) {
                if (x <= r) out.print("YES");
                else out.print("NO");
            } else {
                int t = x;
                int i = 1;
                while (t * k * i <= y && t * k * (i + 1) <= r) ++i;
                if (t * k * (i + 1) > r) out.print("NO");
                else out.print("YES");
            }
        }

    }

    static class FastInput {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public FastInput(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

    }
}

import java.util.Scanner;

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

/**
 *
 * @author Amr
 */
public class fffffff {
    public static void main(String[] args) {

        Scanner sc =new Scanner(System.in);
        int l=sc.nextInt(),r=sc.nextInt(),x=sc.nextInt(),y=sc.nextInt(),k=sc.nextInt();
        int flag=0;
        for(int a=l ;a<=r;a++)
        {
            for(int b=x;b<=x;b++)
            {
                double ef=a/b;
                if(ef==k)
                {
                    flag=1;
                    System.out.println("YES");
                    break;
                }

            }
            if(flag==1) break;
        }
        if(flag == 0) System.out.println("NO");

    }

}

//package CF_430;

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

public class A {
	public static void main(String[] args) throws Exception{ new A(new Reader()); }
	public A(Reader rr) throws IOException{
		int l=rr.ni(), r=rr.ni(), x=rr.ni(), y=rr.ni(), k=rr.ni();
		boolean broke=false;
		here:
		for(int j=x; j<y; j++){
			int tempL=l;
			if(tempL%j>0){
				tempL+=j-(tempL%j);
			}
			for(int i=tempL; i<=r; i+=j){
				if(i/j==k){
					broke=true;
					break here;
				}
			}
		}
		System.out.println(broke==true?"YES":"NO");
	}
	static class Reader{
		private DataInputStream din;
		private byte[] buffer=new byte[1024];
		private int bufP, bytR;
		public Reader() throws IOException{
			din=new DataInputStream(System.in);
			bufP=bytR=0;
		}
		public Reader(String file) throws IOException{
			din=new DataInputStream(new FileInputStream(file));
			bufP=bytR=0;
		}
		private String rl() throws IOException{
			byte[] buf=new byte[1024];
			int cnt=0, c;
			while((c=read())!=-1){
				if(c=='\n') break;
				buf[cnt++]=(byte)c;
			}
			return new String(buf, 0, cnt);
		}
		private int ni() throws IOException{
			int num=0;
			byte c=read();
			while(c<=' ') c=read();
			boolean neg=(c=='-');
			if(neg) c=read();
			do{
				num=num*10+c-'0';
			} while((c=read())>='0'&&c<='9');
			if(neg) return -num;
			return num;
		}
		private long nl() throws IOException{
			long num=0;
			byte c=read();
			while(c<=' ') c=read();
			boolean neg=(c=='-');
			if(neg) c=read();
			do{
				num=num*10+c-'0';
			} while((c=read())>='0'&&c<='9');
			if(neg) return -num;
			return num;
		}
		private double nd() throws IOException{ return Double.parseDouble(ns()); }
		private char nc() throws IOException{ return (char)next(); }
		private String ns() throws IOException{
			int c=next();
			StringBuilder sb=new StringBuilder();
			while(!(isChar(c))){
				sb.appendCodePoint(c);
				c=read();
			}
			return sb.toString();
		}
		private char[] ns(int n) throws IOException{
			char[] buf=new char[n];
			int c=next(), r=0;
			while(r<n&&!(isChar(c))){
				buf[r++]=(char)c;
				c=next();
			}
			return n==r?buf:Arrays.copyOf(buf, r);
		}
		private char[][] nm(int n, int m) throws IOException{
			char[][] map=new char[n][];
			for(int i=0; i<n; i++) map[i]=ns(m);
			return map;
		}
		private int[] na(int n) throws IOException{
			int[] a=new int[n];
			for(int i=0; i<n; i++) a[i]=ni();
			return a;
		}
		private boolean isChar(int c) throws IOException{ return !(c>=33&&c<=126); }
		private int next() throws IOException{ int c; while((c=read())!=-1&&isChar(c)); return c; }
		private byte read() throws IOException{
			if(bufP==bytR){
				bytR=din.read(buffer, bufP=0, 1024);
				if(bytR==-1) buffer[0]=-1;
			}
			return buffer[bufP++];
		}
		public void close() throws IOException{
			if(din==null) return;
			din.close();
		}
	}
}

import java.util.*;

public class Main {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int l = in.nextInt();
        int r = in.nextInt();
        int x = in.nextInt();
        int y = in.nextInt();
        int k = in.nextInt();

        if(k <= r/x && k >= l/y){
            p("YES");
        } else {
            p("NO");
        }

    }

    public static void p(Object str){
        System.out.println(str);
    }
    public static void pa(List<Object> objs){
        String str = "";
        for(Object obj : objs){
            str += obj.toString() + " ";
        }
    }
}

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

public class Main {

    public static void main(String[] args) throws Exception {
        FastReader fr = new FastReader();
        double l = fr.nextInt(), r = fr.nextInt(), x = fr.nextInt(), y = fr.nextInt(), k = fr.nextInt(), db = y-x, da = r-l;
        double lower_bound = l / y;
        double upper_bound = r / x;
        Double delta = Math.max(da, db)/Math.min(da, db);
        if((delta >= 1 || delta.compareTo(Double.NaN) == 0) && k >= lower_bound && k <= upper_bound){
            System.out.println("YES");
        }else{
            System.out.println("NO");
        }
    }

}

class FastReader {

    BufferedReader br;
    StringTokenizer st;

    public FastReader() throws FileNotFoundException {
        br = new BufferedReader(new InputStreamReader(System.in));
    }

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

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

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

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

    String nextLine() {
        String str = "";
        try {
            str = br.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return str;
    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            long l = in.nextLong();
            long r = in.nextLong();
            long x = in.nextLong();
            long y = in.nextLong();
            long k = in.nextLong();
            BigDecimal min = new BigDecimal(l).divide(new BigDecimal(y), 10, BigDecimal.ROUND_UP);
            BigDecimal max = new BigDecimal(r).divide(new BigDecimal(x), 10, BigDecimal.ROUND_UP);
            if (min.compareTo(new BigDecimal(k)) <= 0 && max.compareTo(new BigDecimal(k)) >= 0) {
                out.print("YES");
            } else out.print("NO");
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

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

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

        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 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);

        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void print(Object... objects) {
            for (int i = 0; i < objects.length; i++) {
                if (i != 0) {
                    writer.print(' ');
                }
                writer.print(objects[i]);
            }
        }

        public void close() {
            writer.close();
        }

    }
}

import java.util.Scanner;

public class KrillGame {

	public static void main(String[] args) {
		Scanner scn = new Scanner(System.in);
		int l = scn.nextInt();
		int r = scn.nextInt();
		int x = scn.nextInt();
		int y = scn.nextInt();
		int k = scn.nextInt();

		for (int i = x; i <= y; i++) {
			int temp = k * i;
			if (temp <= r && temp >= l) {
				System.out.println("YES");
				scn.close();
				return;
			}
		}
		System.out.println("NO");
		scn.close();
	}
}

public class kirillAndTheGame {

public static void main(String[] args) {

	int l = 1;
	int r = 10;
	int x = 1;
	int y = 10;
	int k = 1;

	boolean found = false ;
	for (int b = x; b <= y; ++b) {
		int a = k * b;
		if (a >= l && a <= r) {

			found = true ;

	}

	if(found) {
		 System.out.print("Yes");
	}else
		 System.out.println("No");

	return;
 }

}
}

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

public class Main{

	public static Boolean binary_search(double arr[], double key){
		int high = arr.length-1;
		int low = 0;
	//	double TOLERANCE = 1E-120;
		//System.out.println(key + "==========");
		// THIS ARRAY IS IN DESCENDING ORDER
		while(low<=high){//
			int mid = (high + low )/2;
			//System.out.println(mid);
			if(arr[mid]== key )
				return true;
			else if(arr[mid] > key)
			{
				low=mid+1;
			}
			else
				high = mid-1;
		}
		return false;
	}

	public static void main(String[] args) {
		MyScanner sc = new MyScanner();
		out = new PrintWriter(new BufferedOutputStream(System.out));

      // Start writing your solution here. -------------------------------------
		int l,r,x,y,k;
		l=sc.nextInt();
		r= sc.nextInt();
		x=sc.nextInt();
		y=sc.nextInt();
		k=sc.nextInt();
		double div[] = new double[y-x+1];
		for(int i=0; i < div.length;i++){
			div[i] = k * x;
			x++;
		}
		int i =0;
    //System.out.println(Arrays.toString(div));
		double key;
    key = l;
		for( i=0; i < r-l+1;i++){

			//out.println(div[0]+ " "+key);
			if(binary_search(div,key)){
				out.println("YES");
				break;
			}key++;
		}
		//out.println(i);
		if(i==r-l+1)
			out.println("NO");

      /*
      int n      = sc.nextInt();        // read input as integer
      long k     = sc.nextLong();       // read input as long
      double d   = sc.nextDouble();     // read input as double
      String str = sc.next();           // read input as Strigtgtgtgtgtgtgtng
      String s   = sc.nextLine();       // read whole line as String

      int result = 3*n;
      out.println(result);                    // print via PrintWriter;
      for(int i = 0; i lt N ; i++){
        for(int j = 0; j lt N; j++){
          System.out.print();
        }
        System.out.println();
      }
      */

      // Stop writing your solution here. -------------------------------------
      out.close();
  }

   //-----------PrintWriter for faster output---------------------------------
  public static PrintWriter out;

   //-----------MyScanner class for faster input----------
  public static class MyScanner {
  	BufferedReader br;
  	StringTokenizer st;

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

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

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

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

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

  	String nextLine(){
  		String str = "";
  		try {
  			str = br.readLine();
  		} catch (IOException e) {
  			e.printStackTrace();
  		}
  		return str;
  	}

  }
   //--------------------------------------------------------
}

import java.util.Scanner;
import java.io.*;
import java.lang.Math;

public class A {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        long l = scanner.nextLong();
        long r = scanner.nextLong();
        long x = scanner.nextLong();
        long y = scanner.nextLong();
        double k = scanner.nextDouble();

        if ((((k / l) >= x) && ((k / l) <= y)) ||  (((k / r) >= x) && ((k / r) <= y))
            || (((k / y) >= l) && ((k / y) <= r)) || (((k / x) <= r) && ((k / x) >= l)))
        {
            System.out.println("YES");
        } else {
            System.out.println("NO");
        }
    }
}

import java.util.Scanner;
import java.io.*;
import java.lang.Math;

public class A {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        long l = scanner.nextLong();
        long r = scanner.nextLong();
        long x = scanner.nextLong();
        long y = scanner.nextLong();
        double k = scanner.nextDouble();

        if (((((k / l) >= x) || ((k / r) >= x)) && (((k / l) <= y) || ((k / r) <= y)))
            || ((((k / x) >= l) || ((k / y) >= l)) && (((k / x) <= r) || ((k / y) <= r))))
        {
            System.out.println("YES");
        } else {
            System.out.println("NO");
        }
    }
}

import java.util.Scanner;
public class cf842 {

	public static void main(String[] args){

		Scanner sc = new Scanner (System.in);
		int x = sc.nextInt();
		int y = sc.nextInt();
		int u = sc.nextInt();
		int v = sc.nextInt();
		int k = sc.nextInt();
		for(int b=u; b<=v; b++){
		if(b*k>=x && b*k<=y){
			System.out.print("Yes");
			System.exit(0);

			}
		}
		System.out.print("NO");
	}
}

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

public class File {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        int l = sc.nextInt();
        int r = sc.nextInt();
        int x = sc.nextInt();
        int y = sc.nextInt();
        int k = sc.nextInt();

        // Min ratio is l / y
        // Max ratio is r / x

        // 1 30 (l, r)
        // 3 8  (x, y)
        // 7    (k)
        //  [1, 10]
        int min = (int) Math.ceil((double)l / (double)y);
        int max = (int) Math.floor((double)r / (double)x);

        if (min <= k && k <= max) {
            System.out.println("YES");
        }
        else {
            System.out.println("NO");
        }
    }
}

import java.util.Scanner;
public class A {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);

		long L = in.nextLong();
		long R = in.nextLong();
		long X = in.nextLong();
		long Y = in.nextLong();
		long K = in.nextLong();

		if(K*Y<L || K*X>R) System.out.println("NO");
		else System.out.println("YES");

		in.close();
	}
}

import java.util.Scanner;
import java.io.*;
import java.lang.Math;

public class A {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        long l = scanner.nextLong();
        long r = scanner.nextLong();
        long x = scanner.nextLong();
        long y = scanner.nextLong();
        long k = scanner.nextLong();

        for (long i = r; i >= l; i--) {
            if ((k % i) == 0) {
                k /= i;

                for (long j = y; j >= x; j--) {
                    if ((k % j) == 0) {
                        System.out.println("YES");
                        return;
                    }
                }
            }
        }

        System.out.println("NO");
    }
}

import java.util.*;
public class MyClass {
    public static void main(String args[]) {
        Scanner sc = new Scanner(System.in);
        int l=sc.nextInt();
        int r=sc.nextInt();
        int x=sc.nextInt();
        int y=sc.nextInt();
        int k=sc.nextInt();
        int flag=0;
        outer:
       for(int i=r;i<=l;i--)
       {
           for(int j=x;j<=y;j++)
           {
               int h = i/j;
               if(h==k)
               {
                   flag=1;
                   break outer;
               }
           }
       }

        if(flag==1)
        {
            System.out.println("YES");
        }
        else
        {
            System.out.println("NO");
        }
    }
}

//package codeforces;

import java.util.*;
public class solution
{
    public static void main(String args[])
    {
        Scanner in=new Scanner(System.in);
        long a11=in.nextLong();
        long a2=in.nextLong();
        long b1=in.nextLong();
        long b2=in.nextLong();
        double k=in.nextLong();
        int f=0;
        for(long i=a11;i<=a2;i++)
        {
            double r=i*k;
           // System.out.println(r);
            if(r>=b1 && r<=b2)
            {
                f=1;
                break;
            }
        }
        if(f==0)
        {
            System.out.println("NO");
        }
        else
        {
            System.out.println("YES");
        }
    }
}

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

public class KirillGame	{
	public static void main(String[] args)	{
		new Task().run();
	}

	static class Task	{
		public void solve(InputReader in, PrintWriter out)	{
			solve(1, in, out);
		}

		public void solve(int testCase, InputReader in, PrintWriter out)	{
			long l = in.nextLong(), r = in.nextLong(), x = in.nextLong(), y = in.nextLong(), k = in.nextLong();
			if(k < (1.0*l)/y || k > (1.0*r)/x)	{
				System.out.println("NO");
			}	else {
				System.out.println("YES");
			}
		}

		public void run()	{
			InputReader in = new InputReader(System.in);
			PrintWriter out = new PrintWriter(System.out);
			solve(in, out);
			out.close();
		}

		static class InputReader {
			public BufferedReader reader;
			public StringTokenizer tokenizer;

			public InputReader(InputStream stream) {
				reader = new BufferedReader(new InputStreamReader(stream), 32768);
				tokenizer = null;
			}

			public String next() {
				while (tokenizer == null || !tokenizer.hasMoreTokens()) {
					try {
						tokenizer = new StringTokenizer(reader.readLine());
					} catch (IOException e) {
						throw new RuntimeException(e);
					}
				}
				return tokenizer.nextToken();
			}

			public int nextInt() {
				return Integer.parseInt(next());
			}

			public long nextLong() {
				return Long.parseLong(next());
			}
		}
	}
}

import java.util.Scanner;
/**
 *
 * @author никитяночка
 */
public class Main {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code appl0ication logic here
        Scanner in = new Scanner(System.in);
        int l = in.nextInt();
        int r = in.nextInt();
        int x = in.nextInt();
        int y = in.nextInt();
        int k = in.nextInt();
        for (int i = x; i <= y; i++) {
            if (k * y >= l && k * y <= r) {
                System.out.println("YES");
                return;
            }
        }
        System.out.println("NO");
    }

}

import java.util.Scanner;

public class kirillAndTheGame {
	public static void main(String[] args) {

		Scanner kbd = new Scanner(System.in);

		int l = 0;
		int r = 0;
		int x = 0;
		int y = 0;
		int k = 0;

		l = kbd.nextInt();
		r = kbd.nextInt();
		x = kbd.nextInt();
		y = kbd.nextInt();
		k = kbd.nextInt();

		Object cin = l >> r >> x >> y >> k;

		boolean found = false ;

		for (int b = x; b <= y; ++b) {
			int a = k * b;
			if (a >= l && a <= r) {
				found = true ;
				break;
			}
			}

			if(found) {
				System.out.print("Yes");
			}else
				System.out.println("No");

			return;
		}

	}

import java.util.Scanner;

public class numbajuan {

	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
			int b = scan.nextInt();
			int c = scan.nextInt();
			int d = scan.nextInt();
			int e = scan.nextInt();
			int f = scan.nextInt();
			if(b/d == f || c/e == f){
				System.out.println("YES");
			}else{
				System.out.println("NO");
			}

		}

	}

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

public class Kiril_And_The_Game {

	static class FastReader {
		BufferedReader br;
		StringTokenizer st;

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

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

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

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

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

		String nextLine() {
			String str = "";
			try {
				str = br.readLine();
			} catch (IOException e) {
				e.printStackTrace();
			}
			return str;
		}

	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		FastReader t = new FastReader();
		PrintWriter o = new PrintWriter(System.out);
		long l = t.nextLong();
		long r = t.nextLong();
		long x = t.nextLong();
		long y = t.nextLong();
		long k = t.nextLong();
		boolean ans = false;
		long i = x;

		while (i <= y) {
			if (k * i >= l && k * i <= r) {
				ans = true;
				break;
			}

			if (k * i > y)
				break;

			i++;
		}

		if (ans)
			o.println("YES");
		else
			o.println("NO");

		o.flush();
		o.close();
	}
}

import java.util.Scanner;

public class question1 {

	public static void main(String[] args) {

		Scanner s = new Scanner(System.in);

		long l=s.nextInt();
		long r=s.nextInt();
		long x=s.nextInt();
		long y=s.nextInt();
		long k=s.nextInt();

		  long minLimit=Math.min(Math.min(l/x,l/y),Math.min(r/x,r/y));
		  long maxLimit=Math.max(Math.max(r/x, r/y),Math.max(l/x,l/y));

		  if(k>=minLimit && k<=maxLimit){
			  System.out.println("YES");
		  }else{
			  System.out.println("NO");
		  }
}
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.PrintStream;
import java.util.Scanner;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author useless_fellow
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        Scanner in = new Scanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, Scanner in, PrintWriter out) {
            long l = in.nextInt();
            long r = in.nextInt();
            long x = in.nextInt();
            long y = in.nextInt();
            long k = in.nextInt();
            boolean found = false;
            for (long i = x * k; i < y * k; i += k) {
                if (i >= l && i <= r) {
                    found = true;
                    break;
                }
            }
            if (found) System.out.println("YES");
            else System.out.println("NO");
        }

    }
}

import java.util.*;
import java.io.*;
import java.math.*;
import java.util.regex.*;

public class Main {

    static Scanner input = new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    static Reader fastInput = new Reader();

    public static void main(String[] args) throws IOException {
        int l = input.nextInt();
        int r = input.nextInt();
        int x = input.nextInt();
        int y = input.nextInt();
        int k = input.nextInt();
        int esL = x * k;
        int esR = y * k;
        if ((esL >= l && esL <= r) || (esR >= l && esR <= r) || (esR >= r && esL <= l)) {
            System.out.println("YES");
        } else {
            System.out.println("NO");
        }
    }

    static class Reader {

        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;

        public Reader() {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public Reader(String file_name) throws IOException {
            din = new DataInputStream(new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public String readLine() throws IOException {
            byte[] buf = new byte[64]; // line length
            int cnt = 0, c;
            while ((c = read()) != -1) {
                if (c == '\n') {
                    break;
                }
                buf[cnt++] = (byte) c;
            }
            return new String(buf, 0, cnt);
        }

        public int nextInt() throws IOException {
            int ret = 0;
            byte c = read();
            while (c <= ' ') {
                c = read();
            }
            boolean neg = (c == '-');
            if (neg) {
                c = read();
            }
            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');

            if (neg) {
                return -ret;
            }
            return ret;
        }

        public long nextLong() throws IOException {
            long ret = 0;
            byte c = read();
            while (c <= ' ') {
                c = read();
            }
            boolean neg = (c == '-');
            if (neg) {
                c = read();
            }
            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');
            if (neg) {
                return -ret;
            }
            return ret;
        }

        public double nextDouble() throws IOException {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ') {
                c = read();
            }
            boolean neg = (c == '-');
            if (neg) {
                c = read();
            }

            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');

            if (c == '.') {
                while ((c = read()) >= '0' && c <= '9') {
                    ret += (c - '0') / (div *= 10);
                }
            }

            if (neg) {
                return -ret;
            }
            return ret;
        }

        private void fillBuffer() throws IOException {
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            if (bytesRead == -1) {
                buffer[0] = -1;
            }
        }

        private byte read() throws IOException {
            if (bufferPointer == bytesRead) {
                fillBuffer();
            }
            return buffer[bufferPointer++];
        }

        public void close() throws IOException {
            if (din == null) {
                return;
            }
            din.close();
        }
    }
}

//package CF_430;

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

public class A {
	public static void main(String[] args) throws Exception{ new A(new Reader()); }
	public A(Reader rr) throws IOException{
		long l=rr.nl(), r=rr.nl(), x=rr.nl(), y=rr.nl(), k=rr.nl();
		double eff=(double)r/(double)x;
		if(eff>=(double)k) System.out.println("YES");
		else System.out.println("NO");
	}
	static class Reader{
		private DataInputStream din;
		private byte[] buffer=new byte[1024];
		private int bufP, bytR;
		public Reader() throws IOException{
			din=new DataInputStream(System.in);
			bufP=bytR=0;
		}
		public Reader(String file) throws IOException{
			din=new DataInputStream(new FileInputStream(file));
			bufP=bytR=0;
		}
		private String rl() throws IOException{
			byte[] buf=new byte[1024];
			int cnt=0, c;
			while((c=read())!=-1){
				if(c=='\n') break;
				buf[cnt++]=(byte)c;
			}
			return new String(buf, 0, cnt);
		}
		private int ni() throws IOException{
			int num=0;
			byte c=read();
			while(c<=' ') c=read();
			boolean neg=(c=='-');
			if(neg) c=read();
			do{
				num=num*10+c-'0';
			} while((c=read())>='0'&&c<='9');
			if(neg) return -num;
			return num;
		}
		private long nl() throws IOException{
			long num=0;
			byte c=read();
			while(c<=' ') c=read();
			boolean neg=(c=='-');
			if(neg) c=read();
			do{
				num=num*10+c-'0';
			} while((c=read())>='0'&&c<='9');
			if(neg) return -num;
			return num;
		}
		private double nd() throws IOException{ return Double.parseDouble(ns()); }
		private char nc() throws IOException{ return (char)next(); }
		private String ns() throws IOException{
			int c=next();
			StringBuilder sb=new StringBuilder();
			while(!(isChar(c))){
				sb.appendCodePoint(c);
				c=read();
			}
			return sb.toString();
		}
		private char[] ns(int n) throws IOException{
			char[] buf=new char[n];
			int c=next(), r=0;
			while(r<n&&!(isChar(c))){
				buf[r++]=(char)c;
				c=next();
			}
			return n==r?buf:Arrays.copyOf(buf, r);
		}
		private char[][] nm(int n, int m) throws IOException{
			char[][] map=new char[n][];
			for(int i=0; i<n; i++) map[i]=ns(m);
			return map;
		}
		private int[] na(int n) throws IOException{
			int[] a=new int[n];
			for(int i=0; i<n; i++) a[i]=ni();
			return a;
		}
		private boolean isChar(int c) throws IOException{ return !(c>=33&&c<=126); }
		private int next() throws IOException{ int c; while((c=read())!=-1&&isChar(c)); return c; }
		private byte read() throws IOException{
			if(bufP==bytR){
				bytR=din.read(buffer, bufP=0, 1024);
				if(bytR==-1) buffer[0]=-1;
			}
			return buffer[bufP++];
		}
		public void close() throws IOException{
			if(din==null) return;
			din.close();
		}
	}
}

import java.util.*;
public class MyClass {
    public static void main(String args[]) {
        Scanner sc = new Scanner(System.in);
        int l=sc.nextInt();
        int r=sc.nextInt();
        int x=sc.nextInt();
        int y=sc.nextInt();
        int k=sc.nextInt();
        int flag=0;
        int exp;
        outer:
       for(int i=x;i<=y;i++)
       {
           exp = k*x;
           if(exp>=l && exp<=r)
           {
               flag=1;
               System.out.println("YES");
               break;
           }
       }

       if(flag==0)
       {
           System.out.println("NO");
       }

    }
}

import java.util.Scanner;

public class KirillandGame {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Scanner input = new Scanner(System.in);
		int l = input.nextInt();
		int r = input.nextInt();
		int x = input.nextInt();
		int y = input.nextInt();
		int k = input.nextInt();

		for(int i=l;i<=r;i++){
			for(int j=x; j<=y;j++){
				if(k==(int)(i/j)){
					System.out.println("YES");
					return;
				}
			}
		}

	}

}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            long l = in.nextLong();
            long r = in.nextLong();
            long x = in.nextLong();
            long y = in.nextLong();
            double k = in.nextDouble();
            BigDecimal min = new BigDecimal(l).divide(new BigDecimal(y), 10, BigDecimal.ROUND_UP);
            BigDecimal max = new BigDecimal(r).divide(new BigDecimal(x), 10, BigDecimal.ROUND_UP);
            if (min.compareTo(new BigDecimal(k)) <= 0 && max.compareTo(new BigDecimal(k)) >= 0) {
                out.print("YES");
            } else out.print("NO");
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

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

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

        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 < '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 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 double nextDouble() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            double res = 0;
            while (!isSpaceChar(c) && c != '.') {
                if (c == 'e' || c == 'E') {
                    return res * Math.pow(10, nextInt());
                }
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            }
            if (c == '.') {
                c = read();
                double m = 1;
                while (!isSpaceChar(c)) {
                    if (c == 'e' || c == 'E') {
                        return res * Math.pow(10, nextInt());
                    }
                    if (c < '0' || c > '9') {
                        throw new InputMismatchException();
                    }
                    m /= 10;
                    res += (c - '0') * m;
                    c = read();
                }
            }
            return res * sgn;
        }

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

        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void print(Object... objects) {
            for (int i = 0; i < objects.length; i++) {
                if (i != 0) {
                    writer.print(' ');
                }
                writer.print(objects[i]);
            }
        }

        public void close() {
            writer.close();
        }

    }
}

import java.util.Scanner;

public class ProblemA {

	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int l = scan.nextInt();
		int r = scan.nextInt();
		int x = scan.nextInt();
		int y = scan.nextInt();
		int k = scan.nextInt();
		int a = (r-l)+1;
		int b = (y-x)+1;
		int potions = a*b;
		int c = l;
		int d = x;
		if(r < x) {
			System.out.println("NO");
			return;
		}
		if(l == x && r == y && k == 1) {
			System.out.println("YES");
			return;
		}
		if(k > l/y) {
			System.out.println("NO");
			return;
		}
		for(int i = 0; i < potions; i++) {
			for(int j = 0; j < c; j++) {
				if(c/d == k) {
					System.out.println("YES");
					return;
				}
				d++;
			}
			c+=2;
		}
		System.out.println("NO");

	}

}

//package CodeForces;

/*In the name of Allah the Most Merciful.
 * Author
 * Md. Toufiqul Islam
 * Dept. Of CSE
 * Ahsanullah University Of Science And Technology
*/

import java.io.*;
import java.util.*;
public class R430A {

          //Code for Faster Input
    	  public static class MyScanner {

    	      BufferedReader br;
    	      StringTokenizer st;

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

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

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

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

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

    	      String nextLine(){
    	          String str = "";
    		  try {
    		     str = br.readLine();
    		  } catch (IOException e) {
    		     e.printStackTrace();
    		  }
    		  return str;
    	      }

    	   }
    	   //--------------------------------------------------------
           public static void main(String[] args) {
               MyScanner sc = new MyScanner();
               long l = sc.nextLong();
               long r = sc.nextLong();
               long x = sc.nextLong();
               long y = sc.nextLong();
               long k = sc.nextLong();

               double val1 = l/x;
               double val2 = r/y;
               if((r-l+1)*(y-x+1)==0){

                   System.out.println("NO");
               }
               else {
                   if(k>=l && k<=r && (x==1 || y==1) ){
                       System.out.println("YES");
                   }
                   else{
                       System.out.println("NO");
                   }

               }
           }
}

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

public class Main {

    public static void main(String[] args) throws Exception {
        FastReader fr = new FastReader();
        double l = fr.nextInt(), r = fr.nextInt(), x = fr.nextInt(), y = fr.nextInt(), k = fr.nextInt(), db = y-x, da = r-l;
        double lower_bound = l / y;
        double upper_bound = r / x;
        Double delta = (Math.max(da, db)+1)/(Math.min(da, db)+1);
        // System.out.println(delta);
        boolean ok = (delta == 1 || delta >= 4 || delta.compareTo(Double.NaN) == 0) && (delta.compareTo(Double.POSITIVE_INFINITY) != 0);
        if( ok && k >= lower_bound && k <= upper_bound){
            System.out.println("YES");
        }else{
            System.out.println("NO");
        }
    }

}

class FastReader {

    BufferedReader br;
    StringTokenizer st;

    public FastReader() throws FileNotFoundException {
        br = new BufferedReader(new InputStreamReader(System.in));
    }

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

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

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

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

    String nextLine() {
        String str = "";
        try {
            str = br.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return str;
    }
}

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

public class Main {

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

        new Main().go();
    }

    PrintWriter out;
    Reader in;
    BufferedReader br;

    Main() throws IOException {

        try {

            //br = new BufferedReader( new FileReader("input.txt") );
            in = new Reader("input.txt");
            out = new PrintWriter( new BufferedWriter(new FileWriter("output.txt")) );
        }
        catch (Exception e) {

            //br = new BufferedReader( new InputStreamReader( System.in ) );
            in = new Reader();
            out = new PrintWriter( new BufferedWriter(new OutputStreamWriter(System.out)) );
        }
    }

    void go() throws IOException {

        int t = 1;
        while (t > 0) {
            solve();
            //out.println();
            t--;
        }

        out.flush();
        out.close();
    }

    int inf = 2000000000;
    int mod = 1000000007;
    double eps = 0.00000001;

    int n;
    int m;

    ArrayList<Integer>[] g = new ArrayList[200000];
    HashMap<Integer, HashMap<Integer, Boolean>> map = new HashMap<>();

    void solve() throws IOException {

        int l = in.nextInt();
        int r = in.nextInt();

        int x = in.nextInt();
        int y = in.nextInt();

        int k = in.nextInt();

        int res = l/k + l%k;

        if ((res <= r && res/k >= x && res/k <= y) || (1l*k*x >= l && 1l*k*x <= r))
            out.println("YES");
        else
            out.println("NO");

    }

    class Pair implements Comparable<Pair>{

        int a;
        int b;

        Pair(int a, int b) {

            this.a = a;
            this.b = b;
        }

        public int compareTo(Pair p) {

            if (a > p.a) return 1;
            if (a < p.a) return -1;
            if (b > p.b) return 1;
            if (b < p.b) return -1;
            return 0;
        }
    }

    class Item {

        int a;
        int b;
        int c;

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

    }

    class Reader {

        BufferedReader  br;
        StringTokenizer tok;

        Reader(String file) throws IOException {
            br = new BufferedReader( new FileReader(file) );
        }

        Reader() throws IOException {
            br = new BufferedReader( new InputStreamReader(System.in) );
        }

        String next() throws IOException {

            while (tok == null || !tok.hasMoreElements())
                tok = new StringTokenizer(br.readLine());
            return tok.nextToken();
        }

        int nextInt() throws NumberFormatException, IOException {
            return Integer.valueOf(next());
        }

        long nextLong() throws NumberFormatException, IOException {
            return Long.valueOf(next());
        }

        double nextDouble() throws NumberFormatException, IOException {
            return Double.valueOf(next());
        }

        String nextLine() throws IOException {
            return br.readLine();
        }

    }

}

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

public class KirillGame	{
	public static void main(String[] args)	{
		new Task().run();
	}

	static class Task	{
		public void solve(InputReader in, PrintWriter out)	{
			solve(1, in, out);
		}

		public void solve(int testCase, InputReader in, PrintWriter out)	{
			int l = in.nextInt(), r = in.nextInt(), x = in.nextInt(), y = in.nextInt(), k = in.nextInt();
			if(k < (1.0*l)/y || k > (1.0*r)/x)	{
				System.out.println("NO");
			}	else {
				System.out.println("YES");
			}
		}

		public void run()	{
			InputReader in = new InputReader(System.in);
			PrintWriter out = new PrintWriter(System.out);
			solve(in, out);
		}

		static class InputReader {
			public BufferedReader reader;
			public StringTokenizer tokenizer;

			public InputReader(InputStream stream) {
				reader = new BufferedReader(new InputStreamReader(stream), 32768);
				tokenizer = null;
			}

			public String next() {
				while (tokenizer == null || !tokenizer.hasMoreTokens()) {
					try {
						tokenizer = new StringTokenizer(reader.readLine());
					} catch (IOException e) {
						throw new RuntimeException(e);
					}
				}
				return tokenizer.nextToken();
			}

			public int nextInt() {
				return Integer.parseInt(next());
			}
		}
	}
}

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

public class Main
{
	static class FastReader
    {
        BufferedReader br;
        StringTokenizer st;

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

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

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

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

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

        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
    }

	public static void main (String[] args)
	{
		FastReader reader = new FastReader();

		double l = reader.nextInt();
		double r = reader.nextInt();
		double x = reader.nextInt();
		double y = reader.nextInt();
		double k = reader.nextInt();

		int dummy = 3232;

		double low = l / y;
		double high = r / x;

		if (k >= low && k <= high)
			System.out.println ("YES");
		else
			System.out.println ("NO");
	}
}

import java.util.Scanner;

public class contestone {
	public static void main(String[] args) {
		Scanner scanny = new Scanner(System.in);
		double expMin = scanny.nextDouble();
		double expMax = scanny.nextDouble();
		double costMin = scanny.nextDouble();
		double costMax = scanny.nextDouble();
		double goal = scanny.nextDouble();
		String print = "NO";
		for (double i = expMin; i <= expMax; i++) {
			for (double j = costMin; j <= costMax; j++) {
				if (i/j == goal) print = "YES";
				break;
			}
		}
		System.out.println(print);
	}
}

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

/* Name of the class has to be "Main" only if the class is public. */
 public class Ideone
{
	public static void main (String[] args) throws java.lang.Exception
	{
		Scanner s = new Scanner(System.in);
		int l = s.nextInt();
		int r = s.nextInt();
		int x = s.nextInt();
		int y = s.nextInt();
		int k = s.nextInt();
                      //  if(3<3.566) System.out.println("dd");
		for(int i=x;i<=y;i++){
		    long temp = k * i;
			if(temp>=l&&temp<=r){
				System.out.println("YES");
				return;
			}
		}
		System.out.println("NO");
	}
}

import java.util.Scanner;
import java.io.*;
import java.lang.Math;

public class A {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        long l = scanner.nextLong();
        long r = scanner.nextLong();
        long x = scanner.nextLong();
        long y = scanner.nextLong();
        long k = scanner.nextLong();

        for (long i = r; i >= l; i--) {
            if ((k % i) == 0) {
                k /= i;
                for (long j = y; j >= x; j--) {
                    if (k == j) {
                        System.out.println("YES");
                        return;
                    }
                }
                k *= i;
            }
        }

        System.out.println("NO");
    }
}

import java.util.*;
import java.io.*;
import java.math.*;
import java.util.regex.*;

public class Main {

    static Scanner input = new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    static Reader fastInput = new Reader();

    public static void main(String[] args) throws IOException {
        int l = input.nextInt();
        int r = input.nextInt();
        int x = input.nextInt();
        int y = input.nextInt();
        int k = input.nextInt();
        int esL = x * k;
        int esR = y * k;
        if ((esL >= l && esL <= r) || (esR >= l && esR <= r)) {
            System.out.println("YES");
        } else {
            System.out.println("NO");
        }
    }

    static class Reader {

        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;

        public Reader() {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public Reader(String file_name) throws IOException {
            din = new DataInputStream(new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public String readLine() throws IOException {
            byte[] buf = new byte[64]; // line length
            int cnt = 0, c;
            while ((c = read()) != -1) {
                if (c == '\n') {
                    break;
                }
                buf[cnt++] = (byte) c;
            }
            return new String(buf, 0, cnt);
        }

        public int nextInt() throws IOException {
            int ret = 0;
            byte c = read();
            while (c <= ' ') {
                c = read();
            }
            boolean neg = (c == '-');
            if (neg) {
                c = read();
            }
            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');

            if (neg) {
                return -ret;
            }
            return ret;
        }

        public long nextLong() throws IOException {
            long ret = 0;
            byte c = read();
            while (c <= ' ') {
                c = read();
            }
            boolean neg = (c == '-');
            if (neg) {
                c = read();
            }
            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');
            if (neg) {
                return -ret;
            }
            return ret;
        }

        public double nextDouble() throws IOException {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ') {
                c = read();
            }
            boolean neg = (c == '-');
            if (neg) {
                c = read();
            }

            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');

            if (c == '.') {
                while ((c = read()) >= '0' && c <= '9') {
                    ret += (c - '0') / (div *= 10);
                }
            }

            if (neg) {
                return -ret;
            }
            return ret;
        }

        private void fillBuffer() throws IOException {
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            if (bytesRead == -1) {
                buffer[0] = -1;
            }
        }

        private byte read() throws IOException {
            if (bufferPointer == bytesRead) {
                fillBuffer();
            }
            return buffer[bufferPointer++];
        }

        public void close() throws IOException {
            if (din == null) {
                return;
            }
            din.close();
        }
    }
}