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.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.HashSet;
import java.util.InputMismatchException;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.TreeMap;

import static java.lang.Math.abs;

public class Sol implements Runnable {

  long mod = (long) 1e9 + 7;

  void solve(InputReader in, PrintWriter w) {
    boolean[] composite = new boolean[(int)1e7 + 5];
    for(int i = 2; i * i < (int)1e7 + 5; i++) {
      if(!composite[i]) {
        for(int j = 2 * i; j < (int)1e7 + 5; j += i) {
          composite[j] = true;
        }
      }
    }

    int n = in.nextInt();
    for(int b = 4; b < (int)1e7 + 5 - n; b++) {
      if(composite[b]) {
        int a = n + b;
        if(composite[a]) {
          w.println(a + " " + b);
          break;
        }
      }
    }
  }

  // ************* Code ends here ***************

  void init() throws Exception {
    //Scanner in;
    InputReader in;
    PrintWriter w;
    boolean online = false;

    String common_in_fileName = "\\Samplein";
    String common_out_fileName = "\\in";
    int test_files = 0;

    for (int file_no = 0; file_no <= test_files; file_no++) {

      String x = "" + file_no;
      if (x.length() == 1) x = "0" + x;

      String in_fileName = common_in_fileName;// + "" + x;
      String out_fileName = common_out_fileName + "" + x;

      if (online) {
        //in = new Scanner(new File(in_fileName + ".txt"));
        in = new InputReader(new FileInputStream(new File(in_fileName + ".txt")));
        w = new PrintWriter(new FileWriter(out_fileName + ".txt"));
      } else {
        //in = new Scanner(System.in);
        in = new InputReader(System.in);
        w = new PrintWriter(System.out);
      }

      solve(in, w);
      w.close();
    }
  }

  public void run() {
    try {
      init();
    } catch (Exception e) {
      System.out.println(e);
      e.printStackTrace();
    }
  }

  static class InputReader {

    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;
    private SpaceCharFilter filter;

    public InputReader(InputStream stream) {
      this.stream = stream;
    }

    public int read() {
      if (numChars == -1) {
        throw new InputMismatchException();
      }

      if (curChar >= numChars) {
        curChar = 0;
        try {
          numChars = stream.read(buf);
        } catch (IOException e) {
          throw new InputMismatchException();
        }

        if (numChars <= 0) {
          return -1;
        }
      }
      return buf[curChar++];
    }

    public String nextLine() {
      BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
      String str = "";
      try {
        str = br.readLine();
      } catch (IOException e) {
        e.printStackTrace();
      }
      return str;
    }

    public int nextInt() {
      int c = read();

      while (isSpaceChar(c)) {
        c = read();
      }

      int sgn = 1;

      if (c == '-') {
        sgn = -1;
        c = read();
      }

      int res = 0;
      do {
        if (c < '0' || c > '9') {
          throw new InputMismatchException();
        }
        res *= 10;
        res += c - '0';
        c = read();
      } while (!isSpaceChar(c));

      return res * sgn;
    }

    public long nextLong() {
      int c = read();
      while (isSpaceChar(c)) {
        c = read();
      }
      int sgn = 1;
      if (c == '-') {
        sgn = -1;
        c = read();
      }
      long res = 0;

      do {
        if (c < '0' || c > '9') {
          throw new InputMismatchException();
        }
        res *= 10;
        res += c - '0';
        c = read();
      } while (!isSpaceChar(c));
      return res * sgn;
    }

    public double nextDouble() {
      int c = read();
      while (isSpaceChar(c)) {
        c = read();
      }
      int sgn = 1;
      if (c == '-') {
        sgn = -1;
        c = read();
      }
      double res = 0;
      while (!isSpaceChar(c) && c != '.') {
        if (c == 'e' || c == 'E') {
          return res * Math.pow(10, nextInt());
        }
        if (c < '0' || c > '9') {
          throw new InputMismatchException();
        }
        res *= 10;
        res += c - '0';
        c = read();
      }
      if (c == '.') {
        c = read();
        double m = 1;
        while (!isSpaceChar(c)) {
          if (c == 'e' || c == 'E') {
            return res * Math.pow(10, nextInt());
          }
          if (c < '0' || c > '9') {
            throw new InputMismatchException();
          }
          m /= 10;
          res += (c - '0') * m;
          c = read();
        }
      }
      return res * sgn;
    }

    public String readString() {
      int c = read();
      while (isSpaceChar(c)) {
        c = read();
      }
      StringBuilder res = new StringBuilder();
      do {
        res.appendCodePoint(c);
        c = read();
      } while (!isSpaceChar(c));

      return res.toString();
    }

    public boolean isSpaceChar(int c) {
      if (filter != null) {
        return filter.isSpaceChar(c);
      }
      return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    public String next() {
      return readString();
    }

    public interface SpaceCharFilter {

      public boolean isSpaceChar(int ch);
    }
  };

  public static void main(String args[]) throws Exception {
    new Thread(null, new Sol(), "Sol", 1 << 28).start();
  }
}