import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Locale;

public class Euler898 {

    static class PairInfo {
        double weight;
        double pPos, pZero, pNeg;
        short[] exp;
    }

    static class State implements Comparable<State> {
        double score;
        double prob;
        short[] exp;

        @Override
        public int compareTo(State o) {
            return Double.compare(this.score, o.score);
        }
    }

    static List<Integer> collectPrimesForPairs() {
        HashSet<Integer> primesSet = new HashSet<>();

        java.util.function.Consumer<Integer> addFactor = (x) -> {
            int t = x;
            for (int p = 2; p * p <= t; ++p) {
                if (t % p != 0)
                    continue;
                primesSet.add(p);
                while (t % p == 0)
                    t /= p;
            }
            if (t > 1)
                primesSet.add(t);
        };

        for (int k = 25; k <= 49; ++k) {
            addFactor.accept(k);
            addFactor.accept(100 - k);
        }

        List<Integer> primes = new ArrayList<>(primesSet);
        Collections.sort(primes);
        return primes;
    }

    static short[] exponentVector(int num, int den, List<Integer> primes) {
        short[] e = new short[primes.size()];
        int a = num;
        int b = den;
        for (int i = 0; i < primes.size(); ++i) {
            int p = primes.get(i);
            int cn = 0, cd = 0;
            while (a % p == 0) {
                a /= p;
                cn++;
            }
            while (b % p == 0) {
                b /= p;
                cd++;
            }
            e[i] = (short) (2 * (cn - cd));
        }
        return e;
    }

    static List<PairInfo> buildPairs(List<Integer> primes) {
        List<PairInfo> pairs = new ArrayList<>();
        for (int k = 25; k <= 49; ++k) {
            double q = k / 100.0;
            double w = 2.0 * Math.log((1.0 - q) / q);

            PairInfo info = new PairInfo();
            info.weight = w;
            info.pPos = (1.0 - q) * (1.0 - q);
            info.pZero = 2.0 * q * (1.0 - q);
            info.pNeg = q * q;
            info.exp = exponentVector(100 - k, k, primes);
            pairs.add(info);
        }
        return pairs;
    }

    static List<State> enumerateStates(List<PairInfo> pairs, int begin, int end, int numPrimes) {
        List<State> states = new ArrayList<>();
        State init = new State();
        init.score = 0.0;
        init.prob = 1.0;
        init.exp = new short[numPrimes];
        states.add(init);

        for (int i = begin; i < end; ++i) {
            PairInfo pair = pairs.get(i);
            List<State> next = new ArrayList<>(states.size() * 3);

            for (State st : states) {
                State pos = new State();
                pos.score = st.score + pair.weight;
                pos.prob = st.prob * pair.pPos;
                pos.exp = new short[numPrimes];
                for (int j = 0; j < numPrimes; ++j) {
                    pos.exp[j] = (short) (st.exp[j] + pair.exp[j]);
                }
                next.add(pos);

                State zero = new State();
                zero.score = st.score;
                zero.prob = st.prob * pair.pZero;
                zero.exp = st.exp.clone();
                next.add(zero);

                State neg = new State();
                neg.score = st.score - pair.weight;
                neg.prob = st.prob * pair.pNeg;
                neg.exp = new short[numPrimes];
                for (int j = 0; j < numPrimes; ++j) {
                    neg.exp[j] = (short) (st.exp[j] - pair.exp[j]);
                }
                next.add(neg);
            }
            states = next;
        }
        return states;
    }

    static int compareExactProduct(short[] a, short[] b, List<Integer> primes) {
        int[] c = new int[primes.size()];
        boolean allZero = true;
        for (int i = 0; i < primes.size(); ++i) {
            c[i] = a[i] + b[i];
            if (c[i] != 0)
                allZero = false;
        }
        if (allZero)
            return 0;

        BigInteger num = BigInteger.ONE;
        BigInteger den = BigInteger.ONE;

        for (int i = 0; i < primes.size(); ++i) {
            int e = c[i];
            if (e > 0) {
                BigInteger pPow = BigInteger.valueOf(primes.get(i)).pow(e);
                num = num.multiply(pPow);
            } else if (e < 0) {
                BigInteger pPow = BigInteger.valueOf(primes.get(i)).pow(-e);
                den = den.multiply(pPow);
            }
        }

        return num.compareTo(den);
    }

    static int lowerBound(List<State> list, double value) {
        int l = 0, r = list.size();
        while (l < r) {
            int mid = l + (r - l) / 2;
            if (list.get(mid).score < value) {
                l = mid + 1;
            } else {
                r = mid;
            }
        }
        return l;
    }

    static int upperBound(List<State> list, double value) {
        int l = 0, r = list.size();
        while (l < r) {
            int mid = l + (r - l) / 2;
            if (list.get(mid).score <= value) {
                l = mid + 1;
            } else {
                r = mid;
            }
        }
        return l;
    }

    static double solvePairs(List<PairInfo> pairs, List<Integer> primes) {
        int split = pairs.size() / 2;
        List<State> left = enumerateStates(pairs, 0, split, primes.size());
        List<State> right = enumerateStates(pairs, split, pairs.size(), primes.size());

        Collections.sort(right);

        double[] rightPrefix = new double[right.size() + 1];
        for (int i = 0; i < right.size(); ++i) {
            rightPrefix[i + 1] = rightPrefix[i] + right.get(i).prob;
        }
        double totalRight = rightPrefix[right.size()];

        double eps = 1e-12;
        double answer = 0.0;

        for (State ls : left) {
            double threshold = -ls.score;

            int lo = lowerBound(right, threshold - eps);
            int hi = upperBound(right, threshold + eps);

            double pCorrect = totalRight - rightPrefix[hi];

            for (int i = lo; i < hi; ++i) {
                int cmp = compareExactProduct(ls.exp, right.get(i).exp, primes);
                if (cmp > 0) {
                    pCorrect += right.get(i).prob;
                } else if (cmp == 0) {
                    pCorrect += 0.5 * right.get(i).prob;
                }
            }

            answer += ls.prob * pCorrect;
        }

        return answer;
    }

    public static String solve() {
        List<Integer> primes = collectPrimesForPairs();
        List<PairInfo> pairs = buildPairs(primes);
        double result = solvePairs(pairs, primes);
        return String.format(Locale.US, "%.10f", result);
    }

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