Problem: A + B balls are arranged in a row. The leftmost A balls are colored red, and the rightmost B balls are colored blue.

You perform the following operation:

* First, you choose two integers s, t such that 1 \leq s, t \leq A + B.
* Then, you repeat the following step A + B times: In each step, you remove the first ball or the s-th ball (if it exists) or the t-th ball (if it exists, all indices are 1-based) from left in the row, and give it to Snuke.



In how many ways can you give the balls to Snuke? Compute the answer modulo 10^9 + 7.

Here, we consider two ways to be different if for some k, the k-th ball given to Snuke has different colors. In particular, the choice of s, t doesn't matter. Also, we don't distinguish two balls of the same color.

Constraints

* 1 \leq A, B \leq 2000

Input

Input is given from Standard Input in the following format:


A B


Output

Print the answer.

Examples

Input

3 3


Output

20


Input

4 4


Output

67


Input

7 9


Output

7772


Input

1987 1789


Output

456315553

Solution (in CPP):

Solution:
#include <bits/stdc++.h>

#define HEAP priority_queue
#define rep(i, n) for(int i = 0, _end_ = (n); i < _end_; ++i)
#define per(i, n) for(int i = (n) - 1; i >= 0 ; --i)
#define forn(i, l, r) for(int i = (l), _end_ = (r); i <= _end_; ++i)
#define nrof(i, r, l) for(int i = (r), _end_ = (l); i >= _end_; --i)
#define FOR(a, b) for(auto (a): (b))
#define mp make_pair
#define mt make_tuple
#define pb push_back
#define X first
#define Y second
#define eps 1e-6
#define pi 3.1415926535897932384626433832795
#define SZ(x) (int)x.size()
#define ALL(x) x.begin(), x.end()

using namespace std;

typedef long long LL;
typedef double flt;
typedef vector<int> vi;
typedef vector<LL> vl;
typedef pair<int,int> pii;
typedef pair<int,LL> pil;
typedef pair<LL,int> pli;
typedef pair<LL,LL> pll;
typedef vector<pil> vil;
typedef vector<pii> vii;
typedef vector<pli> vli;
typedef vector<pll> vll;

const int iinf = 1e9 + 7;
const int oo = 0x3f3f3f3f;
const LL linf = 1ll << 60;
const flt dinf = 1e60;

template <typename T> inline void scf(T &x)
{
    bool f = 0;
    x = 0;
    char c = getchar();
    while(c != '-' && (c < '0' || c > '9')) c = getchar();
    if(c == '-') f = 1, c = getchar();
    while(c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
    if(f) x = -x;
    return;
}

template <typename T1, typename T2> void scf(T1 &x, T2 &y)
{
    scf(x);
    return scf(y);
}

template <typename T1, typename T2, typename T3> void scf(T1 &x, T2 &y, T3 &z)
{
    scf(x);
    scf(y);
    return scf(z);
}

template <typename T1, typename T2, typename T3, typename T4> void scf(T1 &x, T2 &y, T3 &z, T4 &w)
{
    scf(x);
    scf(y);
    scf(z);
    return scf(w);
}

inline char mygetchar()
{
    char c = getchar();
    while(c == ' ' || c == '\n') c = getchar();
    return c;
}

template <typename T> inline bool chkmax(T &x, const T &y)
{
    return y > x ? x = y, 1 : 0;
}

template <typename T> inline bool chkmin(T &x, const T &y)
{
    return y < x ? x = y, 1 : 0;
}

#ifdef DEBUG
#define debug(...) fprintf(stderr, __VA_ARGS__)
#else
#define debug(...)
#endif

//---------------------------------------------------------head----------------------------------------------------

const int maxn = 2020;

const int mod = 1e9 + 7;

int c[maxn][maxn], f[maxn][maxn], g[maxn][maxn], s[maxn << 1][maxn];

void pre() {
    c[0][0] = 1;
    for (int i = 1; i < maxn; ++i) {
        c[i][0] = 1;
        for (int j = 1; j <= i; ++j) {
            c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % mod;
        }
    }
    for (int i = 0; i < maxn; ++i) {
        f[0][i] = f[i][0] = 1;
    }
    g[maxn - 1][0] = 1;
    s[maxn + maxn - 1][maxn - 1] = 1;
    for (int K = maxn - 2; K >= -(maxn - 1); --K) {
        for (int i = 0; i < maxn; ++i) {
            int j = i - K;
            if(j >= 0 && j < maxn) {
                s[maxn + K][i] = g[i][j] = (j ? s[maxn + K + 1][i] : 1);
            }
        }
        for (int i = 1; i < maxn; ++i) {
            (s[maxn + K][i] += s[maxn + K][i - 1]) %= mod;
        }
    }
    for (int i = 1; i < maxn; ++i) {
        for (int j = 1; j < maxn; ++j) {
            f[i][j] = (f[i - 1][j] + g[i][j]) % mod;
        }
    }
    return;
}

int calc(int x, int y, int n, int m) {
    return c[n + m - x - y][n - x];
}

int main()
{
    pre();
    int n, m, ans = 1;
    scf(n, m);
    for (int i = 0; i < n; ++i) {
        int s = n - i + 1, R = n - i, B = m;
        for (int x = 0; x <= R; ++x) {
            int y = R - x;
            if(y >= 0 && y < B) {
                int K = calc(x, y, R, B - 1);
                //printf("%d\n", K);
                if(!x || !y) {
                    //printf("%d %d %d %d\n", s, x, y, K);
                    (ans += K) %= mod;
                }
                else {
                    //printf("%d %d %d %d\n", s, x, y, K * f[x][y]);
                    ans = (1ll * K * f[x][y] + ans) % mod;
                }
            }
        }
    }
    printf("%d\n", ans); 
    return 0;
}