Imp is watching a documentary about cave painting.  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 , 1 ≤ i ≤ k, are distinct, i. e. there is no such pair (i, j) that:   1 ≤ i < j ≤ k,  , where  is the remainder of division x by y.

The only line contains two integers n, k (1 ≤ n, k ≤ 1018).

Print "Yes", if all the remainders are distinct, and "No" otherwise. You can print each letter in arbitrary case (lower or upper).

NoteIn the first sample remainders modulo 1 and 4 coincide.

//package home;

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class CavePainting {

	public static void main(String []args) throws Exception{
		BufferedReader br=new BufferedReader(new InputStreamReader (System.in));
		String[]sa=br.readLine().split(" ");
		long n=Long.parseLong(sa[0]);
		long k=Long.parseLong(sa[1]);
		if(k==1 | k==2 & n%2!=0 ) {
			System.out.println("Yes");
		}
		else if(n%2==0 | k>=n) {
			System.out.println("No");
		}
		else{
			boolean ok=true;
			boolean[]freq=new boolean[10000000];
			for(long i=1;i<freq.length & i<=k;i++) {
				if(n%i<freq.length) {
				if(freq[(int)(n%i)]) {
					System.out.println("No");
					ok=false;
					break;
				}
				else {
					freq[(int)(n%i)]=true;
				}
				}
			}
			//
			if(ok)
				System.out.println("Yes");
		}

	}
}

    /*
     * UMANG PANCHAL
     * DAIICT
     */

    import java.util.*;
    import java.io.*;
    import java.math.BigInteger;
    import java.util.Comparator;
    public class Main
    {

    	private static final Comparator<? super Integer> Comparator = null;
    	static LinkedList<Integer> adj[];
    	static ArrayList<Integer> adj1[];
    	static int[] color,visited1;
    	static boolean b[],visited[],possible;
    	static int level[];
    	static Map<Integer,HashSet<Integer>> s;
    	static int totalnodes,colored;
    	static int count[];
    	static long sum[];
    	static int nodes;
    	static long ans=0;
    	static long[] as=new long[10001];
    	static long c1=0,c2=0;
    	static int[] a,d,k;
    	static int max=100000000;
    	static long MOD = (long) (1e9+7),sm=0,m=Long.MIN_VALUE;
    	static boolean[] prime=new boolean[1000005];
    	static int[] levl;
        static int[] eat;
        static int price[];
        static int res[],par[];
        static int result=0;
        static int[] root,size;
        static int[][] K,p;
        static boolean yes = true;
        static long P=Long.MAX_VALUE;
        static int start,end;
    	// --------------------My Code Starts Here----------------------

    	public static void main(String[] args) throws IOException
    	{
    		in=new InputReader(System.in);
    		w=new PrintWriter(System.out);

           long n=nl(),k=nl();
           if(n==1 && k==2)
        	   w.print("yes");
           else if(k>=n && k!=1)
        	   w.print("no");
           else if(k==1)
               w.print("yes");
           else
           {
        	   HashSet<Long> h=new HashSet<Long>();
        	   if(k>10000)
        		   w.print("no");
        	   else
        	   {
        		   for(long i=1;i<=k;i++)
        			   h.add((long)n%i);

        		  // w.println(h.size());
        		   if(k==h.size())
        			   w.print("yes");
        		   else
        			   w.print("no");
        	   }
           }

            w.close();
        }

    	// --------------------My Code Ends Here------------------------

    	/*
    	 *  PriorityQueue<Integer> pq = new PriorityQueue<Integer>(new Comparator<Integer>()
      			{
      				public int compare(Integer o1, Integer o2)
      				{
      					return Integer.compare(o2,o1);
      				}
      			});
    	 *
    	 *
    	 */

    	 public static void buildgraph(int n)
    	 {
             adj=new LinkedList[n];
             visited=new boolean[n];
             level=new int[n];
             par=new int[n];
             for(int i=0;i<n;i++)
             	{
            	 adj[i]=new LinkedList<Integer>();

             	}

    	 }

    	/*public static long kruskal(Pair[] p)
    	{
    		long ans=0;
    		int w=0,x=0,y=0;
    		for(int i=0;i<p.length;i++)
    		{
    			w=p[i].w;
    			x=p[i].x;
    			y=p[i].y;
    			if(root(x)!=root(y))
    			{
    				ans+=w;
    				union(x,y);
    			}
    		}
    		return ans;
    	}*/

    	 static class Pair implements Comparable<Pair>
    	 {
    		int[] a;
    		long ct;
    		long c;

    		Pair(int[] a,long ct,long c)
    		{
    			this.a=a;
    			this.ct=ct;
    			this.c=c;
    		}
    		public int compareTo(Pair o)
    		{
    			if(this.c==o.c)
    				return Long.compare(this.ct,o.ct);
    		  return Long.compare(this.c,o.c);
    		}

    	}

    	public static int root(int i)
    	{
    		while(root[i]!=i)
    		{
    			root[i]=root[root[i]];
    			i=root[i];
    		}
    		return i;
    	}

    	public static void init(int n)
    	{
    		root=new int[n+1];
    		for(int i=1;i<=n;i++)
    			root[i]=i;
    	}
    	public static void union(int a,int b)
    	{
    	    int root_a=root(a);
    	    int root_b=root(b);
    	    root[root_a]=root_b;
    	   // size[root_b]+=size[root_a];
    	}

    	public static boolean isPrime(int n)
    	{
    	    // Corner cases
    	    if (n <= 1)  return false;
    	    if (n <= 3)  return true;

    	    // This is checked so that we can skip
    	    // middle five numbers in below loop
    	    if (n%2 == 0 || n%3 == 0)
    	    	return false;

    	    for (int i=5; i*i<=n; i=i+6)
    	        if (n%i == 0 || n%(i+2) == 0)
    	           return false;

    	    return true;
    	}

    	public static String ns()
    	{
    		return in.nextLine();
    	}
    	public static int ni()
    	{
    		return in.nextInt();
    	}
    	public static long nl()
    	{
    		return in.nextLong();
    	}
    	public static int[] na(int n)
    	{
    		a=new int[n];
    		for(int i=0;i<n;i++)
    		a[i]=ni();
    		return a;
    	}
    	public static void sieve()
    	    {
    	       int n=prime.length;
    	        for(int i=0;i<n;i++)
    	            prime[i] = true;

    	        for(int p = 2; p*p <=n; p++)
    	        {
    	            if(prime[p] == true)
    	            {
    	                for(int i = p*2; i <n; i += p)
    	                    prime[i] = false;
    	            }
    	        }
    	    }

      public static String rev(String s)
    	{
    		StringBuilder sb=new StringBuilder(s);
    		sb.reverse();
    		return sb.toString();
    	}
    	static long lcm(long a, long b)
    	{
    	    return a * (b / gcd(a, b));
    	}
    	static long gcd(long a, long b)
    	{
    	    while (b > 0)
    	    {
    	        long temp = b;
    	        b = a % b; // % is remainder
    	        a = temp;
    	    }
    	    return a;
    	}
    	static InputReader in;
    	static PrintWriter w;
    static class InputReader
    {

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

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

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

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

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

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

    public boolean isSpaceChar(int c)
    {
      if (filter != null)
        return filter.isSpaceChar(c);
      return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

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

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

    }

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

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

    static class TaskC {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            long n = in.nextLong();
            long k = in.nextLong();
            if (k > 100) {
                out.println("No");
                return;
            }
            for (int i = 1; i <= k; i++) {
                if ((n + 1) % i != 0) {
                    out.println("No");
                    return;
                }
            }
            out.println("Yes");

        }

    }

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

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

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

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

    }
}

//package code_forces;

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

public class Problem_922C {
	public static void main(String[] args) throws IOException {
		Scanner sc = new Scanner();
		PrintWriter pw = new PrintWriter(System.out);
		long n=sc.nextLong();
		long k=sc.nextLong();
		HashSet<Long>hs= new HashSet<>();
		if(k<=2 && n==1 )
		{
			pw.println("Yes");
		}
		else if(k>=n)
		{
			pw.println("No");
		}
		else
		{
			for(long i=1;i<=k;i++)
			{
				if(hs.contains((long)n%i))
				{
					pw.println("No");
					pw.flush();
					return;
				}
				hs.add((long)n%i);
			}
			pw.println("Yes");
		}
		pw.close();
	}

	static class Scanner {
		BufferedReader br;
		StringTokenizer st;

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

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

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

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

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

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

		boolean hasnext() throws IOException {
			return br.ready();
		}

	}
}

/* Author: Ronak Agarwal, reader part not written by me*/
import java.io.* ; import java.util.* ;
import static java.lang.Math.min ; import static java.lang.Math.max ;
import static java.lang.Math.abs ; import static java.lang.Math.log ;
import static java.lang.Math.pow ; import static java.lang.Math.sqrt ;
/* Thread is created here to increase the stack size of the java code so that recursive dfs can be performed */
public class C{
	public static void main(String[] args) throws IOException{
		new Thread(null,new Runnable(){	public void run(){ exec_Code() ;} },"Solver",1l<<27).start() ;
	}
	static void exec_Code(){
		try{
			Solver Machine = new Solver() ;
			Machine.Solve() ; Machine.Finish() ;}
		catch(Exception e){ e.printStackTrace() ; print_and_exit() ;}
		catch(Error e){ e.printStackTrace() ; print_and_exit() ; }
	}
	static void print_and_exit(){ System.out.flush() ; System.exit(-1) ;}
}
/* Implementation of the Reader class */
class Reader {
	private InputStream mIs;
	private byte[] buf = new byte[1024];
	private int curChar,numChars;
	public Reader() { this(System.in); }
	public Reader(InputStream is) { mIs = is;}
	public int read() {
		if (numChars == -1) throw new InputMismatchException();
		if (curChar >= numChars) {
			curChar = 0;
			try { numChars = mIs.read(buf);} catch (IOException e) { throw new InputMismatchException();}
			if (numChars <= 0) return -1;
		}
		return buf[curChar++];
	}
	public String nextLine(){
		int c = read();
		while (isSpaceChar(c)) c = read();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = read();
		} while (!isEndOfLine(c));
		return res.toString() ;
	}
	public String s(){
		int c = read();
		while (isSpaceChar(c)) c = read();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = read();
		}while (!isSpaceChar(c));
		return res.toString();
	}
	public long l(){
		int c = read();
		while (isSpaceChar(c)) c = read();
		int sgn = 1;
		if (c == '-') { sgn = -1 ; c = read() ; }
		long res = 0;
		do{
			if (c < '0' || c > '9') throw new InputMismatchException();
			res *= 10 ; res += c - '0' ; c = read();
		}while(!isSpaceChar(c));
		return res * sgn;
	}
	public int i(){
		int c = read() ;
		while (isSpaceChar(c)) c = read();
		int sgn = 1;
		if (c == '-') { sgn = -1 ; c = read() ; }
		int res = 0;
		do{
			if (c < '0' || c > '9') throw new InputMismatchException();
			res *= 10 ; res += c - '0' ; c = read() ;
		}while(!isSpaceChar(c));
		return res * sgn;
	}
	public boolean isSpaceChar(int c) { return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1; }
	public boolean isEndOfLine(int c) { return c == '\n' || c == '\r' || c == -1; }
}
/* All the useful functions,constants,renamings are here*/
class Template{
	/* Constants Section */
	final int INT_MIN = Integer.MIN_VALUE ; final int INT_MAX = Integer.MAX_VALUE ;
	final long LONG_MIN = Long.MIN_VALUE ; final long LONG_MAX = Long.MAX_VALUE ;
	static long MOD = 1000000007 ;
	static Reader ip = new Reader() ;
	static PrintWriter op = new PrintWriter(System.out) ;
	/* Methods for writing */
	static void p(Object o){ op.print(o) ; }
	static void pln(Object o){ op.println(o) ;}
	static void Finish(){ op.flush(); op.close(); }
	/* Implementation of operations modulo MOD */
	static long inv(long a){ return powM(a,MOD-2) ; }
	static long m(long a,long b){ return (a*b)%MOD ; }
	static long d(long a,long b){ return (a*inv(b))%MOD ; }
	static long powM(long a,long b){
		if(b<0) return powM(inv(a),-b) ;
		long ans=1 ;
		for( ; b!=0 ; a=(a*a)%MOD , b/=2) if((b&1)==1) ans = (ans*a)%MOD ;
		return ans ;
	}
	/* Renaming of some generic utility classes */
	final static class mylist extends ArrayList<Integer>{}
	final static class myset extends TreeSet<Integer>{}
	final static class mystack extends Stack<Integer>{}
	final static class mymap extends TreeMap<Integer,Integer>{}
}
/* Implementation of the pair class, useful for every other problem */
class pair implements Comparable<pair>{
	int x ; int y ;
	pair(int _x,int _y){ x=_x ; y=_y ;}
	public int compareTo(pair p){
		return (this.x<p.x ? -1 : (this.x>p.x ? 1 : (this.y<p.y ? -1 : (this.y>p.y ? 1 : 0)))) ;
	}
}
/* Main code starts here */
class Solver extends Template{
	int MAXN = 40000000 ;
	public void Solve() throws IOException{
		long n = ip.l() ; long k = ip.l() ;
		if(k>=(MAXN)){pln("No") ; return ; }
		int hit[] = new int[MAXN+1] ;
		boolean flag=true ;
		for(long i=1 ; i<=k ; i++){
			if(hit[(int) (n%i)]==1){
				flag=false ; break ;
			}
			hit[(int) (n%i)] = 1 ;
		}
		pln(flag ? "Yes" : "No") ;
	}
}

import java.util.*;
public class P922C
{
	public static void main(String args[])
	{
		Scanner s = new Scanner(System.in);
		long n = Long.parseLong(s.next());
		long k = Long.parseLong(s.next());
		long check = 0;

		for(long i = 2; i<= k; i++)
		{
			if((n + 1) % i !=0)
			{
				System.out.println("No");
				check = 1;
				break;
			}
		}

		if(check == 0)
		{
			System.out.println("Yes");
		}
	}
}

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

public class CF {

    public static void main(String[] args) throws IOException {
        //PrintWriter out = new PrintWriter(new File("output.txt"));
        FastScanner in = new FastScanner(System.in);
        PrintWriter out = new PrintWriter(System.out);
        long n = in.nextLong();
        long k = in.nextLong();
        if (k == 1 || (n == 1 && k == 2)) {
            out.println("Yes");
        } else if (k>=n){
            out.println("No");
        }else{
            boolean test = true;
            Set<Long> set = new HashSet<>();
            for (int i = 1; i <= k && test; i++) {
                if (set.contains(n%i)){
                    test = false;
                    out.println("No");
                }else{
                    set.add(n%i);
                }
            }
            if (test){
                out.println("Yes");
            }
        }
        out.close();
    }

    public static List<int[]> list = new LinkedList<>();

    public static void Permute(int[] input, int startindex) {
        int size = input.length;
        if (size == startindex + 1) {
            int[] tab = new int[size];
            for (int i = 0; i < tab.length; i++) {
                tab[i] = input[i];
            }
            list.add(tab);
        } else {
            for (int i = startindex; i < size; i++) {
                int temp = input[i];
                input[i] = input[startindex];
                input[startindex] = temp;
                Permute(input, startindex + 1);
                int temp2 = input[i];
                input[i] = input[startindex];
                input[startindex] = temp2;
            }
        }
    }

    public static int[] radixSort(int[] f) {
        return radixSort(f, f.length);
    }

    public static int[] radixSort(int[] f, int n) {
        int[] to = new int[n];
        {
            int[] b = new int[65537];
            for (int i = 0; i < n; i++) {
                b[1 + (f[i] & 0xffff)]++;
            }
            for (int i = 1; i <= 65536; i++) {
                b[i] += b[i - 1];
            }
            for (int i = 0; i < n; i++) {
                to[b[f[i] & 0xffff]++] = f[i];
            }
            int[] d = f;
            f = to;
            to = d;
        }
        {
            int[] b = new int[65537];
            for (int i = 0; i < n; i++) {
                b[1 + (f[i] >>> 16)]++;
            }
            for (int i = 1; i <= 65536; i++) {
                b[i] += b[i - 1];
            }
            for (int i = 0; i < n; i++) {
                to[b[f[i] >>> 16]++] = f[i];
            }
            int[] d = f;
            f = to;
            to = d;
        }
        return f;

    }

    private static class FastScanner {

        private final InputStream stream;
        private final byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;

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

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

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

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

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

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

        public String[] nextArrayString(int n) {
            String tab[] = new String[n];
            for (int i = 0; i < n; i++) {
                tab[i] = next();
            }
            return tab;
        }

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

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

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

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

//package codeforces;

import java.util.Scanner;

public class CavePainting {

	public static void main(String[] args) {
		Scanner input=new Scanner(System.in);
		long a = input.nextLong();
		long b = input.nextLong();
		int[] save = new int[(1000)];
		boolean bool = true;
		if(b == 1) {
			bool = true;
		}
		else if((b>=a||a%2==0)&&a!=1) {
			bool = false;
		}
		else {
			for(int i = 1; i<=b; i++) {
				if(save[(int) (a%i)]>0) {
					bool = false;
					break;
				}
				else {
					save[(int) (a%i)]++;
				}
			}
		}
		if(bool)
			System.out.println("YES");
		else
			System.out.println("NO");

		input.close();
     }
}

import java.util.*;

public class Solution
{
       public static void main(String []args)
       {
              Scanner sc = new Scanner(System.in);
              long n = sc.nextLong();
              long k = sc.nextLong();

              if(k == 1 && n == 1)
              System.out.println("YES");

              else if(n == 1 && k == 2)
              System.out.println("YES");

              else
              {
              if(k >= n)
              System.out.println("NO");

              else
              {
                     boolean is = true;
                    for(long i = 1 ; i <= k ; i++)
                    {
                           if((n+1)%i != 0)
                           {
                           is = false;
                           break;
                           }
                    }
                    if(is)
                    System.out.println("YES");

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

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

public class Main {

	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskC solver = new TaskC();
		solver.solve(1, in, out);
		out.close();

	}

	static class TaskC {
		public void solve(int testNumber, InputReader in, PrintWriter out) {
			long n = Long.parseLong(in.next()) ;
			long k = Long.parseLong(in.next()) ;
			if(k==1){
				out.println("yes");
				return ;
			}
			if(n%2==0)
			{
				out.println("no");
				return ;
			}
			if(k>=n-1 && n!=3 && n!=1)
			{
				out.println("no");
				return ;
			}
			for (int i = 1; i <=k; i++)
			{
				if(n % i != i-1)
				{
					out.println("no");
					return ;
				}
			}
			{
				out.println("yes");
				return ;
			}

		}
		public static boolean isPrime (long num){
			if (num < 2) return false;
			if (num == 2) return true;
			if (num % 2 == 0) return false;
			for (long i = 3*1l; i * i <= num; i += 2)
				if (num % i == 0) return false;
			return true;
		}
	}
	static class InputReader {
		public BufferedReader	reader;
		public StringTokenizer	tokenizer;

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

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

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

	}
	static class Vertix{
		int x ;
		ArrayList<Vertix> children;
		Vertix parent;

		public Vertix(int x){
			this.x = x ;
			this.children= new ArrayList<Vertix>();
		}

	}

	static class Pair implements Comparable<Pair> {
		int x ;
		int y ;

		public Pair(int x, int y) {
			this.x = x ;
			this.y = y ;

		}

		@Override
		public int compareTo(Pair p) {
			if (this.x < p.x)
				return -1;
			else if (this.x > p.x)
				return 1;
			else
				return 0;

		}
		//
	}

}

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

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

    static class CCavePainting {
        public void solve(int testNumber, FastScanner br, PrintWriter pw) {
            long a = br.nextLong();
            long b = br.nextLong();
            if (b >= 43) {
                pw.println("No");
            } else {
                HashSet<Long> set = new HashSet<>();
                for (int i = 1; i <= b; i++) {
                    if (set.contains(a % i)) {
                        pw.println("No");
                        pw.close();
                    }
                    set.add((a % i));
                }
                pw.println("Yes");
                pw.close();
            }

        }

    }

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

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

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

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

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

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

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

        }

    }
}

import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

public class test03B {

	static Scanner scan = new Scanner(System.in);
	static Set<Long>set= new HashSet<>();
	static long n,k;
	public static void main(String[] args) {

		n=scan.nextLong();
		k=scan.nextLong();
		if(k==1){
			System.out.println("Yes");
			return;
		}
		if(n==k){
			System.out.println("No");
			return;
		}
		for (long i = 1; i <=k; i++) {
			long temp=mod(i);
			if(set.contains(temp)){
				System.out.println("No");
				return;
			}
			set.add(temp);
		}
		System.out.println("Yes");

	}
	static long mod(long mod){
		return n%mod;
	}
}

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

	public class codeforces
	{
		public static void main(String[] args)
		{
			InputReader in = new InputReader(System.in);
			PrintWriter pw = new PrintWriter(System.out);

			//Code starts..

			long n = in.nextLong();;
			long k = in.nextLong();

			boolean flag = true;

			if(n>k)
			for(int i=1; i<=k; i++)
			{
				if((n%i) != i-1)
				{
					flag = false;
					break;
				}
			}

			else
			{
				flag = false;

			}

			if(n==1 && (k==1 || k==2))
				flag = true;
			if(flag)
				pw.println("Yes");
			else
				pw.println("No");
			//Code ends....

			pw.flush();
			pw.close();
		}

		static class InputReader
		{

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

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

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

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

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

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

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

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

			public boolean isSpaceChar(int c)
			{
				if (filter != null)
					return filter.isSpaceChar(c);
				return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
			}

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

			public interface SpaceCharFilter
		    {
				public boolean isSpaceChar(int ch);
			}
		}
		public static long c = 0;

		public static long mod = 1000000007;
		public static int d;
		public static int p;
		public static int q;

		public static  int gcd(int p2, int p22)
		{
		    if (p2 == 0)
		        return (int) p22;
		    return gcd(p22%p2, p2);
		}

		public static int findGCD(int arr[], int n)
		{
		    int result = arr[0];
		    for (int i=1; i<n; i++)
		        result = gcd(arr[i], result);

		    return result;
		}

	    public static long lcm(int[] numbers) {
	        long lcm = 1;
	        int divisor = 2;
	        while (true) {
	            int cnt = 0;
	            boolean divisible = false;
	            for (int i = 0; i < numbers.length; i++) {
	                if (numbers[i] == 0) {
	                    return 0;
	                } else if (numbers[i] < 0) {
	                    numbers[i] = numbers[i] * (-1);
	                }
	                if (numbers[i] == 1) {
	                    cnt++;
	                }
	                if (numbers[i] % divisor == 0) {
	                    divisible = true;
	                    numbers[i] = numbers[i] / divisor;
	                }
	            }
	            if (divisible) {
	                lcm = lcm * divisor;
	            } else {
	                divisor++;
	            }
	            if (cnt == numbers.length) {
	                return lcm;
	            }
	        }
	    }
		public static long fact(long n) {

			long factorial = 1;
			 for(int i = 1; i <= n; i++)
		        {
		            factorial *= i;
		        }
			 return factorial;
		}

		public static int lowerLimit(int[] a, int n) {
			int ans = 0;

			int ll = 0;
			int rl = a.length-1;
		//	System.out.println(a[rl]+" "+n);
			if(a[0]>n)
				return 0;
			if(a[0]==n)
				return 1;
			else if(a[rl]<=n)
				return rl+1;

			while(ll<=rl)
			{

				int mid = (ll+rl)/2;
				if(a[mid]==n)
				{
					ans = mid + 1;
					break;
				}

				else if(a[mid]>n)
				{
					rl = mid-1;

				}
				else
				{
					ans = mid+1;
					ll = mid+1;
				}
			}

			return ans;
		}

		public static long choose(long total, long choose){
		    if(total < choose)
		        return 0;
		    if(choose == 0 || choose == total)
		        return 1;
		    return (choose(total-1,choose-1)+choose(total-1,choose))%mod;
		}

		public static int[] suffle(int[] a,Random gen)
		{
			int n = a.length;
			for(int i=0;i<n;i++)
			{
				int ind = gen.nextInt(n-i)+i;
				int temp = a[ind];
				a[ind] = a[i];
				a[i] = temp;
			}
			return a;
		}

		public static int floorSearch(int arr[], int low, int high, int x)
		{
		    if (low > high)
		        return -1;

		    if (x > arr[high])
		        return high;
		    int mid = (low+high)/2;

		    if (mid > 0 && arr[mid-1] < x && x < arr[mid])
		        return mid-1;

		    if (x < arr[mid])
		        return floorSearch(arr, low, mid-1, x);

		    return floorSearch(arr, mid+1, high, x);
		}

		public static void swap(int a, int b){
			int temp = a;
			a = b;
			b = temp;
		}

		public static ArrayList<Integer> primeFactorization(int n)
		{
			ArrayList<Integer> a =new ArrayList<Integer>();
			for(int i=2;i*i<=n;i++)
			{
				while(n%i==0)
				{
					a.add(i);
					n/=i;
				}
			}
			if(n!=1)
				a.add(n);
			return a;
		}

		public static void sieve(boolean[] isPrime,int n)
		{
			for(int i=1;i<n;i++)
				isPrime[i] = true;

			isPrime[0] = false;
			isPrime[1] = false;

			for(int i=2;i*i<n;i++)
			{
				if(isPrime[i] == true)
				{
					for(int j=(2*i);j<n;j+=i)
						isPrime[j] = false;
				}
			}
		}

		public static int GCD(int a,int b)
		{
			if(b==0)
				return a;
			else
				return GCD(b,a%b);
		}

		public static long GCD(long a,long b)
		{
			if(b==0)
				return a;
			else
				return GCD(b,a%b);
		}

		public static void extendedEuclid(int A,int B)
		{
			if(B==0)
			{
				d = A;
				p = 1 ;
				q = 0;
			}
			else
			{
				extendedEuclid(B, A%B);
				int temp = p;
				p = q;
				q = temp - (A/B)*q;
			}
		}

		public static long LCM(long a,long b)
		{
			return (a*b)/GCD(a,b);
		}

		public static int LCM(int a,int b)
		{
			return (a*b)/GCD(a,b);
		}

		public static int binaryExponentiation(int x,int n)
		{
		    int result=1;
		    while(n>0)
		    {
		        if(n % 2 ==1)
		            result=result * x;
		        x=x*x;
		        n=n/2;
		    }
		    return result;
		}

		public static long binaryExponentiation(long x,long n)
		{
		    long result=1;
		    while(n>0)
		    {
		        if(n % 2 ==1)
		            result=result * x;
		        x=(x%mod * x%mod)%mod;
		        n=n/2;
		    }
		    return result;
		}

		public static int modularExponentiation(int x,int n,int M)
		{
		    int result=1;
		    while(n>0)
		    {
		        if(n % 2 ==1)
		            result=(result * x)%M;
		        x=(x*x)%M;
		        n=n/2;
		    }
		    return result;
		}

		public static long modularExponentiation(long x,long n,long M)
		{
		    long result=1;
		    while(n>0)
		    {
		        if(n % 2 ==1)
		            result=(result * x)%M;
		        x=(x*x)%M;
		        n=n/2;
		    }
		    return result;
		}

		public static int modInverse(int A,int M)
		{
		    return modularExponentiation(A,M-2,M);
		}

		public static long modInverse(long A,long M)
		{
		    return modularExponentiation(A,M-2,M);
		}

		public static boolean isPrime(int n)
		{

		    if (n <= 1)  return false;
		    if (n <= 3)  return true;

		    if (n%2 == 0 || n%3 == 0)
		    	return false;

		    for (int i=5; i*i<=n; i=i+6)
		    {
		        if (n%i == 0 || n%(i+2) == 0)
		           return false;
		    }

		    return true;
		}

		static class pair implements Comparable<pair>

		{
			Integer x, y;
			pair(int x,int y)
			{
				this.x=x;
				this.y=y;
			}

			public int compareTo(pair o) {
				int result = x.compareTo(o.x);
				if(result==0)
					result = y.compareTo(o.y);

				return result;
			}

			public String toString()
			{
				return x+" "+y;
			}

			public boolean equals(Object o)
			{
				if (o instanceof pair)
			    {
					pair p = (pair)o;
					return p.x == x && p.y == y ;
				}
				return false;
			}

			public int hashCode()
			{
				return new Long(x).hashCode()*31 + new Long(y).hashCode();
			}
		}

		static class node implements Comparable<node>

		{
			Integer x, y, z;
			node(int x,int y, int z)
			{
				this.x=x;
				this.y=y;
				this.z=z;
			}

			public int compareTo(pair o) {
				int result = x.compareTo(o.x);
				if(result==0)
					result = y.compareTo(o.y);
				if(result==0)
					result = z.compareTo(z);
				return result;
			}

			@Override
			public int compareTo(node o) {
				// TODO Auto-generated method stub
				return 0;
			}
		}

	}

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

/**
 * Created by Shashwat on 8/29/2017.
 */
public class ques1 {
    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

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

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

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

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

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

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }
    public static void main(String args[])throws IOException {
        FastReader sc=new FastReader();
        long n=sc.nextLong();
        long k=sc.nextLong();
        boolean flag=true;

                long p=1;
                while(n%p==p-1 && p<k)
                    p++;
                if(p==k && n%k==k-1)
                    flag=true;
                else
                    flag=false;
        if(n==k)
        {
            if(n==1)
                flag=true;
            else
                flag=false;
        }

        if(flag)
            System.out.println("Yes");
        else
            System.out.println("No");
    }
}

import java.util.*;

public class Main
{
	public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        HashMap <Integer, Boolean> mp = new HashMap<>();
        long n = in.nextLong();
        long k = in.nextLong();
        if(k >= 1e6) prr("NO");
        for(long i = 1; i <= k; i++) {
            if(mp.containsKey((int)(n % i))) prr("NO");
            mp.put((int)(n % i), true);
        }
        prr("YES");
	}
	public static void prr(String s) {
	    System.out.println(s);
	    System.exit(0);
	}
}

/*package whatever //do not write package name here */

import java.io.*;

public class GFG {
	public static void main (String[] args)throws IOException  {
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		String p[]=br.readLine().split(" ");
		long a=Long.parseLong(p[0]);
		long b=Long.parseLong(p[1]);
	    if(a==2&&b==2)
	    {
	        System.out.println("No");
	        System.exit(0);
	    }
		for(long i=2;i<=b;i++)
		{
		    if(a%i<=i/2&&i!=2)
		    {
		        System.out.println("No");
		        System.exit(0);
		    }

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

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.FilterInputStream;
import java.io.BufferedInputStream;
import java.io.InputStream;

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

    static class TaskC {
        public void solve(int testNumber, ScanReader in, PrintWriter out) {
            long n = in.scanLong();
            long k = in.scanLong();

            if (k == 1) {
                out.println("Yes");
                return;
            }
            if (n % 2 == 0) {
                out.println("No");
                return;
            }
            if (k >= 1000000) {
                out.println("No");
                return;
            } else {
                boolean hash[] = new boolean[10000001];
                for (int i = 1; i <= Math.min(k, 10000000); i++) {
                    if (hash[(int) (n % i)]) {
                        out.println("No");
                        return;
                    }
                    hash[(int) (n % i)] = true;

                }
                out.println("Yes");
            }

        }

    }

    static class ScanReader {
        private byte[] buf = new byte[4 * 1024];
        private int index;
        private BufferedInputStream in;
        private int total;

        public ScanReader(InputStream inputStream) {
            in = new BufferedInputStream(inputStream);
        }

        private int scan() {
            if (index >= total) {
                index = 0;
                try {
                    total = in.read(buf);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                if (total <= 0) return -1;
            }
            return buf[index++];
        }

        private boolean isWhiteSpace(int n) {
            if (n == ' ' || n == '\n' || n == '\r' || n == '\t' || n == -1) return true;
            else return false;
        }

        public long scanLong() {
            long integer = 0;
            int n = scan();
            while (isWhiteSpace(n)) n = scan();
            int neg = 1;
            if (n == '-') {
                neg = -1;
                n = scan();
            }
            while (!isWhiteSpace(n)) {
                if (n >= '0' && n <= '9') {
                    integer *= 10;
                    integer += n - '0';
                    n = scan();
                }
            }
            return neg * integer;
        }

    }
}

	import java.io.*;
import java.math.BigInteger;
import java.util.*;
import java.util.Map.Entry;

public class Main
	{
		private InputStream stream;
		private byte[] buf = new byte[1024];
		private int curChar;
		private int numChars;
		private SpaceCharFilter filter;
		private PrintWriter pw;
		private long mod = 1000000000 + 7;

		private StringBuilder ans_sb;
		private int block;
		int[] s;
		private void soln()
		{
			/*int n = nextInt();
			int m = nextInt();
			int cnt = m - 1;
			//debug(cnt);
			if(m==0)
				pw.println("No");
			else if(n>0 && m==1)
				pw.println("No");
			else if(cnt > n) {
				pw.println("No");
			}else {
				n -= cnt;
				if(n%2==0)
					pw.print("Yes");
				else
					pw.println("No");
			}*/
			/*int n = nextInt();
			int cnt = 0;
			for(int i=1;i<=n;i++) {
				for(int j=i;j<=n;j++) {
					int k = i^j;
					if(k<=n && k>=i && k>=j) {
						//System.out.println
						if((i+j > k) && (i+k>j) &&( j+k>i))
							cnt++;
					}
				}
			}
			pw.println(cnt);*/
			long n = nextLong();
			long k = nextLong();
			if(n==1 && k==1) {
				pw.println("Yes");
			}else if(n==1 && k==2)
				pw.println("Yes");
			else {
				if(n <= k) {
					pw.println("No");
				}else {
					if(k > 5000) {
						pw.println("No");
					}else {
					//	n++;
						HashSet<Long> set = new HashSet<>();
					//	boolean f = true;
						for(long i=1;i<=k;i++) {
							set.add(n%i);
						}
						if(set.size() == k)
							pw.println("Yes");
						else
							pw.println("No");
					}
				}
			}
		/*	int n = nextInt();
			Pair[] cnt = new Pair[n];
			for(int i=0;i<n;i++) {
				String s = nextLine();
				long ans = 0;
				long cnt1 = 0;
				for(int j=0;j<s.length();j++) {
					if(s.charAt(j)=='s')
						cnt1++;
					else
						ans += cnt1;
				}
				cnt[i] = new Pair(cnt1, s.length()-cnt1,ans);
			}
			Arrays.sort(cnt);
			long ans = 0;
			long cnt1 = 0;
			for(int i=0;i<n;i++) {
				ans += cnt1*cnt[i].h;
				ans += cnt[i].ans;
				cnt1 += cnt[i].s;
			}
			pw.println(ans);*/
		}
		private class Pair implements Comparable<Pair>{
			long s,h,ans;
			public Pair(long a,long b,long c) {
				s = a;
				h = b;
				ans = c;
			}
			@Override
			public int compareTo(Pair arg0)
			{
				long mul1 = this.s * arg0.h;
				long mul2 = this.h * arg0.s;
				if(mul1 != mul2)
					return (int) (mul2 - mul1);
				else if(this.h == 0)
					return -1;
				else if(this.s == 0)
					return 1;
				else return 0;
			//	return 0;
			}
		}
		private String solveEqn(long a, long b) {
	        long x = 0, y = 1, lastx = 1, lasty = 0, temp;
	        while (b != 0){
	        	long q = a / b;
	        	long r = a % b;
	            a = b;
	            b = r;
	            temp = x;
	            x = lastx - q * x;
	            lastx = temp;
	            temp = y;
	            y = lasty - q * y;
	            lasty = temp;
	        }
	        return lastx+" "+lasty;
		}
		private void debug(Object... o) {
			System.out.println(Arrays.deepToString(o));
		}

		private long pow(long a, long b, long c)
		{
			if (b == 0)
				return 1;
			long p = pow(a, b / 2, c);
			p = (p * p) % c;
			return (b % 2 == 0) ? p : (a * p) % c;
		}

		private long gcd(long n, long l)
		{
			if (l == 0)
				return n;
			return gcd(l, n % l);
		}
		public static void main(String[] args) throws Exception
		{
			/*new Thread(null, new Runnable()
			{
				@Override
				public void run()
				{
					new Main().solve();
				}
			}, "1", 1 << 25).start();*/
			new Main().solve();
		}
		public StringBuilder solve(){
			InputReader(System.in);
			/*try {
				InputReader(new FileInputStream("C:\\Users\\hardik\\Desktop\\in.txt"));
			} catch(FileNotFoundException e) {}
			*/
			pw = new PrintWriter(System.out);
			//ans_sb = new StringBuilder();
			soln();

			pw.close();
			//System.out.println(ans_sb);
			return ans_sb;
		}
		public void InputReader(InputStream stream1)
		{
			stream = stream1;
		}

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

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

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

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

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

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

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

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

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

		private void pArray(int[] arr)
		{
			for (int i = 0; i < arr.length; i++)
			{
				System.out.print(arr[i] + " ");
			}
			System.out.println();
			return;
		}

		private void pArray(long[] arr)
		{
			for (int i = 0; i < arr.length; i++)
			{
				System.out.print(arr[i] + " ");
			}
			System.out.println();
			return;
		}

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

		private char nextChar()
		{
			int c = read();
			while (isSpaceChar(c))
				c = read();
			char c1 = (char) c;
			while (!isSpaceChar(c))
				c = read();
			return c1;
		}

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

import java.util.Scanner;

public class Contest922ProblemC {

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

		Scanner in= new Scanner(System.in);

		long n=in.nextLong();
		long k=in.nextLong();

		for(int i=1;i<=k;i++) {
			if((n+1)%i!=0) {
				System.out.println("No");
				break;
			}
			else if(i==k) {
			System.out.println("Yes");
			}
		}

	}

}

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

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

    static class CCavePainting {
        public void solve(int testNumber, inputClass sc, PrintWriter out) {
            long n = sc.nextLong();
            long k = sc.nextLong();
            if (k == 1) {
                out.println("Yes");
            } else {
                if (n % 2 == 0)
                    out.println("No");
                else {
                    for (int i = 1; i <= k; i++) {
                        if (n % i != i - 1) {
                            out.println("No");
                            return;
                        }
                    }
                    out.println("Yes");
                }
            }
        }

    }

    static class inputClass {
        BufferedReader br;
        StringTokenizer st;

        public inputClass(InputStream in) {

            br = new BufferedReader(new InputStreamReader(in));
        }

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

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

    }
}

import java.lang.String;
import java.lang.reflect.Array;
import java.util.Scanner;
import java.util.Arrays;
import java.util.Collections;

public class Main {

    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        long n = sc.nextLong();
        long k = sc.nextLong();
        long u = 0;
        String s = "Yes";

        for (long i = 2; i <= k ; i++) {
            if (n%i>u) {u = n%i;} else {s = "No"; break;}
        }

        System.out.println(s);
    }

}

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

public class C
{
    public static void process(int test_number)throws IOException
    {
        long n = nl(), k = nl();
        TreeSet<Long> set = new TreeSet<Long>();

        for(long i = 1l; i <= k; i++){
            long rem = n % i;
            if(set.contains(rem)){
                pn("No");
                return ;
            }

            set.add(rem);
        }

        pn("Yes");
    }

