#include<bits/stdc++.h>

#include<bits/stdc++.h>

namespace ProconLib{
    using ll=long long;
    using Int=int;

    template<Int MOD,bool IsPrime=true>
    class ModInt{
        Int n;        
        public:
        ModInt():n(0){};
        ModInt(int n):n(n>=MOD ? n%MOD : (n<0 ? (n%MOD+MOD)%MOD : n)){}
        ModInt(long long n):n(n>=0 ? n%MOD : (n%MOD+MOD)%MOD){}
        ModInt(const ModInt<MOD,IsPrime> &mn):n(mn.n){}
        explicit operator int() const{return n;}
        explicit operator long long() const{return n;}

        ModInt<MOD,IsPrime>& operator+=(ModInt<MOD,IsPrime> rhs);
        ModInt<MOD,IsPrime>& operator-=(ModInt<MOD,IsPrime> rhs);
        ModInt<MOD,IsPrime>& operator*=(ModInt<MOD,IsPrime> rhs);
        ModInt<MOD,IsPrime> operator-(){return ModInt<MOD,IsPrime>(-this->n);};
        bool operator==(ModInt<MOD,IsPrime> rhs){return n==rhs.n;}
        const Int& get() const {return n;}
    };

    template<Int MOD,bool IsPrime>
    ModInt<MOD,IsPrime> operator+(ModInt<MOD,IsPrime> lhs,ModInt<MOD,IsPrime> rhs){return lhs+=rhs;};
    template<Int MOD,bool IsPrime>
    ModInt<MOD,IsPrime> operator+(ModInt<MOD,IsPrime> lhs,int rhs){return lhs+ModInt<MOD,IsPrime>(rhs);}
    template<Int MOD,bool IsPrime>
    ModInt<MOD,IsPrime> operator+(ModInt<MOD,IsPrime> lhs,ll rhs){return lhs+ModInt<MOD,IsPrime>(rhs);}
    template<Int MOD,bool IsPrime>
    ModInt<MOD,IsPrime> operator+(int lhs,ModInt<MOD,IsPrime> rhs){return ModInt<MOD,IsPrime>(lhs)+rhs;}
    template<Int MOD,bool IsPrime>
    ModInt<MOD,IsPrime> operator+(ll lhs,ModInt<MOD,IsPrime> rhs){return ModInt<MOD,IsPrime>(lhs)+rhs;}

    template<Int MOD,bool IsPrime>
    ModInt<MOD,IsPrime> operator+(ModInt<MOD,IsPrime> mn){return mn;};

    template<Int MOD,bool IsPrime>
    ModInt<MOD,IsPrime> operator-(ModInt<MOD,IsPrime> lhs,ModInt<MOD,IsPrime> rhs){return lhs-=rhs;};
    template<Int MOD,bool IsPrime>
    ModInt<MOD,IsPrime> operator-(ModInt<MOD,IsPrime> lhs,int rhs){return lhs-ModInt<MOD,IsPrime>(rhs);};
    template<Int MOD,bool IsPrime>
    ModInt<MOD,IsPrime> operator-(ModInt<MOD,IsPrime> lhs,ll rhs){return lhs-ModInt<MOD,IsPrime>(rhs);};
    template<Int MOD,bool IsPrime>
    ModInt<MOD,IsPrime> operator-(int lhs,ModInt<MOD,IsPrime> rhs){return ModInt<MOD,IsPrime>(lhs)-rhs;};
    template<Int MOD,bool IsPrime>
    ModInt<MOD,IsPrime> operator-(ll lhs,ModInt<MOD,IsPrime> rhs){return ModInt<MOD,IsPrime>(lhs)-rhs;};

    template<Int MOD,bool IsPrime>
    ModInt<MOD,IsPrime> operator*(ModInt<MOD,IsPrime> lhs,ModInt<MOD,IsPrime> rhs){return lhs*=rhs;};
    template<Int MOD,bool IsPrime>
    ModInt<MOD,IsPrime> operator*(ModInt<MOD,IsPrime> lhs,int rhs){return lhs*ModInt<MOD,IsPrime>(rhs);}
    template<Int MOD,bool IsPrime>
    ModInt<MOD,IsPrime> operator*(ModInt<MOD,IsPrime> lhs,ll rhs){return lhs*ModInt<MOD,IsPrime>(rhs);}
    template<Int MOD,bool IsPrime>
    ModInt<MOD,IsPrime> operator*(ll lhs,ModInt<MOD,IsPrime> rhs){return ModInt<MOD,IsPrime>(lhs)*rhs;}
    template<Int MOD,bool IsPrime>
    ModInt<MOD,IsPrime> operator*(int lhs,ModInt<MOD,IsPrime> rhs){return ModInt<MOD,IsPrime>(lhs)*rhs;}

