#include<cstdio>
#include<cmath>
#include<cstdlib>
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
int main()
{
       int n,b,p;
       int i,j,k,x;
       int sum=0;

       cin>>n>>b>>p;
       int a[n];
       for(i=0;i<n;i++)
       {
           cin>>a[i];
       }

       sort(a,a+n);

       for(i=n-1;i>=0;i--)
       {
            if(a[i]==2)
            {
                if(p>0)
                    {
                        p--;
                    }
                else if(p<=0 && b>0)
                {
                    b--;
                }
                else
                    sum++;
            }

            else
            {
                    if(b>0)
                    {
                        b--;
                    }
                    else
                        sum++;
            }
       }

       cout<<sum;

       return 0;
}


#include <iostream>
using namespace std;
int main ()
{
int a[1001],b,i,c,d,x=0,v=0;
cin>>b>>c>>d;
for (i=1;i<=b;i++)
{
cin>>a[i];
}
for (i=1;i<=b;i++)
{
if (a[i]==2){x++;}
if (a[i]==1){v++;}
}
if (x==0){
cout<<(x+v)-c<<endl;}

else cout<<(x+v)-(d+c)<<endl;
}


#include<iostream>
#include<vector>
using namespace std;
int main()
{
int a,b,c;
cin>>a>>b>>c;
vector<int>p(a);
int count=0,co=0,re=0;
for(int i=0;i<a;++i)
{
cin>>p[i];
if(p[i]==1)
count++;
if(p[i]==2)
co++;
}
if (co<c && count<b)
re=0;
else if(co>c && count<b)
{

re=co-c;
if(count==0)
re--;
}
else if (count>b && co<c)
re=count-b;
else
re=(co-c)+(count-b);

cout<<re<<endl;

return 0;
}


#include<iostream>
#include<vector>
using namespace std;
int main()
{
int a,b,c;
cin>>a>>b>>c;
int r;
int re=0;
for(int i=0;i<a;++i)
{
cin>>r;
if(r==1 && b>0)
b--;
else if(r==2 && c>0)
c--;
else if (r==2 && b>0)
b--;
else
re++;
}

cout<<re<<endl;

return 0;
}


#include<iostream>
#include<vector>
using namespace std;
int main()
{
int a,b,c;
cin>>a>>b>>c;
vector<int>p(a);
int count=0,co=0,re=0;
for(int i=0;i<a;++i)
{
cin>>p[i];
if(p[i]==1)
count++;
if(p[i]==2)
co++;
}
if (co<=c && count<=b)
re=0;
else if(co>c && count<b)
{

re=co-c;
if(count<b)
re--;
}
else if (count>b && co<c)
re=count-b;
else
re=(co-c)+(count-b);

cout<<re<<endl;

return 0;
}


#include<iostream>
#include<vector>
using namespace std;
int main()
{
int a,b,c;
cin>>a>>b>>c;
vector<int>p(a);
int count=0,co=0,re=0;
for(int i=0;i<a;++i)
{
cin>>p[i];
if(p[i]==1)
count++;
if(p[i]==2)
co++;
}
if (co<c || count<b)
re=0;
else if(co>c && count<b)
{

re=co-c;
if(count==0)
re--;
}
else if (count>b && co<c)
re=count-b;
else
re=(co-c)+(count-b);

cout<<re<<endl;

return 0;
}


#include<iostream>
#include<vector>
using namespace std;
int main()
{
int a,b,c;
cin>>a>>b>>c;
vector<int>p(a);
int count=0,co=0,re=0;
for(int i=0;i<a;++i)
{
cin>>p[i];
if(p[i]==1)
count++;
if(p[i]==2)
co++;
}
if (co<=c && count<=b)
re=0;
else if(co>c && count<b)
{

re=co-c;
if(count==0)
re--;
}
else if (count>b && co<c)
re=count-b;
else
re=(co-c)+(count-b);

cout<<re<<endl;

return 0;
}


#include<iostream>
#include<vector>
using namespace std;
int main()
{
int a,b,c;
cin>>a>>b>>c;
vector<int>p(a);
int count=0,co=0,re=0;
for(int i=0;i<a;++i)
{
cin>>p[i];
if(p[i]==1)
count++;
if(p[i]==2)
co++;
}

if(co>c && count<b)
{

re=co-c;
if(count==0)
re--;
}
else if (count>b && co<c)
re=count-b;
else
re=(co-c)+(count-b);

cout<<re<<endl;

return 0;
}


#include "iostream"

using namespace std;
void main()
{
	int n,m,k,n1=0,n2=0,temp;
	cin>>n>>m>>k;
	for(int i=1;i<=n;i++)
	{
		cin>>temp;
		if(temp==1)
		{
			n1++;
		}
		else n2++;
	}
	if(n2>k)
	{
		n1+=n2-k;
	}
	if(n1>m)
	{
		cout<<n1-m;

	}
	else cout<<0;
	system("pause");
}


#include <iostream>

using namespace std;
void main()
{
	int n,m,k,n1=0,n2=0,temp;
	cin>>n>>m>>k;
	for(int i=1;i<=n;i++)
	{
		cin>>temp;
		if(temp==1)
		{
			n1++;
		}
		else n2++;
	}
	if(n2>k)
	{
		n1+=n2-k;
	}
	if(n1<=m)
	{
		cout<<n1-m;

	}
	else cout<<0;

}


#include "iostream"

using namespace std;
int main()
{
	int n,m,k,n1=0,n2=0,temp,i;
	cin>>n>>m>>k;
	for(i=1;i<=n;i++)
	{
		cin>>temp;
		if(temp==1)
		{
			n1++;
		}
		else n2++;
	}
	if(n2>k)
	{
		n1+=n2-k;
	}
	if(n1>m)
	{
		cout<<n1-m;

	}
	else cout<<0;
	//system("pause");
	return 0;
}


#include "iostream"

using namespace std;
void main()
{
	int n,m,k,n1=0,n2=0,temp,i;
	cin>>n>>m>>k;
	for(i=1;i<=n;i++)
	{
		cin>>temp;
		if(temp==1)
		{
			n1++;
		}
		else n2++;
	}
	if(n2>k)
	{
		n1+=n2-k;
	}
	if(n1>m)
	{
		cout<<n1-m;

	}
	else cout<<0;
	//system("pause");
}


#include "iostream"

using namespace std;
void main()
{
	int n,m,k,n1=0,n2=0,temp;
	cin>>n>>m>>k;
	for(int i=1;i<=n;i++)
	{
		cin>>temp;
		if(temp==1)
		{
			n1++;
		}
		else n2++;
	}
	if(n2>k)
	{
		n1+=n2-k;
	}
	if(n1>m)
	{
		cout<<n1-m;

	}
	else cout<<0;

}


#include <iostream>

using namespace std;
void main()
{
	int n,m,k,n1=0,n2=0,temp;
	cin>>n>>m>>k;
	for(int i=1;i<=n;i++)
	{
		cin>>temp;
		if(temp==1)
		{
			n1++;
		}
		else n2++;
	}
	if(n2>k)
	{
		n1+=n2;
	}
	if(n1<=m)
	{
		cout<<n1-m;

	}
	else cout<<0;

}


#include <iostream>
using namespace std;

int main()
{
    unsigned int n, m, k, a1 = 0, a2 = 0, day = 0;
    cin>>n;
    cin>>m;
    cin>>k;

    unsigned int *a = new unsigned int[n];

    for (int i = 0; i < n; i++)
    {
        cin>>a[i];
        (a[i] == 1) ? a1++ : a2++;
    }

    if (a1 > m)
        day += a1 - m;

    if(a2 > k)
        day += a2 - k;

    if(day != 0)
        cout << day;
    else
        cout << 0;

    delete[] a;
    return 0;
}


#include <iostream>
using namespace std;

int main()
{
    int n, m, k, a1 = 0, a2 = 0, day = 0, zapas = 0;
    cin>>n>>m>>k;

    int *a = new int[n];

    for (int i = 0; i < n; i++)
    {
        cin>>a[i];
        (a[i] == 1) ? ++a1 : ++a2;
    }

    (a1 > m)? day += a1 - m : zapas = m - a1;

    (a2 > k)? day += a2 - k : 0 ;

    (day == 0)?cout << 0: (day - zapas < 0) ? cout << 0 : cout << day - zapas;

    delete[] a;
    return 0;
}


#include <iostream>
using namespace std;

int main()
{
    int n, m, k, a1 = 0, a2 = 0, day = 0, zapas = 0;
    cin>>n>>m>>k;

    int *a = new int[n];

    for (int i = 0; i < n; i++)
    {
        cin>>a[i];
        (a[i] == 1) ? ++a1 : ++a2;
    }

    if (a1 > m)
        day += a1 - m;
    else
        zapas = m - a1;

    if(a2 > k)
        day += a2 - k;

    if(day == 0)
        cout << 0;
    else
    {
        if (day - zapas < 0)
            cout << 0;
        else
            cout << day - zapas;
    }
    delete[] a;
    return 0;
}


#include <iostream>
using namespace std;

int main()
{
    int n, m, k, a1 = 0, a2 = 0, day = 0, zapas = 0;
    cin>>n>>m>>k;

    int *a = new int[n];

    for (int i = 0; i < n; i++)
    {
        cin>>a[i];
        (a[i] == 1) ? ++a1 : ++a2;
    }

    if (a1 > m)
        day += a1 - m;
    else
        zapas = m - a1;

    if(a2 > k)
        day += a2 - k;

    if(day == 0)
        cout << 0;
    else
        cout << day - zapas;

    delete[] a;
    return 0;
}


#include <iostream>
using namespace std;

int main()
{
    unsigned int n, m, k, a1 = 0, a2 = 0, day = 0, zapas = 0;
    cin>>n>>m>>k;

    unsigned int *a = new unsigned int[n];

    for (int i = 0; i < n; i++)
    {
        cin>>a[i];
        (a[i] == 1) ? ++a1 : ++a2;
    }

    if (a1 > m)
        day += a1 - m;
    else
        zapas = m - a1;

    if(a2 > k)
        day += a2 - k;

    if(day == 0)
        cout << 0;
    else
        cout << day - zapas;

    delete[] a;
    return 0;
}


#include <iostream>
using namespace std;

int main()
{
    unsigned int n, m, k, a1 = 0, a2 = 0, day = 0, zapas = 0;
    cin>>n;
    cin>>m;
    cin>>k;

    unsigned int *a = new unsigned int[n];

    for (int i = 0; i < n; i++)
    {
        cin>>a[i];
        (a[i] == 1) ? a1++ : a2++;
    }

    if (a1 > m)
        day += a1 - m;
    else
        zapas = m - a1;

    if(a2 > k)
        day += a2 - k;

    if(day != 0)
        cout << day - zapas;
    else
        cout << 0;

    delete[] a;
    return 0;
}


#include <iostream>
#include <string>
using namespace std;

int main(){
    int n , b , p , z, d=0;
    cin>>n>>b>>p;
for(int i=0 ; i<n; i++){
    cin>>z;
if(z==1){
    if(b==0){
        d++;
    }else{
        b--;
    }
}else{
    if(b==0&&p==0)
        d++;
    else if(b>p)
    b--;
    else if(p>=b)
        p--;
}
}
cout<<d<<endl;
return 0;
}


#include <iostream>

using namespace std;

int main(){
    int n , b , p , z, d=0;
    cin>>n>>b>>p;
for(int i=0 ; i<n; i++){
    cin>>z;
if(z==1){
    if(b==0){
        d++;
    }else{
        b--;
    }
}else{
    if(b==0&&p==0)
        d++;
    else if(p!=0)
        p--;
     else
    {b--;}
}
}
cout<<d<<endl;
return 0;
}


#include <iostream>
#include <string>
using namespace std;

int main(){
    int n , b , p , z, d=0;
    cin>>n>>b>>p;
for(int i=0 ; i<n; i++){
    cin>>z;
if(z==1){
    if(b==0){
        d++;
    }else{
        b--;
    }
}else{
    if(b==0){
        if(p==0){
            d++;
        }else{
            p--;
        }
    }else if(p==0){
        if(b==0){
            d++;
        }
    }else{
        if(b>p)
            b--;
        else
            p--;
    }
}
}
cout<<d<<endl;
return 0;
}

/*  long long x,sum=0,n,z=1;
    cin>>x;
    n=x;
    if(x>10){
    while(n/10 > 0){
         z*=10;
         n/=10;
    }
        sum = (n*z*-5)/10;
      cout<<n*z<<endl;
    for(long long i=z*n; i<=x ; i++){
       if(i%2==0)
        sum+=i;
       else
        sum = sum-i;
    }
}else{
    for(int i=0; i<=x ; i++){
       if(i%2==0)
        sum+=i;
       else
        sum = sum-i;
    }
}
    cout<<sum<<endl;*/


#include <iostream>
#include <string>
using namespace std;

int main(){
    int n , b , p , z, d=0;
    cin>>n>>b>>p;
for(int i=0 ; i<n; i++){
    cin>>z;
if(z==1){
    if(b==0){
        d++;
    }else{
        b--;
    }
}else{
    if(b==0&&p==0)
        d++;
    else if(b>=p)
    b--;
    else if(p>b)
        p--;
}
}
cout<<d<<endl;
return 0;
}


#include <iostream>
#include <string>
using namespace std;

int main(){
    int n , b , p , z, d=0;
    cin>>n>>b>>p;
for(int i=0 ; i<n; i++){
    cin>>z;
if(z==1){
    if(b==0){
        d++;
    }else{
        b--;
    }
}else{
    if(b==0&&p==0)
        d++;
    else if(p!=0)
        p--;
     else
    {b--;}
}
}
cout<<d<<endl;
return 0;
}


#include <iostream>
#include <string>
#include <vector>

using namespace std;

int main(){
    int n , m , k;
    scanf("%d %d %d",&n , &m , &k);
    int counter = 0;
    for(int i = 1 ; i <= n ; i++){
        int y;
        cin >> y;
        if(y==1){
            if(m==0){
                counter++;
                m++;
            }
            m--;
        }
        else if(y==2){
            if(k==0 && m == 0){
                counter++;
                k++;
            }
            if(m > 2)
                m--;
            else{
                k--;
            }
        }
    }
    printf("%d\n",counter);
    return 0;
}


#include <iostream>
#include <string>
#include <vector>
#include <stdio.h>
using namespace std;

int main(){
    int n , m , k;
    scanf("%d %d %d",&n , &m , &k);
    int counter = 0;
    for(int i = 1 ; i <= n ; i++){
        int y;
        cin >> y;
        if(y==1){
            if(m==0){
                counter++;
                m++;
            }
            m--;
        }
        else if(y==2){
            if(k==0 && m == 0){
                counter++;
                k++;
            }
            if(m > 1)
                m--;
            else{
                k--;
            }
        }
    }
    printf("%d\n",counter);
    return 0;
}


#include <iostream>
#include <string>
#include <vector>
#include <stdio.h>
using namespace std;

int main(){
    int counter1 =0;
    int counter2 = 0;
    int m_cleanBowls,k_cleanPlates,n_days;
    scanf("%d %d %d",&n_days,&m_cleanBowls,&k_cleanPlates);
    for(int i = 0 ; i < n_days;i++){
        int a;
        scanf("%d",&a);
        if(a == 1){
            if(m_cleanBowls==0){
                counter1++;
            }
            else{
                m_cleanBowls--;
            }
        }
        else if(a == 2){
            if(k_cleanPlates == 0){
                if(m_cleanBowls==0){
                counter2++;
                }
                else{
                    counter1++;
                }
            }
            else{
                k_cleanPlates--;
            }

        }
    }

    cout << counter1 + counter2 << endl;
    return 0;
}