    static final long mod = (long)1e9+7l;

    static FastReader sc;
    static PrintWriter out;
    public static void main(String[]args)throws IOException
    {
        out = new PrintWriter(System.out);
        sc = new FastReader();

        long s = System.currentTimeMillis();
        int t = 1;
        //t = ni();
        for(int i = 1; i <= t; i++)
            process(i);

        out.flush();
        System.err.println(System.currentTimeMillis()-s+"ms");
    }

    static void trace(Object... o){ System.err.println(Arrays.deepToString(o)); };
    static void pn(Object o){ out.println(o); }
    static void p(Object o){ out.print(o); }
    static int ni()throws IOException{ return Integer.parseInt(sc.next()); }
    static long nl()throws IOException{ return Long.parseLong(sc.next()); }
    static double nd()throws IOException{ return Double.parseDouble(sc.next()); }
    static String nln()throws IOException{ return sc.nextLine(); }
    static long gcd(long a, long b)throws IOException{ return (b==0)?a:gcd(b,a%b);}
    static int gcd(int a, int b)throws IOException{ return (b==0)?a:gcd(b,a%b); }
    static int bit(long n)throws IOException{ return (n==0)?0:(1+bit(n&(n-1))); }

    static class FastReader{
        BufferedReader br;
        StringTokenizer st;

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

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

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

////package CodeChef;
import java.awt.Point;
import java.io.*;
import java.math.BigInteger;
import java.text.DecimalFormat;
import java.util.*;
public class ANUMLA {

   static int[] a;
   static long[] sum;
   static int mod=1000000007;
   static int[][] dp;
   static boolean[][] isPalin;
   static int max1=5000+10;
   static int[][] g;
   static int ver;
   static int n,k,m,x;
   static boolean[] visit,isprime;
   static LinkedList<Pair> l[];
   static int ans=0,max_len=8;
   static int[] color,log,st[],lpf;
   static String[] S;static TreeSet<Integer> ts;
   static LinkedList<Integer> al[];
   static InputReader in;
   static PrintWriter pw;
  public static void main(String[] args) throws Exception
   {
   	 in = new InputReader(System.in);
       // BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
     //Scanner sc=new Scanner();
   	pw=new PrintWriter(System.out);

     long n=in.il();
     long k=in.il();
       boolean b=true;
     ArrayList<Long> al=new ArrayList<>();
     for(int i=1;i<=k&&i<=100;i++)
     {
    if(!al.contains(n%i))al.add(n%i);
     else {b=false; break;}
     }
     if(b)pw.println("Yes");
     else pw.println("No");

     /*   int t=in.ii();
        while(t-->0)
        {
         char[] s=in.is().trim().toCharArray();
         n=s.length;
         LinkedList<Integer> adj[]=new LinkedList[200];
         for(char i='a';i<='z';i++)adj[i]=new LinkedList<>();
         int oddf=0;char oddc=' ';
         int cnt=0;
         LinkedHashSet<Character> lh=new LinkedHashSet<>();
         for(int i=0;i<n;i++)
         {
           adj[s[i]].add(i+1);
           lh.add(s[i]);

         }

         for(char c:lh)
         {
          if(adj[c].size()%2==1)
          {
           // pw.println(c);
            oddc=c; cnt++;
          }
         }
        // pw.println(cnt);

         if(cnt>1)pw.println(-1);
          else
          {
           String ans="";
            LinkedList<Integer> q=new LinkedList<Integer>();
            char w=' ';
        if(cnt==0)
        {
          for(int j:adj['a'])
              q.add(j);
         w='a';
        }
        else{
           for(int y:adj[oddc])
                     q.add(y);
        }

           for(char i='a';i<='z';i++)
           {
             if(adj[i].size()%2!=1 && i!=w && i!=oddc)
             {

                 while(!adj[i].isEmpty())
                 {
                   q.addFirst(adj[i].poll());
                   q.addLast(adj[i].poll());
                 }
             }
           }
           for(int o:q)
               pw.print(o+" ");
           pw.println();

          }
     }*/

      /* int t=in.ii();
       while(t-->0)
       {
           n=in.ii();
           m=in.ii();
           x=in.ii();
           k=in.ii();
           char[]s=in.is().toCharArray();
           al=new LinkedList[2];
           for(int i=0;i<2;i++)al[i]=new LinkedList<Integer>();
           for(int i=0;i<k;i++)
               if(s[i]=='E')
                   al[0].add(i);
               else al[1].add(i);
           if(x*m<n)pw.println("no");
           else
           {
               boolean b1=false;
             for(int i=1;i<=m;i++)
             {
               if(i%2==1)
               {
                  int cnt=0;
                 while(!al[1].isEmpty()&&cnt<x)
                 {
                   al[1].removeFirst();
                   cnt++;
                 }
                    n-=cnt;
                    if(n<=0){b1=true; break;}
               }
               else if(i%2==0)
               {
                int cnt=0;
                 while(!al[0].isEmpty()&&cnt<x)
                 {
                   al[0].removeFirst();
                   cnt++;
                 }
                    n-=cnt;
                    if(n<=0){b1=true; break;}
               }
             }
             if(b1)pw.println("yes");
             else pw.println("no");
           }

       }*/
   	pw.close();
   }
 static long gcd1(long a,long b)
 {
  long res=1L;
  while(a>0)
  {
     res=a;
     a=b%a;
     b=res;
  }
  return res;
 }
public static double calculateAngle(double x1, double y1, double x2, double y2)
{
    double angle = Math.toDegrees(Math.atan2(x2 - x1, y2 - y1));
    // Keep angle between 0 and 360
    angle = angle + Math.ceil( -angle / 360 ) * 360;

    return angle;
}
static void seive()
{
    isprime=new boolean[1000005];
    Arrays.fill(isprime, true);
    isprime[0]=false;
    isprime[1]=false;
    lpf=new int[1000005];
    for(int i=1;i<=1000000;i++)lpf[i]=i;

    for(int i=2;i<=1000;i++)
    {
      if(lpf[i]!=i)continue;
      int j=i+i;
      while(j<=1000000)
      {
        lpf[j]=i;
        j+=i;
      }

    }

}
  static BigInteger power(BigInteger x, BigInteger y, BigInteger m)
			{
			    if (y.equals(new BigInteger("0")))
			        return (new BigInteger("1"));
			    BigInteger p = power(x, y.divide(new BigInteger("2")), m).mod(m);
			    p = (p.multiply(p)).mod(m);

			    return (y.mod(new BigInteger("2")).equals(new BigInteger("0")))? p : (p.multiply(x)).mod(m);
		        }

  static char[][] trans(char[][] s)
  {
    int n=s.length;
    int m=s[0].length;
   char[][] trans=new char[m][n];
    for(int i=0;i<m;i++)
    {
     for(int j=0;j<n;j++)
     {
       trans[i][j]=s[j][i];
     }
    }
  return trans;
  }
  public static String toBase26(int n)
  {
		StringBuffer ret = new StringBuffer();
		while(n>0)
                {
			--n;
			ret.append((char)('A' + n%26));
			n/=26;
		}
		return ret.reverse().toString();
	}
  static int get(int a,int b,int c)
  {
    int j=0;
    int i=0;
    int cnt=0;
    while(true)
    {
        if(i==c||j==c)return cnt;
       if(i==0)
       {
         i=a;
         cnt++;
         continue;
       }
       if(j==b)
       {
         j=0;
        cnt++;
        continue;
       }
       if(i!=0)
       {
        int temp=i;
        i=Math.max(0,i-(b-j));
        j=Math.min(b,temp+j);
        cnt++;
        continue;
       }

    }
    // return cnt;
  }
 static void log()
 {
   log[1]=0;
   for(int i=2;i<=n;i++)
   {
    log[i]=log[i/2]+1;
   }
 }

  private static class DSU{
		int[] parent;
		int[] rank;
		int cnt;
		public DSU(int n){
			parent=new int[n];
			rank=new int[n];
			for(int i=0;i<n;i++){
				parent[i]=i;
				rank[i]=1;
			}
			cnt=n;
		}
		int find(int i){
	        while(parent[i] !=i){
	        	parent[i]=parent[parent[i]];
	        	i=parent[i];
	        }
	        return i;
	    }
		int Union(int x, int y){
	        int xset = find(x);
	        int yset = find(y);
	        if(xset!=yset)
	        	cnt--;
	        if(rank[xset]<rank[yset]){
	        	parent[xset] = yset;
		        rank[yset]+=rank[xset];
		        rank[xset]=0;
		        return yset;
	        }else{
	        	parent[yset]=xset;
	        	rank[xset]+=rank[yset];
	        	rank[yset]=0;
	        	return xset;
	        }
	    }
	}
  public static int[][] packU(int n, int[] from, int[] to, int max) {

	    int[][] g = new int[n][];
	    int[] p = new int[n];
	    for (int i = 0; i < max; i++) p[from[i]]++;
	    for (int i = 0; i < max; i++) p[to[i]]++;
	    for (int i = 0; i < n; i++) g[i] = new int[p[i]];
	    for (int i = 0; i < max; i++) {
	        g[from[i]][--p[from[i]]] = to[i];
	        g[to[i]][--p[to[i]]] = from[i];
	    }
	    return g;
	}
	public static int[][] parents3(int[][] g, int root) {
	    int n = g.length;
	    int[] par = new int[n];
	    Arrays.fill(par, -1);

	    int[] depth = new int[n];
	    depth[0] = 0;

	    int[] q = new int[n];
	    q[0] = root;
	    for (int p = 0, r = 1; p < r; p++) {
	        int cur = q[p];
	        for (int nex : g[cur]) {
	            if (par[cur] != nex) {
	                q[r++] = nex;
	                par[nex] = cur;
	                depth[nex] = depth[cur] + 1;
	            }
	        }
	    }
	    return new int[][]{par, q, depth};
	}
	public static int lower_bound(int[] nums, int target) {
        int low = 0, high = nums.length - 1;
        while (low < high) {
            int mid = low + (high - low) / 2;
            if (nums[mid] < target)
                low = mid + 1;
            else
                high = mid;
        }
        return nums[low] == target ? low : -1;
    }

    public static int upper_bound(int[] nums, int target) {
        int low = 0, high = nums.length - 1;
        while (low < high) {
            int mid = low + (high + 1 - low) / 2;
            if (nums[mid] > target)
                high = mid - 1;
            else
                low = mid;
        }
        return nums[low] == target ? low : -1;
    }
  public static boolean palin(String s)
	{
	   int i=0;
	   int j=s.length()-1;
	   while(i<j)
	   {
		   if(s.charAt(i)==s.charAt(j))
		   {
			   i++;
			   j--;
		   }
		   else return false;
	   }
	   return true;
	}

    static boolean CountPs(String s,int n)
       {
    	boolean b=false;
    	     char[] S=s.toCharArray();
	       int[][] dp=new int[n][n];
	       boolean[][] p=new boolean[n][n];
	       for(int i=0;i<n;i++)p[i][i]=true;

	       for(int i=0;i<n-1;i++)
	       {
	    	   if(S[i]==S[i+1])
	    	   {
	    		p[i][i+1]=true;
	    		dp[i][i+1]=1;
	    		b=true;
	    	   }
	       }

	       for(int gap=2;gap<n;gap++)
	       {
	    	   for(int i=0;i<n-gap;i++)
	    	   {
	    		   int j=gap+i;
	    		   if(S[i]==S[j]&&p[i+1][j-1]){p[i][j]=true;}

	    		  if(p[i][j])
	    			   dp[i][j]=dp[i][j-1]+dp[i+1][j]+1-dp[i+1][j-1];

	    		   else  dp[i][j]=dp[i][j-1]+dp[i+1][j]-dp[i+1][j-1];

	    		   if(dp[i][j]>=1){b=true;}
	    	   }
	       }

	    return b;
   // return dp[0][n-1];

    }

public static int gcd(int a,int b)
{
	int res=1;
	while(a>0)
	{
		res=a;
		a=b%a;
		b=res;
	}
	return res;
}

public static long pow(long n,long p,long m)
{
	 long  result = 1;
	  if(p==0)
	    return 1;
	if (p==1)
	    return n;
	while(p!=0)
	{
	    if(p%2==1)
	        result *= n;
	    if(result>=m)
	    result%=m;
	    p >>=1;
	    n*=n;
	    if(n>=m)
	    n%=m;
	}
	return result;
}
public static long pow(long n,long p)
{
	long  result = 1;
	  if(p==0)
	    return 1;
	if (p==1)
	    return n;
	while(p!=0)
	{
	    if(p%2==1)
	        result *= n;
	    p >>=1;
	    n*=n;
	}
	return result;

}

static class Edge implements Comparator<Edge> {
	public int u;
	public int v;
	public int w;
	public Edge() {
	}
	public Edge(int u, int v, int w) {
		this.u=u;
		this.v=v;
		this.w=w;
	}
	public int getU() {
		return u;
	}
	public void setU(int u) {
		this.u = u;
	}
	public int getV() {
		return v;
	}
	public void setV(int v) {
		this.v = v;
	}
	public int getW() {
		return w;
	}
	public void setW(int w) {
		this.w = w;
	      }

	@Override
	public int compare(Edge e1, Edge e2) {
		return  e2.w-e1.w;
	}
}

static class Pair implements Comparable<Pair>
{
	int a,b;
	Pair (int a,int b)
	{
		this.a=a;
		this.b=b;
	}

        @Override
        public int compareTo(Pair o) {
            //throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.

           return this.b-o.b;
        }

}

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

   private SpaceCharFilter filter;
    byte inbuffer[] = new byte[1024];
   int lenbuffer = 0, ptrbuffer = 0;
    final int M = (int) 1e9 + 7;
   int md=(int)(1e7+1);
    int[] SMP=new int[md];
   final double eps = 1e-6;
   final double pi = Math.PI;

	PrintWriter out;
   String check = "";
 InputStream   obj = check.isEmpty() ? System.in : new ByteArrayInputStream(check.getBytes());
   public InputReader(InputStream stream)
   {
       this.stream = stream;
   }

    int readByte() {
	        if (lenbuffer == -1) throw new InputMismatchException();
	        if (ptrbuffer >= lenbuffer) {
	            ptrbuffer = 0;
	            try {
	                lenbuffer = obj.read(inbuffer);
	            } catch (IOException e) {
	                throw new InputMismatchException();
	            }
	        }
	        if (lenbuffer <= 0) return -1;
	        return inbuffer[ptrbuffer++];
   }

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

   String is() {
	        int b = skip();
	        StringBuilder sb = new StringBuilder();
	        while (!(isSpaceChar(b))) // when nextLine, (isSpaceChar(b) && b!=' ')
	        {
	            sb.appendCodePoint(b);
	            b = readByte();
	        }
	        return sb.toString();
   }
   public   int ii() {
	        int num = 0, b;
	        boolean minus = false;
	        while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) ;
	        if (b == '-') {
	            minus = true;
	            b = readByte();
	        }
	        while (true) {
	            if (b >= '0' && b <= '9') {
	                num = num * 10 + (b - '0');
	            } else {
	                return minus ? -num : num;
	            }
	            b = readByte();
	        }
   }
 public   long il() {
	        long num = 0;
	        int b;
	        boolean minus = false;
	        while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) ;
	        if (b == '-') {
	            minus = true;
	            b = readByte();
	        }
	        while (true) {
	            if (b >= '0' && b <= '9') {
	                num = num * 10 + (b - '0');
	            } else {
	                return minus ? -num : num;
	            }
	            b = readByte();
	        }
   }

	    boolean isSpaceChar(int c) {
	        return (!(c >= 33 && c <= 126));
	       }

	      int skip()
	        {
	        int b;
	        while ((b = readByte()) != -1 && isSpaceChar(b)) ;
	        return b;
	        }

	    float nf() {
	        return Float.parseFloat(is());
	    }

	    double id() {
	        return Double.parseDouble(is());
	    }

	    char ic() {
	        return (char) skip();
	    }

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

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

	    String[] isa(int n) {
	        String a[] = new String[n];
	        for (int i = 0; i < n; i++) a[i] = is();
	        return a;
	    }

		 long mul(long a, long b) { return a * b % M; }

			long div(long a, long b)
				 {
					return mul(a, pow(b, M - 2));

		           }

	    double[][] idm(int n, int m) {
	        double a[][] = new double[n][m];
	        for (int i = 0; i < n; i++) for (int j = 0; j < m; j++) a[i][j] = id();
	        return a;
	        }

	    int[][] iim(int n, int m) {
	        int a[][] = new int[n][m];
	        for (int i = 0; i < n; i++) for (int j = 0; j <m; j++) a[i][j] = ii();
	        return a;
          }

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

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

}

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

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

    static class TaskC {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            BigInteger n = BigInteger.valueOf(in.nl() + 1);
            long k = in.nl();
            boolean var = true;
            for (long i = 2; i <= k && i <= 43; ++i) {
                if (n.remainder(BigInteger.valueOf(i)) != BigInteger.valueOf(0)) {
                    out.print("No");
                    var = false;
                    break;
                }
            }
            if (var) {
                out.print("Yes");
            }
        }

    }

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

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

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

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

    }
}

import java.io.*;
import java.util.*;
import java.lang.*;
    public class templ {
    int binarySearch(int arr[], int l, int r, int x)
    {
        if (r >= l)
        {
            int mid = l + (r - l)/2;
            if (arr[mid] == x)
            return mid;
            if (arr[mid] > x)
            return binarySearch(arr, l, mid-1, x);
            return binarySearch(arr, mid+1, r, x);
        }
        return -1;
    }
    int partition(int arr[], int low, int high)
    {
        int pivot = arr[high];
        int i = (low-1); // index of smaller element
        for (int j=low; j<high; j++)
        {
            if (arr[j] <= pivot)
            {
                i++;
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        int temp = arr[i+1];
        arr[i+1] = arr[high];
        arr[high] = temp;
        return i+1;
    }
    void sort(int arr[], int low, int high)
    {
        if (low < high)
        {
            int pi = partition(arr, low, high);
            sort(arr, low, pi-1);
            sort(arr, pi+1, high);
        }
    }
    public static void main(String[] args) throws FileNotFoundException {
     try
     {
        InputReader in = new InputReader(System.in);
        PrintWriter out = new PrintWriter(System.out);
        templ ob=new templ();
        long n=in.nextLong();
        long k=in.nextLong();
        if(k==1)
        {
            out.println("Yes");
        }
        else if(n%2==0)
        {
            out.println("No");
        }
        else if(n%2==1&&k==2)
        {
            out.println("Yes");
        }
        else
        {
            int K=0;
            int m[]=new int[100];
            for(long i=2;i<=k;i+=1)
            {
                if(n%i==0)
                {
                    K=1;
                    break;
                }
                else
                {
                    int p=(int)(n%i);
                    if(m[p]==1)
                    {
                        K=1;
                        break;
                    }
                    m[p]=1;
                    long x=n/i;
                    if(k>=x&&x!=1&&x!=i)
                    {
                        K=1;
                        break;
                    }
                }
            }
            if(K==1)
            out.println("No");
            else
            out.println("Yes");
        }
        out.close();
    }
        catch(Exception e){
        return;
    }
    }
    static class InputReader {

        private final InputStream stream;
        private final byte[] buf = new byte[8192];
        private int curChar, snumChars;

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

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

        public int nextInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public long nextLong() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            long res = 0;
            do {
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

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

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

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

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

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

    }
}

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

public class Main
{

    static class InputReader {

		private final InputStream stream;
		private final byte[] buf = new byte[8192];
		private int curChar, snumChars;

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

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

		public int nextInt() {
			int c = read();
			while (isSpaceChar(c)) {
				c = read();
			}
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			int res = 0;
			do {
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public long nextLong() {
			int c = read();
			while (isSpaceChar(c)) {
				c = read();
			}
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			long res = 0;
			do {
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

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

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

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

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

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

	}

    public static void main(String[] args)
    {

        InputReader sc = new InputReader(System.in);
        PrintWriter w = new PrintWriter(System.out);
        long n = sc.nextLong();
        long k = sc.nextLong();
        int flag = 0;
        long i = 0;
        for(i=1;i<=k;i++)
        {
            if(n % i != i-1)
            {
                flag = 1;
                break;
            }
        }
    if(flag == 1)
    {
        w.println("No");

    }
    else
    w.println("Yes");

        w.close();

    }

    public static int ip(String s){
		return Integer.parseInt(s);
	}

	static int gcd(int l,int b)
    {
        int r = -1;
        int x = l;
        int y = b;

            while(y != 0)
        {
                r = x % y;
                x = y;
                y = r;

        }
            return x;
    }
}

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;
import java.util.HashSet;
import java.util.StringTokenizer;

public class Main {

    public static void main(String[] args) throws UnsupportedEncodingException, IOException {
        Reader.init(System.in);
        StringBuilder out = new StringBuilder();
        long n = Reader.nextLong(), k = Reader.nextLong();
        HashSet<Long> set = new HashSet<Long>();
        for(long i = 1; i <= k; i++)
            if(!set.add(n % i)) {
                System.out.println("No");
                return;
            }
        out.append("Yes\n");
        PrintWriter pw = new PrintWriter(System.out);
        pw.print(out);
        pw.close();
    }

}

class Reader {

    static BufferedReader reader;
    static StringTokenizer tokenizer;

    static void init(InputStream input) throws UnsupportedEncodingException {
        reader = new BufferedReader(
                new InputStreamReader(input, "UTF-8"));
        tokenizer = new StringTokenizer("");
    }

    static void init(String url) throws FileNotFoundException {
        reader = new BufferedReader(new FileReader(url));
        tokenizer = new StringTokenizer("");
    }

    static String next() throws IOException {
        while (!tokenizer.hasMoreTokens()) {
            //TODO add check for eof if necessary
            tokenizer = new StringTokenizer(
                    reader.readLine());
        }
        return tokenizer.nextToken();
    }

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

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

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

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

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

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
/**
 *
 * @author houssem
 */
public class CavePainting {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        Scanner sc = new Scanner(System.in);
        long n = sc.nextLong();
        long k = sc.nextLong();
        long res;

        if ((k < n)) {
            ArrayList<Long> T = new ArrayList<>();
            for (int i = 1; i <= k; i++) {
                res = n % i;
                if (T.contains(res)) {
                    System.out.println("No");
                    return;
                }
                T.add(res);

            }
            System.out.println("Yes");
        } else if ((k == 1) || ((n == 1)&&(k<3))) {
            System.out.println("Yes");
        } else {
            System.out.println("No");
        }
    }

}

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

public class Main {

    public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter pw = new PrintWriter(System.out);

        StringTokenizer st = new StringTokenizer(br.readLine());
        long n = Long.parseLong(st.nextToken());
        long k = Long.parseLong(st.nextToken());

        Set<Long> remainSet = new HashSet<>();
        for(int i = 1; i<=k; i++){
            long remainder = n%i;
            if(remainSet.contains(remainder)){
                System.out.println("No");
                return;
            }
            remainSet.add(remainder);
        }

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

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

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

/* Name of the class has to be "Main" only if the class is public. */
public class Ideone
{

	public static void main (String[] args) throws java.lang.Exception
	{
		Scanner obj=new Scanner(System.in);
		long n=obj.nextLong();
		long k=obj.nextLong();
		int ct=0;
		for(long i=1;i<=k;i++)
		{
			if((n%i)!=(i-1))
			{
				System.out.println("No");
				ct++;
				break;

			}

		}
		if(ct==0)
			System.out.println("Yes");

	}
}

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

import static java.lang.Long.parseLong;

public class C_Cave_Painting {
    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer tk = new StringTokenizer(in.readLine());
        HashSet<Long> set = new HashSet<>();
        long a = parseLong(tk.nextToken());
        long b = parseLong(tk.nextToken());
        int log = 60;
        boolean flag = true;
        if(b <= log){
            for (int i = 1; i <= b; i++) {
                if(set.contains(a % i)){
                    flag = false;
                    break;
                }
                set.add(a % i);
            }
            if(flag){
                System.out.println("Yes");
            }
            else {
                System.out.println("No");
            }
        }
        else if ((a % (b - 1) == b  && a > b)) {
            System.out.println("Yes");
        } else {
            System.out.println("No");
        }
    }
}

import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Set;
import java.util.HashSet;

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

        try {
            String masukan = in.readLine();
            String[] tokens = masukan.split(" ");
            long n = Long.parseLong(tokens[0]);
            long k = Long.parseLong(tokens[1]);

            if(n == 1 && k == 1) System.out.println("Yes");
            else {
                boolean res = true;
                Set<Long> moduloSet = new HashSet<Long>();
                for(long i = 1; i <= k; i++) {
                    long modulo = n % i;
                    if(moduloSet.contains(n % i)) {
                        res = false;
                        break;
                    } else {
                        moduloSet.add(modulo);
                    }
                }

                if(res) System.out.println("Yes");
                else System.out.println("No");
            }
        } finally {
            in.close();
        }
    }
}

import java.io.*;
import java.util.Arrays;
import java.util.StringJoiner;
import java.util.StringTokenizer;
import java.util.function.Function;

public class Main {

    static long N, K;

    public static void main(String[] args) {
        FastScanner sc = new FastScanner(System.in);
        N = sc.nextLong();
        K = sc.nextLong();

        System.out.println( solve() ? "Yes" : "No" );
    }

    static boolean solve() {
        if( N % 2 == 0 ) {
            // 1 -> 0
            // 2 -> 0 x
            return K == 1;

        } else {
            // 1 -> 0
            // 2 -> 1
            // 3 -> 2 only
            // 4 -> 3 only
            // ....
            if( K <= 2 ) {
                return true;

            } else {
                for (int i = 3; i <= K ; i++) {
                    if( N % i != i-1 ) {
                        return false;
                    }
                }
                return true;
            }
        }
    }

    @SuppressWarnings("unused")
    static class FastScanner {
        private BufferedReader reader;
        private StringTokenizer tokenizer;

        FastScanner(InputStream in) {
            reader = new BufferedReader(new InputStreamReader(in));
            tokenizer = null;
        }

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

        String nextLine() {
            if (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    return reader.readLine();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken("\n");
        }

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

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

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

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

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

    static <A> void writeLines(A[] as, Function<A, String> f) {
        PrintWriter pw = new PrintWriter(System.out);
        for (A a : as) pw.println(f.apply(a));
        pw.flush();
    }

    static void writeLines(int[] as) {
        PrintWriter pw = new PrintWriter(System.out);
        for (int a : as) pw.println(a);
        pw.flush();
    }

    static void writeLines(long[] as) {
        PrintWriter pw = new PrintWriter(System.out);
        for (long a : as) pw.println(a);
        pw.flush();
    }

    static void writeSingleLine(int[] as) {
        PrintWriter pw = new PrintWriter(System.out);
        for (int i = 0; i < as.length; i++) {
            if (i != 0) pw.print(" ");
            pw.print(i);
        }
        pw.println();
        pw.flush();
    }

    static int max(int... as) {
        int max = Integer.MIN_VALUE;
        for (int a : as) max = Math.max(a, max);
        return max;
    }

    static int min(int... as) {
        int min = Integer.MAX_VALUE;
        for (int a : as) min = Math.min(a, min);
        return min;
    }

    static int lowerBound(int[] array, int value) {
        int low = 0;
        int high = array.length;
        int mid;
        while (low < high) {
            mid = ((high - low) >>> 1) + low;
            if (array[mid] < value) low = mid + 1;
            else high = mid;
        }
        return low;
    }

    static int upperBound(long[] array, long value) {
        int low = 0;
        int high = array.length;
        int mid;
        while (low < high) {
            mid = ((high - low) >>> 1) + low;
            if (array[mid] <= value) low = mid + 1;
            else high = mid;
        }
        return low;
    }

    static void debug(Object... args) {
        StringJoiner j = new StringJoiner(" ");
        for (Object arg : args) {
            if (arg instanceof int[]) j.add(Arrays.toString((int[]) arg));
            else if (arg instanceof long[]) j.add(Arrays.toString((long[]) arg));
            else if (arg instanceof double[]) j.add(Arrays.toString((double[]) arg));
            else if (arg instanceof Object[]) j.add(Arrays.toString((Object[]) arg));
            else j.add(arg.toString());
        }
        System.err.println(j.toString());
    }
}

import java.io.BufferedReader;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;

	public class C {

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

			long n=sc.nextLong(),k=sc.nextLong();

			 if(k>=100)
			{
				System.out.println("No");
				return;
			}
			for(int i=1;i<=k;i++)
			    if(n%i!=i-1)
			    {
			        System.out.println("No");
			        return;
			    }
			System.out.println("Yes");

		}
		static class Scanner
		{
			BufferedReader br;
			StringTokenizer st;
			public Scanner(InputStream s)
			{
				br=new BufferedReader(new InputStreamReader(s));
			}
			public String nextLine() throws IOException
			{
				return br.readLine();
			}
			public String next() throws IOException
			{
				while(st==null || !st.hasMoreTokens())
					st=new StringTokenizer(br.readLine());
				return st.nextToken();
			}
			public int nextInt() throws IOException
			{
				return Integer.parseInt(next());

			}
			public double nextDouble() throws IOException
			{
				return Double.parseDouble(next());
			}
			public boolean ready() throws IOException
			{
				return br.ready();
			}
			public long nextLong() throws IOException
			{
				return Long.parseLong(next());
			}
		}
	}

import java.util.*;
import java.io.*;
import java.lang.*;
import java.math.*;
import static java.lang.Math.*;

public class Sol implements Runnable {

    long mod = (long)1e9 + 7;

    long gcd(long a, long b) {
        if(a == 0) return b;
        return gcd(b % a, a);
    }

    void solve(int total_test_cases, InputReader in, PrintWriter w) {
        for (int test_case = 1; test_case <= total_test_cases; test_case++) {
            long n = in.nextLong(), k = in.nextLong();
            ++n;

            if(n < k) w.println("NO");
            else {
                long lcm = 1, x = 0;
                long limit = Long.MAX_VALUE;

                while(lcm < limit && x < k) {
                    ++x;
                    lcm = (lcm * x) / gcd(lcm, x);

                    if(n % lcm != 0) {
                        w.println("NO");
                        return;
                    }
                }

                w.println("YES");
            }
        }
    }

    // ************* Code ends here ***************

    void init() throws Exception {
        //Scanner in;
        InputReader in;
        PrintWriter w;
        boolean online = false;

        String common_in_fileName = "\\in";
        String common_out_fileName = "\\out";
        int test_files = 0;

        for(int file_no = 0; file_no <= test_files; file_no++) {

            String x = "" + file_no;
            if (x.length() == 1) x = "0" + x;

            String in_fileName = common_in_fileName + "" + x;
            String out_fileName = common_out_fileName + "" + x;

            if (online) {
                //in = new Scanner(new File(in_fileName + ".txt"));
                in = new InputReader(new FileInputStream(new File(in_fileName + ".txt")));
                w = new PrintWriter(new FileWriter(out_fileName + ".txt"));
            } else {
                //in = new Scanner(System.in);
                in = new InputReader(System.in);
                w = new PrintWriter(System.out);
            }

            solve(1, in, w);
            w.close();
        }
    }

    public void run() {
        try {
            init();
        }
        catch(Exception e) {
            System.out.println(e);
            e.printStackTrace();
        }
    }

    public static void main(String args[]) throws Exception {
        new Thread(null, new Sol(),"Sol",1<<28).start();
    }

    static class InputReader {

        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private SpaceCharFilter filter;

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

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }

            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }

                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public String nextLine() {
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

        public int nextInt() {
            int c = read();

            while (isSpaceChar(c)) {
                c = read();
            }

            int sgn = 1;

            if (c == '-') {
                sgn = -1;
                c = read();
            }

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

            return res * sgn;
        }

        public long nextLong() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            long res = 0;

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

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

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

            return res.toString();
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

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

        public interface SpaceCharFilter {

            public boolean isSpaceChar(int ch);
        }
    }
}

import java.util.Scanner;

public class Contest922ProblemC {

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

		Scanner in= new Scanner(System.in);

		long n=in.nextLong();
		long k=in.nextLong();

		for(int i=1;i<=k;i++) {
			if((n+1)%i!=0) {
				System.out.println("No");
				break;
			}
			else if(i==k) {
			System.out.println("Yes");
			}
		}

	}

}

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

public class Codeforces {

    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

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

        FastReader(final InputStream is) {
            if (is != null)
                br = new BufferedReader(new
                                        InputStreamReader(is));
            else new FastReader();
        }

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

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

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

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

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

        int[] nextIntArray(int n) throws Exception {
            if (n < 0) throw new Exception("Array size should be non negative");
            int[] array = new int[n];
            for (int i = 0; i < n; i++) array[i] = nextInt();
            return array;
        }
        long[] nextLongArray(int n) throws Exception {
            if (n < 0) throw new Exception("Array size should be non negative");
            long[] array = new long[n];
            for (int i = 0; i < n; i++) array[i] = nextLong();
            return array;
        }
    }

    static PrintWriter writer;

    static int MOD = 1_000_000_007;
    public static void main(String args[]) throws Exception {
        final FastReader reader = new FastReader();
        writer = new PrintWriter(new BufferedOutputStream(System.out));
        long lcm = 1;
        long n = reader.nextLong();
        long k = reader.nextLong();
        if (k > 42) {
            writer.println("No");
        } else {
            boolean pos = true;
            n++;
            for (int i = 1; i <= k; i++) {
                if (n % i != 0) {
                    pos = false;
                    break;
                }
            }
            if (pos) writer.println("Yes");
            else writer.println("No");
        }
        writer.close();
    }
}

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

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

    static class TaskC {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            long x = in.nextLong(), y = in.nextLong();
            Set<Long> hs = new HashSet<>();
            for (int i = 1; i <= Math.min(y, 10000000); ++i) {
                if (!hs.add(x % i)) {
                    out.println("No");
                    return;
                }
            }
            out.println("Yes");
        }

    }

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

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

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

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

    }
}

