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.
							import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.InputMismatchException;
import java.util.Iterator;
import java.util.Stack;



											public class Solution1 implements Runnable
											{
												static final long MAX = 464897L;
												static class InputReader
												{
													private InputStream stream;
													private byte[] buf = new byte[1024];
													private int curChar;
													private int numChars;
													private SpaceCharFilter filter;
													private BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
											 
													public InputReader(InputStream stream)
													{
														this.stream = stream;
													}
													
													public int read()
													{
														if (numChars==-1) 
															throw new InputMismatchException();
														
														if (curChar >= numChars)
														{
															curChar = 0;
															try 
															{
																numChars = stream.read(buf);
															}
															catch (IOException e)
															{
																throw new InputMismatchException();
															}
															
															if(numChars <= 0)				
																return -1;
														}
														return buf[curChar++];
													}
												 
													public String nextLine()
													{
														String str = "";
											            try
											            {
											                str = br.readLine();
											            }
											            catch (IOException e)
											            {
											                e.printStackTrace();
											            }
											            return str;
													}
													public int nextInt()
													{
														int c = read();
														
														while(isSpaceChar(c)) 
															c = read();
														
														int sgn = 1;
														
														if (c == '-') 
														{
															sgn = -1;
															c = read();
														}
														
														int res = 0;
														do 
														{
															if(c<'0'||c>'9') 
																throw new InputMismatchException();
															res *= 10;
															res += c - '0';
															c = read();
														}
														while (!isSpaceChar(c)); 
														
														return res * sgn;
													}
													
													public long nextLong() 
													{
														int c = read();
														while (isSpaceChar(c))
															c = read();
														int sgn = 1;
														if (c == '-') 
														{
															sgn = -1;
															c = read();
														}
														long res = 0;
														
														do 
														{
															if (c < '0' || c > '9')
																throw new InputMismatchException();
															res *= 10;
															res += c - '0';
															c = read();
														}
														while (!isSpaceChar(c));
															return res * sgn;
													}
													
													public double nextDouble() 
													{
														int c = read();
														while (isSpaceChar(c))
															c = read();
														int sgn = 1;
														if (c == '-') 
														{
															sgn = -1;
															c = read();
														}
														double res = 0;
														while (!isSpaceChar(c) && c != '.') 
														{
															if (c == 'e' || c == 'E')
																return res * Math.pow(10, nextInt());
															if (c < '0' || c > '9')
																throw new InputMismatchException();
															res *= 10;
															res += c - '0';
															c = read();
														}
														if (c == '.') 
														{
															c = read();
															double m = 1;
															while (!isSpaceChar(c)) 
															{
																if (c == 'e' || c == 'E')
																	return res * Math.pow(10, nextInt());
																if (c < '0' || c > '9')
																	throw new InputMismatchException();
																m /= 10;
																res += (c - '0') * m;
																c = read();
															}
														}
														return res * sgn;
													}
													
													public String readString() 
													{
														int c = read();
														while (isSpaceChar(c))
															c = read();
														StringBuilder res = new StringBuilder();
														do 
														{
															res.appendCodePoint(c);
															c = read();
														} 
														while (!isSpaceChar(c));
														
														return res.toString();
													}
												 
													public boolean isSpaceChar(int c) 
													{
														if (filter != null)
															return filter.isSpaceChar(c);
														return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
													}
												 
													public String next() 
													{
														return readString();
													}
													
													public interface SpaceCharFilter 
													{
														public boolean isSpaceChar(int ch);
													}
												}
											 	
												public static void main(String args[]) throws Exception
												{
													new Thread(null, new Solution1(),"Solution",1<<26).start();
												}	
												public static int gcd(int a, int b)
											    {
											        if (a == 0)
											            return b;
											         
											        return gcd(b%a, a);
											    }
												int lcm(int a, int b)
												{
												    return (a*b)/gcd(a, b);
												}
												ArrayList<Integer> adj[];
												static long MOD = 1000000007;
												int[] dx = {1,-1,0,0};
												int[] dy = {0,0,1,-1};
												int MAXN = 1000005;
												public void run() 
												{
													
														//InputReader sc= new InputReader(new FileInputStream("input.txt"));
														//PrintWriter w= new PrintWriter(new FileWriter("output.txt"));
														InputReader sc = new InputReader(System.in);
												        PrintWriter w = new PrintWriter(System.out);
												        int n = sc.nextInt();
												        int curr = (int)Math.sqrt(n);
												        int[] ans = new int[n + 1];
												        if(n == 1) {
												        	w.println("1");
												        	w.close();
												        	System.exit(0);
												        }
												        if(n == 2) {
												        	w.println("2 1");
												        	w.close();
												        	System.exit(0);
												        }
												        if(n == 4) {
												        	w.println("3 4 1 2");
												        	w.close();
												        	System.exit(0);
												        }
												        int x = 1;
												        if(n % curr != 0) {
												        	for(int i = n % curr;i >= 1;i--) {
												        		ans[i] = x;
												        		x++;
												        	}
												        }
												        int temp = x + curr - 1;
												        int start = temp;
												        for(int i = 1;i <= curr;i++) {
												        	
												        	for(int idx = x;idx <= n;idx += curr) {
												        		ans[idx] = temp;
												        		temp += curr;
												        	}
												        	temp = start - i;
												        	x++;
												        }
												        for(int i = 1;i <= n;i++) {
												        	w.print(ans[i] + " ");
												        }
												        w.close();			
													
												}
												
												boolean[] prime;
												void seive() {
													prime = new boolean[1000005];
													Arrays.fill(prime, true);
													prime[1] = false;
													for(int i = 2;i < prime.length;i++) {
														if(prime[i]) {
															for(int j = 2*i;j < prime.length;j+=i) {
																prime[j] = false;
															}
														}
													}
												}
												static class Pair implements Comparable<Pair>{
													int a;
													long b;
													int c;
													
													Pair(int a,long b,int x){
														this.a  =a;
														this.b = b;
														this.c = x;
													}
													Pair(){}	
													public boolean equals(Object o)
													{
														Pair p = (Pair)o;
														return this.a == p.a && this.b == p.b;
													}
													
													public int compareTo(Pair p){
														
														return Long.compare(this.b,p.b);
													}
													public int hashCode()
													{
														return new Long(a).hashCode()*31 + new Long(b).hashCode()*2 + new Long(a).hashCode() * 3;
													}

												}
												
								}