Vus the Cossack holds a programming competition, in which $n$ people participate. He decided to award them all with pens and notebooks. It is known that Vus has exactly $m$ pens and $k$ notebooks.

Determine whether the Cossack can reward all participants, giving each of them at least one pen and at least one notebook.


-----Input-----

The first line contains three integers $n$, $m$, and $k$ ($1 \leq n, m, k \leq 100$) — the number of participants, the number of pens, and the number of notebooks respectively.


-----Output-----

Print "Yes" if it possible to reward all the participants. Otherwise, print "No".

You can print each letter in any case (upper or lower).


-----Examples-----
Input
5 8 6

Output
Yes

Input
3 9 3

Output
Yes

Input
8 5 20

Output
No



-----Note-----

In the first example, there are $5$ participants. The Cossack has $8$ pens and $6$ notebooks. Therefore, he has enough pens and notebooks.

In the second example, there are $3$ participants. The Cossack has $9$ pens and $3$ notebooks. He has more than enough pens but only the minimum needed number of notebooks.

In the third example, there are $8$ participants but only $5$ pens. Since the Cossack does not have enough pens, the answer is "No".

Difficulty: EASY
Tags: Implementation

Starter code:

Solutions:
(n, m, k) = map(int, input().split())
if m < n or k < n:
	print('No')
else:
	print('Yes')


(n, m, k) = map(int, input().split())
print('YNEOS'[m < n or k < n::2])


(nc, p, n) = [int(x) for x in input().split()]
if p >= nc and n >= nc:
	print('Yes')
else:
	print('No')


(a, b, c) = map(int, input().split())
if b >= a and c >= a:
	print('Yes')
else:
	print('No')


participants = list(map(int, input().split()))
if participants[1] >= participants[0] and participants[2] >= participants[0]:
	print('Yes')
else:
	print('No')


(part, pen, notebooks) = [int(i) for i in input().strip().split()]
pen = min(pen, notebooks)
if part <= pen:
	print('Yes')
else:
	print('No')


(n, m, k) = list(map(int, input().split(' ')))
if m < n or k < n:
	print('NO')
else:
	print('YES')


(n, m, k) = input().split()
n = int(n)
m = int(m)
k = int(k)
minimum_obj = min(m, k)
if minimum_obj >= n:
	print('Yes')
else:
	print('No')


(n, m, k) = map(int, input().split())
print('YES' if n <= min(m, k) else 'NO')


li = [int(x) for x in input().split()]
if li[1] >= li[0] and li[2] >= li[0]:
	print('Yes')
else:
	print('No')


(n, m, k) = [int(a) for a in input().split()]
if m < n or k < n:
	print('No')
else:
	print('Yes')


def f(n, m, k):
	if n <= m and n <= k:
		return True
	else:
		return False
x = input().split()
n = int(x[0])
m = int(x[1])
k = int(x[2])
if f(n, m, k) == True:
	print('yes')
else:
	print('no')


(participants, pens, notebooks) = [int(i) for i in input().split(' ')]
if participants > min(pens, notebooks):
	print('No')
else:
	print('Yes')


(n, m, k) = map(int, input().split())
if m >= n and k >= n:
	print('yes')
else:
	print('no')


(p, a, b) = map(int, input().split())
if a >= p and b >= p:
	print('YES')
else:
	print('NO')


(n, m, k) = [int(_) for _ in input().split()]
print('Yes' if k >= n and m >= n else 'No')


(a, b, c) = map(int, input().split())
print('NO' if min(b, c) < a else 'YES')


(participants, pens, notebooks) = map(int, input().split(' '))
if pens < participants or notebooks < participants:
	print('NO')
elif notebooks and pens > participants:
	print('YES')
elif notebooks > pens and notebooks > participants and (pens > participants):
	print('YES')
elif pens > notebooks and notebooks > participants:
	print('YES')
elif pens > notebooks and participants > notebooks:
	print('NO')
else:
	print('YES')


(n, x, y) = map(int, input().split())
if x >= n and y >= n:
	print('Yes')
else:
	print('No')


def solve(n):
	if n[0] <= n[1] and n[0] <= n[2]:
		return 'YES'
	return 'NO'
n = [int(i) for i in input().split()]
print(solve(n))


def main():
	l = input().split()
	if int(l[0]) <= int(l[1]) and int(l[0]) <= int(l[2]):
		print('yes')
	else:
		print('no')
main()


(a, b, c) = [int(tmp) for tmp in input().split()]
print('YES' if b >= a and c >= a else 'NO')


(n, m, k) = input().split()
n = int(n)
m = int(m)
k = int(k)
if m >= n and k >= n:
	print('Yes')
else:
	print('No')


def answer(n, m, k):
	if m / n >= 1 and k / n >= 1:
		return 'Yes'
	else:
		return 'No'
(n, m, k) = map(int, input().split())
print(answer(n, m, k))


(n, m, k) = input().split()
n = int(n)
m = int(m)
k = int(k)
if m >= n and k >= n:
	print('YES')
else:
	print('NO')


arr = list(map(int, input().rstrip().split()))
n = arr[0]
m = arr[1]
k = arr[2]
if n <= m and n <= k:
	print('Yes')
else:
	print('No')


(x1, x2, x3) = map(int, input().split())
if x2 >= x1 and x3 >= x1:
	print('Yes')
else:
	print('No')


a = input().split()
if int(a[0]) <= int(a[1]) and int(a[0]) <= int(a[2]):
	print('Yes')
else:
	print('No')


(n, m, k) = [int(i) for i in input().split()]
if min(m, k) < n:
	print('NO')
else:
	print('YES')


(n, m, k) = [int(x) for x in input().split()]
if m < n:
	a = 0
else:
	a = 1
if k < n:
	b = 0
else:
	b = 1
c = b * a
if c == 1:
	print('Yes')
else:
	print('No')


nmk = input()
nmk = nmk.split()
nmk[0] = eval(nmk[0])
nmk[1] = eval(nmk[1])
nmk[2] = eval(nmk[2])
if min(nmk) == nmk[0]:
	print('Yes')
else:
	print('No')


(a, b, c) = input().split()
a = int(a)
b = int(b)
c = int(c)
if b >= a and c >= a:
	print('YES')
else:
	print('NO')


from sys import stdin
(n, m, k) = map(int, input().split())
if min(m, k) >= n:
	print('YES')
else:
	print('NO')


inp = list(map(int, input().split()))
if inp[1] < inp[0] or inp[2] < inp[0]:
	print('No')
else:
	print('Yes')


(a, b, c) = map(int, input().split())
print(['Yes', 'No'][a > min(b, c)])


def vp(n, m, k):
	if m < n or k < n:
		return 'No'
	elif m >= n and k >= n:
		return 'Yes'
(n, m, k) = map(int, input().strip().split())
print(vp(n, m, k))


def sprav(n, m, k):
	if n > m or n > k:
		return 'No'
	return 'Yes'
(n, m, k) = list(map(int, input().split()))
print(sprav(n, m, k))


import sys
(n, m, k) = map(int, sys.stdin.readline().rstrip().split())
if m >= n and k >= n:
	print('yes\n')
else:
	print('no\n')


(a, b, c) = input().split()
a = int(a)
b = int(b)
c = int(c)
if a > b or a > c:
	print('No')
else:
	print('Yes')


import sys
from operator import itemgetter
input = sys.stdin.readline
from collections import defaultdict as dc
from bisect import bisect_left, bisect_right
import math
(n, m, k) = map(int, input().split())
if m >= n and k >= n:
	print('Yes')
else:
	print('No')


s = list(map(int, input().split()))
if s[1] >= s[0] and s[2] >= s[0]:
	print('YES')
else:
	print('NO')


(n, m, k) = map(int, input().split())
print(['No', 'Yes'][m >= n and k >= n])


a = list(map(int, input().split()))
b = min(a[0], a[1], a[2])
if b == a[0]:
	print('Yes')
else:
	print('No')


(n, p, k) = map(int, input().split())
if p >= n and k >= n:
	print('YES')
else:
	print('NO')


from collections import deque
from math import sqrt, ceil

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

def si():
	return input()

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

def li():
	return list(mi())

def isprime(n):
	if n == 1:
		return 0
	for i in range(2, int(sqrt(n)) + 1):
		if n % i == 0:
			return 0
	return 1
(n, a, b) = mi()
if n > min(a, b):
	print('No')
else:
	print('Yes')


(n, m, k) = tuple(map(int, input().split(' ')))
print('Yes') if n <= min(m, k) else print('No')


from collections import Counter

def adequacy_check(counts):
	return max(counts.values()) == 1

def does_first_win_steps(pile___stones_nr):
	steps_nr = sum(pile___stones_nr) - sum(range(len(pile___stones_nr)))
	if steps_nr % 2 == 1:
		return True
	else:
		return False

def does_first_win(pile___stones_nr):
	counts = Counter(pile___stones_nr)
	for (stones_nr, count) in counts.items():
		if count >= 2:
			if stones_nr == 0:
				return False
			counts[stones_nr] -= 1
			counts[stones_nr - 1] += 1
			if not adequacy_check(counts):
				return False
			return does_first_win_steps(pile___stones_nr)
	return does_first_win_steps(pile___stones_nr)
(n, m, k) = (int(x) for x in input().split())
if n <= min(m, k):
	print('Yes')
else:
	print('No')


(n, m, k) = list(map(int, input().strip().split()))
if m >= n and k >= n:
	print('Yes')
else:
	print('No')


(a, b, c) = input().split()
print(['NO', 'YES'][int(a) <= int(b) and int(a) <= int(c)])


import sys
fin = sys.stdin
fout = sys.stdout
lines = (line.strip() for line in fin)
(participants, pens, notebooks) = map(int, next(lines).split())
enough = pens >= participants and notebooks >= participants
print('YES' if enough else 'NO', file=fout)


q = input().split()
a = int(q[0])
b = int(q[1])
c = int(q[2])
if min(b, c) >= a:
	print('Yes')
else:
	print('No')


(n, m, k) = [int(x) for x in input().split()]
if n <= m and n <= k:
	print('YES')
else:
	print('NO')


(a, b, c) = map(int, input().split())
x = [a, b, c]
y = min(x)
if a == y:
	print('Yes')
else:
	print('No')


import time
(n, m, k) = (int(i) for i in input().split())
start = time.time()
if n <= m and n <= k:
	ans = 'Yes'
else:
	ans = 'No'
print(ans)
finish = time.time()


a = input().split()
for i in range(len(a)):
	a[i] = int(a[i])
if a[0] <= a[1]:
	if a[0] <= a[2]:
		print('Yes')
	else:
		print('No')
else:
	print('No')


arr = input()
(N, M, K) = [int(x) for x in arr.split(' ')]
if M >= N and K >= N:
	print('YES')
else:
	print('NO')


(participants, pens, notebooks) = input().split(' ')
if int(participants) <= int(pens) and int(participants) <= int(notebooks):
	print('Yes')
else:
	print('No')


from sys import stdin
from collections import deque

def main():
	cs = deque(''.join(stdin.readlines()).split())
	(n, m, k) = (int(cs.popleft()), int(cs.popleft()), int(cs.popleft()))
	print('Yes' if m >= n and k >= n else 'No')
main()


def Judge_reward():
	tem_list = [int(i) for i in input().split()][0:3]
	n = int(tem_list[0])
	m = int(tem_list[1])
	k = int(tem_list[2])
	if m >= n and k >= n:
		print('Yes')
	else:
		print('No')
Judge_reward()


import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from functools import lru_cache
import bisect
import re
import queue

class Scanner:

	@staticmethod
	def int():
		return int(sys.stdin.readline().rstrip())

	@staticmethod
	def string():
		return sys.stdin.readline().rstrip()

	@staticmethod
	def map_int():
		return [int(x) for x in Scanner.string().split()]

	@staticmethod
	def string_list(n):
		return [input() for i in range(n)]

	@staticmethod
	def int_list_list(n):
		return [Scanner.map_int() for i in range(n)]

	@staticmethod
	def int_cols_list(n):
		return [int(input()) for i in range(n)]

