#include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <queue>
#include <string>
#include <utility>
#include <vector>

using namespace std;

#define ALL(a) (a).begin(), (a).end()

#define min_e(v) *min_element(ALL(v))
#define max_e(v) *max_element(ALL(v))

#define order(neq_sl) [](const auto s, const auto l){return neq_sl;}
#define make_lr(v,type,l,r) vector<type> l(n+1),r(n+1);FOR(i,n){l[i+1]=l[i]+v[i];r[i+1]=r[i]+v[n-1-i];}

#define acm accumulate
#define SUM(v) accumulate(ALL(v), 0l)
#define SORT(v) sort(ALL(v))
#define P 1000000007
long powP (long a, long b) {
  if (b == 1) return a;
  else if (b == 0) return 1;
  else if (b < 0) return powP(a, P - 1 + b);
  else {
    long b2 = powP(a, b/2);
    b2*=b2;
    b2%=P;
    return (b2 * powP(a, b%2)) % P;
  }
}

template <typename T>
using vec = vector<T>;

template <typename T>
using vvec = vector<vector<T>>;

/*
template <typename T>
T gcd(T a, T b) {
    if (a > b) swap(a, b);
    if (a == 0) return b;
    return gcd(b%a, a);
}
template <typename InputItr, typename T>
T gcd(InputItr first, InputItr last, T init) {
    for (; first != last; ++first) init = gcd(init, *first);
    return init;
}
template <typename T>
T lcm(T a, T b) {
    return (a * b / gcd(a, b)) % P;
}
template <typename InputItr, typename T>
T lcm(InputItr first, InputItr last, T init) {
    for (; first != last; ++first) init = lcm(init, *first);
    return init;
}

#define GCD(v) gcd(ALL(v), 0l)
#define LCM(v) lcm(ALL(v), 1l)
*/


//#define x first
//#define y second


int main() {

  vec<int> p(3);
  cin>>p[0]>>p[1]>>p[2];
  SORT(p);

  if (p[1]==0) cout<<100-p[2];
  else if (p[0]==0) {
    vvec<double> v(101, vec<double>(101));
    v[100][100]=0;
    for (int i = 99; i >= p[1]; i--) {
      for (int j = 99; j >= p[2]; j--) {
        v[i][j] = (v[i+1][j]*i+v[i][j+1]*j)/(i+j)+1;
      }
    }
    cout<<setprecision(12)<<v[p[1]][p[2]];
  } else {
    vec<vvec<double>> v(101, vvec<double>(101, vec<double>(101)));
    v[100][100][100]=0;
    for (int i = 99; i >= p[0]; i--) {
      for (int j = 99; j >= p[1]; j--) {
        for (int k = 99; k >= p[2]; k--) {
          v[i][j][k] = (v[i+1][j][k]*i+v[i][j+1][k]*j+v[i][j][k+1]*k)/(i+j+k)+1;
        }
      }
    }
    cout<<setprecision(12)<<v[p[0]][p[1]][p[2]];
  }
  
  return 0;

}

#include <iostream>
#include <cmath>
#include <stdio.h>
#include <string.h>
#include <bits/stdc++.h>
#include <vector>
#include <array> 
#include <tuple>
using namespace std; 

int main() {
  int A, B, C;
  cin >> A >> B >> C;
  double p[101][101][101];
  for (int i=0; i<=100; i++){
    for (int j=0; j<=100; j++){
      p[i][j][100]=0.0;
      p[i][100][j]=0.0;
      p[100][i][j]=0.0;
    }
  }
  for (int i=0; i<=99; i++){
    for (int j=0; j<=99; j++){
      for (int k=0; k<=99; k++){
        p[99-i][99-j][99-k]=(p[99-i+1][99-j][99-k]+1)*(99-i)/(297-(i+j+k))+(p[99-i][99-j+1][99-k]+1)*(99-j)/(297-(i+j+k))+(p[99-i][99-j][99-k+1]+1)*(99-k)/(297-(i+j+k));
      }
    }
  }
 cout << fixed << setprecision(6) << p[A][B][C] << endl;
}