import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Collections;

public class Euler838 {

    static class Edge {
        int to;
        int rev;
        double cap;

        Edge(int to, int rev, double cap) {
            this.to = to;
            this.rev = rev;
            this.cap = cap;
        }
    }

    static class Dinic {
        ArrayList<ArrayList<Edge>> g;
        int[] level;
        int[] it;
        int n;

        Dinic(int n) {
            this.n = n;
            g = new ArrayList<>(n);
            for (int i = 0; i < n; i++) {
                g.add(new ArrayList<>());
            }
            level = new int[n];
            it = new int[n];
        }

        void addEdge(int u, int v, double cap) {
            Edge a = new Edge(v, g.get(v).size(), cap);
            Edge b = new Edge(u, g.get(u).size(), 0.0);
            g.get(u).add(a);
            g.get(v).add(b);
        }

        boolean bfs(int s, int t) {
            Arrays.fill(level, -1);
            Queue<Integer> q = new LinkedList<>();
            level[s] = 0;
            q.add(s);
            while (!q.isEmpty()) {
                int v = q.poll();
                for (Edge e : g.get(v)) {
                    if (e.cap > 1e-12 && level[e.to] < 0) {
                        level[e.to] = level[v] + 1;
                        q.add(e.to);
                    }
                }
            }
            return level[t] >= 0;
        }

        double dfs(int v, int t, double f) {
            if (v == t)
                return f;
            for (; it[v] < g.get(v).size(); ++it[v]) {
                Edge e = g.get(v).get(it[v]);
                if (e.cap <= 1e-12 || level[e.to] != level[v] + 1)
                    continue;
                double got = dfs(e.to, t, Math.min(f, e.cap));
                if (got > 1e-12) {
                    e.cap -= got;
                    g.get(e.to).get(e.rev).cap += got;
                    return got;
                }
            }
            return 0.0;
        }

        double maxFlow(int s, int t) {
            double flow = 0.0;
            while (bfs(s, t)) {
                Arrays.fill(it, 0);
                while (true) {
                    double f = dfs(s, t, Double.POSITIVE_INFINITY);
                    if (f <= 1e-12)
                        break;
                    flow += f;
                }
            }
            return flow;
        }
    }

    static ArrayList<Integer> sievePrimes(int n) {
        int[] spf = new int[n + 1];
        for (int i = 0; i <= n; ++i)
            spf[i] = i;

        for (int i = 2; (long) i * i <= n; ++i) {
            if (spf[i] != i)
                continue;
            for (int j = i * i; j <= n; j += i) {
                if (spf[j] == j)
                    spf[j] = i;
            }
        }
        ArrayList<Integer> primes = new ArrayList<>();
        for (int i = 2; i <= n; ++i) {
            if (spf[i] == i)
                primes.add(i);
        }
        return primes;
    }

    static double solveLn(int n) {
        ArrayList<Integer> primes = sievePrimes(n);

        ArrayList<Integer> a7 = new ArrayList<>();
        ArrayList<Integer> b9 = new ArrayList<>();
        double mandatoryLog = 0.0;

        for (int p : primes) {
            int r = p % 10;
            if (r == 3)
                mandatoryLog += Math.log(p);
            if (r == 7)
                a7.add(p);
            if (r == 9)
                b9.add(p);
        }

        boolean[] forced = new boolean[n + 1];
        double forcedLog = 0.0;
        for (int p : a7) {
            long cube = (long) p * p * p;
            if (cube <= n) {
                forced[p] = true;
                forcedLog += Math.log(p);
            }
        }

        ArrayList<Integer> nonforcedA = new ArrayList<>();
        for (int p : a7) {
            if (!forced[p])
                nonforcedA.add(p);
        }

        class IntPair {
            int a, b;

            IntPair(int a, int b) {
                this.a = a;
                this.b = b;
            }
        }
        ArrayList<IntPair> edges = new ArrayList<>();
        boolean[] usedA = new boolean[n + 1];
        boolean[] usedB = new boolean[n + 1];

        for (int a : nonforcedA) {
            int limit = n / a;
            int idx = Collections.binarySearch(b9, limit);
            if (idx < 0)
                idx = -(idx + 1);
            else {
                while (idx < b9.size() && b9.get(idx).equals(limit))
                    idx++;
            }

            for (int i = 0; i < idx; ++i) {
                int b = b9.get(i);
                edges.add(new IntPair(a, b));
                usedA[a] = true;
                usedB[b] = true;
            }
        }

        double coverLog = 0.0;
        if (!edges.isEmpty()) {
            int[] idA = new int[n + 1];
            int[] idB = new int[n + 1];
            Arrays.fill(idA, -1);
            Arrays.fill(idB, -1);

            int nodeCount = 1;
            for (int a : nonforcedA) {
                if (usedA[a])
                    idA[a] = nodeCount++;
            }
            for (int b : b9) {
                if (usedB[b])
                    idB[b] = nodeCount++;
            }

            int source = 0;
            int sink = nodeCount++;

            Dinic dinic = new Dinic(nodeCount);
            double infCap = 1e30;

            for (int a : nonforcedA) {
                if (usedA[a]) {
                    dinic.addEdge(source, idA[a], Math.log(a));
                }
            }
            for (int b : b9) {
                if (usedB[b]) {
                    dinic.addEdge(idB[b], sink, Math.log(b));
                }
            }
            for (IntPair e : edges) {
                dinic.addEdge(idA[e.a], idB[e.b], infCap);
            }

            coverLog = dinic.maxFlow(source, sink);
        }

        return mandatoryLog + forcedLog + coverLog;
    }

    public static String solve() {
        double ans = solveLn(1000000);
        ans = Math.round(ans * 1e6) / 1e6;
        return String.format(java.util.Locale.US, "%.6f", ans);
    }

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