#include<bits/stdc++.h>

using namespace std;

const int N = 209;
int A, B, C;
double f[N][N][N];

signed main()
{
	scanf("%d %d %d", &A, &B, &C);
	if (A > B) swap(A, B);
	if (A > C) swap(A, C);
	if (B > C) swap(B, C);
	if (A == 0 && B == 0) printf("%d\n", 100 - C);
	else
	{
		f[A][B][C] = 1;
		for (int i = A; i < 100; i++)
			for (int j = B; j < 100; j++)
				for (int k = C; k < 100; k++)
				{
					if ((A == 0 && i != 0) || (B == 0 && j != 0) || (C == 0 && k != 0))
						continue;
					int tmp = i + j + k;
					if (i != 0) f[i + 1][j][k] = f[i + 1][j][k] + 1.0 * f[i][j][k] / tmp * i;
					if (j != 0) f[i][j + 1][k] = f[i][j + 1][k] + 1.0 * f[i][j][k] / tmp * j;
					if (k != 0) f[i][j][k + 1] = f[i][j][k + 1] + 1.0 * f[i][j][k] / tmp * k;
				}
		double ans = 0;
		for (int i = A; i <= 100; i++)
			for (int j = B; j <= 100; j++)
				for (int k = C; k <= 100; k++)
				{
					int tmp = (i == 100) + (j == 100) + (k == 100);
					if (tmp > 1 || tmp == 0) continue;
					ans += f[i][j][k] * (i - A + j - B + k - C);
				}
		printf("%.10lf\n", ans);
	}
	return 0;
}
#include <iostream>
#include <map>
#include <tuple>
#include <algorithm>
#include <iomanip>
#include <array>

int main()
{
  int A, B, C;
  std::cin >> A >> B >> C;

  std::array<int, 3> init_status = {A,B,C};
  std::sort(init_status.begin(), init_status.end());

  std::map<std::array<int,3>, double> status;
  status.emplace(init_status, 1);

  double coinsExpected = 0.0;

  while( !status.empty() )
  {
    std::map<std::array<int, 3>, double> statusNext;

    for (const auto& e : status)
    {
      const auto& state = e.first;
      double coins = state[0] + state[1] + state[2];
      double pA = e.second * state[0] / coins;
      double pB = e.second * state[1] / coins;
      double pC = e.second * state[2] / coins;

      if (pA != 0)
      {
        if (state[0] == 99)
        {
          coinsExpected += pA * (coins + 1);
        }
        else
        {
          auto next = state;
          next[0] += 1;
          std::sort(next.begin(), next.end());
          statusNext[next] = (statusNext.count(next) ? statusNext[next] : 0.0) + pA;
        }
      }

      if (pB != 0)
      {
        if (state[1] == 99)
        {
          coinsExpected += pB * (coins + 1);
        }
        else
        {
          auto next = state;
          next[1] += 1;
          std::sort(next.begin(), next.end());
          statusNext[next] = (statusNext.count(next) ? statusNext[next] : 0.0) + pB;
        }
      }

      if (pC != 0)
      {
        if (state[2] == 99)
        {
          coinsExpected += pC * (coins + 1);
        }
        else
        {
          auto next = state;
          next[2] += 1;
          std::sort(next.begin(), next.end());
          statusNext[next] = (statusNext.count(next) ? statusNext[next] : 0.0) + pC;
        }
      }
    }
    status = statusNext;
  }
  std::cout <<
    std::setprecision(14) <<
    coinsExpected-A-B-C << std::endl;
  return 0;
}
