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

public class candies {
    public static boolean test(long k, long num) {
        long sum = 0;
        long current = num;
        while(current > 0) {
            long temp = Math.min(current, k);
            sum += temp;
            current -= temp;
            current -= (current/10);
        }
    }

    public static void main(String[] args) {
        BufferedReader input  = new BufferedReader(new InputStreamReader(System.in));
		long n = Long.parseLong(input.readLine());
		long start = 1;
		long end = n;
		long sol = n;
		while(start <= end) {
		    long midp = (start + end)/2;
		    if(test(mid,n)) {
		        sol = mid;
		        end = mid-1;
		    }
		    else {
		        start = mid+1;
		    }
		}
		System.out.println(sol);
    }
}


import java.util.*;
public class Main{
    public static void main(String[]args){
        Scanner input = new Scanner(System.in);
        int x = input.nextInt();
        int y = input.nextInt();
        if((remoZero(x + y)) == (remoZero(x) + remoZero(y)))
            System.out.println("YES");
        else
            System.out.println("NO");
    }
    public static int remoZero(int n){
        String s = String.valueOf(n);
        return Integer.parseInt(s.replace("0", ""));
    }
}
    }
}


import com.sun.xml.internal.ws.wsdl.parser.InaccessibleWSDLException;

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

/**
 * Author -
 * User: kansal
 * Date: 4/13/11
 * Time: 8:28 PM
 */
public class TaskA {
    public static void main(String[] args) {
        reader = new BufferedReader(new InputStreamReader(System.in));

        String A = next(), B = next();
        int c = Integer.parseInt(A) + Integer.parseInt(B);
        A = A.replace("0", "");
        B = B.replace("0", "");
        if (c == Integer.parseInt(A) + Integer.parseInt(B)) {
            System.out.println("YES");
        }
        else {
            System.out.println("NO");
        }

    }

    public static BufferedReader reader;

    public static StringTokenizer tokenizer = null;

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

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

    static public String next() {
        return nextToken();
    }

    static public String nextLine() {
        try {
            return reader.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }
}


import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

public class LifeWithoutZero {

    public static void main(String[] args) {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        String n1 = "", n2 = "", aa = "", bb = "", ss = "", sss = "";

        int a, b, sum, s;

        try {

            n1 = br.readLine();

            n2 = br.readLine();

            a = Integer.parseInt(n1);

            b = Integer.parseInt(n2);

            sum = a + b;

            ss = sum + "";

            for (int i = 0; i < n1.length(); i++) {

                if (Integer.parseInt(n1.substring(i, i + 1)) != 0) {

                    aa += n1.substring(i, i + 1);

                }

            }

            for (int i = 0; i < n2.length(); i++) {

                if (Integer.parseInt(n2.substring(i, i + 1)) != 0) {

                    bb += n2.substring(i, i + 1);

                }

            }

            for (int i = 0; i < ss.length(); i++) {

                if (Integer.parseInt(ss.substring(i, i + 1)) != 0) {

                    sss += ss.substring(i, i + 1);

                }

            }


import java.util.*;
import java.io.*;
public class Hello
{
    public int removeZero(int m)
    {
        int reverse = 0;
        while(m>0)
        {
            if(m%10!=0)
                reverse = (reverse*10)+(m%10);
            m/=10;
        }
        int sum = 0;
        while(reverse>0)
        {
            sum = sum*10+(reverse%10);
            reverse/=10;
        }
        return sum;
    }
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        int m  = sc.nextInt();
        int n = sc.nextInt():
        int sum = m+n;
        int k = removeZero(m);
        int l = removeZero(n);
        int s = removeZero(k+l);
        if(k+l==s)
            System.out.println("Yes");
        else
            System.out.println("No");
    }
}


import java.util.*;

public class QuickQuantifiers {

	private static final Scanner SCANNER = new Scanner(System.in);

	public static void main(String[] args) {
		int input = SCANNER.nextInt();
		if(!input % 2 == 0) {
			System.out.println("1");
		} else {
			System.out.println("0");
		}
	}
}


public class A{
    public static void main(String[] args) throws Exception {
        Scanner scan = new Scanner(System.in)   ;
        int a = scan.nextInt();
        System.out.println(a%2);
    }

}


public class Driver {

	public static Scanner scanner;

	public static void main(String[] args) {

		scanner = new Scanner(System.in);
		Driver driver = new Driver();

		int n = scanner.nextInt();

		if(n%2==0) {
			System.out.println(0);
		}else {
			System.out.println(1);
		}

	}

}


public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
       int n = sc.nextInt();
      if(n%2=0)
        System.out.println("0");

        else{
          System.out.println("1");
        }
    }
}


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

import static java.lang.Math.*;
import static java.util.Arrays.fill;
import static java.util.Arrays.binarySearch;
import static java.util.Arrays.sort;

public class Main {
	public static void main(String[] args) throws IOException {
		new Thread(null, new Runnable() {
			public void run() {
				try {
					try {
						if (new File("input.txt").exists())
							System.setIn(new FileInputStream("input.txt"));
					} catch (SecurityException e) {}
					new Main().run();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}, "1", 1L << 24).start();
	}

	BufferedReader in;
	PrintWriter out;
	StringTokenizer st = new StringTokenizer("");

	long MOD = 1000000009L;

	int N;
	int M;
	List<String> sss = new ArrayList<String>(10);
	List<String> ss = new ArrayList<String>(10);
	char[][] s;

	long[][] dp;

	String checkS;
	int checkL;
	int checkI;

	void run() throws IOException {
		in = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);

		N = nextInt();
		M = nextInt();

		for (int i = 0; i < M; i++) {
			String cs = nextToken();
			if (cs.length() <= N)
				sss.add(cs);
		}

		for (int i = 0; i < sss.size(); i++) {
			String si = sss.get(i);
			checkS = si;
			checkL = si.length();
			checkI = i;
			fill(used, false);
			if (!rec(0)) {
				ss.add(si);
			}
		}

		M = ss.size();

		if (M == 0) {
			out.println(0);
			out.close();
			return;
		}

		s = new char [M][];
		for (int i = 0; i < M; i++)
			s[i] = ss.get(i).toCharArray();

		dp = new long [N + 1][M];
		for (int i = 0; i < M; i++)
			dp[s[i].length][i]++;
		for (int pos = 0; pos < N; pos++) {
			for (int last = 0; last < M; last++) {
				if (dp[pos][last] == 0L) continue;
				for (int next = 0; next < M; next++) {
					for (int offset = 1; offset <= s[last].length; offset++) {
						if (can(last, next, offset)) {
							int npos = pos - s[last].length + offset + s[next].length;
							if (npos <= N)
								dp[npos][next] = (dp[npos][next] + dp[pos][last]) % MOD;
						}
					}
				}
			}
		}

//		for (long[] a : dp)
//			System.out.println(Arrays.toString(a));

		long ans = 0L;
		for (int last = 0; last < M; last++)
			ans = (ans + dp[N][last]) % MOD;
		out.println(ans);

		out.close();
	}

	boolean[] used = new boolean [20];

	boolean rec(int pos) {
		if (pos == checkL) return true;
		if (used[pos]) return false;
		used[pos] = true;
		for (int i = 0; i < M; i++) {
			if (i == checkI) continue;
			String cs = sss.get(i);
			for (int offset = 0; offset < checkL; offset++) {
				int npos = offset + cs.length();
				if (npos <= checkL && match(offset, cs)) {
					if (rec(npos))
						return true;
				}
			}
		}
		return false;
	}

	boolean match(int offset, String s) {
		for (int i = 0; i < s.length(); i++)
			if (checkS.charAt(offset + i) != s.charAt(i))
				return false;
		return true;
	}

	boolean can(int last, int next, int offset) {
		char[] s1 = s[last];
		char[] s2 = s[next];
		if (offset + s2.length <= s1.length) return false;
		for (int i = offset; i < s1.length; i++)
			if (s1[i] != s2[i - offset])
				return false;
		return true;
	}

	/***************************************************************
	 * Input
	 **************************************************************/
	String nextToken() throws IOException {
		while (!st.hasMoreTokens())
			st = new StringTokenizer(in.readLine());
		return st.nextToken();
	}

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

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

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

	String nextLine() throws IOException {
		st = new StringTokenizer("");
		return in.readLine();
	}

	boolean EOF() throws IOException {
		while (!st.hasMoreTokens()) {
			String s = in.readLine();
			if (s == null)
				return true;
			st = new StringTokenizer(s);
		}
		return false;
	}
}


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

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Solution {
	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(1, in, out);
		out.close();
	}
}

class Task
{
    public void solve(int testNumber, InputReader in, PrintWriter out)
    {
        int n = in.nextInt();
        int m = in.nextInt();
        String[] Viruses = new String[m];
        for (int i = 0; i < m; i++)
        {
            Viruses[i] = in.nextToken();
        }
        HashMap<String, Integer> Index = new HashMap<String, Integer>();
        int lastIndex = 1;
        for (int i = 0; i < m; i++)
        {
            for (int j = 0; j < Viruses[i].length(); j++)
            {
                Index.put(Viruses[i].substring(0, j + 1), lastIndex++);
            }
        }
        Index.put("",0);
        int[][] replaceMent = new int[lastIndex][26];
        int[] longestSuffix = new int[lastIndex];
        //Найдем строку, которая заканчиывает каждый префикс и является наибольшей:
        for (String s : Index.keySet())
            for (String t : Viruses)
                if (s.endsWith(t))
                    longestSuffix[Index.get(s)] = Math.max(longestSuffix[Index.get(s)], t.length());

        //Допустим мы в позиции I, и пишем букву CH. Найдем максимальный префикс который в итоге получитcя:

        for (String s : Index.keySet()) {
            int start = Index.get(s);
            for (char ch = 'A'; ch <= 'Z'; ch++) {
                String candidate=s.concat(Character.toString(ch));//берем по максимуму
                while (!Index.containsKey(candidate))
                    candidate = candidate.substring(1);//отрезаем первый символ
                replaceMent[start][ch-'A'] = Index.get(candidate);
            }
        }

        int[][] dp = new int[Index.size()][20]; //За состояние в индексе I примем последний
                                                //префикс И удаленность первого ненакрытого символа
        int modulo=1000000009;
        dp[Index.get("")][0] = 1;//Существует ровно одна пустая строка
        for (int idx = 0; idx < n; ++idx) {
            int[][] newDp = new int[Index.size()][20];
            for (int oldprefix = 0; oldprefix < lastIndex; oldprefix++)
                for (int oldCover = 0; oldCover < 20; oldCover++) {
                    for (char ch='A'; ch <='Z'; ch++) {
                        int newPrefix = replaceMent[oldprefix][ch-'A'];
                        int newCover = oldCover + 1; //теперь нам надо на 1 больше,так как мы продвинулись на 1
                        if (newCover <= longestSuffix[newPrefix])
                            newCover = 0;//если мы накрыли то что было ненакрыто, то we are happy!
                        if (newCover >=20)//тяжелый случай
                            continue;
                        newDp[newPrefix][newCover] = (newDp[newPrefix][newCover]+dp[oldprefix][oldCover])%modulo;

                    }
                }
            dp=newDp;
            //cnt = oneStep(cnt, maxLength, last, isFinish, next);
        }
        int answer = 0;
        for (int i = 0; i < lastIndex; i++) {
            answer = (answer+dp[i][0])%modulo;

        }
        out.println(answer);
    }
}

class InputReader {
    StringTokenizer st;
    BufferedReader in;
    public InputReader(InputStream ins)
    {
        in = new BufferedReader(new InputStreamReader(ins));
    }

