There was once young lass called Mary,  

Whose jokes were occasionally scary.  

On this April's Fool  

Fixed limerick rules  

Allowed her to trip the unwary.



Can she fill all the lines

To work at all times?

On juggling the words

Right around two-thirds

She nearly ran out of rhymes.




-----Input-----

The input contains a single integer $a$ ($4 \le a \le 998$). Not every integer in the range is a valid input for the problem; you are guaranteed that the input will be a valid integer.


-----Output-----

Output a single number.


-----Examples-----
Input
35

Output
57

Input
57

Output
319

Input
391

Output
1723

Difficulty: MEDIUM

Starter code:

Solutions:
z = int(input())
a = 2
while z / a != z // a:
	a += 1
stri = ''
if a < z // a:
	stri += f'{a}'
	stri += f'{z // a}'
else:
	stri += f'{z // a}'
	stri += f'{a}'
print(stri)


n = int(input())
for i in range(2, n + 1):
	if n % i == 0:
		print(i, n // i, sep='')
		break


n = int(input())
for i in range(2, 101):
	if n % i == 0:
		print(str(i) + str(n // i))
		break


n = int(input())
for i in range(2, n):
	if n % i == 0:
		x = i
		y = n // i
		break
print(str(x) + str(y))


t = int(input())
s = ''
while t % 2 == 0:
	s += '2'
	t //= 2
for i in range(3, int(t ** 0.5) + 1, 2):
	while t % i == 0:
		s += str(i)
		t //= i
if t > 1:
	s += str(t)
print(s)


a = int(input())
for i in range(2, a // 2 + 1):
	if a % i == 0:
		print('{f1}{f2}'.format(f1=i, f2=a // i))
		break


from math import sqrt, ceil
a = int(input())
for i in range(2, ceil(sqrt(a)) + 1):
	if a % i == 0:
		print(i, end='')
		print(a // i)
		break


n = int(input())
l = []
c = 0
for i in range(2, n):
	for j in range(2, n):
		if i * j == n:
			l.append(str(i))
			l.append(str(j))
			print(''.join(l))
			c = 1
			break
	if c == 1:
		break


x = int(input())
i = 2
ans = 1
while i * i <= x:
	if x % i == 0:
		ans = i
		break
	i += 1
print(ans, end='')
ans2 = x // ans
print(ans2)


a = int(input())
for i in range(2, a):
	if a % i == 0:
		print(i, a // i, sep='')
		break


import sys, bisect
from math import gcd
input = sys.stdin.readline

def inp():
	return int(input().rstrip())

def inlt():
	return list(map(int, input().rstrip().split()))

def insr():
	s = input().rstrip()
	return s[:len(s) - 1]

def invr():
	return map(int, input().rstrip().split())
primes = []
for j in range(2, 1000):
	for i in range(2, j):
		if j % i == 0:
			break
	else:
		primes.append(j)
n = inp()
for i in primes:
	if n % i == 0:
		print(str(i) + str(n // i))
		break


def search(arr, n, x):
	for i in range(0, n):
		if arr[i] == x:
			return i
	return 0
n = int(input())
l = [1, 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, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499]
for i in range(len(l)):
	k = search(l, len(l), n / l[i])
	if k:
		print(l[i], l[k], sep='')
		break


ans = ''
a = int(input())
primes = []
for i in range(0, a + 1):
	primes.append(1)
for i in range(2, a + 1):
	if primes[i] == 1:
		for j in range(2 * i, a + 1, i):
			primes[j] = 0
for i in range(2, a + 1):
	if primes[i] == 1 and a % i == 0:
		temp = a
		while temp % i == 0:
			ans = ans + str(i)
			temp = temp / i
print(int(ans))


a = int(input())
for i in range(1, a):
	for j in range(i, a):
		if i * j == a:
			print(i, end='')
			print(j)
			break


n = input()
f = 1
for i in range(2, 1000):
	for j in range(2, 1000):
		if i * j == int(n):
			print(str(i) + str(j))
			f = 0
			break
	if f == 0:
		break


def fact(n):
	Ans = []
	d = 2
	while d * d <= n:
		if n % d == 0:
			Ans.append(d)
			n //= d
		else:
			d += 1
	if n > 1:
		Ans.append(n)
	return Ans
print(*fact(int(input())), sep='')


n = int(input())
for i in range(2, n):
	if n % i == 0:
		break
print(i, end='')
print(n // i)


def factors(n):
	p = 2
	f = []
	while n > 1:
		if n % p:
			p += 1
		else:
			n //= p
			if p not in f:
				f.append(f'{p}')
	return ''.join(f)
n = int(input())
print(factors(n))


from sys import stdin
input = lambda : stdin.readline()
from math import ceil, sqrt, factorial
n = int(input())
for i in range(2, n + 1):
	if n % i == 0:
		a = i
		b = n // i
		break
print(str(min(a, b)) + str(max(a, b)))


a = int(input())
x = []
for i in range(1, a):
	if a % i == 0:
		x.append(i)
c = a // x[-1]
print('{}{}'.format(c, x[-1]))


import os
import sys
from io import BytesIO, IOBase
import heapq as h
from bisect import bisect_left
from types import GeneratorType
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		import os
		self.os = os
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			self.os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
import time
start_time = time.time()
import collections as col
import math, string
from functools import reduce

def getInts():
	return [int(s) for s in input().split()]

def getInt():
	return int(input())

def getStrs():
	return [s for s in input().split()]

def getStr():
	return input()

def listStr():
	return list(input())
MOD = 10 ** 9 + 7

def solve():
	N = getInt()
	i = 2
	while True:
		if N % i == 0:
			print(i, N // i, sep='')
			return
		i += 1
solve()


n = int(input())
primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]
ans = []
for prime in primes:
	if n % prime == 0:
		print('{}{}'.format(prime, n // prime))
		break


a = int(input())
b = [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, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503]
ans = ''
flag = 0
for i in b:
	for j in b:
		if i * j == a:
			flag = 1
			mini = min(i, j)
			maxi = max(i, j)
			ans = str(mini) + str(maxi)
			break
	if flag == 1:
		break
print(ans)


l = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]
x = int(input())
for i in l:
	if x % i == 0:
		print(str(i) + str(x // i))
		break


n = int(input())
i = 2
while i * i <= n:
	if n % i == 0:
		print(i, end='')
		print(n // i, end='')
	i += 1


a = int(input())
for i in range(2, a // 2 + 1):
	if a % i == 0:
		res = i * 10 ** len(str(a // i)) + a // i
		break
print(res)


a = int(input())
for i in range(2, a - 1):
	if a % i == 0:
		print(str(i) + str(a // i))
		break


n = int(input())
ans = ''
for i in range(2, n):
	if n % i == 0:
		ans = str(n // i) + str(i)
print(ans)


from math import *

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

def findPrimePair(n):
	flag = 0
	isPrime = [False] * (n + 1)
	SieveOfEratosthenes(n, isPrime)
	for i in range(2, n):
		x = int(n / i)
		if isPrime[i] & isPrime[x] and x * i == n:
			print(i, end='')
			print(x)
			flag = 1
			break
	if not flag:
		print('No such pair found')
n = int(input())
findPrimePair(n)


inp = int(input())
least = 2
while True:
	if inp / least % 1 == 0.0:
		break
	least = least + 1
second = int(inp / least)
print(str(least) + str(second))


n = int(input())
arr = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]
ans = ''
for i in range(11):
	if n % arr[i] == 0:
		n = n // arr[i]
		ans += str(arr[i])
if n != 1:
	ans += str(n)
print(ans)


from math import sqrt
n = int(input())
i = int(sqrt(n))
while i >= 1:
	if n % i == 0:
		print(str(i) + str(n // i))
		break
	i -= 1


n = int(input())
for d in range(2, n):
	if n % d == 0:
		print(str(d) + str(n // d))
		break


n = int(input())
for i in range(2, n + 1):
	while n % i == 0:
		print(i, end='')
		n /= i


no = int(input())
i = 2
while i <= no:
	if no % i == 0:
		print(i, end='')
		no = no / i
	else:
		i += 1


def SoE(n):
	prime = [True for _ in range(n + 1)]
	prime[0] = False
	prime[1] = False
	p = 2
	while p * p <= n:
		if prime[p]:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime
prime = SoE(1000)
a = int(input())
for i in range(2, int(a ** 0.5) + 1):
	if prime[i] and a % i == 0:
		b1 = i
		b2 = a // i
		break
print(str(b1) + str(b2))


def ispr(n):
	n = abs(int(n))
	if n < 2:
		return False
	if n == 2:
		return True
	if not n & 1:
		return False
	for x in range(3, int(n ** 0.5) + 1, 2):
		if n % x == 0:
			return False
	return True
n = int(input())
a = ''
for i in range(2, n):
	if n % i == 0 and ispr(i):
		if ispr(n // i):
			print(i, n // i, sep='')
			break


n = int(input())
answer = ''
for i in range(2, n + 1):
	if n % i == 0:
		answer = str(i) + str(n // i)
		break
print(answer)


from sys import exit
n = int(input())
for i in range(2, n):
	if n % i == 0:
		print(i, n // i, sep='')
		exit()


n = int(input())
k = ''
for i in range(2, 998):
	if n % i == 0:
		k += str(i)
		z = i
		break
k += str(n // z)
print(k)


n = int(input())
arr = [str(i) + str(n // i) for i in range(2, int(n ** 0.5) + 1) if n % i == 0]
print(arr[0])


def Factor(n):
	Ans = []
	d = 2
	while d * d <= n:
		if n % d == 0:
			Ans.append(d)
			n //= d
		else:
			d += 1
	if n > 1:
		Ans.append(n)
	return Ans
a = Factor(int(input()))
print(*sorted(a), sep='')


from math import *
n = int(input())
sq = floor(sqrt(n))
div1 = 1
for i in range(sq, 1, -1):
	if n % i == 0:
		div1 = i
		break
div2 = n // i
print(str(div1) + str(div2))


from math import sqrt

def factor(x):
	for i in range(2, int(sqrt(x) + 1)):
		if x % i == 0:
			return i
num = int(input())
x = factor(num)
y = num // factor(num)
print(str(x) + str(y))


N = int(input())
i = 2
while N != 1:
	while N % i == 0:
		print(i, end='')
		N //= i
	i = i + 1


def prime_factors(n):
	i = 2
	s = ''
	while i * i <= n:
		if n % i:
			i += 1
		else:
			n //= i
			s += str(i)
	if n > 1:
		s += str(n)
	return s
a = int(input())
print(int(prime_factors(a)))


n = int(input())
i = 2
l = []
for i in range(2, n):
	if i * i == n:
		l.append(i)
		l.append(i)
	elif n % i == 0:
		l.append(i)
for i in l:
	print(i, end='')
print()


a = int(input())
s = ''
for x in range(2, int(a ** 0.5) + 1):
	if a % x == 0:
		s += str(x)
		s += str(a // x)
		break
print(s)


a = int(input())
for i in range(2, int(a ** 0.5 + 1)):
	if a % i == 0:
		print(i, a // i, sep='')


p = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]
s = int(input())
a = 1
for i in p:
	if s % i == 0:
		a = i
		break
print(str(a) + str(s // a))


n = int(input())

def factors(n):
	factor = []
	for i in range(1, n // 2 + 1):
		if n % i == 0:
			factor.append(i)
	return factor

def is_prime(lst):
	prime_list = []
	for item in lst:
		c = 0
		for i in range(1, item + 1):
			if item % i == 0:
				c += 1
		if c == 2:
			prime_list.append(item)
	return prime_list
a = is_prime(factors(n))
print(int(str(min(a)) + str(max(a))))


n = int(input())
facts = []
for x in range(2, n + 1):
	while n % x == 0:
		n /= x
		facts.append(x)
if n > 1:
	facts.append(n)
for x in sorted(facts):
	print(x, end='')


n = int(input())
i = 2
a = 0
b = 0
while i < n:
	if n % i == 0:
		a = i
		b = n // i
		break
	i += 1
print(''.join(str(a) + str(b)))


def primes(c):
	primes = []
	p = 2
	while c >= p * p:
		if c % p == 0:
			primes.append(p)
			c = c // p
		elif p == 2:
			p += 1
		else:
			p += 2
	if c != 1:
		primes.append(c)
	return primes
n = int(input())
ps = primes(n)
print(''.join(map(str, ps)))


n = int(input())
i = 2
while n % i != 0:
	i += 1
print(i, n // i, sep='')


def prime_factor(n):
	factors = []
	i = 2
	while i * i <= n:
		while n % i == 0:
			factors.append(i)
			n //= i
		i += 1
	if n != 1:
		factors.append(n)
	return factors
a = int(input())
print(''.join(map(str, prime_factor(a))))


def factors(n):
	for f in range(2, n):
		if n % f == 0:
			q = n // f
			if q < f:
				return f'{q}{f}'
			else:
				return f'{f}{q}'
n = int(input())
print(factors(n))


n = int(input())
d = 2
s = ''
while d <= n:
	while n % d == 0:
		s += str(d)
		n //= d
	d += 1
print(s)


import math

def primeFactors(n):
	while n % 2 == 0:
		print(2, end='')
		n = n // 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			print(i, end='')
			n = n // i
	if n > 2:
		print(n)
n = int(input())
primeFactors(n)


import sys, math, cmath
input = sys.stdin.readline

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	s = input()
	return s[:len(s) - 1]

def invr():
	return map(int, input().split())
t = 1

def qw(n):
	a = []
	while n % 2 == 0:
		a.append(2)
		n = n // 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			a.append(i)
			n = n // i
	if n > 2:
		a.append(n)
	return a
for tt in range(t):
	n = inp()
	a = qw(n)
	print(str(a[0]) + str(n // a[0]))


n = int(input())
for i in range(2, int(pow(n ** 2, 0.5)) + 1):
	if n % i == 0:
		print(i, n // i, sep='', end='\n')
		break


n = int(input())
for i in range(2, 999):
	if n % i < 1:
		print(i, end='')
		print(n // i)
		break


n = int(input())
p = 2
while n % p != 0:
	p += 1
print(str(p) + str(n // p))


from sys import exit

def i():
	return input()

def ii():
	return int(input())

def iis():
	return map(int, input().split())

def liis():
	return list(map(int, input().split()))

def print_array(a):
	print(' '.join(map(str, a)))
n = ii()
for i in range(2, n):
	if n % i == 0:
		print(str(i) + str(n // i))
		break


def main():
	a = int(input())
	d = 2
	while a % d != 0:
		d += 1
	print(f'{d}{a // d}')
main()


from math import sqrt
a = input().split()
a = int(a[0])
for i in range(2, int(sqrt(a)) + 1):
	if a % i == 0:
		m = a // i
		print(min(m, i), end='')
		print(max(m, i), end='')
		break


z = int(input())
n = 1000
a = [1] * n
a[1] = 0
i = 2
while i < n:
	if a[i] != 0:
		j = i + i
		while j < n:
			a[j] = 0
			j = j + i
	i += 1
b = ''
for i in range(1, n):
	x1 = z // i
	if z / i == x1 and a[x1] == 1:
		b += str(min(i, x1))
		b += str(max(i, x1))
		break
print(b)


n = int(input())
a = int(n ** 0.5)
(b, c) = (1, n)
for i in range(1, a + 1):
	if n % i == 0:
		b = i
		c = n // i
print(str(b) + str(c))


a = int(input())
primes = [2]
factors = []
while True:
	if a % primes[-1] == 0:
		a /= primes[-1]
		factors.append(primes[-1])
	else:
		break
for i in range(3, 500):
	if a == 1:
		break
	is_prime = True
	for pri in primes:
		if i % pri == 0:
			is_prime = False
			break
	if is_prime:
		primes.append(i)
		while True:
			if a % primes[-1] == 0:
				a /= primes[-1]
				factors.append(primes[-1])
			else:
				break
print(''.join([str(i) for i in sorted(factors)]))


n = int(input())
i = 2
while i <= n:
	if n % i == 0:
		print(i, n // i, sep='')
		break
	i += 1


N = int(input())
for x in range(2, N):
	if N % x == 0:
		print(str(x) + str(N // x))
		break


ans = ''
x = int(input())
for i in range(2, x + 1):
	if x % i == 0:
		ans += str(i)
		ans += str(x // i)
		break
print(int(ans))


a = int(input())
primes = [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, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997]
output = ''
while a > 1:
	for n in primes:
		if a % n == 0:
			a /= n
			output += str(n)
			break
print(int(output))


from math import gcd

def Fenjie(n):
	k = {}
	if n == 1:
		return {}
	a = 2
	while n >= 2:
		if a * a > n:
			if n in k:
				k[n] += 1
			else:
				k[n] = 1
			break
		b = n % a
		if b == 0:
			if a in k:
				k[a] += 1
			else:
				k[a] = 1
			n = n // a
		else:
			a += 1
	return k

def Euler(n):
	if n == 0:
		return 0
	k = Fenjie(n)
	ans = n
	for i in k:
		ans = ans // i * (i - 1)
	return ans
n = int(input())
k = Fenjie(n)
ans = 0
l = []
for i in k:
	l.append(i)
print(min(l), max(l), sep='')


a = int(input())
i = 2
while a % i != 0:
	i += 1
print(str(i) + str(a // i))


n = int(input())
ans = ''
for i in range(2, n + 1):
	while n % i == 0:
		ans += str(i)
		n //= i
print(ans)


x = int(input())
i = 2
while i * i <= x:
	if x % i == 0:
		y = i
		z = int(x / i)
		y = str(y)
		z = str(z)
		s = y + z
		print(s)
		break
	i += 1


n = int(input())
for i in range(2, n):
	if n % i == 0:
		a = i
		b = n // i
		print(str(a) + str(b))
		break


def prime_factors(n):
	i = 2
	factors = []
	while i * i <= n:
		if n % i:
			i += 1
		else:
			n //= i
			factors.append(str(i))
	if n > 1:
		factors.append(str(n))
	return factors
n = int(input())
print(''.join(prime_factors(n)))


num = int(input())

def prime(x):
	i = 2
	ans = []
	while x > 1:
		if x % i == 0:
			ans.append(i)
			ans.append(x // i)
			return ans
		else:
			i += 1
a = prime(num)
for i in a:
	print(i, end='')


n = int(input())
check = [0] * 10001
ok = []
for i in range(2, 10001):
	if check[i] == 0:
		ok.append(i)
		for j in range(i + i, 10001, i):
			check[j] = 1
ans = ''
i = 0
while n != 1:
	if n % ok[i] == 0:
		ans += str(ok[i])
		n /= ok[i]
	else:
		i += 1
print(ans)


import math
a = int(input())
p = [2]
for i in range(3, 1000):
	flag = True
	for j in range(2, int(math.sqrt(i)) + 1):
		if i % j == 0:
			flag = False
	if flag:
		p.append(i)
ans = ''
for k in p:
	while a % k == 0:
		ans += str(k)
		a /= k
print(ans)


lower = 1
upper = 100
ara = []
for num in range(lower, upper + 1):
	if num > 1:
		for i in range(2, num):
			if num % i == 0:
				break
		else:
			ara.append(num)
number = int(input())
for i in ara:
	count = i
	result = number % i
	if result == 0:
		break
string = ''
resutl2 = int(number / count)
string += str(count)
string += str(resutl2)
print(string)


import sys
n = int(sys.stdin.readline().strip())
L = []
i = 2
while n > 1:
	if n % i == 0:
		L.append(str(i))
		n = n // i
	else:
		i = i + 1
print(''.join(L))


n = int(input())
s = ''
flag = 0
for i in range(1000):
	for k in range(1000):
		if i * k == n:
			isprime = 1
			isp = 1
			for j in range(2, i // 2 + 1):
				if i % j == 0:
					isprime = 0
					break
			for j in range(2, k // 2 + 1):
				if k % j == 0:
					isp = 0
					break
			if isprime and isp:
				print(str(i) + str(k))
				exit(0)


N = int(input())
for i in range(2, N):
	if N % i == 0:
		print(str(i) + str(N // i))
		return


import math
x = int(input())
s = int(x / 2 + 1)
l = []
count = 0
i = 2
while i < s:
	while x % i == 0:
		l.append(i)
		x = int(x / i)
		count += 1
	i += 1
	if count == 2:
		break
print('%d%d' % (l[0], l[1]))


n = int(input())
for a in range(2, int(n ** 0.5) + 1):
	if n % a == 0:
		b = n // a
		break
print(str(a) + str(b))


x = int(input())
ans = []
st = ''
count = 0
for i in range(2, x):
	if x % i == 0 and count != 2:
		count += 1
		ans.append(i)
		if i * i == x:
			ans.append(i)
for i in ans:
	st += str(i)
print(st)


import math
n = int(input())
m = []
c = 0
while n % 2 == 0:
	m.append(str(2))
	n = n / 2
for i in range(3, int(math.sqrt(n)) + 1, 2):
	while n % i == 0:
		m.append(str(i))
		n = n / i
if n > 2:
	m.append(str(int(n)))
print(''.join(m))


n = int(input())
i = 2
while i * i <= n:
	if n % i == 0:
		print(f'{i}{n // i}')
	i += 1


def main():
	n = int(input())
	for i in range(2, n):
		if n % i == 0:
			print(str(i) + str(n // i))
			return

def __starting_point():
	main()
__starting_point()


n = int(input())
while n > 1:
	i = 2
	f = 0
	while 1:
		if n % i == 0:
			n = n // i
			print(i, end='')
			f = 1
			break
		else:
			i += 1
	if f == 1:
		continue


import math
a = int(input())
for i in range(2, int(math.sqrt(a)) + 1):
	if a % i == 0:
		print(i, end='')
		print(int(a / i), end='')
print()


a = int(input())
while a != 1:
	for i in range(2, a + 1):
		if a % i == 0:
			print(i, end='')
			a = int(a / i)
			break


n = int(input())
factors = []
x = 2
while x * x <= n:
	if n % x == 0:
		n = n // x
		factors.append(x)
	else:
		x += 1
if n != 1:
	factors.append(n)
multiplication = ''
for i in range(len(factors)):
	multiplication += str(factors[i])
print(multiplication)


a = []
for num in range(2, 500):
	prime = True
	for i in range(2, num):
		if num % i == 0:
			prime = False
	if prime:
		a += [num]
t = int(input())
for i in range(len(a)):
	if t % a[i] == 0:
		print(a[i], end='')
		temp = t // a[i]
		print(temp)
		break


def primfacs(n):
	i = 2
	primfac = []
	while i * i <= n:
		while n % i == 0:
			primfac.append(i)
			n = n / i
		i = i + 1
	if n > 1:
		primfac.append(n)
	return primfac
nums = list(map(str, primfacs(int(input()))))
print(int(float(''.join(nums))))


from math import sqrt
n = int(input())
for i in range(2, int(sqrt(n)) + 1):
	if n % i == 0:
		print(i, end='')
		print(n // i)


def p(n):
	g = 0
	c = 0
	for i in range(1, n + 1):
		if n % i == 0:
			c += 1
	if c == 2:
		return 1
	else:
		return 0
n = int(input())
for i in range(1, n):
	if n % i == 0:
		if p(i) and p(n // i):
			print(i, end='')
			print(n // i)
			break


n = int(input())
ans = ''
flag = 0
for i in range(2, n // 2 + 1):
	if n % i == 0 and flag == 0:
		flag = 1
		b = int(i)
		ans += str(int(i))
		ans += str(int(n / b))
		break
print(ans)


import math
n = int(input())
c = []
for i in range(2, n, 1):
	if n % i == 0:
		if i not in c:
			c.append(i)
			c.append(int(n / i))
c = sorted(c)
print(str(c[len(c) - 2]) + str(c[len(c) - 1]))


from functools import reduce

def factors(n):
	return set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))
n = int(input())
f = sorted(list(factors(n)))
print(f[1], int(n / f[1]), sep='')


n = int(input())
first = 0
for i in range(2, n):
	if n % i == 0:
		first = i
		break
second = n // first
print(str(first) + str(second))


fprime = [1 for i in range(0, 999)]

def preprocess():
	sieve = [1 for i in range(0, 999)]
	for i in range(2, 999):
		if sieve[i] == 1:
			fprime[i] = i
			for j in range(2, 998 // i + 1):
				sieve[i * j] = 0
				fprime[i * j] = i
preprocess()
n = int(input())
res = []
while n > 1:
	res.append(str(fprime[n]))
	n = n // fprime[n]
print(''.join(res[::-1]))


n = int(input())
i = 2
ans = []
while i * i <= n:
	if n % i == 0:
		ans.append(i)
		ans.append(int(n / i))
		break
	i += 1
print(ans[0], end='')
print(ans[1])


import math
from functools import reduce

def factors(n):
	return set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))
n = int(input())
inamo = list(factors(n))
inamo.sort()
ans = ''
for ina in inamo:
	if ina != 1 and ina != n:
		ans += str(ina)
		ans += str(n // ina)
		break
print(int(ans))


n = int(input())
l = []
i = 2
while n != 1:
	if n % i == 0:
		while n % i == 0:
			n /= i
			l.append(str(i))
	else:
		i += 1
print(''.join(l))


import math
a = list()
for i in range(1000):
	s = 0
	for j in range(1, int(math.sqrt(i)) + 1):
		if i % j == 0:
			s += 1
	if s == 1:
		a.append(i)

def get_no(n):
	for i in a:
		if i > n // 2:
			break
		if n % i == 0:
			if n // i in a:
				return int(str(i) + str(n // i))
n = int(input())
print(get_no(n))


m = int(input())
j = 2
while m % j != 0:
	j += 1
print(j, m // j, sep='')


n = int(input())
for i in range(2, n):
	if n % i == 0:
		a = i
		b = n // i
		print(''.join(map(str, (a, b))))
		exit()


a = input()
a = int(a)
for i in range(2, a):
	if a % i == 0:
		print('%d%d' % (i, a / i))
		exit(0)


from math import *
n = int(input())
last = 0
for i in range(1, int(sqrt(n * 1.0)) + 1):
	if n % i == 0:
		last = i
last = int(last)
then = int(n / last)
print(str(last) + str(then))


def main():
	N = int(input())
	count = 0
	(a, b) = (0, 0)
	for i in range(N - 1, 1, -1):
		if count == 2:
			break
		if N % i == 0:
			if count == 0:
				a = i
			else:
				b = i
			count += 1
	if a != b and a != 0 and (b != 0):
		print(str(b) + str(a))
	elif a * a == N:
		print(str(a) + str(a))
	else:
		print()
main()


a = int(input())
d = 2
while d * d <= a:
	if a % d == 0:
		print(d, a // d, sep='')
		break
	d += 1


import sys, os, io
from sys import stdin, stdout
from math import log, gcd, ceil
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import math
alphabets = list('abcdefghijklmnopqrstuvwxyz')

def isPrime(x):
	for i in range(2, x):
		if i * i > x:
			break
		if x % i == 0:
			return False
	return True

def ncr(n, r, p):
	num = den = 1
	for i in range(r):
		num = num * (n - i) % p
		den = den * (i + 1) % p
	return num * pow(den, p - 2, p) % p

def primeFactors(n):
	l = []
	while n % 2 == 0:
		l.append(2)
		n = n / 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			l.append(int(i))
			n = n / i
	if n > 2:
		l.append(n)
	return list(set(l))

def power(x, y, p):
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

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
	return prime

def countdig(n):
	c = 0
	while n > 0:
		n //= 10
		c += 1
	return c

def si():
	return input()

def prefix_sum(arr):
	r = [0] * (len(arr) + 1)
	for (i, el) in enumerate(arr):
		r[i + 1] = r[i] + el
	return r

def divideCeil(n, x):
	if n % x == 0:
		return n // x
	return n // x + 1

def ii():
	return int(input())

def li():
	return list(map(int, input().split()))

def ws(s):
	sys.stdout.write(s + '\n')

def wi(n):
	sys.stdout.write(str(n) + '\n')

def wia(a):
	sys.stdout.write(' '.join([str(x) for x in a]) + '\n')

def power_set(L):
	cardinality = len(L)
	n = 2 ** cardinality
	powerset = []
	for i in range(n):
		a = bin(i)[2:]
		subset = []
		for j in range(len(a)):
			if a[-j - 1] == '1':
				subset.append(L[j])
		powerset.append(subset)
	powerset_orderred = []
	for k in range(cardinality + 1):
		for w in powerset:
			if len(w) == k:
				powerset_orderred.append(w)
	return powerset_orderred

def fastPlrintNextLines(a):
	print('\n'.join(map(str, a)))

def sortByFirstAndSecond(A):
	A = sorted(A, key=lambda x: x[0])
	A = sorted(A, key=lambda x: x[1])
	return list(A)
n = int(input())
li = []
while n % 2 == 0:
	li.append(2)
	n = n / 2
for i in range(3, int(math.sqrt(n)) + 1, 2):
	while n % i == 0:
		li.append(int(i))
		n = n / i
if n > 2:
	li.append(int(n))
print(''.join((str(i) for i in li)))


def ans(n):
	for i in range(2, n + 1, 1):
		while n % i == 0:
			print(i, end='')
			n = n // i
t = int(input())
ans(t)


a = int(input())
for p in range(2, a):
	if a % p == 0:
		print(str(p) + str(a // p))
		exit(0)


a = int(input())
result = ''
if a == 4:
	result = '22'
else:
	for i in range(2, a // 2):
		if a % i == 0:
			result = str(i) + str(a // i)
			break
print(result)


def factorize(n):
	(c, ans) = (2, [])
	while c * c <= n:
		if n % c == 0:
			ans.extend([c, n // c])
			break
		c += 1
	return sorted(ans)
print(''.join((str(i) for i in factorize(int(input())))))


a = int(input())
i = 2
while i <= a:
	if a % i == 0:
		t = i
		break
	i += 1
print(str(t) + str(a // t))


from math import sqrt
n = int(input())
for i in range(2, int(sqrt(n)) + 1):
	if n % i == 0:
		break
print(str(i) + str(n // i))


import math
l = int(input())

def primeFactors(n):
	while n % 2 == 0:
		return 2
		n = n / 2
		return n
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			return i
	return n
x = primeFactors(l)
m = str(l)
y = int(l / x)
y = str(y)
print(str(x) + str(y))


from collections import Counter
from math import gcd

def memodict(f):

	class memodict(dict):

		def __missing__(self, key):
			ret = self[key] = f(key)
			return ret
	return memodict().__getitem__

def pollard_rho(n):
	if n & 1 == 0:
		return 2
	if n % 3 == 0:
		return 3
	s = (n - 1 & 1 - n).bit_length() - 1
	d = n >> s
	for a in [2, 325, 9375, 28178, 450775, 9780504, 1795265022]:
		p = pow(a, d, n)
		if p == 1 or p == n - 1 or a % n == 0:
			continue
		for _ in range(s):
			prev = p
			p = p * p % n
			if p == 1:
				return gcd(prev - 1, n)
			if p == n - 1:
				break
		else:
			for i in range(2, n):
				(x, y) = (i, (i * i + 1) % n)
				f = gcd(abs(x - y), n)
				while f == 1:
					(x, y) = ((x * x + 1) % n, (y * y + 1) % n)
					y = (y * y + 1) % n
					f = gcd(abs(x - y), n)
				if f != n:
					return f
	return n

@memodict
def prime_factors(n):
	if n <= 1:
		return Counter()
	f = pollard_rho(n)
	return Counter([n]) if f == n else prime_factors(f) + prime_factors(n // f)

def distinct_factors(n):
	factors = [1]
	for (p, exp) in prime_factors(n).items():
		factors += [p ** i * factor for factor in factors for i in range(1, exp + 1)]
	return factors

def all_factors(n):
	(small, large) = ([], [])
	for i in range(1, int(n ** 0.5) + 1, 2 if n & 1 else 1):
		if not n % i:
			small.append(i)
			large.append(n // i)
	if small[-1] == large[-1]:
		large.pop()
	large.reverse()
	small.extend(large)
	return small
print(''.join((str(x) for x in sorted(prime_factors(int(input())).elements()))))


i = 2
a = int(input())
result = ''
while a != 1:
	while a % i:
		i += 1
	result += str(i)
	a //= i
print(result)


import bisect, collections

def solution():
	n = int(input().strip())
	for i in range(2, n):
		if n % i == 0:
			print(str(i) + str(n // i))
			break

def main():
	for _ in range(1):
		solution()
main()


n = int(input())
factors = []
while n > 1:
	for i in range(2, n + 1):
		if n % i == 0:
			factors.append(str(i))
			n = int(n / i)
			break
print(''.join(factors))


x = int(input())
for i in range(2, x - 1):
	if x % i == 0:
		print(i, end='')
		print(x // i)
		break


import math
n = int(input())
for j in range(1, math.trunc(math.sqrt(n)) + 1):
	if n % j == 0:
		i = j
print(str(i) + str(n // i))


a = int(input())
for i in range(2, 100):
	if a % i == 0:
		print(f'{i}{a // i}')
		break


def factorize(n):
	a = 2
	fct = []
	while a * a <= n:
		while n % a == 0:
			n //= a
			fct.append(a)
		a += 1
	if n > 1:
		fct.append(n)
	return fct
n = int(input())
ans = ''
for p in factorize(n):
	ans += str(p)
print(ans)


n = int(input())
t = []
for i in range(2, n):
	while n % i == 0:
		t.append(str(i))
		n //= i
print(''.join(t))


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
n = int(input())
for i in range(2, n):
	if n % i == 0:
		s = str(i) + str(n // i)
		print(s)
		break


def find_min_del(x: int):
	i = 1
	while i <= x:
		i += 1
		if x % i == 0:
			return i
a = int(input())
s = ''
while a != 1:
	s += str(find_min_del(a))
	a /= find_min_del(a)
print(s)


N = int(input())
i = 2
while N % i != 0:
	i += 1
print(str(i) + str(N // i))


import sys
input = sys.stdin.readline

def main():
	n = int(input())
	ans = ''
	for i in range(2, n + 1):
		while n % i == 0:
			ans += str(i)
			n //= i
	print(ans)
main()


n = int(input())
i = 2
while i ** 2 <= n and n % i != 0:
	i += 1
print(f'{i}{n // i}')


t = int(input())
k = int(t ** 0.5)
if t % k == 0:
	print(str(k) + str(t // k))
else:
	x = k - 1
	while True:
		if x >= 1:
			if t % x == 0:
				print(str(x) + str(t // x))
				break
		else:
			print(str(1) + str(t))
			break
		x = x - 1


import sys
a = int(input())
for i in range(2, a):
	if a % i == 0:
		print(str(i) + str(a // i))
		sys.exit(0)


n = int(input())
was = False
for i in range(2, 1000):
	if n % i == 0 and (not was):
		print(i, n // i, sep='')
		was = True


var = int(input())
i = var - 1
while var % i != 0:
	i -= 1
new = var / i
if new < i:
	print(int(new), int(i), sep='')
else:
	print(int(i), int(new), sep='')


def factors(n):
	factors = []
	while n % 2 == 0:
		factors.append(2)
		n /= 2
	for i in range(3, int(n ** 0.5) + 1, 2):
		while n % i == 0:
			factors.append(i)
			n /= i
	if n != 1:
		factors.append(int(n))
	return factors

def main():
	n = int(input())
	f = factors(n)[:2]
	print(''.join(map(str, f)))
main()


def solve(a):
	rez = []
	i = 2
	while i * i <= a:
		while a % i == 0:
			a //= i
			rez.append(i)
		i += 1
	if a != 1:
		rez.append(a)
	rez.sort()
	return ''.join((str(rez[i]) for i in range(len(rez))))
a = int(input())
print(solve(a))


a = int(input())
for i in range(2, a // 2 + 1):
	b = a / i
	if b.is_integer():
		print(str(i) + str(int(b)))
		break


k = int(input())
from math import *
for x in range(2, ceil(k ** 0.5) + 1):
	if k % x == 0:
		k = k // x
		print(x, end='')
if k >= 2:
	print(k)


a = int(input())
factor = 2
while a % factor != 0:
	factor += 1
print(factor, a // factor, sep='')


def splitprime(n):
	if n % 2 == 0:
		return [2, n // 2]
	else:
		lim = int(n ** 0.5) + 1
		for i in range(3, lim, 2):
			if n % i == 0:
				return [i, n // i]
n = int(input())
print(*splitprime(n), sep='')


s = input()
i = 2
s = int(s)
while i * i <= s:
	if s % i == 0:
		ans = str(i) + str(s // i)
		print(ans)
		break
	i += 1


def factor(X):
	for i in range(2, X):
		if X % i == 0:
			tmp = int(X / i)
			return str(i) + str(tmp)
	return str(1) + str(X)
x = int(input())
print(factor(x))


import sys
input = lambda : sys.stdin.readline().strip()
ipnut = input
n = int(input())
for i in range(n - 2):
	if n % (i + 2) == 0:
		if (i + 2) ** 2 == n:
			print(i + 2, end='')
		print(i + 2, end='')


a = int(input())
q = []
for i in range(a - 1, 0, -1):
	if a % i == 0:
		q.append(a // i)
		q.append(i)
print(str(q[0]) + str(q[1]))


import sys
n = int(sys.stdin.readline())
for i in range(2, n):
	if n % i == 0:
		sys.stdout.write(str(i) + str(n // i))
		break


import math
a = int(input())
mass = []
for i in range(2, int(math.sqrt(a)) + 1):
	if a % i == 0:
		mass.append(i)
		break
mass.append(a // mass[0])
print(str(mass[0]) + str(mass[1]))


N = int(input())
for i in range(2, N + 1):
	if N % i == 0:
		print(str(i) + str(N // i))
		exit()


n = int(input())
st = str()
for i in range(2, n):
	while n % i == 0:
		st += str(i)
		n = n // i
print(st)


t = int(input())
for i in range(2, t):
	if t % i == 0:
		print(str(i) + str(t // i))
		break


a = int(input())
for x in range(2, a + 1):
	if a % x == 0:
		print(x, a // x, sep='')
		break


n = int(input())
for i in range(2, n):
	if n % i == 0:
		a = n // i
		print(str(i) + str(a))
		exit()


num = int(input())
num1 = num
for i in range(2, num):
	if num % i == 0:
		num1 = num // i
		break
ans = str(i) + str(num1)
print(ans)


from sys import stdin, stdout
import math
from itertools import permutations, combinations
from collections import defaultdict
from bisect import bisect_left

def L():
	return list(map(int, stdin.readline().split()))

def In():
	return map(int, stdin.readline().split())

def I():
	return int(stdin.readline())
P = 1000000007
n = I()
for i in range(2, n):
	if n % i == 0:
		break
print(i, end='')
print(n // i)


x = int(input())
primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37]
ans = ''
for prime in primes:
	if x % prime == 0:
		ans += str(int(prime))
		ans += str(x // prime)
		break
print(ans)


a = int(input())
for x in range(2, a):
	if a % x == 0:
		print(f'{x}{a // x}')
		exit(0)


n = int(input())
for i in range(2, n):
	if n % i == 0:
		ans = [i, n // i]
		print(''.join(map(str, ans)))
		exit()


from math import ceil

def is_prime(x):
	if x == 2:
		return True
	for i in range(2, x):
		if x % i == 0:
			return False
	return True
n = int(input())
ans = ''
for i in range(2, n):
	if n % i == 0:
		if is_prime(i):
			ans += str(i)
			break
print(ans + str(int(n / int(ans))))


n = int(input())

def primes(n):
	i = 2
	factors = []
	while i * i <= n:
		if n % i:
			i += 1
		else:
			n //= i
			factors.append(i)
	if n > 1:
		factors.append(n)
	return factors
results = list(map(str, primes(n)))
print(''.join(results))


import math
n = int(input())

def primee(p):
	for i in range(2, int(math.sqrt(p)) + 1):
		if p % i == 0:
			return False
	return True
t = 1
for p in range(2, int(math.sqrt(n)) + 1):
	if n % p == 0:
		alpha = primee(p)
		if alpha == True:
			t = p
			break
s = n // t
print(str(t) + str(s))


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
s = [int(i) for i in '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 101 103 107 109 113 127 131 137 139 149 151 157 163 167 173 179 181 191 193 197 199 211 223 227 229 233 239 241 251 257 263 269 271 277 281 283 293 307 311 313 317 331 337 347 349 353 359 367 373 379 383 389 397 401 409 419 421 431 433 439 443 449 457 461 463 467 479 487 491 499 503 509 521 523 541 547 557 563 569 571 577 587 593 599 601 607 613 617 619 631 641 643 647 653 659 661 673 677 683 691 701 709 719 727 733 739 743 751 757 761 769 773 787 797 809 811 821 823 827 829 839 853 857 859 863 877 881 883 887 907 911 919 929 937 941 947 953 967 971 977 983 991 997'.split(' ')]
n = int(input())
for i in s:
	if n % i == 0 and n // i in s:
		print(str(i) + str(n // i))
		break


def prime(p):
	for i in range(2, p):
		if p % i == 0:
			return False
	return True
n = int(input())
if prime(n):
	print(n)
else:
	w = []
	for i in range(2, n):
		if prime(i):
			while n % i == 0:
				w.append(i)
				n = n // i
		if n == 1:
			break
	for i in w:
		print(i, end='')
	print()


from __future__ import division, print_function
import os
import sys
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
	from __builtin__ import xrange as range
	from future_builtins import ascii, filter, hex, map, oct, zip

def main():
	a = int(input().strip())
	for x in range(int(a ** 0.5), 0, -1):
		if a % x == 0:
			print('{}{}'.format(x, a // x))
			return
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')

def print(*args, **kwargs):
	(sep, file) = (kwargs.pop('sep', ' '), kwargs.pop('file', sys.stdout))
	at_start = True
	for x in args:
		if not at_start:
			file.write(sep)
		file.write(str(x))
		at_start = False
	file.write(kwargs.pop('end', '\n'))
	if kwargs.pop('flush', False):
		file.flush()
if sys.version_info[0] < 3:
	(sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


import sys
from math import *
input = sys.stdin.buffer.readline
n = int(input())
for i in range(2, int(sqrt(n)) + 1):
	if n % i == 0:
		print(i, end='')
		print(n // i)
		break


n = int(input())
for i in range(2, n + 1):
	if n % i == 0:
		print(str(min(n // i, i)) + str(max(n // i, i)))
		break


n = int(input())
ans = ''
i = 2
while True:
	if n % i == 0:
		ans += str(i) + str(n // i)
		break
	else:
		i += 1
print(ans)


n = int(input())
p = 1
for i in range(2, n + 1):
	if int(n % i) == 0:
		p = i
		break
s = ''
s += str(p)
s += str(int(n / p))
print(s)


primes = [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, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499]
num = int(input())
divisors = []
for prime in primes:
	if num == 1:
		break
	while num % prime == 0:
		divisors.append(prime)
		num = num // prime
s = ''
for n in divisors:
	s = f'{s}{n}'
print(s)


def main_function():
	a = int(input())
	for num in range(2, a):
		if a % num == 0:
			print(str(num) + str(a // num))
			break
main_function()


n = int(input())
for i in range(2, 1000):
	if not n % i:
		break
print(str(i) + str(n // i))


num = int(input())
count = 1
flag = True
while flag:
	count += 1
	if num % count == 0:
		flag = False
print(str(count) + str(num // count))


a = int(input())

def solve():
	for i in range(2, a + 1):
		for j in range(2, a + 1):
			if i * j == a:
				print('{}{}'.format(i, j))
				return
solve()


A = int(input())
S = []
for i in range(2, A + 1):
	while A % i == 0:
		A //= i
		S.append(str(i))
print(''.join(S))


p = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79]
n = int(input())
for i in p:
	if n % i == 0:
		print(i, n // i, sep='')
		break


n = int(input())

def solve(n):
	if n == 1:
		return ''
	else:
		for i in range(2, n + 1):
			if not n % i:
				return str(i) + solve(n // i)
print(solve(n))


c = int(0)
a = int(input())
i = int(2)
while True:
	if a % i == 0:
		c = int(a / i)
		break
	i = i + 1
print(f'{i}{c}')


n = int(input())
res = ''
while n != 1:
	for i in range(2, n + 1):
		if n % i == 0:
			res += str(i)
			n //= i
			break
print(res)


n = int(input())
for i in range(2, n + 1):
	if n % i == 0:
		a = i
		b = n // i
		break
print(min(a, b), max(a, b), sep='')


def primes(n):
	l = []
	for i in range(2, n + 1):
		if n % i == 0:
			p = 1
			for j in range(2, i // 2 + 1):
				if i % j == 0:
					p = 0
					break
			if p == 1:
				l.append(i)
	return l
n = int(input())
primes = primes(n)
y = primes[0]
z = str(y)
z += str(int(n / y))
print(z)


import math
n = int(input())
for i in range(2, math.floor(n / 2 + 1)):
	while n % i == 0:
		print(i, end='')
		n /= i


import math

def primeFactors(n):
	arr = []
	while n % 2 == 0:
		arr.append(2)
		n = n // 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			arr.append(i)
			n = n // i
	if n > 2:
		arr.append(n)
	return arr
n = int(input())
x = primeFactors(n)
x = sorted(x)
for i in x:
	print(i, end='')


def mp():
	return map(int, input().split())
n = int(input())
for i in range(2, n):
	if n % i == 0:
		print(i, n // i, sep='')
		break


n = int(input())
for x in range(2, n):
	if n % x == 0:
		X = x
		break
Y = n // X
print(X, Y, sep='')


import sys
import math
import bisect

def solve(n):
	ans = []
	for i in range(2, n):
		if n % i == 0:
			ans = [i, n // i]
			break
	return ans

def main():
	n = int(input())
	ans = solve(n)
	print(''.join(list((str(a) for a in ans))))
main()


i = int(input())
for x in range(2, int(pow(i, 0.5) + 1)):
	if i % x == 0:
		s = str(x) + str(int(i / x))
		print(s)
		break


a = int(input())
c = 2
m = 10
r = 0
while a > 1:
	if a % c == 0:
		r = r * m + c
		a = a / c
	else:
		c += 1
		if c > 9:
			m = 100
		if c > 100:
			m = 1000
print(r)


num = int(input())
prime = [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, 101]
for n in prime:
	if num % n == 0:
		res1 = n
		break
res2 = int(num / res1)
print(str(res1) + str(res2))


n = int(input())
x = 2
while n % x > 0:
	x += 1
print('{}{}'.format(x, n // x))


x = int(input())
for i in range(2, x):
	if x % i == 0:
		print(str(i) + str(x // i))
		break
	else:
		pass


n = int(input())
for i in range(2, n):
	if n % i == 0:
		print(i, n // i, sep='')
		exit(0)


n = int(input())
for x in range(2, n + 1):
	if n % x == 0:
		print(str(x) + str(n // x))
		break


primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 1]
a = int(input())
for p in primes:
	if not a % p:
		print('{}{}'.format(p, a // p))
		break


from math import sqrt

def delit(x):
	for i in range(2, int(sqrt(x) + 1)):
		while x % i == 0:
			print(i, end='')
			x //= i
	if x != 1:
		print(x)
delit(int(input()))


def prost(n):
	for i in range(2, n):
		if n % i == 0:
			return False
	return True
n = int(input())
a = []
for i in range(2, n):
	if n % i == 0 and prost(i):
		b = n
		t = 0
		while b % i == 0:
			t += 1
			b = b // i
		for j in range(t):
			a.append(i)
a.sort()
for i in a:
	print(i, end='')


x = int(input())
for d in range(2, x + 1):
	while x % d == 0:
		x //= d
		print(d, end='')


def solve():
	x = int(input())
	for i in range(2, 1000):
		if x % i == 0:
			j = x // i
			(a, b) = (min(i, j), max(i, j))
			print(a, b, sep='')
			return
solve()


n = int(input().strip())
for i in range(2, 101010):
	if n % i == 0:
		print(str(i) + str(n // i))
		exit()


import math
x = int(input())
r = int(math.sqrt(x))
for i in range(2, x - 1):
	if x % i == 0:
		print(str(i) + str(x // i))
		break


import math
n = int(input())
st = ''
for i in range(2, n):
	if n % i == 0:
		st += str(i)
		break
ip = int(st)
ip = int(n / ip)
st += str(ip)
print(st)


r = ''
s = int(input())
i = 2
while i <= s:
	while s % i == 0:
		s //= i
		r += str(i)
	i += 1
print(r)


n = int(input())
s = ''
for i in range(int(n ** 0.5), 0, -1):
	if n % i == 0:
		s = s + str(i) + str(n // i)
		break
print(s)


import math as mt
MAXN = 100001
spf = [0 for i in range(MAXN)]

def sieve():
	spf[1] = 1
	for i in range(2, MAXN):
		spf[i] = i
	for i in range(4, MAXN, 2):
		spf[i] = 2
	for i in range(3, mt.ceil(mt.sqrt(MAXN))):
		if spf[i] == i:
			for j in range(i * i, MAXN, i):
				if spf[j] == j:
					spf[j] = i

def getFactorization(x):
	ret = list()
	while x != 1:
		ret.append(spf[x])
		x = x // spf[x]
	return ret
sieve()
x = int(input())
p = getFactorization(x)
for i in sorted(p):
	print(i, end='')
print()


n = int(input())
for i in range(2, n):
	if n % i == 0:
		if i ** 2 == n:
			print(i, i, sep='', end='')
		else:
			print(i, end='')


import sys

def input():
	return sys.stdin.readline().strip()

def iinput():
	return int(input())

def rinput():
	return map(int, input().split())

def rlinput():
	return list(map(int, input().split()))

def main():

	def pro(a, b, x, x1, x2):
		if (a == -2 * b or x != x1 or x != x2 or (b == 0)) and x1 <= x - a + b <= x2:
			return True
		return False
	n = iinput()
	q = []
	s = ''
	for i in range(2, int(n ** 0.5) + 1):
		if n % i == 0:
			q.append(i)
			s += str(q[-1])
	for i in range(len(q)):
		q.append(n // q[-1 - 2 * i])
		s += str(q[-1])
	print(s)
for i in range(1):
	main()


n = int(input())
t = ''

def primes(n):
	a = [0] * n
	for i in range(n):
		a[i] = i
	a[1] = 0
	m = 2
	while m < n:
		if a[m] != 0:
			j = m * 2
			while j < n:
				a[j] = 0
				j = j + m
		m += 1
	b = []
	for i in a:
		if a[i] != 0:
			b.append(a[i])
	del a
	return b
a = primes(998)
for i in a:
	if n % i == 0:
		t += str(i)
		n = n / i
		for i in a:
			if n % i == 0:
				t += str(i)
				n = n / i
print(t)


def solve(t):
	i = 2
	while t % i != 0:
		i += 1
	j = t // i
	return str(i) + str(j)
t = int(input())
print(solve(t))


a = int(input())
b = []
for i in range(2, a):
	if a % i == 0:
		print(i, end='')
		print(int(a / i))
		break


x = int(input())
f1 = 0
f2 = 0
for i in range(2, 999):
	if x % i == 0:
		f1 = i
		f2 = x // i
		break
print(str(f1) + str(f2))


n = int(input())
for x in range(2, n + 1):
	if x * (n // x) == n:
		print('%d%d' % (x, n // x))
		break


import sys

def IOE():
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')

def main():
	n = int(sys.stdin.readline())
	for i in range(2, n):
		if n % i == 0:
			print(str(i) + str(n // i))
			break
try:
	IOE()
except:
	pass
main()


def Factor(n):
	Ans = []
	d = 2
	while d * d <= n:
		if n % d == 0:
			Ans.append(d)
			n //= d
		else:
			d += 1
	if n > 1:
		Ans.append(n)
	return Ans
data = Factor(int(input()))
print('{}{}'.format(data[0], data[1]))


def divPrime(num):
	lt = []
	while num != 1:
		for i in range(2, int(num + 1)):
			if num % i == 0:
				lt.append(i)
				num = num / i
				break
	for i in range(0, len(lt)):
		print(lt[i], end='')
a = input()
divPrime(int(a))


s = int(input())
for i in range(2, s + 1):
	if s % i == 0:
		print(str(i), str(s // i), sep='')
		break


n = int(input())
for i in range(2, int(n ** 0.5 + 1)):
	if n % i == 0:
		a = i
		b = n // a
		print(a, end='')
		print(b)


import math

def factorize(n):
	for i in range(2, math.ceil(math.sqrt(n)) + 1):
		if n % i == 0:
			return (i, int(n / i))
n = int(input())
(i, j) = factorize(n)
print(int(str(i) + str(j)))


xd = int(input())
currentVal = xd
factor = 2
output = ''
while currentVal > 1:
	if currentVal % factor == 0:
		output += str(factor)
		currentVal = currentVal // factor
	else:
		factor += 1
print(output)


a = int(input())
n = 2
res = ''
while a >= n:
	if a % n == 0:
		a /= n
		res += str(n)
	else:
		n += 1
print(res)


def main():
	n = int(input())
	for i in range(2, n + 1):
		if n % i == 0:
			print(f'{i}{n // i}')
			break
main()


def Sieve(n):
	ret = []
	divlis = [-1] * (n + 1)
	flag = [True] * (n + 1)
	flag[0] = False
	flag[1] = False
	ind = 2
	while ind <= n:
		if flag[ind]:
			ret.append(ind)
			ind2 = ind ** 2
			while ind2 <= n:
				flag[ind2] = False
				divlis[ind2] = ind
				ind2 += ind
		ind += 1
	return (ret, divlis)
import sys
a = int(input())
(slis, divlis) = Sieve(1000)
for i in slis:
	if a % i == 0:
		ans = str(i) + str(a // i)
		print(ans)
		sys.exit()


n = int(input())
i = 2
while True:
	if n % i == 0:
		print(str(i) + '' + str(n // i))
		exit(0)
	i += 1


a = int(input())
s = ''
if a % 2 == 0:
	s = '2' + str(a // 2)
else:
	for i in range(3, int(a ** 0.5) + 1, 2):
		if a % i == 0:
			s = str(i) + str(a // i)
			break
print(s)


def isPrime(n):
	if n <= 1:
		return False
	if n <= 3:
		return True
	if n % 2 == 0 or n % 3 == 0:
		return False
	i = 5
	while i * i <= n:
		if n % i == 0 or n % (i + 2) == 0:
			return False
		i = i + 6
	return True
x = int(input())
string = ''
for i in range(2, x):
	if x % i == 0:
		string = str(i) + str(x // i)
		break
print(string)


k = int(input())
for i in range(2, int(k ** 0.5) + 1):
	if k % i == 0:
		print(str(i) + str(k // i))
		break


from math import ceil, sqrt, log, gcd

def ii():
	return int(input())

def si():
	return input()

def mi():
	return map(int, input().split())

def li():
	return list(mi())

def main():
	n = ii()
	for i in range(2, n):
		if n % i == 0:
			print(i, end='')
			print(n // i, end='')
			f = 1
			break
	if f == 0:
		print(1, end='')
		print(n)
main()


n = int(input())
for v in range(2, n):
	if n % v == 0:
		print(v, n // v, sep='')
		break


test = input()
for i in range(2, 300):
	if int(test) % i == 0:
		print(str(i) + str(int(int(test) / i)))
		break


def fact(x):
	l = []
	i = 2
	while i * i <= x:
		while x % i == 0:
			x //= i
			l.append(i)
		i += 1
	if x != 1:
		l.append(x)
	return l
n = int(input())
print(*fact(n), sep='')


n = int(input())
ind = 2
a = 1
b = n
while ind * ind <= n:
	if n % ind == 0:
		a = ind
		b = n // ind
	ind += 1
print(a, b, sep='')


number = int(input())
string = ''
i = 2
while number % i != 0:
	i += 1
print(i, number // i, sep='')


a = int(input())
for i in range(2, 10 ** 5):
	if a % i == 0:
		print(str(i) + str(a // i))
		exit()


n = int(input())
x = 2
while n % x != 0:
	x += 1
print(str(x) + str(n // x))


from sys import stdin, stdout
a = int(stdin.readline())
i = 1
while True:
	i += 1
	if a % i == 0:
		break
stdout.write(str(i) + str(a // i))


n = int(input())
i = 2
a = 1
b = 1
while i * i <= n:
	if n % i == 0:
		a = i
		b = n // i
	i += 1
ls = []
ls.append(a)
ls.append(b)
print(''.join((str(a) for a in ls)))


a = int(input())
c = 2
while True:
	if a % c == 0:
		print(str(c) + str(a // c))
		break
	else:
		c += 1
		continue


n = int(input())
res = ''
for div in range(2, n // 2 + 1):
	if n % div == 0:
		res = str(div) + str(n // div)
		break
print(res)


def get_factors(number):
	factors = []
	str_factors = ''
	for i in range(2, number):
		if number % i == 0:
			factors.append(i)
			factors.append(number // i)
	str_factors = str(factors[0]) + str(factors[1])
	return str_factors
number = int(input())
results = get_factors(number)
print(results)


def delitlist(k):
	q = []
	for i in range(1, int(pow(k, 0.5)) + 1):
		if k % i == 0:
			q.append(i)
	s = len(q)
	for i in range(s):
		if k // q[s - i - 1] != q[-1]:
			q.append(k // q[s - i - 1])
	return q
n = int(input())
s = ''
x = delitlist(n)
if len(x) == 3:
	s = 2 * str(x[1])
else:
	s = str(x[1]) + str(x[2])
print(s)


n = int(input())
i = 2
while i * i <= n:
	if n % i == 0:
		print(i, n // i, sep='')
		exit()
	i += 1


n = int(input())
a = []

def print_factors(x):
	for i in range(1, x + 1):
		if x % i == 0:
			a.append(i)
print_factors(n)
l = len(a)
print(a[1], end='')
print(a[l - 2])


n = int(input())
r = 0
for i in range(2, 33):
	if r == 0:
		for j in range(2, 500):
			if j * i == n:
				r = str(i) + str(j)
print(r)


n = int(input().strip())
for i in range(2, n):
	if n % i == 0:
		print('{}{}'.format(i, n // i))
		break


def main():
	t = 1
	for _ in range(t):
		n = int(input())
		x = 2
		while n % x > 0:
			x += 1
		print(f'{x}{n // x}')
main()


def fun(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * 2, n + 1, p):
				prime[i] = False
		p += 1
	prime[0] = False
	prime[1] = False
	for p in range(n + 1):
		if prime[p] and n % p == 0:
			return str(p) + str(n // p)
n = int(input())
print(fun(n))


n = int(input())
for i in range(2, n):
	if not n % i:
		print('{}{}'.format(i, n // i))
		break


def Factor(n):
	Ans = []
	d = 2
	while d * d <= n:
		if n % d == 0:
			Ans.append(d)
			n //= d
		else:
			d += 1
	if n > 1:
		Ans.append(n)
	return Ans
n = int(input())
res = Factor(n)
print(str(res[0]) + str(res[1]))


def main():
	import sys
	input = sys.stdin.readline

	def PrimeDecomposition(N):
		ret = {}
		n = int(N ** 0.5)
		for d in range(2, n + 1):
			while N % d == 0:
				if d not in ret:
					ret[d] = 1
				else:
					ret[d] += 1
				N //= d
			if N == 1:
				break
		if N != 1:
			ret[N] = 1
		return ret
	N = int(input())
	prime = PrimeDecomposition(N)
	ans = []
	for p in prime:
		for _ in range(prime[p]):
			ans.append(p)
	ans.sort()
	print(''.join(map(str, ans)))

def __starting_point():
	main()
__starting_point()


def f(A):
	C = ''
	d = 0
	for i in range(2, A):
		if A % i == 0:
			d = i
			break
	C = str(d) + str(A // d)
	return C
A = int(input())
print(f(A))


i = 2
r = int(input())
while r % i != 0:
	i = i + 1
print(i, end='')
print(int(r / i), end='')


import math

def isprime(x):
	for i in range(3, int(math.sqrt(x)) + 1, 2):
		if x % i == 0:
			return False
	return True
n = int(input())
if n % 2 == 0 and isprime(n // 2):
	print('2', n // 2, sep='')
else:
	for i in range(3, n // 3 + 1, 2):
		if isprime(i) and n % i == 0:
			print(i, n // i, sep='')
			break


def factors(num):
	for x in range(2, num):
		if num % x == 0:
			return (x, num // x)
num = int(input())
(x, y) = factors(num)
print(str(min(x, y)) + str(max(x, y)))


a = input().split()
a = int(a[0])
for i in range(2, a):
	if a % i == 0:
		l = a / i
		l = int(l)
		print(min(l, i), end='')
		print(max(l, i), end='')
		break


def isPrime(n):
	for i in range(2, n):
		if n % i == 0:
			return False
	return True
n = int(input())
ans = ''
fact = -1
for i in range(2, n // 2 + 1):
	if n % i == 0 and isPrime(i):
		ans += str(i)
		fact = i
		break
ans += str(n // fact)
print(ans)


ans = []
import math

def primeFactors(n):
	while n % 2 == 0:
		ans.append(2)
		n = n // 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			ans.append(i)
			n = n // i
	if n > 2:
		ans.append(n)
n = int(input())
primeFactors(n)
a = ''
for i in range(len(ans)):
	a += str(ans[i])
print(a)


from math import sqrt

def A():
	print('NO')

def B():
	a = int(input())
	factors = []
	for i in range(2, int(sqrt(a)) + 1):
		if a % i == 0:
			factors.append(i)
			factors.append(a // i)
	print(''.join([str(x) for x in sorted(factors)]))
B()


x = int(input())
for i in range(2, int(x ** 0.5) + 1):
	if not x % i:
		print(str(i) + str(x // i))
		break


q = int(input())
i = 2
while q % i != 0:
	i += 1
print(str(i) + str(q // i))


numero = int(input())
contador = 2
primer_divisor = 0
segundo_divisor = 0
cant_divisores = 0
while cant_divisores <= 1:
	if numero % contador == 0:
		cant_divisores += 1
		primer_divisor = contador
		break
	contador += 1
segundo_divisor = numero // primer_divisor
print(str(primer_divisor) + str(segundo_divisor))


import math
N = int(input())
factor1 = 1
SQ = int(math.sqrt(N)) + 1
for i in range(2, SQ):
	if N % i == 0:
		factor1 = i
		break
factor2 = N // factor1
print(str(factor1) + str(factor2))


from collections import Counter
from collections import defaultdict
import math

def SieveOfEratosthenes(n):
	prime = [True for i in range(n + 1)]
	l = []
	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):
		if prime[p]:
			l.append(p)
	return l
a = SieveOfEratosthenes(1001)
n = int(input())
s = ''
i = 0
while n != 1:
	if n % a[i] == 0:
		n = n // a[i]
		s = s + str(a[i])
	else:
		i = i + 1
print(s)


n = int(input())
s = ''
for i in range(n):
	if i >= 2:
		while n % i == 0:
			s += str(i)
			n //= i
print(s)


import sys
input = sys.stdin.readline
inputi = lambda : map(int, input().split())
from math import *
from bisect import *
from functools import reduce, lru_cache
from collections import Counter, defaultdict

def factor(n):
	i = 2
	while i <= int(sqrt(n)):
		while n % i == 0:
			print(i, end='')
			n //= i
		i += 1
	if n != 1:
		print(n, end='')
c = int(input())
factor(c)
print()


n = int(input())
i = 2
while n % i != 0:
	i += 1
print(str(i) + str(int(n / i)))


n = int(input())

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 * 2, n + 1, p):
				prime[i] = False
		p += 1
	prime[0] = False
	prime[1] = False
	res = []
	for p in range(n + 1):
		if prime[p]:
			res.append(p)
	return res
primes = SieveOfEratosthenes(1000)
pset = set(primes)
m1 = None
m2 = None
for p in primes:
	if n % p == 0:
		e = n // p
		if e in pset:
			(m1, m2) = (p, e)
			break
res = ''
if m1 is not None and m2 is not None:
	if m1 > m2:
		(m1, m2) = (m2, m1)
	res += str(m1) + str(m2)
print(res)


x = int(input())
b = []
for i in range(2, x):
	if x % i == 0:
		b.append(i)
h = False
for i in range(len(b)):
	for j in range(len(b)):
		if b[i] * b[j] == x:
			print(str(b[i]) + str(b[j]))
			h = True
			break
	if h == True:
		break


MAX_SIZE = 1000001
isprime = [True] * MAX_SIZE
prime = []
SPF = [None] * MAX_SIZE

def manipulated_seive(N):
	isprime[0] = isprime[1] = False
	for i in range(2, N):
		if isprime[i] == True:
			prime.append(i)
			SPF[i] = i
		j = 0
		while j < len(prime) and i * prime[j] < N and (prime[j] <= SPF[i]):
			isprime[i * prime[j]] = False
			SPF[i * prime[j]] = prime[j]
			j += 1
N = 10000
manipulated_seive(N)
i = 0
ans = []
while i < len(prime) and prime[i] <= N:
	ans.append(prime[i])
	i += 1
n = int(input())
for i in range(n):
	f = 0
	for j in range(n):
		if ans[i] * ans[j] == n:
			mini = min(ans[i], ans[j])
			maxi = max(ans[i], ans[j])
			print(str(mini) + str(maxi))
			f = 1
			break
	if f:
		break


n = int(input())
factors = []
for i in range(2, n + 1):
	if n % i == 0:
		print(i, n // i, sep='')
		quit()


a = int(input())
n = 2
while a % n != 0:
	n += 1
print(str(n) + str(a // n))


n = int(input())

def func(x):
	(a, b) = (1000000, 100000000)
	for i in range(1, x):
		if x % i == 0:
			if abs(x / i - i) < a:
				(a, b) = (abs(x / i - i), i)
	return b
if func(n) == 1:
	print('1' + str(n))
else:
	print(str(func(n)) + str(n // func(n)))


n = int(input())
for i in range(2, n):
	tmp = n / i
	if tmp - int(tmp) == 0:
		other = int(tmp)
		ans = str(i) + str(tmp)
		print(int(float(ans)))
		break


pr = [0] * 1000
pr[0] = pr[1] = 1
for i in range(2, 1000):
	if pr[i] == 0:
		for j in range(2 * i, 1000, i):
			pr[j] = 1
n = int(input())
for i in range(1000):
	for j in range(1000):
		if i * j == n and pr[i] == pr[j] == 0:
			exit(print(str(i) + str(j)))


import sys
import os
from io import BytesIO, IOBase

def cel(n, k):
	return n // k + (n % k != 0)

def ii():
	return int(input())

def mi():
	return map(int, input().split())

def li():
	return list(map(int, input().split()))

def lcm(a, b):
	return abs(a * b) // math.gcd(a, b)

def prr(a, sep=' '):
	print(sep.join(map(str, a)))

def dd():
	return defaultdict(int)

def ddl():
	return defaultdict(list)

def ddd():
	return defaultdict(defaultdict(int))
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
from collections import defaultdict
for _ in range(1):
	n = ii()
	res = ''
	for i in range(2, n):
		if n % i == 0:
			while n % i == 0:
				res += str(i)
				n //= i
	print(res)


import math
arr = []

def ff(N):
	cnt = 0
	for i in range(2, int(math.sqrt(N)) + 1):
		while N % i == 0:
			N = N / i
			cnt += 1
			arr.append(i)
		if cnt >= 2:
			break
	if N > 1:
		arr.append(int(N))
		cnt += 1
	return cnt == 2
N = int(input())
if ff(N):
	print(str(arr[0]) + str(arr[1]))
else:
	print(N)


N = int(input())
for i in range(2, N):
	if N % i == 0:
		print(f'{i}{N // i}')
		break


n = int(input())
cur = 0
for i in range(n - 1, -1, -1):
	if n % i == 0:
		cur = i
		break
print(min(n // cur, cur), max(n // cur, cur), sep='')


n = int(input())
for d in range(2, n):
	if n % d == 0:
		print(min(d, n // d), max(d, n // d), sep='')
		break


x = int(input())
s = []
for n in range(2, int(x ** 0.5) + 1):
	if x % n == 0:
		s.append(n)
		s.append(x // n)
s.sort()
for n in s:
	print(n, end='')


n = int(input())
for i in range(2, n):
	if n % i == 0:
		p = i
		q = n // i
		break
print(str(p) + str(q))


import math

def primeFactors(n):
	arr = []
	while n % 2 == 0:
		arr += [2]
		n = n / 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			arr += [int(i)]
			n = n / i
	if n > 2:
		arr += [int(n)]
	return arr

def limericks(arr):
	out = ''
	s_arr = list(sorted(arr))
	for x in s_arr:
		out += str(x)
	return out
n = int(input())
if 4 <= n <= 998:
	l = primeFactors(n)
	print(limericks(l))


a = int(input())
for i in range(2, a):
	aa = a / i
	if aa == round(aa):
		print(str(i) + str(round(aa)))
		break


n = int(input())
i = 2
while n % i != 0:
	i += 1
k = i
m = n // i
if k < m:
	print(k, m, sep='')
else:
	print(m, k, sep='')


(s, f) = (set(), set())
for i in range(2, 1000):
	s.add(i)
	for j in range(2, 1000 // i + 2):
		f.add(i * j)
s = list(s - f)
s.sort()
n = int(input())
x = ''
for elem in s:
	if n % elem == 0:
		while n % elem == 0:
			n //= elem
			x += str(elem)
print(int(x))


n = int(input())
i = 2
while n % i > 0:
	i += 1
print('{}{}'.format(i, n // i))


def factorize(n):
	a = []
	f = 2
	n_ = n
	while f * f <= n_:
		while n % f == 0:
			a.append(f)
			n //= f
		f += 1
	if n != 1:
		a.append(n)
	return a
n = int(input())
print(*factorize(n), sep='')


a = int(input())
i = 2
while True:
	if a % i == 0:
		break
	i += 1
print(i, a // i, sep='')


l = [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, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199]
n = int(input())
for i in l:
	if n % i == 0:
		x = str(i)
		y = str(n // i)
		break
print(int(x + y))


n = int(input())
a = []
st = ''
for i in range(2, int(n ** 0.5) + 1):
	if n % i == 0:
		a.append(i)
		a.append(n // i)
a.sort()
for i in a:
	st += str(i)
print(st)


t = int(input())
for i in range(1, int(t ** 0.5) + 1):
	if t % i == 0:
		n = i
m = t // n
if n < m:
	print(str(n) + str(m))
else:
	print(str(m) + str(n))


a = int(input())
b = a
l = []
f = 0
for i in range(2, b):
	if a % i == 0:
		c = 0
		for j in range(2, i):
			if i % j == 0:
				c += 1
		if c == 0:
			l.append(i)
			d = a
			d = int(a / i)
			m = 0
			for k in range(2, d):
				if d % k == 0:
					m += 1
			if m == 0:
				l.append(d)
				f = 1
	if f == 1:
		break
s = ''
for i in l:
	s += str(i)
print(s)


s = int(input())
for i in range(2, s):
	if s % i == 0:
		print(str(i) + str(s // i))
		exit(0)


def main():
	num = int(input())
	i = 2
	while num % i != 0:
		i += 1
	print(str(i) + str(num // i))
main()


n = int(input())
x = 2
while n % x > 0:
	x += 1
print(f'{x}{n // x}')


def mai(a):
	str1 = ''
	for i in range(2, a):
		if a % i == 0:
			str1 += str(i)
			str1 += str(a // i)
			break
	print(str1)
mai(int(input()))


x = int(input())
ind = 2
while ind * ind <= x:
	if x % ind == 0:
		print(str(ind) + str(x // ind))
		exit(0)
	ind += 1


(a, b, c) = (int(input()), 0, 0)
for i in range(1, a + 1):
	if a % i == 0:
		if a // i < i:
			print(str(b) + str(c))
			break
		else:
			(b, c) = (i, a // i)


import math
n = int(input())
k = math.sqrt(n)
i = int(k)
while n % i != 0:
	i -= 1
print(i, end='')
print(n // i)


a = int(input())
b = []
i = 2
k = a // 2 + 1
while i < k:
	if a % i == 0:
		b.append(i)
		a //= i
	else:
		i += 1
print(str(b[0]) + str(b[1]))


A = int(input())
div = []
for i in range(2, int(A)):
	if A % i == 0:
		print(str(i) + str(A // i))
		break


import sys
fin = sys.stdin
n = int(fin.readline().strip())
for i in range(2, n):
	if n % i == 0:
		print(str(i) + str(int(n / i)))
		break


n = int(input())
i = 2
dz = []
while n > 1:
	if n % i == 0:
		n //= i
		dz.append(i)
	else:
		i += 1
print(''.join(list(map(str, dz))))


import sys
input = sys.stdin.readline

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())

def prime_factors(n):
	i = 2
	factors = []
	while i * i <= n:
		if n % i:
			i += 1
		else:
			n //= i
			factors.append(i)
	if n > 1:
		factors.append(n)
	return factors
n = inp()
f = prime_factors(n)
for i in f:
	print(i, end='')


import math
n = int(input())
f = int(math.sqrt(n))
lst = []
for i in range(2, f + 1):
	if n % i == 0:
		lst.append(i)
		lst.append(n // i)
lst.sort()
s = ''
for i in lst:
	s += str(i)
print(s)


x = int(input())
for i in range(2, x):
	if x % i == 0:
		print('%d%d' % (i, x // i))
		break


import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from functools import lru_cache
import bisect
import re
import queue
from decimal import *

class Scanner:

	@staticmethod
	def int():
		return int(sys.stdin.readline().rstrip())

	@staticmethod
	def string():
		return sys.stdin.readline().rstrip()

	@staticmethod
	def map_int():
		return [int(x) for x in Scanner.string().split()]

	@staticmethod
	def string_list(n):
		return [input() for i in range(n)]

	@staticmethod
	def int_list_list(n):
		return [Scanner.map_int() for i in range(n)]

	@staticmethod
	def int_cols_list(n):
		return [int(input()) for i in range(n)]

class Math:

	@staticmethod
	def gcd(a, b):
		if b == 0:
			return a
		return Math.gcd(b, a % b)

	@staticmethod
	def lcm(a, b):
		return a * b // Math.gcd(a, b)

	@staticmethod
	def divisor(n):
		res = []
		i = 1
		for i in range(1, int(n ** 0.5) + 1):
			if n % i == 0:
				res.append(i)
				if i != n // i:
					res.append(n // i)
		return res

	@staticmethod
	def round_up(a, b):
		return -(-a // b)

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

def pop_count(x):
	x = x - (x >> 1 & 6148914691236517205)
	x = (x & 3689348814741910323) + (x >> 2 & 3689348814741910323)
	x = x + (x >> 4) & 1085102592571150095
	x = x + (x >> 8)
	x = x + (x >> 16)
	x = x + (x >> 32)
	return x & 127
MOD = int(1000000000.0) + 7
INF = int(1000000000000000.0)

def solve():
	N = Scanner.int()
	M = int(math.sqrt(N)) + 1
	for i in range(2, M):
		if N % i == 0:
			print(i, end='')
			N //= i
	if N != 1:
		print(N)

def main():
	solve()
main()


n = int(input())
A = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]
k = 0
for i in A:
	if n % i == 0:
		k = i
		break
l = n // k
a = str(k) + str(l)
print(int(a))


n = int(input())

def a(n):
	for i in range(2, n):
		if n % i == 0:
			return i
	return 1
print(str(a(n)) + '' + str(n // a(n)))


pri = {}

def Sieve():
	n = 1000
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * 2, n + 1, p):
				prime[i] = False
		p += 1
	prime[0] = False
	prime[1] = False
	for p in range(n + 1):
		if prime[p]:
			pri[p] = 1
Sieve()
n = int(input())
ans = ''
for i in pri.keys():
	if n / i in pri.keys():
		ans = str(i) + str(n // i)
		break
print(ans)


a = int(input())
x = 2
while x ** 2 <= a:
	while a % x == 0:
		print(x, end='')
		a //= x
	x += 1
if a > 1:
	print(a, end='')
print()


n = int(input())
p = 2
s = ''
while n > 1:
	if n % p == 0:
		s += str(p)
		n //= p
	else:
		p += 1
print(s)


import sys
input = lambda : sys.stdin.readline().rstrip()
x = int(input())
for i in range(2, x):
	if x % i == 0:
		print(str(x // (x // i)) + str(x // i))
		break


n = int(input())
p = 2
loop = True
while loop == True:
	if n % p == 0:
		a = p
		b = n // p
		loop = False
	else:
		p += 1
output = str(a) + str(b)
print(output)


import math

def primeFactors(n):
	l = []
	while n % 2 == 0:
		l.append(str(2))
		n = n / 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			l.append(str(i))
			n = n / i
	if n > 2:
		l.append(str(n))
	return ''.join(l)
n = int(input())
x = primeFactors(n)
l = x.split('.')
print(l[0])


n = int(input())
isp = [0] * 1000
spf = [i for i in range(1000)]
for i in range(2, 1000):
	if isp[i] == 0 and i * i < 1000:
		j = i * i
		while j < 1000:
			if spf[j] == j:
				spf[j] = i
			isp[j] = 1
			j += i
s = []
while n != 1:
	s += [spf[n]]
	n //= spf[n]
s = list(map(str, s))
print(''.join(s))


import math
n = int(input())
q = []
arr = [i for i in range(2, n + 1)]
for i in range(len(arr)):
	for j in range(i, len(arr)):
		if arr[i] * arr[j] == n:
			q.append(arr[i])
			q.append(arr[j])
l = str(q[0]) + str(q[1])
print(int(l))


from math import factorial
from math import log, ceil
from collections import defaultdict
from math import *
from sys import stdin, stdout
import itertools
import os
import sys
import threading
from collections import deque, Counter, OrderedDict, defaultdict
from heapq import *
from fractions import Fraction
mod = int(pow(10, 9) + 7)

def ii():
	return int(input())

def si():
	return str(input())

def mi():
	return map(int, input().split())

def li():
	return list(mi())

def fii():
	return int(stdin.readline())

def fsi():
	return str(stdin.readline())

def fmi():
	return map(int, stdin.readline().split())

def fli():
	return list(fmi())
abd = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}

def getKey(item):
	return item[0]

def sort2(l):
	return sorted(l, key=getKey)

def d2(n, m, num):
	return [[num for x in range(m)] for y in range(n)]

def isPowerOfTwo(x):
	return x and (not x & x - 1)

def decimalToBinary(n):
	return bin(n).replace('0b', '')

def ntl(n):
	return [int(i) for i in str(n)]

def powerMod(x, y, p):
	res = 1
	x %= p
	while y > 0:
		if y & 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res
graph = defaultdict(list)
visited = [0] * 1000000
col = [-1] * 1000000

def bfs(d, v):
	q = []
	q.append(v)
	visited[v] = 1
	while len(q) != 0:
		x = q[0]
		q.pop(0)
		for i in d[x]:
			if visited[i] != 1:
				visited[i] = 1
				q.append(i)
		print(x)

def make_graph(e):
	d = {}
	for i in range(e):
		(x, y) = mi()
		if x not in d:
			d[x] = [y]
		else:
			d[x].append(y)
		if y not in d:
			d[y] = [x]
		else:
			d[y].append(x)
	return d

def gr2(n):
	d = defaultdict(list)
	for i in range(n):
		(x, y) = mi()
		d[x].append(y)
	return d

def connected_components(graph):
	seen = set()

	def dfs(v):
		vs = set([v])
		component = []
		while vs:
			v = vs.pop()
			seen.add(v)
			vs |= set(graph[v]) - seen
			component.append(v)
		return component
	ans = []
	for v in graph:
		if v not in seen:
			d = dfs(v)
			ans.append(d)
	return ans

def primeFactors(n):
	s = set()
	while n % 2 == 0:
		s.add(2)
		n = n // 2
	for i in range(3, int(sqrt(n)) + 1, 2):
		while n % i == 0:
			s.add(i)
			n = n // i
	if n > 2:
		s.add(n)
	return s

def find_all(a_str, sub):
	start = 0
	while True:
		start = a_str.find(sub, start)
		if start == -1:
			return
		yield start
		start += len(sub)

def SieveOfEratosthenes(n, isPrime):
	isPrime[0] = isPrime[1] = False
	for i in range(2, n):
		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
	return isPrime

def dijkstra(edges, f, t):
	g = defaultdict(list)
	for (l, r, c) in edges:
		g[l].append((c, r))
	(q, seen, mins) = ([(0, f, ())], set(), {f: 0})
	while q:
		(cost, v1, path) = heappop(q)
		if v1 not in seen:
			seen.add(v1)
			path = (v1, path)
			if v1 == t:
				return (cost, path)
			for (c, v2) in g.get(v1, ()):
				if v2 in seen:
					continue
				prev = mins.get(v2, None)
				next = cost + c
				if prev is None or next < prev:
					mins[v2] = next
					heappush(q, (next, v2, path))
	return float('inf')

def binsearch(a, l, r, x):
	while l <= r:
		mid = l + (r - 1) // 2
		if a[mid]:
			return mid
		elif a[mid] > x:
			l = mid - 1
		else:
			r = mid + 1
	return -1
n = int(input())
l = [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, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997]
for i in l:
	if n % i == 0:
		print(str(i) + str(n // i))
		exit()


n = int(input())
primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53]
for i in primes:
	if n % i == 0:
		j = n // i
		if j >= i:
			ans = str(i) + str(j)
			print(int(ans))
			break
		else:
			ans = str(j) + str(i)
			print(int(ans))
			break


pre = [2]
for i in range(3, 999, 2):
	c = 0
	for j in range(1, int(pow(i, 0.5) + 1)):
		if i % j == 0:
			c += 1
	if c == 1:
		pre.append(i)
n = int(input())
s = ''
for i in pre:
	if n % i == 0:
		q = 0
		while n % i == 0:
			n = n // i
			q += 1
		s += str(i) * q
print(s)


from sys import stdin, stdout
from collections import defaultdict
from functools import lru_cache
from math import gcd, floor, ceil

def ilist():
	return [int(x) for x in stdin.readline().strip().split(' ')]

def iint():
	return int(stdin.readline())

def istr():
	return stdin.readline()
n = iint()
for i in range(2, n + 1):
	while n % i == 0:
		print(i, end='')
		n //= i


def prime(a):
	for i in range(2, a):
		if a % i == 0:
			return False
	return True
n = int(input())
if prime(n):
	print(n, 1, sep='')
else:
	for i in range(2, n + 1):
		if n % i == 0:
			a = i
			b = n // i
			if prime(a) and prime(b):
				a = min(a, b)
				b = max(a, b)
				break
			elif prime(a):
				break
			elif prime(b):
				(a, b) = (b, a)
				break
	print(a, b, sep='')


a = int(input())
L = []
for i in range(a):
	if i > 1:
		if a % i == 0:
			print(i, int(a / i), sep='')
			break


from sys import stdin, stdout
a = int(stdin.readline())
for i in range(2, a // 2 + 1):
	if a % i == 0:
		stdout.write(str(i))
		stdout.write(str(a // i))
		break


a = int(input())
c = 2
while a % c != 0:
	c += 1
d = a // c
(d, c) = (max(d, c), min(d, c))
print(c, d, sep='')


n = int(input())
i = 2
l = []
while n:
	while n % i == 0:
		n //= i
		print(i, end='')
	if i > n ** (1 / 2):
		break
	i += 1
if n != 1:
	print(n, end='')
print()


n = int(input())
i = 2
ans = []
while i <= n:
	while n % i == 0:
		n /= i
		ans.append(i)
	i += 1
print(str(ans)[1:-1].replace(', ', ''))


a = eval(input())
for i in range(2, 100):
	if a / i == a // i:
		print('{}{}'.format(i, a // i))
		break


x = int(input())
P = []
for a in range(2, x):
	y = x
	while y % a == 0:
		P.append(a)
		y = y // a
print(''.join(map(str, P)))


n = int(input())
ans1 = 1
ans2 = n
for i in range(2, n + 1):
	if n % i == 0:
		ans1 = i
		ans2 = int(n / i)
		break
print(str(ans1) + str(ans2))


import math
L = lambda : list(map(int, input().split()))
M = lambda : map(int, input().split())
I = lambda : int(input())
IN = lambda : input()

def s(a):
	print(''.join(list(map(str, a))))
n = I()
for i in range(2, n + 1):
	if n % i == 0:
		print(str(i) + str(n // i))
		break


import random
a = int(input())
for i in range(2, a):
	if a % i == 0:
		print(str(i) + str(int(a / i)))
		break


import sys
from functools import lru_cache
from heapq import merge, heapify, heappop, heappush
from math import ceil, floor, gcd, fabs, factorial, fmod, sqrt, inf
from collections import defaultdict as dd, deque, Counter as c
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
mod = pow(10, 9) + 7
mod2 = 998244353

def data():
	return sys.stdin.readline().strip()

def out(var):
	sys.stdout.write(str(var))

def outln(var):
	sys.stdout.write(str(var) + '\n')

def l():
	return list(sp())

def sl():
	return list(ssp())

def sp():
	return map(int, data().split())

def ssp():
	return map(str, data().split())

def l1d(n, val=0):
	return [val for i in range(n)]

def l2d(n, m, val=0):
	return [l1d(n, val) for j in range(m)]
n = int(data())
mod += 1
mod = 2
while n % mod:
	mod += 1
outln(str(mod) + str(n // mod))


x = int(input())
primes = []
for d in range(2, 1000):
	while not x % d:
		primes.append(d)
		x //= d
if x != 1:
	primes.append(x)
primes.sort()
print(''.join(list(map(str, primes))))


a = int(input())
if a % 2 == 0:
	x1 = 2
	x2 = a // 2
	print(str(min(x1, x2)) + str(max(x1, x2)))
else:
	for i in range(3, int(a ** (1 / 2)) + 1, 2):
		if a % i == 0:
			x1 = i
			x2 = a // i
			print(str(min(x1, x2)) + str(max(x1, x2)))
			break


a = int(input())
isnp = [0] * (a + 1)
p = []
for i in range(2, a + 1):
	if isnp[i] == 0:
		p.append(i)
		for j in range(i * i, a + 1, i):
			isnp[j] = 1
for i in p:
	if a % i == 0 and a / i in p:
		print('%d%d' % (i, a / i))
		break


idk = int(input())
i = 2
factors = []
while i * i <= idk:
	if idk % i:
		i += 1
	else:
		idk //= i
		factors.append(i)
if idk > 1:
	factors.append(idk)
r = ''
for factor in factors:
	r += str(factor)
print(r)


i = int(input())
Done = False
for a in range(2, i):
	for b in range(2, i):
		if a * b == i:
			Done = True
			print(str(a) + str(b))
			break
	if Done:
		break


n = int(input())
i = 2
while 1:
	if n % i == 0:
		print(str(i) + str(n // i))
		break
	i += 1


import math
n = int(input())
for i in range(2, 999):
	if n % i == 0:
		break
print(i, end='')
print(n // i)


n = int(input())
li = []
for i in range(2, 1000):
	while n % i == 0:
		li.append(i)
		n //= i
s = ''
for i in li:
	s = s + str(i)
print(s)


n = int(input())

def p(n):
	r = []
	while n % 2 == 0:
		n = n // 2
		r.append(2)
	z = n
	for i in range(3, int(z ** 0.5) + 1, 2):
		while n % i == 0:
			r.append(i)
			n = n // i
	if n > 2:
		r.append(n)
	return r
r = p(n)
f = 0
for i in range(len(r)):
	for j in range(i + 1, len(r)):
		if r[i] * r[j] == n:
			f = 1
			break
	if f == 1:
		break
print(str(r[i]) + str(r[j]))


from math import ceil, sqrt
n = input()
flag = 0

def check_prime(n):
	for i in range(2, n):
		if n % i == 0:
			return False
	return True
if check_prime(int(n)):
	print('1' + str(n))
else:
	flag = 0
	for i in range(2, 100):
		for j in range(2, 500):
			if i * j == int(n):
				print(str(i) + str(j))
				flag = 1
				break
		if flag == 1:
			break


n = int(input())
while n % 2 == 0:
	print(2, end='')
	n //= 2
i = 3
while n != 1:
	while n % i == 0:
		print(i, end='')
		n //= i
	i += 2


x = int(input())
for i in range(2, x):
	if x % i == 0:
		print('{}{}'.format(i, x // i))
		exit()


n = int(input())
for i in range(2, 1000):
	if n % i == 0:
		print(str(i) + str(n // i))
		break
	else:
		continue


n = int(input())
for i in range(2, n - 1):
	if n % i == 0:
		l = i
		break
a = n // i
print(l, end='')
print(a)


x = int(input())
for i in range(2, x // 2 + 1):
	if x % i == 0:
		print(i, x // i, sep='', end='')
		exit(0)


n = int(input())
a = int(n ** 0.5)
for i in range(0, a):
	if n % (a - i) == 0:
		sec = int(n / (a - i))
		fir = min(sec, a - i)
		sec = max(sec, a - i)
		print(str(fir) + str(sec))
		break
	else:
		continue


def fun(x):
	i = 2
	while i <= x:
		if x % i == 0:
			print(i, x // i, sep='')
			return
		i = i + 1
x = int(input())
fun(x)


n = int(input())
a = ''
for i in range(2, n):
	if n % i == 0 and len(a) <= 2:
		a += str(i)
		a += str(n // i)
		break
if len(a) == 0:
	print('1' + str(n))
else:
	print(int(a))


(a, d) = (int(input()), 2)
while a % d:
	d += 1
print(f'{d}{a // d}')


def gcd(a):
	num = []
	for i in range(2, int(a ** 0.5) + 1):
		if a % i == 0:
			num.append(str(i))
			num.append(str(a // i))
			a /= i
	return num
n = int(input())
ans = gcd(n)
print(''.join(ans))


n = int(input())
import math

def fact(a):
	if isprime(a):
		return int(a)
	for i in range(math.ceil(math.sqrt(a))):
		if a % (i + 2) == 0:
			return [i + 2, fact(a / (i + 2))]

def isprime(a):
	if a == 1 or a == 2 or a == 3:
		return True
	for i in range(math.ceil(math.sqrt(a))):
		if a % (i + 2) == 0:
			return False
	return True
facts = fact(n)
for i in range(len(facts)):
	facts[i] = str(facts[i])
hello = ''.join(facts)
print(hello)


n = int(input())
i = 2
ans = []
while n > 1:
	while n % i == 0:
		ans.append(i)
		n //= i
	i += 1
for i in sorted(list(ans)):
	print(i, end='')


x = int(input())
i = 2
s = ''
while i <= x:
	while x % i == 0:
		s += str(i)
		x //= i
	i += 1
print(s)


a = int(input())
arr = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]
(p, q) = (0, 0)
for i in arr:
	if a % i == 0:
		p = int(a / i)
		q = i
		break
s = str(min(p, q)) + str(max(p, q))
print(int(s))


n = int(input(''))
k = []
for i in range(1, n):
	if n % i == 0:
		k.append(i)
	else:
		pass
print(n // max(k), end='')
print(max(k), end='')


n = int(input())
for i in range(2, n + 1):
	if n % i == 0:
		print(str(i) + str(n // i))
		quit()