You are given an integer N. Consider all possible segments on the coordinate axis with endpoints at integer points with coordinates between 0 and N, inclusive; there will be <image> of them.

You want to draw these segments in several layers so that in each layer the segments don't overlap (they might touch at the endpoints though). You can not move the segments to a different location on the coordinate axis. 

Find the minimal number of layers you have to use for the given N.

Input

The only input line contains a single integer N (1 ≤ N ≤ 100).

Output

Output a single integer - the minimal number of layers required to draw the segments for the given N.

Examples

Input

2


Output

2


Input

3


Output

4


Input

4


Output

6

Note

As an example, here are the segments and their optimal arrangement into layers for N = 4.

<image>
import java.io.*;
import java.util.*;

public class Main {
    
    public static void main(String[] args) throws IOException {
        Reader.init(System.in);
        int n = Reader.nextInt();
        layers = new ArrayList<>();
        layers.add(new ArrayList<>());
        layers.get(0).add(new Segment(0, 1));

        for (int i = 0; i < n; i++) {
            for (int j = 1; j < n + 1; j++) {
                if (i + j > n) break;
                if (i == 0 && j == 1) continue;
                canGoInLayer(new Segment(i, j));
            }
        }

        System.out.println(layers.size());
    }

    private static ArrayList<ArrayList<Segment>> layers;

    private static void canGoInLayer(Segment segment){
        for (ArrayList<Segment> layer: layers) {
            boolean can = true;
            for (Segment segment1: layer)
                if (segment.start < segment1.start + segment1.length) can = false;

            if (can){
                layer.add(segment);
                return;
            }
        }
        ArrayList<Segment> newLayer = new ArrayList<>();
        newLayer.add(segment);
        layers.add(newLayer);
    }
}

class Segment{
    int start, length;
    Segment(int start, int length){
        this.start = start;
        this.length = length;
    }
}


/**
 * Reader class based on the article at "https://www.cpe.ku.ac.th/~jim/java-io.html"
 * */
class Reader{
    private static BufferedReader reader;
    private static StringTokenizer tokenizer;
    static void init(InputStream inputStream){
        reader = new BufferedReader(new InputStreamReader(inputStream));
        tokenizer = new StringTokenizer("");
    }
    static String next() throws IOException {
        String read;
        while (!tokenizer.hasMoreTokens()){
            read = reader.readLine();
            if (read == null || read.equals(""))
                return "-1";
            tokenizer = new StringTokenizer(read);
        }

        return tokenizer.nextToken();
    }
    static int nextInt() throws IOException{
        return Integer.parseInt(next());
    }

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

    //Get a whole line.
//    static String line() throws IOException{
//        return reader.readLine();
//    }
//
//    static double nextDouble() throws IOException{return Double.parseDouble(next());}
}



