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

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class ModularStability {
    public static void main(String[] args) throws IOException {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }
    static class TaskA {
        long mod = (long)(998244353);
        long fact[];
        public void solve(int testNumber, InputReader in, PrintWriter out) throws IOException {
            while(testNumber-->0){
            	int n = in.nextInt();
            	int k = in.nextInt();
            	long ans = 0;
            	fact = new long[n+1];
            	fact[0] = 1;
            	for(int i=1;i<=n;i++)
            		fact[i] = (i*fact[i-1])%mod;
            	for(int i=1;i<=n;i++){
            		int terms = (n - i)/i + 1;
            		if(terms<k)
            			continue;
            		terms--;
            		ans = (ans + Math.max(1 , nCrPFermet(terms , k-1 , mod)))%mod;
            	}
            	out.println(ans);
            }
        }
		public void build(int lookup[][] , int arr[], int n) {
			for (int i = 0; i < n; i++)
				lookup[i][0] = arr[i];
			for (int j = 1; (1 << j) <= n; j++) {
				for (int i = 0; (i + (1 << j) - 1) < n; i++) {
					if (lookup[i][j - 1] > lookup[i + (1 << (j - 1))][j - 1])
						lookup[i][j] = lookup[i][j - 1];
					else
						lookup[i][j] = lookup[i + (1 << (j - 1))][j - 1];
				}
			}
		}
		public int query(int lookup[][] , int L, int R) {
			int j = (int)(Math.log(R - L + 1)/Math.log(2));
			if (lookup[L][j] >= lookup[R - (1 << j) + 1][j])
				return lookup[L][j];
			else
				return lookup[R - (1 << j) + 1][j];
		}
        public void print1d(int a[] , PrintWriter out){
        	for(int i=0;i<a.length;i++)
        		out.print(a[i] + " ");
        	out.println();
        }
        public void print2d(int a[][] , PrintWriter out){
            for(int i=0;i<a.length;i++){
                for(int j=0;j<a[i].length;j++)
                    out.print(a[i][j] + " ");
                out.println();
            }
            out.println();
        }
        public void sieve(int a[]){
            a[0] = a[1] = 1;
            int i;
            for(i=2;i*i<=a.length;i++){
                if(a[i] != 0)
                    continue;
                a[i] = i;
                for(int k = (i)*(i);k<a.length;k+=i){
                    if(a[k] != 0)
                        continue;
                    a[k] = i;
                }
            }
        }
        public int [][] matrixExpo(int c[][] , int n){
            int a[][] = new int[c.length][c[0].length];
            int b[][] = new int[a.length][a[0].length];
            for(int i=0;i<c.length;i++)
                for(int j=0;j<c[0].length;j++)
                    a[i][j] = c[i][j];
            for(int i=0;i<a.length;i++)
                b[i][i] = 1;
            while(n!=1){
                if(n%2 == 1){
                    b = matrixMultiply(a , a);
                    n--;
                }
                a = matrixMultiply(a , a);
                n/=2;
            }
            return matrixMultiply(a , b);
        }
        public int [][] matrixMultiply(int a[][] , int b[][]){
            int r1 = a.length;
            int c1 = a[0].length;
            int c2 = b[0].length;
            int c[][] = new int[r1][c2];
            for(int i=0;i<r1;i++){
                for(int j=0;j<c2;j++){
                    for(int k=0;k<c1;k++)
                        c[i][j] += a[i][k]*b[k][j];
                }
            }
            return c;
        }
        public long nCrPFermet(int n , int r , long p){
            if(r==0)
                return 1l;
            // long fact[] = new long[n+1];
            // fact[0] = 1;
            // for(int i=1;i<=n;i++)
            //     fact[i] = (i*fact[i-1])%p;
            long modInverseR = pow(fact[r] , p-2 , p);
            long modInverseNR = pow(fact[n-r] , p-2 , p);
            long w = (((fact[n]*modInverseR)%p)*modInverseNR)%p;
            return w;
        }
        public long pow(long a, long b, long m) {
            a %= m;
            long res = 1;
            while (b > 0) {
                long x = b&1;
                if (x == 1)
                    res = res * a % m;
                a = a * a % m;
                b >>= 1;
            }
            return res;
        }
        public long pow(long a, long b) {
            long res = 1;
            while (b > 0) {
                long x = b&1;
                if (x == 1)
                    res = res * a;
                a = a * a;
                b >>= 1;
            }
            return res;
        }
        public void swap(int a[] , int p1 , int p2){
            int x = a[p1];
            a[p1] = a[p2];
            a[p2] = x;
        }
        public void sortedArrayToBST(TreeSet<Integer> a , int start, int end) {
            if (start > end) {
                return;
            }
            int mid = (start + end) / 2;
            a.add(mid);
            sortedArrayToBST(a, start, mid - 1);
            sortedArrayToBST(a, mid + 1, end);
        }
        class Combine{
            int value;
            int delete;
            Combine(int val , int delete){
                this.value = val;
                this.delete = delete;
            }
        }
        class Sort2 implements Comparator<Combine>{
            public int compare(Combine a , Combine b){
                if(a.value > b.value)
                    return 1;
                else if(a.value == b.value && a.delete>b.delete)
                    return 1;
                else if(a.value == b.value && a.delete == b.delete)
                    return 0;
                return -1;
            }
        }
        public int lowerLastBound(ArrayList<Integer> a , int x){
            int l = 0;
            int r = a.size()-1;
            if(a.get(l)>=x)
                return -1;
            if(a.get(r)<x)
                return r;
            int mid = -1;
            while(l<=r){
                mid = (l+r)/2;
                if(a.get(mid) == x && a.get(mid-1)<x)
                    return mid-1;
                else if(a.get(mid)>=x)
                    r = mid-1;
                else if(a.get(mid)<x && a.get(mid+1)>=x)
                    return mid;
                else if(a.get(mid)<x && a.get(mid+1)<x)
                    l = mid+1;
            }
            return mid;
        }
        public int upperFirstBound(ArrayList<Integer> a , Integer x){
            int l = 0;
            int r = a.size()-1;
            if(a.get(l)>x)
                return l;
            if(a.get(r)<=x)
                return r+1;
            int mid = -1;
            while(l<=r){
                mid = (l+r)/2;
                if(a.get(mid) == x && a.get(mid+1)>x)
                    return mid+1;
                else if(a.get(mid)<=x)
                    l = mid+1;
                else if(a.get(mid)>x && a.get(mid-1)<=x)
                    return mid;
                else if(a.get(mid)>x && a.get(mid-1)>x)
                    r = mid-1;
            }
            return mid;
        }
        public int lowerLastBound(int a[] , int x){
            int l = 0;
            int r = a.length-1;
            if(a[l]>=x)
                return -1;
            if(a[r]<x)
                return r;
            int mid = -1;
            while(l<=r){
                mid = (l+r)/2;
                if(a[mid] == x && a[mid-1]<x)
                    return mid-1;
                else if(a[mid]>=x)
                    r = mid-1;
                else if(a[mid]<x && a[mid+1]>=x)
                    return mid;
                else if(a[mid]<x && a[mid+1]<x)
                    l = mid+1;
            }
            return mid;
        }
        public int upperFirstBound(long a[] , long x){
            int l = 0;
            int r = a.length-1;
            if(a[l]>x)
                return l;
            if(a[r]<=x)
                return r+1;
            int mid = -1;
            while(l<=r){
                mid = (l+r)/2;
                if(a[mid] == x && a[mid+1]>x)
                    return mid+1;
                else if(a[mid]<=x)
                    l = mid+1;
                else if(a[mid]>x && a[mid-1]<=x)
                    return mid;
                else if(a[mid]>x && a[mid-1]>x)
                    r = mid-1;
            }
            return mid;
        }
        public long log(float number , int base){
            return (long) Math.ceil((Math.log(number) / Math.log(base)) + 1e-9);
        }
        public long gcd(long a , long b){
            if(a<b){
                long c = b;
                b = a;
                a = c;
            }
            while(b!=0){
            	long c = a;
            	a = b;
            	b = c%a;
            }
            return a;
        }
        public long[] gcdEx(long p, long q) {
            if (q == 0)
                return new long[] { p, 1, 0 };
            long[] vals = gcdEx(q, p % q);
            long d = vals[0];
            long a = vals[2];
            long b = vals[1] - (p / q) * vals[2];
            // 0->gcd 1->xValue 2->yValue
            return new long[] { d, a, b };
        }
        public void sievePhi(int a[]){
            a[0] = 0;
            a[1] = 1;
            for(int i=2;i<a.length;i++)
                a[i] = i-1;
            for(int i=2;i<a.length;i++)
                for(int j = 2*i;j<a.length;j+=i)
                    a[j] -= a[i];
        }
        public void lcmSum(long a[]){
        	int sievePhi[] = new int[(int)1e6 + 1];
        	sievePhi(sievePhi);
        	a[0] = 0;
        	for(int i=1;i<a.length;i++)
        		for(int j = i;j<a.length;j+=i)
        			a[j] += (long)i*sievePhi[i];
        }
        static class AVLTree{
            Node root;
            public AVLTree(){
                this.root = null;
            }
            public int height(Node n){
                return (n == null ? 0 : n.height);
            }
            public int getBalance(Node n){
                return (n == null ? 0 : height(n.left) - height(n.right));
            }
            public Node rotateRight(Node a){
                Node b = a.left;
                Node br = b.right;

                a.lSum -= b.lSum;
                a.lCount -= b.lCount;

                b.rSum += a.rSum;
                b.rCount += a.rCount;

                b.right = a;
                a.left = br;

                a.height = 1 + Math.max(height(a.left) , height(a.right));
                b.height = 1 + Math.max(height(b.left) , height(b.right));
                return b;
            }
            public Node rotateLeft(Node a){
                Node b = a.right;
                Node bl = b.left;

                a.rSum -= b.rSum;
                a.rCount -= b.rCount;

                b.lSum += a.lSum;
                b.lCount += a.lCount;

                b.left = a;
                a.right = bl;

                a.height = 1 + Math.max(height(a.left) , height(a.right));
                b.height = 1 + Math.max(height(b.left) , height(b.right));
                return b;
            }
            public Node insert(Node root , long value){
                if(root == null){
                    return new Node(value);
                }
                if(value<=root.value){
                    root.lCount++;
                    root.lSum += value;
                    root.left =  insert(root.left , value);
                }
                if(value>root.value){
                    root.rCount++;
                    root.rSum += value;
                    root.right = insert(root.right , value);
                }
                // updating the height of the root
                root.height = 1 + Math.max(height(root.left) , height(root.right));
                int balance = getBalance(root);

                //ll
                if(balance>1 && value<=root.left.value)
                    return rotateRight(root);
                //rr
                if(balance<-1 && value>root.right.value)
                    return rotateLeft(root);
                //lr
                if(balance>1 && value>root.left.value){
                    root.left = rotateLeft(root.left);
                    return rotateRight(root);
                }
                //rl
                if(balance<-1 && value<=root.right.value){
                    root.right = rotateRight(root.right);
                    return rotateLeft(root);
                }
                return root;
            }
            public void insertElement(long value){
                this.root = insert(root , value);
            }
            public int getElementLessThanK(long k){
                int count = 0;
                Node temp = root;
                while(temp!=null){
                    if(temp.value == k){
                        if(temp.left == null || temp.left.value<k){
                            count += temp.lCount;
                            return count-1;
                        }
                        else
                            temp = temp.left;
                    }
                    else if(temp.value>k){
                        temp = temp.left;
                    }
                    else{
                        count += temp.lCount;
                        temp = temp.right;
                    }
                }
                return count;
            }
            public void inorder(Node root , PrintWriter out){
                Node temp = root;
                if(temp!=null){
                    inorder(temp.left , out);
                    out.println(temp.value + " " + temp.lCount + " " + temp.rCount);
                    inorder(temp.right , out);
                }
            }
        }
        static class Node{
            long value;
            long lCount , rCount;
            long lSum , rSum;
            Node left , right;
            int height;
            public Node(long value){
                this.value = value;
                left = null;
                right = null;
                lCount = 1;
                rCount = 1;
                lSum = value;
                rSum = value;
                height = 1;
            }
        }
    }

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

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

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

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

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

    }
}

// package EducationalRound88;

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

public class ProblemE {
    public static void main(String[] args)throws IOException {
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st=new StringTokenizer(br.readLine());
        int n=Integer.parseInt(st.nextToken());
        int k=Integer.parseInt(st.nextToken());
        int mod=998244353;
        long fact[]=new long[n+1];
        fact[1]=1;
        fact[0]=1;
        long inv[]=new long[n+1];
        for(int i=2;i<=n;i++){
            fact[i]=(fact[i-1]*i)%mod;
        }
        inv[n]=modexp(fact[n],mod-2,mod);
        for(int i=n-1;i>=0;i--){
            inv[i]=(inv[i+1]*(i+1))%mod;
        }
        long ans=0;
        for(int i=1;i<=n;i++){
            int p=(n-i)/i;
            int r=k-1;
            if(p<r){
                break;
            }
            long num=fact[p];
            long den=inv[r];
            den=(den*inv[p-r])%mod;
            num=(num*den)%mod;
            ans=(ans+num)%mod;
        }
        System.out.println(ans);
    }
    public static long modexp(long a,long power,int mod){
        if(power==0){
            return 1;
        }
        if(power==1){
            return a;
        }
        long small=modexp(a,power/2,mod);
        long ans=(small%mod*small%mod)%mod;
        if(power%2!=0){
            ans=(ans%mod*a%mod)%mod;
        }
        return ans;
    }
}

// Java implementation of the approach
import java.io.*;
import java.math.BigInteger;
import java.util.*;

public class Solution {

	public static class FastReader {
		BufferedReader br;
		StringTokenizer root;

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

		String next() {
			while (root == null || !root.hasMoreTokens()) {
				try {
					root = new StringTokenizer(br.readLine());
				} catch (Exception addd) {
					addd.printStackTrace();
				}
			}
			return root.nextToken();
		}

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

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

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

		String nextLine() {
			String str = "";
			try {
				str = br.readLine();
			} catch (Exception addd) {
				addd.printStackTrace();
			}
			return str;
		}
	}
	public static PrintWriter out = new PrintWriter (new BufferedOutputStream(System.out));
	public static FastReader sc = new FastReader();
	static List<Integer>[] edges;
	public static int[][] parent;
	public static int mod = 998244353;

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

		int n = sc.nextInt();
		int k = sc.nextInt();
		precompute(n);
		long ans = 0;
		for(int i=1;i<=n;++i) {
			ans+=ncr(n/i-1,k-1);
			if(ans >= mod) ans-=mod;
		}
		out.println(ans);
		out.close();
	}

	static long[] fac,inv;
	static void precompute(int n)
	{

		 fac = new long[n+1];
	     inv = new long[n+1];
		fac[0]=fac[1]=1;
		for(int i=2;i<fac.length;i++)
		{
			fac[i]=fac[i-1]*i;
			fac[i]%=mod;
		}

		inv[n]=pow(fac[n],(int) (mod-2));
		for(int i=n-1;i>=0;i--)
		{
			inv[i]=inv[i+1]*(i+1);
			inv[i]%=mod;
		}
	}
	 private static long pow(long a, int b) {
		return BigInteger.valueOf(a).modPow(BigInteger.valueOf(b), BigInteger.valueOf(mod)).longValue();
	}

	private static long ncr(int n , int r) {
		if(n < 0 || r < 0 || r > n) return 0;
		return ((fac[n]*inv[r]%mod)*(inv[n-r]%mod))%mod;
	}

}

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

public class E {
    public static long[] factorial;
    public static long MOD = 998244353;
    public static void main(String[] args) throws IOException{
        BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
        StringTokenizer st = new StringTokenizer(f.readLine());
        int n = Integer.parseInt(st.nextToken());
        int k = Integer.parseInt(st.nextToken());
        if(k > n){
            out.println(0);
            out.close();
            System.exit(0);
        }
        factorial = new long[n+1];
        factorial[0] = 1L;
        for(int i = 1; i <= n; i++){
            factorial[i] = (factorial[i-1]*i)%MOD;
        }
        long ans = 0;
        for(int i = 1; i <= n-k+1; i++){
            int left = (i+1)/i;
            int right = (n)/i;
            int count = right-left;
            if((i+1)%i == 0 && n%i == 0) count++;
            if(count >= k-1) {
                ans += ncr(count, k - 1);
                ans %= MOD;
            }
        }
        out.println(ans);

        out.close();
    }
    public static long ncr(int n, int r){
        return (((factorial[(int)n] * power(factorial[(int)r], MOD-2, MOD))%MOD)*power(factorial[(int)(n-r)], MOD-2, MOD)%MOD);
    }

    public static long power(long x, long y, long p){
        long res = 1;

        x = x % p;

        while (y > 0)
        {

            if (y % 2 == 1)
                res = (res * x) % p;

            y = y >> 1;
            x = (x * x) % p;
        }

        return res;
    }
}

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

public class MainClass
{
    static long fact[];
    static long M = 998244353L;
    static NumberTheory numberTheory = new NumberTheory();
    public static void main(String[] args)throws IOException
    {
        Reader in = new Reader();
        int n = in.nextInt();
        int k = in.nextInt();
        fact = new long[500000 + 10];
        fact[0] = 1L;
        for (int i =1;i<fact.length;i++)    fact[i] = (fact[i - 1] * 1L * i) % M;
        if (n < k)
        {
            System.out.println("0");
            System.exit(0);
        }
        long ans = 0L;
        for (int i=1;i<=n;i++)
        {
            int g = i;
            int c = n / g;
            if (c < k)
                break;
            long res = nCr(c - 1, k - 1);
            ans = (ans + res + M) % M;
        }
        System.out.println(ans);
    }
    public static long nCr(int n, int r)
    {
        long ans = fact[n];
        long den1 = (fact[r] * fact[n - r]) % M;
        long den = (numberTheory.extendedEuclid(den1, M).x + M) % M;
        ans = (ans * den) % M;
        return ans;
    }
}
class Reader
{
    final private int BUFFER_SIZE = 1 << 16;
    private DataInputStream din;
    private byte[] buffer;
    private int bufferPointer, bytesRead;

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

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

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

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

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

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

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

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

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

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

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

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

    public void close() throws IOException
    {
        if (din == null)
            return;
        din.close();
    }
}
class NumberTheory
{
    public boolean isPrime(long n)
    {
        if(n < 2)
            return false;
        for(long x = 2;x * x <= n;x++)
        {
            if(n % x == 0)
                return false;
        }
        return true;
    }
    public ArrayList<Long> primeFactorisation(long n)
    {
        ArrayList<Long> f = new ArrayList<>();
        for(long x=2;x * x <= n;x++)
        {
            while(n % x == 0)
            {
                f.add(x);
                n /= x;
            }
        }
        if(n > 1)
            f.add(n);
        return f;
    }
    public int[] sieveOfEratosthenes(int n)
    {
        //Returns an array with the smallest prime factor for each number and primes marked as 0
        int[] sieve = new int[n + 1];
        for(int x=2;x * x <= n;x++)
        {
            if(sieve[x] != 0)
                continue;
            for(int u=x*x;u<=n;u+=x)
            {
                if(sieve[u] == 0)
                {
                    sieve[u] = x;
                }
            }
        }
        return sieve;
    }
    public long gcd(long a, long b)
    {
        if(b == 0)
            return a;
        return gcd(b, a % b);
    }
    public long phi(long n)
    {
        double result = n;

        for(long p=2;p*p<=n;p++)
        {
            if(n % p == 0)
            {
                while (n % p == 0)
                    n /= p;
                result *= (1.0 - (1.0 / (double)p));
            }
        }
        if(n > 1)
            result *= (1.0 - (1.0 / (double)n));
        return (long)result;
    }
    public Name extendedEuclid(long a, long b)
    {
        if(b == 0)
            return new Name(a, 1, 0);
        Name n1 = extendedEuclid(b, a % b);
        Name n2 = new Name(n1.d, n1.y, n1.x - (long)Math.floor((double)a / b) * n1.y);
        return n2;
    }
    public long modularExponentiation(long a, long b, long n)
    {
        long d = 1L;
        String bString = Long.toBinaryString(b);
        for(int i=0;i<bString.length();i++)
        {
            d = (d * d) % n;
            if(bString.charAt(i) == '1')
                d = (d * a) % n;
        }
        return d;
    }
}
class Name
{
    long d;
    long x;
    long y;

    public Name(long d, long x, long y)
    {
        this.d = d;
        this.x = x;
        this.y = y;
    }
}

//package learning;
import java.util.*;
import java.io.*;
import java.lang.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;
public class NitsLocal {
    static ArrayList<String> s1;
    static boolean[] prime;
    static int n = 200001;

     static void sieve() {
Arrays.fill(prime	, true);
prime[0] = prime[1] = false;
for(int i = 2 ; i * i <= n ; ++i) {
if(prime[i]) {
for(int k = i * i; k<= n ; k+=i) {
prime[k] = false;
}
}
}

}
    public static void main(String[] args) {
        InputReader sc = new InputReader(System.in);

           //prime  = new boolean[n + 1];
          // sieve();
                //prime[1] = false;

             /*
        int n = sc.ni();
        int k = sc.ni();
        int []vis = new int[n+1];
        int []a = new int[k];
        for(int i=0;i<k;i++)
        {
            a[i] = i+1;
        }
        int j = k+1;
        int []b = new int[n+1];
        for(int i=1;i<=n;i++)
        {
            b[i] = -1;
        }
        int y = n - k +1;
        int tr = 0;
        int y1 = k+1;
        while(y-- > 0)
        {
        System.out.print("? ");
        for(int i=0;i<k;i++)
        {
            System.out.print(a[i] + " ");
        }

        System.out.flush();
        int pos = sc.ni();
        int a1 = sc.ni();
        b[pos] = a1;

        for(int i=0;i<k;i++)
        {
            if(a[i] == pos)
            {
                a[i] = y1;
                y1++;
            }
        }
        }
        ArrayList<Integer> a2 = new ArrayList<>();
        if(y >= k)
        {

        int c = 0;
        int k1 = 0;
            for(int i=1;i<=n;i++)
            {
                if(b[i] != -1)
                {
                    c++;
                    a[k1] = i;
                    a2.add(b[i]);
                    k1++;
                }
                if(c==k)
                    break;
            }

            Collections.sort(a2);
            System.out.print("? ");
        for(int i=0;i<k;i++)
        {
            System.out.print(a[i] + " ");
        }
        System.out.println();
        System.out.flush();
        int pos = sc.ni();
        int a1 = sc.ni();
        int ans = -1;
        for(int i=0;i<a2.size();i++)
        {
            if(a2.get(i) == a1)
            {
                ans = i+1;
                break;
            }
        }
        System.out.println("!" + " " + ans);
           System.out.flush();
        }
        else
        {
            int k1 = 0;
            a = new int[k];
             for(int i=1;i<=n;i++)
            {
                if(b[i] != -1)
                {

                    a[k1] = i;
                    a2.add(b[i]);
                    k1++;
                }

            }
              for(int i=1;i<=n;i++)
            {
                if(b[i] == -1)
                {

                    a[k1] = i;

                    k1++;
                    if(k1==k)
                        break;
                }

            }
              int ans = -1;
              while(true)
              {
                   System.out.print("? ");
                     for(int i=0;i<k;i++)
                   {
                         System.out.print(a[i] + " ");
                  }
                   System.out.println();
                   System.out.flush();
                   int pos = sc.ni();
                   int a1 = sc.ni();
                   int f = 0;

                   if(b[pos] != -1)
                   {
                       Collections.sort(a2);
                       for(int i=0;i<a2.size();i++)
                       {
                           if(a2.get(i) == a1)
                           {
                               ans = i+1;
                               f = 1;
                               System.out.println("!" + " " + ans);
                               System.out.flush();
                               break;
                           }
                       }
                       if(f==1)
                           break;
                   }
                   else
                   {
                       b[pos] = a1;
                        a = new int[k];
                        a2.add(a1);
             for(int i=1;i<=n;i++)
            {
                if(b[i] != -1)
                {

                    a[k1] = i;
                    a2.add(b[i]);
                    k1++;
                }

            }
              for(int i=1;i<=n;i++)
            {
                if(b[i] == -1)
                {

                    a[k1] = i;

                    k1++;
                    if(k1==k)
                        break;
                }

                   }
              }
        }
          */

    /*
          int n = sc.ni();
          int []a = sc.nia(n);
          int []b = sc.nia(n);
          Integer []d = new Integer[n];
          int []d1 = new int[n];
          for(int i=0;i<n;i++)
          {
              d[i] = (a[i] - b[i]);

          }
          int l = 0;
          int r = n-1;
          Arrays.sort(d);
          long res = 0;
          while(l < r)
          {
              if(d[l] + d[r] > 0)
              {
                  res += (long) (r-l);
                  r--;
              }
              else
                  l++;
          }

          w.println(res);
*/
      /*
      int n = sc.ni();

      ArrayList<Integer> t1 = new ArrayList<>();
      int []p1 = new int[n+1];
      int []q1 = new int[n-1];
      int []q2 = new int[n-1];
      for(int i=0;i<n-1;i++)
      {
          int p = sc.ni();
          int q = sc.ni();
          t1.add(q);
          p1[p]++;
          q1[i] = p;
          q2[i] = q;

      }
      int res = 0;
      for(int i=0;i<t1.size();i++)
      {
          if(p1[t1.get(i)] == 0)
          {
              res = t1.get(i);
              //break;
          }
      }

    int y = 1;
    for(int i=0;i<n-1;i++)
    {
        if(q2[i] == res)
        {
            w.println("0");
        }
        else
        {
            w.println(y + " ");
            y++;
        }
    }
      */
 /*
   int n = sc.ni();
   int k = sc.ni();
   Integer []a = new Integer[n];
   for(int i=0;i<n;i++)
   {
       a[i] = sc.ni();
       a[i] = a[i]%k;
   }
   HashMap<Integer,Integer> hm = new HashMap<>();
   for(int i=0;i<n;i++)
   {
       if(!hm.containsKey(a[i]))
           hm.put(a[i], 1);
       else
           hm.put(a[i], hm.get(a[i]) + 1);
   }
  Arrays.sort(a);
  int z = 0;
  long res = 0;
  HashMap<Integer,Integer> v = new HashMap<>();
  for(int i=0;i<n;i++)
  {
      if(a[i] == 0)
          res++;
      else
      {
          if(a[i] == k-a[i] && !v.containsKey(a[i]))
          {
              res += (long) hm.get(a[i]) / 2;
              v.put(a[i],1);
          }
          else
          {
          if(hm.containsKey(a[i]) && hm.containsKey(k-a[i]))
          {
          int temp = a[i];

          if(!v.containsKey(a[i]) && !v.containsKey(k-a[i]))
          {
             res += (long) Math.min(hm.get(temp), hm.get(k-temp));
             v.put(temp,1);
             v.put(k-temp,1);
          }
          }
          }
      }
  }
  w.println(res);
*/
 /*
int []a = new int[4];
//G0
a[0] = 0;
a[1] = 1;
a[2] = 0;
a[3] = 1;
int []b = new int[4];
//g1
b[0] = 0;
b[1] = 1;
b[2] = 1;
b[3] = 0;
int [][]dp1 = new int[4][4];
int [][]dp2 = new int[4][4];
for(int i=0;i<4;i++)
{
    for(int j=0;j<4;j++)
    {
        dp1[i][j] = (a[i] | a[j]);
    }
   // w.println();
}
w.println();
for(int i=0;i<4;i++)
{
    for(int j=0;j<4;j++)
    {
        dp2[i][j] = (b[i] | b[j]);
    }
    //w.println();
}
int a1 = 0;
int b1 = 0;
int c1 = 0;
int d1 = 0;
for(int i=0;i<4;i++)
{
    for(int j=0;j<4;j++)
    {
        if(dp1[i][j] == 0 && dp2[i][j] == 0)
            a1++;
        else  if(dp1[i][j] == 1 && dp2[i][j] == 1)
            b1++;
        else  if(dp1[i][j] == 0 && dp2[i][j] == 1)
            c1++;
        else
            d1++;

    }
}
w.println(a1+ " " + b1 + " " + c1 +" "+ d1);

Scanner sc = new Scanner(System.in);
    int q = sc.nextInt();
    while(q-- > 0)
    {
        long x = sc.nextLong();
        long y = sc.nextLong();
        long a = (x - y)/2;
        long a1 = 0, b1 = 0;

        int lim     = 8;

    int f = 0;

    for (int i=0; i<8*lim; i++)
    {
        long pi = (y & (1 << i));
        long qi = (a & (1 << i));
        if (pi == 0 && qi == 0)
        {

        }
        else if (pi == 0 && qi > 0)
        {
            a1 = ((1 << i) | a1);
            b1 = ((1 << i) | b1);
        }
        else if (pi > 0 && qi == 0)
        {
            a1 = ((1 << i) | a1);

        }
        else
        {
            f = 1;

        }
    }
    if(a1+b1 != x)
        f  =1;
  if(f==1)
            System.out.println("-1");
  else
  {
       if(a1 > b1)
       {
           long temp = a1;
           a1 = b1;
           b1 = temp;
       }
    System.out.println(a1 + " " + b1);

  }

    }

     */

    fact = new long[500001];
    long mod = 998244353;
    fact[0] = 1;
    fact[1] = 1;
    for(int i=2;i<=500000;i++)
    {
        fact[i] = ((long)i* fact[i-1])%mod;
    }
    int n = sc.ni();
    int k = sc.ni();

        long ans = 0;
        for(int i=1;i<=n;i++)
        {
            int temp = n/i;
            if(temp >= k)
            {
                ans += nCrModPFermat(temp-1,k-1,mod);
                ans = ans%mod;
            }
        }
        w.println(ans);

       w.close();

}

    static long nCrModPFermat(int n, int r,
                                    long p)
    {

        // Base case
        if (r == 0)
            return 1;

        // Fill factorial array so that we
        // can find all factorial of r, n
        // and n-r

        return (fact[n]* modInverse(fact[r], p) % p * modInverse(fact[n-r], p) % p) % p;
    }
   static long []fact;
    static int []res;
    static int c = 0;
    static class Pair{
        int fir;
        int last;
        Pair(int fir,int last)
        {
            this.fir = fir;
            this.last = last;
        }
    }
    static class m1 implements Comparator<Pair>{
        public int compare(Pair a, Pair b)
        {
            int t1 = a.last - a.fir;
            int t2 = b.last - b.fir;
            if(t1 < t2)
                return 1;
            else if(t1 > t2)
                return -1;
            else
            {
                if(a.fir < b.fir)
                    return -1;
                else
                    return 1;
            }
        }
    }

    static long calc(long x)
    {
        double res = Math.sqrt(1 + 24*(double)x);
        res -= 1.0;
        res = res / (double) 6;
        return (long) res;
    }

 public static final BigInteger MOD = BigInteger.valueOf(998244353L);

    static BigInteger fact(int x)
    {
        BigInteger res = BigInteger.ONE;
        for(int i=2;i<=x;i++)
        {
            res = res.multiply(BigInteger.valueOf(i)).mod(MOD);
        }
        return res;
    }

    public static long calc(int x,int y,int z)
    {
        long res = ((long) (x-y) * (long) (x-y)) + ((long) (z-y) * (long) (z-y)) + ((long) (x-z) * (long) (x-z));
        return res;
    }

    public static int upperBound(ArrayList<Integer>arr, int length, int value) {
        int low = 0;
        int high = length;
        while (low < high) {
            final int mid = (low + high) / 2;
            if (value >= arr.get(mid)) {
                low = mid + 1;
            } else {
                high = mid;
            }
        }
        return low;
    }

     public static int lowerBound(ArrayList<Integer> arr, int length, int value) {
        int low = 0;
        int high = length;
        while (low < high) {
            final int mid = (low + high) / 2;
            //checks if the value is less than middle element of the array
            if (value <= arr.get(mid)) {
                high = mid;
            } else {
                low = mid + 1;
            }
        }
        return low;
    }
    static HashMap<Long,Integer> map;

    static class Coin{
        long a;
        long b;

        Coin(long a, long b)
        {
            this.a = a;
            this.b = b;

        }
    }
    static ArrayList<Long> fac;
    static HashSet<Long> hs;
    public static void primeFactors(long n)
    {
        // Print the number of 2s that divide n
        while (n % 2 == 0) {
            fac.add(2l);
            hs.add(2l);
            n /= 2;
        }

        // n must be odd at this point.  So we can
        // skip one element (Note i = i +2)
        for (long i = 3; i*i <= n; i += 2) {
            // While i divides n, print i and divide n
            while (n % i == 0) {
                fac.add(i);
                hs.add(i);
                n /= i;
            }
        }

        // This condition is to handle the case whien
        // n is a prime number greater than 2
        if (n > 2)
            fac.add(n);
    }
   static int smallestDivisor(int n)
{
    // if divisible by 2
    if (n % 2 == 0)
        return 2;

    // iterate from 3 to sqrt(n)
    for (int i = 3; i * i <= n; i += 2) {
        if (n % i == 0)
            return i;
    }

    return n;
}
 static boolean IsP(String s,int l,int r)
 {
      while(l <= r)
      {
          if(s.charAt(l) != s.charAt(r))
          {
              return false;
          }
         l++;
         r--;
      }
      return true;
 }

 static class Student{
    int id;
    int val;
     Student(int id,int val)
     {
      this.id = id;
      this.val = val;
     }
 }

     static int upperBound(ArrayList<Integer> a, int low, int high, int element){
    while(low < high){
        int middle = low + (high - low)/2;
        if(a.get(middle) >= element)
            high = middle;
        else
            low = middle + 1;
    }
    return low;
}
   static long func(long t,long e,long h,long a, long b)
   {
       if(e*a >= t)
           return t/a;
       else
       {
           return e + Math.min(h,(t-e*a)/b);
       }
   }

    public static int countSetBits(int number){
        int count = 0;
        while(number>0){
            ++count;
            number &= number-1;
        }
        return count;
    }

     static long modexp(long x,long n,long M)
{
    long power = n;
    long result=1;
    x = x%M;
    while(power>0)
    {
        if(power % 2 ==1)
            result=(result * x)%M;
        x=(x*x)%M;
        power = power/2;
    }
    return result;
}
      static long modInverse(long A,long M)
{
    return modexp(A,M-2,M);
}
    static long gcd(long a,long b)
    {
        if(a==0)
            return b;
        else
            return gcd(b%a,a);
    }
    static class Temp{
        int a;
        int b;
        int c;
        int d;

        Temp(int a,int b,int c,int d)
        {
            this.a = a;
            this.b = b;
            this.c  =c;
            this.d = d;
            //this.d = d;
        }
    }

   static long sum1(int t1,int t2,int x,int []t)
   {
       int mid = (t2-t1+1)/2;
  if(t1==t2)
      return 0;

   else
   return sum1(t1,mid-1,x,t) + sum1(mid,t2,x,t);

   }

    static String replace(String s,int a,int n)
    {
        char []c = s.toCharArray();
        for(int i=1;i<n;i+=2)
        {
            int num = (int) (c[i] - 48);
            num += a;
            num%=10;
            c[i] = (char) (num+48);
        }
        return new String(c);
    }
    static String move(String s,int h,int n)
    {
        h%=n;
        char []c = s.toCharArray();
        char []temp = new char[n];
        for(int i=0;i<n;i++)
        {
            temp[(i+h)%n] = c[i];
        }
        return new String(temp);
    }

     public static int ip(String s){
return Integer.parseInt(s);
}
     static class multipliers implements Comparator<Long>{

  public int compare(Long a,Long b) {
   if(a<b)
    return 1;
   else if(b<a)
    return -1;
   else
    return 0;
  }
 }

     static class multipliers1 implements Comparator<Coin>{

  public int compare(Coin a,Coin b) {
   if(a.a < b.a)
       return 1;
   else if(a.a > b.a)
       return -1;
   else{
       if(a.b < b.b)
       return 1;
   else if(a.b > b.b)
       return -1;
       else
       return 0;
   }

     }
     }

// Java program to generate power set in
// lexicographic order.

      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 ni() {
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 nl() {
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[] nia(int n) {
int a[] = new int[n];
for (int i = 0; i < n; i++) {
a[i] = ni();
}
return a;
}

public String rs() {
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;
}

}

static PrintWriter w = new PrintWriter(System.out);
                  static class Student1
    {
        int id;
        //int x;

       int b;

        //long z;

        Student1(int id,int b)
        {
            this.id = id;
            //this.x = x;
            //this.s = s;
            this.b = b;

           // this.z = z;

        }

    }
}

import java.util.*;
public class E {

