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]. 
/**
 * #dp
 
 Solution.
 a0 <= a1 <= ... <= am  <= bm <= b(m-1) <= ... <= b0
                    <=
 b0 >= b1 >= .. >= bm
 
 * Method basic:
 dp[i][x][y] -- so cach tao duoc 2 day a, b do dai i
                phan tu cuoi cua a la x va cua b la y
                
                
   m * n * n -> n^2 * m ~= 10^7
   
   dp[i+1]  <=> dp[i]
 */
import java.util.Scanner;
public class TwoArrays {
    private static long MOD = 1000000007L;
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        long[][] L = new long[2 * m][n+1];
        for (int i = 0; i < 2 * m; i++) {
            long sumTmp = 0;
            for (int j = 1; j <= n; j++) {
                if (i == 0 || j == 1) {
                    L[i][j] = 1;
                    sumTmp = 1;
                    continue;
                }
                /*
                L[i][j] = sum(L[i-1][k]), k = 1 .. j
                L[i][j+1] = sum(L[i-1][k]), k = 1 .. j+1
                */
                L[i][j] = (L[i - 1][j] + sumTmp) % MOD;
                sumTmp = L[i][j];
            }
        }
        long result = 0;
        for (int j = 1; j <= n; j++) {
            result = (result + L[2 * m - 1][j]) % MOD;
        }
        System.out.println(result);
    }
}