#include <iostream>
#include <string>
#include <vector>

using namespace std;

int main(){
    int n , m , k;
    scanf("%d %d %d",&n , &m , &k);
    int counter = 0;
    for(int i = 1 ; i <= n ; i++){
        int y;
        cin >> y;
        if(y==1){
            if(m==0){
                counter++;
                m++;
            }
            m--;
        }
        else if(y==2){
            if(k==0 && m == 0){
                counter++;
                k++;
            }
            if(m > 1)
                m--;
            else{
                k--;
            }
        }
    }
    printf("%d\n",counter);
    return 0;
}


#include <iostream>
#include <string>
#include <vector>
#include <stdio.h>
using namespace std;

int main(){
    int m , k , n;
    cin >> n >> m >> k;
    int counter = 0;
    for(int i = 0 ; i < n ; i++){
        int a;
        cin >> a;
        if(a==1){
            if(m == 0){
                counter++;
            }
            else{
            m--;
            }
        }
        else {
            if(k!=0){
                k--;
            }
            else if (m!=0){
                m--;
            }
            else if(k== 0){
                    counter++;
                    }
            }
        }
    cout << counter << endl;
    return 0;
}


#include <iostream>
#include <string>
#include <vector>
#include <stdio.h>
using namespace std;

int main(){
    int m , k , n;
    cin >> n >> m >> k;
    int counter = 0;
    for(int i = 0 ; i < n ; i++){
        int a;
        cin >> a;
        if(a==1){
            if(m == 0){
                counter++;
            }
            else{
            m--;
            }
        }
        else {
                if(k== 0){
                    counter++;
                    }
                else if (m!=0){
                    m--;
                }
                else if(k!=0){
                    k--;
                }
            }
        }
    cout << counter << endl;
    return 0;
}


#include <iostream>
#include <string>
#include <vector>
#include <stdio.h>
using namespace std;

int main(){
    int counter1 =0;
    int counter2 = 0;
    int m_cleanBowls,k_cleanPlates,n_days;
    scanf("%d %d %d",&n_days,&m_cleanBowls,&k_cleanPlates);
    for(int i = 0 ; i < n_days;i++){
        int a;
        scanf("%d",&a);
        if(a == 1){
            if(m_cleanBowls==0){
                counter1++;
            }
            else{
                m_cleanBowls--;
            }
        }
        else if(a == 2){
            if(k_cleanPlates == 0){
                if(m_cleanBowls==0){
                counter2++;
                }
            }
            else{
                k_cleanPlates--;
            }

        }
    }

    cout << counter1 + counter2 << endl;
    return 0;
}


#include <iostream>
#include <string>
#include <vector>
#include <stdio.h>
using namespace std;

int main(){
    int counter1 =0;
    int counter2 = 0;
    int m_cleanBowls,k_cleanPlates,n_days;//first types from bowls second diish bowls or plates
    int m = m_cleanBowls;
    int k = k_cleanPlates;
    scanf("%d %d %d",&n_days,&m_cleanBowls,&k_cleanPlates);
    for(int i = 0 ; i < n_days;i++){
        int a;
        scanf("%d",&a);
        if(a == 1){
            counter1++;
            m--;
        }
        else if(a == 2){
            if(k_cleanPlates != 0){
                k--;
            counter2++;
            }
            else{
                counter1++;
                m--;
            }

        }
    }
    if(counter2 == 0){
        cout << counter1 - m_cleanBowls << endl;
    }
       else{
        cout << counter1 - m_cleanBowls + counter2 - k_cleanPlates << endl;
    }
    return 0;
}


#include <iostream>
#include <string>
#include <vector>
#include <stdio.h>
using namespace std;

int main(){
    int n , m , k;
    scanf("%d %d %d",&n , &m , &k);
    int counter = 0;
    for(int i = 1 ; i <= n ; i++){
        int y;
        cin >> y;
        if(y==1){
            if(m==0){
                counter++;
                m++;
            }
            m--;
        }
        else if(y==2){
            if(k==0 && m == 0){
                counter++;
                k++;
            }
            if(m > 2)
                m--;
            else{
                k--;
            }
        }
    }
    printf("%d\n",counter);
    return 0;
}


#include <iostream>
#include <string>
#include <vector>
#include <stdio.h>
using namespace std;

int main(){
    int n , m , k;
    scanf("%d %d %d",&n , &m , &k);
    int counter = 0;
    for(int i = 1 ; i <= n ; i++){
        int y;
        cin >> y;
        if(y==1){
            if(m==0){
                counter++;
                m++;
            }
            m--;
        }
        else if(y==2){
            if(k==0 && m == 0){
                counter++;
                k++;
            }
            if(m > 3)
                m--;
            else{
                k--;
            }
        }
    }
    printf("%d\n",counter);
    return 0;
}


#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <string>
#include <algorithm>
#include <time.h>
//#include <math.h>
#include <cmath>
#include <fstream>
#include <deque>
#include <unordered_map>
#include <unordered_set>
#include <stdlib.h>
#include <iomanip>
#include <cstdio>
#include <cassert>
#include <bitset>
#pragma comment(linker, "/STACK:36777216")
using namespace std;

#define flu fflush(stdout)
#define gg return 0
#define mp make_pair

long long mod = /*27449*//*998244353*/ 1e9 + 7 /*1e9 + 9*/;
long long inf = 1e9;
long double eps = 1e-7;
long double pi = acosl(-1);
ifstream in("input.txt");
ofstream out("output.txt");

int main()
{
	int r, s, p;
	cin >> r >> s >> p;
	vector<vector<vector<double>>> dp(r + 1, vector<vector<double>>(s + 1, vector<double>(p + 1, 0)));
	dp[r][s][p] = 1;
	for (int i = r; i >= 0; i--)
	{
		for (int j = s; j >= 0; j--)
		{
			for (int k = p; k >= 0; k--)
			{
				double v1 = i * j;
				double v2 = i * k;
				double v3 = j * k;
				if (i > 0 && j > 0)
				{
					dp[i][j - 1][k] += dp[i][j][k]  * v1 / (v1 + v2 + v3);
				}
				if (i > 0 && k > 0)
				{
					dp[i - 1][j][k] += dp[i][j][k] * v2 / (v1 + v2 + v3);
				}
				if (k > 0 && j > 0)
				{
					dp[i][j][k - 1] += dp[i][j][k] * v3 / (v1 + v2 + v3);
				}
			}
		}
	}
	double ra = 0, sa = 0, pa = 0;
	for (int i = 1; i <= r; i++)
	{
		ra += dp[i][0][0];
	}
	for (int i = 1; i <= s; i++)
	{
		sa += dp[0][i][0];
	}
	for (int i = 1; i <= p; i++)
	{
		pa += dp[0][0][i];
	}
	cout << setprecision(20) << fixed;
	cout << ra << " " << sa << " " << pa;
	gg;
}


#include <iostream>
#include <string>
#include <cstdio>
#include <cmath>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <sstream>
#include <algorithm>
using namespace std;
#define rep(_m,s,e) for(int _m=s;_m<e;_m++)
typedef long long ll;
int  toInt(string s)   {int r=0; istringstream sin(s); sin>>r; return r;}
ll   toInt64(string s) {ll r=0; istringstream sin(s); sin>>r; return r;}
double  toDouble(string s){double r=0; istringstream sin(s); sin>>r; return r;}
string toString(ll n) {string s,s1; while (n / 10 > 0){ s += (char)((n%10) + 48); n/=10;} s += (char)((n%10) + 48); n/=10; s1 = s; rep(i,0,s.length()) s1[(s.length()-1)-i] = s[i]; return s1;}
bool isUpperCase(char c){return c >= 'A' && c <= 'Z';}
bool isLowerCase(char c){return c >= 'a' && c <= 'z';}
bool isLetter(char c)   {return c >= 'A' && c <= 'Z' || c >= 'a' && c <= 'z';}
bool isDigit(char c)    {return c >= '0' && c <= '9';}
char toLowerCase(char c){return (isUpperCase(c))?(c + 32) : c;}
char toUpperCase(char c){return (isLowerCase(c))?(c - 32) : c;}
ll gcd(ll a, ll b) {if(!a) return b; return gcd(b%a, a);}

struct Data{
	double r,s,p;
	Data(double a, double b, double c){r = a; s = b; p = c;}
	Data(){r = s = p = 0;}
};

bool mark[101][101][101];
Data mem[101][101][101];

bool onlyOne(Data input)
{
	if (input.r == 0 && input.s == 0 && input.p != 0)
		return 1;
	if (input.r == 0 && input.s != 0 && input.p == 0)
		return 1;
	if (input.r != 0 && input.s == 0 && input.p == 0)
		return 1;
	return 0;
}

Data theOne(Data input)
{
	if (input.r == 0 && input.s == 0 && input.p != 0)
		return Data(0,0,1);
	if (input.r == 0 && input.s != 0 && input.p == 0)
		return Data(0,1,0);
	if (input.r != 0 && input.s == 0 && input.p == 0)
		return Data(1,0,0);
}

Data solve(Data input)
{
	Data ans;
	if (mark[(int)input.r][(int)input.s][(int)input.p])
		return mem[(int)input.r][(int)input.s][(int)input.p];
	if (onlyOne(input))
		return theOne(input);
	double total = input.r*input.s + input.s*input.p + input.p*input.r;
	double prop;
	Data ret;
	//r-s
	prop = input.r * input.s; prop /= total;
	if (prop > 0)
		ret = solve(Data(input.r, input.s-1, input.p));
	ans.r += prop * ret.r;
	ans.s += prop * ret.s;
	ans.p += prop * ret.p;

	//r-p
	prop = input.r * input.p; prop /= total;
	if (prop > 0)
		ret = solve(Data(input.r-1, input.s, input.p));
	ans.r += prop * ret.r;
	ans.s += prop * ret.s;
	ans.p += prop * ret.p;

	//s-p
	prop = input.p * input.s; prop /= total;
	if (prop > 0)
		ret = solve(Data(input.r, input.s, input.p-1));
	ans.r += prop * ret.r;
	ans.s += prop * ret.s;
	ans.p += prop * ret.p;

	mark[(int)input.r][(int)input.s][(int)input.p] = 1;
	mem[(int)input.r][(int)input.s][(int)input.p] = ans;
	return ans;
}

int main()
{
	ios::sync_with_stdio(0);
	cin.tie(0);
	int r,p,s;
	cin >> r >> s >> p;
	mem[0][1][1] = Data(0,1,0);
	mem[1][0][1] = Data(0,0,1);
	mem[1][1][0] = Data(1,0,0);
	mark[0][1][1] = mark[1][1][0] = mark[1][0][1] = 1;
	Data ans = solve(Data(r,s,p));
	double R = ans.r, S = ans.s, P = ans.p;
	printf("%0.9f", R);
	cout << ' ';

		printf("%0.9f", S);
		cout << ' ';
		printf("%0.9f", P);
		cout << endl;

}


#include<iostream>
#include<iomanip>
using namespace std;

double dp1[101][101][101], dp2[101][101][101], dp3[101][101][101];

double solve(int r, int s, int p, double memo[101][101][101]) {
	if (r == 0 || s == 0) return 0;
	if (p == 0) return 1;

	if (dp1[r][s][p] != 0) return dp1[r][s][p];

	double total = r * s + r * p + s * p;

	dp1[r][s][p] = r*s/total * solve(r, s-1, p, memo) + r*p/total * solve(r-1, s, p, memo) + s*p/total * solve(r, s, p-1, memo);
	return dp1[r][s][p];
}

int main() {
	int r, s, p;
	cin >> r >> s >> p;

	cout << setprecision(10) << fixed;
	cout << solve(r, s, p, dp1) << " " << solve(s, p, r, dp2) << " " << solve(p, r, s, dp3) << "\n";

	return 0;
}


#include<iostream>
#include<algorithm>
#include<fstream>
using namespace std;

typedef long double ld;

const int n = 105;
ld arr[n][n][n];

void main()
{
	/*ifstream in("in.txt");*/
	int R, S, P;
	cin >> R >> S >> P;
	arr[R][S][P] = 1;
	for (int r = R; r >= 0; r--)
	{
		for (int s = S; s >= 0; s--)
		{
			for (int p = P; p >= 0; p--)
			{
				if (p == 0 && r == 0) continue;
				if (p == 0 && s == 0) continue;
				if (s == 0 && r == 0) continue;
				ld cur = arr[r][s][p];
				int WaysS = s*p;
				int WaysR = r*s;
				int WaysP = p*r;
				int totalWays = WaysP + WaysR + WaysS;
				if (r > 0) arr[r - 1][s][p] += cur*WaysP / totalWays;
				if (s> 0) arr[r][s-1][p] += cur*WaysR / totalWays;
				if (p > 0) arr[r][s][p-1] += cur*WaysS/ totalWays;
			}
		}
	}
	ld AnsS = 0, AnsR = 0, AnsP = 0;
	for (int r = R; r >= 1; r--) AnsR += arr[r][0][0];
	for (int p = P; p >= 1; p--) AnsP += arr[0][0][p];
	for (int s = S; s >= 1; s--) AnsS += arr[0][s][0];
	printf("%.12f %.12f %.12f\n", (double)AnsR, (double)AnsS, (double)AnsP);
	/*system("pause");*/
}


#include <iostream>
#include <set>
#include <vector>
#include <string>
#include <algorithm>
#include <queue>
#include <set>
#include <cstring>
#include <map>
#include <bitset>
#include <random>

using namespace std;

#define ll long long
#define sc second
#define fs first
#define mp make_pair

ll a, b, c;
double dp[111][111][111], aa, ab, ac;

int main()
{
	memset(dp, 0, sizeof(dp));
	cin >> a >> b >> c;
	dp[a][b][c] = 1.0;
	for (int i = a; i > -1; i--){
		for (int j = b; j > -1; j--){
			for (int k = c; k > -1; k--){
				double sm = i*j + i*k + k*j;
				if (sm == 0) break;
				double t;
				if (i&&k)
					dp[i - 1][j][k] += dp[i][j][k] * (double)(i*k) / sm;
				if (j && i)
					dp[i][j - 1][k] += dp[i][j][k] * (double)(j*i) / sm;
				if (j && k)
					dp[i][j][k-1] += dp[i][j][k] * (double)(j*k) / sm;
			}
		}
	}
	for (int i = 0; i <= a; i++)
		aa += dp[i][0][0];
	for (int i = 0; i <= b; i++)
		ab += dp[0][i][0];
	for (int i = 0; i <= c; i++)
		ac += dp[0][0][i];
	cout.precision(10);
	cout << fixed << aa << ' ' << fixed << ab << ' ' << fixed << ac << endl;
	return 0;
}


#include <iostream>
#include <set>
#include <vector>
#include <string>
#include <algorithm>
#include <queue>
#include <set>
#include <cstring>
#include <map>
#include <bitset>
#include <random>

using namespace std;

#define ll long long
#define sc second
#define fs first
#define mp make_pair

ll a, b, c;
double dp[111][111][111], aa, ab, ac;