    public String nextToken()
    {
        while(st==null || !st.hasMoreTokens())
        {
            try {
                st=new StringTokenizer(in.readLine());
            } catch (IOException e) {
                e.printStackTrace();  //To change body of catch statement use File | Settings | File Templates.
            }
        }
        return st.nextToken();
    }
    public int nextInt()
    {

        return Integer.parseInt(nextToken());
    }

    }


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

public class C {

    int[] charToNumber;
    final int alphabetSize = 4;
    final int MOD = 1000000009;

    int getSymbNumber(char c) {
        return charToNumber[c];
    }

    class Trie {
        class Node {
            boolean isFinal;
            Node sufLink;
            Node[] child;
            Node[] go;
            Node parent;
            int parSymb;
            int index;

            ArrayList<Integer> finalNums;
            ArrayList<Integer> finalDepth;

            public Node() {
                child = new Node[alphabetSize];
                go = new Node[alphabetSize];
                index = ls.size();
                finalNums = new ArrayList<Integer>();
                finalDepth = new ArrayList<Integer>();
            }
        }

        ArrayList<Node> ls = new ArrayList<Node>();

        Node root;

        public Trie() {
            root = new Node();
            ls.add(root);
        }

        void addString(String s) {
            Node v = root;
            for (int i = 0; i < s.length(); i++) {
                Node prev = v;
                int symb = getSymbNumber(s.charAt(i));
                if (v.child[symb] == null) {
                    v.child[symb] = new Node();
                    ls.add(v.child[symb]);
                }
                v = v.child[symb];
                v.parent = prev;
                v.parSymb = symb;
            }
            v.isFinal = true;
        }

        void buildAutomaton() {
            ArrayDeque<Node> q = new ArrayDeque<Node>();
            root.sufLink = root;
            for (int i = 0; i < alphabetSize; i++) {
                if (root.child[i] != null) {
                    root.go[i] = root.child[i];
                    q.addLast(root.child[i]);
                } else
                    root.go[i] = root;
            }
            while (!q.isEmpty()) {
                Node v = q.pollFirst();
                v.sufLink = v.parent == root ? root
                        : v.parent.sufLink.go[v.parSymb];
                v.isFinal |= v.sufLink.isFinal;
                for (int i = 0; i < alphabetSize; i++)
                    if (v.child[i] != null) {
                        v.go[i] = v.child[i];
                        q.addLast(v.child[i]);
                    } else
                        v.go[i] = v.sufLink.go[i];
            }
        }

