Fox Ciel has n boxes in her room. They have the same size and weight, but they might have different strength. The i-th box can hold at most xi boxes on its top (we'll call xi the strength of the box). 

Since all the boxes have the same size, Ciel cannot put more than one box directly on the top of some box. For example, imagine Ciel has three boxes: the first has strength 2, the second has strength 1 and the third has strength 1. She cannot put the second and the third box simultaneously directly on the top of the first one. But she can put the second box directly on the top of the first one, and then the third box directly on the top of the second one. We will call such a construction of boxes a pile.

<image>

Fox Ciel wants to construct piles from all the boxes. Each pile will contain some boxes from top to bottom, and there cannot be more than xi boxes on the top of i-th box. What is the minimal number of piles she needs to construct?

Input

The first line contains an integer n (1 ≤ n ≤ 100). The next line contains n integers x1, x2, ..., xn (0 ≤ xi ≤ 100).

Output

Output a single integer — the minimal possible number of piles.

Examples

Input

3
0 0 10


Output

2


Input

5
0 1 2 3 4


Output

1


Input

4
0 0 0 0


Output

4


Input

9
0 1 0 2 0 1 1 2 10


Output

3

Note

In example 1, one optimal way is to build 2 piles: the first pile contains boxes 1 and 3 (from top to bottom), the second pile contains only box 2.

<image>

In example 2, we can build only 1 pile that contains boxes 1, 2, 3, 4, 5 (from top to bottom).

<image>
/*
* To change this template, choose Tools | Templates and open the template in
* the editor.
*/

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.text.ParseException;
import java.util.*;

/**
 * @author Artem_Mikhalevitch
 */
public class Task extends ASolver {

    int n;
    int[] x;

    public static void main(String[] args) throws ParseException {

        Task task = new Task();
        task.init();
        if (task.readData()) {
            //task.solve();
            task.writeData("" + task.solve());
        }
    }

    @Override
    public void init() {
        super.init();
    }

    @Override
    public boolean readData() {
        try {
            n = nextInt();
            x = new int[n];
            for (int i = 0; i < n; i++) {
                x[i] = nextInt();
            }
        } catch (Exception ex) {
            System.out.println(ex.getCause());
            System.out.println(ex.getMessage());
            return false;
        }
        return true;
    }


    public String solve() {
        int count = 0;
        x=ArraySorter.sortIntArray(x);
        count = bsearch(1, n);
        return ""+count;
    }

    public int bsearch(int left, int right) {
        if (left == right) {
            return left;
        }
        if (left == right - 1) {
            return check(left) ? left : right;
        }
        int middle = (left + right) % 2 == 0 ? (left + right) / 2 : (left + right) / 2 + 1;
        if (check(middle)) {
            right = middle;
        } else {
            left = middle;
        }
        return bsearch(left, right);
    }

    public boolean check(int k) {
        int l = x.length;
        for (int i = 0; i < l; i++) {
            if (x[i] < i / k) {
                return false;
            }
        }
        return true;
    }
}

abstract class ASolver {

    protected StringTokenizer tokens;
    protected BufferedReader input;
    protected PrintWriter output;

    public void init() {
        input = new BufferedReader(new InputStreamReader(System.in));
    }

    public abstract boolean readData();

    public void writeData(String result) {
        System.out.println(result);
    }

    public void writeData(int result) {
        System.out.println(result);
    }

    public void writeData(long result) {
        System.out.println(result);
    }

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

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

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

    public String next() throws IOException {
        while (tokens == null || !tokens.hasMoreTokens()) {
            tokens = new StringTokenizer(input.readLine());
        }
        return tokens.nextToken();
    }

    public String nextLine() throws IOException {
        while (tokens == null || !tokens.hasMoreTokens()) {
            tokens = new StringTokenizer(input.readLine(), "\n");
        }
        return tokens.nextToken();
    }

    public long infinityImitator(long a, long b) {
        if (a == Long.MIN_VALUE) {
            return Long.MIN_VALUE;
        } else {
            return a + b;
        }
    }

    public int infinityImitator(int a, int b) {
        if (a == Integer.MIN_VALUE) {
            return Integer.MIN_VALUE;
        } else {
            return a + b;
        }
    }

    /*
     * public long max(long... a) { long result = Long.MIN_VALUE; for (int i =
     * 0; i < a.length; i++) { result = Math.max(result, a[i]); } return result;
     * }
     */
    public int indexMax(int... a) {
        int result = 0;
        int index = -1;
        int length = a.length;
        for (int i = 0; i < length; i++) {
            if (a[i] > result) {
                result = a[i];
                index = i;
            }
        }
        return index;
    }

    public int indexMax(long... a) {
        long result = 0;
        int index = -1;
        int length = a.length;
        for (int i = 0; i < length; i++) {
            if (a[i] > result) {
                result = a[i];
                index = i;
            }
        }
        return index;
    }

    public int max(int... a) {
        int result = Integer.MIN_VALUE;
        for (int i = 0; i < a.length; i++) {
            result = Math.max(result, a[i]);
        }
        return result;
    }

    public long max(long... a) {
        long result = Integer.MIN_VALUE;
        for (int i = 0; i < a.length; i++) {
            result = Math.max(result, a[i]);
        }
        return result;
    }
}

class ArraySorter {

    public static int[] sortIntArray(int[] array) {

        int length = array.length;
        if (length == 1) {
            return array;
        } else if (length == 2) {
            return array[0] < array[1] ? array : new int[]{array[1], array[0]};
        } else {
            int l1 = length / 2, l2 = length - l1;
            int[] array1 = new int[l1];
            int[] array2 = new int[l2];
            System.arraycopy(array, 0, array1, 0, l1);
            System.arraycopy(array, l1, array2, 0, l2);
            array1 = sortIntArray(array1);
            array2 = sortIntArray(array2);
            return splitSortedIntArrays(array1, array2);
        }
    }


    private static int[] splitSortedIntArrays(int[] mas1, int[] mas2) {
        int l1 = mas1.length;
        int l2 = mas2.length;
        int[] result = new int[l1 + l2];
        int i1 = 0, i2 = 0, i;
        for (i = 0; i1 < l1 && i2 < l2; i++) {
            if (mas1[i1] <= mas2[i2]) {
                result[i] = mas1[i1++];
            } else {
                result[i] = mas2[i2++];
            }
        }
        for (int j = i; i1 < l1; j++) {
            result[j] = mas1[i1++];
        }
        for (int j = i; i2 < l2; j++) {
            result[j] = mas2[i2++];
        }
        return result;
    }

    private static double[] splitSortedDoubleArrays(double[] mas1, double[] mas2) {
        int l1 = mas1.length;
        int l2 = mas2.length;
        double[] result = new double[l1 + l2];
        int i1 = 0, i2 = 0;
        int i = 0;
        for (i = 0; i1 < l1 && i2 < l2; i++) {
            if (mas1[i1] <= mas2[i2]) {
                result[i] = mas1[i1++];
            } else {
                result[i] = mas2[i2++];
            }
        }
        for (int j = i; i1 < l1; j++) {
            result[j] = mas1[i1++];
        }
        for (int j = i; i2 < l2; j++) {
            result[j] = mas2[i2++];
        }
        return result;
    }
}
/*class ABSComparator implements Comparator<Pair> {

    /**
     * Compares its two arguments for order. Returns a negative integer, zero,
     * or a positive integer as the first argument is less than, equal to, or
     * greater than the second.
     */
/*@Override
public int compare(Pair o1, Pair o2) {
   if (o1.getA() == o2.getA()) {
       return o2.getB() - o1.getB();
   }
   return o1.getA() - o2.getA();
}
}     */