Imp is watching a documentary about cave painting. [Image] 

Some numbers, carved in chaotic order, immediately attracted his attention. Imp rapidly proposed a guess that they are the remainders of division of a number n by all integers i from 1 to k. Unfortunately, there are too many integers to analyze for Imp.

Imp wants you to check whether all these remainders are distinct. Formally, he wants to check, if all $n \text{mod} i$, 1 ≤ i ≤ k, are distinct, i. e. there is no such pair (i, j) that:   1 ≤ i < j ≤ k,  $n \operatorname{mod} i = n \operatorname{mod} j$, where $x \operatorname{mod} y$ is the remainder of division x by y. 


-----Input-----

The only line contains two integers n, k (1 ≤ n, k ≤ 10^18).


-----Output-----

Print "Yes", if all the remainders are distinct, and "No" otherwise.

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


-----Examples-----
Input
4 4

Output
No

Input
5 3

Output
Yes



-----Note-----

In the first sample remainders modulo 1 and 4 coincide.

Difficulty: MEDIUM_HARD
Tags: Number theory

Complete search
Skill types: Complete search

Starter code:

Solutions:
from math import sqrt, pow, ceil
from decimal import *
l1 = input().split()
l1 = [int(i) for i in l1]
x = l1[0]
y = l1[1]
for i in range(1, y + 1):
	if x % i != i - 1:
		print('No')
		exit()
print('Yes')


from fractions import gcd

def lcm(a, b):
	return a // gcd(a, b) * b
(n, k) = map(int, input().split())
if k == 1:
	print('Yes')
	exit()
n1 = 1
for i in range(1, k + 1):
	n1 = lcm(n1, i)
	if n % n1 == n1 - 1 and i == k:
		print('Yes')
		exit()
	if n1 - 1 > n:
		print('No')
		exit()
print('No')


(n, k) = list(map(int, input().split()))
d = {}
pos = False
for i in range(1, k + 1):
	r = n % i
	try:
		d[r] += 1
		if d[r] > 1:
			print('No')
			pos = True
			break
	except:
		d[r] = i
	if i > int(10000000.0):
		print('No')
		break
if not pos:
	print('Yes')


(h, m) = list(map(int, input().split()))
if h <= m and h != 1 and (m != 1):
	print('NO')
else:
	r = 'YES'
	for i in range(1, m + 1):
		if h % i != i - 1:
			r = 'NO'
			break
	print(r)


(n, k) = map(int, input().split())
a = [0] * 100
for i in range(1, k + 1):
	a[n % i] += 1
	if a[n % i] > 1:
		print('NO')
		exit(0)
print('YES')


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

def lcm(a, b):
	return a * b // gcd(a, b)
(n, k) = map(int, input().strip().split(' '))
if k > 43:
	print('No')
else:
	p = 1
	for i in range(1, k + 1):
		p = lcm(p, i)
	if (n + 1) % p == 0:
		print('Yes')
	else:
		print('No')


from sys import stdin, stdout
(n, k) = map(int, input().split())
print(['Yes', 'No'][any(((n + 1) % i for i in range(2, k + 1)))])


a = [int(q) for q in input().strip().split()]
b = []
t = 0
for k in range(1, a[1] + 1):
	b.append(a[0] % k)
	if len(b) != len(list(set(b))):
		print('No')
		t = 1
		break
if t == 0:
	print('Yes')


(n, k) = map(int, input().split())
s = set()
for i in range(1, k + 1):
	cur = n % i
	if cur in s:
		print('No')
		exit()
	s.add(cur)
print('Yes')


def remainderSet(n, k):
	rem = set()
	for i in range(1, k + 1):
		r = n % i
		if r in rem:
			return False
		else:
			rem.add(r)
	return True

def test():
	print(remainderSet(4, 4))
	print(remainderSet(5, 3))

def nia():
	s = input()
	while len(s) == 0:
		s = input()
	s = s.split()
	iVal = []
	for i in range(len(s)):
		iVal.append(int(s[i]))
	return iVal

def solve():
	arr = nia()
	if remainderSet(arr[0], arr[1]):
		print('Yes')
	else:
		print('No')
solve()


from collections import *
(n, k) = input().split()
n = int(n)
k = int(k)
cnt = Counter()
a = min(k + 1, 100005)
fl = 1
for i in range(1, a):
	if cnt[n % i] != 0:
		fl = 0
		break
	else:
		cnt[n % i] = 1
if fl:
	print('Yes\n')
else:
	print('No\n')


(n, k) = [int(i) for i in input().split()]
if k > 100:
	print('No')
else:
	x = set()
	for i in range(1, k + 1):
		x.add(n % i)
	if len(x) != k:
		print('No')
	else:
		print('Yes')


(n, k) = map(int, input().split())
if k > 60:
	print('No')
	exit(0)
s = set()
for i in range(1, k + 1):
	s.add(n % i)
if len(s) == k:
	print('Yes')
else:
	print('No')


(n, k) = [int(x) for x in input().split()]
ls = []
flag = True
for i in range(1, k + 1):
	mod = n % i
	if mod in ls:
		flag = False
		print('No')
		break
	ls.append(mod)
if flag:
	print('Yes')


(n, k) = list(map(int, input().split()))
ps = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43]

def LCM():
	lcm = 1
	for p in ps:
		max_p = 0
		while p ** max_p <= k:
			max_p += 1
		max_p -= 1
		lcm *= p ** max_p
		if lcm > 10 ** 18:
			return -1
	return lcm

def f():
	if k > 200:
		return False
	for i in range(2, k + 1):
		if n % i != i - 1:
			return False
	return True
if f():
	print('Yes')
else:
	print('No')


(n, k) = map(int, input().split())
if n == 1:
	if k <= 2:
		print('YES')
	else:
		print('NO')