	static long mod = 998244353 ;
	public static void main(String[] args) {
		for(int i = 1; i <= N; i++) fac(i);
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int k = sc.nextInt();
		long res = 0;
		for(int i = 1; i <= n; i++) {
			int s = n/i - 1;
			res += choose(s, k-1); res %= mod;
		}
		System.out.println(res);
	}

	static int N = 500000;
	static long[] fac = new long[N+1];
	static long[] invfac = new long[N+1];
	static long fac(int n){
		if(n == 0) return fac[0] = 1;
		else if(fac[n] > 0) return fac[n];
		else return fac[n] = n * fac(n-1) % mod;
	}
	static long invfac(int n){
		if(invfac[n] > 0) return invfac[n];
		else return invfac[n] = inv(fac[n]);
	}
	static long choose(int n, int k){
		if(k > n) return 0;
		return fac(n) * invfac(k) % mod * invfac(n-k) % mod;
	}
	static long inv(long a){
		return (gcdex(a, mod).r + mod) % mod;
	}
	static Pair gcdex(long a, long b){
		if(b > a) return gcdex(b, a).invert();
		else if(b == 0) return new Pair(1, 0);
		else{
			Pair p = gcdex(b, a % b);
			return new Pair(p.s, p.r - p.s*(a/b));
		}
	}
	static class Pair{
		long r, s;
		public Pair(long r, long s){
			this.r = r; this.s = s;
		}
		public Pair invert(){
			return new Pair(s, r);
		}
		public String toString() {
			return r+" "+s;
		}
	}

}

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

public class Main implements Runnable {

    private boolean console=false;
    private long MOD = 998244353L;
    private int MAX = 1000_001;

    long[] fact = new long[MAX];

    void initFact(){

        fact[0] = 1L;
        for(int i=1;i<MAX;++i){
            fact[i] = (fact[i-1]*i)%MOD;
        }
    }

    long NCR(int n,int r){

        long deno = fact[r] * fact[n-r];

        return ( fact[n] * ModPow(deno,MOD-2,MOD) )%MOD;
    }

    private void solve1(){

        initFact();

        int n=in.ni(),k=in.ni();
        long ans=0;

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

            int num = n/i;
            if(num<k)
                continue;

            long temp = NCR(num-1,k-1);
            ans =  (ans+temp)%MOD;
        }

        out.println(ans);

    }

    private void solve() {
        int testCases = 1;
//        testCases = in.ni();
        while (testCases-->0){
            solve1();
        }
    }

    private void add(Map<Integer,Integer> map,int key){
        map.put(key,map.getOrDefault(key,0)+1);
    }

    private void remove(Map<Integer,Integer> map,int key){
        if(!map.containsKey(key))
            return;
        map.put(key,map.getOrDefault(key,0)-1);
        if(map.get(key)==0)
            map.remove(key);
    }

    @Override
    public void run() {
        long time = System.currentTimeMillis();
        try {
            init();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        try {
            solve();
            out.flush();
            System.err.println(System.currentTimeMillis()-time);
            System.exit(0);
        }catch (Exception e){
            e.printStackTrace(); System.exit(1);
        }
    }

    /* -------------------- Templates and Input Classes -------------------------------*/

    private FastInput in;
    private PrintWriter out;
    public static void main(String[] args) throws Exception {
        new Main().run();
//        new Thread(null, new Main(), "Main", 1 << 27).start();
    }
    private void init() throws FileNotFoundException {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        try {
            if (!console && System.getProperty("user.name").equals("puneet")) {
                outputStream = new FileOutputStream("/home/puneet/Desktop/output.txt");
                inputStream = new FileInputStream("/home/puneet/Desktop/input.txt");
            }
        } catch (Exception ignored) {
        }
        out = new PrintWriter(outputStream);
        in = new FastInput(inputStream);
    }
    private void maualAssert(int a,int b,int c){
        if(a<b || a>c) throw new RuntimeException();
    }
    private void maualAssert(long a,long b,long c){
        if(a<b || a>c) throw new RuntimeException();
    }
    private void sort(int[] arr) {
        List<Integer> list = new ArrayList<>();
        for (int object : arr) list.add(object);
        Collections.sort(list);
        for (int i = 0; i < list.size(); ++i) arr[i] = list.get(i);
    }
    private void sort(long[] arr) {
        List<Long> list = new ArrayList<>();
        for (long object : arr) list.add(object);
        Collections.sort(list);
        for (int i = 0; i < list.size(); ++i) arr[i] = list.get(i);
    }
    private long ModPow(long x, long y, long MOD) {
        long res = 1L;
        x = x % MOD;
        while (y >= 1L) {
            if ((y & 1L) > 0) res = (res * x) % MOD;
            x = (x * x) % MOD;
            y >>= 1L;
        }
        return res;
    }
    private int gcd(int a, int b) {
        if (a == 0) return b;
        return gcd(b % a, a);
    }
    private long gcd(long a, long b) {
        if (a == 0) return b;
        return gcd(b % a, a);
    }
    private int[] arrInt(int n){
        int[] arr=new int[n];for(int i=0;i<n;++i)arr[i]=in.ni();
        return arr;
    }
    private long[] arrLong(int n){
        long[] arr=new long[n];for(int i=0;i<n;++i)arr[i]=in.nl();
        return arr;
    }

    private int arrMax(int[] arr){
        int ans = arr[0];
        for(int i=1;i<arr.length;++i){
            ans = max(ans,arr[i]);
        }
        return ans;
    }

    private long arrMax(long[] arr){
        long ans = arr[0];
        for(int i=1;i<arr.length;++i){
            ans = max(ans,arr[i]);
        }
        return ans;
    }

    private int arrMin(int[] arr){
        int ans = arr[0];
        for(int i=1;i<arr.length;++i){
            ans = max(ans,arr[i]);
        }
        return ans;
    }

    private long arrMin(long[] arr){
        long ans = arr[0];
        for(int i=1;i<arr.length;++i){
            ans = max(ans,arr[i]);
        }
        return ans;
    }

    static class FastInput { InputStream obj;
        public FastInput(InputStream obj) {
            this.obj = obj;
        }
        private byte inbuffer[] = new byte[1024];
        private int lenbuffer = 0, ptrbuffer = 0;
        private 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++]; }
        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();}
        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(); }}
        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 * 10L + (b - '0'); } else {
                return minus ? -num : num; }b = readByte(); } }
        private 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(ns());}
        double nd() {return Double.parseDouble(ns());}
        char nc() {return (char) skip();}
    }

}

/*****Author: Satyajeet Singh************************************/
    import java.io.*;
    import java.util.*;
    import java.text.*;
    import java.lang.*;
    import java.math.*;
public class Main{
/*********************************************Constants******************************************/
    static PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static long mod=(long)1e9+7;
    static long mod1=998244353;
    static ArrayList<Integer> graph[];
    static int pptr=0,pptrmax=0;
    static String st[];
/*****************************************Solution Begins***************************************/
    static long factorial[],invFactorial[];
    static void fact(int n){
        factorial=new long[n+1];
        invFactorial=new long [n+1];
        factorial[0]=1l;
        invFactorial[0]=1l;
        for(int i=1;i<=n;i++){
            factorial[i]=(factorial[i-1]*i)%mod;
            invFactorial[i]=modulo(factorial[i],mod-2,mod);
        }
    }
    static long ncr(long n,long k){
        if(k>n)return 0l;
        long ans=0;
        if(n<mod){
            long aa=invFactorial[(int)(n-k)];
            long bb=invFactorial[(int)k];
            long cc=factorial[(int)n];
            ans=(aa*cc)%mod;
            ans=(ans*bb)%mod;
        }
        else{
            ArrayList<Long> K=new ArrayList<>();
            ArrayList<Long> N=new ArrayList<>();
            while(n>0){
                N.add(n%mod);
                n/=mod;
            }
            while(k>0){
                K.add(k%mod);
                k/=mod;
            }
            ans=1;
            for(int i=0;i<K.size();i++)
                ans=(ans*ncr(N.get(i),K.get(i)))%mod;
        }
        return ans;
    }
    static long npr(long n,long k){
        if(k>n)return 0l;
        long ans=0;
        long aa=invFactorial[(int)(n-k)];
        long cc=factorial[(int)n];
        ans=(cc*aa)%mod;
        return ans;
    }
    public static void main(String args[]) throws Exception{
        int n=pi();
        int k=pi();
        mod=mod1;
        fact(n+10);
        long ans=0;
        for(int i=1;i<=n;i++){
            ans+=ncr(n/i-1,k-1);
            if(ans>=mod)ans-=mod;
        }
        out.println(ans);
/****************************************Solution Ends**************************************************/
        clr();
    }
    static void clr(){
        out.flush();
        out.close();
    }
    static void nl() throws Exception{
        pptr=0;
        st=br.readLine().split(" ");
        pptrmax=st.length;
    }
    static void nls() throws Exception{
        pptr=0;
        st=br.readLine().split("");
        pptrmax=st.length;
    }
    static int pi() throws Exception{
        if(pptr==pptrmax)
            nl();
        return Integer.parseInt(st[pptr++]);
    }
    static long pl() throws Exception{
        if(pptr==pptrmax)
            nl();
        return Long.parseLong(st[pptr++]);
    }
    static double pd() throws Exception{
        if(pptr==pptrmax)
            nl();
        return Double.parseDouble(st[pptr++]);
    }
    static String ps() throws Exception{
        if(pptr==pptrmax)
            nl();
        return st[pptr++];
    }
/***************************************Precision Printing**********************************************/
    static void printPrecision(double d){
        DecimalFormat ft = new DecimalFormat("0.00000000000");
        out.println(ft.format(d));
    }
/**************************************Bit Manipulation**************************************************/
    static int countBit(long mask){
        int ans=0;
        while(mask!=0){
            mask&=(mask-1);
            ans++;
        }
        return ans;
    }
/******************************************Graph*********************************************************/
    static void Makegraph(int n){
        graph=new ArrayList[n];
        for(int i=0;i<n;i++)
            graph[i]=new ArrayList<>();
    }
    static void addEdge(int a,int b){
        graph[a].add(b);
    }
    // static void addEdge(int a,int b,int c){
    //     graph[a].add(new Pair(b,c));
    // }
/*********************************************PAIR********************************************************/
    static class Pair{
        int u;
        int v;
        public Pair(int u, int v) {
            this.u = u;
            this.v = v;
        }
        public int hashCode() {
            int hu = (int) (u ^ (u >>> 32));
            int hv = (int) (v ^ (v >>> 32));
            return 31 * hu + hv;
        }
        public boolean equals(Object o) {
            Pair other = (Pair) o;
            return u == other.u && v == other.v;
        }
        public String toString() {
            return "[u=" + u + ", v=" + v + "]";
        }
    }
/******************************************Long Pair*******************************************************/
    static class Pairl{
        long u;
        long v;
        public Pairl(long u, long v) {
            this.u = u;
            this.v = v;
        }
        public int hashCode() {
            int hu = (int) (u ^ (u >>> 32));
            int hv = (int) (v ^ (v >>> 32));
            return 31 * hu + hv;
        }
        public boolean equals(Object o) {
            Pairl other = (Pairl) o;
            return u == other.u && v == other.v;
        }
        public String toString() {
            return "[u=" + u + ", v=" + v + "]";
        }
    }
/*****************************************DEBUG***********************************************************/
    public static void debug(Object... o){
        System.out.println(Arrays.deepToString(o));
    }
/************************************MODULAR EXPONENTIATION***********************************************/
    static long modulo(long a,long b,long c){
        long x=1,y=a%c;
        while(b > 0){
            if(b%2 == 1)
                x=(x*y)%c;
            y = (y*y)%c;
            b = b>>1;
        }
        return  x%c;
    }
/********************************************GCD**********************************************************/
    static long gcd(long x, long y){
        if(x==0)
            return y;
        if(y==0)
            return x;
        long r=0, a, b;
        a = (x > y) ? x : y;
        b = (x < y) ? x : y;
        r = b;
        while(a % b != 0){
            r = a % b;
            a = b;
            b = r;
        }
        return r;
    }
}

import java.util.Scanner;

public class er88e {
	public static void main(String[] args) {
		Scanner scan=new Scanner(System.in);
		int n=scan.nextInt(), k=scan.nextInt();
		/*
			an array is stable if all the other elements
			are divisible by the minimum element

			because if we mod by the min element
			nothing else matters
			and if we mod by another element
			it must subtract out only multiples of the min element
			so the answer does not change

			we iterate through all the min elements
			and calculate the answer
		 */

		fac=new long[500001];
		invfac=new long[500001];
		fac[0]=invfac[0]=1;

		for(int i=1;i<fac.length;i++) {
			fac[i]=mult(fac[i-1],i);
			invfac[i]=pow(fac[i],MOD-2);
		}
		long res=0L;
		for(int minelem=1;minelem<=n;minelem++) {
			res=add(res,choose(n/minelem-1,k-1));
		}
		System.out.println(res);
	}
	static final int MOD=998244353;
	static long[] fac,invfac;

	public static long choose(int n, int k) {
		if(n<0||k<0) return 0L;
		if(k==0) return 1L;
		if(n<k) return 0L;

		long den=mult(invfac[k],invfac[n-k]);
		return mult(fac[n],den);
	}
	public static long pow(long b, long e) {
		if(e==0L) return 1L;
		if(e%2==0) {
			long temp=pow(b,e/2);
			return mult(temp,temp);
		}
		return mult(b,pow(b,e-1));
	}
	public static long mult(long a, long b) {
		return ((a%MOD)*(b%MOD))%MOD;
	}
	public static long add(long a, long b) {
		return ((a%MOD)+(b%MOD))%MOD;
	}
}

import java.util.Scanner;

public class er88e {
	public static void main(String[] args) {
		Scanner scan=new Scanner(System.in);
		int n=scan.nextInt(), k=scan.nextInt();
		/*
			an array is stable if all the other elements
			are divisible by the minimum element

			because if we mod by the min element
			nothing else matters
			and if we mod by another element
			it must subtract out only multiples of the min element
			so the answer does not change

			we iterate through all the min elements
			and calculate the answer
		*/

		fac=new long[500001];
		invfac=new long[500001];
		fac[0]=invfac[0]=1;

		for(int i=1;i<fac.length;i++) {
			fac[i]=mult(fac[i-1],i);
			invfac[i]=pow(fac[i],MOD-2);
		}
		long res=0L;
		for(int minelem=1;minelem<=n;minelem++) {
			if(minelem==1) {
				res=add(res,choose(n-minelem,k-1));
			}
			else {
				res=add(res,choose(n/minelem-1,k-1));
			}
//			System.out.println(minelem+" "+res);
		}
		System.out.println(res);
	}
	static final int MOD=998244353;
	static long[] fac,invfac;

	public static long choose(int n, int k) {
		if(n<0||k<0) return 0L;
		if(k==0) return 1L;
		if(n<k) return 0L;

		long den=mult(invfac[k],invfac[n-k]);
		return mult(fac[n],den);
	}
	public static long pow(long b, long e) {
		if(e==0L) return 1L;
		if(e%2==0) {
			long temp=pow(b,e/2);
			return mult(temp,temp);
		}
		return mult(b,pow(b,e-1));
	}
	public static long mult(long a, long b) {
		return ((a%MOD)*(b%MOD))%MOD;
	}
	public static long add(long a, long b) {
		return ((a%MOD)+(b%MOD))%MOD;
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.StringTokenizer;

public class E {

	static long mod=998244353;
	static long[] facts=new long[1_000_000];
	static long[] factsInv=new long[1_000_000];

	public static void main(String[] args) {
		precomp();
//		for (int i=0; i<n10; i++) {
//			System.out.println(i+" "+facts[i]);
//		}
		FastScanner fs=new FastScanner();
		int n=fs.nextInt(), k=fs.nextInt();
		if (n<k) {
			System.out.println(0);
			return;
		}
		long ans=0;
		for (int min=1; min<=n; min++) {
			int size=n/min;
			if (size<k) continue;
			ans+=nCk(size-1, k-1);
			ans%=mod;
		}
		System.out.println(ans);
	}

	static void precomp() {
		facts[0]=1;
		for (int i=1; i<facts.length; i++) facts[i]=mul(facts[i-1], i);
		factsInv[factsInv.length-1]=inv(facts[facts.length-1]);
		for (int i=factsInv.length-2; i>=0; i--)
			factsInv[i]=mul(factsInv[i+1], i+1);
	}

	static long nCk(int n, int k) {
		return mul(facts[n], mul(factsInv[k], factsInv[n-k]));
	}

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

	static long pow(long base, long e) {
		if (e==0) return 1;
		long half=pow(base, e/2);
		if (e%2==0) return mul(half, half);
		return mul(half, mul(base, half));
	}

	static long inv(long x) {
		return pow(x, mod-2);
	}

	static void sort(int[] a) {
		ArrayList<Integer> l=new ArrayList<>();
		for (int i:a) l.add(i);
		Collections.sort(l);
		for (int i=0; i<a.length; i++) a[i]=l.get(i);
	}

	static class FastScanner {
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st=new StringTokenizer("");
		String next() {
			while (!st.hasMoreTokens())
				try {
					st=new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			return st.nextToken();
		}

		int nextInt() {
			return Integer.parseInt(next());
		}
		int[] readArray(int n) {
			int[] a=new int[n];
			for (int i=0; i<n; i++) a[i]=nextInt();
			return a;
		}
		long nextLong() {
			return Long.parseLong(next());
		}
	}

}

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.math.BigInteger;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author sumit
 */
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);
            EModularStability solver = new EModularStability();
            solver.solve(1, in, out);
            out.close();
      }

      static class EModularStability {
            long mod = 998244353;

            long modInverse(long xx) {
                  BigInteger bg = new BigInteger(xx + "");
                  long val = Long.parseLong(bg.modInverse(new BigInteger(mod + "")).toString());
                  return val;
            }

            void fill(long[] fact) {
                  fact[0] = 1;
                  for (int i = 1; i < fact.length; i++) {
                        fact[i] = (fact[i - 1] * i) % mod;
                  }
            }

            public void solve(int testNumber, InputReader in, OutputWriter out) {
                  int n = in.nextInt();
                  int k = in.nextInt();
                  long[] fact = new long[n + 1];
                  fill(fact);
                  if (n < k) {
                        out.printLine(0);
                        return;
                  }
                  long ans = 0;
                  for (int i = 1; (n - i + 1) >= k; i++) {
                        int div = n / i - 1;
                        if (div >= k - 1) {
                              long aa = (((fact[div] * modInverse(fact[div - k + 1])) % mod) * modInverse(fact[k - 1])) % mod;
                              ans = (ans + aa) % mod;
                        }
                  }
                  out.printLine(ans);
            }

      }

      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 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 & 15;

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

                  return res * sgn;
            }

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

      }

      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 close() {
                  writer.close();
            }

            public void printLine(long i) {
                  writer.println(i);
            }

            public void printLine(int i) {
                  writer.println(i);
            }

      }
}

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

	public static void main(String[] args) throws Exception{
		int num = 998244353;

		// TODO Auto-generated method stub
 		BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
 		PrintWriter out = new PrintWriter(System.out);
 		StringTokenizer st = new StringTokenizer(bf.readLine());
 		int n = Integer.parseInt(st.nextToken());
 		int k = Integer.parseInt(st.nextToken());
 		if (k == 1)
 			out.println(n);
 		else{
	 		long[] fact = new long[n+1];
	 		fact[0] = 1;
	 		long ans1 = 1;
	 		for(int i = 1;i<=n;i++){
	 			ans1= (ans1*i) % num;
	 			fact[i] = ans1;
	 		}
	 		long[] inv = new long[n+1];
	 		inv[0] = 1;
	 		for(int i = 1;i<=n;i++){
	 			inv[i] = power(fact[i], num-2, num)%num;
	 		}

	 		long answer = 0;
	 		for (int i=1;i<=n;i++){
	 			int t = Math.floorDiv(n, i)-1;
	 			if (t >= (k-1)){
	 				long add = (fact[t]*inv[k-1])%num;
	 				add= (add*inv[t-k+1])%num;
	 				answer+= add;
	 				answer%= num;

	 			}

	 		}
	 		out.println(answer);
 		}
 		out.close();

 	}
	public static int power(long x, long y, long mod){
		long ans = 1;
		while(y>0){
			if (y%2==1)
				ans = (ans*x)%mod;
			x = (x*x)%mod;
			y/=2;
		}
		return (int)(ans);
	}
	public static ArrayList<Integer> sieveOfEratosthenes(int n){
		ArrayList<Integer> answer = new ArrayList<Integer>();
        boolean prime[] = new boolean[n+1];
        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*p; i <= n; i += p)
                    prime[i] = false;
            }
        }
        answer.add(1);
        for(int i = 2; i <= n; i++){
            if(prime[i] == true)
                answer.add(i);
        }
        return answer;
    }
}

//StringJoiner sj = new StringJoiner(" ");
//sj.add(strings)
//sj.toString() gives string of those stuff w spaces or whatever that sequence is

// Utilities
import java.io.*;
import java.util.*;

public class Main {
	static int N, K;
	static long[] fac;
	static long res = 0;
	static final int MOD = 998244353;

	public static void main(String[] args) throws IOException {
		N = in.iscan(); K = in.iscan(); fac = new long[N+1]; fac[0] = 1;
		for (int i = 1; i <= N; i++) fac[i] = fac[i-1] * i % MOD;
		for (int i = 1; i <= N; i++) {
			res = (res + choose(N/i-1, K-1)) % MOD;
		}
		out.println(res);
		out.close();
	}

	static long choose(int n, int k) {
		if (k > n) return 0;
		long a = fac[n];
		long b = fac[k] * fac[n-k] % MOD;
		// b ^ prime-1 = 1 -> b ^ 998244352 = 1 -> b * (b ^ 998244351) = 1
		// -> Mod_inv = b ^ 998244351
		return a * UTILITIES.fast_pow_mod(b, MOD-2, MOD) % MOD;
	}

	static INPUT in = new INPUT(System.in);
	static PrintWriter out = new PrintWriter(System.out);
	private static class INPUT {

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

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

		public INPUT (String file) throws IOException {
			this.stream = new FileInputStream (file);
		}

		public int cscan () throws IOException {
			if (curChar >= numChars) {
				curChar = 0;
				numChars = stream.read (buf);
			}

			if (numChars == -1)
				return numChars;

			return buf[curChar++];
		}

		public int iscan () throws IOException {
			int c = cscan (), sgn = 1;

			while (space (c))
				c = cscan ();

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

			int res = 0;

			do {
				res = (res << 1) + (res << 3);
				res += c - '0';
				c = cscan ();
			}
			while (!space (c));

			return res * sgn;
		}

		public String sscan () throws IOException {
			int c = cscan ();

			while (space (c))
				c = cscan ();

			StringBuilder res = new StringBuilder ();

			do {
				res.appendCodePoint (c);
				c = cscan ();
			}
			while (!space (c));

			return res.toString ();
		}

		public double dscan () throws IOException {
			int c = cscan (), sgn = 1;

			while (space (c))
				c = cscan ();

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

			double res = 0;

			while (!space (c) && c != '.') {
				if (c == 'e' || c == 'E')
					return res * UTILITIES.fast_pow (10, iscan ());

				res *= 10;
				res += c - '0';
				c = cscan ();
			}

			if (c == '.') {
				c = cscan ();
				double m = 1;

				while (!space (c)) {
					if (c == 'e' || c == 'E')
						return res * UTILITIES.fast_pow (10, iscan ());

					m /= 10;
					res += (c - '0') * m;
					c = cscan ();
				}
			}

			return res * sgn;
		}

		public long lscan () throws IOException {
			int c = cscan (), sgn = 1;

			while (space (c))
				c = cscan ();

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

			long res = 0;

			do {
				res = (res << 1) + (res << 3);
				res += c - '0';
				c = cscan ();
			}
			while (!space (c));

			return res * sgn;
		}

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

	public static class UTILITIES {

		static final double EPS = 10e-6;

		public static int lower_bound (int[] arr, int x) {
			int low = 0, high = arr.length, mid = -1;

			while (low < high) {
				mid = (low + high) / 2;

				if (arr[mid] >= x)
					high = mid;
				else
					low = mid + 1;
			}

			return low;
		}

		public static int upper_bound (int[] arr, int x) {
			int low = 0, high = arr.length, mid = -1;

			while (low < high) {
				mid = (low + high) / 2;

				if (arr[mid] > x)
					high = mid;
				else
					low = mid + 1;
			}

			return low;
		}

		public static long gcd (long a, long b) {
			return b == 0 ? a : gcd (b, a % b);
		}

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

		public static long fast_pow_mod (long b, long x, int mod) {
			if (x == 0) return 1;
			if (x == 1) return b;
			if (x % 2 == 0) return fast_pow_mod (b * b % mod, x / 2, mod) % mod;

			return b * fast_pow_mod (b * b % mod, x / 2, mod) % mod;
		}

		public static int fast_pow (int b, int x) {
			if (x == 0) return 1;
			if (x == 1) return b;
			if (x % 2 == 0) return fast_pow (b * b, x / 2);

			return b * fast_pow (b * b, x / 2);
		}

		public static long choose (long n, long k) {
			k = Math.min (k, n - k);
			long val = 1;

			for (int i = 0; i < k; ++i)
				val = val * (n - i) / (i + 1);

			return val;
		}

		public static long permute (int n, int k) {
			if (n < k) return 0;
			long val = 1;

			for (int i = 0; i < k; ++i)
				val = (val * (n - i));

			return val;
		}
	}
}

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

public class Main {
//    public static final Random rd = new Random(System.currentTimeMillis() * ThreadLocalRandom.current().nextInt());
//    private static final boolean oj = System.getProperty("ONLINE_JUDGE") != null;

    final static int mod = 998244353;
    public static long[] fact;

    public static void main(String[] args) throws Exception {
        ScanReader in = new ScanReader(System.in);
        PrintWriter out = new PrintWriter(System.out);
//        long start = System.currentTimeMillis();
        int query = 1;

        fact = new long[1000005];
        fact[0] = 1;
        for (int i = 1; i <= 1000000; i++) fact[i] = fact[i - 1] * i % mod;
        out:
        for (int test = 1; test <= query; test++) {
            int n = in.scanInt();
            int k = in.scanInt();
            long ans = 0;
            for (int i = 1; i <= n; i++) {
                int rem = (n / i) - 1;
                ans = (ans + findIt(rem, k - 1)) % mod;
            }
            out.println(ans);
        }
        long end = System.currentTimeMillis();
//        if (!oj) out.println(end - start);
        out.close();
    }

    public static long findIt(int a, int b) {
        if (b > a) return 0;
        return fact[a] * pow(fact[b] * fact[a - b], mod - 2, mod) % mod;
    }

    public static long pow(long a, long b, long m) {
        long res = 1;
        a %= m;
        while (b > 0) {
            if ((b & 1) == 1) res = (res * a) % m;
            a = (a * a) % m;
            b >>= 1;
        }
        return res;
    }

}

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

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

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

    public char scanChar() throws IOException {
        int c = scan();
        while (isWhiteSpace(c)) c = scan();
        return (char) c;
    }

    public int scanInt() throws IOException {
        int 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;
    }

    public String scanString() throws IOException {
        int c = scan();
        while (isWhiteSpace(c)) c = scan();
        StringBuilder res = new StringBuilder();
        do {
            res.appendCodePoint(c);
            c = scan();
        } while (!isWhiteSpace(c));
        return res.toString();
    }

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

    public long scanLong() throws IOException {
        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;
    }

    public void scanLong(long[] A) throws IOException {
        for (int i = 0; i < A.length; i++) A[i] = scanLong();
    }

    public void scanInt(int[] A) throws IOException {
        for (int i = 0; i < A.length; i++) A[i] = scanInt();
    }

    public double scanDouble() throws IOException {
        int c = scan();
        while (isWhiteSpace(c)) c = scan();
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = scan();
        }
        double res = 0;
        while (!isWhiteSpace(c) && c != '.') {
            if (c == 'e' || c == 'E') {
                return res * Math.pow(10, scanInt());
            }
            res *= 10;
            res += c - '0';
            c = scan();
        }
        if (c == '.') {
            c = scan();
            double m = 1;
            while (!isWhiteSpace(c)) {
                if (c == 'e' || c == 'E') {
                    return res * Math.pow(10, scanInt());
                }
                m /= 10;
                res += (c - '0') * m;
                c = scan();
            }
        }
        return res * sgn;
    }

}

/*
If you want to aim high, aim high
Don't let that studying and grades consume you
Just live life young
******************************
What do you think? What do you think?
1st on Billboard, what do you think of it
Next is a Grammy, what do you think of it
However you think, I’m sorry, but shit, I have no fucking interest
*******************************
Higher, higher, even higher, to the point you won’t even be able to see me
https://www.a2oj.com/Ladder16.html
*******************************
NEVER DO 300IQ CONTESTS EVER
300IQ AS WRITER = EXTRA NONO
*/
import java.util.*;
import java.io.*;
import java.math.*;

   public class E
   {
      static long MOD = 998244353L;
      public static void main(String omkar[]) throws Exception
      {
         BufferedReader infile = new BufferedReader(new InputStreamReader(System.in));
         StringTokenizer st = new StringTokenizer(infile.readLine());
         int N = Integer.parseInt(st.nextToken());
         int K = Integer.parseInt(st.nextToken());
         fac = new long[500001];
         invfac = new long[500001];
         fac[0] = invfac[0] = 1L;
         for(int i=1; i <= 500000; i++)
         {
            fac[i] = (fac[i-1]*i)%MOD;
            invfac[i] = power(fac[i], MOD-2, MOD);
         }
         long res = 0L;
         for(int i=1; i <= N; i++)
         {
            int total = N/i;
            total--;
            if(K-1 <= total)
            {
               res += nCr(total, K-1);
               res %= MOD;
            }
         }
         System.out.println(res);
      }
      static long[] fac;
      static long[] invfac;
      public static long nCr(int large, int small)
      {
         long res = (fac[large]*invfac[large-small])%MOD;
         return (res*invfac[small])%MOD;
      }
      public static long power(long x, long y, long p)
      {
          long res = 1L;
          x = x % p;
          while (y > 0)
          {
              if((y & 1)==1)
                  res = (res * x) % p;
              y = y >> 1;
              x = (x * x) % p;
          }
          return res;
      }
   }

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

public class Main {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw = new PrintWriter(System.out);
    static int MOD = 998244353;

    public static void main(String[] args) throws IOException {
        Main m = new Main();
        m.solve();
        m.close();
    }

    void close() throws IOException {
        pw.flush();
        pw.close();
        br.close();
    }

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

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

    int[] readIntLine() throws IOException {
        String[] tokens = br.readLine().split(" ");
        int[] A = new int[tokens.length];
        for (int i = 0; i < A.length; i++)
            A[i] = Integer.parseInt(tokens[i]);
        return A;
    }

    long[] readLongLine() throws IOException {
        String[] tokens = br.readLine().split(" ");
        long[] A = new long[tokens.length];
        for (int i = 0; i < A.length; i++)
            A[i] = Long.parseLong(tokens[i]);
        return A;
    }

    void solve() throws IOException {
        int[] nk = readIntLine();
        int n = nk[0];
        int k = nk[1];
        if (k > n) {
            pw.println(0);
            return;
        }
        long[] f = new long[n+1];
        f[0] = 1;
        for (int i = 1; i <= n; i++) {
            f[i] = f[i-1] * i % MOD;
        }
        long ans = 0;
        long modInvKf = modInverseGcd(f[k-1], MOD);
        for (int i = 1; i <= n && n / i >= k; i++) {
            long add = f[n / i - 1] * modInvKf % MOD * modInverseGcd(f[n / i - k], MOD) % MOD;
            ans = (ans + add) % MOD;
        }
        pw.println(ans);
    }

    public static long modInverseGcd(long a, long m) {
        if (m == 1) return 0;

        long m0 = m;
        long y = 0;
        long x = 1;
        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;
    }
}

import java.io.*;
import java.util.Random;
import java.util.StringTokenizer;

public class F {
    //Solution by Sathvik Kuthuru
    public static void main(String[] args) {
        FastReader scan = new FastReader();
        PrintWriter out = new PrintWriter(System.out);
        Task solver = new Task();
        int t = 1;
        for(int tt = 1; tt <= t; tt++) solver.solve(tt, scan, out);
        out.close();
    }

    static class Task {
        static int MOD = 998244353;
        static int max = (int) (1e6);
        static long[] fact = new long[max+1], invFact = new long[max+1], naturalInverse = new long[max+1];

        public void solve(int testNumber, FastReader scan, PrintWriter out) {
            int n = scan.nextInt(), k = scan.nextInt();
            fact[0] = invFact[0] = invFact[1] = naturalInverse[0] = naturalInverse[1] = 1;
            for(int i = 1; i <= max; i++) {
                fact[i] = (fact[i-1]*i)%MOD;
                if(i == 1) continue;
                naturalInverse[i] = naturalInverse[MOD % i] * (MOD - MOD/i) % MOD;
                invFact[i] = (invFact[i-1]*naturalInverse[i])%MOD;
            }
            long ans = 0;
            for(int i = 1; i <= n; i++) {
                int have = n / i - 1;
                if(have >= k - 1) {
                    ans += binomial(have, k - 1);
                    ans %= MOD;
                }
            }
            out.println(ans);
        }

        static long binomial(int a, int b) {
            return ((fact[a]*invFact[b])%MOD*invFact[a-b])%MOD;
        }

        long pow(long a, long b) {
            if(b == 0) return 1;
            if(b == 1) return a;
            long res = pow(a, b / 2) % MOD;
            res = (res * res) % MOD;
            if(b % 2 == 1) res = (res * a) % MOD;
            return res;
        }

    }

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

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

    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

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

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

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

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

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

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

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

}

/*
Keep solving problems.
*/

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

public class CFA {
    BufferedReader br;
    PrintWriter out;
    StringTokenizer st;
    boolean eof;
    private static final long MOD = 998244353L;
    private static final int[] dx1 = {0, 1};
    private static final int[] dy1 = {1, 0};
    private static final int[] dx2 = {-1, 0};
    private static final int[] dy2 = {0, -1};
    private static final String yes = "Yes";
    private static final String no = "No";

    int LIMIT = 1000 * 100 * 5 + 100;
//    int LIMIT = 100;
    long[] inv;
    long[] fact;
    void solve() throws IOException {
        int n = nextInt();
        int k = nextInt();
        inv = new long[LIMIT];
        fact = new long[LIMIT];
        fact[0] = 1;
        for (int i = 1; i < LIMIT; i++) {
            fact[i] = fact[i - 1] * i % MOD;
        }
        inv[LIMIT - 1] = powMod(fact[LIMIT - 1], MOD - 2, MOD);
        for (int i = LIMIT - 2; i >= 0; i--) {
            inv[i] = inv[i + 1] * (i + 1) % MOD;
        }
        long res = 0;
        for (int i = 1; i <= n; i++) {
            int cnt = n / i;
            int need = k - 1;
            if (cnt - 1 >= need) {
                res += comb(cnt - 1, need);
                if (res >= MOD) {
                    res -= MOD;
                }
            }
        }
        outln(res % MOD);
    }

    // Power Calculate N^M % MOD, N and M can be long (up to 2^64, ~10^18)
    public long powMod(long N, long M, long MOD){//N^M % MOD
        if(M == 0L)
            return 1L;
        long[] hp = new long[64];
        boolean[] bp = new boolean[64];
        hp[0] = N;
        for(int i = 1; i < hp.length; i++) {
            hp[i] = (hp[i - 1] * hp[i - 1]) % MOD;
        }
        for(int j = 0; j < hp.length; j++) {
            if((M & (1L << j)) != 0)
                bp[j] = true;
        }
        long res = 1;
        for(int i = 0;i < bp.length; i++){
            if(bp[i]) {
                res = (res * hp[i]) % MOD;
            }
        }
        return res;
    }

    long comb(int n, int k) {
        long res = fact[n] * inv[k] % MOD;
        res = res * inv[n - k] % MOD;
        return res;
    }

    void shuffle(long[] a) {
        int n = a.length;
        for(int i = 0; i < n; i++) {
            int r = i + (int) (Math.random() * (n - i));
            long tmp = a[i];
            a[i] = a[r];
            a[r] = tmp;
        }
    }
    long gcd(long a, long b) {
        while(a != 0 && b != 0) {
            long c = b;
            b = a % b;
            a = c;
        }
        return a + b;
    }
    private void outln(Object o) {
        out.println(o);
    }
    private void out(Object o) {
        out.print(o);
    }
    private void formatPrint(double val) {
        outln(String.format("%.9f%n", val));
    }
    public CFA() throws IOException {
        br = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(System.out);
        solve();
        out.close();
    }
    public static void main(String[] args) throws IOException {
        new CFA();
    }