int main()
{
	memset(dp, 0, sizeof(dp));
	cin >> a >> b >> c;
	dp[a][b][c] = 1.0;
	for (int i = a; i > -1; i--){
		for (int j = b; j > -1; j--){
			for (int k = c; k > -1; k--){
				double sm = i*j + i*k + k*j;
				if (sm == 0) break;
				double t;
				dp[i - 1][j][k] += dp[i][j][k] * (double)(i*k) / sm;
				dp[i][j - 1][k] += dp[i][j][k] * (double)(j*i) / sm;
				dp[i][j][k-1] += dp[i][j][k] * (double)(j*k) / sm;
			}
		}
	}
	for (int i = 0; i <= a; i++)
		aa += dp[i][0][0];
	for (int i = 0; i <= b; i++)
		ab += dp[0][i][0];
	for (int i = 0; i <= c; i++)
		ac += dp[0][0][i];
	cout.precision(10);
	cout << fixed << aa << ' ' << fixed << ab << ' ' << fixed << ac << endl;
	return 0;
}


#include <iostream>
#include <algorithm>
#include <functional>
#include <vector>
#include <map>
#include <cstdio>
#include <string>
#include <queue>
#include <stack>
#include <math.h>
#include <cstring>
using namespace std;

int rock, scissor, paper;
double dp[110][110][110];

double sol(int r, int s, int p) {

    if ((s|p) == 0) return 1.0;
    else if ((r|s) == 0) return 0.0;
    else if ((r|p) == 0) return 0.0;

    double &ret = dp[r][s][p];
    if (ret != 0.0) return ret;

    double prob = 1.0 / (r*s + s*p + p*r)*1.0;

    if (r&&s) ret += sol(r, s-1, p)*prob*r*s;
    if (s&&p) ret += sol(r, s , p-1)*prob*s*p;
    if (p&&r) ret += sol(r-1, s, p)*prob*p*r;

    return ret;
}

int main()
{
#ifdef _CONSOLE
    freopen("input.txt", "r", stdin);
#endif

    //ios::sync_with_stdio(false);

    cin >> rock >> scissor >> paper;

    cout.precision(12);
    cout << fixed;

    cout << sol(rock, scissor, paper) << " ";
    cout << sol(scissor, paper, rock) << " ";
    cout << sol(paper, rock, scissor) << " ";

    cout << endl;
}


#include <iostream>
#include <algorithm>
#include <functional>
#include <vector>
#include <map>
#include <cstdio>
#include <string>
#include <queue>
#include <stack>
#include <math.h>
#include <cstring>
using namespace std;

int rock, scissor, paper;
double dp[110][110][110];

double sol(int r, int s, int p) {

    if ((s|p) == 0) return 1.0;
    else if ((r|s) == 0) return 0.0;
    else if ((r|p) == 0) return 0.0;

    double &ret = dp[r][s][p];
    if (ret != 0.0) return ret;

    double prob = 1.0 / (r*s + s*p + p*r)*1.0;

    if (r&&s) ret += sol(r, s-1, p)*prob*r*s;
    if (s&&p) ret += sol(r, s , p-1)*prob*s*p;
    if (p&&r) ret += sol(r-1, s, p)*prob*p*r;

    return ret;
}

int main()
{
#ifdef _CONSOLE
    freopen("input.txt", "r", stdin);
#endif

    //ios::sync_with_stdio(false);

    cin >> rock >> scissor >> paper;

    cout.precision(12);
    cout << fixed;

    cout << sol(rock, scissor, paper) << " ";
    for (int i = 0; i < 110; i++)
        for (int j = 0; j < 110; j++)
            for (int k = 0; k < 110; k++)
                dp[i][j][k] = 0.0;
    cout << sol(scissor, paper, rock) << " ";
    for (int i = 0; i < 110; i++)
        for (int j = 0; j < 110; j++)
            for (int k = 0; k < 110; k++)
                dp[i][j][k] = 0.0;
    cout << sol(paper, rock, scissor) << " ";

    cout << endl;
}


#include<stdio.h>
#include<string.h>
#include<vector>
#include<algorithm>
using namespace std;
double dp[101][101][101];
double ff(int r,int s,int p)
{
    if(r==0||s==0)return 0.0;
    if(p==0)return 1.0;
    double a=r*s;
    double b=s*p;
    double c=p*r;
    double sum=a+b+c;
    return dp[r][s][p]=a/sum*ff(r,s-1,p)+b/sum*ff(r,s,p-1)+c/sum*ff(r-1,s,p);
}
int main()
{
    int r,s,p;
    memset(dp,0,sizeof(dp));
    scanf("%d%d%d",&r,&s,&p);
    printf("%.9lf %.9lf %.9lf\n",ff(r,s,p),ff(s,p,r),ff(p,r,s));
    return 0;
}


#include<stdio.h>
#include<string.h>
#include<vector>
#include<algorithm>
using namespace std;
double dp[101][101][101];
int vis[101][101][101];
double ff(int r,int s,int p)
{
    if(vis[r][s][p])return dp[r][s][p];
    vis[r][s][p]=1;
    if(r==0||s==0)return 0.0;
    if(p==0)return 1.0;
    double a=r*s;
    double b=s*p;
    double c=p*r;
    double sum=a+b+c;
    return dp[r][s][p]=a/sum*ff(r,s-1,p)+b/sum*ff(r,s,p-1)+c/sum*ff(r-1,s,p);
}
int main()
{
    int r,s,p;
    memset(dp,0,sizeof(dp));
    scanf("%d%d%d",&r,&s,&p);
    printf("%.9lf %.9lf %.9lf\n",ff(r,s,p),ff(s,p,r),ff(p,r,s));
    return 0;
}


#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
#include<vector>
#include<set>
#include<list>
#include<queue>
#include<cmath>
#include<functional>
#include<algorithm>
#define INF (1<<29)
#define rep(i,n) for(int i=0;i<(int)(n);i++)
using namespace std;

double dp[101][101][101];

int main(){
    ios::sync_with_stdio(0);
    cin.tie(0);

    int r,s,p;
    cin>>r>>s>>p;
    dp[r][s][p]=1;
    for(int i=r;i>=0;i--){
        for(int j=s;j>=0;j--){
            for(int k=p;k>=0;k--){
                double v=dp[i][j][k];
                double m=i*j+j*k+k*i;
                if(i&&j){
                    dp[i][j-1][k]+=v*i*j/m;
                }
                if(j&&k){
                    dp[i][j][k-1]+=v*j*k/m;
                }
                if(i&&k){
                    dp[i-1][j][k]+=v*i*k/m;
                }
            }
        }
    }
    double a=0,b=0,c=0;
    for(int i=r;i>=0;i--)a+=dp[i][0][0];
    for(int j=s;j>=0;j--)b+=dp[0][j][0];
    for(int k=p;k>=0;k--)c+=dp[0][0][k];
    printf("%.9f %.9f %.9f\n",a,b,c);
    return 0;
}


#include<cstring>
#include<cstdlib>
#include<iostream>
#include<stdio.h>
#include<cmath>
#include<algorithm>
#include<vector>
using namespace std;
#define N 100010
#define MOD 1000000007
#define LL long long

struct node
{
    double x;
    double y;
    double z;

    double v;
};

node dp[105][105][105];
double c[305][3];

void init()
{
    c[0][0]=1;
    for(int i=1;i<=100;i++)
    {
        c[i][0]=1;
        for(int j=1;j<=i&&j<=2;j++){
            c[i][j]=c[i-1][j]+c[i-1][j-1];
        }
    }
}

void DP(int x,int y,int z)
{
    if(dp[x][y][z].v)
        return ;
    dp[x][y][z].v=1;
    if(x==0&&y==0)
    {
        dp[x][y][z].z=1;
        return ;
    }
    if(z==0&&y==0)
    {
        dp[x][y][z].x=1;
        return ;
    }
    if(x==0&&z==0)
    {
        dp[x][y][z].y=1;
        return ;
    }
    double tot=c[x+y+z][2]-c[x][2]-c[y][2]-c[z][2];
    if(x>0&&y>0)
    {
        double q=x*y/tot;
        DP(x,y-1,z);
        dp[x][y][z].x+=q*dp[x][y-1][z].x;
        dp[x][y][z].y+=q*dp[x][y-1][z].y;
        dp[x][y][z].z+=q*dp[x][y-1][z].z;
    }

    if(x>0&&z>0)
    {
        double q=x*z/tot;
        DP(x-1,y,z);
        dp[x][y][z].x+=q*dp[x-1][y][z].x;
        dp[x][y][z].y+=q*dp[x-1][y][z].y;
        dp[x][y][z].z+=q*dp[x-1][y][z].z;
    }

    if(y>0&&z>0)
    {
        double q=z*y/tot;
        DP(x,y,z-1);
        dp[x][y][z].x+=q*dp[x][y][z-1].x;
        dp[x][y][z].y+=q*dp[x][y][z-1].y;
        dp[x][y][z].z+=q*dp[x][y][z-1].z;
    }
}

int main()
{
    init();
    int x,y,z;
    scanf("%d%d%d",&x,&y,&z);
    DP(x,y,z);
    printf("%.12lf %.12lf %.12lf\n",dp[x][y][z].x,dp[x][y][z].y,dp[x][y][z].z);
    return 0;
}


#include<cstring>
#include<cstdlib>
#include<iostream>
#include<stdio.h>
#include<cmath>
#include<algorithm>
#include<vector>
using namespace std;
#define N 100010
#define MOD 1000000007
#define LL long long

struct node
{
    double x;
    double y;
    double z;

    double v;
};

node dp[105][105][105];
double c[305][3];

void init()
{
    c[0][0]=1;
    for(int i=1;i<=300;i++)
    {
        c[i][0]=1;
        for(int j=1;j<=i&&j<=2;j++){
            c[i][j]=c[i-1][j]+c[i-1][j-1];
        }
    }
}

void DP(int x,int y,int z)
{
    if(dp[x][y][z].v)
        return ;
    dp[x][y][z].v=1;
    if(x==0&&y==0)
    {
        dp[x][y][z].z=1;
        return ;
    }
    if(z==0&&y==0)
    {
        dp[x][y][z].x=1;
        return ;
    }
    if(x==0&&z==0)
    {
        dp[x][y][z].y=1;
        return ;
    }
    double tot=c[x+y+z][2]-c[x][2]-c[y][2]-c[z][2];
    if(x>0&&y>0)
    {
        double q=x*y/tot;
        DP(x,y-1,z);
        dp[x][y][z].x+=q*dp[x][y-1][z].x;
        dp[x][y][z].y+=q*dp[x][y-1][z].y;
        dp[x][y][z].z+=q*dp[x][y-1][z].z;
    }

    if(x>0&&z>0)
    {
        double q=x*z/tot;
        DP(x-1,y,z);
        dp[x][y][z].x+=q*dp[x-1][y][z].x;
        dp[x][y][z].y+=q*dp[x-1][y][z].y;
        dp[x][y][z].z+=q*dp[x-1][y][z].z;
    }

    if(y>0&&z>0)
    {
        double q=z*y/tot;
        DP(x,y,z-1);
        dp[x][y][z].x+=q*dp[x][y][z-1].x;
        dp[x][y][z].y+=q*dp[x][y][z-1].y;
        dp[x][y][z].z+=q*dp[x][y][z-1].z;
    }
}

int main()
{
    init();
    int x,y,z;
    scanf("%d%d%d",&x,&y,&z);
    DP(x,y,z);
    printf("%.12lf %.12lf %.12lf\n",dp[x][y][z].x,dp[x][y][z].y,dp[x][y][z].z);
    return 0;
}


#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <cassert>
#include <iomanip>
#include <set>
#include <map>
#include <algorithm>
#include <math.h>
#include <ctime>
#include <cmath>
#include <stack>

using namespace std;

#define mp make_pair
#define sz size()
#define all(x) x.begin(), x.end()
#define forn(i,n) for(int i = 0; i<int(n); i++)
#define sqr(x) ((x)*(x))
#define sgn(x) ((x)<0 ? -1 : (((x) == 0) ? 0 : 1))
typedef long long ll;
typedef long double ld;
typedef pair<int, int> ii;
const ll INF = 1e9 + 7;
const ld EPS = 1e-10;
#define y1 jkghsfgdspfgsd
#define X first
#define Y second

const int NUM = 107;
ld dp[NUM][NUM][NUM];

void init(){
    for (int i = 0; i < NUM; i++){
        for (int j = 0; j < NUM; j++){
            for (int k = 0; k < NUM; k++){
                dp[i][j][k] = -1;
            }
        }
    }
}

ld f(int a, int b, int c){
    if (a < 0 || b < 0 || c < 0)
        return 0;
    if (a == 0)
        return 0;
    if (b == 0 && c == 0)
        return dp[a][b][c] = 1;
    if (dp[a][b][c]>-0.5)
        return dp[a][b][c];

    dp[a][b][c] = 0;
    ld koefa, koefb, koefc;

    koefa = ((ld)(a + c)) / ((ld)(a + b + c));
    dp[a][b][c] += koefa*koefa*f(a - 1, b, c);

    koefb = ((ld)(a + b)) / ((ld)(a + b + c));
    dp[a][b][c] += koefb*koefb*f(a, b-1, c);

    koefc = ((ld)(b + c)) / ((ld)(a + b + c));
    dp[a][b][c] += koefc*koefc*f(a, b, c-1);

    if (dp[a][b][c] > 1.0)
        dp[a][b][c] = 1.0;
    return dp[a][b][c];
}

#define DEBUG
int main(){
#ifdef DEBUG
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
#endif

    int a, b, c;
    cin >> a >> b >> c;

    init();
    cout << fixed << setprecision(9) << f(a, b, c) << " ";
    init();
    cout << fixed << setprecision(9) << f(c, a, b) << " ";
    init();
    cout << fixed << setprecision(9) << f(b, c, a) << " ";

#ifdef DEBUG
    cerr << "Time elapsed: " << (ld)clock() / CLOCKS_PER_SEC << " sec." << endl;
#endif
    return 0;
}


#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <cassert>
#include <iomanip>
#include <set>
#include <map>
#include <algorithm>
#include <math.h>
#include <ctime>
#include <cmath>
#include <stack>

using namespace std;

#define mp make_pair
#define sz size()
#define all(x) x.begin(), x.end()
#define forn(i,n) for(int i = 0; i<int(n); i++)
#define sqr(x) ((x)*(x))
#define sgn(x) ((x)<0 ? -1 : (((x) == 0) ? 0 : 1))
typedef long long ll;
typedef long double ld;
typedef pair<int, int> ii;
const ll INF = 1e9 + 7;
const ld EPS = 1e-10;
#define y1 jkghsfgdspfgsd
#define X first
#define Y second

const int NUM = 107;
ld dp[NUM][NUM][NUM];
void init(){
    for (int i = 0; i < NUM; i++){
        for (int j = 0; j < NUM; j++){
            for (int k = 0; k < NUM; k++){
                dp[i][j][k] = 0;
            }
        }
    }
}

//#define DEBUG
int main(){
#ifdef DEBUG
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
#endif

    init();
    int aa, bb, cc;
    cin >> aa >> bb >> cc;
    dp[aa][bb][cc] = 1;

    for (int a = aa; a >= 0; a--){
        for (int b = bb; b >= 0; b--){
            for (int c = cc; c >= 0; c--){
                if (a*b + b*c + a*c == 0)
                    continue;
                if (a != 0){
                    dp[a - 1][b][c] += dp[a][b][c] * ((ld)(a*c) / ((ld)(a*b + b*c + a*c)));
                }
                if (b != 0){
                    dp[a][b - 1][c] += dp[a][b][c] * ((ld)(a*b) / ((ld)(a*b + b*c + a*c)));
                }
                if (c != 0){
                    dp[a][b][c - 1] += dp[a][b][c] * ((ld)(b*c) / ((ld)(a*b + b*c + a*c)));
                }
            }
        }
    }

    ld sa = 0, sb = 0, sc = 0;
    for (int a = 1; a <= aa; a++){
        sa += dp[a][0][0];
    }
    for (int b = 1; b <= bb; b++){
        sb += dp[0][b][0];
    }
    for (int c = 0; c <= cc; c++){
        sc += dp[0][0][c];
    }

    cout << fixed << setprecision(9) << sa << " "<<sb << " " << sc;

#ifdef DEBUG
    cerr << "Time elapsed: " << (ld)clock() / CLOCKS_PER_SEC << " sec." << endl;
#endif
    return 0;
}