elif k >= n:
	print('NO')
else:
	d = set()
	x = True
	for i in range(1, k + 1):
		if n % i in d:
			x = False
			break
		else:
			d.add(n % i)
	if x:
		print('YES')
	else:
		print('NO')


import math
import sys

def lcm(u, v):
	return u * v // math.gcd(u, v)

def main():
	(n, k) = list(map(int, input().split()))
	m = 1
	for i in range(1, k + 1):
		m = lcm(m, i)
		if m - 1 > n:
			print('No')
			return
	if (n + 1) % m == 0:
		print('Yes')
	else:
		print('No')

def __starting_point():
	main()
__starting_point()


import os
import sys
from io import BytesIO, IOBase

def main():
	(n, k) = map(int, input().split())
	s = set()
	for i in range(1, k + 1):
		if n % i in s:
			print('No')
			exit(0)
		s.add(n % i)
	print('Yes')
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')
main()


def first_fail(n):
	assert n >= 2
	was = set()
	for k in range(1, n + 1):
		mod = n % k
		if mod in was:
			return k
		was.add(mod)
	assert False, n

def solve(n, k):
	if n == 1:
		return k <= 2
	return k < first_fail(n)
(n, k) = [int(v) for v in input().split()]
print(['No', 'Yes'][solve(n, k)])


(n, k) = list(map(int, input().split()))
c = 1
z = 1
ok = 1
for i in range(1, k + 1):
	c = z
	while z % i != 0:
		z += c
	if z > n + 10:
		ok = 0
		break
if (n + 1) % z == 0 and ok:
	print('Yes')
else:
	print('No')


import sys
f = sys.stdin
(n, k) = map(int, f.readline().split())
ans = 'Yes'
for tk in range(1, k + 1):
	if len(set((n % (i + 1) for i in range(tk)))) != tk:
		ans = 'No'
		break
print(ans)


(n, k) = map(int, input().split())
rs = set()
for i in range(1, k + 1):
	r = n % i
	if r in rs:
		print('No')
		exit(0)
	rs.add(r)
print('Yes')


(n, k) = map(int, input().strip().split())
if k == 1:
	print('Yes')
elif k > 50000:
	print('No')
else:
	rems = [n % i for i in range(1, k + 1)]
	print('Yes' if len(set(rems)) == len(rems) else 'No')


(n, k) = map(int, input().split())
box = []
for i in range(1, k + 1):
	r = n % i
	if r in box:
		print('No')
		break
	else:
		box.append(r)
else:
	print('Yes')


(n, k) = map(int, input().split())
for i in range(1, min(k + 1, 101)):
	if (n + 1) % i != 0:
		print('No')
		exit()
print('Yes')


values = input()
(n, k) = values.split()
n = int(n)
k = int(k)
old = 0
distinct = True
for i in range(1, k + 1):
	res = n % i
	if res != old:
		print('No')
		distinct = False
		break
	old = i
if distinct:
	print('Yes')


(n, k) = list(map(int, input().split()))
l = []
c = 0
for i in range(1, k + 1):
	l.append(n % i)
	p = set(l)
	if len(p) != len(l):
		print('No')
		c = 1
		break
if c == 0:
	print('Yes')


(n, k) = map(int, input().strip().split())
primes = []
isP = [True] * 1000005
for i in range(3, 1000005, 2):
	if isP[i]:
		primes.append(i)
		for j in range(i * i, 1000005, 2 * i):
			isP[j] = False
seen = {}
if k == 1:
	print('Yes')
	exit(0)
if n == 1:
	if k > 2:
		print('No')
	else:
		print('Yes')
	exit(0)
if k >= n:
	print('No')
elif n % 2 == 0:
	if k > 1:
		print('No')
	else:
		print('Yes')
else:
	f = True
	if k <= 10 ** 6:
		for i in range(1, k + 1):
			x = n % i
			if x in seen:
				f = False
				break
			seen[x] = True
		if f:
			print('Yes')
		else:
			print('No')
		exit(0)
	for p in primes:
		if p > k:
			break
		x = n % p
		if x in seen:
			f = False
			break
		seen[x] = True
	if f:
		print('Yes')
	else:
		print('No')


seen = set()
(n, k) = map(int, input().split())
for x in range(1, k + 1):
	r = n % x
	if r in seen:
		print('No')
		exit()
	else:
		seen.add(r)
print('Yes')


[n, k] = list(map(int, input().split()))
if k == 1:
	print('YES')
elif n % 2 == 0:
	print('NO')
elif k <= 2:
	print('YES')
else:
	flag = 0
	rem = {}
	for i in range(1, min(k + 1, 100000)):
		try:
			rem[n % i]
		except:
			rem[n % i] = 0
		rem[n % i] += 1
		if rem[n % i] > 1:
			flag = 1
			break
	if flag:
		print('NO')
	else:
		print('YES')


(a, b) = map(int, input().split())
s = set()
for i in range(1, b + 1):
	x = a % i
	if not x in s:
		s.add(x)
	else:
		print('No')
		break
else:
	print('Yes')


def test(n, k):
	a = set()
	for i in range(1, min(100000, k + 1)):
		if n % i in a:
			return i
		a.add(n % i)
	return 0
(n, k) = map(int, input().strip().split(' '))
print('Yes' if test(n, k) == 0 else 'No')


(n, k) = map(int, input().split())
if k > 70:
	print('NO')
	exit(0)
s = set()
for i in range(1, k + 1):
	if n % i in s:
		print('NO')
		exit(0)
	s.add(n % i)
print('YES')


from math import gcd

