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

public class Euler687 {
    static class ProbDP {
        Map<Integer, Double> memo = new HashMap<>();

        static int encode(int f, int c1, int c2, int c3, int c4, int prev) {
            int p = (prev < 0) ? 0 : prev;
            return f | (c1 << 6) | (c2 << 10) | (c3 << 14) | (c4 << 18) | (p << 22);
        }

        double dfs(int f, int c1, int c2, int c3, int c4, int prev) {
            int rem = f + c1 + 2 * c2 + 3 * c3 + 4 * c4;
            if (rem == 0)
                return 1.0;

            int key = encode(f, c1, c2, c3, c4, prev);
            if (memo.containsKey(key)) {
                return memo.get(key);
            }

            double out = 0.0;

            if (f > 0) {
                out += ((double) f / rem) * dfs(f - 1, c1, c2, c3, c4, -1);
            }

            if (c1 > 0) {
                int avail = c1;
                if (prev == 1)
                    avail--;
                if (avail > 0) {
                    double prob = (double) (avail * 1) / rem;
                    out += prob * dfs(f, c1 - 1, c2, c3, c4, -1);
                }
            }

            if (c2 > 0) {
                int avail = c2;
                if (prev == 2)
                    avail--;
                if (avail > 0) {
                    double prob = (double) (avail * 2) / rem;
                    out += prob * dfs(f, c1 + 1, c2 - 1, c3, c4, 1);
                }
            }

            if (c3 > 0) {
                int avail = c3;
                if (prev == 3)
                    avail--;
                if (avail > 0) {
                    double prob = (double) (avail * 3) / rem;
                    out += prob * dfs(f, c1, c2 + 1, c3 - 1, c4, 2);
                }
            }

            if (c4 > 0) {
                int avail = c4;
                if (prev == 4)
                    avail--;
                if (avail > 0) {
                    double prob = (double) (avail * 4) / rem;
                    out += prob * dfs(f, c1, c2, c3 + 1, c4 - 1, 3);
                }
            }

            memo.put(key, out);
            return out;
        }

        double probAllPerfect(int j) {
            memo.clear();
            return dfs(52 - 4 * j, 0, 0, 0, j, -1);
        }
    }

    public static String solve() {
        int[][] C = new int[14][14];
        for (int n = 0; n <= 13; ++n) {
            C[n][0] = 1;
            C[n][n] = 1;
            for (int k = 1; k < n; ++k) {
                C[n][k] = C[n - 1][k - 1] + C[n - 1][k];
            }
        }

        ProbDP solver = new ProbDP();

        double[] p = new double[14];
        p[0] = 1.0;
        for (int j = 1; j <= 13; ++j) {
            p[j] = solver.probAllPerfect(j);
        }

        double[] M = new double[14];
        for (int j = 0; j <= 13; ++j) {
            M[j] = C[13][j] * p[j];
        }

        double[] P = new double[14];
        for (int k = 13; k >= 0; --k) {
            double v = M[k];
            for (int t = k + 1; t <= 13; ++t) {
                v -= C[t][k] * P[t];
            }
            P[k] = v;
        }

        int[] primes = { 2, 3, 5, 7, 11, 13 };
        double ans = 0.0;
        for (int pval : primes) {
            ans += P[pval];
        }

        return String.format(Locale.US, "%.10f", ans);
    }

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