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.awt.color.*;
import java.util.*;


import java.awt.Point;
import java.math.*;
import java.io.*;
@SuppressWarnings("unused")
public class implementation {int[] b;	String g="";int c=0;int M=1000000000+7;ArrayList<Long> list=new ArrayList<Long>();String s;int[] size;int[] id;
int[]ab;int[] data;int mod=100000;LinkedList<Integer> queue=new LinkedList<Integer>();int dis=0;int max=0;ArrayList<Integer>[] arr;
	public static void main(String[] args) {
                new implementation().solve();
                                  }
	long[] fact;long[] inv;
            public void solve() {
           int n=sc.nextInt();
          int c=n;
          int ff=0;
        for(int i=1;i<=n;i++) {
        	if(i*i==n) {
        		ff=i;break;
        	}
        	if(i*i>n) {
        		ff=i-1;break;
        		
        	}
        }
        int y=n%ff;;
        int h=n/ff;
        StringBuilder sb =new StringBuilder();
               while(y--!=0) {
            	   int p=n;
            	   n=n-(h+1);
            	   for(int i=n+1;i<=p;i++)
            		   sb.append(Integer.toString(i)+" ");
            	   System.out.print(sb);
            	   sb.setLength(0);
               }
               
               while(n!=0) {
            	   int p=n;
            	   n=n-(h);
            	   for(int i=n+1;i<=p;i++)
            		   sb.append(Integer.toString(i)+" ");
            	   System.out.print(sb);
            	   sb.setLength(0);
               }
            	
            }

               
      public class Node{
	     long x;long color;long y;
	       Node par;
	        public Node(long a,long b,long c) {
	          	x=a;y=b;color=c;
		
	             }
                  }
              class sortbyweight implements Comparator<Node>{

				@Override
				public int compare(Node arg0, Node arg1) {
					// TODO Auto-generated method stub
					
					return (int)(arg0.color-arg1.color);
				}}
				
				 FastReader sc=new FastReader();
				 static class FastReader
				     {
				         BufferedReader br;
				         StringTokenizer st;
				  
				         public FastReader()
				         {
				             br = new BufferedReader(new
				                      InputStreamReader(System.in));
				         }
				  
				         String next()
				         {
				             while (st == null || !st.hasMoreElements())
				             {
				                 try
				                 {
				                     st = new StringTokenizer(br.readLine());
				                 }
				                 catch (IOException  e)
				                 {
				                     e.printStackTrace();
				                 }
				             }
				             return st.nextToken();
				         }
				  
				         int nextInt()
				         {
				             return Integer.parseInt(next());
				         }
				  
				         long nextLong()
				         {
				             return Long.parseLong(next());
				         }
				  
				         double nextDouble()
				         {
				             return Double.parseDouble(next());
				         }
				  
				         String nextLine()
				         {
				             String str = "";
				             try
				             {
				                 str = br.readLine();
				             }
				             catch (IOException e)
				             {
				                 e.printStackTrace();
				             }
				             return str;
				         }
				     }}
            	  
            	  