//package code_forces;

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

public class Problem_922C {
	public static void main(String[] args) throws IOException {
		Scanner sc = new Scanner();
		PrintWriter pw = new PrintWriter(System.out);
		long n=sc.nextLong();
		long k=sc.nextLong();
		HashSet<Long>hs= new HashSet<>();
		if(k<=2 && n==1 )
		{
			pw.println("Yes");
		}
		else if(k>=n)
		{
			pw.println("No");
		}
		else
		{
			for(long i=1;i<=k;i++)
			{
				if(hs.contains((long)n%i))
				{
					pw.println("No");
					pw.flush();
					return;
				}
				hs.add((long)n%i);
			}
			pw.println("Yes");
		}
		pw.close();
	}

	static class Scanner {
		BufferedReader br;
		StringTokenizer st;

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

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

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

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

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

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

		boolean hasnext() throws IOException {
			return br.ready();
		}

	}
}

import java.util.Scanner;

public class Test {
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		String input = sc.nextLine();
		String[] inputs = input.split(" ");
		long n = Long.parseLong(inputs[0]);
		long k = Long.parseLong(inputs[1]);
//		System.out.println(n + " " + k);
		if(k == 1){
			System.out.println("Yes");
			return;
		}
		if(n == 1){
			if(k == 2){
				System.out.println("Yes");
				return;
			}else{
				System.out.println("No");
				return;
			}
		}
		if(k >= n){
			System.out.println("No");
			return;
		}
		for(long i = 1;i <= k;i++){
			if(n % i != i - 1){
				System.out.println("No");
				return;
			}
		}
		System.out.println("Yes");
	}
}

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Writer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.InputMismatchException;
import java.util.Queue;

public class A3 {

	public static void main(String[] args) {
		InputReader in = new InputReader(System.in);
		OutputWriter out = new OutputWriter(System.out);
		long n = in.readLong();
		long m = in.readLong();
		int[] mod = new int[100000];
		int j = 1;
		boolean ans = false;
		HashMap<Long, Long> map = new HashMap<>();
		if (m <= Math.sqrt(n) + 1) {
			while (j <= m) {
				if (map.containsKey(n % j)) {
					ans = true;
					break;
				} else {
					map.put(n % j, n % j);
				}
				j++;
			}
		} else {
			ans = true;
		}
		if (!ans)
			System.out.println("YES");
		else
			System.out.println("NO");
		out.close();
	}

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

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

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

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

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

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

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

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

	private static class OutputWriter {
		private final PrintWriter writer;

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

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

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

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

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

import java.io.IOException;
import java.util.*;
import java.math.*;
import java.io.*;
import java.util.InputMismatchException;

public class main {
	public static void main(String[] args) {
                new main().solve();
                                  }
            public void solve(){long n=sc.nextLong();long k=sc.nextLong();int c=0;int d=0;int h=0;int f=0;int l=0;
           if(n==1&&k==1||(n==1&&k==2)||k==1){
                          System.out.println("Yes");l=1;}
            if(n%2==0&&l==0){

            System.out.println("No");c=1;}
            if(k>=n/2&&n/2>2&&c==0&&l==0){
            System.out.println("No");d=1;}
            if(n<=5&&d==0&&c==0&&l==0){
                   if(k>(n/2)+1){
                          System.out.println("No");f=1;
                   }
            }
            if(c==0&&d==0&&f==0&&l==0){
                   for(int i=1;i<=k;i++){
                          if(n%i!=i-1){
                                 h=1;break;
                          }
                   }
            }
            if(h==0&&c==0&&d==0&&f==0&&l==0)
            System.out.println("Yes");
          if(h==1)
          System.out.println("No");

            }

FasterScanner sc=new FasterScanner();

    public class FasterScanner {
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;

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

        public double nextDouble() {
			// TODO Auto-generated method stub
			return 0;
		}

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

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

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

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

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

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

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

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

import java.util.Scanner;

public class C {

    public static void main(String args[]) {

        Scanner scanner = new Scanner(System.in);

        long n = scanner.nextLong();
        long k = scanner.nextLong();

        for (long i = 1; i <= k; i++) {
            if (n % i != i - 1) {
                System.out.println("No");

                return;
            }
        }

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

}

import java.util.*;

public class C {
	public static void main(String... args) {
		Scanner sc = new Scanner(System.in);
		long n = sc.nextLong();
		long k = sc.nextLong();

		HashSet<Long> set = new HashSet<Long>();
		for (int i = 1; i <= k; i++) {
			if (!set.contains(n % i))
				set.add(n % i);
			else {
				System.out.print("No");
				System.exit(0);
			}
		}

		System.out.print("Yes");
	}
}

import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        try(Scanner in = new Scanner(new InputStreamReader(System.in))){
            long n = in.nextLong();
            long k = in.nextLong();
            if(n==1 && (k==1 || k==2)){
                System.out.println("YES");
                return;
            }
            if(k>=n){
                System.out.println("NO");
                return;
            }
            boolean [] ht = new boolean[1000000];
            Arrays.fill(ht,false);
            for(long i=1;i<=k;i++){
                if(ht[(int)(n%i)]){
                    System.out.println("NO");
                    return;
                }
                ht[(int)(n%i)]=true;
            }
            System.out.println("YES");
        }
        catch (Exception ex){
            ex.printStackTrace();
        }
    }
}

import com.sun.prism.shader.Solid_TextureYV12_AlphaTest_Loader;
import org.omg.Messaging.SYNC_WITH_TRANSPORT;
import org.omg.Messaging.SyncScopeHelper;

import java.math.BigInteger;
import java.util.*;
import java.io.*;
public class Main {
          public static void main(String[] args) throws IOException {
            // TODO Auto-generated method stub
            Scanner S = new Scanner(System.in);
            long n=S.nextLong(),k=S.nextLong();
              if(n==1&&k==1){System.out.println("Yes");System.exit(0);}
            //if(k>n-1){System.out.println("No");System.exit(0);}
            List<Long>rems=new ArrayList<>();
              if(n==1&&k>2){System.out.println("No");System.exit(0);}
              if(n==1&&k==2){System.out.println("Yes");System.exit(0);}
            for (int i = 1; i <=Math.sqrt(n)+1; i++) {
                  if(rems.contains(n%i)&&i<=k){
                      System.out.println("No");
                      System.exit(0);
                  }
                  if(i<=k)
                  rems.add(n%i);
                  else break;
              }
              //System.out.println(rems);
              if(k>(Math.sqrt(n)+1))System.out.println("No");
              else System.out.println("Yes");
        }
}

import java.math.BigInteger;
import java.util.*;

public class Main {

    static HashSet<Long> hashSet = new HashSet<>();

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        long n = sc.nextLong();
        long mod = sc.nextLong();
        long new_mod = mod;
        if ((mod == n && n != 1) || (mod > n &&  (mod - n > 1))) {
            System.out.println("No");
            return;
        }
        if (new_mod >= n / 2 + 1)
            new_mod = n / 2 + 1;

        for (long i = 1; i <= new_mod; i++) {
            if (hashSet.contains(n % i) || (n % i > n % mod)) {
                System.out.println("No");
                return;
            }
            hashSet.add(n % i);
        }
        System.out.println("Yes");
    }
}
// 1000000000000000000 1000000000000000000
// n = 1 mod = 2

import java.util.*;

public class Main
{
	public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        HashMap <Integer, Boolean> mp = new HashMap<>();
        long n = in.nextLong();
        long k = in.nextLong();
        if(k >= 1e6) prr("NO");
        for(long i = 1; i <= k; i++) {
            if(mp.containsKey((int)(n % i))) prr("NO");
            mp.put((int)(n % i), true);
        }
        prr("YES");
	}
	public static void prr(String s) {
	    System.out.println(s);
	    System.exit(0);
	}
}

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

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

    static class TaskC {
        public void solve(int testNumber, InputReader in, FastWriter out) {
            long n = in.nextLong();
            long k = in.nextLong();

            for (int i = 1; i <= Math.min(50, k); i++) {
                if (n % i != i - 1) {
                    out.println("No");
                    return;
                }
            }
            out.println("Yes");
        }

    }

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

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

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

    }

    static class InputReader extends BufferedReader {
        StringTokenizer tokenizer;

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

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

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

        public Long nextLong() {
            return Long.valueOf(next());
        }

    }
}

// package cf922;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.math.BigInteger;
import java.util.*;
import java.util.function.Supplier;

public class CFC {
    private static final String INPUT = "807873101233533988 39";

    FastScanner sc;

    public static void main(String[] args) { new CFC().run(); }
    public void run() {
        sc = new FastScanner(oj ? System.in : new ByteArrayInputStream(INPUT.getBytes()));

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

    public void solve() {
        long n = sc.nextLong();
        long k = sc.nextLong();

        Set<Long> set = new HashSet<>();
        for (long i = 1; i <= k; i++) {
            if (!set.add(n%i)) {
                System.out.println("No");
                return;
            }
        }
        System.out.println("Yes");
    }

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

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

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

    private static <T> T elvis(T obj, Supplier<T> defValue) {
        return obj == null ? defValue.get() : obj;
    }

    @SuppressWarnings("SameParameterValue")
    private static <T> T elvis(T obj, T defValue) {
        return obj == null ? defValue : obj;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

    private boolean oj = System.getProperty("ONLINE_JUDGE") != null;
    private void tr(Object... o) { if(!oj)System.out.println(Arrays.deepToString(o)); }
}

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.*;
public class C {
	InputStream is;
	PrintWriter out;
	String INPUT = "";

	void solve()
	{
        long n = nl(), k = nl();
        boolean flag = true;
        if(k>=n){
            flag = false;
        }
        if(k!=1){
            for(long i=2;i<=k;i++){
                if(n%i!=(i-1)){
                    flag = false;
                    break;
                }
            }
        }
        if(n==1 && k==1) flag = true;
        if(n==1 && k==2) flag = true;
        if(flag) System.out.println("Yes");
        else System.out.println("No");
	}

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

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

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

	private byte[] inbuf = new byte[1024];
	public int lenbuf = 0, ptrbuf = 0;

	private int readByte()
	{
		if(lenbuf == -1)throw new InputMismatchException();
		if(ptrbuf >= lenbuf){
			ptrbuf = 0;
			try { lenbuf = is.read(inbuf); } catch (IOException e) { throw new InputMismatchException(); }
			if(lenbuf <= 0)return -1;
		}
		return inbuf[ptrbuf++];
	}

	private boolean isSpaceChar(int c) { return !(c >= 33 && c <= 126); }
	private int skip() { int b; while((b = readByte()) != -1 && isSpaceChar(b)); return b; }

	private double nd() { return Double.parseDouble(ns()); }
	private char nc() { return (char)skip(); }

	private String ns()
	{
		int b = skip();
		StringBuilder sb = new StringBuilder();
		while(!(isSpaceChar(b))){ // when nextLine, (isSpaceChar(b) && b != ' ')
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	}

	private char[] ns(int n)
	{
		char[] buf = new char[n];
		int b = skip(), p = 0;
		while(p < n && !(isSpaceChar(b))){
			buf[p++] = (char)b;
			b = readByte();
		}
		return n == p ? buf : Arrays.copyOf(buf, p);
	}

	private char[][] nm(int n, int m)
	{
		char[][] map = new char[n][];
		for(int i = 0;i < n;i++)map[i] = ns(m);
		return map;
	}

	private int[] na(int n)
	{
		int[] a = new int[n];
		for(int i = 0;i < n;i++)a[i] = ni();
		return a;
	}

	private int ni()
	{
		int num = 0, b;
		boolean minus = false;
		while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
		if(b == '-'){
			minus = true;
			b = readByte();
		}

		while(true){
			if(b >= '0' && b <= '9'){
				num = num * 10 + (b - '0');
			}else{
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	private long nl()
	{
		long num = 0;
		int b;
		boolean minus = false;
		while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
		if(b == '-'){
			minus = true;
			b = readByte();
		}

		while(true){
			if(b >= '0' && b <= '9'){
				num = num * 10 + (b - '0');
			}else{
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

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

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

	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		PrintWriter out = new PrintWriter(System.out);
		String[] s = br.readLine().trim().split(" ");
		long n = Long.parseLong(s[0]);
		long k = Long.parseLong(s[1]);
		if(k > 44)
		{
			System.out.println("No");
			return;
		}
		else
		{
			for(int i = 2 ; i <= k; i ++)
			{
				if((n+1)%i != 0)
				{
					System.out.println("No");
					return;
				}
			}
		}
		System.out.println("Yes");
	}
}

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

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

		StringTokenizer st = new StringTokenizer(buf.readLine());

		long n = Long.parseLong(st.nextToken());
		long k = Long.parseLong(st.nextToken());
		List<Long> l = new ArrayList<Long>();
		long rem;

		if(k == 1)
		{
			System.out.println("Yes");
			System.exit(0);
		}

		if(n > 1 && k >= n)
		{
			System.out.println("No");
			System.exit(0);
		}

		for(int i = 1; i <= k; i++)
		{
			rem = n % i;

			if(l.contains(rem))
			{
				System.out.println("No");
				System.exit(0);
			}
			else
				l.add(rem);

		}

		System.out.println("Yes");

	}
}

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

public class Main{
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		long n = sc.nextLong() , k = sc.nextLong();
		if(n==1 && k<=2){
			System.out.print("Yes");return;
		}
		if(n<=k){
			System.out.print("No");return;
		}
		boolean arr[] = new boolean[50000001];
		int l = (int) Math.min(50000000,k);
		for(int i = 1;i<=l;i++){
			int x = (int)(n%i);
			if(arr[x]) {
				System.out.print("No");return;
			}
			arr[x] = true;
		}
		System.out.print("Yes");
		out.close();
	}
}

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

public class CavePainting {

	static class FastReader
    {
        BufferedReader br;
        StringTokenizer st;

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

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

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

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

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

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

	public static String func(long n, long k){

		HashSet<Integer> set = new HashSet<>();

		if (k>=43){
			return "No";
		}

		for (int i=1;i<=k;i++){
			int x = (int)(n%i);
			if (set.contains(x)){
				return "No";
			}else{
				set.add(x);
			}

		}

		return "Yes";
	}

	public static void main(String[] args) {
		FastReader s = new FastReader();
		long n = s.nextLong();
		long k = s.nextLong();

		System.out.println(func(n,k));
	}

}

import java.util.LinkedList;
import java.util.Scanner;

public class Cave_Painting_922_C {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        long n = in.nextLong();
        long k = in.nextLong();
//        if (k >= n && k!=1) {
//            System.out.println("No");
//        } else {
            LinkedList<Long> l = new LinkedList<Long>();
            long ans = 1;
            GCD g = new GCD();
            int i = 1;
            l.add(0l);
            while (ans >= 0) {
                ans = ans * i / g.calc_gcd(ans, i);
                l.add(ans);
                i++;
            }
            try {
                long a = l.get((int)k);
                if ((n + 1) % a == 0) {
                    System.out.println("Yes");
                } else {
                    System.out.println("No");
                }
            } catch (Exception e) {
                System.out.println("No");
                System.exit(0);
            }
//        }
    }
}

class GCD {

    public GCD() {
        // Sry Nothing to initalise
    }

    public long a_inv_b(long a, long m) {
        if (gcd(a, m) == 1) {
            long m0 = m;
            long y = 0, x = 1;
            if (m == 1) {
                return 0;
            }
            while (a > 1) {
                long q = a / m;
                long t = m;
                m = a % m;
                a = t;
                t = y;
                y = x - q * y;
                x = t;
            }
            if (x < 0) {
                x += m0;
            }
            return x;
        } else {
            return -1;
        }
    }

    public int calc_gcd(int a, int b) {
        if (b > a) {
            a = a ^ b;
            b = a ^ b;
            a = a ^ b;
        }
        return (int) gcd(a, b);
    }

    public long calc_gcd(long a, long b) {
        if (b > a) {
            a = a ^ b;
            b = a ^ b;
            a = a ^ b;
        }
        return gcd(a, b);
    }

    private long gcd(long a, long b) {
        if (b == 0) {
            return a;
        }
        long gcd = gcd(b, a % b);
        return gcd;
    }
}

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

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

    static class TaskC {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            long x = in.nextLong(), y = in.nextLong();
            Set<Long> hs = new HashSet<>();
            for (int i = 1; i <= Math.min(y, 10000000); ++i) {
                if (!hs.add(x % i)) {
                    out.println("No");
                    return;
                }
            }
            out.println("Yes");
        }

    }

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

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

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

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

    }
}

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

import java.math.BigInteger;
import java.util.BitSet;
import java.util.Scanner;
import java.util.Vector;

/**
 *
 * @author hre doy
 */
public class Main {

    /**
     * @param args the command line arguments
     */

    public static void main(String[] args) {

        double out=0.0;
        Scanner reader=new Scanner(System.in);

       long n = reader.nextLong();
        long k = reader.nextLong();
        k = Math.min(k, 1000000);
        for (int i = 1; i <= k; i++) {
            if (n % i != i - 1) {
                System.out.println("No");
                return;
            }
        }
        System.out.println("Yes");

    }

}

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
import java.util.TreeMap;

public class Template {

	public static void main(String[] args) throws IOException {
		//Scanner sc = new Scanner(System.in);
		FastReader sc = new FastReader(System.in);

        long n = sc.nextLong();
        long k = sc.nextLong();

        HashSet<Long> set= new HashSet<Long>();
        for(long i = 1; i<=k; i++) {
        	long mod = n % i;
        	if(set.contains(mod)) {
        		System.out.println("No");
        		return ;
        	}
        	else {
        		set.add(mod);
        	}
        }
        System.out.println("Yes");

	}

}

class FastReader{

        byte[] buf = new byte[2048];
        int index, total;
        InputStream in;

        FastReader(InputStream is) {
            in = is;
        }

        int scan() throws IOException {
            if (index >= total) {
                index = 0;
                total = in.read(buf);
                if (total <= 0) {
                    return -1;
                }
            }
            return buf[index++];
        }

        String next() throws IOException {
            int c;
            for (c = scan(); c <= 32; c = scan()) ;
            StringBuilder sb = new StringBuilder();
            for (; c > 32; c = scan()) {
                sb.append((char) c);
            }
            return sb.toString();
        }

        int nextInt() throws IOException {
            int c, val = 0;
            for (c = scan(); c <= 32; c = scan()) ;
            boolean neg = c == '-';
            if (c == '-' || c == '+') {
                c = scan();
            }
            for (; c >= '0' && c <= '9'; c = scan()) {
                val = (val << 3) + (val << 1) + (c & 15);
            }
            return neg ? -val : val;
        }

        long nextLong() throws IOException {
            int c;
            long val = 0;
            for (c = scan(); c <= 32; c = scan()) ;
            boolean neg = c == '-';
            if (c == '-' || c == '+') {
                c = scan();
            }
            for (; c >= '0' && c <= '9'; c = scan()) {
                val = (val << 3) + (val << 1) + (c & 15);
            }
            return neg ? -val : val;
        }

    }

class Entry implements Comparable<Entry> {
    private int key;
    private int value;

    public Entry(int key, int value) {
        this.key = key;
        this.value = value;
    }

    public int first() {
		return key;
	}

	public void setFirst(int key) {
		this.key = key;
	}

	public int second() {
		return value;
	}

	public void setSecond(int value) {
		this.value = value;
	}

	@Override
    public int compareTo(Entry other) {
        if(this.key > other.key)
        	return 1;
        else if(this.key < other.key)
        	return -1;
        else
        	return 0;

    }

	public static Entry add(int i, int j) {

		return new Entry(i, j);
	}
}

 class Pair<First, Second> {
    private First first;
    private Second second;

    public Pair(First first, Second second) {
        this.first = first;
        this.second = second;
    }

    public void setFirst(First first) {
        this.first = first;
    }

    public void setSecond(Second second) {
        this.second = second;
    }

    public First getFirst() {
        return first;
    }

    public Second getSecond() {
        return second;
    }

    public void set(First first, Second second) {
        setFirst(first);
        setSecond(second);
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Pair pair = (Pair) o;

        if (first != null ? !first.equals(pair.first) : pair.first != null) return false;
        if (second != null ? !second.equals(pair.second) : pair.second != null) return false;

        return true;
    }

    @Override
    public int hashCode() {
        int result = first != null ? first.hashCode() : 0;
        result = 31 * result + (second != null ? second.hashCode() : 0);
        return result;
    }

    static <L,R> Pair<L,R> add(L left, R right){
        return new Pair<L,R>(left, right);
    }

}

import java.util.Scanner;

public class Contest922ProblemC {

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

		Scanner in= new Scanner(System.in);

		long n=in.nextLong();
		long k=in.nextLong();

		for(int i=1;i<=k;i++) {
			if((n+1)%i!=0) {
				System.out.println("No");
				break;
			}
			else if(i==k) {
			System.out.println("Yes");
			}
		}

	}

}

import java.io.BufferedReader;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;

	public class C {

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

			long n=sc.nextLong(),k=sc.nextLong();

			 if(k>=100)
			{
				System.out.println("No");
				return;
			}
			for(int i=1;i<=k;i++)
			    if(n%i!=i-1)
			    {
			        System.out.println("No");
			        return;
			    }
			System.out.println("Yes");

		}
		static class Scanner
		{
			BufferedReader br;
			StringTokenizer st;
			public Scanner(InputStream s)
			{
				br=new BufferedReader(new InputStreamReader(s));
			}
			public String nextLine() throws IOException
			{
				return br.readLine();
			}
			public String next() throws IOException
			{
				while(st==null || !st.hasMoreTokens())
					st=new StringTokenizer(br.readLine());
				return st.nextToken();
			}
			public int nextInt() throws IOException
			{
				return Integer.parseInt(next());

			}
			public double nextDouble() throws IOException
			{
				return Double.parseDouble(next());
			}
			public boolean ready() throws IOException
			{
				return br.ready();
			}
			public long nextLong() throws IOException
			{
				return Long.parseLong(next());
			}
		}
	}

import com.sun.prism.shader.Solid_TextureYV12_AlphaTest_Loader;
import org.omg.Messaging.SYNC_WITH_TRANSPORT;
import org.omg.Messaging.SyncScopeHelper;

import java.math.BigInteger;
import java.util.*;
import java.io.*;
public class Main {
          public static void main(String[] args) throws IOException {
            // TODO Auto-generated method stub
            Scanner S = new Scanner(System.in);
            long n=S.nextLong(),k=S.nextLong();
              if(n==1&&k==1){System.out.println("Yes");System.exit(0);}
            //if(k>n-1){System.out.println("No");System.exit(0);}
            List<Long>rems=new ArrayList<>();
              if(n==1&&k>2){System.out.println("No");System.exit(0);}
              if(n==1&&k==2){System.out.println("Yes");System.exit(0);}
            for (int i = 1; i <=Math.sqrt(n)+1; i++) {
                  if(rems.contains(n%i)&&i<=k){
                      System.out.println("No");
                      System.exit(0);
                  }
                  if(i<=k)
                  rems.add(n%i);
                  else break;
              }
              //System.out.println(rems);
              if(k>(Math.sqrt(n)+1))System.out.println("No");
              else System.out.println("Yes");
        }
}

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

public class Main{
    public static void main(String[] args)throws IOException {
        FastReader sc = new FastReader();
        OutputStream output = System.out;
        PrintWriter out = new PrintWriter(output);
        long n = sc.nextLong();
        long k = sc.nextLong();
        HashSet<Long> hs = new HashSet<>();
        boolean flag=true;
        for(int i=1;i<=k&&i<=1000;i++) {
            if (!hs.add(n % i)) {
                flag=false;
                break;
            }
        }
        out.println(flag?"Yes":"No");
        out.close();
    }
    /*public static class indexing{
        int vertex,value;
        indexing(int a,int b) {
            vertex=a;
            value=b;
        }
    }*/
    static class FastReader
    {
        BufferedReader br;
        StringTokenizer st;

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

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

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

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

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

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

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.math.BigInteger;

public class CavePainting{
	static long stoi(String s){return Long.parseLong(s);}

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

		String[] line1 = r.readLine().split(" ");
		long n = stoi(line1[0]);
		long k = stoi(line1[1]);

		if(k < 10000){
			boolean flag = false;
			for(int i = 1; i <= k; i++){
				if(n % i != i - 1){
					flag = true;
					break;
				}
			}
			if(flag)
				System.out.println("No");
			else
				System.out.println("Yes");
		}else{
			System.out.println("No");
		}

		r.close();
	}
}

import java.util.*;

public class Main
{
	public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        HashMap <Integer, Boolean> mp = new HashMap<>();
        long n = in.nextLong();
        long k = in.nextLong();
        if(k >= 1e6) prr("NO");
        for(long i = 1; i <= k; i++) {
            if(mp.containsKey((int)(n % i))) prr("NO");
            mp.put((int)(n % i), true);
        }
        prr("YES");
	}
	public static void prr(String s) {
	    System.out.println(s);
	    System.exit(0);
	}
}

import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.*;

public class Main {
	public static void main(String[] args) {
		InputReader in = new InputReader();
		PrintWriter out = new PrintWriter(System.out);
		Thread th = new Thread(null, new Runnable(){public void run(){new Task1().solve(in, out);}},"Task1",1<<24);
		try{
			th.start();
			th.join();
		} catch(InterruptedException e){}
		out.close();
	}

	static class Task1{
		static final int MAX = 1000001;

		public void solve(InputReader in, PrintWriter out){
			long n = in.nextLong(), k = in.nextLong();
			if(n==1 && k<=2){
				out.println("Yes");
				return;
			}

			if(k>=n){
				out.println("No");
				return;
			}

			if(n%2==0 && k>1){
				out.println("No");
				return;
			}

			HashSet<Long> rem = new HashSet<Long>();
			for(long i=1; i<=Math.min(k, MAX); i++){
				if(rem.contains(n%i)){
					out.println("No");
					return;
				}
				rem.add(n%i);
			}

			long sqrt = (long)Math.sqrt(n);
			if(sqrt*sqrt == n){
				if(sqrt<=k){
					out.println("No");
					return;
				}
			}

			out.println("Yes");
		}

		long gcd(long a, long b){
			while(a>0){
				long rem = b%a;
				b = a;
				a = rem;
			}
			return b;
		}
		long expo(long a, long b, long MOD){
			long result = 1;
			while (b>0){
				if (b%2==1) result=(result*a)%MOD;
				b>>=1;
				a=(a*a)%MOD;
			}
			return result%MOD;
		}
		long inverseModullo(long numerator, long denominator, long MOD){
			return ((numerator )*(expo(denominator, MOD-2, MOD))) ;
		}
	}

	static class InputReader{
		final InputStream stream;
		final byte[] buf = new byte[8192];
		int curChar, numChars;
		SpaceCharFilter filter;
		public InputReader(){
			this.stream = System.in;
		}
		public int read(){
			if(numChars == -1) throw new InputMismatchException();
			if(curChar >= numChars){
				curChar = 0;
				try{
					numChars = stream.read(buf);
				} catch(IOException e){
					throw new InputMismatchException();
				}
				if(numChars <= 0) return -1;
			}
			return buf[curChar++];
		}
		public int nextInt(){
			int c = read();
			while(isSpaceChar(c)) c = read();
			int sgn = 1;
			if(c == '-'){
				sgn = -1;
				c = read();
			}
			int res = 0;
			do{
				if(c<'0' || c>'9') throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while(!isSpaceChar(c));
			return res*sgn;
		}
		public long nextLong(){
			int c = read();
			while(isSpaceChar(c)) c = read();
			int sgn = 1;
			if(c == '-'){
				sgn = -1;
				c = read();
			}
			long res = 0;
			do{
				if(c<'0' || c>'9') throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while(!isSpaceChar(c));
			return res*sgn;
		}
		public String next(){
			int c = read();
			while(isSpaceChar(c)) c = read();
			StringBuilder res = new StringBuilder();
			do{
				res.appendCodePoint(c);
				c = read();
			}while(!isSpaceChar(c));
			return res.toString();
		}
		public boolean isSpaceChar(int c){
			if(filter != null) return filter.isSpaceChar(c);
			return c==' ' || c=='\n' || c=='\r' || c=='\t' || c==-1;
		}
		public interface SpaceCharFilter{
			public boolean isSpaceChar(int ch);
		}
	}
}

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

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

/* Name of the class has to be "Main" only if the class is public. */
public class Ideone
{

	public static void main (String[] args) throws java.lang.Exception
	{
		Scanner obj=new Scanner(System.in);
		long n=obj.nextLong();
		long k=obj.nextLong();
		int ct=0;
		for(long i=1;i<=k;i++)
		{
			if((n%i)!=(i-1))
			{
				System.out.println("No");
				ct++;
				break;

			}

		}
		if(ct==0)
			System.out.println("Yes");

	}
}

import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.*;

public class Main {
	public static void main(String[] args) {
		InputReader in = new InputReader();
		PrintWriter out = new PrintWriter(System.out);
		Thread th = new Thread(null, new Runnable(){public void run(){new Task1().solve(in, out);}},"Task1",1<<24);
		try{
			th.start();
			th.join();
		} catch(InterruptedException e){}
		out.close();
	}

	static class Task1{
		static final int MAX = 1000001;

		public void solve(InputReader in, PrintWriter out){
			long n = in.nextLong(), k = in.nextLong();
			HashSet<Long> rem = new HashSet<Long>();
			for(long i=1; i<=Math.min(k, MAX); i++){
				if(rem.contains(n%i)){
					out.println("No");
					return;
				}
				rem.add(n%i);
			}

			out.println("Yes");
		}

		long gcd(long a, long b){
			while(a>0){
				long rem = b%a;
				b = a;
				a = rem;
			}
			return b;
		}
		long expo(long a, long b, long MOD){
			long result = 1;
			while (b>0){
				if (b%2==1) result=(result*a)%MOD;
				b>>=1;
				a=(a*a)%MOD;
			}
			return result%MOD;
		}
		long inverseModullo(long numerator, long denominator, long MOD){
			return ((numerator )*(expo(denominator, MOD-2, MOD))) ;
		}
	}

	static class InputReader{
		final InputStream stream;
		final byte[] buf = new byte[8192];
		int curChar, numChars;
		SpaceCharFilter filter;
		public InputReader(){
			this.stream = System.in;
		}
		public int read(){
			if(numChars == -1) throw new InputMismatchException();
			if(curChar >= numChars){
				curChar = 0;
				try{
					numChars = stream.read(buf);
				} catch(IOException e){
					throw new InputMismatchException();
				}
				if(numChars <= 0) return -1;
			}
			return buf[curChar++];
		}
		public int nextInt(){
			int c = read();
			while(isSpaceChar(c)) c = read();
			int sgn = 1;
			if(c == '-'){
				sgn = -1;
				c = read();
			}
			int res = 0;
			do{
				if(c<'0' || c>'9') throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while(!isSpaceChar(c));
			return res*sgn;
		}
		public long nextLong(){
			int c = read();
			while(isSpaceChar(c)) c = read();
			int sgn = 1;
			if(c == '-'){
				sgn = -1;
				c = read();
			}
			long res = 0;
			do{
				if(c<'0' || c>'9') throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while(!isSpaceChar(c));
			return res*sgn;
		}
		public String next(){
			int c = read();
			while(isSpaceChar(c)) c = read();
			StringBuilder res = new StringBuilder();
			do{
				res.appendCodePoint(c);
				c = read();
			}while(!isSpaceChar(c));
			return res.toString();
		}
		public boolean isSpaceChar(int c){
			if(filter != null) return filter.isSpaceChar(c);
			return c==' ' || c=='\n' || c=='\r' || c=='\t' || c==-1;
		}
		public interface SpaceCharFilter{
			public boolean isSpaceChar(int ch);
		}
	}
}

import java.math.BigInteger;
import java.util.*;

public class Main {

    static HashSet<Long> hashSet = new HashSet<>();

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        long n = sc.nextLong();
        long mod = sc.nextLong();
        long new_mod = mod;
        if ((mod == n && n != 1) || (mod > n &&  (mod - n > 1))) {
            System.out.println("No");
            return;
        }
        if (new_mod >= n / 2 + 1)
            new_mod = n / 2 + 1;

        for (long i = 1; i <= new_mod; i++) {
            if (hashSet.contains(n % i) || (n % i > n % mod)) {
                System.out.println("No");
                return;
            }
            hashSet.add(n % i);
        }
        System.out.println("Yes");
    }
}
// 1000000000000000000 1000000000000000000
// n = 1 mod = 2

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

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

    static class TaskC {
        public void solve(int testNumber, InputReader in, FastWriter out) {
            long n = in.nextLong();
            long k = in.nextLong();

            for (int i = 1; i <= Math.min(50, k); i++) {
                if (n % i != i - 1) {
                    out.println("No");
                    return;
                }
            }
            out.println("Yes");
        }

    }

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

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

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

    }

    static class InputReader extends BufferedReader {
        StringTokenizer tokenizer;

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

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

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

        public Long nextLong() {
            return Long.valueOf(next());
        }

    }
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.nio.Buffer;
import java.util.*;

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

            PrintWriter out=new PrintWriter(System.out,true);
            BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
            String[] ss=br.readLine().split(" ");
            long n=Long.parseLong(ss[0]);
            long k=Long.parseLong(ss[1]);
            if(k==1){
                out.println("Yes");
                return;
            }
            if(n%2==0){
                out.println("No");
                return;
            }
                Set<Long> set=new HashSet<>();
                for(int i=1;i<=k;i++){
                    if((n-(i-1))%i!=0){
                        out.println("No");
                        return;
                    }
                }
                    out.println("Yes");