class Math:

	@staticmethod
	def gcd(a, b):
		if b == 0:
			return a
		return Math.gcd(b, a % b)

	@staticmethod
	def lcm(a, b):
		return a * b // Math.gcd(a, b)

	@staticmethod
	def divisor(n):
		res = []
		i = 1
		for i in range(1, int(n ** 0.5) + 1):
			if n % i == 0:
				res.append(i)
				if i != n // i:
					res.append(n // i)
		return res

	@staticmethod
	def round_up(a, b):
		return -(-a // b)

	@staticmethod
	def is_prime(n):
		if n < 2:
			return False
		if n == 2:
			return True
		if n % 2 == 0:
			return False
		d = int(n ** 0.5) + 1
		for i in range(3, d + 1, 2):
			if n % i == 0:
				return False
		return True

class PriorityQueue:

	def __init__(self, l=[]):
		self.q = l
		heapq.heapify(self.q)
		return

	def push(self, n):
		heapq.heappush(self.q, n)
		return

	def pop(self):
		return heapq.heappop(self.q)
MOD = int(1000000000.0) + 7
INF = int(1000000000000000.0)

def main():
	(n, m, k) = Scanner.map_int()
	if m >= n and k >= n:
		print('Yes')
	else:
		print('No')
main()


from sys import exit as sys_return
(amount, notebooks, pens) = map(int, input().split())
if amount <= min(notebooks, pens):
	print('Yes')
else:
	print('No')


import sys
(n, m, k) = tuple(map(int, sys.stdin.readline().split()))
minimum = min(m, k)
if n > minimum:
	print('No')
else:
	print('Yes')


(n, m, k) = map(int, input().split())
ans = 'No'
if m >= n and k >= n:
	ans = 'Yes'
print(ans)


def check(n, p, nb):
	if p >= n and nb >= n:
		print('Yes')
		return
	else:
		print('No')
arr = list(map(int, input().rstrip().split()))
n = arr[0]
p = arr[1]
nb = arr[2]
check(n, p, nb)


x = [int(x) for x in input().split()]
if x[1] < x[0] or x[2] < x[0]:
	print('no')
else:
	print('yes')


(n, k, j) = map(int, input().split())
if n > j or n > k:
	print('no')
else:
	print('yes')


(n, m, k) = [int(i) for i in input().split()]
print(['NO', 'YES'][n <= m and n <= k])


def func(n):
	if n[1] < n[0] or n[2] < n[0]:
		print('NO')
	else:
		print('YES')
n = list(map(int, input().split()))
func(n)


(n, m, k) = input().split()
if int(m) < int(n) or int(k) < int(n):
	print('no')
else:
	print('yes')


def is_enough(n, m, k):
	if m >= n and k >= n:
		return 'Yes'
	return 'No'
(n, m, k) = input().split()
print(is_enough(int(n), int(m), int(k)))


R = lambda : map(int, input().split())
(n, m, k) = R()

def solve(n, m, k):
	if n <= min(m, k):
		return 'YES'
	return 'NO'
print(solve(n, m, k))


l = list(map(int, input().split()))
if (l[1] >= l[0]) & (l[2] >= l[0]):
	print('Yes')
else:
	print('No')


import sys
import random
input = sys.stdin.readline
(n, m, k) = map(int, input().split())
print('YES' if n <= min(m, k) else 'NO')


ar = list(map(int, input().strip().split()))
if ar[1] < ar[0] or ar[2] < ar[0]:
	print('No')
else:
	print('Yes')


def main():
	s = [int(x) for x in input().split()]
	n = s[0]
	m = s[1]
	k = s[2]
	if min(m, k) >= n:
		print('Yes')
	else:
		print('No')
main()


(x, y, z) = map(int, input().split())
if y >= x and z >= x:
	print('YES')
else:
	print('NO')


(n, m, k) = list(map(int, input().split()))
flag = 1
if n > m:
	flag = 0
if n > k:
	flag = 0
if not flag:
	print('No')
else:
	print('Yes')


x = input()
i = len(x) - 1
par = 0
pens = 0
notes = 0
y = i
while x[i] != ' ':
	notes = int(x[i]) * pow(10, y - i) + notes
	i -= 1
i -= 1
y = i
while x[i] != ' ':
	pens = int(x[i]) * pow(10, y - i) + pens
	i -= 1
i -= 1
y = i
while i >= 0:
	par = int(x[i]) * pow(10, y - i) + par
	i -= 1
if par <= notes and par <= pens:
	print('Yes')
else:
	print('No')


(n, m, k) = list((int(a) for a in input().split()))
print('Yes') if min(m, k) >= n else print('No')


numbers = input().split()
n = int(numbers[0])
m = int(numbers[1])
k = int(numbers[2])
if m - n >= 0 and k - n >= 0:
	print('Yes')
else:
	print('No')


from sys import *
from math import *
(n, m, k) = map(int, stdin.readline().split())
x = min(m, k)
if x >= n:
	print('YES')
else:
	print('NO')


def main():
	import sys
	input = sys.stdin.readline
	(n, m, k) = map(int, input().split())
	if n > m or n > k:
		print('No')
	else:
		print('Yes')
	return 0
main()


(a, b, c) = [int(x) for x in input().split()]
if a <= b and a <= c:
	print('Yes')
else:
	print('No')


(a, b, c) = map(int, input().split(' '))
if a <= b and a <= c:
	print('yes')
else:
	print('no')


n = input().split()
N = int(n[0])
a = int(n[1])
b = int(n[2])
if a >= N:
	if b >= N:
		print('Yes')
	else:
		print('No')
else:
	print('No')


(participant, pen, notebook) = list(map(int, input().split()))
answer = 'Yes' if participant <= min([pen, notebook]) else 'No'
print(answer)


import sys
(x, y, z) = map(int, input().split())
if y < x or z < x:
	print('NO')
else:
	print('YES')


import sys, os, io

def rs():
	return sys.stdin.readline().rstrip()

def ri():
	return int(sys.stdin.readline())

def ria():
	return list(map(int, sys.stdin.readline().split()))

def ws(s):
	sys.stdout.write(s + '\n')

def wi(n):
	sys.stdout.write(str(n) + '\n')

def wia(a):
	sys.stdout.write(' '.join([str(x) for x in a]) + '\n')
import math, datetime, functools, itertools, operator, bisect
from collections import deque, defaultdict, OrderedDict
import collections

def main():
	starttime = datetime.datetime.now()
	if os.path.exists('input.txt'):
		sys.stdin = open('input.txt', 'r')
		sys.stdout = open('output.txt', 'w')
	for _ in range(1):
		(n, m, k) = ria()
		if min(m, k) >= n:
			print('Yes')
		else:
			print('No')
	endtime = datetime.datetime.now()
	time = (endtime - starttime).total_seconds() * 1000
	if os.path.exists('input.txt'):
		print('Time:', time, 'ms')

class FastReader(io.IOBase):
	newlines = 0

	def __init__(self, fd, chunk_size=1024 * 8):
		self._fd = fd
		self._chunk_size = chunk_size
		self.buffer = io.BytesIO()

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size))
			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, size=-1):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size if size == -1 else size))
			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()

class FastWriter(io.IOBase):

	def __init__(self, fd):
		self._fd = fd
		self.buffer = io.BytesIO()
		self.write = self.buffer.write

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

class FastStdin(io.IOBase):

	def __init__(self, fd=0):
		self.buffer = FastReader(fd)
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')

class FastStdout(io.IOBase):

	def __init__(self, fd=1):
		self.buffer = FastWriter(fd)
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.flush = self.buffer.flush
sys.stdin = FastStdin()
sys.stdout = FastStdout()
main()


(N, M, K) = map(int, input().split())
if M >= N and K >= N:
	print('Yes')
else:
	print('No')


(l, a, b) = map(int, input().split())
if l <= min(a, b):
	print('Yes')
else:
	print('No')


(x, y, z) = map(int, input().split())
if min(y, z) >= x:
	print('Yes')
else:
	print('No')


(n, m, k) = [int(i) for i in input().split()]
least = min(m, k)
if n > least:
	print('No')
else:
	print('Yes')


def main():
	(n, m, k) = [int(i) for i in input().split()]
	if n <= k and n <= m:
		print('YES')
	else:
		print('NO')
main()


nums = input()
nums = nums.split(' ')
n = int(nums[0])
m = int(nums[1])
k = int(nums[2])
while n < 1 or m < 1 or k < 1 or (n > 100) or (m > 100) or (k > 100):
	nums = input()
	nums = nums.split(' ')
	n = nums[0]
	m = nums[1]
	k = nums[2]
if m >= n and k >= n:
	print('Yes')
elif m < n or k < n:
	print('No')


(a, b, c) = map(int, input().split())
print(['YES', 'NO'][min(b, c) < a])


def solve(n, m, k):
	if m >= n and k >= n:
		return 'Yes'
	return 'No'
(n, m, k) = map(int, input().split())
print(solve(n, m, k))


args = input().split(' ')
for i in range(0, len(args)):
	args[i] = int(args[i])
if args[0] == min(args):
	print('Yes')
else:
	print('No')


ii = lambda : int(input())
mi = lambda : map(int, input().split())
li = lambda : list(mi())
(n, m, k) = mi()
print('Yes' if min(m, k) >= n else 'No')


arr = input().split()
n = int(arr[0])
m = int(arr[1])
k = int(arr[2])
if k >= n and m >= n and n and m and (k <= 100):
	print('Yes')
else:
	print('No')


l = list(map(int, input().split()))
if l[0] <= l[1] and l[0] <= l[2]:
	print('yes')
else:
	print('No')


X = list(map(int, input().split()))
print('YES' if X[0] <= min(X) else 'NO')


(perticipent, pen, note_book) = input().split(' ')
perticipent = int(perticipent)
pen = int(pen)
note_book = int(note_book)
if perticipent <= pen and perticipent <= note_book:
	print('Yes')
else:
	print('No')


import sys
input = sys.stdin.readline
(n, p, note) = list(map(int, input().split()))
if n > p:
	print('NO')
elif n > note:
	print('NO')
else:
	print('YES')


(n, a, b) = map(int, input().split())
if n > a or n > b:
	print('No')
else:
	print('Yes')


def get_list_input():
	s = input()
	return s.split(' ')

def main():
	case = get_list_input()
	n = int(case[0])
	m = int(case[1])
	k = int(case[2])
	print('Yes') if m >= n and k >= n else print('No')
main()


(n, m, k) = map(int, input().split())
for i in range(1):
	if m >= n and k >= n:
		print('Yes')
	else:
		print('No')


def main():
	[n, m, k] = list(map(int, input().split()))
	minVal = min(m, k)
	if minVal >= n:
		print('YES')
		return
	else:
		print('NO')
		return
main()


(n, m, k) = [int(s) for s in input().split()]
if n <= m:
	if n <= k:
		print('Yes')
	else:
		print('No')
else:
	print('No')


(n, a, k) = map(int, input().strip().split(' '))
if a >= n and k >= n:
	print('Yes')
else:
	print('No')


(a, b, c) = list(map(int, input().split()))
if min(b, c) >= a:
	print('Yes')
else:
	print('No')


st = input()
l = st.split()
n = int(l[0])
m = int(l[1])
k = int(l[2])
if k < n or m < n:
	print('NO')
else:
	print('YES')


import sys
t = [int(x) for x in sys.stdin.read().strip().split()]
print(('NO', 'YES')[min(t) == t[0]])


from re import findall
from typing import Iterator

def get_num_input() -> Iterator[int]:
	return map(int, input().split())

def main() -> None:
	people: int
	pens: int
	notebooks: int
	(people, pens, notebooks) = get_num_input()
	print('Yes' if people <= min(pens, notebooks) else 'No')
ONLY_ONCE: bool = True
for _ in range(1 if ONLY_ONCE else int(input())):
	main()


