#include <bits/stdc++.h>
inline long long getnum() {
  char c = getchar();
  long long num, sign = 1;
  for (; c < '0' || c > '9'; c = getchar())
    if (c == '-') sign = -1;
  for (num = 0; c >= '0' && c <= '9';) {
    c -= '0';
    num = num * 10 + c;
    c = getchar();
  }
  return num * sign;
}
using namespace std;
unsigned int N, a, b, c, d, ans = 0;
const int64_t L1D_CACHE_SIZE = 32768;
unsigned int calc(unsigned int n) {
  return a * n * n * n + b * n * n + c * n + d;
}
void segmented_sieve(int64_t limit) {
  int64_t sqrt = (int64_t)std::sqrt(limit);
  int64_t segment_size = std::max(sqrt, L1D_CACHE_SIZE);
  int64_t count = (limit < 2) ? 0 : 1;
  int64_t i = 3;
  int64_t n = 3;
  int64_t s = 3;
  std::vector<char> sieve(segment_size);
  std::vector<char> is_prime(sqrt + 1, true);
  std::vector<int64_t> primes;
  std::vector<int64_t> multiples;
  for (int64_t low = 0; low <= limit; low += segment_size) {
    std::fill(sieve.begin(), sieve.end(), true);
    int64_t high = low + segment_size - 1;
    high = std::min(high, limit);
    for (; i * i <= high; i += 2)
      if (is_prime[i]) {
        for (int64_t j = i * i; j <= sqrt; j += i) is_prime[j] = false;
      }
    for (; s * s <= high; s += 2) {
      if (is_prime[s]) {
        primes.push_back(s);
        multiples.push_back(s * s - low);
      }
    }
    for (std::size_t i = 0; i < primes.size(); i++) {
      int64_t j = multiples[i];
      for (int64_t k = primes[i] * 2; j < segment_size; j += k)
        sieve[j] = false;
      multiples[i] = j - segment_size;
    }
    for (; n <= high; n += 2)
      if (sieve[n - low]) {
        for (long long i = n; i <= N; i *= n) {
          ans += calc(n) * (N / i);
        }
      }
  }
}
int main(int argc, char** argv) {
  N = getnum(), a = getnum(), b = getnum(), c = getnum(), d = getnum();
  segmented_sieve(N);
  for (long long j = 2; j <= N; j *= 2) {
    ans += calc(2) * (N / j);
  }
  std::cout << ans;
  return 0;
}