    public long[] nextLongArr(int n) throws IOException{
        long[] res = new long[n];
        for(int i = 0; i < n; i++)
            res[i] = nextLong();
        return res;
    }
    public int[] nextIntArr(int n) throws IOException {
        int[] res = new int[n];
        for(int i = 0; i < n; i++)
            res[i] = nextInt();
        return res;
    }
    public String nextToken() {
        while (st == null || !st.hasMoreTokens()) {
            try {
                st = new StringTokenizer(br.readLine());
            } catch (Exception e) {
                eof = true;
                return null;
            }
        }
        return st.nextToken();
    }
    public String nextString() {
        try {
            return br.readLine();
        } catch (IOException e) {
            eof = true;
            return null;
        }
    }
    public int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }
    public long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }
    public double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }
}

import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.io.*;
import java.math.*;
public class Main7{
	static public void main(String args[])throws IOException{
		int tt=1;
		StringBuilder sb=new StringBuilder();
		for(int ttt=1;ttt<=tt;ttt++){
			n=i();
			k=i();
			if(n<k){
				sb.append("0\n");
			}else{
				long[] fact=new long[n+1];
				fact[0]=1;
				long ans=1;
				for(int i=1;i<=n;i++){
					ans=(ans*i)%mod;
					fact[i]=ans;
				}
				long[] inv=new long[n+1];
				for(int i=0;i<=n;i++){
					inv[i]=pow(fact[i],mod-2);
				}
				long tmp=pow((fact[n-k]),mod-2);
				long tmp1=pow((fact[k-1]),mod-2);
				long ans1=(fact[n-1]*tmp)%mod;
				ans1=(ans1*tmp1)%mod;
				for(int i=2;i<=n;i++){
					int count=n/i;
					count--;
					if(count>=k-1){
						long pp=fact[count];
						pp=(pp*inv[k-1])%mod;
						pp=(pp*inv[count-k+1])%mod;
						ans1=(ans1+pp)%mod;//countCk-1;
					}
				}
				sb.append((ans1)+"\n");
			}
		}
		System.out.print(sb.toString());
	}
	static int n,k;
	static InputReader in=new InputReader(System.in);
	static OutputWriter out=new OutputWriter(System.out);
	static ArrayList<ArrayList<Integer>> graph;
	static int mod=998244353;
	static class Pair{
		int x;
		int y;
		Pair(int x,int y){
			this.x=x;
			this.y=y;
		}
		@Override
            public int hashCode()
            {
                final int temp = 14;
                int ans = 1;
                ans =x*31+y*13;
                return ans;
            }
       @Override
        public boolean equals(Object o)
        {
            if (this == o) {
                return true;
            }
            if (o == null) {
                return false;
            }
            if (this.getClass() != o.getClass()) {
                return false;
            }
            Pair other = (Pair)o;
            if (this.x != other.x || this.y!=other.y) {
                return false;
            }
            return true;
        }
	}
	public static int[] sort(int[] a){
		int n=a.length;
		ArrayList<Integer> ar=new ArrayList<>();
		for(int i=0;i<a.length;i++){
			ar.add(a[i]);
		}
		Collections.sort(ar);
		for(int i=0;i<n;i++){
			a[i]=ar.get(i);
		}
		return a;
	}
	public static long pow(long a, long b){
        long result=1;
        while(b>0){
            if (b % 2 != 0){
                result=(result*a)%mod;
                b--;
            }
            a=(a*a)%mod;
            b /= 2;
        }
        return result;
    }
	public static long gcd(long a, long b){
        if (a == 0){
            return b;
		}
        return gcd(b%a, a);
    }
	public static long lcm(long a, long b){
		return a*(b/gcd(a,b));
	}
	public static long l(){
		String s=in.String();
		return Long.parseLong(s);
	}
	public static void pln(String value){
		System.out.println(value);
	}
	public static int i(){
		return in.Int();
	}
	public static String s(){
		return in.String();
	}
}
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 int Int() {
		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 String() {
		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 String();
	}
	public interface SpaceCharFilter {
		public boolean isSpaceChar(int ch);
	}
}
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 printLine(Object...objects) {
		print(objects);
		writer.println();
	}
	public void close() {
		writer.close();
	}
	public void flush() {
		writer.flush();
	}
 }
class IOUtils {
	public static int[] readIntArray(InputReader in, int size) {
		int[] array = new int[size];
		for (int i = 0; i < size; i++)
			array[i] = in.Int();
		return array;
	}
}

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

public class Main {
    static PrintWriter out = new PrintWriter(System.out);
    static Scanner sc = new Scanner(System.in);
    static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    long mod = 998244353;
    long[] frac, inv;
    public static void main(String[] args) throws IOException {
        Main main = new Main();
//        main.solve();
        out.println(main.solve());
        out.flush();
    }
    long solve() throws IOException {
        int n = sc.nextInt(), k = sc.nextInt();
        if(k>n) return 0;
        if(k==1) return n;
        ini(n);
        long[] dp = new long[n+1];
        // dp[i]: a[1]=1, a[k]<=i, how many sequences a[1]<a[2]<...<a[k]
        dp[k] = 1;
        for(int hi = k+1; hi<=n; hi++){
            int diff = hi-k;
            // k-1 slots + diff balls
            if(k==2) dp[hi] = (dp[hi-1]+1)%mod;
            else{
                long cur = comb(k-2+diff,diff);
                dp[hi] = (dp[hi-1]+cur)%mod;
            }
        }
        long ans = 0;
        // can be sure that k>=2
        for(int i=1;i<=n/(k-1);i++){
            int hi = n/i; // maximum a_k that can be achieved
            ans += dp[hi];
            ans %= mod;
        }
        return ans;
    }
    long comb(int n, int m){
        if(n<m) return 0;
        return frac[n]*inv[m]%mod*inv[n-m]%mod;
    }
    void ini(int n){
        frac = new long[n+1]; inv = new long[n+1];
        frac[0] = 1;
        for(int i=1; i<=n; i++) frac[i] = frac[i-1]*i%mod;
        inv[0] = 1;
        inv[n] = power(frac[n],mod-2);
        for(int i=n-1; i>0; i--) inv[i] = (i+1)*inv[i+1]%mod;
    }
    long power(long base, long p){
        long ans = 1;
        while(p>0){
            if(p%2==1) ans = ans*base%mod;
            base= base*base%mod;
            p /= 2;
        }
        return ans;
    }
}

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

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

        pair(int i, int j) {
            x = i;
            y = j;

        }
        public int compareTo(pair p) {
            if (this.x != p.x) {
                return this.x - p.x;
            } else {
                return this.y - p.y;
            }
        }
        public int hashCode() {
            return (x + " " + y).hashCode();
        }
        public String toString() {
            return x + " " + y;
        }
        public boolean equals(Object o) {
            pair x = (pair) o;
            return (x.x == this.x && x.y == this.y);
        }
    }
    // int[] dx = {0,0,1,-1};
    // int[] dy = {1,-1,0,0};
    // int[] ddx = {0,0,1,-1,1,-1,1,-1};
    // int[] ddy = {1,-1,0,0,1,-1,-1,1};

    int inf = (int) 1e9 + 5;

long mod  = 998244353L ;
int N = (int)5e5+5;
long[] fact = new long[N+1];
long[] ifact = new long[N+1];
void solve() throws Exception {
init();
long n=nl(),k=nl();

if(n>=k){
	long ans = 0;
	for(int i=1;i<=n;++i){
		ans  = (ans + nCr(n/i -1 ,k-1))%mod ;
	}
	pn(ans);
}
else pn(0);

}

void init(){

	fact[0] =1 ;
	ifact[0] = 1 ;
	for(int i=1;i<=N;++i){
		fact[i] = (fact[i-1] * i )%mod ;
		ifact[i] = pow(fact[i],mod-2) ;
	}

}
long nCr (long n,long r){
	long ans =1 ;

	if(r>n || r< 0) return 0L ;

	ans = (ans*fact[(int)n])%mod ;
	ans= (ans*ifact[(int)(n-r)])%mod ;
	ans= (ans*ifact[(int)r])%mod ;
	return ans ;

}

    long pow(long a, long b) {
        long result = 1;
        while (b > 0) {
            if (b % 2 == 1) result = (result * a) % mod;
            b /= 2;
            a = (a * a) % mod;
        }
        return result;
    }

    void print(Object o) {
        System.out.println(o);
        System.out.flush();
    }

    long gcd(long a, long b) {
        if (b == 0)
            return a;
        return gcd(b, a % b);
    }
    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 Main().run();
    }

    //output methods
    private void pn(Object o) {
        out.println(o);
    }
    private void p(Object o) {
        out.print(o);
    }
    private ArrayList < ArrayList < Integer >> ng(int n, int e) {
        ArrayList < ArrayList < Integer >> g = new ArrayList < > ();
        for (int i = 0; i <= n; ++i) g.add(new ArrayList < > ());

        for (int i = 0; i < e; ++i) {
            int u = ni(), v = ni();
            g.get(u).add(v);
            g.get(v).add(u);
        }

        return g;
    }

    private ArrayList < ArrayList < pair >> nwg(int n, int e) {
        ArrayList < ArrayList < pair >> g = new ArrayList < > ();
        for (int i = 0; i <= n; ++i) g.add(new ArrayList < > ());

        for (int i = 0; i < e; ++i) {
            int u = ni(), v = ni(), w = ni();
            g.get(u).add(new pair(w, v));
            g.get(v).add(new pair(w, u));
        }

        return g;
    }

    //input methods
    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 void tr(Object...o) {
        if (INPUT.length() > 0) System.out.println(Arrays.deepToString(o));
    }
    void watch(Object...a) throws Exception {
        int i = 1;
        print("watch starts :");
        for (Object o: a) {
            //print(o);
            boolean notfound = true;
            if (o.getClass().isArray()) {

                String type = o.getClass().getName().toString();
                //print("type is "+type);
                switch (type) {
                    case "[I":
                        {
                            int[] test = (int[]) o;
                            print(i + " " + Arrays.toString(test));
                            break;
                        }
                    case "[[I":
                        {
                            int[][] obj = (int[][]) o;

                            print(i + " " + Arrays.deepToString(obj));
                            break;
                        }
                    case "[J":
                        {

                            long[] obj = (long[]) o;
                            print(i + " " + Arrays.toString(obj));
                            break;
                        }
                    case "[[J":
                        {

                            long[][] obj = (long[][]) o;
                            print(i + " " + Arrays.deepToString(obj));
                            break;
                        }
                    case "[D":
                        {

                            double[] obj = (double[]) o;
                            print(i + " " + Arrays.toString(obj));
                            break;
                        }
                    case "[[D":
                        {

                            double[][] obj = (double[][]) o;
                            print(i + " " + Arrays.deepToString(obj));
                            break;
                        }
                    case "[Ljava.lang.String":
                        {

                            String[] obj = (String[]) o;
                            print(i + " " + Arrays.toString(obj));
                            break;
                        }
                    case "[[Ljava.lang.String":
                        {

                            String[][] obj = (String[][]) o;
                            print(i + " " + Arrays.deepToString(obj));
                            break;
                        }
                    case "[C":
                        {
                            char[] obj = (char[]) o;
                            print(i + " " + Arrays.toString(obj));
                            break;
                        }
                    case "[[C":
                        {

                            char[][] obj = (char[][]) o;
                            print(i + " " + Arrays.deepToString(obj));
                            break;
                        }

                    default:
                        {
                            print(i + " type not identified");
                            break;
                        }
                }
                notfound = false;

            }
            if (o.getClass() == ArrayList.class) {
                print(i + " al: " + o);
                notfound = false;
            }
            if (o.getClass() == HashSet.class) {
                print(i + " hs: " + o);
                notfound = false;
            }
            if (o.getClass() == TreeSet.class) {
                print(i + " ts: " + o);
                notfound = false;
            }
            if (o.getClass() == TreeMap.class) {
                print(i + " tm: " + o);
                notfound = false;
            }
            if (o.getClass() == HashMap.class) {
                print(i + " hm: " + o);
                notfound = false;
            }
            if (o.getClass() == LinkedList.class) {
                print(i + " ll: " + o);
                notfound = false;
            }
            if (o.getClass() == PriorityQueue.class) {
                print(i + " pq : " + o);
                notfound = false;
            }
            if (o.getClass() == pair.class) {
                print(i + " pq : " + o);
                notfound = false;
            }

            if (notfound) {
                print(i + " unknown: " + o);
            }
            i++;
        }
        print("watch ends ");
    }

}

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

public class E {

    static final long MODULO = 998244353;

    public static void main(String[] args) {
        BufferedScanner scanner = new BufferedScanner();
        PrintWriter writer = new PrintWriter(new BufferedOutputStream(System.out));

        int t = 1;//scanner.nextInt();
        for (int tc = 0; tc < t; tc++) {
            int n = scanner.nextInt();
            int k = scanner.nextInt();
            long ans = 0;
            Comb comb = new Comb(n, MODULO);
            for (int i = 1; i <= n; i++) {
                int howMany = n / i;
                ans = add(ans, comb.c(howMany - 1, k - 1));
            }
            writer.println(ans);
        }

        scanner.close();
        writer.flush();
        writer.close();
    }

    public static class BufferedScanner {
        BufferedReader br;
        StringTokenizer st;

        public BufferedScanner(Reader reader) {
            br = new BufferedReader(reader);
        }

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

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

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

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

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

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

        void close() {
            try {
                br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

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

    static long inverse(long a, long m) {
        long[] ans = extgcd(a, m);
        return ans[0] == 1 ? (ans[1] + m) % m : -1;
    }

    private static long[] extgcd(long a, long m) {
        if (m == 0) {
            return new long[]{a, 1, 0};
        } else {
            long[] ans = extgcd(m, a % m);
            long tmp = ans[1];
            ans[1] = ans[2];
            ans[2] = tmp;
            ans[2] -= ans[1] * (a / m);
            return ans;
        }
    }

    static long add(long a, long b) {
        a += b;
        if (a >= MODULO) {
            a -= MODULO;
        }
        return a;
    }

    static long sub(long a, long b) {
        a -= b;
        if (a < 0) {
            a += MODULO;
        }
        return a;
    }

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

    static long div(long a, long b) {
        return a * inverse(b, MODULO) % MODULO;
    }

    static class Comb {
        final long modulo;
        final long[] fac, fnv;

        Comb(int limit, long modulo) {
            fac = new long[limit + 1];
            fnv = new long[limit + 1];
            fac[0] = 1;
            fnv[0] = 1;
            for (int i = 1; i <= limit; i++) {
                fac[i] = mul(fac[i - 1], i);
                fnv[i] = div(fnv[i - 1], i);
            }
            this.modulo = modulo;
        }

        long c(int total, int choose) {
            if (total < choose) {
                return 0;
            }
            if (total == 0 || total == choose) {
                return 1;
            }
            return mul(mul(fac[total], fnv[choose]), fnv[total - choose]);
        }
    }

}

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

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

		FastReader in = new FastReader();
		PrintWriter out = new PrintWriter(System.out);
		void run(){
			work();
			out.flush();
		}
		long mod=998244353L;
		int[][] dir=new int[][] {{0,1},{1,0},{0,-1},{-1,0}};
		long inf=Long.MAX_VALUE;
		long gcd(long a,long b) {
			return a==0?b:gcd(b%a,a);
		}
		long[] rec=new long[555555];
		void work() {
			long n=nl(),k=nl();
			long ret=0;
			rec[0]=1;
			for(int i=1;i<rec.length;i++) {
				rec[i]=(rec[i-1]*i)%mod;
			}
			for(long i=1;i<=n;i++) {
				long c=n/i-1;
				ret+=C(k-1,c);
				ret%=mod;
			}
			out.println(ret);
		}

		private long C(long k, long c) {
			if(c<k)return 0;
			//c!/(k!(c-k)!)
			long v=(rec[(int)k]*rec[(int)(c-k)])%mod;
			return (rec[(int)c]*(pow(v,mod-2)))%mod;
		}
		private long pow(long v, long k) {
			long ret=1;
			while(k>0) {
				if(k%2==1) {
					ret=(ret*v)%mod;
				}
				k/=2;
				v=(v*v)%mod;
			}
			return ret;
		}
		//input
		private ArrayList<Integer>[] ng(int n, int m) {
			ArrayList<Integer>[] graph=(ArrayList<Integer>[])new ArrayList[n];
			for(int i=0;i<n;i++) {
				graph[i]=new ArrayList<>();
			}
			for(int i=1;i<=m;i++) {
				int s=in.nextInt()-1,e=in.nextInt()-1;
				graph[s].add(e);
				graph[e].add(s);
			}
			return graph;
		}

		private ArrayList<long[]>[] ngw(int n, int m) {
			ArrayList<long[]>[] graph=(ArrayList<long[]>[])new ArrayList[n];
			for(int i=0;i<n;i++) {
				graph[i]=new ArrayList<>();
			}
			for(int i=1;i<=m;i++) {
				long s=in.nextLong()-1,e=in.nextLong()-1,w=in.nextLong();
				graph[(int)s].add(new long[] {e,w,i});
				graph[(int)e].add(new long[] {s,w});
			}
			return graph;
		}

		private int ni() {
			return in.nextInt();
		}

		private long nl() {
			return in.nextLong();
		}

		private String ns() {
			return in.next();
		}

		private long[] na(int n) {
			long[] A=new long[n];
			for(int i=0;i<n;i++) {
				A[i]=in.nextLong();
			}
			return A;
		}
		private int[] nia(int n) {
			int[] A=new int[n];
			for(int i=0;i<n;i++) {
				A[i]=in.nextInt();
			}
			return A;
		}
	}

	class FastReader
	{
		BufferedReader br;
		StringTokenizer st;

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

		public String next()
		{
			while(st==null || !st.hasMoreElements())//回车，空行情况
			{
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

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

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

import java.io.*;
import java.text.*;
import java.util.*;
import java.math.*;
public class template {
	public static void main(String[] args) throws Exception {
		new template().run();
	}
	long MOD = 998_244_353;
	public void run() throws Exception {
		FastScanner f = new FastScanner();
		PrintWriter out = new PrintWriter(System.out);
		int k = f.nextInt(), n = f.nextInt();
		long[] fact = new long[k+1];
		long[] inv = new long[k+1];
		inv[0] = 1;
		fact[0] = 1;
		for(int i = 1; i <= k; i++)
			inv[i] = inv(fact[i] = fact[i-1]*i%MOD);
		long ans = 0;
		for(int i = 1; i <= k; i++) {
			int nk = k/i;
			if(nk < n) break;
			ans = (fact[nk-1]*inv[nk-n]%MOD*inv[n-1]%MOD+ans)%MOD;
		}
		out.println(ans);
		out.flush();
	}
    public long inv(long v) {
		gcd(v,MOD);
		return (x%MOD+MOD)%MOD;
	}
	long x, y;
	public void gcd(long a, long b) {
		if(a == 0 || b == 0) {
			x = 0;
			y = 1;
			return;
		}
		gcd(b%a,a);
		long nx = y-b/a*x;
		long ny = x;
		x = nx;
		y = ny;
	}
	static class FastScanner {
        public BufferedReader reader;
        public StringTokenizer tokenizer;
        public FastScanner() {
            reader = new BufferedReader(new InputStreamReader(System.in), 32768);
            tokenizer = null;
        }
        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }
        public int nextInt() {
            return Integer.parseInt(next());
        }
        public long nextLong() {
        	return Long.parseLong(next());
        }
        public double nextDouble() {
        	return Double.parseDouble(next());
        }
        public String nextLine() {
        	try {
        		return reader.readLine();
        	} catch(IOException e) {
        		throw new RuntimeException(e);
        	}
        }
    }
}

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

public class Run {
    static InputReader in = new InputReader(System.in);
    static PrintWriter pw = new PrintWriter(System.out);
    static long mod =   998244353L;

    public static void main(String args[]) {

        int t = 1;
        //t = in.nextInt();
        for(int i = 1; i <= t ;i ++) {
            solve();
        }
        pw.flush();
        pw.close();
    }

    private static void solve() {

        long n = in.nextLong();
        long k = in.nextLong();
        int N = (int)1e6;

        long[] fact = new long[N];
        fact[0] = 1;
        fact[1] = 1;
        for(int i = 2; i < N; i++) {
            fact[i] = (fact[i-1] * i) % mod;
        }

        long ans = 0;
        for(int i = 1 ; i <= n ; i++) {
            ans = (ans + ncr(n/i - 1,k-1, fact)) % mod;
        }

        pw.print(ans);

    }

    private static long ncr(long n, long k, long[] fact) {
        if(n < k) return  0;
        long ret = fact[(int)n];
        ret = (ret * pow(fact[(int)(n-k)], mod-2, mod)) % mod;
        ret = (ret * pow(fact[(int)(k)], mod-2, mod)) % mod;
        return ret;
    }

    private static long pow(long a, long b, long mod) {
        if(b == 0) return 1;
        if(b == 1) return a % mod;
        long t = pow(a,b/2, mod);
        t  = (t * t) % mod;
        if(b%2!=0) {
            t = ( t * a) % mod;
        }
        return t;
    }

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

    private static int[] bfs(ArrayList<Integer>[] g, int a, int n) {
        int dist[] = new int[n + 1];
        for (int i = 0; i < n + 1; i++) {
            dist[i] = n + 10;
        }
        Queue<Integer> q = new LinkedList<>();
        boolean vis[] = new boolean[n + 1];
        dist[a] = 0;
        q.add(a);
        while (!q.isEmpty()) {
            int p = q.poll();
            if (vis[p] == true) {
                continue;
            }
            vis[p] = true;
            for (Integer i : g[p]) {
                if (!vis[i]) {
                    dist[i] = Integer.min(dist[i], dist[p] + 1);
                    q.add(i);
                }
            }
        }
        return dist;
    }

}

import java.util.*;
import java.io.*;
import java.math.BigInteger;
 public class Solution
{
     static class Pair<A,B>
     {
        A parent;
        B rank;
        Pair(A parent,B rank)
        {
            this.rank=rank;
            this.parent=parent;
        }
    }
     static class Node{
         int x;
         int y;
         Node(int i,int j)
         {
             x=i;
             y=j;
         }
     }
     static int m=998244353;
     static ArrayList<Integer> graph[];
     static boolean visited[];
     static int fact[];
    public static void main (String[] args) throws IOException
    {
        StringBuilder sb = new StringBuilder();
        FastReader s1 = new FastReader();
        int n=s1.I();
        int k=s1.I();
        long fact[] = new long[n+1];
        long inv[] = new long[n+1];
        fact[0]=1;
        if(n<k)
        {
            System.out.println("0");
            System.exit(0);
        }
        for(int i=1;i<=n;i++)
        {
            fact[i]=(fact[i-1]*i)%m;
        }
        for(int i=0;i<=n;i++)
        {
            inv[i]=pow(fact[i],m-2);
        }
        long ans=(((fact[n-1]*inv[k-1])%m)*inv[n-k])%m;
        int i=2;
        while(true)
        {
            int value=n/i;
            if(value<k)
            {
                break;
            }
            value--;
            long ans1=(((fact[value]*inv[k-1])%m)*inv[value-k+1])%m;
            ans=(ans+ans1)%m;
            i++;
        }
        System.out.println(ans);
    }
    static long sum(long a)
    {
        return (a*(a+1))/2;
    }
    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 I()
        {
            return Integer.parseInt(next());
        }

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

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

        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
    }
    static long gcd(long a,long b)
    {
        if(a%b==0)
            return b;
        return gcd(b,a%b);
    }
    static float power(float x, int y)
    {
        float temp;
        if( y == 0)
            return 1;
        temp = power(x, y/2);

        if (y%2 == 0)
            return temp*temp;
        else
        {
            if(y > 0)
                return x * temp * temp;
            else
                return (temp * temp) / x;
        }
    }
    static long pow(long x, long y)
    {
        long res = 1;
        x = x % m;
        if(x<0)
            x+=m;
        while (y > 0)
        {
            if((y & 1)==1){
                res = (res * x) % m;
                if(res<0)
                    res+=m;
            }
            y = y >> 1;
            x = (x * x) % m;
            if(x<0)
                x=x+m;
        }
        res=res%m;
                if(res<0)
                    res+=m;
        return res;
    }
    static void sieveOfEratosthenes(int n)
    {
        ArrayList<Integer> prime=new ArrayList<Integer>();
        boolean Prime[] = new boolean[n+1];
        for(int i=2;i<n;i++)
            Prime[i] = true;

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

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 out_of_the_box
 */
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);
        EModularStability solver = new EModularStability();
        solver.solve(1, in, out);
        out.close();
    }

    static class EModularStability {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            int n = in.nextInt();
            int k = in.nextInt();
            int ans = 0;
            int MOD = 998244353;
            int MAXN = 500003;
            int[] fact = new int[MAXN];
            fact[0] = 1;
            for (int i = 1; i < MAXN; i++) {
                fact[i] = MathUtility.mult(fact[i - 1], i, MOD);
            }
            for (int i = 1; i <= n; i++) {
                int q = n / i;
                if (q >= k) {
                    int op = q - 1;
                    int ch = k - 1;
                    ans = MathUtility.add(ans, C(op, ch, fact, MOD), MOD);
                }
            }
            out.println(ans);
        }

        private int C(int n, int r, int[] fact, int MOD) {
            if (n >= r) {
                int num = fact[n];
                int denom = MathUtility.mult(fact[r], fact[n - r], MOD);
                return MathUtility.dividePrime(num, denom, MOD);
            } else {
                return 0;
            }
        }

    }

    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 close() {
            writer.close();
        }

        public void println(int i) {
            writer.println(i);
        }

    }

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

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

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

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

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

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

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

        }

    }

    static class MathUtility {
        public static int pow(int b, long p, int MOD) {
            int ret = 1;
            while (p > 0L) {
                if ((p & 1L) == 1L) {
                    ret = mult(ret, b, MOD);
                }
                p >>= 1L;
                b = mult(b, b, MOD);
            }
            return ret;
        }

        public static int mult(int a, int b, int MOD) {
            long temp = ((long) a) * ((long) b);
            if (temp >= ((long) MOD)) {
                temp %= MOD;
            }
            return (int) temp;
        }

        public static int add(int a, int b, int MOD) {
            int res = a + b;
            if (res >= MOD) {
                res -= MOD;
            }
            return res;
        }

        public static int modInversePrime(int a, int MOD) {
            return pow(a, MOD - 2, MOD);
        }

        public static int dividePrime(int num, int denom, int MOD) {
            int mul = modInversePrime(denom, MOD);
            return mult(num, mul, MOD);
        }

    }
}

import java.util.*;
import java.io.*;
public class Main {
    static class Scan {
        private byte[] buf=new byte[1024];
        private int index;
        private InputStream in;
        private int total;
        public Scan()
        {
            in=System.in;
        }
        public int scan()throws IOException
        {
            if(total<0)
            throw new InputMismatchException();
            if(index>=total)
            {
                index=0;
                total=in.read(buf);
                if(total<=0)
                return -1;
            }
            return buf[index++];
        }
        public int scanInt()throws IOException
        {
            int 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();
                }
                else throw new InputMismatchException();
            }
            return neg*integer;
        }
        public double scanDouble()throws IOException
        {
            double doub=0;
            int n=scan();
            while(isWhiteSpace(n))
            n=scan();
            int neg=1;
            if(n=='-')
            {
                neg=-1;
                n=scan();
            }
            while(!isWhiteSpace(n)&&n!='.')
            {
                if(n>='0'&&n<='9')
                {
                    doub*=10;
                    doub+=n-'0';
                    n=scan();
                }
                else throw new InputMismatchException();
            }
            if(n=='.')
            {
                n=scan();
                double temp=1;
                while(!isWhiteSpace(n))
                {
                    if(n>='0'&&n<='9')
                    {
                        temp/=10;
                        doub+=(n-'0')*temp;
                        n=scan();
                    }
                    else throw new InputMismatchException();
                }
            }
            return doub*neg;
        }
        public String scanString()throws IOException
        {
            StringBuilder sb=new StringBuilder();
            int n=scan();
            while(isWhiteSpace(n))
            n=scan();
            while(!isWhiteSpace(n))
            {
                sb.append((char)n);
                n=scan();
            }
            return sb.toString();
        }
        private boolean isWhiteSpace(int n)
        {
            if(n==' '||n=='\n'||n=='\r'||n=='\t'||n==-1)
            return true;
            return false;
        }
    }
    static long fact[],mod=998244353L;
    public static void main(String args[]) throws IOException {
        Scan input=new Scan();
        fact=new long[500001];
        fact[0]=1;
        for(int i=1;i<fact.length;i++) {
            fact[i]=i*fact[i-1];
            fact[i]%=mod;
        }
        int n=input.scanInt();
        int k=input.scanInt();
        long ans=0;
        for(int i=1;i<=n;i++) {
            int num=n/i;
            if(num<k) {
                continue;
            }
            ans+=ncr(num-1,k-1);
            ans%=mod;
//            System.out.println(i+" "+ans);
        }
        System.out.println(ans);
    }
    public static long ncr(int n,int r) {
        long ncr=(((fact[n]*Inverse(fact[n-r],mod))%mod)*Inverse(fact[r],mod))%mod;
        return ncr;
    }

    public static long Inverse(long a,long n) {
        long q,r1=n,r2=a,r,t1=0,t2=1,t;
        while(true) {
            q=r1/r2;
            r=r1%r2;
            t=t1-(q*t2);
            r1=r2;
            r2=r;
            t1=t2;
            t2=t;
            if(r2==0) {
                    break;
            }
        }
        if(r1!=1) {
                return -1;
        }
        t1%=n;
        if(t1<0) {
                t1+=n;
        }
        return t1;
    }
}

import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Educational88 {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	public static long[] initArray(int n, Reader scan) throws IOException {

		long arr[] = new long[n];
		for (int i = 0; i < n; i++) {
			arr[i] = scan.nextLong();
		}

		return arr;
	}

	public static long sum(long arr[]) {

		long sum = 0;
		for (long i : arr) {
			sum += (long) i;
		}

		return sum;
	}

	public static long max(long arr[]) {

		long max = Long.MIN_VALUE;

		for (long i : arr) {
			max = Math.max(i, max);
		}

		return max;
	}

	public static long min(long arr[]) {
		long min = Long.MAX_VALUE;

		for (long i : arr) {
			min = Math.min(i, min);
		}

		return min;
	}

	public static List<Integer>[] initAdjacency(int n, Reader scan, boolean type) throws IOException{

		List<Integer> adj[]=new ArrayList[n];

		for(int i=0;i<n;i++) {
			int u=scan.nextInt();
			int v=scan.nextInt();

			if(adj[u]==null) adj[u]=new ArrayList<>();
			if(type&&adj[v]==null) adj[v]=new ArrayList<>();

			adj[u].add(v);

			if(type) adj[v].add(u);

		}

		return adj;
	}
	public static void main(String[] args) throws IOException {

		Reader scan=new Reader();
		int t=1;
		while(t-->0) {
			long n=scan.nextLong();
			long k=scan.nextLong();
			System.out.println(E(n, k));
		}
	}

	public static int A(int n, int m, int k) {

		int val=n/k;

		if(m<=val) {
			return m;
		}

		int rem= m-val;

		int max= (int)Math.ceil((double)(rem)/(k-1));

		return val-max;

	}

	public static long B(String arr[], int n, int m, long x, long y) {

		long ans=0;
		for(int i=0;i<n;i++) {

			int last=-1;
			int j=0;

			while(j<m) {

				if(arr[i].charAt(j)=='*') {

					ans+= BHelper(j-last-1, x, y);
					last=j;
				}

				j++;

			}

			ans+= BHelper(j-last-1, x, y);

		}

		return ans;

	}

	public static long BHelper(int len, long x, long y) {

		long cost1= len*x;
		long cost2= (len/2)*y+ (len%2)*x;

		return Math.min(cost1,  cost2);

	}

	public static long C(long h, long c, long t) {

		if((h+c)>=2*t) {
			return 2;
		}

		if(t>=h) return 1;

		long x= Math.abs((t-h)/(h+c-2*t));
		System.out.println("x="+x);

		System.out.println(2*x+1);
		System.out.println(2*x+3);

		//System.out.println(low+" "+high);

		double val1= (double)((double)x*c)/((long)2*x+(long)1)+ (double)((double)(x+1)*h)/((long)2*x+(long)1);

		double val2= (double)((double)(x+1)*c)/((long)2*x+(long)3)+ (double)((double)(x+2)*h)/((long)2*x+(long)3);

		System.out.println("val1="+val1);
		System.out.println("val2="+val2);

		double diff1= Math.abs((double)t-val1);
		double diff2= Math.abs((double)t-val2);
		double diff3= Math.abs((double)(t-((double)(h+c)/(double)2)));

		System.out.println(diff1+"-");
		System.out.println(diff2+"-");
		System.out.println(diff3+"-");

		double min= Math.min(diff1,  Math.min(diff2, diff3));
		//System.out.println("min="+min);

		if(diff3==min) {
			return 2;
		}

		if(diff1==min) {
			return 2*x+1;
		}

		if(diff2==min) {
			return 2*x+3;
		}

		return 2;

	}

	public static long D(int n, long arr[]) {

		long dp[]=new long[n];
		long max[]=new long[n];

		dp[n-1]=0;
		max[n-1]=arr[n-1];

		for(int i=n-2;i>=0;i--) {

			long nextSum= dp[i+1];
			long nextMax= max[i+1];

			long curAns=0;
			long curMax= arr[i];
			if(arr[i]>nextMax) {
				long val= nextSum+nextMax;
				long newMax= arr[i];

				if(val>curAns) {
					curAns= val;
					curMax= newMax;
				}

			}else {
				long val= nextSum+ arr[i];
				long newMax= nextMax;

				if(val>curAns) {
					curAns= val;
					curMax=newMax;
				}
			}

			dp[i]=curAns;
			max[i]=curMax;

		}

		return max(dp);

	}

	public static long E(long n, long k) {

		long mod=998244353;

		long fact[]=new long[500000];
		long factInv[]=new long[500000];

		fact[0]=1;
		for(int i=1;i<500000;i++) {
			fact[i]=i*fact[i-1];
			fact[i]%=mod;
		}

//		for(int i=0;i<=10;i++) {
//			System.out.print(fact[i]+" ");
//		}

		for(int i=0;i<500000;i++) {
			factInv[i]= BigInteger.valueOf(fact[i]).modInverse(BigInteger.valueOf(998244353)).longValue();
		}

//		for(int i=0;i<=10;i++) {
//			System.out.print(factInv[i]+" ");
//		}
//		System.out.println();

		long ans=0;
		for(int i=1;;i++) {

			long count= n/i-1;

//			System.out.println("count for i="+i+" = " +count);

			if(count>=(k-1)) {
				ans+= (((fact[(int)count]*factInv[(int)count-(int)k+1])%mod)*(factInv[(int)k-1]))%mod;
				ans%=mod;
//				System.out.println("ans is "+ans);
			}else {
				break;
			}

		}

		return ans;

	}

	public static long calFact(long k) {

		long mod=998244353;
		long ans=1;
		for(long i=1;i<=k;i++) {
			ans*=i;
			ans%=mod;
		}

		return ans;
	}

}

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

public class Main{

	public static void main(String[] args)  {
		Scanner s= new Scanner(System.in);
		long mod = 998244353;
		long fact[]=new long[500000];
		long factinv[]=new long[500000];
		int n=s.nextInt();
		int k=s.nextInt();
		fact[0]=1;
		for(int i=1;i<500000;i++)
			fact[i]=( i*fact[i-1])%mod;
		for(int i=0;i<500000;i++)
			factinv[i] = BigInteger.valueOf(fact[i]).modInverse(BigInteger.valueOf(mod)).longValue();
		long ans = 0;
		for(int i=1;i<=n;i++)
		{
			int count = n/i - 1;
			if(count<(k-1))
				break;
			ans += ( ((fact[count]*factinv[k-1])%mod )*factinv[count-k+1])%mod  ;
			ans = ans%mod;
		}
		System.out.println(ans);
	}
}

