import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Euler516 {

    static long modPow(long base, long exp, long mod) {
        long result = 1 % mod;
        long cur = base % mod;
        long e = exp;
        while (e > 0) {
            if ((e & 1) == 1) {
                result = modMul(result, cur, mod);
            }
            cur = modMul(cur, cur, mod);
            e >>= 1;
        }
        return result;
    }

    static long modMul(long a, long b, long mod) {
        long q = (long) ((double) a * b / mod);
        long r = a * b - q * mod;
        while (r < 0)
            r += mod;
        while (r >= mod)
            r -= mod;
        return r;
    }

    static boolean isPrime(long n) {
        if (n < 2)
            return false;
        long[] p_list = { 2, 3, 5, 7, 11, 13 };
        for (long p : p_list) {
            if (n == p)
                return true;
            if (n % p == 0)
                return false;
        }

        long d = n - 1;
        int s = 0;
        while ((d & 1) == 0) {
            d >>= 1;
            s++;
        }

        for (long a : p_list) {
            if (a >= n)
                break;
            long x = modPow(a, d, n);
            if (x == 1 || x == n - 1)
                continue;
            boolean witness = true;
            for (int r = 1; r < s; r++) {
                x = modMul(x, x, n);
                if (x == n - 1) {
                    witness = false;
                    break;
                }
            }
            if (witness)
                return false;
        }
        return true;
    }

    static List<Long> generateHamming(long limit) {
        List<Long> out = new ArrayList<>();
        for (long a = 1; a <= limit; a *= 2) {
            for (long b = a; b <= limit; b *= 3) {
                for (long c = b; c <= limit; c *= 5) {
                    out.add(c);
                    if (c > limit / 5)
                        break;
                }
                if (b > limit / 3)
                    break;
            }
            if (a > limit / 2)
                break;
        }
        Collections.sort(out);
        List<Long> uniqueOut = new ArrayList<>();
        if (!out.isEmpty()) {
            uniqueOut.add(out.get(0));
            for (int i = 1; i < out.size(); i++) {
                if (!out.get(i).equals(out.get(i - 1))) {
                    uniqueOut.add(out.get(i));
                }
            }
        }
        return uniqueOut;
    }

    static final long kMask32 = 0xFFFFFFFFL;
    static long totalMod = 0;
    static long limit = 1000000000000L;
    static List<Long> hamming;
    static long[] prefixMod;
    static List<Long> admissiblePrimes;

    static long sumHammingMod(long x) {
        int low = 0, high = hamming.size();
        while (low < high) {
            int mid = low + (high - low) / 2;
            if (hamming.get(mid) <= x) {
                low = mid + 1;
            } else {
                high = mid;
            }
        }
        return prefixMod[low];
    }

    static void dfs(int idx, long prod) {
        long hSum = sumHammingMod(limit / prod);
        totalMod = (totalMod + ((prod & kMask32) * hSum & kMask32)) & kMask32;

        for (int i = idx; i < admissiblePrimes.size(); i++) {
            long p = admissiblePrimes.get(i);
            if (prod > limit / p)
                break;
            dfs(i + 1, prod * p);
        }
    }

    public static void main(String[] args) {
        hamming = generateHamming(limit);
        prefixMod = new long[hamming.size() + 1];
        for (int i = 0; i < hamming.size(); i++) {
            prefixMod[i + 1] = (prefixMod[i] + (hamming.get(i) & kMask32)) & kMask32;
        }

        admissiblePrimes = new ArrayList<>();
        for (long h : hamming) {
            long p = h + 1;
            if (p > 5 && p <= limit && isPrime(p)) {
                admissiblePrimes.add(p);
            }
        }
        Collections.sort(admissiblePrimes);

        dfs(0, 1);

        System.out.println(totalMod);
    }
}