Problem: Today, Osama gave Fadi an integer X, and Fadi was wondering about the minimum possible value of max(a, b) such that LCM(a, b) equals X. Both a and b should be positive integers.

LCM(a, b) is the smallest positive integer that is divisible by both a and b. For example, LCM(6, 8) = 24, LCM(4, 12) = 12, LCM(2, 3) = 6.

Of course, Fadi immediately knew the answer. Can you be just like Fadi and find any such pair?

Input

The first and only line contains an integer X (1 ≤ X ≤ 10^{12}).

Output

Print two positive integers, a and b, such that the value of max(a, b) is minimum possible and LCM(a, b) equals X. If there are several possible such pairs, you can print any.

Examples

Input


2


Output


1 2


Input


6


Output


2 3


Input


4


Output


1 4


Input


1


Output


1 1

Solution (in JAVA):

Solution:
import java.io.*;
import java.util.*;
public class code {
	static PrintWriter pw;
	public static int ceil(double x) {
		if(x%1==0) {
			return (int)x;
		}else if(x>0) {
			return (int)x+1;
		}else {
			return (int)x-1;
		}
	}
	static long gcf(long x, long y) {
		while(x%y!=0 && y%x!=0) {
			long tempx=x;
			x%=y;
			y%=tempx;
		}
		return x>y? y:x;
	}
	public static void main(String[] args) throws Exception {
		Scanner sc= new Scanner(System.in);
		pw = new PrintWriter(System.out);
//		while(true) {
//			int n=sc.nextInt();
//			if(n==0)
//				break;
//			Pair[] arr=new Pair[n];
//			for(int i=0; i<n; i++) {
//				double x1=sc.nextDouble(),y1=sc.nextDouble(),x2=sc.nextDouble(),y2=sc.nextDouble();
//				double ang1=x1>=0? Math.atan(y1/x1): 180+Math.atan(y1/x1);
//				double ang2= x2>=0? Math.atan(y2/x2): 180+Math.atan(y2/x2);
//				arr[i]=new Pair(Math.min(ang1, ang2),Math.max(ang1, ang2));
//			}
//			Arrays.sort(arr);
//			double start=arr[0].x,end=arr[0].y;
//			int ans=0;
//			for(int i=1; i<n; i++) {
//				if(arr[i].y>=start && arr[i].x<=end) {
//					start=Math.max(arr[i].x, start);
//					end=Math.min(arr[i].y, end);
//				}else {
//					ans++;
//					start=arr[i].x;
//					end=arr[i].y;
//				}
//			}
//			pw.println(ans+1);
//		}
		long x=sc.nextLong();
		int n=(int)Math.sqrt(x);
		for(;n>=1;n--) {
			if(x%n==0 && gcf(n, x/n)==1) {
				pw.println(n+" "+x/n);
				break;
			}
		}
		pw.close();
	}
 
	static class Scanner {
		StringTokenizer st;
		BufferedReader br;
 
		public Scanner(InputStream s) {
			br = new BufferedReader(new InputStreamReader(s));
		}
 
		public Scanner(FileReader r) {
			br = new BufferedReader(r);
		}
 
		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}
 
		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}
 
		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}
 
		public String nextLine() throws IOException {
			return br.readLine();
		}
 
		public double nextDouble() throws IOException {
			return Double.parseDouble(next());
		}
 
		public int[] nextArr(int n) throws IOException {
			int[] arr = new int[n];
			for (int i = 0; i < arr.length; i++)
				arr[i] = nextInt();
			return arr;
		}
 
		public boolean ready() throws IOException {
			return br.ready();
		}
	}
	static class Pair implements Comparable<Pair>{
		double x;
		double y;
		public Pair(double a, double b) {
			this.x=a;
			this.y=b;
		}
		public int compareTo(Pair other) {
			if(this.x!=other.x)
				return ceil(this.x-other.x);
			else
				return ceil(this.x-other.x);
		}
	}
}
class gate implements Comparable<gate>{
	int rate;
	int cost;
	public gate(int a, int b) {
		rate=a;
		cost=b;
	}
	public int compareTo(gate other) {
		if(this.rate!=other.rate)
			return this.rate-other.rate;
		else
			return other.cost-this.cost;
	}
}