#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <vector>
using namespace std;
using ll = long long;
#define fst first
#define snd second

/* clang-format off */
template <class T, size_t D> struct _vec { using type = vector<typename _vec<T, D - 1>::type>; };
template <class T> struct _vec<T, 0> { using type = T; };
template <class T, size_t D> using vec = typename _vec<T, D>::type;
template <class T> vector<T> make_v(size_t size, const T& init) { return vector<T>(size, init); }
template <class... Ts> auto make_v(size_t size, Ts... rest) { return vector<decltype(make_v(rest...))>(size, make_v(rest...)); }
template <class T> inline void chmin(T &a, const T& b) { if (b < a) a = b; }
template <class T> inline void chmax(T &a, const T& b) { if (b > a) a = b; }
/* clang-format on */

const ll MOD = 1e9 + 7;

ll power(ll x, ll e) {
  ll v = 1;
  for (; e > 0; e >>= 1) {
    if (e & 1) {
      v = v * x % MOD;
    }
    x = x * x % MOD;
  }
  return v;
}

ll inverse(ll x) {
  return power(x, MOD - 2);
}

vector<ll> fact, factInv;
void initFact(int N) {
  fact.resize(N + 1);
  factInv.resize(N + 1);
  fact[0] = 1;
  for (int i = 1; i <= N; i++) {
    fact[i] = fact[i - 1] * i % MOD;
  }
  factInv[N] = inverse(fact[N]);
  for (int i = N - 1; i >= 0; i--) {
    factInv[i] = factInv[i + 1] * (i + 1) % MOD;
  }
}

ll choose(int n, int k) {
  if (k > n || k < 0) {
    return 0;
  } else {
    return fact[n] * factInv[k] % MOD * factInv[n - k] % MOD;
  }
}

struct CombSum {
  int n;
  int lb, ub;
  ll sum = 0;

  CombSum succ(int lb_, int ub_) const {
    ll S = sum * 2 % MOD;
    S = (S - choose(n, lb) + MOD) % MOD;
    S = (S - choose(n, ub) + MOD) % MOD;
    int l = lb + 1, u = ub;
    while (lb_ < l) (S += choose(n + 1, --l)) %= MOD;
    while (l < lb_) (S += MOD - choose(n + 1, l++)) %= MOD;
    while (u < ub_) (S += choose(n + 1, ++u)) %= MOD;
    while (ub_ < u) (S += MOD - choose(n + 1, u--)) %= MOD;
    return {n + 1, lb_, ub_, S};
  }
};

void naive(int B, int W) {
  for (int i = 1; i <= B + W; i++) {
    int pre = i - 1;
    ll res = 0;
    for (int w = 0; w <= W && w <= pre; w++) {
      int b = pre - w;
      if (b > B - 1) continue;
      if (w < W) {
        ll p = power(inverse(2), pre + 1);
        p = p * choose(pre, w) % MOD;
        res = (res + p) % MOD;
      } else {
        for (int b1 = 0; b1 <= b; b1++) {
          ll p = power(inverse(2), w + b1);
          p = p * choose(w - 1 + b1, b1) % MOD;
          res = (res + p) % MOD;
        }
      }
    }
    cout << res << endl;
  }
}

void solve(int B, int W) {
  CombSum csum = {0, 0, -1, 0ll};
  ll bsum = 0;
  int cb = 0;
  for (int pre = 0; pre < B + W; pre++) {
    ll res = 0;
    int lb = max(0, pre - B + 1);
    int ub = min(W, pre);
    if (pre > 0) {
      csum = csum.succ(lb, ub - 1);
    }
    res = (res + csum.sum * power(inverse(2), pre + 1) % MOD) % MOD;
    if (ub < W) {
      ll p = power(inverse(2), pre + 1);
      p = p * choose(pre, ub) % MOD;
      res = (res + p) % MOD;
    } else {
      int b = pre - W;
      for (; cb <= b; cb++) {
        ll p = power(inverse(2), W + cb);
        p = p * choose(W - 1 + cb, cb) % MOD;
        bsum = (bsum + p) % MOD;
      }
      res = (res + bsum) % MOD;
    }
    cout << res << endl;
  }
}

int main() {
#ifdef DEBUG
  ifstream ifs("in.txt");
  cin.rdbuf(ifs.rdbuf());
#endif
  initFact(200010);
  int B, W;
  while (cin >> B >> W) {
    solve(B, W);
  }
  return 0;
}


Measured memory_bytes: 5376