        void buildFinal(Node v) {
            for (int i = 0; i < alphabetSize; i++)
                if (v.child[i] != null) {
                    buildFinal(v.child[i]);
                    for (int j = 0; j < v.child[i].finalNums.size(); j++) {
                        v.finalDepth.add(v.child[i].finalDepth.get(j) + 1);
                        v.finalNums.add(v.child[i].finalNums.get(j));
                    }
                    if (v.child[i].isFinal) {
                        v.finalDepth.add(1);
                        v.finalNums.add(v.child[i].index);
                    }
                }
        }

        void lastMagic() {
            ArrayDeque<Node> q = new ArrayDeque<Node>();
            for (int i = 0; i < alphabetSize; i++)
                if (root.child[i] != null)
                    q.add(root.child[i]);

            while (!q.isEmpty()) {
                Node v = q.pollFirst();
                v.finalDepth.addAll(v.sufLink.finalDepth);
                v.finalNums.addAll(v.sufLink.finalNums);
                for (int i = 0; i < alphabetSize; i++)
                    if (v.child[i] != null) {
                        q.add(v.child[i]);
                    }
            }
        }
    }

    BufferedReader br;
    PrintWriter out;
    StringTokenizer st;
    boolean eof;

    void solve() throws IOException {
        int n = nextInt();
        int m = nextInt();

        charToNumber = new int[256];
        Arrays.fill(charToNumber, -1);
        charToNumber['A'] = 0;
        charToNumber['C'] = 1;
        charToNumber['G'] = 2;
        charToNumber['T'] = 3;

        Trie t = new Trie();

        for (int i = 0; i < m; i++)
            t.addString(nextToken());

        t.buildAutomaton();
        t.buildFinal(t.root);
        t.lastMagic();

        int[][] dp = new int[n + 1][t.ls.size()];
        for (int i = 0; i < t.root.finalDepth.size(); i++)
            dp[t.root.finalDepth.get(i)][t.root.finalNums.get(i)]++;

        for (int i = 1; i <= n; i++)
            for (int j = 0; j < t.ls.size(); j++)
                if (dp[i][j] != 0) {
                    Trie.Node v = t.ls.get(j).sufLink;

                    for (int k = 0; k < v.finalDepth.size(); k++)
                        if (i + v.finalDepth.get(k) <= n) {
                            dp[i + v.finalDepth.get(k)][v.finalNums.get(k)] += dp[i][j];
                            if (dp[i + v.finalDepth.get(k)][v.finalNums.get(k)] >= MOD)
                                dp[i + v.finalDepth.get(k)][v.finalNums.get(k)] -= MOD;
                        }
                }

        int ans = 0;
        for (int i = 0; i < t.ls.size(); i++) {
            ans += dp[n][i];
            if (ans >= MOD)
                ans -= MOD;
        }

        out.print(ans);

    }

    void inp() 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 C().inp();
    }

    String nextToken() {
        while (st == null || !st.hasMoreTokens()) {
            try {
                st = new StringTokenizer(br.readLine());
            } catch (Exception e) {
                eof = true;
                return "0";
            }
        }
        return st.nextToken();
    }

    String nextString() {
        while (st == null || !st.hasMoreTokens()) {
            try {
                st = new StringTokenizer(br.readLine());
            } catch (Exception e) {
                eof = true;
                return "0";
            }
        }
        return st.nextToken("\n");
    }

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

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

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

}


package code;

import iensen.IO.InputReader;

import java.io.PrintWriter;
import java.util.HashMap;

public class Task
{
    public void solve(int testNumber, InputReader in, PrintWriter out)
    {
        int n = in.nextInt();
        int m = in.nextInt();
        String[] Viruses = new String[m];
        for (int i = 0; i < m; i++)
        {
            Viruses[i] = in.nextToken();
        }
        HashMap<String, Integer> Index = new HashMap<String, Integer>();
        int lastIndex = 1;
        for (int i = 0; i < m; i++)
        {
            for (int j = 0; j < Viruses[i].length(); j++)
            {
                Index.put(Viruses[i].substring(0, j + 1), lastIndex++);
            }
        }
        Index.put("",0);
        int[][] replaceMent = new int[lastIndex][26];
        int[] longestSuffix = new int[lastIndex];
        //Найдем строку, которая заканчиывает каждый префикс и является наибольшей:
        for (String s : Index.keySet())
            for (String t : Viruses)
                if (s.endsWith(t))
                    longestSuffix[Index.get(s)] = Math.max(longestSuffix[Index.get(s)], t.length());

        //Допустим мы в позиции I, и пишем букву CH. Найдем максимальный префикс который в итоге получитcя:

        for (String s : Index.keySet()) {
            int start = Index.get(s);
            for (char ch = 'A'; ch <= 'Z'; ch++) {
                String candidate=s.concat(Character.toString(ch));//берем по максимуму
                while (!Index.containsKey(candidate))
                    candidate = candidate.substring(1);//отрезаем первый символ
                replaceMent[start][ch-'A'] = Index.get(candidate);
            }
        }

        int[][] dp = new int[lastIndex][20]; //За состояние в индексе I примем последний
                                                //префикс И удаленность первого ненакрытого символа
        int modulo=1000000009;
        dp[Index.get("")][0] = 1;//Существует ровно одна пустая строка
        for (int idx = 0; idx < n; ++idx) {
            int[][] newDp = new int[lastIndex][20];
            for (int oldprefix = 0; oldprefix < lastIndex; oldprefix++)
                for (int oldCover = 0; oldCover < 20; oldCover++) {
                    for (char ch='A'; ch <='Z'; ch++) {
                        int newPrefix = replaceMent[oldprefix][ch-'A'];
                        int newCover = oldCover + 1; //теперь нам надо на 1 больше,так как мы продвинулись на 1
                        if (newCover <= longestSuffix[newPrefix])
                            newCover = 0;//если мы накрыли то что было ненакрыто, то we are happy!
                        if (newCover >=20)//тяжелый случай
                            continue;
                        newDp[newPrefix][newCover] = (newDp[newPrefix][newCover]+dp[oldprefix][oldCover])%modulo;

                    }
                }
            dp=newDp;
            //cnt = oneStep(cnt, maxLength, last, isFinish, next);
        }
        int answer = 0;
        for (int i = 0; i < lastIndex; i++) {
            answer = (answer+dp[i][0])%modulo;

        }
        out.println(answer);
    }
}


import java.util.Scanner;

public class CF_1092F {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        int n = in.nextInt();
        int[] a = new int[n];

        for (int i=0; i<n;i++) a[i] = in.nextInt();

        for (int i=0; i<n; i++) {
            for (int j=i; j>0 && a[j-1] > a[j]; j--) {
                int temp = a[j-1];
                a[j-1] = a[j];
                a[j] = temp;
            }
        }
        int res = 0;a

        for (int i=0; i<n; i+=2) res += Math.abs(a[i] - a[i+1]);
        System.out.println(res);
    }
}


import java.util.Scanner;

