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.
n = int(raw_input())
num_arr = range(1, n + 1)

def solve():
	if (n == 1): return ["1"]

	chunksize = decideChunkSize()
	# print chunksize
	ptr1_start = n - chunksize
	ptr1 = n - chunksize
	result = []
	
	num_chunk = n / chunksize
	# import pdb; pdb.set_trace()
	while (num_chunk > 0):
		for j in range(chunksize):
			result.append(str(num_arr[ptr1]))
			ptr1 += 1
		ptr1_start -= chunksize
		ptr1 = ptr1_start
		num_chunk -= 1

	# import pdb; pdb.set_trace()
	ptr1 = 0
	last_idx = n - (n / chunksize) * chunksize
	while (ptr1 < last_idx):
		result.append(str(num_arr[ptr1]))
		ptr1 += 1
	return result



def decideChunkSize():
	current_min = 987654321
	current_min_chunk = -1
	chunksize = 1
	
	while (chunksize <= n):
		expected_value = n / chunksize + chunksize
		
		if (n % chunksize > 0):
			expected_value += 1

		if (expected_value <= current_min):
			current_min = expected_value
			current_min_chunk = chunksize

		chunksize += 1

	return current_min_chunk

# solve()
print " ".join(solve())




# 	if (n % 2 == 1):
# 		return return_odd(num_arr)
# 	else:
# 		return return_even(num_arr)

# def return_odd(num_arr):
# 	ptr1 = n - 1
# 	ptr2 = n - 2
# 	ptr3 = n - 3
# 	result = []
# 	while (ptr3 >= 0):
# 		result.append(str(num_arr[ptr3]))
# 		result.append(str(num_arr[ptr2]))
# 		result.append(str(num_arr[ptr1]))

# 		ptr1 -= 3
# 		ptr2 -= 3
# 		ptr3 -= 3

# 	if (ptr2 >= 0):
# 		result.append(str(num_arr[ptr2]))
		
# 	if (ptr1 >= 0):
# 		result.append(str(num_arr[ptr1]))

# 	return result


# def return_even(num_arr):
# 	ptr1 = n - 1
# 	ptr2 = n - 2
	
# 	result = []
# 	while (ptr2 >= 0):

# 		result.append(str(num_arr[ptr2]))
# 		result.append(str(num_arr[ptr1]))

# 		ptr1 -= 2
# 		ptr2 -= 2

# 	return result


# print " ".join(solve())