#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <vector>
#include <set>
#include <queue>
#include <algorithm>
#include <cmath>
#define pb push_back
#define mp make_pair
#define re return
#define cont continue
#define xx first
#define yy second
using namespace std;

template <typename T>
void disp(T& x) {
    for (typename T::iterator it = x.begin(); it != x.end(); it++)
        cout << *it << ' ';
    cout << endl;
}

double mas[305][305][305];

int main() {
    //freopen("input.txt","r",stdin);
    //freopen("output.txt","w",stdout);

    int a,b,c;
    cin >> a >> b >> c;

    mas[a][b][c] = 1;
    int sum = a+b+c;

    for (int s = sum; s >= 1; s--)
        for (int a = 0; a <= s; ++a)
            for (int b = 0; b <= s-a; ++b) {
                int c = s-a-b;
                if (a+b == 0 || b+c == 0 || a+c == 0) cont;
                double d = a*b + b*c + a*c;
                if (b > 0) mas[a][b-1][c] += (mas[a][b][c]) * (a*b / d);
                if (c > 0) mas[a][b][c-1] += (mas[a][b][c]) * (b*c / d);
                if (a > 0) mas[a-1][b][c] += (mas[a][b][c]) * (a*c / d);
            }

    double aa,bb,cc;
    aa = 0;
    bb = 0;
    cc = 0;

    for (int a = 1; a <= 100; ++a)
        aa += mas[a][0][0];

    for (int b = 1; b <= 100; ++b)
        bb += mas[0][b][0];

    for (int c = 1; c <= 100; ++c)
        cc += mas[0][0][c];

    printf("%.9lf %.9lf %.9lf",aa,bb,cc);

    /*for (int a = 0; a <= 2; ++a)
        for (int b = 0; b <= 2; ++b)
            for (int c = 0; c <= 2; ++c)
                cout << a <<' '<< b << ' ' << c << " : " << mas[a][b][c] << endl;*/

    return 0;
}


#include<stdio.h>
#include<vector>
#include<algorithm>
#include<math.h>
#include<string>
#include<map>
using namespace std;
#define ll long long int
const ll mod1=1e9+9,mod2=1e9+7,p1=1124,p2=5938;

int x,y,z;
double d[107][107][107];

void sol(){
    int a,b,c,i;
    double ansa=0,ansb=0,ansc=0;
    for(a=0;a<107;a++)for(b=0;b<107;b++)for(c=0;c<107;c++)d[a][b][c]=0;
    d[x][y][z]=1;
    for(a=x;a>=0;a--){
        for(b=y;b>=0;b--){
            for(c=z;c>=0;c--){
                if(a==0){
                    if(b!=0&&c!=0){
                        d[a][b][c-1]+=(double)d[a][b][c];
                    }
                }else if(b==0){
                    if(a!=0&&c!=0){
                        d[a-1][b][c]+=(double)d[a][b][c];
                    }
                }else if(c==0){
                    if(a!=0&&b!=0){
                        d[a][b-1][c]+=(double)d[a][b][c];
                    }
                }else{
                    d[a-1][b][c]+=(double)d[a][b][c]*(((double)a*(double)c)/((double)(a*b+b*c+c*a)));
                    d[a][b-1][c]+=(double)d[a][b][c]*(((double)a*(double)b)/((double)(a*b+b*c+c*a)));
                    d[a][b][c-1]+=(double)d[a][b][c]*(((double)c*(double)b)/((double)(a*b+b*c+c*a)));
                }
            }
        }
    }
    for(i=1;i<=x;i++)ansa+=(double)d[i][0][0];
    for(i=1;i<=y;i++)ansb+=(double)d[0][i][0];
    for(i=1;i<=z;i++)ansc+=(double)d[0][0][i];
    printf("%.10lf %.10lf %.10lf\n",ansa,ansb,ansc);
}

int main(){
#pragma comment(linker, "/STACK:1073741824")
#ifdef HOME
    freopen("input.txt","rt",stdin);
    freopen("output.txt","wt",stdout);
#else
//    freopen("substrcmp.in","rt",stdin);
//    freopen("substrcmp.out","wt",stdout);
#endif
    while(scanf("%d%d%d",&x,&y,&z)!=EOF)sol();
    return 0;
}


#include <cstdio>
#include <cstdlib>
#include <string>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <iostream>
#include <vector>
#include <map>
#include <set>
using namespace std;

enum{base = int(1e9) + 9};
enum{N = 101, K = 10001};
enum{INF = 1000000};

int main()
{
#ifndef ONLINE_JUDGE
	freopen("input.txt", "r", stdin);
	freopen("output.txt", "w", stdout);
#endif

	int r, s, p;
	cin >> r >> s >> p;
	static long double dp[101][101][101] = {{0}, {0}, {0}};
	for (int i = 1; i <= 100; i++)
		dp[i][0][0] = 1.0;
	for (int i = 1; i <= 100; i++)
		for (int j = 0; j <= 100; j++)
			for (int l = 0; l <= 100; l++)
				if (j > 0 || l > 0)
				{
					if (j > 0)
						dp[i][j][l] += (long double)(i * j) / (i * j + i * l + j * l) * dp[i][j - 1][l];
					if (l > 0)
						dp[i][j][l] += (long double)(j * l) / (i * j + i * l + j * l) * dp[i][j][l - 1];
					if (i > 0)
						dp[i][j][l] += (long double)(l * i) / (i * j + i * l + j * l) * dp[i - 1][j][l];
				}

	cout.precision(20);
	cout << dp[r][s][p] << " " << dp[s][p][r] << " " << dp[p][r][s];

    return 0;
}


#define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <queue>
#include <vector>
#include <ctime>
#include <cstring>
#include <sstream>

//#include <unordered_map>

using namespace std;

typedef unsigned long long ull;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<pii, pii> ppii;
typedef vector<int> vi;

#define SI(n) scanf("%d", &n)
#define SII(x, y) scanf("%d%d", &x, &y)
#define SD(n) scanf("%lf", &n)
#define SPII(n) scanf("%d%d", &n.first, &n.second)
#define FI(n) for (int i=0; i<n; i++)
#define FJ(n) for (int j=0; j<n; j++)
#define WS(n) while(SI(n) != EOF && n)
#define DB(n) cout<<#n<<" = "<<n<<" ";
#define DBN(n) cout<<#n<<" = "<<n<<"\n";
#define FIX(n) cout.precision(2), cout.setf(cout.fixed)
#define PI(n) printf("%d", n)
#define SPACE() putchar(' ')
#define ENDL() putchar('\n')

double d[103][103][103];

int main() {
    int r, s, p;
    cin >> r >> s >> p;

    d[0][0][0] = 1; //all alive

    double ai = 0, aj = 0, az = 0;
    for (int i = 0; i <= r; i++)
        for (int j = 0; j <= s; j++)
            for (int z = 0; z <= p; z++)  {
                int leftI = r - i;
                int leftJ = s - j;
                int leftZ = p - z;
                int sum = leftI * leftZ + leftJ * leftZ + leftI * leftJ;

                if (sum == 0)
                    break;

                double pI = 1.0 * leftI * leftZ / sum;
                double pJ = 1.0 * leftI * leftJ / sum;
                double pZ = 1.0 * leftJ * leftZ / sum;
                d[i][j][z + 1] += d[i][j][z] * pZ;
                d[i][j + 1][z] += d[i][j][z] * pJ;
                d[i + 1][j][z] += d[i][j][z] * pI;
            }

    for (int i = 0; i < r; i++)
        ai += d[i][s][p];

    for (int j = 0; j < s; j++)
        aj += d[r][j][p];

    for (int z = 0; z < p; z++)
        az += d[r][s][z];

    cout.setf(cout.fixed);
    cout.precision(10);
    cout << ai << " " << aj << " " << az << endl;

    int n;
    cin >> n;
    return 0;
}


#define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <queue>
#include <vector>
#include <ctime>
#include <cstring>
#include <sstream>

//#include <unordered_map>

using namespace std;

typedef unsigned long long ull;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<pii, pii> ppii;
typedef vector<int> vi;

#define SI(n) scanf("%d", &n)
#define SII(x, y) scanf("%d%d", &x, &y)
#define SD(n) scanf("%lf", &n)
#define SPII(n) scanf("%d%d", &n.first, &n.second)
#define FI(n) for (int i=0; i<n; i++)
#define FJ(n) for (int j=0; j<n; j++)
#define WS(n) while(SI(n) != EOF && n)
#define DB(n) cout<<#n<<" = "<<n<<" ";
#define DBN(n) cout<<#n<<" = "<<n<<"\n";
#define FIX(n) cout.precision(2), cout.setf(cout.fixed)
#define PI(n) printf("%d", n)
#define SPACE() putchar(' ')
#define ENDL() putchar('\n')

int a[1001];
int b[1001];
int blen = 0;

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

int main() {
    int r, s, p;
    cin >> r >> s >> p;

    d[0][0][0] = 1; //all alive

    double ai = 0, aj = 0, az = 0;
    for (int i = 0; i <= r; i++)
        for (int j = 0; j <= s; j++)
            for (int z = 0; z <= p; z++)  {
                int leftI = r - i;
                int leftJ = s - j;
                int leftZ = p - z;
                int sum = leftI * leftZ + leftJ * leftZ + leftI * leftJ;

                if (sum == 0)
                    break;

                double pI = 1.0 * leftI * leftZ / sum;
                double pJ = 1.0 * leftI * leftJ / sum;
                double pZ = 1.0 * leftJ * leftZ / sum;
                d[i][j][z + 1] += d[i][j][z] * pZ;
                d[i][j + 1][z] += d[i][j][z] * pJ;
                d[i + 1][j][z] += d[i][j][z] * pI;
            }

    for (int i = 0; i < r; i++)
        ai += d[i][s][p];

    for (int j = 0; j < s; j++)
        aj += d[r][j][p];

    for (int z = 0; z < p; z++)
        az += d[r][s][z];

    cout.setf(cout.fixed);
    cout.precision(10);
    cout << ai << " " << aj << " " << az << endl;

    int n;
    cin >> n;
    return 0;
}


// Codeforces Round 301
// D - Bad Luck Island

#include <iostream>
#include <iomanip> // setprecision()

using namespace std;

struct prob
{
	double r, s, p;
};

#define MAXN 100

prob probs[MAXN][MAXN][MAXN];

void Solve(int R, int S, int P);

int main()
{
	int r, s, p;
	cin >> r >> s >> p;

	Solve(r, s, p);

	cout << setprecision(12);
	cout << probs[r][s][p].r << " ";
	cout << probs[r][s][p].s << " ";
	cout << probs[r][s][p].p << endl;

	return 0;
}

void Solve(int R, int S, int P)
{
	for(int r = 0; r < R; r++)
	{
		for(int s = 0; s < S; s++)
		{
			for(int p = 0; p < P; p++)
			{
				int total = r * s + s * p + r * p;
				probs[r][s][p].r = (r * p + 0.0) / total *
					probs[r - 1][s][p].r +
					(r * s + 0.0) / total *
					probs[r][s - 1][p].r +
					(s * p + 0.0) / total *
					probs[r][s][p - 1].r;
				probs[r][s][p].s = (r * p + 0.0) / total *
					probs[r - 1][s][p].s +
					(r * s + 0.0) / total *
					probs[r][s - 1][p].s +
					(s * p + 0.0) / total *
					probs[r][s][p - 1].s;
				probs[r][s][p].p = (r * p + 0.0) / total *
					probs[r - 1][s][p].p +
					(r * s + 0.0) / total *
					probs[r][s - 1][p].p +
					(s * p + 0.0) / total *
					probs[r][s][p - 1].p;
			}
		}
	}
}

/*
void Solve(int r, int s, int p)
{
	if(r == 0)
	{
		probs[r][s][p].r = 0.0;
		probs[r][s][p].s = 1.0;
		probs[r][s][p].p = 0.0;
		return;
	}

	if(s == 0)
	{
		probs[r][s][p].r = 0.0;
		probs[r][s][p].s = 0.0;
		probs[r][s][p].p = 1.0;
		return;
	}

	if(p == 0)
	{
		probs[r][s][p].r = 1.0;
		probs[r][s][p].s = 0.0;
		probs[r][s][p].p = 0.0;
		return;
	}

	Solve

	int total = r * s + s * p + r * p;
	probs[r][s][p].r = (r * p + 0.0) / total * probs[
}
*/

/*
double ProbR(int r, int s, int p);
double ProbS(int r, int s, int p);
double ProbP(int r, int s, int p);

int main()
{
	int r, s, p;
	cin >> r >> s >> p;

	cout << setprecision(12);
	cout << ProbR(r, s, p) << " ";
	cout << ProbS(r, s, p) << " ";
       	cout << ProbP(r, s, p) << endl;

	return 0;
}

double ProbR(int r, int s, int p)
{
	if(r == 0 || s == 0) return 0.0;
	if(p == 0) return 1.0;

	int total = r * s + s * p + r * p;
	double prob1 = (r * p + 0.0) / total * ProbR(r - 1, s, p);
	double prob2 = (r * s + 0.0) / total * ProbR(r, s - 1, p);
	double prob3 = (s * p + 0.0) / total * ProbR(r, s, p - 1);

	return prob1 + prob2 + prob3;
}

double ProbS(int r, int s, int p)
{
	if(s == 0 || p == 0) return 0.0;
	if(r == 0) return 1.0;

	int total = r * s + s * p + r * p;
	double prob1 = (r * p + 0.0) / total * ProbS(r - 1, s, p);
	double prob2 = (r * s + 0.0) / total * ProbS(r, s - 1, p);
	double prob3 = (s * p + 0.0) / total * ProbS(r, s, p - 1);

	return prob1 + prob2 + prob3;
}

double ProbP(int r, int s, int p)
{
	if(p == 0 || r == 0) return 0.0;
	if(s == 0) return 1.0;

	int total = r * s + s * p + r * p;
	double prob1 = (r * p + 0.0) / total * ProbP(r - 1, s, p);
	double prob2 = (r * s + 0.0) / total * ProbP(r, s - 1, p);
	double prob3 = (s * p + 0.0) / total * ProbP(r, s, p - 1);

	return prob1 + prob2 + prob3;
}
*/


// Codeforces Round 301
// D - Bad Luck Island

#include <iostream>
#include <iomanip> // setprecision()

using namespace std;

#define MAXSIZE 100

double a[MAXSIZE][MAXSIZE][MAXSIZE];

