Vladik and Chloe decided to determine who of them is better at math. Vladik claimed that for any positive integer n he can represent fraction <image> as a sum of three distinct positive fractions in form <image>.

Help Vladik with that, i.e for a given n find three distinct positive integers x, y and z such that <image>. Because Chloe can't check Vladik's answer if the numbers are large, he asks you to print numbers not exceeding 109.

If there is no such answer, print -1.

Input

The single line contains single integer n (1 ≤ n ≤ 104).

Output

If the answer exists, print 3 distinct numbers x, y and z (1 ≤ x, y, z ≤ 109, x ≠ y, x ≠ z, y ≠ z). Otherwise print -1.

If there are multiple answers, print any of them.

Examples

Input

3


Output

2 7 42


Input

7


Output

7 8 56
import java.util.*;
import java.io.*;

public class ggg {

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

	private static void soln(){
		int n=nextInt();
		if(n==1)
			pw.println(-1);
		else
			pw.println(n+" "+(n+1)+" "+n*(n+1));
	}
	private static boolean isPrime(int n){
		if(n%2==0 || n%3==0)
			return false;
		for(int i=5;i*i<=n;i+=6)
			if(n%i==0 || n%(i+2)==0)
				return false;
		return true;
				
	}
	private static int knapsack(int[] val,int[] w, int W,ArrayList<LinkedList<Integer>> l){
		int[][] old=new int[2][W+1];
		int i=0;
		while(i<l.size()){
			int j=0;
			int[][] mat_new=new int[2][W+1];
			for(int k=0;k<W+1;k++){
				mat_new[0][k]=old[0][k];
				mat_new[1][k]=old[1][k];
			}
			int tot_w=0;
			int tot_b=0;
			Iterator<Integer> q=l.get(i).listIterator();
			while(q.hasNext()){
				int a=q.next();
				tot_w+=w[a-1];
				tot_b+=val[a-1];
			}
			//System.out.println(tot_w+" "+tot_b);
			if(i%2!=0){
				while(++j<=W){
					Iterator<Integer> k=l.get(i).listIterator();
					while(k.hasNext()){
						int a=k.next();
						if(w[a-1]<=j){
							mat_new[1][j]=max(val[a-1]+old[0][j-w[a-1]],max(mat_new[1][j],old[0][j]));
						}else{
							mat_new[1][j]=max(old[0][j],mat_new[1][j]);
						}	
					}
					if(tot_w<=j){	
						mat_new[1][j]=max(tot_b+old[0][j-tot_w],max(mat_new[1][j],old[0][j]));
					}else{
						mat_new[1][j]=max(old[0][j],mat_new[1][j]);
					}
				}
			}else{
				while(++j<=W){
					Iterator<Integer> k=l.get(i).listIterator();
					while(k.hasNext()){
						//System.out.println(a);
						int a=k.next();
						//System.out.println(a);
						if(w[a-1]<=j){
							mat_new[0][j]=max(val[a-1]+old[1][j-w[a-1]],max(mat_new[0][j],old[1][j]));
						}else{
							mat_new[0][j]=max(old[1][j],mat_new[0][j]);
						}	
					}
					if(tot_w<=j){
						mat_new[0][j]=max(tot_b+old[1][j-tot_w],max(mat_new[0][j],old[1][j]));
					}else{
						mat_new[0][j]=max(old[1][j],mat_new[0][j]);
					}
				}
				//for(int t=0;t<=W;t++)
					//System.out.println(mat_new[0][t]);
			}
			old=mat_new;
			i++;
		}
		return (l.size()%2 !=0)?old[0][W]:old[1][W];
	}
	private static int DFSUtils(int v,LinkedList<Integer>[] g,int[] colour){
		Iterator<Integer> i=g[v].listIterator();
		while(i.hasNext()){
			int j=i.next();
			if(colour[j]==0){
				if(colour[v]==1)
					colour[j]=2;
				else
					colour[j]=1;
				if(DFSUtils(j,g,colour)==-1)
					return -1;
			}else if(colour[j]==colour[v])
				return -1;
		}
		return 0;
	}
	private static int[] DFS(LinkedList<Integer>[] g,int n){
		int[] colour=new int[2*n];
		for(int i=0;i<n;i++){
			if(colour[i]==0){
				colour[i]=1;
				//System.out.println(1);
				if(DFSUtils(i,g,colour)==-1)
					return null;
			}
		}
		return colour;
	}
	private static long gcd(long a,long b){
		if(b==0)
			return a;
		else return gcd(b,a%b);
	}
	private static long lcm(long a,long b){
		return (a*b)/gcd(a,b);
	}
	private static int min(int a,int b){
		if(a>b)
			return b;
		else
			return a;
	}
	private static class Pair implements Comparable<Pair>{
		int x;
		int y;
		public Pair(int a,int b){
			x=a;
			y=b;
		}
		@Override
		public int compareTo(Pair arg0) {
			if(this.x > arg0.x)
				return 1;
			return 0;
		}
	}
	static long pow(int a, long b, int MOD) {
		long x = 1, y = a;
		    while(b > 0) {
		        if(b%2 == 1) {
		            x=(x*y);
		            if(x>MOD) x%=MOD;
		        }
		        y = (y*y);
		        if(y>MOD) y%=MOD;
		        b /= 2;
		    }
		    return x;
		}
		 