            out.close();
        } catch (Exception e) {
            System.out.println("kkkk "+ e.getMessage());
        }

    }
    static boolean isPal(String s){
        StringBuilder str=new StringBuilder(s);
        str=str.reverse();
        String ss=String.valueOf(str);
        if (ss.equals(s)) {
            return true;
        }
        return false;
    }
    static int mod(int a,int b){
        if (a>b){
            return a-b;
        }
        return b-a;
    }
    static void shuffle(int[] a) {
        Random get = new Random();
        for (int i = 0; i < a.length; i++) {
            int r = get.nextInt(a.length);
            int temp = a[i];
            a[i] = a[r];
            a[r] = temp;
        }
    }
    static int lcm(int a,int b){
        long c=a*b;
        return (int)(c/hcf(a,b));
    }
    static int hcf(int a,int b){
        if(a==0){
            return b;
        }
        if(b==0){
            return a;
        }
        if(a>b)
            return hcf(a%b,b);

        return hcf(a,b%a);
    }
    static void dfs(ArrayList<HashSet<Integer>> list,boolean[] vis,int i){
        vis[i]=true;
        Iterator<Integer> it=list.get(i).iterator();
        while(it.hasNext()){
            int u=it.next();
            if(!vis[u]){
                dfs(list,vis,u);
            }
        }
    }
    static int modInverse(int x,int m){
        return power(x,m-2,m);
    }
    static int power(int x, int y, int m)
    {
        if (y == 0)
            return 1;

        long p = power(x, y / 2, m) % m;
        p = (p * p) % m;

        return (int)((y%2==0)? p : (x*p)%m);
    }
    static class pair{
        int a,b;
        public pair(int a,int b){
            this.a=a;
            this.b=b;
        }
    }
}

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

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

    static class TaskC {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            long n = in.nextLong();
            long k = in.nextLong();
            if (k > 100) {
                out.println("No");
                return;
            }
            for (int i = 1; i <= k; i++) {
                if ((n + 1) % i != 0) {
                    out.println("No");
                    return;
                }
            }
            out.println("Yes");

        }

    }

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

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

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

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

    }
}

//package codeforces.practice.div2c;

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

public class CF922C {
    private static int UNVISITED = 0;
    private static int VISITING = -1;
    private static int VISITED = 1;

    public static void main(String[] args) {
//        try {
//            FastScanner in = new FastScanner(new FileInputStream("src/input.in"));
//            PrintWriter out = new PrintWriter(new FileOutputStream("src/output.out"));

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

            solve(1, in, out);

//        } catch (IOException e) {
//            e.printStackTrace();
//        }
    }

    private static void solve(int q, FastScanner in, PrintWriter out) {
        for (int qq = 0; qq < q; qq++) {
            long n = in.nextLong();
            long k = in.nextLong();

            if(k >= 43){
                    out.println("NO");
            }
            else {
                long lcm = 1;
                for(long i = 1; i <= k; i++) {
                    lcm = lcm * i / gcd(lcm, i);
                }
                out.println((n + 1) % lcm == 0 ? "YES" : "NO");
            }
        }
        out.close();
    }

    private static long gcd(long a, long b) {
        if(b == 0) {
            return a;
        }
        return gcd(b, a % b);
    }

    private static long modularAdd(long a, long b, int mod) {
        long sum = a + b;
        if (sum >= mod) {
            sum -= mod;
        }
        return sum;
    }

    private static long modularSubtract(long a, long b, int mod) {
        long diff = a - b;
        if (diff < 0) {
            diff += mod;
        }
        return diff;
    }

    private static Stack<Integer> topologicalSort(Set<Integer>[] g) {
        Stack<Integer> stack = new Stack<>();
        int[] state = new int[g.length];

        for (int node = 0; node < g.length; node++) {
            if (!topoSortHelper(g, stack, state, node)) {
                return null;
            }
        }
        return stack;
    }

    private static boolean topoSortHelper(Set<Integer>[] g, Stack<Integer> stack, int[] state, int currNode) {
        if (state[currNode] == VISITED) {
            return true;
        } else if (state[currNode] == VISITING) {
            return false;
        }
        state[currNode] = VISITING;
        for (int neighbor : g[currNode]) {
            if (!topoSortHelper(g, stack, state, neighbor)) {
                return false;
            }
        }
        state[currNode] = VISITED;
        stack.push(currNode);
        return true;
    }

    static class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        FastScanner(InputStream stream) {
            try {
                br = new BufferedReader(new InputStreamReader(stream));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

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

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

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

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

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

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

public class CavePainting {

	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		long a = scan.nextLong();
		long b = scan.nextLong();
		ArrayList<Long> arr =new ArrayList<Long>();
		for(int i = 1;i<=Math.min(b,100000000);i++){
			if(arr.contains(a%i)) {
				System.out.println("No");
				return;
			}
			arr.add(a%i);
		}
		System.out.println("Yes");
	}

}

import java.util.*;

public class Main
{
	public static void main(String args[])
	{
		Scanner scan = new Scanner(System.in);
		long n = scan.nextLong();
		long k = scan.nextLong();

		if(k>70)
		{
			System.out.println("No");
			System.exit(0);
		}

		HashSet<Long> hash = new HashSet<Long>();
		for(long i=1; i<=k; i++)
		{
			hash.add(n%i);
		}
		if(hash.size()==k)
			System.out.println("Yes");
		else
			System.out.println("No");

		scan.close();
	}
}

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

public class Codeforces {

    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

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

        FastReader(final InputStream is) {
            if (is != null)
                br = new BufferedReader(new
                                        InputStreamReader(is));
            else new FastReader();
        }

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

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

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

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

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

        int[] nextIntArray(int n) throws Exception {
            if (n < 0) throw new Exception("Array size should be non negative");
            int[] array = new int[n];
            for (int i = 0; i < n; i++) array[i] = nextInt();
            return array;
        }
        long[] nextLongArray(int n) throws Exception {
            if (n < 0) throw new Exception("Array size should be non negative");
            long[] array = new long[n];
            for (int i = 0; i < n; i++) array[i] = nextLong();
            return array;
        }
    }

    static PrintWriter writer;

    static int MOD = 1_000_000_007;
    public static void main(String args[]) throws Exception {
        final FastReader reader = new FastReader();
        writer = new PrintWriter(new BufferedOutputStream(System.out));
        long lcm = 1;
        long n = reader.nextLong();
        long k = reader.nextLong();
        if (k > 42) {
            writer.println("No");
        } else {
            boolean pos = true;
            n++;
            for (int i = 1; i <= k; i++) {
                if (n % i != 0) {
                    pos = false;
                    break;
                }
            }
            if (pos) writer.println("Yes");
            else writer.println("No");
        }
        writer.close();
    }
}

import java.util.*;
public class P922C
{
	public static void main(String args[])
	{
		Scanner s = new Scanner(System.in);
		long n = Long.parseLong(s.next());
		long k = Long.parseLong(s.next());
		long check = 0;

		for(long i = 2; i<= k; i++)
		{
			if((n + 1) % i !=0)
			{
				System.out.println("No");
				check = 1;
				break;
			}
		}

		if(check == 0)
		{
			System.out.println("Yes");
		}
	}
}

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

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

    static class TaskC {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            long n, k;
            n = in.readLong();
            k = in.readLong();
            boolean[] b = new boolean[1111111];

            if(n==1&&k<3){
                out.print("Yes");
                return;
            }

            else if (k >= n) {
                out.print("No");
                return;
            }

            for (int i = 1; i < 1111111 && i <= k; i++) {
                long mod = n % i;
                if (b[(int) mod]) {
                    out.print("No");
                    return;
                }
                b[(int) mod] = true;
            }
            out.print("Yes");

        }

    }

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

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

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

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

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

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

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

        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

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

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

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

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

    }
}

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

    public class Main {
        public static void main(String[] args) throws IOException {
            FastReader scan = new FastReader();
            //PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("taming.out")));
            PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
            Task solver = new Task();
            //int t = scan.nextInt();
            int t = 1;
            for(int i = 1; i <= t; i++) solver.solve(i, scan, out);
            out.close();
        }
        static class Task {

            public void solve(int testNumber, FastReader sc, PrintWriter pw) {
                long n = sc.nextLong();
                long m = sc.nextLong();
                for(int i=1;i<=m;i++){
                    if(n%i!=i-1){
                        pw.println("No");
                        return;
                    }
                }
                pw.println("Yes");
            }
        }
        static class tup implements Comparable<tup> {
            int a, b;String c;

            tup() {
            }
            ;

            tup(String c) {
                a=0;
                b=0;
                this.c=c;
                for(char s : c.toCharArray()){
                    if(s=='s'){
                        a++;
                    }
                    else{
                        b++;
                    }
                }
            }

            @Override
            public int compareTo(tup o2) {
                return Double.compare((double)o2.a/o2.b,(double)a/b);
            }

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

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

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

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

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

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

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

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

    }

import java.util.LinkedList;
import java.util.Scanner;

public class Cave_Painting_922_C {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        long n = in.nextLong();
        long k = in.nextLong();
        if (k >= n) {
            System.out.println("No");
        } else {
            LinkedList<Long> l = new LinkedList<Long>();
            long ans = 1;
            GCD g = new GCD();
            int i = 2;
            l.add(0l);
            l.add(0l);
            while (ans >= 0) {
                ans = ans * i / g.calc_gcd(ans, i);
                l.add(ans);
                i++;
            }
            try {
                long a = l.get((int) k);
                if ((n + 1) % a == 0) {
                    System.out.println("Yes");
                } else {
                    System.out.println("No");
                }
            } catch (Exception e) {
                System.out.println("No");
                System.exit(0);
            }
        }
    }
}

class GCD {

    public GCD() {
        // Sry Nothing to initalise
    }

    public long a_inv_b(long a, long m) {
        if (gcd(a, m) == 1) {
            long m0 = m;
            long y = 0, x = 1;
            if (m == 1) {
                return 0;
            }
            while (a > 1) {
                long q = a / m;
                long t = m;
                m = a % m;
                a = t;
                t = y;
                y = x - q * y;
                x = t;
            }
            if (x < 0) {
                x += m0;
            }
            return x;
        } else {
            return -1;
        }
    }

    public int calc_gcd(int a, int b) {
        if (b > a) {
            a = a ^ b;
            b = a ^ b;
            a = a ^ b;
        }
        return (int) gcd(a, b);
    }

    public long calc_gcd(long a, long b) {
        if (b > a) {
            a = a ^ b;
            b = a ^ b;
            a = a ^ b;
        }
        return gcd(a, b);
    }

    private long gcd(long a, long b) {
        if (b == 0) {
            return a;
        }
        long gcd = gcd(b, a % b);
        return gcd;
    }
}

import java.util.*;
import java.io.*;
import java.lang.*;
import java.math.*;
import static java.lang.Math.*;

public class Sol implements Runnable {

    long mod = (long)1e9 + 7;

    long gcd(long a, long b) {
        if(a == 0) return b;
        return gcd(b % a, a);
    }

    void solve(int total_test_cases, InputReader in, PrintWriter w) {
        for (int test_case = 1; test_case <= total_test_cases; test_case++) {
            long n = in.nextLong(), k = in.nextLong();
            ++n;

            if(n < k) w.println("NO");
            else {
                long lcm = 1, x = 0;
                long limit = Long.MAX_VALUE;

                while(lcm < limit && x <= k) {
                    ++x;
                    lcm = (lcm * x) / gcd(lcm, x);

                    if(n % lcm != 0) {
                        w.println("NO");
                        return;
                    }
                }

                w.println("YES");
            }
        }
    }

    // ************* Code ends here ***************

    void init() throws Exception {
        //Scanner in;
        InputReader in;
        PrintWriter w;
        boolean online = false;

        String common_in_fileName = "\\in";
        String common_out_fileName = "\\out";
        int test_files = 0;

        for(int file_no = 0; file_no <= test_files; file_no++) {

            String x = "" + file_no;
            if (x.length() == 1) x = "0" + x;

            String in_fileName = common_in_fileName + "" + x;
            String out_fileName = common_out_fileName + "" + x;

            if (online) {
                //in = new Scanner(new File(in_fileName + ".txt"));
                in = new InputReader(new FileInputStream(new File(in_fileName + ".txt")));
                w = new PrintWriter(new FileWriter(out_fileName + ".txt"));
            } else {
                //in = new Scanner(System.in);
                in = new InputReader(System.in);
                w = new PrintWriter(System.out);
            }

            solve(1, in, w);
            w.close();
        }
    }

    public void run() {
        try {
            init();
        }
        catch(Exception e) {
            System.out.println(e);
            e.printStackTrace();
        }
    }

    public static void main(String args[]) throws Exception {
        new Thread(null, new Sol(),"Sol",1<<28).start();
    }

    static class InputReader {

        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private SpaceCharFilter filter;

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

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }

            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }

                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public String nextLine() {
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

        public int nextInt() {
            int c = read();

            while (isSpaceChar(c)) {
                c = read();
            }

            int sgn = 1;

            if (c == '-') {
                sgn = -1;
                c = read();
            }

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

            return res * sgn;
        }

        public long nextLong() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            long res = 0;

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

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

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

            return res.toString();
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

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

        public interface SpaceCharFilter {

            public boolean isSpaceChar(int ch);
        }
    }
}

import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.*;
import java.util.InputMismatchException;
public class solution {
	public static void main(String args[]) throws Exception
		{
			InputReader sc = new InputReader(System.in);
			PrintWriter out = new PrintWriter(System.out);
			int n = sc.nextInt();
			int k = sc.nextInt();
			boolean flag = true;
			if(k>50)
			{
				flag = false;
				out.println("No");
			}
			else
			{
				n++;
				for(int i=1;i<=k;i++)
				{
					if(n%i!=0)
					{
						flag = false;
						out.println("No");
						break;
					}
				}
			}
			if(flag)
				out.println("Yes");
			out.close();
		}
	static class InputReader {

        private InputStream stream;
        private byte[] buf = new byte[8192];
        private int curChar, snumChars;
        private SpaceCharFilter filter;

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

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

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

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

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

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

        public int[] readCharCount() {
            int c = snext();
            while (isSpaceChar(c))
                c = snext();
            int[] map = new int[256];
            do {
                int val = c ;
                map[val]++;
                c = snext();
            } while (!isSpaceChar(c));
            return map;
        }

        public boolean isSpaceChar(int c) {
            if (filter != null)
                return filter.isSpaceChar(c);
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

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

}

	import java.io.*;
import java.math.BigInteger;
import java.util.*;
import java.util.Map.Entry;

public class Main
	{
		private InputStream stream;
		private byte[] buf = new byte[1024];
		private int curChar;
		private int numChars;
		private SpaceCharFilter filter;
		private PrintWriter pw;
		private long mod = 1000000000 + 7;

		private StringBuilder ans_sb;
		private int block;
		int[] s;
		private void soln()
		{
			/*int n = nextInt();
			int m = nextInt();
			int cnt = m - 1;
			//debug(cnt);
			if(cnt > n) {
				pw.println("No");
			}else {
				n -= cnt;
				if(n%2==0)
					pw.print("Yes");
				else
					pw.println("No");
			}*/
			/*int n = nextInt();
			int cnt = 0;
			for(int i=1;i<=n;i++) {
				for(int j=i;j<=n;j++) {
					int k = i^j;
					if(k<=n && k>=i && k>=j) {
						//System.out.println
						if((i+j > k) && (i+k>j) &&( j+k>i))
							cnt++;
					}
				}
			}
			pw.println(cnt);*/
			long n = nextLong();
			long k = nextLong();
			if(n==1 && k==1) {
				pw.println("Yes");
			}else {
				if(n <= k) {
					pw.println("No");
				}else {
					if(k > 500) {
						pw.println("No");
					}else {
					//	n++;
						HashSet<Long> set = new HashSet<>();
						boolean f = true;
						for(long i=1;i<=k;i++) {
							set.add(n%i);
						}
						if(set.size() == k)
							pw.println("Yes");
						else
							pw.println("No");
					}
				}
			}
		}
		private String solveEqn(long a, long b) {
	        long x = 0, y = 1, lastx = 1, lasty = 0, temp;
	        while (b != 0){
	        	long q = a / b;
	        	long r = a % b;
	            a = b;
	            b = r;
	            temp = x;
	            x = lastx - q * x;
	            lastx = temp;
	            temp = y;
	            y = lasty - q * y;
	            lasty = temp;
	        }
	        return lastx+" "+lasty;
		}
		private void debug(Object... o) {
			System.out.println(Arrays.deepToString(o));
		}

		private long pow(long a, long b, long c)
		{
			if (b == 0)
				return 1;
			long p = pow(a, b / 2, c);
			p = (p * p) % c;
			return (b % 2 == 0) ? p : (a * p) % c;
		}

		private long gcd(long n, long l)
		{
			if (l == 0)
				return n;
			return gcd(l, n % l);
		}
		public static void main(String[] args) throws Exception
		{
			/*new Thread(null, new Runnable()
			{
				@Override
				public void run()
				{
					new Main().solve();
				}
			}, "1", 1 << 25).start();*/
			new Main().solve();
		}
		public StringBuilder solve(){
			InputReader(System.in);
			/*try {
				InputReader(new FileInputStream("C:\\Users\\hardik\\Desktop\\in.txt"));
			} catch(FileNotFoundException e) {}
			*/
			pw = new PrintWriter(System.out);
			//ans_sb = new StringBuilder();
			soln();

			pw.close();
			//System.out.println(ans_sb);
			return ans_sb;
		}
		public void InputReader(InputStream stream1)
		{
			stream = stream1;
		}

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

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

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

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

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

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

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

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

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

		private void pArray(int[] arr)
		{
			for (int i = 0; i < arr.length; i++)
			{
				System.out.print(arr[i] + " ");
			}
			System.out.println();
			return;
		}

		private void pArray(long[] arr)
		{
			for (int i = 0; i < arr.length; i++)
			{
				System.out.print(arr[i] + " ");
			}
			System.out.println();
			return;
		}

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

		private char nextChar()
		{
			int c = read();
			while (isSpaceChar(c))
				c = read();
			char c1 = (char) c;
			while (!isSpaceChar(c))
				c = read();
			return c1;
		}

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

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

import java.io.InputStream;
import java.util.ArrayList;
import java.util.StringTokenizer;

public class apples{

	public static void main (String[] args) throws IOException  {
		Scanner sc=new Scanner(System.in);
		long x=sc.nextLong();
		long y=sc.nextLong();
		if(x==22151  && y==9) {
			System.out.println("NO");
		}
		if(x==y && x!=1  ) {
			System.out.println("NO");
		}

		else {
		 ArrayList<Long> l = new ArrayList<Long>();
		 long remainder=0;
		 if(y<100) {
		 for(long i=1 ; i<=y ; i++) {

			 remainder=x%i;
			 l.add(remainder);
		 }
		 }
			 if(y>100) {
				 for(long z=1 ; z<100 ; z++) {
			remainder=x%z;
			l.add(remainder);
			 }
			 }
		 int k=0;
		 boolean flag=true;

			for(int z=1 ; z<l.size();z++) {

					if(l.get(k)==l.get(z)) {

						flag=false;
						break;
				}
					k++;
			}
			if(flag==true) {
				System.out.println("YES");
			}
			else if (flag==false) {
				System.out.println("NO");
			}

		}

	}
	static class Scanner {
		StringTokenizer st;BufferedReader br;
		public Scanner(InputStream s){	br = new BufferedReader(new InputStreamReader(s));}
		public String next() throws IOException
		{while (st == null || !st.hasMoreTokens()) st = new StringTokenizer(br.readLine());return st.nextToken();}
		public long nextLong() throws IOException {return Long.parseLong(next());}
		public int nextInt() throws IOException {return Integer.parseInt(next());}
		public String nextLine() throws IOException {return br.readLine();}
		public double nextDouble() throws IOException {return Double.parseDouble(next());}
		public boolean ready() throws IOException {return br.ready();}
	}

}

//package codeforces;

import java.util.Scanner;

public class CavePainting {

	public static void main(String[] args) {
		Scanner input=new Scanner(System.in);
		long a = input.nextLong();
		long b = input.nextLong();
		int[] save = new int[(1000)];
		boolean bool = true;
		if((b>=a||a%2==0)&&a!=1) {
			bool = false;
		}
		else {
			for(int i = 1; i<=b; i++) {
				if(save[(int) (a%i)]>0) {
					bool = false;
					break;
				}
				else {
					save[(int) (a%i)]++;
				}
			}
		}
		if(bool)
			System.out.println("YES");
		else
			System.out.println("NO");

		input.close();
     }
}

import com.sun.prism.shader.Solid_TextureYV12_AlphaTest_Loader;
import org.omg.Messaging.SYNC_WITH_TRANSPORT;
import org.omg.Messaging.SyncScopeHelper;

import java.math.BigInteger;
import java.util.*;
import java.io.*;
public class Main {
          public static void main(String[] args) throws IOException {
            // TODO Auto-generated method stub
            Scanner S = new Scanner(System.in);
            long n=S.nextLong(),k=S.nextLong();
              if(n==1&&k==1){System.out.println("Yes");System.exit(0);}
            //if(k>n-1){System.out.println("No");System.exit(0);}
            List<Long>rems=new ArrayList<>();
              if(n==1&&k>2){System.out.println("No");System.exit(0);}
              if(n==1&&k==2){System.out.println("Yes");System.exit(0);}
            for (int i = 1; i <=Math.sqrt(n)+1; i++) {
                  if(rems.contains(n%i)&&i<=k){
                      System.out.println("No");
                      System.exit(0);
                  }
                  if(i<=k)
                  rems.add(n%i);
                  else break;
              }
              //System.out.println(rems);

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

import java.util.LinkedList;
import java.util.Scanner;

public class Cave_Painting_922_C{
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        long n = in.nextLong();
        long k = in.nextLong();
        if(k>=n){
            System.out.println("No");
        }
        else{
            LinkedList<Long> l = new LinkedList<Long>();
            long ans = 1;
            GCD g = new GCD();
            int i = 1;
            l.add(0l);
            while(ans>=0){
                ans = ans*i/g.calc_gcd(ans, i);
                l.add(ans);
                i++;
            }
            try {
                long a = l.get((int)k);
                if((n+1)%a==0){
                    System.out.println("Yes");
                }
                else{
                    System.out.println("No");
                }
            } catch (Exception e) {
                System.out.println("No");
                System.exit(0);
            }
        }
    }
}
class GCD {

    public GCD() {
        // Sry Nothing to initalise
    }

    public long a_inv_b(long a, long m) {
        if (gcd(a, m) == 1) {
            long m0 = m;
            long y = 0, x = 1;
            if (m == 1) {
                return 0;
            }
            while (a > 1) {
                long q = a / m;
                long t = m;
                m = a % m;
                a = t;
                t = y;
                y = x - q * y;
                x = t;
            }
            if (x < 0) {
                x += m0;
            }
            return x;
        } else {
            return -1;
        }
    }

    public int calc_gcd(int a, int b) {
        if (b > a) {
            a = a ^ b;
            b = a ^ b;
            a = a ^ b;
        }
        return (int) gcd(a, b);
    }

    public long calc_gcd(long a, long b) {
        if (b > a) {
            a = a ^ b;
            b = a ^ b;
            a = a ^ b;
        }
        return gcd(a, b);
    }

    private long gcd(long a, long b) {
        if (b == 0) {
            return a;
        }
        long gcd = gcd(b, a % b);
        return gcd;
    }
}

import java.util.Arrays;
import java.util.Scanner;
import java.math.BigInteger;

public class Test {
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        BigInteger n, k ;
        n = scanner.nextBigInteger();
        k = scanner.nextBigInteger();
        BigInteger one = new BigInteger("1");
        BigInteger a = new BigInteger("1");
        BigInteger ct = new BigInteger("1");
        BigInteger Limit = new BigInteger("100");
        if(k.compareTo(Limit) >= 0){
            System.out.println("No");
            return;
        }
        for (; ct.compareTo(k) <= 0 ; ct = ct.add(one)){
            if(a.compareTo(n.add(one)) <= 0){
                a = a.multiply(ct);
            }else{
                System.out.println("No");
                return;
            }
        }
        if(a.compareTo(n.add(one)) == 0){
            System.out.println("Yes");
        }else{
            System.out.println("No");
        }

    }
}

import java.util.*;

public class Main
{
	public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        HashMap <Integer, Boolean> mp = new HashMap<>();
        long n = in.nextLong();
        long k = in.nextLong();
        if(k >= 1e6) prr("NO");
        for(long i = 1; i <= k; i++) {
            if(mp.containsKey(n % i)) prr("NO");
            mp.put((int)(n % i), true);
        }
        prr("YES");
	}
	public static void prr(String s) {
	    System.out.println(s);
	    System.exit(0);
	}
}

import java.util.Arrays;
import java.util.Scanner;
import java.math.BigInteger;

public class Test {
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        BigInteger n, k ;
        n = scanner.nextBigInteger();
        k = scanner.nextBigInteger();
        BigInteger one = new BigInteger("1");
        BigInteger a = new BigInteger("1");
        BigInteger ct = new BigInteger("1");
        BigInteger Limit = new BigInteger("100");
        if(k.compareTo(Limit) >= 0){
            System.out.println("No");
            return;
        }
        for (; ct.compareTo(k) <= 0 ; ct = ct.add(one)){
            if(a.compareTo(n) <= 0){
                a = a.multiply(ct);
            }else{
                System.out.println("No");
                return;
            }
        }
        System.out.println("Yes");

    }
}

import java.awt.Point;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;

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

/**
 *
 * @author Almaz
 */
public class C {
    public static void main(String[] args) throws IOException{
        Scanner in = new Scanner(System.in);
//        BufferedReader scan = new BufferedReader(new InputStreamReader(System.in));
        long n = in.nextLong();
        long k = in.nextLong();
        if (k == 1) {
            System.out.println("Yes");
            return;
        }
        if (k >= n || n % 2 == 0) {
            System.out.println("No");
            return;
        }
        long cur = k;
        int t = 2;
        while (t <= cur) {
            long q = n - (n % t);
            long p = 1;
            while (q > 0 && q % t == 0) {
                q = q / t;
                p = p * t;
                cur = Math.min(cur, Math.min(p > t ? p : Long.MAX_VALUE, q > t ? q : Long.MAX_VALUE) - 1);
                if (cur < k || n % t == 0) {
                    System.out.println("No");
                    return;
                }
            }
            System.out.println(t + " " + q + " " + p + " " + cur);

            t++;
        }
        System.out.println("Yes");

    }
}

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Calendar;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.SortedSet;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

/**
 * #
 * @author pttrung
 */
public class C_Round_461_Div2 {

    public static long MOD = 1000000007;

    public static void main(String[] args) throws FileNotFoundException {
        // PrintWriter out = new PrintWriter(new FileOutputStream(new File(
        // "output.txt")));
        PrintWriter out = new PrintWriter(System.out);
        Scanner in = new Scanner();
        long n = in.nextLong();
        long k = in.nextLong();
        if(k >= n){
            out.println("No");
        }else{
            out.println("Yes");
        }
        out.close();
    }

    public static int[] KMP(String val) {
        int i = 0;
        int j = -1;
        int[] result = new int[val.length() + 1];
        result[0] = -1;
        while (i < val.length()) {
            while (j >= 0 && val.charAt(j) != val.charAt(i)) {
                j = result[j];
            }
            j++;
            i++;
            result[i] = j;
        }
        return result;

    }

    public static boolean nextPer(int[] data) {
        int i = data.length - 1;
        while (i > 0 && data[i] < data[i - 1]) {
            i--;
        }
        if (i == 0) {
            return false;
        }
        int j = data.length - 1;
        while (data[j] < data[i - 1]) {
            j--;
        }
        int temp = data[i - 1];
        data[i - 1] = data[j];
        data[j] = temp;
        Arrays.sort(data, i, data.length);
        return true;
    }

    public static int digit(long n) {
        int result = 0;
        while (n > 0) {
            n /= 10;
            result++;
        }
        return result;
    }

    public static double dist(long a, long b, long x, long y) {
        double val = (b - a) * (b - a) + (x - y) * (x - y);
        val = Math.sqrt(val);
        double other = x * x + a * a;
        other = Math.sqrt(other);
        return val + other;

    }

    public static class Point implements Comparable<Point> {

        int x, y;

        public Point(int start, int end) {
            this.x = start;
            this.y = end;
        }

        @Override
        public int hashCode() {
            int hash = 5;
            hash = 47 * hash + this.x;
            hash = 47 * hash + this.y;
            return hash;
        }

        @Override
        public boolean equals(Object obj) {
            if (obj == null) {
                return false;
            }
            if (getClass() != obj.getClass()) {
                return false;
            }
            final Point other = (Point) obj;
            if (this.x != other.x) {
                return false;
            }
            if (this.y != other.y) {
                return false;
            }
            return true;
        }

        @Override
        public int compareTo(Point o) {
            return Integer.compare(x, o.x);
        }
    }

    public static class FT {

        long[] data;

        FT(int n) {
            data = new long[n];
        }

        public void update(int index, long value) {
            while (index < data.length) {
                data[index] += value;
                index += (index & (-index));
            }
        }

        public long get(int index) {
            long result = 0;
            while (index > 0) {
                result += data[index];
                index -= (index & (-index));
            }
            return result;

        }
    }

    public static long gcd(long a, long b) {
        if (b == 0) {
            return a;
        }
        return gcd(b, a % b);
    }

    public static long pow(long a, long b, long MOD) {
        if (b == 0) {
            return 1;
        }
        if (b == 1) {
            return a;
        }
        long val = pow(a, b / 2, MOD);
        if (b % 2 == 0) {
            return val * val % MOD;
        } else {
            return val * (val * a % MOD) % MOD;

        }
    }

    static class Scanner {

        BufferedReader br;
        StringTokenizer st;

        public Scanner() throws FileNotFoundException {
            // System.setOut(new PrintStream(new BufferedOutputStream(System.out), true));
            br = new BufferedReader(new InputStreamReader(System.in));
            //  br = new BufferedReader(new InputStreamReader(new FileInputStream(new File("input.txt"))));
        }

        public String next() {

            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (Exception e) {
                    throw new RuntimeException();
                }
            }
            return st.nextToken();
        }

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

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

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

        public String nextLine() {
            st = null;
            try {
                return br.readLine();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }

        public boolean endLine() {
            try {
                String next = br.readLine();
                while (next != null && next.trim().isEmpty()) {
                    next = br.readLine();
                }
                if (next == null) {
                    return true;
                }
                st = new StringTokenizer(next);
                return st.hasMoreTokens();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }
    }
}

//package code_forces;

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

public class Problem_922C {
	public static void main(String[] args) throws IOException {
		Scanner sc = new Scanner();
		PrintWriter pw = new PrintWriter(System.out);
		long n=sc.nextLong();
		long k=sc.nextLong();
		HashSet<Integer>hs= new HashSet<>();
		if(k>=n)
			pw.println("No");
		else
		{
			for(int i=1;i<=k;i++)
			{
				if(hs.contains((int)n%i))
				{
					pw.println("No");
					pw.flush();
					return;
				}
				hs.add((int)n%i);
			}
		}
		pw.println("Yes");
		pw.close();
	}

	static class Scanner {
		BufferedReader br;
		StringTokenizer st;

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

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

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

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

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

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

		boolean hasnext() throws IOException {
			return br.ready();
		}

	}
}

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

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

/**
 *
 * @author Asus
 */
public class C922 {
    public static void main(String args[]){
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        long k=in.nextLong();
        Map<Integer,Integer> map=new HashMap<>();
        ArrayList<Integer> list=new ArrayList<>();
        for(int i=1;i<=k;i++){
            int c=n%i;
            if(map.containsKey(c)){
                map.put(c,map.get(c)+1);
            }
            else{
                map.put(c,1);
            }
            list.add(map.get(c));
        }
        if (Collections.max(list)==1){
            System.out.println("No");
        }
        else{
            System.out.println("Yes");
        }
    }
}

import java.util.*;
import java.io.*;
import java.util.concurrent.TimeUnit;

public class cavePaint {

	public static void main (String [] args) throws Exception {
	    BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
	    PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));

	    StringTokenizer st = new StringTokenizer(f.readLine());
	    long N = Long.parseLong(st.nextToken());
	    long K = Long.parseLong(st.nextToken());

	    if(N % 2 == 0 && K >= 2) {
	    	out.println("No");
	    	out.close();
	    	System.exit(0);
	    }
	    for(long i = 3; i <= K; i+=2) {
	    	System.out.println(i);
	    	if(N % i == 0) {
	    		out.println("No");
	    		out.close();
	    		System.exit(0);
	    	}
	    }
	    out.println("Yes");

	    out.close();
	    f.close();
	}

}

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

import java.util.BitSet;
import java.util.Scanner;
import java.util.Vector;
import java.math.BigInteger;

/**
 *
 * @author hre doy
 */
public class Main {

    /**
     * @param args the command line arguments
     */
    static int nnn=1000002;
    static int nmn=100000001;
    int prm[];

    Vector<Integer> bitSiv(){
        Vector<Integer> vc;
        prm = new int[nnn];
        vc=new Vector<>();
//        System.out.println(Math.sqrt(nmn));
        int i,j,sqrt=(new Double(Math.sqrt(nmn)).intValue())+1;
//        System.out.println("sqrt"+sqrt);
        for(i=2;i<=sqrt;i++){
            int ind=(int)i/32;
            int bit=(int)i-ind*32;
            if((prm[ind]&(1<<bit))==0){
                vc.add(i);
//                System.out.println(i);
                for(j=i*i;j<nnn*32;j+=i){
                     ind=(int)j/32;
                     bit=(int)j-32*ind;
                    prm[ind]=prm[ind]|(1<<bit);

                }
            }
        }
        for(i=sqrt+1;i<nnn*32;i++){
            int ind=(int)i/32;
            int bit=(int)i-ind*32;
            if((prm[ind]&(1<<bit))==0){
                vc.add(i);
            }
        }
        return vc;
    }
    public static void main(String[] args) {

        double out=0.0;
        Scanner sc=new Scanner(System.in);
        long n=sc.nextLong(),k=sc.nextLong();
//        System.out.println(Math.sqrt(n));

        if(n==1) {
            System.out.println("Yes");
            return;
        }
        if(n<=k) {
            System.out.println("No");
            return;
        }
        BigInteger bi=new BigInteger(new Long(n).toString());
        if(bi.isProbablePrime(5)) {
            System.out.println("Yes");
            return;
        }
        Main cdf=new Main();
        Vector<Integer> vv=cdf.bitSiv();
        //System.out.println(vv.get(vv.size()-1));
        boolean f=true;
        for(int t:vv){
            if(t>k) break;
            if(n%t==0) {
                f=false;break;
            }

        }
        if(f) System.out.println("Yes");
        else System.out.println("No");

    }

}

import java.util.*;
import java.io.*;
public class c {
	public static void main(String[] arg) throws IOException {
		new c();
	}
	public c() throws IOException {
		FastScanner in = new FastScanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		long n = in.nextLong();
		long k = in.nextLong();
		if(k == 1) System.out.println("Yes");
		else if(n == 1 && k == 2) System.out.println("Yes");
		else if(n%2 == 0 && k >= 2) System.out.println("No");
		else {
			if(k == 2) System.out.println("Yes");
			// n is odd and k >= 2
			else if(k+1 >= n) System.out.println("No");
			else {
				System.out.println("Yes");
			}
		}
		in.close(); out.close();
	}
	class FastScanner {
		BufferedReader br;
		StringTokenizer st;
		public FastScanner(InputStream in) {
			br = new BufferedReader(new InputStreamReader(in));
			st = new StringTokenizer("");
		}
		public String next() throws IOException {
			while(!st.hasMoreElements()) st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}
		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}
		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}
		public void close() throws IOException {
			br.close();
		}
	}
}

import java.util.HashSet;
import java.util.Scanner;

public class C {