int main()
{
	// Read the input
	int R, S, P;
	cin >> R >> S >> P;

	// a[r][s][p] is the probability of reaching a state with r, s, and p
	// rocks, papers, and scissors, respectively.  (Moved this to global
	// scope in order to initiailze properly.)
	a[R][S][P] = 1;

	// Now we calculate all relevant a[r][s][p]
	for(int sum = R + S + P; sum > 0; sum--)
	{
		for(int r = R; r >= 0; r--)
		{
			for(int s = S; s >= 0; s--)
			{
				int p = sum - r - s;
				if(p < 0 || p > P) continue;
				if(r == 0 && p == 0) continue;
				if(r == 0 && s == 0) continue;
				if(s == 0 && p == 0) continue;

				double cur = a[r][s][p];
				int total = r * s + r * p + s * p;

				if(r > 0) a[r - 1][s][p] +=
					cur * (p * r) / total;
				if(s > 0) a[r][s - 1][p] +=
					cur * (r * s) / total;
				if(p > 0) a[r][s][p - 1] +=
					cur * (p * s) / total;
			}
		}
	}

	// Calculate the total for each species
	double pR = 0;
	for(int r = 1; r <= R; r++)
		pR += a[r][0][0];

	double pS = 0;
	for(int s = 1; s <= S; s++)
		pS += a[0][s][0];

	double pP = 0;
	for(int p = 1; p <= P; p++)
		pP += a[0][0][p];

	// Display the results
	cout << setprecision(12);
	cout << pR << " ";
	cout << pS << " ";
	cout << pP << endl;

	return 0;
}


// Codeforces Round 301
// D - Bad Luck Island

#include <iostream>
#include <iomanip> // setprecision()

using namespace std;

double ProbR(int r, int s, int p);
double ProbS(int r, int s, int p);
double ProbP(int r, int s, int p);

int main()
{
	int r, s, p;
	cin >> r >> s >> p;

	cout << setprecision(12);
	cout << ProbR(r, s, p) << " ";
	cout << ProbS(r, s, p) << " ";
       	cout << ProbP(r, s, p) << endl;

	return 0;
}

double ProbR(int r, int s, int p)
{
	if(r == 0 || s == 0) return 0.0;
	if(p == 0) return 1.0;

	int total = r * s + s * p + r * p;
	double prob1 = (r * p + 0.0) / total * ProbR(r - 1, s, p);
	double prob2 = (r * s + 0.0) / total * ProbR(r, s - 1, p);
	double prob3 = (s * p + 0.0) / total * ProbR(r, s, p - 1);

	return prob1 + prob2 + prob3;
}

double ProbS(int r, int s, int p)
{
	if(s == 0 || p == 0) return 0.0;
	if(r == 0) return 1.0;

	int total = r * s + s * p + r * p;
	double prob1 = (r * p + 0.0) / total * ProbS(r - 1, s, p);
	double prob2 = (r * s + 0.0) / total * ProbS(r, s - 1, p);
	double prob3 = (s * p + 0.0) / total * ProbS(r, s, p - 1);

	return prob1 + prob2 + prob3;
}

double ProbP(int r, int s, int p)
{
	if(p == 0 || r == 0) return 0.0;
	if(s == 0) return 1.0;

	int total = r * s + s * p + r * p;
	double prob1 = (r * p + 0.0) / total * ProbP(r - 1, s, p);
	double prob2 = (r * s + 0.0) / total * ProbP(r, s - 1, p);
	double prob3 = (s * p + 0.0) / total * ProbP(r, s, p - 1);

	return prob1 + prob2 + prob3;
}


// Codeforces Round 301
// D - Bad Luck Island

#include <iostream>
#include <iomanip> // setprecision()

using namespace std;

#define MAXSIZE 101

double a[MAXSIZE][MAXSIZE][MAXSIZE];

int main()
{
	// Read the input
	int R, S, P;
	cin >> R >> S >> P;

	// a[r][s][p] is the probability of reaching a state with r, s, and p
	// rocks, papers, and scissors, respectively.  (Moved this to global
	// scope in order to initiailze properly.)
	a[R][S][P] = 1;

	// Now we calculate all relevant a[r][s][p]
	for(int sum = R + S + P; sum > 0; sum--)
	{
		for(int r = R; r >= 0; r--)
		{
			for(int s = S; s >= 0; s--)
			{
				int p = sum - r - s;
				if(p < 0 || p > P) continue;
				if(r == 0 && p == 0) continue;
				if(r == 0 && s == 0) continue;
				if(s == 0 && p == 0) continue;

				double cur = a[r][s][p];
				int total = r * s + r * p + s * p;

				if(r > 0) a[r - 1][s][p] +=
					cur * (p * r) / total;
				if(s > 0) a[r][s - 1][p] +=
					cur * (r * s) / total;
				if(p > 0) a[r][s][p - 1] +=
					cur * (p * s) / total;
			}
		}
	}

	// Calculate the total for each species
	double pR = 0;
	for(int r = 1; r <= R; r++)
		pR += a[r][0][0];

	double pS = 0;
	for(int s = 1; s <= S; s++)
		pS += a[0][s][0];

	double pP = 0;
	for(int p = 1; p <= P; p++)
		pP += a[0][0][p];

	// Display the results
	cout << setprecision(12);
	cout << pR << " ";
	cout << pS << " ";
	cout << pP << endl;

	return 0;
}


// Codeforces Round 301
// D - Bad Luck Island

#include <iostream>
#include <iomanip> // setprecision()

using namespace std;

struct prob
{
	double r, s, p;
};

#define MAXN 100

prob probs[MAXN][MAXN][MAXN];

void Solve(void);

int main()
{
	int r, s, p;
	cin >> r >> s >> p;

	Solve();

	cout << setprecision(12);
	cout << probs[r][s][p].r << " ";
	cout << probs[r][s][p].s << " ";
	cout << probs[r][s][p].p << endl;

	return 0;
}

void Solve(void)
{
	for(int r = 0; r < MAXN; r++)
	{
		for(int s = 0; s < MAXN; s++)
		{
			for(int p = 0; p < MAXN; p++)
			{
				int total = r * s + s * p + r * p;
				probs[r][s][p].r = (r * p + 0.0) / total *
					probs[r - 1][s][p].r +
					(r * s + 0.0) / total *
					probs[r][s - 1][p].r +
					(s * p + 0.0) / total *
					probs[r][s][p - 1].r;
				probs[r][s][p].s = (r * p + 0.0) / total *
					probs[r - 1][s][p].s +
					(r * s + 0.0) / total *
					probs[r][s - 1][p].s +
					(s * p + 0.0) / total *
					probs[r][s][p - 1].s;
				probs[r][s][p].p = (r * p + 0.0) / total *
					probs[r - 1][s][p].p +
					(r * s + 0.0) / total *
					probs[r][s - 1][p].p +
					(s * p + 0.0) / total *
					probs[r][s][p - 1].p;
			}
		}
	}
}

/*
void Solve(int r, int s, int p)
{
	if(r == 0)
	{
		probs[r][s][p].r = 0.0;
		probs[r][s][p].s = 1.0;
		probs[r][s][p].p = 0.0;
		return;
	}

	if(s == 0)
	{
		probs[r][s][p].r = 0.0;
		probs[r][s][p].s = 0.0;
		probs[r][s][p].p = 1.0;
		return;
	}

	if(p == 0)
	{
		probs[r][s][p].r = 1.0;
		probs[r][s][p].s = 0.0;
		probs[r][s][p].p = 0.0;
		return;
	}

	Solve

	int total = r * s + s * p + r * p;
	probs[r][s][p].r = (r * p + 0.0) / total * probs[
}
*/

/*
double ProbR(int r, int s, int p);
double ProbS(int r, int s, int p);
double ProbP(int r, int s, int p);

int main()
{
	int r, s, p;
	cin >> r >> s >> p;

	cout << setprecision(12);
	cout << ProbR(r, s, p) << " ";
	cout << ProbS(r, s, p) << " ";
       	cout << ProbP(r, s, p) << endl;

	return 0;
}

double ProbR(int r, int s, int p)
{
	if(r == 0 || s == 0) return 0.0;
	if(p == 0) return 1.0;

	int total = r * s + s * p + r * p;
	double prob1 = (r * p + 0.0) / total * ProbR(r - 1, s, p);
	double prob2 = (r * s + 0.0) / total * ProbR(r, s - 1, p);
	double prob3 = (s * p + 0.0) / total * ProbR(r, s, p - 1);

	return prob1 + prob2 + prob3;
}

double ProbS(int r, int s, int p)
{
	if(s == 0 || p == 0) return 0.0;
	if(r == 0) return 1.0;

	int total = r * s + s * p + r * p;
	double prob1 = (r * p + 0.0) / total * ProbS(r - 1, s, p);
	double prob2 = (r * s + 0.0) / total * ProbS(r, s - 1, p);
	double prob3 = (s * p + 0.0) / total * ProbS(r, s, p - 1);

	return prob1 + prob2 + prob3;
}

double ProbP(int r, int s, int p)
{
	if(p == 0 || r == 0) return 0.0;
	if(s == 0) return 1.0;

	int total = r * s + s * p + r * p;
	double prob1 = (r * p + 0.0) / total * ProbP(r - 1, s, p);
	double prob2 = (r * s + 0.0) / total * ProbP(r, s - 1, p);
	double prob3 = (s * p + 0.0) / total * ProbP(r, s, p - 1);

	return prob1 + prob2 + prob3;
}
*/


#include <cstdio>
#include <string>
#include <cmath>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <iostream>
#include <queue>

using namespace std;

typedef long double ld;
typedef long long ll;

const int MAXN = 1e2;

struct creatures{
	int arr[3];

	creatures(int r, int s, int p)
	{
		arr[0] = r;
		arr[1] = s;
		arr[2] = p;
	}
};

int r, s, p;
ld d[MAXN+2][MAXN+2][MAXN+2];

queue<creatures> que;
bool used[MAXN+2][MAXN+2][MAXN+2];

bool two_zeroes(creatures a)
{
	int ans = 0;
	for(int i=0; i<3; ++i)
		ans += a.arr[i] == 0;

	return ans >= 2;
}

ld* get_d(creatures a)
{
	return &d[a.arr[0]][a.arr[1]][a.arr[2]];
}

bool not_used(creatures a)
{
	if(!used[a.arr[0]][a.arr[1]][a.arr[2]]){
		used[a.arr[0]][a.arr[1]][a.arr[2]] = 1;
		return 1;
	}
	return 0;
}

int main()
{
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
	freopen("output.txt", "w", stdout);
#endif

	scanf("%d%d%d", &r, &s, &p);

	d[r][s][p] = 1;
	que.push(creatures(r, s, p));

	while(que.size()){
		creatures t = que.front();
		que.pop();

		if(two_zeroes(t)) continue;
		ld ourval = *get_d(t);

		for(int i=1; i<=3; ++i){
			if(t.arr[i % 3] == 0) continue;

			ld tempval = t.arr[i - 1] * t.arr[i % 3];
			tempval /= t.arr[0] * t.arr[1] + t.arr[1] * t.arr[2] + t.arr[2] * t.arr[0];

			--t.arr[i % 3];

			if(not_used(t))
				que.push(t);

			*get_d(t) += ourval * tempval;
			++t.arr[i % 3];
		}
	}

	for(int i=0; i<3; ++i){
		ld ans = 0;
		creatures a(0, 0, 0);

		for(int j=0; j<=MAXN; ++j){
			a.arr[i] = j;
			ans += *get_d(a);
		}

		printf("%.12Lf ", ans);
	}

	return 0;
}


#pragma comment (linker,"/stack:102400000,102400000")
#include <cstdio>
#include <map>
#include <vector>
#include <stack>
#include <queue>
#include <cstring>
#include <algorithm>
#include <string>
#include <cstdlib>
#include <iostream>
#include <cmath>
#include <set>
#include <ctime>

using namespace std;

#define ll long long
#define ull unsigned long long
#define ls (root << 1)
#define rs (root << 1 | 1)
#define lson l, mid, ls
#define rson mid + 1, r, rs
#define MID mid = ((l + r) >> 1)
#define PR pair<int, int>
#define MP make_pair
#define sqr(x) ((x) * (x))

int lowbit(int x) {return (x & -x);}
//int sgn(double x) {return (x > eps) - (x < -eps);}
template <class T_> T_ f_abs(T_ x) {return x < 0 ? -x : x;}
template <class T_> T_ f_max(T_ a, T_ b) {return a > b ? a : b;}
template <class T_> T_ f_min(T_ a, T_ b) {return a < b ? a : b;}
template <class T_> T_ gcd(T_ a, T_ b) {while(T_ t = a % b) a = b, b = t; return b;}
template <class T_> void f_swap(T_ &a, T_ &b) {T_ t = a; a = b; b = t;}

const double eps = 1e-9;
const int dx[] = {-1, 1, 0, 0, -1, -1, 1, 1}, dy[] = {0, 0, -1, 1, -1, 1, -1, 1};//UDLR
const int inf = 0x7fffffff;
const int mod = 1000000007;
const int N = 1100003;
int r, s, p, tot, ind[N], order[N];
vector< int > edg[N];
double dp[N];
bool vis[N];

int CalcId(int a, int b, int c) {
    return a * (s + 1) * (p + 1) + b * (p + 1) + c;
}

void RevId(int id, int &a, int &b, int &c) {
    a = id / ((s + 1) * (p + 1));
    b = id % ((s + 1) * (p + 1)) / (p + 1);
    c = id % (p + 1);
}

void Init() {
    int i;
    tot = (r + 1) * (s + 1) * (p + 1);
    memset(dp, 0, sizeof(dp));
    memset(vis, false, sizeof(vis));
    dp[CalcId(r, s, p)] = 1;
    for(i = 0; i < tot; ++i) {
        edg[i].clear();
        ind[i] = 0;
    }
}

void GetData() {}

void Dfs(int a, int b, int c) {
    int u, v;
    u = CalcId(a, b, c);
    if(vis[u]) return;
    vis[u] = true;
    if(a != 0 && c != 0) {
        v = CalcId(a - 1, b, c);
        edg[u].push_back(v); ind[v]++;
        Dfs(a - 1, b, c);
    }
    if(b != 0 && a != 0) {
        v = CalcId(a, b - 1, c);
        edg[u].push_back(v); ind[v]++;
        Dfs(a, b - 1, c);
    }
    if(c != 0 && b != 0) {
        v = CalcId(a, b, c - 1);
        edg[u].push_back(v); ind[v]++;
        Dfs(a, b, c - 1);
    }
}

void TopoSort() {
    int i, u, v;
    queue< int > que;
    for(i = 0; i < tot; ++i)
        if(ind[i] == 0 && vis[i])
            que.push(i);
    tot = 0;
    while(!que.empty()) {
        u = que.front(); que.pop();
        order[++tot] = u;
        for(i = 0; i < (int)edg[u].size(); ++i) {
            v = edg[u][i];
            if(--ind[v] == 0)
                que.push(v);
        }
    }
}

double CalcP(int a, int b, int c, int a1, int b1, int c1) {
    int s = a + b + c;
    double p1, p2, p3, p4;
    p1 = p2 = p3 = 0;
    if(a != 0 && c != 0) p1 = (double)2 * (a * c) / s / (s - 1);
    if(b != 0 && a != 0) p2 = (double)2 * (b * a) / s / (s - 1);
    if(c != 0 && b != 0) p3 = (double)2 * (c * b) / s / (s - 1);
    p4 = 1.0 - p1 - p2 - p3; p4 = 1.0 / (1.0 - p4);
    if(a1 + 1 == a) return p1 * p4;
    if(b1 + 1 == b) return p2 * p4;
    if(c1 + 1 == c) return p3 * p4;
    return 0;
}

void Solve() {
    int i, j, u, v, a, b, c, a1, b1, c1;
    double p1, p2, p3;
    p1 = p2 = p3 = 0;
    Dfs(r, s, p);
    TopoSort();
    for(i = 1; i <= tot; ++i) {
        u = order[i];
        RevId(u, a, b, c);
        for(j = 0; j < (int)edg[u].size(); ++j) {
            v = edg[u][j];
            RevId(v, a1, b1, c1);
            dp[v] += dp[u] * CalcP(a, b, c, a1, b1, c1);
        }
    }
    for(i = 1; i <= tot; ++i) {
        RevId(order[i], a, b, c);
        if(b == 0 && c == 0)
            p1 += dp[order[i]];
        else if(a == 0 && c == 0)
            p2 += dp[order[i]];
        else if(a == 0 && b == 0)
            p3 += dp[order[i]];
    }
    printf("%.12lf %.12lf %.12lf\n", p1, p2, p3);
}

