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 java.util.zip.Adler32;

public class Main {
    static int[]c;
    static long[][]memo;
    static char[]s;
    static int mod = (int)1e9+7;
    static long dp(int idx,int rem){
        if (idx==s.length)
            return rem==0?1:0;
        if (memo[idx][rem]!=-1)
            return memo[idx][rem];
        long ans=0;
        if (s[idx]=='f'){
            ans=dp(idx+1,rem+1);
            if (rem>0&&c[idx]-c[idx-1]!=1)
            ans+=dp(idx,rem-1);
            ans%=mod;
        }
        else {
            ans=dp(idx+1,rem);
            if (rem>0)
            ans+=dp(idx,rem-1);
            ans%=mod;
        }
        return memo[idx][rem]=ans;
    }
    public static void main(String[]args) throws Exception {
        Scanner sc = new Scanner(System.in);
        PrintWriter pw = new PrintWriter(System.out);
        int n = sc.nextInt();
        int [] c= new int[n];
        for (int i =1;i<=n;i++){
            for (int j =0;j<n;j++){
                if (j+i-1>=n)
                    break;
                for (int k =j;k-j+1<=i;k++)
                    c[k]++;
            }
        }
        int mx =0;
        for (int x:c)mx=Math.max(mx,x);
        pw.println(mx);
        pw.flush();
    }


    static class Scanner
    {
        StringTokenizer st;
        BufferedReader br;

        public Scanner(InputStream s){	br = new BufferedReader(new InputStreamReader(s));}

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

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

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

        public String nextLine() throws IOException {return br.readLine();}

        public double nextDouble() throws IOException
        {
            String x = next();
            StringBuilder sb = new StringBuilder("0");
            double res = 0, f = 1;
            boolean dec = false, neg = false;
            int start = 0;
            if(x.charAt(0) == '-')
            {
                neg = true;
                start++;
            }
            for(int i = start; i < x.length(); i++)
                if(x.charAt(i) == '.')
                {
                    res = Long.parseLong(sb.toString());
                    sb = new StringBuilder("0");
                    dec = true;
                }
                else
                {
                    sb.append(x.charAt(i));
                    if(dec)
                        f *= 10;
                }
            res += Long.parseLong(sb.toString()) / f;
            return res * (neg?-1:1);
        }

        public boolean ready() throws IOException {return br.ready();}


    }
}