public class teamsForming {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
int numOfTeams=0;
Scanner k=new Scanner(System.in);
numOfTeams=k.nextInt();
int a[]=new int[numOfTeams];
for(int i=0;i<numOfTeams;i++) {
	a[i]=k.nextInt();
}{
sort(a,0,a.length-1);
  int sum=0;
 int i=0;
 int j=1;

 while(j<numOfTeams) {
	 sum+=a[j]-a[i];
	 i+=2;
	 j+=2;
 }
  System.out.println(sum);
	}static int partition(int arr[], int low, int high)
    {
        int pivot = arr[high];
        int i = (low-1);
        for (int j=low; j<high; j++)
        {
             if (arr[j] <= pivot)
            {
                i++;

                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }

        int temp = arr[i+1];
        arr[i+1] = arr[high];
        arr[high] = temp;

        return i+1;
    }

    public static void sort(int arr[], int low, int high)
    {
        if (low < high)
        {
            int pi = partition(arr, low, high);

           sort(arr, low, pi-1);
            sort(arr, pi+1, high);
        }
    }
}


import java.util.*;
public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n=sc.nextInt();

        int sum=0;

        int[] arr = new int[];

        for(int i=0;i<n;i++){
            arr[i]=sc.nextInt();
        }

        Arrays.sort(arr);

        for(int i=1;i<n;i=i+2){
            sum+=arr[i]-arr[i-1];
        }

        System.out.println(sum);
    }
}


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

import static java.lang.System.out;
public class Main {

    private Scanner in = new Scanner(new BufferedReader(new InputStreamReader(System.in)));

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

    void solveAll(){
        int T = in.nextInt();
        for(int i = 1; i <= T; i++){
            String res = solveTest();
            out.println(res);
        }
    }

    void solveTest(){
        int N = in.nextInt();

        int[] students = new int[N];

        for(int i = 0; i < N; i++){
            students[i] = in.nextInt();
        }

        Arrays.sort(students);

        int res = 0;
        for(int i = 1; i < students.length; i = i + 2){
            res+= students[i] - students[i - 1];
        }

        out.println(res);
    }

    String getLetter(List<BigInteger> bigIntegers, BigInteger s){
        for(int i = 0; i < bigIntegers.size(); i++){
            if(bigIntegers.get(i).equals(s)){
                char c = (char) (65 + i);
                return Character.toString(c);
            }
        }
        return null;
    }

    BigInteger primeF(BigInteger b){
        BigInteger next = new BigInteger("2");
        while (true) {
            if (b.remainder(next).equals(BigInteger.ZERO)) {
                return next;
            } else {
                next = next.nextProbablePrime();
            }
        }
    }
}


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

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

		//Code Starts Here

		int n = in.nextInt();
		long fact=1;
		for(int i=n;i>(n-5);i--)
			fact *= i;

	//	pw.println(comb(7,5)+" "+factorial(6));

		pw.print(fact * comb(n,5));

		//Code Ends Here

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

	static class InputReader {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		for(int i=2;i*i<n;i++)
		{
			if(isPrime[i] == true)
			{
				for(int j=(2*i);j<n;j+=i)
					isPrime[j] = false;
			}
		}
	}
	static boolean coprime(long u, long v)
	{
	    if (((u | v) & 1) == 0) return false;

	    while ((u & 1) == 0) u >>= 1;
	    if (u == 1) return true;

	    do
	    {
	        while ((v & 1) == 0) v >>= 1;
	        if (v == 1) return true;

	        if (u > v) { long t = v; v = u; u = t; }
	        v -= u;
	    } while (v != 0);

	    return false;
	}

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

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

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

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

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

	public static long  factorial(long n) {

		long fact = 1;
		for(int i=1; i<=n; i++)
			fact*= i;

		return fact;

	}

	public static long comb(int a, int b) {
		long c= factorial(a)/(factorial(b)*factorial(a-b));

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

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

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

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

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

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

	public static boolean isPrime(int n)
	{

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

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

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

	    return true;
	}

	static class pair implements Comparable<pair>
	{
		Integer x, y;
		pair(int x,int y)
		{
			this.x=x;
			this.y=y;
		}

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

			return result;
		}

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

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

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


public class Z630H {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        PrintWriter writer = new PrintWriter(System.out);
        long n = in.nextLong();
        long otv  = n/1 * (n-1) /2*(n-2)/3*(n-3)/4*(n-4)/5;
        long a = n*(n-1)*(n-2)*(n-3)*(n-4);
        System.out.println(otv*a);
    }
}


import java.util.*;

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

        long n = in.nextLong();
        long cn5 = n * (n - 1) / 2 * (n - 2) / 3 * (n - 3) / 4 * (n - 4) / 5;
        long an5 = n * (n - 1) * (n - 2) *  (n - 3) * (n - 4);

        System.out.println(cn5*an5);
    }
}


import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Calendar;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.SortedSet;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

/**
 * #
 * @author pttrung
 */
public class H_Volbit {

    public static long MOD = 1000000007;

    public static void main(String[] args) throws FileNotFoundException {
        // PrintWriter out = new PrintWriter(new FileOutputStream(new File(
        // "output.txt")));
        PrintWriter out = new PrintWriter(System.out);
        Scanner in = new Scanner();
        int n = in.nextInt();
        long v = cal(0, 5, n, n);
        out.println(v);
        out.close();
    }

    public static long cal(int index, int left, int bench, int n){
    	if(index == n){
    		if(left == 0){
    			return 1;
    		}
    		return 0;
    	}
    	if(left == 0){
    		return 1;
    	}
    	long result = bench*cal(index + 1, left - 1, bench - 1, n) + cal(index + 1, left, bench, n);
    	return result;
    }

    public static int[] KMP(String val) {
        int i = 0;
        int j = -1;
        int[] result = new int[val.length() + 1];
        result[0] = -1;
        while (i < val.length()) {
            while (j >= 0 && val.charAt(j) != val.charAt(i)) {
                j = result[j];
            }
            j++;
            i++;
            result[i] = j;
        }
        return result;

    }

    public static boolean nextPer(int[] data) {
        int i = data.length - 1;
        while (i > 0 && data[i] < data[i - 1]) {
            i--;
        }
        if (i == 0) {
            return false;
        }
        int j = data.length - 1;
        while (data[j] < data[i - 1]) {
            j--;
        }
        int temp = data[i - 1];
        data[i - 1] = data[j];
        data[j] = temp;
        Arrays.sort(data, i, data.length);
        return true;
    }

    public static int digit(long n) {
        int result = 0;
        while (n > 0) {
            n /= 10;
            result++;
        }
        return result;
    }

    public static double dist(long a, long b, long x, long y) {
        double val = (b - a) * (b - a) + (x - y) * (x - y);
        val = Math.sqrt(val);
        double other = x * x + a * a;
        other = Math.sqrt(other);
        return val + other;

    }

    public static class Point implements Comparable<Point> {

        int x, y;

        public Point(int start, int end) {
            this.x = start;
            this.y = end;
        }