import java.io.*;
import java.util.*;
public class sol {
    InputReader in;
    PrintWriter out;
    helper_class h;
    final long mod=1000000007;
    final long p=998244353;
    long fact[];
    public static void main(String[] args) throws java.lang.Exception{
        new sol().run();
    }
    void run() throws Exception{
        in=new InputReader(System.in);
        out = new PrintWriter(System.out);
        h = new helper_class();
        precompute();
        int t=1;
        while(t-->0){
            solve();
        }
        out.flush();
        out.close();
    }
    void solve() {
        int n=h.i(),k=h.i();
        precompute();
        long ans=0;
        for(int i=1;i<=n;i++)
            ans = add(ans, nCr(n/i-1,k-1));
        h.p(ans);
    }
    void precompute() {
        fact=new long[500001];
        fact[0]=1;
        for(int i=1;i<=500000;i++)
            fact[i]=(fact[i-1]*i)%p;
    }
    long nCr(int n,int r) {
        if(r > n) return 0;
        return mul(fact[n], mul(inv(fact[r]),inv(fact[n-r])));
    }
    long inv(long x) {
        return power(x,p-2,p);
    }
    long add(long x,long y) {
        return (x%p + y%p)%p;
    }
    long mul(long x,long y) {
        return (x%p * y%p)%p;
    }
    long power(long a, long b,long p){
        if(b == 0)
            return 1L;
        long val = power(a, b/2, p);
        if(b % 2 == 0)
            return val * val%p;
        else
            return val * val%p * a%p;
    }
    class helper_class{
        long gcd(long a, long b){return (b==0)?a:gcd(b,a%b);}
        void p(Object o){out.println(o);}
        String s(){return in.next();}
        String nl(){return in.nextLine();}
        int i(){return in.nextInt();}
        long l(){return in.nextLong();}
    }
    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 UnknownError();
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new UnknownError();
                }
                if (numChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }
        public int peek() {
            if (numChars == -1)
                return -1;
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    return -1;
                }
                if (numChars <= 0)
                    return -1;
            }
            return buf[curChar];
        }
        public void skip(int x) {
            while (x-->0)
                read();
        }
        public int nextInt() {
            return Integer.parseInt(next());
        }
        public long nextLong() {
            return Long.parseLong(next());
        }
        public String nextString() {
            return next();
        }
        public String next() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            StringBuffer res = new StringBuffer();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isSpaceChar(c));

            return res.toString();
        }
        public String nextLine() {
            StringBuffer buf = new StringBuffer();
            int c = read();
            while (c != '\n' && c != -1) {
                if (c != '\r')
                    buf.appendCodePoint(c);
                c = read();
            }
            return buf.toString();
        }
        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 boolean hasNext() {
            int value;
            while (isSpaceChar(value = peek()) && value != -1)
                read();
            return value != -1;
        }
        private boolean isSpaceChar(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }
    }
}

import java.io.*;
import java.util.*;
public class sol {
    InputReader in;
    PrintWriter out;
    helper_class h;
    final long mod=1000000007;
    final long p=998244353;
    long fact[];
    public static void main(String[] args) throws java.lang.Exception{
        new sol().run();
    }
    void run() throws Exception{
        in=new InputReader(System.in);
        out = new PrintWriter(System.out);
        h = new helper_class();
        precompute();
        int t=1;
        while(t-->0){
            solve();
        }
        out.flush();
        out.close();
    }
    void solve() {
        int n=h.i(),k=h.i();
        if(k>n)
            h.p(0);
        else if(k==1)
            h.p(n);
        else {
            precompute();
            long ans=0;
            for(int i=1;i<=n;i++)
                ans = add(ans, nCr(n/i-1, k-1));
            h.p(ans);
        }
    }
    void precompute() {
        fact=new long[500001];
        fact[0]=1;
        for(int i=1;i<=500000;i++)
            fact[i]=(fact[i-1]*i)%p;
    }
    long nCr(int n,int r) {
        if(r > n) return 0;
        return mul(fact[n], mul(inv(fact[r]),inv(fact[n-r])));
    }
    long inv(long x) {
        return power(x,p-2,p);
    }
    long add(long x,long y) {
        return (x%p + y%p)%p;
    }
    long mul(long x,long y) {
        return (x%p * y%p)%p;
    }
    long power(long a, long b,long p){
        if(b == 0)
            return 1L;
        long val = power(a, b/2, p);
        if(b % 2 == 0)
            return val * val%p;
        else
            return val * val%p * a%p;
    }
    class helper_class{
        long gcd(long a, long b){return (b==0)?a:gcd(b,a%b);}
        void p(Object o){out.println(o);}
        String s(){return in.next();}
        String nl(){return in.nextLine();}
        int i(){return in.nextInt();}
        long l(){return in.nextLong();}
    }
    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 UnknownError();
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new UnknownError();
                }
                if (numChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }
        public int peek() {
            if (numChars == -1)
                return -1;
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    return -1;
                }
                if (numChars <= 0)
                    return -1;
            }
            return buf[curChar];
        }
        public void skip(int x) {
            while (x-->0)
                read();
        }
        public int nextInt() {
            return Integer.parseInt(next());
        }
        public long nextLong() {
            return Long.parseLong(next());
        }
        public String nextString() {
            return next();
        }
        public String next() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            StringBuffer res = new StringBuffer();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isSpaceChar(c));

            return res.toString();
        }
        public String nextLine() {
            StringBuffer buf = new StringBuffer();
            int c = read();
            while (c != '\n' && c != -1) {
                if (c != '\r')
                    buf.appendCodePoint(c);
                c = read();
            }
            return buf.toString();
        }
        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 boolean hasNext() {
            int value;
            while (isSpaceChar(value = peek()) && value != -1)
                read();
            return value != -1;
        }
        private boolean isSpaceChar(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }
    }
}

// Working program with FastReader
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Scanner;
import java.util.StringTokenizer;

public class e
{
    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;
        }
    }

    //        long start = System.currentTimeMillis();
//        long end = System.currentTimeMillis();
//        System.out.println((end - start) + "ms");

    static int M =998244353;
    static int N =600000+5;
    static long[] fac = new long[N];
    static long[] fac_inv = new long[N];
    static long[] inv = new long[N];

    public static void initialise(){
        int i;
        inv[1]=1;
        for(i=2;i<N;++i){
            inv[i] = (M * 1l - (M / i * 1l)) * inv[M % i] % M;
        }
        fac[0] = fac[1] = 1;
        for(i=2;i<N;i++){
            fac[i] = ((i*1l)*fac[i-1])%M;
        }
        fac_inv[0] = fac_inv[1] = 1;
        for(i=2;i<N;i++){
            fac_inv[i] = (inv[i]*1l*fac_inv[i-1])%M;
        }
    }

    public static long ncr(int n,int r){
        if(n<r){
            return 0;
        }
        return (((fac[n]*fac_inv[r])%M) *fac_inv[n-r])%M;
    }

    public static void main(String[] args)
    {
        FastReader s=new FastReader();
        initialise();
        int n = s.nextInt();
        int k = s.nextInt();
        System.out.println(n_ways(n,k));
    }
    public static long n_ways(int n,int k){
        long count =0l;
        for(int i=1;i<=n;i++){
            int temp = (n/i)-1;
            if(temp>=k-1){
                count+=ncr(temp,k-1);
                count%=M;
            }
        }
        return count;
    }

    public static void debug(long[][] arr){
        int len = arr.length;
        for(int i=0;i<len;i++){
            System.out.println(Arrays.toString(arr[i]));
        }
    }
    public static void debug(int[][] arr){
        int len = arr.length;
        for(int i=0;i<len;i++){
            System.out.println(Arrays.toString(arr[i]));
        }
    }
    public static void debug(String[] arr){
        int len = arr.length;
        for(int i=0;i<len;i++){
            System.out.println(arr[i]);
        }
    }

    public static void print(int[] arr){
        int len = arr.length;
        for(int i=0;i<len;i++){
            System.out.print(arr[i]+" ");
        }
        System.out.print('\n');
    }
    public static void print(String[] arr){
        int len = arr.length;
        for(int i=0;i<len;i++){
            System.out.print(arr[i]+" ");
        }
        System.out.print('\n');
    }
    public static void print(long[] arr){
        int len = arr.length;
        for(int i=0;i<len;i++){
            System.out.print(arr[i]+" ");
        }
        System.out.print('\n');
    }

}

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

public class Solution{

	static long mod = 998244353L;
	static long[] fact;

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

		FastScanner fs = new FastScanner();

		int n = fs.nextInt(), k = fs.nextInt();

		fact = new long[n+1];

		fact[0] = 1L;
		for(int i=1;i<=n;i++) {
			fact[i] = mul(fact[i-1],i);
		}

		long ans = 0L;
		for(int i=1;i<=n;i++) {
			int num = (n-i)/i;
			ans = add(ans, C(num,k-1));
		}

		System.out.println(ans);

	}

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

	static long add(long a,long b) {
		return (a+b)%mod;
	}

	static long C(int n, int r) {
		if(r>n) return 0;
		return mul(fact[n],inv(mul(fact[n-r],fact[r])));
	}

	//FINDING MODULAR MULTIPLICATIVE INVERSE USING FERMAT'S LITTLE THEORUM AND BINARY EXPONENTIATION
	static long inv(long a) {
		long m = mod-2;
		long res = 1;
		while(m>0) {
			if((m&1)==1) {
				res = mul(res,a);
			}
			a = mul(a,a);
			m = m>>1;
		}
		return res;
	}

	static class FastScanner{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer("");

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

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

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

}

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

public class Main implements Runnable {
    @Override
    public void run() {
        try {
            new Solver().solve();
            System.exit(0);
        } catch (Exception | Error e) {
            e.printStackTrace();
            System.exit(1);
        }
    }

    public static void main(String[] args) {
        //new Thread(null, new Main(), "Solver", 1l << 25).start();
        new Main().run();
    }
}

class Solver {
    final Helper hp;
    final int MAXN = 1000_006;
    final long MOD = (long) 998244353;

    final Timer timer;
    final TimerTask task;

    Solver() {
        hp = new Helper(MOD, MAXN);
        hp.initIO(System.in, System.out);

        timer = new Timer();
        task = new TimerTask() {
            @Override
            public void run() {
                try {
                    hp.flush();
                    System.exit(0);
                } catch (Exception e) {
                }
            }
        };
        //timer.schedule(task, 4700);
    }

    void solve() throws Exception {
        int tc = TESTCASES ? hp.nextInt() : 1;
        for (int tce = 1; tce <= tc; ++tce) solve(tce);
        timer.cancel();
        hp.flush();
    }

    boolean TESTCASES = false;

    void solve(int tc) throws Exception {
        int i, j, k;

        int N = hp.nextInt(), K = hp.nextInt();

        long ans = 0;
        for (i = 1; i <= N; ++i) {
            int count = N / i - 1;
            if (count >= K - 1) {
                ans += hp.ncr(count, K - 1);
                ans %= MOD;
            }
        }
        hp.println(ans);
    }
}

class Helper {
    final long MOD;
    final int MAXN;
    final Random rnd;

    public Helper(long mod, int maxn) {
        MOD = mod;
        MAXN = maxn;
        rnd = new Random();
    }

    public static int[] sieve;
    public static ArrayList<Integer> primes;

    public void setSieve() {
        primes = new ArrayList<>();
        sieve = new int[MAXN];
        int i, j;
        for (i = 2; i < MAXN; ++i)
            if (sieve[i] == 0) {
                primes.add(i);
                for (j = i; j < MAXN; j += i) {
                    sieve[j] = i;
                }
            }
    }

    public static long[] factorial;

    public void setFactorial() {
        factorial = new long[MAXN];
        factorial[0] = 1;
        for (int i = 1; i < MAXN; ++i) factorial[i] = factorial[i - 1] * i % MOD;
    }

    public long getFactorial(int n) {
        if (factorial == null) setFactorial();
        return factorial[n];
    }

    public long ncr(int n, int r) {
        if (r > n) return 0;
        if (factorial == null) setFactorial();
        long numerator = factorial[n];
        long denominator = factorial[r] * factorial[n - r] % MOD;
        return numerator * pow(denominator, MOD - 2, MOD) % MOD;
    }

    public long[] getLongArray(int size) throws Exception {
        long[] ar = new long[size];
        for (int i = 0; i < size; ++i) ar[i] = nextLong();
        return ar;
    }

    public int[] getIntArray(int size) throws Exception {
        int[] ar = new int[size];
        for (int i = 0; i < size; ++i) ar[i] = nextInt();
        return ar;
    }

    public String[] getStringArray(int size) throws Exception {
        String[] ar = new String[size];
        for (int i = 0; i < size; ++i) ar[i] = next();
        return ar;
    }

    public String joinElements(long... ar) {
        StringBuilder sb = new StringBuilder();
        for (long itr : ar) sb.append(itr).append(" ");
        return sb.toString().trim();
    }

    public String joinElements(int... ar) {
        StringBuilder sb = new StringBuilder();
        for (int itr : ar) sb.append(itr).append(" ");
        return sb.toString().trim();
    }

    public String joinElements(String... ar) {
        StringBuilder sb = new StringBuilder();
        for (String itr : ar) sb.append(itr).append(" ");
        return sb.toString().trim();
    }

    public String joinElements(Object... ar) {
        StringBuilder sb = new StringBuilder();
        for (Object itr : ar) sb.append(itr).append(" ");
        return sb.toString().trim();
    }

    public long gcd(long a, long b) {
        return b == 0 ? a : gcd(b, a % b);
    }

    public int gcd(int a, int b) {
        return b == 0 ? a : gcd(b, a % b);
    }

    public long max(long... ar) {
        long ret = ar[0];
        for (long itr : ar) ret = Math.max(ret, itr);
        return ret;
    }

    public int max(int... ar) {
        int ret = ar[0];
        for (int itr : ar) ret = Math.max(ret, itr);
        return ret;
    }

    public long min(long... ar) {
        long ret = ar[0];
        for (long itr : ar) ret = Math.min(ret, itr);
        return ret;
    }

    public int min(int... ar) {
        int ret = ar[0];
        for (int itr : ar) ret = Math.min(ret, itr);
        return ret;
    }

    public long sum(long... ar) {
        long sum = 0;
        for (long itr : ar) sum += itr;
        return sum;
    }

    public long sum(int... ar) {
        long sum = 0;
        for (int itr : ar) sum += itr;
        return sum;
    }

    public void shuffle(int[] ar) {
        int r;
        for (int i = 0; i < ar.length; ++i) {
            r = rnd.nextInt(ar.length);
            if (r != i) {
                ar[i] ^= ar[r];
                ar[r] ^= ar[i];
                ar[i] ^= ar[r];
            }
        }
    }

    public void shuffle(long[] ar) {
        int r;
        for (int i = 0; i < ar.length; ++i) {
            r = rnd.nextInt(ar.length);
            if (r != i) {
                ar[i] ^= ar[r];
                ar[r] ^= ar[i];
                ar[i] ^= ar[r];
            }
        }
    }

    public void reverse(int[] ar) {
        int r;
        for (int i = 0; i < ar.length; ++i) {
            r = ar.length - 1 - i;
            if (r > i) {
                ar[i] ^= ar[r];
                ar[r] ^= ar[i];
                ar[i] ^= ar[r];
            }
        }
    }

    public void reverse(long[] ar) {
        int r;
        for (int i = 0; i < ar.length; ++i) {
            r = ar.length - 1 - i;
            if (r > i) {
                ar[i] ^= ar[r];
                ar[r] ^= ar[i];
                ar[i] ^= ar[r];
            }
        }
    }

    public long pow(long base, long exp, long MOD) {
        base %= MOD;
        long ret = 1;
        while (exp > 0) {
            if ((exp & 1) == 1) ret = ret * base % MOD;
            base = base * base % MOD;
            exp >>= 1;
        }
        return ret;
    }

    static final int BUFSIZE = 1 << 20;
    static byte[] buf;
    static int index, total;
    static InputStream in;
    static BufferedWriter bw;

    public void initIO(InputStream is, OutputStream os) {
        try {
            in = is;
            bw = new BufferedWriter(new OutputStreamWriter(os));
            buf = new byte[BUFSIZE];
        } catch (Exception e) {
        }
    }

    public void initIO(String inputFile, String outputFile) {
        try {
            in = new FileInputStream(inputFile);
            bw = new BufferedWriter(new OutputStreamWriter(
                    new FileOutputStream(outputFile)));
            buf = new byte[BUFSIZE];
        } catch (Exception e) {
        }
    }

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

    public String next() throws Exception {
        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();
    }

    public int nextInt() throws Exception {
        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;
    }

    public long nextLong() throws Exception {
        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;
    }

    public void print(Object a) throws Exception {
        bw.write(a.toString());
    }

    public void printsp(Object a) throws Exception {
        print(a);
        print(" ");
    }

    public void println() throws Exception {
        bw.write("\n");
    }

    public void println(Object a) throws Exception {
        print(a);
        println();
    }

    public void flush() throws Exception {
        bw.flush();
    }
}

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

public class Main{

    static long MOD = 998244353L;
    static long [] fac;
    static int[][] dir = new int[][]{{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
    static long lMax = 0x3f3f3f3f3f3f3f3fL;
    static int iMax = 0x3f3f3f3f;
    static HashMap <Long, Long> memo = new HashMap();
    public static void main(String[] args) {
        MyScanner sc = new MyScanner();
        out = new PrintWriter(new BufferedOutputStream(System.out));
        // Start writing your solution here. -------------------------------------
        //int t = sc.nextInt();
        int t = 1;
        while(t-- > 0) {
            int n = sc.nextInt();
            int k = sc.nextInt();
            fac = new long[n + 1];
            fac[1] = 1L;
            for(int i = 2; i <= n; i++)
                fac[i] = fac[i - 1] * i % MOD;
            long res = 0L;
            if(n == k) res = 1L;
            else
            {
                for(int i = 1; i <= n / k; i++)
                {
                    res += C( n / i - 1, k - 1);
                }
            }
            out.println(res % MOD);
        }

        out.close();
    }
    public static long C(int n, int m)
    {
        if(m == 0 || m == n) return 1l;
        if(m > n || m < 0) return 0l;
        long res = fac[n] * quickPOW((fac[m] * fac[n - m]) % MOD, MOD - 2) % MOD;

        return res;
    }
    public static long quickPOW(long n, long m)
    {
        long ans = 1l;
        while(m > 0)
        {
            if(m % 2 == 1)
                ans = (ans * n) % MOD;
            n = (n * n) % MOD;
            m >>= 1;
        }
        return ans;
    }
    public static int gcd(int a, int b)
    {
        if(a % b == 0) return b;
        return gcd(b, a % b);
    }
    public static long gcd(long a, long b)
    {
        if(a % b == 0) return b;
        return gcd(b, a % b);
    }
    public static long solve(long cur){
        return 0L;
    }
    //-----------PrintWriter for faster output---------------------------------
    public static PrintWriter out;
    //-----------MyScanner class for faster input----------
    public static class MyScanner {
        BufferedReader br;
        StringTokenizer st;

        public MyScanner() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }
        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }
        int nextInt() {
            return Integer.parseInt(next());
        }
        long nextLong() {
            return Long.parseLong(next());
        }
        double nextDouble() {
            return Double.parseDouble(next());
        }
        String nextLine(){
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }
    //--------------------------------------------------------
}

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

public class Main {
    static int MOD = 998244353;
    static int N = 500000 + 5;
    static int[] fac = new int[N];

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

        fac[0] = 1; fac[1] = 1;
        for (int i = 2; i < N; i++)
            fac[i] = (int) (1l * fac[i - 1] * i % MOD);
        int n = sc.nextInt(), k = sc.nextInt();
        long res = 0;
        for (int i = 1; i <= n; i++) {
            int div_cnt = n / i - 1;
            res += nCr(div_cnt, k - 1);
            res %= MOD;
        }
        out.print(res);
        out.flush();
        out.close();
    }
    static int power(int a, int b) {
        long result = 1;
        while (b > 0) {
            if (b % 2 == 1) result = (result * a) % MOD;
            a =  (int) (1l * a * a % MOD);
            b >>= 1;
        }
        return (int) result;
    }
    static int nCr(int n, int r) {
        if (r > n) return 0;
        return (int) ((1l * fac[n] * power(fac[r], MOD - 2) % MOD) * power(fac[n - r], MOD - 2) % MOD);
    }
}

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

public class E {
    public static void main(String[] args) throws Throwable {

        Scanner sc = new Scanner();
        PrintWriter pw = new PrintWriter(System.out);

//        for (int i = 4; i <= 100; i++)
//            for (int j = i + 1; j <= 100; j++)
//                for (int k = j + 1; k <= 100; k++) {
//                    boolean ok = true;
//                    for (int n = 1; n <= 201; n++) {
//                        HashSet<Integer> mods = new HashSet<>();
//                        mods.add(n % i % j % k);
//                        mods.add(n % i % k % j);
//                        mods.add(n % j % i % k);
//                        mods.add(n % j % k % i);
//                        mods.add(n % k % i % j);
//                        mods.add(n % k % j % i);
//                        if (mods.size() > 1) {
//                            ok = false;
//                            break;
//                        }
//                    }
//                    if (ok)
//                        System.err.println(i + " " + j + " " + k);
//                }

        int n = sc.nextInt();
        int k = sc.nextInt();
        fac = new long[n + 1];
        fac[0] = 1;
        for (int i = 1; i <= n; i++)
            fac[i] = fac[i - 1] * i % mod;
        inv = new long[n + 1];
        for (int i = 0; i <= n; i++)
            inv[i] = modPow(fac[i], mod - 2);
        long ans = 0;
        for (int i = 1; i <= n; i++) {
            int d = n / i;
            int N = d - 1;
            int K = k - 1;
            ans = (ans + nCk(N, K)) % mod;
        }
        pw.println(ans);

        pw.close();
    }

    static int mod = 998244353;
    static long[] fac, inv;

    static long nCk(int N, int K) {
        if (N < K)
            return 0;
        return fac[N] * inv[N - K] % mod * inv[K] % mod;
    }

    static long modPow(long x, long y) {
        if (y == 0)
            return 1;
        if (y % 2 == 0) {
            long z = modPow(x, y / 2);
            return z * z % mod;
        }
        long z = modPow(x, y - 1);
        return x * z % mod;

    }

    static class Scanner {
        StringTokenizer st;
        BufferedReader br;

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

        Scanner(String s) throws Throwable {
            br = new BufferedReader(new FileReader(new File(s)));
        }

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

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

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

    }

}

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

public class Main{
	static int mod=998244353;
	static long fastpow(long n,long ti) {
		 if (ti == 0)
		        return 1l;
		if(ti%2==0) {
			long y=fastpow(n, ti/2);
			long k=y*y;
			k%=mod;
			return k;
		}
		else {
			long y=fastpow(n, ti/2);
			long k=((n*y)%mod)*y;
			k%=mod;
			return k;
		}
	}
	static long[]fac;
	public static long ncr(int n,int k) {
		if(n<k)return 0;
		long num=fac[(n)];
		long den=(fac[(n-k)]*fac[k])%mod;
		long ans=(num*fastpow(den,mod-2));
		return ans%mod;
	}
   	static void main() throws Exception{
   		fac=new long[500001];
   		fac[0]=1;for(int i=1;i<fac.length;i++)fac[i]=(fac[i-1]*i)%mod;
   		int n=sc.nextInt(),k=sc.nextInt();
   		long ans=0;
   		for(int i=1;i<=n;i++) {
   			int multiples=(n/i)-1;
   			long ways=ncr(multiples, k-1);
   			ans=(ans+ways)%mod;
   		}
   		pw.println(ans);
	}
	public static void main(String[] args) throws Exception{
		pw=new PrintWriter(System.out);
		sc = new MScanner(System.in);
		int tc=1;
		while(tc-->0)main();
		pw.flush();
	}
	static PrintWriter pw;
	static MScanner  sc;
	static class MScanner {
		StringTokenizer st;
		BufferedReader br;
		public MScanner(InputStream system) {
			br = new BufferedReader(new InputStreamReader(system));
		}

		public MScanner(String file) throws Exception {
			br = new BufferedReader(new FileReader(file));
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}
		public int[] intArr(int n) throws IOException {
	        int[]in=new int[n];for(int i=0;i<n;i++)in[i]=nextInt();
	        return in;
		}
		public long[] longArr(int n) throws IOException {
	        long[]in=new long[n];for(int i=0;i<n;i++)in[i]=nextLong();
	        return in;
		}
		public int[] intSortedArr(int n) throws IOException {
	        int[]in=new int[n];for(int i=0;i<n;i++)in[i]=nextInt();
	        shuffle(in);
	        Arrays.sort(in);
	        return in;
		}
		public long[] longSortedArr(int n) throws IOException {
	        long[]in=new long[n];for(int i=0;i<n;i++)in[i]=nextLong();
	        shuffle(in);
	        Arrays.sort(in);
	        return in;
		}
		public Integer[] IntegerArr(int n) throws IOException {
	        Integer[]in=new Integer[n];for(int i=0;i<n;i++)in[i]=nextInt();
	        return in;
		}
		public Long[] LongArr(int n) throws IOException {
	        Long[]in=new Long[n];for(int i=0;i<n;i++)in[i]=nextLong();
	        return in;
		}
		public String nextLine() throws IOException {
			return br.readLine();
		}

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

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

		public char nextChar() throws IOException {
			return next().charAt(0);
		}

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

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

		public void waitForInput() throws InterruptedException {
			Thread.sleep(3000);
		}
	}
	static void shuffle(int[]in) {
		for(int i=0;i<in.length;i++) {
			int idx=(int)(Math.random()*in.length);
			int tmp=in[i];
			in[i]=in[idx];
			in[idx]=tmp;
		}
	}
	static void shuffle(long[]in) {
		for(int i=0;i<in.length;i++) {
			int idx=(int)(Math.random()*in.length);
			long tmp=in[i];
			in[i]=in[idx];
			in[idx]=tmp;
		}
	}
}

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

public class Solution {
    static long fact[],infact[],M;
    static long pow(long a,long b){
        if(b==0)
            return 1;
        long ans=pow(a,b/2);
        ans=(ans*ans)%M;
        if(b%2==1)
            ans=(ans*a)%M;
        return ans;
    }
    static long nCr(int a,int b){
        if(a-b<0 || b<0 || a<0)
            return 0;
        if(a-b==0 || b==0)
            return 1;
        return (fact[a]*infact[b]%M) *infact[a-b]%M;
    }
    public static void main(String args[]) throws IOException {
        Scanner in = new Scanner(System.in);
        StringBuilder sb = new StringBuilder();
        int MN=1000000,i,j;
        M=998244353;
        fact=new long[MN+1];
        infact=new long[MN+1];
        fact[0]=infact[0]=1;
        for(i=1;i<=MN;i++){
            fact[i]=fact[i-1]*i%M;
            infact[i]=pow(fact[i],M-2);
        }
        int n = in.nextInt();
        int k = in.nextInt();
        long ans=0;
        for(i=1;i<=n;i++){
            int x=n/i-1;
            ans=(ans+nCr(x,k-1))%M;
        }
        System.out.println(ans);

    }
}

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

public class Main {
    static long fact[],infact[],M;
    static long pow(long a,long b){
        long ans=1;
        while(b>0){
            if(b%2==1)
                ans=ans*a%M;
            a=a*a%M;
            b=b>>1;
        }
        return ans;
    }
    static long nCr(int a,int b){
        if(a-b<0 || b<0 || a<0)
            return 0;
        if(a-b==0 || b==0)
            return 1;
        return (fact[a]*infact[b]%M) *infact[a-b]%M;
    }
    public static void main(String args[]) throws IOException {
        Scanner in = new Scanner(System.in);
        StringBuilder sb = new StringBuilder();
        int MN=500000,i,j;
        M=998244353;
        fact=new long[MN+1];
        infact=new long[MN+1];
        fact[0]=infact[0]=1;
        for(i=1;i<=MN;i++){
            fact[i]=fact[i-1]*i%M;
            infact[i]=pow(fact[i],M-2);
        }
        int n = in.nextInt();
        int k = in.nextInt();
        long ans=0;
        for(i=1;i<=n;i++){
            int x=n/i-1;
            ans=(ans+nCr(x,k-1))%M;
        }
        System.out.println(ans);

    }
}

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

public class Main {
    static long fact[],infact[],M;
    static long pow(long a,long b){
        long ans=1;
        while(b>0){
            if(b%2==1)
                ans=ans*a%M;
            a=a*a%M;
            b=b>>1;
        }
        return ans;
    }
    static long nCr(int a,int b){
        if(a-b<0 || b<0 || a<0)
            return 0;
        if(a-b==0 || b==0)
            return 1;
        return (fact[a]*infact[b]%M) *infact[a-b]%M;
    }
    public static void main(String args[]) throws IOException {
        Scanner in = new Scanner(System.in);
        StringBuilder sb = new StringBuilder();
        int MN=1000000,i,j;
        M=998244353;
        fact=new long[MN+1];
        infact=new long[MN+1];
        fact[0]=infact[0]=1;
        for(i=1;i<=MN;i++){
            fact[i]=fact[i-1]*i%M;
            infact[i]=pow(fact[i],M-2);
        }
        int n = in.nextInt();
        int k = in.nextInt();
        long ans=0;
        for(i=1;i<=n;i++){
            int x=n/i-1;
            ans=(ans+nCr(x,k-1))%M;
        }
        System.out.println(ans);

    }
}

/**
 * @author egaeus
 * @mail sebegaeusprogram@gmail.com
 * @veredict Not sended
 * @url <https://codeforces.com/problemset/problem/>
 * @category ?
 * @date 28/05/2020
 **/

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

import static java.lang.Integer.*;
import static java.lang.Math.*;

public class CFE {
    static int N, K, MOD = 998244353;

    public static void main(String args[]) throws Throwable {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        for (String ln; (ln = in.readLine()) != null && !ln.equals(""); ) {
            StringTokenizer st = new StringTokenizer(ln);
            N = parseInt(st.nextToken());
            K = parseInt(st.nextToken());
            long s = 0;
            for (int i = 1; i <= N; i++) {
                    s = (s+f(N / i - 1, K - 1))%MOD;
                }
            System.out.println(s);
        }
    }

    static long f(int N, int K) {
        if (K > N) return 0;
        long ans = 1;
        for (long i = Math.max(K, N - K) + 1; i <= N; i++)
            ans = (ans * i) % MOD;
        for (long i = Math.min(K, N - K); i > 1; i--) {
            //System.out.println(i+" "+modInverse(i, MOD));
            ans = (ans * modInverse(i, MOD)) % MOD;
        }
        return ans;
    }

    //Existe si a y mod son coprimos
    static long modInverse(long a, long mod) {
        return euclidesExtendido(a, mod)[1]>0?euclidesExtendido(a, mod)[1]:mod+euclidesExtendido(a, mod)[1];
    }

    static long[] euclidesExtendido(long a, long b) {
        for (long q, s = 1, t = 0, s1 = 0, t1 = 1, x; ; ) {
            x = b;
            q = a / b;
            b = a % b;
            a = x;
            x = s1;
            s1 = s - q * s1;
            s = x;
            x = t1;
            t1 = t - q * t1;
            t = x;
            if (b == 0) return new long[]{a, s, t};
        }
    }
}

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

public class ModularStability {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Task solver = new Task();
        solver.solve(in, out);
        out.close();
    }
    // main solver
    static class Task{
        static int N = 500000;
        static int MOD = 998244353;
        static long[] fac = new long[N + 1];
        static long[] inv = new long[N + 1];
        public void solve(InputReader in, PrintWriter out) {
            int n = in.nextInt();
            int k = in.nextInt();
            if (n < k){
                out.println(0);
            }
            else{
                fac[0] = 1;
                inv[0] = 1;
                for (int i = 1; i <= n; i++){
                    fac[i] = (fac[i - 1] * i) % MOD;
                    inv[i] = pow(fac[i], MOD - 2);
                }
                long result = 0;
                for (int i = 1; i <= n; i++){
                    int au = n / i - 1;
                    if (au < k - 1){
                        break;
                    }
                    else{
                        long t = ((fac[au] * inv[au - (k - 1)]) % MOD * inv[k - 1]) % MOD;
                        result = (result + t) % MOD;
                    }
                }
                out.println(result);
            }
        }
        static long pow(long x, int y){
            if (y == 0){
                return 1;
            }
            else{
                long au = pow(x, y / 2);
                if (y % 2 == 0){
                    return (au * au) % MOD;
                }
                else{
                    return ((au * au) % MOD * x) % MOD;
                }
            }
        }
    }
    // fast input reader class;
    static class InputReader {
        BufferedReader br;
        StringTokenizer st;

        public InputReader(InputStream stream) {
            br = new BufferedReader(new InputStreamReader(stream));
        }

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

        public int nextInt() {
            return Integer.parseInt(nextToken());
        }
        public long nextLong(){
            return Long.parseLong(nextToken());
        }
    }
}

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

import java.lang.*;
import java.io.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.util.*;
/* Name of the class has to be "Main" only if the class is public. */
public class Codechef
{
	public static void main (String[] args) throws java.lang.Exception
	{
		// your code goes here
		FastReader sc = new FastReader();
		PrintWriter out = new PrintWriter(System.out);
		int n = sc.nextInt();
		int k = sc.nextInt();
		if(n<k) out.println("0");
		else if(k==1) out.println(n);
		else
		{
		    long m = 998244353;
		    long fact[] = fact((int)Math.pow(10,6),m);
		    //long temp1 = nCk(n-1,k-1,m,fact);
		    //long temp2=nCk((n/2)-1,k-1,m,fact);
		    long ans=0;
		    for(int i=1;i<=n/2;i++)
		    {
		        ans+=nCk((n/i)-1,k-1,m,fact);
		        ans=ans%m;
		        //out.println(ans);
		    }
		    out.println(ans);
		}
		out.close();
	}
	static long[] fact(int n,long m)
	{
	    long fact[] = new long[n+1];
	    fact[0]=1;
	    fact[1]=1;
	    for(int i=2;i<=n;i++)
	    {
	        fact[i]=(i*fact[i-1])%m;
	    }
	    return fact;
	}

	static long nCk(int n,int k,long m,long fact[])
	{
	    //formula for nCk is (n!/(k!*(n-k)!)) %m
	    if(k>n) return 0;
	    long ans=1;
	    ans=(ans*fact[n])%m;  // now the ans is n!%m

	    //Now we need to find ((k!)^-1)%m = ((k!%m)^(m-2))%m
	    //Using Fermats theorem i.e. (n^-1)%m = (n^(m-2))%m when m is prime

	    ans = (ans*mmi((int)fact[k],m))%m;
	    ans= (ans*mmi((int)fact[n-k],m))%m;
	    return ans;
	}
	static long mmi (int a,long n)
	{
	    return recursivePower(a,n-2,n);
	}
	static long recursivePower(int a,long n,long mod)
	{
	    if(a==0) return 0;
	    if(n==0) return 1;
	    long temp=recursivePower(a,n/2,mod);
	    long ans = ((temp%mod)*(temp%mod))%mod;

	    if(n%2==0)
	    {
	        return ans;
	    }
	    else
	    {
	        return ((a%mod)*(ans%mod))%mod;
	    }
	}

}

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.*;
import java.util.*;

public class F {

	static int MOD = 998244353;

	static int pow(long b, int e) {
		long ans = 1;
		while (e > 0) {
			if (e % 2 == 1)
				ans = ans * b % MOD;
			e >>= 1;
			b = b * b % MOD;
		}
		return (int) ans;
	}

	static int[] fac;

	static int nck(int n, int k) {
		if (k > n)
			return 0;
		long ans = fac[n];
		long den = fac[k] * 1L * fac[n - k] % MOD;
		return (int) (ans * pow(den, MOD - 2) % MOD);
	}

	public static void main(String[] args) throws IOException {
		Scanner sc = new Scanner();
		PrintWriter out = new PrintWriter(System.out);
		int n = sc.nextInt(), k = sc.nextInt();
		fac = new int[Math.max(n, k) + 10];
		fac[0] = 1;
		for (int i = 1; i < fac.length; i++)
			fac[i] = (int) (1L * fac[i - 1] * i % MOD);
		long ans = 0;
		for (int min = 1; min <= n; min++) {
			int mutltiples = n / min - 1;

			ans += nck(mutltiples, k - 1);
			ans %= MOD;
		}
		out.println(ans);
		out.close();

	}

	static class Scanner {
		BufferedReader br;
		StringTokenizer st;

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

		Scanner(String fileName) throws FileNotFoundException {
			br = new BufferedReader(new FileReader(fileName));
		}

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

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

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

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

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

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

		int[] nxtArr(int n) throws IOException {
			int[] ans = new int[n];
			for (int i = 0; i < n; i++)
				ans[i] = nextInt();
			return ans;
		}

	}