int main() {
    while(~scanf("%d%d%d", &r, &s, &p)) {
        Init();
        GetData();
        Solve();
    }
    return 0;
}


//In the name of Allah
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<algorithm>
#include<vector>
#include<set>
#include<map>
#include<queue>
#include<stack>
#include<iterator>
#include<cmath>
#include<string>
#include<sstream>
#include<cstring>
#include<ctype.h>
#include<iomanip>
#include<functional>
#include<bitset>
#include<stdio.h>
#include<fstream>
#include<stdlib.h>
#include<math.h>
#include<ctime>
#include<string>
#include<cstdio>
#include<locale>
#include<codecvt>
using namespace std;
#define lop(i,a,n) for(int i=a;i<n;++i)
#define loop(i,n,a)for(int i=n-1;i>=a;--i)
#define R_(s)      freopen(s, "r", stdin)
#define W_(s)      freopen(s, "w", stdout)
#define R_W        R_("input.txt"),W_("output.txt")
#define ll         long long
#define ld         long double
#define ii         pair<ll,ll>
#define vii        vector<ii>
#define vi         vector<int>
#define vll        vector<ll>
#define vs         vector<string>
#define vvii       vector<vector<ii>>
#define vvi        vector<vector<int>>
#define vvll       vector<vector<ll>>
#define sz(v)      (ll)v.size()
#define all(v)     v.begin(),v.end()
#define sc(n)      scanf("%d",&n)
#define scl(n)     scanf("%lld",&n)
#define pr1(n)     printf("%d\n",n)
#define pr2(n)     printf("%d " ,n)
#define pr4(n)     printf("%lld\n",n)
#define pr3(n)     cout<<fixed<<setprecision(4)<<n<<endl
#define endl       "\n"
#define PI         2*acos(0.0)
#define DFS_GRAY  -1
#define DFS_WHITE  0
#define DFS_BLACK  1
#define oo  1e9
#define OO  1e18
#define EPS 1e-9
int dr[] = { 1, 0, -1, 0, -1, -1, 1, 1 };
int dc[] = { 0, -1, 0, 1, -1, 1, -1, 1 };
const int MAX = 100 + 7;
const int MOD = 1e9 + 7;
struct node {
	ld r, s, p;node(ld _r=0,ld _s=0,ld _p=0):r(_r),s(_s),p(_p){}
	void operator+=(node &n){
		r += n.r; s += n.s; p += n.p;}
	node operator*(ld x) {
		return node(r*x, s*x, p*x);
	}
};
map<pair<ii,int>, node>mem;
node solve(int r, int s, int p)
{
	if (r == 0 && s == 0)return node(0, 0, 1);
	if (r == 0 && p == 0)return node(0, 1, 0);
	if (p == 0 && s == 0)return node(1, 0, 0);
	if (mem.count(make_pair(make_pair(r, s), p)) != 0)
		return mem[make_pair(make_pair(r, s), p)];
	node ans;
	ld t = r*s + r*p + s*p;
	if (r&&s)ans+=(solve(r, s - 1, p)*((r*s)/t));
	if (r&&p)ans+=(solve(r - 1, s, p)*((r*p)/t));
	if (s&&p)ans+=(solve(r, s, p - 1)*((s*p)/t));

	return  mem[make_pair(make_pair(r, s), p)] = ans;
}
int main()
{
	int r, s, p;
	sc(r), sc(s), sc(p);
	node ans = solve(r, s, p);
	ld all = ans.p + ans.r + ans.s;
	cout << ans.r/all << " " << ans.s/all << " " << ans.p/all << endl;
}


//In the name of Allah
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<algorithm>
#include<vector>
#include<set>
#include<map>
#include<queue>
#include<stack>
#include<iterator>
#include<cmath>
#include<string>
#include<sstream>
#include<cstring>
#include<ctype.h>
#include<iomanip>
#include<functional>
#include<bitset>
#include<stdio.h>
#include<fstream>
#include<stdlib.h>
#include<math.h>
#include<ctime>
#include<string>
#include<cstdio>
#include<locale>
#include<codecvt>
using namespace std;
#define lop(i,a,n) for(int i=a;i<n;++i)
#define loop(i,n,a)for(int i=n-1;i>=a;--i)
#define R_(s)      freopen(s, "r", stdin)
#define W_(s)      freopen(s, "w", stdout)
#define R_W        R_("input.txt"),W_("output.txt")
#define ll         long long
#define ld         long double
#define ii         pair<ll,ll>
#define vii        vector<ii>
#define vi         vector<int>
#define vll        vector<ll>
#define vs         vector<string>
#define vvii       vector<vector<ii>>
#define vvi        vector<vector<int>>
#define vvll       vector<vector<ll>>
#define sz(v)      (ll)v.size()
#define all(v)     v.begin(),v.end()
#define sc(n)      scanf("%d",&n)
#define scl(n)     scanf("%lld",&n)
#define pr1(n)     printf("%d\n",n)
#define pr2(n)     printf("%d " ,n)
#define pr4(n)     printf("%lld\n",n)
#define pr3(n)     cout<<fixed<<setprecision(4)<<n<<endl
#define endl       "\n"
#define PI         2*acos(0.0)
#define DFS_GRAY  -1
#define DFS_WHITE  0
#define DFS_BLACK  1
#define oo  1e9
#define OO  1e18
#define EPS 1e-9
int dr[] = { 1, 0, -1, 0, -1, -1, 1, 1 };
int dc[] = { 0, -1, 0, 1, -1, 1, -1, 1 };
const int MAX = 100 + 7;
const int MOD = 1e9 + 7;
struct node {
	ld r, s, p;node(ld _r=0,ld _s=0,ld _p=0):r(_r),s(_s),p(_p){}
	void operator+=(node &n){
		r += n.r; s += n.s; p += n.p;}
	node operator*(ld x) {
		return node(r*x, s*x, p*x);
	}
};
map<pair<ii,int>, node>mem;
node solve(int r, int s, int p)
{
	if (r == 0 && s == 0)return node(0, 0, 1);
	if (r == 0 && p == 0)return node(0, 1, 0);
	if (p == 0 && s == 0)return node(1, 0, 0);
	if (mem.count(make_pair(make_pair(r, s), p)) != 0)
		return mem[make_pair(make_pair(r, s), p)];
	node ans;
	ld t = r*s + r*p + s*p;
	if (r&&s)ans+=(solve(r, s - 1, p)*((r*s)/t));
	if (r&&p)ans+=(solve(r - 1, s, p)*((r*p)/t));
	if (s&&p)ans+=(solve(r, s, p - 1)*((s*p)/t));

	return  mem[make_pair(make_pair(r, s), p)] = ans;
}
int main()
{
	int r, s, p;
	sc(r), sc(s), sc(p);
	node ans = solve(r, s, p);
	ld all = ans.p + ans.r + ans.s;
	cout << fixed << setprecision(12) << ans.r / all << " " << ans.s / all << " " << ans.p / all << endl;
}


#include <iostream>
#include <fstream>
#include <iomanip>
#include <math.h>
#include <limits.h>
#include <algorithm>
#include <vector>
#include <list>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <bitset>
#include <string>
#include <string.h>
#include <sstream>
#include <ctime>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
int r,s,p,comb[310];
long double pr[110][110][110][5];
int main()
{
	std::ios::sync_with_stdio(false);
	for(int i=0;i<310;i++)
	{
		comb[i]=(i*(i-1))/2;
	}
	for(int i=1;i<110;i++)
	{
		for(int j=1;j<110;j++)
		{
			for(int k=1;k<110;k++)
			{
				for(int h=0;h<3;h++)
				{
					pr[i][j][k][h]=0;
				}
			}
		}
	}
	for(int i=1;i<110;i++)
	{
		pr[i][0][0][0]=1;
		pr[0][i][0][1]=1;
		pr[0][0][i][2]=1;
	}
	for(int i=1;i<110;i++)
	{
		for(int j=1;j<110;j++)
		{
			pr[i][j][0][0]=1;
			pr[i][0][j][2]=1;
			pr[0][i][j][1]=1;
		}
	}
	cin>>r>>s>>p;
	for(int i=1;i<=r;i++)
	{
		for(int j=1;j<=s;j++)
		{
			for(int k=1;k<=p;k++)
			{
				for(int h=0;h<3;h++)
				{
					pr[i][j][k][h]=(i*j*pr[i][j-1][k][h]+i*k*pr[i-1][j][k][h]+j*k*pr[i][j][k-1][h])/(comb[i+j+k]-(comb[i]+comb[j]+comb[k]));
				}
			}
		}
	}
	cout<<fixed<<setprecision(12)<<pr[r][s][p][0]<<" "<<pr[r][s][p][1]<<" "<<pr[r][s][p][2]<<"\n";
	return 0;
}


#include<iostream>
#include<iomanip>
using namespace std;
double dp[101][101][101];
int main()
{
	int a,b,c;
	cin>>a>>b>>c;
	dp[a][b][c]=1.0;
	for(int i=a;i>=1;i--)
	for(int j=b;j>=1;j--)
	for(int k=c;k>=1;k--)
	{
		if(dp[i][j][k]==0)
		continue;
		int tot=i*j+i*k+j*k;
		dp[i-1][j][k]+=i*k*1.0/tot*dp[i][j][k];
		dp[i][j-1][k]+=j*i*1.0/tot*dp[i][j][k];
		dp[i][j][k-1]+=k*j*1.0/tot*dp[i][j][k];
	}
	double ans=0;
	for(int i=1;i<=a;i++)
	for(int j=0;j<=b;j++)
	ans+=dp[i][j][0];
	cout<<setiosflags(ios::fixed)<<setprecision(12)<<ans;
	ans=0;
	for(int i=1;i<=b;i++)
	for(int j=0;j<=c;j++)
	ans+=dp[0][i][j];
	cout<<" "<<setiosflags(ios::fixed)<<setprecision(12)<<ans;
	ans=0;
	for(int i=1;i<=a;i++)
	for(int j=1;j<=c;j++)
	ans+=dp[i][0][j];
	cout<<" "<<setiosflags(ios::fixed)<<setprecision(12)<<ans<<endl;

}


//#pragma comment (linker,"/stack:102400000,102400000")
#include <stdio.h>
#include <math.h>
#include <string.h>
#include <queue>
#include <string>
#include <iostream>
#include <algorithm>
#define ll __int64
using namespace std;

const ll inf = (1LL<<60);
const int N = 110;
double dp[N][N][N];
int r, s, p;
int main() {
	while(~scanf("%d%d%d",&r,&s,&p)) {
		memset(dp, 0, sizeof(dp));
		dp[r][s][p] = 1;
		double rp, sp, pp;
		rp = sp = pp = 0;
		for(int i = r; i >= 0; i--) {
			for(int j = s; j >= 0; j--) {
				for(int k = p; k >= 0; k--) {
					if(i == r && j == s && k == p || !(i + j + k)) continue;
					if(j + k)
						dp[i][j][k] += dp[i + 1][j][k] * (i + 1) * k/((i + 1) * (j + k) + k * j);
					if(i + k)
						dp[i][j][k] += dp[i][j + 1][k] * (j + 1) * i/((j + 1) * (k + i) + k * i);
					if(i + j)
						dp[i][j][k] += dp[i][j][k + 1] * (k + 1) * j/((k + 1) * (i + j) + i * j);
					if(!(j + k)) rp += dp[i][j][k];
					if(!(i + k)) sp += dp[i][j][k];
					if(!(i + j)) pp += dp[i][j][k];
				}
			}
		}
		printf("%.12f %.12f %.12f\n",rp,sp,pp);
	}
	return 0;
}


#include<iostream>
#include<cstdio>
#include<cstring>
#include <cmath>
#include<stack>
#include<vector>
#include<map>
#include<set>
#include<queue>
#include<algorithm>
using namespace std;
typedef long long LL;
int i,j,k,n,m,x,y,T,ans,big,cas,num,len;
bool flag;
struct node
{
    double x,y,z;
    node (){}
    node (double x,double y,double z):x(x),y(y),z(z){}
}dp[105][105][105];
bool vis[105][105][105];

node dfs(int a,int b,int c)
{
    if (vis[a][b][c]) return dp[a][b][c];

    vis[a][b][c]=1;

    int sum=a*b+b*c+a*c;

    node r=node(0,0,0),s=node(0,0,0),t=node(0,0,0),rt;

    if (b>0) r=dfs(a,b-1,c); double p1=a*b*1.0/sum;
    if (c>0) s=dfs(a,b,c-1); double p2=b*c*1.0/sum;
    if (a>0) t=dfs(a-1,b,c); double p3=c*a*1.0/sum;

    rt.x=p1*r.x+p2*s.x+p3*t.x;
    rt.y=p1*r.y+p2*s.y+p3*t.y;
    rt.z=p1*r.z+p2*s.z+p3*t.z;

    return dp[a][b][c]=rt;
}

int main()
{
    int a,b,c;
    scanf("%d%d%d",&a,&b,&c);
    memset(vis,0,sizeof(vis));
    for (i=1;i<=100;i++)
    {
        vis[0][0][i]=1; dp[0][0][i].z=1;
        vis[0][i][0]=1; dp[0][i][0].y=1;
        vis[i][0][0]=1; dp[i][0][0].x=1;
    }
    node ans=dfs(a,b,c);
    memset(dp,-1,sizeof(dp));
    printf("%.12f %.12f %.12f\n",ans.x,ans.y,ans.z);
    return 0;
}


#include <cctype>
#include <iostream>
#include <fstream>
#include <string.h>
#include <algorithm>
#include <vector>
#include <math.h>
#include <cmath>
#include <vector>
#include <queue>
#include <deque>
#include <map>
#include <list>
#include <set>
#include <string>
#include <iomanip>
#include <iterator>

#define forn(i, n) for (i64 i = 0; i < n; ++i)
#define revn(i, n) for (i64 i = n-1; i>=0; --i)
#define cyc(i, s, n) for (i64 i = s; i <= n; ++i)
#define pb push_back
#define mp(a,b) make_pair(a,b)
#define all(x) x.begin(), x.end()
#define F first
#define S second
#define eps 1e-7
#define inf (1000*1000*1000+9)
#define debug(x) cout << x << endl;

using namespace std;
typedef unsigned long long u64;
typedef long long i64;
typedef long double ld;
typedef vector < i64 > vi64;
typedef vector < u64 > vu64;
typedef pair < i64, i64 > pi64;
typedef vector < vi64 > graph;
typedef int huint;
#define huint int

ld dp[120][120][120];

int main() {

    i64 r,s,p;
    cin >> r >> s >> p;
    ld x = .0, y = .0, z = .0;
    dp[r][s][p] = 1;
    revn(i, r+1) {
        revn(j, s+1) {
            revn(k, p+1) {
                ld all = i*j+j*k+i*k;
                if (i && k)
                    dp[i - 1][j][k]+=(ld)i*k*dp[i][j][k]/all;
                if (i && j)
                    dp[i][j - 1][k]+=(ld)i*j*dp[i][j][k]/all;
                if (j && k)
                    dp[i][j][k - 1]+=(ld)j*k*dp[i][j][k]/all;
            }
        }
    }
    cyc(i,1,110) {
        x += dp[i][0][0];
        y += dp[0][i][0];
        z += dp[0][0][i];
    }
    cout << setprecision(12) << x << " " << y << " " << z;
    return 0;
}


