import java.util.*;
import java.util.concurrent.*;

public class Euler233 {
    static final long LIMIT = 100_000_000_000L;

    static long powWithLimit(long base, int exp, long limit) {
        long result = 1;
        for (int i = 0; i < exp; ++i) {
            if (result > limit / base) {
                return limit + 1;
            }
            result *= base;
        }
        return result;
    }

    static int[] primes1Mod4UpTo(int limit) {
        if (limit < 2)
            return new int[0];
        byte[] isPrime = new byte[limit + 1];
        Arrays.fill(isPrime, (byte) 1);
        isPrime[0] = isPrime[1] = 0;
        int root = (int) Math.sqrt(limit);
        for (int p = 2; p <= root; ++p) {
            if (isPrime[p] == 1) {
                for (long m = (long) p * p; m <= limit; m += p) {
                    isPrime[(int) m] = 0;
                }
            }
        }
        int count = 0;
        for (int p = 2; p <= limit; ++p) {
            if (isPrime[p] == 1 && p % 4 == 1)
                count++;
        }
        int[] primes = new int[count];
        int idx = 0;
        for (int p = 2; p <= limit; ++p) {
            if (isPrime[p] == 1 && p % 4 == 1)
                primes[idx++] = p;
        }
        return primes;
    }

    static int[] buildSpf(int maxN) {
        int[] spf = new int[maxN + 1];
        int[] primes = new int[maxN / 10 + 100];
        int numPrimes = 0;

        for (int i = 2; i <= maxN; ++i) {
            if (spf[i] == 0) {
                spf[i] = i;
                if (numPrimes < primes.length) {
                    primes[numPrimes++] = i;
                }
            }
            for (int j = 0; j < numPrimes; ++j) {
                int p = primes[j];
                long m = (long) p * i;
                if (m > maxN)
                    break;
                spf[(int) m] = p;
                if (p == spf[i])
                    break;
            }
        }
        return spf;
    }

    static boolean tailFits(int[] orderedExponents, int nextPos, int nextPrimeIdx, long remainingLimit,
            int[] primes1Mod4) {
        int idx = nextPrimeIdx;
        for (int pos = nextPos; pos < orderedExponents.length; ++pos, ++idx) {
            if (idx >= primes1Mod4.length)
                return false;
            long p = primes1Mod4[idx];
            long pe = powWithLimit(p, orderedExponents[pos], remainingLimit);
            if (pe > remainingLimit)
                return false;
            remainingLimit /= pe;
        }
        return true;
    }

    static void enumerateCoreForOrder(int[] orderedExponents, int pos, int startPrimeIdx, long currentProduct,
            long limit, int[] primes1Mod4, List<Long> out) {
        if (pos == orderedExponents.length) {
            out.add(currentProduct);
            return;
        }
        int remainingSlots = orderedExponents.length - pos;
        if (startPrimeIdx + remainingSlots > primes1Mod4.length)
            return;

        long headLimit = limit / currentProduct;
        for (int i = startPrimeIdx; i + remainingSlots <= primes1Mod4.length; ++i) {
            long p = primes1Mod4[i];
            long pe = powWithLimit(p, orderedExponents[pos], headLimit);
            if (pe > headLimit)
                break;

            long nextProduct = currentProduct * pe;
            if (pos + 1 < orderedExponents.length) {
                if (!tailFits(orderedExponents, pos + 1, i + 1, limit / nextProduct, primes1Mod4)) {
                    break;
                }
            }
            enumerateCoreForOrder(orderedExponents, pos + 1, i + 1, nextProduct, limit, primes1Mod4, out);
        }
    }

    static void swap(int[] arr, int i, int j) {
        int t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }

    static void reverse(int[] arr, int i, int j) {
        while (i < j)
            swap(arr, i++, j--);
    }