    template<Int MOD>
    ModInt<MOD,true> operator/(ModInt<MOD,true> lhs,ModInt<MOD,true> rhs);
    template<Int MOD,bool IsPrime>
    ModInt<MOD,IsPrime> powm(ModInt<MOD,IsPrime> x,Int k);
    template<Int MOD>
    ModInt<MOD,true> inv(ModInt<MOD,true> x){return powm(x,MOD-2);}

    template<Int MOD,bool IsPrime>
    std::ostream& operator<<(std::ostream& os,const ModInt<MOD,IsPrime> &mn);
    

    template<Int MOD,bool IsPrime>
    ModInt<MOD,IsPrime>& ModInt<MOD,IsPrime>::operator+=(ModInt<MOD,IsPrime> rhs){
        n+=rhs.n;
        n= n>=MOD ? n-MOD : n;
        return *this;
    }
    
    template<Int MOD,bool IsPrime>
    ModInt<MOD,IsPrime>& ModInt<MOD,IsPrime>::operator-=(ModInt rhs){
        n=n-rhs.n<0 ? n-rhs.n+MOD : n-rhs.n;
        return *this;
    }
    template<Int MOD,bool IsPrime>
    ModInt<MOD,IsPrime>& ModInt<MOD,IsPrime>::operator*=(ModInt<MOD,IsPrime> rhs){
        n=ll(n)*rhs.n%MOD;
        return *this;
    }
    
    template<Int MOD>
    ModInt<MOD,true> operator/(ModInt<MOD,true> lhs,ModInt<MOD,true> rhs){
        return lhs*inv(rhs);
    }
    template<Int MOD,bool IsPrime>
    ModInt<MOD,IsPrime> powm(ModInt<MOD,IsPrime> x,Int k){
        ModInt<MOD,IsPrime> res(1);
        while(k){
            if(k&1) res*=x;
            k>>=1;
            x*=x;
        }
        return res;
    }

    template<Int MOD,bool IsPrime>
    std::ostream& operator<<(std::ostream& os,const ModInt<MOD,IsPrime> &mn){
        os<<mn.get();
        return os;
    }

        template<typename MInt>
    class ModCombination{
        int N;
        std::vector<MInt> fact;
        std::vector<MInt> factInv;
        public:
        ModCombination(int n);
        MInt F(int n){return fact[n];}
        MInt FI(int n){return factInv[n];}
        MInt P(int n,int k){return fact[n]*factInv[n-k];}
        MInt PI(int n,int k){return factInv[n]*fact[n-k];}
        MInt C(int n,int k){return fact[n]*factInv[k]*factInv[n-k];}
        MInt CI(int n,int k){return factInv[n]*fact[k]*fact[n-k];}
    };

    template<typename MInt>
    ModCombination<MInt>::ModCombination(int n):N(n),fact(n+1),factInv(n+1){
        fact[0]=MInt(1);
        for(int i=1;i<=n;i++) fact[i]=fact[i-1]*MInt(i);
        factInv[n]=inv(fact[n]);
        for(int i=n-1;i>=0;i--){
            factInv[i]=factInv[i+1]*MInt(i+1);
        }
    }
    
}
using namespace std;
using namespace ProconLib;

const int MOD=1e9+7;
using mint=ModInt<MOD,true>;
int main(){
    int b,w;
    cin>>b>>w;
    vector<mint> res(b+w);
    vector<mint> v(b+w);
    mint ext=0;
    ModCombination<mint> comb(b+w+1);
    for(int i=0;i<b+w;i++){
        if(i==0){
            v[i]=1;
        }
        else{
            int x=max(i-w+1,0);
            int y=min(i,b-1);
            bool xb=(x!=0);
            bool yb=(y!=i);
            v[i]=v[i-1]*2;
            if(xb) v[i]-=comb.C(i-1,x-1);
            if(yb) v[i]-=comb.C(i-1,b-1);
        }
        mint lv=powm(inv(mint(2)),i+1)*v[i];
        res[i]=lv+ext;
        if(i>=w-1) ext+=powm(inv(mint(2)),i+1)*comb.C(i,w-1);
    }
    for(int i=0;i<b+w;i++){
        cout<<res[i]<<endl;
    }
    return 0;
}

Measured memory_bytes: 5376