The Bad Luck Island is inhabited by three kinds of species: *r* rocks, *s* scissors and *p* papers. At some moments of time two random individuals meet (all pairs of individuals can meet equiprobably), and if they belong to different species, then one individual kills the other one: a rock kills scissors, scissors kill paper, and paper kills a rock. Your task is to determine for each species what is the probability that this species will be the only one to inhabit this island after a long enough period of time.
The single line contains three integers *r*, *s* and *p* (1 ≤ *r*, *s*, *p* ≤ 100) — the original number of individuals in the species of rock, scissors and paper, respectively.
import sys
import math
from collections import deque, defaultdict


input = lambda: sys.stdin.buffer.readline().decode().strip()
mod = 10 ** 9 + 7

def CreateMinSparseTree(arr):
    n=len(arr)
    m,i=[],1
    while i<=n:
        m.append([0]*(n-i+1))
        i*=2
    i=1
    # print(m)
    for i in range(n):m[0][i]=arr[i]
    i=1
    while 2**i<=n:
        for j in range(n-2**i+1):
            m[i][j]=min(m[i-1][j],m[i-1][j+2**(i-1)])
        i+=1
    return m
def RMinQ(M,i,j):
    # M=CreateMinSparseTree(arr)
    n=j-i+1
    x=int(math.log(n,2))
    r=2**x
    return min(M[x][i],M[x][j-r+1])

def ceil(x, y):
    return (x + y - 1) // y
def fast_expo(n,k):
    if k==0:return 1
    if k==1:return n%mod

    if k%2==0:return fast_expo(n,k//2)*fast_expo(n,k//2)%mod
    return fast_expo(n,k//2)*fast_expo(n,k//2)*n%mod


def maxSubArraySum(a):
    size=len(a)
    max_so_far = -float('inf')
    max_ending_here = 0

    for i in range(0, size):
        max_ending_here = max_ending_here + a[i]
        if (max_so_far < max_ending_here):
            max_so_far = max_ending_here

        if max_ending_here < 0:
            max_ending_here = 0
    return max_so_far
def nCr_mod(n, r, mod):
    num = 1
    den = 1

    for i in range(r):
        num = (num * (n - i)) % mod

    for i in range(1, r + 1):
        den = (den * i) % mod
    den_inv = pow(den, mod - 2, mod)
    result = (num * den_inv) % mod

    return result

def binary_search(arr, target):
    low = 0
    high = len(arr) - 1
    index = -1

    while low <= high:
        mid = low + (high - low) // 2
        if arr[mid] == target:
            index = mid
            break
        elif arr[mid] < target:
            low = mid + 1
        else:
            high = mid - 1

    if index != -1:
        return index
    else:
        return high


def recur(dp,x,y,z):
    if dp[x][y][z]!=-1:return dp[x][y][z]
    t1,t2,t3=recur(dp,x-1,y,z),recur(dp,x,y-1,z),recur(dp,x,y,z-1)
    p,q,r=0,0,0
    val=x*y+y*z+z*x
    a,b,c=(x*z/val)*t1[0], (x*z/val)*t1[1], (x*z/val)*t1[2]
    p,q,r=p+a,q+b,r+c
    a, b, c = (x*y/val) * t2[0], (x*y/val) * t2[1], (x*y/val) * t2[2]
    p, q, r = p + a, q + b, r + c
    a, b, c = (y*z/ val) * t3[0], (y*z / val) * t3[1], (y*z / val)*t3[2]
    p, q, r = p + a, q + b, r + c
    dp[x][y][z]=(p,q,r)
    return (p,q,r)
r,s,p= map(int,input().split())
dp=[[[-1]*(p+1) for _ in range(s+1)] for _ in range(r+1)]
for i in range(s+1):
    for j in range(p+1):dp[0][i][j]=(0,1,0)
for i in range(r+1):
    for j in range(s+1):dp[i][j][0]=(1,0,0)
for i in range(r+1):
    for j in range(p+1):
        dp[i][0][j]=(0,0,1)
recur(dp,r,s,p)
# print(dp[1][1][1])
print(dp[r][s][p])
































































