	static void sort(int[] a) {
		shuffle(a);
		Arrays.sort(a);
	}

	static void shuffle(int[] a) {
		int n = a.length;
		Random rand = new Random();
		for (int i = 0; i < n; i++) {
			int tmpIdx = rand.nextInt(n);
			int tmp = a[i];
			a[i] = a[tmpIdx];
			a[tmpIdx] = tmp;
		}
	}

}

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

public class E {
    static final boolean RUN_TIMING = false;
    static PushbackReader in = new PushbackReader(new BufferedReader(new InputStreamReader(System.in)), 1024);
    static PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    final long MOD = 998244353;
    long[] fact;
    long[] invFact;

    public void go() throws IOException {
        // in = new PushbackReader(new BufferedReader(new FileReader(new File("test.txt"))), 1024);
        // out = new PrintWriter(new FileWriter(new File("output.txt")));
        fact = new long[500001];
        invFact = new long[500001];
        fact[0] = 1;
        invFact[0] = 1;
        for (int i = 1; i < fact.length; i++) {
            fact[i] = fact[i-1] * i % MOD;
            invFact[i] = invFact[i-1] * inverse(i) % MOD;
        }
        int n = ipar();
        int k = ipar();
        long ans = 0;
        for (int i = 1; i <= n; i++) {
            if (n/i == 0 || k-1 > n/i-1) {
                break;
            }
            ans += nck(n/i-1, k-1);
            ans %= MOD;
        }
        out.println(ans);
    }

    public long nck(int n, int k) {
        return fact[n] * invFact[k] % MOD * invFact[n-k] % MOD;
    }

    public long inverse(long n) {
        return modPow(n, MOD-2);
    }

    public long modPow(long a, long b) {
        if (b == 0) {
            return 1;
        }
        if (b % 2 == 0) {
            return modPow(a*a%MOD, b/2);
        }
        return modPow(a*a%MOD, b/2) * a % MOD;
    }

    public int ipar() throws IOException {
        return Integer.parseInt(spar());
    }

    public int[] iapar(int n) throws IOException {
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = ipar();
        }
        return arr;
    }

    public long lpar() throws IOException {
        return Long.parseLong(spar());
    }

    public long[] lapar(int n) throws IOException {
        long[] arr = new long[n];
        for (int i = 0; i < n; i++) {
            arr[i] = lpar();
        }
        return arr;
    }

    public double dpar() throws IOException {
        return Double.parseDouble(spar());
    }

    public String spar() throws IOException {
        StringBuilder sb = new StringBuilder(1024);
        int c;
        do {
            c = in.read();
        } while (Character.isWhitespace(c) && c != -1);
        if (c == -1) {
            throw new NoSuchElementException("Reached EOF");
        }
        do {
            sb.append((char)c);
            c = in.read();
        } while (!Character.isWhitespace(c) && c != -1);
        while (c != '\n' && Character.isWhitespace(c) && c != -1) {
            c = in.read();
        }
        if (c != -1 && c != '\n') {
            in.unread(c);
        }
        return sb.toString();
    }

    public String linepar() throws IOException {
        StringBuilder sb = new StringBuilder(1024);
        int c;
        while ((c = in.read()) != '\n' && c != -1) {
            if (c == '\r') {
                continue;
            }
            sb.append((char)c);
        }
        return sb.toString();
    }

    public boolean haspar() throws IOException {
        String line = linepar();
        if (line.isEmpty()) {
            return false;
        }
        in.unread('\n');
        in.unread(line.toCharArray());
        return true;
    }

    public static void main(String[] args) throws IOException {
        long time = 0;
        time -= System.nanoTime();
        new E().go();
        time += System.nanoTime();
        if (RUN_TIMING) {
            System.out.printf("%.3f ms%n", time/1000000.0);
        }
        out.flush();
        in.close();
    }
}

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

import static java.lang.Math.*;
import static java.util.Arrays.*;

public class cf1359e {

    static int fact[] = new int[500005], invfact[] = new int[500005];

    public static void main(String[] args) throws IOException {
        int n = rni(), k = ni(), mod = 998244353;
        fact[0] = fact[1] = invfact[0] = invfact[1] = 1;
        for(int i = 2; i <= 500000; ++i) {
            fact[i] = fmul(fact[i - 1], i, mod);
            invfact[i] = fpow(fact[i], mod - 2, mod);
        }
        long ans = 0;
        for(int i = 1; i <= n / k; ++i) {
            int cnt = n / i;
            if(cnt >= k) {
                // prln(fmul(fact[cnt - 1], fmul(invfact[k - 1], invfact[cnt - k], mod), mod));
                ans = (ans + fmul(fact[cnt - 1], fmul(invfact[k - 1], invfact[cnt - k], mod), mod)) % mod;
            }
        }
        prln(ans);
        close();
    }

    static int fpow(int a, int b) {
        return fpow(a, b, IBIG);
    }

    static int fpow(int a, int b, int mod) {
        if(a == 0) {
            return 0;
        }
        long ans = 1, aL = a;
        while(b > 0) {
            if((b & 1) > 0) {
                ans = (ans * aL) % mod;
            }
            aL = (aL * aL) % mod;
            b >>= 1;
        }
        return (int)(ans % mod);
    }

    static int fmul(int a, int b) {
        return fmul(a, b, IBIG);
    }

    static int fmul(int a, int b, int mod) {
        long ans = 0, aL = a;
        while(b > 0) {
            if((b & 1) > 0) {
                ans = (ans + aL) % mod;
            }
            aL = (aL << 1) % mod;
            b >>= 1;
        }
        return (int)(ans % mod);
    }

    static BufferedReader __in = new BufferedReader(new InputStreamReader(System.in));
    static PrintWriter __out = new PrintWriter(new OutputStreamWriter(System.out));
    static StringTokenizer input;
    static Random rand = new Random();

    // references
    // IBIG = 1e9 + 7
    // IMAX ~= 2e10
    // LMAX ~= 9e18

    // constants
    static final int IBIG = 1000000007;
    static final int IMAX = 2147483647;
    static final int IMIN = -2147483648;
    static final long LMAX = 9223372036854775807L;
    static final long LMIN = -9223372036854775808L;
    // math util
    static int minof(int a, int b, int c) {return min(a, min(b, c));}
    static int minof(int... x) {if(x.length == 1) return x[0]; if(x.length == 2) return min(x[0], x[1]); if(x.length == 3) return min(x[0], min(x[1], x[2])); int min = x[0]; for(int i = 1; i < x.length; ++i) if(x[i] < min) min = x[i]; return min;}
    static long minof(long a, long b, long c) {return min(a, min(b, c));}
    static long minof(long... x) {if(x.length == 1) return x[0]; if(x.length == 2) return min(x[0], x[1]); if(x.length == 3) return min(x[0], min(x[1], x[2])); long min = x[0]; for(int i = 1; i < x.length; ++i) if(x[i] < min) min = x[i]; return min;}
    static int maxof(int a, int b, int c) {return max(a, max(b, c));}
    static int maxof(int... x) {if(x.length == 1) return x[0]; if(x.length == 2) return max(x[0], x[1]); if(x.length == 3) return max(x[0], max(x[1], x[2])); int max = x[0]; for(int i = 1; i < x.length; ++i) if(x[i] > max) max = x[i]; return max;}
    static long maxof(long a, long b, long c) {return max(a, max(b, c));}
    static long maxof(long... x) {if(x.length == 1) return x[0]; if(x.length == 2) return max(x[0], x[1]); if(x.length == 3) return max(x[0], max(x[1], x[2])); long max = x[0]; for(int i = 1; i < x.length; ++i) if(x[i] > max) max = x[i]; return max;}
    static int powi(int a, int b) {if(a == 0) return 0; int ans = 1; while(b > 0) {if((b & 1) > 0) ans *= a; a *= a; b >>= 1;} return ans;}
    static long powl(long a, int b) {if(a == 0) return 0; long ans = 1; while(b > 0) {if((b & 1) > 0) ans *= a; a *= a; b >>= 1;} return ans;}
    static int floori(double d) {return (int)d;}
    static int ceili(double d) {return (int)ceil(d);}
    static long floorl(double d) {return (long)d;}
    static long ceill(double d) {return (long)ceil(d);}
    static int randInt(int min, int max) {return rand.nextInt(max - min + 1) + min;}
    // array util
    static void reverse(int[] a) {for(int i = 0, n = a.length, half = n / 2; i < half; ++i) {int swap = a[i]; a[i] = a[n - i - 1]; a[n - i - 1] = swap;}}
    static void reverse(long[] a) {for(int i = 0, n = a.length, half = n / 2; i < half; ++i) {long swap = a[i]; a[i] = a[n - i - 1]; a[n - i - 1] = swap;}}
    static void reverse(double[] a) {for(int i = 0, n = a.length, half = n / 2; i < half; ++i) {double swap = a[i]; a[i] = a[n - i - 1]; a[n - i - 1] = swap;}}
    static void reverse(char[] a) {for(int i = 0, n = a.length, half = n / 2; i < half; ++i) {char swap = a[i]; a[i] = a[n - i - 1]; a[n - i - 1] = swap;}}
    static <T> void reverse(T[] a) {for(int i = 0, n = a.length, half = n / 2; i < half; ++i) {T swap = a[i]; a[i] = a[n - i - 1]; a[n - i - 1] = swap;}}
    static void shuffle(int[] a) {int n = a.length - 1; for(int i = 0; i < n; ++i) {int ind = randInt(i, n); int swap = a[i]; a[i] = a[ind]; a[ind] = swap;}}
    static void shuffle(long[] a) {int n = a.length - 1; for(int i = 0; i < n; ++i) {int ind = randInt(i, n); long swap = a[i]; a[i] = a[ind]; a[ind] = swap;}}
    static void shuffle(double[] a) {int n = a.length - 1; for(int i = 0; i < n; ++i) {int ind = randInt(i, n); double swap = a[i]; a[i] = a[ind]; a[ind] = swap;}}
    static void shuffle(char[] a) {int n = a.length - 1; for(int i = 0; i < n; ++i) {int ind = randInt(i, n); char swap = a[i]; a[i] = a[ind]; a[ind] = swap;}}
    static <T> void shuffle(T[] a) {int n = a.length - 1; for(int i = 0; i < n; ++i) {int ind = randInt(i, n); T swap = a[i]; a[i] = a[ind]; a[ind] = swap;}}
    static void rsort(int[] a) {shuffle(a); sort(a);}
    static void rsort(long[] a) {shuffle(a); sort(a);}
    static void rsort(double[] a) {shuffle(a); sort(a);}
    static void rsort(char[] a) {shuffle(a); sort(a);}
    static <T> void rsort(T[] a) {shuffle(a); sort(a);}
    // graph util
    static List<List<Integer>> graph(int n) {List<List<Integer>> g = new ArrayList<>(); for(int i = 0; i < n; ++i) g.add(new ArrayList<>()); return g;}
    static void connect(List<List<Integer>> g, int u, int v) {g.get(u).add(v); g.get(v).add(u);}
    static void connectDirected(List<List<Integer>> g, int u, int v) {g.get(u).add(v);};
    // input
    static void r() throws IOException {input = new StringTokenizer(__in.readLine());}
    static int ri() throws IOException {return Integer.parseInt(__in.readLine());}
    static long rl() throws IOException {return Long.parseLong(__in.readLine());}
    static int[] ria(int n) throws IOException {int[] a = new int[n]; input = new StringTokenizer(__in.readLine()); for(int i = 0; i < n; ++i) a[i] = Integer.parseInt(input.nextToken()); return a;}
    static int[] riam1(int n) throws IOException {int[] a = new int[n]; input = new StringTokenizer(__in.readLine()); for(int i = 0; i < n; ++i) a[i] = Integer.parseInt(input.nextToken()) - 1; return a;}
    static long[] rla(int n) throws IOException {long[] a = new long[n]; input = new StringTokenizer(__in.readLine()); for(int i = 0; i < n; ++i) a[i] = Long.parseLong(input.nextToken()); return a;}
    static char[] rcha() throws IOException {return __in.readLine().toCharArray();}
    static String rline() throws IOException {return __in.readLine();}
    static int rni() throws IOException {input = new StringTokenizer(__in.readLine()); return Integer.parseInt(input.nextToken());}
    static int ni() {return Integer.parseInt(input.nextToken());}
    static long rnl() throws IOException {input = new StringTokenizer(__in.readLine()); return Long.parseLong(input.nextToken());}
    static long nl() {return Long.parseLong(input.nextToken());}
    // output
    static void pr(int i) {__out.print(i);}
    static void prln(int i) {__out.println(i);}
    static void pr(long l) {__out.print(l);}
    static void prln(long l) {__out.println(l);}
    static void pr(double d) {__out.print(d);}
    static void prln(double d) {__out.println(d);}
    static void pr(char c) {__out.print(c);}
    static void prln(char c) {__out.println(c);}
    static void pr(char[] s) {__out.print(new String(s));}
    static void prln(char[] s) {__out.println(new String(s));}
    static void pr(String s) {__out.print(s);}
    static void prln(String s) {__out.println(s);}
    static void pr(Object o) {__out.print(o);}
    static void prln(Object o) {__out.println(o);}
    static void prln() {__out.println();}
    static void pryes() {__out.println("yes");}
    static void pry() {__out.println("Yes");}
    static void prY() {__out.println("YES");}
    static void prno() {__out.println("no");}
    static void prn() {__out.println("No");}
    static void prN() {__out.println("NO");}
    static void pryesno(boolean b) {__out.println(b ? "yes" : "no");};
    static void pryn(boolean b) {__out.println(b ? "Yes" : "No");}
    static void prYN(boolean b) {__out.println(b ? "YES" : "NO");}
    static void prln(int... a) {for(int i = 0, len = a.length - 1; i < len; __out.print(a[i]), __out.print(' '), ++i); __out.println(a[a.length - 1]);}
    static void prln(long... a) {for(int i = 0, len = a.length - 1; i < len; __out.print(a[i]), __out.print(' '), ++i); __out.println(a[a.length - 1]);}
    static <T> void prln(Collection<T> c) {int n = c.size() - 1; Iterator<T> iter = c.iterator(); for(int i = 0; i < n; __out.print(iter.next()), __out.print(' '), ++i); __out.println(iter.next());}
    static void h() {__out.println("hlfd");}
    static void flush() {__out.flush();}
    static void close() {__out.close();}
}

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

public class p5 {
    static int mod=998244353;
    public static void main(String[] uselessScrub) throws Exception {
        FastScanner in = new FastScanner();
        FastPrinter out = new FastPrinter();

        int n=in.nextInt(), k=in.nextInt();
        int i=1; long ans=0;
        while (n/i>=k) {
            ans+=choose_mod_two(n/i-1, k-1, mod);
            ans%=mod;
            i++;
        }
        out.println(ans);
        out.close();
    }

    public static long choose(int n, int k) {
        long ans=1;
        for (int i=1; i<=k; i++) {
            ans *= (n-(k-i));
            ans /= i;
        }
        System.out.println(ans);
        ans%=mod;
        return ans;
    }
    public static long choose_mod_two(long n, long k, long p)
    {
        // reduce n modulo p
        n %= p;
        // Trivial checks
        if (n < k) return 0;
        if (k == 0 || k == n) return 1;
        // Now 0 < k < n, save a bit of work if k > n/2
        if (k > n/2) k = n-k;
        // calculate numerator and denominator modulo p
         long num = n, den = 1;
        for(n = n-1; k > 1; --n, --k)
        {
            num = (num * n) % p;
            den = (den * k) % p;
        }
        // Invert denominator modulo p
        den = invert_mod(den,p);
        return (num * den) % p;
    }

    public static long invert_mod( long k,  long m)
    {
        if (m == 0) return (k == 1 || k == -1) ? k : 0;
        if (m < 0) m = -m;
        k %= m;
        if (k < 0) k += m;
        int neg = 1;
         long p1 = 1, p2 = 0, k1 = k, m1 = m, q, r, temp;
        while(k1 > 0) {
            q = m1 / k1;
            r = m1 % k1;
            temp = q*p1 + p2;
            p2 = p1;
            p1 = temp;
            m1 = k1;
            k1 = r;
            neg = 1-neg;
        }
        return neg==1 ? m - p2 : p2;
    }

    private static class FastPrinter {
        static final char ENDL = '\n';
        StringBuilder buf;
        PrintWriter pw;

        public FastPrinter() {
            buf = new StringBuilder();
            pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
        }

        public FastPrinter(OutputStream stream) {
            buf = new StringBuilder();
            pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(stream)));
        }

        public FastPrinter(String fileName) throws Exception {
            buf = new StringBuilder();
            pw = new PrintWriter(new BufferedWriter(new FileWriter(fileName)));
        }

        public FastPrinter(StringBuilder buf) {
            this.buf = buf;
        }

        public void print(int a) {
            buf.append(a);
        }

        public void print(long a) {
            buf.append(a);
        }

        public void print(char a) {
            buf.append(a);
        }

        public void print(char[] a) {
            buf.append(a);
        }

        public void print(double a) {
            buf.append(a);
        }

        public void print(String a) {
            buf.append(a);
        }

        public void print(Object a) {
            buf.append(a.toString());
        }

        public void println() {
            buf.append(ENDL);
        }

        public void println(int a) {
            buf.append(a);
            buf.append(ENDL);
        }

        public void println(long a) {
            buf.append(a);
            buf.append(ENDL);
        }

        public void println(char a) {
            buf.append(a);
            buf.append(ENDL);
        }

        public void println(char[] a) {
            buf.append(a);
            buf.append(ENDL);
        }

        public void println(double a) {
            buf.append(a);
            buf.append(ENDL);
        }

        public void println(String a) {
            buf.append(a);
            buf.append(ENDL);
        }

        public void println(Object a) {
            buf.append(a.toString());
            buf.append(ENDL);
        }

        public void close() {
            pw.print(buf);
            pw.close();
        }

        public void flush() {
            pw.print(buf);
            pw.flush();
            buf.setLength(0);
        }

    }

    private static class FastScanner {
        final private int BUFFER_SIZE = 1 << 10;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;

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

        public FastScanner(InputStream stream) {
            din = new DataInputStream(stream);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public FastScanner(String fileName) throws IOException {
            Path p = Paths.get(fileName);
            buffer = Files.readAllBytes(p);
            bytesRead = buffer.length;
        }

        int[] nextIntArray(int N) throws IOException {
            int[] arr = new int[N];
            for (int i = 0; i < N; i++) arr[i] = nextInt();
            return arr;
        }

        int[][] nextDoubleIntArray(int n, int m) throws IOException {
            int[][] arr = new int[n][m];
            for (int i=0; i<n; i++) for (int j=0; j<m; j++) arr[i][j]=nextInt();
            return arr;
        }

        String nextLine() throws IOException {
            int c = read();
            while (c != -1 && isEndline(c))
                c = read();
            if (c == -1) {
                return null;
            }
            StringBuilder res = new StringBuilder();
            do {
                if (c >= 0) {
                    res.appendCodePoint(c);
                }
                c = read();
            } while (!isEndline(c));
            return res.toString();
        }

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

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

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

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

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

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

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

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

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

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

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

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

        private int readOutSpaces() throws IOException {
            while (true) {
                if (bufferPointer == bytesRead) fillBuffer();
                int c = buffer[bufferPointer++];
                if (!isSpaceChar(c)) {
                    return c;
                }
            }
        }

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

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Arrays;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.BufferedOutputStream;
import java.io.UncheckedIOException;
import java.util.Objects;
import java.nio.charset.Charset;
import java.util.StringTokenizer;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.BufferedReader;
import java.io.InputStream;

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

    static class EModularStability {
        private static final int MOD = 998244353;

        public void solve(int testNumber, LightScanner in, LightWriter out) {
            int n = in.ints(), k = in.ints();
            ModMath mod = new ModMath(MOD);
            Factorial fact = mod.getFactorial(Math.max(n, k) + 1);
            long ans = 0;
            for (int i = 1; i <= n; i++) {
                ans += fact.ncr(n / i - 1, k - 1);
            }
            out.ans(ans % MOD).ln();
        }

    }

    static class Vec3i implements Comparable<Vec3i> {
        public int x;
        public int y;
        public int z;

        public Vec3i(int x, int y, int z) {
            this.x = x;
            this.y = y;
            this.z = z;
        }

        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Vec3i vec3i = (Vec3i) o;
            return x == vec3i.x &&
                    y == vec3i.y &&
                    z == vec3i.z;
        }

        public int hashCode() {
            return Objects.hash(x, y, z);
        }

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

        public int compareTo(Vec3i o) {
            if (x == o.x) {
                if (y == o.y) {
                    return Integer.compare(z, o.z);
                }
                return Integer.compare(y, o.z);
            }
            return Integer.compare(x, o.x);
        }

    }

    static class LightScanner implements AutoCloseable {
        private BufferedReader reader = null;
        private StringTokenizer tokenizer = null;

        public LightScanner(InputStream in) {
            reader = new BufferedReader(new InputStreamReader(in));
        }

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

        public int ints() {
            return Integer.parseInt(string());
        }

        public void close() {
            try {
                this.reader.close();
            } catch (IOException ex) {
                throw new UncheckedIOException(ex);
            }
        }

    }

    static class ModMath {
        private static final int DEFAULT_MOD = 1_000_000_007;
        private final long mod;

        public ModMath(long mod, boolean unsafe) {
        /*if (!unsafe && !IntMath.isPrime(mod)) {
            throw new RuntimeException("This class is designed for primes!");
        }*/
            this.mod = mod;
        }

        public ModMath(long mod) {
            this(mod, false);
        }

        public ModMath() {
            this(DEFAULT_MOD, true);
        }

        public long mod(long x) {
            x %= mod;
            return x < 0 ? x + mod : x;
        }

        public long inv(long x) {
            //return pow(x, mod - 2);
            return mod(LongEuclidSolver.solve(x, mod).x);
        }

        public Factorial getFactorial(int n) {
            return new Factorial(this, n);
        }

    }

    static class LongEuclidSolver {
        private LongEuclidSolver() {
        }

        public static Vec3l solve(long a, long b) {
            LongEuclidSolver.ReferenceLong p = new LongEuclidSolver.ReferenceLong(), q = new LongEuclidSolver.ReferenceLong();
            long d = solve(a, b, p, q);
            return new Vec3l(p.val, q.val, d);
        }

        private static long solve(long a, long b, LongEuclidSolver.ReferenceLong p, LongEuclidSolver.ReferenceLong q) {
            if (b == 0) {
                p.val = 1;
                q.val = 0;
                return a;
            } else {
                long d = solve(b, a % b, q, p);
                q.val -= (a / b) * p.val;
                return d;
            }
        }

        private static class ReferenceLong {
            private long val;

        }

    }

    static class Vec3l implements Comparable<Vec3l> {
        public long x;
        public long y;
        public long z;

        public Vec3l(long x, long y, long z) {
            this.x = x;
            this.y = y;
            this.z = z;
        }

        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Vec3i vec3i = (Vec3i) o;
            return x == vec3i.x &&
                    y == vec3i.y &&
                    z == vec3i.z;
        }

        public int hashCode() {
            return Objects.hash(x, y, z);
        }

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

        public int compareTo(Vec3l o) {
            if (x == o.x) {
                if (y == o.y) {
                    return Long.compare(z, o.z);
                }
                return Long.compare(y, o.z);
            }
            return Long.compare(x, o.x);
        }

    }

    static class Factorial {
        private final ModMath mod;
        private final long[] natural;
        private final long[] reverse;

        public Factorial(ModMath mod, int max) {
            this.mod = mod;
            this.natural = new long[max];
            this.reverse = new long[max];
            natural[0] = 1;
            for (int i = 1; i < max; i++) {
                natural[i] = mod.mod(natural[i - 1] * i);
            }
            reverse[max - 1] = mod.inv(natural[max - 1]);
            for (int i = max - 1; i > 0; i--) {
                reverse[i - 1] = mod.mod(reverse[i] * i);
            }
        }

        public long fact(long x) {
            return natural[(int) x];
        }

        public long factinv(long x) {
            return reverse[(int) x];
        }

        public long npr(long n, long r) {
            return n < r ? 0 : mod.mod(fact(n) * factinv(n - r));
        }

        public long ncr(long n, long r) {
            return mod.mod(npr(n, r) * factinv(r));
        }

        public String toString() {
            return "Factorial{" +
                    "natural=" + Arrays.toString(natural) +
                    ", reverse=" + Arrays.toString(reverse) +
                    '}';
        }

    }

    static class LightWriter implements AutoCloseable {
        private final Writer out;
        private boolean autoflush = false;
        private boolean breaked = true;

        public LightWriter(Writer out) {
            this.out = out;
        }

        public LightWriter(OutputStream out) {
            this(new OutputStreamWriter(new BufferedOutputStream(out), Charset.defaultCharset()));
        }

        public LightWriter print(char c) {
            try {
                out.write(c);
                breaked = false;
            } catch (IOException ex) {
                throw new UncheckedIOException(ex);
            }
            return this;
        }

        public LightWriter print(String s) {
            try {
                out.write(s, 0, s.length());
                breaked = false;
            } catch (IOException ex) {
                throw new UncheckedIOException(ex);
            }
            return this;
        }

        public LightWriter ans(String s) {
            if (!breaked) {
                print(' ');
            }
            return print(s);
        }

        public LightWriter ans(long l) {
            return ans(Long.toString(l));
        }

        public LightWriter ln() {
            print(System.lineSeparator());
            breaked = true;
            if (autoflush) {
                try {
                    out.flush();
                } catch (IOException ex) {
                    throw new UncheckedIOException(ex);
                }
            }
            return this;
        }

        public void close() {
            try {
                out.close();
            } catch (IOException ex) {
                throw new UncheckedIOException(ex);
            }
        }

    }
}

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

public class E {
    private static final int MOD = 998_244_353;
    private long[] facts;

    public static void main(String[] args) {
        try {
            FastScanner in = new FastScanner(System.in);
            PrintWriter out = new PrintWriter(System.out);
            int n = in.nextInt(), k = in.nextInt();

            int solution = solve(n, k);
            out.printf("%d\n", solution);
            out.close();

        } catch(Exception exc) {
            throw new RuntimeException(exc);
        }
    }

    private static int solve(int n, int k) {
        if (n < k) return 0;

        long[] facts = getFactorials(n);

        long ret = 0;
        for (int i = 1; i <= n; i++) {
            int numDividedBy = n / i;
            if (numDividedBy < k) break;
            ret += choose(numDividedBy - 1, k - 1, facts);
            //System.out.println(ret);
            ret %= MOD;
        }
        return (int) ret;
    }

    private static long[] getFactorials(int n) {
        long[] facts = new long[n + 1];
        facts[0] = 1;
        for (int i = 1; i <= n; i++) facts[i] = (facts[i - 1] * i) % MOD;
        return facts;
    }

    private static long choose(int n, int k, long[] facts) {
        return (facts[n] * inverse(facts[n - k]) % MOD) * inverse(facts[k]) % MOD;
    }

    private static long inverse(long x) {
        long ret = 1;
        int k = MOD - 2;
        while (k > 0) {
            if (k % 2 == 1) ret = (ret * x) % MOD;
            x = x * x % MOD;
            k >>= 1;
        }
        return ret;
    }

    //@
    static class FastScanner {
        StringTokenizer st;
        BufferedReader br;

        public FastScanner(InputStream i) {
            br = new BufferedReader(new InputStreamReader(i));
            st = new StringTokenizer("");
        }

        public String next() throws IOException {
            if(st.hasMoreTokens())
                return st.nextToken();
            else
                st = new StringTokenizer(br.readLine());
            return next();
        }

        public int nextInt() throws IOException {
            return Integer.parseInt(next());
        }
        //#
        public long nextLong() throws IOException {
            return Long.parseLong(next());
        }
        public double nextDouble() throws IOException {
            return Double.parseDouble(next());
        }
        //$
    }
}

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

public class E {

    static long A = 998244353l;
    static long[] fact;
    static void gen(){
        fact = new long[500002];
        fact[0] = 1;
        for(int i=1;i<fact.length;i++){
            fact[i] = fact[i-1]*i;
            fact[i]%=A;
        }
    }
    static long binomialCoeff(int n, int k)
    {
        if(k<0)return 0;
        if(k==0)return 1;
        if(k==n)return 1;
        if(k>n)return 0;
        BigInteger factn = new BigInteger(fact[n]+"");
        BigInteger factk = new BigInteger(fact[k]+"");
        BigInteger factnminusk = new BigInteger((fact[n-k])+"");
        BigInteger denominator = factk.multiply(factnminusk);
        denominator = denominator.mod(new BigInteger(A+""));
     //   denominator = denominator.modInverse(new BigInteger(A+""));
        BigInteger Dinv = denominator.modInverse(new BigInteger(A+""));
        BigInteger res = factn.multiply(Dinv);
        res = res.mod(new BigInteger(A+""));
        return res.longValue()%A;
    }
    public static void main(String[] args) throws IOException{
        Scanner sc = new Scanner(System.in);
        PrintWriter pw = new PrintWriter(System.out);
        int n = sc.nextInt();
        int k = sc.nextInt();
        if(k==1){
            pw.println(n);
        }else if(k==n){
            pw.println(1);
        }else {
            long res = 0;
            gen();
            //  System.out.println(binomialCoeff(6,2));
            for (int i = 1; i <= n - k; i++) {
                res += binomialCoeff((n - i) / i, k - 1);
                res %= A;
            }
            pw.println(res);
        }
        pw.flush();
        pw.close();
    }

    static class Pair implements Comparable<Pair>{
        long x,bitmask;
        public Pair(long x,long bitmask){
            this.x= x;
            this.bitmask = bitmask;
        }
        public int compareTo(Pair p){
            if(this.x==p.x)return Long.compare(this.bitmask,p.bitmask);
            return Long.compare(this.x,p.x);
        }
        public boolean equals(Object p){
            return (this.x==((Pair)p).x)&&(this.bitmask==((Pair)p).bitmask);
        }

    }
    static class Scanner {
        StringTokenizer st;
        BufferedReader br;

        public Scanner(FileReader r) {
            br = new BufferedReader(r);
        }

        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 int nextInt() throws IOException {
            return Integer.parseInt(next());
        }

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

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

        public double nextDouble() throws IOException {
            String x = next();
            StringBuilder sb = new StringBuilder("0");
            double res = 0, f = 1;
            boolean dec = false, neg = false;
            int start = 0;
            if (x.charAt(0) == '-') {
                neg = true;
                start++;
            }
            for (int i = start; i < x.length(); i++)
                if (x.charAt(i) == '.') {
                    res = Long.parseLong(sb.toString());
                    sb = new StringBuilder("0");
                    dec = true;
                } else {
                    sb.append(x.charAt(i));
                    if (dec)
                        f *= 10;
                }
            res += Long.parseLong(sb.toString()) / f;
            return res * (neg ? -1 : 1);
        }

        public boolean ready() throws IOException {
            return br.ready();

        }
    }
}

import java.io.BufferedOutputStream;
import java.io.Closeable;
import java.io.DataInputStream;
import java.io.Flushable;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.InputMismatchException;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
	static class TaskAdapter implements Runnable {
		@Override
		public void run() {
			long startTime = System.currentTimeMillis();
			InputStream inputStream = System.in;
			OutputStream outputStream = System.out;
			FastReader in = new FastReader(inputStream);
			Output out = new Output(outputStream);
			EModularStability solver = new EModularStability();
			solver.solve(1, in, out);
			out.close();
			System.err.println(System.currentTimeMillis()-startTime+"ms");
		}
	}

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

	static class EModularStability {
		private final int mod = 998244353;

		public EModularStability() {
		}

		public void solve(int kase, InputReader in, Output pw) {
			int n = in.nextInt(), k = in.nextInt();
			if(n<k) {
				pw.println("0");
				return;
			}
			long[] choose = Utilities.math.choose(n, k-1, mod);
			long ans = 0;
			for(int i = 1; i<=n; i++) {
				ans += choose[n/i-1];
			}
			pw.println(ans%mod);
		}

	}

	static interface InputReader {
		int nextInt();

	}

	static class Utilities {
		public static class math {
			public static long[] modInverse(int n, long mod) {
				long[] ret = new long[n+1];
				ret[1] = 1;
				for(int i = 2; i<=n; i++) {
					ret[i] = (-(mod/i)*ret[(int) (mod%i)])%mod;
					ret[i] += mod;
				}
				return ret;
			}

			public static long[] choose(int n, int k, long mod) {
				long[] ret = new long[n+1], inverse = modInverse(n-k, mod);
				ret[k] = 1;
				for(int i = k+1; i<=n; i++) {
					ret[i] = ((ret[i-1]*i)%mod*inverse[i-k])%mod;
				}
				return ret;
			}

		}

	}

	static class FastReader implements InputReader {
		final private int BUFFER_SIZE = 1<<16;
		private DataInputStream din;
		private byte[] buffer;
		private int bufferPointer;
		private int bytesRead;

		public FastReader(InputStream is) {
			din = new DataInputStream(is);
			buffer = new byte[BUFFER_SIZE];
			bufferPointer = bytesRead = 0;
		}

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

		private boolean isDigit(byte b) {
			return b>='0'&&b<='9';
		}

		private byte skipToDigit() {
			byte ret;
			while(!isDigit(ret = read())&&ret!='-') ;
			return ret;
		}

		private void fillBuffer() {
			try {
				bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
			}catch(IOException e) {
				e.printStackTrace();
				throw new InputMismatchException();
			}
			if(bytesRead==-1) {
				buffer[0] = -1;
			}
		}

		private byte read() {
			if(bytesRead==-1) {
				throw new InputMismatchException();
			}else if(bufferPointer==bytesRead) {
				fillBuffer();
			}
			return buffer[bufferPointer++];
		}

	}

	static class Output implements Closeable, Flushable {
		public StringBuilder sb;
		public OutputStream os;
		public int BUFFER_SIZE;
		public String lineSeparator;

		public Output(OutputStream os) {
			this(os, 1<<16);
		}

		public Output(OutputStream os, int bs) {
			BUFFER_SIZE = bs;
			sb = new StringBuilder(BUFFER_SIZE);
			this.os = new BufferedOutputStream(os, 1<<17);
			lineSeparator = System.lineSeparator();
		}

		public void println(long l) {
			println(String.valueOf(l));
		}

		public void println(String s) {
			sb.append(s);
			println();
		}

		public void println() {
			sb.append(lineSeparator);
		}

		private void flushToBuffer() {
			try {
				os.write(sb.toString().getBytes());
			}catch(IOException e) {
				e.printStackTrace();
			}
			sb = new StringBuilder(BUFFER_SIZE);
		}

		public void flush() {
			try {
				flushToBuffer();
				os.flush();
			}catch(IOException e) {
				e.printStackTrace();
			}
		}

		public void close() {
			flush();
			try {
				os.close();
			}catch(IOException e) {
				e.printStackTrace();
			}
		}

	}
}

import java.io.*;
import java.util.*;
public class Sol{
	final public static int MOD = 998244353;
	public static long fact[];
	public static void main(String[] args) throws IOException{
		FastIO sc = new FastIO(System.in);
		PrintWriter out = new PrintWriter(System.out);
		int n = sc.nextInt();
		int k = sc.nextInt();
		fact = new long[500001];
		fact[0] = 1;
		long ans = 0;
		for(int i=1; i<500001; ++i) {
			fact[i] = (fact[i-1]*i)%MOD;
		}
		int max = n/k;
		for(int i=1; i<=max; ++i) {
			int num = n/i;
			ans = (ans + nCr(num-1,k-1))%MOD;
		}
		System.out.println(ans);
		out.close();
	}
    public static long nCr(int n, int r) {
    	if(r==0) return 1;
    	return (fact[n]*modInv(fact[r],MOD)%MOD*modInv(fact[n-r],MOD)%MOD)%MOD;
    }
    public static long power(long x, long y)
    {
        long res = 1;
        x = x % MOD;

        while (y > 0)
        {
            if (y % 2 == 1)
                res = (res * x) % MOD;
            y = y >> 1;
            x = (x * x) % MOD;
        }

        return res;
    }
    public static long modInv(long n, int p)
    {
        return power(n, p-2);
    }
	static class FastIO {

		// Is your Fast I/O being bad?

		InputStream dis;
		byte[] buffer = new byte[1 << 17];
		int pointer = 0;

		public FastIO(String fileName) throws IOException {
			dis = new FileInputStream(fileName);
		}

		public FastIO(InputStream is) throws IOException {
			dis = is;
		}

