Given an even number N (greater than 2), return two prime numbers whose sum will be equal to given number. There are several combinations possible. Print only the pair whose minimum value is the smallest among all the minimum values of pairs and print the minimum element first.
NOTE: A solution will always exist, read Goldbachs conjecture. 
Example 1:
Input: N = 74
Output: 3 71
Explaination: There are several possibilities 
like 37 37. But the minimum value of this pair 
is 3 which is smallest among all possible 
minimum values of all the pairs.
Example 2:
Input: 4
Output: 2 2
Explaination: This is the only possible 
prtitioning of 4.
Your Task:
You do not need to read input or print anything. Your task is to complete the function primeDivision() which takes N as input parameter and returns the partition satisfying the condition.
Expected Time Complexity: O(N*log(logN))
Expected Auxiliary Space: O(N)
Constraints:
4 ≤ N ≤ 10^{4}

Source: geeksforgeeks | Difficulty: MEDIUM_HARD
Tags: Mathematics

Starter code: #User function Template for python3



class Solution:

    def primeDivision(self, N):

        # code here

Solutions:
class Solution:

	def primeDivision(self, N):

		def check_prime(n):
			for i in range(2, int(n ** 0.5) + 1):
				if n % i == 0:
					return False
			return True
		for i in range(N - 2, 1, -1):
			if check_prime(i) and check_prime(N - i):
				return (N - i, i)
				break


class Solution:

	def primeDivision(self, N):
		primes = [True] * (N + 1)
		primes[0] = primes[1] = False
		for i in range(2, int(N ** 0.5) + 1):
			if primes[i]:
				for j in range(i * i, N + 1, i):
					primes[j] = False
		primes_list = [i for i in range(2, N + 1) if primes[i]]
		primes_set = set(primes_list)
		for p in primes_list:
			if N - p in primes_set:
				return (p, N - p)
		return None


class Solution:

	def primeDivision(self, N):
		u = [0] * (N + 3)
		u[0] = 1
		u[1] = 1
		for h in range(2, N + 3):
			if u[h] == 0:
				for g in range(h + h, N + 3, h):
					u[g] = 1
		for h in range(2, N):
			if u[h] == 0 and u[N - h] == 0:
				return [h, N - h]
		return [0, 0]


from math import sqrt

class Solution:

	def isprime(N):
		for i in range(2, int(sqrt(N)) + 1):
			if N % i == 0:
				return False
		return True

	def primeDivision(self, N):
		primes = [2]
		for t in range(2, N):
			if Solution.isprime(t):
				primes.append(t)
		for i in primes:
			try:
				primes.index(N - i)
				first = i
				second = N - i
			except:
				pass
		if first <= second:
			return (first, second)
		else:
			return (second, first)


