Problem: Let's call a positive integer composite if it has at least one divisor other than 1 and itself. For example:

  * the following numbers are composite: 1024, 4, 6, 9; 
  * the following numbers are not composite: 13, 1, 2, 3, 37. 



You are given a positive integer n. Find two composite integers a,b such that a-b=n.

It can be proven that solution always exists.

Input

The input contains one integer n (1 ≤ n ≤ 10^7): the given integer.

Output

Print two composite integers a,b (2 ≤ a, b ≤ 10^9, a-b=n).

It can be proven, that solution always exists.

If there are several possible solutions, you can print any. 

Examples

Input


1


Output


9 8


Input


512


Output


4608 4096

Solution (in PYTHON3):

Solution:
import random 
  
# modulo function to perform binary  
# exponentiation  
def modulo(base, exponent, mod):  
    x = 1;  
    y = base;  
    while (exponent > 0):  
        if (exponent % 2 == 1):  
            x = (x * y) % mod;  
  
        y = (y * y) % mod;  
        exponent = exponent // 2;  
  
    return x % mod;  
  
# To calculate Jacobian symbol of a 
# given number  
def calculateJacobian(a, n):  
  
    if (a == 0):  
        return 0;# (0/n) = 0  
  
    ans = 1;  
    if (a < 0):  
          
        # (a/n) = (-a/n)*(-1/n)  
        a = -a;  
        if (n % 4 == 3):  
          
            # (-1/n) = -1 if n = 3 (mod 4)  
            ans = -ans;  
  
    if (a == 1):  
        return ans; # (1/n) = 1  
  
    while (a):  
        if (a < 0): 
              
            # (a/n) = (-a/n)*(-1/n)  
            a = -a;  
            if (n % 4 == 3): 
                  
                # (-1/n) = -1 if n = 3 (mod 4)  
                ans = -ans;  
  
        while (a % 2 == 0):  
            a = a // 2;  
            if (n % 8 == 3 or n % 8 == 5):  
                ans = -ans;  
  
        # swap  
        a, n = n, a;  
  
        if (a % 4 == 3 and n % 4 == 3):  
            ans = -ans;  
        a = a % n;  
  
        if (a > n // 2):  
            a = a - n;  
  
    if (n == 1):  
        return ans;  
  
    return 0;  
  
# To perform the Solovay- Strassen  
# Primality Test  
def solovoyStrassen(p, iterations):  
  
    if (p < 2):  
        return False;  
    if (p != 2 and p % 2 == 0):  
        return False;  
  
    for i in range(iterations): 
          
        # Generate a random number a  
        a = random.randrange(p - 1) + 1;  
        jacobian = (p + calculateJacobian(a, p)) % p;  
        mod = modulo(a, (p - 1) / 2, p);  
  
        if (jacobian == 0 or mod != jacobian):  
            return False;  
  
    return True;  

n=int(input())
iterations=50
if n%2==0:
    print(n+4,4)
else:
    h=1
    m=4
    while(h):
        if solovoyStrassen(m, iterations)==False and solovoyStrassen(m+n, iterations)==False:
            print(m+n,m)
            h=0
            break
        m+=1