Vanya got n cubes. He decided to build a pyramid from them. Vanya wants to build the pyramid as follows: the top level of the pyramid must consist of 1 cube, the second level must consist of 1 + 2 = 3 cubes, the third level must have 1 + 2 + 3 = 6 cubes, and so on. Thus, the i-th level of the pyramid must have 1 + 2 + ... + (i - 1) + i cubes.

Vanya wants to know what is the maximum height of the pyramid that he can make using the given cubes.

Input

The first line contains integer n (1 ≤ n ≤ 104) — the number of cubes given to Vanya.

Output

Print the maximum possible height of the pyramid in the single line.

Examples

Input

1


Output

1


Input

25


Output

4

Note

Illustration to the second sample: 

<image>
import java.util.*;
import java.io.*;
import java.awt.Point;
import java.math.BigDecimal;
import java.math.BigInteger;

import static java.lang.Math.*;

// Solution is at the bottom of code

public class A implements Runnable{
    
    final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;
    
    BufferedReader in;
    OutputWriter out;
    StringTokenizer tok = new StringTokenizer("");
    
    public static void main(String[] args){
        new Thread(null, new A(), "", 128 * (1L << 20)).start();
    }
    
    /////////////////////////////////////////////////////////////////////
    
    void init() throws FileNotFoundException{
        Locale.setDefault(Locale.US);
        
        if (ONLINE_JUDGE){
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new OutputWriter(System.out);
        }else{
            in = new BufferedReader(new FileReader("input.txt"));
            out = new OutputWriter("output.txt");
        }
    }
    
    ////////////////////////////////////////////////////////////////
    
    long timeBegin, timeEnd;

    void time(){
        timeEnd = System.currentTimeMillis();
        System.err.println("Time = " + (timeEnd - timeBegin));
    }
    
    void debug(Object... objects){
        if (ONLINE_JUDGE){
            for (Object o: objects){
                System.err.println(o.toString());
            }
        }
    }
    
    /////////////////////////////////////////////////////////////////////
    
    public void run(){
        try{
            timeBegin = System.currentTimeMillis();
            Locale.setDefault(Locale.US);
            
            init();
            solve();
            
            out.close();
            time();
        }catch (Exception e){
            e.printStackTrace(System.err);
            System.exit(-1);
        }
    }
    
    /////////////////////////////////////////////////////////////////////
    
    String delim = " ";
    
    String readString() throws IOException{
        while(!tok.hasMoreTokens()){
            try{
                tok = new StringTokenizer(in.readLine());
            }catch (Exception e){
                return null;
            }
        }
        
        return tok.nextToken(delim);
    }
    
    String readLine() throws IOException{
        return in.readLine();
    }
    
    /////////////////////////////////////////////////////////////////
    
    final char NOT_A_SYMBOL = '\0';
    
    char readChar() throws IOException{
        int intValue = in.read();
        
        if (intValue == -1){
            return NOT_A_SYMBOL;
        }
        
        return (char) intValue;
    }
    
    char[] readCharArray() throws IOException{
        return readLine().toCharArray();
    }
    
    /////////////////////////////////////////////////////////////////
    
    int readInt() throws IOException {
        return Integer.parseInt(readString());
    }
    
    int[] readIntArray(int size) throws IOException {
        int[] array = new int[size];
        
        for (int index = 0; index < size; ++index){
            array[index] = readInt();
        }
        
        return array;
    }
    
    int[] readSortedIntArray(int size) throws IOException {
        Integer[] array = new Integer[size];
        
        for (int index = 0; index < size; ++index) {
            array[index] = readInt();
        }
        Arrays.sort(array);
        
        int[] sortedArray = new int[size];
        for (int index = 0; index < size; ++index) {
            sortedArray[index] = array[index];
        }
        
        return sortedArray;
    }
    
    int[] readIntArrayWithDecrease(int size) throws IOException {
        int[] array = readIntArray(size);
        
        for (int i = 0; i < size; ++i) {
            array[i]--;
        }
        
        return array;
    }
    
    ///////////////////////////////////////////////////////////////////
    
    int[][] readIntMatrix(int rowsCount, int columnsCount) throws IOException {
        int[][] matrix = new int[rowsCount][];
        
        for (int rowIndex = 0; rowIndex < rowsCount; ++rowIndex) {
            matrix[rowIndex] = readIntArray(columnsCount);
        }
        
        return matrix;
    }
    
    int[][] readIntMatrixWithDecrease(int rowsCount, int columnsCount) throws IOException {
        int[][] matrix = new int[rowsCount][];
        
        for (int rowIndex = 0; rowIndex < rowsCount; ++rowIndex) {
            matrix[rowIndex] = readIntArrayWithDecrease(columnsCount);
        }
        
        return matrix;
    }
    
    ///////////////////////////////////////////////////////////////////
    
    long readLong() throws IOException{
        return Long.parseLong(readString());
    }
    
    long[] readLongArray(int size) throws IOException{
        long[] array = new long[size];
        
        for (int index = 0; index < size; ++index){
            array[index] = readLong();
        }
        
        return array;
    }
    
    ////////////////////////////////////////////////////////////////////
    
    double readDouble() throws IOException{
        return Double.parseDouble(readString());
    }
    
    double[] readDoubleArray(int size) throws IOException{
        double[] array = new double[size];
        
        for (int index = 0; index < size; ++index){
            array[index] = readDouble();
        }
        
        return array;
    }
    
    ////////////////////////////////////////////////////////////////////
        