        @Override
        public int hashCode() {
            int hash = 5;
            hash = 47 * hash + this.x;
            hash = 47 * hash + this.y;
            return hash;
        }

        @Override
        public boolean equals(Object obj) {
            if (obj == null) {
                return false;
            }
            if (getClass() != obj.getClass()) {
                return false;
            }
            final Point other = (Point) obj;
            if (this.x != other.x) {
                return false;
            }
            if (this.y != other.y) {
                return false;
            }
            return true;
        }

        @Override
        public int compareTo(Point o) {
            return x - o.x;
        }
    }

    public static class FT {

        long[] data;

        FT(int n) {
            data = new long[n];
        }

        public void update(int index, long value) {
            while (index < data.length) {
                data[index] += value;
                index += (index & (-index));
            }
        }

        public long get(int index) {
            long result = 0;
            while (index > 0) {
                result += data[index];
                index -= (index & (-index));
            }
            return result;

        }
    }

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

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

        }
    }

    static class Scanner {

        BufferedReader br;
        StringTokenizer st;

        public Scanner() throws FileNotFoundException {
            // System.setOut(new PrintStream(new BufferedOutputStream(System.out), true));
            br = new BufferedReader(new InputStreamReader(System.in));
            //  br = new BufferedReader(new InputStreamReader(new FileInputStream(new File("input.txt"))));
        }

        public String next() {

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

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

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

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

        public String nextLine() {
            st = null;
            try {
                return br.readLine();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }

        public boolean endLine() {
            try {
                String next = br.readLine();
                while (next != null && next.trim().isEmpty()) {
                    next = br.readLine();
                }
                if (next == null) {
                    return true;
                }
                st = new StringTokenizer(next);
                return st.hasMoreTokens();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }
    }
}


import java.util.Scanner;

public class Checker {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int a = s.nextInt();

        int b = s.nextInt();

        int c = s.nextInt();

        int sum = a + b + c;

        int max = Math.max(a, Math.max(b, c));

        System.out.println(Math.max(0, max - (sum - max) + 1));

    }
}


public class CodeforceMasha {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        int b = sc.nextInt();
        int c = sc.nextInt();
        if (a > b) {
            int temp = a;
            a = b;
            b = temp;
        }

        if (b > c) {
            int temp = b;
            b = c;
            c = temp;
        }

        int ans = 0;
        if (c - (a + b) > 0) {
            ans = c - (a + b) + 1;
        }
        System.out.println(ans);

    }

}


public class GFG {
	public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        int b = sc.nextInt();
        int c = sc.nextInt();

        int[] p = new int[3];
        p[0] = a;
        p[1] = b;
        p[2] = c;
        Arrays.sort(p);

        if((p[0] + p[1] > p[2]) && (p[0] + p[2] > p[1]) && (p[1] + p[2] > p[0])){
            System.out.println("0");
        }
        else{
            if((p[0] + p[1] <= p[2])){
                System.out.println(p[2] - (p[0] +  p[1]) + 1);
            }
            if((p[0] + p[2] <= p[1])){
                System.out.println(p[1] - (p[0] +  p[2]) + 1);
            }
            if((p[1] + p[2] <= p[0])){
                System.out.println(p[0] - (p[1] +  p[2]) + 1);
            }
        }

   }
}


import java.util.Scanner;

public class aseel {
public static void main (String args []) {
	Scanner in = new Scanner(System.in);
int [] arr = new int [3];
arr[0]=in.nextInt();
arr[1]=in.nextInt();
arr[2]=in.nextInt();
Arrays.parallelSort(arr);
if ((arr[2]-(arr[0]+arr[1])>=0)){
System.out.println(arr[2]-(arr[0]+arr[1])+1);
}else {
	System.out.println("0");
}
}
}


import java.util.*;

public class Time {
    int hour;
    int min;

    Time(int h, int m){
        super();
        hour=h;
        min=m;
    }
    public int getHours(){
        return hour;
    }
    public int getMinutes(){
        return min;
    }
    public void printTime(){
        if (hour<10) System.out.print("0"+hour+":");
        else System.out.print(hour+":");
        if (min<10) System.out.print("0"+min);
        else System.out.print(min);
    }
}

public class A387 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int h,m;
        Scanner in = new Scanner(System.in);
        in.useDelimiter("[:\n\\s]+");
        h=in.nextInt();
        m=in.nextInt();
        Time s = new Time(h,m);
        h=in.nextInt();
        m=in.nextInt();
        Time t = new Time(h,m);
        h=s.getHours()-t.getHours();
        m=s.getMinutes()-t.getMinutes();
        if (m<0) {
            m+=60;
            h--;
        }
        if (h<0) h+=24;
        Time res = new Time(h,m);
        res.printTime();

        in.close();
    }
}


import java.util.Scanner;

public class Time {
    int hour;
    int min;

    Time(int h, int m){
        super();
        hour=h;
        min=m;
    }
    public int getHours(){
        return hour;
    }
    public int getMinutes(){
        return min;
    }
    public void printTime(){
        if (hour<10) System.out.print("0"+hour+":");
        else System.out.print(hour+":");
        if (min<10) System.out.print("0"+min);
        else System.out.print(min);
    }
}

public class A387 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int h,m;
        Scanner in = new Scanner(System.in);
        in.useDelimiter("[:\n\\s]+");
        h=in.nextInt();
        m=in.nextInt();
        Time s = new Time(h,m);
        h=in.nextInt();
        m=in.nextInt();
        Time t = new Time(h,m);
        h=s.getHours()-t.getHours();
        m=s.getMinutes()-t.getMinutes();
        if (m<0) {
            m+=60;
            h--;
        }
        if (h<0) h+=24;
        Time res = new Time(h,m);
        res.printTime();

        in.close();
    }
}


import java.util.Scanner;

/**
 * Created by peter.bykov on 19.05.2014.
 */
public class Archive387A {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        String[] now = s.nextLine().split(":");
        String[] sleepTime = s.nextLine().split(":");
        int hours = Integer.parseInt(now[0]) - Integer.parseInt(sleepTime[0]);
        if(hours < 0) {
            hours = 24 + hours;
        }
        int minutes = Integer.parseInt(now[1]) - Integer.parseInt(sleepTime[1]);
        if(minutes < 0) {
            if(hours > 0) {
                --hours;
            } else {
                hours = 23;
            }
            minutes = 60 + minutes;
        }
        System.out.println(((hours>=10)?hours:"0"+hours) + ":" + ((minutes>=10)?minutes:"0"+minutes));

    }


import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.StringTokenizer;

/**
 *
 * @author nastra - Eduard Tudenhoefner
 */
public class One {

    private static final SimpleDateFormat df = new SimpleDateFormat("HH:mm");

    public static void main(String[] args) throws Exception {
        com.nastra.hackerrank.util.FastScanner sc = new com.nastra.hackerrank.util.FastScanner(System.in);
        String start = sc.next();
        String duration = sc.next();
        System.out.println(time(start, duration));
    }

