import java.util.HashMap;
import java.util.Map;

public class Euler815 {

    static final int kBase = 61;

    static int pack(int n0, int n1, int n2, int n3) {
        return (((n0 * kBase) + n1) * kBase + n2) * kBase + n3;
    }

    static int[] unpack(int key) {
        int n3 = key % kBase;
        key /= kBase;
        int n2 = key % kBase;
        key /= kBase;
        int n1 = key % kBase;
        key /= kBase;
        int n0 = key;
        return new int[] { n0, n1, n2, n3 };
    }

    static double probMaxLt(int n, int k) {
        HashMap<Integer, Double> cur = new HashMap<>();
        cur.put(pack(n, 0, 0, 0), 1.0);

        int totalCards = 4 * n;

        for (int step = 0; step < totalCards; ++step) {
            HashMap<Integer, Double> nxt = new HashMap<>();

            for (Map.Entry<Integer, Double> entry : cur.entrySet()) {
                int key = entry.getKey();
                double prob = entry.getValue();

                int[] unpacked = unpack(key);
                int n0 = unpacked[0];
                int n1 = unpacked[1];
                int n2 = unpacked[2];
                int n3 = unpacked[3];

                int remaining = 4 * n0 + 3 * n1 + 2 * n2 + n3;
                int piles = n1 + n2 + n3;
                double inv = 1.0 / remaining;

                if (n0 > 0 && piles + 1 < k) {
                    double add = prob * (4 * n0) * inv;
                    int nxtKey = pack(n0 - 1, n1 + 1, n2, n3);
                    nxt.put(nxtKey, nxt.getOrDefault(nxtKey, 0.0) + add);
                }
                if (n1 > 0 && piles < k) {
                    double add = prob * (3 * n1) * inv;
                    int nxtKey = pack(n0, n1 - 1, n2 + 1, n3);
                    nxt.put(nxtKey, nxt.getOrDefault(nxtKey, 0.0) + add);
                }
                if (n2 > 0 && piles < k) {
                    double add = prob * (2 * n2) * inv;
                    int nxtKey = pack(n0, n1, n2 - 1, n3 + 1);
                    nxt.put(nxtKey, nxt.getOrDefault(nxtKey, 0.0) + add);
                }
                if (n3 > 0 && piles - 1 < k) {
                    double add = prob * n3 * inv;
                    int nxtKey = pack(n0, n1, n2, n3 - 1);
                    nxt.put(nxtKey, nxt.getOrDefault(nxtKey, 0.0) + add);
                }
            }

            cur = nxt;
            if (cur.isEmpty()) {
                return 0.0;
            }
        }

        return cur.getOrDefault(pack(0, 0, 0, 0), 0.0);
    }

    static double expectedMaxPiles(int n) {
        double ans = 0.0;
        for (int k = 1; k <= n; ++k) {
            ans += (1.0 - probMaxLt(n, k));
        }
        return ans;
    }

    public static String solve() {
        double e60 = expectedMaxPiles(60);
        double rounded = Math.round(e60 * 100000000.0) / 100000000.0;
        return String.format(java.util.Locale.US, "%.8f", rounded);
    }

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