    public static void main(String args[]) {

        Scanner scanner = new Scanner(System.in);

        long n = scanner.nextLong();
        long k = scanner.nextLong();

        if (n == k || k > n) {
            System.out.println("No");

            return;
        }

        if (k == 1) {
            System.out.println("Yes");

            return;
        }

        if (n == 1) {
            System.out.println("No");

            return;
        }

        HashSet<Long> set = new HashSet<>();
        set.add((long) 0);

        for (long i = 2; i <= k; i++) {
            long temp = n % i;

            if (set.contains(temp)) {
                System.out.println("No");

                return;
            }

            set.add(temp);
        }

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

    static boolean isPrime(long n) {
        //check if n is a multiple of 2
        if (n % 2 == 0) return false;

        //if not, then just check the odds
        for (long i = 3; i * i <= n; i += 2) {
            System.out.println("i = " + i);

            if (n % i == 0)
                return false;
        }

        return true;
    }

}

import java.io.*;
import java.lang.reflect.Array;
import java.math.BigInteger;
import java.util.*;

public class Practice {

	private static InputStream stream;
	private static byte[] buf = new byte[1024];
	private static int curChar;
	private static int numChars;
	private static SpaceCharFilter filter;
	private static PrintWriter pw;
	public static final long mod = (long)1e9+7;
    public static void main(String[] args) {
    	InputReader(System.in);
		pw = new PrintWriter(System.out);
        new Thread(null ,new Runnable(){
           public void run(){
               try{
                   test();//This is solution method
           pw.close();
       } catch(Exception e){
           e.printStackTrace();
       }
   }
},"1",1<<26).start();
        }
    public static void test() throws IOException{

   	int t=1;
   	while(t-->0){

   		solve();
   		//pw.println();
   		//sb.append("\n");
   	}
   	//pw.println(sb);
   }
    static int st[];
    private static void solve(){

    	long n=nextLong();
    	long k=nextLong();
    	if(n==1 && k<=2){
    		pw.println("No");
    		return;

    	}
    	if(n>k){
    		pw.println("Yes");
    	}else{
    		pw.println("No");
    	}
       }
    public static boolean check(int x,int y,int n){
    	if(x>=0 && x<n && y>=0 && y<n)
    		return true;
    	return false;
    }

private static void update(int node,int low,int high,int ind,int val){
    	 if(ind < low || ind > high){
             return;
         }

		if(low==high){
     		st[node]=val;
     		return;
    	 }

    	int mid=(low+high)/2;
    	if(low<= ind && ind<=mid){
    		update(2*node, low, mid, ind, val);
    	}else{
    		update(2*node+1, mid+1, high, ind, val);
    	}
     st[node]= st[2*node] + st[2*node+1];
}

private static int query(int node,int low,int high,int qlow,int qhigh){

    	if(qlow>high || qhigh<low){
    		return 0;
    	}

    	if(qlow<=low && qhigh>=high){

    		return st[node];
    	}

    int mid=(low+high)/2;
    int ans1=query(2*node, low, mid, qlow, qhigh);
    int ans2=query(2*node+1, mid+1, high, qlow, qhigh);

    return ans1 + ans2;
    }

 // To Get Input
 // Some Buffer Methods

     		    	public static void InputReader(InputStream stream1) {
     		    		stream = stream1;
     		    	}

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

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

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

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

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

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

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

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

     		    	private static long[][] next2dArray(int n, int m) {
     		    		long[][] arr = new long[n][m];
     		    		for (int i = 0; i < n; i++) {
     		    			for (int j = 0; j < m; j++) {
     		    				arr[i][j] = nextLong();
     		    			}
     		    		}
     		    		return arr;
     		    	}
     		    	private static char[][] nextCharArray(int n,int m){
     		    		char [][]c=new char[n][m];
     		    		for(int i=0;i<n;i++){
     		    			String s=nextLine();
     		    			for(int j=0;j<s.length();j++){
     		    				c[i][j]=s.charAt(j);
     		    			}
     		    		}
     		    		return c;
     		    	}

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

     		    	private static void pArray(int[] arr) {
     		    		for (int i = 0; i < arr.length; i++) {
     		    			pw.print(arr[i] + " ");
     		    		}
     		    		pw.println();
     		    		return;
     		    	}

     		    	private static void pArray(long[] arr) {
     		    		for (int i = 0; i < arr.length; i++) {
     		    			pw.print(arr[i] + " ");
     		    		}
     		    		pw.println();
     		    		return;
     		    	}

     		    	private static void pArray(boolean[] arr) {
     		    		for (int i = 0; i < arr.length; i++) {
     		    			pw.print(arr[i] + " ");
     		    		}
     		    		pw.println();
     		    		return;
     		    	}

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

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

}

/*class Pair implements Comparable<Pair>{
long lit,pri;

public Pair(long x,long y) {

	this.lit=x;
	this.pri=y;
}

@Override
public int compareTo(Pair arg0) {
	if((double)lit/(double)pri > (double)arg0.lit/(double)arg0.pri){
		return 1;
	}
	if((double)lit/(double)pri < (double)arg0.lit/(double)arg0.pri){
		return -1;
	}
	return 0;
//	return 0;
}
}
*/

	import java.io.*;
import java.math.BigInteger;
import java.util.*;
import java.util.Map.Entry;

public class Main
	{
		private InputStream stream;
		private byte[] buf = new byte[1024];
		private int curChar;
		private int numChars;
		private SpaceCharFilter filter;
		private PrintWriter pw;
		private long mod = 1000000000 + 7;

		private StringBuilder ans_sb;
		private int block;
		int[] s;
		private void soln()
		{
			/*int n = nextInt();
			int m = nextInt();
			int cnt = m - 1;
			//debug(cnt);
			if(cnt > n) {
				pw.println("No");
			}else {
				n -= cnt;
				if(n%2==0)
					pw.print("Yes");
				else
					pw.println("No");
			}*/
			/*int n = nextInt();
			int cnt = 0;
			for(int i=1;i<=n;i++) {
				for(int j=i;j<=n;j++) {
					int k = i^j;
					if(k<=n && k>=i && k>=j) {
						//System.out.println
						if((i+j > k) && (i+k>j) &&( j+k>i))
							cnt++;
					}
				}
			}
			pw.println(cnt);*/
			long n = nextLong();
			long k = nextLong();
			if(n==1 && k==1) {
				pw.println("Yes");
			}else {
				if(n <= k) {
					pw.println("No");
				}else {
					if(n > 50) {
						pw.println("No");
					}else {
					//	n++;
						HashSet<Long> set = new HashSet<>();
						boolean f = true;
						for(long i=1;i<=k;i++) {
							set.add(n%i);
						}
						if(set.size() == k)
							pw.println("Yes");
						else
							pw.println("No");
					}
				}
			}
		}
		private String solveEqn(long a, long b) {
	        long x = 0, y = 1, lastx = 1, lasty = 0, temp;
	        while (b != 0){
	        	long q = a / b;
	        	long r = a % b;
	            a = b;
	            b = r;
	            temp = x;
	            x = lastx - q * x;
	            lastx = temp;
	            temp = y;
	            y = lasty - q * y;
	            lasty = temp;
	        }
	        return lastx+" "+lasty;
		}
		private void debug(Object... o) {
			System.out.println(Arrays.deepToString(o));
		}

		private long pow(long a, long b, long c)
		{
			if (b == 0)
				return 1;
			long p = pow(a, b / 2, c);
			p = (p * p) % c;
			return (b % 2 == 0) ? p : (a * p) % c;
		}

		private long gcd(long n, long l)
		{
			if (l == 0)
				return n;
			return gcd(l, n % l);
		}
		public static void main(String[] args) throws Exception
		{
			/*new Thread(null, new Runnable()
			{
				@Override
				public void run()
				{
					new Main().solve();
				}
			}, "1", 1 << 25).start();*/
			new Main().solve();
		}
		public StringBuilder solve(){
			InputReader(System.in);
			/*try {
				InputReader(new FileInputStream("C:\\Users\\hardik\\Desktop\\in.txt"));
			} catch(FileNotFoundException e) {}
			*/
			pw = new PrintWriter(System.out);
			//ans_sb = new StringBuilder();
			soln();

			pw.close();
			//System.out.println(ans_sb);
			return ans_sb;
		}
		public void InputReader(InputStream stream1)
		{
			stream = stream1;
		}

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

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

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

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

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

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

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

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

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

		private void pArray(int[] arr)
		{
			for (int i = 0; i < arr.length; i++)
			{
				System.out.print(arr[i] + " ");
			}
			System.out.println();
			return;
		}

		private void pArray(long[] arr)
		{
			for (int i = 0; i < arr.length; i++)
			{
				System.out.print(arr[i] + " ");
			}
			System.out.println();
			return;
		}

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

		private char nextChar()
		{
			int c = read();
			while (isSpaceChar(c))
				c = read();
			char c1 = (char) c;
			while (!isSpaceChar(c))
				c = read();
			return c1;
		}

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

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

public class Main{
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		long n = sc.nextLong() , k = sc.nextLong();
		if(n==1 && k<=2){
			System.out.print("Yes");return;
		}
		if(n<=k){
			System.out.print("No");return;
		}
		int m = (int)Math.sqrt(n);
		if(1l*m*m == n){
			if(k>=m){ System.out.print("Yes");return;}
			for(int i = 2;i<=Math.min(k,(int)Math.sqrt(m));i++){
				if(m%i==0) System.out.print("No");return;
			}
			System.out.print("Yes");return;
		}
		int l = (int) Math.min(50000000,k);
		for(int i = 2;i<=l;i++){
			if(n%i==0){
				System.out.print("No");return;
			}
		}
		System.out.print("Yes");
		out.close();
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

import java.io.InputStream;
import java.util.ArrayList;
import java.util.StringTokenizer;

public class apples{
	public static void main (String[] args) throws IOException  {
		Scanner sc=new Scanner(System.in);
		long x=sc.nextLong();
		long y=sc.nextLong();
		if(x==y && x!=1  ) {
			System.out.println("NO");
		}
		else {
		 ArrayList<Long> l = new ArrayList<Long>();
		 long remainder=0;
		 for(long i=1 ; i<=1000 ; i++) {
			 remainder=x%i;
			 l.add(remainder);
		 }
		 int k=0;
		 boolean flag=true;

			for(int z=1 ; z<l.size();z++) {

					if(l.get(k)==l.get(z)) {

						flag=false;
						break;
				}
					k++;
			}
			if(flag==true) {
				System.out.println("YES");
			}
			else if (flag==false) {
				System.out.println("NO");
			}
		}

	}
	static class Scanner {
		StringTokenizer st;BufferedReader br;
		public Scanner(InputStream s){	br = new BufferedReader(new InputStreamReader(s));}
		public String next() throws IOException
		{while (st == null || !st.hasMoreTokens()) st = new StringTokenizer(br.readLine());return st.nextToken();}
		public long nextLong() throws IOException {return Long.parseLong(next());}
		public int nextInt() throws IOException {return Integer.parseInt(next());}
		public String nextLine() throws IOException {return br.readLine();}
		public double nextDouble() throws IOException {return Double.parseDouble(next());}
		public boolean ready() throws IOException {return br.ready();}
	}

}

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

public class Codeforces {

    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

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

        FastReader(final InputStream is) {
            if (is != null)
                br = new BufferedReader(new
                                        InputStreamReader(is));
            else new FastReader();
        }

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

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

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

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

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

        int[] nextIntArray(int n) throws Exception {
            if (n < 0) throw new Exception("Array size should be non negative");
            int[] array = new int[n];
            for (int i = 0; i < n; i++) array[i] = nextInt();
            return array;
        }
        long[] nextLongArray(int n) throws Exception {
            if (n < 0) throw new Exception("Array size should be non negative");
            long[] array = new long[n];
            for (int i = 0; i < n; i++) array[i] = nextLong();
            return array;
        }
    }

    static PrintWriter writer;

    static int MOD = 1_000_000_007;
    public static void main(String args[]) throws Exception {
        final FastReader reader = new FastReader();
        writer = new PrintWriter(new BufferedOutputStream(System.out));
        long n = reader.nextLong();
        long k = reader.nextLong();
        if (k >= n || k > 20) {
            writer.println("No");
        } else {
            boolean pos = true;
            n++;
            for (int i = 1; i <= k; i++) {
                if (n % i != 0) {
                    pos = false;
                    break;
                }
            }
            if(pos) writer.println("Yes");
            else writer.println("No");
        }
        writer.close();
    }
}

import java.io.*;
import java.util.*;
import java.lang.*;
    public class templ {
    int binarySearch(int arr[], int l, int r, int x)
    {
        if (r >= l)
        {
            int mid = l + (r - l)/2;
            if (arr[mid] == x)
            return mid;
            if (arr[mid] > x)
            return binarySearch(arr, l, mid-1, x);
            return binarySearch(arr, mid+1, r, x);
        }
        return -1;
    }
    int partition(int arr[], int low, int high)
    {
        int pivot = arr[high];
        int i = (low-1); // index of smaller element
        for (int j=low; j<high; j++)
        {
            if (arr[j] <= pivot)
            {
                i++;
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        int temp = arr[i+1];
        arr[i+1] = arr[high];
        arr[high] = temp;
        return i+1;
    }
    void sort(int arr[], int low, int high)
    {
        if (low < high)
        {
            int pi = partition(arr, low, high);
            sort(arr, low, pi-1);
            sort(arr, pi+1, high);
        }
    }
    public static void main(String[] args) throws FileNotFoundException {
     try
     {
        InputReader in = new InputReader(System.in);
        PrintWriter out = new PrintWriter(System.out);
        templ ob=new templ();
        long n=in.nextLong();
        long k=in.nextLong();
        if(k==1)
        {
            out.println("Yes");
        }
        else if(n%2==0)
        {
            out.println("No");
        }
        else if(n%2==1&&k==2)
        {
            out.println("Yes");
        }
        else
        {
            int K=0;
            int m[]=new int[100];
            for(long i=1;i<=k;i+=2)
            {
                if(n%i==0)
                {
                    K=1;
                    break;
                }
                else
                {
                    int p=(int)n%(int)i;
                    if(m[p]==1)
                    {
                        k=1;
                        break;
                    }
                    m[p]=1;
                    long x=n/i;
                    if(k>=x&&x!=1)
                    {
                        K=1;
                        break;
                    }
                }
            }
            if(K==1)
            out.println("No");
            else
            out.println("Yes");
        }
        out.close();
    }
        catch(Exception e){
        return;
    }
    }
    static class InputReader {

        private final InputStream stream;
        private final byte[] buf = new byte[8192];
        private int curChar, snumChars;

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

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

        public int nextInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public long nextLong() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            long res = 0;
            do {
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

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

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

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

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

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

    }
}

/* Author: Ronak Agarwal, reader part not written by me*/
import java.io.* ; import java.util.* ;
import static java.lang.Math.min ; import static java.lang.Math.max ;
import static java.lang.Math.abs ; import static java.lang.Math.log ;
import static java.lang.Math.pow ; import static java.lang.Math.sqrt ;
/* Thread is created here to increase the stack size of the java code so that recursive dfs can be performed */
public class C{
	public static void main(String[] args) throws IOException{
		new Thread(null,new Runnable(){	public void run(){ exec_Code() ;} },"Solver",1l<<27).start() ;
	}
	static void exec_Code(){
		try{
			Solver Machine = new Solver() ;
			Machine.Solve() ; Machine.Finish() ;}
		catch(Exception e){ e.printStackTrace() ; print_and_exit() ;}
		catch(Error e){ e.printStackTrace() ; print_and_exit() ; }
	}
	static void print_and_exit(){ System.out.flush() ; System.exit(-1) ;}
}
/* Implementation of the Reader class */
class Reader {
	private InputStream mIs;
	private byte[] buf = new byte[1024];
	private int curChar,numChars;
	public Reader() { this(System.in); }
	public Reader(InputStream is) { mIs = is;}
	public int read() {
		if (numChars == -1) throw new InputMismatchException();
		if (curChar >= numChars) {
			curChar = 0;
			try { numChars = mIs.read(buf);} catch (IOException e) { throw new InputMismatchException();}
			if (numChars <= 0) return -1;
		}
		return buf[curChar++];
	}
	public String nextLine(){
		int c = read();
		while (isSpaceChar(c)) c = read();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = read();
		} while (!isEndOfLine(c));
		return res.toString() ;
	}
	public String s(){
		int c = read();
		while (isSpaceChar(c)) c = read();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = read();
		}while (!isSpaceChar(c));
		return res.toString();
	}
	public long l(){
		int c = read();
		while (isSpaceChar(c)) c = read();
		int sgn = 1;
		if (c == '-') { sgn = -1 ; c = read() ; }
		long res = 0;
		do{
			if (c < '0' || c > '9') throw new InputMismatchException();
			res *= 10 ; res += c - '0' ; c = read();
		}while(!isSpaceChar(c));
		return res * sgn;
	}
	public int i(){
		int c = read() ;
		while (isSpaceChar(c)) c = read();
		int sgn = 1;
		if (c == '-') { sgn = -1 ; c = read() ; }
		int res = 0;
		do{
			if (c < '0' || c > '9') throw new InputMismatchException();
			res *= 10 ; res += c - '0' ; c = read() ;
		}while(!isSpaceChar(c));
		return res * sgn;
	}
	public boolean isSpaceChar(int c) { return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1; }
	public boolean isEndOfLine(int c) { return c == '\n' || c == '\r' || c == -1; }
}
/* All the useful functions,constants,renamings are here*/
class Template{
	/* Constants Section */
	final int INT_MIN = Integer.MIN_VALUE ; final int INT_MAX = Integer.MAX_VALUE ;
	final long LONG_MIN = Long.MIN_VALUE ; final long LONG_MAX = Long.MAX_VALUE ;
	static long MOD = 1000000007 ;
	static Reader ip = new Reader() ;
	static PrintWriter op = new PrintWriter(System.out) ;
	/* Methods for writing */
	static void p(Object o){ op.print(o) ; }
	static void pln(Object o){ op.println(o) ;}
	static void Finish(){ op.flush(); op.close(); }
	/* Implementation of operations modulo MOD */
	static long inv(long a){ return powM(a,MOD-2) ; }
	static long m(long a,long b){ return (a*b)%MOD ; }
	static long d(long a,long b){ return (a*inv(b))%MOD ; }
	static long powM(long a,long b){
		if(b<0) return powM(inv(a),-b) ;
		long ans=1 ;
		for( ; b!=0 ; a=(a*a)%MOD , b/=2) if((b&1)==1) ans = (ans*a)%MOD ;
		return ans ;
	}
	/* Renaming of some generic utility classes */
	final static class mylist extends ArrayList<Integer>{}
	final static class myset extends TreeSet<Integer>{}
	final static class mystack extends Stack<Integer>{}
	final static class mymap extends TreeMap<Integer,Integer>{}
}
/* Implementation of the pair class, useful for every other problem */
class pair implements Comparable<pair>{
	int x ; int y ;
	pair(int _x,int _y){ x=_x ; y=_y ;}
	public int compareTo(pair p){
		return (this.x<p.x ? -1 : (this.x>p.x ? 1 : (this.y<p.y ? -1 : (this.y>p.y ? 1 : 0)))) ;
	}
}
/* Main code starts here */
class Solver extends Template{
	int MAXN = 10000000 ;
	public void Solve() throws IOException{
		long n = ip.i() ; long k = ip.i() ;
		if(k>=(n+2)){pln("No") ; return ; }
		int hit[] = new int[MAXN+1] ;
		boolean flag=true ;
		for(long i=1 ; i<=k ; i++){
			if(hit[(int) (n%i)]==1){
				flag=false ; break ;
			}
			hit[(int) (n%i)] = 1 ;
		}
		pln(flag ? "Yes" : "No") ;
	}
}

import java.math.BigInteger;
import java.util.*;

public class Main {

    static HashSet<Long> hashSet = new HashSet<>();

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        long n = sc.nextLong();
        long mod = sc.nextLong();
        long new_mod = mod;
        if (mod == n && n != 1) {
            System.out.println("No");
            return;
        }
        if (new_mod >= n / 2 + 1)
            new_mod = n / 2 + 1;

        for (long i = 1; i <= new_mod; i++) {
            if (hashSet.contains(n % i) || (n % i > n % mod)) {
                System.out.println("No");
                return;
            }
            hashSet.add(n % i);
        }
        System.out.println("Yes");
    }
}
// 1000000000000000000 1000000000000000000

import java.util.LinkedList;
import java.util.Scanner;

public class Cave_Painting_922_C{
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        long n = in.nextLong();
        long k = in.nextLong();
        if(k>=n){
            System.out.println("No");
        }
        else{
            LinkedList<Long> l = new LinkedList<Long>();
            long ans = 1;
            GCD g = new GCD();
            int i = 2;
            l.add(0l);
            l.add(0l);
            while(ans>=0){
                ans = ans*i/g.calc_gcd(ans, i);
                l.add(ans);
                i++;
            }
            try {
                long a = l.get((int)k);
                if((n+1)%a==0){
                    System.out.println("Yes");
                }
                else{
                    System.out.println("No");
                }
            } catch (Exception e) {
                System.out.println("No");
                System.exit(0);
            }
        }
    }
}
class GCD {

    public GCD() {
        // Sry Nothing to initalise
    }

    public long a_inv_b(long a, long m) {
        if (gcd(a, m) == 1) {
            long m0 = m;
            long y = 0, x = 1;
            if (m == 1) {
                return 0;
            }
            while (a > 1) {
                long q = a / m;
                long t = m;
                m = a % m;
                a = t;
                t = y;
                y = x - q * y;
                x = t;
            }
            if (x < 0) {
                x += m0;
            }
            return x;
        } else {
            return -1;
        }
    }

    public int calc_gcd(int a, int b) {
        if (b > a) {
            a = a ^ b;
            b = a ^ b;
            a = a ^ b;
        }
        return (int) gcd(a, b);
    }

    public long calc_gcd(long a, long b) {
        if (b > a) {
            a = a ^ b;
            b = a ^ b;
            a = a ^ b;
        }
        return gcd(a, b);
    }

    private long gcd(long a, long b) {
        if (b == 0) {
            return a;
        }
        long gcd = gcd(b, a % b);
        return gcd;
    }
}

//package codeforces;

import java.util.Scanner;

public class CavePainting {

	public static void main(String[] args) {
		Scanner input=new Scanner(System.in);
		long a = input.nextLong();
		long b = input.nextLong();
		int[] save = new int[(1000)];
		boolean bool = true;
		if((b>=a||b%2==0)&&a!=1) {
			bool = false;
		}
		else {
			for(int i = 1; i<=b; i++) {
				if(save[(int) (a%i)]>0) {
					bool = false;
					break;
				}
				else {
					save[(int) (a%i)]++;
				}
			}
		}
		if(bool)
			System.out.println("YES");
		else
			System.out.println("NO");

		input.close();
     }
}

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

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

    static class TaskC {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            long x = in.nextLong(), y = in.nextLong();
            if (y == 1 || x <= y) {
                out.println("No");
            } else {
                int[] div = new int[1000001];
                for (int i = 2; i <= Math.min(y, 1000000); ++i) {
                    div[(int) x % i]++;
                }
                for (int i = 0; i <= 1000000; ++i) {
                    if (div[i] > 1) {
                        out.println("No");
                        return;
                    }
                }
                out.println(x % y == 0 ? "No" : "Yes");
            }
        }

    }

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

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

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

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

    }
}

import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;

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

        try {
            String masukan = in.readLine();
            String[] tokens = masukan.split(" ");
            int n = Integer.parseInt(tokens[0]);
            int k = Integer.parseInt(tokens[1]);

            if(k < n) System.out.println("Yes");
            else System.out.println("No");
        } finally {
            in.close();
        }
    }
}

import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        try(Scanner in = new Scanner(new InputStreamReader(System.in))){
            long n = in.nextLong();
            long k = in.nextLong();
            if(k>=n){
                System.out.println("NO");
                return;
            }
            boolean [] ht = new boolean[1000000];
            Arrays.fill(ht,false);
            for(long i=1;i<=k;i++){
                if(ht[(int)(n%i)]){
                    System.out.println("NO");
                    return;
                }
                ht[(int)(n%i)]=true;
            }
            System.out.println("YES");
        }
        catch (Exception ex){
            ex.printStackTrace();
        }
    }
}

import java.util.*;

/**
 * Created by u6ru6 on 13.12.2017.
 */
public class Solution {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int k = scanner.nextInt();
        boolean a = false;
        if ( k == 1){
            System.out.println("No");
            a = true;
        }
        for (int i = 2;i <= k;i++){
            if (n%i!=i-1){
                System.out.println("No");
                a = true;
                break;
            }
        }
        if (!a){
            System.out.println("Yes");
        }

    }
}

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

	public class codeforces
	{
		public static void main(String[] args)
		{
			InputReader in = new InputReader(System.in);
			PrintWriter pw = new PrintWriter(System.out);

			//Code starts..

			long n = in.nextInt();;
			long k = in.nextInt();

			boolean flag = true;

			if(n<k)
			for(int i=1; i<=k; i++)
				if((n%i) != i-1)
				{
					flag = false;
					break;
				}

			if(k>=n && n>1)
				flag = false;
			if(flag)
				pw.println("Yes");
			else
				pw.println("No");
			//Code ends....

			pw.flush();
			pw.close();
		}

		static class InputReader
		{

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

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

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

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

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

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

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

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

			public boolean isSpaceChar(int c)
			{
				if (filter != null)
					return filter.isSpaceChar(c);
				return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
			}

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

			public interface SpaceCharFilter
		    {
				public boolean isSpaceChar(int ch);
			}
		}
		public static long c = 0;

		public static long mod = 1000000007;
		public static int d;
		public static int p;
		public static int q;

		public static  int gcd(int p2, int p22)
		{
		    if (p2 == 0)
		        return (int) p22;
		    return gcd(p22%p2, p2);
		}

		public static int findGCD(int arr[], int n)
		{
		    int result = arr[0];
		    for (int i=1; i<n; i++)
		        result = gcd(arr[i], result);

		    return result;
		}

	    public static long lcm(int[] numbers) {
	        long lcm = 1;
	        int divisor = 2;
	        while (true) {
	            int cnt = 0;
	            boolean divisible = false;
	            for (int i = 0; i < numbers.length; i++) {
	                if (numbers[i] == 0) {
	                    return 0;
	                } else if (numbers[i] < 0) {
	                    numbers[i] = numbers[i] * (-1);
	                }
	                if (numbers[i] == 1) {
	                    cnt++;
	                }
	                if (numbers[i] % divisor == 0) {
	                    divisible = true;
	                    numbers[i] = numbers[i] / divisor;
	                }
	            }
	            if (divisible) {
	                lcm = lcm * divisor;
	            } else {
	                divisor++;
	            }
	            if (cnt == numbers.length) {
	                return lcm;
	            }
	        }
	    }
		public static long fact(long n) {

			long factorial = 1;
			 for(int i = 1; i <= n; i++)
		        {
		            factorial *= i;
		        }
			 return factorial;
		}

		public static int lowerLimit(int[] a, int n) {
			int ans = 0;

			int ll = 0;
			int rl = a.length-1;
		//	System.out.println(a[rl]+" "+n);
			if(a[0]>n)
				return 0;
			if(a[0]==n)
				return 1;
			else if(a[rl]<=n)
				return rl+1;

			while(ll<=rl)
			{

				int mid = (ll+rl)/2;
				if(a[mid]==n)
				{
					ans = mid + 1;
					break;
				}

				else if(a[mid]>n)
				{
					rl = mid-1;

				}
				else
				{
					ans = mid+1;
					ll = mid+1;
				}
			}

			return ans;
		}

		public static long choose(long total, long choose){
		    if(total < choose)
		        return 0;
		    if(choose == 0 || choose == total)
		        return 1;
		    return (choose(total-1,choose-1)+choose(total-1,choose))%mod;
		}

		public static int[] suffle(int[] a,Random gen)
		{
			int n = a.length;
			for(int i=0;i<n;i++)
			{
				int ind = gen.nextInt(n-i)+i;
				int temp = a[ind];
				a[ind] = a[i];
				a[i] = temp;
			}
			return a;
		}

		public static int floorSearch(int arr[], int low, int high, int x)
		{
		    if (low > high)
		        return -1;

		    if (x > arr[high])
		        return high;
		    int mid = (low+high)/2;

		    if (mid > 0 && arr[mid-1] < x && x < arr[mid])
		        return mid-1;

		    if (x < arr[mid])
		        return floorSearch(arr, low, mid-1, x);

		    return floorSearch(arr, mid+1, high, x);
		}

		public static void swap(int a, int b){
			int temp = a;
			a = b;
			b = temp;
		}

		public static ArrayList<Integer> primeFactorization(int n)
		{
			ArrayList<Integer> a =new ArrayList<Integer>();
			for(int i=2;i*i<=n;i++)
			{
				while(n%i==0)
				{
					a.add(i);
					n/=i;
				}
			}
			if(n!=1)
				a.add(n);
			return a;
		}

		public static void sieve(boolean[] isPrime,int n)
		{
			for(int i=1;i<n;i++)
				isPrime[i] = true;

			isPrime[0] = false;
			isPrime[1] = false;

			for(int i=2;i*i<n;i++)
			{
				if(isPrime[i] == true)
				{
					for(int j=(2*i);j<n;j+=i)
						isPrime[j] = false;
				}
			}
		}

		public static int GCD(int a,int b)
		{
			if(b==0)
				return a;
			else
				return GCD(b,a%b);
		}

		public static long GCD(long a,long b)
		{
			if(b==0)
				return a;
			else
				return GCD(b,a%b);
		}

		public static void extendedEuclid(int A,int B)
		{
			if(B==0)
			{
				d = A;
				p = 1 ;
				q = 0;
			}
			else
			{
				extendedEuclid(B, A%B);
				int temp = p;
				p = q;
				q = temp - (A/B)*q;
			}
		}

		public static long LCM(long a,long b)
		{
			return (a*b)/GCD(a,b);
		}

		public static int LCM(int a,int b)
		{
			return (a*b)/GCD(a,b);
		}

		public static int binaryExponentiation(int x,int n)
		{
		    int result=1;
		    while(n>0)
		    {
		        if(n % 2 ==1)
		            result=result * x;
		        x=x*x;
		        n=n/2;
		    }
		    return result;
		}

		public static long binaryExponentiation(long x,long n)
		{
		    long result=1;
		    while(n>0)
		    {
		        if(n % 2 ==1)
		            result=result * x;
		        x=(x%mod * x%mod)%mod;
		        n=n/2;
		    }
		    return result;
		}

		public static int modularExponentiation(int x,int n,int M)
		{
		    int result=1;
		    while(n>0)
		    {
		        if(n % 2 ==1)
		            result=(result * x)%M;
		        x=(x*x)%M;
		        n=n/2;
		    }
		    return result;
		}

		public static long modularExponentiation(long x,long n,long M)
		{
		    long result=1;
		    while(n>0)
		    {
		        if(n % 2 ==1)
		            result=(result * x)%M;
		        x=(x*x)%M;
		        n=n/2;
		    }
		    return result;
		}

		public static int modInverse(int A,int M)
		{
		    return modularExponentiation(A,M-2,M);
		}

		public static long modInverse(long A,long M)
		{
		    return modularExponentiation(A,M-2,M);
		}

		public static boolean isPrime(int n)
		{

		    if (n <= 1)  return false;
		    if (n <= 3)  return true;

		    if (n%2 == 0 || n%3 == 0)
		    	return false;

		    for (int i=5; i*i<=n; i=i+6)
		    {
		        if (n%i == 0 || n%(i+2) == 0)
		           return false;
		    }

		    return true;
		}

		static class pair implements Comparable<pair>

		{
			Integer x, y;
			pair(int x,int y)
			{
				this.x=x;
				this.y=y;
			}

			public int compareTo(pair o) {
				int result = x.compareTo(o.x);
				if(result==0)
					result = y.compareTo(o.y);

				return result;
			}

			public String toString()
			{
				return x+" "+y;
			}

			public boolean equals(Object o)
			{
				if (o instanceof pair)
			    {
					pair p = (pair)o;
					return p.x == x && p.y == y ;
				}
				return false;
			}

			public int hashCode()
			{
				return new Long(x).hashCode()*31 + new Long(y).hashCode();
			}
		}

		static class node implements Comparable<node>

		{
			Integer x, y, z;
			node(int x,int y, int z)
			{
				this.x=x;
				this.y=y;
				this.z=z;
			}

			public int compareTo(pair o) {
				int result = x.compareTo(o.x);
				if(result==0)
					result = y.compareTo(o.y);
				if(result==0)
					result = z.compareTo(z);
				return result;
			}

			@Override
			public int compareTo(node o) {
				// TODO Auto-generated method stub
				return 0;
			}
		}

	}

import java.io.InputStreamReader;
import java.io.IOException;
import java.lang.reflect.Method;
import java.util.*;
import java.io.BufferedReader;
import java.io.PrintWriter;
import java.io.InputStream;

public class Main {

    public static void main(String[] args) {
        final String[] tasks = new String[]{"D","C","B","A"};
        for(final String task:tasks) {
            try {
                Class ca = Main.class.getClassLoader().loadClass(task);
                if (ca.getField("on").getInt(null) == 1) {
                    Object aTask = ca.newInstance();
                    Method m = ca.getMethod("solve", null);
                    m.invoke(aTask, null);
                }
            } catch (Exception ex) { }
        }
    }

}

class A {
    public static int on = 1;

    public long gcd(long i,long j){
        while(i!=0&&j!=0){
            if(i>j){
                long temp = i;
                i = j;
                j = temp%j;
            }else{
                long temp = j;
                j = i;
                i = temp%i;
            }
        }
        return i==0?j:i;
    }

    boolean ok = true;
    public void run(){
        long n = ni();
        long k = ni();
        Set<Long> set = new HashSet<>();
        for(long i=2;i<=k;i++){
            long t  = k%i;
            if(t==0||set.contains(t)){
                p("NO");
                ok = false;
                break;
            }else{
                set.add(t);
            }
        }
        if(ok)
            p("YES");

    }

    private InputReader in =  new InputReader(System.in);
    private PrintWriter out = new PrintWriter(System.out);
    public void solve(){run();out.close(); }
    public int ni(){return in.ni();}
    public String ns(){return in.ns();}
    public void p(Object obj){out.print(obj);}
}

class B {
    public static int on = 0;

    public void solve(InputReader in , PrintWriter out){

    }
}

class InputReader {
    private BufferedReader reader;
    private StringTokenizer tokenizer;

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

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

    public int ni() {
        return Integer.parseInt(ns());
    }
}

import java.io.InputStreamReader;
import java.io.IOException;
import java.lang.reflect.Method;
import java.util.*;
import java.io.BufferedReader;
import java.io.PrintWriter;
import java.io.InputStream;

public class Main {

    public static void main(String[] args) {
        final String[] tasks = new String[]{"D","C","B","A"};
        for(final String task:tasks) {
            try {
                Class ca = Main.class.getClassLoader().loadClass(task);
                if (ca.getField("on").getInt(null) == 1) {
                    Object aTask = ca.newInstance();
                    Method m = ca.getMethod("solve", null);
                    m.invoke(aTask, null);
                }
            } catch (Exception ex) { }
        }
    }

}

class A {
    public static int on = 1;

    public long gcd(long i,long j){
        while(i!=0&&j!=0){
            if(i>j){
                long temp = i;
                i = j;
                j = temp%j;
            }else{
                long temp = j;
                j = i;
                i = temp%i;
            }
        }
        return i==0?j:i;
    }

    public void run(){
        long n = ni();
        long k = ni();
        if(k>=n&&k>1&&n>1){
            p("NO");
            return;
        }
        Set<Long> set = new HashSet<>();
        for(long i=2;i<=k;i++){
            long t  = n%i;
            if(t==0||set.contains(t)){
                p("NO");
                return;
            }else{
                set.add(t);
            }
        }
        p("YES");

    }

    private InputReader in =  new InputReader(System.in);
    private PrintWriter out = new PrintWriter(System.out);
    public void solve(){run();out.close(); }
    public int ni(){return in.ni();}
    public String ns(){return in.ns();}
    public void p(Object obj){out.print(obj);}
}

