import java.math.BigDecimal;
import java.math.MathContext;
import java.math.RoundingMode;

public class Euler471 {

    private static final MathContext MC = new MathContext(60, RoundingMode.HALF_UP);
    private static final BigDecimal EULER_GAMMA = new BigDecimal(
            "0.57721566490153286060651209008240243104215933593992");

    private static double log(BigDecimal val) {
        return Math.log(val.doubleValue());
    }

    private static BigDecimal harmonicAsymptotic(long nVal) {
        if (nVal == 0)
            return BigDecimal.ZERO;

        BigDecimal x = new BigDecimal(nVal);
        BigDecimal inv = BigDecimal.ONE.divide(x, MC);
        BigDecimal inv2 = inv.multiply(inv, MC);
        BigDecimal inv4 = inv2.multiply(inv2, MC);
        BigDecimal inv6 = inv4.multiply(inv2, MC);
        BigDecimal inv8 = inv4.multiply(inv4, MC);
        BigDecimal inv10 = inv8.multiply(inv2, MC);

        BigDecimal logX = new BigDecimal(log(x));

        BigDecimal res = logX.add(EULER_GAMMA, MC)
                .add(inv.divide(new BigDecimal(2), MC), MC)
                .subtract(inv2.divide(new BigDecimal(12), MC), MC)
                .add(inv4.divide(new BigDecimal(120), MC), MC)
                .subtract(inv6.divide(new BigDecimal(252), MC), MC)
                .add(inv8.divide(new BigDecimal(240), MC), MC)
                .subtract(new BigDecimal(5).multiply(inv10, MC).divide(new BigDecimal(660), MC), MC);

        return res;
    }

    private static BigDecimal harmonicRange(long left, long right) {
        if (left > right)
            return BigDecimal.ZERO;

        long kDirectHarmonicLimit = 5_000_000;
        long width = right - left + 1;

        if (right <= kDirectHarmonicLimit || width <= kDirectHarmonicLimit) {
            BigDecimal total = BigDecimal.ZERO;
            for (long k = left; k <= right; ++k) {
                total = total.add(BigDecimal.ONE.divide(new BigDecimal(k), MC), MC);
            }
            return total;
        }

        return harmonicAsymptotic(right).subtract(harmonicAsymptotic(left - 1), MC);
    }

    private static BigDecimal computeGFast(long n) {
        if (n < 3)
            return BigDecimal.ZERO;

        long q = n / 2;
        long m = (n - 1) / 2;
        long left = n - m;
        long right = n - 1;

        BigDecimal qd = new BigDecimal(q);
        BigDecimal md = new BigDecimal(m);
        BigDecimal nd = new BigDecimal(n);
        BigDecimal ld = new BigDecimal(left);
        BigDecimal rd = new BigDecimal(right);

        BigDecimal partLow = qd.multiply(
                new BigDecimal(2).multiply(qd).multiply(qd)
                        .add(new BigDecimal(3).multiply(qd))
                        .subtract(new BigDecimal(5)))
                .divide(new BigDecimal(36), MC);

        BigDecimal partHighPoly = md.multiply(md.add(BigDecimal.ONE))
                .multiply(md.add(new BigDecimal(2)))
                .divide(new BigDecimal(6), MC);

        BigDecimal harmonic = harmonicRange(left, right);

        BigDecimal acoef = nd.multiply(new BigDecimal(2).multiply(nd).add(BigDecimal.ONE))
                .multiply(nd.add(BigDecimal.ONE));
        BigDecimal bcoef = new BigDecimal(6).multiply(nd).multiply(nd)
                .add(new BigDecimal(6).multiply(nd))
                .add(BigDecimal.ONE).negate();
        BigDecimal ccoef = new BigDecimal(6).multiply(nd).add(new BigDecimal(3));

        BigDecimal sumK = ld.add(rd).multiply(md).divide(new BigDecimal(2), MC);

        BigDecimal v1 = rd.multiply(rd.add(BigDecimal.ONE))
                .multiply(new BigDecimal(2).multiply(rd).add(BigDecimal.ONE));
        BigDecimal v2 = ld.subtract(BigDecimal.ONE).multiply(ld)
                .multiply(new BigDecimal(2).multiply(ld).subtract(BigDecimal.ONE));
        BigDecimal sumK2 = v1.subtract(v2).divide(new BigDecimal(6), MC);

        BigDecimal rationalTail = acoef.multiply(harmonic, MC)
                .add(bcoef.multiply(md, MC), MC)
                .add(ccoef.multiply(sumK, MC), MC)
                .subtract(new BigDecimal(2).multiply(sumK2, MC), MC);

        return partLow.add(partHighPoly, MC)
                .subtract(rationalTail.divide(new BigDecimal(6), MC), MC);
    }

    private static String toScientific10Significant(BigDecimal value) {
        if (value.compareTo(BigDecimal.ZERO) == 0)
            return "0.000000000e0";

        boolean negative = value.compareTo(BigDecimal.ZERO) < 0;
        double x = negative ? -value.doubleValue() : value.doubleValue();

        int exponent = (int) Math.floor(Math.log10(x));
        double mantissa = x / Math.pow(10.0, exponent);

        long scaled = (long) Math.floor(mantissa * 1_000_000_000.0 + 0.5);
        if (scaled >= 10_000_000_000L) {
            scaled /= 10L;
            exponent += 1;
        }

        long lead = scaled / 1_000_000_000L;
        long frac = scaled % 1_000_000_000L;

        String signStr = negative ? "-" : "";
        return String.format("%s%d.%09de%d", signStr, lead, frac, exponent);
    }

    public static void main(String[] args) {
        long n = 100_000_000_000L;
        BigDecimal ans = computeGFast(n);
        System.out.println(toScientific10Significant(ans));
    }
}