You are given two integers n and m. Calculate the number of pairs of arrays (a, b) such that:

  * the length of both arrays is equal to m; 
  * each element of each array is an integer between 1 and n (inclusive); 
  * a_i ≤ b_i for any index i from 1 to m; 
  * array a is sorted in non-descending order; 
  * array b is sorted in non-ascending order. 



As the result can be very large, you should print it modulo 10^9+7.

Input

The only line contains two integers n and m (1 ≤ n ≤ 1000, 1 ≤ m ≤ 10).

Output

Print one integer – the number of arrays a and b satisfying the conditions described above modulo 10^9+7.

Examples

Input


2 2


Output


5


Input


10 1


Output


55


Input


723 9


Output


157557417

Note

In the first test there are 5 suitable arrays: 

  * a = [1, 1], b = [2, 2]; 
  * a = [1, 2], b = [2, 2]; 
  * a = [2, 2], b = [2, 2]; 
  * a = [1, 1], b = [2, 1]; 
  * a = [1, 1], b = [1, 1]. 

import java.io.OutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.*;
import java.io.BufferedReader;
import java.io.InputStreamReader;
//import java.math.*;
 
/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
 
public class Main {
	
	static int MD= 1000000007 ;
	static int N=100005;
    public static void main(String[] args) throws IOException {
    	OutputStream outputStream = System.out;
        InputReader in = new InputReader();
        PrintWriter out = new PrintWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }
   

	static class TaskC {
    	 
	    public void solve(int testNumber, InputReader in, PrintWriter out) throws IOException {
	    	int[][] dp=new int[1000+26][20+1];
    		
    		for(int i=0;i<=1025;i++) {
    			dp[i][0]=1;
    		}
    		for(int i=1;i<=1025;i++) {
    			for(int j=1;j<=20;j++) {
    				if(i<j) {
    					dp[i][j]=0;
    				}
    				else {
    					dp[i][j]=(dp[i-1][j]+dp[i-1][j-1])%MD;
    				}
    			}
    			
    		}
	    	int t=1;
	    	while(t-->0) {
	    		int n=in.nextInt();
	    		int m=in.nextInt();
	    		
	    		out.println(dp[2*m+n-1][2*m]);
	    	}
	    }
	    	
	}

	   static int sumDigit(int n) {
		   int sum=0;
		   while(n>0) {
			   sum+=n%10;
			   n/=10;
		   }
		   return sum;
	   }
	
	   static boolean isPrime(int n) 
	   { 
	       if (n <= 1) 
	           return false; 
	     
	       for (int i = 2; i*i < n; i++) 
	           if (n % i == 0) 
	               return false; 
	     
	       return true; 
	   } 
    static long modexp(long x, long n) 
    { 
        if (n == 0) { 
            return 1; 
        } 
        else if (n % 2 == 0) { 
            return modexp((x * x) % MD, n / 2); 
        } 
        else { 
            return (x * modexp((x * x) % MD, (n - 1) / 2) % MD); 
        } 
    } 
      
     static long getInv(long b) 
    { 
      
        long  d = modexp(b, MD - 2); 
      
        long ans =  (d % MD) ;
      
        return ans; 
    } 
    
    static class InputReader
    {
        BufferedReader br;
        StringTokenizer st;
 
        public InputReader()
        {
            br = new BufferedReader(new
                     InputStreamReader(System.in));
        }
 
        String next()
        {
            while (st == null || !st.hasMoreElements())
            {
                try
                {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException  e)
                {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }
   
        int nextInt()
        {
            return Integer.parseInt(next());
        }
 
        long nextLong()
        {
            return Long.parseLong(next());
        }
 
        double nextDouble()
        {
            return Double.parseDouble(next());
        }
 
        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
    
    }
    static void sort(int[] a, int low, int high) 
    {
        int N = high - low;         
        if (N <= 1) 
            return; 
        int mid = low + N/2; 
        sort(a, low, mid); 
        sort(a, mid, high); 
        int[] temp = new int[N];
        int i = low, j = mid;
        for (int k = 0; k < N; k++) 
        {
            if (i == mid)  
                temp[k] = a[j++];
            else if (j == high) 
                temp[k] = a[i++];
            else if (a[j]<a[i]) 
                temp[k] = a[j++];
            else 
                temp[k] = a[i++];
        }    
        for (int k = 0; k < N; k++) 
            a[low + k] = temp[k];         
    }
    static void lsort(long[] a, int low, int high) 
    {
        int N = high - low;         
        if (N <= 1) 
            return; 
        int mid = low + N/2; 
        lsort(a, low, mid); 
        lsort(a, mid, high); 
        long[] temp = new long[N];
        int i = low, j = mid;
        for (int k = 0; k < N; k++) 
        {
            if (i == mid)  
                temp[k] = a[j++];
            else if (j == high) 
                temp[k] = a[i++];
            else if (a[j]<a[i]) 
                temp[k] = a[j++];
            else 
                temp[k] = a[i++];
        }    
        for (int k = 0; k < N; k++) 
            a[low + k] = temp[k];         
    }
    public static long fexp(long x, long y, long p) {
        long res = 1;      
        
       
        x = x % p;  
      
        while (y > 0) 
        { 
         
            if((y & 1)==1) 
                res = (res * x) % p; 
      
          
            y = y >> 1;  
            x = (x * x) % p;  
        } 
        return res; 
        
    }
    static int gcd(int a, int b) 
    { 
        if (b == 0) 
            return a; 
        return gcd(b, a % b);  
          
    }
    static long lgcd(long a, long b) 
    { 
        if (b == 0) 
            return a; 
        return lgcd(b, a % b);  
          
    }
   
	
	
}
 