    public static String time(String start, String duration) throws ParseException {
        Date s = df.parse(start);
        Date t = df.parse(start);
        String[] dur = duration.split(":");
        String f = dur[0];
        if (f.startsWith("0")) {
            f = f.substring(1);
        }
        String g = dur[1];
        if (g.startsWith("0")) {
            g = g.substring(1);
        }
        Integer hour = Integer.valueOf(f);
        Integer min = Integer.valueOf(g);
        Calendar a = Calendar.getInstance();
        a.setTime(s);
        a.add(Calendar.HOUR_OF_DAY, -hour);
        a.add(Calendar.MINUTE, -min);

        return df.format(a.getTime());
    }

    static class FastScanner {

        private static BufferedReader reader;
        private static StringTokenizer tokenizer;

        public static void main(String[] args) throws Exception {
            com.nastra.hackerrank.util.FastScanner sc = new com.nastra.hackerrank.util.FastScanner(System.in);

        }

        public FastScanner(InputStream in) throws Exception {
            reader = new BufferedReader(new InputStreamReader(in));
            tokenizer = new StringTokenizer(reader.readLine().trim());
        }

        public int numTokens() throws Exception {
            if (!tokenizer.hasMoreTokens()) {
                tokenizer = new StringTokenizer(reader.readLine().trim());
                return numTokens();
            }
            return tokenizer.countTokens();
        }

        public boolean hasNext() throws Exception {
            if (!tokenizer.hasMoreTokens()) {
                tokenizer = new StringTokenizer(reader.readLine().trim());
                return hasNext();
            }
            return true;
        }

        public String next() throws Exception {
            if (!tokenizer.hasMoreTokens()) {
                tokenizer = new StringTokenizer(reader.readLine().trim());
                return next();
            }
            return tokenizer.nextToken();
        }

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

        public float nextFloat() throws Exception {
            return Float.parseFloat(next());
        }

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

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

        public String nextLine() throws Exception {
            return reader.readLine().trim();
        }
    }
}


import java.io.*;
import java.util.StringTokenizer;
import java.util.prefs.BackingStoreException;

/**
 * Author: Luis Manuel Díaz Barón
 * Problem:
 * Online Judge:
 * Idea:
 * Fecha: 20/02/2013
 */

public class Main {

    static MyScanner sc;
    static MyWriter pw;
    static String filePathWin="d:\\lmo.in";
    static String filePathLinux="/media/luismo/Trabajo/lmo.in";
    public static void main(String[] args) throws IOException {
        sc = new MyScanner(System.in);

        // sc = new MyScanner(new FileReader(filePathWin));
       // sc = new MyScanner(new FileReader(filePathLinux));

        pw = new MyWriter(System.out);

        while(sc.canRead())
            SolveSingleProblem();

        pw.close();
    }

    static boolean marks[] = new boolean[5];
    static int perm[] = new int[5];

    static long best = 0;

    static void backTrack(int idx){
        // base
        if(idx == 5){

            long k1 = G[perm[0]][perm[1]] + G[perm[1]][perm[0]] + G[perm[2]][perm[3]] + G[perm[3]][perm[2]];

            long k2 = G[perm[1]][perm[2]] + G[perm[2]][perm[1]] + G[perm[3]][perm[4]] + G[perm[4]][perm[3]];

            long k3 = G[perm[2]][perm[3]] + G[perm[3]][perm[2]];

            long k4 = G[perm[3]][perm[4]] + G[perm[4]][perm[3]];

            int val = k1 + k2 + k3 + k4;

            best = max(best,val);
            /*
            for(int i =0; i < perm.length; i++)
                pw.print(" "+ perm[i]);

            pw.println(" val: "+ val);
            */

            return;
        }

        for(int i = 0; i < 5; i++){

            if(!marks[i]){

                marks[i] = true;
                perm[idx] = i;

                backTrack(idx + 1);
                marks[i] = false;
            }
        }
    }

    static int G[][] = new int[5][5];
    public static void SolveSingleProblem() throws IOException{
        for(int i = 0; i < 5; i++){
            for(int j = 0; j < 5; j++){

                G[i][j] = sc.nextInt();
            }
        }

        backTrack(0);

        pw.println(best);

    }

    static int min(int a, int b){

        return (a<b)? a: b;
    }

    static int max(int a, int b){

        return (a>b)? a: b;
    }

}

// INPUT / OUTPUT
class MyScanner{
    BufferedReader br;
    StringTokenizer stk;
    public MyScanner(InputStream stream){
        this.br = new BufferedReader(new InputStreamReader(stream),72357);
        this.stk = new StringTokenizer("");
    }
    public MyScanner(FileReader fr){
        this.br = new BufferedReader(fr);
        this.stk = new StringTokenizer("");
    }
    public String next() throws IOException {
        while(!stk.hasMoreElements()){
            String line = br.readLine();
            if(line == null)
                return null;
            stk = new StringTokenizer(line);
        }
        return stk.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());
    }

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

class MyWriter{
    PrintWriter pw;
    public MyWriter(OutputStream out){
        this.pw = new PrintWriter(out);
    }
    public void print(Object obj){
        pw.print(obj.toString());
    }
    public void println(Object obj){
        pw.println(obj.toString());
    }
    public void close() {
        pw.close();
    }
}


import java.util.Scanner;

public class C {
    static int g[][] = new int[5][5];
    static int used[] = new int[5];
    static int maxi = 0;

    static void makeQueue(String str) {
        if (str.length() == 5) {
            //System.out.println(str);
            findMaxi(str);
        }
        for (int i = 0; i < 5; i++) {
            if (used[i] != 1) {
                used[i] = 1;

                makeQueue(str + i);
                used[i] = 0;
            }
        }
    }
    static void findMaxi(String str) {
        int sum = 0;
        for (int i = 1; i < 5; i++) {
            for (int j = i; j < 5; j+=2)
                sum = sum + g[str.charAt(i) - 48][str.charAt(i - 1) - 48] + g[str.charAt(i - 1) - 48][str.charAt(i) - 48];
        }
        if (maxi < sum) {
            maxi = Math.max(sum, maxi);
            //System.out.println(str);
        }
    }

    public static void main(String[] args) {
        int N;
        Scanner in = new Scanner(System.in);
        for (int i = 0; i < 5; i++)
            for (int j = 0; j < 5; j++) {
                g[i][j] = in.nextInt();
            }

        makeQueue("");
        System.out.print(maxi);

    }


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

public class Main {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        //BufferedReader br = new BufferedReader(new FileReader("data"));

        int[][] happy = new int[5][5];
        for (int r = 0; r < 5; r++) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            for (int c = 0; c < 5; c++) {
                happy[r][c] = Integer.parseInt(st.nextToken());
            }
        }