		static long modInverse(int a,long b, int m) {
			//pw.println((m-2)*b);
		    return pow(a,(m-2)*b,m);
		}
	private static void computeLpsArray(String pat,int size,int[] lps){
		int len=0;
		int i=1;
		lps[0]=0;
		while(i<size){
			if(pat.charAt(i)==pat.charAt(len)){
				len++;
				lps[i]=len;
				i++;
			}else{
				if(len!=0){
					len=lps[len-1];
				}else{
					lps[i]=len;
					i++;
				}
			}
		}
	}
	private static int KMP(String pat,String txt){
		int m=pat.length();
		int n=txt.length();
		int[] lps=new int[m];
		int j=0;
		int len=0;
		int index=0;
		computeLpsArray(pat,m,lps);
		int i=0;
		while(i<n){
			if(pat.charAt(j)==txt.charAt(i)){
				i++;
				j++;
			}else{
				if(j!=0)
					j=lps[j-1];
				else
					i++;
			}
			if(len<j){
				len=j;
				//pw.println(i);
				index=i;
			}
		}
		return index-len;
	}
	private static int max(int a,int b){
		if(a>b)
			return a;
		return b;
	}
	public static void main(String[] args) {
		InputReader(System.in);
		pw = new PrintWriter(System.out);
		soln();
		pw.close();
	}

	// To Get Input
	// Some Buffer Methods

	public static void InputReader(InputStream stream1) {
		stream = stream1;
	}

	private static boolean isWhitespace(int c) {
		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	}

	private static boolean isEndOfLine(int c) {
		return c == '\n' || c == '\r' || c == -1;
	}

	private static 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++];
	}

	private static 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;
	}

	private static 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;
	}

	private static String nextToken() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = read();
		} while (!isSpaceChar(c));
		return res.toString();
	}

	private static String nextLine() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = read();
		} while (!isEndOfLine(c));
		return res.toString();
	}

	private static int[] nextIntArray(int n) {
		int[] arr = new int[n];
		for (int i = 0; i < n; i++) {
			arr[i] = nextInt();
		}
		return arr;
	}

	private static long[] nextLongArray(int n) {
		long[] arr = new long[n];
		for (int i = 0; i < n; i++) {
			arr[i] = nextLong();
		}
		return arr;
	}

	private static void pArray(int[] arr) {
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
		System.out.println();
		return;
	}

	private static void pArray(long[] arr) {
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
		System.out.println();
		return;
	}

	private static boolean isSpaceChar(int c) {
		if (filter != null)
			return filter.isSpaceChar(c);
		return isWhitespace(c);
	}

	private interface SpaceCharFilter {
		public boolean isSpaceChar(int ch);
	}

}