		int nextInt() throws IOException {
			int ret = 0;

			byte b;
			do {
				b = nextByte();
			} while (b <= ' ');
			boolean negative = false;
			if (b == '-') {
				negative = true;
				b = nextByte();
			}
			while (b >= '0' && b <= '9') {
				ret = 10 * ret + b - '0';
				b = nextByte();
			}

			return (negative) ? -ret : ret;
		}

		long nextLong() throws IOException {
			long ret = 0;

			byte b;
			do {
				b = nextByte();
			} while (b <= ' ');
			boolean negative = false;
			if (b == '-') {
				negative = true;
				b = nextByte();
			}
			while (b >= '0' && b <= '9') {
				ret = 10 * ret + b - '0';
				b = nextByte();
			}

			return (negative) ? -ret : ret;
		}

		byte nextByte() throws IOException {
			if (pointer == buffer.length) {
				dis.read(buffer, 0, buffer.length);
				pointer = 0;
			}
			return buffer[pointer++];
		}

		String next() throws IOException {
			StringBuffer ret = new StringBuffer();

			byte b;
			do {
				b = nextByte();
			} while (b <= ' ');
			while (b > ' ') {
				ret.appendCodePoint(b);
				b = nextByte();
			}

			return ret.toString();
		}

	}
}

import java.util.Scanner;

public class E {
	static int [] factorial;
	static int MOD = 998244353;
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int k = sc.nextInt();
		factorial = new int[n+1];
		factorial[0] = 1;
		for(int i=1;i<=n;i++) {
			long x = (long) factorial[i-1]*i;
			x%=MOD;
			factorial[i] = (int) x;
		}
		int ans =0;
		for(int i=1;i<=n;i++) {
			int top = n/i-1;
			int bot = k-1;
			ans+=choose(top,bot);
			ans%=MOD;
		}
		System.out.println(ans);
	}
	static int choose(int n,int r) {
		if(r==n) return 1;
		if(r>n) return 0;
		int a = factorial[n];
		int b = factorial[r];
		int c = factorial[n-r];
		b = (int) exp(b,MOD-2);
		c = (int) exp(c,MOD-2);
		long x = (long) a*b;
		x%=MOD;
		x*=(long) c;
		return (int) ((x+MOD)%MOD);
	}

	static long exp(int base,int power) {
		if(base==0) return 0;
		if(power==0) return 1;
		if(power==1) return (base+MOD)%MOD;
		long ans = exp(base,power/2);
		ans = (ans*ans+MOD)%MOD;
		if(power%2==1) ans = (ans*base+MOD)%MOD;
		return (ans+MOD)%MOD;
	}

}

import java.io.*;
import java.util.StringTokenizer;
import java.util.stream.IntStream;

public class Main {
    private static final int MODULO = 998244353;
    private FastScanner in;
    private PrintWriter out;

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

    private void run() throws Exception {
        in = new FastScanner(System.in);
        out = new PrintWriter(System.out);
        solve();
        out.close();
    }

    private void solve() throws Exception {
        final int n = in.nextInt();
        final int k = in.nextInt();
        final C c = new C();
        c.init(MODULO, 600_000);
        long result = IntStream.rangeClosed(1, n)
                .map(min -> n / min)
                .filter(divNumber -> divNumber >= k)
                .mapToLong(divNumber -> c.getC(divNumber - 1, k - 1))
                .reduce(0, (a, b) -> (a + b) % MODULO);
        out.println(result);
    }

    private static class C {
        private long modulo;
        private long[] facts;
        private long[] invertedFacts;

        private void init(long modulo, int size) {
            this.modulo = modulo;
            this.facts = new long[size];
            this.invertedFacts = new long[size];
            this.facts[0] = 1;
            for (int i = 1; i < size; i++) {
                facts[i] = facts[i - 1] * i % modulo;
            }
            for (int i = 0; i < size; i++) {
                invertedFacts[i] = inverse(facts[i]);
            }
        }

        private long inverse(long value) {
            return pow(value, modulo - 2);
        }

        public long getC(int n, int k) {
            long div = invertedFacts[k] * invertedFacts[n - k] % modulo;
            return facts[n] * div % modulo;
        }

        private long pow(long a, long b) {
            long res = 1;
            while (b > 0) {
                if ((b & 1) == 0) {
                    a *= a;
                    a %= MODULO;
                    b = b >> 1;
                } else {
                    res *= a;
                    res %= MODULO;
                    b--;
                }
            }
            return res;
        }
    }

    private static class FastScanner implements Closeable {
        BufferedReader bufferedReader;
        StringTokenizer stringTokenizer;

        public FastScanner(InputStream inputStream) {
            this.bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        }

        public String next() throws IOException {
            while (stringTokenizer == null || !stringTokenizer.hasMoreTokens()) {
                String line = bufferedReader.readLine();
                if (line == null) {
                    throw new EOFException("End of input stream is reached.");
                }
                stringTokenizer = new StringTokenizer(line);
            }
            return stringTokenizer.nextToken();
        }

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

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

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

        @Override
        public void close() throws IOException {
            bufferedReader.close();
        }
    }
}

import java.util.*;
import java.io.*;
public class E88
{
    public static void main(String [] args)
    {
        MyScanner sc = new MyScanner();
        PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
        int t = 1;
        while (t > 0) {
            int n = sc.nextInt(); int k = sc.nextInt();
            long res = 0;
            initFac(n + 6);
            for (int i = 1; i <= n; i++) {
                int mul = n / i - 1;
                res = (res + nck(mul, k - 1)) % mod;
            }
            out.println(res);
            t--;
        }
        out.close();
    }

    static long[] fac;
    static long mod = (long) 998244353;

    static void initFac(long n) {
        fac = new long[(int)n + 1];
        fac[0] = 1;
        for (int i = 1; i <= n; i++) {
            fac[i] = (fac[i - 1]  * i) % mod;
        }
    }

    static long nck(int n, int k) {
        if (n < k)
            return 0;
        long den = inv((int) (fac[k] * fac[n - k] % mod));
        return fac[n] * den % mod;
    }

    static long pow(long b, long e) {
        long ans = 1;
        while (e > 0) {
            if (e % 2 == 1)
                ans = ans * b % mod;
            e >>= 1;
            b = b * b % mod;
        }
        return ans;
    }

    static long inv(long x) {
        return pow(x, mod - 2);
    }

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

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

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

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

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

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

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

    }

}

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

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

	void solve()
	{
		int n = ni(), K = ni();
		int mod = 998244353;
		int[][] fif = enumFIF(1000000, mod);
		long ans = 0;
		for(int i = 1;i <= n;i++){
			ans += C(n/i-1, K-1, mod, fif);
		}
		out.println(ans%mod);
	}

	public static long C(int n, int r, int mod, int[][] fif) {
		if (n < 0 || r < 0 || r > n)
			return 0;
		return (long) fif[0][n] * fif[1][r] % mod * fif[1][n - r] % mod;
	}

	public static int[][] enumFIF(int n, int mod) {
		int[] f = new int[n + 1];
		int[] invf = new int[n + 1];
		f[0] = 1;
		for (int i = 1; i <= n; i++) {
			f[i] = (int) ((long) f[i - 1] * i % mod);
		}
		long a = f[n];
		long b = mod;
		long p = 1, q = 0;
		while (b > 0) {
			long c = a / b;
			long d;
			d = a;
			a = b;
			b = d % b;
			d = p;
			p = q;
			q = d - c * q;
		}
		invf[n] = (int) (p < 0 ? p + mod : p);
		for (int i = n - 1; i >= 0; i--) {
			invf[i] = (int) ((long) invf[i + 1] * (i + 1) % mod);
		}
		return new int[][] { f, invf };
	}

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

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

	public static void main(String[] args) throws Exception { new E().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 boolean oj = System.getProperty("ONLINE_JUDGE") != null;
	private void tr(Object... o) { if(!oj)System.out.println(Arrays.deepToString(o)); }
}

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

public class Solution {
    public static void main(String[] args) throws IOException {
        Reader rd = new Reader();
        int n = rd.nextInt(), k = rd.nextInt();

        int MOD = 998244353;
        long ans = 0;
        ModMath mod = new ModMath(MOD);
        Factorial fc = mod.getFactorial(n);
        for(int i = 1; i <= n; i++) {
            // find the max ak(l * i)
            long l = n / i;
            // C(l - 1, k - 1)
            if(l < k) break;
            ans = mod.mod(ans + fc.ncr(l - 1, k - 1));
        }
        System.out.println(ans);
    }

    //Fast IO class
    static class Reader {
        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;

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

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

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

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

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

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

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

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

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

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

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

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

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

    private static void sort(double[] arr) {
        Double[] objArr = Arrays.stream(arr).boxed().toArray(Double[]::new);
        Arrays.sort(objArr);
        for (int i = 0; i < arr.length; i++) {
            arr[i] = objArr[i];
        }
    }

    private static void sort(int[] arr) {
        Integer[] objArr = Arrays.stream(arr).boxed().toArray(Integer[]::new);
        Arrays.sort(objArr);
        for (int i = 0; i < arr.length; i++) {
            arr[i] = objArr[i];
        }
    }

    private static void sort(long[] arr) {
        Long[] objArr = Arrays.stream(arr).boxed().toArray(Long[]::new);
        Arrays.sort(objArr);
        for (int i = 0; i < arr.length; i++) {
            arr[i] = objArr[i];
        }
    }

    static class ModMath {
        private static final int DEFAULT_MOD = 1_000_000_007;
        private final long mod;

        public ModMath(long mod, boolean unsafe) {
        /*if (!unsafe && !IntMath.isPrime(mod)) {
            throw new RuntimeException("This class is designed for primes!");
        }*/
            this.mod = mod;
        }

        public ModMath(long mod) {
            this(mod, false);
        }

        public ModMath() {
            this(DEFAULT_MOD, true);
        }

        public long mod(long x) {
            x %= mod;
            return x < 0 ? x + mod : x;
        }

        public long inv(long x) {
            //return pow(x, mod - 2);
            return mod(LongEuclidSolver.solve(x, mod).x);
        }

        public Factorial getFactorial(int n) {
            return new Factorial(this, n);
        }

    }

    static class Factorial {
        private final ModMath mod;
        private final long[] natural;
        private final long[] reverse;

        public Factorial(ModMath mod, int max) {
            this.mod = mod;
            this.natural = new long[max];
            this.reverse = new long[max];
            natural[0] = 1;
            for (int i = 1; i < max; i++) {
                natural[i] = mod.mod(natural[i - 1] * i);
            }
            reverse[max - 1] = mod.inv(natural[max - 1]);
            for (int i = max - 1; i > 0; i--) {
                reverse[i - 1] = mod.mod(reverse[i] * i);
            }
        }

        public long fact(long x) {
            return natural[(int) x];
        }

        public long factinv(long x) {
            return reverse[(int) x];
        }

        public long npr(long n, long r) {
            return n < r ? 0 : mod.mod(fact(n) * factinv(n - r));
        }

        public long ncr(long n, long r) {
            return mod.mod(npr(n, r) * factinv(r));
        }

        public String toString() {
            return "Factorial{" +
                    "natural=" + Arrays.toString(natural) +
                    ", reverse=" + Arrays.toString(reverse) +
                    '}';
        }

    }

    static class LongEuclidSolver {
        private LongEuclidSolver() {
        }

        public static Vec3l solve(long a, long b) {
            LongEuclidSolver.ReferenceLong p = new LongEuclidSolver.ReferenceLong(), q = new LongEuclidSolver.ReferenceLong();
            long d = solve(a, b, p, q);
            return new Vec3l(p.val, q.val, d);
        }

        private static long solve(long a, long b, LongEuclidSolver.ReferenceLong p, LongEuclidSolver.ReferenceLong q) {
            if (b == 0) {
                p.val = 1;
                q.val = 0;
                return a;
            } else {
                long d = solve(b, a % b, q, p);
                q.val -= (a / b) * p.val;
                return d;
            }
        }

        private static class ReferenceLong {
            private long val;

        }

    }

    static class Vec3l implements Comparable<Vec3l> {
        public long x;
        public long y;
        public long z;

        public Vec3l(long x, long y, long z) {
            this.x = x;
            this.y = y;
            this.z = z;
        }

        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Vec3i vec3i = (Vec3i) o;
            return x == vec3i.x &&
                    y == vec3i.y &&
                    z == vec3i.z;
        }

        public int hashCode() {
            return Objects.hash(x, y, z);
        }

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

        public int compareTo(Vec3l o) {
            if (x == o.x) {
                if (y == o.y) {
                    return Long.compare(z, o.z);
                }
                return Long.compare(y, o.z);
            }
            return Long.compare(x, o.x);
        }

    }

    static class Vec3i implements Comparable<Vec3i> {
        public int x;
        public int y;
        public int z;

        public Vec3i(int x, int y, int z) {
            this.x = x;
            this.y = y;
            this.z = z;
        }

        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Vec3i vec3i = (Vec3i) o;
            return x == vec3i.x &&
                    y == vec3i.y &&
                    z == vec3i.z;
        }

        public int hashCode() {
            return Objects.hash(x, y, z);
        }

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

        public int compareTo(Vec3i o) {
            if (x == o.x) {
                if (y == o.y) {
                    return Integer.compare(z, o.z);
                }
                return Integer.compare(y, o.z);
            }
            return Integer.compare(x, o.x);
        }

    }
}

/**
 * @author derrick20
 */
import java.io.*;
import java.util.*;

public class ModularStability {
    public static void main(String[] args) throws Exception {
        FastScanner sc = new FastScanner();
        PrintWriter out = new PrintWriter(System.out);

        int N = sc.nextInt();
        int K = sc.nextInt();
        if (N < K) {
            out.println(0);
        }
        else {
            fact = new long[(int) 5e5 + 1];
            factInv = new long[(int) 5e5 + 1];
            fact[0] = 1;
            factInv[0] = 1;
            for (int i = 1; i < fact.length; i++) {
                fact[i] = ((long) i * fact[i - 1]) % mod;
                factInv[i] = inv(fact[i]);
            }
            long ans = 0;
            for (int i = 1; i <= N; i++) {
                if (N / i >= K) {
                    // force this number, then we need to fill the remaining K - 1
                    // with numbers that are multiples of us.
                    // We can prove that any case that isn't a list of
                    // multiples of a number, we'll be able to find a pair a, b that
                    // doesn't have b = k * a, then we can choose x = b. This will
                    // give 0 if we order b first, but it'll give nonzero if a is placed
                    // first, then the b will be bigger so it won't change!
                    ans = (ans + choose(N / i - 1, K - 1)) % mod;
                }
            }
            out.println(ans);
        }
        out.close();
    }
    static long mod = 998244353;
    static long[] fact, factInv;
    static long choose(int n, int k) {
        long ans = (fact[n] * factInv[k]) % mod;
        return (ans * factInv[n - k]) % mod;
    }
    static long inv(long x) {
        return fastExpo(x, mod - 2);
    }

    static long fastExpo(long x, long k) {
        if (k == 0) {
            return 1;
        } else {
            long root = fastExpo(x, k / 2);
            long ans = (root * root) % mod;
            if (k % 2 == 1) {
                ans = (ans * x) % mod;
            }
            return ans;
        }
    }

    static class FastScanner {
        private int BS = 1<<16;
        private char NC = (char)0;
        private byte[] buf = new byte[BS];
        private int bId = 0, size = 0;
        private char c = NC;
        private double cnt = 1;
        private BufferedInputStream in;

        public FastScanner() {
            in = new BufferedInputStream(System.in, BS);
        }

        public FastScanner(String s) {
            try {
                in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
            }
            catch (Exception e) {
                in = new BufferedInputStream(System.in, BS);
            }
        }

        private char getChar(){
            while(bId==size) {
                try {
                    size = in.read(buf);
                }catch(Exception e) {
                    return NC;
                }
                if(size==-1)return NC;
                bId=0;
            }
            return (char)buf[bId++];
        }

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

        public int[] nextInts(int N) {
            int[] res = new int[N];
            for (int i = 0; i < N; i++) {
                res[i] = (int) nextLong();
            }
            return res;
        }

        public long[] nextLongs(int N) {
            long[] res = new long[N];
            for (int i = 0; i < N; i++) {
                res[i] = nextLong();
            }
            return res;
        }

        public long nextLong() {
            cnt=1;
            boolean neg = false;
            if(c==NC)c=getChar();
            for(;(c<'0' || c>'9'); c = getChar()) {
                if(c=='-')neg=true;
            }
            long res = 0;
            for(; c>='0' && c <='9'; c=getChar()) {
                res = (res<<3)+(res<<1)+c-'0';
                cnt*=10;
            }
            return neg?-res:res;
        }

        public double nextDouble() {
            double cur = nextLong();
            return c!='.' ? cur:cur+nextLong()/cnt;
        }

        public double[] nextDoubles(int N) {
            double[] res = new double[N];
            for (int i = 0; i < N; i++) {
                res[i] = nextDouble();
            }
            return res;
        }

        public String next() {
            StringBuilder res = new StringBuilder();
            while(c<=32)c=getChar();
            while(c>32) {
                res.append(c);
                c=getChar();
            }
            return res.toString();
        }

        public String nextLine() {
            StringBuilder res = new StringBuilder();
            while(c<=32)c=getChar();
            while(c!='\n') {
                res.append(c);
                c=getChar();
            }
            return res.toString();
        }

        public boolean hasNext() {
            if(c>32)return true;
            while(true) {
                c=getChar();
                if(c==NC)return false;
                else if(c>32)return true;
            }
        }
    }

    static void ASSERT(boolean assertion, String message) {
        if (!assertion) throw new AssertionError(message);
    }
}

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

import static java.lang.Math.*;

public class E {
    public static void main(String[] args) throws Exception {
        Scanner in = new Scanner(System.in);
        PrintWriter pw = new PrintWriter(System.out);
        int n = in.nextInt(), k = in.nextInt();
        if (n < k) {
            pw.println(0);
        } else {
            initialize(n + 10);
            long res = 0;
            if (k == 1) res = n;
            else {
                for (int i = 1; i <= n; i++) {
                    int cnt = n / i;
                    if (cnt >= k) {
                        res += nCr(cnt - 1, k - 1);
                        res %= mod;
                    }
                }
            }
            pw.println(res);
        }

        pw.close();
    }

    static long f[], inv[], mod = 998244353;

    static void initialize(int n) {
        f = new long[n + 1];
        f[0] = 1;
        for (int i = 1; i <= n; i++) {
            f[i] = (f[i - 1] * i) % mod;
        }
        inv = new long[n + 1];
        inv[n] = modInverse(f[n], mod);
        for (int i = n - 1; i >= 0; i--) {
            inv[i] = (inv[i + 1] * (i + 1)) % mod;
        }
    }

    static long nCr(int n, int c) {
        long u = f[n], d = (inv[c] * inv[n - c]) % mod;
        return (u * d) % mod;
    }

    public static long modInverse(long a, long m) {
        a = mod(a, m);
        return a == 0 ? 0 : mod((1 - modInverse(m % a, a) * m) / a, m);
    }

    public static long mod(long a, long m) {
        long A = (a % m);
        return A >= 0 ? A : A + m;
    }

    static void debug(Object... obj) {
        System.err.println(Arrays.deepToString(obj));
    }
}

import java.util.*;
import java.io.*;
 public class Main implements Runnable{
    FastScanner sc;
    PrintWriter pw;
    final class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        public FastScanner() {
            try {
                br = new BufferedReader(new InputStreamReader(System.in));
                st = new StringTokenizer(br.readLine());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

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

        public String next() {
            if (st.hasMoreTokens()) return st.nextToken();
            try {
                st = new StringTokenizer(br.readLine());
            } catch (Exception e) {
                e.printStackTrace();
            }
            return st.nextToken();
        }

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

        public String nli() {
            String line = "";
            if (st.hasMoreTokens()) line = st.nextToken();
            else try {
                return br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            while (st.hasMoreTokens()) line += " " + st.nextToken();
            return line;
        }

        public double nd() {
            return Double.parseDouble(next());
        }
    }
    public static void main(String[] args) throws Exception
    {
        new Thread(null,new Main(),"codeforces",1<<28).start();
    }
    public void run()
    {
        sc=new FastScanner();
        pw=new PrintWriter(System.out);
        solve();
        pw.flush();
        pw.close();
    }
    public long gcd(long a,long b)
    {
        return b==0L?a:gcd(b,a%b);
    }
    public long ppow(long a,long b,long mod)
    {
        if(b==0L)
        return 1L;
        long tmp=1;
        while(b>1L)
        {
            if((b&1L)==1)
            tmp*=a;
            a*=a;
            a%=mod;
            tmp%=mod;
            b>>=1;
        }
        return (tmp*a)%mod;
    }
    public  int gcd(int x,int y)
    {
        return y==0?x:gcd(y,x%y);
    }
    long[] fact,inv;
    long mod;
    //////////////////////////////////
    /////////////  LOGIC  ///////////
    ////////////////////////////////
    public void solve()
    {
        int T=1;
        while(T-->0)
        {
            int n,k;
            n=sc.ni();
            k=sc.ni();
            if(k==1)
            {
                pw.println(n);
                return;
            }
            fact=new long[n+1];
            inv=new long[n+1];
            mod=998244353;
            fact[0]=1;
            for(int i=1;i<=n;i++)
            {
                fact[i]=fact[i-1]*i;
                fact[i]%=mod;
                inv[i]=ppow(fact[i],mod-2,mod);
            }
            long ans=0;
            for(int i=1;i<=n;i++)
            {
                int x=n/i;
                if(x-1>0)
                ans+=ncr(x-1,k-1);
                ans%=mod;
            }
            pw.println(ans);
        }
    }
    public long ncr(int n,int r)
    {
        if(n==r)
              return 1;
        if(r>n)
              return 0;
         if(r==0)
              return 1;
        long tmp=fact[n];
        long tmp2=inv[n-r];
        tmp=(tmp*tmp2)%mod;
        tmp=(tmp*inv[r])%mod;
        return tmp;
    }
}

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

     public static void main(String []args) throws Exception{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        int n = Integer.parseInt(st.nextToken());
        int k = Integer.parseInt(st.nextToken());
        int mod = 998244353;
        if(n >= k){
            long[] fact = new long[n];
            fact[0] = 1;
            for(int i = 1; i < n; i++)
                fact[i] = (i*fact[i-1])%mod;
            long ans = 0;
            for(int i = 1; n >= i*k; i++){
                int l = n/i;
                long stuff = fact[l-1];
                stuff = (stuff*power(fact[k-1],mod-2,mod))%mod;
                stuff = (stuff*power(fact[l-k],mod-2,mod))%mod;
                ans = (ans + stuff)%mod;
            }
            System.out.println(ans);
        }
        else
            System.out.println(0);
     }
     static void modInverse(int a, int m)
    {
            System.out.println("Modular multiplicative inverse is " +
                                power(a, m - 2, m));
    }

    // To compute x^y under modulo m
    static long power(long x, int y, int m)
    {
        if (y == 0)
            return 1;

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

        if (y % 2 == 0)
            return p;
        else
            return (x * p) % m;
    }
}

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

public class E implements Runnable {
	boolean oj = false;
	Reader scn;
	PrintWriter out;
	String INPUT = "";

	void solve() {
		int n = scn.nextInt(), k = scn.nextInt(), mod = 998244353;

		long[] fact = new long[n + k + 1];
		long[] ifact = new long[fact.length];

		fact[0] = 1;
		for (int i = 1; i < fact.length; i++) {
			fact[i] = i * fact[i - 1] % mod;
		}
		ifact[fact.length - 1] = pow(fact[fact.length - 1], mod - 2, mod);
		for (int i = fact.length - 2; i >= 0; i--) {
			ifact[i] = ifact[i + 1] * (i + 1) % mod;
		}

		long ans = 0;
		for(int cur = 1; cur <= n; cur++) {
			int tot = n / cur;
			long rv = ncr(fact, ifact, tot - 1, k - 1, mod);
			ans += rv;
			ans %= mod;
		}
		out.println(ans);
	}

	long ncr(long[] fact, long[] ifact, int n, int r, int mod) {
		if(n < r || n < 0 || r < 0) {
			return 0;
		}
		return (fact[n] * ifact[r]) % mod * ifact[n - r] % mod;
	}

	long pow(long a, long x, long m) {
		long rv = 1;
		while (x != 0) {
			if ((x & 1) == 1) {
				rv = (rv * a) % m;
			}
			a = (a * a) % m;
			x = x >> 1;
		}
		return rv;
	}

	public void run() {
		long time = System.currentTimeMillis();
		boolean judge = System.getProperty("ONLINE_JUDGE") != null || oj;
		out = new PrintWriter(System.out);
		scn = new Reader(judge);
		solve();
		out.flush();
		if (!judge) {
			System.out.println(Arrays.deepToString(new Object[] { System.currentTimeMillis() - time + " ms" }));
		}
	}

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

	class Reader {
		InputStream is;

		public Reader(boolean oj) {
			is = oj ? System.in : new ByteArrayInputStream(INPUT.getBytes());
		}

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

		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++];
		}

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

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

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

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

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

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

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

		int nextInt() {
			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();
			}
		}

		long nextLong() {
			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();
			}
		}

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

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

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

		long[][] next2Long(int n, int m) {
			long[][] arr = new long[n][];
			for (int i = 0; i < n; i++) {
				arr[i] = nextLongArr(m);
			}
			return arr;
		}

		int[][] next2Int(int n, int m) {
			int[][] arr = new int[n][];
			for (int i = 0; i < n; i++) {
				arr[i] = nextIntArr(m);
			}
			return arr;
		}

		long[] shuffle(long[] arr) {
			Random r = new Random();
			for (int i = 1, j; i < arr.length; i++) {
				j = r.nextInt(i);
				arr[i] = arr[i] ^ arr[j];
				arr[j] = arr[i] ^ arr[j];
				arr[i] = arr[i] ^ arr[j];
			}
			return arr;
		}

		int[] shuffle(int[] arr) {
			Random r = new Random();
			for (int i = 1, j; i < arr.length; i++) {
				j = r.nextInt(i);
				arr[i] = arr[i] ^ arr[j];
				arr[j] = arr[i] ^ arr[j];
				arr[i] = arr[i] ^ arr[j];
			}
			return arr;
		}

		long[] uniq(long[] arr) {
			arr = scn.shuffle(arr);
			Arrays.parallelSort(arr);
			long[] rv = new long[arr.length];
			int pos = 0;
			rv[pos++] = arr[0];
			for (int i = 1; i < arr.length; i++) {
				if (arr[i] != arr[i - 1]) {
					rv[pos++] = arr[i];
				}
			}
			return Arrays.copyOf(rv, pos);
		}

		int[] uniq(int[] arr) {
			arr = scn.shuffle(arr);
			Arrays.parallelSort(arr);
			int[] rv = new int[arr.length];
			int pos = 0;
			rv[pos++] = arr[0];
			for (int i = 1; i < arr.length; i++) {
				if (arr[i] != arr[i - 1]) {
					rv[pos++] = arr[i];
				}
			}
			return Arrays.copyOf(rv, pos);
		}

		long[] reverse(long[] arr) {
			int i = 0, j = arr.length - 1;
			while (i < j) {
				arr[i] = arr[i] ^ arr[j];
				arr[j] = arr[i] ^ arr[j];
				arr[i] = arr[i] ^ arr[j];
				i++;
				j--;
			}
			return arr;
		}

		int[] reverse(int[] arr) {
			int i = 0, j = arr.length - 1;
			while (i < j) {
				arr[i] = arr[i] ^ arr[j];
				arr[j] = arr[i] ^ arr[j];
				arr[i] = arr[i] ^ arr[j];
				i++;
				j--;
			}
			return arr;
		}

		long[] compres(long[] arr) {
			int n = arr.length;
			long[] rv = Arrays.copyOf(arr, n);
			rv = uniq(rv);
			for (int i = 0; i < n; i++) {
				arr[i] = Arrays.binarySearch(rv, arr[i]);
			}
			return arr;
		}

		int[] compres(int[] arr) {
			int n = arr.length;
			int[] rv = Arrays.copyOf(arr, n);
			rv = uniq(rv);
			for (int i = 0; i < n; i++) {
				arr[i] = Arrays.binarySearch(rv, arr[i]);
			}
			return arr;
		}

		void deepFillLong(Object array, long val) {
			if (!array.getClass().isArray()) {
				throw new IllegalArgumentException();
			}
			if (array instanceof long[]) {
				long[] intArray = (long[]) array;
				Arrays.fill(intArray, val);
			} else {
				Object[] objArray = (Object[]) array;
				for (Object obj : objArray) {
					deepFillLong(obj, val);
				}
			}
		}

		void deepFillInt(Object array, int val) {
			if (!array.getClass().isArray()) {
				throw new IllegalArgumentException();
			}
			if (array instanceof int[]) {
				int[] intArray = (int[]) array;
				Arrays.fill(intArray, val);
			} else {
				Object[] objArray = (Object[]) array;
				for (Object obj : objArray) {
					deepFillInt(obj, val);
				}
			}
		}

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

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

public class EducationRound688E {

	public static final int max = (int)5e5+10;
	public static final long mod = (long)998244353;
	public static long[] fact;
	public static long[] invfact;

	public static long nCr(int n, int r) {
		return (((fact[n] * invfact[n - r])%mod) * invfact[r])%mod;
	}

	public static void solve() {
		fact = new long[max];
		invfact = new long[max];
		fact[0] = invfact[0] = 1;
		for(int i = 1; i < max; i++) {
			fact[i] = fact[i - 1] * i;
			fact[i] %= mod;
			invfact[i] = invfact[i - 1] * ModInverse(i, mod);
			invfact[i] %= mod;
		}
		int n = s.nextInt();
		int k = s.nextInt();
		long ans = 0;
		for(int i = 1; i <= n; i++) {
			int mul = n/i;
			if(mul - 1 >= k - 1) {
				ans += nCr(mul - 1, k - 1);
				if(ans >= mod) ans -= mod;
			}
		}
		out.println(ans);
	}

	public static void main(String[] args) {
		out = new PrintWriter(new BufferedOutputStream(System.out));
		s = new FastReader();
		solve();
		out.close();
	}

	public static class Triplet {
		long gcd;
		long x;
		long y;

		Triplet(long gcd, long x, long y) {
			this.gcd = gcd;
			this.x = x;
			this.y = y;
		}
	}

	public static Triplet ExtendedEuclideanAlgo(long a, long b) {
		if (a == 0) {
			return new Triplet(b, 0, 1);
		}
		Triplet ans = ExtendedEuclideanAlgo(b % a, a);
		long x = ans.y - (b / a) * ans.x;
		long y = ans.x;
		return new Triplet(ans.gcd, x, y);
	}

	public static long ModInverse(long a, long m) {
		Triplet ans = ExtendedEuclideanAlgo(a, m);
		if (ans.gcd != 1) {
			//System.out.println("Multiplicative inverse doesnot exist");
			return -1;
		} else {
			//m is added to handle negative x
			long result = (ans.x % m + m) % m;
			return result;
		}
	}

	public static FastReader s;
	public static PrintWriter out;

	public static class FastReader {
		BufferedReader br;
		StringTokenizer st;

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

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

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

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

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

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

}

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

public class Main {
	static final long MOD = 998244353L;
	//static final long INF = 1000000000000000007L;
	static String letters = "abcdefghijklmnopqrstuvwxyz";
	//static final long MOD = 1000000007L;
	static final int INF = 1000000007;

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

		int N = sc.ni();
		int K = sc.ni();
		int L = K-1;
		long[] fac = new long[500001];
		fac[0] = 1L;
		for (int i = 1; i <= 500000; i++)
			fac[i] = (fac[i-1]*i)%MOD;
		long[] invFac = new long[500001];
		invFac[500000] = power(fac[500000],MOD-2,MOD);
		for (int i = 499999; i >= 0; i--) {
			invFac[i] = (invFac[i+1]*(i+1))%MOD;
		}

		long ans = 0;
		for (int i = 1; i <= N; i++) {
			int rem = N/i - 1;
			//rem choose L
			if (rem >= L) {
				long num = fac[rem];
				long denInv = (invFac[L]*invFac[rem-L])%MOD;
				long val = (num*denInv)%MOD;
				ans += val;
				ans %= MOD;
			}
		}

		pw.println(ans);

		pw.close();
	}

	public static long dist(long[] p1, long[] p2) {
		return (Math.abs(p2[0]-p1[0])+Math.abs(p2[1]-p1[1]));
	}

	//Find the GCD of two numbers
	public static long gcd(long a, long b) {
		if (a < b) return gcd(b,a);
		if (b == 0)
			return a;
		else
			return gcd(b,a%b);
	}

	//Fast exponentiation (x^y mod m)
	public static long power(long x, long y, long m) {
		if (y < 0) return 0L;
		long ans = 1;
		x %= m;
		while (y > 0) {
			if(y % 2 == 1)
				ans = (ans * x) % m;
			y /= 2;
			x = (x * x) % m;
		}
		return ans;
	}

	public static int[] shuffle(int[] array) {
		Random rgen = new Random();
		for (int i = 0; i < array.length; i++) {
		    int randomPosition = rgen.nextInt(array.length);
		    int temp = array[i];
		    array[i] = array[randomPosition];
		    array[randomPosition] = temp;
		}
		return array;
	}

	public static long[] shuffle(long[] array) {
		Random rgen = new Random();
		for (int i = 0; i < array.length; i++) {
		    int randomPosition = rgen.nextInt(array.length);
		    long temp = array[i];
		    array[i] = array[randomPosition];
		    array[randomPosition] = temp;
		}
		return array;
	}

	public static int[][] shuffle(int[][] array) {
		Random rgen = new Random();
		for (int i = 0; i < array.length; i++) {
		    int randomPosition = rgen.nextInt(array.length);
		    int[] temp = array[i];
		    array[i] = array[randomPosition];
		    array[randomPosition] = temp;
		}
		return array;
	}

    public static int[][] sort(int[][] array) {
    	//Sort an array (immune to quicksort TLE)

		Arrays.sort(array, new Comparator<int[]>() {
			  @Override
        	  public int compare(int[] a, int[] b) {
				  return a[0]-b[0]; //ascending order
	          }
		});
		return array;
	}

    public static long[][] sort(long[][] array) {
    	//Sort an array (immune to quicksort TLE)
		Random rgen = new Random();
		for (int i = 0; i < array.length; i++) {
		    int randomPosition = rgen.nextInt(array.length);
		    long[] temp = array[i];
		    array[i] = array[randomPosition];
		    array[randomPosition] = temp;
		}
		Arrays.sort(array, new Comparator<long[]>() {
			  @Override
        	  public int compare(long[] a, long[] b) {
				  if (a[0] < b[0])
					  return -1;
				  else
					  return 1;
	          }
		});
		return array;
	}

    static class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        public FastScanner() {
            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 ni() {
            return Integer.parseInt(next());
        }

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

