import java.util.*;

public class Euler975 {
    public static String solve() {
        List<Integer> primes = sieve(1000);
        primes.removeIf(p -> p < 500);
        double total = 0;
        for (int i = 0; i < primes.size(); i++)
            for (int j = i + 1; j < primes.size(); j++) {
                int p = primes.get(i), q = primes.get(j);
                total += computeF(p, q, p, 2 * q - p);
            }
        return String.format("%.5f", total);
    }

    static double H(int a, int b, double x) {
        double denom = 2.0 * (a + b);
        double v = 0.5 - (b * Math.cos(a * Math.PI * x) + a * Math.cos(b * Math.PI * x)) / denom;
        if (v < 0 && v > -1e-15)
            return 0;
        if (v > 1 && v < 1 + 1e-15)
            return 1;
        return v;
    }

    static int derivSign(int a, int b, double x) {
        int diff = Math.abs(b - a);
        double s = Math.sin((a + b) * Math.PI * x / 2) * Math.cos(diff * Math.PI * x / 2);
        return s > 0 ? 1 : (s < 0 ? -1 : 0);
    }

    static double[] turningValues(int a, int b) {
        int sm = a + b, diff = Math.abs(b - a);
        List<Double> pts = new ArrayList<>();
        pts.add(0.0);
        pts.add(1.0);
        for (int k = 1; k < sm / 2; k++)
            pts.add(2.0 * k / sm);
        if (diff > 0)
            for (int k = 0; k < diff / 2; k++)
                pts.add((2.0 * k + 1.0) / diff);
        Collections.sort(pts);
        List<Double> uniq = new ArrayList<>();
        uniq.add(pts.get(0));
        for (int i = 1; i < pts.size(); i++)
            if (Math.abs(pts.get(i) - uniq.get(uniq.size() - 1)) > 1e-18)
                uniq.add(pts.get(i));
        int[] signs = new int[uniq.size() - 1];
        for (int i = 0; i < uniq.size() - 1; i++) {
            double mid = (uniq.get(i) + uniq.get(i + 1)) / 2;
            int s = derivSign(a, b, mid);
            if (s == 0) {
                mid = uniq.get(i) * 0.75 + uniq.get(i + 1) * 0.25;
                s = derivSign(a, b, mid);
            }
            signs[i] = s;
        }
        List<Double> turning = new ArrayList<>();
        turning.add(uniq.get(0));
        for (int i = 1; i < uniq.size() - 1; i++)
            if (signs[i - 1] != signs[i])
                turning.add(uniq.get(i));
        turning.add(uniq.get(uniq.size() - 1));
        double[] result = new double[turning.size()];
        for (int i = 0; i < turning.size(); i++)
            result[i] = H(a, b, turning.get(i));
        return result;
    }

    static double pathVariation(double[] za, double[] zb) {
        int i = 0, j = 0;
        double zcur = 0, d = 1, total = 0;
        int mx = (za.length + zb.length) * (za.length + zb.length) + 10;
        for (int steps = 0; steps < mx; steps++) {
            if (i == za.length - 1 && j == zb.length - 1)
                return total;
            if (i < 0 || j < 0 || i >= za.length - 1 || j >= zb.length - 1)
                return Double.NaN;
            double fa0 = za[i], fa1 = za[i + 1], ga0 = zb[j], ga1 = zb[j + 1], eps = 1e-15;
            if (d > 0) {
                double nz = Math.min(Math.max(fa0, fa1), Math.max(ga0, ga1));
                total += Math.abs(nz - zcur);
                zcur = nz;
                if (Math.abs(Math.max(fa0, fa1) - nz) <= eps)
                    i += (fa1 >= fa0 ? 1 : -1);
                if (Math.abs(Math.max(ga0, ga1) - nz) <= eps)
                    j += (ga1 >= ga0 ? 1 : -1);
            } else {
                double nz = Math.max(Math.min(fa0, fa1), Math.min(ga0, ga1));
                total += Math.abs(nz - zcur);
                zcur = nz;
                if (Math.abs(Math.min(fa0, fa1) - nz) <= eps)
                    i += (fa1 <= fa0 ? 1 : -1);
                if (Math.abs(Math.min(ga0, ga1) - nz) <= eps)
                    j += (ga1 <= ga0 ? 1 : -1);
            }
            d = -d;
        }
        return Double.NaN;
    }

    static double computeF(int a, int b, int c, int d) {
        return pathVariation(turningValues(a, b), turningValues(c, d));
    }

    static List<Integer> sieve(int n) {
        boolean[] isP = new boolean[n + 1];
        Arrays.fill(isP, true);
        isP[0] = isP[1] = false;
        for (int p = 2; p * p <= n; p++)
            if (isP[p])
                for (int q = p * p; q <= n; q += p)
                    isP[q] = false;
        List<Integer> r = new ArrayList<>();
        for (int x = 3; x <= n; x += 2)
            if (isP[x])
                r.add(x);
        return r;
    }

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