#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
constexpr int Inf = 1000000030;
constexpr ll INF= 2000000000000000000;
constexpr ll MOD = 1000000007;
const double PI = 3.1415926535897;
typedef pair<int,int> P;
typedef pair<int,P> PP;

template<class T> inline bool chmax(T &a, T b) {
    if (a < b) {
        a = b;
        return 1;
    }
    return 0;
}

template<class T> inline bool chmin(T &a, T b) {
    if (a > b) {
        a = b;
        return 1;
    }
    return 0;
}

ll mod(ll val, ll M) {
    val = val % M;
    if(val < 0) {
        val += M;
    }
    return val;
}

template<typename T>
T RS(T N, T P, T M){
    if(P == 0) {
        return 1;
    }
    if(P < 0) {
        return 0;
    }
    if(P % 2 == 0){
        ll t = RS(N, P/2, M);
        if(M == -1) return t * t;
        return t * t % M;
    }
    if(M == -1) {
        return N * RS(N,P - 1,M);
    }
    return N * RS(N, P-1, M) % M;
}

long double d[101][101][101];

long double solve(int A,int B,int C) {
    if(d[A][B][C] != -1) {
        return d[A][B][C];
    }
    if(A == 100 || B == 100 || C == 100) return 0;
    long double a = A;
    long double b = B;
    long double c = C;
    return d[A][B][C] = 1 + solve(A + 1,B,C) * (long double)(a / (a + b + c)) + solve(A,B + 1,C) * (long double)(b / (a + b + c)) + solve(A,B,C + 1) * (long double)(c / (a + b + c));
}

int main() {
    int A,B,C;
    cin >> A >> B >> C;
    for(int i = 0;i < 101;i++) {
        for(int j = 0;j < 101;j++) {
            for(int k = 0;k < 101;k++) {
                d[i][j][k] = -1;
            }
        }
    }
    cout << fixed;
    cout << setprecision(8) << solve(A,B,C) << endl;
}
#include <bits/stdc++.h>
using namespace std;

void DBG() { cerr << endl; }
template<class Head, class... Tail>
void DBG(Head H, Tail... T) { cerr << ' ' << H; DBG(T...); }
#define dbg(...) cerr << "(" << (#__VA_ARGS__) << "):", DBG(__VA_ARGS__)

using ll = long long;
using ld = long double;

#define sqr(a) ll(a) * (a)
#define siz(a) int(a.size())
#define ints(a...) int a; read(a)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define trav(i, v) for (const auto i : v)
#define fill(a, b) memset(a, b, sizeof(a))
#define rep(i, b, n) for (auto i = b; i < n; i++)
#define per(i, b, n) for (auto i = b; i >= n; i--)
#define unify(a) sort(all(a)); a.resize(unique(all(a)) - a.begin())

template <class T> using vec = vector<T>;
template <class... Args> inline void read(Args&... args) { ((cin >> args), ...); }
template <class... Args> inline void show(Args... args) { ((cout << args << " "), ...); }
template <class T1, class T2> inline bool ckmin(T1 &a, T2 b) { return a > b ? a = b, 1 : 0; }
template <class T1, class T2> inline bool ckmax(T1 &a, T2 b) { return a < b ? a = b, 1 : 0;  }
template <class T> inline void operator>> (istream& in, vector<T>& v) { rep(i, 0, siz(v)) in >> v[i]; }
template <class T> inline void operator<< (ostream& out, const vector<T>& v) { rep(i, 0, siz(v)) out << v[i] << " \n"[i + 1 == siz(v)]; }

const int MOD = 1e9 + 7;
const int N = 101;
ld dp[N][N][N];

ld f(int a, int b, int c) {
    if (a == 100 || b == 100 || c == 100)
        return 0;
    if (dp[a][b][c] >= 0)
        return dp[a][b][c];

    ld res = 1, sum = a + b + c;
    if (sum == 0)
        return 0;
    if (a < 100)
        res += a * f(a + 1, b, c) / sum;
    if (b < 100)
        res += b * f(a, b + 1, c) / sum;
    if (c < 100)
        res += c * f(a, b, c + 1) / sum;
    return dp[a][b][c] = res;
}

void solve() {
    ints(a, b, c);
    fill(dp, -1);
    cout << f(a, b, c);
}

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout << fixed << setprecision(12);
    cerr << fixed << setprecision(12);
    int _ = 1;
    // cin >> _;
    rep(i, 1, _ + 1) {
        // printf("Case %d: ", i);
        // Solution solve;
        solve();
    }
    return 0;
}