(a, b, c) = input().split()
n = int(a)
m = int(b)
k = int(c)
if m >= k and k >= n:
	print('Yes')
elif k > m and m >= n:
	print('Yes')
else:
	print('No')


arr = list(map(int, input().split()))
minim = arr[1]
if arr[2] < minim:
	minim = arr[2]
if arr[0] <= minim:
	print('Yes')
else:
	print('No')


t = 1
while t > 0:
	t -= 1
	(n, m, k) = map(int, input().split())
	if n <= m and n <= k:
		print('Yes')
	else:
		print('No')


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, copy, functools
import random
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return list(map(int, sys.stdin.readline().split()))

def LLI():
	return [list(map(int, l.split())) for l in sys.stdin.readlines()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

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

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def pe(s):
	return print(str(s), file=sys.stderr)
(n, m, k) = LI()
mini = min(m, k)
if n <= mini:
	print('Yes')
else:
	print('No')


(people, ry, bl) = input().split()
people = int(people)
ry = int(ry)
bl = int(bl)
for i in range(1, 101):
	if bl >= people and ry >= people:
		print('Yes')
		break
	else:
		print('No')
		break


s = input()
s = s.split()
s = list(map(int, s))
mini = min(s)
if mini == s[0]:
	print('Yes')
else:
	print('No')


n = input()
data = [int(i) for i in n.split()]
if data[0] <= data[1] and data[0] <= data[2]:
	print('Yes')
else:
	print('No')


import sys
numbers = input().split()
numbers = list(map(int, numbers))
if numbers[0] <= numbers[1] and numbers[0] <= numbers[2]:
	print('Yes')
else:
	print('No')


ss = input().split(' ')
ii = [int(s) for s in ss]
(n, m, k) = ii
if n <= m and n <= k:
	print('Yes')
else:
	print('No')


(n, m, k) = map(int, input().split())
if m >= n and k >= n:
	print('Yes')
else:
	print('NO')


(n, m, k) = map(int, input().split())
if n >= 1:
	if m <= 100 and k <= 100:
		if n <= m and n <= k:
			print('Yes')
		elif n > m or n > k:
			print('No')
else:
	print('No')


l = list(map(int, input().split()))
m = min(l[1], l[2])
if m >= l[0]:
	print('YES')
else:
	print('NO')


def solve(test):
	(n, a, b) = map(int, input().split())
	print('YES' if min(a, b) >= n else 'NO')
t = 1
for _ in range(t):
	solve(_ + 1)


import math

def main():
	(n, m, k) = map(int, input().split())
	if n <= m and n <= k:
		print('Yes')
	else:
		print('No')
main()


line = input().split()
n = int(line[0])
m = int(line[1])
k = int(line[2])
if m >= n and k >= n:
	print('YES')
else:
	print('NO')


from sys import stdin
input = stdin.readline
(n, m, k) = map(int, input().split())
if n <= min(m, k):
	print('Yes')
else:
	print('No')


(a, b, c) = [int(i) for i in input().split()]
if b < a or c < a:
	print('No')
else:
	print('Yes')


nums = input().split()
nums = [int(x) for x in nums]
(n, m, k) = nums
if m >= n and k >= n:
	print('Yes')
else:
	print('No')


s = input().split()
s = [int(i) for i in s]
if s[0] > s[1] or s[0] > s[2]:
	print('No')
else:
	print('Yes')


(n, pen, note) = map(int, input().split())
if n <= pen and n <= note:
	print('Yes')
else:
	print('No')


def three_numbers():
	numbers = list(map(int, input().split(sep=' ')))
	m = max(numbers)
	for i in numbers:
		if i != m:
			print(m - i, end=' ')

def gen_and_card_game():
	card = input()
	my_cards = list(input().split(sep=' '))
	for i in my_cards:
		if i[0] == card[0] or i[1] == card[1]:
			print('YES')
			break
	else:
		print('NO')

def kazak_vus_and_contest():
	(a, b, c) = map(int, input().split(sep=' '))
	if a - b <= 0 and a - c <= 0:
		print('YES')
	else:
		print('NO')
kazak_vus_and_contest()


n = list(map(int, input().strip().split()))
if n[0] == min(n):
	print('Yes')
else:
	print('No')


import itertools
from collections import Counter
from collections import defaultdict
import bisect
from heapq import heappush, heappop

def main():
	(n, m, k) = map(int, input().split())
	if n <= min(m, k):
		print('Yes')
	else:
		print('No')
main()


(n, m, k) = [int(x) for x in input().split()]
print('Yes' if min(m, k) >= n else 'No')


(participants, pens, notepads) = list(map(int, input().split()))
if participants > pens or participants > notepads:
	print('No')
else:
	print('Yes')


t = list(map(int, input().split()))
if t[0] <= min(t[1], t[2]):
	print('Yes')
else:
	print('No')


ol = input().split(' ')
num = []
for x in ol:
	num.append(int(x))
if num[0] <= num[1] and num[0] <= num[2]:
	print('Yes')
else:
	print('No')


(people, pens, notebooks) = map(int, input().split())
if pens >= people and notebooks >= people:
	print('Yes')
else:
	print('No')


(n, m, k) = list(map(int, input().split()))
minV = min(m, k)
if minV < n:
	print('No')
else:
	print('Yes')


l = input().split()
l = [int(i) for i in l]
if l[0] <= l[1] and l[0] <= l[2]:
	print('YES')
else:
	print('NO')


l = list(input().split())
n = int(l[0])
m = int(l[1])
k = int(l[2])
if min(m, k) >= n:
	print('Yes')
else:
	print('No')


num = str(input())
a = [int(x) for x in num.split()]
if a[0] <= a[1] and a[0] <= a[2]:
	print('Yes')
else:
	print('NO')


(x, y, z) = input().split()
n = int(x)
m = int(y)
k = int(z)
if m >= n and k >= n:
	print('Yes')
else:
	print('No')


from sys import stdin, stdout, maxsize
import math
(n, m, k) = list(map(int, stdin.readline().split()))
if n <= min(m, k):
	print('Yes')
else:
	print('No')


sp = list(map(int, input().split(' ')))
tx = 'YES' if sp[0] <= sp[1] and sp[0] <= sp[2] else 'No'
print(tx)


n = list(map(int, input().split()))
a = n[0]
b = n[1]
c = n[2]
if b >= a and c >= a:
	print('YES')
else:
	print('NO')


n = list(map(int, input().strip().split()))
ability = False
if n[0] <= n[1]:
	ability = True
if n[0] > n[2]:
	ability = False
if ability is True:
	print('Yes')
else:
	print('No')


(c, p, n) = map(int, input().split())
if p < c or n < c:
	print('NO')
else:
	print('YES')


from sys import stdin, stdout, exit
(n, m, k) = map(int, stdin.readline().split())
if m >= n and k >= n:
	print('Yes')
else:
	print('No')


(x, a, b) = map(int, input().split())
if a - x >= 0 and b - x >= 0:
	print('Yes')
else:
	print('No')


(n, k, l) = map(int, input().split())
flag = 0
if k >= n:
	flag += 1
if l >= n:
	flag += 1
if flag == 2:
	print('Yes')
else:
	print('No')


from math import sqrt
(m, n, k) = map(int, input().split())
if n >= m and k >= m:
	print('YES')
else:
	print('NO')


a = input()
a = a.split()
for i in range(3):
	a[i] = int(a[i])
if a[1] >= a[0] and a[2] >= a[0]:
	print('Yes')
else:
	print('No')


p = list(map(int, input().split()))
n = p[0]
m = p[1]
k = p[2]
if min(n, m) == n and min(n, k) == n:
	print('Yes')
else:
	print('No')


import sys
import math
input = sys.stdin.readline
(n, m, k) = map(int, input().split())
if m >= n and k >= n:
	print('Yes')
else:
	print('No')


(n, p, b) = map(int, input().split())
if n <= p and n <= b:
	print('Yes')
else:
	print('No')


from bisect import bisect_left as bl
from bisect import bisect_right as br
import heapq
import math
from collections import *
from functools import reduce, cmp_to_key
import sys
input = sys.stdin.readline
M = mod = 998244353

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

def inv_mod(n):
	return pow(n, mod - 2, mod)

def li():
	return [int(i) for i in input().rstrip('\n').split(' ')]

def st():
	return input().rstrip('\n')

def val():
	return int(input().rstrip('\n'))

def li2():
	return [i for i in input().rstrip('\n').split(' ')]

def li3():
	return [int(i) for i in input().rstrip('\n')]
(n, m, k) = li()
m = min(m, k)
print('No' if n > m else 'Yes')


(n, m, k) = map(int, input().split())
if m >= n and k >= n:
	print('YES')
else:
	print('No')


import sys

class AVusTheCossackAndAContest:

	def solve(self):
		(n, m, k) = [int(_) for _ in input().split()]
		print('Yes' if min(m, k) >= n else 'No')
solver = AVusTheCossackAndAContest()
input = sys.stdin.readline
solver.solve()


n = input().split()
if int(n[1]) < int(n[0]) or int(n[2]) < int(n[0]):
	print('No')
else:
	print('Yes')


(a, b, c) = input().split()
part = int(a)
pen = int(b)
notebook = int(c)
if pen >= part and notebook >= part:
	print('YES')
else:
	print('NO')


(m, p, n) = input().split(' ')
if int(p) >= int(m) and int(n) >= int(m):
	print('Yes')
else:
	print('No')


x = input()
y = x.split()
z = [int(d) for d in y]
if z[1] >= z[0] and z[2] >= z[0]:
	print('YES')
else:
	print('NO')


nmk = [int(x) for x in input().split()]
n = nmk[0]
m = nmk[1]
k = nmk[2]
if n > m or n > k:
	print('NO')
else:
	print('YES')


import sys, os, io
from sys import stdin
from math import log, gcd, ceil
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import math
sys.setrecursionlimit(100000)
alphabets = list('abcdefghijklmnopqrstuvwxyz')

def isPrime(x):
	for i in range(2, x):
		if i * i > x:
			break
		if x % i == 0:
			return False
	return True

def ncr(n, r, p):
	num = den = 1
	for i in range(r):
		num = num * (n - i) % p
		den = den * (i + 1) % p
	return num * pow(den, p - 2, p) % p

def primeFactors(n):
	l = []
	while n % 2 == 0:
		l.append(2)
		n = n / 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			l.append(int(i))
			n = n / i
	if n > 2:
		l.append(n)
	c = dict(Counter(l))
	return list(set(l))

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 sieveForSmallestPrimeFactor():
	MAXN = 100001
	spf = [0 for i in range(MAXN)]
	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, math.ceil(math.sqrt(MAXN))):
		if spf[i] == i:
			for j in range(i * i, MAXN, i):
				if spf[j] == j:
					spf[j] = i
	return spf

def getPrimeFactorizationLOGN(x):
	spf = sieveForSmallestPrimeFactor()
	ret = list()
	while x != 1:
		ret.append(spf[x])
		x = x // spf[x]
	return ret

def SieveOfEratosthenes(n):
	prime = [True for i in range(n + 1)]
	p = 2
	pr = []
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	for i in range(2, len(prime)):
		if prime[i]:
			pr.append(i)
	return pr

def si():
	return input()

def divideCeil(n, x):
	if n % x == 0:
		return n // x
	return n // x + 1

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

def li():
	return list(map(int, input().split()))
if os.path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
else:
	input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline

def solve():
	(n, m, k) = li()
	if n <= m and n <= k:
		print('YES')
	else:
		print('NO')
t = 1
for _ in range(t):
	solve()


import math
import sys

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

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

def li():
	return list(map(int, input().split()))
(n, m, k) = mi()
if min(m, k) >= n:
	print('Yes')
else:
	print('No')


def find_enough_gifts(n, p, b):
	if p >= n and b >= n:
		return 'Yes'
	return 'No'
(n, p, b) = map(int, input().split())
print(find_enough_gifts(n, p, b))


