#include <bits/stdc++.h>
using namespace std;using ll=long long;using vi=vector<int>;using vvi=vector<vi>;using vl=vector<ll>;using vvl=vector<vl>;using P=pair<int,int>;using PL=pair<ll,ll>;using vp=vector<P>;using vpl=vector<PL>;

#define all(v)(v).begin(),(v).end()
#define rall(v)(v).rbegin(),(v).rend()

// cin and cout of a vector
template<class T>class iterable{static false_type c(string v);template<class U>static auto c(U v)->decltype(all(v),true_type());static false_type c(...);public:const static bool value=decltype(c(declval<T>()))::value;};
template<class T,enable_if_t<iterable<T>::value,int> =0>ostream&operator<<(ostream&o,const T&v){for(auto&&i:v)o<<i<<' ';return o;}
template<class T>istream&operator>>(istream&i,vector<T>&v){for(T&j:v)i>>j;return i;}template<class T>vector<T>&operator<<(vector<T>&v,const T&t){v.push_back(t);return v;}

// for loop
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define repp(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define revv(i, a, b) for (int i = (int)(b-1); i >= (int)(a); i--)
#define rev(i, n) for(int i = (int)(n - 1); i >= 0; i--)
#define rev1(i, n) for(int i = (int)(n); i > 0; i--)
// #define FOR(i,n,m) for(int i=(int)(n); i<=(int)(m); i++)
// #define RFOR(i,n,m) for(int i=(int)(n); i>=(int)(m); i--)
// #define ITR(x,c) for(__typeof(c.begin()) x=c.begin();x!=c.end();x++)
// #define RITR(x,c) for(__typeof(c.rbegin()) x=c.rbegin();x!=c.rend();x++)

// Yes/no
#define cho(n,a,b) cout<< ((n)?a:b)<<endl;
void YES(int n){cho(n,"YES","NO");}void Yes(int n){cho(n,"Yes","No");}void Poss(int n){cho(n,"Possible","Impossible");}


#define pb push_back
#define revsort(v) sort((v).rbegin(), (v).rend())
#define sortv(v) sort((v).begin(), (v).end())

// max/min
template<class T, class U>bool chmax(T&a,const U&b){bool x=a<b;x?a=b:b;return x;}template<class T, class U>bool chmin(T&a,const U&b){bool x=a>b;x?a=b:b;return x;}
template<class T, class U>auto max(const T&a,const U&b){return a<b?b:a;}template<class T, class U>auto min(const T&a,const U&b){return a<b?a:b;}

//========================================
//========================================
//========================================

template<class T>auto minv(const T&a){return *min_element(all(a));}
template<class T>auto maxv(const T&a){return *max_element(all(a));}
template<class T>auto sumv(const T&a){ll sum = 0; for(auto x: a) sum+= x; return sum;}
template<class T>void pr(const T&a){cout << a << endl;}
template<class T>void pr_precise(const T&a){cout.precision(10); cout << fixed << a << endl;}


int check(ll a, ll b){
    if (a == 0 && b == 0) return 0;
    if (a == b || a + b <= 3) return 1;

    if ((a-b)%2 == 0) return 2; // long + long
    if (a + b <= 6) return 2; // short + short. miss this case;
    if ( abs(a - b) <= 3) return 2; // long + short
    
    return 3;
}

int main() {
    int cases = 1;
    // cin >> cases;
    rep(CASE, cases){
        ll a, b, c;
        cin >> a >> b >> c;
        double dp[101][101][101] = {{{0.}}};
        rev(i,100){
            rev(j,100){
                rev(k, 100){
                    dp[i][j][k] = (i*dp[i+1][j][k] + j*dp[i][j+1][k] + k*dp[i][j][k+1])/(i+j+k) + 1.;
                }
            }
        }
        pr_precise(dp[a][b][c]);
    }
}
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
int main() {
  double a, b, c;
  cin >> a >> b >> c;
  vector<vector<vector<double>>> dp(
      110, vector<vector<double>>(110, vector<double>(110, 0.0)));
  dp[a][b][c] = 1.0;
  for(int i = 0; i <= 100; i++) {
    for(int j = 0; j <= 100; j++) {
      for(int k = 0; k <= 100; k++) {
        if(i == 0 && j == 0 && k == 0) {
          continue;
        }
        dp[i + 1][j][k] += dp[i][j][k] * (double)i / (i + j + k);
        dp[i][j + 1][k] += dp[i][j][k] * (double)j / (i + j + k);
        dp[i][j][k + 1] += dp[i][j][k] * (double)k / (i + j + k);
      }
    }
  }
  double ans = 0;
  for(int i = 0; i < 100; i++) {
    for(int j = 0; j < 100; j++) {
      ans += dp[i][j][100] * (100 - c);
      ans += dp[i][100][j] * (100 - b);
      ans += dp[100][i][j] * (100 - a);
    }
  }
  printf("%.10f\n", ans);
  return 0;
}