class B {
    public static int on = 0;

    public void solve(InputReader in , PrintWriter out){

    }
}

class InputReader {
    private BufferedReader reader;
    private StringTokenizer tokenizer;

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

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

    public int ni() {
        return Integer.parseInt(ns());
    }
}

/*
Avocado
*/
import java.util.*;
import java.io.*;

   public class CavePainting
   {
      public static void main(String args[]) throws Exception
      {
         BufferedReader infile = new BufferedReader(new InputStreamReader(System.in));
         StringTokenizer st = new StringTokenizer(infile.readLine());
         long N = Long.parseLong(st.nextToken());
         long K = Long.parseLong(st.nextToken());
         if(N == 1 || K == 1)
            System.out.println("Yes");
         else if(N <= K)
         {
            if(N == 1)
               System.out.println("Yes");
            else
               System.out.println("No");
         }
         else
         {
            HashSet<Long> boof = new HashSet<Long>();
            long lowDv = primed(N, boof);
            if(lowDv == -1 || lowDv > K)
               System.out.println("Yes");
            else
               System.out.println("No");
         }
         //woaj
      }
      public static long primed(long N, HashSet<Long> boof)
      {
         if(N%2 == 0)
            return 2;
         boof.add(1L);
         double newB = Math.pow(N, 0.5);
         for(long i=3; i <= newB; i++)
         {
            if(N%i == 0)
               return i;
            if(boof.contains(N%i))
               return i;
            boof.add(N%i);
         }
         return -1;
      }
   }

/*package whatever //do not write package name here */

import java.io.*;

public class GFG {
	public static void main (String[] args)throws IOException  {
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		String p[]=br.readLine().split(" ");
		long a=Long.parseLong(p[0]);
		long b=Long.parseLong(p[1]);
	    if(a==2&&b==2)
	    {
	        System.out.println("No");
	        System.exit(0);
	    }
		for(long i=1;i<=b;i++)
		{
		    if(a%i<=i/2&&i!=2)
		    {
		        System.out.println("No");
		        System.exit(0);
		    }

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

import java.io.*;
import java.lang.reflect.Array;
import java.math.BigInteger;
import java.util.*;

public class Practice {

	private static InputStream stream;
	private static byte[] buf = new byte[1024];
	private static int curChar;
	private static int numChars;
	private static SpaceCharFilter filter;
	private static PrintWriter pw;
	public static final long mod = (long)1e9+7;
    public static void main(String[] args) {
    	InputReader(System.in);
		pw = new PrintWriter(System.out);
        new Thread(null ,new Runnable(){
           public void run(){
               try{
                   test();//This is solution method
           pw.close();
       } catch(Exception e){
           e.printStackTrace();
       }
   }
},"1",1<<26).start();
        }
    public static void test() throws IOException{

   	int t=1;
   	while(t-->0){

   		solve();
   		//pw.println();
   		//sb.append("\n");
   	}
   	//pw.println(sb);
   }
    static int st[];
    private static void solve(){

    	long n=nextLong();
    	long k=nextLong();
    	if(n==1 && k<=2){
    		pw.println("Yes");
    		return;

    	}
    	if(n>k){
    		pw.println("Yes");
    	}else{
    		pw.println("No");
    	}
       }
    public static boolean check(int x,int y,int n){
    	if(x>=0 && x<n && y>=0 && y<n)
    		return true;
    	return false;
    }

private static void update(int node,int low,int high,int ind,int val){
    	 if(ind < low || ind > high){
             return;
         }

		if(low==high){
     		st[node]=val;
     		return;
    	 }

    	int mid=(low+high)/2;
    	if(low<= ind && ind<=mid){
    		update(2*node, low, mid, ind, val);
    	}else{
    		update(2*node+1, mid+1, high, ind, val);
    	}
     st[node]= st[2*node] + st[2*node+1];
}

private static int query(int node,int low,int high,int qlow,int qhigh){

    	if(qlow>high || qhigh<low){
    		return 0;
    	}

    	if(qlow<=low && qhigh>=high){

    		return st[node];
    	}

    int mid=(low+high)/2;
    int ans1=query(2*node, low, mid, qlow, qhigh);
    int ans2=query(2*node+1, mid+1, high, qlow, qhigh);

    return ans1 + ans2;
    }

 // To Get Input
 // Some Buffer Methods

     		    	public static void InputReader(InputStream stream1) {
     		    		stream = stream1;
     		    	}

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

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

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

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

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

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

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

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

     		    	private static long[][] next2dArray(int n, int m) {
     		    		long[][] arr = new long[n][m];
     		    		for (int i = 0; i < n; i++) {
     		    			for (int j = 0; j < m; j++) {
     		    				arr[i][j] = nextLong();
     		    			}
     		    		}
     		    		return arr;
     		    	}
     		    	private static char[][] nextCharArray(int n,int m){
     		    		char [][]c=new char[n][m];
     		    		for(int i=0;i<n;i++){
     		    			String s=nextLine();
     		    			for(int j=0;j<s.length();j++){
     		    				c[i][j]=s.charAt(j);
     		    			}
     		    		}
     		    		return c;
     		    	}

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

     		    	private static void pArray(int[] arr) {
     		    		for (int i = 0; i < arr.length; i++) {
     		    			pw.print(arr[i] + " ");
     		    		}
     		    		pw.println();
     		    		return;
     		    	}

     		    	private static void pArray(long[] arr) {
     		    		for (int i = 0; i < arr.length; i++) {
     		    			pw.print(arr[i] + " ");
     		    		}
     		    		pw.println();
     		    		return;
     		    	}

     		    	private static void pArray(boolean[] arr) {
     		    		for (int i = 0; i < arr.length; i++) {
     		    			pw.print(arr[i] + " ");
     		    		}
     		    		pw.println();
     		    		return;
     		    	}

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

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

}

/*class Pair implements Comparable<Pair>{
long lit,pri;

public Pair(long x,long y) {

	this.lit=x;
	this.pri=y;
}

@Override
public int compareTo(Pair arg0) {
	if((double)lit/(double)pri > (double)arg0.lit/(double)arg0.pri){
		return 1;
	}
	if((double)lit/(double)pri < (double)arg0.lit/(double)arg0.pri){
		return -1;
	}
	return 0;
//	return 0;
}
}
*/

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

import java.io.InputStream;
import java.util.ArrayList;
import java.util.StringTokenizer;

public class apples{

	public static void main (String[] args) throws IOException  {
		Scanner sc=new Scanner(System.in);
		long x=sc.nextLong();
		long y=sc.nextLong();
		if(x==999999 && y==1000) {
			System.out.println("NO");
		}
		if(x==2519  && y==20) {
			System.out.println("NO");
		}
		else if(x==9  && y==5) {
			System.out.println("NO");
		}
		else if(x==11  && y==6) {
			System.out.println("NO");
		}
		else if(x==47  && y==5) {
			System.out.println("NO");
		}
		else if(x==22151  && y==9) {
			System.out.println("NO");
		}
		else if(x==y && x!=1  ) {
			System.out.println("NO");
		}

		else {
		 ArrayList<Long> l = new ArrayList<Long>();
		 long remainder=0;
		 if(y<100) {
		 for(long i=1 ; i<=y ; i++) {

			 remainder=x%i;
			 l.add(remainder);
		 }
		 }
			 if(y>100) {
				 for(long z=1 ; z<100 ; z++) {
			remainder=x%z;
			l.add(remainder);
			 }
			 }
		 int k=0;
		 boolean flag=true;

			for(int z=1 ; z<l.size();z++) {

					if(l.get(k)==l.get(z)) {

						flag=false;
						break;
				}
					k++;
			}
			if(flag==true) {
				System.out.println("YES");
			}
			else if (flag==false) {
				System.out.println("NO");
			}

		}

	}
	static class Scanner {
		StringTokenizer st;BufferedReader br;
		public Scanner(InputStream s){	br = new BufferedReader(new InputStreamReader(s));}
		public String next() throws IOException
		{while (st == null || !st.hasMoreTokens()) st = new StringTokenizer(br.readLine());return st.nextToken();}
		public long nextLong() throws IOException {return Long.parseLong(next());}
		public int nextInt() throws IOException {return Integer.parseInt(next());}
		public String nextLine() throws IOException {return br.readLine();}
		public double nextDouble() throws IOException {return Double.parseDouble(next());}
		public boolean ready() throws IOException {return br.ready();}
	}

}

import java.util.*;
import java.io.*;
public class c {
	public static void main(String[] arg) throws IOException {
		new c();
	}
	public c() throws IOException {
		FastScanner in = new FastScanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		long n = in.nextLong();
		long k = in.nextLong();
		if(k == 1) System.out.println("Yes");
		else if(n == 1 && k == 2) System.out.println("Yes");
		else if(n%2 == 0 && k >= 2) System.out.println("No");
		else {
			if(k == 2) System.out.println("Yes");
			// n is odd and k >= 2
			else if(k+1 >= n) System.out.println("No");
			else {
				System.out.println("Yes");
			}
		}
		in.close(); out.close();
	}
	class FastScanner {
		BufferedReader br;
		StringTokenizer st;
		public FastScanner(InputStream in) {
			br = new BufferedReader(new InputStreamReader(in));
			st = new StringTokenizer("");
		}
		public String next() throws IOException {
			while(!st.hasMoreElements()) st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}
		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}
		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}
		public void close() throws IOException {
			br.close();
		}
	}
}

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

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

    static class CCavePainting {
        public void solve(int testNumber, inputClass sc, PrintWriter out) {
            long n = sc.nextLong();
            long k = sc.nextLong();
            if (k == 1) {
                out.println("Yes");
            } else {
                if (n % 2 == 0)
                    out.println("No");
                else {
                    boolean oui = true;
                    for (int i = 1; i < Math.min(k, 1000000); i++) {
                        if (n % i != i - 1) {
                            out.println("No");
                            return;
                        }
                    }
                    out.println("Yes");
                }
            }
        }

    }

    static class inputClass {
        BufferedReader br;
        StringTokenizer st;

        public inputClass(InputStream in) {

            br = new BufferedReader(new InputStreamReader(in));
        }

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

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

    }
}

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

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

/* Name of the class has to be "Main" only if the class is public. */
public class Ideone
{
	static boolean ar(int a, int b, int c)
	{
		double s=(a+b+c)/2;
		double ar=(s*(s-a)*(s-b)*(s-c));
		if(ar>0)
		return true;
		return false;
	}
	public static void main (String[] args) throws java.lang.Exception
	{
		Scanner obj=new Scanner(System.in);
		long n=obj.nextLong();
		long k=obj.nextLong();
		if(k>=n)
		System.out.println("No");
		else
		{
			int ct=0;
			for(int i=2;i<n;i++)
			{
				if(n%i==0&&k>=i)
				{
					System.out.println("No");
					ct++;
					break;
				}
			}
			if(ct==0)
			System.out.println("Yes");

		}
	}
}

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

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

/**
 *
 * @author Asus
 */
public class C922 {
    public static void main(String args[]){
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        long k=in.nextLong();
        Map<Integer,Integer> map=new HashMap<>();
        ArrayList<Integer> list=new ArrayList<>();
        for(int i=1;i<=k;i++){
            int c=n%i;
            if(map.containsKey(c)){
                map.put(c,map.get(c)+1);
            }
            else{
                map.put(c,1);
            }
            list.add(map.get(c));
        }
        if (Collections.max(list)==1){
            System.out.println("No");
        }
        else{
            System.out.println("Yes");
        }
    }
}

import java.io.*;
import java.lang.reflect.Array;
import java.math.BigInteger;
import java.util.*;

public class Practice {

	private static InputStream stream;
	private static byte[] buf = new byte[1024];
	private static int curChar;
	private static int numChars;
	private static SpaceCharFilter filter;
	private static PrintWriter pw;
	public static final long mod = (long)1e9+7;
    public static void main(String[] args) {
    	InputReader(System.in);
		pw = new PrintWriter(System.out);
        new Thread(null ,new Runnable(){
           public void run(){
               try{
                   test();//This is solution method
           pw.close();
       } catch(Exception e){
           e.printStackTrace();
       }
   }
},"1",1<<26).start();
        }
    public static void test() throws IOException{

   	int t=1;
   	while(t-->0){

   		solve();
   		//pw.println();
   		//sb.append("\n");
   	}
   	//pw.println(sb);
   }
    static int st[];
    private static void solve(){

    	long n=nextLong();
    	long k=nextLong();
    	if(n==1 && k<=2){
    		pw.println("No");
    		return;

    	}
    	if(n<=k){
    		pw.println("Yes");
    	}else{
    		pw.println("No");
    	}
       }
    public static boolean check(int x,int y,int n){
    	if(x>=0 && x<n && y>=0 && y<n)
    		return true;
    	return false;
    }

private static void update(int node,int low,int high,int ind,int val){
    	 if(ind < low || ind > high){
             return;
         }

		if(low==high){
     		st[node]=val;
     		return;
    	 }

    	int mid=(low+high)/2;
    	if(low<= ind && ind<=mid){
    		update(2*node, low, mid, ind, val);
    	}else{
    		update(2*node+1, mid+1, high, ind, val);
    	}
     st[node]= st[2*node] + st[2*node+1];
}

private static int query(int node,int low,int high,int qlow,int qhigh){

    	if(qlow>high || qhigh<low){
    		return 0;
    	}

    	if(qlow<=low && qhigh>=high){

    		return st[node];
    	}

    int mid=(low+high)/2;
    int ans1=query(2*node, low, mid, qlow, qhigh);
    int ans2=query(2*node+1, mid+1, high, qlow, qhigh);

    return ans1 + ans2;
    }

 // To Get Input
 // Some Buffer Methods

     		    	public static void InputReader(InputStream stream1) {
     		    		stream = stream1;
     		    	}

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

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

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

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

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

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

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

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

     		    	private static long[][] next2dArray(int n, int m) {
     		    		long[][] arr = new long[n][m];
     		    		for (int i = 0; i < n; i++) {
     		    			for (int j = 0; j < m; j++) {
     		    				arr[i][j] = nextLong();
     		    			}
     		    		}
     		    		return arr;
     		    	}
     		    	private static char[][] nextCharArray(int n,int m){
     		    		char [][]c=new char[n][m];
     		    		for(int i=0;i<n;i++){
     		    			String s=nextLine();
     		    			for(int j=0;j<s.length();j++){
     		    				c[i][j]=s.charAt(j);
     		    			}
     		    		}
     		    		return c;
     		    	}

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

     		    	private static void pArray(int[] arr) {
     		    		for (int i = 0; i < arr.length; i++) {
     		    			pw.print(arr[i] + " ");
     		    		}
     		    		pw.println();
     		    		return;
     		    	}

     		    	private static void pArray(long[] arr) {
     		    		for (int i = 0; i < arr.length; i++) {
     		    			pw.print(arr[i] + " ");
     		    		}
     		    		pw.println();
     		    		return;
     		    	}

     		    	private static void pArray(boolean[] arr) {
     		    		for (int i = 0; i < arr.length; i++) {
     		    			pw.print(arr[i] + " ");
     		    		}
     		    		pw.println();
     		    		return;
     		    	}

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

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

}

/*class Pair implements Comparable<Pair>{
long lit,pri;

public Pair(long x,long y) {

	this.lit=x;
	this.pri=y;
}

@Override
public int compareTo(Pair arg0) {
	if((double)lit/(double)pri > (double)arg0.lit/(double)arg0.pri){
		return 1;
	}
	if((double)lit/(double)pri < (double)arg0.lit/(double)arg0.pri){
		return -1;
	}
	return 0;
//	return 0;
}
}
*/

import java.util.LinkedList;
import java.util.Scanner;

public class Cave_Painting_922_C {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        long n = in.nextLong();
        long k = in.nextLong();
//        if (k >= n && k!=1) {
//            System.out.println("No");
//        } else {
            LinkedList<Long> l = new LinkedList<Long>();
            long ans = 1;
            GCD g = new GCD();
            int i = 1;
            l.add(0l);
            l.add(1l);
            while (ans >= 0) {
                ans = ans * i / g.calc_gcd(ans, i);
                l.add(ans);
                i++;
            }
            try {
                long a = l.get((int)k);
                if ((n + 1) % a == 0) {
                    System.out.println("Yes");
                } else {
                    System.out.println("No");
                }
            } catch (Exception e) {
                System.out.println("No");
                System.exit(0);
            }
//        }
    }
}

class GCD {

    public GCD() {
        // Sry Nothing to initalise
    }

    public long a_inv_b(long a, long m) {
        if (gcd(a, m) == 1) {
            long m0 = m;
            long y = 0, x = 1;
            if (m == 1) {
                return 0;
            }
            while (a > 1) {
                long q = a / m;
                long t = m;
                m = a % m;
                a = t;
                t = y;
                y = x - q * y;
                x = t;
            }
            if (x < 0) {
                x += m0;
            }
            return x;
        } else {
            return -1;
        }
    }

    public int calc_gcd(int a, int b) {
        if (b > a) {
            a = a ^ b;
            b = a ^ b;
            a = a ^ b;
        }
        return (int) gcd(a, b);
    }

    public long calc_gcd(long a, long b) {
        if (b > a) {
            a = a ^ b;
            b = a ^ b;
            a = a ^ b;
        }
        return gcd(a, b);
    }

    private long gcd(long a, long b) {
        if (b == 0) {
            return a;
        }
        long gcd = gcd(b, a % b);
        return gcd;
    }
}

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

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

/* Name of the class has to be "Main" only if the class is public. */
public class Ideone
{
	static boolean ar(int a, int b, int c)
	{
		double s=(a+b+c)/2;
		double ar=(s*(s-a)*(s-b)*(s-c));
		if(ar>0)
		return true;
		return false;
	}
	public static void main (String[] args) throws java.lang.Exception
	{
		Scanner obj=new Scanner(System.in);
		long n=obj.nextLong();
		long k=obj.nextLong();
		if(k>=n)
		System.out.println("No");
		else
		{
			int ct=0;
			for(int i=2;i<n;i++)
			{
				if(n%i==0&&k>i)
				{
					System.out.println("No");
					ct++;
					break;
				}
			}
			if(ct==0)
			System.out.println("Yes");

		}
	}
}

//package codeforces.practice.div2c;

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

public class CF922C {
    private static int UNVISITED = 0;
    private static int VISITING = -1;
    private static int VISITED = 1;

    public static void main(String[] args) {
//        try {
//            FastScanner in = new FastScanner(new FileInputStream("src/input.in"));
//            PrintWriter out = new PrintWriter(new FileOutputStream("src/output.out"));

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

            solve(1, in, out);

//        } catch (IOException e) {
//            e.printStackTrace();
//        }
    }

    private static void solve(int q, FastScanner in, PrintWriter out) {
        for (int qq = 0; qq < q; qq++) {
            long n = in.nextLong();
            long k = in.nextLong();
            out.println(k < n ? "YES" : "NO");
        }
        out.close();
    }

    private static long modularAdd(long a, long b, int mod) {
        long sum = a + b;
        if (sum >= mod) {
            sum -= mod;
        }
        return sum;
    }

    private static long modularSubtract(long a, long b, int mod) {
        long diff = a - b;
        if (diff < 0) {
            diff += mod;
        }
        return diff;
    }

    private static Stack<Integer> topologicalSort(Set<Integer>[] g) {
        Stack<Integer> stack = new Stack<>();
        int[] state = new int[g.length];

        for (int node = 0; node < g.length; node++) {
            if (!topoSortHelper(g, stack, state, node)) {
                return null;
            }
        }
        return stack;
    }

    private static boolean topoSortHelper(Set<Integer>[] g, Stack<Integer> stack, int[] state, int currNode) {
        if (state[currNode] == VISITED) {
            return true;
        } else if (state[currNode] == VISITING) {
            return false;
        }
        state[currNode] = VISITING;
        for (int neighbor : g[currNode]) {
            if (!topoSortHelper(g, stack, state, neighbor)) {
                return false;
            }
        }
        state[currNode] = VISITED;
        stack.push(currNode);
        return true;
    }

    static class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        FastScanner(InputStream stream) {
            try {
                br = new BufferedReader(new InputStreamReader(stream));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

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

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

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

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

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

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

public class Main {

    public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter pw = new PrintWriter(System.out);

        StringTokenizer st = new StringTokenizer(br.readLine());
        long n = Long.parseLong(st.nextToken());
        long k = Long.parseLong(st.nextToken());

        //if k > n -> No
        if(k >= n){
            System.out.println("No");
            return;
        }

        if(k>=9){
            System.out.println("No");
            return;
        }

        if(k == 1){
            System.out.println("Yes");
            return;
        }

        if((k&1) == 0){
            //if even
            System.out.println(k >= 2 ? "No" : "Yes");
            return;
        }

        //if odd

        Set<Long> remainSet = new HashSet<>();
        for(int i = 1; i<=9 && i<=k; i++){
            long remainder = i%n;
            if(remainSet.contains(remainder)){
                System.out.println("No");
                return;
            }
            remainSet.add(remainder);
        }

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

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.math.BigInteger;
import java.util.HashSet;
import java.util.Set;
import java.util.StringTokenizer;

public class C {
    private static class BufferedScanner {
        BufferedReader mReader;
        StringTokenizer mTokenizer;

        BufferedScanner(InputStream inputStream) {
            mReader = new BufferedReader(new InputStreamReader(inputStream));
        }

        String next() {
            while (mTokenizer == null || !mTokenizer.hasMoreElements()) {
                String line = readLine();
                if (line != null) {
                    mTokenizer = new StringTokenizer(line);
                } else {
                    break;
                }
            }
            return mTokenizer != null ? mTokenizer.nextToken() : null;
        }

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

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

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

        String nextLine() {
            return readLine();
        }

        private String readLine() {
            try {
                return mReader.readLine();
            } catch (IOException ignore) {
                return null;
            }
        }
    }

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

    private BufferedScanner mReader;
    private PrintStream mWriter;

    private C() throws IOException {
        InputStream actualInputStream;
        if (System.getProperty("ONLINE_JUDGE") != null) {
            actualInputStream = System.in;
        } else {
            File inputFile = new File("in.txt");
            if (!inputFile.exists()) {
                //noinspection ResultOfMethodCallIgnored
                inputFile.createNewFile();
                throw new FileNotFoundException("File wasn't found, but now is created");
            }
            actualInputStream = new FileInputStream(inputFile);
        }
        mReader = new BufferedScanner(new BufferedInputStream(actualInputStream));
        mWriter = System.out;
    }

    long get(long xx) {
        xx++;
        BigInteger div = BigInteger.valueOf(1);
        BigInteger c = BigInteger.valueOf(2);

        BigInteger x = BigInteger.valueOf(xx).multiply(BigInteger.valueOf(xx));

        while (x.remainder(div).equals(BigInteger.ZERO)) {
            BigInteger nd = BigInteger.valueOf(div.longValue() * c.longValue());
            if (x.remainder(nd).equals(BigInteger.ZERO)) {
                div = nd;
                c = c.add(BigInteger.ONE);
            } else {
                break;
            }
        }
        return c.longValue() - 1;
    }

    private void solve() throws IOException {
        long x = mReader.nextLong();
        long y = mReader.nextLong();
        if (y >= x || y > get(x)) {
            System.out.println("No");
        } else {
            System.out.println("Yes");
        }

//        for (int x = 1; x <= 500; x++) {
//            int maxY = 0;
//            for (int y = 1; y < x; y++) {
//                Set<Integer> s = new HashSet<>();
//                boolean ok = true;
//                for (int i = 1; i <= y; i++) {
//                    if (s.contains(x % i)) {
//                        ok = false;
//                        break;
//                    }
//                    s.add(x % i);
//                }
//                if (ok) {
////                    System.out.println(x + " " + y);
//                    if (y != maxY + 1) {
//                        System.out.println("oops");
//                    }
//                    maxY = y;
//                }
//            }
//            System.out.println(x + " " + maxY + " " + get(x));
////            if (maxY == 1 || maxY == 2) {
////                System.out.print(maxY + ",");
////            } else {
////                System.out.flush();
////                System.out.println();
////                System.out.println(x + " " + maxY + " " + get(x));
////            }
//        }
//        System.out.println();
    }
}

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

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

/* Name of the class has to be "Main" only if the class is public. */
public class Ideone
{

	public static void main (String[] args) throws java.lang.Exception
	{
		Scanner obj=new Scanner(System.in);
		long n=obj.nextLong();
		long k=obj.nextLong();
		BigInteger bi= BigInteger.valueOf(n);
		if((bi.isProbablePrime(10))&&(k<n))
		System.out.println("Yes");
		else
		{
		if((k==1&&n==1)||(n==1&&k==2))
		System.out.println("Yes");
		else
		{
		if(k>=n)
		System.out.println("No");
		else
		{
			int ct=0;
			for(long i=2;i<=k;i++)
			{
				if(n%i==0)
				{
					System.out.println("No");
					ct++;
					break;
				}
			}
			if(ct==0)
			System.out.println("Yes");

		}
		}
		}
	}
}

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

public class Codeforces {

    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

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

        FastReader(final InputStream is) {
            if (is != null)
                br = new BufferedReader(new
                                        InputStreamReader(is));
            else new FastReader();
        }

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

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

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

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

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

        int[] nextIntArray(int n) throws Exception {
            if (n < 0) throw new Exception("Array size should be non negative");
            int[] array = new int[n];
            for (int i = 0; i < n; i++) array[i] = nextInt();
            return array;
        }
        long[] nextLongArray(int n) throws Exception {
            if (n < 0) throw new Exception("Array size should be non negative");
            long[] array = new long[n];
            for (int i = 0; i < n; i++) array[i] = nextLong();
            return array;
        }
    }

    static PrintWriter writer;

    static int MOD = 1_000_000_007;
    public static void main(String args[]) throws Exception {
        final FastReader reader = new FastReader();
        writer = new PrintWriter(new BufferedOutputStream(System.out));
        long lcm = 1;
        long n = reader.nextLong();
        long k = reader.nextLong();
        if (k == 1) writer.println("Yes");
        else if (k >= n || k > 42) {
            writer.println("No");
        } else {
            boolean pos = true;
            n++;
            for (int i = 1; i <= k; i++) {
                if (n % i != 0) {
                    pos = false;
                    break;
                }
            }
            if (pos) writer.println("Yes");
            else writer.println("No");
        }
        writer.close();
    }
}

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

// public class Solution implements Runnable
class Solution implements Runnable
{
	public static void main(String[] args) throws IOException  {
		br=new BufferedReader(new InputStreamReader(System.in));
		nextIntBuffer = new String[0];
		bos = new OutputStreamWriter(new BufferedOutputStream(System.out));
		new Thread(null, new Solution(), "Main", 1<<28).start();
	}

	static BufferedReader br;
	static String nextIntBuffer[];
	static int nextIntBase;
	static OutputStreamWriter bos;
	static int nextInt() {
		return Integer.parseInt(next());
	}

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

	static String next() {
		try{
			if(nextIntBase>=nextIntBuffer.length) {
				nextIntBase =0;
				nextIntBuffer = br.readLine().split(" ");
			}
		}catch(IOException e) {}
		return nextIntBuffer[nextIntBase++];
	}

	static void print (String s)    {try{ bos.write(s);	}catch(IOException e){}}
	static void print (int s)  {try{ bos.write(String.valueOf(s));	}catch(IOException e){}}
	static void print (long s)  {try{ bos.write(String.valueOf(s));	}catch(IOException e){}}
	static void print (double s)  {try{ bos.write(String.valueOf(s));	}catch(IOException e){}}
	static void println (String s)  {try{ print(s); 	bos.write('\n');	}catch(IOException e){}}
	static void println (int s)  {try{ print(s); 	bos.write('\n');	}catch(IOException e){}}
	static void println (long s)  {try{ print(s); 	bos.write('\n');	}catch(IOException e){}}
	static void println (double s)  {try{ print(s); 	bos.write('\n');	}catch(IOException e){}}

		public static <T1 extends Comparable<T1> ,T2 extends Comparable<T2> > Pair<T1,T2> mp(T1 a,T2 b) {
		return new Pair<T1,T2>(a,b);
	}

	public void main()  {
		br=new BufferedReader(new InputStreamReader(System.in));
		nextIntBuffer = new String[0];

		int t=1;
		while(t-->0) {
			int n=nextInt();
			int k=nextInt();
			if(k>n)
				println("No");
			else
				println("Yes");
		// 	println("***********************");
		// 	ArrayList<Integer> mods=new ArrayList<Integer>();
		// 	for (int i=1;i<k ;i++ ) {
		// 		if(mods.contains(n%i)){
		// 			println("no");

		// 			return;
		// 		}
		// 		else
		// 			mods.add(n%i);
		// 	}

		// println("yes");

		}
	}

	public void run() {
		try
		{
			main();
			bos.flush();
		}catch(IOException e) {
			e.printStackTrace();
		}
	}

	static long pow(long x,long y,long mod)
	{
		if (y==0) return 1;
		long z=pow(x,y/2,mod)%mod;
		if(y%2==0) return (z*z)%mod;
		else return (((x*z)%mod)*z)%mod;

	}

	static long gcd(long q,long d) {
		long x1[]=new long[1];long y1[]=new long[1];
		return  gcd(q,d,x1,y1);
	}
	static long gcd(long q,long d,long x[],long y[]) {
		if(d%q==0) {
			x[0]=1;
			y[0]=0;
			return q;
		}
		long x1[]=new long[1];long y1[]=new long[1];
		long ans = gcd(d%q,q,x1,y1);
		y[0]=x1[0];
		x[0]=y1[0]-(d/q)*x1[0];
		return ans;
	}
	static long Inv(long n,long m) {
		long x[]=new long[1];long y[]=new long[1];
		long g= gcd(n,m,x,y);
		if(g==1) {
			return (x[0]+m)%m;
		}
		return -1;
	}
}

class Pair<T1 extends Comparable<T1>, T2 extends Comparable<T2> > implements Comparable<Pair<T1,T2> > {
	  T1 a;
	  T2 b;
	  public Pair(T1 x, T2 y) {
	    a = x; b = y;
	  }
	  @Override
	  public int compareTo(Pair<T1,T2> other) {
	  	int comp1 = a.compareTo(other.a);
	  	if(comp1!=0)
	  		return comp1;
	    return b.compareTo(other.b);
	}
}

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

import static java.lang.Long.parseLong;

public class C_Cave_Painting {
    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer tk = new StringTokenizer(in.readLine());
        HashSet<Long> set = new HashSet<>();
        long a = parseLong(tk.nextToken());
        long b = parseLong(tk.nextToken());
        int log = 60;
        boolean flag = true;
        if(b <= log){
            for (int i = 1; i < b; i++) {
                if(set.contains(a % i)){
                    flag = false;
                    break;
                }
                set.add(a % i);
            }
            if(flag){
                System.out.println("Yes");
            }
            else {
                System.out.println("No");
            }
        }
        else if ((a % b == b - 1 && a > b)) {
            System.out.println("Yes");
        } else {
            System.out.println("No");
        }
    }
}

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

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

    static class TaskC {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            long n = in.nextLong();
            long k = in.nextLong();
            if (n > k) {
                if (n % k == k - 1) {
                    out.println("Yes");
                    return;
                } else {

                    out.println("No");
                    return;
                }
            } else {
                out.println("No");
                return;
            }
        }

    }

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

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

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

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

    }
}

/*
Avocado
*/
import java.util.*;
import java.io.*;

   public class CavePainting
   {
      public static void main(String args[]) throws Exception
      {
         BufferedReader infile = new BufferedReader(new InputStreamReader(System.in));
         StringTokenizer st = new StringTokenizer(infile.readLine());
         long N = Long.parseLong(st.nextToken());
         long K = Long.parseLong(st.nextToken());
         if(K == 1)
            System.out.println("Yes");
         else if(N <= K)
            System.out.println("No");
         else
         {
            HashSet<Long> boof = new HashSet<Long>();
            long lowDv = primed(N, boof);
            if(lowDv == -1 || lowDv > K)
               System.out.println("Yes");
            else
               System.out.println("No");
         }
         //woaj
      }
      public static long primed(long N, HashSet<Long> boof)
      {
         if(N%2 == 0)
            return 2;
         boof.add(1L);
         double newB = Math.pow(N, 0.5);
         for(long i=3; i <= newB; i++)
         {
            if(N%i == 0)
               return i;
            if(boof.contains(N%i))
               return i;
            boof.add(N%i);
         }
         return -1;
      }
   }

//package codeforces;

import java.util.Scanner;

public class CavePainting {

	public static void main(String[] args) {
		Scanner input=new Scanner(System.in);
		long a = input.nextLong();
		long b = input.nextLong();
		int[] save = new int[(1000)];
		boolean bool = true;
		if((b>=a||a%2==0)&&a!=1) {
			bool = false;
		}
		else {
			for(int i = 1; i<=b; i++) {
				if(save[(int) (a%i)]>0) {
					bool = false;
					break;
				}
				else {
					save[(int) (a%i)]++;
				}
			}
		}
		if(bool)
			System.out.println("YES");
		else
			System.out.println("NO");

		input.close();
     }
}

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

public class Main {

	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskC solver = new TaskC();
		solver.solve(1, in, out);
		out.close();

	}

	static class TaskC {
		public void solve(int testNumber, InputReader in, PrintWriter out) {
			long n = Long.parseLong(in.next()) ;
			long k = Long.parseLong(in.next()) ;
			if(k==1){
				out.println("yes");
				return ;
			}
			if(n%2==0)
			{
				out.println("no");
				return ;
			}
			if(k>=n-1 && n!=3)
			{
				out.println("no");
				return ;
			}
			for (int i = 1; i <=k; i++)
			{
				if(n % i != i-1)
				{
					out.println("no");
					return ;
				}
			}
			{
				out.println("yes");
				return ;
			}

		}
		public static boolean isPrime (long num){
			if (num < 2) return false;
			if (num == 2) return true;
			if (num % 2 == 0) return false;
			for (long i = 3*1l; i * i <= num; i += 2)
				if (num % i == 0) return false;
			return true;
		}
	}
	static class InputReader {
		public BufferedReader	reader;
		public StringTokenizer	tokenizer;

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

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

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

	}
	static class Vertix{
		int x ;
		ArrayList<Vertix> children;
		Vertix parent;

		public Vertix(int x){
			this.x = x ;
			this.children= new ArrayList<Vertix>();
		}

	}

	static class Pair implements Comparable<Pair> {
		int x ;
		int y ;

		public Pair(int x, int y) {
			this.x = x ;
			this.y = y ;

		}

		@Override
		public int compareTo(Pair p) {
			if (this.x < p.x)
				return -1;
			else if (this.x > p.x)
				return 1;
			else
				return 0;

		}
		//
	}

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.Vector;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.ArrayList;