input = __import__('sys').stdin.readline
(n, m, k) = map(int, input().split())
if n <= m and n <= k:
	print('Yes')
else:
	print('No')


numbers = list(input('').split())
no_of_participants = int(numbers[0])
no_of_pens = int(numbers[1])
no_of_notebooks = int(numbers[2])
if no_of_pens // no_of_participants >= 1 and no_of_notebooks // no_of_participants >= 1:
	print('Yes')
else:
	print('No')


n = input()
n = n.split()
a = int(n[0])
if a - int(n[1]) <= 0 and a - int(n[2]) <= 0:
	print('YES')
else:
	print('NO')


mod = 1000000007
ii = lambda : int(input())
si = lambda : input()
dgl = lambda : list(map(int, input()))
f = lambda : map(int, input().split())
il = lambda : list(map(int, input().split()))
ls = lambda : list(input())
(n, m, k) = f()
if min(m, k) >= n:
	print('Yes')
else:
	print('No')


(n, m, k) = (int(x) for x in input().split())
if n <= m and n <= k:
	print('yes')
else:
	print('no')


(x, y, z) = [int(x) for x in input().split()]
if y >= x and z >= x:
	print('Yes')
else:
	print('No')


def main(inp):
	n = inp[0]
	m = inp[1]
	k = inp[2]
	if m >= n and k >= n:
		return 'Yes'
	else:
		return 'No'
inp = list(map(int, input().split(' ')))
print(main(inp))


def cossackAndContest():
	values = input().split()
	if int(values[1]) >= int(values[0]) and int(values[2]) >= int(values[0]):
		print('YES')
	else:
		print('NO')
cossackAndContest()


l = str(input()).split()
n = int(l[0])
m = int(l[1])
k = int(l[2])
out = 'NO'
if m >= n and k >= n:
	out = 'YES'
print(out)


l = list(map(int, input().split()))
if l[1] >= l[0] and l[2] >= l[0]:
	print('Yes')
elif l[1] < l[0] or l[2] < l[0]:
	print('No')


l = input().split()
n = int(l[0])
m = int(l[1])
k = int(l[2])
if m < n or k < n:
	print('No')
else:
	print('Yes')


(n, m, k) = map(int, input().split())
if m < n or k < n:
	print('NO')
else:
	print('yes')


x = list(map(int, input().split()))
if x[0] <= min(x[1], x[2]):
	print('YES')
else:
	print('NO')


(z, n, k) = map(int, input().split())
if z <= min(n, k):
	print('Yes')
else:
	print('No')


import sys

def main():
	(x, y, z) = map(int, input().split())
	result = min(x, y, z) == x
	result = 'Yes' if result else 'No'
	print(result)
main()


def main():
	f = [int(x) for x in input().split()]
	n = f[0]
	pen = f[1]
	notebook = f[2]
	if n <= min(pen, notebook):
		print('Yes')
	else:
		print('No')
main()


(N, M, K) = map(int, input().split())
if N > M or N > K:
	print('NO')
else:
	print('YES')


(n, m, k) = map(int, input().split())
print(['YES', 'NO'][n > m or n > k])


a = input().split()
b = int(a[0])
c = int(a[1])
d = int(a[2])
if c >= b and d >= b:
	print('yes')
else:
	print('no')


(a, b, c) = map(int, input().split())
print('YNEOS'[not (b - a >= 0 and c - a >= 0)::2])


n = 0
m = 0
k = 0

def Input():
	global n, m, k
	(n, m, k) = list(map(int, input().split()))

def Output():
	global n, m, k
	if m >= n and k >= n:
		print('Yes')
	else:
		print('No')
Input()
Output()


(n, m, k) = map(int, input().split())
print(['NO', 'YES'][m >= n and k >= n])


(n, m, k) = [int(x) for x in input().split()]

def distribute(n, m, k):
	if m >= n and k >= n:
		print('Yes')
	else:
		print('No')
distribute(n, m, k)


from collections import deque
import math
import os
import random
import re
import sys

def main():
	(n, m, k) = map(int, input().split())
	if n <= k and n <= m:
		print('Yes')
	else:
		print('No')
main()


num = input()
a = []

def get_the_data(count, num, arr):
	for i in range(0, len(num)):
		if num[i] == ' ':
			arr.append(int(num[count:i]))
			count = i + 1
		elif i == len(num) - 1:
			arr.append(int(num[count:len(num)]))
	return arr
arr = get_the_data(0, num, a)
counting = arr[0]
arr = arr[1:len(arr)]
arr.sort()
if arr[0] >= counting:
	print('YES')
else:
	print('NO')


arr = [0] * 4
arr = list(map(int, input().split()))
n = arr[0]
m = arr[1]
k = arr[2]
if n > m or n > k:
	print('No')
else:
	print('Yes')


def go():
	a = [int(i) for i in input().split(' ')]
	if a[0] <= a[1] and a[0] <= a[2]:
		return 'Yes'
	return 'No'
print(go())


I = [int(i) for i in input().split()]
if I[0] <= I[1] and I[0] <= I[2]:
	print('Yes')
else:
	print('No')


(n, m, p) = map(int, input().split())
if min(m, p) >= n:
	print('Yes')
else:
	print('No')


import sys
(n, m, k) = map(int, input().split())
print('YES' if n <= m and n <= k else 'NO')


(n, m, k) = map(int, input().split())
print('NYOE S'[min(m, k) >= n::2])


firstline = list(map(int, input().split(' ')))
(n, m, k) = (firstline[0], firstline[1], firstline[2])
ans = 'Yes' if n <= m and n <= k else 'No'
print(ans)


data = input().split()
data = [int(data[i]) for i in range(0, 3)]
students = data[0]
pen = data[1]
notebooks = data[2]
if students <= pen and students <= notebooks:
	print('YES')
else:
	print('NO')


(n, m, k) = map(int, input().split())

def main():
	if m >= n and k >= n:
		print('Yes')
		return 0
	else:
		print('No')
		return 0
main()


s = input()
tokens = s.split(' ')
n = int(tokens[0])
m = int(tokens[1])
k = int(tokens[2])
if m >= n and k >= n:
	print('Yes')
else:
	print('No')


l = [int(x) for x in input().split()]
if (l[1] > l[0] or l[1] == l[0]) and (l[2] > l[0] or l[2] == l[0]):
	print('Yes')
else:
	print('No')


(n, m, k) = map(int, input().split())
print('NYOE S'[bool(n <= m and n <= k)::2])


vals = [int(a) for a in input().split() if a != ' ']
print('Yes') if vals[1] >= vals[0] and vals[2] >= vals[0] else print('No')


import math

def main():
	(n, m, k) = map(int, input().split())
	mm = min(m, k)
	if mm >= n:
		print('Yes')
	else:
		print('No')
main()


(par, pen, book) = map(int, input().split())
if par > pen or par > book:
	print('No')
else:
	print('Yes')


(n, m, k) = map(int, input().split())
if (n == m or m > n) and (n == k or k > n):
	print('Yes')
elif m < n or k < n:
	print('No')
else:
	pass


x = [int(s) for s in input().split()]
x = list(filter(lambda a: a >= x[0], x))
if len(x) == 3:
	print('YES')
else:
	print('NO')


from sys import stdin

def main():
	(n, m, k) = map(int, stdin.readline().split())
	if m >= n and k >= n:
		print('Yes')
	else:
		print('No')
main()


lin = input()
nums = lin.split(' ')
n = int(nums[0])
m = int(nums[1])
k = int(nums[2])
if m >= n and k >= n:
	print('Yes')
else:
	print('No')


inp = list(map(int, input().split()))
if inp[1] <= inp[2] and inp[0] <= inp[1]:
	print('YES')
elif inp[2] <= inp[1] and inp[0] <= inp[2]:
	print('YES')
else:
	print('NO')


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

def function(n, m, k):
	if k - n >= 0 and m - n >= 0:
		print('Yes')
	else:
		print('No')
(n, m, k) = inlt()
function(n, m, k)


nmk = input().split(' ')
list = []
for _ in range(len(nmk)):
	list.append(int(nmk[_]))
	if list[_] < 1 or list[_] > 100:
		print('invalind numbers')
		exit()
if list[0] > list[1] or list[0] > list[2]:
	print('No')
else:
	print('Yes')


(n, x, y) = input().split()
n = int(n)
x = int(x)
y = int(y)
if x < n or y < n:
	print('No')
else:
	print('Yes')


i = input()
a = i.split()
if int(a[1]) < int(a[0]):
	print('NO')
elif int(a[2]) < int(a[0]):
	print('NO')
else:
	print('YES')


(n, k, d) = map(int, input().split())
if k >= n and d >= n:
	print('Yes')
else:
	print('No')


mas = [int(a) for a in input().split()]
if mas[1] <= mas[2]:
	max = mas[1]
else:
	max = mas[2]
if max >= mas[0]:
	print('Yes')
else:
	print('No')


n = [int(x) for x in input().split()]
if n[0] <= n[1] and n[0] <= n[2]:
	print('YES')
else:
	print('NO')


angka = input().split()
a = int(angka[0])
b = int(angka[1])
c = int(angka[2])
for i in range(a):
	b -= 1
	c -= 1
	if b == -1 or c == -1:
		hasil = 'No'
		break
	else:
		hasil = 'Yes'
print(hasil)


def main():
	(n, m, k) = list(map(int, input().split()))
	if min(m, k) >= n:
		print('Yes')
	else:
		print('No')
main()


numbers = map(int, input().split())
lst = list(numbers)
participant = lst[0]
pens = lst[1]
notebooks = lst[2]
if participant <= pens and participant <= notebooks:
	print('Yes')
else:
	print('No')


print('Yes' if (lambda a: a[1] >= a[0] and a[2] >= a[0])([int(x) for x in input().split(' ')]) else 'No')


from sys import stdin, stdout
(a, b, c) = map(int, stdin.readline().strip().split())
if b >= a and c >= a:
	stdout.write('Yes\n')
else:
	stdout.write('No\n')


l = list(map(int, input().strip().split()))
n = l[0]
m = l[1]
k = l[2]
if m >= n and k >= n:
	print('Yes')
else:
	print('No')


str = input()
parts = str.split(' ')
n = int(parts[0])
m = int(parts[1])
k = int(parts[2])
mk_min = min(m, k)
if mk_min >= n:
	print('Yes')
else:
	print('No')


(memb, pens, notepads) = map(int, input().split())
if pens - memb >= 0 and notepads - memb >= 0:
	print('Yes')
else:
	print('No')


import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush, nlargest, nsmallest, _heapify_max, _heapreplace_max
from math import ceil, floor, gcd, fabs, factorial, fmod, sqrt, inf, log
from collections import defaultdict as dd, deque, Counter as c
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from fractions import Fraction
mod = pow(10, 9) + 7
mod2 = 998244353

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

def out(*var, end='\n'):
	sys.stdout.write(' '.join(map(str, var)) + end)

def l():
	return list(sp())

def sl():
	return list(ssp())

def sp():
	return map(int, data().split())

def ssp():
	return map(str, data().split())

def l1d(n, val=0):
	return [val for i in range(n)]

def l2d(n, m, val=0):
	return [l1d(n, val) for j in range(m)]
(n, m, k) = sp()
if n <= min(m, k):
	out('Yes')
	exit()
out('No')


def answer():
	a = input().split()
	a = [int(x) for x in a]
	if a[0] <= a[1] and a[0] <= a[2]:
		return 'Yes'
	else:
		return 'No'
print(answer())


(hm, pens, notebooks) = map(int, input().split(' '))
if hm > pens or hm > notebooks:
	print('no')
else:
	print('yes')


a = input().split()
n = int(a[0])
m = int(a[1])
k = int(a[2])
if m >= n:
	if k >= n:
		print('Yes')
	else:
		print('No')
else:
	print('No')


no = input()
no = no.split(' ')
no1 = int(no[0])
no2 = int(no[1])
no3 = int(no[2])
if no1 <= no2 and no1 <= no3:
	print('Yes')
