import java.math.BigDecimal;
import java.math.MathContext;

public class Euler807 {

    static class Result {
        BigDecimal probZero;
        BigDecimal totalMass;
    }

    static Result computeProbability(int n) {
        MathContext mc = new MathContext(60);

        int m = n - 1;
        int maxDeg = 2 * m;
        int offset = m;

        BigDecimal[][] curr = new BigDecimal[2 * m + 1][maxDeg + 1];
        for (int i = 0; i < 2 * m + 1; i++) {
            for (int j = 0; j <= maxDeg; j++) {
                curr[i][j] = BigDecimal.ZERO;
            }
        }
        curr[offset][0] = BigDecimal.ONE;

        for (int step = 1; step <= m; ++step) {
            BigDecimal[][] next = new BigDecimal[2 * m + 1][maxDeg + 1];
            for (int i = 0; i < 2 * m + 1; i++) {
                for (int j = 0; j <= maxDeg; j++) {
                    next[i][j] = BigDecimal.ZERO;
                }
            }

            for (int s = -(step - 1); s <= (step - 1); ++s) {
                BigDecimal[] P = curr[offset + s];

                BigDecimal total = BigDecimal.ZERO;
                BigDecimal totalR = BigDecimal.ZERO;

                for (int i = 0; i <= maxDeg; ++i) {
                    if (P[i].signum() == 0)
                        continue;
                    total = total.add(P[i].divide(new BigDecimal(i + 1), mc), mc);
                    totalR = totalR.add(P[i].divide(new BigDecimal(i + 2), mc), mc);
                }

                BigDecimal[] A = new BigDecimal[maxDeg + 1];
                BigDecimal[] B = new BigDecimal[maxDeg + 1];
                for (int i = 0; i <= maxDeg; i++) {
                    A[i] = BigDecimal.ZERO;
                    B[i] = BigDecimal.ZERO;
                }

                for (int i = 0; i <= maxDeg; ++i) {
                    if (P[i].signum() == 0)
                        continue;
                    if (i + 1 <= maxDeg)
                        A[i + 1] = P[i].divide(new BigDecimal(i + 1), mc);
                    if (i + 2 <= maxDeg)
                        B[i + 2] = P[i].divide(new BigDecimal(i + 2), mc);
                }

                BigDecimal[] TminusA = new BigDecimal[maxDeg + 1];
                TminusA[0] = total;
                for (int i = 1; i <= maxDeg; ++i)
                    TminusA[i] = A[i].negate();

                BigDecimal[] same = next[offset + s];
                BigDecimal[] plus = next[offset + s + 1];
                BigDecimal[] minus = next[offset + s - 1];

                for (int i = 0; i <= maxDeg; ++i) {
                    BigDecimal i1 = A[i].add(B[i]);
                    if (i > 0)
                        i1 = i1.subtract(A[i - 1]);

                    BigDecimal i2 = TminusA[i].add(B[i]);
                    if (i > 0)
                        i2 = i2.add(TminusA[i - 1]);
                    if (i == 0)
                        i2 = i2.subtract(totalR);

                    same[i] = same[i].add(i1).add(i2);

                    BigDecimal jplus = B[i].negate();
                    if (i > 0)
                        jplus = jplus.add(A[i - 1]);
                    plus[i] = plus[i].add(jplus);

                    BigDecimal jminus = B[i].negate();
                    if (i == 0)
                        jminus = jminus.add(totalR);
                    if (i > 0)
                        jminus = jminus.subtract(TminusA[i - 1]);
                    minus[i] = minus[i].add(jminus);
                }
            }

            curr = next;
        }

        Result out = new Result();
        BigDecimal res01 = BigDecimal.ZERO;
        for (int i = 0; i <= maxDeg; ++i) {
            BigDecimal val = curr[offset][i];
            if (val.signum() == 0)
                continue;
            res01 = res01.add(val.divide(new BigDecimal(i + 1), mc), mc);
        }
        out.probZero = res01;

        return out;
    }

    public static String solve() {
        Result r80 = computeProbability(80);
        return String.format(java.util.Locale.US, "%.10f", r80.probZero);
    }

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