Problem: 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.

Solution (in JAVA):

Solution:
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import static java.lang.Math.*;
import static java.util.Arrays.*;

public class Main {

	public static void main(String[] args) throws IOException {
		new Main().run();
	}

	BufferedReader in;
	PrintWriter out;
	StringTokenizer st = new StringTokenizer("");

	private void run() throws IOException {
		if (new File("input.txt").exists())
			in = new BufferedReader(new FileReader("input.txt"));
		else
			in = new BufferedReader(new InputStreamReader(System.in));
		if (new File("output.txt").exists())
			out = new PrintWriter("output.txt");
		else
			out = new PrintWriter(System.out);

		solve();

		in.close();
		out.close();
	}

	final int maxn = 1000 * 1000 + 100;

	int cntPrimes;
	int primes[] = new int[maxn];
	int cntComposites;
	int composites[] = new int[maxn];
	int minDiv[] = new int[maxn];

	void precalc() {
		cntPrimes = 0;
		cntComposites = 0;
		for (int i = 2; i < maxn; i++)
			minDiv[i] = i;
		for (int i = 2; i < maxn; i++) {
			if (minDiv[i] == i)
				primes[cntPrimes++] = i;
			else
				composites[cntComposites++] = i;
			for (int j = 0, index; j < cntPrimes && primes[j] <= minDiv[i] && (index = i * primes[j]) < maxn; j++)
				minDiv[index] = primes[j];
		}
	}

	void solve() throws IOException {
		precalc();

		int n = nextInt();
		int ans = -1;
		for (int l = 0, r = cntComposites - 1; l <= r && ans == -1; l++) {
			while (composites[l] + composites[r] > n)
				r--;
			if (composites[l] + composites[r] == n)
				ans = composites[l];
		}

		out.println(ans + " " + (n - ans));
	}

	String nextLine() throws IOException {
		st = new StringTokenizer("");
		return in.readLine();
	}

	String nextToken() throws IOException {
		while (!st.hasMoreTokens()) {
			st = new StringTokenizer(in.readLine());
		}
		return st.nextToken();
	}

	int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}

	double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}

	boolean EOF() throws IOException {
		while (!st.hasMoreTokens()) {
			String str = in.readLine();
			if (str == null)
				return true;
			st = new StringTokenizer(str);
		}
		return false;
	}

}