else:
	print('No')


s = input().split(' ')
u = int(s[0])
r = int(s[1])
b = int(s[2])
if r >= u and b >= u:
	print('Yes')
else:
	print('No')


def foo(x):
	if x[0] <= min(x[1], x[2]):
		print('Yes')
	else:
		print('No')
second = [int(x) for x in input().split()]
foo(second)


(n, m, k) = list(map(int, input().split()))
if m >= n and k >= n:
	print('Yes')
elif n > m or n < m or n > k or (n < k):
	print('No')


j = input()
list1 = []
list1 = j.split(' ')
n = int(list1[0])
p = int(list1[1])
b = int(list1[2])
if p >= n and b >= n:
	print('Yes')
else:
	print('No')


t = list(map(int, input().split(' ')))
n = t[0]
m = t[1]
k = t[2]
if m < n or k < n:
	print('NO')
else:
	print('YES')


(n, m, k) = list(map(int, input().split()))
if n > m:
	print('No')
	exit()
if n > k:
	print('No')
	exit()
if n <= m:
	print('Yes')
	exit()
if n <= k:
	print('Yes')
	exit()


(participants, pens, books) = map(int, input().split())
if participants <= min(pens, books):
	print('Yes')
else:
	print('No')


(a, b, c) = map(int, input().split())
while a > 0:
	a -= 1
	b -= 1
	c -= 1
if b < 0 or c < 0:
	print('NO')
else:
	print('YES')


b = list(map(int, input().split()))
if b[0] <= b[1] and b[2] >= b[0]:
	print('yes')
else:
	print('no')


def solve():
	(n, m, k) = [int(s) for s in input().split()]
	if m >= n and k >= n:
		print('YES')
	else:
		print('NO')
solve()


ipList = input().split()
ipListNew = [int(x) for x in ipList]
ipListNew[0]
if ipListNew[0] <= ipListNew[1] and ipListNew[0] <= ipListNew[2]:
	print('Yes')
else:
	print('No')


import sys
input = lambda : sys.stdin.readline()
int_arr = lambda : list(map(int, input().split()))
str_arr = lambda : list(map(str, input().split()))
get_str = lambda : map(str, input().split())
get_int = lambda : map(int, input().split())
get_flo = lambda : map(float, input().split())

def solve(n, a, b):
	print('YES' if a >= n and b >= n else 'NO')
(n, a, b) = get_int()
solve(n, a, b)


(n, a, b) = map(int, input().split())
t = 0 if n <= min(a, b) else 1
print('YNeos'[t::2])


import sys

def solve():
	(n, m, k) = [int(x) for x in input().split(' ')]
	if m >= n and k >= n:
		ans = 'Yes'
	else:
		ans = 'No'
	return ans
ans = solve()
print(ans)


(n, m, k) = [int(d) for d in input().split()]
print(('No', 'Yes')[m >= n and k >= n])


import sys
import math
counter = -1
count = 0
for lin in sys.stdin:
	line = lin.rstrip()
	counter += 1
	if counter == 0:
		(a, b, c) = [int(j) for j in line.split()]
		break
print('Yes' if b >= a and c >= a else 'No')


def CanReward(n, m, k):
	if n <= m and n <= k:
		return 'Yes'
	else:
		return 'No'
(n, m, k) = map(int, input().split())
print(CanReward(n, m, k))


def main():
	(n, m, k) = map(int, input().split())
	if n <= m and n <= k:
		print('YES')
	else:
		print('NO')
main()


def solve():
	(N, M, K) = map(int, input().split())
	print('Yes' if min(M, K) >= N else 'No')
solve()


i = input().split()
n = int(i[0])
m = int(i[1])
k = int(i[2])
res = 'No'
if m >= n and k >= n:
	res = 'Yes'
print(res)


l = list(map(int, input().strip().split()))
n = l[0]
m = l[1]
k = l[2]
x = min(k, m)
if x >= n:
	print('yes')
else:
	print('no')


(par, pen, note) = input().split(' ')
if int(par) <= int(pen) and int(par) <= int(note):
	print('Yes')
else:
	print('No')


numbers = list(map(int, input().split()))
a = numbers[0]
b = numbers[1]
c = numbers[2]
if a > c or a > b:
	print('No')
else:
	print('Yes')


(u, b, r) = map(int, input().split())
if u <= r and u <= b:
	print('YES')
else:
	print('NO')


s = input().split()
n = int(s[0])
if int(s[1]) > int(s[2]):
	m = int(s[2])
else:
	m = int(s[1])
if n > m:
	print('No')
else:
	print('Yes')


n = input()
(n1, n2, n3) = n.split()
if int(n2) >= int(n1) and int(n3) >= int(n1):
	print('Yes')
else:
	print('No')


(n, m, k) = map(int, input().split())
print(['no', 'yes'][m >= n and k >= n])


import sys
from collections import defaultdict, deque
from math import sqrt

def input():
	return sys.stdin.readline()[:-1]
(n, m, k) = [int(x) for x in input().split()]
x = min(m, k)
if x < n:
	print('No')
else:
	print('Yes')


def dkwpwn(ppl, pen, note):
	return 'yes' if ppl <= pen and ppl <= note else 'no'
(ppl, pen, note) = list(map(int, input().split()))
print(dkwpwn(ppl, pen, note))


(a, b, c) = input().split(' ')
(a, b, c) = (int(a), int(b), int(c))
if a <= b and a <= c:
	print('Yes')
else:
	print('NO')


(n, p, q) = map(int, input().split()[:3])
if p < n or q < n:
	print('No')
else:
	print('Yes')


(n, pen, notebook) = map(int, input().split())
a = min(pen, notebook)
if n <= a:
	print('Yes')
else:
	print('No')


k = input().split(' ')
n = int(k[0])
s = int(k[1])
t = int(k[2])
if n - s > 0 or n - t > 0:
	print('No')
else:
	print('Yes')


(n, nb, pen) = [int(x) for x in input().split()]
ans = 'No'
if n <= nb and n <= pen:
	ans = 'Yes'
print(ans)


def solution(n, m, k):
	flag = True
	if m < n:
		flag = False
	if k < n:
		flag = False
	if flag == True:
		return 'Yes'
	elif flag == False:
		return 'No'

def main():
	(n, m, k) = map(int, input().split())
	result = solution(n, m, k)
	print(result)
main()


inp = input()
inp = inp.split(' ')
num_people = int(inp[0])
num_pens = int(inp[1])
num_books = int(inp[2])

def answer(a, b, c):
	if a <= b and a <= c:
		return 'Yes'
	else:
		return 'No'
print(answer(num_people, num_pens, num_books))


inputs = [int(element) for element in input().split(' ')]
if inputs[0] <= inputs[1] and inputs[0] <= inputs[2]:
	print('Yes')
else:
	print('No')


def solv(n, m, k):
	t = 'YES'
	f = 'NO'
	if m < n or k < n:
		print(f)
	else:
		print(t)
(n, m, k) = map(int, input().split())
solv(n, m, k)


A = input()
A = list(A.split())
pens = int(A[1])
nbooks = int(A[-1])
ppl = int(A[0])
if pens < nbooks:
	B = pens
else:
	B = nbooks
if ppl > B:
	print('No')
else:
	print('Yes')


(a, b, c) = map(int, input().split())
z = 0
if b >= a:
	if c >= a:
		print('Yes')
		z = 1
if z == 0:
	print('No')


s = [i for i in input().split()]
(n, p, k) = (int(s[0]), int(s[1]), int(s[2]))
if p >= n and k >= n:
	print('YES')
else:
	print('NO')


masukan = [int(y) for y in input().split()]
if masukan[0] <= masukan[1] and masukan[0] <= masukan[2]:
	print('Yes')
else:
	print('No')


import sys
from collections import Counter
import itertools

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

def dinput():
	return int(input())

def tinput():
	return input().split()

def rinput():
	return map(int, tinput())

def main():
	(a, s, r) = rinput()
	if a <= min(s, r):
		print('Yes')
	else:
		print('No')
main()


first_line = list(map(int, input().strip().split()))
(n, m, k) = (first_line[0], first_line[1], first_line[2])
if n <= m and n <= k:
	print('YES')
else:
	print('NO')


line = input().split(' ')
(n, m, k) = [int(i) for i in line]
if m >= n and k >= n:
	print('YES')
else:
	print('NO')


def rewardAll(values):
	if values[0] <= values[1] and values[0] <= values[2]:
		return 'Yes'
	return 'No'
values = [int(s) for s in input().split()]
print(rewardAll(values))


n = input().split(' ')
people = int(n[0])
pens = int(n[1])
notebooks = int(n[2])
if people > pens or people > notebooks:
	print('No')
else:
	print('Yes')


from sys import stdin
inp = stdin.readline
(n, m, k) = [int(k) for k in inp().strip().split()]
print('YES' if n <= m and n <= k else 'NO')


(n, m, k) = map(int, input().split())
moze = True
if m < n or k < n:
	moze = False
if moze:
	print('Yes')
else:
	print('No')


n = input('').split()
m = int(n[1])
k = int(n[2])
n = int(n[0])
if n <= m and n <= k:
	print('Yes')
else:
	print('NO')


is_debug = False
(n, m, k) = map(int, input().split())
v = min(m, k)
print(f"{('Yes' if v >= n else 'No')}")


lst = list(map(int, input().split()))
(a, b, c) = (lst[0], lst[1], lst[2])
x = 0
if b >= a and c >= a:
	print('Yes')
else:
	print('No')


import itertools
import math
import sys
import heapq
from collections import Counter
from collections import deque
from fractions import gcd
from functools import reduce
sys.setrecursionlimit(4100000)
INF = 1 << 60
MOD = 10 ** 9 + 7
(n, m, k) = map(int, input().split())
if m >= n and k >= n:
	print('YES')
else:
	print('NO')


from sys import stdin
(n, m, k) = map(int, stdin.readline().split())
if n <= m and n <= k:
	print('YES')
else:
	print('NO')


import sys
for s in sys.stdin:
	s = list(map(int, s.split(' ')))
	if s[0] <= s[1] and s[0] <= s[2]:
		print('Yes')
	else:
		print('No')


from math import *
(n, m, k) = map(int, input().split(' '))
if n <= m and n <= k:
	print('Yes')
else:
	print('No')


(person, pen, note) = list(map(int, input().split()))
if person <= pen and person <= note:
	print('yes')
else:
	print('no')


from sys import stdin, stdout

def main():
	inp = [int(x) for x in str(stdin.readline()).split()]
	if inp[1] >= inp[0] and inp[2] >= inp[0]:
		stdout.write('Yes' + '\n')
	else:
		stdout.write('No' + '\n')
main()


(q, w, e) = input().split()
q = int(q)
w = int(w)
e = int(e)

def check(a, s, d):
	if d / a >= 1:
		if s / a >= 1:
			print('yes')
		else:
			print('no')
	else:
		print('no')
check(q, w, e)


data = [int(nums) for nums in input().split()]
n = data[0]
m = data[1]
k = data[2]
if m >= n and k >= n:
	print('Yes')
else:
	print('No')


a = input().split()
i = int(a[0])
j = int(a[1])
k = int(a[2])
if i <= j and i <= k:
	print('Yes')
else:
	print('No')


var = [int(x) for x in input().split(' ')]
if min(var) == var[0]:
	print('Yes')
else:
	print('No')


(a, b, c) = map(int, input().split())
if a in range(b + 1) and a in range(c + 1):
	print('YES')
else:
	print('NO')


a = str(input(''))
b = a.split(' ')
num = int(b[0])
p = int(b[1])
n = int(b[2])
if num <= p and num <= n:
	print('Yes')
else:
	print('No')


(X, Y, Z) = map(int, input().split())
if X > min(Y, Z):
	print('No')
else:
	print('Yes')


(n, s, t) = list(map(int, input().split()))
if n <= s and n <= t:
	print('Yes')
else:
	print('No')


