import java.util.*;

public class Euler314 {
    static final int GRID = 250;
    static final int DIM = GRID + 1;
    static final double K_NEG = -1e100;
    static final double K_EPS = 1e-12;

    static class Vec implements Comparable<Vec> {
        int u, v;
        double len, slope;

        Vec(int u, int v, double len, double slope) {
            this.u = u;
            this.v = v;
            this.len = len;
            this.slope = slope;
        }

        public int compareTo(Vec o) {
            return Double.compare(this.slope, o.slope);
        }
    }

    static int gcd(int a, int b) {
        while (b != 0) {
            int temp = b;
            b = a % b;
            a = temp;
        }
        return a;
    }

    static List<Vec> buildVectors() {
        List<Vec> vecs = new ArrayList<>();
        vecs.add(new Vec(1, 0, 1.0, 0.0));
        for (int u = 1; u <= GRID; ++u) {
            for (int v = 1; v <= GRID; ++v) {
                if (gcd(u, v) == 1) {
                    double len = Math.sqrt((double) u * u + (double) v * v);
                    double slope = (double) v / u;
                    vecs.add(new Vec(u, v, len, slope));
                }
            }
        }
        vecs.add(new Vec(0, 1, 1.0, 1e100));
        Collections.sort(vecs);
        return vecs;
    }

    static class Result {
        double area, len, score;

        Result(double a, double l, double s) {
            area = a;
            len = l;
            score = s;
        }
    }

    static double[] score = new double[DIM * DIM];
    static double[] area = new double[DIM * DIM];
    static double[] length = new double[DIM * DIM];
    static double[] rowMax = new double[DIM];

    static Result solveForLambda(double lambda, List<Vec> vecs) {
        Arrays.fill(score, K_NEG);
        Arrays.fill(area, 0.0);
        Arrays.fill(length, 0.0);
        Arrays.fill(rowMax, K_NEG);

        score[0] = 0.0;
        rowMax[0] = 0.0;

        for (int vi = 0; vi < vecs.size(); vi++) {
            Vec vec = vecs.get(vi);
            int u = vec.u;
            int v = vec.v;
            double len = vec.len;
            double baseArea = (double) u * (GRID - 0.5 * v);
            double baseScore = baseArea - lambda * len;

            for (int i = 0; i <= GRID - u; ++i) {
                if (rowMax[i] <= K_NEG / 2)
                    continue;

                int idxFrom = i * DIM;
                int idxTo = (i + u) * DIM;
                double areaGain = baseArea;
                double scoreGain = baseScore;

                for (int j = 0; j <= GRID - v; ++j) {
                    double curScore = score[idxFrom + j];
                    if (curScore > K_NEG / 2) {
                        int tj = idxTo + j + v;
                        double candScore = curScore + scoreGain;
                        if (candScore > score[tj] + K_EPS) {
                            score[tj] = candScore;
                            area[tj] = area[idxFrom + j] + areaGain;
                            length[tj] = length[idxFrom + j] + len;
                            if (candScore > rowMax[i + u]) {
                                rowMax[i + u] = candScore;
                            }
                        }
                    }
                    areaGain -= u;
                    scoreGain -= u;
                }
            }
        }

        int end = GRID * DIM + GRID;
        return new Result(area[end], length[end], score[end]);
    }

    public static String solve() {
        List<Vec> vecs = buildVectors();
        double lambda = 132.0;

        for (int iter = 0; iter < 40; ++iter) {
            Result res = solveForLambda(lambda, vecs);
            double newLambda = res.area / res.len;
            if (Math.abs(newLambda - lambda) < 1e-12 || Math.abs(res.score) < 1e-11) {
                lambda = newLambda;
                break;
            }
            lambda = newLambda;
        }

        return String.format(Locale.US, "%.8f", lambda);
    }

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