class Solution:

	def primeDivision(self, N):
		primes = [True] * (N + 1)
		primes[0] = primes[1] = False
		for i in range(2, int(N ** 0.5) + 1):
			if primes[i]:
				for j in range(i * i, N + 1, i):
					primes[j] = False
		for i in range(2, N // 2 + 1):
			if primes[i] and primes[N - i]:
				return (i, N - i)


class Solution:

	def primeDivision(self, N):
		check = [1 for i in range(N + 1)]
		for i in range(2, N + 1):
			for k in range(i * i, N + 1, i):
				check[k] = 0
		for i in range(2, N - 1):
			if check[i] and check[N - i]:
				return [i, N - i]


import math

def checkPrime(num):
	for i in range(2, int(math.sqrt(num)) + 1):
		if num % i == 0:
			return 0
	return 1

class Solution:

	def primeDivision(self, N):
		primes = set()
		for i in range(2, N):
			if checkPrime(i):
				primes.add(i)
		res = [100000000, 100000000]
		for prime in primes:
			if N - prime in primes:
				if res[0] > prime:
					res = [prime, N - prime]
		return res


import math

def isprime(n):
	if n <= 1:
		return False
	if n == 2:
		return True
	if n > 2 and n % 2 == 0:
		return False
	max_div = math.floor(math.sqrt(n))
	for i in range(3, 1 + max_div, 2):
		if n % i == 0:
			return False
	return True

class Solution:

	def primeDivision(self, N):
		i = 2
		while 1:
			if isprime(i) and isprime(N - i):
				return (i, N - i)
			i += 1


x = 10001
arr = [True] * x
arr[0] = arr[1] = False
for i in range(2, x):
	if arr[i]:
		for j in range(i * i, x, i):
			arr[j] = False

class Solution:

	def primeDivision(self, N):
		a = int(N)
		for i in range(2, a):
			if arr[i] and arr[a - i]:
				return (i, a - i)


class Solution:

	def primeDivision(self, N):
		n = N
		prime = [True for i in range(n + 1)]
		p = 2
		while p * p <= n:
			if prime[p] == True:
				for i in range(p * p, n + 1, p):
					prime[i] = False
			p += 1
		for p in range(2, n + 1):
			if prime[p]:
				if prime[N - p]:
					return (p, N - p)


class Solution:

	def primeDivision(self, n):
		import math

		def is_prime(n):
			if n < 2:
				return False
			i = 2
			while i * i <= n:
				if n % i == 0:
					return False
				i += 1
			return True
		for i in range(2, n - 1):
			if is_prime(i) and is_prime(n - i):
				return [i, n - i]
		return [-1, -1]


class Solution:

	def primeDivision(self, N):

		def prime(n):
			v = int(n ** 0.5) + 1
			for i in range(2, v):
				if n % i == 0:
					return False
			return True
		for num in range(2, N):
			if prime(num):
				value = abs(N - num)
				if prime(value):
					return (num, value)


import math

class Solution:

	def primeDivision(self, N):
		prime = [1] * (N + 1)
		prime[0] = prime[1] = 0
		for i in range(2, int(math.sqrt(N)) + 1):
			if prime[i]:
				for j in range(i * i, N + 1, i):
					prime[j] = 0
		ans = [-1, -1]
		for i in range(2, N // 2 + 1):
			if prime[i] and prime[N - i]:
				return [i, N - i]
		return ans


def p(x):
	for i in range(2, x // 2):
		if x % i == 0:
			return 0
	return 1

class Solution:

	def primeDivision(self, N):
		for i in range(2, N):
			if p(i) == 1:
				if p(N - i) == 1:
					return (i, N - i)
		return (-1, -1)


def isprimes(a):
	w = [1] * (a + 1)
	w[0] = w[1] = 0
	for i in range(2, int(a ** 0.5) + 1):
		if w[i]:
			for j in range(i * i, a + 1, i):
				w[j] = 0
	l = []
	for (i, j) in enumerate(w):
		if j:
			l.append(i)
	return l

class Solution:

	def primeDivision(self, N):
		w = isprimes(N)
		for i in range(len(w)):
			if N - w[i] in w:
				return [w[i], N - w[i]]


class Solution:

	def primeDivision(self, N):
		P = [True for i in range(N + 1)]
		p = 2
		while p * p <= N:
			if P[p] == True:
				for i in range(p * p, N + 1, p):
					P[i] = False
			p = p + 1
		l = []
		for i in range(2, len(P)):
			if P[i]:
				l.append(i)
		(i, j) = (0, len(l) - 1)
		while j >= i:
			if l[i] + l[j] == N:
				return (l[i], l[j])
			if l[i] + l[j] > N:
				j = j - 1
				continue
			i = i + 1


class Solution:

	def primeDivision(self, N):
		arr = [1] * (N + 1)
		for i in range(2, N + 1):
			if arr[i] == 1:
				for j in range(i * i, N + 1, i):
					arr[j] = 0
		for i in range(2, N + 1):
			if arr[i] == 1 and arr[N - i] == 1:
				return [i, N - i]


class Solution:

	def primeDivision(self, N):
		if N == 3:
			return (1, 2)
		elif N == 4:
			return (2, 2)
		elif N == 5:
			return (3, 5)
		elif N > 5:
			f_not_prime = []
			s_not_prime = []
			for i in range(2, int(N / 2)):
				sec = N - i
				for j in range(2, i):
					if len(f_not_prime) == 0 and i % j == 0:
						f_not_prime.append(i)
						break
				if len(f_not_prime) == 0:
					for l in range(2, int(sec / 2)):
						if len(s_not_prime) == 0 and sec % l == 0:
							s_not_prime.append(l)
							break
					if len(s_not_prime) == 0 and i + sec == N:
						return (i, sec)
						break
					elif len(s_not_prime) != 0:
						s_not_prime = []
				elif len(f_not_prime) != 0:
					f_not_prime = []


class Solution:

	def is_prime(self, n):
		for i in range(2, int(n ** 0.5) + 1):
			if n % i == 0:
				return False
		return True

	def primeDivision(self, N):
		l = []
		for i in range(2, N + 1):
			if self.is_prime(i):
				l.append(i)
		for ele in l:
			if N - ele in l:
				return [ele, N - ele]


class Solution:

	def sieve(self, n, l):
		prime = [True for i in range(n + 1)]
		p = 2
		while p * p <= n:
			if prime[p] == True:
				for i in range(p * p, n + 1, p):
					prime[i] = False
			p += 1
		for p in range(2, n + 1):
			if prime[p] == True:
				l.append(p)

	def pairs(self, l, t):
		low = 0
		high = len(l) - 1
		while low <= high:
			if l[low] + l[high] == N:
				t.append([l[low], l[high]])
			if l[low] + l[high] > N:
				high -= 1
			else:
				low += 1

	def primeDivision(self, N):
		l = []
		self.sieve(N, l)
		t = []
		self.pairs(l, t)
		t.sort()
		return t[0]


class Solution:

	def isPrime(self, n):
		if n == 0 or n == 1:
			return False
		for i in range(2, int(n ** 0.5) + 1):
			if n % i == 0:
				return False
		return True

	def primeDivision(self, N):
		a = []
		for i in range(1, N):
			if self.isPrime(i) and self.isPrime(N - i):
				a.append(i)
				a.append(N - i)
				break
		return (a[0], a[1])


class Solution:

	def primeDivision(self, N):

		def sieveoferatosthene(N):
			dp = [False] * (N + 1)
			for i in range(2, N + 1):
				dp[i] = True
			p = 0
			while p * p <= N:
				if dp[p]:
					i = p * p
					while i <= N:
						dp[i] = False
						i += p
				p += 1
			return dp
		dp = sieveoferatosthene(N)
		for i in range(0, N):
			if dp[i] and dp[N - i]:
				return [i, N - i]


def fun(n):
	if n == 0 or n == 1:
		return False
	for i in range(2, int(n ** 0.5) + 1):
		if n % i == 0:
			return False
	return True

class Solution:

	def primeDivision(self, N):
		d = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]
		if fun(N):
			return (0, N)
		else:
			for i in d:
				if fun(N - i):
					return (i, N - i)


class Solution:

	def isPrime(self, p):
		if p <= 1:
			return 0
		for i in range(2, int(p ** 0.5) + 1):
			if p % i == 0:
				return False
		return True

	def primeDivision(self, N):
		for i in range(2, N + 1):
			if self.isPrime(i) and self.isPrime(N - i):
				return [i, N - i]


from math import *

class Solution:

	def primeDivision(self, n):

		def isprime(n):
			if n > 1:
				for i in range(2, int(sqrt(n)) + 1):
					if n % i == 0:
						return False
				else:
					return True
			else:
				return False
		i = 2
		while True:
			if isprime(i) and isprime(n - i):
				return [i, n - i]
			i += 1


class Solution:

	def primes(self, n):
		pl = [True] * (10 ** 4 + 1)
		pl[0] = pl[1] = False
		for i in range(2, 101):
			if pl[i] == True:
				for j in range(i * i, 10 ** 4 + 1, i):
					pl[j] = False
		res = []
		for i in range(2, 10 ** 4 + 1):
			if pl[i] == True:
				res.append(i)
		x = self.bsf(res, n)
		return res[:x + 1]

	def bsf(self, a, k):
		n = len(a)
		(l, h) = (0, n - 1)
		while l <= h:
			m = (l + h) // 2
			if a[m] > k:
				h = m - 1
			else:
				idx = m
				l = m + 1
		return idx

	def primeDivision(self, N):
		sl = self.primes(N)
		(p1, p2) = (0, len(sl) - 1)
		while p1 <= p2:
			t = sl[p1] + sl[p2]
			if t == N:
				return (sl[p1], sl[p2])
			elif t > N:
				p2 -= 1
			else:
				p1 += 1


from math import sqrt, ceil

class Solution:

	def primeDivision(self, N):
		primes = [True] * (N + 1)
		primes[0] = primes[1] = False
		for i in range(2, ceil(sqrt(N)) + 1):
			if not primes[i]:
				continue
			for j in range(i * i, N + 1, i):
				primes[j] = False
		for i in range(2, N // 2 + 1):
			if primes[i] and primes[N - i]:
				return (i, N - i)


class Solution:

	def primeDivision(self, N):

		def is_prime(a):
			for i in range(2, int(a ** 0.5) + 1):
				if a % i == 0:
					return False
			return True
		if is_prime(N - 2):
			return [2, N - 2]
		for j in range(3, N, 2):
			if is_prime(j) and is_prime(N - j):
				return [j, N - j]


import math

class Solution:

	def primeDivision(self, N):

		def isPrime(n):
			for i in range(2, int(math.sqrt(n)) + 1):
				if n % i == 0:
					return False
			return True
		for i in range(2, N // 2 + 1):
			if isPrime(N - i) and isPrime(i):
				return (i, N - i)


import math

class Solution:

	def primeDivision(self, n):

		def prime(n):
			if n == 1:
				return 1
			for i in range(2, int(math.sqrt(n)) + 1):
				if n % i == 0:
					return 1
			return 0
		for i in range(2, n):
			if prime(i) == 0 and prime(n - i) == 0:
				return (i, n - i)


class Solution:

	def checkPrime(self, n):
		for x in range(2, int(pow(n, 0.5)) + 1):
			if not n % x:
				return False
		return True

	def primeDivision(self, N):
		arr = []
		for x in range(2, int(N >> 1) + 1):
			if self.checkPrime(x):
				if self.checkPrime(N - x):
					return (x, N - x)


class Solution:

	def primeDivision(self, N):

		def prime(n):
			for i in range(2, int(n ** 0.5) + 1):
				if n % i == 0:
					return False
			return True
		l = []
		for i in range(2, N + 1):
			if prime(i) and prime(N - i):
				return (i, N - i)
		return (-1, -1)


class Solution:

	def primeDivision(self, N):
		z = []
		for i in range(1, N + 1):
			if i > 1:
				for j in range(2, int(i ** 0.5) + 1):
					if i % j == 0:
						break
				else:
					z.append(i)
		l = []
		i = 0
		j = len(z) - 1
		while i < len(z) and j < len(z) and (i <= j):
			if z[i] + z[j] == N:
				l.append([z[i], z[j]])
				i += 1
				j -= 1
			elif z[i] + z[j] > N:
				j -= 1
			elif z[i] + z[j] < N:
				i += 1
		return l[0]


class Solution:

	def primeDivision(self, N):
		(start, end) = (2, N - 1)
		i = 0

		def isPrime(n):
			if n == 2:
				return True
			else:
				for i in range(2, n):
					if n % i == 0:
						return False
				else:
					return True
		while i <= N:
			if isPrime(start) == True and isPrime(end) == True:
				if start + end == N:
					return (start, end)
				elif start + end < N:
					start += 1
				elif start + end > N:
					end -= 1
			elif isPrime(start) == False and isPrime(end) == True:
				start += 1
			elif isPrime(start) == True and isPrime(end) == False:
				end -= 1
			else:
				start += 1
				end -= 1
			i += 1


class Solution:

	def primeDivision(self, N):

		def seive_prime(N):
			seive = [True] * (N + 1)
			(seive[0], seive[1]) = (False, False)
			for i in range(1, N + 1):
				if seive[i] == True:
					for j in range(2 * i, N + 1, i):
						seive[j] = False
			prime = []
			for (i, boolean) in enumerate(seive):
				if boolean == True:
					prime.append(i)
			return prime

		def twoSum(prime, N):
			n = len(prime)
			(left, right) = (0, n - 1)
			while left <= right:
				currSum = prime[left] + prime[right]
				if currSum == N:
					return (prime[left], prime[right])
				elif currSum < N:
					left += 1
				else:
					right -= 1
			return []
		return twoSum(seive_prime(N), N)


class Solution:

	def primeDivision(self, N):
		d = dict()
		for i in range(2, N):
			d[i] = True
		i = 2
		while i * i < N:
			if d[i]:
				multiple = i
				while multiple < N:
					multiple = multiple + i
					d[multiple] = False
			i = i + 1
		for i in range(2, N):
			if d[i] and d[N - i]:
				return [i, N - i]


from math import *

class Solution:

	def primeDivision(self, n):
		for i in range(2, ceil(sqrt(n)) + 1):
			if isprime(i) and isprime(n - i):
				return (i, n - i)

def isprime(n):
	if n <= 1:
		return
	if n == 2 or n == 3:
		return True
	if n % 2 == 0 or n % 3 == 0:
		return False
	for i in range(2, int(sqrt(n)) + 1):
		if n % i == 0 or n % (i + 2) == 0:
			return False
	return True


class Solution:

	def primeDivision(self, N):
		prime = [True for _ in range(N + 1)]
		p = 2
		while p * p <= N:
			if prime[p] == True:
				for i in range(p * p, N + 1, p):
					prime[i] = False
			p += 1
		prime_numbers = []
		for p in range(2, N + 1):
			if prime[p]:
				prime_numbers.append(p)
		for i in prime_numbers:
			for j in prime_numbers[::-1]:
				if i + j == N:
					return [i, j]


class Solution:

	def isPrime(self, num):
		if num == 1:
			return False
		for x in range(2, int(pow(num, 0.5)) + 1):
			if num % x == 0:
				return False
		return True

	def primeDivision(self, N):
		O = N
		N -= 1
		while N > 0:
			if N & 1 == 0 and N != 2:
				N -= 1
				continue
			if self.isPrime(N):
				if self.isPrime(O - N):
					return [O - N, N]
				else:
					N -= 1
			else:
				N -= 1
		return [-1, -1]


import math

def isprime(num) -> bool:
	itr = 2
	while itr <= math.sqrt(num):
		if num % itr < 1:
			return False
		itr = itr + 1
	return num > 1

class Solution:

	def primeDivision(self, N):
		start = 2
		while True:
			if isprime(start) and isprime(N - start):
				return (start, N - start)
			start += 1


class Solution:

	def primeDivision(self, N):

		def isPrime(num):
			if num < 2:
				return False
			i = 2
			while i * i <= num:
				if num % i == 0:
					return False
				i += 1
			return True
		if N < 3:
			return (-1, -1)
		for i in range(2, N // 2 + 1):
			if isPrime(i) and isPrime(N - i):
				return (i, N - i)
		return (-1, -1)


from math import *

class Solution:

	def primeDivision(self, N):

		def ispr(n):
			if n <= 1:
				return 0
			else:
				for i in range(2, int(sqrt(n)) + 1):
					if n % i == 0:
						return 0
				else:
					return 1
		for i in range(2, N + 1):
			if ispr(i) == 1 and ispr(N - i) == 1:
				return [i, N - i]


class Solution:

	def primeDivision(self, n):

		def fun(n):
			if n <= 1:
				return 0
			else:
				k = int(n ** (1 / 2)) + 1
				for i in range(2, k):
					if n % i == 0:
						return 0
				return 1
		for i in range(2, n + 1):
			if fun(i) == 1 and fun(n - i) == 1:
				return [i, n - i]


class Solution:

	def primeDivision(self, N):
		prime = [True] * (N - 1)
		self.eratosthenes(N - 2, prime)
		for k in range(N):
			if prime[k] and prime[N - k]:
				return (k, N - k)

	@staticmethod
	def eratosthenes(n, prime):
		prime[0] = False
		prime[1] = False
		num = 2
		while num * num <= n:
			if prime[num]:
				for i in range(num * num, n + 1, num):
					prime[i] = False
			num += 1


def prime(n):
	for i in range(2, int(n ** (1 / 2)) + 1):
		if n % i == 0:
			return False
		else:
			continue
	return True

class Solution:

	def primeDivision(self, N):
		d = {}
		b = []
		for i in range(2, N):
			if prime(i) == True:
				b.append(i)
				d[i] = 1
			else:
				continue
		for i in range(0, len(b)):
			if d.get(N - b[i], 0) == 1 and d.get(b[i], 0) == 1:
				return [b[i], N - b[i]]
				break
			else:
				continue


def SieveOfEratosthenes(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	s = set()
	for p in range(2, n + 1):
		if prime[p]:
			s.add(p)
	return s

class Solution:

	def primeDivision(self, N):
		s = SieveOfEratosthenes(N)
		l = sorted(list(s))
		for a in l:
			if N - a in s:
				return [a, N - a]


class Solution:

	def isprime(self, N):
		c = 0
		for i in range(2, int(N / 2) + 1):
			if N % i == 0:
				return 0
		else:
			return 1
		return 1

	def primeDivision(self, N):
		for i in range(2, N):
			if self.isprime(i):
				if self.isprime(N - i):
					return (i, N - i)


class Solution:

	def primeDivision(self, N):

		def isPrime(n):
			k = int(n ** 0.5) + 1
			for i in range(3, k, 2):
				if n % i == 0:
					return False
			return True
		if N == 4:
			return (2, 2)
		for i in range(3, N // 2 + 1, 2):
			if isPrime(i) and isPrime(N - i):
				return (i, N - i)


class Solution:

	def prime(self, n):
		for j in range(2, int(n ** 0.5) + 1):
			if n % j == 0:
				return 0
		return n

	def primeDivision(self, N):
		for i in range(2, N):
			a = self.prime(i)
			if a:
				b = self.prime(N - a)
				if b:
					return (a, b)


def SieveOfEratosthenes(n, isPrime):
	isPrime[0] = isPrime[1] = False
	for i in range(2, n + 1):
		isPrime[i] = True
	p = 2
	while p * p <= n:
		if isPrime[p] == True:
			i = p * p
			while i <= n:
				isPrime[i] = False
				i += p
		p += 1

class Solution:

	def primeDivision(self, N):
		res = []
		isPrime = [0] * (N + 1)
		SieveOfEratosthenes(N, isPrime)
		for i in range(0, N):
			if isPrime[i] and isPrime[N - i]:
				res.append(i)
				res.append(N - i)
				return res


def isPrime(n, r=False):
	if n < 4:
		return n > 1
	(isDivisible, k, i) = (lambda n, i, r: n if n % i else i if r else r, int(n ** 0.5), 2)
	while i <= k:
		d = isDivisible(n, i, r)
		if d - n:
			return d
		i += i - 1 if i in (2, 3) else (i - 3) % 6
	return True

class Solution:

	def primeDivision(self, N):
		if N == 4:
			return (2, 2)
		if isPrime(N - 3):
			return (3, N - 3)
		(i, n, a) = (5, N // 2, [])
		while i <= n:
			if isPrime(N - i) and isPrime(i):
				return (i, N - i)
			i += (i - 3) % 6


class Solution:

	def primeDivision(self, A):
		sieve = [True for i in range(A + 1)]
		for i in range(2, A + 1):
			if sieve[i]:
				for j in range(i * i, A + 1, i):
					if sieve[j]:
						sieve[j] = False
		for i in range(2, A):
			if sieve[i] and sieve[A - i]:
				ans = [i, A - i]
				break
		return ans


class Solution:

	def check(self, n):
		if n == 2:
			return True
		c = 0
		for i in range(2, n // 2):
			if n % i == 0:
				c += 1
				break
		if c > 0:
			return False
		return True

	def primeDivision(self, n):
		l = []
		for i in range(2, n // 2 + 1):
			if self.check(i):
				if self.check(n - i):
					l.append(i)
					l.append(n - i)
					break
		return (l[0], l[1])


class Solution:

	def primeDivision(self, N):
		prime_list = [True] * (N + 1)
		pi = 2
		while pi * pi <= N:
			if prime_list[pi]:
				for i in range(pi * pi, N + 1, pi):
					prime_list[i] = False
			pi += 1
		for i in range(2, N // 2 + 1):
			if prime_list[i] and prime_list[N - i]:
				return [i, N - i]
		return [-1, -1]


class Solution:

	def pr(n):
		if n == 1 or n == 0:
			return False
		if n == 2 or n == 3:
			return True
		if n % 2 == 0 or n % 3 == 0:
			return False
		for i in range(5, int(n ** 0.5) + 1, 6):
			if n % i == 0 or n % (i + 2) == 0:
				return False
		return True

	def primeDivision(self, N):
		a = 0
		b = 0
		for i in range(1, N // 2 + 1):
			if Solution.pr(i) == True and Solution.pr(N - i) == True:
				return (i, N - i)


class Solution:

	def prime(self, n):
		if n < 2:
			return 0
		for i in range(2, int(n ** 0.5) + 1):
			if n % i == 0:
				return 0
		return 1

	def primeDivision(self, N):
		r = []
		for i in range(2, N):
			if self.prime(i):
				if self.prime(N - i):
					r.append(i)
					r.append(N - i)
					break
		return r


import math

class Solution:

	def isPrime(self, x):
		if x % 2 == 0:
			return False
		for i in range(3, int(math.sqrt(x)) + 1, 1):
			if x % i == 0:
				return False
		return True

	def primeDivision(self, N):
		if N == 4:
			return (2, 2)
		if N == 5:
			return (2, 3)
		for i in range(3, N // 2, 2):
			if self.isPrime(i) and self.isPrime(N - i):
				return (i, N - i)


import math

class Solution:

	def primeDivision(self, n):
		if n == 2:
			return 0

		def prime(num):
			if num >= 2:
				for i in range(2, int(math.sqrt(num)) + 1):
					if num % i == 0:
						return False
				return True
			return False
		l = []
		for i in range(2, n // 2 + 1):
			y = n - i
			if prime(i) and prime(y):
				l.append([i, y])
		if len(l) == 1:
			return l[0]
		ans = 99999999
		for i in l:
			m = min(i)
			if m < ans:
				ans = min(i)
				res = i
		return res


import math

def isprime(num):
	i = 2
	while i <= math.sqrt(num):
		if num % i < 1:
			return False
		i = i + 1
	return num > 1

class Solution:

	def primeDivision(self, N):
		a = 2
		while True:
			if isprime(a) and isprime(N - a):
				return (a, N - a)
			a += 1


class Solution:

	def primeDivision(self, N):

		def isprime(x):
			if x == 1 or x == 0:
				return False
			if x == 2:
				return True
			if x % 2 == 0:
				return False
			i = 3
			while i * i <= x:
				if x % i == 0:
					return False
				i += 2
			else:
				return True
		for i in range(N // 2 + 1):
			if isprime(i) and isprime(N - i):
				return [i, N - i]


class Solution:

	def primeDivision(self, N):

		def isprime(num):
			for i in range(2, int(num ** 0.5) + 1):
				if num % i == 0:
					return 0
			return 1
		for i in range(2, N):
			if isprime(i):
				if isprime(N - i):
					return (i, N - i)


class Solution:

	def primeDivision(self, n):

		def prime(num):
			count = 0
			for i in range(2, num // 2):
				if num % i == 0:
					count += 1
			if count == 0:
				return True
			else:
				return False
		x = []
		y = []
		prime(n)
		for i in range(2, n):
			if prime(i) and prime(n - i):
				return (i, n - i)


import math

class Solution:

	def primeDivision(self, N):

		def findingPrime(num):
			count = 0
			for i in range(2, int(num ** 0.5) + 1):
				if num % i == 0:
					count += 1
					break
			if count == 0:
				return 'prime'
			else:
				return 'notPrime'
		for i in range(2, N):
			if findingPrime(i) == 'prime' and findingPrime(N - i) == 'prime':
				return (i, N - i)
				break