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.BufferedReader;
import java.io.InputStreamReader;
import java.util.Scanner;

public class C {

	private int[] sol = new int[101];

	private void work() {
		// for (int i = 2; i <= 70; i++) {
		// sol[i] = solve(i);
		// System.out.printf("%2d: %d\n", i, sol[i]);
		// }

		int cur = 2;
		int curLim = 6;
		int add = 4;
		int n = 3;
		while (cur <= 100) {
			sol[cur++] = n;
			if (cur == curLim) {
				add += 4;
				curLim = cur + add;
				n += 2;
			}
		}
		sol[1] = 1;
		sol[3] = 5;
		Scanner sc = new Scanner(new BufferedReader(new InputStreamReader(
				System.in)));
		while (sc.hasNextInt()) {
			int x = sc.nextInt();
			System.out.println(sol[x]);
		}
	}

	// private int solve(int x) {
	// int n = 3;
	// while (true) {
	// if (canDo(x, n))
	// return n;
	// n += 2;
	// }
	// }
	//
	// private int lim;
	// private Boolean[][][][][] m;
	//
	// private boolean canDo(int x, int n) {
	// lim = n / 2;
	// m = new Boolean[lim + 1][lim + 1][1 << (lim + 1)][1 << (lim + 1)][x + 1];
	// return go(0, 0, 0, 0, x);
	// }
	//
	// private boolean go(int r, int c, int prev, int cur, int rem) {
	// if (c > lim)
	// return go(r + 1, 0, cur, 0, rem);
	// if (rem == 0)
	// return true;
	// if (rem < 0 || r > lim)
	// return false;
	// if (m[r][c][prev][cur][rem] != null)
	// return m[r][c][prev][cur][rem];
	// boolean ret = go(r, c + 1, prev, cur, rem);
	// if (((1 << c) & prev) == 0 && (c == 0 || ((1 << (c - 1)) & cur) == 0)) {
	// int blah = 4;
	// if (r == lim)
	// blah >>= 1;
	// if (c == lim)
	// blah >>= 1;
	// ret |= go(r, c + 1, prev, cur | (1 << c), rem - blah);
	// }
	// return m[r][c][prev][cur][rem] = ret;
	// }

	public static void main(String[] args) {
		new C().work();
	}
}
