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.*;

import static java.lang.Integer.max;
import static java.lang.Long.max;

public class Main {

    int INF = (int) 1e9;
    long LNF = (long) 1e18;
    int mod = (int) (1e9 + 7);
    int day = 24 * 60 * 60;
    int n;
    int m;
    ArrayList<Integer> g[];

    public void solve() throws IOException {
        n = nextInt();
        event[] tt = new event[n * (n + 1)];
        int ind = 0;
        for (int i = 0; i <= n; i++) {
            for (int j = i + 1; j <= n; j++) {
                tt[ind] = new event(i, 1);
                ind++;
                tt[ind] = new event(j, -1);
                ind++;
            }
        }
        Arrays.sort(tt);
        int b = 0;
        int ans = 0;
        for (int i = 0; i < tt.length; i++) {
            b+= tt[i].t;
            ans = max(ans, b);
        }
        pw.print(ans);
    }

    class event implements Comparable<event> {
        int time;
        int t;

        public event(int time, int t) {
            this.t = t;
            this.time = time;
        }

        @Override
        public int compareTo(event o) {
            if (time != o.time) return time - o.time;
           return t - o.t;
        }
    }

    public void run() {
        try {
//            br = new BufferedReader(new FileReader("input.txt"));
//            pw = new PrintWriter(new FileWriter("output.txt"));
            br = new BufferedReader(new InputStreamReader(System.in));
            pw = new PrintWriter(new OutputStreamWriter(System.out));
//            br = new BufferedReader(new FileReader("movie.in"));
//            pw = new PrintWriter(new FileWriter("movie.out"));
            solve();
            pw.close();
        } catch (IOException e) {
            e.printStackTrace();
            System.exit(1);
        }
    }

    BufferedReader br;
    StringTokenizer in;
    PrintWriter pw;

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

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

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

    public static void main(String[] args) throws IOException {
        //Locale.setDefault(Locale.US);
        new Main().run();
    }
}