def main():
	(n, k) = map(int, input().split(' '))
	if n == 1 and k <= 2:
		print('YES')
		return
	if n <= k:
		print('NO')
		return
	x = 1
	for i in range(2, k + 1):
		x = x * i // gcd(x, i)
		if x - 1 > n:
			print('NO')
			return
	if n % x == x - 1:
		print('YES')
	else:
		print('NO')
main()


def main():
	(n, k) = map(int, input().split())
	for i in range(1, k + 1):
		if n % i != i - 1:
			print('No')
			return
	print('Yes')
main()


(n, k) = map(int, input().split())
if n == 1 and k == 1:
	print('Yes')
elif n == k:
	print('No')
else:
	flag = True
	for i in range(2, k + 1):
		if n % i != i - 1:
			print('No')
			flag = False
			break
		if i > 10000000:
			flag = True
			break
	if flag == True:
		print('Yes')


import math

def main():
	(n, k) = map(int, input().split())
	if k > 43:
		print('No')
	else:
		lcm = 1
		for i in range(1, k + 1):
			lcm = i * lcm // math.gcd(i, lcm)
		print('Yes' if (n + 1) % lcm == 0 else 'No')
main()


def gcd(x, y):
	while y:
		(x, y) = (y, x % y)
	return x

def lcm(x, y):
	lcm = x * y // gcd(x, y)
	return lcm
(n, k) = map(int, input().split())
x = 1
jmp = 1
for i in range(1, k + 1):
	if jmp > n * 2:
		break
	jmp = lcm(jmp, i)
if n % jmp != jmp - 1:
	print('No')
else:
	print('Yes')


(n, k) = input().split()
(n, k) = (int(n), int(k))
ans = True
n += 1
for i in range(1, min(100, k + 1)):
	if n % i != 0:
		ans = False
if ans:
	print('Yes')
else:
	print('No')


(n, k) = map(int, input().split())
for i in range(1, min(k + 1, 10000000)):
	if n % i != i - 1:
		print('No')
		break
else:
	print('Yes')


(n, k) = list(map(int, input().split()))
ans = 'Yes'
for i in range(2, k + 1):
	if n % i != i - 1:
		ans = 'No'
		break
	elif 1000000.0 < i:
		break
print(ans)


(n, k) = map(int, input().strip().split())
if n == k:
	if n == 1:
		print('Yes')
	else:
		print('No')
	exit(0)
M = {}
for i in range(1, k + 1):
	r = n % i
	if r in M:
		print('No')
		exit(0)
	M[r] = 1
print('Yes')


(n, k) = map(int, input().split())
if k > 42:
	print('No')
else:
	s = set()
	for i in range(1, k + 1):
		s.add(n % i)
	if len(s) == k:
		print('Yes')
	else:
		print('No')


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

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

def lcmn(n):
	a = [i + 1 for i in range(n)]
	b = a[0]
	for i in range(1, n):
		b = lcm(b, a[i])
	return b
(n, k) = list(map(int, input().strip().split()))
if k >= 43:
	print('No')
elif (n + 1) % lcmn(k) == 0 or k == 1:
	print('Yes')
else:
	print('No')


(n, k) = map(int, input().split())
n += 1
for i in range(2, k + 1):
	if n % i != 0:
		print('no')
		break
else:
	print('yes')


(n, k) = map(int, input().split())
print(['Yes', 'No'][any(((n + 1) % i for i in range(2, k + 1)))])


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

def solve(n, k):
	if k == 1 and n == 1:
		return True
	if k == 2 and n == 1:
		return True
	if k >= n:
		return False
	hist = {}
	for i in range(1, k + 1):
		if n % i in hist:
			return False
		hist[n % i] = True
	return True
print('Yes' if solve(n, k) else 'No')


def main():
	(n, k) = [int(x) for x in input().split()]
	x = 1
	ans = 'YES'
	while x <= k:
		if n % x != x - 1:
			ans = 'NO'
			break
		x += 1
	print(ans)
main()


(n, k) = map(int, input().split())
for i in range(1, k + 1):
	if n % i != i - 1:
		print('No')
		quit()
print('Yes')


import bisect
from itertools import accumulate, count
import os
import sys
import math
from decimal import *
from io import BytesIO, IOBase
from sys import maxsize
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))

def input():
	return sys.stdin.readline().rstrip('\r\n')

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 SieveOfEratosthenes(n):
	prime = []
	primes = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if primes[p] == True:
			prime.append(p)
			for i in range(p * p, n + 1, p):
				primes[i] = False
		p += 1
	return prime

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

