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.
if True:
    from io import BytesIO, IOBase
    import math

    import random
    import sys
    import os

    import bisect
    import typing
    from collections import Counter, defaultdict, deque
    from copy import deepcopy
    from functools import cmp_to_key, lru_cache, reduce
    from heapq import heapify, heappop, heappush, heappushpop, nlargest, nsmallest
    from itertools import accumulate, combinations, permutations, count
    from operator import add, iand, ior, itemgetter, mul, xor
    from string import ascii_lowercase, ascii_uppercase, ascii_letters
    from typing import *
    BUFSIZE = 4096

    class FastIO(IOBase):
        newlines = 0

        def __init__(self, file):
            self._fd = file.fileno()
            self.buffer = BytesIO()
            self.writable = "x" in file.mode or "r" not in file.mode
            self.write = self.buffer.write if self.writable else None

        def read(self):
            while True:
                b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
                if not b:
                    break
                ptr = self.buffer.tell()
                self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
            self.newlines = 0
            return self.buffer.read()

        def readline(self):
            while self.newlines == 0:
                b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
                self.newlines = b.count(b"\n") + (not b)
                ptr = self.buffer.tell()
                self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
            self.newlines -= 1
            return self.buffer.readline()

        def flush(self):
            if self.writable:
                os.write(self._fd, self.buffer.getvalue())
                self.buffer.truncate(0), self.buffer.seek(0)

    class IOWrapper(IOBase):
        def __init__(self, file):
            self.buffer = FastIO(file)
            self.flush = self.buffer.flush
            self.writable = self.buffer.writable
            self.write = lambda s: self.buffer.write(s.encode("ascii"))
            self.read = lambda: self.buffer.read().decode("ascii")
            self.readline = lambda: self.buffer.readline().decode("ascii")

    sys.stdin = IOWrapper(sys.stdin)
    sys.stdout = IOWrapper(sys.stdout)
    input = lambda: sys.stdin.readline().rstrip("\r\n")
    
    def I():
        return input()

    def II():
        return int(input())

    def MII():
        return map(int, input().split())

    def LI():
        return list(input().split())

    def LII():
        return list(map(int, input().split()))

    def LFI():
        return list(map(float, input().split()))

    def GMI():
        return map(lambda x: int(x) - 1, input().split())

    def LGMI():
        return list(map(lambda x: int(x) - 1, input().split()))

    inf = float('inf')

dfs, hashing = False, False

if dfs:
    from types import GeneratorType

    def bootstrap(f, stack=[]):
        def wrappedfunc(*args, **kwargs):
            if stack:
                return f(*args, **kwargs)
            else:
                to = f(*args, **kwargs)
                while True:
                    if type(to) is GeneratorType:
                        stack.append(to)
                        to = next(to)
                    else:
                        stack.pop()
                        if not stack:
                            break
                        to = stack[-1].send(to)
                return to
        return wrappedfunc

if hashing:
    RANDOM = random.getrandbits(20)
    class Wrapper(int):
        def __init__(self, x):
            int.__init__(x)

        def __hash__(self):
            return super(Wrapper, self).__hash__() ^ RANDOM

r, s, p = MII()
def pos(x, y, z):
    return x * (s + 1) * (p + 1) + y * (p + 1) + z

dp = [None] * ((r + 1) * (s + 1) * (p + 1))
for i in range(r + 1):
    for j in range(s + 1):
        for k in range(p + 1):
            if max(i, j, k) == 0: continue
            if not i and not j: dp[pos(i, j, k)] = [0, 0, 1]
            elif not i and not k: dp[pos(i, j, k)] = [0, 1, 0]
            elif not j and not k: dp[pos(i, j, k)] = [1, 0, 0]
            else:
                dp[pos(i, j, k)] = [0, 0, 0]
                if i:
                    prob = (i * k) / (i * j + j * k + i * k)
                    dp[pos(i, j, k)][0] += prob * dp[pos(i-1, j, k)][0]
                    dp[pos(i, j, k)][1] += prob * dp[pos(i-1, j, k)][1]
                    dp[pos(i, j, k)][2] += prob * dp[pos(i-1, j, k)][2]
                if j:
                    prob = (i * j) / (i * j + j * k + i * k)
                    dp[pos(i, j, k)][0] += prob * dp[pos(i, j-1, k)][0]
                    dp[pos(i, j, k)][1] += prob * dp[pos(i, j-1, k)][1]
                    dp[pos(i, j, k)][2] += prob * dp[pos(i, j-1, k)][2]
                if k:
                    prob = (j * k) / (i * j + j * k + i * k)
                    dp[pos(i, j, k)][0] += prob * dp[pos(i, j, k-1)][0]
                    dp[pos(i, j, k)][1] += prob * dp[pos(i, j, k-1)][1]
                    dp[pos(i, j, k)][2] += prob * dp[pos(i, j, k-1)][2]

print(*dp[-1])