a = input().split()
n = int(a[0])
m = int(a[1])
k = int(a[2])
if n <= k:
	if n <= m:
		print('YES')
	else:
		print('NO')
else:
	print('NO')


a = list(map(int, input().split()))
u = a[0]
r = a[1]
b = a[2]
if r >= u and b >= u:
	print('Yes')
else:
	print('No')


(a, b, c) = map(int, input().split())
print('YNEOS'[a > b or a > c::2])


import sys
data = [int(x) for x in sys.stdin.readline().split()]
if data[0] <= data[1] and data[0] <= data[2]:
	print('Yes')
else:
	print('No')


times = ['', '', '']
tmp = list(input())
x = 0
for j in range(0, 3):
	while x < len(tmp):
		if tmp[x] == ' ':
			x += 1
			break
		else:
			times[j] = times[j] + tmp[x]
			x += 1
if int(times[0]) <= int(times[1]) and int(times[0]) <= int(times[2]):
	print('Yes')
else:
	print('No')


x = input().split()
n = int(x[0])
w = int(x[1])
q = int(x[2])
if w >= n and q >= n:
	print('Yes')
else:
	print('NO')


l = input().split()
n = int(l[0])
if int(l[1]) < n or int(l[2]) < n:
	print('No')
else:
	print('yes')


(m, n, o) = [int(i) for i in input().split(' ')]
if n >= m and o >= m:
	print('Yes')
else:
	print('No')


(x, y, z) = map(int, input().split())
if z >= x:
	if y >= x:
		print('YES')
	else:
		print('no')
else:
	print('no')


a = input()
b = a.split(' ')
if int(b[0]) > int(b[1]) or int(b[0]) > int(b[2]):
	print('NO')
else:
	print('YES')


(num, pen, nb) = [int(x) for x in input().split()]
if pen >= num and nb >= num:
	print('Yes')
else:
	print('No')


p = input().rstrip().split(' ')
if int(p[1]) >= int(p[0]) and int(p[2]) >= int(p[0]):
	print('Yes')
else:
	print('No')


(people, pens, books) = map(int, input().split())
if pens < people or books < people:
	print('No')
else:
	print('Yes')


def vus(n, m, k):
	if m >= n and k >= n:
		print('YES')
	else:
		print('NO')
(n, m, k) = map(int, input().split())
res = vus(n, m, k)


(n, m, k) = map(int, input().split())
print(('no', 'yes')[n <= min(m, k)])


(a, b, c) = input().split()
if int(a) > int(b):
	print('No')
elif int(a) > int(c):
	print('No')
else:
	print('Yes')


m = input().split()
n = []
for i in range(3):
	n.append(int(m[i]))
if n[1] / n[0] >= 1 and n[2] / n[0] >= 1:
	print('yes')
else:
	print('No')


(a, b, c) = map(int, input().split())
print(['Yes', 'No'][b < a or c < a])


def solve():
	(a, b, c) = map(int, input().split())
	return a <= b and a <= c
print('NYoe s'[solve()::2])


arr = [int(el) for el in input().split()]
n = arr[0]
m = arr[1]
k = arr[2]
if n <= m and n <= k:
	print('Yes')
else:
	print('No')


[x, y, z] = [int(c) for c in input().split()]
if min(y, z) < x:
	print('No')
else:
	print('Yes')


(n, m, k) = map(int, input().split())
mn = min(m, k)
print(['Yes', 'No'][mn < n])


from __future__ import division, print_function
import itertools, os, sys, threading
from collections import deque, Counter, OrderedDict, defaultdict
import heapq
from math import ceil, floor, log, sqrt, factorial, pow, pi

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

def si():
	return str(input())

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

def li():
	return list(mi())
abc = 'abcdefghijklmnopqrstuvwxyz'
abd = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
mod = 1000000007
(dx, dy) = ([-1, 1, 0, 0], [0, 0, 1, -1])

def getKey(item):
	return item[0]

def sort2(l):
	return sorted(l, key=getKey)

def d2(n, m, num):
	return [[num for x in range(m)] for y in range(n)]

def isPowerOfTwo(x):
	return x and (not x & x - 1)

def decimalToBinary(n):
	return bin(n).replace('0b', '')

def ntl(n):
	return [int(i) for i in str(n)]

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

def gcd(x, y):
	while y:
		(x, y) = (y, x % y)
	return x
graph = defaultdict(list)
visited = [0] * 1000000
col = [-1] * 1000000

def dfs(v, c):
	if visited[v]:
		if col[v] != c:
			print('-1')
			exit()
		return
	col[v] = c
	visited[v] = 1
	for i in graph[v]:
		dfs(i, c ^ 1)

def bfs(d, v):
	q = []
	q.append(v)
	visited[v] = 1
	while len(q) != 0:
		x = q[0]
		q.pop(0)
		for i in d[x]:
			if visited[i] != 1:
				visited[i] = 1
				q.append(i)
		print(x)
	print(l)

def make_graph(e):
	d = {}
	for i in range(e):
		(x, y) = mi()
		if x not in d.keys():
			d[x] = [y]
		else:
			d[x].append(y)
		if y not in d.keys():
			d[y] = [x]
		else:
			d[y].append(x)
	return d

def gr2(n):
	d = {}
	for i in range(n):
		(x, y) = mi()
		if x not in d.keys():
			d[x] = [y]
		else:
			d[x].append(y)
	return d

def connected_components(graph):
	seen = set()

	def dfs(v):
		vs = set([v])
		component = []
		while vs:
			v = vs.pop()
			seen.add(v)
			vs |= set(graph[v]) - seen
			component.append(v)
		return component
	ans = []
	for v in graph:
		if v not in seen:
			d = dfs(v)
			ans.append(d)
	return ans
(n, m, k) = mi()
if m >= n and k >= n:
	print('Yes')
else:
	print('No')


def comp(aa):
	(n, m, k) = (aa[0], aa[1], aa[2])
	if n <= m and n <= k:
		return 'Yes'
	return 'No'
n = list(map(int, input().split()))
print(comp(n))


def check_Vus():
	raw_in = input().split()
	[n, m, k] = [int(x) for x in raw_in]
	if k >= n and m >= n:
		return True
	else:
		return False
if check_Vus():
	print('Yes')
else:
	print('No')


def vus(n, m, k):
	if m >= n and k >= n:
		print('Yes')
	else:
		print('No')
ar = list(map(int, input().rstrip().split()))
vus(ar[0], ar[1], ar[2])


import time

def main():
	(n, m, k) = input().split()
	(n, m, k) = (int(n), int(m), int(k))
	if n <= m and n <= k:
		return print('Yes')
	else:
		return print('No')
main()


import math
import os
import random
import re
import sys
a = [int(x) for x in input().split()]
if a[0] == min(a):
	print('YES')
else:
	print('NO')


l = [int(i) for i in input().split()]
n = l[0]
m = l[1]
k = l[2]
if m < n or k < n:
	print('No')
else:
	print('Yes')


a = list(map(int, input().split()))
if a[0] > a[1] or a[0] > a[2]:
	print('no')
else:
	print('yes')


import collections as cc
import math as mt
import sys
I = lambda : list(map(int, input().split()))
(n, m, k) = I()
if min(m, k) >= n:
	print('Yes')
else:
	print('No')


n = map(int, input().split())
p = list(n)
if p[0] > p[1]:
	print('NO')
elif p[0] > p[2]:
	print('NO')
else:
	print('YES')


from sys import stdin
number = list(map(int, stdin.readline().split()))
person = number[0]
pens = number[1]
notebook = number[2]
if person <= pens and person <= notebook:
	print('Yes')
else:
	print('No')


a = [int(i) for i in input().split()]
if a[0] > min(a[1:]):
	print('No')
else:
	print('Yes')


inp = input
li = list
iinp = lambda : int(inp())
ent = lambda : map(int, inp().split())
lient = lambda : li(ent())
(n, m, k) = ent()
if m >= n and k >= n:
	print('YES')
else:
	print('NO')


import sys
a = list(map(int, sys.stdin.readline().split()))
if min(a[1], a[2]) >= a[0]:
	print('YES')
else:
	print('NO')


(n, a, b) = map(int, input().split())
if a < n or b < n:
	print('NO')
else:
	print('YES')


import sys
string = sys.stdin.readline()
(n, m, k) = map(int, string.split())
if m >= n and k >= n:
	print('Yes')
else:
	print('No')


(x, y, z) = map(int, input().split())
if y < x or z < x:
	print('no')
else:
	print('yes')


l = list(map(int, input().strip().split()))
if l[0] <= min(l[1:]):
	print('YES')
else:
	print('NO')


def input_func():
	while True:
		(people, pens, notebooks) = [int(x) for x in input().split()]
		if 1 <= people <= 100 or 1 <= pens <= 100 or 1 <= notebooks <= 100:
			return (people, pens, notebooks)
		else:
			continue

def check_func(people, pens, notebooks):
	if pens < people or notebooks < people:
		print('No')
	else:
		print('Yes')
(people, pens, notebooks) = input_func()
check_func(people, pens, notebooks)


x = [int(x) for x in input().split()]
if min(x[1], x[2]) >= x[0]:
	print('YES')
else:
	print('NO')


(people, pen, books) = map(int, input().split(' '))

def canDistributable(people, pen, books):
	if people <= pen and people <= books:
		return 'Yes'
	return 'No'
print(canDistributable(people, pen, books))


arr = [int(i) for i in input().split()]
print('Yes' if arr[0] == min(arr) else 'No')


(n, p, b) = input().split()
if int(p) < int(n) or int(b) < int(n):
	print('No')
else:
	print('Yes')


i = [int(i) for i in input().split()]

def cont(i):
	return 'YES' if i[0] <= i[1] and i[0] <= i[2] else 'NO'
print(cont(i))


(n, pen, book) = map(int, input().split())
if n <= min(pen, book):
	print('yes')
else:
	print('no')


y = input()
x = y.split(' ')
n = int(x[0])
m = int(x[1])
k = int(x[2])
if n <= m and n <= k:
	print('Yes')
else:
	print('No')


s = list(map(int, input().split()))
s1 = s[0]
s2 = s[1]
s3 = s[2]
if s1 <= s2 and s1 <= s3:
	print('Yes')
else:
	print('No')


(x, y, z) = input().split()
x = int(x)
y = int(y)
z = int(z)
if y >= x and z >= x:
	print('yes')
elif y < x or z < x:
	print('no')


(n, m, k) = input().split()
is_ok = False
n = int(n)
m = int(m)
k = int(k)
for i in range(1, n + 1):
	if i != n + 1:
		if m == 0 or k == 0:
			print('No')
			quit()
		else:
			m -= 1
			k -= 1
print('Yes')


a = [int(x) for x in input().split()]
if a[0] > a[1] or a[0] > a[2]:
	print('No')
else:
	print('Yes')


(student, pen, notebook) = [int(x) for x in input().split()]
if student <= min(pen, notebook):
	print('Yes')
else:
	print('No')


(n, m, k) = map(int, input().split())

def contest(n, m, k):
	if m >= n:
		if k >= n:
			print('Yes')
		else:
			print('No')
	else:
		print('No')
contest(n, m, k)


class win(object):

	def is_prize(self):
		(n, m, k) = map(int, input().strip().split())
		if k >= n and m >= n:
			print('Yes')
		else:
			print('No')
cc = win()
cc.is_prize()


input = input()
args = input.split()
n = int(args[0])
m = int(args[1])
k = int(args[2])
result = n <= m and n <= k
print('Yes' if result else 'No')


foo = list(map(int, input().split()))
if foo[0] <= min(foo[1:]):
	print('Yes')
else:
	print('No')


import sys
inf = float('inf')
abc = 'abcdefghijklmnopqrstuvwxyz'
abd = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
(mod, MOD) = (1000000007, 998244353)
vow = ['a', 'e', 'i', 'o', 'u']
(dx, dy) = ([-1, 1, 0, 0], [0, 0, 1, -1])

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

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

def input():
	return sys.stdin.readline().strip()