def factors(n):
	fac = set()
	fac.add(1)
	fac.add(n)
	for i in range(2, int(math.sqrt(n)) + 1):
		if n % i == 0:
			fac.add(i)
			fac.add(n // i)
	return list(fac)

def modInverse(a, m):
	m0 = m
	y = 0
	x = 1
	if m == 1:
		return 0
	while a > 1:
		q = a // m
		t = m
		m = a % m
		a = t
		t = y
		y = x - q * y
		x = t
	if x < 0:
		x = x + m0
	return x
(n, k) = map(int, input().split())
if k > 70:
	print('No')
else:
	s = set()
	for i in range(1, k + 1):
		s.add(n % i)
	if len(s) == k:
		print('Yes')
	else:
		print('No')


def gcd(a, b):
	while min(a, b):
		if a > b:
			(a, b) = (b, a)
		b %= a
	return max(a, b)

def lcm(a, b):
	return a * b // gcd(a, b)
(n, k) = map(int, input().split())
if k > 50:
	print('no')
else:
	for i in range(1, k + 1):
		for j in range(i + 1, k + 1):
			if n % i == n % j:
				print('no')
				exit()
	print('yes')


(n, k) = map(int, input().split())
c = set()
for i in range(1, min(k + 1, 1000000)):
	x = n % i
	if n % i in c:
		print('No')
		break
	c.add(n % i)
else:
	print('Yes')


import sys
(n, k) = map(int, input().split())
n += 1
for i in range(1, k + 1):
	if n % i > 0:
		print('No')
		sys.exit()
print('Yes')


(a, b) = map(int, list(input().split(' ')))
hasno = False
for i in range(1, b + 1):
	if a % i != i - 1:
		print('NO')
		hasno = True
		break
if not hasno:
	print('YES')


(n, k) = map(int, input().split())
s = set()
for i in range(1, k + 1):
	x = n % i
	if x in s:
		print('NO')
		quit()
	s.add(x)
print('YES')


import math
(n, k) = [int(x) for x in input().split()]
lc = []
gc = []
lc.append(1)
l = 1
i = 2
while l <= 1e+18:
	l = i * l // math.gcd(i, l)
	if l <= 1e+18:
		lc.append(l)
	i += 1
s = len(lc)
if k > s:
	print('No')
elif (n + 1) % lc[k - 1] == 0:
	print('Yes')
else:
	print('No')


def gcd(x, y):
	if y == 0:
		return x
	return gcd(y, x % y)

def lcm(x, y):
	return x // gcd(x, y) * y
a = input().split()
(n, k) = (int(a[0]), int(a[1]))
ans = 1
for x in range(1, k + 1):
	ans = lcm(ans, x)
	if ans > n + 1:
		print('No')
		exit(0)
if (n + 1) % ans == 0:
	print('Yes')
else:
	print('No')


(n, k) = [int(x) for x in input().split()]
leftOver = list()
tmp = 0
for i in range(1, k + 1, 1):
	tmp = n % i
	if tmp not in leftOver:
		leftOver.append(tmp)
	else:
		i = -1
		break
if i == k:
	print('Yes')
else:
	print('No')


(n, k) = map(int, input().split())
if k == 1:
	print('Yes')
else:
	if k >= 43:
		print('No')
		exit(0)
	for i in range(2, k + 1):
		if n % i != i - 1:
			print('No')
			exit(0)
	print('Yes')


(n, k) = map(int, input().split())
if k > 43:
	print('No')
else:
	a = set()
	for x in range(1, k + 1):
		a.add(n % x)
	if len(a) == k:
		print('Yes')
	else:
		print('No')


(n, k) = map(int, input().split())
mods = []
for i in range(1, k + 1):
	mod = n % i
	if mod in mods:
		print('No')
		raise SystemExit
	else:
		mods.append(mod)
print('Yes')


(n, k) = map(int, input().split())
vetor = [0] * 1000
boolean = 0
for i in range(1, k + 2):
	vetor[i] = i
	if boolean == 1:
		print('No')
		exit()
	cont = 2
	while cont < i:
		if n % vetor[i] == n % vetor[cont]:
			boolean = 1
			break
		cont += 1
print('Yes')


from collections import defaultdict as dd
(n, k) = [int(i) for i in input().split()]
if n % 2 == 0 and k > 1:
	print('No')
elif n % 2 == 0 and k == 1:
	print('Yes')
else:
	flag = 0
	dic = dd(int)
	for i in range(1, k + 1):
		if dic[n % i] == 1:
			flag = 1
			break
		else:
			dic[n % i] = 1
	if flag == 1:
		print('No')
	else:
		print('Yes')


ost = {}
stop = False
(n, k) = map(int, input().split(' '))
for i in range(k):
	try:
		x = ost[n % (i + 1)]
		stop = True
		break
	except:
		ost[n % (i + 1)] = 0
if stop:
	print('No')
else:
	print('Yes')


(n, k) = map(int, input().split())
if k > 100000:
	print('No')
else:
	ans = True
	for i in range(2, k + 1):
		ans &= n % i == i - 1
	print('Yes' if ans else 'No')


(n, k) = map(int, input().split())
print('No' if any((n % i != i - 1 for i in range(1, k + 1))) else 'Yes')


(n, k) = map(int, input().split())
if k >= n and n != 1:
	print('No')
elif n & 1 == 0:
	if k == 1:
		print('Yes')
	else:
		print('No')
else:
	s = {}
	f = 0
	for i in range(1, k + 1):
		if n % i not in s:
			s[n % i] = 1
		else:
			f = 1
			print('No')
			break
	if not f:
		print('Yes')


from sys import stdin, stdout
from math import gcd
(n, k) = map(int, input().split())
n += 1
for i in range(2, k + 1):
	if n % i != 0:
		print('no')
		exit()
print('yes')


(n, k) = input().split()
n = int(n)
k = int(k)
if n < 0 or k < 0:
	pass
else:
	rem = []
	found = False
	for i in range(1, k + 1):
		check = n % i
		if check in rem:
			print('No\n')
			found = True
			break
		rem.append(check)
	if not found:
		print('Yes\n')


(n, k) = map(int, input().split())
d = []
flag = 0
for i in range(1, k + 1):
	if n % i in d:
		flag = 1
		break
	d += [n % i]
if flag == 0:
	print('Yes')
else:
	print('No')


(n, k) = tuple(map(int, input().split()))
alre = set()
i = 1
count = 0
while True:
	r = n % i
	if r in alre:
		break
	alre.add(r)
	count += 1
	i += 1
print('Yes' if count >= k else 'No')


(n, k) = map(int, input().split())
l = []
c = 0
for i in range(1, k + 1):
	if n % i not in l:
		l.append(n % i)
	else:
		print('No')
		c = 1
		break
if c == 0:
	print('Yes')


(n, k) = [int(x) for x in input().split()]
ost = set()
i = 1
f = True
while i <= k:
	if n % i not in ost:
		ost.add(n % i)
		i += 1
	else:
		f = False
		break
if f:
	print('Yes')
else:
	print('No')


def func(n, k):
	lst = []
	for i in range(1, k + 1):
		a = n % i
		if a not in lst:
			lst.append(a)
		else:
			return 'No'
	return 'Yes'
(n, k) = map(int, input().split())
print(func(n, k))


s = set()
(a, b) = map(int, input().split())
for i in range(1, b + 1):
	if a % i in s:
		exit(print('No'))
	s.add(a % i)
print('Yes')


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

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

def solve(n, k):
	l = 1
	for i in range(1, k + 1):
		l = lcm(l, i)
		if l > n + 1:
			return False
	return (n + 1) % l == 0

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


(n, k) = map(int, input().split())
d = dict()
maxi = 1
for i in range(1, k + 1):
	try:
		if d[n % i]:
			break
	except:
		d[n % i] = 1
		maxi = i
if k <= maxi:
	print('Yes')
else:
	print('No')


(n, k) = map(int, input().split())
mas = []
for i in range(1, k + 1):
	q = n % i
	if q in mas:
		print('No')
		return
	else:
		mas.append(q)
print('Yes')


(n, k) = map(int, input().split())
list = []
for a in range(1, k + 1):
	w = n % a
	if w in list:
		print('NO')
		q = 1
		break
	else:
		list.append(w)
		q = 0
if q == 0:
	print('YES')


arr = [int(x) for x in input().split()]
n = arr[0]
k = arr[1]
flag = False
if k == 1:
	print('Yes')
elif n % 2 == 0:
	print('No')
else:
	for i in range(1, k + 1):
		if flag:
			break
		for j in range(2, i):
			if n % i == n % j:
				flag = True
				break
	resp = 'No' if flag else 'Yes'
	print(resp)


def mcd(m, n):
	if n == 0:
		return m
	else:
		return mcd(n, m % n)

def lcm(m, n):
	return m * (n // mcd(m, n))

def recursive_lcm(top_val):
	result = 1
	alter_index = 1
	while result <= top_val:
		result = lcm(result, alter_index + 1)
		alter_index += 1
	return alter_index

def main():
	[n, k] = [int(x) for x in input('').split()]
	max_k = recursive_lcm(10 ** 18)
	dict = {}
	if k < max_k:
		max_k = k
	for i in range(1, max_k + 1):
		try:
			dict[n % i]
		except Exception as e:
			dict[n % i] = True
		else:
			if dict[n % i]:
				print('No')
				return None
			else:
				pass
	print('Yes')
	return None
main()


def gcd(x, y):
	while y:
		(x, y) = (y, x % y)
	return x
(n, k) = list(map(int, input().split(' ')))
if k > 42:
	print('No')
else:
	x = 1
	for i in range(1, k + 1):
		x = x * i // gcd(x, i)
	if (n + 1) % x == 0:
		print('Yes')
	else:
		print('No')


(n, k) = [int(x) for x in input().split()]
ans = True
for i in range(1, min([k + 1, 201])):
	if n % i != i - 1:
		ans = False
print('Yes' if ans else 'No')


(n, k) = [int(i) for i in input().split()]
f = []
t = True
for i in range(1, k + 1):
	if n % i in f:
		t = False
		break
	else:
		f.append(n % i)
if t:
	print('Yes')
else:
	print('No')


import sys
word = input().split(' ')
(n, k) = (int(word[0]), int(word[1]))
capture = set()
for i in range(1, k + 1):
	rem_n = n % i
	if rem_n in capture:
		print('No')
		exit(0)
	else:
		capture.add(rem_n)
if len(capture) != 0:
	print('Yes')
	exit(0)
else:
	exit(1)


(n, k) = map(int, input().split())
if k > 50:
	print('No')
	quit()
rems = set((n % x for x in range(1, k + 1)))
print(['No', 'Yes'][len(rems) == k])


import sys

def gcd(a, b):
	if a % b == 0:
		return b
	else:
		return gcd(b, a % b)
(n, k) = [int(x) for x in sys.stdin.readline().split()]
m = 1
n += 1
can = True
for i in range(2, k + 1):
	m = m * i // gcd(m, i)
	if m > n or n % m != 0:
		can = False
		break
if can:
	sys.stdout.write('Yes\n')
else:
	sys.stdout.write('No\n')


(n, k) = map(int, input().split())
i = 1
while i <= k:
	if n % i != i - 1:
		print('No')
		break
	i += 1
else:
	print('Yes')


(n, k) = map(int, input().split())
ss = set()
ans = 'Yes'
for i in range(1, k + 1):
	s = n % i
	if s not in ss:
		ss.add(s)
	else:
		ans = 'No'
		break
print(ans)


def main():
	inp = input().split()
	n = int(inp[0])
	k = int(inp[1])
	mySet = set()
	for i in range(1, k + 1):
		rem = n % i
		if rem in mySet:
			print('No')
			exit(0)
		mySet.add(rem)
	print('Yes')
main()


intro = input().split(' ')
n = int(intro[0])
k = int(intro[1])
if n % 2 == 0:
	if k == 1:
		print('Yes')
	else:
		print('No')
else:
	aux = list()
	answer = True
	for i in range(1, k + 1):
		if aux.count(n % i) > 0:
			answer = False
			break
		else:
			aux.append(n % i)
	if answer:
		print('Yes')
	else:
		print('No')


(n, k) = map(int, input().split())
if n == 1 or k == 1:
	if n == 1 and k == 1:
		print('Yes')
	elif n == 1:
		if k > 2:
			print('No')
		else:
			print('Yes')
	else:
		print('Yes')
elif k >= n:
	print('No')
else:
	i = 1
	while i <= k and n % i == i - 1:
		i += 1
	if i == k + 1:
		print('Yes')
	else:
		print('No')


(n, k) = map(int, input().strip().split(' '))
if k == 1 or (n == 1 and k <= 2):
	print('YES')
elif k >= n:
	print('NO')
else:
	i = 1
	while i <= k and n % i == i - 1:
		i = i + 1
	if i == k + 1:
		print('YES')
	else:
		print('NO')


import sys
(n, k) = map(int, input().split())
if k > 100:
	print('No')
	sys.exit()
st = []
for i in range(1, k + 1):
	st.append(n % i)
if len(set(st)) == k:
	print('Yes')
else:
	print('No')


s = input()
s = s.split()
n = int(s[0])
k = int(s[1])
b = 1
a = []
for i in range(1, k + 1):
	c = n % i
	a.append(c)
	if c in a[:-1]:
		print('No')
		b = 0
		break
if b == 1:
	print('Yes')


(N, K) = map(int, input().split())
if K == 1:
	print('Yes')
elif K >= 50:
	print('No')
else:
	N += 1
	flag = True
	for i in range(2, K + 1):
		if N % i != 0:
			flag = False
			break
	if flag:
		print('Yes')
	else:
		print('No')


(n, k) = [int(n) for n in input().split()]
s = set()
if k >= 10 ** 5:
	print('No')
	exit()
for i in range(1, k + 1):
	s.add(n % i)
if len(s) == k:
	print('Yes')
else:
	print('No')


(n, k) = map(int, input().split())
flag = True
for x in range(1, k + 1):
	flag &= n % x == x - 1
	if not flag:
		break
if flag:
	print('Yes')
else:
	print('No')


(n, k) = map(int, input().split())
if k == 1:
	print('Yes')
elif n == 1:
	if k <= 2:
		print('Yes')
	else:
		print('No')
elif k >= n:
	print('No')
elif n % 2 == 0:
	print('No')
else:
	ans = 0
	rem = [0] * 100010
	for i in range(1, 100002):
		if rem[n % i] == 0:
			ans += 1
			rem[n % i] = 1
		else:
			break
	if ans >= k:
		print('Yes')
	else:
		print('No')


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

def lcm(a, b):
	return a // gcd(a, b) * b
(n, k) = list(map(int, input().split()))
inf = 10 ** 18
x = 1
for i in range(1, k + 1):
	x = lcm(x, i)
	if x > inf:
		break
if x > inf or n % x != x - 1:
	print('No')
else:
	print('Yes')


(n, k) = map(int, input().split(' '))
if n % 2 == 0:
	if k == 1:
		print('Yes')
	else:
		print('No')
elif n % 4 == 1:
	if n % 2 == n % 3 or n % 3 == 0:
		if k <= 2:
			print('Yes')
		else:
			print('No')
	elif k <= 3:
		print('Yes')
	else:
		print('No')
elif n % 6 == 1 or n % 6 == 3:
	if k <= 2:
		print('Yes')
	else:
		print('No')
elif n % 5 != 4:
	if k <= 3:
		print('Yes')
	else:
		print('No')
else:
	for i in range(1, k + 1):
		if n % i != i - 1:
			i -= 1
			break
	if i == k:
		print('Yes')
	else:
		print('No')


def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)
(n, k) = list(map(int, input().split()))
l = 1
if k <= 100:
	for i in range(1, k + 1):
		l = l * i // gcd(l, i)
	p = l
	l = l - 1
	if n < l:
		print('NO')
	else:
		n = n - l
		if n % p == 0:
			print('YES')
		else:
			print('NO')
else:
	print('NO')


import sys
(n, k) = map(int, sys.stdin.readline().split())
s = set()
for i in range(1, k + 1):
	if n % i in s:
		print('No')
		exit(0)
	s.add(n % i)
print('Yes')


import math as m
(n, k) = map(int, input().split())
d1 = {}
flag = 0
l1 = [k, m.sqrt(10 ** 18)]
c = int(min(l1))
for i in range(1, c + 1, 1):
	a = n % i
	if a in d1.keys():
		flag = 1
		break
	else:
		d1.update({a: i})
if flag == 0:
	print('Yes')
else:
	print('No')


def gcd(x, y):
	if y == 0:
		return x
	return gcd(y, x % y)

def lcm(n):
	ans = 1
	for i in range(1, n + 1):
		ans *= i // gcd(i, ans)
	return ans
(n, k) = map(int, input().split())
if k >= 75:
	print('NO')
elif (n + 1) % lcm(k) == 0:
	print('yes')
else:
	print('no')


(n, k) = input().strip().split()
n = int(n)
k = int(k)
a = {}
for i in range(1, k + 1):
	if n % i in a:
		print('No')
		exit()
	else:
		a[n % i] = 1
print('Yes')


import math

def factorize(n):
	fct = []
	(b, e) = (2, 0)
	while b * b <= n:
		while n % b == 0:
			n = n // b
			e = e + 1
		if e > 0:
			fct.append(b)
		(b, e) = (b + 1, 0)
	if n > 1:
		fct.append(n)
	return fct

def main():
	(n, k) = map(int, input().split())
	if k > 10000:
		print('No')
		exit()
	l = set()
	for i in range(1, k + 1):
		l.add(n % i)
	if len(l) == k:
		print('Yes')
	else:
		print('No')
main()


(a, b) = map(int, input().split())
for i in range(1, b + 1):
	if a % i != i - 1:
		print('No')
		break
else:
	print('Yes')


(n, k) = [int(x) for x in input().split()]
flag = True
for i in range(2, k + 1):
	if (n + 1) % i != 0:
		flag = False
		break
print('yes' if flag else 'no')


(n, k) = [int(x) for x in input().split()]
for i in range(1, k + 1):
	if n % i != i - 1:
		print('No')
		break
else:
	print('Yes')


(n, k) = map(int, input().split())
mod = set()
b = True
for i in range(1, k + 1):
	if n % i in mod:
		b = False
		break
	else:
		mod.add(n % i)
if b:
	print('Yes')
else:
	print('No')


import sys
(m, n) = map(int, input().split())
if n > 43:
	print('no')
	sys.exit()
s = set()
for i in range(1, n + 1):
	s.add(m % i)
print('yes') if len(s) == n else print('no')


from collections import defaultdict, deque, Counter
from sys import stdin, stdout
from heapq import heappush, heappop
import math
import io
import os
import math
import bisect

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 = []
	if n % 2 == 0:
		l.append(2)
	while n % 2 == 0:
		n = n // 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		if n % i == 0:
			l.append(i)
		while n % i == 0:
			n = n // i
	if n > 2:
		l.append(n)
	return 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 sieve(n):
	prime = [True for i in range(n + 1)]
	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 digits(n):
	c = 0
	while n > 0:
		n //= 10
		c += 1
	return c

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

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

def solve(l, r, p):
	return r // p - (l - 1) // p

def y():
	print('Yes')

def no():
	print('No')
(n, k) = mapin()
if k > 100:
	no()
	exit()
d = []
for i in range(1, k + 1):
	d.append(n % i)
if len(set(d)) == k:
	y()
else:
	no()


def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)
(n, k) = map(int, input().split())
sol = True
lcm = 1
for i in range(1, k + 1):
	lcm = lcm * i / gcd(lcm, i)
	if lcm > n + 1:
		sol = False
		break
