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

public class c {
  static boolean debug = false;
  static int MOD = 1_000_000_007;
  public static void main(String[] args) {
    Scanner in = new Scanner(System.in);

    int n = in.nextInt(); 
    int len = in.nextInt();

    
    long[][] memo = new long[len][n+1]; // [curLen][gapRem]
    for(int l=0; l<len; l++) Arrays.fill(memo[l], 0);
    for(int gap=n-1; gap>=0; gap--) {
      int numWays = n-gap;
      memo[0][gap] = numWays;
    }
    // Arrays.fill(memo[0], 1);
    for(int curLen=1; curLen<len; curLen++) {
      for(int gap=0; gap<n; gap++) {
        // build upon previous.
        for(int prev=n; prev>=gap; prev--) {
          int numWays = prev - gap +1;
          memo[curLen][gap] += memo[curLen-1][prev]*numWays;
          memo[curLen][gap] %= MOD;
        }
      }
    }

    if(debug) {
      for(int l=0; l<len; l++) {
        for(int gap=0; gap<n; gap++) {
          System.out.printf("%2d ", memo[l][gap]);
        }
        System.out.println();
      }
    }

    long sum = 0;
    for(int gap=0; gap<=n; gap++) {
      sum += memo[len-1][gap];
      sum %= MOD;
    }
    System.out.println(sum);


  }
}

/* 

2 2

5


10 1

55


723 9

157557417


1000 10




Looks like
^-_
_-^

They approach eachother
Almost like a dp
Digit descent
But with numbers
But 1000^10 is gross

11111 = a makes every b legal
11112 = makes every b legal except ending in 1

Alternate prob:
Choose an array of numbers, each number 1 to n
If the cumulative sum of both is > n, then its impossible.
So you basically store the differences rather than the numbers themselves.

Then it's a simpler dp i feel
Just how much of a gap is left
1000*10... wait. yeah.
The gap always shrinks.

Every number goes to up or lower

*/