// #define _GLIBCXX_DEBUG // for STL debug (optional)
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <string>
#include <cstring>
#include <deque>
#include <list>
#include <queue>
#include <stack>
#include <vector>
#include <utility>
#include <algorithm>
#include <map>
#include <set>
#include <complex>
#include <cmath>
#include <limits>
#include <cfloat>
#include <climits>
#include <ctime>
#include <cassert>
#include <numeric>
#include <fstream>
#include <functional>
#include <bitset>
using namespace std;

#define debug(...) fprintf(stderr, __VA_ARGS__)
#define int long long int
 
template<typename T> void chmax(T &a, T b) {a = max(a, b);}
template<typename T> void chmin(T &a, T b) {a = min(a, b);}
template<typename T> void chadd(T &a, T b) {a = a + b;}
 
typedef pair<int, int> pii;
typedef long long ll;
 
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
const ll INF = 1001001001001001LL;
const ll MOD = 1000000007LL;

ll mod_pow(ll x, ll k) {
    ll res = 1;
    for(; k>0; k>>=1) {
        if(k & 1) (res *= x) %= MOD;
        (x *= x) %= MOD;
    }
    return res;
}

ll mod_inv(ll x) {
    return mod_pow(x, MOD-2);
}

ll pow2_inv(ll k) {
    return mod_inv(mod_pow(2, k));
}

ll frac(ll P, ll Q) {
    return P * mod_inv(Q) % MOD;
}


const int MAXN = 300010;
long long  fact[MAXN], inv[MAXN];

void init_fact() {
    fact[0] = 1;
    for(int i=1; i<MAXN; i++) {
        fact[i] = (fact[i-1] * i) % MOD;
    }

    inv[MAXN - 1] = mod_pow(fact[MAXN - 1], MOD-2);
    for(int i=MAXN - 2; i>=0; i--) {
        inv[i] = (inv[i+1] * (i+1)) % MOD;
    }
}

long long  comb(int n, int r) {
    if(r < 0 || n < r) return 0;
    return fact[n] * inv[n-r] % MOD * inv[r] % MOD;
}


signed main() {
    init_fact();
    int B, W; cin >> B >> W;
    vector<ll> ans(B+W+5);

    // (i, 0) で初めて一方が 0 に
    for(int i=1; i<=B; i++) {
        // 最後は必ず 'W' で終わるので W-1 とかにする
        int useB = B - i;
        int useW = W - 1;

        // それが発生する確率
        ll C = comb(useB + useW, useB);
        ll prob = pow2_inv(useB + useW + 1);
        // 黒を取る確率
        ll takeB = prob * C % MOD * frac(useB, useB + useW) % MOD;
        // 白を取る確率
        ll takeW = prob * C % MOD * frac(useW, useB + useW) % MOD;

        // fprintf(stderr, "! useB = %lld, useW = %lld\n", useB, useW);
        // fprintf(stderr, "! (%lld, 0): prob = %lld, takeB = %lld, takeW = %lld\n", i, prob, takeB, takeW);

        // いもす
        // fprintf(stderr, "! add to %lld, sub to %lld\n", 1, useB + useW + 1);
        (ans[1] += takeB) %= MOD;
        (ans[useB + useW + 1] += MOD - takeB) %= MOD;

        // いもす (この後は黒を取り続けるので)
        // fprintf(stderr, "comb = %lld\n", comb(useB + useW, useB));
        (prob *= C) %= MOD;
        // fprintf(stderr, "!!! prob = %lld\n", prob);
        (ans[useB + useW + 2] += prob) %= MOD;
        (ans[B+W+1] += MOD - prob) %= MOD;
    }
    // (0, i) で初めて一方が 0 に
    for(int i=1; i<=W; i++) {
        // 最後は必ず 'B' で終わるので
        int useB = B - 1;
        int useW = W - i;

        ll C = comb(useB + useW, useB);
        ll prob = pow2_inv(useB + useW + 1);
        // 黒を取る確率
        ll takeB = prob * C % MOD * frac(useB, useB + useW) % MOD;
        // 白を取る確率
        ll takeW = prob * C % MOD * frac(useW, useB + useW) % MOD;
        
        // fprintf(stderr, "# useB = %lld, useW = %lld\n", useB, useW);
        // fprintf(stderr, "# (0, %lld): prob = %lld, takeB = %lld, takeW = %lld\n", i, prob, takeB, takeW);

        // いもす
        // fprintf(stderr, "# add to %lld, sub to %lld\n", 1, useB + useW + 1);

        (ans[1] += takeB) %= MOD;
        (ans[useB + useW + 1] += MOD - takeB) %= MOD;

        (prob *= C) %= MOD;
        // fprintf(stderr, "### prob = %lld\n", prob);
        (ans[useB + useW + 1] += prob) %= MOD;
        (ans[useB + useW + 2] += MOD - prob) %= MOD;
    }

    for(int i=1; i<=B+W+1; i++) {
        (ans[i] += ans[i-1]) %= MOD;
    }
    for(int i=1; i<=B+W; i++) {
        cout << ans[i] << endl;
    }
    return 0;
}


Measured memory_bytes: 8448