if int(n + 1) % int(lcm):
	sol = False
if sol:
	print('Yes')
else:
	print('No')


import sys
(n, k) = map(int, sys.stdin.readline().split())
s = set()
ctr = 0
for i in range(1, k + 1):
	s.add(n % i)
	if len(s) != i:
		print('No')
		ctr += 1
		break
if ctr == 0:
	print('Yes')


def fun():
	(n, k) = (int(x) for x in input().split())
	mods = {}
	for i in range(1, k + 1):
		mod = n % i
		if mod in mods:
			print('No')
			return
		else:
			mods[mod] = 1
	print('Yes')
fun()


(n, k) = map(int, input().split())
d1 = {}
flag = 0
for i in range(1, k + 1, 1):
	a = n % i
	if a in d1.keys():
		flag = 1
		break
	else:
		d1.update({a: i})
if flag == 0:
	print('Yes')
else:
	print('No')


def paintings(n, k):
	for i in range(1, k + 1):
		if n % i != i - 1:
			return 'No'
	return 'Yes'
(N, K) = [int(j) for j in input().split()]
print(paintings(N, K))


str = input().split()
n = int(str[0])
k = int(str[1])
map = {}
Limit = min(k, 100000)
ok = 1
for i in range(1, Limit + 1):
	if map.get(n % i, -1) != -1:
		ok = 0
		break
	map[n % i] = 1
