<image>

Input

The input contains a single floating-point number x with exactly 6 decimal places (0 < x < 5).

Output

Output two integers separated by a single space. Each integer should be between 1 and 10, inclusive. If several solutions exist, output any of them. Solution will exist for all tests.

Examples

Input

1.200000


Output

3 2


Input

2.572479


Output

10 3


Input

4.024922


Output

9 9
import java.awt.*;
import java.io.*; 
import java.math.*;
import java.util.*;
import java.util.Map.Entry;

import static java.lang.Math.*; 
   
public class solver implements Runnable { 
        final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null; 
        BufferedReader in; 
        PrintWriter out; 
        StringTokenizer tok = new StringTokenizer(""); 
        
        boolean HasTokens(){
            while(!tok.hasMoreTokens()){ 
                try{ 
                        tok = new StringTokenizer(in.readLine()); 
                }catch (Exception e){ 
                        return false; 
                } 
            }
            return true;
        }
          
        String readString() throws IOException{                 
            return HasTokens() ? tok.nextToken():null; 
        } 
        String readString(String delim) throws IOException{ 
            return HasTokens() ? tok.nextToken(delim):null;
        } 
         
        int readInt() throws IOException{ 
            return Integer.parseInt(readString()); 
        }   
        long readLong() throws IOException{ 
            return Long.parseLong(readString()); 
        }       
        double readDouble() throws IOException{ 
            return Double.parseDouble(readString()); 
        }  
        char readChar() throws IOException { 
            char val = 0; 
            do{ 
                val = (char) in.read(); 
            }while(val == '\n' || val == '\r'); 
            return val; 
        } 
//----------------------------------
        int gcd(int x, int y){
            while (y != 0) {
                int temp = x%y; x = y; y = temp;
            }
            return x;
        }
//----------------------------------        
          
        public class Pair<T1,T2> { 
            public T1 x1; 
            public T2 x2; 
            public Pair(){}; 
            public Pair(T1 x1, T2 x2){ 
                this.x1 = x1; 
                this.x2 = x2; 
            } 
            public String toString(){ 
                return x1 + ":" + x2; 
            } 
        }  
        
        public class Three implements Comparable<Three>{ 
            public int x1, x2, x3; 
            public Three(){} 
            public Three(int a, int b, int c){x1 = a;x2=b;x3=c;} 
            public int compareTo(Three o) {//               
                if(x1 == o.x1 && x2 == o.x2) return x3-o.x3;
                if(x1 == o.x1) return x2-o.x2;
                return (x1-o.x1);  
                // (x1-o.x1) - increase; -(x1-o.x1) - decrease 
            } 
            public String toString(){ 
                return x1 + ":" + x2 + ":" + x3; 
            } 
        } 
//----------------------------------------  
       
        
        double getH(int h, int a){
            double aa = a / 2.0;
            double bb = h;
            double cc = Math.sqrt(aa*aa+bb*bb);
            double polup = (aa+bb+cc)/2;
            double s = Math.sqrt(polup*(polup-aa)*(polup-bb)*(polup-cc));
            return s*2/cc;
        }
        
        
        void solve() throws NumberFormatException, IOException {
            double x = readDouble();
            double eps = 10000;
            int ans1=0;
            int ans2=0;
            for (int h=1;h<11;h++){
                for (int a=1;a<11;a++){
                    double res = getH(h,a);
                    double abs = Math.abs(x-res);
                    if (abs < eps){
                        eps = abs;
                        ans1=h;
                        ans2=a;
                    }
                }
            }
            out.println(ans2+" "+ans1);
            
        }
        
//---------------------------------------- 
        public static void main(String[] args){ 
            new Thread(null, new solver(), "", 256 * (1L << 20)).start(); 
        } 
         
        public void run(){ 
                try{ 
                        timeBegin = System.currentTimeMillis(); 
                        try{ 
                            if (ONLINE_JUDGE){ 
                                in = new BufferedReader(new InputStreamReader(System.in)); 
                                out = new PrintWriter(System.out); 
//                                in = new BufferedReader(new FileReader("log.in")); 
//                                out = new PrintWriter("log.out"); 
                            }  
                            else { 
                                in = new BufferedReader(new FileReader("input.txt")); 
                                out = new PrintWriter("output.txt"); 
                            } 
                        }catch(Throwable e){
                            in = new BufferedReader(new InputStreamReader(System.in)); 
                            out = new PrintWriter(System.out); 
                        }
                          
                        solve(); 
                        out.close(); 
                          
                        timeEnd = System.currentTimeMillis(); 
                        System.err.println("Time = " + (timeEnd - timeBegin)); 
                }catch (Exception e){ 
                        e.printStackTrace(System.err); 
                        System.exit(-1); 
                } 
        } 
         
        long timeBegin, timeEnd; 
   
          
//----------        
        void update(int[] doo, int v, int i, int val, int ll, int rr){ 
            if (ll == rr){ 
                doo[v] = val; 
            }else{ 
                int med = ll + ((rr-ll)>>1); 
                  
                if (i <= med){ 
                    update(doo, v<<1, i, val, ll, med); 
                }else{ 
                    update(doo, (v<<1)+1, i, val, med+1, rr); 
                } 
                doo[v] = min(doo[v<<1], doo[(v<<1)+1]); 
            } 
        } 
        long get(long[] doo, int v, int l, int r, int ll, int rr){ 
            if (l > r){ 
                return Integer.MAX_VALUE; 
            } 
            if (ll == l && r == rr){ 
                return doo[v]; 
            } 
            int med = ll + ((rr-ll)>>1);
            return min(get(doo, v<<1, l, min(r, med), ll, med),  
                    get(doo, (v<<1)+1, max(l, med+1), r, med+1, rr)); 
        }
 
//-----------------------------------------
}