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.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PipedReader;
import java.util.HashMap;
import java.util.HashSet;

/**
 * @author Himanshu Bhardwaj
 * Date 06/Feb/2020
 * Statement: https://codeforces.com/contest/1288/problem/C
 */
public class TwoArrays {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String[] str = br.readLine().split(" ");

        int n = Integer.parseInt(str[0]);
        int m = Integer.parseInt(str[1]);

        TwoArraysI twoArraysI = new TwoArraysSol1();
        System.out.print(twoArraysI.solve(n, m));
    }
}


class TwoArraysSol1 implements TwoArraysI {
    static HashMap<String, Long> dp = new HashMap<>();
    static int prime = 1000000000 + 7;

    @Override
    public long solve(int n, int m) {
        long count = 0;
        int k = Math.min(2 * m, n);
        long choose = 1;//choose(n, k);
        long arrangement = numWays(0, n, 2 * m, new int[n]);
        count = (choose * arrangement) % prime;
        return count;
    }


    //number of solution of Xi+Xi+i+..Xm-1 = n ; Xi>=0
    static long numWays(int index, int m, int n, int[] arr) {
        long count = 0;


        if (n == 0 || index == (m - 1)) {
            if (index == (m - 1)) {
                arr[index] = n;
            }
//            for (int x : arr) {
//                System.out.print(x + ",");
//            }
//            System.out.println();
            return 1;
        }

        if (n < 0 || index >= m) {
            return 0;
        }


        String key = index(arr, index, m, n);
        if (dp.containsKey(key)) {
            return dp.get(key);
        }


        for (int i = 0; i <= n; i++) {
            arr[index] = i;
            count += numWays(index + 1, m, n - i, arr);
//            for (int j = index + 1; j < arr.length; j++) {
//                arr[j] = 0;
//            }
        }

        dp.put(key, count % prime);
        return count % prime;
    }

    static String index(int[] arr, int index, int m, int n) {
        StringBuilder sb = new StringBuilder();
//        for (int x : arr) {
//            sb.append(x + ",");
//        }
        sb.append((m - index) + ",");
        sb.append(n);
        return sb.toString();
    }
}

interface TwoArraysI {
    long solve(int n, int m);
}