        double nd() {
            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 {
    private static final boolean N_CASE = false;
    private static final int MOD = 998244353;
    private static final int N = 500005;
    private long[] frac;

    private long pow(long a, long n) {
        long ret = 1;
        long base = a;
        while (n > 0) {
            if ((n & 1) > 0) {
                ret = (ret * base) % MOD;
            }
            base = (base * base) % MOD;
            n >>= 1;
        }
        return ret;
    }

    private long inv(long a) {
        return pow(a, MOD - 2);
    }

    private void init() {
        frac = new long[N];
        frac[0] = frac[1] = 1;
        for (int i = 2; i < N; i++) {
            frac[i] = (frac[i - 1] * i) % MOD;
        }
    }

    private long c(int n, int m) {
        if (n == m || m == 0) {
            return 1;
        }

        return (((frac[n] * inv(frac[m])) % MOD) * inv(frac[n - m])) % MOD;
    }

    private void solve() {
        int n = sc.nextInt();
        int k = sc.nextInt();

        if (k == 1) {
            out.println(n);
            return;
        }

        long ans = 0;
        for (int i = 1; i <= n; i++) {
            int t = n / i;
            if (t >= k) {
                ans += c(t - 1, k - 1);
                ans %= MOD;
            }
        }
        out.println(ans);
    }

    private void run() {
        init();
        int T = N_CASE ? sc.nextInt() : 1;
        for (int t = 0; t < T; ++t) {
            solve();
        }
    }

    private static MyWriter out;
    private static MyScanner sc;

    private static class MyScanner {
        BufferedReader br;
        StringTokenizer st;

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

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

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

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

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

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

        List<Integer> nextList(int n) {
            List<Integer> list = new ArrayList<>();
            for (int i = 0; i < n; i++) {
                list.add(nextInt());
            }
            return list;
        }
    }

    private static class MyWriter extends PrintWriter {
        private MyWriter(OutputStream outputStream) {
            super(outputStream);
        }

        void printArray(int[] a) {
            for (int i = 0; i < a.length; ++i) {
                print(a[i]);
                print(i == a.length - 1 ? '\n' : ' ');
            }
        }

        void printlnArray(int[] a) {
            for (int v : a) {
                println(v);
            }
        }

        void printList(List<Integer> list) {
            for (int i = 0; i < list.size(); ++i) {
                print(list.get(i));
                print(i == list.size() - 1 ? '\n' : ' ');
            }
        }

        void printlnList(List<Integer> list) {
            list.forEach(this::println);
        }
    }

    public static void main(String[] args) {
        out = new MyWriter(new BufferedOutputStream(System.out));
        sc = new MyScanner();
        new Main().run();
        out.close();
    }
}

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

 public class Main	{
	static class book implements Comparable<book>{
		int t, a, b;
		public book(int x, int y, int z) {t=x;a=y;z=b;}
		public int compareTo(book b) {
			return Integer.compare(t, b.t);
		}

		@Override
		public boolean equals(Object obj) {
			book cur = (book)obj;
			return (t == cur.t && a == cur.a && b == cur.b);
		}
	}
   static class Pair implements Comparable<Pair>{

	   int a;
	   int b;
//	   int ind;
//	   public Pair(int x, long y) {a = x;b=y;}
	   public Pair(int x, int y) {a = x;b=y;}
//	   public Pair(int x,int y, int z){a=x;b=y;ind = z;}
	   public int compareTo(Pair p){
		   return b - p.b;
	   }
//		@Override
//		public int hashCode() {
//			final int prime = 31;
//			int result = 1;
//			result = prime * result + a;
//			result = prime * result + b;
//
//			return result;
//		}
//		@Override
//		public boolean equals(Object obj) {
//			Pair cur = (Pair)obj;
//			if((a==cur.a && b==cur.b))return true;
//			return false;
//		}
 }
  static class cell{
	  int a, b;
	  public cell(int x, int y) {
		  a = x;
		  b = y;
	  }
  }
static class TrieNode{
	TrieNode left, right;
	int cnt;
	public TrieNode() {
		cnt = 0;
	}
}
  public static int gcd(int a,int b)
  {
    if(a<b)
      return gcd(b,a);
    if(b==0)
      return a;
    return gcd(b,a%b);

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

    public static void main(String[] args) throws Exception {
       new Thread(null, null, "Anshum Gupta", 99999999) {
            public void run() {
                try {
                    solve();
                } catch(Exception e) {
                    e.printStackTrace();
                    System.exit(1);
                }
            }
        }.start();
    }

static long pow(long x,long y){
    if(y == 0)return 1;
    if(y==1)return x;
    long a = pow(x,y/2);
    a = (a*a)%mod;
    if(y%2==0){
        return a;
    }
    return (a*x)%mod;
}

static final long mxx = (long)(1e18+5);
static final int mxN = (int)(5e5 + 5);
static final int mxV = (int)(1e6+5);
static final long mod = 998244353;//(long)(1e9+7); //
static long[]fact,inv_fact;
static long my_inv(long a) {
	return pow(a,mod-2);
}
static long bin(int a,int b) {
	if(a < b || a<0 || b<0)return 0;
    return ((fact[a]*inv_fact[a-b])%mod * inv_fact[b])%mod;
}

static void make_facts() {
  fact=new long[mxN];
  inv_fact = new long[mxN];
  fact[0]=inv_fact[0]=1L;
  for(int i=1;i<mxN;i++) {
	   fact[i] = (i*fact[i-1])%mod;
	   inv_fact[i] = my_inv(fact[i]);
  }
}
static void lazy(int st, int e, int tn) {
	if(lazy[tn] != INF) {
		tree[tn] = Math.min(tree[tn], lazy[tn]);
		if(st != e) {
			lazy[2*tn] = Math.min(lazy[2*tn], lazy[tn]);
			lazy[2*tn+1] = Math.min(lazy[2*tn+1], lazy[tn]);
		}
		lazy[tn] = INF;
	}
}
static void update(int ind, int val, int st, int e, int tn) {
	if(st == e) {
		tree[tn] = val;
		return;
	}
	int mid = (st + e) >> 1;
  	if(ind <= mid)
		update(ind, val, st, mid, 2*tn);
  	else
		update(ind, val, mid+1, e, 2*tn+1);
	tree[tn] = Math.min(tree[2*tn], tree[2*tn+1]);
}
static int query(int l, int r, int st, int e, int tn) {
	if(st > r || e < l)return INF;

	if(st >= l && e <= r) {
		return tree[tn];
	}

	int mid = (st + e) >> 1;
	int x = query(l, r, st, mid, 2 * tn);
	int y = query(l, r, mid+1, e, 2 * tn + 1);
	return Math.min(x, y);
}
static int[]tree, lazy;
static final int INF = (int)1e9+5;
static ArrayList<ArrayList<Integer>> adj;
static boolean[]vis;
static int n, m, k;
 public static void solve() throws Exception {
   // solve the problem here
   MyScanner s = new MyScanner();
        out = new PrintWriter(new BufferedOutputStream(System.out), true);
        int tc = 1;//s.nextInt();
        make_facts();
        while(tc-->0){
        	n = s.nextInt();
        	k = s.nextInt();
        	if(n < k) {
        		out.println("0");
        		return;
        	}
        	if(k == 1) {
        		out.println(n);
        		return;
        	}
        	long res = 0;
        	for(int i=1; i <= n / k; i++) {
        		int cnt = (n - i) / i; // how many in range [2 * i, n] % i == 0 ?
//        		out.println(cnt);
        		res += bin(cnt, k - 1);
        		res %= mod;
        	}
        	out.println(res);
        }

        out.flush();
}

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

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

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

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

        int nextInt() { return Integer.parseInt(next()); }
        long nextLong() { return Long.parseLong(next()); }
        double nextDouble() { return Double.parseDouble(next()); }

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

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

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

    static class TaskC1 {
        public void solve(int testNumber, Scanner in, PrintWriter out) {
            long n = in.nextInt();
            long k = in.nextInt();
            long ans = 0;
            long mod = 998244353;

            if (n < k) out.println(0);
            else {
                if (k == 1) {
                    out.println(n);
                    return;
                }
                for (long i = 1; n / i >= k; i++) {
                    if (n / i == k) {
                        ans++;
                        ans %= mod;
                    } else {
                        long ans_ = 1;
                        for (long j = n / i - k + 1; j <= n / i - 1; j++) {
                            ans_ *= j;
                            ans_ %= mod;
                        }
                        long rep = ans_;
                        ans_ = 1;
                        for (long j = 2; j <= k - 1; j++) {
                            ans_ *= j;
                            ans_ %= mod;
                        }
                        long z = mod - 2, c = 0, j = 0;
                        while (z > 0) {
                            if (z % 2 == 1) {
                                while (j < c) {
                                    ans_ *= ans_;
                                    ans_ %= mod;
                                    j++;
                                }
                                rep *= ans_;
                                rep %= mod;
                            }
                            z /= 2;
                            c++;
                        }
                        ans += rep;
                        ans %= mod;
                    }
                }
                out.println(ans);
            }
        }

    }
}

import java.io.*;
import java.util.*;
public class Main
{
	final int maxn=(int)(5e5);
	final long mod=998244353;
	int n,k,freq[];
	private void solve()throws Exception
	{
		sieve();
		n=nextInt();
		k=nextInt();
		freq=new int[maxn+1];
		long ans=0;
		for(int i=1;i<=n;i++)
		{
			int mul=n/i-1;
			ans=(ans+choose(mul,k-1))%mod;
		}
		out.println(ans);
	}
	long choose(int n,int r)
	{
		if(r>n)
			return 0;
		r=Math.min(r,n-r);
		long ret=1;
		for(int i=r;i>=1;i--)
		{
			for(int j=i;j>1;)
			{
				int x=sieve[j];
				int p=0;
				while(j%x==0)
				{
					p++;
					j=j/x;
				}
				freq[x]+=p;
			}
		}
		for(int i=n;i>=n-r+1;i--)
		{
			for(int j=i;j>1;)
			{
				int x=sieve[j];
				int p=0;
				while(j%x==0)
				{
					p++;
					j=j/x;
				}
				int rem=Math.min(freq[x],p);
				freq[x]-=rem;
				p-=rem;
				ret=(ret*modpow(x,p))%mod;
			}
		}
		return ret;
	}
	int sieve[];
	void sieve(){
		sieve=new int[maxn+1];
		for(int i=1;i<=maxn;i++)
			sieve[i]=i;
		for(int i=2;i*i<=maxn;i++){
			if(sieve[i]==i){
				for(int j=i;j<=maxn;j+=i)
					sieve[j]=i;
			}
		}
	}
	long modpow(long a,long b){
	    long ret=1;
	    while(b!=0)
	    {
	        if(b%2==1)
	            ret=(ret*a)%mod;
	        a=(a*a)%mod;
	        b=b/2;
	    }
	    return ret;
	}

	///////////////////////////////////////////////////////////

	public void run()throws Exception
	{
		br=new BufferedReader(new InputStreamReader(System.in));
		st=null;
		out=new PrintWriter(System.out);

		solve();

		br.close();
		out.close();
	}
	public static void main(String args[])throws Exception{
		new Main().run();
	}
	BufferedReader br;
	StringTokenizer st;
	PrintWriter out;
	String nextToken()throws Exception{
		while(st==null || !st.hasMoreTokens())
		st=new StringTokenizer(br.readLine());
		return st.nextToken();
	}
	String nextLine()throws Exception{
		return br.readLine();
	}
	int nextInt()throws Exception{
		return Integer.parseInt(nextToken());
	}
	long nextLong()throws Exception{
		return Long.parseLong(nextToken());
	}
	double nextDouble()throws Exception{
		return Double.parseDouble(nextToken());
	}
}

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

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

    static class EModularStability {
        public void solve(int testNumber, FastReader s, PrintWriter out) {
            int N = s.nextInt(), K = s.nextInt();
            long MOD = (long) 998244353;
            long ans = 0;
            int i;
            for (i = 1; i <= N; ++i) {
                int count = N / i - 1;
                if (count >= K - 1) {
                    ans += nCrModPFermat(count, K - 1, MOD);
                    ans %= MOD;
                }
            }
            out.println(ans);
        }

        static long power(long x, long y, long p) {
            long res = 1L;
            x = x % p;
            while (y > 0) {
                if (y % 2L == 1L) {
                    res = (res * x) % p;
                }
                y = y >> 1L;
                x = (x * x) % p;
            }
            return res;
        }

        static long modInverse(long n, long p) {
            return power(n, p - 2, p);
        }

        static long nCrModPFermat(int n, int r, long p) {
            if (n < r) {
                return 0;
            }

            if (r == 0) {
                return 1;
            }

            long[] fac = new long[n + 1];
            fac[0] = 1L;

            for (long i = 1; i <= n; i++) {
                fac[(int) i] = (fac[(int) (i - 1)] * i) % p;
            }

            return ((fac[n] * modInverse(fac[r], p) % p) * (modInverse(fac[n - r], p) % p)) % p;
        }

    }

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

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

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

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

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

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

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

        }

    }
}

import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.InputMismatchException;

public class E1359 {
	static class Solver {

		long MOD = 998244353, fac[], ifac[], imoo[];
		long mul(long a, long b) { return (a * b) % MOD; }
		long add(long a, long b) { return (a + b) % MOD; }
		long pow(long b, long e) {
			if(e == 0) return 1;
			if(e == 1) return b % MOD;
			long sq = pow(b, e >> 1); sq = mul(sq, sq);
			return (e & 1L) > 0 ? mul(sq, b) : sq;
		}
		long imod(long n) { return pow(n, MOD - 2); }

		Solver() {
			fac = new long[500_420 + 69]; fac[0] = 1L;
			ifac = new long[500_420 + 69]; ifac[0] = 1L;
			for(int i = 1; i < fac.length; i++) {
				fac[i] = mul(fac[i - 1], i);
				ifac[i] = imod(fac[i]);
			}
		}

		long choose(int n, int k) {
			long den = mul(ifac[k], ifac[n - k]);
			return mul(fac[n], den);
		}

		int N, K;

		void solve(int testNumber, FastScanner s, PrintWriter out) {
			N = s.nextInt(); K = s.nextInt();
			long res = 0;
			for(int lo = 1; lo <= N; lo++) {
				int rem = N / lo - 1;
				if(rem >= K - 1)
					res = add(res, choose(rem, K - 1));
			}
			out.println(res);
		}

	}

	final static boolean cases = false;

	public static void main(String[] args) {

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

		Solver solver = new Solver();
		for (int t = 1, T = cases ? s.nextInt() : 1; t <= T; t++)
			solver.solve(t, s, out);

		out.close();

	}

	static int min(int a, int b) {
		return a < b ? a : b;
	}

	static int max(int a, int b) {
		return a > b ? a : b;
	}

	static long min(long a, long b) {
		return a < b ? a : b;
	}

	static long max(long a, long b) {
		return a > b ? a : b;
	}

	static int swap(int a, int b) {
		return a;
	}

	static Object swap(Object a, Object b) {
		return a;
	}

	static String ts(Object... o) {
		return Arrays.deepToString(o);
	}

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

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

		public FastScanner(File f) throws FileNotFoundException {
			this(new FileInputStream(f));
		}

		public FastScanner(String s) {
			this.stream = new ByteArrayInputStream(s.getBytes(StandardCharsets.UTF_8));
		}

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

		// Jacob Garbage

		public int[] nextIntArray(int N) {
			int[] ret = new int[N];
			for (int i = 0; i < N; i++)
				ret[i] = this.nextInt();
			return ret;
		}

		public int[][] next2DIntArray(int N, int M) {
			int[][] ret = new int[N][];
			for (int i = 0; i < N; i++)
				ret[i] = this.nextIntArray(M);
			return ret;
		}

		public long[] nextLongArray(int N) {
			long[] ret = new long[N];
			for (int i = 0; i < N; i++)
				ret[i] = this.nextLong();
			return ret;
		}

		public long[][] next2DLongArray(int N, int M) {
			long[][] ret = new long[N][];
			for (int i = 0; i < N; i++)
				ret[i] = nextLongArray(M);
			return ret;
		}

		public double[] nextDoubleArray(int N) {
			double[] ret = new double[N];
			for (int i = 0; i < N; i++)
				ret[i] = this.nextDouble();
			return ret;
		}

		public double[][] next2DDoubleArray(int N, int M) {
			double[][] ret = new double[N][];
			for (int i = 0; i < N; i++)
				ret[i] = this.nextDoubleArray(M);
			return ret;
		}

	}
}

import java.io.*;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.MathContext;
import java.math.RoundingMode;
import java.util.*;

/*
polyakoff
*/

public class Main {

    static FastReader in;
    static PrintWriter out;
    static Random rand = new Random();
    static final int oo = (int) 2e9;
    static final long OO = (long) 4e18;
    static final int MOD = 998244353;
    static final int N = (int) (5e5 + 5);

    static long[] f, f1;

    static long pow(long a, long b) {
        long res = 1;
        while (b != 0) {
            if ((b & 1) == 1)
                res = (res * a) % MOD;
            a = (a * a) % MOD;
            b >>= 1;
        }
        return res;
    }

    static void precalc() {
        f = new long[N]; f[0] = 1;
        f1 = new long[N]; f1[0] = 1;
        for (int i = 1; i < N; i++) {
            f[i] = (f[i - 1] * i) % MOD;
            f1[i] = pow(f[i], MOD - 2);
        }
    }

    static long C(int n, int k) {
        if (n < k)
            return 0;
        return f[n] * f1[n - k] % MOD * f1[k] % MOD;
    }

    static void solve() {
        int n = in.nextInt();
        int k = in.nextInt();

        precalc();

        long ans = 0;
        for (int fi = 1; fi <= n; fi++) {
            int max = n / fi;
            ans = (ans + C(max - 1, k - 1)) % MOD;
        }

        out.println(ans);
    }

    public static void main(String[] args) throws FileNotFoundException {
        in = new FastReader(System.in);
//        in = new FastReader(new FileInputStream("sometext.txt"));
        out = new PrintWriter(System.out);
//        out = new PrintWriter(new FileOutputStream("output.txt"));

        solve();

//        Thread thread = new Thread(null, () -> {
//            solve();
//        }, "Main", 1 << 28);
//        thread.start();
//        try {
//            thread.join();
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }

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

    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

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

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

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

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

        String next() {
            while (st == null || !st.hasMoreTokens()) {
                st = new StringTokenizer(nextLine());
            }
            return st.nextToken();
        }

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

    static void dbg(Object... args) {
        for (Object arg : args)
            out.print(arg + " ");
        out.println();
    }

}

import java.util.*;
import java.io.*;
public class A
{
      public static void main(String ar[]) throws Exception
      {
            BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
            String s1[]=br.readLine().split(" ");
            int n=Integer.parseInt(s1[0]);
            int k=Integer.parseInt(s1[1]);

            long mod=998244353;
            long fact[]=new long[n+1];
            long factInv[]=new long[n+1];

            fact[0]=1;
            for(int i=1;i<=n;i++)
             fact[i]=(fact[i-1]*i)%mod;

            factInv[0]=1;
            for(int i=1;i<=n;i++)
            {
                  factInv[i]=(factInv[i-1]*pow(i,mod-2,mod))%mod;
            }

            long S=0;
            for(int i=1;i<=n;i++)
            {
                  int u=n/i-1;
                  if(u<k-1)
                  { break; }

                  long x=fact[u];
                  x=(x*factInv[u-(k-1)])%mod;
                  x=(x*factInv[k-1])%mod;

                  S=(S+x)%mod;
            }

            System.out.println(S);
      }

      public static long pow(long a,long n,long mod)
      {
            long r=1;
            while(n>0)
            {
                  if(n%2==1)
                   r=(r*a)%mod;
                  a=(a*a)%mod;
                  n=n/2;
            }

            return r;
      }
}

import java.util.*;
import java.io.*;
import java.math.BigInteger;
import java.text.*;
public class cf1 {
    //static long mod = (long)1e9 + 7;
    static long mod = 998244353;
    static FastScanner f;
    static PrintWriter pw = new PrintWriter(System.out);
    static Scanner S = new Scanner(System.in);
    static long x0; static long y0;
    static long fact[];
    static long ncr(int n , int r) {
        if(r == 0) return 1;
        long ans = fact[n];
        ans = mul(mpow(fact[r] , mod - 2) , ans);
        ans = mul(mpow(fact[n - r] , mod - 2) , ans);
        return ans;
    }
    static void solve()throws IOException {
        int n = f.ni(); int k = f.ni();
        long ans = 0l;
        for(int i = 1; i <= n; ++i) {
            int num_d = n / i;
            if(num_d >= k) {
                //pn("n = " + (num_d - 1) + " " + " r = " + (k - 1));
                ans = adp(ans , ncr(num_d - 1 , k - 1));
            }
            else break;
        }
        pn(ans);
    }
    public static void main(String[] args)throws IOException {
        init();
        fact = new long[(int)1e6];
        fact[0] = 1;
        for(int i = 1; i < (int)1e6; ++i) {
            fact[i] = mul(i , fact[i - 1]);
        }
        int t = 1;
        while(t --> 0) {solve();}
        pw.flush();
        pw.close();
    }

/******************************END OF MAIN PROGRAM*******************************************/
    public static void init()throws IOException{if(System.getProperty("ONLINE_JUDGE")==null){f=new FastScanner("");}else{f=new FastScanner(System.in);}}
    public static class FastScanner {
        BufferedReader br;StringTokenizer st;
        FastScanner(InputStream stream){try{br=new BufferedReader(new InputStreamReader(stream));}catch(Exception e){e.printStackTrace();}}
        FastScanner(String str){try{br=new BufferedReader(new FileReader("!a.txt"));}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();}
        String nextLine()throws IOException{return br.readLine();}int ni(){return Integer.parseInt(next());}long nl(){return Long.parseLong(next());}double nextDouble(){return Double.parseDouble(next());}
    }
    public static void pn(Object o){pw.println(o);}
    public static void p(Object o){pw.print(o);}
    public static void pni(Object o){pw.println(o);pw.flush();}
    static int gcd(int a,int b){if(b==0)return a;else{return gcd(b,a%b);}}
    static long gcd(long a,long b){if(b==0l)return a;else{return gcd(b,a%b);}}
    static long lcm(long a,long b){return (a*b/gcd(a,b));}
    static long exgcd(long a,long b){if(b==0){x0=1;y0=0;return a;}long temp=exgcd(b,a%b);long t=x0;x0=y0;y0=t-a/b*y0;return temp;}
    static long pow(long a,long b){long res=1;while(b>0){if((b&1)==1)res=res*a;b>>=1;a=a*a;}return res;}
    static long mpow(long a,long b){long res=1;while(b>0){if((b&1)==1)res=((res%mod)*(a%mod))%mod;b>>=1;a=((a%mod)*(a%mod))%mod;}return res;}
    static long mul(long a , long b){return ((a%mod)*(b%mod)%mod);}
    static long adp(long a , long b){return ((a%mod)+(b%mod)%mod);}
    static boolean isPrime(long n){if(n<=1)return false;if(n<=3)return true;if(n%2==0||n%3==0)return false;for(long i=5;i*i<=n;i=i+6)if(n%i==0||n%(i+2)==0)return false;return true;}
    static 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 HashSet<Long> factors(long n){HashSet<Long> hs=new HashSet<Long>();for(long i=1;i<=(long)Math.sqrt(n);i++){if(n%i==0){hs.add(i);hs.add(n/i);}}return hs;}
    static HashSet<Integer> factors(int n){HashSet<Integer> hs=new HashSet<Integer>();for(int i=1;i<=(int)Math.sqrt(n);i++){if(n%i==0){hs.add(i);hs.add(n/i);}}return hs;}
    static HashSet<Long> pf(long n){HashSet<Long> ff=factors(n);HashSet<Long> ans=new HashSet<Long>();for(Long i:ff)if(isPrime(i))ans.add(i);return ans;}
    static HashSet<Integer> pf(int n){HashSet<Integer> ff=factors(n);HashSet<Integer> ans=new HashSet<Integer>();for(Integer i:ff)if(isPrime(i))ans.add(i);return ans;}
    static int[] inpint(int n){int arr[]=new int[n];for(int i=0;i<n;i++){arr[i]=f.ni();}return arr;}
    static long[] inplong(int n){long arr[] = new long[n];for(int i=0;i<n;i++){arr[i]=f.nl();}return arr;}
    static boolean ise(int x){return ((x&1)==0);}static boolean ise(long x){return ((x&1)==0);}
    static int gnv(char c){return Character.getNumericValue(c);}
    static int log(long x){return x==1?0:(1+log(x/2));} static int log(int x){return x==1?0:(1+log(x/2));}
    static void sort(int[] a){ArrayList<Integer> l=new ArrayList<>();for(int i:a)l.add(i);Collections.sort(l);for(int i=0;i<a.length;++i)a[i]=l.get(i);}
    static void sort(long[] a){ArrayList<Long> l=new ArrayList<>();for(long i:a)l.add(i);Collections.sort(l);for(int i=0;i<a.length;++i)a[i]=l.get(i);}
    static void sort(ArrayList<Integer> a){Collections.sort(a);}
}

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);
        TaskE solver = new TaskE();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskE {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int N = in.nextInt();
            int k = in.nextInt();
            if (k > N) {
                out.println(0);
            } else {
//            int[] base = new int[N];
//            for (int i = 0; i < N; i++) {
//                base[i] = i+1;
//            }
//            combinations(k, base);
//            int cnt = 0;
//            for (int i = 0; i < combs.size(); i++) {
//                ArrayList<int[]> perms = ArrayUtils.getPermutations(combs.get(i));
//                boolean flag = true;
//                iter:
//                for (int x = 0; x <= 100; x++) {
//                    int val = x%combs.get(i)[0];
//                    for (int[] p : perms) {
//                        int c = x;
//                        for (int a : p) {
//                            c %= a;
//                        }
//                        if (c != val) {
//                            flag = false;
//                            break iter;
//                        }
//                    }
//                }
//                if (flag) {
//                    cnt++;
//                    out.println(Arrays.toString(combs.get(i)));
//                }
//            }
//            out.println(cnt);
                long[] fact = new long[N + 1];
                long[] invFact = new long[N + 1];
                int MOD = 998244353;
                fact[0] = 1;
                invFact[0] = 1;
                for (int i = 1; i <= N; i++) {
                    fact[i] = fact[i - 1] * i;
                    fact[i] %= MOD;
                    invFact[i] = invFact[i - 1] * MathUtils.inverse(i, MOD);
                    invFact[i] %= MOD;
                }
                long res = 0;
                for (int i = 1; i <= N; i++) {
                    int tot = N / i - 1;
                    int need = k - 1;
                    if (tot >= need) {
                        res += (((fact[tot] * invFact[need]) % MOD) * invFact[tot - need]) % MOD;
                        res %= MOD;
                    }
                }
                out.println(res);
            }
        }

    }

    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 MathUtils {
        public static long inverse(long a, long mod) {
            long[] inv = extended_gcd(a, mod);
            if (inv[0] != 1) {
                return 0;
            } else {
                return (inv[1] + 2 * mod) % mod;
            }
        }

        public static long[] extended_gcd(long a, long b) {
            //three numbers, first is gcd, second is x, third is y
            if (a == 0) {
                return new long[]{b, 0, 1};
            }
            long[] next = extended_gcd(b % a, a);
            long tempX = next[1];
            next[1] = next[2] - (b / a) * next[1];
            next[2] = tempX;
            return next;
        }

    }
}

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

public class Code0306 {

    static  long mod = 998244353;
    static  long fac[] = new long[1000001];

    static long rx = 0;
    static long ry = 0;
    static void gcd(long x,long y){
        if(x<y){
            gcd(y,x);
        }

        if(x%y == 0){
            rx = 0;
            ry = -1;
        }
        else{
            gcd(y,x%y);
            long tx = rx;
            long ty = ry;

             rx = -ty;
             ry = -(tx + ty*(x/y));

        }

    }
    public static void main(String args[]){
         Reader s = new Reader();
         int n = s.nextInt();
         int k = s.nextInt();
         if(k==1){
             System.out.println(n);
             return;
         }
         fac[0] = 1;
        for (int i = 1; i < fac.length ; i++) {
            fac[i] = (i*fac[i-1])%mod;
        }

        long ans = 0;

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

            int p = n/i - 1;

            if(p < k-1){
                break;
            }

           // System.out.println(p);

            long x = fac[p];
            long y = (fac[p-k+1]*fac[k-1])%mod;

            gcd(mod,y);

            long rem = -ry;

            while (rem <0){
                rem +=  mod;
            }

            ans  = (ans + x*rem)%mod;

        }

        System.out.println(ans);

    }
    static class Reader {

        private InputStream mIs;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int 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 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();
        }

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

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

    }

}

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

// n = k(lw(n/k)) + n%k
public class Sola5 {
	static int MOD = 998244353;

	public static long modexp(long x, long y, int N){
		// System.out.println(y)
;		if(y == 0)return 1;
		long z = modexp(x, y/2, N);
		long d = z*z%N;
		if((y&1) == 0)return d;
		else{
			return (x*d%N);
		}
	}

	long fac[] = new long[500001];
	long inverseFac[] = new long[500001];

	public long nCr(int n, int r)
	{
	    if(n == r || r== 0)return 1;
	    long ll = 1;
	    long res = ((((ll*fac[n]*inverseFac[r])%MOD)*inverseFac[n-r])%MOD);
	    return res;
	}

	// Returns factorial of n
	int fact(int n)
	{
	    int res = 1;
	    for (int i = 2; i <= n; i++)
	        res = res * i;
	    return res;
	}
	public int getPossibility(int n, int k){
		long total = 0;
		for(int i = 1;i<=n;i++){
			int no = n/i;
			if(no < k)break;
			total += nCr(no-1,k-1);
			total %= MOD;
		}
		return (int)total;
	}

	public void init(){
		fac[0] = 1;
		long l1 = 1;
		for(int i = 1;i<500001;i++){
			long product = l1*fac[i-1]*i%MOD;
	    	fac[i] = product;
	    	inverseFac[i] = modexp(fac[i], MOD-2, MOD);
	    	/*if(inverseFac[i] < 0){
	    		long l = modexp(fac[i], MOD-2, MOD);
	    		System.out.println(i+","+l+","+fac[i]+"," + (l1*fac[i-1]*i)%MOD+","+fac[i-1]);
	    		break;
	    	}*/
		}

	}
	public static void main(String[] args) throws IOException{
		Sola5 s5 = new Sola5();
		s5.init();
		BufferedReader obj = new BufferedReader(new InputStreamReader(System.in));
		String lineNo = obj.readLine();
		String[] a = lineNo.split(" ");
		int a1 = Integer.parseInt(a[0]);
		int a2 = Integer.parseInt(a[1]);

		System.out.println(s5.getPossibility(a1, a2));
	}

}

/**
 * @author derrick20
 */
import java.io.*;
import java.util.*;

public class ModularStability {
    public static void main(String[] args) throws Exception {
        FastScanner sc = new FastScanner();
        PrintWriter out = new PrintWriter(System.out);

        int N = sc.nextInt();
        int K = sc.nextInt();
        if (N < K) {
            out.println(0);
        }
        else {
            fact = new long[(int) 5e5 + 1];
            factInv = new long[(int) 5e5 + 1];
            fact[0] = 1;
            factInv[0] = 1;
            for (int i = 1; i < fact.length; i++) {
                fact[i] = ((long) i * fact[i - 1]) % mod;
                factInv[i] = inv(fact[i]);
            }
            long ans = 0;
            for (int i = 1; i <= N; i++) {
                if (N / i >= K) {
                    // force this number, then we need to fill the remaining K - 1
                    // with numbers that are multiples of us.
                    // We can prove that any case that isn't a list of
                    // multiples of a number, we'll be able to find a pair a, b that
                    // doesn't have b = k * a, then we can choose x = b. This will
                    // give 0 if we order b first, but it'll give nonzero if a is placed
                    // first, then the b will be bigger so it won't change!
                    ans = (ans + choose(N / i - 1, K - 1)) % mod;
                }
            }
            out.println(ans);
        }
        out.close();
    }
    static long mod = 998244353;
    static long[] fact, factInv;
    static long choose(int n, int k) {
        long ans = (fact[n] * factInv[k]) % mod;
        return (ans * factInv[n - k]) % mod;
    }
    static long inv(long x) {
        return fastExpo(x, mod - 2);
    }

    static long fastExpo(long x, long k) {
        if (k == 0) {
            return 1;
        }
        else if (k == 1) {
            return x;
        }
        else {
            long root = fastExpo(x, k / 2);
            long ans = (root * root) % mod;
            if (k % 2 == 1) {
                ans = (ans * x) % mod;
            }
            return ans;
        }
    }

    static class FastScanner {
        private int BS = 1<<16;
        private char NC = (char)0;
        private byte[] buf = new byte[BS];
        private int bId = 0, size = 0;
        private char c = NC;
        private double cnt = 1;
        private BufferedInputStream in;

        public FastScanner() {
            in = new BufferedInputStream(System.in, BS);
        }

        public FastScanner(String s) {
            try {
                in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
            }
            catch (Exception e) {
                in = new BufferedInputStream(System.in, BS);
            }
        }

        private char getChar(){
            while(bId==size) {
                try {
                    size = in.read(buf);
                }catch(Exception e) {
                    return NC;
                }
                if(size==-1)return NC;
                bId=0;
            }
            return (char)buf[bId++];
        }

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

        public int[] nextInts(int N) {
            int[] res = new int[N];
            for (int i = 0; i < N; i++) {
                res[i] = (int) nextLong();
            }
            return res;
        }

        public long[] nextLongs(int N) {
            long[] res = new long[N];
            for (int i = 0; i < N; i++) {
                res[i] = nextLong();
            }
            return res;
        }

        public long nextLong() {
            cnt=1;
            boolean neg = false;
            if(c==NC)c=getChar();
            for(;(c<'0' || c>'9'); c = getChar()) {
                if(c=='-')neg=true;
            }
            long res = 0;
            for(; c>='0' && c <='9'; c=getChar()) {
                res = (res<<3)+(res<<1)+c-'0';
                cnt*=10;
            }
            return neg?-res:res;
        }

        public double nextDouble() {
            double cur = nextLong();
            return c!='.' ? cur:cur+nextLong()/cnt;
        }

        public double[] nextDoubles(int N) {
            double[] res = new double[N];
            for (int i = 0; i < N; i++) {
                res[i] = nextDouble();
            }
            return res;
        }

        public String next() {
            StringBuilder res = new StringBuilder();
            while(c<=32)c=getChar();
            while(c>32) {
                res.append(c);
                c=getChar();
            }
            return res.toString();
        }

        public String nextLine() {
            StringBuilder res = new StringBuilder();
            while(c<=32)c=getChar();
            while(c!='\n') {
                res.append(c);
                c=getChar();
            }
            return res.toString();
        }

        public boolean hasNext() {
            if(c>32)return true;
            while(true) {
                c=getChar();
                if(c==NC)return false;
                else if(c>32)return true;
            }
        }
    }

    static void ASSERT(boolean assertion, String message) {
        if (!assertion) throw new AssertionError(message);
    }
}

/**
 * @author derrick20
 */
import java.io.*;
import java.util.*;

public class ModularStability {
    public static void main(String[] args) throws Exception {
        FastScanner sc = new FastScanner();
        PrintWriter out = new PrintWriter(System.out);

        int N = sc.nextInt();
        int K = sc.nextInt();
        if (N < K) {
            out.println(0);
        }
        else {
            fact = new long[(int) 5e5 + 1];
            factInv = new long[(int) 5e5 + 1];
            fact[0] = 1;
            factInv[0] = 1;
            for (int i = 1; i < fact.length; i++) {
                fact[i] = ((long) i * fact[i - 1]) % mod;
                factInv[i] = inv(fact[i]);
            }
            long ans = 0;
            for (int i = 1; i <= N; i++) {
                if (N / i >= K) {
                    // force this number, then we need to fill the remaining K - 1
                    // with numbers that are multiples of us.
                    // We can prove that any case that isn't a list of
                    // multiples of a number, we'll be able to find a pair a, b that
                    // doesn't have b = k * a, then we can choose x = b. This will
                    // give 0 if we order b first, but it'll give nonzero if a is placed
                    // first, then the b will be bigger so it won't change!
                    ans = (ans + choose(N / i - 1, K - 1)) % mod;
                }
            }
            out.println(ans);
        }
        out.close();
    }
    static long mod = 998244353;
    static long[] fact, factInv;
    static long choose(int n, int k) {
        long ans = (fact[n] * factInv[k]) % mod;
        return (ans * factInv[n - k]) % mod;
    }
    static long inv(long x) {
        return fastExpo(x, mod - 2);
    }

    static long fastExpo(long x, long k) {
        long bit = x;
        long ans = 1;
        while (k > 0) {
            if ((k & 1) > 0) {
                ans = (ans * bit) % mod;
            }
            bit = (bit * bit) % mod;
            k >>= 1;
        }
        return ans;
    }

    static class FastScanner {
        private int BS = 1<<16;
        private char NC = (char)0;
        private byte[] buf = new byte[BS];
        private int bId = 0, size = 0;
        private char c = NC;
        private double cnt = 1;
        private BufferedInputStream in;

        public FastScanner() {
            in = new BufferedInputStream(System.in, BS);
        }

        public FastScanner(String s) {
            try {
                in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
            }
            catch (Exception e) {
                in = new BufferedInputStream(System.in, BS);
            }
        }

        private char getChar(){
            while(bId==size) {
                try {
                    size = in.read(buf);
                }catch(Exception e) {
                    return NC;
                }
                if(size==-1)return NC;
                bId=0;
            }
            return (char)buf[bId++];
        }

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

        public int[] nextInts(int N) {
            int[] res = new int[N];
            for (int i = 0; i < N; i++) {
                res[i] = (int) nextLong();
            }
            return res;
        }

        public long[] nextLongs(int N) {
            long[] res = new long[N];
            for (int i = 0; i < N; i++) {
                res[i] = nextLong();
            }
            return res;
        }

        public long nextLong() {
            cnt=1;
            boolean neg = false;
            if(c==NC)c=getChar();
            for(;(c<'0' || c>'9'); c = getChar()) {
                if(c=='-')neg=true;
            }
            long res = 0;
            for(; c>='0' && c <='9'; c=getChar()) {
                res = (res<<3)+(res<<1)+c-'0';
                cnt*=10;
            }
            return neg?-res:res;
        }

