Mrs. Smith is trying to contact her husband, John Smith, but she forgot the secret phone number!

The only thing Mrs. Smith remembered was that any permutation of n can be a secret phone number. Only those permutations that minimize secret value might be the phone of her husband.

The sequence of n integers is called a permutation if it contains all integers from 1 to n exactly once.

The secret value of a phone number is defined as the sum of the length of the longest increasing subsequence (LIS) and length of the longest decreasing subsequence (LDS). 

A subsequence a_{i_1}, a_{i_2}, …, a_{i_k} where 1≤ i_1 < i_2 < … < i_k≤ n is called increasing if a_{i_1} < a_{i_2} < a_{i_3} < … < a_{i_k}. If a_{i_1} > a_{i_2} > a_{i_3} > … > a_{i_k}, a subsequence is called decreasing. An increasing/decreasing subsequence is called longest if it has maximum length among all increasing/decreasing subsequences.

For example, if there is a permutation [6, 4, 1, 7, 2, 3, 5], LIS of this permutation will be [1, 2, 3, 5], so the length of LIS is equal to 4. LDS can be [6, 4, 1], [6, 4, 2], or [6, 4, 3], so the length of LDS is 3.

Note, the lengths of LIS and LDS can be different.

So please help Mrs. Smith to find a permutation that gives a minimum sum of lengths of LIS and LDS.

Input

The only line contains one integer n (1 ≤ n ≤ 10^5) — the length of permutation that you need to build.

Output

Print a permutation that gives a minimum sum of lengths of LIS and LDS. 

If there are multiple answers, print any.

Examples

Input

4


Output

3 4 1 2


Input

2


Output

2 1

Note

In the first sample, you can build a permutation [3, 4, 1, 2]. LIS is [3, 4] (or [1, 2]), so the length of LIS is equal to 2. LDS can be ony of [3, 1], [4, 2], [3, 2], or [4, 1]. The length of LDS is also equal to 2. The sum is equal to 4. Note that [3, 4, 1, 2] is not the only permutation that is valid.

In the second sample, you can build a permutation [2, 1]. LIS is [1] (or [2]), so the length of LIS is equal to 1. LDS is [2, 1], so the length of LDS is equal to 2. The sum is equal to 3. Note that permutation [1, 2] is also valid.
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int dx[] = {1, -1, 0, 0};
const int dy[] = {0, 0, -1, 1};
char in() {
  static char buf[10001], *p1 = buf, *p2 = buf;
  return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 10000, stdin), p1 == p2)
             ? EOF
             : *p1++;
}
template <class Tp>
void read(register Tp &s) {
  s = 0;
  register bool neg = 0;
  register char c;
  while (!isdigit(c = in()))
    if (c == '-') neg = 1;
  while (s = (s << 3) + (s << 1) + c - 48, isdigit(c = in()))
    ;
  s = (neg ? -s : s);
}
template <class Tp>
void write(register Tp x) {
  if (x < 0) putchar('-'), x = -x;
  if (x > 9) write(x / 10);
  putchar(x % 10 + '0');
}
template <class Tp>
void print(const Tp &x, const char &end) {
  write(x);
  putchar(end);
}
template <class Tp>
Tp pow(register Tp x, register Tp p, const Tp &mod) {
  register Tp res = 1;
  for (; p; p >>= 1, x = (x * x) % mod)
    if (p & 1) res = (res * x) % mod;
  return res;
}
int comp(const double &x, const double &y) {
  const double d = x - y, eps = 1e-8;
  return (d <= eps && d >= -eps) ? 0 : (d > eps ? 1 : -1);
}
template <class Tp>
Tp sqr(const Tp &x) {
  return x * x;
}
template <class Tp>
Tp gcd(const Tp &x, const Tp &y) {
  return ((!y) ? x : gcd(y, x % y));
}
template <class Tp>
Tp inv(const Tp &x, const Tp &MOD) {
  return pow(x, MOD - 2, MOD);
}
template <class Tp>
Tp lowbit(const Tp &x) {
  return x & -x;
}
int n;
int main() {
  cin >> n;
  int s = sqrt(n) + 0.500;
  int num = n - s + 1;
  for (;;) {
    for (int i = (1); i <= (s); ++i) printf("%d ", num + i - 1);
    num -= s;
    if (num <= 0) {
      for (int i = (1); i <= (num + s - 1); ++i) printf("%d ", i);
      return 0;
    }
  }
  return 0;
}
