#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;
}

### Prompt

Please provide a Cpp coded solution to the problem described below:

Notice: unusual memory limit!

After the war, destroyed cities in the neutral zone were restored. And children went back to school.

The war changed the world, as well as education. In those hard days, a new math concept was created.

As we all know, logarithm function can be described as: $$$ log(p_1^{a_1}p_2^{a_2}...p_k^{a_2}) = a_1 log p_1 + a_2 log p_2 + ... + a_k log p_k  Where p_1^{a_1}p_2^{a_2}...p_k^{a_2}$$$ is the prime factorization of a integer. A problem is that the function uses itself in the definition. That is why it is hard to calculate.

So, the mathematicians from the neutral zone invented this: $$$ exlog_f(p_1^{a_1}p_2^{a_2}...p_k^{a_2}) = a_1 f(p_1) + a_2 f(p_2) + ... + a_k f(p_k) $$$

Notice that exlog_f(1) is always equal to 0.

This concept for any function f was too hard for children. So teachers told them that f can only be a polynomial of degree no more than 3 in daily uses (i.e., f(x) = Ax^3+Bx^2+Cx+D).

"Class is over! Don't forget to do your homework!" Here it is: $$$ ∑_{i=1}^n exlog_f(i) $$$

Help children to do their homework. Since the value can be very big, you need to find the answer modulo 2^{32}.

Input

The only line contains five integers n, A, B, C, and D (1 ≤ n ≤ 3 ⋅ 10^8, 0 ≤ A,B,C,D ≤ 10^6).

Output

Print the answer modulo 2^{32}.

Examples

Input

12 0 0 1 0


Output

63


Input

4 1 2 3 4


Output

136

Note

In the first sample:

exlog_f(1) = 0

exlog_f(2) = 2

exlog_f(3) = 3

exlog_f(4) = 2 + 2 = 4

exlog_f(5) = 5

exlog_f(6) = 2 + 3 = 5

exlog_f(7) = 7

exlog_f(8) = 2 + 2 + 2 = 6

exlog_f(9) = 3 + 3 = 6

exlog_f(10) = 2 + 5 = 7

exlog_f(11) = 11

exlog_f(12) = 2 + 2 + 3 = 7

 ∑_{i=1}^{12} exlog_f(i)=63 

In the second sample:

exlog_f(1) = 0

exlog_f(2) = (1 × 2^3 + 2 × 2^2 + 3 × 2 + 4) = 26

exlog_f(3) = (1 × 3^3 + 2 × 3^2 + 3 × 3 + 4) = 58

exlog_f(4) = 2 × exlog_f(2) = 52

 ∑_{i=1}^4 exlog_f(i)=0+26+58+52=136 

### Response

```cpp
#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;
}

```