import java.util.ArrayList;
import java.util.List;
import java.util.Locale;

public class Euler481 {

    private static int nextAliveAfter(int mask, int chef) {
        int higherBits = mask & ~((1 << (chef + 1)) - 1);
        if (higherBits != 0) {
            return Integer.numberOfTrailingZeros(higherBits);
        }
        return Integer.numberOfTrailingZeros(mask);
    }

    private static double[] fibonacciSkills(int n) {
        double[] fib = new double[n + 2];
        fib[1] = 1.0;
        fib[2] = 1.0;
        for (int i = 3; i <= n + 1; ++i) {
            fib[i] = fib[i - 1] + fib[i - 2];
        }
        double[] skills = new double[n];
        for (int k = 1; k <= n; ++k) {
            skills[k - 1] = fib[k] / fib[n + 1];
        }
        return skills;
    }

    private static double solveCompetition(double[] skills) {
        int n = skills.length;
        int totalMasks = 1 << n;

        // Flatten arrays for speed: wins[mask * n * n + turn * n + chef]
        double[] wins = new double[totalMasks * n * n];
        double[] dishes = new double[totalMasks * n];

        List<List<Integer>> masksBySize = new ArrayList<>(n + 1);
        for (int i = 0; i <= n; i++) {
            masksBySize.add(new ArrayList<>());
        }

        for (int mask = 1; mask < totalMasks; ++mask) {
            int bits = Integer.bitCount(mask);
            masksBySize.get(bits).add(mask);
        }

        for (int size = 1; size <= n; ++size) {
            for (int mask : masksBySize.get(size)) {
                List<Integer> members = new ArrayList<>(n);
                int temp = mask;
                while (temp != 0) {
                    int chef = Integer.numberOfTrailingZeros(temp);
                    members.add(chef);
                    temp &= (temp - 1);
                }

                int m = members.size();
                if (m == 1) {
                    int chef = members.get(0);
                    wins[mask * n * n + chef * n + chef] = 1.0;
                    dishes[mask * n + chef] = 0.0;
                    continue;
                }

                double[][] aWin = new double[m][n];
                double[] bArray = new double[m];
                double[] aDish = new double[m];

                for (int t = 0; t < m; ++t) {
                    int current = members.get(t);
                    double p = skills[current];
                    bArray[t] = 1.0 - p;

                    double bestSelfWin = -1.0;
                    int bestTargetPos = 0;
                    int bestDistance = Integer.MAX_VALUE;

                    for (int u = 0; u < m; ++u) {
                        if (u == t)
                            continue;

                        int target = members.get(u);
                        int nextMask = mask & ~(1 << target);
                        int nextTurn = nextAliveAfter(nextMask, current);

                        double selfWin = wins[nextMask * n * n + nextTurn * n + current];
                        int distance = (u + m - t) % m;

                        if (selfWin > bestSelfWin + 1e-15 ||
                                (Math.abs(selfWin - bestSelfWin) <= 1e-15 && distance < bestDistance)) {
                            bestSelfWin = selfWin;
                            bestTargetPos = u;
                            bestDistance = distance;
                        }
                    }

                    int target = members.get(bestTargetPos);
                    int nextMask = mask & ~(1 << target);
                    int nextTurn = nextAliveAfter(nextMask, current);

                    int offset = nextMask * n * n + nextTurn * n;
                    for (int k = 0; k < n; ++k) {
                        aWin[t][k] = p * wins[offset + k];
                    }
                    aDish[t] = 1.0 + p * dishes[nextMask * n + nextTurn];
                }

                double[] x0 = new double[n];
                double[] acc = new double[n];
                double B = bArray[0];

                for (int k = 0; k < n; ++k) {
                    acc[k] = aWin[0][k];
                }

                for (int t = 1; t < m; ++t) {
                    for (int k = 0; k < n; ++k) {
                        acc[k] += B * aWin[t][k];
                    }
                    B *= bArray[t];
                }

                double den = 1.0 - B;
                for (int k = 0; k < n; ++k) {
                    x0[k] = acc[k] / den;
                }

                double[][] stateWins = new double[m][n];
                for (int k = 0; k < n; ++k) {
                    stateWins[0][k] = x0[k];
                    stateWins[m - 1][k] = aWin[m - 1][k] + bArray[m - 1] * x0[k];
                }
                for (int t = m - 2; t >= 1; --t) {
                    for (int k = 0; k < n; ++k) {
                        stateWins[t][k] = aWin[t][k] + bArray[t] * stateWins[t + 1][k];
                    }
                }

                double bD = bArray[0];
                double aD = aDish[0];
                for (int t = 1; t < m; ++t) {
                    aD += bD * aDish[t];
                    bD *= bArray[t];
                }
                double denD = 1.0 - bD;
                double d0 = aD / denD;

                double[] stateDishes = new double[m];
                stateDishes[0] = d0;
                stateDishes[m - 1] = aDish[m - 1] + bArray[m - 1] * d0;
                for (int t = m - 2; t >= 1; --t) {
                    stateDishes[t] = aDish[t] + bArray[t] * stateDishes[t + 1];
                }

                for (int t = 0; t < m; ++t) {
                    int turn = members.get(t);
                    int offset = mask * n * n + turn * n;
                    for (int k = 0; k < n; ++k) {
                        wins[offset + k] = stateWins[t][k];
                    }
                    dishes[mask * n + turn] = stateDishes[t];
                }
            }
        }

        int fullMask = totalMasks - 1;
        return dishes[fullMask * n + 0];
    }

    public static void main(String[] args) {
        int n = 14;
        double[] skills = fibonacciSkills(n);
        double result = solveCompetition(skills);
        System.out.printf(Locale.US, "%.8f\n", result);
    }
}