if ok:
	print('Yes')
else:
	print('No')


(n, k) = map(int, input().split())
s = set()
for i in range(1, min(1000000, k + 1)):
	r = n % i
	if r in s:
		print('No')
		exit(0)
	else:
		s.add(r)
print('Yes')


(n, k) = map(int, input().split())
dp = dict()
ok = 1
for i in range(1, k + 1):
	if n % i in dp:
		ok = 0
		break
	dp[n % i] = 1
if ok:
	print('Yes')
else:
	print('No')


n = input().split()
(n, k) = (int(n[0]), int(n[1]))
s = 'Yes'
for i in range(1, k + 1):
	if n % i != i - 1:
		s = 'No'
		break
print(s)


(n, k) = map(int, input().split())
if not n & 1 and k != 1:
	print('No')
else:
	d = {}
	(i, f) = (1, True)
	while i <= k:
		if n % i in d:
			f = False
			break
		else:
			d[n % i] = 1
		i += 1
	print('Yes' if f else 'No')


(n, m) = map(int, input().split())
for i in range(2, m + 1):
	if (n + 1) % i != 0:
		print('NO')
		exit()
print('YES')


(n, k) = map(int, input().split())
if k > 800:
	print('No')
else:
	mods = []
	for i in range(1, k + 1):
		mods.append(n % i)
		if mods.count(mods[-1]) > 1:
			print('No')
			break
	else:
		print('Yes')


