#include <bits/stdc++.h>
using namespace std;
string to_string(string s) { return '"' + s + '"'; }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A, typename B>
string to_string(pair<A, B> p) {
  return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A>
string to_string(A v) {
  bool first = true;
  string res = "{";
  for (const auto& x : v) {
    if (!first) {
      res += ", ";
    }
    first = false;
    res += to_string(x);
  }
  res += "}";
  return res;
}
void debug_out() { cerr << '\n'; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
  cerr << " " << to_string(H);
  debug_out(T...);
}
const int64_t L1D_CACHE_SIZE = 32768;
int64_t n, A, B, C, D;
const int64_t mod = 1LL << 32;
int64_t get_poly(int64_t p) {
  return (D + p * (C + p * (B + p * A % mod) % mod)) % mod;
}
int64_t get_val(int64_t p) {
  int64_t cnt = 0;
  for (int64_t x = p; x <= n; x *= p) {
    cnt += n / x;
  }
  return (cnt * get_poly(p)) % mod;
}
int64_t 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 val = (limit < 2) ? 0 : get_val(2);
  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]) val += get_val(n);
  }
  return val % mod;
}
void solve() {
  cin >> n >> A >> B >> C >> D;
  cout << segmented_sieve(n) << '\n';
}
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);
  int t = 1;
  while (t--) {
    solve();
  }
  return 0;
}
