import java.text.DecimalFormat;
import java.text.DecimalFormatSymbols;
import java.util.Locale;

public class Euler796 {

    static long binom(int n, int k) {
        if (k < 0 || k > n) {
            return 0;
        }
        k = Math.min(k, n - k);
        long res = 1;
        for (int i = 1; i <= k; ++i) {
            res = res * (n - k + i) / i;
        }
        return res;
    }

    static double expectedFormula(int decks, int suits, int ranks, int jokersPerDeck,
            boolean needSuits, boolean needRanks, boolean needDecks) {
        long totalCards = (long) decks * ((long) suits * ranks + jokersPerDeck);

        int maxS = needSuits ? suits : 0;
        int maxR = needRanks ? ranks : 0;
        int maxD = needDecks ? decks : 0;

        double ans = 0.0; // Using double instead of long double is sufficient for 8 decimal places here
                          // usually, but if precision issues arise, BigDecimal might be needed. For this
                          // logic, Python float (double equivalent) passes test.

        for (int s = 0; s <= maxS; ++s) {
            long cs = needSuits ? binom(suits, s) : 1;
            for (int r = 0; r <= maxR; ++r) {
                long cr = needRanks ? binom(ranks, r) : 1;
                for (int d = 0; d <= maxD; ++d) {
                    long cd = needDecks ? binom(decks, d) : 1;

                    int missed = s + r + d;
                    if (missed == 0)
                        continue;

                    long safePerDeck = (long) (suits - s) * (ranks - r) + jokersPerDeck;
                    long safeCards = (long) (decks - d) * safePerDeck;
                    long badCards = totalCards - safeCards;

                    double weight = (double) (totalCards + 1) / (double) (badCards + 1);
                    double mult = (double) cs * (double) cr * (double) cd;

                    if ((missed & 1) == 1) {
                        ans += mult * weight;
                    } else {
                        ans -= mult * weight;
                    }
                }
            }
        }

        return ans;
    }

    public static String solve() {
        double ans = expectedFormula(10, 4, 13, 2, true, true, true);
        DecimalFormatSymbols symbols = new DecimalFormatSymbols(Locale.US);
        DecimalFormat df = new DecimalFormat("0.00000000", symbols);
        return df.format(ans);
    }

    public static void main(String[] args) {
        System.out.println(solve());
    }
}