(n, m, k) = get_ints()
if min(m, k) < n:
	print('No')
else:
	print('Yes')


[c, p, n] = list(map(int, input().split()))
if c <= p and c <= n:
	print('Yes')
else:
	print('No')


import sys
import os
from io import IOBase, BytesIO

def main():
	(n, m, k) = get_ints()
	if m >= n and k >= n:
		print('Yes')
	else:
		print('No')
BUFSIZE = 8192

class FastIO(BytesIO):
	newlines = 0

	def __init__(self, file):
		self._file = file
		self._fd = file.fileno()
		self.writable = 'x' in file.mode or 'w' in file.mode
		self.write = super(FastIO, self).write if self.writable else None

	def _fill(self):
		s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
		self.seek((self.tell(), self.seek(0, 2), super(FastIO, self).write(s))[0])
		return s

	def read(self):
		while self._fill():
			pass
		return super(FastIO, self).read()

	def readline(self):
		while self.newlines == 0:
			s = self._fill()
			self.newlines = s.count(b'\n') + (not s)
		self.newlines -= 1
		return super(FastIO, self).readline()

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

class IOWrapper(IOBase):

	def __init__(self, file):
		py2 = round(0.5)
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		if py2 == 1:
			self.write = self.buffer.write
			self.read = self.buffer.read
			self.readline = self.buffer.readline
		else:
			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))

def get_array():
	return list(map(int, sys.stdin.readline().split()))

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

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


x = list(map(int, input().rstrip().split()))
if x[0] <= x[1] and x[0] <= x[2]:
	print('Yes')
else:
	print('No')


import math
from collections import *
import sys
from functools import reduce

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

def get_list():
	return list(get_ints())

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

def printxsp(*args):
	return print(*args, end='')

def printsp(*args):
	return print(*args, end=' ')
UGLYMOD = int(1000000000.0) + 7
SEXYMOD = 998244353
MAXN = int(100000.0)
(n, m, k) = get_ints()
if n <= min(m, k):
	print('Yes')
else:
	print('No')


n = input()
arr = n.split()
a = int(arr[0])
b = int(arr[1])
c = int(arr[2])
if a <= b and a <= c:
	print('YES')
else:
	print('NO')


from sys import stdin
import collections
import math
import queue
(n, m, k) = list(map(int, stdin.readline().split()))
if min(m, k) >= n:
	print('Yes')
else:
	print('No')


(r, t, q) = map(int, input().strip().split())
if q >= r and t >= r:
	print('Yes')
else:
	print('No')


a = str(input())
b = a.split()
n = b[0]
m = b[1]
k = b[2]
n = int(n)
m = int(m)
k = int(k)
if m >= n and k >= n:
	print('YES')
else:
	print('NO')


mas = [int(i) for i in input().split()]
print('Yes' if min(mas[1], mas[2]) >= mas[0] else 'No')


[participants, pens, notebooks] = list(map(int, input().strip().split()))
if participants <= pens and participants <= notebooks:
	print('Yes')
else:
	print('No')


def cossack(n, m, k):
	if n <= m and n <= k:
		return 'Yes'
	else:
		return 'No'
(n, m, k) = input().split()
print(cossack(int(n), int(m), int(k)))


def program(n):
	if n[0] <= n[1] and n[0] <= n[2]:
		return 'Yes'
	return 'No'
n = list(map(int, input().strip().split()))
print(program(n))


import sys
inf = float('inf')
mod = 1000000007

def get_array():
	return list(map(int, sys.stdin.readline().split()))

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

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

def int1():
	return int(input())
import string
import math
from itertools import combinations

def main():
	(n, m, k) = get_array()
	if m >= n and k >= n:
		print('YES')
	else:
		print('NO')
main()


S = input()
A = S.split()
n = int(A[0])
pens = int(A[1])
notebooks = int(A[2])
if pens >= n and notebooks >= n:
	print('Yes')
else:
	print('No')


inp = input().split()
a = int(inp[0])
b = int(inp[1])
c = int(inp[2])
if a <= b and a <= c:
	print('YES')
else:
	print('NO')


import sys
IS_LOCAL = False

def readMultiple(f):
	return f(map(int, input().split()))

def main():
	(n, m, k) = (5, 8, 6)
	if not IS_LOCAL:
		(n, m, k) = readMultiple(tuple)
	print('Yes' if n <= m and n <= k else 'No')
if len(sys.argv) > 1 and sys.argv[1] == 'True':
	IS_LOCAL = True
main()


a = input().split()
b = int(a[0])
c = int(a[1])
d = int(a[2])
if c / b >= 1 and d / b >= 1:
	print('Yes')
else:
	print('No')


(num, pen, note) = input().split()
num = int(num)
pen = int(pen)
note = int(note)
if num <= pen and num <= note:
	print('Yes')
else:
	print('No')


(n, p, no) = input().strip().split()[:3]
n = int(n)
p = int(p)
no = int(no)
if n <= p and n <= no:
	print('Yes')
else:
	print('No')


def contest(n, m, k):
	if n <= min(m, k):
		return 'Yes'
	return 'No'
(x, y, z) = [int(i) for i in input().split()]
print(contest(x, y, z))


import math as mt
import sys, string, bisect
input = sys.stdin.readline
from collections import deque, defaultdict
from decimal import *
getcontext().prec = 100
L = lambda : list(map(int, input().split()))
Ls = lambda : list(input().split())
M = lambda : map(int, input().split())
I = lambda : int(input())

def dist(x, y, c, d):
	return (x - c) ** 2 + (y - d) ** 2

def circle(x1, y1, x2, y2, r1, r2):
	distSq = ((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)) ** 0.5
	if distSq + r2 <= r1:
		return True
	else:
		return False
	print(c[i][1], end=' ')
(a, b, c) = M()
if a <= min(b, c):
	print('Yes')
else:
	print('No')


inputs = list(map(int, input().split()))
people = inputs[0]
pens = inputs[1]
notebooks = inputs[2]
if pens >= people and notebooks >= people:
	print('Yes')
else:
	print('No')


(n, m, k) = map(int, input().split())
x = lambda n, m, k: 'Yes' if n <= m and n <= k else 'No'
print(x(n, m, k))


(x, y, z) = [int(x) for x in input().split()]
if y - x >= 0 and z - x >= 0:
	print('YES')
else:
	print('NO')


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, copy, functools
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return list(map(int, sys.stdin.readline().split()))

def LLI():
	return [list(map(int, l.split())) for l in sys.stdin.readlines()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

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

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def pe(s):
	return print(str(s), file=sys.stderr)

def JA(a, sep):
	return sep.join(map(str, a))

def JAA(a, s, t):
	return s.join((t.join(map(str, b)) for b in a))

def main():
	(n, m, k) = LI()
	if n > m or n > k:
		return 'No'
	return 'Yes'
print(main())


def main(a, b, c):
	if b >= a and c >= a:
		return 'Yes'
	else:
		return 'No'
try:
	while True:
		(a, b, c) = list(map(int, input().split()))
		print(main(a, b, c))
except:
	pass


(n, n1, n2) = map(int, input().split())
if n <= min(n1, n2):
	print('Yes')
else:
	print('No')


(x, y, z) = map(int, input().strip().split(' '))
if x <= y and x <= z:
	print('Yes')
else:
	print('no')


z = input().split()
penting = int(z[0])
satu = int(z[1])
dua = int(z[2])
if penting <= satu and penting <= dua:
	print('Yes')
else:
	print('No')


(t, n, p) = input().split()
t = int(t)
n = int(n)
p = int(p)
if t <= n and t <= p:
	print('YES')
else:
	print('No')


def solve(n, m, k):
	return 'YES' if m >= n and k >= n else 'No'
(n, m, k) = map(int, input().split())
print(solve(n, m, k))


(n, k, m) = map(int, input().split())
if k >= n and m >= n:
	print('YES')
else:
	print('NO')
if m > 100:
	print('dfdf')


inputs = input().split(' ')
for i in range(len(inputs)):
	inputs[i] = int(inputs[i])
if inputs[0] <= inputs[1] and inputs[0] <= inputs[2]:
	print('YES')
else:
	print('NO')


(n, pens, books) = map(int, input().split())
x = min(n, pens, books)
if x == n:
	print('Yes')
else:
	print('No')


(a, b, c) = [int(x) for x in input('').split()]
if a == 0 or (c // a >= 1 and b // a >= 1):
	print('Yes')
else:
	print('No')


(perticipents, pens, notebook) = map(int, input().split())
if pens >= perticipents and notebook >= perticipents:
	print('YES')
else:
	print('NO')


class cinn:

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

	def cin(self, t=int):
		if len(self.x) == 0:
			a = input()
			self.x = a.split()
			self.x.reverse()
		return self.get(t)

	def get(self, t):
		return t(self.x.pop())

	def clist(self, n, t=int):
		l = [0] * n
		for i in range(n):
			l[i] = self.cin(t)
		return l

	def clist2(self, n, t1=int, t2=int, t3=int, tn=2):
		l = [0] * n
		for i in range(n):
			if tn == 2:
				a1 = self.cin(t1)
				a2 = self.cin(t2)
				l[i] = (a1, a2)
			elif tn == 3:
				a1 = self.cin(t1)
				a2 = self.cin(t2)
				a3 = self.cin(t3)
				l[i] = (a1, a2, a3)
		return l

	def clist3(self, n, t1=int, t2=int, t3=int):
		return self.clist2(self, n, t1, t2, t3, 3)

	def cout(self, i, ans=''):
		if ans == '':
			print('Case #' + str(i + 1) + ':', end=' ')
		else:
			print('Case #' + str(i + 1) + ':', ans)

	def printf(self, thing):
		print(thing, end='')

	def countlist(self, l, s=0, e=None):
		if e == None:
			e = len(l)
		dic = {}
		for el in range(s, e):
			if l[el] not in dic:
				dic[l[el]] = 1
			else:
				dic[l[el]] += 1
		return dic

	def talk(self, x):
		print(x, flush=True)

	def dp1(self, k):
		L = [-1] * k
		return L

	def dp2(self, k, kk):
		L = [-1] * k
		for i in range(k):
			L[i] = [-1] * kk
		return L

	def isprime(self, n):
		if n == 1 or n == 0:
			return False
		for i in range(2, int(n ** 0.5 + 1)):
			if n % i == 0:
				return False
		return True

	def factors(self, n):
		from functools import reduce
		return set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))

	def nthprime(self, n):
		i = 0
		s = 2
		L = []
		while i < n:
			while not self.isprime(s):
				s += 1
			L.append(s)
			s += 1
			i += 1
		return L

	def matrixin(self, m, n, t=int):
		L = []
		for i in range(m):
			p = self.clist(n, t)
			L.append(p)
		return L

	def seive(self, k):
		n = k + 1
		L = [True] * n
		L[1] = False
		L[0] = False
		for i in range(2, n):
			if L[i] == True:
				for j in range(2 * i, n, i):
					L[j] = False
		return L

	def seiven(self, n, L):
		i = 0
		for j in range(len(L)):
			if L[j] == True:
				i += 1
			if i == n:
				return j

	def matrixin2(self, m, t=int):
		L = []
		for i in range(m):
			iny = self.cin(str)
			lsmall = []
			for el in iny:
				lsmall.append(t(el))
			L.append(lsmall)
		return L
c = cinn()
n = c.cin()
x = c.cin()
y = c.cin()
if n <= x and n <= y:
	print('Yes')
else:
	print('No')


(n, m, k) = map(int, input().split())
print(('Yes', 'No')[n > m or n > k])


(a, b, c) = list(map(int, input().split(' ')))
if a > b or a > c:
	print('NO')
else:
	print('YES')


import sys
sys.setrecursionlimit(1000000)

