{-# LANGUAGE TypeFamilies, BangPatterns, FlexibleContexts #-}
import Data.Array
import Data.Array.Unboxed
import Data.Array.IO
import Data.Array.Unsafe
import qualified Data.Map.Strict as M
import qualified Data.Set as S
import qualified Data.Vector.Unboxed as U
import Data.Int
import Control.Monad.State.Strict
import qualified Data.ByteString.Char8 as B
import Data.ByteString(ByteString)
import Data.Char

type Scanner a = StateT ByteString IO a
type family Freeze a where
  Freeze (IOUArray i v) = UArray i v
  Freeze (IOArray i v) = Array i v

foldM :: Monad m => (b -> a -> m b) -> b -> [a] -> m b
foldM f z0 xs = foldr c return xs z0
    where c x k = \z -> f z x >>= k
          {-# INLINE c #-}

scan :: Read a => Scanner a
scan = state $ \s ->
    let (s1, s2) = B.span (not . isSpace) s 
        !v = read (B.unpack s1)
    in (v, B.dropWhile isSpace s2)

scanInt :: Scanner Int
scanInt = scan

scanString :: Scanner B.ByteString
scanString = state $ \s ->
    let (s1, s2) = B.span (not . isSpace) s in
    (s1, B.dropWhile isSpace s2)

scanReal :: Scanner Double
scanReal = scan

newtype M = M Int
    deriving Show

modulo = 1000000007

instance Num M where
    M a + M b = M $ (a + b) `mod` modulo
    M a - M b = M $ (a - b) `mod` modulo
    M a * M b = M $ (a * b) `mod` modulo
    fromInteger x = M $ fromInteger x `mod` modulo
    abs = id
    signum _ = M 1

instance Fractional M where
    recip (M x) = M (recipM x modulo)

data EGCD = EGCD !Int !Int !Int

{-# NOINLINE recipM #-}
recipM :: Int -> Int -> Int
recipM x m | g /= 1 = error $ "No inverse for " ++ show x ++ " % " ++ show m 
           | s <  0 = s + m
           | otherwise = s
    where 
    EGCD s _ g = extgcd x m

extgcd :: Int -> Int -> EGCD
extgcd = go
    where 
    go a 0 = EGCD 1 0 a
    go a b = EGCD t (s - q * t) g
        where
        (q, r) = quotRem a b
        EGCD s t g = go b r

main :: IO ()
main = B.getContents >>= \content -> flip evalStateT content $ do
    vB <- scanInt
    vW <- scanInt
    liftIO $ solve vB vW

solve :: Int -> Int -> IO ()
solve vB vW = do
    let n = vB + vW
    let factTbl = U.unfoldrN (n + 1) factGen (1,1)
        factGen :: (M, Int) -> Maybe (Int, (M, Int))
        factGen (M m, i) = Just (m, (M m * M i, i + 1))
        fact :: Int -> M
        fact n = M (factTbl U.! n )
        comb :: Int -> Int -> M
        comb x y = fact x / (fact y * fact (x - y)) 
    let go !i !p !q = when (i < n) $ do
            let M z = p + (1 / 2) * ( 1 - p - q)
                p' | i + 1 < vW = 0
                   | otherwise = p + (1 / 2)^(i + 1) * comb i (vW-1)
                q' | i + 1 < vB = 0
                   | otherwise = q + (1 / 2)^(i + 1) * comb i (vB-1)
            print z
            go (i + 1) p' q'
    go 0 0 0
