Consider some square matrix A with side n consisting of zeros and ones. There are n rows numbered from 1 to n from top to bottom and n columns numbered from 1 to n from left to right in this matrix. We'll denote the element of the matrix which is located at the intersection of the i-row and the j-th column as Ai, j.

Let's call matrix A clear if no two cells containing ones have a common side.

Let's call matrix A symmetrical if it matches the matrices formed from it by a horizontal and/or a vertical reflection. Formally, for each pair (i, j) (1 ≤ i, j ≤ n) both of the following conditions must be met: Ai, j = An - i + 1, j and Ai, j = Ai, n - j + 1.

Let's define the sharpness of matrix A as the number of ones in it.

Given integer x, your task is to find the smallest positive integer n such that there exists a clear symmetrical matrix A with side n and sharpness x.

Input

The only line contains a single integer x (1 ≤ x ≤ 100) — the required sharpness of the matrix.

Output

Print a single number — the sought value of n.

Examples

Input

4


Output

3


Input

9


Output

5

Note

The figure below shows the matrices that correspond to the samples:

<image>

import java.io.*;
import java.util.*;

public class Main implements Runnable {

    public void solve() throws IOException {
        int x = nextInt();

        if ( x == 1 ) {
            out.println( 1 );
            return;
        }
        
        if( x == 3 ){
            out.println( 5 );
            return;
        }
        
        if( x == 6 ){
            out.println( 5 );
            return;
        }

        int n = 1;

        while (true) {
            int k = n*n;
            k /= 2;
            if( (n*n) % 2 == 1 ){
                k++;
            }
            int max = 0;
            if( n % 2 == 0 ){
                max = 4*k;
                max += (2*n+1);
            } else {
                max = n/2;
                max *= 4;
                max++;
                max += 4*k;
                int max2 = (n*n)/2;
                int r = n/2+1;
                r *= 4;
                //max = Math.max( max, max2+r );
            }
            if( max >= x ){
                out.println( 2*n+1 );
                return;
            }
            n++;
        }

//        if( x == 1 ){
//            out.println( 1 );
//            return;
//        }
//        
//        if( x == 3 ){
//            out.println( 5 );
//            return;
//        }
//        
//        if( x == 6 ){
//            out.println( 5 );
//            return;
//        }
//        
//        int n = 1;
//        
//        int t = x/4;
//        
//        while( true ){
//            int k = n*n;
//            k /= 2;
//            if( (n*n) % 2 == 1 ){
//                k++;
//            }
//            if( k >= t ){
//                out.println( 2*n+1 );
//                return;
//            }
//            n++;
//        }
    }

    public static void main(String[] args) {
        new Main().run();
    }

    public void run() {
        try {
            in = new BufferedReader(new InputStreamReader((System.in)));
            out = new PrintWriter(System.out);

            st = null;
            rnd = new Random();

            // double start = System.currentTimeMillis();
            solve();
            //double total = (System.currentTimeMillis() - start) / 1000.0;
            // total *= 10;

            //out.println("Total time: " + total + " sec.");

            out.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private String nextToken() throws IOException, NullPointerException {
        while (st == null || !st.hasMoreTokens()) {
            st = new StringTokenizer(in.readLine());
        }

        return st.nextToken();
    }

    private int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }

    private long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }

    private double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }
    private BufferedReader in;
    private PrintWriter out;
    private StringTokenizer st;
    private Random rnd;
}