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 JAVA):

Solution:
import java.io.*;
import java.util.*;

public class A_Equation {
    double PI = 3.141592653589793238462643383279502884197169399375105820974944;
    int MOD = 1000000007;

    public static void main(String[] args) {
        FastScanner f = new FastScanner();
        PrintWriter out = new PrintWriter(System.out);
        int n= f.ri();
        if(n==1){
           out.println(9+" "+8);
        }
        else{
            out.println(n*3+" "+2*n);
        }
        out.close();
    }

    // any other class you make,make it static.




    static class FastScanner {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer("");

        String rs() {
            while (!st.hasMoreTokens())
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            return st.nextToken();
        }

        int ri() {
            return Integer.parseInt(rs());
        }

        int[] rarr(int n) {
            int[] a = new int[n];
            for (int i = 0; i < n; i++)
                a[i] = ri();
            return a;
        }

        long rl() {
            return Long.parseLong(rs());
        }
    }

    static void sort(int[] a) {
		ArrayList<Integer> l=new ArrayList<>();
		for (int i:a) l.add(i);
		Collections.sort(l);
		for (int i=0; i<a.length; i++) a[i]=l.get(i);
	}

    static int gcd(int a, int b) {
        return (b == 0) ? a : gcd(b, a % b);
    }

    static long ncr(int n, int k) // note it returns long
    {
        if (k > n - k) {
            k = n - k;
        }
        long c[] = new long[k + 1];
        c[0] = 1;
        for (int i = 1; i <= n; i++) {
            for (int j = Math.min(i, k); j > 0; j--) {
                c[j] = c[j] + c[j - 1];
                // c[j]=c[j]%(1000000000+7);when asked or int is used instead of long
            }
        }
        return c[k];
    }

}