class Main:

	def __init__(self):
		self.buff = None
		self.index = 0

	def next(self):
		if self.buff is None or self.index == len(self.buff):
			self.buff = self.next_line()
			self.index = 0
		val = self.buff[self.index]
		self.index += 1
		return val

	def next_line(self):
		return sys.stdin.readline().split()

	def next_ints(self):
		return [int(x) for x in sys.stdin.readline().split()]

	def next_int(self):
		return int(self.next())

	def solve(self):
		(n, m, k) = self.next_ints()
		print('Yes' if m >= n and k >= n else 'No')
Main().solve()


(n, m, k) = map(int, input().split())
r = 0
for i in range(n):
	m -= 1
	k -= 1
	if m < 0 or k < 0:
		r += 1
		break
if r == 1:
	print('NO')
else:
	print('YES')


values = list(map(int, input().split()))
print(['No', 'Yes'][values[0] <= min(values)])


def solve():
	(n, m, k) = input().split(' ')
	n = int(n)
	m = int(m)
	k = int(k)
	if m >= n and k >= n:
		print('Yes')
	else:
		print('No')
while True:
	try:
		solve()
	except Exception as e:
		break


(a, b, c) = list(map(int, input().split()))
if a <= b and a <= c:
	print('Yes')
elif a == 0:
	print('No')
else:
	print('No')


from sys import stdin, stdout
input = stdin.readline

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

def main():
	(n, m, k) = invr()
	people = int(n)
	if int(m) - people < 0 or int(k) - people < 0:
		print('No')
	else:
		print('Yes')
main()


(a, s, d) = map(int, input().split())
if s >= a and d >= a:
	print('YES')
else:
	print('NO')


(i, j, k) = input().split()
i = int(i)
j = int(j)
k = int(k)
if i <= j and i <= k:
	print('Yes')
else:
	print('No')


def Cossack_and_Contest(n, p, b):
	to_return = n <= p and n <= b
	if to_return:
		return 'YES'
	return 'NO'
(n, p, b) = list(map(int, input().strip(' ').split(' ')))
print(Cossack_and_Contest(n, p, b))


from math import ceil

def main():
	(n, m, k) = [int(v) for v in input().split()]
	if k >= n and m >= n:
		print('Yes')
	else:
		print('No')
main()


str = input()
str = str.split(' ')
(n, m, k) = (eval(str[0]), eval(str[1]), eval(str[2]))
if n <= 100 and n >= 1:
	if m <= 100 and m >= 1:
		if k <= 100 and k >= 1:
			print('Yes') if n <= m and n <= k else print('No')


(n, m, l) = map(int, input().split())
if m >= n:
	if l >= n:
		print('Yes')
	else:
		print('No')
else:
	print('No')


listy = list(map(int, input().split()))
n = listy[0]
p = listy[1]
note = listy[2]
if n <= p:
	if n <= note:
		print('yes')
	else:
		print('no')
else:
	print('no')


def awards(n, m, k):
	if n > m or n > k:
		return 'NO'
	return 'YES'
x = list(map(int, input().rstrip().split()))
n = x[0]
m = x[1]
k = x[2]
print(awards(n, m, k))


def solution():
	inputs = str(input())
	inputs = inputs.split()
	n = int(inputs[0])
	m = int(inputs[1])
	k = int(inputs[2])
	n_pair = min(m, k)
	if n <= n_pair:
		print('Yes')
	else:
		print('No')
solution()


class CodeforcesTask1186ASolution:

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

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

	def process_task(self):
		self.result = 'Yes' if self.n_m_k[0] <= min(self.n_m_k[1], self.n_m_k[2]) else 'No'

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


import sys
import math
input = sys.stdin.readline

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

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

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

def invr():
	return map(int, input().split())
(n, m, k) = invr()
if min(m, k) >= n:
	print('YES')
else:
	print('NO')


import time

def distributePensNotebooks(people, pens, nbooks):
	if pens >= people and nbooks >= people:
		return 'Yes'
	else:
		return 'No'

def solve():
	(people, pens, nbooks) = [int(x) for x in input().split()]
	print(distributePensNotebooks(people, pens, nbooks))
solve()


def compare(p, k):
	if p - k >= 0:
		return int(k)
	else:
		return p
(n, p, k) = map(int, input().split())
result = compare(p, k)
if result - n >= 0:
	print('YES')
else:
	print('NO')


l = list(map(lambda x: int(x), input().split()))
n = l[0]
pens = l[1]
notebooks = l[2]
if pens >= n and notebooks >= n:
	print('Yes')
else:
	print('No')


def main():
	(n, m, k) = tuple([int(num) for num in input().split()])
	if n > m or n > k:
		print('No')
	else:
		print('Yes')
main()


import math
import os
import random
import re
import sys
(a, b, c) = map(int, input().rstrip().split())
if b < a or c < a:
	print('NO')
else:
	print('YES')


import sys
(n, m, k) = list(map(int, sys.stdin.readline().split()))

def vus(n, m, k):
	if m - n >= 0 and k - n >= 0:
		print('Yes')
	else:
		print('No')
vus(n, m, k)


import sys
[n, m, k] = sys.stdin.readline().split(' ')
m = int(m)
n = int(n)
k = int(k)
answer = 'No'
if m >= n and k >= n:
	answer = 'YES'
sys.stdout.writelines(answer)


import sys
(n, m, k) = map(int, input().split())
if n <= min(m, k):
	print('Yes')
else:
	print('No')


(n, m, k) = map(int, input().split())
print(['NO', 'YES'][min(m, k) >= n])


import sys
input = sys.stdin.readline

def inlt():
	return list(map(int, input().split()))
total = inlt()
n = total[0]
m = total[1]
k = total[2]
j = 0
if m >= n:
	j += 1
if k >= n:
	j += 1
if j == 2:
	print('Yes')
else:
	print('No')


def num(n, m, k):
	if n <= m and n <= k:
		return 'Yes'
	return 'No'
(x, y, z) = map(int, input().split(' '))
print(num(x, y, z))


from sys import *
(a, b, c) = list(map(int, stdin.readline().rstrip().split()))
if a <= min(b, c):
	print('Yes')
else:
	print('No')


(n, r, l) = map(int, input().split())
if r >= n and l >= n:
	print('Yes')
else:
	print('No')


(contestants, pens, notebooks) = list(map(int, input().split()))
if pens >= contestants and notebooks >= contestants:
	print('Yes')
else:
	print('No')


import sys
(n, m, k) = [int(elem) for elem in sys.stdin.readline().split()]
if m >= n and k >= n:
	print('Yes')
else:
	print('No')


list_ = list(map(int, input().split()))
n = list_[0]
m = list_[1]
k = list_[2]
pen_books = min(m, k)
if n > pen_books:
	print('NO')
else:
	print('YES')


input_string = input()
userList = input_string.split()
results = list(map(int, userList))
if results[1] >= results[0] and results[2] >= results[0]:
	print('YES')
else:
	print('NO')


(a, b, c) = map(int, input().split())
print(['no', 'yes'][a <= b and a <= c])


gi = lambda : list(map(int, input().strip().split()))
(n, m, k) = gi()
print('YNEOS'[min(k, m) < n::2])


(n, m, k) = list(map(int, input().split()))
if m / n >= 1 and k / n >= 1:
	print('YES')
else:
	print('NO')


b = list(input().split(' '))
if int(b[1]) >= int(b[0]) and int(b[2]) >= int(b[0]):
	print('Yes')
else:
	print('No')


(n, b, k) = [int(x) for x in input().split()]
if b - n >= 0 and k - n >= 0:
	print('YES')
else:
	print('NO')


import math
import cmath
from decimal import *
from fractions import *
(n, m, k) = map(int, input().split())
if min(m, k) < n:
	print('No')
else:
	print('Yes')


(a, b, c) = list(map(int, input().strip().split()))
if a <= b and a <= c:
	print('yes')
else:
	print('No')


from sys import stdin, stdout

def input():
	return stdin.readline()

def print(x, end='\n'):
	return stdout.write(str(x) + str(end))
(n, m, k) = map(int, input().split())
if m >= n and k >= n:
	print('YES')
else:
	print('NO')


def main():
	(participants, pens, notebooks) = map(int, input().split())
	if pens >= participants and notebooks >= participants:
		print('Yes')
	else:
		print('No')
main()


a = [int(x) for x in input().split()]
print('yes' if a[0] <= a[1] and a[0] <= a[2] else 'no')


arr = [int(num) for num in input().split()]
if arr[0] <= arr[1] and arr[0] <= arr[2]:
	print('Yes')
else:
	print('No')


user_input = list(map(int, input().split()))
n = user_input[0]
m = user_input[1]
k = user_input[2]
if m >= n and k >= n:
	print('yes')
else:
	print('no')


(x, y, z) = list(map(int, input().strip().split()))
if x <= y and x <= z:
	print('Yes')
else:
	print('No')


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, queue, copy
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

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

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

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

def LS():
	return sys.stdin.readline().split()

def S():
	return input()

def main():
	(a, b, c) = LI()
	if a <= b and a <= c:
		return 'Yes'
	return 'No'
print(main())


import math
arr = list(map(int, input().strip().split(' ')))
if arr[0] <= arr[1] and arr[0] <= arr[2]:
	print('Yes')
else:
	print('No')


(n, m, k) = map(int, input().split())
print('nyoe s'[n <= min(m, k)::2])


import sys
import math
import bisect

def main():
	(a, b, c) = map(int, input().split())
	if b >= a and c >= a:
		print('Yes')
	else:
		print('No')
main()


(n, b, c) = map(int, input().split())
if n <= min(b, c):
	print('yes')
else:
	print('no')


(pe, p, b) = map(int, input().split())
if p - pe >= 0 and b - pe >= 0:
	print('Yes')
else:
	print('No')


string = input()
li = string.split(' ')
n = int(li[0])
m = int(li[1])
k = int(li[2])
if k >= n and m >= n:
	print('Yes')
else:
	print('No')


def isPossibleToRewardAllParticipants(input):
	if input[1] < input[0] or input[2] < input[0]:
		return 'No'
	return 'Yes'
input = list(map(int, input().split()))
print(isPossibleToRewardAllParticipants(input))


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

def ss():
	return [x for x in input()]

def si():
	return [int(x) for x in input().split()]

def mi():
	return map(int, input().split())
(a, b, c) = mi()
if a <= b and a <= c:
	print('YES')
else:
	print('NO')


import sys, math

def read_int():
	return int(sys.stdin.readline().strip())

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

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

def read_string_list(delim=' '):
	return sys.stdin.readline().strip().split(delim)

def print_list(l):
	print(' '.join(map(str, l)))
(n, m, k) = read_int_list()
if n > min(m, k):
	print('NO')
else:
	print('YES')


while True:
	try:
		(n, m, k) = map(lambda x: int(x), input('').split())
		if m >= n and k >= n:
			print('Yes')
		else:
			print('No')
	except:
		break


q = lambda : map(int, input().split())
(n, m, k) = q()
print('Yes' if n == min(n, m, k) else 'No')


(a, b, c) = input().split()
a = int(a)
b = int(b)
c = int(c)
ok = 1
if a > b:
	ok = 0
if a > c:
	ok = 0
print(['No', 'Yes'][ok])


import sys

def eprint(*args, **kwargs):
	if __debug__:
		print(*args, file=sys.stderr, **kwargs)
(n, m, k) = map(int, input().split(' '))
if m >= n and k >= n:
	print('Yes')
else:
	print('No')


(n, m, k) = map(int, input().split())
if m >= n and k >= n:
	print('YES')
	exit(0)
print('NO')


try:
	(n, m, k) = map(int, input().split())
	if n <= m and n <= k:
		print('Yes')
	else:
		print('No')
except Exception:
	pass


a = list(map(int, input().split()))
participant = a[0]
pen = a[1]
notebook = a[2]
if pen >= participant and notebook >= participant:
	print('Yes')
else:
	print('No')


import sys
import math
from collections import defaultdict, deque
input = sys.stdin.readline

def inar():
	return [int(el) for el in input().split()]

def main():
	t = 1
	for _ in range(t):
		(n, m, k) = inar()
		if n <= min(m, k):
			print('Yes')
		else:
			print('No')
main()