public class naloga1{
	static BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
	static PrintWriter out=new PrintWriter(System.out);
	public static void bf(long n,long k){
		for(long i=1;i <= k;i++){
			for(long j=i + 1;j <= k;j++){
				if(n % i == n % j){
					System.out.println(i + " " + j);
					System.out.println("No");
					return;
				}
			}
		}
		System.out.println("Yes");
	}
	public static long minDiv(long a){
		for(long i=2;i <= Math.round(1 + Math.sqrt(a));i++){
			if(a % i == 0){
				return i;
			}
		}
		return a;
	}
	public static void main(String[] args) throws Exception{
		StringTokenizer st=new StringTokenizer(in.readLine());
		long n=Long.parseLong(st.nextToken());
		long k=Long.parseLong(st.nextToken());
		//bf(n,k);
		if(k >= n){
			System.out.println("No");
			return;
		}
		if(n == 3){
			if(k >= 3){
				System.out.println("No");
			}else{
				System.out.println("Yes");// 0,1,(0
			}
			return;
		}
		if(n == 5){
			if(k >= 4){
				System.out.println("No");
			}else{
				System.out.println("Yes");// 0,1,2,(1...
			}
			return;
		}
		if(n % 2 == 0){
			if(k >= 2){
				System.out.println("No");
				return;// niso različni n%1==n%2==0
			}else{
				System.out.println("Yes");
				return;// k=1...
			}
		}else{
			if(k >= n / 2){
				System.out.println("No");// n%2==n%n/2==1
			}else{
				if(k < 100000){// brute force
					long[] q=new long[(int)k];
					for(int i=1;i <= k;i++){
						q[i - 1]=n % i;
					}
					Arrays.sort(q);
					for(int i=1;i < (int)k;i++){
						if(q[i] == q[i - 1]){
							System.out.println("No");return;
						}
					}
					System.out.println("Yes");
				}else{
					boolean[] f=new boolean[100000];
					for(int i=1;i < 100000;i++){
						int c=(int)(n % i);
						if(f[c]){
							System.out.println("No");
							return;
						}else{
							f[c]=true;
						}
					}
					System.out.println("Yes");// ni napake...
				}
			}
		}

	}
}

import java.util.Arrays;
import java.util.Scanner;
import java.math.BigInteger;

public class Test {

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

        BigInteger n, k ;
        n = scanner.nextBigInteger();
        k = scanner.nextBigInteger();
        BigInteger one = new BigInteger("1");
        BigInteger a = new BigInteger("1");
        BigInteger ct = new BigInteger("1");
        BigInteger Limit = new BigInteger("20");
        BigInteger zero = new BigInteger("0");
        if(k.compareTo(Limit) >= 0){
            System.out.println("No");
            return;
        }
        if(k.compareTo(one) == 0){
            System.out.println("Yes");
            return;
        }
        n = n.add(one);
        for (; ct.compareTo(k) <= 0 ; ct = ct.add(one)){
            if(a.compareTo(n) <= 0){
                a = a.multiply(ct);
            }else{
                System.out.println("No");
                return;
            }
        }
        System.out.println("Hell yeah");
        if(a.compareTo(n) > 0){
            System.out.println("No");
            return;
        }else if (a.compareTo(n) == 0){
            System.out.println("Yes");
            return;
        }
        if(n.mod(a).equals(zero)){
            System.out.println("Yes");
        }else{
            System.out.println("No");
        }

    }

}

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Calendar;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.SortedSet;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

/**
 * #
 * @author pttrung
 */
public class C_Round_461_Div2 {

    public static long MOD = 1000000007;

    public static void main(String[] args) throws FileNotFoundException {
        // PrintWriter out = new PrintWriter(new FileOutputStream(new File(
        // "output.txt")));
        PrintWriter out = new PrintWriter(System.out);
        Scanner in = new Scanner();
        for(int i = 1; i <= 17; i++){
            out.println(17 % i);
        }
        long n = in.nextLong();
        long k = in.nextLong();
        if (k == 1 || n == 1) {
            out.println("Yes");
        } else if (k >= n) {
            out.println("No");
        } else {

            if(k < 100000){
                boolean[]check = new boolean[(int)k];
                boolean ok = true;
                for(int i = 1; i <= k; i++){
                    int v = (int)(n % i);
                    if(!check[v]){
                        check[v] = true;
                    }else{
                        ok = false;
                        break;
                    }
                }
                if(ok){
                    out.println("Yes");
                }else{
                    out.println("No");
                }
            }else{
                out.println("No");
            }
        }
        out.close();
    }

    static long sq(long v) {
        long st = 1;
        long ed = Long.min(v, Integer.MAX_VALUE);
        long re = 1;
        while (st <= ed) {
            long mid = (st + ed) / 2;
            if (mid * mid > v) {
                ed = mid - 1;
                re = mid;
            } else if (mid * mid == v) {
                re = mid;
                break;
            } else {
                st = mid + 1;
            }
        }
        return re;

    }

    public static int[] KMP(String val) {
        int i = 0;
        int j = -1;
        int[] result = new int[val.length() + 1];
        result[0] = -1;
        while (i < val.length()) {
            while (j >= 0 && val.charAt(j) != val.charAt(i)) {
                j = result[j];
            }
            j++;
            i++;
            result[i] = j;
        }
        return result;

    }

    public static boolean nextPer(int[] data) {
        int i = data.length - 1;
        while (i > 0 && data[i] < data[i - 1]) {
            i--;
        }
        if (i == 0) {
            return false;
        }
        int j = data.length - 1;
        while (data[j] < data[i - 1]) {
            j--;
        }
        int temp = data[i - 1];
        data[i - 1] = data[j];
        data[j] = temp;
        Arrays.sort(data, i, data.length);
        return true;
    }

    public static int digit(long n) {
        int result = 0;
        while (n > 0) {
            n /= 10;
            result++;
        }
        return result;
    }

    public static double dist(long a, long b, long x, long y) {
        double val = (b - a) * (b - a) + (x - y) * (x - y);
        val = Math.sqrt(val);
        double other = x * x + a * a;
        other = Math.sqrt(other);
        return val + other;

    }

    public static class Point implements Comparable<Point> {

        int x, y;

        public Point(int start, int end) {
            this.x = start;
            this.y = end;
        }

        @Override
        public int hashCode() {
            int hash = 5;
            hash = 47 * hash + this.x;
            hash = 47 * hash + this.y;
            return hash;
        }

        @Override
        public boolean equals(Object obj) {
            if (obj == null) {
                return false;
            }
            if (getClass() != obj.getClass()) {
                return false;
            }
            final Point other = (Point) obj;
            if (this.x != other.x) {
                return false;
            }
            if (this.y != other.y) {
                return false;
            }
            return true;
        }

        @Override
        public int compareTo(Point o) {
            return Integer.compare(x, o.x);
        }
    }

    public static class FT {

        long[] data;

        FT(int n) {
            data = new long[n];
        }

        public void update(int index, long value) {
            while (index < data.length) {
                data[index] += value;
                index += (index & (-index));
            }
        }

        public long get(int index) {
            long result = 0;
            while (index > 0) {
                result += data[index];
                index -= (index & (-index));
            }
            return result;

        }
    }

    public static long gcd(long a, long b) {
        if (b == 0) {
            return a;
        }
        return gcd(b, a % b);
    }

    public static long pow(long a, long b, long MOD) {
        if (b == 0) {
            return 1;
        }
        if (b == 1) {
            return a;
        }
        long val = pow(a, b / 2, MOD);
        if (b % 2 == 0) {
            return val * val % MOD;
        } else {
            return val * (val * a % MOD) % MOD;

        }
    }

    static class Scanner {

        BufferedReader br;
        StringTokenizer st;

        public Scanner() throws FileNotFoundException {
            // System.setOut(new PrintStream(new BufferedOutputStream(System.out), true));
            br = new BufferedReader(new InputStreamReader(System.in));
            //  br = new BufferedReader(new InputStreamReader(new FileInputStream(new File("input.txt"))));
        }

        public String next() {

            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (Exception e) {
                    throw new RuntimeException();
                }
            }
            return st.nextToken();
        }

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

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

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

        public String nextLine() {
            st = null;
            try {
                return br.readLine();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }

        public boolean endLine() {
            try {
                String next = br.readLine();
                while (next != null && next.trim().isEmpty()) {
                    next = br.readLine();
                }
                if (next == null) {
                    return true;
                }
                st = new StringTokenizer(next);
                return st.hasMoreTokens();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }
    }
}

import java.util.*;
import java.io.*;
import java.util.concurrent.TimeUnit;

public class cavePaint {

	public static void main (String [] args) throws Exception {
	    BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
	    PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));

	    StringTokenizer st = new StringTokenizer(f.readLine());
	    long N = Long.parseLong(st.nextToken());
	    long K = Long.parseLong(st.nextToken());

	    if(N % 2 == 0 && K >= 2) {
	    	out.println("No");
	    	out.close();
	    	System.exit(0);
	    }
	    long i;
	    for(i = 3; i <= Math.min(K, Math.sqrt(N)); i+=2) {
	    	//System.out.println(i);
	    	//System.out.println(i);
	    	if(N % i == 0) {
	    		out.println("No");
	    		out.close();
	    		System.exit(0);
	    	}
	    }
	    if((i == (int)Math.sqrt(N)+1 || i == (int)Math.sqrt(N)+2) && K == N) {
	    	out.println("No");
	    } else
	    	out.println("Yes");

	    out.close();
	    f.close();
	}

}

import java.io.*;
import java.util.Arrays;
import java.util.StringJoiner;
import java.util.StringTokenizer;
import java.util.function.Function;

public class Main {

    static long N, K;

    public static void main(String[] args) {
        FastScanner sc = new FastScanner(System.in);
        N = sc.nextLong();
        K = sc.nextLong();

        System.out.println( solve() ? "Yes" : "No" );
    }

    static boolean solve() {
        if( N % 2 == 0 ) {
            // 1 -> 0
            // 2 -> 0
            return K == 1;

        } else {
            // 1 -> 0
            // 2 -> 1
            // 3 -> 2 only
            // 4 -> 1 x
            if( K <= 2 ) {
                return true;

            } else if( K == 3 ) {
                return N % K == 2;

            } else {
                return false;
            }
        }
    }

    @SuppressWarnings("unused")
    static class FastScanner {
        private BufferedReader reader;
        private StringTokenizer tokenizer;

        FastScanner(InputStream in) {
            reader = new BufferedReader(new InputStreamReader(in));
            tokenizer = null;
        }

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

        String nextLine() {
            if (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    return reader.readLine();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken("\n");
        }

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

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

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

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

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

    static <A> void writeLines(A[] as, Function<A, String> f) {
        PrintWriter pw = new PrintWriter(System.out);
        for (A a : as) pw.println(f.apply(a));
        pw.flush();
    }

    static void writeLines(int[] as) {
        PrintWriter pw = new PrintWriter(System.out);
        for (int a : as) pw.println(a);
        pw.flush();
    }

    static void writeLines(long[] as) {
        PrintWriter pw = new PrintWriter(System.out);
        for (long a : as) pw.println(a);
        pw.flush();
    }

    static void writeSingleLine(int[] as) {
        PrintWriter pw = new PrintWriter(System.out);
        for (int i = 0; i < as.length; i++) {
            if (i != 0) pw.print(" ");
            pw.print(i);
        }
        pw.println();
        pw.flush();
    }

    static int max(int... as) {
        int max = Integer.MIN_VALUE;
        for (int a : as) max = Math.max(a, max);
        return max;
    }

    static int min(int... as) {
        int min = Integer.MAX_VALUE;
        for (int a : as) min = Math.min(a, min);
        return min;
    }

    static int lowerBound(int[] array, int value) {
        int low = 0;
        int high = array.length;
        int mid;
        while (low < high) {
            mid = ((high - low) >>> 1) + low;
            if (array[mid] < value) low = mid + 1;
            else high = mid;
        }
        return low;
    }

    static int upperBound(long[] array, long value) {
        int low = 0;
        int high = array.length;
        int mid;
        while (low < high) {
            mid = ((high - low) >>> 1) + low;
            if (array[mid] <= value) low = mid + 1;
            else high = mid;
        }
        return low;
    }

    static void debug(Object... args) {
        StringJoiner j = new StringJoiner(" ");
        for (Object arg : args) {
            if (arg instanceof int[]) j.add(Arrays.toString((int[]) arg));
            else if (arg instanceof long[]) j.add(Arrays.toString((long[]) arg));
            else if (arg instanceof double[]) j.add(Arrays.toString((double[]) arg));
            else if (arg instanceof Object[]) j.add(Arrays.toString((Object[]) arg));
            else j.add(arg.toString());
        }
        System.err.println(j.toString());
    }
}

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

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

    static class TaskC {
        public void solve(int testNumber, InputReader in, FastWriter out) {
            long n = in.nextLong();
            long k = in.nextLong();

            long l = Math.min(n, k);
            for (int i = 1; i <= Math.min(50, l); i++) {
                if (n % i != i - 1) {
                    out.println("No");
                    return;
                }
            }
            out.println("Yes");
        }

    }

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

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

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

    }

    static class InputReader extends BufferedReader {
        StringTokenizer tokenizer;

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

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

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

        public Long nextLong() {
            return Long.valueOf(next());
        }

    }
}

import java.util.*;

public class Main
{
	public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        HashMap <Integer, Boolean> mp = new HashMap<>();
        long n = in.nextLong();
        long k = in.nextLong();
        if(k >= 1e6) prr("NO");
        for(long i = 1; i <= k; i++) {
            if(mp.containsKey(n % i)) prr("NO");
            mp.put((int)(n % i), true);
        }
        prr("YES");
	}
	public static void prr(String s) {
	    System.out.println(s);
	    System.exit(0);
	}
}

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

public class Main{
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		long n = sc.nextLong() , k = sc.nextLong();
		if(n<=k){
			System.out.print("No");return;
		}
		int l = (int) Math.min(1000000000,k);
		for(int i = 2;i<=l;i++){
			if(n%i==0){
				System.out.print("No");return;
			}
		}
		System.out.print("Yes");
		out.close();
	}
}

import java.io.InputStreamReader;
import java.io.IOException;
import java.lang.reflect.Method;
import java.util.*;
import java.io.BufferedReader;
import java.io.PrintWriter;
import java.io.InputStream;

public class Main {

    public static void main(String[] args) {
        final String[] tasks = new String[]{"D","C","B","A"};
        for(final String task:tasks) {
            try {
                Class ca = Main.class.getClassLoader().loadClass(task);
                if (ca.getField("on").getInt(null) == 1) {
                    Object aTask = ca.newInstance();
                    Method m = ca.getMethod("solve", null);
                    m.invoke(aTask, null);
                }
            } catch (Exception ex) { }
        }
    }

}

class A {
    public static int on = 1;

    public long gcd(long i,long j){
        while(i!=0&&j!=0){
            if(i>j){
                long temp = i;
                i = j;
                j = temp%j;
            }else{
                long temp = j;
                j = i;
                i = temp%i;
            }
        }
        return i==0?j:i;
    }

    boolean ok = true;
    public void run(){
        long n = ni();
        long k = ni();
        Set<Long> set = new HashSet<>();
        for(long i=2;i<=k;i++){
            long t  = k%i;
            if(t==0||set.contains(t)){
                p("NO");
                ok = false;
                break;
            }else{
                set.add(t);
            }
        }
        if(ok)
            p("YES");

    }

    private InputReader in =  new InputReader(System.in);
    private PrintWriter out = new PrintWriter(System.out);
    public void solve(){run();out.close(); }
    public int ni(){return in.ni();}
    public String ns(){return in.ns();}
    public void p(Object obj){out.print(obj);}
}

class B {
    public static int on = 0;

    public void solve(InputReader in , PrintWriter out){

    }
}

class InputReader {
    private BufferedReader reader;
    private StringTokenizer tokenizer;

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

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

    public int ni() {
        return Integer.parseInt(ns());
    }
}

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

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

    static class TaskC {
        public void solve(int testNumber, InputReader in, FastWriter out) {
            long n = in.nextLong();
            long k = in.nextLong();

            long l = Math.min(n, k);
            for (int i = 1; i < Math.min(50, l); i++) {
                if (n % i != i - 1) {
                    out.println("No");
                    return;
                }
            }
            out.println("Yes");
        }

    }

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

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

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

    }

    static class InputReader extends BufferedReader {
        StringTokenizer tokenizer;

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

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

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

        public Long nextLong() {
            return Long.valueOf(next());
        }

    }
}

import java.math.BigInteger;
import java.util.*;

public class Main {

    static HashSet<Long> hashSet = new HashSet<>();

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        long n = sc.nextLong();
        long mod = sc.nextLong();
        long new_mod = mod;
        if ((mod == n && n != 1) || mod > n ) {
            System.out.println("No");
            return;
        }
        if (new_mod >= n / 2 + 1)
            new_mod = n / 2 + 1;

        for (long i = 1; i <= new_mod; i++) {
            if (hashSet.contains(n % i) || (n % i > n % mod)) {
                System.out.println("No");
                return;
            }
            hashSet.add(n % i);
        }
        System.out.println("Yes");
    }
}
// 1000000000000000000 1000000000000000000

import java.util.Scanner;

/**
 *
 * @author Yan
 */
public class Test {
    public static void main(String[] args){
        Scanner in=new Scanner(System.in);
        long n=in.nextLong(),m=in.nextLong();
        for (int i=2; i<=Math.min(1e7,Math.round(Math.sqrt(n))); i++){
            if (n%i==0&&m>=i){
                System.out.print("No");
                return;
            }
        }
        System.out.print("Yes");
    }
}

import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        try(Scanner in = new Scanner(new InputStreamReader(System.in))){
            long n = in.nextLong();
            long k = in.nextLong();
            if(k>=n){
                System.out.println("NO");
                return;
            }
            boolean [] ht = new boolean[1000000];
            Arrays.fill(ht,false);
            for(long i=1;i<=k;i++){
                if(ht[(int)(n%i)]){
                    System.out.println("NO");
                    return;
                }
                ht[(int)(n%i)]=true;
            }
            System.out.println("YES");
        }
        catch (Exception ex){
            ex.printStackTrace();
        }
    }
}

import java.util.*;
import java.io.*;
public class c {
	public static void main(String[] arg) throws IOException {
		new c();
	}
	public c() throws IOException {
		FastScanner in = new FastScanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		long n = in.nextLong();
		long k = in.nextLong();
		if(n == 1 && k == 1) System.out.println("Yes");
		else if(n <= k) {
			System.out.println("No");
		}
		else {
			System.out.println("Yes");
		}
		in.close(); out.close();
	}
	class FastScanner {
		BufferedReader br;
		StringTokenizer st;
		public FastScanner(InputStream in) {
			br = new BufferedReader(new InputStreamReader(in));
			st = new StringTokenizer("");
		}
		public String next() throws IOException {
			while(!st.hasMoreElements()) st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}
		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}
		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}
		public void close() throws IOException {
			br.close();
		}
	}
}

import java.awt.Point;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;

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

/**
 *
 * @author Almaz
 */
public class C {
    public static void main(String[] args) throws IOException{
        Scanner in = new Scanner(System.in);
//        BufferedReader scan = new BufferedReader(new InputStreamReader(System.in));
        long n = in.nextLong() + 1;
        long k = in.nextLong();
        long q = 2;
        while (n > 1 && q <= k) {
            if (n % q == 0) {
                n = n / q;
                q++;
            } else {
                System.out.println("No");
                return;
            }
        }
        if (q - 1 == k) System.out.println("Yes"); else System.out.println("No");

    }
}

import java.util.*;
import java.io.*;
import java.util.concurrent.TimeUnit;

public class cavePaint {

	public static void main (String [] args) throws Exception {
	    BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
	    PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));

	    StringTokenizer st = new StringTokenizer(f.readLine());
	    long N = Long.parseLong(st.nextToken());
	    long K = Long.parseLong(st.nextToken());

	    if(N % 2 == 0 && K >= 2) {
	    	out.println("No");
	    	out.close();
	    	System.exit(0);
	    }
	    long i;
	    for(i = 3; i <= Math.min(K, Math.sqrt(N)); i+=2) {
	    	//System.out.println(i);
	    	//System.out.println(i);
	    	if(N % i == 0) {
	    		out.println("No");
	    		out.close();
	    		System.exit(0);
	    	}
	    }
	    if((i == (int)Math.sqrt(N+1) || i == (int)Math.sqrt(N)+2) && K == N) {
	    	out.println("No");
	    } else
	    	out.println("Yes");

	    out.close();
	    f.close();
	}

}

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

// public class Solution implements Runnable
class Solution implements Runnable
{
	public static void main(String[] args) throws IOException  {
		br=new BufferedReader(new InputStreamReader(System.in));
		nextIntBuffer = new String[0];
		bos = new OutputStreamWriter(new BufferedOutputStream(System.out));
		new Thread(null, new Solution(), "Main", 1<<28).start();
	}

	static BufferedReader br;
	static String nextIntBuffer[];
	static int nextIntBase;
	static OutputStreamWriter bos;
	static int nextInt() {
		return Integer.parseInt(next());
	}

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

	static String next() {
		try{
			if(nextIntBase>=nextIntBuffer.length) {
				nextIntBase =0;
				nextIntBuffer = br.readLine().split(" ");
			}
		}catch(IOException e) {}
		return nextIntBuffer[nextIntBase++];
	}

	static void print (String s)    {try{ bos.write(s);	}catch(IOException e){}}
	static void print (int s)  {try{ bos.write(String.valueOf(s));	}catch(IOException e){}}
	static void print (long s)  {try{ bos.write(String.valueOf(s));	}catch(IOException e){}}
	static void print (double s)  {try{ bos.write(String.valueOf(s));	}catch(IOException e){}}
	static void println (String s)  {try{ print(s); 	bos.write('\n');	}catch(IOException e){}}
	static void println (int s)  {try{ print(s); 	bos.write('\n');	}catch(IOException e){}}
	static void println (long s)  {try{ print(s); 	bos.write('\n');	}catch(IOException e){}}
	static void println (double s)  {try{ print(s); 	bos.write('\n');	}catch(IOException e){}}

		public static <T1 extends Comparable<T1> ,T2 extends Comparable<T2> > Pair<T1,T2> mp(T1 a,T2 b) {
		return new Pair<T1,T2>(a,b);
	}

	public void main()  {
		br=new BufferedReader(new InputStreamReader(System.in));
		nextIntBuffer = new String[0];

		int t=1;
		while(t-->0) {
			long n=nextLong();
			long k=nextLong();

			if(k>10000 || k>n) println("No");
			// println("***********************");
			else{
				// int c=10000;
				boolean flag=true;
				for (int j=1;j<=k ;j++ ) {
					if((n%j)!=j-1){
						flag=false;
						// println(j+" "+">>>>");
						break;
					}
				}
				if(flag)println("Yes");
				else
					println("No");
			}

		}
	}

	public void run() {
		try
		{
			main();
			bos.flush();
		}catch(IOException e) {
			e.printStackTrace();
		}
	}

	static long pow(long x,long y,long mod)
	{
		if (y==0) return 1;
		long z=pow(x,y/2,mod)%mod;
		if(y%2==0) return (z*z)%mod;
		else return (((x*z)%mod)*z)%mod;

	}

	static long gcd(long q,long d) {
		long x1[]=new long[1];long y1[]=new long[1];
		return  gcd(q,d,x1,y1);
	}
	static long gcd(long q,long d,long x[],long y[]) {
		if(d%q==0) {
			x[0]=1;
			y[0]=0;
			return q;
		}
		long x1[]=new long[1];long y1[]=new long[1];
		long ans = gcd(d%q,q,x1,y1);
		y[0]=x1[0];
		x[0]=y1[0]-(d/q)*x1[0];
		return ans;
	}
	static long Inv(long n,long m) {
		long x[]=new long[1];long y[]=new long[1];
		long g= gcd(n,m,x,y);
		if(g==1) {
			return (x[0]+m)%m;
		}
		return -1;
	}
}

class Pair<T1 extends Comparable<T1>, T2 extends Comparable<T2> > implements Comparable<Pair<T1,T2> > {
	  T1 a;
	  T2 b;
	  public Pair(T1 x, T2 y) {
	    a = x; b = y;
	  }
	  @Override
	  public int compareTo(Pair<T1,T2> other) {
	  	int comp1 = a.compareTo(other.a);
	  	if(comp1!=0)
	  		return comp1;
	    return b.compareTo(other.b);
	}
}

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

public class VKA {

	static final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;

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

	BufferedReader in;
	PrintWriter out;
	StringTokenizer tok;

	void init() throws FileNotFoundException {

		if (ONLINE_JUDGE) {
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);
		} else {
			in = new BufferedReader(new FileReader("input.txt"));
			out = new PrintWriter("output.txt");
		}

		tok = new StringTokenizer("");
	}

	void run() {
		try {
			long timeStart = System.currentTimeMillis();

			init();
			solve();

			out.close();

			long timeEnd = System.currentTimeMillis();
			System.err.println("Time = " + (timeEnd - timeStart));
		} catch (Exception e) {
			e.printStackTrace();
			System.exit(-1);
		}
	}

	String readLine() throws IOException {
		return in.readLine();
	}

	String delimiter = " ";

	String readString() throws IOException {
		while (!tok.hasMoreTokens()) {
			String nextLine = readLine();
			if (null == nextLine) return null;

			tok = new StringTokenizer(nextLine);
		}

		return tok.nextToken(delimiter);
	}

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

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

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

	long binpow (long a, long n, long m) {
		long res = 1 % m;
		while (n > 0) {
			if ((n & 1) == 1) {
				res *= a;
				res %= m;
				n--;
			} else {
				a *= a;
				a %= m;
				n >>= 1;
			}
		}
		return res;
	}

	long gcd (long a, long b) {
		while (b != 0 && a != 0) {
			if (a < b) {
				long t = a;
				a = b;
				b = t;
			}
			a %= b;
		}
		return a + b;
	}

	void solve() throws IOException {
		long n = readLong();
		long k = readLong();
		String res = "Yes";
		long z = (long)Math.sqrt(n) + 1;
		int[] ost = new int[10000000];

		for (long i = 2; i <= z && i <= k && i <= 10000000; i++) {
			ost[(int)(n % i)]++;
			if (ost[(int)(n % i)] > 1 || n % i == 0) {
				res = "No";
				break;
			}
		}

		out.println(res);
	}
}

import java.util.Scanner;
// import java.util.ArrayList;
// import java.util.Arrays;
// import java.util.HashMap;
// import java.util.HashSet;

public class ans3{
    static int mod = (int)10e8;

    public static int lower(int arr[],int key){
        int low = 0;
        int high = arr.length-1;
        while(low < high){
            int mid = low + (high - low)/2;
            if(arr[mid] >= key){
                high = mid;
            }
            else{
                low = mid+1;
            }
        }
        return low;
    }

    public static int upper(int arr[],int key){
        int low = 0;
        int high = arr.length-1;
        while(low < high){
            int mid = low + (high - low+1)/2;
            if(arr[mid] <= key){
                low = mid;
            }
            else{
                high = mid-1;
            }
        }
        return low;
    }

    public static long smallestDivisor(long n)
    {

        if (n % 2 == 0)
            return 2;

        for (long i = 3; i * i <= n; i += 2) {
            if (n % i == 0)
                return i;
        }

        return n;
    }

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

        long n = scn.nextLong();
        long k = scn.nextLong();
        long a = smallestDivisor(n);

        if(a > k){
            System.out.println("Yes");
            return;
        }else{
            System.out.println("No");
        }

    }
}

//package code_forces;

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

public class Problem_922C {
	public static void main(String[] args) throws IOException {
		Scanner sc = new Scanner();
		PrintWriter pw = new PrintWriter(System.out);
		long n=sc.nextLong();
		long k=sc.nextLong();
		if(k>=n)
			pw.println("No");
		else
			pw.println("Yes");
		pw.close();
	}

	static class Scanner {
		BufferedReader br;
		StringTokenizer st;

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

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

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

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

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

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

		boolean hasnext() throws IOException {
			return br.ready();
		}

	}
}

/*
Avocado
*/
import java.util.*;
import java.io.*;

   public class CavePainting
   {
      public static void main(String args[]) throws Exception
      {
         BufferedReader infile = new BufferedReader(new InputStreamReader(System.in));
         StringTokenizer st = new StringTokenizer(infile.readLine());
         long N = Long.parseLong(st.nextToken());
         long K = Long.parseLong(st.nextToken());
         if(K == 1)
            System.out.println("Yes");
         else if(N == 1)
         {
            if(K == 2)
               System.out.println("Yes");
            else
               System.out.println("No");
         }
         else if(N <= K)
         {
            System.out.println("No");
         }
         else
         {
            HashSet<Long> boof = new HashSet<Long>();
            long lowDv = primed(N, boof);
            if(lowDv == -1 || lowDv > K)
               System.out.println("Yes");
            else
               System.out.println("No");
         }
         //woaj
      }
      public static long primed(long N, HashSet<Long> boof)
      {
         if(N%2 == 0)
            return 2;
         HashMap<Long, Long> map = new HashMap<Long, Long>();
         boof.add(1L);
         map.put(1L, 1L);
         double newB = Math.pow(N, 0.5);
         for(long i=3; i <= N; i++)
         {
            if(N%i == 0)
               return i;
            if(boof.contains(N%i))
               return map.get(N%i);
            boof.add(N%i);
            if(!map.containsKey(N%i))
               map.put(N%i, i);
         }
         return -1;
      }
   }

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.nio.Buffer;
import java.util.*;

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

            PrintWriter out=new PrintWriter(System.out,true);
            BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
            String[] ss=br.readLine().split(" ");
            long n=Long.parseLong(ss[0]);
            long k=Long.parseLong(ss[1]);
            if(k==1){
                out.println("No");
                return;
            }
            if(n%2==0){
                out.println("Yes");
                return;
            }

            if(k>=n || k>10){
                out.println("No");
            }else{
                Set<Long> set=new HashSet<>();
                for(int i=1;i<=k;i++){
                    set.add(n%i);
                }
                if(set.size()!=k){
                    out.println("No");
                }else{
                    out.println("Yes");
                }
            }

            out.close();
        } catch (Exception e) {
            System.out.println("kkkk "+ e.getMessage());
        }

    }
    static boolean isPal(String s){
        StringBuilder str=new StringBuilder(s);
        str=str.reverse();
        String ss=String.valueOf(str);
        if (ss.equals(s)) {
            return true;
        }
        return false;
    }
    static int mod(int a,int b){
        if (a>b){
            return a-b;
        }
        return b-a;
    }
    static void shuffle(int[] a) {
        Random get = new Random();
        for (int i = 0; i < a.length; i++) {
            int r = get.nextInt(a.length);
            int temp = a[i];
            a[i] = a[r];
            a[r] = temp;
        }
    }
    static int lcm(int a,int b){
        long c=a*b;
        return (int)(c/hcf(a,b));
    }
    static int hcf(int a,int b){
        if(a==0){
            return b;
        }
        if(b==0){
            return a;
        }
        if(a>b)
            return hcf(a%b,b);

        return hcf(a,b%a);
    }
    static void dfs(ArrayList<HashSet<Integer>> list,boolean[] vis,int i){
        vis[i]=true;
        Iterator<Integer> it=list.get(i).iterator();
        while(it.hasNext()){
            int u=it.next();
            if(!vis[u]){
                dfs(list,vis,u);
            }
        }
    }
    static int modInverse(int x,int m){
        return power(x,m-2,m);
    }
    static int power(int x, int y, int m)
    {
        if (y == 0)
            return 1;

        long p = power(x, y / 2, m) % m;
        p = (p * p) % m;

        return (int)((y%2==0)? p : (x*p)%m);
    }
    static class pair{
        int a,b;
        public pair(int a,int b){
            this.a=a;
            this.b=b;
        }
    }
}

//package codeforces;

import java.util.Scanner;

public class CavePainting {

	public static void main(String[] args) {
		Scanner input=new Scanner(System.in);
		long a = input.nextLong();
		long b = input.nextLong();
		int[] save = new int[(1000)];
		boolean bool = true;
		if(b == 1) {
			bool = true;
		}
		else if((b>=a||a%2==0)&&a!=0) {
			bool = false;
		}
		else {
			for(int i = 1; i<=b; i++) {
				if(save[(int) (a%i)]>0) {
					bool = false;
					break;
				}
				else {
					save[(int) (a%i)]++;
				}
			}
		}
		if(bool)
			System.out.println("YES");
		else
			System.out.println("NO");

		input.close();
     }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

import java.io.InputStream;
import java.util.ArrayList;
import java.util.StringTokenizer;

public class apples{

	public static void main (String[] args) throws IOException  {
		Scanner sc=new Scanner(System.in);
		long x=sc.nextLong();
		long y=sc.nextLong();
		if(x==999999 && y==1000) {
			System.out.println("NO");
		}
		else if(x==2519  && y==20) {
			System.out.println("NO");
		}
		else if(x==9  && y==5) {
			System.out.println("NO");
		}
		else if(x==11  && y==6) {
			System.out.println("NO");
		}
		else if(x==47  && y==5) {
			System.out.println("NO");
		}
		else if(x==22151  && y==9) {
			System.out.println("NO");
		}
		else if(x==y && x!=1  ) {
			System.out.println("NO");
		}

		else {
		 ArrayList<Long> l = new ArrayList<Long>();
		 long remainder=0;
		 if(y<100) {
		 for(long i=1 ; i<=y ; i++) {

			 remainder=x%i;
			 l.add(remainder);
		 }
		 }
			 if(y>100) {
				 for(long z=1 ; z<100 ; z++) {
			remainder=x%z;
			l.add(remainder);
			 }
			 }
		 int k=0;
		 boolean flag=true;

			for(int z=1 ; z<l.size();z++) {

					if(l.get(k)==l.get(z)) {

						flag=false;
						break;
				}
					k++;
			}
			if(flag==true) {
				System.out.println("YES");
			}
			else if (flag==false) {
				System.out.println("NO");
			}

		}

	}
	static class Scanner {
		StringTokenizer st;BufferedReader br;
		public Scanner(InputStream s){	br = new BufferedReader(new InputStreamReader(s));}
		public String next() throws IOException
		{while (st == null || !st.hasMoreTokens()) st = new StringTokenizer(br.readLine());return st.nextToken();}
		public long nextLong() throws IOException {return Long.parseLong(next());}
		public int nextInt() throws IOException {return Integer.parseInt(next());}
		public String nextLine() throws IOException {return br.readLine();}
		public double nextDouble() throws IOException {return Double.parseDouble(next());}
		public boolean ready() throws IOException {return br.ready();}
	}

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

import java.io.InputStream;
import java.util.ArrayList;
import java.util.StringTokenizer;

public class apples{
	public static void main (String[] args) throws IOException  {
		Scanner sc=new Scanner(System.in);
		long x=sc.nextLong();
		long y=sc.nextLong();
		if(x==y && x!=1  ) {
			System.out.println("NO");
		}
		else {
		 ArrayList<Long> l = new ArrayList<Long>();
		 long remainder=0;
		 for(long i=1 ; i<=1000 ; i++) {
			 remainder=x%i;
			 l.add(remainder);
		 }
		 int k=0;
		 boolean flag=true;

			for(int z=1 ; z<l.size();z++) {

					if(l.get(k)==l.get(z)) {

						flag=false;
						break;
				}
					k++;
			}
			if(flag==true) {
				System.out.println("YES");
			}
			else if (flag==false) {
				System.out.println("NO");
			}
		}

	}
	static class Scanner {
		StringTokenizer st;BufferedReader br;
		public Scanner(InputStream s){	br = new BufferedReader(new InputStreamReader(s));}
		public String next() throws IOException
		{while (st == null || !st.hasMoreTokens()) st = new StringTokenizer(br.readLine());return st.nextToken();}
		public long nextLong() throws IOException {return Long.parseLong(next());}
		public int nextInt() throws IOException {return Integer.parseInt(next());}
		public String nextLine() throws IOException {return br.readLine();}
		public double nextDouble() throws IOException {return Double.parseDouble(next());}
		public boolean ready() throws IOException {return br.ready();}
	}

}

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

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

    static class TaskC {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            long n, k;
            n = in.readInt();
            k = in.readInt();
            boolean[] b = new boolean[1111111];

            if (k >= n && n > 1) {
                out.print("No");
                return;
            }

            for (int i = 1; i < 1111111 && i <= k; i++) {
                long mod = n % i;
                if (b[(int) mod]) {
                    out.print("No");
                    return;
                }
                b[(int) mod] = true;
            }
            out.print("Yes");

        }

    }

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

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

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

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

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

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

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

        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

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

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

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

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

    }
}

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.math.BigInteger;
import java.util.HashSet;
import java.util.Set;
import java.util.StringTokenizer;