    static boolean nextPermutation(int[] arr) {
        int i = arr.length - 2;
        while (i >= 0 && arr[i] >= arr[i + 1])
            i--;
        if (i < 0)
            return false;
        int j = arr.length - 1;
        while (arr[j] <= arr[i])
            j--;
        swap(arr, i, j);
        reverse(arr, i + 1, arr.length - 1);
        return true;
    }

    static long[] enumerateCoreNumbers(long limit, int[] primes1Mod4) {
        int[][] exponentPatterns = {
                { 52 }, { 1, 17 }, { 2, 10 }, { 3, 7 }, { 1, 2, 3 }
        };

        List<Long> coreList = new ArrayList<>();
        for (int[] pattern : exponentPatterns) {
            Arrays.sort(pattern);
            do {
                enumerateCoreForOrder(pattern, 0, 0, 1L, limit, primes1Mod4, coreList);
            } while (nextPermutation(pattern));
        }

        Collections.sort(coreList);
        int uniqueCount = 0;
        for (int i = 0; i < coreList.size(); ++i) {
            if (i == 0 || !coreList.get(i).equals(coreList.get(i - 1))) {
                uniqueCount++;
            }
        }
        long[] coreNumbers = new long[uniqueCount];
        int idx = 0;
        for (int i = 0; i < coreList.size(); ++i) {
            if (i == 0 || !coreList.get(i).equals(coreList.get(i - 1))) {
                coreNumbers[idx++] = coreList.get(i);
            }
        }
        return coreNumbers;
    }

    static long[] buildAllowedMultiplierPrefix(int maxMultiplier) {
        long[] prefix = new long[maxMultiplier + 1];
        if (maxMultiplier == 0)
            return prefix;

        int[] spf = buildSpf(maxMultiplier);
        byte[] valid = new byte[maxMultiplier + 1];
        valid[1] = 1;

        for (int n = 2; n <= maxMultiplier; ++n) {
            int p = spf[n];
            int m = n / p;
            boolean allowed = (p == 2) || ((p % 4) == 3);
            if (allowed && valid[m] == 1) {
                valid[n] = 1;
            }
        }

        long running = 0;
        for (int n = 1; n <= maxMultiplier; ++n) {
            if (valid[n] == 1) {
                running += n;
            }
            prefix[n] = running;
        }
        return prefix;
    }

    static long accumulateRange(long[] coreNumbers, int begin, int end, long limit, long[] allowedPrefix) {
        long local = 0;
        for (int i = begin; i < end; ++i) {
            long core = coreNumbers[i];
            int maxMult = (int) (limit / core);
            local += core * allowedPrefix[maxMult];
        }
        return local;
    }

    public static String solve() {
        int primeBound = (int) Math.max(200L, LIMIT / 21125 + 100);
        int[] primes1Mod4 = primes1Mod4UpTo(primeBound);
        long[] coreNumbers = enumerateCoreNumbers(LIMIT, primes1Mod4);

        if (coreNumbers.length == 0)
            return "0";

        long minCore = coreNumbers[0];
        int maxMultiplier = (int) (LIMIT / minCore);
        long[] allowedPrefix = buildAllowedMultiplierPrefix(maxMultiplier);

        int threads = Math.max(1, Runtime.getRuntime().availableProcessors());
        threads = Math.min(threads, coreNumbers.length);

        if (threads <= 1) {
            return String.valueOf(accumulateRange(coreNumbers, 0, coreNumbers.length, LIMIT, allowedPrefix));
        }

        ExecutorService executor = Executors.newFixedThreadPool(threads);
        List<Future<Long>> futures = new ArrayList<>();

        for (int t = 0; t < threads; ++t) {
            final int begin = coreNumbers.length * t / threads;
            final int end = coreNumbers.length * (t + 1) / threads;
            futures.add(executor.submit(() -> accumulateRange(coreNumbers, begin, end, LIMIT, allowedPrefix)));
        }

        long total = 0;
        for (Future<Long> f : futures) {
            try {
                total += f.get();
            } catch (Exception e) {
            }
        }
        executor.shutdown();

        return String.valueOf(total);
    }

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