#include <bits/stdc++.h>
using namespace std;
const int dir[4][2] = {1, 0, 0, -1, -1, 0, 0, 1};
const int MAXN = 101;
const int MAXD = 101;
int cnt[MAXN][MAXN];
bool g[MAXN][MAXN];
int ans[MAXN];
void solved(int x, int y, int c) {
  cnt[x][y] += c;
  g[x][y] = c == 1 ? true : false;
  for (int k = 0; k < 4; ++k) {
    int tx = x + dir[k][0];
    int ty = y + dir[k][1];
    cnt[tx][ty] += c;
  }
}
void dfs(int n, int d, int px, int py) {
  if (d > 100) return;
  ans[d] = min(ans[d], n);
  int tn = (n + 1) / 2;
  if (py > tn) {
    dfs(n, d, px + 1, 1);
    return;
  } else if (px > tn) {
    return;
  }
  if (cnt[px][py])
    dfs(n, d, px, py + 1);
  else {
    if (px + 1 == n - px + 1 || py + 1 == n - py + 1) {
      dfs(n, d, px, py + 1);
    } else {
      int c = 1;
      solved(px, py, c);
      solved(n - px + 1, py, c);
      solved(px, n - py + 1, c);
      solved(n - px + 1, n - py + 1, c);
      int tc = 0;
      if (px == n - px + 1 && py == n - py + 1)
        tc = 1;
      else if (px == n - px + 1)
        tc = 2;
      else if (py == n - py + 1)
        tc = 2;
      else
        tc = 4;
      dfs(n, d + tc, px, py + 2);
      c = -1;
      solved(px, py, c);
      solved(n - px + 1, py, c);
      solved(px, n - py + 1, c);
      solved(n - px + 1, n - py + 1, c);
      dfs(n, d, px, py + 1);
    }
  }
}
int main() {
  int n, x;
  scanf("%d", &x);
  if (x == 3) {
    printf("5\n");
    return 0;
  }
  for (n = 1;; n += 2) {
    int tn = (n + 1) / 2;
    if (tn * tn + (tn - 1) * (tn - 1) >= x) {
      printf("%d\n", n);
      break;
    }
  }
  return 0;
}

### Prompt

In CPP, your task is to solve the following problem:

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>

### Response

```cpp
#include <bits/stdc++.h>
using namespace std;
const int dir[4][2] = {1, 0, 0, -1, -1, 0, 0, 1};
const int MAXN = 101;
const int MAXD = 101;
int cnt[MAXN][MAXN];
bool g[MAXN][MAXN];
int ans[MAXN];
void solved(int x, int y, int c) {
  cnt[x][y] += c;
  g[x][y] = c == 1 ? true : false;
  for (int k = 0; k < 4; ++k) {
    int tx = x + dir[k][0];
    int ty = y + dir[k][1];
    cnt[tx][ty] += c;
  }
}
void dfs(int n, int d, int px, int py) {
  if (d > 100) return;
  ans[d] = min(ans[d], n);
  int tn = (n + 1) / 2;
  if (py > tn) {
    dfs(n, d, px + 1, 1);
    return;
  } else if (px > tn) {
    return;
  }
  if (cnt[px][py])
    dfs(n, d, px, py + 1);
  else {
    if (px + 1 == n - px + 1 || py + 1 == n - py + 1) {
      dfs(n, d, px, py + 1);
    } else {
      int c = 1;
      solved(px, py, c);
      solved(n - px + 1, py, c);
      solved(px, n - py + 1, c);
      solved(n - px + 1, n - py + 1, c);
      int tc = 0;
      if (px == n - px + 1 && py == n - py + 1)
        tc = 1;
      else if (px == n - px + 1)
        tc = 2;
      else if (py == n - py + 1)
        tc = 2;
      else
        tc = 4;
      dfs(n, d + tc, px, py + 2);
      c = -1;
      solved(px, py, c);
      solved(n - px + 1, py, c);
      solved(px, n - py + 1, c);
      solved(n - px + 1, n - py + 1, c);
      dfs(n, d, px, py + 1);
    }
  }
}
int main() {
  int n, x;
  scanf("%d", &x);
  if (x == 3) {
    printf("5\n");
    return 0;
  }
  for (n = 1;; n += 2) {
    int tn = (n + 1) / 2;
    if (tn * tn + (tn - 1) * (tn - 1) >= x) {
      printf("%d\n", n);
      break;
    }
  }
  return 0;
}

```