        public double nextDouble() {
            double cur = nextLong();
            return c!='.' ? cur:cur+nextLong()/cnt;
        }

        public double[] nextDoubles(int N) {
            double[] res = new double[N];
            for (int i = 0; i < N; i++) {
                res[i] = nextDouble();
            }
            return res;
        }

        public String next() {
            StringBuilder res = new StringBuilder();
            while(c<=32)c=getChar();
            while(c>32) {
                res.append(c);
                c=getChar();
            }
            return res.toString();
        }

        public String nextLine() {
            StringBuilder res = new StringBuilder();
            while(c<=32)c=getChar();
            while(c!='\n') {
                res.append(c);
                c=getChar();
            }
            return res.toString();
        }

        public boolean hasNext() {
            if(c>32)return true;
            while(true) {
                c=getChar();
                if(c==NC)return false;
                else if(c>32)return true;
            }
        }
    }

    static void ASSERT(boolean assertion, String message) {
        if (!assertion) throw new AssertionError(message);
    }
}

//make sure to make new file!
import java.io.*;
import java.util.*;

public class E88{

   public static long MOD = 998244353L;
   public static long[] fac;

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

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

      long n = Long.parseLong(st.nextToken());
      long m = Long.parseLong(st.nextToken());

      fac = new long[500005];
      fac[0] = 1L;
      for(int k = 1; k < 500005; k++){
         fac[k] = (fac[k-1]*(long)k + MOD)%MOD;
      }

      long answer = 0L;
      for(long k = 1; k <= n; k++){
         long next = k*2;

         long num = (n-next)/k+1;
         //if(n%k == 0) num++;
         if(num < m-1)
            break;
         //out.println(num);
         answer = (answer + choose(num,m-1) + MOD) % MOD;
      }

      out.println(answer);

      out.close();
   }
   /* Iterative Function to calculate
    (x^y)%p in O(log y) */
   static long power(long x, long y, long p)
   {

        // Initialize result
      long res = 1;

        // Update x if it is more than or
        // equal to p
      x = x % p;

      while (y > 0)
      {

            // If y is odd, multiply x
            // with result
         if (y % 2 == 1)
            res = (res * x) % p;

            // y must be even now
         y = y >> 1; // y = y/2
         x = (x * x) % p;
      }

      return res;
   }

    // Returns n^(-1) mod p
   static long modInverse(long n, long p)
   {
      return power(n, p-2, p);
   }

    // Returns nCr % p using Fermat's
    // little theorem.
   static long choose(long n, long r)
   {
      if (r == 0)
         return 1;

      return (((fac[(int)n] * modInverse(fac[(int)r], MOD) + MOD) % MOD) * modInverse(fac[(int)(n-r)], MOD) + MOD) % MOD;
   }

}

import java.io.*;
import java.util.*;
public class Solution {
	static Scanner sc=new Scanner(System.in);
	static PrintWriter out=new PrintWriter(System.out);
	//Main
	static long MOD=998244353;
	static long exp(long x,long n) {
		if(n==0) return 1;
		if(n%2==0) return exp((x*x)%MOD,n/2)%MOD;
		else return ((x%MOD)*(exp((x*x)%MOD,n/2)%MOD))%MOD;
	}
	static long inv(long x) {
		return exp(x,MOD-2);
	}
	static int N=(int)5e5+5;
	static long fact[]=new long[N];
	static long C(int n,int r) {
		long num=fact[n];
		long denom=(fact[r]*fact[n-r])%MOD;
		return ((num%MOD)*(inv(denom))%MOD)%MOD;
	}
	public static void main(String args[]) {
		fact[0]=1;
		for(int i=1;i<N;i++) fact[i]=(fact[i-1]*i)%MOD;
		int test=1;
		//test=sc.nextInt();
		while(test-->0) {
			int n=sc.nextInt(),k=sc.nextInt();
			if(n<k) {
				out.println(0);
				continue;
			}
			long ans=0;
			for(int i=1;i<=n;i++) {
				int x=n/i-1;
				if(x<k-1) continue;
				ans=(ans+C(x,k-1))%MOD;
			}
			out.println(ans);
		}
		out.flush();
		out.close();
	}
}

import java.io.*;
import java.util.*;
public class Solution {
    private static int MOD = 998244353;
    private static int[] fac;

    private static int add(int a, int b) {
        a += b;
        while (a >= MOD) a -= MOD;
        while (a < 0) a += MOD;
        return a;
    }

    private static int mul(int a, int b) {
        long x = (long) a * b;
        return (int) (x % MOD);
    }

    private static int binexp(int a, int b) {
        int res = 1;
        while (b > 0) {
            if (b % 2 == 1) res = mul(res, a);
            a = mul(a, a);
            b /= 2;
        }
        return res;
    }

    public static int inv(int a) {
        return binexp(a, MOD - 2);
    }

    public static int div(int a, int b) {
        return mul(a, inv(b));
    }

    public static void precomfac() {
        fac[0] = 1;
        for (int i = 1; i < fac.length; ++i) {
            fac[i] = mul(i, fac[i - 1]);
        }
    }

    public static int C(int n, int k) {
        if (k > n) return 0;
        return div(fac[n], mul(fac[k], fac[n - k]));
    }
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int k = scan.nextInt();
        int answer = 0;
        fac = new int[n];
        precomfac();
        for (int i = 1; i <= n; ++i) {
            int d = n / i;
            answer = add(answer, C(d - 1, k - 1));
        }
        System.out.println(answer);
    }
}

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

import javax.swing.text.html.MinimalHTMLWriter;

public class tr1 {
	static PrintWriter out;
	static StringBuilder sb;
	static int n, m, k, ones, zeros;
	static long mod = 998244353;
	static Boolean[][] memo;
	static String s;
	static ArrayList<Integer>[] ad;
	static long inf = Long.MAX_VALUE;
	static int N = 1 << 20 + 1;
	static int[] color;
	static ArrayList<Integer> o, z;
	static int[] ans, head;

	public static void main(String[] args) throws Exception {
		Scanner sc = new Scanner(System.in);
		out = new PrintWriter(System.out);
		long n = sc.nextInt();
		long k = sc.nextInt();
		if (n < k) {
			System.out.println(0);
			return;
		}
		if (n == k) {
			System.out.println(1);
			return;
		}
		if (k == 1) {
			System.out.println(n);
			return;
		}
		long[] fac = new long[1000000];
		fac[0] = 1;
		for (int i = 1; i < fac.length; i++) {
			fac[i] = i * fac[i - 1] % mod;
		}
		long ans = fac[(int) n - 1] * modPow(fac[(int) (n - k)], mod - 2) % mod;
		ans = ans * modPow(fac[(int) k - 1], mod - 2) % mod;
		for (int i = 2; i <= n; i++) {
			int num = (int) n / i;
			if (num < k)
				continue;
			long tem = fac[num-1] * modPow(fac[(int) k-1], mod - 2) % mod;
			tem = tem * modPow(fac[num - (int) k], mod - 2) % mod;
			ans = (ans + tem) % mod;
		}
		System.out.println(ans);
		out.flush();
	}

	static long modPow(long a, long e)

	{
		long res = 1;
		while (e > 0) {
			if ((e & 1) == 1)
				res = (res * a) % mod;
			a = (a * a) % mod;
			e >>= 1;
		}
		return res;
	}

	static class Scanner {
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream system) {
			br = new BufferedReader(new InputStreamReader(system));
		}

		public Scanner(String file) throws Exception {
			br = new BufferedReader(new FileReader(file));
		}

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

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

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

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

		public char nextChar() throws IOException {
			return next().charAt(0);
		}

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

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

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

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

		public void waitForInput() throws InterruptedException {
			Thread.sleep(3000);
		}
	}
}

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

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author AnandOza
 */
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);
        EModularStability solver = new EModularStability();
        solver.solve(1, in, out);
        out.close();
    }

    static class EModularStability {
        NumberTheory.Mod998 m = new NumberTheory.Mod998();

        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int n = in.nextInt(), k = in.nextInt();

            long answer = 0;
            for (int i = 1; n / i >= k; i++) {
                answer = m.add(answer, m.ncr(n / i - 1, k - 1));
            }

            out.println(answer);
        }

    }

    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 NumberTheory {
        private static void ASSERT(boolean assertion) {
            if (!assertion)
                throw new AssertionError();
        }

        public abstract static class Modulus<M extends NumberTheory.Modulus<M>> {
            ArrayList<Long> factorial = new ArrayList<>();
            ArrayList<Long> invFactorial = new ArrayList<>();

            public abstract long modulus();

            public Modulus() {
                super();
                factorial.add(1L);
                invFactorial.add(1L);
            }

            public long fact(int n) {
                while (factorial.size() <= n) {
                    factorial.add(mult(factorial.get(factorial.size() - 1), factorial.size()));
                }

                return factorial.get(n);
            }

            public long fInv(int n) {
                int lastKnown = invFactorial.size() - 1;

                if (lastKnown < n) {
                    long[] fInv = new long[n - lastKnown];
                    fInv[0] = inv(fact(n));
                    for (int i = 1; i < fInv.length; i++) {
                        fInv[i] = mult(fInv[i - 1], n - i + 1);
                    }
                    for (int i = fInv.length - 1; i >= 0; i--) {
                        invFactorial.add(fInv[i]);
                    }
                }

                return invFactorial.get(n);
            }

            public long ncr(int n, int r) {
                ASSERT(n >= 0);
                if (r < 0 || n < r)
                    return 0;
                return mult(fact(n), mult(fInv(r), fInv(n - r)));
            }

            public long normalize(long x) {
                x %= modulus();
                if (x < 0)
                    x += modulus();
                return x;
            }

            public long add(long a, long b) {
                long v = a + b;
                return v < modulus() ? v : v - modulus();
            }

            public long mult(long a, long b) {
                return (a * b) % modulus();
            }

            public long inv(long value) {
                long g = modulus(), x = 0, y = 1;
                for (long r = value; r != 0; ) {
                    long q = g / r;
                    g %= r;

                    long temp = g;
                    g = r;
                    r = temp;

                    x -= q * y;

                    temp = x;
                    x = y;
                    y = temp;
                }

                ASSERT(g == 1);
                ASSERT(y == modulus() || y == -modulus());

                return normalize(x);
            }

        }

        public static class Mod998 extends NumberTheory.Modulus<NumberTheory.Mod998> {
            public long modulus() {
                return 998_244_353L;
            }

        }

    }
}

import java.util.*;
import java.io.*;
public class Main {
    static class Scan {
        private byte[] buf=new byte[1024];
        private int index;
        private InputStream in;
        private int total;
        public Scan()
        {
            in=System.in;
        }
        public int scan()throws IOException
        {
            if(total<0)
            throw new InputMismatchException();
            if(index>=total)
            {
                index=0;
                total=in.read(buf);
                if(total<=0)
                return -1;
            }
            return buf[index++];
        }
        public int scanInt()throws IOException
        {
            int 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();
                }
                else throw new InputMismatchException();
            }
            return neg*integer;
        }
        public double scanDouble()throws IOException
        {
            double doub=0;
            int n=scan();
            while(isWhiteSpace(n))
            n=scan();
            int neg=1;
            if(n=='-')
            {
                neg=-1;
                n=scan();
            }
            while(!isWhiteSpace(n)&&n!='.')
            {
                if(n>='0'&&n<='9')
                {
                    doub*=10;
                    doub+=n-'0';
                    n=scan();
                }
                else throw new InputMismatchException();
            }
            if(n=='.')
            {
                n=scan();
                double temp=1;
                while(!isWhiteSpace(n))
                {
                    if(n>='0'&&n<='9')
                    {
                        temp/=10;
                        doub+=(n-'0')*temp;
                        n=scan();
                    }
                    else throw new InputMismatchException();
                }
            }
            return doub*neg;
        }
        public String scanString()throws IOException
        {
            StringBuilder sb=new StringBuilder();
            int n=scan();
            while(isWhiteSpace(n))
            n=scan();
            while(!isWhiteSpace(n))
            {
                sb.append((char)n);
                n=scan();
            }
            return sb.toString();
        }
        private boolean isWhiteSpace(int n)
        {
            if(n==' '||n=='\n'||n=='\r'||n=='\t'||n==-1)
            return true;
            return false;
        }
    }
    static long fact[],mod=998244353L;
    public static void main(String args[]) throws IOException {
        Scan input=new Scan();
        fact=new long[500001];
        fact[0]=1;
        for(int i=1;i<fact.length;i++) {
            fact[i]=i*fact[i-1];
            fact[i]%=mod;
        }
        int n=input.scanInt();
        int k=input.scanInt();
        long ans=0;
        for(int i=1;i<=n;i++) {
            int num=n/i;
            if(num<k) {
                continue;
            }
            ans+=ncr(num-1,k-1);
//            System.out.println(i+" "+ans);
        }
        System.out.println(ans);
    }
    public static long ncr(int n,int r) {
        long ncr=(((fact[n]*Inverse(fact[n-r],mod))%mod)*Inverse(fact[r],mod))%mod;
        return ncr;
    }

    public static long Inverse(long a,long n) {
        long q,r1=n,r2=a,r,t1=0,t2=1,t;
        while(true) {
            q=r1/r2;
            r=r1%r2;
            t=t1-(q*t2);
            r1=r2;
            r2=r;
            t1=t2;
            t2=t;
            if(r2==0) {
                    break;
            }
        }
        if(r1!=1) {
                return -1;
        }
        t1%=n;
        if(t1<0) {
                t1+=n;
        }
        return t1;
    }
}

import java.io.*;
import java.util.*;
public class sol {
    InputReader in;
    PrintWriter out;
    helper_class h;
    final long mod=1000000007;
    final long p=998244353;
    long fact[];
    public static void main(String[] args) throws java.lang.Exception{
        new sol().run();
    }
    void run() throws Exception{
        in=new InputReader(System.in);
        out = new PrintWriter(System.out);
        h = new helper_class();
        precompute();
        int t=1;
        while(t-->0){
            solve();
        }
        out.flush();
        out.close();
    }
    void solve() {
        int n=h.i(),k=h.i();
        if(k>n)
            h.p(0);
        else if(k==1)
            h.p(1);
        else {
            precompute();
            long ans=0;
            for(int i=1;i<=n;i++)
                ans = add(ans, nCr(n/i-1, k-1));
            h.p(ans);
        }
    }
    void precompute() {
        fact=new long[500001];
        fact[0]=1;
        for(int i=1;i<=500000;i++)
            fact[i]=(fact[i-1]*i)%p;
    }
    long nCr(int n,int r) {
        if(r > n) return 0;
        return mul(fact[n], mul(inv(fact[r]),inv(fact[n-r])));
    }
    long inv(long x) {
        return power(x,p-2,p);
    }
    long add(long x,long y) {
        return (x%p + y%p)%p;
    }
    long mul(long x,long y) {
        return (x%p * y%p)%p;
    }
    long power(long a, long b,long p){
        if(b == 0)
            return 1L;
        long val = power(a, b/2, p);
        if(b % 2 == 0)
            return val * val%p;
        else
            return val * val%p * a%p;
    }
    class helper_class{
        long gcd(long a, long b){return (b==0)?a:gcd(b,a%b);}
        void p(Object o){out.println(o);}
        String s(){return in.next();}
        String nl(){return in.nextLine();}
        int i(){return in.nextInt();}
        long l(){return in.nextLong();}
    }
    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 UnknownError();
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new UnknownError();
                }
                if (numChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }
        public int peek() {
            if (numChars == -1)
                return -1;
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    return -1;
                }
                if (numChars <= 0)
                    return -1;
            }
            return buf[curChar];
        }
        public void skip(int x) {
            while (x-->0)
                read();
        }
        public int nextInt() {
            return Integer.parseInt(next());
        }
        public long nextLong() {
            return Long.parseLong(next());
        }
        public String nextString() {
            return next();
        }
        public String next() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            StringBuffer res = new StringBuffer();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isSpaceChar(c));

            return res.toString();
        }
        public String nextLine() {
            StringBuffer buf = new StringBuffer();
            int c = read();
            while (c != '\n' && c != -1) {
                if (c != '\r')
                    buf.appendCodePoint(c);
                c = read();
            }
            return buf.toString();
        }
        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 boolean hasNext() {
            int value;
            while (isSpaceChar(value = peek()) && value != -1)
                read();
            return value != -1;
        }
        private boolean isSpaceChar(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }
    }
}

// Working program with FastReader
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Scanner;
import java.util.StringTokenizer;

public class e
{
    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;
        }
    }

    //        long start = System.currentTimeMillis();
//        long end = System.currentTimeMillis();
//        System.out.println((end - start) + "ms");

    static int M =998244353;
    static int N =600000+5;
    static long[] fac = new long[N];
    static long[] fac_inv = new long[N];
    static long[] inv = new long[N];

    public static void initialise(){
        int i;
        inv[1]=1;
        for(i=2;i<N;++i){
            inv[i] = (M * 1l - (M / i * 1l)) * inv[M % i] % M;
        }
        fac[0] = fac[1] = 1;
        for(i=2;i<N;i++){
            fac[i] = ((i*1l)*fac[i-1])%M;
        }
        fac_inv[0] = fac_inv[1] = 1;
        for(i=2;i<N;i++){
            fac_inv[i] = (inv[i]*1l*fac_inv[i-1])%M;
        }
    }

    public static long ncr(int n,int r){
        if(n<r){
            return 0;
        }
        return (((fac[n]*fac_inv[r])%M) *fac_inv[n-r])%M;
    }

    public static void main(String[] args)
    {
        FastReader s=new FastReader();
        initialise();
        int n = s.nextInt();
        int k = s.nextInt();
        System.out.println(n_ways(n,k));
    }
    public static long n_ways(int n,int k){
        long count =0l;
        for(int i=1;i<=n;i++){
            int temp = (n/i)-1;
            if(temp>=k){
                count+=ncr(temp,k-1);
                count%=M;
            }
        }
        return count;
    }

    public static void debug(long[][] arr){
        int len = arr.length;
        for(int i=0;i<len;i++){
            System.out.println(Arrays.toString(arr[i]));
        }
    }
    public static void debug(int[][] arr){
        int len = arr.length;
        for(int i=0;i<len;i++){
            System.out.println(Arrays.toString(arr[i]));
        }
    }
    public static void debug(String[] arr){
        int len = arr.length;
        for(int i=0;i<len;i++){
            System.out.println(arr[i]);
        }
    }

    public static void print(int[] arr){
        int len = arr.length;
        for(int i=0;i<len;i++){
            System.out.print(arr[i]+" ");
        }
        System.out.print('\n');
    }
    public static void print(String[] arr){
        int len = arr.length;
        for(int i=0;i<len;i++){
            System.out.print(arr[i]+" ");
        }
        System.out.print('\n');
    }
    public static void print(long[] arr){
        int len = arr.length;
        for(int i=0;i<len;i++){
            System.out.print(arr[i]+" ");
        }
        System.out.print('\n');
    }

}

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

import java.lang.*;
import java.io.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.util.*;
/* Name of the class has to be "Main" only if the class is public. */
public class Codechef
{
	public static void main (String[] args) throws java.lang.Exception
	{
		// your code goes here
		FastReader sc = new FastReader();
		PrintWriter out = new PrintWriter(System.out);
		int n = sc.nextInt();
		int k = sc.nextInt();
		if(n<k) out.println("0");
		else if(k==1) out.println(n);
		else
		{
		    long m = 998244353;
		    long fact[] = fact((int)Math.pow(10,6),m);
		    //long temp1 = nCk(n-1,k-1,m,fact);
		    //long temp2=nCk((n/2)-1,k-1,m,fact);
		    long ans=0;
		    for(int i=1;i<=n/2;i++)
		    {
		        ans+=nCk((n/i)-1,k-1,m,fact);
		        ans=ans%m;
		        out.println(ans);
		    }
		    out.println(ans);
		}
		out.close();
	}
	static long[] fact(int n,long m)
	{
	    long fact[] = new long[n+1];
	    fact[0]=1;
	    fact[1]=1;
	    for(int i=2;i<=n;i++)
	    {
	        fact[i]=(i*fact[i-1])%m;
	    }
	    return fact;
	}

	static long nCk(int n,int k,long m,long fact[])
	{
	    //formula for nCk is (n!/(k!*(n-k)!)) %m
	    if(k>n) return 0;
	    long ans=1;
	    ans=(ans*fact[n])%m;  // now the ans is n!%m

	    //Now we need to find ((k!)^-1)%m = ((k!%m)^(m-2))%m
	    //Using Fermats theorem i.e. (n^-1)%m = (n^(m-2))%m when m is prime

	    ans = (ans*mmi((int)fact[k],m))%m;
	    ans= (ans*mmi((int)fact[n-k],m))%m;
	    return ans;
	}
	static long mmi (int a,long n)
	{
	    return recursivePower(a,n-2,n);
	}
	static long recursivePower(int a,long n,long mod)
	{
	    if(a==0) return 0;
	    if(n==0) return 1;
	    long temp=recursivePower(a,n/2,mod);
	    long ans = ((temp%mod)*(temp%mod))%mod;

	    if(n%2==0)
	    {
	        return ans;
	    }
	    else
	    {
	        return ((a%mod)*(ans%mod))%mod;
	    }
	}

}

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

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

import java.lang.*;
import java.io.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.util.*;
/* Name of the class has to be "Main" only if the class is public. */
public class Codechef
{
	public static void main (String[] args) throws java.lang.Exception
	{
		// your code goes here
		FastReader sc = new FastReader();
		PrintWriter out = new PrintWriter(System.out);
		int n = sc.nextInt();
		int k = sc.nextInt();
		if(n<k) out.println("0");
		else if(k==1) out.println("1");
		else
		{
		    long m = 998244353;
		    long fact[] = fact((int)Math.pow(10,6),m);
		    //long temp1 = nCk(n-1,k-1,m,fact);
		    //long temp2=nCk((n/2)-1,k-1,m,fact);
		    long ans=0;
		    for(int i=1;i<=n/2;i++)
		    {
		        ans+=nCk((n/i)-1,k-1,m,fact);
		        ans=ans%m;
		    }
		    out.println(ans);
		}
		out.close();
	}
	static long[] fact(int n,long m)
	{
	    long fact[] = new long[n+1];
	    fact[0]=1;
	    fact[1]=1;
	    for(int i=2;i<=n;i++)
	    {
	        fact[i]=(i*fact[i-1])%m;
	    }
	    return fact;
	}

	static long nCk(int n,int k,long m,long fact[])
	{
	    //formula for nCk is (n!/(k!*(n-k)!)) %m
	    if(k>n) return 0;
	    long ans=1;
	    ans=(ans*fact[n])%m;  // now the ans is n!%m

	    //Now we need to find ((k!)^-1)%m = ((k!%m)^(m-2))%m
	    //Using Fermats theorem i.e. (n^-1)%m = (n^(m-2))%m when m is prime

	    ans = (ans*mmi((int)fact[k],m))%m;
	    ans= (ans*mmi((int)fact[n-k],m))%m;
	    return ans;
	}
	static long mmi (int a,long n)
	{
	    return recursivePower(a,n-2,n);
	}
	static long recursivePower(int a,long n,long mod)
	{
	    if(a==0) return 0;
	    if(n==0) return 1;
	    long temp=recursivePower(a,n/2,mod);
	    long ans = ((temp%mod)*(temp%mod))%mod;

	    if(n%2==0)
	    {
	        return ans;
	    }
	    else
	    {
	        return ((a%mod)*(ans%mod))%mod;
	    }
	}

}

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.*;
import java.math.BigInteger;
import java.util.*;

public class E {

    static long A = 998244353l;
    static long[] fact;
    static void gen(){
        fact = new long[500002];
        fact[0] = 1;
        for(int i=1;i<fact.length;i++){
            fact[i] = fact[i-1]*i;
            fact[i]%=A;
        }
    }
    static long binomialCoeff(int n, int k)
    {
        if(k<0)return 0;
        if(k==0)return 1;
        if(k==n)return 1;
        if(k>n)return 0;
        BigInteger factn = new BigInteger(fact[n]+"");
        BigInteger factk = new BigInteger(fact[k]+"");
        BigInteger factnminusk = new BigInteger((fact[n-k])+"");
        BigInteger denominator = factk.multiply(factnminusk);
        denominator = denominator.mod(new BigInteger(A+""));
     //   denominator = denominator.modInverse(new BigInteger(A+""));
        BigInteger Dinv = denominator.modInverse(new BigInteger(A+""));
        BigInteger res = factn.multiply(Dinv);
        res = res.mod(new BigInteger(A+""));
        return res.longValue()%A;
    }
    public static void main(String[] args) throws IOException{
        Scanner sc = new Scanner(System.in);
        PrintWriter pw = new PrintWriter(System.out);
        int n = sc.nextInt();
        int k = sc.nextInt();
        if(k==1){
            pw.println(n);
        }else {
            long res = 0;
            gen();
            //  System.out.println(binomialCoeff(6,2));
            for (int i = 1; i <= n - k; i++) {
                res += binomialCoeff((n - i) / i, k - 1);
                res %= A;
            }
            pw.println(res);
        }
        pw.flush();
        pw.close();
    }

    static class Pair implements Comparable<Pair>{
        long x,bitmask;
        public Pair(long x,long bitmask){
            this.x= x;
            this.bitmask = bitmask;
        }
        public int compareTo(Pair p){
            if(this.x==p.x)return Long.compare(this.bitmask,p.bitmask);
            return Long.compare(this.x,p.x);
        }
        public boolean equals(Object p){
            return (this.x==((Pair)p).x)&&(this.bitmask==((Pair)p).bitmask);
        }

    }
    static class Scanner {
        StringTokenizer st;
        BufferedReader br;

        public Scanner(FileReader r) {
            br = new BufferedReader(r);
        }

        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 int nextInt() throws IOException {
            return Integer.parseInt(next());
        }

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

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

        public double nextDouble() throws IOException {
            String x = next();
            StringBuilder sb = new StringBuilder("0");
            double res = 0, f = 1;
            boolean dec = false, neg = false;
            int start = 0;
            if (x.charAt(0) == '-') {
                neg = true;
                start++;
            }
            for (int i = start; i < x.length(); i++)
                if (x.charAt(i) == '.') {
                    res = Long.parseLong(sb.toString());
                    sb = new StringBuilder("0");
                    dec = true;
                } else {
                    sb.append(x.charAt(i));
                    if (dec)
                        f *= 10;
                }
            res += Long.parseLong(sb.toString()) / f;
            return res * (neg ? -1 : 1);
        }

        public boolean ready() throws IOException {
            return br.ready();

        }
    }
}

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

public class Solution {
    public static void main(String[] args) throws IOException {
        Reader rd = new Reader();
        int n = rd.nextInt(), k = rd.nextInt();

        int MOD = 998244353;
        long ans = 0;
        int K = 1;
        for(int j = 1; j <= k - 1; j++) K = (K * j) % MOD;
        for(int i = 1; i <= n; i++) {
            // find the max ak(l * i)
            int l = 1, r = n;
            while(l < r) {
                int mid = (l + r + 1) >> 1;
                if(mid * i <= n) l = mid;
                else r = mid - 1;
            }
            // C(l - 1, k - 1)
            if(l < k) continue;
            ans = (ans + CNK(l - 1, k - 1, MOD)) % MOD;
        }
        System.out.println(ans);
    }

    //Fast IO class
    static class Reader {
        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;

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

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

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

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

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

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

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

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

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

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

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

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

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

    private static void sort(double[] arr) {
        Double[] objArr = Arrays.stream(arr).boxed().toArray(Double[]::new);
        Arrays.sort(objArr);
        for (int i = 0; i < arr.length; i++) {
            arr[i] = objArr[i];
        }
    }

    private static void sort(int[] arr) {
        Integer[] objArr = Arrays.stream(arr).boxed().toArray(Integer[]::new);
        Arrays.sort(objArr);
        for (int i = 0; i < arr.length; i++) {
            arr[i] = objArr[i];
        }
    }

    private static void sort(long[] arr) {
        Long[] objArr = Arrays.stream(arr).boxed().toArray(Long[]::new);
        Arrays.sort(objArr);
        for (int i = 0; i < arr.length; i++) {
            arr[i] = objArr[i];
        }
    }

    static long CNK(int N, int K, long MOD) {
        if (K > N) return 0;
        long ans = 1;
        for (long i = Math.max(K, N - K) + 1; i <= N; i++)
            ans = (ans * i) % MOD;
        for (long i = Math.min(K, N - K); i > 1; i--) {
            ans = (ans * modInverse(i, MOD)) % MOD;
        }
        return ans;
    }

    static long modInverse(long a, long mod) {
        return euclidesExtendido(a, mod)[1]>0?euclidesExtendido(a, mod)[1]:mod+euclidesExtendido(a, mod)[1];
    }

    static long[] euclidesExtendido(long a, long b) {
        for (long q, s = 1, t = 0, s1 = 0, t1 = 1, x; ; ) {
            x = b;
            q = a / b;
            b = a % b;
            a = x;
            x = s1;
            s1 = s - q * s1;
            s = x;
            x = t1;
            t1 = t - q * t1;
            t = x;
            if (b == 0) return new long[]{a, s, t};
        }
    }
}

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

// n = k(lw(n/k)) + n%k
public class Sola5 {
	static int MOD = 998244353;

	public static long modexp(long x, long y, int N){
		// System.out.println(y)
;		if(y == 0)return 1;
		long z = modexp(x, y/2, N);
		long d = z*z%N;
		if((y&1) == 0)return d;
		else{
			return (x*d%N);
		}
	}

	int fac[] = new int[500001];
	int inverseFac[] = new int[500001];

	public long nCr(int n, int r)
	{
	    if(n == r || r== 0)return 1;
	    long ll = 1;
	    long res = ((((ll*fac[n]*inverseFac[r])%MOD)*inverseFac[n-r])%MOD);
	    return res;
	}

	// Returns factorial of n
	int fact(int n)
	{
	    int res = 1;
	    for (int i = 2; i <= n; i++)
	        res = res * i;
	    return res;
	}
	public int getPossibility(int n, int k){
		long total = 0;
		for(int i = 1;i<=n;i++){
			int no = n/i;
			if(no < k)break;
			total += nCr(no-1,k-1);
			total %= MOD;
		}
		return (int)total;
	}

	public void init(){
		fac[0] = 1;
		long l1 = 1;
		for(int i = 1;i<100001;i++){
			long product = l1*fac[i-1]*i%MOD;
	    	fac[i] = (int)product;
	    	inverseFac[i] = (int)modexp(fac[i], MOD-2, MOD);
	    	/*if(inverseFac[i] < 0){
	    		long l = modexp(fac[i], MOD-2, MOD);
	    		System.out.println(i+","+l+","+fac[i]+"," + (l1*fac[i-1]*i)%MOD+","+fac[i-1]);
	    		break;
	    	}*/
		}

	}
	public static void main(String[] args) throws IOException{
		Sola5 s5 = new Sola5();
		s5.init();
		BufferedReader obj = new BufferedReader(new InputStreamReader(System.in));
		String lineNo = obj.readLine();
		String[] a = lineNo.split(" ");
		int a1 = Integer.parseInt(a[0]);
		int a2 = Integer.parseInt(a[1]);

		System.out.println(s5.getPossibility(a1, a2));
	}

}

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

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

    static class TaskC1 {
        public void solve(int testNumber, Scanner in, PrintWriter out) {
            int n = in.nextInt();
            int k = in.nextInt();
            long ans = 0;
            int mod = 998244353;

            if (n < k) out.println(0);
            else {
                for (int i = 1; i <= n && n / i >= k; i++) {
                    if (n / i == k) {
                        ans++;
                        break;
                    }
                    long ans_ = 1;
                    for (int j = n / i - 1 - k + 1 + 1; j <= n / i - 1; j++) {
                        ans_ *= j;
                        ans_ %= mod;
                    }

                    long rep = ans_;
                    ans_ = 1;
                    for (int j = 2; j <= k - 1; j++) {
                        ans_ *= j;
                        ans_ %= mod;
                    }
                    int z = mod - 2;
                    int c = 0;
                    int j = 0;
                    long ans_1 = ans_;
                    while (z > 0) {
//                    long ans_1 = ans_;
                        if (z % 2 == 1) {
                            for (; j < c; j++) {
                                ans_1 *= ans_1;
                                ans_1 %= mod;
                            }
                            rep *= ans_1;
                            rep %= mod;
                        }
                        z /= 2;
                        c++;
                    }
                    ans += rep;
                    ans %= mod;
                }
                out.println(ans);
            }
        }

    }
}

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

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

    static class TaskC1 {
        public void solve(int testNumber, Scanner in, PrintWriter out) {
            int n = in.nextInt();
            int k = in.nextInt();
            long ans = 0;
            int mod = 998244353;

            if (n < k) out.println(0);
            else {
                if (k == 1) {
                    out.println(n);
                    return;
                }
                for (int i = 1; i <= n && n / i >= k; i++) {
                    if (n / i == k) {
                        ans++;
                        break;
                    }
                    long ans_ = 1;
                    for (int j = n / i - 1 - k + 1 + 1; j <= n / i - 1; j++) {
                        ans_ *= j;
                        ans_ %= mod;
                    }

                    long rep = ans_;
                    ans_ = 1;
                    for (int j = 2; j <= k - 1; j++) {
                        ans_ *= j;
                        ans_ %= mod;
                    }
                    int z = mod - 2;
                    int c = 0;
                    int j = 0;
                    long ans_1 = ans_;
                    while (z > 0) {
//                    long ans_1 = ans_;
                        if (z % 2 == 1) {
                            for (; j < c; j++) {
                                ans_1 *= ans_1;
                                ans_1 %= mod;
                            }
                            rep *= ans_1;
                            rep %= mod;
                        }
                        z /= 2;
                        c++;
                    }
                    ans += rep;
                    ans %= mod;
                }
                out.println(ans);
            }
        }

    }
}

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

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

    static class TaskC1 {
        public void solve(int testNumber, Scanner in, PrintWriter out) {
            int n = in.nextInt();
            int k = in.nextInt();
            long ans = 0;
            int mod = 998244353;

            if (n < k) out.println(0);
            else {
                if (k == 1) {
                    out.println(n);
                    return;
                }
                for (int i = 1; i <= k && n / i >= k; i++) {
                    if (n / i == k) {
                        ans++;
                        break;
                    }
                    long ans_ = 1;
                    for (int j = n / i - 1 - k + 1 + 1; j <= n / i - 1; j++) {
                        ans_ *= j;
                        ans_ %= mod;
                    }

                    long rep = ans_;
                    ans_ = 1;
                    for (int j = 2; j <= k - 1; j++) {
                        ans_ *= j;
                        ans_ %= mod;
                    }
                    int z = mod - 2;
                    int c = 0;
                    int j = 0;
                    long ans_1 = ans_;
                    while (z > 0) {
//                    long ans_1 = ans_;
                        if (z % 2 == 1) {
                            for (; j < c; j++) {
                                ans_1 *= ans_1;
                                ans_1 %= mod;
                            }
                            rep *= ans_1;
                            rep %= mod;
                        }
                        z /= 2;
                        c++;
                    }
                    ans += rep;
                    ans %= mod;
                }
                out.println(ans);
            }
        }

    }
}

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

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

    static class EModularStability {
        public void solve(int testNumber, FastReader s, PrintWriter out) {
            int n = s.nextInt(), k = s.nextInt();

            long ans1 = 0L;
            long mod = 998244353L;
            for (int i = 1; i <= k; i++) {
                int div = n / i;
                ans1 = ((ans1 % mod) + nCrModPFermat(div - 1, k - 1, mod)) % mod;
            }
            if (k == 1) {
                ans1 = n;
            }
            out.println(ans1);
        }

        static long power(long x, long y, long p) {
            long res = 1;
            x = x % p;
            while (y > 0) {
                if (y % 2 == 1) {
                    res = (res * x) % p;
                }
                y = y >> 1;
                x = (x * x) % p;
            }
            return res;
        }

        static long modInverse(long n, long p) {
            return power(n, p - 2, p);
        }

        static long nCrModPFermat(int n, int r, long p) {
            if (n < r) {
                return 0;
            }

            if (r == 0) {
                return 1;
            }

            long[] fac = new long[n + 1];
            fac[0] = 1L;

            for (long i = 1; i <= n; i++) {
                fac[(int) i] = (fac[(int) (i - 1)] * i) % p;
            }

            return ((fac[n] * modInverse(fac[r], p) % p) * (modInverse(fac[n - r], p) % p)) % p;
        }

    }

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

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

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

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

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

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

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

        }

    }
}