public class Euler568 {

    static class DD {
        double hi;
        double lo;

        DD(double hi, double lo) {
            this.hi = hi;
            this.lo = lo;
        }
    }

    static DD twoSum(double a, double b) {
        double s = a + b;
        double bb = s - a;
        double err = (a - (s - bb)) + (b - bb);
        return new DD(s, err);
    }

    static DD quickTwoSum(double a, double b) {
        double s = a + b;
        double err = b - (s - a);
        return new DD(s, err);
    }

    static DD twoProd(double a, double b) {
        double p = a * b;
        double split = 134217729.0;
        double ca = split * a;
        double a_hi = ca - (ca - a);
        double a_lo = a - a_hi;
        double cb = split * b;
        double b_hi = cb - (cb - b);
        double b_lo = b - b_hi;
        double err = ((a_hi * b_hi - p) + a_hi * b_lo + a_lo * b_hi) + a_lo * b_lo;
        return new DD(p, err);
    }

    static DD ddAdd(DD x, DD y) {
        DD s = twoSum(x.hi, y.hi);
        double e = x.lo + y.lo;
        DD t = twoSum(s.lo, e);
        DD u = quickTwoSum(s.hi, t.hi);
        double lo = u.lo + t.lo;
        return quickTwoSum(u.hi, lo);
    }

    static DD ddSub(DD x, DD y) {
        return ddAdd(x, new DD(-y.hi, -y.lo));
    }

    static DD ddMulD(DD x, double y) {
        DD p = twoProd(x.hi, y);
        double e = x.lo * y;
        DD s = twoSum(p.lo, e);
        DD u = quickTwoSum(p.hi, s.hi);
        double lo = u.lo + s.lo;
        return quickTwoSum(u.hi, lo);
    }

    static double harmonicAsymptotic(long n) {
        double gamma = 0.577215664901532860606512090082402431042159;
        double nn = (double) n;
        double inv = 1.0 / nn;
        double inv2 = inv * inv;
        double inv4 = inv2 * inv2;
        double inv6 = inv4 * inv2;
        double inv8 = inv4 * inv4;
        double inv10 = inv8 * inv2;
        return Math.log(nn) + gamma + 0.5 * inv - (1.0 / 12.0) * inv2 + (1.0 / 120.0) * inv4 - (1.0 / 252.0) * inv6
                + (1.0 / 240.0) * inv8 - (5.0 / 660.0) * inv10;
    }

    public static String solve() {
        long n = 123456789L;
        double Hn = harmonicAsymptotic(n);

        DD log10_2 = new DD(0.3010299956639812, -4.786261105275507e-18);
        DD log10_H = new DD(Math.log10(Hn), 0.0);
        DD nlog10_2 = ddMulD(log10_2, (double) n);
        DD L = ddSub(log10_H, nlog10_2);

        double frac = L.hi - Math.floor(L.hi);
        frac += L.lo;
        frac -= Math.floor(frac);

        double x = Math.pow(10.0, frac + 6.0);
        double eps = 8.0 * Math.ulp(1.0) * Math.abs(x);
        long ans = (long) Math.floor(x + eps);
        if (ans >= 10000000L)
            ans = 9999999L;

        return String.valueOf(ans);
    }

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