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.text.*;
import java.util.*;
import java.math.*;

public class C {
	static int rec(int n) {
		if(n % 2 == 1)
			return ((n * n) / 2 +1);
		else return (n * n / 2);
	}
	private static void solve() throws IOException {
		int x = nextInt();
		boolean w = false;
		if(x == 1) {
			out.println(1);
			return;
		}
		if(x == 1 || x == 2 || x == 4 || x == 5) {
			out.println(3);
			return;
		}
		for(int n = 4; ; n++) {
			if(n % 2 == 0) {
				int max = 4 * rec(n/2 - 1);
				if(x % 4 == 0 && x <= max) {
					w = true;
				}
			}
			else {
				int max = rec(n);
				if(x <= max)
					w = true;
			}
			if(w) {
				out.println(n);
				return;
			}
		}
	}
	
	
	public static void main(String[] args) {
		try {
			br = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);
			solve();
			out.close();
		} catch (Throwable e) {
			e.printStackTrace();
			System.exit(239);
		}
	}

	static BufferedReader br;
	static StringTokenizer st;
	static PrintWriter out;

	static String nextToken() throws IOException {
		while (st == null || !st.hasMoreTokens()) {
			String line = br.readLine();
			if (line == null) {
				return null;
			}
			st = new StringTokenizer(line);
		}
		return st.nextToken();
	}

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

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

	static double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}
}
class Info implements Comparable<Info>{
	int gf, go, w;
	Info(int f, int o, int w) {
		gf = f;
		go = o;
		this.w = w;
	}
	public int compareTo(Info o) {
		if(this.w > o.w)
			return 1;
		else if(this.w < o.w)
			return -1;
		else if(this.gf - this.go < o.gf - o.go)
			return -1;
		else if(this.gf - this.go > o.gf - o.go)
			return 1;
		else if(this.gf < o.gf)
			return -1;
		else if(this.gf > o.gf)
			return 1;
		else
			return 0;
	}
}