Kirill plays a new computer game. He came to the potion store where he can buy any potion. Each potion is characterized by two integers — amount of experience and cost. The efficiency of a potion is the ratio of the amount of experience to the cost. Efficiency may be a non-integer number.

For each two integer numbers a and b such that l ≤ a ≤ r and x ≤ b ≤ y there is a potion with experience a and cost b in the store (that is, there are (r - l + 1)·(y - x + 1) potions).

Kirill wants to buy a potion which has efficiency k. Will he be able to do this?


-----Input-----

First string contains five integer numbers l, r, x, y, k (1 ≤ l ≤ r ≤ 10^7, 1 ≤ x ≤ y ≤ 10^7, 1 ≤ k ≤ 10^7).


-----Output-----

Print "YES" without quotes if a potion with efficiency exactly k can be bought in the store and "NO" without quotes otherwise.

You can output each of the letters in any register.


-----Examples-----
Input
1 10 1 10 1

Output
YES
Input
1 5 6 10 1

Output
NO

Difficulty: EASY

Solutions:
(l, r, x, y, k) = [int(x) for x in input().split()]

def function_k(k):
	for b in range(x, y + 1):
		if l <= k * b <= r:
			return b
if function_k(k) is not None:
	print('YES')
else:
	print('NO')


(l, r, x, y, k) = list(map(int, input().split()))
ans = 0
for i in range(x, y + 1):
	if i * k <= r and i * k >= l:
		if ans == 0:
			print('YES')
			ans = 1
if ans == 0:
	print('NO')


(l, r, x, y, k) = map(int, input().split())
for i in range(x, y + 1):
	if i * k <= r and i * k >= l:
		print('YES')
		break
else:
	print('NO')


import math
import sys
import collections

def In():
	return map(int, sys.stdin.readline().split())
input = sys.stdin.readline

def krillgame():
	(l, r, x, y, k) = In()
	for i in range(x, y + 1):
		if l <= k * i <= r:
			print('YES')
			break
	else:
		print('NO')
krillgame()


(l, r, x, y, k) = map(int, input().split())
if min(k * y, r) >= max(k * x, l) and (l - 1) // k < r // k:
	print('YES')
else:
	print('NO')


(l, r, x, y, k) = list(map(int, input().split()))
s = x
for f in range(l, r + 1):
	while s <= y and s * k < f:
		s += 1
	if s <= y and s * k == f:
		print('YES')
		exit(0)
print('NO')


(l, r, x, y, k) = map(int, input().split())
if x * k > r or y * k < l:
	print('NO')
	exit()
b = x
while b <= y:
	t = b * k
	if t >= l and t <= r:
		print('YES')
		exit()
	if t > r:
		break
	b += 1
print('NO')


(l, r, x, y, k) = map(int, input().split())

def samt(n):
	if k * n > r:
		return 1
	if k * n < l:
		return -1
	return 0
(av, ox) = (x, y)
while av < ox + 1:
	n = (av + ox) // 2
	s = samt(n)
	if s == -1:
		av = n + 1
	elif s == 1:
		ox = n - 1
	else:
		break
found = False
for n in range(av, ox + 1):
	if samt(n) == 0:
		found = True
if found:
	print('YES')
else:
	print('NO')


import math