(n, k) = map(int, input().split())
d = {}
for i in range(1, k + 1):
	c = n % i
	if c in d:
		print('No')
		exit()
	else:
		d[c] = 1
print('Yes')


(n, k) = map(int, input().split())
l = []
for i in range(1, min(k + 1, 100)):
	if n % i in l:
		print('No')
		exit()
	l.append(n % i)
print('Yes')


import sys, math
from itertools import permutations, combinations
from collections import defaultdict, deque
input = sys.stdin.readline
(n, k) = map(int, input().split())
if k >= 43:
	print('No')
else:
	f = 0
	for i in range(1, k + 1):
		if (n + 1) % i != 0:
			f = 1
			break
	print('Yes' if f == 0 else 'No')


(n, k) = [int(i) for i in input().split()]
s = set()
for i in range(1, k + 1):
	if n % i in s:
		print('No')
		break
	s.add(n % i)
else:
	print('Yes')


x = input().split()
(n, k) = (int(x[0]), int(x[1]))
list = [0] * 10000000
f = 0
for i in range(1, k + 1):
	if list[n % i] == 1:
		f = 1
		break
	list[n % i] = 1
if f == 1:
	print('No')
else:
	print('Yes')


(n, k) = map(int, input().split())
for i in range(1, k + 1):
	if n % i != i - 1:
		print('NO')
		exit()
print('YES')


import math
l = input()
n = list()
n = l.split()
for i in range(1, int(n[1]) + 1):
	if int(n[0]) % i != i - 1:
		print('No')
		exit(0)
print('Yes')