#include <iostreaM>
#include <cstdio>
#include <algorithm>
#include <vector>

using namespace std;

long double D[109][109][109];

long double qr(int r, int s, int p){if(p*r)return p*r*1.0/(p*r+p*s+r*s+0.0);return 0;}
long double qs(int r, int s, int p){if(s*r)return s*r*1.0/(p*r+p*s+r*s+0.0);return 0;}
long double qp(int r, int s, int p){if(p*s)return p*s*1.0/(p*r+p*s+r*s+0.0);return 0;}

long double d(int r, int s, int p){
    if(D[r][s][p]==-1){
        D[r][s][p] = d(r+1,s,p)*qr(r+1,s,p) + d(r,s+1,p)*qs(r,s+1,p) + d(r,s,p+1)*qp(r,s,p+1);
    }
    return D[r][s][p];
}
int main(){
    int r,s,p;
    scanf("%d%d%d", &r, &s, &p);
    for(int i=0;i<109;i++){
        for(int j=0;j<109;j++){
            for(int k=0;k<109;k++){
                if(i>r || j>s || k>p){
                    D[i][j][k] = 0;
                }
                else{
                    D[i][j][k] = -1;
                }

            }
        }
    }
    D[r][s][p] = 1;
    long double ret = 0;
    d(1,0,0);

    for(int i=1;i<=r;i++){
        ret +=d(i,0,0);
    }
    printf("%0.12f ", ret);

    ret = 0;
    for(int i=1;i<=s;i++){
        ret +=d(0,i,0);
    }
    printf("%0.12f ", ret);

    ret = 0;
    for(int i=1;i<=p;i++){
        ret +=d(0,0,i);
    }
    printf("%0.12f ", ret);

    printf("\n");
    return 0;
}


#include <ios>
#include <iostream>
#include <iomanip>

double dp[105][105][105] = {};
double d2p[105][105][105] = {};

double prob_rleft(int r, int s, int p)
{
	if (r < 0 || s < 0 || p < 0) return 0;
	if (dp[r][s][p] < -1)
	{
		if (r == 0) dp[r][s][p] = 0;
		else if (r > 0 && s == 0 && p == 0) dp[r][s][p] = 1;
		else
		{
			dp[r][s][p] = 0;

			//rock and scissors meet with this probability
			dp[r][s][p] += (((double)(r*s))/((double)(r*s+s*p+r*p)))*prob_rleft(r, s-1, p);

			//rock and papers meet with this probability
			dp[r][s][p] += (((double)(r*p))/((double)(r*s+s*p+r*p)))*prob_rleft(r-1, s, p);

			//papers and scissors meet with this probability
			dp[r][s][p] += (((double)(p*s))/((double)(r*s+s*p+r*p)))*prob_rleft(r, s, p-1);
		}
	}
	return dp[r][s][p];
}

double prob_sleft(int r, int s, int p)
{
	if (r < 0 || s < 0 || p < 0) return 0;
	if (d2p[r][s][p] < -1)
	{
		if (s == 0) d2p[r][s][p] = 0;
		else if (r == 0 && s > 0 && p == 0) d2p[r][s][p] = 1;
		else
		{
			d2p[r][s][p] = 0;

			//rock and scissors meet with this probability
			d2p[r][s][p] += (((double)(r*s))/((double)(r*s+s*p+r*p)))*prob_sleft(r, s-1, p);

			//rock and papers meet with this probability
			d2p[r][s][p] += (((double)(r*p))/((double)(r*s+s*p+r*p)))*prob_sleft(r-1, s, p);

			//papers and scissors meet with this probability
			d2p[r][s][p] += (((double)(p*s))/((double)(r*s+s*p+r*p)))*prob_sleft(r, s, p-1);
		}
	}
	return d2p[r][s][p];
}

int main()
{
	std::ios_base::sync_with_stdio(false);
	std::cin.tie(NULL);
	std::cout.tie(NULL);
	int r, s, p;
	for (int i = 0; i < 105; i++)
	{
		for (int j = 0; j < 105; j++)
		{
			for (int k = 0; k < 105; k++)
			{
				dp[i][j][k] = -100;
				d2p[i][j][k] = -100;
			}
		}
	}

	std::cin >> r >> s >> p;
	std::cout << std::fixed << std::setprecision(12) << prob_rleft(r, s, p) << ' ' << prob_sleft(r, s, p) << ' ' << 1-prob_rleft(r, s, p)-prob_sleft(r, s, p) << '\n';
}


#include<stdio.h>
#include<stdlib.h>
#include<iostream>
#include<cstdio>
using namespace std;
double f[105][105][105];

double getc(int a,int b,int tot)
{
	tot=tot*(tot-1)/2;
	return ((double)a*b/tot);
}

double getans(int r,int s,int p)
{
	int i,j,t;
	for (i=0; i<=r; i++)
	    for (j=0; j<=s; j++)
	        for (t=0; t<=p; t++)
	        {
	        	if (i==0 && j==0 && t==0) continue;
	        	if (i>0 && j==0 && t==0) f[i][j][t]=1;
	        	else if (i==0) f[i][j][t]=0;
	        	else
	        	{
	        		 f[i][j][t]=0;   double p=1;
	        		 if (i>0 && j>0)
					 {
					       f[i][j][t]+=(getc(i,j,i+j+t)*f[i][j-1][t]);
					       p-=getc(i,j,i+j+t);
					 }
	        		 if (i>0 && t>0)
					 {
					       f[i][j][t]+=(getc(i,t,i+j+t)*f[i-1][j][t]);
					       p-=getc(i,t,i+j+t);
					 }
	        		 if (j>0 && t>0)
					 {
					       f[i][j][t]+=(getc(j,t,i+j+t)*f[i][j][t-1]);
					       p-=getc(j,t,i+j+t);
					 }
					 f[i][j][t]=f[i][j][t]/(1-p);
	        	}
	        }
	return f[r][s][p];
}

int main()
{
	int x,y,z;
	//freopen("in.txt","r",stdin);
	cin>>x>>y>>z;
	printf("%.10lf ",getans(x,y,z));
	printf("%.10lf ",getans(y,z,x));
	printf("%.10lf\n",getans(z,x,y));
	return 0;
}


#include <iostream>
#include <stdio.h>      /* printf */
#include <math.h>       /* log */
#include <string>
#include <map>
#include <iomanip>
using namespace std;

typedef long double typeR[3][1100000];

long index(long r, long s, long p)
{
    return r+s*101+p*101*101;
}

void calc(long r, long s, long p, long double** result)
{
    long indx = index(r,s,p);
    for (int i=0;i<=2;i++) result[i][indx] = 0;

    if ((r==0) && (s==0) && (p == 0)) return;
    if ((r>=1) && (p==0)) {result[0][indx] = 1; return;}
    if ((s>=1) && (r==0)) {result[1][indx] = 1; return;}
    if ((p>=1) && (s==0)) {result[2][indx] = 1; return;}

    long double sum = p*r+s*r+p*s;
    long double pr = p*r/sum;
    long double ps = s*r/sum;
    long double pp = p*s/sum;

    result[0][indx] = pr*result[0][index(r-1,s,p)]+ps*result[0][index(r,s-1,p)]+pp*result[0][index(r,s,p-1)];
    result[1][indx] = pr*result[1][index(r-1,s,p)]+ps*result[1][index(r,s-1,p)]+pp*result[1][index(r,s,p-1)];
    result[2][indx] = pr*result[2][index(r-1,s,p)]+ps*result[2][index(r,s-1,p)]+pp*result[2][index(r,s,p-1)];
}

int main()
{
    int r, s, p;
    cin >> r >> s >> p;

    //typeR result;
    long double** result;
    result = new long double * [3];
    for (int i = 0; i < 3; i++)
    {   // (3)
        result[i] = new long double [1100000];     // инициализация указателей
    }
    //
    //&result[0][0][0][0] = mem;

    for (int ir = 0 ; ir <= r; ir++)
        for (int is = 0; is <= s; is++)
            for (int ip = 0; ip <= p; ip++)
            {
                calc(ir, is, ip, result);
            }

    cout << fixed<<setprecision(12) << result[0][index(r,s,p)] << " " << result[1][index(r,s,p)] << " " << result[2][index(r,s,p)] << endl;

//  cin >> r;

    return 0;
}


#include <iostream>
#include <stdio.h>      /* printf */
#include <math.h>       /* log */
#include <string>
#include <map>
#include <iomanip>
using namespace std;

typedef long double typeR[3];

int calc(long r, long s, long p, typeR result)
{
    if ((s==0) && (p==0))
    {
        result[0] = 1;
        result[1] = 0;
        result[2] = 0;
        return 0;
    }
    if ((r== 0) && (p==0))
    {
        result[0] = 0;
        result[1] = 1;
        result[2] = 0;
        return 0;
    }
    if ((r== 0) && (s==0))
    {
        result[0] = 0;
        result[1] = 0;
        result[2] = 1;
        return 0;
    }

    typeR rr, rs, rp;
    if (r > 0) calc(r-1,s,p,rr);
    if (s > 0) calc(r,s-1,p,rs);
    if (p > 0) calc(r,s,p-1,rp);

    long double sum = p*r+s*r+p*s;
    long double pr = p*r/sum;
    long double ps = s*r/sum;
    long double pp = p*s/sum;

    result[0] = pr*rr[0]+ps*rs[0]+pp*rp[0];
    result[1] = pr*rr[1]+ps*rs[1]+pp*rp[1];
    result[2] = pr*rr[2]+ps*rs[2]+pp*rp[2];
    return 0;
}

int main()
{
    long r, s, p;
    cin >> r >> s >> p;

    typeR result;
    calc(r,s,p,result);

    cout << fixed<<setprecision(12) << result[0] << " " << result[1] << " " << result[2] << endl;

    return 0;
}


#include <iostream>
using namespace std;

double * prob;
bool * bprob;

#define getId(i1,i2,i3) (i1*10201+i2*101+i3)

double getProb(int i1, int i2, int i3)
{
	int id = getId(i1, i2, i3);
	if (bprob[id])
		return prob[id];

	double dv = 1.0 / (i1*i2 + i1*i3 + i2*i3);
	double res = 0.0;
	if (i2>0)
		res += i1*i2*dv*getProb(i1, i2 - 1, i3);
	if (i1>0)
		res += i1*i3*dv*getProb(i1-1, i2, i3);
	if (i3>0)
		res += i2*i3*dv*getProb(i1, i2, i3-1);

	prob[id] = res;
	bprob[id] = true;
	return res;
}

int main()
{
	prob = new double[1030300];
	bprob = new bool[1030300]();
	for (int i = 0; i <= 100; i++)
	{
		prob[getId(i, 0, 0)] = 1.0; bprob[getId(i, 0, 0)] = true;
		prob[getId(0, i, 0)] = 0.0; bprob[getId(0, i, 0)] = true;
		prob[getId(0, 0, i)] = 0.0; bprob[getId(0, 0, i)] = true;
	}

	int r, s, p;
	cin >> r >> s >> p;
	cout.precision(15);
	cout << getProb(r, s, p) << " " << getProb(s, p, r) << " " << getProb(p, r, s) << endl;

	return 0;
}


#pragma comment(linker,"/STACK:102400000,102400000")
#include<iostream>
#include<vector>
#include<algorithm>
#include<cmath>
#include<string>
#include<stack>
#include<cstdio>
#include<queue>
#include<map>
#include<set>
#include<time.h>
#include<cstdlib>
#include<list>
#include<cstring>
#include<iterator>
#include<fstream>
#include<sstream>
using namespace std;
#define inf 1888888888
#define PI acos(-1.0)
#define FIR 1,n,1
#define LEFT l,mid,dq<<1
#define RIGHT mid+1,r,dq<<1|1
#define L (dq<<1)
#define R (dq<<1|1)
#define DQ l,r,dq
#define MID (l+r)>>1
#define LL __int64
template<class _T> inline _T low(_T n){return n&(-n);}
template<class _T> inline void swapp(_T &x,_T &y){_T t;t=x,x=y,y=t;}
template<class _T> inline _T minn(_T i,_T j){return i>j?j:i;}
template<class _T> inline _T maxx(_T i,_T j){return i>j?i:j;}
template<class _T> inline _T gcd(_T b,_T c){return b&&c?(c?gcd(c,b%c):b):b|c;}
template<class _T> inline _T abss(_T b){return b>0?b:-b;}
double dp[101][101][101][3];
void A(double dp[],double i,double j,double k){
	dp[0]=i;dp[1]=j;dp[2]=k;
}
int main(){
	int i,j,k;
	double ss,di,dj,dk;
	for(i=0;i<101;i++)
		for(j=0;j<101;j++)
			for(k=0;k<101;k++){
				if(i==0&&j==0&&k==0)continue;
				if(i==0){
					if(j)A(dp[i][j][k],0.0,1.0,0.0);
					else A(dp[i][j][k],0.0,0.0,1.0);
				}
				else if(j==0){
					if(k)A(dp[i][j][k],0.0,0.0,1.0);
					else A(dp[i][j][k],1.0,0.0,0.0);
				}
				else if(k==0){
					if(i)A(dp[i][j][k],1.0,0.0,0.0);
					else A(dp[i][j][k],0.0,1.0,0.0);
				}
				else{
					ss=i*j+j*k+i*k;
					di=i*k/ss;dj=i*j/ss;dk=j*k/ss;
					A(dp[i][j][k],di*dp[i-1][j][k][0]+dj*dp[i][j-1][k][0]+dk*dp[i][j][k-1][0],di*dp[i-1][j][k][1]+dj*dp[i][j-1][k][1]+dk*dp[i][j][k-1][1],di*dp[i-1][j][k][2]+dj*dp[i][j-1][k][2]+dk*dp[i][j][k-1][2]);
				}
			}
		scanf("%d%d%d",&i,&j,&k);
		printf("%.12lf %.12lf %.12lf\n",dp[i][j][k][0],dp[i][j][k][1],dp[i][j][k][2]);
	return 0;
}


#define _CRT_SECURE_NO_WARNINGS

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <vector>
#include <cstring>
#include <string>
#include <cmath>
#include <set>
#include <ctime>
#include <cstdlib>
#include <map>
#include <queue>

using namespace std;

double dp[105][105][105];

int main()
{
    int x, y, z;
    cin >> x >> y >> z;
    dp[x][y][z] = 1;
    for (int i = x; i >= 0; i--)
    {
        for (int j = y; j >= 0; j--)
        {
            for (int k = z; k >= 0; k--)
            {
                if (i * j + j * k + i * k <= 0)
                    continue;
                double p = 1.0 / (i * j + j * k + i * k);
                if (i > 0)
                    dp[i - 1][j][k] += p * i * k * dp[i][j][k];
                if (j > 0)
                    dp[i][j - 1][k] += p * i * j * dp[i][j][k];
                if (k > 0)
                    dp[i][j][k - 1] += p * j * k * dp[i][j][k];
            }
        }
    }
    double ans[3] = {0, 0, 0};
    for (int i = 1; i <= x; i++)
        ans[0] += dp[i][0][0];
    for (int i = 1; i <= y; i++)
        ans[1] += dp[0][i][0];
    for (int i = 1; i <= z; i++)
        ans[2] += dp[0][0][i];
    printf("%.12lf %.12lf %.12lf\n", ans[0], ans[1], ans[2]);

    return 0;
}


