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.lang.annotation.Retention;
import java.util.*;
import java.math.BigInteger;
import java.util.Map.Entry;

import static java.lang.Math.*;

public class C extends PrintWriter {

    int inc(int... p) {
        int n = p.length;
        int[] d = new int[n];

        int max = 1;

        for (int i = 0; i < n; i++) {
            d[i] = 1;

            for (int j = 0; j < i; j++) {
                if (p[j] < p[i]) {
                    d[i] = max(d[i], d[j] + 1);
                }
            }

            max = max(max, d[i]);
        }

        return max;
    }

    int dec(int... p) {
        int n = p.length;
        int[] d = new int[n];

        int max = 1;

        for (int i = 0; i < n; i++) {
            d[i] = 1;

            for (int j = 0; j < i; j++) {
                if (p[j] > p[i]) {
                    d[i] = max(d[i], d[j] + 1);
                }
            }

            max = max(max, d[i]);
        }

        return max;
    }

    int[] solve(int n) {
        int minVal = 0;
        int minSum = 2 * (n + 3);

        for (int lis = 1; lis <= n; lis++) {
            int q = n / lis;
            int r = n % lis;

            int lds = q + ((r > 0) ? 1 : 0);

            int cur = lis + lds;

            if (cur < minSum) {
                minSum = cur;
                minVal = lis;
            }

        }

        int lis = minVal;
        int q = n / lis;
        int r = n % lis;

        int lds = q + ((r > 0) ? 1 : 0);

        int x = lis - r, y = r;

        if (r == 0) {
            x = lis;
            y = 0;
        }

        int p = 0;

        int[] ans = new int[n];
        int s = 0;

        while (--x >= 0) {
            int len = q;

            for (int i = len; i >= 1; i--) {
                ans[s++] = p + i;
            }

            p += len;
        }

        while (--y >= 0) {
            int len = q + 1;
            for (int i = len; i >= 1; i--) {
                ans[s++] = p + i;
            }
            p += len;
        }

        return ans;
    }
//
//    int[] bf(int n) {
//        int[] ans = new int[n];
//        int min = 2 * (n + 3);
//
//        for (Permutation p = new Permutation(n); p != null; p = p.next()) {
//            int cur = inc(p.toArray()) + dec(p.toArray());
//
//            if (cur < min) {
//                min = cur;
//                ans = p.toArray();
//            }
//        }
//        return ans;
//
//    }

    void run() {
        int n = nextInt();
        int[] p = solve(n);

        for (int i = 0; i < n; i++) {
            print(p[i]);
            print(' ');
        }

        // println();
        // println(inc(p) + dec(p));

        // int[] q = bf(n);

        // for (int i = 0; i < n; i++) {
        // print(q[i]);
        // print(' ');
        // }
        // println();
        // println(inc(q) + dec(q));
        // flush();
    }

    boolean skip() {
        while (hasNext()) {
            next();
        }
        return true;
    }

    int[][] nextMatrix(int n, int m) {
        int[][] matrix = new int[n][m];
        for (int i = 0; i < n; i++)
            for (int j = 0; j < m; j++)
                matrix[i][j] = nextInt();
        return matrix;
    }

    String next() {
        while (!tokenizer.hasMoreTokens())
            tokenizer = new StringTokenizer(nextLine());
        return tokenizer.nextToken();
    }

    boolean hasNext() {
        while (!tokenizer.hasMoreTokens()) {
            String line = nextLine();
            if (line == null) {
                return false;
            }
            tokenizer = new StringTokenizer(line);
        }
        return true;
    }

    int[] nextArray(int n) {
        int[] array = new int[n];
        for (int i = 0; i < n; i++) {
            array[i] = nextInt();
        }
        return array;
    }

    long[] nextLongArray(int n) {
        long[] array = new long[n];
        for (int i = 0; i < n; i++) {
            array[i] = nextLong();
        }
        return array;
    }

    int nextInt() {
        return Integer.parseInt(next());
    }

    long nextLong() {
        return Long.parseLong(next());
    }

    double nextDouble() {
        return Double.parseDouble(next());
    }

    String nextLine() {
        try {
            return reader.readLine();
        } catch (IOException err) {
            return null;
        }
    }

    public C(OutputStream outputStream) {
        super(outputStream);
    }

    static BufferedReader reader;
    static StringTokenizer tokenizer = new StringTokenizer("");
    static Random rnd = new Random();
    static boolean OJ;

    public static void main(String[] args) throws IOException {
        OJ = System.getProperty("ONLINE_JUDGE") != null;
        C solution = new C(System.out);
        if (OJ) {
            reader = new BufferedReader(new InputStreamReader(System.in));
            solution.run();
        } else {
            reader = new BufferedReader(new FileReader(new File(C.class.getName() + ".txt")));
            long timeout = System.currentTimeMillis();
            while (solution.hasNext()) {
                solution.run();
                solution.println();
                solution.println("----------------------------------");
            }
            solution.println("time: " + (System.currentTimeMillis() - timeout));
        }
        solution.close();
        reader.close();
    }
}