        int max = 0;

        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 5; j++) {
                if (i != j) {
                    for (int k = 0; k < 5; k++) {
                        if (k != i && k != j) {
                            for (int l = 0; l < 5; l++) {
                                if (l != i && l != j && l != k) {
                                    for (int m = 0; m < 5; m++) {
                                        if (m != i && m != j && m != k && m != l) {
                                            int happiness = happy[i][j] + happy[j][i] +
                                                    happy[j][k] + happy[k][j] +
                                                    2 * (happy[k][l] + happy[l][k]) +
                                                    2 * (happy[l][m] + happy[m][l]);

                                            if (happiness > max) max = happiness;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        System.out.println(max);
    }
}


import java.util.Arrays;
import java.util.Scanner;

/
public class Main {
    static int[][] matriz=new int[5][5];
    public static void main(String[] args) {
        Scanner entrada=new Scanner(System.in);
        Integer compas[]={0,1,2,3,4};
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 5; j++) {
                matriz[i][j]=entrada.nextInt();
            }
        }
        System.out.println(calcularMax(compas));
        //printPermutations(compas);
    }

    private static int calcularMax( Comparable[] c ) {
        //System.out.println( Arrays.toString( c ) );
                int acc=0;
                int max=0;
        while ( ( c = nextPermutation( c ) ) != null ) {
            //ystem.out.println( Arrays.toString( c ) );
                        int i=(Integer)c[0];
                        int j=(Integer)c[1];
                        acc+=matriz[i][j]+matriz[j][i];
                        i=(Integer)c[1];
                        j=(Integer)c[2];
                        acc+=matriz[i][j]+matriz[j][i];
                        i=(Integer)c[2];
                        j=(Integer)c[3];
                        acc+=(matriz[i][j]+matriz[j][i])*2;
                        i=(Integer)c[3];
                        j=(Integer)c[4];
                        acc+=(matriz[i][j]+matriz[j][i])*2;
                        if(max<acc)
                            max=acc;
                        acc=0;
        }
                return max;
    }

    // simply prints all permutation - to see how it works
    private static void printPermutations( Comparable[] c ) {
        //System.out.println( Arrays.toString( c ) );
        while ( ( c = nextPermutation( c ) ) != null ) {
            System.out.println( Arrays.toString( c ) );
        }
    }

    // modifies c to next permutation or returns null if such permutation does not exist
    private static Comparable[] nextPermutation( final Comparable[] c ) {
        // 1. finds the largest k, that c[k] < c[k+1]
        int first = getFirst( c );
        if ( first == -1 ) return null; // no greater permutation
        // 2. find last index toSwap, that c[k] < c[toSwap]
        int toSwap = c.length - 1;
        while ( c[ first ].compareTo( c[ toSwap ] ) >= 0 )
            --toSwap;
        // 3. swap elements with indexes first and last
        swap( c, first++, toSwap );
        // 4. reverse sequence from k+1 to n (inclusive)
        toSwap = c.length - 1;
        while ( first < toSwap )
            swap( c, first++, toSwap-- );
        return c;
    }

    // finds the largest k, that c[k] < c[k+1]
    // if no such k exists (there is not greater permutation), return -1
    private static int getFirst( final Comparable[] c ) {
        for ( int i = c.length - 2; i >= 0; --i )
            if ( c[ i ].compareTo( c[ i + 1 ] ) < 0 )
                return i;
        return -1;
    }

    // swaps two elements (with indexes i and j) in array
    private static void swap( final Comparable[] c, final int i, final int j ) {
        final Comparable tmp = c[ i ];
        c[ i ] = c[ j ];
        c[ j ] = tmp;
    }
}


 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
import java.util.Scanner;
import java.util.ArrayList;
import java.util.Collections;
import java.lang.Math;
/**
 *
 * @author SONY
 */
public class chess {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
    Scanner s = new Scanner(System.in);
    int r1,r2,c1,c2;
    int n1,n2,n3;
    r1=s.nextInt();
    c1=s.nextInt();
    r2=s.nextInt();
    c2=s.nextInt();
     if(c2<c1)
            n1=n2=n3=0;
     else
     {
    //for rook (goes horixontally and vertically any no. of steps )
    if(r1==r2||c1==c2)
    {

    if(r1==r2&&c1==c2)
        n1=0;

    else
        n1=1;
    }
    else
            n1=2;
      //for bishop (goes vertically any no. of steps
    int y =c2-c1;
    int x=r2-r1;
     int x1 ,x2,y1,y2;
    x1=r2-1;
    y1=c2-1;
    x2=r2+1;
    y2=c2-1;
    //diagonal qs
    if(x==y||x==((-1)*y))
    {
        n2=1;
    }

    else if((x2-r1)==(y2-c1)||(x2-r1)==(c1-y2))
        n2=2;
    else if((x1-r1)==(y1-c1)||(x1-r1)==(c1-y1))
        n2=2;
    else
        n2=0;

    // for king (1 move only any direction)
      if(x==y||x==((-1)*y)) //diagonal
      {
            n3=y;
      }
      else if ((r1==r2))
          n3=c2-c1;
        else if ((c1==c2))
          n3=r2-r1;
        else
        {
            if(r2<c2)
            {
                //a=r2;
                int b=c1+r2-r1;
                n3=r2-r1-1+c2-b;

            }
            else //a=c2;
            {
                int c=r1+r2-r1;
                n3=c2-c1+r2-c;
            }
        }
     }
     n1=Math.abs(n1);
     n2=Math.abs(n2);
     n3=Math.abs(n3);
    System.out.println(n1+" "+n2+" "+n3);
    }
}


import java.awt.Point;
import java.io.*;
import java.lang.reflect.Array;
import java.math.BigInteger;
import java.util.*;

import static java.lang.Math.*;

public class Solution implements Runnable {

        BufferedReader in;
        PrintWriter out;
        StringTokenizer tok = new StringTokenizer("");

        public static void main(String[] args) {
                new Thread(null, new Solution(), "", 256 * (1L << 20)).start();
        }

        public void run() {
                try {
                        long t1 = System.currentTimeMillis();
                        if (System.getProperty("ONLINE_JUDGE") != null) {
                                in = new BufferedReader(new InputStreamReader(System.in));
                                out = new PrintWriter(System.out);
                        } else {
                                in = new BufferedReader(new FileReader("input.txt"));
                                //out = new PrintWriter("output.txt");
                                out = new PrintWriter(System.out);
                        }
                        Locale.setDefault(Locale.US);
                        solve();
                        in.close();
                        out.close();
                        long t2 = System.currentTimeMillis();
                        System.err.println("Time = " + (t2 - t1));
                } catch (Throwable t) {
                        t.printStackTrace(System.err);
                        System.exit(-1);
                }
        }

        String readString() throws IOException {
                while (!tok.hasMoreTokens()) {
                        tok = new StringTokenizer(in.readLine());
                }
                return tok.nextToken();
        }

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

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

        double readDouble() throws IOException {
                return Double.parseDouble(readString());
        }

        // solution

        void solve() throws IOException {
        	int r1 = readInt(), c1=readInt() , r2 = readInt(), c2 = readInt();

        	if(r1 == r2 && c1 == c2){
        		out.println("0 0 0");
        		return;
        	}

        	//ладья
        	if(r1 == r2 || c1==c2) out.print(1);
        	else out.print(2);
        	out.print(" ");

        	//слон
        	if((r1 + c1)%2 != (r2 + c2)%2)
        		out.print(0);
        	else{
        		if(r1 - c1 == r2 - c2 || r1 + c1 == r2 + c2)
        			out.print(1);
        		else
        			out.print(2);
        	}
        	out.print(" ");

        	//король
        	int dc = Math.abs(c1 - c2), dr = Math.abs(r1 - r2);
        	out.println(Math.max(dc, dr));
        }
    }


import java.util.*;
import java.lang.*;
import java.io.*;
public class RBK
{
	public static void main(String[] args)
	{

   Scanner scan = new Scanner(System.in);
   int x1 = scan.nextInt();
   int y1 = scan.nextInt();
   int x2 = scan.nextInt();
   int y2 = scan.nextInt();
   Chess Moves = new Chess();
   Moves.rook(x1,y1,x2,y2);
   Moves.bishop(x1,y1,x2,y2);
   Moves.king(x1,y1,x2,y2);

	}
}

public class Chess
{
	void rook (int x1,int y1,int x2,int y2)
	{
		if(x1==x2 || y1==y2)
		{
			System.out.println("1");
		}
		else
			System.out.println("2");
	}

	void bishop (int x1,int y1,int x2,int y2)
	{
       int a,b;
       a=x1-x2;
       b=y1-y2;
       if(a<0)	a=-a;
       if(b<0)	b=-b;
       if((a%2)==(b%2))
       {
       	if(a==b)
       		System.out.println("1");
       	else
       		System.out.println("2");
       }
       else
       	System.out.println("0");
	}

	void king (int x1,int y1,int x2,int y2)
	{
		int a,b;
       a=x1-x2;
       b=y1-y2;
       if(a<0)	a=-a;
       if(b<0)	b=-b;
       if(a==b)
       {
         System.out.println(a);
       }
       else
       {
       	 if (a>b)
         	System.out.println(a);
         else
         	System.out.println(b);
       }

	}

}


package practice;

import util.FastReader;
import java.io.PrintWriter;

public class RookBishopKing {
    public void solve(int testNumber, FastReader in, PrintWriter out) {
        int r1 = in.nextInt();
        int c1 = in.nextInt();
        int r2 = in.nextInt();
        int c2 = in.nextInt();

        // rook
        if (r1 == r2 || c1 == c2) {
            out.print("1 ");
        } else {
            out.print("2 ");
        }

        // bishop
        if ((r1 + r2) % 2 != (c1 + c2) % 2) {
            out.print("0 ");
        } else {
            if (Math.abs(r1 - r2) == Math.abs(c1 - c2)) {
                out.print("1 ");
            } else {
                out.print("2 ");
            }
        }

        // king
        out.print(Math.max(Math.abs(r1-r2), Math.abs(c1-c2)));
    }
}


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


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.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[100001];
		invfac=new long[100001];
		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;
	}
}


//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[100001];
    long mod = 998244353;
    fact[0] = 1;
    fact[1] = 1;
    for(int i=2;i<=100000;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;

        }

    }
}


