import java.util.stream.IntStream;
import java.util.stream.LongStream;

public class Euler430 {

    static double rValue(long n, long i) {
        double nf = (double) n;
        double n2 = nf * nf;
        double a = (double) (i - 1);
        double b = (double) (n - i);
        return (2.0 * (a * a + b * b) - n2) / n2;
    }

    static double expectedExact(long n, int m) {
        double ans = 0.0;
        for (long i = 1; i <= n; i++) {
            double r = rValue(n, i);
            ans += 0.5 * (1.0 + Math.pow(r, m));
        }
        return ans;
    }

    static long edgeLimitByRho(long n, double rho) {
        long lo = 0;
        long hi = n / 2;
        while (lo < hi) {
            long mid = lo + (hi - lo + 1) / 2;
            if (rValue(n, mid) > rho) {
                lo = mid;
            } else {
                hi = mid - 1;
            }
        }
        return lo;
    }

    static double edgeSumParallel(long n, int m, long edgeCount) {
        if (edgeCount == 0)
            return 0.0;
        int threads = Math.min(Runtime.getRuntime().availableProcessors(), (int) Math.min(edgeCount, 1000));
        if (threads < 1)
            threads = 1;

        final int numThreads = threads;
        return IntStream.range(0, numThreads)
                .parallel()
                .mapToDouble(t -> {
                    long begin = edgeCount * t / numThreads + 1;
                    long end = edgeCount * (t + 1) / numThreads;
                    double local = 0.0;
                    for (long i = begin; i <= end; i++) {
                        double r = rValue(n, i);
                        local += Math.pow(r, m);
                    }
                    return local;
                })
                .sum();
    }

    static double expectedFast(long n, int m) {
        if (m == 0)
            return (double) n;
        if (n <= 2000000)
            return expectedExact(n, m);

        double eps = 1e-4;
        double rho = Math.exp(Math.log((2.0 * eps) / (double) n) / (double) m);

        long l = edgeLimitByRho(n, rho);
        double edge = edgeSumParallel(n, m, l);

        double estimate = (double) n * 0.5 + edge;

        long omitted = n - 2 * l;
        double errBound = 0.5 * (double) omitted * Math.pow(rho, m);
        if (errBound >= 0.005) {
            double rho2 = rho * 0.99;
            long l2 = edgeLimitByRho(n, rho2);
            double edge2 = edgeSumParallel(n, m, l2);
            estimate = (double) n * 0.5 + edge2;
        }

        return estimate;
    }

    public static String solve() {
        long n = 10000000000L;
        int m = 4000;
        double ans = expectedFast(n, m);
        return String.format(java.util.Locale.US, "%.2f", ans);
    }

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