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

public class Main {
    static int lis(int[] a, int n)
    {
        int lis = 0;
        int[] L = new int[n];
        for(int i = 0; i < n; ++i)
        {
            int cur_L = 1;
            for(int j = 0; j < i; ++j)
                if(a[j] < a[i])
                    cur_L = Math.max(cur_L, L[j] + 1);
            L[i] = cur_L;
            lis = Math.max(lis, cur_L);
        }
        return lis;
    }
    static int lds(int[] a, int n)
    {
        int lis = 0;
        int[] L = new int[n];
        for(int i = 0; i < n; ++i)
        {
            int cur_L = 1;
            for(int j = 0; j < i; ++j)
                if(a[j] > a[i])
                    cur_L = Math.max(cur_L, L[j] + 1);
            L[i] = cur_L;
            lis = Math.max(lis, cur_L);
        }
        return lis;
    }
    public static void main(String[] args) throws Throwable {
        MyScanner sc = new MyScanner();
        PrintWriter pw = new PrintWriter(System.out);

//        for(int n=1;n<=10;n++) {
        int n = sc.nextInt();
            int a[] = new int[n];
//            for (int i = 0; i < n; i++) {
//                a[i] = i + 1;
//            }
//
//            int best[] = a.clone();
            int bstL=(int)1e6,bstR=(int)1e6;
            for(int LIS=1;LIS<=n;LIS++){
                int LDS=(n+LIS-1)/LIS;
//                System.err.println(LIS+" " +LDS);
                if(LIS+LDS<bstR+bstL){
                    bstL=LIS;
                    bstR=LDS;
                }
            }
            int[] mine = new int[n];

            ArrayList<Integer>arrayList[]=new ArrayList[bstL];
            for (int i =0;i<bstL;i++)arrayList[i]=new ArrayList<>();
            for(int i=0;i<n;i++){
                arrayList[Math.min(bstL-1,i/bstR)].add(i+1);
            }
            for(ArrayList<Integer> aa:arrayList) {
//                System.err.println(aa);
                Collections.reverse(aa);
            }
//            System.err.println("asdfadsf");
            ArrayList<Integer>last=new ArrayList<>();
            for(ArrayList<Integer> aa:arrayList)
                for(int i:aa)
                    last.add(i);
            for(int i = 0; i < n; i++)
                mine[i]=last.get(i);
            for(int i = 0; i < n; i++){
                if(i > 0) pw.print(" ");
                pw.print(mine[i]);
            }
            pw.println();
//            int bst = 100;
//            System.err.println(Arrays.toString(mine));
//            do {
//                if (lis(a, n) + lds(a, n) < bst) {
//                    bst = lis(a, n) + lds(a, n);
//                    best = a.clone();
//                }
//            } while (next_permutation(a));

//            System.err.println(Arrays.toString(best));
//            System.err.println(lis(best, n) + " " + lds(best, n)+" "+(lis(best, n) + lds(best, n)) + " " + (lis(mine, n) + lds(mine, n)));
//        }
        pw.flush();
        pw.close();
    }

    static boolean next_permutation(int[] A) {
        for (int a = A.length - 2; a >= 0; --a) {
            if (A[a] < A[a + 1]) {
                for (int b = A.length - 1;; --b) {
                    if (A[b] > A[a]) {
                        int t = A[a];
                        A[a] = A[b];
                        A[b] = t;
                        for (++a, b = A.length - 1; a < b; ++a, --b) {
                            t = A[a];
                            A[a] = A[b];
                            A[b] = t;
                        }
                        return true;
                    }
                }
            }
        }
        return false;
    }
    static class MyScanner {
        BufferedReader br;
        StringTokenizer st;

        public MyScanner() {
            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;
        }
    }
}