One way to create a task is to learn from math. You can generate some random math statement or modify some theorems to get something new and build a new task from that.

For example, there is a statement called the "Goldbach's conjecture". It says: "each even number no less than four can be expressed as the sum of two primes". Let's modify it. How about a statement like that: "each integer no less than 12 can be expressed as the sum of two composite numbers." Not like the Goldbach's conjecture, I can prove this theorem.

You are given an integer n no less than 12, express it as a sum of two composite numbers.

Input

The only line contains an integer n (12 ≤ n ≤ 106).

Output

Output two composite integers x and y (1 < x, y < n) such that x + y = n. If there are multiple solutions, you can output any of them.

Examples

Input

12


Output

4 8


Input

15


Output

6 9


Input

23


Output

8 15


Input

1000000


Output

500000 500000

Note

In the first example, 12 = 4 + 8 and both 4, 8 are composite numbers. You can output "6 6" or "8 4" as well.

In the second example, 15 = 6 + 9. Note that you can't output "1 14" because 1 is not a composite number.
#include <bits/stdc++.h>
using namespace std;
inline int POPCNT(int _x) { return __builtin_popcount(_x); }
inline int POPCNT(long long _x) { return __builtin_popcountll(_x); }
const int iINF = 1L << 30;
const long long lINF = 1LL << 60;
double EPS = 1e-9;
inline bool in_range(int _v, int _mx, int _mi) { return _mi <= _v && _v < _mx; }
inline bool in_range(double _v, double _mi, double _mx) {
  return -EPS < _v - _mi && _v - _mx < EPS;
}
inline bool in_range(int _x, int _y, int _W, int _H) {
  return 0 <= _x && _x < _W && 0 <= _y && _y < _H;
}
const int DX[4] = {0, 1, 0, -1}, DY[4] = {-1, 0, 1, 0};
const int DX_[8] = {0, 1, 1, 1, 0, -1, -1, -1},
          DY_[8] = {-1, -1, 0, 1, 1, 1, 0, -1};
int n;
struct Primes {
  int max_p;
  vector<int> primes;
  vector<int> prime_num;
  vector<int> composit;
  Primes(int _mx) : max_p(_mx) { enum_primes(); }
  void enum_primes() {
    primes.clear();
    prime_num.assign(max_p + 1, 0);
    vector<bool> is_p(max_p + 1, true);
    for (int i = 2; i < max_p + 1; ++i) {
      if (is_p[i]) {
        prime_num[i]++;
        primes.push_back(i);
        for (int j = 2 * i; j <= max_p; j += i) is_p[j] = false;
      } else {
        composit.push_back(i);
      }
      prime_num[i] += prime_num[i - 1];
    }
  }
  int p_count(int _x) { return prime_num[_x]; }
  int p_count(int _mi, int _mx) { return prime_num[_mx] - prime_num[_mi - 1]; }
  int at(int _i) { return primes[_i]; }
  int cat(int _i) { return composit[_i]; }
  bool p_search(int x) {
    return binary_search(primes.begin(), primes.end(), x);
  }
  bool c_search(int x) {
    return binary_search(composit.begin(), composit.end(), x);
  }
};
void solve() {
  Primes primes((int)1e6);
  for (int i = 3; i < (int)1e6; ++i) {
    if (primes.c_search(i)) {
      int s = n - i;
      if (primes.c_search(s)) {
        cout << i << " " << s << endl;
        return;
      }
    }
  }
}
int main() {
  cin >> n;
  solve();
  return 0;
}