    BigInteger readBigInteger() throws IOException {
        return new BigInteger(readString());
    }
    
    BigDecimal readBigDecimal() throws IOException {
        return new BigDecimal(readString());
    }
    
    /////////////////////////////////////////////////////////////////////
    
    Point readPoint() throws IOException{
        int x = readInt();
        int y = readInt();
        return new Point(x, y);
    }
    
    Point[] readPointArray(int size) throws IOException{
        Point[] array = new Point[size];
        
        for (int index = 0; index < size; ++index){
            array[index] = readPoint();
        }
        
        return array;
    }
    
    /////////////////////////////////////////////////////////////////////
    
    List<Integer>[] readGraph(int vertexNumber, int edgeNumber)
    throws IOException{
        @SuppressWarnings("unchecked")
        List<Integer>[] graph = new List[vertexNumber];
        
        for (int index = 0; index < vertexNumber; ++index){
            graph[index] = new ArrayList<Integer>();
        }
        
        while (edgeNumber-- > 0){
            int from = readInt() - 1;
            int to = readInt() - 1;
            
            graph[from].add(to);
            graph[to].add(from);
        }
        
        return graph;
    }
    
    /////////////////////////////////////////////////////////////////////
    
    static class IntIndexPair {
        
        static Comparator<IntIndexPair> increaseComparator = new Comparator<IntIndexPair>() {
            
            @Override
            public int compare(IntIndexPair indexPair1, IntIndexPair indexPair2) {
                int value1 = indexPair1.value;
                int value2 = indexPair2.value;
                
                if (value1 != value2) return value1 - value2;
                
                int index1 = indexPair1.index;
                int index2 = indexPair2.index;
                
                return index1 - index2;
            }
        };
        
        static Comparator<IntIndexPair> decreaseComparator = new Comparator<IntIndexPair>() {
            
            @Override
            public int compare(IntIndexPair indexPair1, IntIndexPair indexPair2) {
                int value1 = indexPair1.value;
                int value2 = indexPair2.value;
                
                if (value1 != value2) return -(value1 - value2);
                
                int index1 = indexPair1.index;
                int index2 = indexPair2.index;
                
                return index1 - index2;
            }
        };
        
        int value, index;

        public IntIndexPair(int value, int index) {
            super();
            this.value = value;
            this.index = index;
        }       
        
        public int getRealIndex() {
            return index + 1;
        }
    }
    
    IntIndexPair[] readIntIndexArray(int size) throws IOException {
        IntIndexPair[] array = new IntIndexPair[size];
        
        for (int index = 0; index < size; ++index) {
            array[index] = new IntIndexPair(readInt(), index);
        }
        
        return array;
    }
    
    /////////////////////////////////////////////////////////////////////
    
    static class OutputWriter extends PrintWriter {

        final int DEFAULT_PRECISION = 12;
        
        protected int precision;
        protected String format, formatWithSpace;
        
        {
            precision = DEFAULT_PRECISION;
            
            format = createFormat(precision);
            formatWithSpace = format + " ";
        }
        
        public OutputWriter(OutputStream out) {
            super(out);
        }

        public OutputWriter(String fileName) throws FileNotFoundException {
            super(fileName);
        }
        
        public int getPrecision() {
            return precision;
        }

        public void setPrecision(int precision) {
            precision = max(0, precision);
            this.precision = precision;
            
            format = createFormat(precision);
            formatWithSpace = format + " ";
        }
        
        private String createFormat(int precision){
            return "%." + precision + "f";
        }
        
        @Override
        public void print(double d){
            printf(format, d);
        }
        
        public void printWithSpace(double d){
            printf(formatWithSpace, d);
        }

        public void printAll(double...d){
            for (int i = 0; i < d.length - 1; ++i){
                printWithSpace(d[i]);
            }
            
            print(d[d.length - 1]);
        }
        
        @Override
        public void println(double d){
            printlnAll(d);
        }
        
        public void printlnAll(double... d){
            printAll(d);
            println();
        }
    }
    
    /////////////////////////////////////////////////////////////////////
    
    static final int[][] steps = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}}; 
    static final int[][] steps8 = {
            {-1, 0}, {1, 0}, {0, -1}, {0, 1},
            {-1, -1}, {1, 1}, {1, -1}, {-1, 1}
    };
    
    static final boolean check(int index, int lim){
        return (0 <= index && index < lim);
    }
    
    /////////////////////////////////////////////////////////////////////
    
    static final boolean checkBit(int mask, int bit){
        return (mask & (1 << bit)) != 0;
    }
    
    /////////////////////////////////////////////////////////////////////
    
    static final long getSum(int[] array) {
        long sum = 0;
        for (int value: array) {
            sum += value;
        }
        
        return sum;
    }
    
    static final Point getMinMax(int[] array) {
        int min = array[0];
        int max = array[0];
        
        for (int index = 0, size = array.length; index < size; ++index, ++index) {
            int value = array[index];
            
            if (index == size - 1) {
                min = min(min, value);
                max = max(max, value);
            } else {
                int otherValue = array[index + 1];
                
                if (value <= otherValue) {
                    min = min(min, value);
                    max = max(max, otherValue);
                } else {
                    min = min(min, otherValue);
                    max = max(max, value);
                }
            }
        }
        
        return new Point(min, max);
    }
    
    /////////////////////////////////////////////////////////////////////
    

    public void solve() throws IOException {
        int n = readInt();
		
		int height = 0;
		for (int index = 1, need = 1; need <= n; n -= need, need += (++index), ++height);
		
		out.println(height);
    }
}

