Problem: Mashmokh's boss, Bimokh, didn't like Mashmokh. So he fired him. Mashmokh decided to go to university and participate in ACM instead of finding a new job. He wants to become a member of Bamokh's team. In order to join he was given some programming tasks and one week to solve them. Mashmokh is not a very experienced programmer. Actually he is not a programmer at all. So he wasn't able to solve them. That's why he asked you to help him with these tasks. One of these tasks is the following.

A sequence of l integers b1, b2, ..., bl (1 ≤ b1 ≤ b2 ≤ ... ≤ bl ≤ n) is called good if each number divides (without a remainder) by the next number in the sequence. More formally <image> for all i (1 ≤ i ≤ l - 1).

Given n and k find the number of good sequences of length k. As the answer can be rather large print it modulo 1000000007 (109 + 7).

Input

The first line of input contains two space-separated integers n, k (1 ≤ n, k ≤ 2000).

Output

Output a single integer — the number of good sequences of length k modulo 1000000007 (109 + 7).

Examples

Input

3 2


Output

5


Input

6 4


Output

39


Input

2 1


Output

2

Note

In the first sample the good sequences are: [1, 1], [2, 2], [3, 3], [1, 2], [1, 3].

Solution (in JAVA):

Solution:


     
        import java.io.*;
     
        import java.math.BigInteger;
    import java.text.DecimalFormat;
    import java.util.*;
     
    //import Submatrix.InputReader;
         
         
         
         public class Main {
        	public static InputReader in;
            public static PrintWriter pw;
         
         
         
        	public static void main(String args[]) {
        		new Thread(null, new Runnable() {
                    public void run() {
                        try{
                            solve();
                        }
                        catch(Exception e){
                            e.printStackTrace();
                        }
                    }
                }, "1", 1 << 26).start();
            }
        	static ArrayList<Integer> g[];
        	static ArrayList<Integer> h[];
        	static boolean visited[];
        	static boolean visit[];
        	static int par[];
        	static int degree[];
        	static int edjes=0;
        	static int start=-1;
        	static int end=-1;
        	static int Total=0;
        	static int time1[];
        	static int time2[];
        	static int glob=0;
        	static long ans[]=new long[1000000];
        	static boolean vis2[][];
        	//static long sum1=0;
        	//static long val[];
            static ArrayList<Integer> levels[];
            static int max=0;
            static int lev=1;
            static ArrayList<Integer> nodes[];
            static ArrayList<Integer> values[];
            static int depth[];
            static boolean found=false;
           // static long sm[];
            static int sum1=0;
            static int pre[][];
            static int subtree[];
           static  int cnt=0;
           static  HashMap<String,Integer> hm;
           static int sm[];
           static int prime[];
           static long mul[];
           static long d[]=new long[1000000];
           static int tot=0;
           static long highest=(long)1e9;
           static int count=0;
            static Stack<Integer> tt=new Stack();
            static long Cardinality[];
            static int k;
            public static void solve(){
        		
        	
        		 in = new InputReader(System.in);
        		 pw = new PrintWriter(System.out);
            int n=in.nextInt();
            int k=in.nextInt();
            long dp[][]=new long[k+1][n+1];
            for(int i=1;i<=n;i++)
            	dp[1][i]=(long)1;
            
            for(int i=2;i<=k;i++)
            {
            	for(int j=1;j<=n;j++)
            	{
                 for(int p=j;p<=n;p+=j)
                 {
                	 dp[i][j]=(dp[i-1][p]+dp[i][j])%1000000007;
                 }
            	}
            }
            long ans=0;
            for(int i=1;i<=n;i++)
            {
            	ans+=(dp[k][i]);
            	ans%=1000000007;
            }
            System.out.println(ans);
            }
            public static void rot(int a[])
            {
            	int n = a.length;
        		int temp =a[0];
        		for(int i=1;i<n;i++)
        			a[i-1] = a[i];
        		a[n-1] = temp;
            }
            private static Comparator MyComp() {
				
				return null;
			}
			public static long gcd(long a, long b) {
      		  if (b == 0) return a;
    		  return gcd(b, a%b);
    		}


             static class Pair implements Comparable<Pair>{
            	int now;
            		int aft;
            		//int index;
            		Pair(int ver,int weight){
            	     	this.now=ver;
            			this.aft=weight;
            			//this.index=index;
            			
            		}
            		@Override
            		public int compareTo(Pair o) {
                            
            				return (int)(o.now-now);
            		}
            				
            	}
        	static class InputReader {
         
        		private InputStream stream;
        		private byte[] buf = new byte[8192];
        		private int curChar, snumChars;
        		private SpaceCharFilter filter;
         
        		public InputReader(InputStream stream) {
        			this.stream = stream;
        		}
         
        		public int snext() {
        			if (snumChars == -1)
        				throw new InputMismatchException();
        			if (curChar >= snumChars) {
        				curChar = 0;
        				try {
        					snumChars = stream.read(buf);
        				} catch (IOException e) {
        					throw new InputMismatchException();
        				}
        				if (snumChars <= 0)
        					return -1;
        			}
        			return buf[curChar++];
        		}
         
        		public   int nextInt() {
        			int c = snext();
        			while (isSpaceChar(c))
        				c = snext();
        			int sgn = 1;
        			if (c == '-') {
        				sgn = -1;
        				c = snext();
        			}
        			int res = 0;
        			do {
        				if (c < '0' || c > '9')
        					throw new InputMismatchException();
        				res *= 10;
        				res += c - '0';
        				c = snext();
        			} while (!isSpaceChar(c));
        			return res * sgn;
        		}
         
        		public long nextLong() {
        			int c = snext();
        			while (isSpaceChar(c))
        				c = snext();
        			int sgn = 1;
        			if (c == '-') {
        				sgn = -1;
        				c = snext();
        			}
        			long res = 0;
        			do {
        				if (c < '0' || c > '9')
        					throw new InputMismatchException();
        				res *= 10;
        				res += c - '0';
        				c = snext();
        			} while (!isSpaceChar(c));
        			return res * sgn;
        		}
         
        		public int[] nextIntArray(int n) {
        			int a[] = new int[n];
        			for (int i = 0; i < n; i++)
        				a[i] = nextInt();
        			return a;
        		}
         
        		public String readString() {
        			int c = snext();
        			while (isSpaceChar(c))
        				c = snext();
        			StringBuilder res = new StringBuilder();
        			do {
        				res.appendCodePoint(c);
        				c = snext();
        			} while (!isSpaceChar(c));
        			return res.toString();
        		}
         
        		public boolean isSpaceChar(int c) {
        			if (filter != null)
        				return filter.isSpaceChar(c);
        			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        		}
         
        		public interface SpaceCharFilter {
        			public boolean isSpaceChar(int ch);
        		}
        	}
        }