#include <bits/stdc++.h>
using namespace std;

#define F first
#define S second 
#define sz(x) (int)x.size()
#define all(x) x.begin(), x.end()
#define make_unique(x) sort(all(x)), x.erase(unique(all(x)), x.end())

mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
mt19937_64 Rng(chrono::steady_clock::now().time_since_epoch().count());

typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;

const int N = 3e3 + 200;
const int M = 1e6;
const int inf = 2e9 + 3;
const ll INF = 1e18;

template<int mod>
class Modular {
public:
    int val;
    Modular() : val(0) {}
    Modular(int new_val) : val(new_val) {}
    // Modular(long long new_val) : val(new_val % mod) {}  // AFFECTS OPERATOR* (because it has one more %)
    friend Modular operator+(const Modular& a, const Modular& b) {
        if (a.val + b.val >= mod) return a.val + b.val - mod;
        else return a.val + b.val;
    }
    friend Modular operator-(const Modular& a, const Modular& b) {
        if (a.val - b.val < 0) return a.val - b.val + mod;
        else return a.val - b.val;
    }
    friend Modular operator*(const Modular& a, const Modular& b) {
        return 1ll * a.val * b.val % mod;
    }
    friend Modular binpow(Modular a, long long n) {
        Modular res = 1;
        for (; n; n >>= 1) {
            if (n & 1) res *= a;
            a *= a;
        }
        return res;
    }
    /*
    friend Modular inv(const Modular& a) {
        Modular x, y;
        gcd(a.val, mod, x, y);
        return x;
    }
    */
    friend Modular inv(const Modular& a) {
        return binpow(a, mod - 2);
    }
    friend Modular operator^(const Modular& a, const long long& b) {
        if (b >= 0)
            return binpow(a, b % (mod - 1));
        return binpow(inv(a), (-b) % (mod - 1));
    }
    /* ALTERNATIVE INVERSE FUNCTION USING EXTENDED EUCLIDEAN ALGORITHM
    friend void gcd(int a, int b, Modular& x, Modular& y) {
        if (a == 0) {
            x = Modular(0);
            y = Modular(1);
            return;
        }
        Modular x1, y1;
        gcd(b % a, a, x1, y1);
        x = y1 - (b / a) * x1;
        y = x1;
    }
    */
    Modular operator/(const Modular& ot) const {
        return *this * inv(ot);
    }
    Modular& operator++() {
        if (val + 1 == mod) val = 0;
        else ++val;
        return *this;
    }
    Modular operator++(int) {
        Modular tmp = *this;
        ++(*this);
        return tmp;
    }
    Modular operator+() const {
        return *this;
    }
    Modular operator-() const {
        return 0 - *this;
    }
    Modular& operator+=(const Modular& ot) {
        return *this = *this + ot;
    }
    Modular& operator-=(const Modular& ot) {
        return *this = *this - ot;
    }
    Modular& operator*=(const Modular& ot) {
        return *this = *this * ot;
    }
    Modular& operator/=(const Modular& ot) {
        return *this = *this / ot;
    }
    bool operator==(const Modular& ot) const {
        return val == ot.val;
    }
    bool operator!=(const Modular& ot) const {
        return val != ot.val;
    }
    bool operator<(const Modular& ot) const {
        return val < ot.val;
    }
    bool operator>(const Modular& ot) const {
        return val > ot.val;
    }
    explicit operator int() const {
        return val;
    }
};
 
template<int mod>
istream& operator>>(istream& istr, Modular<mod>& x) {
    return istr >> x.val;
}
 
template<int mod>
ostream& operator<<(ostream& ostr, const Modular<mod>& x) {
    return ostr << x.val;
}
 
const int mod = 1e9 + 7;
using Mint = Modular<mod>;

int a, b;
Mint g[N][N], P[N][N], G[N][N];

int main() {
    cin.tie(0)->sync_with_stdio(0);
    g[0][0] = 1;
    P[0][0] = 1;
    G[0][0] = 1;
    cin >> a >> b;
    for (int n = 1; n <= a; ++n) {
        Mint ii2 = Mint(1)/2;
        Mint iin = Mint(1)/n;
        for (int m = 1; m <= b; ++m) {
            if (n >= 2) g[n][m] += P[n-2][m-1] + G[n-2][m-1];
            if (m >= 2) g[n][m] += P[n-1][m-2];
            if (n >= 2 && m >= 2) g[n][m] += G[n-2][m-2];
            g[n][m] *= ii2;
            g[n][m] += P[n-1][m-1];
            g[n][m] *= iin;
            G[n][m] = G[n-1][m-1] + g[n][m];
            P[n][m] = P[n-1][m-1] + G[n][m];
        }
    }
    Mint ans = g[a][b];
    for (int i = 1; i <= a; ++i) ans = ans * i;
    for (int i = 1; i <= b; ++i) ans = ans * i;
    cout << ans << '\n';
}