#include <bits/stdc++.h>
using namespace std;

struct iofast_t {
    iofast_t() {
        ios::sync_with_stdio(false);
        cin.tie(nullptr);
    }
} iofast;

struct uns_t {} uns;
template <typename Element, typename Head, typename ...Args>
auto vec(Element init, Head arg, Args ...args) {
    if constexpr (sizeof...(Args) == 0) return std::vector(arg, init);
    else return std::vector(arg, vec(init, args...));
}
template <typename Element, typename Head, typename ...Args>
auto vec(uns_t, Head arg, Args ...args) {
    return vec(Element(), arg, args...);
}

template <typename T, typename Compare = less<T>>
T &chmin(T &l, T r, Compare &&f = less<T>()) { return l = min(l, r, f); }
template <typename T, typename Compare = less<T>>
T &chmax(T &l, T r, Compare &&f = less<T>()) { return l = max(l, r, f); }

int main() {
    cout << fixed << setprecision(15);

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

    auto dp = vec<double>(0, n + 1, a + 1, b + 1, c + 1);

    dp[0][0][0][0] = 1;
    for (int i = 1; i <= n; ++i) {
        for (int x = 0; x <= a; ++x) {
            for (int y = 0; y <= b; ++y) {
                for (int z = 0; z <= c; ++z) {
                    int p = a - x;
                    int q = b - y;
                    int r = c - z;

                    if (0 < (p + q + r) * (p + q + r - 1) / 2) {
                        dp[i][x][y][z] =
                            dp[i - 1][x][y][z] *
                            (p * q + p * r + q * r) / ((p + q + r) * (p + q + r - 1) / 2);
                    }

                    if ((p + q + r) * (p + q + r + 1) <= 0) {
                        continue;
                    }

                    if (0 <= x - 1) {
                        dp[i][x][y][z] += dp[i - 1][x - 1][y][z] * (p * (p + 1)) / ((p + q + r) * (p + q + r + 1));
                    }
                    if (0 <= y - 1) {
                        dp[i][x][y][z] += dp[i - 1][x][y - 1][z] * (q * (q + 1)) / ((p + q + r) * (p + q + r + 1));
                    }
                    if (0 <= z - 1) {
                        dp[i][x][y][z] += dp[i - 1][x][y][z - 1] * (r * (r + 1)) / ((p + q + r) * (p + q + r + 1));
                    }
                }
            }
        }
    }

    double ans1 = 0, ans2 = 0, ans3 = 0;
    for (int i = 0; i <= a; ++i) {
        for (int j = 0; j <= b; ++j) {
            for (int k = 0; k <= c; ++k) {
                ans1 += i * dp[n][i][j][k];
                ans2 += j * dp[n][i][j][k];
                ans3 += k * dp[n][i][j][k];
            }
        }
    }

    cout << ans1 << ' ' << ans2 << ' ' << ans3 << endl;
}