public class CG {
    public static void main(String args[]){
Scanner s=new Scanner(System.in);

                        int w=s.nextInt();
                        int h=s.nextInt();
                        int u1=s.nextInt();
                        int d1=s.nextInt();
                        int u2=s.nextInt();
                        int d2=s.nextInt();

                        int finalweight=w;

                        if(d1!=d2&&d1>=1&&d2>=1)
                        {

                           while(h!=0){
                            //System.out.println(h);
                       finalweight=finalweight+h;
                              //System.out.println(finalweight);
                            if(d1==h)
                            {
                                finalweight-=u1;
                            }
                            if(d2==h)
                            {
                                finalweight-=u2;

                                    }
                                    h=h-1;
                           }

                        }
                        if(finalweight<0)
                            finalweight=0;
                        System.out.println(finalweight);

    }
}


import java.util.Scanner;
public class Code1
{
	public static void main(String args[])
	{
Scanner sc=new Scanner(System.in);
int w=sc.nextInt();
int h=sc.nextInt();

int w1=sc.nextInt();
int h1=sc.nextInt();
int w2=sc.nextInt();
int h2=sc.nextInt();
while(h=>0)
{
w=w+h;
if(w<0)
w=0;
h=h-1;

}
w=w-w1-w2;
System.out.println(w);

	}
}


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

	public static void main(String[] args) throws IOException {
		BufferedReader reader= new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st= new StringTokenizer(reader.readLine());
		int peso = Integer.parseInt(st.nextToken());
		int altura = Integer.parseInt(st.nextToken());
		st= new StringTokenizer(reader.readLine());
		int roca1=Integer.parseInt(st.nextToken());
		int lugar1= Integer.parseInt(st.nextToken());
		st= new StringTokenizer(reader.readLine());
		int roca2= Integer.parseInt(st.nextToken());
		int lugar2= Integer.parseInt(st.nextToken());
		for(;altura>=0;altura--) {
			peso+=altura;
			if(altura==lugar1) {
				peso-=roca1;
			}
			else if(altura==lugar2) {
				peso-=roca2;
			}
		}
		System.out.println(peso);


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

public class Snowball{

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

        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        String[] snowball = bufferedReader.readLine().split(" ");
        int w = Integer.parseInt(snowball[0]);
        int h = Integer.parseInt(snowball[1]);
        String[] rock1 = bufferedReader.readLine().split(" ");
        int u1 = Integer.parseInt(rock1[0]);
        int d1 = Integer.parseInt(rock1[1]);
        String[] rock2 = bufferedReader.readLine().split(" ");
        int u2 = Integer.parseInt(rock2[0]);
        int w2 = Integer.parseInt(rock2[1]);
        for(int i = 1; i <= h; i++){
            w+=i;
            if(i == d1){
                w-=u1;
                if(w < 0){
                    w = 0;
                }
            }
            else if(i == d2){
                w-=u2;
                if(w < 0){
                    w = 0;
                }
            }
        }
        if(w < 0){
            w = 0;
        }
        System.out.println(w);
    }
}


import java.util.*;
import java.util.Arrays;
public class Icpc {

	public static void main(String[] args) {
		Scanner in=new Scanner(System.in);
		int a[]=new int[6],i,sum=0;
	    Arraysrrays.sort(a);
	    for(i=0;i<6;i++){a[i]=in.nextInt();sum+=a[i]}
		if(sum%2==0(a[0]+a[3]+a[4])==(a[1]+a[2]+a[5]))
			System.out.print("yes");
		else System.out.print("no");
	}

}


public class ACMICPC {

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

		Scanner in= new Scanner(System.in);

		int a[]=new int[6];
		int sum=0;
		for(int i=0;i<6;i++) {
			a[i]=in.nextInt();
			sum+=a[i];
		}

		if(res(a,sum)==true) {
			System.out.println("yes");
		}
		else {
			System.out.println("NO");
		}

	}

	static boolean res(int a[], int sum) {
		boolean f= false;
		for(int i=0;i<4;i++) {
			for(int j=i+1;j<5;j++) {
				for(int k=j+1;k<6;k++) {
					if(a[i]+a[j]+a[k]==sum/2) {
						return true;
					}
				}
			}
		}

		return false;
	}

}