public class Euler593 {

    static long nthPrimeUpperBound(long n) {
        if (n < 6)
            return 15;
        double nn = (double) n;
        double bound = nn * (Math.log(nn) + Math.log(Math.log(nn)));
        return (long) (bound + 16.0);
    }

    static class OddCompositeBits {
        long limit;
        long[] bits;

        OddCompositeBits(long limit) {
            this.limit = limit;
            long szBits = (limit >> 1) + 1;
            bits = new long[(int) ((szBits + 63) >> 6)];
        }

        boolean get(long half) {
            return ((bits[(int) (half >> 6)] >> (half & 63L)) & 1L) == 1L;
        }

        void set(long half) {
            bits[(int) (half >> 6)] |= (1L << (half & 63L));
        }
    }

    static void sieveOdd(OddCompositeBits comp) {
        long limit = comp.limit;
        long r = (long) Math.sqrt((double) limit);
        for (long p = 3; p <= r; p += 2) {
            if (comp.get(p >> 1))
                continue;
            long step = p << 1;
            for (long x = p * p; x <= limit; x += step) {
                comp.set(x >> 1);
            }
        }
    }

    static int powmodInt(int a, int e, int mod) {
        int r = 1;
        int x = a % mod;
        while (e > 0) {
            if ((e & 1) != 0)
                r = (int) ((1L * r * x) % mod);
            x = (int) ((1L * x * x) % mod);
            e >>= 1;
        }
        return r;
    }

    static class Fenwick {
        int n;
        int[] bit;

        Fenwick(int n) {
            this.n = n;
            bit = new int[n + 1];
        }

        void add(int idx0, int delta) {
            int i = idx0 + 1;
            for (; i <= n; i += i & -i)
                bit[i] += delta;
        }

        int kth(int k) {
            int idx = 0;
            int step = 1;
            while (step << 1 <= n)
                step <<= 1;
            for (; step > 0; step >>= 1) {
                int nxt = idx + step;
                if (nxt <= n && bit[nxt] < k) {
                    idx = nxt;
                    k -= bit[nxt];
                }
            }
            return idx;
        }
    }

    public static String solve() {
        int MOD = 10007;
        int PHI = MOD - 1;
        int VMAX = 20013;
        long n = 10000000L;
        int K = 100000;

        long limit = nthPrimeUpperBound(n);
        OddCompositeBits comp = new OddCompositeBits(limit);
        sieveOdd(comp);

        int[] Sfirst = new int[1002];
        Fenwick fw = new Fenwick(VMAX);
        int[] ring = new int[K];
        int ptr = 0;

        long sum2Long = 0;
        long k_final = 0;

        int kHalf1 = (K % 2 == 1) ? (K + 1) / 2 : K / 2;
        int kHalf2 = (K % 2 == 1) ? kHalf1 : K / 2 + 1;

        // Process 2
        k_final++;
        int baseVal = 2 % MOD;
        int s = 0;
        if (baseVal != 0) {
            int e = (int) (k_final % PHI);
            s = powmodInt(baseVal, e, MOD);
        }
        Sfirst[1] = s;
        int v2 = s + Sfirst[1];

        ring[ptr++] = v2;
        fw.add(v2, 1);

        for (long x = 3; x <= limit && k_final < n; x += 2) {
            if (!comp.get(x >> 1)) {
                k_final++;
                baseVal = (int) (x % MOD);
                s = 0;
                if (baseVal != 0) {
                    int e = (int) (k_final % PHI);
                    if (e != 0) {
                        s = powmodInt(baseVal, e, MOD);
                    } else {
                        s = 1;
                    }
                }

                if (k_final <= 1001)
                    Sfirst[(int) k_final] = s;
                int idx = (int) (k_final / 10000 + 1);
                int v = s + Sfirst[idx];

                if (k_final <= K) {
                    ring[ptr++] = v;
                    fw.add(v, 1);
                    if (k_final == K) {
                        ptr = 0;
                        if (K % 2 == 1) {
                            sum2Long += 2L * fw.kth(kHalf1);
                        } else {
                            sum2Long += (long) fw.kth(kHalf1) + fw.kth(kHalf2);
                        }
                    }
                } else {
                    int out = ring[ptr];
                    fw.add(out, -1);
                    ring[ptr] = v;
                    fw.add(v, 1);
                    ptr++;
                    if (ptr == K)
                        ptr = 0;

                    if (K % 2 == 1) {
                        sum2Long += 2L * fw.kth(kHalf1);
                    } else {
                        sum2Long += (long) fw.kth(kHalf1) + fw.kth(kHalf2);
                    }
                }
            }
        }

        String out = Long.toString(sum2Long / 2);
        out += (sum2Long % 2 == 1) ? ".5" : ".0";
        return out;
    }

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