# include <iostream>
# include <math.h>
# include <fstream>
# include <vector>
# include <algorithm>
# include <string>
# include <set>
using namespace std;
//printf ("%.8lf\n", a);
// erase

/*
    ifstream fin;
    fin.open("input.txt");
    ofstream fout;
    fout.open("output.txt");
*/

# define all(a) a.begin(), a.end()
# define Sort(a) sort(all(a));
# define pause system("pause");
# define ll long long
# define VI vector <int>
# define vll vector <ll>
# define pb push_back
# define pob pop_back
# define Graph vector < vector <bool> >

double x[101][101][101];

int main()
{
    int r, s, p, c;
    cin>>r>>s>>p;

    //int q=max( r, max(s, p) );

    for(int i=1; i<=100; ++i)
    for(int j=1; j<=100; ++j)
    {
        x[0][i][j]=0;

        x[i][j][0]=1;
        x[i][0][j]=0;
    }

    for(int i=0; i<=100; ++i)
    {
        x[0][0][i]=0;
        x[0][i][0]=0;
        x[i][0][0]=1;
    }

    for(int s=3; s<=300; ++s)
    {
        for(int a=1; a<min(101,s-1); ++a)
        for(int b=1; b<s-a; ++b)
        {
            c=(s-a)-b;

            if(c>100) break;

            x[a][b][c] = (double(b*c)*x[a][b][c-1] + double(c*a)*x[a-1][b][c] + double(b*a)*x[a][b-1][c]) /double(a*b + b*c + c*a);
        }
    }

    printf ("%.11lf %.11lf %.11lf\n", x[r][s][p], x[s][p][r], x[p][r][s]);

    //pause;

}


# include <iostream>
# include <math.h>
# include <fstream>
# include <vector>
# include <algorithm>
# include <string>
# include <set>
using namespace std;
//printf ("%.8lf\n", a);
// erase

/*
    ifstream fin;
    fin.open("input.txt");
    ofstream fout;
    fout.open("output.txt");
*/

# define all(a) a.begin(), a.end()
# define Sort(a) sort(all(a));
# define pause system("pause");
# define ll long long
# define VI vector <int>
# define vll vector <ll>
# define pb push_back
# define pob pop_back
# define Graph vector < vector <bool> >

double x[101][101][101];

int main()
{
    int r, s, p, c;
    cin>>r>>s>>p;

    //int q=max( r, max(s, p) );

    for(int i=1; i<=100; ++i)
    for(int j=1; j<=100; ++j)
    {
        x[0][i][j]=0;

        x[i][j][0]=1;
        x[i][0][j]=0;
    }

    for(int i=0; i<=100; ++i)
    {
        x[0][0][i]=0;
        x[0][i][0]=0;
        x[i][0][0]=1;
    }

    for(int s=3; s<=300; ++s)
    {
        for(int a=1; a<min(101,s-1); ++a)
        for(int b=1; b<s-a; ++b)
        {
            c=(s-a)-b;

            if(c<=100&& b<=100)

            x[a][b][c] = (double(b*c)*x[a][b][c-1] + double(c*a)*x[a-1][b][c] + double(b*a)*x[a][b-1][c]) /double(a*b + b*c + c*a);
        }
    }

    printf ("%.11lf %.11lf %.11lf\n", x[r][s][p], x[s][p][r], x[p][r][s]);

    //pause;

}


#include <iostream>
#include <vector>
#include <cstdio>
using namespace std;

vector < vector < vector <double> > > dp;
vector < vector < vector <double> > > was;
double DFS(int r, int s, int p)
{
    if (was[r][s][p])
        return dp[r][s][p];
    double sum = r*s + s*p + p*r;
    if (p + 1 < dp[0][0].size() && s)
        dp[r][s][p] += DFS(r, s, p+1) * s * (p+1) / (sum + r + s);
    if (s + 1 < dp[0].size() && r)
        dp[r][s][p] += DFS(r, s+1, p) * r * (s+1) / (sum + p + r);
    if (r + 1 < dp.size() && p)
        dp[r][s][p] += DFS(r+1, s, p) * p * (r+1) / (sum + p + s);

    was[r][s][p] = true;
    return dp[r][s][p];
}

int main()
{
    int r, s, p;
    cin >> r >> s >> p;
    dp.resize(r+1);
    was.resize(r+1);
    for (int i = 0; i <= r; i++)
    {
        dp[i].resize(s+1);
        was[i].resize(s+1);
        for (int j = 0; j <= s; j++)
        {
            dp[i][j].resize(p+1, 0);
            was[i][j].resize(p+1, false);
        }
    }

    dp[r][s][p] = 1;
    was[r][s][p] = true;

    double res = 0;
    for (int i = 1; i <= r; i++)
        res += DFS(i, 0, 0);
    printf("%.9lf", res);
    res = 0;
    for (int i = 1; i <= s; i++)
        res += DFS(0, i, 0);
    printf("%.9lf", res);
    res = 0;
    for (int i = 1; i <= p; i++)
        res += DFS(0, 0, i);
    printf("%.9lf", res);
}


#include <iostream>
#include <vector>
#include <cstdio>
using namespace std;

vector < vector < vector <double> > > dp;
vector < vector < vector <double> > > was;
double DFS(int r, int s, int p)
{
    if (was[r][s][p])
        return dp[r][s][p];
    double sum = r*s + s*p + p*r;
    if (p + 1 < dp[0][0].size() && s)
        dp[r][s][p] += DFS(r, s, p+1) * s * (p+1) / (sum + r + s);
    if (s + 1 < dp[0].size() && r)
        dp[r][s][p] += DFS(r, s+1, p) * r * (s+1) / (sum + p + r);
    if (r + 1 < dp.size() && p)
        dp[r][s][p] += DFS(r+1, s, p) * p * (r+1) / (sum + p + s);

    was[r][s][p] = true;
    return dp[r][s][p];
}

int main()
{
    int r, s, p;
    cin >> r >> s >> p;
    dp.resize(r+1);
    was.resize(r+1);
    for (int i = 0; i <= r; i++)
    {
        dp[i].resize(s+1);
        was[i].resize(s+1);
        for (int j = 0; j <= s; j++)
        {
            dp[i][j].resize(p+1, 0);
            was[i][j].resize(p+1, false);
        }
    }

    dp[r][s][p] = 1;
    was[r][s][p] = true;

    double res = 0;
    for (int i = 1; i <= r; i++)
        res += DFS(i, 0, 0);
    printf("%.9lf ", res);
    res = 0;
    for (int i = 1; i <= s; i++)
        res += DFS(0, i, 0);
    printf("%.9lf ", res);
    res = 0;
    for (int i = 1; i <= p; i++)
        res += DFS(0, 0, i);
    printf("%.9lf ", res);
}


#include<iostream>
#include<iomanip>
#include<vector>
#include<string>
#include<algorithm>
#include<math.h>
#include<conio.h>

using namespace std;
double d[105][105][105];

void main ()
{
    int r,s,p;
    cin >> r >> s >> p;

    int i,  j , k;
    d[r][s][p] = 1;
    for (int sum = r + s + p; sum > 0; sum--) {
    for (i=r;i>=0;i--)
        for (j=s;j>=0;j--)
            //for (k=p;k>=0;k--)
            {
                int k = sum - i - j;
                if (k < 0 || k > p) continue;

                if (i==0 && j==0 && k==0) continue;
                if (i == 0 && j == 0) continue;
                if (i == 0 && k == 0) continue;
                if (j == 0 && k == 0) continue;
                double cur = d[i][j][k];
                int wholeWays = i*j + j*k + k*i;

                if (i > 0) d[i][j-1][k] += cur*(i*j)/wholeWays;
                if (j > 0) d[i][j][k-1] += cur*(j*k)/wholeWays;
                if (k > 0) d[i-1][j][k] += cur*(i*k)/wholeWays;
            }
    }
    double r_win = 0, s_win = 0, p_win = 0;
    j = 0; k = 0;
    for (i=1;i<=r;i++)
    {
        r_win += d[i][j][k];
    }
    i = 0; k = 0;
    for (j=1;j<=s;j++)
    {
        s_win += d[i][j][k];
    }
    j = 0; i = 0;
    for (k=1;k<=p;k++)
    {
        p_win += d[i][j][k];
    }

    cout << setprecision(12) << r_win << " "<< s_win << " "<< p_win ;

    return;

}


#include <cstdio>
#include <iostream>
#include<iomanip>
#include<vector>
#include<string>
#include<algorithm>
#include<math.h>
#include<conio.h>

using namespace std;
typedef long double ld;

ld a[105][105][105];

int main() {
        int R, S, P;
        cin >> R >> S >> P;

        a[R][S][P] = 1;
        for (int sum = R + S + P; sum > 0; sum--) {
                for (int r = R; r >= 0; r--) {
                        for (int s = S; s >= 0; s--) {
                                int p = sum - r - s;
                                if (p < 0 || p > P) continue;
                                if (r == 0 && s == 0) continue;
                                if (r == 0 && p == 0) continue;
                                if (s == 0 && p == 0) continue;
                                ld cur = a[r][s][p];
                                int waysR = r * s;
                                int waysS = s * p;
                                int waysP = p * r;
                                int totalWays = waysR + waysS + waysP;
                                if (r > 0) a[r - 1][s][p] += cur * waysP / totalWays;
                                if (s > 0) a[r][s - 1][p] += cur * waysR / totalWays;
                                if (p > 0) a[r][s][p - 1] += cur * waysS / totalWays;
                        }
                }
        }

        ld ansR = 0;
        ld ansS = 0;
        ld ansP = 0;
        for (int r = 1; r <= R; r++) ansR += a[r][0][0];
        for (int s = 1; s <= S; s++) ansS += a[0][s][0];
        for (int p = 1; p <= P; p++) ansP += a[0][0][p];

        printf("%.12f %.12f %.12f\n", (double)ansR, (double)ansS, (double)ansP);
}


#include<string>
#include<algorithm>
#include<math.h>
#include<conio.h>

using namespace std;
typedef long double ld;

ld a[105][105][105];

int main() {
        int R, S, P;
        cin >> R >> S >> P;

        a[R][S][P] = 1;
        for (int sum = R + S + P; sum > 0; sum--) {
                for (int r = R; r >= 0; r--) {
                        for (int s = S; s >= 0; s--) {
                                int p = sum - r - s;
                                if (p < 0 || p > P) continue;
                                if (r == 0 && s == 0) continue;
                                if (r == 0 && p == 0) continue;
                                if (s == 0 && p == 0) continue;
                                ld cur = a[r][s][p];
                                int waysR = r * s;
                                int waysS = s * p;
                                int waysP = p * r;
                                int totalWays = waysR + waysS + waysP;
                                if (r > 0) a[r - 1][s][p] += cur * waysP / totalWays;
                                if (s > 0) a[r][s - 1][p] += cur * waysR / totalWays;
                                if (p > 0) a[r][s][p - 1] += cur * waysS / totalWays;
                        }
                }
        }

        ld ansR = 0;
        ld ansS = 0;
        ld ansP = 0;
        for (int r = 1; r <= R; r++) ansR += a[r][0][0];
        for (int s = 1; s <= S; s++) ansS += a[0][s][0];
        for (int p = 1; p <= P; p++) ansP += a[0][0][p];

        printf("%.12f %.12f %.12f\n", (double)ansR, (double)ansS, (double)ansP);
}


typedef long double ld;

ld a[105][105][105];

int main() {
        int R, S, P;
        cin >> R >> S >> P;

        a[R][S][P] = 1;
        for (int sum = R + S + P; sum > 0; sum--) {
                for (int r = R; r >= 0; r--) {
                        for (int s = S; s >= 0; s--) {
                                int p = sum - r - s;
                                if (p < 0 || p > P) continue;
                                if (r == 0 && s == 0) continue;
                                if (r == 0 && p == 0) continue;
                                if (s == 0 && p == 0) continue;
                                ld cur = a[r][s][p];
                                int waysR = r * s;
                                int waysS = s * p;
                                int waysP = p * r;
                                int totalWays = waysR + waysS + waysP;
                                if (r > 0) a[r - 1][s][p] += cur * waysP / totalWays;
                                if (s > 0) a[r][s - 1][p] += cur * waysR / totalWays;
                                if (p > 0) a[r][s][p - 1] += cur * waysS / totalWays;
                        }
                }
        }

        ld ansR = 0;
        ld ansS = 0;
        ld ansP = 0;
        for (int r = 1; r <= R; r++) ansR += a[r][0][0];
        for (int s = 1; s <= S; s++) ansS += a[0][s][0];
        for (int p = 1; p <= P; p++) ansP += a[0][0][p];

        printf("%.12f %.12f %.12f\n", (double)ansR, (double)ansS, (double)ansP);
}


#include<iostream>
#include<cstdio>

#include<string>
#include<vector>
#include<set>
#include<map>
#include<queue>
#include<deque>
#include<stack>

#include<iomanip>
#include<algorithm>
#include<cstring>
#include<ctime>
#include<cassert>

using namespace std;

#define forn(i, n) for(int i = 0; i < (int)(n); ++i)
#define correct(x, y, n, m) (0 <= x && x < n && 0 <= y && y < m)
#define X first
#define Y second
#define all(a) a.begin(), a.end()
#define pb push_back
#define mp make_pair
#define sz(v) (int)(v.size())

template<typename T> inline T abs(T a){ return ((a < 0) ? -a : a); }
template<typename T> inline T sqr(T a){ return a * a; }

typedef long long li;
typedef unsigned long long uli;
typedef long double ld;
typedef pair<int, int> pt;

const int N = 109;
const int sqrN = 450;
const int MOD = 1000000007;
const int INF = 1e9;
const li INF64 = 1e18;
const ld PI = 3.1415926535897932384626433832795;
const ld eps = 1e-9;

int dx[] = {0, 0, -1, 1};
int dy[] = {-1, 1, 0, 0};

bool u[N][N][N][3];
ld dp[N][N][N][3];
int cnt[N][N];

int rec(int mx, int mn){
    if(mx == 0)
        return 1;
    return mx * rec(mx - 1, mn - 1);
}

void precalc(){
    forn(i, N)
        forn(j, N){

            cnt[i][j] = i * j;
        }
}

ld calc_dp(int r, int s, int p, int t){
    if(r < 0 || s < 0 || p < 0)
        return .0;
    ld &res = dp[r][s][p][t];
    if(u[r][s][p][t])
        return res;
    u[r][s][p][t] = true;
    res = .0;
    if(t == 0 && r == 0)
        return res;
    if(t == 1 && s == 0)
        return res;
    if(t == 2 && p == 0)
        return res;

    if(t == 0 && s + p == 0)
        return res = 1.0;
    if(t == 1 && r + p == 0)
        return res = 1.0;
    if(t == 2 && r + s == 0)
        return res = 1.0;

    int rs = cnt[r][s], rp = cnt[r][p], sp = cnt[s][p];
    int sum = rs + rp + sp;
    res = ld(rs) / ld(sum) * calc_dp(r, s - 1, p, t) + ld(rp) / ld(sum) * calc_dp(r - 1, s, p, t) + ld(sp) / ld(sum) * calc_dp(r, s, p - 1, t);

    return res;
}

int main(){
#ifdef _DEBUG
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
#endif

    srand(time(NULL));
    cout << setprecision(10) << fixed;
    cerr << setprecision(10) << fixed;

    int r, s, p;
    cin >> r >> s >> p;

    precalc();
    cout << calc_dp(r, s, p, 0) << ' ' << calc_dp(r, s, p, 1) << ' ' << calc_dp(r, s, p, 2);
    return 0;
}