numbers = [int(n) for n in input().split()]
(n, k) = numbers
remainders = []
for d in range(1, k + 1):
	res = n % d
	if res not in remainders:
		remainders.append(res)
	else:
		print('No')
		exit()
print('Yes')


import os, sys
from io import BytesIO, IOBase
from math import sqrt, ceil, gcd, log2
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')

def dtb(n):
	return bin(n).replace('0b', '')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def lcm(a, b):
	return a * b // gcd(a, b)
(n, k) = map(int, input().split())
s = set()
for i in range(1, min(50, k) + 1):
	s.add(n % i)
if len(s) == min(50, k):
	print('YES')
else:
	print('NO')


import getpass
import sys
import math

def ria():
	return [int(i) for i in input().split()]
files = True
if getpass.getuser() == 'frohenk' and files:
	sys.stdin = open('test.in')
(n, k) = ria()
if k > 100:
	print('No')
	exit(0)
mp = {}
for i in range(1, k + 1):
	mp[n % i] = 1
if len(mp) == k:
	print('Yes')
else:
	print('No')
sys.stdout.close()


import sys
(n, k) = map(int, input().split())
lis = []
for i in range(1, k + 1):
	if n % i in lis:
		print('No')
		sys.exit()
	else:
		lis.append(n % i)
print('Yes')


(n, k) = map(int, input().split())
ok = True
for i in range(1, 100001):
	if n % i != i - 1 and i <= k:
		ok = False
if ok:
	print('Yes')
else:
	print('No')


import math

def testCase(n, k):
	k = min(k, 100)
	for i in range(2, k + 1):
		r = n % i
		for j in range(1, i):
			if n % j == r:
				return False
	return True

def main():
	(n, k) = [int(x) for x in input().split()]
	print('Yes' if testCase(n, k) else 'No')
main()


(n, k) = input().split(' ')
n = int(n)
k = int(k)
if k == 1:
	print('Yes')
	exit()
elif k >= 2 and n % 2 == 0:
	print('No')
	exit()
else:
	for i in range(1, k + 1):
		a = n % i
		if a == i - 1:
			continue
		else:
			print('No')
			exit()
	print('Yes')


s = input().split()
n = int(s[0])
k = int(s[1])
st = True
mod = []
for i in range(1, k + 1):
	if i > n + 1:
		st = False
		break
	x = n % i
	if x not in mod:
		mod.append(x)
	else:
		st = False
		break
if st:
	print('Yes')
else:
	print('No')


(n, k) = list(map(int, input().split()))
a = set()
for i in range(1, k + 1):
	if n % i in a:
		print('No')
		return
	else:
		a.add(n % i)
print('Yes')


def __starting_point():
	(n, k) = input().strip().split()
	n = int(n)
	k = int(k)
	a = {}
	for i in range(1, k + 1):
		if n % i in a:
			print('No')
			return
		else:
			a[n % i] = 1
	print('Yes')
__starting_point()


from fractions import gcd
(n, k) = list(map(int, input().split()))
for i in range(1, k + 1):
	if n % i != i - 1:
		print('No')
		exit()
print('Yes')


from math import sqrt
(n, k) = map(int, input().split())
remains = set()
ans = True
for i in range(1, k + 1):
	if n % i in remains:
		ans = False
		break
	else:
		remains.add(n % i)
if ans:
	print('Yes')
else:
	print('No')


def gcd(a, b):
	while b != 0:
		(a, b) = (b, a % b)
	return a
(n, k) = map(int, input().split())
cur = 1
if k >= 1000000.0:
	print('NO')
	exit()
for i in range(1, k + 1):
	cur = cur // gcd(cur, i) * i
if cur > n + 1:
	print('No')
	exit()
if (n + 1) % cur == 0:
	print('Yes')
else:
	print('No')


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, heapify
from bisect import bisect_left, bisect_right
import math

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
no = 'NO'
yes = 'YES'

def solve():
	(n, k) = li()
	d = set()
	for i in range(1, k + 1):
		if n % i in d:
			print('NO')
			return
		d.add(n % i)
	print('YES')
t = 1
for _ in range(t):
	solve()


(n, k) = map(int, input().split())
if k > 1000:
	print('No')
else:
	for phibrain_orz in range(1, k + 1):
		if n % phibrain_orz != phibrain_orz - 1:
			print('No')
			exit()
	print('Yes')


from collections import defaultdict, Counter
import os
import sys
from io import BytesIO, IOBase
ii = lambda : int(input())
lmii = lambda : list(map(int, input().split()))
slmii = lambda : sorted(map(int, input().split()))
li = lambda : list(input())
mii = lambda : map(int, input().split())
msi = lambda : map(str, input().split())

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

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

def main():
	(n, k) = mii()
	s = set()
	for i in range(1, k + 1):
		if n % i in s:
			print('No')
			exit(0)
		s.add(n % i)
	print('Yes')
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')
main()


from sys import stdin, stdout
(n, k) = map(int, stdin.readline().split())
sze = 10000
used = [0 for i in range(sze)]
if k <= sze:
	for i in range(1, k + 1):
		used[n % i] += 1
	if max(used) > 1:
		stdout.write('No')
	else:
		stdout.write('Yes')
else:
	stdout.write('No')


(n, k) = map(int, input().split())
ans = 1
if k < 10 ** 5:
	for i in range(1, k + 1):
		if n % i != i - 1:
			ans = 0
			break
else:
	ans = 0
print('Yes' * ans + 'No' * (1 - ans))


(n, k) = map(int, input().split())
if k == 1:
	print('Yes')
elif k > 100:
	print('No')
else:
	c = 1
	for i in range(1, k + 1):
		if (n + 1) % i != 0:
			c = 0
	if c == 1:
		print('Yes')
	else:
		print('No')