def potion(exp1, exp2, cost1, cost2, k):
	minExp = k * cost1
	if minExp > exp2:
		return False
	maxExp = k * cost2
	if maxExp < exp1:
		return False
	if exp1 > minExp and exp2 < maxExp:
		if exp1 % k == 0:
			return True
		if (exp1 // k + 1) * k <= exp2:
			return True
		return False
	return True

def potion2(exp1, exp2, cost1, cost2, k):
	for i in range(cost2 - cost1 + 1):
		exp = (i + cost1) * k
		if exp <= exp2 and exp >= exp1:
			return True
	return False

def test():
	print(potion(1, 10, 9, 10, 1) == True)
	print(potion(1, 11, 6, 10, 2) == False)
	print(potion(1, 10000000, 1, 10000000, 10000000) == True)
	print(potion(1, 1000000, 1, 10000000, 10000000) == False)
	print(potion(10000000, 10000000, 10, 10000000, 1000000) == True)
	print(potion(10000000, 10000000, 1, 2, 1000000) == False)
	print(potion(2000000, 10000000, 1, 2, 1000000) == True)
	print(potion(2000001, 10000000, 1, 2, 1000000) == False)
	print(potion(4, 4, 1, 2, 3) == False)
	print(potion(99, 100, 1, 100, 50) == True)

def solve():
	s = input()
	s = s.split()
	ok = potion(int(s[0]), int(s[1]), int(s[2]), int(s[3]), int(s[4]))
	print('YES' if ok else 'NO')
solve()


class CodeforcesTask842ASolution:

	def __init__(self):
		self.result = ''
		self.l_r_x_y_k = []

	def read_input(self):
		self.l_r_x_y_k = [int(x) for x in input().split(' ')]

	def process_task(self):
		can = False
		for b in range(self.l_r_x_y_k[2], self.l_r_x_y_k[3] + 1):
			a = self.l_r_x_y_k[-1] * b
			if self.l_r_x_y_k[0] <= a <= self.l_r_x_y_k[1]:
				can = True
				break
		self.result = 'YES' if can else 'NO'

	def get_result(self):
		return self.result
Solution = CodeforcesTask842ASolution()
Solution.read_input()
Solution.process_task()
print(Solution.get_result())


(l, r, x, y, k) = map(int, input().split())
for i in range(x, y + 1):
	if l <= i * k <= r:
		print('YES')
		exit()
print('NO')


p = list(map(int, input().split()))
flag = 0
for i in range(p[2], p[3] + 1):
	j = i * p[4]
	if j >= p[0] and j <= p[1]:
		flag = 1
		break
if flag == 0:
	print('NO')
else:
	print('YES')


(l, r, x, y, k) = map(int, input().split())
a11 = k * x
a12 = k * y
flag = 0
if a12 < l or r < a11:
	print('NO')
	flag += 1
d = 0
if flag == 0 and a12 >= l:
	for i in range(l, min(int(a12) + 1, r + 1)):
		if i % k == 0:
			print('YES')
			flag += 1
			break
	d += 1
if flag == 0 and a11 <= r:
	for i in range(max(int(a11), l), min(r + 1, int(a12) + 1)):
		if i % k == 0:
			print('YES')
			flag += 1
			break
	d += 1
if flag == 0 and d == 2:
	print('NO')


import math
(l, r, x, y, k) = map(int, input().split())
(la, ra) = (k * x, k * y)
if r < la or ra < l:
	print('NO')
elif l <= la <= r or l <= ra <= r:
	print('YES')
else:
	xb = int(math.floor(l / k))
	yb = int(math.ceil(r / k))
	for b in range(xb, yb + 1):
		if l <= k * b <= r:
			print('YES')
			break
	else:
		print('NO')


import math
(l, r, x, y, k) = map(int, input().split())
print('YES' if not (y < math.ceil(l / k) or x > r // k) and math.ceil(l / k) <= r // k else 'NO')


(l, r, x, y, k) = list(map(int, input().split()))
if l > y * k or r < x * k:
	print('NO')
elif l <= x * k or r >= y * k:
	print('YES')
elif r - l + 1 >= k or r // k > (l - 1) // k:
	print('YES')
else:
	print('NO')


import math

def main():
	(l, r, x, y, k) = (int(n) for n in input().split())
	print(solver(l, r, x, y, k))

def solver(l, r, x, y, k):
	hi = r // k
	lo = math.ceil(l / k)
	if lo > hi or lo > y or hi < x:
		return 'NO'
	else:
		return 'YES'
main()


(l, r, x, y, k) = list(map(int, input().split()))
if x * k <= r and y * k >= l and (l // k != r // k or l // k * k == l):
	print('YES')
else:
	print('NO')


(l, r, x, y, k) = map(int, input().split())
if r - l > x - y:
	for b in range(x, y + 1):
		if l <= k * b <= r:
			print('YES')
			quit()
else:
	for a in range(l, r + 1):
		if x <= k * a <= y:
			print('YES')
			quit()
print('NO')


import sys

def main():
	x = sys.stdin.readline().split()
	l = int(x[0])
	r = int(x[1])
	xx = int(x[2])
	y = int(x[3])
	k = int(x[4])
	for i in range(xx, y + 1):
		p = i * k
		if l <= p and p <= r:
			print('YES')
			return
	print('NO')

def __starting_point():
	main()
__starting_point()


from sys import stdin

def get_ints():
	return list(map(int, stdin.readline().strip().split()))
(l, r, x, y, k) = get_ints()
ans = sum([1 for i in range(x, y + 1) if l <= i * k <= r])
print('NO' if ans == 0 else 'YES')


def charo(l, r, x, y, k):
	if l <= r < x < y:
		return 'NO'
	oo = r // k
	kk = l // k
	compteur = oo - kk
	if l % k == 0 or r % k == 0:
		compteur += 1
	if compteur >= 1:
		for loop in range(x, y + 1):
			if l <= k * loop and r >= k * loop:
				return 'YES'
	return 'NO'
(l, r, x, y, k) = map(int, input().split())
print(charo(l, r, x, y, k))


def crossRange(r1, r2):
	low = max(r1[0], r2[0])
	high = min(r1[1], r2[1])
	return low <= high
(l, r, x, y, k) = map(int, input().split())
r1 = ((l + k - 1) // k, r // k)
print('YES' if crossRange(r1, (x, y)) else 'NO')


import sys
input = sys.stdin.readline
read = lambda : map(int, input().split())

def ceil(x):
	if x != int(x):
		x = int(x) + 1
	return x

def factorial(x, m):
	val = 1
	while x > 0:
		val = val * x % m
		x -= 1
	return val

def fact(x):
	val = 1
	while x > 0:
		val *= x
		x -= 1
	return val

def swaparr(arr, a, b):
	temp = arr[a]
	arr[a] = arr[b]
	arr[b] = temp

def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)

def lcm(a, b):
	return a * b // math.gcd(a, b)

def nCr(n, k):
	if k > n:
		return 0
	if k > n - k:
		k = n - k
	res = 1
	for i in range(k):
		res = res * (n - i)
		res = res / (i + 1)
	return int(res)

def primefs(n):
	primes = {}
	while n % 2 == 0 and n > 0:
		primes[2] = primes.get(2, 0) + 1
		n = n // 2
	for i in range(3, int(n ** 0.5) + 2, 2):
		while n % i == 0 and n > 0:
			primes[i] = primes.get(i, 0) + 1
			n = n // i
	if n > 2:
		primes[n] = primes.get(n, 0) + 1
	return primes

def power(x, y, p):
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def swap(a, b):
	temp = a
	a = b
	b = temp
	return (a, b)

def find(x, link):
	p = x
	while p != link[p]:
		p = link[p]
	while x != p:
		nex = link[x]
		link[x] = p
		x = nex
	return p

def union(x, y, link, size):
	x = find(x, link)
	y = find(y, link)
	if size[x] < size[y]:
		(x, y) = swap(x, y)
	if x != y:
		size[x] += size[y]
		link[y] = x

def sieve(n):
	prime = [True for i in range(n + 1)]
	(prime[0], prime[1]) = (False, False)
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime

def phi(n):
	result = n
	p = 2
	while p * p <= n:
		if n % p == 0:
			while n % p == 0:
				n = n // p
			result = result * (1.0 - 1.0 / float(p))
		p = p + 1
	if n > 1:
		result = result * (1.0 - 1.0 / float(n))
	return int(result)

def is_prime(n):
	if n == 0:
		return False
	if n == 1:
		return True
	for i in range(2, int(n ** (1 / 2)) + 1):
		if not n % i:
			return False
	return True
MAXN = int(100000.0 + 5)

def spf_sieve():
	spf[1] = 1
	for i in range(2, MAXN):
		spf[i] = i
	for i in range(4, MAXN, 2):
		spf[i] = 2
	for i in range(3, ceil(MAXN ** 0.5), 2):
		if spf[i] == i:
			for j in range(i * i, MAXN, i):
				if spf[j] == j:
					spf[j] = i
spf = [0 for i in range(MAXN)]

def factoriazation(x):
	res = []
	for i in range(2, int(x ** 0.5) + 1):
		while x % i == 0:
			res.append(i)
			x //= i
	if x != 1:
		res.append(x)
	return res

def factors(n):
	res = []
	for i in range(1, int(n ** 0.5) + 1):
		if n % i == 0:
			res.append(i)
			res.append(n // i)
	return list(set(res))

def int_array():
	return list(map(int, input().strip().split()))

def float_array():
	return list(map(float, input().strip().split()))

def str_array():
	return input().strip().split()

def binary_search(low, high, w, h, n):
	while low < high:
		mid = low + (high - low) // 2
		if check(mid, w, h, n):
			high = mid
		else:
			low = mid + 1
	return low

def check(time, m, assistants):
	summ = 0
	for p in assistants:
		time_needed_with_rest = p[0] * p[1] + p[2]
		time_needed_without_rest = p[0]
		baloons_can_be_inflated = p[1]
		summ += time // time_needed_with_rest * baloons_can_be_inflated
		ntime = time % time_needed_with_rest
		summ += min(ntime // time_needed_without_rest, baloons_can_be_inflated)
	return summ >= m
MOD = int(1000000000.0) + 7
CMOD = 998244353
INF = float('inf')
NINF = -float('inf')
from itertools import permutations
import math
import bisect as bis
import random
import sys

def solve():
	(l, r, x, y, k) = read()
	for i in range(x, y + 1):
		if i * k <= r and i * k >= l:
			print('YES')
			return
	print('NO')
for _ in range(1):
	solve()


def solve(l: int, r: int, x: int, y: int, k: int) -> str:
	min_exp = x * k
	max_exp = y * k
	range_overlaps = min_exp <= r and max_exp >= l
	range_not_divisible = int(r / k) == int(l / k) and int(l / k) != l / k
	return 'YES' if range_overlaps and (not range_not_divisible) else 'NO'
(l, r, x, y, k) = map(int, input().split())
print(solve(l, r, x, y, k))


from sys import stdin, stdout
(l, r, x, y, k) = map(int, stdin.readline().rstrip().split())
if k * x > r or k * y < l:
	print('NO')
elif int(r / k) == int(l / k) and int(l / k) != l / k:
	print('NO')
else:
	print('YES')


(l, r, x, y, k) = [float(i) for i in input().split()]
for i in range(int(x), int(y + 1)):
	if i * k >= l and i * k <= r:
		print('YES')
		exit(0)
print('NO')


from sys import maxsize, stdout, stdin, stderr
mod = int(1000000000.0 + 7)
import re

def tup():
	return map(int, stdin.readline().split())

def I():
	return int(stdin.readline())

def lint():
	return [int(x) for x in stdin.readline().split()]

def S():
	return input().strip()

def grid(r, c):
	return [lint() for i in range(r)]

def debug(*args, c=6):
	print('\x1b[3{}m'.format(c), *args, '\x1b[0m', file=stderr)
from math import log2, sqrt

def work():
	(l, r, x, y, k) = tup()
	f = False
	for i in range(x, y + 1):
		if l <= i * k and i * k <= r:
			f = True
		if f == True:
			return 'YES'
	return 'NO'
print(work())


import sys

def input():
	return sys.stdin.readline().strip()

def iinput():
	return int(input())

def rinput():
	return map(int, sys.stdin.readline().strip().split())

def get_list():
	return list(map(int, sys.stdin.readline().strip().split()))
(l, r, x, y, k) = rinput()
if max((l + k - 1) // k, x) > min(r // k, y):
	print('NO')
else:
	print('YES')


(l, r, x, y, k) = list(map(int, input().split()))

def f():
	for i in range(x, y + 1):
		n = i * k
		if l <= n <= r:
			print('YES')
			return
		if n > r:
			print('NO')
			return
	print('NO')
	return
f()


import math
(l, r, x, y, k) = map(int, input().split())
(lb, ub) = (max(math.ceil(l / k), x), min(int(r / k), y))
for i in range(lb, ub + 1):
	if l <= i * k <= r:
		print('YES')
		break
else:
	print('NO')


from sys import stdin
from math import ceil
from math import floor
(l, r, x, y, k) = map(int, stdin.readline().split())
L = max(l, k * x)
R = min(r, k * y)
L = ceil(L / k)
R = floor(R / k)
print('YES' if R >= L else 'NO')


(l, r, x, y, k) = map(int, input().split())
if l % k != 0:
	l -= l % k
	l += k
r -= r % k
l //= k
r //= k
if max(l, x) <= min(r, y):
	print('YES')
else:
	print('NO')


def foo():
	(x, y, l, r, k) = [int(x) for x in input().split()]
	for i in range(l, r + 1):
		if x <= k * i <= y:
			return 'YES'
	return 'NO'
print(foo())


(l, r, x, y, k) = map(int, input().split())
X = (l + k - 1) // k
Y = r // k
if X <= Y and (x <= X <= y or y <= Y <= y or X <= x <= Y or (X <= y <= Y)):
	print('YES')
else:
	print('NO')


(l, r, x, y, k) = map(float, input().split())
lis = []
l = int(l)
r = int(r)
x = int(x)
y = int(y)
for i in range(x, y + 1):
	lis += [i]
mid = 0
while len(lis) != 0:
	mid = int(len(lis) / 2 // 1)
	if lis[mid] * k >= l and lis[mid] * k <= r and lis[mid] * k.is_integer():
		print('YES')
		break
	elif lis[-1] * k >= l and lis[-1] * k <= r and lis[-1] * k.is_integer():
		print('YES')
		break
	elif lis[mid] * k < l:
		lis = lis[mid:-1]
	elif lis[mid] * k > r:
		lis = lis[:mid]
if len(lis) == 0:
	print('NO')


from math import *
import itertools as it
from collections import *
EPS = 1e-09

def get_int():
	return int(input().strip())

def get_string():
	return input().strip()

def get_array():
	return list(map(int, input().strip().split(' ')))

def print_array(a, glue=' '):
	print(glue.join(map(str, a)))

def print_grid(grid, glue=' '):
	for row in grid:
		print_array(row, glue)

def solve():
	(l, r, x, y, k) = get_array()
	return 'YES' if any((l <= i * k <= r for i in range(x, y + 1))) else 'NO'
ntest = 1
for _ in range(ntest):
	print(solve())


IL = lambda : list(map(int, input().split()))
IS = lambda : input().split()
I = lambda : int(input())
S = lambda : input()
(l, r, x, y, k) = IL()
for i in range(max(l, x * k), min(r, y * k) + 1):
	if i % k == 0:
		print('YES')
		quit()
print('NO')


(l, r, x, y, k) = input().split()
(l, r, x, y) = map(int, (l, r, x, y))
k = float(k)
l_min = int(k * x)
r_max = int(k * y)
x_min = int(l / k)
y_max = int(r / k)
for a in range(max(l_min, l), min(r_max, r) + 1):
	for b in range(max(x_min, x), min(y_max, y) + 1):
		if k == float(a) / b:
			print('YES')
			exit(0)
print('NO')


(l, r, x, y, k) = map(int, input().split())
c = 1
for i in range(x, y + 1):
	exp = k * i
	if exp >= l and exp <= r:
		print('YES')
		c = 0
		break
	elif exp > r:
		break
if c:
	print('NO')


def main(l, r, x, y, k):
	for cost in range(x, y + 1):
		exp = k * cost
		if exp <= r and exp >= l:
			return 'YES'
	return 'NO'
print(main(*list(map(int, input().split(' ')))))


(l, r, x, y, k) = map(int, input().split())
d = 0
for n in range(x, y + 1):
	if l <= n * k <= r and n * k == int(n * k):
		d = 1
		print('YES')
		break
if d == 0:
	print('NO')


(l, r, x, y, k) = map(int, input().split())
L = x - 1
R = y + 1
while R - L > 1:
	M = (L + R) // 2
	if M * k <= r:
		L = M
	else:
		R = M
if L * k >= l and L != x - 1:
	print('YES')
else:
	print('NO')


(l, r, x, y, k) = map(int, input().split())
check = True
if x * k > r or y * k < l:
	print('NO')
else:
	for i in range(x, y + 1):
		if k * i <= r and k * i >= l:
			check = False
			break
	if check == True:
		print('NO')
	else:
		print('YES')


import sys
input = sys.stdin.readline

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())
flag = True
(l, r, x, y, k) = invr()
for cost in range(x, y + 1):
	if k * cost <= r and k * cost >= l:
		print('YES')
		flag = False
		break
if flag:
	print('NO')


(l, r, x, y, k) = map(int, input().split(' '))
e = False
for i in range(x, y + 1):
	if l <= i * k <= r:
		e = True
		break
if e:
	print('YES')
else:
	print('NO')


def chop():
	return (int(i) for i in input().split())
f = False
(l, r, x, y, k) = chop()
for i in range(x, y + 1):
	if i * k in range(l, r + 1):
		f = True
		break
print('YES' if f else 'NO')


import sys
import string
from collections import Counter, defaultdict
from math import fsum, sqrt, gcd, ceil, factorial
from operator import add
inf = float('inf')
flush = lambda : sys.stdout.flush
comb = lambda x, y: factorial(x) // factorial(y) // factorial(x - y)
ip = lambda : input()
ii = lambda : int(input())
r = lambda : map(int, input().split())
rr = lambda : list(r())
(a, b, x, y, k) = r()
for i in range(a, b + 1):
	c = i / k
	if x <= c <= y and int(c) == c:
		print('YES')
		exit()
print('NO')


(l, r, x, y, k) = map(int, input().split())
flag = True
for i in range(l, r + 1):
	if i % k == 0:
		b = i / k
		if x <= b <= y:
			flag = False
			print('YES')
	if not flag:
		break
if flag:
	print('NO')


ins = input().split()
l = int(ins[0])
r = int(ins[1])
x = int(ins[2])
y = int(ins[3])
k = int(ins[4])
found = False
for i in range(x, y + 1):
	if i * k >= l and i * k <= r:
		found = True
if found == True:
	print('YES')
else:
	print('NO')


(l, r, x, y, k) = map(int, input().split())
if y * k < l or x * k > r:
	print('NO')
elif y * k <= r or x * k >= l:
	print('YES')
elif l // k == r // k and l % k != 0:
	print('NO')
else:
	print('YES')


(r, l, x, y, k) = map(int, input().split())
ok = 0
if (r / x <= k or r / y <= k) and (l / x >= k or l / y >= k):
	MAX_MIN = range(r, l + 1)
	MIN_MAX = range(x, y + 1)
	i = x
	while i <= y:
		if k * i in MAX_MIN:
			print('YES')
			ok = 1
			break
		i += 1
		if k * i > l:
			break
	if ok == 0:
		print('NO')
else:
	print('NO')


import math
import collections
import bisect
import heapq
import time
import random
import itertools
import sys
(l, r, x, y, k) = map(int, input().split())
while x <= y:
	b = (x + y) // 2
	if l <= b * k <= r:
		print('YES')
		exit(0)
	elif b * k < l:
		x = b + 1
	else:
		y = b - 1
print('NO')


(l, r, x, y, k) = list(map(int, input().split()))
ans = 'NO'
for b in range(x, y + 1):
	a = k * b
	if l <= a <= r:
		ans = 'YES'
		break
print(ans)


def main():
	(l, r, x, y, k) = map(int, input().split())
	flag = False
	for i in range(x, y + 1):
		ans = i * k
		if int(ans) - ans == 0 and (l <= ans and ans <= r):
			flag = True
			break
	if flag:
		print('YES')
	else:
		print('NO')
main()


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
(l, r, x, y, k) = map(int, input().split())
f = 0
for i in range(x, y + 1):
	if l <= i * k <= r:
		print('YES')
		f = 1
		break
if f == 0:
	print('NO')


import sys
(l, r, x, y, k) = map(int, input().split())
if l % k != 0 and r - l == r % k - l % k:
	print('NO')
	sys.exit()
if r >= x * k and l <= y * k:
	print('YES')
else:
	print('NO')


int_inp = lambda : int(input())
strng = lambda : input().strip()
strl = lambda : list(input().strip())
mul = lambda : map(int, input().split())
mulf = lambda : map(float, input().split())
seq = lambda : list(map(int, input().split()))
import math
from collections import Counter, defaultdict
(l, r, x, y, k) = mul()
if k >= l / y and k <= r / x:
	for i in range(x, y + 1):
		p = k * i
		if p == round(p) and p >= l and (p <= r):
			print('YES')
			exit()
		if p > r:
			break
print('NO')


def play(l, r, x, y, k):
	for i in range(x, y + 1):
		if l <= k * i <= r:
			return 'YES'
	return 'NO'
(L, R, X, Y, K) = [int(j) for j in input().split()]
print(play(L, R, X, Y, K))


(l, r, x, y, k) = map(int, input().split())
(start, end) = (max(l, k * x), min(r, k * y))
for i in range(start, end + 1):
	if not i % k:
		print('YES')
		exit(0)
print('NO')


def list_from_input():
	return list(map(int, input().split()))

def main():
	(l, r, x, y, k) = list_from_input()
	cost_range = range(x, y + 1)
	exp_range = range(l, r + 1)
	for cost in cost_range:
		needed_exp = k * cost
		potion_found = int(needed_exp) == needed_exp and needed_exp in exp_range
		if potion_found:
			print('YES')
			return
	print('NO')
	return
main()


def list_input():
	return list(map(int, input().split()))

def map_input():
	return map(int, input().split())

def map_string():
	return input().split()
(l, r, x, y, k) = map_input()
ans = 'NO'
for i in range(x, y + 1):
	if k * i > r:
		break
	elif k * i < l:
		continue
	ans = 'YES'
	break
print(ans)


def main():
	(l, r, x, y, k) = map(int, input().split())
	for i in range(x, y + 1):
		v = i * k
		if v >= l and v <= r:
			return 'YES'
	return 'NO'
print(main())


entrada = input().split()
l = int(entrada[0])
r = int(entrada[1])
x = int(entrada[2])
y = int(entrada[3])
k = int(entrada[4])
bo = True
while x <= y and bo:
	j = k * x
	if j >= l and j <= r:
		print('YES')
		bo = False
	elif j > r:
		break
	x += 1
if bo:
	print('NO')


import math

def main():
	(xpmin, xpmax, cmin, cmax, k) = [int(i) for i in input().split()]
	xmin = math.ceil(xpmin / k)
	xmax = xpmax // k
	if xmax < xmin:
		print('NO')
		return
	if xmax < cmin or xmin > cmax:
		print('NO')
	else:
		print('YES')
main()


(l, r, x, y, k) = map(int, input().split())
l = (l - 1) // k + 1
r //= k
print(['YES', 'NO'][l > r or x > r or l > y])


(l, r, x, y, k) = list(map(int, input().split()))
d = y - x + 1
p = y + 1
while d > 0:
	while p - d >= x and (p - d) * k >= l:
		p -= d
	d //= 2
res = p <= y and p * k <= r
print('YES' if res else 'NO')


from fractions import Fraction
import math
[startA, endA, startB, endB, efficacy] = input().split('\n')[0].split(' ')
[startA, endA, startB, endB] = map(int, [startA, endA, startB, endB])
res = Fraction(efficacy)
startA_constant = math.ceil(startA / res.numerator)
endA_constant = math.floor(endA / res.numerator)
startB_constant = math.ceil(startB / res.denominator)
endB_constant = math.floor(endB / res.denominator)
if startA_constant <= endA_constant and startB_constant <= endB_constant and (endA_constant >= startB_constant and endB_constant >= endA_constant or (endB_constant >= startA_constant and endA_constant >= endB_constant)):
	print('YES')
else:
	print('NO')


(start_exp, end_exp, start_cost, end_cost, factor) = [int(x) for x in input().split()]

def find_effective_elixir(start_exp, end_exp, start_cost, end_cost, factor):
	start_exp = start_exp / factor
	end_exp = end_exp / factor
	start_exp = int(start_exp) if int(start_exp) >= start_exp else int(start_exp) + 1
	end_exp = int(end_exp) if int(end_exp) <= end_exp else int(end_exp) - 1
	if start_exp > end_exp:
		print('NO')
		return
	if end_exp < start_cost or end_cost < start_exp:
		print('NO')
	else:
		print('YES')
find_effective_elixir(start_exp, end_exp, start_cost, end_cost, factor)


(l, r, x, y, k) = map(int, input().split())
(low_ex, high_ex) = (x * k, y * k)
if high_ex < l or low_ex > r:
	print('NO')
else:
	low = l // k * k
	up = r // k * k + k
	a = low
	b = low // k
	ok = 0
	while a <= up:
		if x <= b and b <= y and (l <= a) and (a <= r):
			ok = 1
		a += k
		b += 1
	if ok == 1:
		print('YES')
	else:
		print('NO')


(l, r, x, y, k) = [int(i) for i in input().split()]
global is_potion
is_potion = False
for b in range(x, y + 1):
	if k * b >= l and k * b <= r:
		is_potion = is_potion or True
	else:
		is_potion = is_potion or False
if is_potion:
	print('YES')
else:
	print('NO')


(l, r, x, y, k) = map(int, input().split())
for i in range(x, y + 1):
	q = k * i
	if q <= r and q >= l:
		print('YES')
		return
print('NO')


(l, r, x, y, k) = map(int, input().split())
flag = 'NO'
for cost in range(x, y + 1):
	value = k * cost
	if value >= l and value <= r:
		flag = 'YES'
		break
print(flag)


(l, r, x, y, k) = list(map(int, input().split()))
a = max(k * x, l)
b = min(k * y, r)
a = (a + k - 1) // k
b = b // k
if a <= b:
	print('YES')
else:
	print('NO')


(l, r, x, y, k) = list(map(int, input().split()))
a = int(l / k) if l % k == 0 else int(l / k) + 1
b = int(r / k) + 1
flag = False
for i in range(a, b):
	if i >= x and i <= y:
		flag = True
print('YES' if flag else 'NO')


from collections import deque as de
import math
from collections import Counter as cnt

class My_stack:

	def __init__(self):
		self.data = []

	def my_push(self, x):
		return self.data.append(x)

	def my_pop(self):
		return self.data.pop()

	def my_peak(self):
		return self.data[-1]

	def my_contains(self, x):
		return self.data.count(x)

	def my_show_all(self):
		return self.data

	def isEmpty(self):
		return len(self.data) == 0
arrStack = My_stack()

def isPrime(n):
	if n <= 1:
		return False
	if n <= 3:
		return True
	if n % 2 == 0 or n % 3 == 0:
		return False
	i = 5
	while i * i <= n:
		if n % i == 0 or n % (i + 2) == 0:
			return False
		i = i + 6
	return True

def get_prime_factors(number):
	prime_factors = []
	while number % 2 == 0:
		prime_factors.append(2)
		number = number / 2
	for i in range(3, int(math.sqrt(number)) + 1, 2):
		while number % i == 0:
			prime_factors.append(int(i))
			number = number / i
	if number > 2:
		prime_factors.append(int(number))
	return prime_factors

def get_frequency(list):
	dic = {}
	for ele in list:
		if ele in dic:
			dic[ele] += 1
		else:
			dic[ele] = 1
	return dic
(l, r, x, y, k) = map(int, input().split())
ch = 1
for i in range(x, y + 1):
	if l <= i * k <= r:
		print('YES')
		ch = 0
		break
if ch:
	print('NO')


import sys
(l, r, x, y, k) = map(int, input().split())
for j in range(x, y + 1):
	if l <= j * k <= r:
		print('YES')
		sys.exit()
print('NO')


(l, r, x, y, k) = [int(i) for i in input().strip().split(' ')]
found = False
for i in range(x, y + 1):
	if l <= k * i and k * i <= r:
		found = True
		break
if found:
	print('YES')
else:
	print('NO')


(a1, a2, b1, b2, k) = map(int, input().split(' '))
if b1 * k > a2 or b2 * k < a1:
	print('NO')
elif a1 % k != 0 and a2 % k != 0 and (a2 - a1 < k - 1):
	print('NO')
else:
	print('YES')


3

def read_ints():
	return [int(i) for i in input().split()]
(l, r, x, y, k) = read_ints()
if x * k <= r and y * k >= l and (l // k + (l % k > 0) <= r // k):
	print('YES')
else:
	print('NO')


a = list(input().split(' '))
a = [int(i) for i in a]
tempExp = 0
pFlag = 0
l = a[0]
r = a[1]
x = a[2]
y = a[3]
k = a[4]
for i in range(x, y + 1):
	tempExp = k * i
	if tempExp >= l and tempExp <= r:
		pFlag = 1
		break
if pFlag == 1:
	print('YES')
else:
	print('NO')


import sys
import math
import itertools
import functools
import collections
import operator

def ii():
	return int(input())

def mi():
	return map(int, input().split())

def li():
	return list(map(int, input().split()))

def lcm(a, b):
	return abs(a * b) // math.gcd(a, b)

def revn(n):
	return str(n)[::-1]

def dd():
	return collections.defaultdict(int)

def ddl():
	return collections.defaultdict(list)

def sieve(n):
	if n < 2:
		return list()
	prime = [True for _ in range(n + 1)]
	p = 3
	while p * p <= n:
		if prime[p]:
			for i in range(p * 2, n + 1, p):
				prime[i] = False
		p += 2
	r = [2]
	for p in range(3, n + 1, 2):
		if prime[p]:
			r.append(p)
	return r

def divs(n, start=2):
	r = []
	for i in range(start, int(math.sqrt(n) + 1)):
		if n % i == 0:
			if n / i == i:
				r.append(i)
			else:
				r.extend([i, n // i])
	return r

def divn(n, primes):
	divs_number = 1
	for i in primes:
		if n == 1:
			return divs_number
		t = 1
		while n % i == 0:
			t += 1
			n //= i
		divs_number *= t

def prime(n):
	if n == 2:
		return True
	if n % 2 == 0 or n <= 1:
		return False
	sqr = int(math.sqrt(n)) + 1
	for d in range(3, sqr, 2):
		if n % d == 0:
			return False
	return True

def convn(number, base):
	newnumber = 0
	while number > 0:
		newnumber += number % base
		number //= base
	return newnumber

def cdiv(n, k):
	return n // k + (n % k != 0)
(l, r, x, y, k) = mi()
for i in range(x, y + 1):
	if l <= i * k and i * k <= r:
		exit(print('YES'))
print('NO')


(l, r, x, y, k) = map(int, input().split())
x1 = k * x
y1 = k * y
iX = max(l, x1)
iY = min(r, y1)
lower = iX // k if iX % k == 0 else iX // k + 1
higher = iY // k
if higher - lower >= 0:
	print('YES')
else:
	print('NO')


(l, r, x, y, k) = map(int, input().split())
a = l
b = x
answer = 'NO'
if k < l / y or k > r / x:
	answer = 'NO'
else:
	if k < l / x:
		b = l // k
	else:
		a = x * k
	while a <= r and b <= y:
		if k < a / b:
			b += 1
		elif k > a / b:
			a += 1
		else:
			answer = 'YES'
			break
print(answer)


(l, r, x, y, k) = list(map(int, input().split()))
answer = 'NO'
while x <= y:
	mid = (x + y) // 2
	res = mid * k
	if l <= res <= r:
		answer = 'YES'
		break
	elif res > r:
		y = mid - 1
	else:
		x = mid + 1
print(answer)


(l, r, x, y, k) = map(int, input().split(' '))
min_exp = x * k
max_exp = y * k
flag = False
if not (min_exp > r or max_exp < l):
	if l % k == 0 or (l // k + 1) * k <= r:
		flag = True
print('YES' if flag else 'NO')


l = list(map(int, input().split()))
for i in range(l[2], l[3] + 1):
	if l[0] <= i * l[-1] and i * l[-1] <= l[1]:
		print('YES')
		exit()
print('NO')


inp = list(map(int, input().split()))
l = inp[0]
r = inp[1]
x = inp[2]
y = inp[3]
k = inp[4]
if l % k != 0:
	l = l - l % k + k
if r % k != 0:
	r = r - r % k
if l > r:
	print('NO')
elif k * x > r or k * y < l:
	print('NO')
else:
	print('YES')


(l, r, x, y, k) = list(map(int, input().split()))

def possible():
	global l, r, x, y, k
	for i in range(x, y + 1):
		if l <= i * k <= r:
			return True
		if i * k > r:
			break
	return False
if possible():
	print('YES')
else:
	print('NO')


from bisect import bisect_left
(l, r, x, y, k) = list(map(int, input().split()))
p = bisect_left(range(x, y + 1), l / k) + x
res = p <= y and p * k <= r
print('YES' if res else 'NO')


from math import *
(l, r, x, y, k) = map(int, input().split())
_l = ceil(l / k)
_r = floor(r / k)
if _l > _r or _l > y or x > _r:
	print('NO')
else:
	print('YES')


(l, r, x, y, k) = [int(x) for x in input().split()]
flag = True
for i in range(x, y + 1):
	j = i * k
	if j >= l and j <= r and (j == int(j)):
		print('YES')
		flag = False
		break
if flag == True:
	print('NO')


(l, r, x, y, k) = map(int, input().split())
flag = 0
for i in range(x, y + 1):
	if l <= i * k <= r:
		flag = 1
		break
	elif i * k > r:
		break
print('YES' if flag == 1 else 'NO')


(l, r, x, y, k) = list(map(int, input().split()))
res = any([l <= i * k <= r for i in range(x, y + 1)])
print('YES' if res else 'NO')


import sys
(l, r, x, y, k) = map(int, input().split(' '))
(a, b) = (0, 0)
ch = range(l, r + 1)
for x in range(x, y + 1):
	if k * x in ch:
		print('YES')
		sys.exit(0)
print('NO')


[l, r, x, y, k] = list(map(int, input().split()))
for b in range(x, y + 1):
	a = k * b
	if l <= a and a <= r:
		print('YES')
		exit(0)
print('NO')