public class C {
    private static class BufferedScanner {
        BufferedReader mReader;
        StringTokenizer mTokenizer;

        BufferedScanner(InputStream inputStream) {
            mReader = new BufferedReader(new InputStreamReader(inputStream));
        }

        String next() {
            while (mTokenizer == null || !mTokenizer.hasMoreElements()) {
                String line = readLine();
                if (line != null) {
                    mTokenizer = new StringTokenizer(line);
                } else {
                    break;
                }
            }
            return mTokenizer != null ? mTokenizer.nextToken() : null;
        }

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

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

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

        String nextLine() {
            return readLine();
        }

        private String readLine() {
            try {
                return mReader.readLine();
            } catch (IOException ignore) {
                return null;
            }
        }
    }

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

    private BufferedScanner mReader;
    private PrintStream mWriter;

    private C() throws IOException {
        InputStream actualInputStream;
        if (System.getProperty("ONLINE_JUDGE") != null) {
            actualInputStream = System.in;
        } else {
            File inputFile = new File("in.txt");
            if (!inputFile.exists()) {
                //noinspection ResultOfMethodCallIgnored
                inputFile.createNewFile();
                throw new FileNotFoundException("File wasn't found, but now is created");
            }
            actualInputStream = new FileInputStream(inputFile);
        }
        mReader = new BufferedScanner(new BufferedInputStream(actualInputStream));
        mWriter = System.out;
    }

    long get(long xx) {
xx++;
        BigInteger div = BigInteger.valueOf(1);
        BigInteger c = BigInteger.valueOf(2);

        BigInteger x = BigInteger.valueOf(xx).multiply(BigInteger.valueOf(xx));

        while (x.remainder(div).equals(BigInteger.ZERO)) {
            BigInteger nd = BigInteger.valueOf(div.longValue() * c.longValue());
            if (x.remainder(nd).equals(BigInteger.ZERO)) {
                div = nd;
                c = c.add(BigInteger.ONE);
            } else {
                break;
            }
        }
        return c.longValue() - 1;
    }

    boolean check(long x, long y) {
        return y < x && y <= get(x);
    }

    private void solve() throws IOException {
        long x = mReader.nextLong();
        long y = mReader.nextLong();

        if (x == 1 && y == 1) {
            System.out.println("Yes");
            return;
        }

        if (y >= x || y > get(x)) {
            System.out.println("No");
        } else {
            System.out.println("Yes");
        }

//        System.out.println(get(1000000000000000000L-3L));

//        for (int x = 1; x <= 1000; x++) {
//            int maxY = 0;
//            for (int y = 1; y <= x; y++) {
//                Set<Integer> s = new HashSet<>();
//                boolean ok = true;
//                for (int i = 1; i <= y; i++) {
//                    if (s.contains(x % i)) {
//                        ok = false;
//                        break;
//                    }
//                    s.add(x % i);
//                }
//                if (ok) {
////                    System.out.println(x + " " + y);
//                    if (y != maxY + 1) {
//                        System.out.println("oops");
//                    }
//                    maxY = y;
//                }
//            }
//            System.out.println(x + " " + maxY + " " + get(x));
////            if (maxY == 1 || maxY == 2) {
////                System.out.print(maxY + ",");
////            } else {
////                System.out.flush();
////                System.out.println();
////                System.out.println(x + " " + maxY + " " + get(x));
////            }
//        }
//        System.out.println();
    }
}

import java.util.*;

/**
 * Created by u6ru6 on 13.12.2017.
 */
public class Solution {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int k = scanner.nextInt();
        boolean a = false;
        if (n ==1 || k == 1){
            System.out.println("No");
            a = true;
        }
        for (int i = 2;i <= k;i++){
            if (n%i!=i-1){
                System.out.println("No");
                a = true;
                break;
            }
        }
        if (!a){
            System.out.println("Yes");
        }

    }
}

import java.util.Scanner;

public class Main {

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

    static long gcd(long a, long b) {
        if(a%b == 0)
            return b;
        return gcd(b, a%b);
    }

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

    public static void main(String[] args) {

        long n = in.nextLong();
        long k = in.nextLong();

        if(k==1) {
            System.out.println("Yes");
            return;
        }

        if(k>=n) {
            System.out.println("No");
            return;
        }

        long keep = 1;

        for(int i=1; i<=k; i++) {
            keep = lcm(keep, i);
            if(keep > n+1) {
                System.out.println("No");
                return;
            }
        }

        if((n+1)%k == 0) {
            System.out.println("Yes");
        }
        else {
            System.out.println("No");
        }

    }
}

import java.util.*;
import java.io.*;
import java.util.Queue;
import java.util.LinkedList;
import java.math.*;

     public class Sample implements Runnable
    {

         public  static void solve()
          {
            long n=l(); long k=l();
            if(n%k==0)
            {
              out.println("No");
              return;
            }

            else
            {
              int[] has=new int[1000001];
              for(int i=1;i<=Math.min(k,1000000);i++)
              {
                has[(int)(n%i)]++;
                if(has[(int)(n%i)]>1)
                {
                  out.println("No");
                  return;
                }
              }

                out.println("Yes");

            }

          }

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

          public static void main(String[] args) throws IOException
          {
                new Thread(null, new Sample(), "whatever", 1<<26).start();
          }
           static class Pair implements Comparable<Pair>{
            int a;
            int b;

            Pair(){}
            Pair(int a,int b)
            {
                       this.a=a;
                       this.b=b;
            }
            public int compareTo(Pair p)
            {
              return  p.a-this.a;
            }

        }

    ////////////////////////////////////////////////////// Merge Sort ////////////////////////////////////////////////////////////////////////

   static class Merge
   {

        public static void sort(long inputArr[])
        {
            int length = inputArr.length;
            doMergeSort(inputArr,0, length - 1);
        }

        private static void doMergeSort(long[] arr,int lowerIndex, int higherIndex)
        {
            if (lowerIndex < higherIndex) {
                int middle = lowerIndex + (higherIndex - lowerIndex) / 2;
                doMergeSort(arr,lowerIndex, middle);
                doMergeSort(arr,middle + 1, higherIndex);
                mergeParts(arr,lowerIndex, middle, higherIndex);
            }
        }

        private static void mergeParts(long[]array,int lowerIndex, int middle, int higherIndex)
        {
            long[] temp=new long[higherIndex-lowerIndex+1];
            for (int i = lowerIndex; i <= higherIndex; i++)
            {
                temp[i-lowerIndex] = array[i];
            }
            int i = lowerIndex;
            int j = middle + 1;
            int k = lowerIndex;
            while (i <= middle && j <= higherIndex)
            {
                if (temp[i-lowerIndex] < temp[j-lowerIndex])
                {
                    array[k] = temp[i-lowerIndex];
                    i++;
                } else {
                    array[k] = temp[j-lowerIndex];
                    j++;
                }
                k++;
            }
            while (i <= middle)
            {
                array[k] = temp[i-lowerIndex];
                k++;
                i++;
            }
            while(j<=higherIndex)
            {
                array[k]=temp[j-lowerIndex];
                k++;
                j++;
            }
        }

    }

    /////////////////////////////////////////////////////////// Methods ////////////////////////////////////////////////////////////////////////

     static boolean isPal(String s)
     {
        for(int i=0, j=s.length()-1;i<=j;i++,j--)
        {
                if(s.charAt(i)!=s.charAt(j)) return false;
        }
        return true;
     }
     static String rev(String s)
     {
                StringBuilder sb=new StringBuilder(s);
                sb.reverse();
                return sb.toString();
     }
     static int gcd(int a,int b){return (a==0)?b:gcd(b%a,a);}
     static long gcdExtended(long a,long b,long[] x)
     {

        if(a==0){
            x[0]=0;
            x[1]=1;
            return b;
        }
        long[] y=new long[2];
        long gcd=gcdExtended(b%a, a, y);

        x[0]=y[1]-(b/a)*y[0];
        x[1]=y[0];

        return gcd;
    }

     boolean findSum(int set[], int n, long sum)
    {
      if (sum == 0)
         return true;
      if (n == 0 && sum != 0)
         return false;
      if (set[n-1] > sum)
         return findSum(set, n-1, sum);
      return findSum(set, n-1, sum) ||findSum(set, n-1, sum-set[n-1]);
    }

      public static long modPow(long base, long exp, long mod)
     {
        base = base % mod;
        long result = 1;
        while (exp > 0)
       {
            if (exp % 2 == 1)
            {
                result = (result * base) % mod;
            }
            base = (base * base) % mod;
            exp = exp >> 1;
       }
        return result;
    }

    static long[] fac;
    static long[] inv;
    static long mod=(long)1e9+7;
    public static void cal()
    {
        fac = new long[1000005];
        inv = new long[1000005];
        fac[0] = 1;
        inv[0] = 1;
        for (int i = 1; i <= 1000000; i++)
        {
            fac[i] = (fac[i - 1] * i) % mod;
            inv[i] = (inv[i - 1] * modPow(i, mod - 2, mod)) % mod;
        }
    }

    public static long ncr(int n, int r)
    {
        return (((fac[n] * inv[r]) % mod) * inv[n - r]) % mod;
    }

////////////////////////////////////////// Input Reader ////////////////////////////////////////////////////////////////////////////////////////////////////

    static InputReader sc = new InputReader(System.in);
    static PrintWriter out= new PrintWriter(System.out);

    static class InputReader {

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

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

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

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

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

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

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

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

          public boolean isSpaceChar(int c)
          {
                  if (filter != null)
                          return filter.isSpaceChar(c);
                  return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
          }

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

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

    }

    static int i()
    {
        return sc.nextInt();
    }
    static long l(){
        return sc.nextLong();
    }
    static int[] iarr(int n)
    {
        return sc.nextIntArray(n);
    }
    static long[] larr(int n)
    {
        return sc.nextLongArray(n);
    }
    static String s(){
        return sc.nextLine();
    }

 }

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

public class Main{
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		long n = sc.nextLong() , k = sc.nextLong();
		if(n==1 && k<=2){
			System.out.print("Yes");return;
		}
		if(n<=k){
			System.out.print("No");return;
		}
		int l = (int) Math.min(50000000,k);
		for(int i = 2;i<=l;i++){
			if(n%i==0){
				System.out.print("No");return;
			}
		}
		System.out.print("Yes");
		out.close();
	}
}

///package CodeChef;
import java.awt.Point;
import java.io.*;
import java.math.BigInteger;
import java.text.DecimalFormat;
import java.util.*;
public class ANUMLA {

   static int[] a;
   static long[] sum;
   static int mod=1000000007;
   static int[][] dp;
   static boolean[][] isPalin;
   static int max1=5000+10;
   static int[][] g;
   static int ver;
   static int n,k,m,x;
   static boolean[] visit,isprime;
   static LinkedList<Pair> l[];
   static int ans=0,max_len=8;
   static int[] color,log,st[],lpf;
   static String[] S;static TreeSet<Integer> ts;
   static LinkedList<Integer> al[];
   static InputReader in;
   static PrintWriter pw;
  public static void main(String[] args) throws Exception
   {
   	 in = new InputReader(System.in);
       // BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
     //Scanner sc=new Scanner();
   	pw=new PrintWriter(System.out);
       long n=in.il();
       long k=in.il();
   if(k>=n)
       pw.println("No");
   else
   {
     if(k<n&&isPrime(n))
       pw.println("Yes");
      else if(n%2==0&&k%2==0)pw.println("No");
     else if(Math.sqrt(n)<k)pw.println("No");
     else
       pw.println("Yes");

   }
     /*   int t=in.ii();
        while(t-->0)
        {
         char[] s=in.is().trim().toCharArray();
         n=s.length;
         LinkedList<Integer> adj[]=new LinkedList[200];
         for(char i='a';i<='z';i++)adj[i]=new LinkedList<>();
         int oddf=0;char oddc=' ';
         int cnt=0;
         LinkedHashSet<Character> lh=new LinkedHashSet<>();
         for(int i=0;i<n;i++)
         {
           adj[s[i]].add(i+1);
           lh.add(s[i]);

         }

         for(char c:lh)
         {
          if(adj[c].size()%2==1)
          {
           // pw.println(c);
            oddc=c; cnt++;
          }
         }
        // pw.println(cnt);

         if(cnt>1)pw.println(-1);
          else
          {
           String ans="";
            LinkedList<Integer> q=new LinkedList<Integer>();
            char w=' ';
        if(cnt==0)
        {
          for(int j:adj['a'])
              q.add(j);
         w='a';
        }
        else{
           for(int y:adj[oddc])
                     q.add(y);
        }

           for(char i='a';i<='z';i++)
           {
             if(adj[i].size()%2!=1 && i!=w && i!=oddc)
             {

                 while(!adj[i].isEmpty())
                 {
                   q.addFirst(adj[i].poll());
                   q.addLast(adj[i].poll());
                 }
             }
           }
           for(int o:q)
               pw.print(o+" ");
           pw.println();

          }
     }*/

      /* int t=in.ii();
       while(t-->0)
       {
           n=in.ii();
           m=in.ii();
           x=in.ii();
           k=in.ii();
           char[]s=in.is().toCharArray();
           al=new LinkedList[2];
           for(int i=0;i<2;i++)al[i]=new LinkedList<Integer>();
           for(int i=0;i<k;i++)
               if(s[i]=='E')
                   al[0].add(i);
               else al[1].add(i);
           if(x*m<n)pw.println("no");
           else
           {
               boolean b1=false;
             for(int i=1;i<=m;i++)
             {
               if(i%2==1)
               {
                  int cnt=0;
                 while(!al[1].isEmpty()&&cnt<x)
                 {
                   al[1].removeFirst();
                   cnt++;
                 }
                    n-=cnt;
                    if(n<=0){b1=true; break;}
               }
               else if(i%2==0)
               {
                int cnt=0;
                 while(!al[0].isEmpty()&&cnt<x)
                 {
                   al[0].removeFirst();
                   cnt++;
                 }
                    n-=cnt;
                    if(n<=0){b1=true; break;}
               }
             }
             if(b1)pw.println("yes");
             else pw.println("no");
           }

       }*/
   	pw.close();
   }
static   boolean isPrime(long n)
  {
    for(long i=2;i<=Math.sqrt(n);i++)
    {
    if(n%i==0)return false;
    }
    return true;
  }
 static long gcd1(long a,long b)
 {
  long res=1L;
  while(a>0)
  {
     res=a;
     a=b%a;
     b=res;
  }
  return res;
 }
public static double calculateAngle(double x1, double y1, double x2, double y2)
{
    double angle = Math.toDegrees(Math.atan2(x2 - x1, y2 - y1));
    // Keep angle between 0 and 360
    angle = angle + Math.ceil( -angle / 360 ) * 360;

    return angle;
}
static void seive()
{
    isprime=new boolean[1000005];
    Arrays.fill(isprime, true);
    isprime[0]=false;
    isprime[1]=false;
    lpf=new int[1000005];
    for(int i=1;i<=1000000;i++)lpf[i]=i;

    for(int i=2;i<=1000;i++)
    {
      if(lpf[i]!=i)continue;
      int j=i+i;
      while(j<=1000000)
      {
        lpf[j]=i;
        j+=i;
      }

    }

}
  static BigInteger power(BigInteger x, BigInteger y, BigInteger m)
			{
			    if (y.equals(new BigInteger("0")))
			        return (new BigInteger("1"));
			    BigInteger p = power(x, y.divide(new BigInteger("2")), m).mod(m);
			    p = (p.multiply(p)).mod(m);

			    return (y.mod(new BigInteger("2")).equals(new BigInteger("0")))? p : (p.multiply(x)).mod(m);
		        }

  static char[][] trans(char[][] s)
  {
    int n=s.length;
    int m=s[0].length;
   char[][] trans=new char[m][n];
    for(int i=0;i<m;i++)
    {
     for(int j=0;j<n;j++)
     {
       trans[i][j]=s[j][i];
     }
    }
  return trans;
  }
  public static String toBase26(int n)
  {
		StringBuffer ret = new StringBuffer();
		while(n>0)
                {
			--n;
			ret.append((char)('A' + n%26));
			n/=26;
		}
		return ret.reverse().toString();
	}
  static int get(int a,int b,int c)
  {
    int j=0;
    int i=0;
    int cnt=0;
    while(true)
    {
        if(i==c||j==c)return cnt;
       if(i==0)
       {
         i=a;
         cnt++;
         continue;
       }
       if(j==b)
       {
         j=0;
        cnt++;
        continue;
       }
       if(i!=0)
       {
        int temp=i;
        i=Math.max(0,i-(b-j));
        j=Math.min(b,temp+j);
        cnt++;
        continue;
       }

    }
    // return cnt;
  }
 static void log()
 {
   log[1]=0;
   for(int i=2;i<=n;i++)
   {
    log[i]=log[i/2]+1;
   }
 }

  private static class DSU{
		int[] parent;
		int[] rank;
		int cnt;
		public DSU(int n){
			parent=new int[n];
			rank=new int[n];
			for(int i=0;i<n;i++){
				parent[i]=i;
				rank[i]=1;
			}
			cnt=n;
		}
		int find(int i){
	        while(parent[i] !=i){
	        	parent[i]=parent[parent[i]];
	        	i=parent[i];
	        }
	        return i;
	    }
		int Union(int x, int y){
	        int xset = find(x);
	        int yset = find(y);
	        if(xset!=yset)
	        	cnt--;
	        if(rank[xset]<rank[yset]){
	        	parent[xset] = yset;
		        rank[yset]+=rank[xset];
		        rank[xset]=0;
		        return yset;
	        }else{
	        	parent[yset]=xset;
	        	rank[xset]+=rank[yset];
	        	rank[yset]=0;
	        	return xset;
	        }
	    }
	}
  public static int[][] packU(int n, int[] from, int[] to, int max) {

	    int[][] g = new int[n][];
	    int[] p = new int[n];
	    for (int i = 0; i < max; i++) p[from[i]]++;
	    for (int i = 0; i < max; i++) p[to[i]]++;
	    for (int i = 0; i < n; i++) g[i] = new int[p[i]];
	    for (int i = 0; i < max; i++) {
	        g[from[i]][--p[from[i]]] = to[i];
	        g[to[i]][--p[to[i]]] = from[i];
	    }
	    return g;
	}
	public static int[][] parents3(int[][] g, int root) {
	    int n = g.length;
	    int[] par = new int[n];
	    Arrays.fill(par, -1);

	    int[] depth = new int[n];
	    depth[0] = 0;

	    int[] q = new int[n];
	    q[0] = root;
	    for (int p = 0, r = 1; p < r; p++) {
	        int cur = q[p];
	        for (int nex : g[cur]) {
	            if (par[cur] != nex) {
	                q[r++] = nex;
	                par[nex] = cur;
	                depth[nex] = depth[cur] + 1;
	            }
	        }
	    }
	    return new int[][]{par, q, depth};
	}
	public static int lower_bound(int[] nums, int target) {
        int low = 0, high = nums.length - 1;
        while (low < high) {
            int mid = low + (high - low) / 2;
            if (nums[mid] < target)
                low = mid + 1;
            else
                high = mid;
        }
        return nums[low] == target ? low : -1;
    }

    public static int upper_bound(int[] nums, int target) {
        int low = 0, high = nums.length - 1;
        while (low < high) {
            int mid = low + (high + 1 - low) / 2;
            if (nums[mid] > target)
                high = mid - 1;
            else
                low = mid;
        }
        return nums[low] == target ? low : -1;
    }
  public static boolean palin(String s)
	{
	   int i=0;
	   int j=s.length()-1;
	   while(i<j)
	   {
		   if(s.charAt(i)==s.charAt(j))
		   {
			   i++;
			   j--;
		   }
		   else return false;
	   }
	   return true;
	}

    static boolean CountPs(String s,int n)
       {
    	boolean b=false;
    	     char[] S=s.toCharArray();
	       int[][] dp=new int[n][n];
	       boolean[][] p=new boolean[n][n];
	       for(int i=0;i<n;i++)p[i][i]=true;

	       for(int i=0;i<n-1;i++)
	       {
	    	   if(S[i]==S[i+1])
	    	   {
	    		p[i][i+1]=true;
	    		dp[i][i+1]=1;
	    		b=true;
	    	   }
	       }

	       for(int gap=2;gap<n;gap++)
	       {
	    	   for(int i=0;i<n-gap;i++)
	    	   {
	    		   int j=gap+i;
	    		   if(S[i]==S[j]&&p[i+1][j-1]){p[i][j]=true;}

	    		  if(p[i][j])
	    			   dp[i][j]=dp[i][j-1]+dp[i+1][j]+1-dp[i+1][j-1];

	    		   else  dp[i][j]=dp[i][j-1]+dp[i+1][j]-dp[i+1][j-1];

	    		   if(dp[i][j]>=1){b=true;}
	    	   }
	       }

	    return b;
   // return dp[0][n-1];

    }

public static int gcd(int a,int b)
{
	int res=1;
	while(a>0)
	{
		res=a;
		a=b%a;
		b=res;
	}
	return res;
}

public static long pow(long n,long p,long m)
{
	 long  result = 1;
	  if(p==0)
	    return 1;
	if (p==1)
	    return n;
	while(p!=0)
	{
	    if(p%2==1)
	        result *= n;
	    if(result>=m)
	    result%=m;
	    p >>=1;
	    n*=n;
	    if(n>=m)
	    n%=m;
	}
	return result;
}
public static long pow(long n,long p)
{
	long  result = 1;
	  if(p==0)
	    return 1;
	if (p==1)
	    return n;
	while(p!=0)
	{
	    if(p%2==1)
	        result *= n;
	    p >>=1;
	    n*=n;
	}
	return result;

}

static class Edge implements Comparator<Edge> {
	public int u;
	public int v;
	public int w;
	public Edge() {
	}
	public Edge(int u, int v, int w) {
		this.u=u;
		this.v=v;
		this.w=w;
	}
	public int getU() {
		return u;
	}
	public void setU(int u) {
		this.u = u;
	}
	public int getV() {
		return v;
	}
	public void setV(int v) {
		this.v = v;
	}
	public int getW() {
		return w;
	}
	public void setW(int w) {
		this.w = w;
	      }

	@Override
	public int compare(Edge e1, Edge e2) {
		return  e2.w-e1.w;
	}
}

static class Pair implements Comparable<Pair>
{
	int a,b;
	Pair (int a,int b)
	{
		this.a=a;
		this.b=b;
	}

        @Override
        public int compareTo(Pair o) {
            //throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.

           return this.b-o.b;
        }

}

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

   private SpaceCharFilter filter;
    byte inbuffer[] = new byte[1024];
   int lenbuffer = 0, ptrbuffer = 0;
    final int M = (int) 1e9 + 7;
   int md=(int)(1e7+1);
    int[] SMP=new int[md];
   final double eps = 1e-6;
   final double pi = Math.PI;

	PrintWriter out;
   String check = "";
 InputStream   obj = check.isEmpty() ? System.in : new ByteArrayInputStream(check.getBytes());
   public InputReader(InputStream stream)
   {
       this.stream = stream;
   }

    int readByte() {
	        if (lenbuffer == -1) throw new InputMismatchException();
	        if (ptrbuffer >= lenbuffer) {
	            ptrbuffer = 0;
	            try {
	                lenbuffer = obj.read(inbuffer);
	            } catch (IOException e) {
	                throw new InputMismatchException();
	            }
	        }
	        if (lenbuffer <= 0) return -1;
	        return inbuffer[ptrbuffer++];
   }

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

   String is() {
	        int b = skip();
	        StringBuilder sb = new StringBuilder();
	        while (!(isSpaceChar(b))) // when nextLine, (isSpaceChar(b) && b!=' ')
	        {
	            sb.appendCodePoint(b);
	            b = readByte();
	        }
	        return sb.toString();
   }
   public   int ii() {
	        int num = 0, b;
	        boolean minus = false;
	        while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) ;
	        if (b == '-') {
	            minus = true;
	            b = readByte();
	        }
	        while (true) {
	            if (b >= '0' && b <= '9') {
	                num = num * 10 + (b - '0');
	            } else {
	                return minus ? -num : num;
	            }
	            b = readByte();
	        }
   }
 public   long il() {
	        long num = 0;
	        int b;
	        boolean minus = false;
	        while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) ;
	        if (b == '-') {
	            minus = true;
	            b = readByte();
	        }
	        while (true) {
	            if (b >= '0' && b <= '9') {
	                num = num * 10 + (b - '0');
	            } else {
	                return minus ? -num : num;
	            }
	            b = readByte();
	        }
   }

	    boolean isSpaceChar(int c) {
	        return (!(c >= 33 && c <= 126));
	       }

	      int skip()
	        {
	        int b;
	        while ((b = readByte()) != -1 && isSpaceChar(b)) ;
	        return b;
	        }

	    float nf() {
	        return Float.parseFloat(is());
	    }

	    double id() {
	        return Double.parseDouble(is());
	    }

	    char ic() {
	        return (char) skip();
	    }

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

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

	    String[] isa(int n) {
	        String a[] = new String[n];
	        for (int i = 0; i < n; i++) a[i] = is();
	        return a;
	    }

		 long mul(long a, long b) { return a * b % M; }

			long div(long a, long b)
				 {
					return mul(a, pow(b, M - 2));

		           }

	    double[][] idm(int n, int m) {
	        double a[][] = new double[n][m];
	        for (int i = 0; i < n; i++) for (int j = 0; j < m; j++) a[i][j] = id();
	        return a;
	        }

	    int[][] iim(int n, int m) {
	        int a[][] = new int[n][m];
	        for (int i = 0; i < n; i++) for (int j = 0; j <m; j++) a[i][j] = ii();
	        return a;
          }

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

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

}

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Writer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.Queue;

public class A3 {

	public static void main(String[] args) {
		InputReader in = new InputReader(System.in);
		OutputWriter out = new OutputWriter(System.out);
		int n = in.readInt();
		int m = in.readInt();
		int[] mod = new int[100000];
		int j = 1;
		boolean ans = false;
		while (j <= m) {
			if (mod[n % j] != 0) {
				ans = true;
				break;
			} else {
				mod[n % j] = 1;
			}
			j++;
		}
		if(!ans)
			System.out.println("YES");
		else
			System.out.println("NO");
		out.close();
	}

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

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

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

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

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

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

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

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

	private static class OutputWriter {
		private final PrintWriter writer;

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

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

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

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

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

/* Author: Ronak Agarwal, reader part not written by me*/
import java.io.* ; import java.util.* ;
import static java.lang.Math.min ; import static java.lang.Math.max ;
import static java.lang.Math.abs ; import static java.lang.Math.log ;
import static java.lang.Math.pow ; import static java.lang.Math.sqrt ;
/* Thread is created here to increase the stack size of the java code so that recursive dfs can be performed */
public class C{
	public static void main(String[] args) throws IOException{
		new Thread(null,new Runnable(){	public void run(){ exec_Code() ;} },"Solver",1l<<27).start() ;
	}
	static void exec_Code(){
		try{
			Solver Machine = new Solver() ;
			Machine.Solve() ; Machine.Finish() ;}
		catch(Exception e){ e.printStackTrace() ; print_and_exit() ;}
		catch(Error e){ e.printStackTrace() ; print_and_exit() ; }
	}
	static void print_and_exit(){ System.out.flush() ; System.exit(-1) ;}
}
/* Implementation of the Reader class */
class Reader {
	private InputStream mIs;
	private byte[] buf = new byte[1024];
	private int curChar,numChars;
	public Reader() { this(System.in); }
	public Reader(InputStream is) { mIs = is;}
	public int read() {
		if (numChars == -1) throw new InputMismatchException();
		if (curChar >= numChars) {
			curChar = 0;
			try { numChars = mIs.read(buf);} catch (IOException e) { throw new InputMismatchException();}
			if (numChars <= 0) return -1;
		}
		return buf[curChar++];
	}
	public String nextLine(){
		int c = read();
		while (isSpaceChar(c)) c = read();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = read();
		} while (!isEndOfLine(c));
		return res.toString() ;
	}
	public String s(){
		int c = read();
		while (isSpaceChar(c)) c = read();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = read();
		}while (!isSpaceChar(c));
		return res.toString();
	}
	public long l(){
		int c = read();
		while (isSpaceChar(c)) c = read();
		int sgn = 1;
		if (c == '-') { sgn = -1 ; c = read() ; }
		long res = 0;
		do{
			if (c < '0' || c > '9') throw new InputMismatchException();
			res *= 10 ; res += c - '0' ; c = read();
		}while(!isSpaceChar(c));
		return res * sgn;
	}
	public int i(){
		int c = read() ;
		while (isSpaceChar(c)) c = read();
		int sgn = 1;
		if (c == '-') { sgn = -1 ; c = read() ; }
		int res = 0;
		do{
			if (c < '0' || c > '9') throw new InputMismatchException();
			res *= 10 ; res += c - '0' ; c = read() ;
		}while(!isSpaceChar(c));
		return res * sgn;
	}
	public boolean isSpaceChar(int c) { return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1; }
	public boolean isEndOfLine(int c) { return c == '\n' || c == '\r' || c == -1; }
}
/* All the useful functions,constants,renamings are here*/
class Template{
	/* Constants Section */
	final int INT_MIN = Integer.MIN_VALUE ; final int INT_MAX = Integer.MAX_VALUE ;
	final long LONG_MIN = Long.MIN_VALUE ; final long LONG_MAX = Long.MAX_VALUE ;
	static long MOD = 1000000007 ;
	static Reader ip = new Reader() ;
	static PrintWriter op = new PrintWriter(System.out) ;
	/* Methods for writing */
	static void p(Object o){ op.print(o) ; }
	static void pln(Object o){ op.println(o) ;}
	static void Finish(){ op.flush(); op.close(); }
	/* Implementation of operations modulo MOD */
	static long inv(long a){ return powM(a,MOD-2) ; }
	static long m(long a,long b){ return (a*b)%MOD ; }
	static long d(long a,long b){ return (a*inv(b))%MOD ; }
	static long powM(long a,long b){
		if(b<0) return powM(inv(a),-b) ;
		long ans=1 ;
		for( ; b!=0 ; a=(a*a)%MOD , b/=2) if((b&1)==1) ans = (ans*a)%MOD ;
		return ans ;
	}
	/* Renaming of some generic utility classes */
	final static class mylist extends ArrayList<Integer>{}
	final static class myset extends TreeSet<Integer>{}
	final static class mystack extends Stack<Integer>{}
	final static class mymap extends TreeMap<Integer,Integer>{}
}
/* Implementation of the pair class, useful for every other problem */
class pair implements Comparable<pair>{
	int x ; int y ;
	pair(int _x,int _y){ x=_x ; y=_y ;}
	public int compareTo(pair p){
		return (this.x<p.x ? -1 : (this.x>p.x ? 1 : (this.y<p.y ? -1 : (this.y>p.y ? 1 : 0)))) ;
	}
}
/* Main code starts here */
class Solver extends Template{
	int MAXN = 40000000 ;
	public void Solve() throws IOException{
		long n = ip.i() ; long k = ip.i() ;
		if(k>=(n+2)){pln("No") ; return ; }
		int hit[] = new int[MAXN+1] ;
		boolean flag=true ;
		for(long i=1 ; i<=k ; i++){
			if(hit[(int) (n%i)]==1){
				flag=false ; break ;
			}
			hit[(int) (n%i)] = 1 ;
		}
		pln(flag ? "Yes" : "No") ;
	}
}

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

public class Main implements Runnable {

    int maxn = (int)1e5+111;
    int inf = (int)1e9+111;
    int n,m,k;
    String a[] = new String[maxn];
    HashMap<String, Integer> map = new HashMap<>();

    void solve() throws Exception {
        long n = in.nextLong();
        long k = in.nextLong();

        if (k==1) {
            out.println("Yes");
            return;
        }

        if (k >= n) {
            out.println("No");
            return;
        }

        HashSet<Long> set = new HashSet<>();
        for (int i=1; i<=Math.min(k, 100*1000); i++) {
            long val = n%i;
            if (set.contains(val)) {
                out.println("No");
                return;
            }
            set.add(val);
        }

        out.println("Yes");

    }

    class Pair implements Comparable<Pair> {
        int x;
        int y;

        public Pair (int x, int y) {
            this.x = x;
            this.y = y;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Pair pair = (Pair) o;
            return x == pair.x &&
                    y == pair.y;
        }

        @Override
        public int hashCode() {

            return Objects.hash(x, y);
        }

        @Override
        public int compareTo(Pair p) {
            if (this.x>p.x) {
                return 1;
            } else if(this.x == p.x) {
                if (this.y < p.y) {
                    return 1;
                } else if (this.y == p.y) return 0;
                else return -1;
            } else {
                return -1;
            }
        }

        @Override
        public String toString() {
            return "Pair{" +
                    "x=" + x +
                    ", y=" + y +
                    '}';
        }
    }

    String fileInName = "freecell";
    boolean file = false;
    boolean isAcmp = false;

    static Throwable throwable;
    public static void main (String [] args) throws Throwable {
        Thread thread = new Thread(null, new Main(), "", (1 << 26));
        thread.start();
        thread.join();
        thread.run();
        if (throwable != null)
            throw throwable;
    }

    FastReader in;
    PrintWriter out;

    public void run() {
        String fileIn = "absum.in";
        String fileOut = "absum.out";

        try {
            if (isAcmp) {
                if (file) {
                    in = new FastReader(new BufferedReader(new FileReader(fileIn)));
                    out = new PrintWriter (fileOut);
                } else {
                    in = new FastReader(new BufferedReader(new InputStreamReader(System.in)));
                    out = new PrintWriter(System.out);
                }
            } else if (file) {
                in = new FastReader(new BufferedReader(new FileReader(fileInName+".in")));
                out = new PrintWriter (fileInName + ".out");
            } else {
                in = new FastReader(new BufferedReader(new InputStreamReader(System.in)));
                out = new PrintWriter(System.out);
            }

            solve();
        } catch(Exception e) {
            throwable = e;
        } finally {
            out.close();
        }

    }
}

class FastReader {
    BufferedReader bf;
    StringTokenizer tk = null;

    public FastReader(BufferedReader bf) {
        this.bf = bf;
    }

    public String nextToken () throws Exception {
        if (tk==null || !tk.hasMoreTokens()) {
            tk = new StringTokenizer(bf.readLine());
        }
        if (!tk.hasMoreTokens()) return nextToken();
        else
            return tk.nextToken();
    }

    public int nextInt() throws Exception {
        return Integer.parseInt(nextToken());
    }

    public long nextLong() throws Exception {
        return Long.parseLong(nextToken());
    }

    public double nextDouble() throws Exception {
        return Double.parseDouble(nextToken());
    }
}

import java.util.*;
import java.io.*;
import java.util.concurrent.TimeUnit;

public class cavePaint {

	public static void main (String [] args) throws Exception {
	    BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
	    PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));

	    StringTokenizer st = new StringTokenizer(f.readLine());
	    long N = Long.parseLong(st.nextToken());
	    long K = Long.parseLong(st.nextToken());

	    if(N % 2 == 0 && K >= 2) {
	    	out.println("No");
	    	out.close();
	    	System.exit(0);
	    }
	    long i;
	    for(i = 3; i <= Math.min(K, Math.sqrt(N)); i+=2) {
	    	//System.out.println(i);
	    	//System.out.println(i);
	    	if(N % i == 0) {
	    		out.println("No");
	    		out.close();
	    		System.exit(0);
	    	}
	    }
	    if((i == (int)Math.sqrt(N)+1 || i == (int)Math.sqrt(N)+2) && K == N) {
	    	out.println("No");
	    } else
	    	out.println("Yes");

	    out.close();
	    f.close();
	}

}