Tonight is brain dinner night and all zombies will gather together to scarf down some delicious brains. The artful Heidi plans to crash the party, incognito, disguised as one of them. Her objective is to get away with at least one brain, so she can analyze the zombies' mindset back home and gain a strategic advantage.They will be N guests tonight: N - 1 real zombies and a fake one, our Heidi. The living-dead love hierarchies as much as they love brains: each one has a unique rank in the range 1 to N - 1, and Heidi, who still appears slightly different from the others, is attributed the highest rank, N. Tonight there will be a chest with brains on display and every attendee sees how many there are. These will then be split among the attendees according to the following procedure:The zombie of the highest rank makes a suggestion on who gets how many brains (every brain is an indivisible entity). A vote follows. If at least half of the attendees accept the offer, the brains are shared in the suggested way and the feast begins. But if majority is not reached, then the highest-ranked zombie is killed, and the next zombie in hierarchy has to make a suggestion. If he is killed too, then the third highest-ranked makes one, etc. (It's enough to have exactly half of the votes – in case of a tie, the vote of the highest-ranked alive zombie counts twice, and he will of course vote in favor of his own suggestion in order to stay alive.)You should know that zombies are very greedy and sly, and they know this too – basically all zombie brains are alike. Consequently, a zombie will never accept an offer which is suboptimal for him. That is, if an offer is not strictly better than a potential later offer, he will vote against it. And make no mistake: while zombies may normally seem rather dull, tonight their intellects are perfect. Each zombie's priorities for tonight are, in descending order:   survive the event (they experienced death already once and know it is no fun),  get as many brains as possible. Heidi goes first and must make an offer which at least half of the attendees will accept, and which allocates at least one brain for Heidi herself.What is the smallest number of brains that have to be in the chest for this to be possible?

The only line of input contains one integer: N, the number of attendees (1 ≤ N ≤ 109).

Output one integer: the smallest number of brains in the chest which allows Heidi to take one brain home.

import java.util.Scanner;

public class CollectiveMindsets {
	public static void main(String args[])
	{
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		System.out.println((n+1)/2);
	}
}

import java.util.Scanner;

public class A690A1 {

	public static void main(String[] args) {
		int n, b;
		Scanner sc = new Scanner(System.in);

		n = sc.nextInt();
		while(n <= 0) {
			n = sc.nextInt();
		}

		if (n % 2 == 0) {
			b = n / 2;
		} else {
			b = (n / 2) + 1;
		}

		System.out.println(b);
	}

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;
public class lee
{
	public static void main(String[]args) throws IOException{
	Scanner s=new Scanner(System.in);
 	PrintWriter pw=new PrintWriter(System.out);
 	long n = s.nextLong();
 	if (n % 2 == 0)
 		pw.print(n / 2);
 	else
 		pw.print(n / 2 + 1);
 	pw.flush();
     }
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Collectivemindset
{
	public static void main(String args[])
	{
		MyScannercm sc=new MyScannercm();
		int n=sc.nextInt();
		int extra=(n-1)/2;
		System.out.println(extra+1);
	}

}
class MyScannercm
{
	BufferedReader br;
	StringTokenizer st;
	MyScannercm()
	{
		br=new BufferedReader(new InputStreamReader(System.in));
	}
	String next()
	{

		while(st==null || !st.hasMoreTokens())
		{
			try
			{
				st=new StringTokenizer(br.readLine());
			}
			catch(Exception e)
			{
				e.printStackTrace();
			}
		}
		return st.nextToken();

	}
	int nextInt()
	{
		return Integer.parseInt(next());
	}
	long nextLong()
	{
		return Long.parseLong(next());
	}
	double nextDouble()
	{
		return Double.parseDouble(next());
	}
	String nextLine()
	{
		String str="";
		try
		{
			str=br.readLine();
		}
		catch(Exception e)
		{
			e.printStackTrace();
		}
		return str;

	}
}

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Calendar;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.SortedSet;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

/**
 * #
 *
 * @author pttrung
 */
public class A1_Helvetic_2016 {

	public static long MOD = 1000000007;

	public static void main(String[] args) throws FileNotFoundException {
		// PrintWriter out = new PrintWriter(new FileOutputStream(new File(
		// "output.txt")));
		PrintWriter out = new PrintWriter(System.out);
		Scanner in = new Scanner();
		int n = in.nextInt();
		int need = n / 2;
		if (need * 2 < n) {
			need++;
		}

		out.println(need);

		out.close();
	}

	public static int[] KMP(String val) {
		int i = 0;
		int j = -1;
		int[] result = new int[val.length() + 1];
		result[0] = -1;
		while (i < val.length()) {
			while (j >= 0 && val.charAt(j) != val.charAt(i)) {
				j = result[j];
			}
			j++;
			i++;
			result[i] = j;
		}
		return result;

	}

	public static boolean nextPer(int[] data) {
		int i = data.length - 1;
		while (i > 0 && data[i] < data[i - 1]) {
			i--;
		}
		if (i == 0) {
			return false;
		}
		int j = data.length - 1;
		while (data[j] < data[i - 1]) {
			j--;
		}
		int temp = data[i - 1];
		data[i - 1] = data[j];
		data[j] = temp;
		Arrays.sort(data, i, data.length);
		return true;
	}

	public static int digit(long n) {
		int result = 0;
		while (n > 0) {
			n /= 10;
			result++;
		}
		return result;
	}

	public static double dist(long a, long b, long x, long y) {
		double val = (b - a) * (b - a) + (x - y) * (x - y);
		val = Math.sqrt(val);
		double other = x * x + a * a;
		other = Math.sqrt(other);
		return val + other;

	}

	public static class Point implements Comparable<Point> {

		int x, y;

		public Point(int start, int end) {
			this.x = start;
			this.y = end;
		}

		@Override
		public int hashCode() {
			int hash = 5;
			hash = 47 * hash + this.x;
			hash = 47 * hash + this.y;
			return hash;
		}

		@Override
		public boolean equals(Object obj) {
			if (obj == null) {
				return false;
			}
			if (getClass() != obj.getClass()) {
				return false;
			}
			final Point other = (Point) obj;
			if (this.x != other.x) {
				return false;
			}
			if (this.y != other.y) {
				return false;
			}
			return true;
		}

		@Override
		public int compareTo(Point o) {
			return Integer.compare(x, o.x);
		}
	}

	public static class FT {

		long[] data;

		FT(int n) {
			data = new long[n];
		}

		public void update(int index, long value) {
			while (index < data.length) {
				data[index] += value;
				index += (index & (-index));
			}
		}

		public long get(int index) {
			long result = 0;
			while (index > 0) {
				result += data[index];
				index -= (index & (-index));
			}
			return result;

		}
	}

	public static long gcd(long a, long b) {
		if (b == 0) {
			return a;
		}
		return gcd(b, a % b);
	}

	public static long pow(long a, long b) {
		if (b == 0) {
			return 1;
		}
		if (b == 1) {
			return a;
		}
		long val = pow(a, b / 2);
		if (b % 2 == 0) {
			return val * val % MOD;
		} else {
			return val * (val * a % MOD) % MOD;

		}
	}

	static class Scanner {

		BufferedReader br;
		StringTokenizer st;

		public Scanner() throws FileNotFoundException {
			// System.setOut(new PrintStream(new
			// BufferedOutputStream(System.out), true));
			br = new BufferedReader(new InputStreamReader(System.in));
			// br = new BufferedReader(new InputStreamReader(new
			// FileInputStream(new File("input.txt"))));
		}

		public String next() {

			while (st == null || !st.hasMoreTokens()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (Exception e) {
					throw new RuntimeException();
				}
			}
			return st.nextToken();
		}

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

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

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

		public String nextLine() {
			st = null;
			try {
				return br.readLine();
			} catch (Exception e) {
				throw new RuntimeException();
			}
		}

		public boolean endLine() {
			try {
				String next = br.readLine();
				while (next != null && next.trim().isEmpty()) {
					next = br.readLine();
				}
				if (next == null) {
					return true;
				}
				st = new StringTokenizer(next);
				return st.hasMoreTokens();
			} catch (Exception e) {
				throw new RuntimeException();
			}
		}
	}
}

import java.io.*;
import java.util.*;
public class a1
{
    public static void main(String args[])throws IOException
    {
        BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
        Scanner ex=new Scanner(System.in);
        int n=ex.nextInt();
        int ans=n/2+n%2;
        System.out.println(ans);
    }
}

import java.util.*;

public class Main{
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);

		int N = sc.nextInt();

		sc.close();

		int ctr = 0;

		if(N==1) ctr = 1;
		else if(N%2 == 0) ctr = N/2;
		else ctr = (N/2) + 1;

		System.out.println(ctr);
	}
}

import java.util.Scanner;

public class P690A1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		int n, b;
		Scanner sc = new Scanner(System.in);

		n = sc.nextInt();

		if (n % 2 == 0) {
			b = n / 2;
		} else {
			b = n / 2 + 1;
		}

		System.out.println(b);
	}

}

import java.util.Scanner;

public class file1 {

	public static void main(String[] args){
		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		System.out.println((n+1)/2);
	}
}

import java.util.Scanner;

public class Main
{
    public static final void main(String[] args)
    {
        Scanner s = new Scanner(System.in);
        int val = s.nextInt();
        System.out.println((val / 2) + (val % 2));
        s.close();
    }

}

import java.util.Scanner;

public class Prob960{
    public static void main(String args[]){
        Scanner input = new Scanner(System.in);
        long n = input.nextLong();

        if(n==1) System.out.println(n);
        else if(n%2==0) System.out.println(n/2);
        else if(n%2==1)System.out.println(n/2+1);
    }
}

import java.util.Scanner;

public class Solution {

	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int n = scan.nextInt();
		scan.close();
		System.out.println(n/2+n%2);
	}

}

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n =sc.nextInt();
		System.out.println(n/2+n%2);
	}

}

import java.io.*;
import java.math.*;
import java.util.*;
import java.util.stream.*;

@SuppressWarnings("unchecked")
public class P690A1 {

  public void run() throws Exception {
    println((nextInt() + 1) >> 1);
  }

  public static void main(String... args) throws Exception {
    br = new BufferedReader(new InputStreamReader(System.in));
    pw = new PrintWriter(new BufferedOutputStream(System.out));
    new P690A1().run();
    br.close();
    pw.close();
    System.err.println("\n[Time : " + (System.currentTimeMillis() - startTime) + " ms]");
  }

  static long startTime = System.currentTimeMillis();
  static BufferedReader br;
  static PrintWriter pw;
  StringTokenizer stok;

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

  void print(byte b) { print("" + b); }
  void print(int i) { print("" + i); }
  void print(long l) { print("" + l); }
  void print(double d) { print("" + d); }
  void print(char c) { print("" + c); }
  void print(Object o) {
    if (o instanceof int[]) { print(Arrays.toString((int [])o));
    } else if (o instanceof long[]) { print(Arrays.toString((long [])o));
    } else if (o instanceof char[]) { print(Arrays.toString((char [])o));
    } else if (o instanceof byte[]) { print(Arrays.toString((byte [])o));
    } else if (o instanceof short[]) { print(Arrays.toString((short [])o));
    } else if (o instanceof boolean[]) { print(Arrays.toString((boolean [])o));
    } else if (o instanceof float[]) { print(Arrays.toString((float [])o));
    } else if (o instanceof double[]) { print(Arrays.toString((double [])o));
    } else if (o instanceof Object[]) { print(Arrays.toString((Object [])o));
    } else { print("" + o); }
  }
  void print(String s) { pw.print(s); }
  void println() { println(""); }
  void println(byte b) { println("" + b); }
  void println(int i) { println("" + i); }
  void println(long l) { println("" + l); }
  void println(double d) { println("" + d); }
  void println(char c) { println("" + c); }
  void println(Object o) { print(o); println(); }
  void println(String s) { pw.println(s); }
  int nextInt() throws IOException { return Integer.parseInt(nextToken()); }
  long nextLong() throws IOException { return Long.parseLong(nextToken()); }
  double nextDouble() throws IOException { return Double.parseDouble(nextToken()); }
  char nextChar() throws IOException { return (char) (br.read()); }
  String next() throws IOException { return nextToken(); }
  String nextLine() throws IOException { return br.readLine(); }
  int [] readInt(int size) throws IOException {
    int [] array = new int [size];
    for (int i = 0; i < size; i++) { array[i] = nextInt(); }
    return array;
  }
  long [] readLong(int size) throws IOException {
    long [] array = new long [size];
    for (int i = 0; i < size; i++) { array[i] = nextLong(); }
    return array;
  }
  double [] readDouble(int size) throws IOException {
    double [] array = new double [size];
    for (int i = 0; i < size; i++) { array[i] = nextDouble(); }
    return array;
  }
  String [] readLines(int size) throws IOException {
    String [] array = new String [size];
    for (int i = 0; i < size; i++) { array[i] = nextLine(); }
    return array;
  }

  int gcd(int a, int b) {
    return ((b > 0) ? gcd(b, a % b) : a);
  }
}

/* package codechef; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */
public class Codechef
{
	public static void main (String[] args) throws java.lang.Exception
	{
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

		    int n=Integer.parseInt(br.readLine());
		    if(n%2==0)
		        System.out.println(n/2);
		    else
		        System.out.println(n/2+1);

	}
}

import java.lang.Math;
import java.io.*;

public class A1{
	public static void main(String[] args){

        try{
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

            int x = Integer.parseInt(br.readLine());
            System.out.println((int)Math.floor((x+1)/2.0));
        }
        catch(IOException e){

        }
	}
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author ale64bit
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA1 solver = new TaskA1();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA1 {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int n = in.readInt();
            out.println((n + 1) / 2);
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int readInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }
}

import java.util.Scanner;

public class collectiveMindset {
    static Scanner key = new Scanner (System.in);
    public static void main (String args[]){
        int input = key.nextInt();
        int output = 0;
        output = input/2;
        if (input%2==1)
            output+=1;
        System.out.println (output);
    }
}

import java.util.*;

public class a{

	public static void main (String[] args) {
		Scanner kbd = new Scanner(System.in);
		long n = Long.parseLong(kbd.nextLine());

			while(n>0){
   			if(n==1){
   			 	System.out.println(1);
   			}else if(n%2==0){
   			 	System.out.println(n/2);
   			}else if(n%2==1){
   				System.out.println(n/2+1);
   			}else if (n<0){
   				System.out.println(0);
   			}else if (n==0)
   				System.out.println(0);
   					break;
		}

	}
}

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner dados = new Scanner(System.in);
		long num;
		num = dados.nextLong();
		System.out.println((num+1)/2);
	}
}

import java.io.*;
import java.util.*;

public class Ultimo {

    public static void main(String[] args) {
    	Scanner in = new Scanner(System.in);
        int n = Integer.parseInt(in.next());
        if(n > 1)
        	n = (n / 2) + (n % 2);
        System.out.println(n);
    }
}

/*@Author: buhnahnah
 *date: 08/11/16
 *
 */
import java.util.Scanner;

public class collectivemindset {
	public static void main(String[] args) {

		Scanner kbd = new Scanner(System.in);
		int n = kbd.nextInt();
		if (n%2==0)
		System.out.println(n/2);
		else
		System.out.println( n / 2 + 1);

	}
}

import java.util.*;
import java.io.*;
/**
 *
 * @author umang
 */

public class A690Easy {

    public static void main(String[] args) {

        InputReader in = new InputReader(System.in);
        PrintWriter w = new PrintWriter(System.out);

        int n = in.nextInt();
        if(n%2==0) w.println(n/2);
        else w.println(n/2+1);
        w.close();
    }

	static class InputReader {

		private final InputStream stream;
		private final byte[] buf = new byte[8192];
		private int curChar, snumChars;
		private SpaceCharFilter filter;

		public InputReader(InputStream stream) {
			this.stream = stream;
		}

		public int snext() {
			if (snumChars == -1)
				throw new InputMismatchException();
			if (curChar >= snumChars) {
				curChar = 0;
				try {
					snumChars = stream.read(buf);
				} catch (IOException e) {
					throw new InputMismatchException();
				}
				if (snumChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}

		public int nextInt() {
			int c = snext();
			while (isSpaceChar(c))
				c = snext();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = snext();
			}
			int res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = snext();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public long nextLong() {
			int c = snext();
			while (isSpaceChar(c))
				c = snext();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = snext();
			}
			long res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = snext();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public int[] nextIntArray(int n) {
			int a[] = new int[n];
			for (int i = 0; i < n; i++)
				a[i] = nextInt();
			return a;
		}

		public String readString() {
			int c = snext();
			while (isSpaceChar(c))
				c = snext();
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = snext();
			} while (!isSpaceChar(c));
			return res.toString();
		}

		public boolean isSpaceChar(int c) {
			if (filter != null)
				return filter.isSpaceChar(c);
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		public interface SpaceCharFilter {
			public boolean isSpaceChar(int ch);
		}
	}
}

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Main {
	public static void main(String[] args) {
		new D1().solve();
	}
}

class D1 {

	InputReader in = new InputReader(System.in);
	PrintWriter out = new PrintWriter(System.out);

	void solve() {
		 out.println((in.nextInt() + 1) / 2)  ;
		 out.flush() ;
	}

}

class InputReader {
	public BufferedReader reader;
	public StringTokenizer tokenizer;

	public InputReader(InputStream stream) {
		reader = new BufferedReader(new InputStreamReader(stream), 32768);
		tokenizer = new StringTokenizer("") ;
	}

	private void eat(String s){
		tokenizer = new StringTokenizer(s) ;
	}

	public String nextLine(){
		try {
			return reader.readLine() ;
		} catch (Exception e) {
			return null ;
		}
	}

	public boolean hasNext(){
		while(!tokenizer.hasMoreTokens()){
			String s = nextLine() ;
			if(s == null) return false ;
			eat(s) ;
		}
		return true ;
	}

	public String next() {
		hasNext() ;
		return tokenizer.nextToken();
	}

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

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

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

	public BigInteger nextBigInteger() {
		return new BigInteger(next());
	}

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;

public class CollectiveMindsets {

	public static void main(String[] args) throws IOException {
		BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
		PrintWriter out=new PrintWriter(System.out);
		int n=Integer.parseInt(reader.readLine());
		if(n%2==0){
			out.println(n/2);
		}
		else{
			out.println(n/2 +1);
		}
		out.close();
	}
}

import java.io.IOException;
import java.io.StreamTokenizer;

/**
 * Created by abragin on 5/9/2016.
 */

public class A {

    public static void main(String[] args) throws IOException {
        final StreamTokenizer tokenizer = new StreamTokenizer(System.in);
        tokenizer.nextToken();
        final int n = (int) tokenizer.nval;
        System.out.println(n % 2 == 0 ? n / 2 : n / 2 + 1);
    }
}

import java.util.Scanner;

/**
 * Created by RFShahrear on 7/10/2016.
 */
public class Collective_Mindsets_Easy {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        int n = scanner.nextInt();
        if (n%2 == 0) System.out.println(n/2);
        else System.out.println(n/2 + 1);
    }
}

import java.io.*;
import java.util.*;

public class HelveticqA {

    public static void main(String[] args) {
        InputReader in = new InputReader(System.in);
        PrintWriter w = new PrintWriter(System.out);

        int n = in.nextInt();
        w.println( (n + 1) / 2 );

        w.close();
    }

    static class InputReader {

        private final InputStream stream;
        private final byte[] buf = new byte[8192];
        private int curChar, snumChars;
        private SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int snext() {
            if (snumChars == -1)
                throw new InputMismatchException();
            if (curChar >= snumChars) {
                curChar = 0;
                try {
                    snumChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (snumChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }

        public int nextInt() {
            int c = snext();
            while (isSpaceChar(c)) {
                c = snext();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = snext();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = snext();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public long nextLong() {
            int c = snext();
            while (isSpaceChar(c)) {
                c = snext();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = snext();
            }
            long res = 0;
            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = snext();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public int[] nextIntArray(int n) {
            int a[] = new int[n];
            for (int i = 0; i < n; i++) {
                a[i] = nextInt();
            }
            return a;
        }

        public String readString() {
            int c = snext();
            while (isSpaceChar(c)) {
                c = snext();
            }
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = snext();
            } while (!isSpaceChar(c));
            return res.toString();
        }

        public boolean isSpaceChar(int c) {
            if (filter != null)
                return filter.isSpaceChar(c);
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);
        }
    }
}

import java.util.Scanner;

public class hevticA {
public static void main(String [] args){
	Scanner scan=new Scanner(System.in);

	int x=scan.nextInt();

	if(x%2==0){
		System.out.print(x/2);

	}

	else{

		System.out.print(x/2+1);
	}

}
}

import java.util.Scanner;

public class CodeForces{

	public static void main(String args[]){
		Scanner scan = new Scanner(System.in);
		int n = scan.nextInt();
		if(n%2 == 0){
			System.out.println(n/2);
		}else{
			System.out.println(n/2+1);
		}
	}

}

import java.util.*;

public class CF690A1 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		System.out.println(n/2 + n%2);
	}
}

/*Author LAVLESH*/
import java.util.*;
import java.io.*;
public class solution{
	static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
	static StringTokenizer st=new StringTokenizer("");

	static public String next() {
	        while (st == null || !st.hasMoreTokens()) {
	            try {
	                st = new StringTokenizer(br.readLine());
	            } catch (IOException e) {
	                throw new RuntimeException(e);
	            }
	        }
	        return st.nextToken();
	    }

	public static void main(String[]args)throws IOException{
		PrintWriter op =new PrintWriter(System.out,true);
		 int n=Integer.parseInt(next());
		 if(n%2==0)op.print(n/2);
		 else op.print(n/2+1);
	  op.close();
  }
}

//package olymp_prog;

import java.util.Scanner;

/**
 * Created by Максим on 15.12.2016.
 */
public class Brain {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        if (n % 2 == 0) {
            System.out.println(n / 2);
        } else {
            System.out.println((n + 1) / 2);
        }
    }
}

import java.util.*;

public class Main {
	public static void main(String [] args) {
		Scanner in = new Scanner(System.in);
		int n;
		while(in.hasNext())
		{
			n = in.nextInt();
			if((n & 1) == 1)
				System.out.println(n / 2 + 1);
			else
				System.out.println(n / 2);
		}
		in.close();
	}
}

import java.util.Scanner;
public class joyMagi{
  public static void main (String []args)
  {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    if (n%2!=0)
    {
      n+=1;
      n=n/2;
      System.out.println(n);
    }
    else
    {
      n=n/2;
       System.out.println(n);
    }
  }
}

import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.*;

public class A1
{
	public static void main (String[] args) throws java.lang.Exception
	{
		A1 obj = new A1();
		obj.solve();
	}

	public void solve()
	{
	    FastReader in = new FastReader(System.in);
	    int n = in.nextInt();
	    System.out.println((n + 1)/2);
	}
}

class FastReader{
	private boolean finished = false;

	private InputStream stream;
	private byte[] buf = new byte[1024];
	private int curChar;
	private int numChars;
	private SpaceCharFilter filter;

	public FastReader(InputStream stream){
		this.stream = stream;
	}

	public int read(){
		if (numChars == -1){
			throw new InputMismatchException ();
		}
		if (curChar >= numChars){
			curChar = 0;
			try{
				numChars = stream.read (buf);
			} catch (IOException e){
				throw new InputMismatchException ();
			}
			if (numChars <= 0){
				return -1;
			}
		}
		return buf[curChar++];
	}

	public int peek(){
		if (numChars == -1){
			return -1;
		}
		if (curChar >= numChars){
			curChar = 0;
			try{
				numChars = stream.read (buf);
			} catch (IOException e){
				return -1;
			}
			if (numChars <= 0){
				return -1;
			}
		}
		return buf[curChar];
	}

	public int nextInt(){
		int c = read ();
		while (isSpaceChar (c))
			c = read ();
		int sgn = 1;
		if (c == '-'){
			sgn = -1;
			c = read ();
		}
		int res = 0;
		do{
			if(c==','){
				c = read();
			}
			if (c < '0' || c > '9'){
				throw new InputMismatchException ();
			}
			res *= 10;
			res += c - '0';
			c = read ();
		} while (!isSpaceChar (c));
		return res * sgn;
	}

	public long nextLong(){
		int c = read ();
		while (isSpaceChar (c))
			c = read ();
		int sgn = 1;
		if (c == '-'){
			sgn = -1;
			c = read ();
		}
		long res = 0;
		do{
			if (c < '0' || c > '9'){
				throw new InputMismatchException ();
			}
			res *= 10;
			res += c - '0';
			c = read ();
		} while (!isSpaceChar (c));
		return res * sgn;
	}

	public String nextString(){
		int c = read ();
		while (isSpaceChar (c))
			c = read ();
		StringBuilder res = new StringBuilder ();
		do{
			res.appendCodePoint (c);
			c = read ();
		} while (!isSpaceChar (c));
		return res.toString ();
	}

	public boolean isSpaceChar(int c){
		if (filter != null){
			return filter.isSpaceChar (c);
		}
		return isWhitespace (c);
	}

	public static boolean isWhitespace(int c){
		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	}

	private String readLine0(){
		StringBuilder buf = new StringBuilder ();
		int c = read ();
		while (c != '\n' && c != -1){
			if (c != '\r'){
				buf.appendCodePoint (c);
			}
			c = read ();
		}
		return buf.toString ();
	}

	public String nextLine(){
		String s = readLine0 ();
		while (s.trim ().length () == 0)
			s = readLine0 ();
		return s;
	}

	public String nextLine(boolean ignoreEmptyLines){
		if (ignoreEmptyLines){
			return nextLine ();
		}else{
			return readLine0 ();
		}
	}

	public BigInteger nextBigInteger(){
		try{
			return new BigInteger (nextString ());
		} catch (NumberFormatException e){
			throw new InputMismatchException ();
		}
	}

	public char nextCharacter(){
		int c = read ();
		while (isSpaceChar (c))
			c = read ();
		return (char) c;
	}

	public double nextDouble(){
		int c = read ();
		while (isSpaceChar (c))
			c = read ();
		int sgn = 1;
		if (c == '-'){
			sgn = -1;
			c = read ();
		}
		double res = 0;
		while (!isSpaceChar (c) && c != '.'){
			if (c == 'e' || c == 'E'){
				return res * Math.pow (10, nextInt ());
			}
			if (c < '0' || c > '9'){
				throw new InputMismatchException ();
			}
			res *= 10;
			res += c - '0';
			c = read ();
		}
		if (c == '.'){
			c = read ();
			double m = 1;
			while (!isSpaceChar (c)){
				if (c == 'e' || c == 'E'){
					return res * Math.pow (10, nextInt ());
				}
				if (c < '0' || c > '9'){
					throw new InputMismatchException ();
				}
				m /= 10;
				res += (c - '0') * m;
				c = read ();
			}
		}
		return res * sgn;
	}

	public boolean isExhausted(){
		int value;
		while (isSpaceChar (value = peek ()) && value != -1)
			read ();
		return value == -1;
	}

	public String next(){
		return nextString ();
	}

	public SpaceCharFilter getFilter(){
		return filter;
	}

	public void setFilter(SpaceCharFilter filter){
		this.filter = filter;
	}

	public interface SpaceCharFilter{
		public boolean isSpaceChar(int ch);
	}
}

class Obj implements Comparable<Obj>{
	char c;
	int size;

	public Obj(char c, int size){
		this.c = c;
		this.size = size;
	}

	public int compareTo(Obj that){
		if(this.size>that.size){
			return -1;
		}else if(this.size<that.size){
			return 1;
		}else{
			if(this.c < that.c){
				return -1;
			}else if(this.c > that.c){
				return 1;
			}else{
				return 0;
			}
		}
	}
}

import static java.lang.Double.parseDouble;
import static java.lang.Integer.parseInt;
import static java.lang.Long.parseLong;
import static java.lang.System.exit;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class A1 {

	static BufferedReader in;
	static PrintWriter out;
	static StringTokenizer tok;

	static void solve() throws Exception {
		out.print((nextInt() + 1) / 2);
	}

	static int nextInt() throws IOException {
		return parseInt(next());
	}

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

	static double nextDouble() throws IOException {
		return parseDouble(next());
	}

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

	public static void main(String[] args) {
		try {
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(new OutputStreamWriter(System.out));
			solve();
			in.close();
			out.close();
		} catch (Throwable e) {
			e.printStackTrace();
			exit(1);
		}
	}
}

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {

		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		sc.close();
		System.out.println(n % 2 == 0 ? n / 2 : n / 2 + 1);

	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;

public class Main {

	final static Scanner s = new Scanner(System.in);
	final static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

	public static void main(String[] args) throws IOException {
		int n=s.nextInt();
		if(n%2==0)
			n/=2;
		else
			n=n/2+1;
		System.out.println(n);
		s.close();
		br.close();
	}// end of main(String[])

}// end of class Main

//package com.company;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
	    Solve solve = new Solve(new Scanner(System.in));

        solve.run();
    }

}
class Solve {
    private final Scanner SCANNER;

    public Solve(Scanner scanner){
        this.SCANNER = scanner;
    }

    public void run(){
        long N;
        N = SCANNER.nextLong();
        long ans  = 0 ;
        if(N % 2 == 0){
            ans = N / 2;
        }else {
            ans = N / 2 + 1;
        }

        System.out.print(ans);
    }
}

import java.io.*;
import java.util.*;

public class Template implements Runnable {

    BufferedReader in;
    PrintWriter out;
    StringTokenizer tok = new StringTokenizer("");

    void init() throws FileNotFoundException {
        try {
            in = new BufferedReader(new FileReader("input.txt"));
            out = new PrintWriter("output.txt");
        } catch (Exception e) {
            String filename = "";
            if (filename.isEmpty()) {
                in = new BufferedReader(new InputStreamReader(System.in));
                out = new PrintWriter(System.out);
            } else {
                in = new BufferedReader(new FileReader(filename + ".in"));
                out = new PrintWriter(filename + ".out");
            }
        }
    }

    String readString() throws IOException {
        while (!tok.hasMoreTokens()) {
            try {
                tok = new StringTokenizer(in.readLine());
            } catch (Exception e) {
                return null;
            }
        }
        return tok.nextToken();
    }

    int readInt() throws IOException {
        return Integer.parseInt(readString());
    }

    int[] readIntArray(int size) throws IOException {
        int[] res = new int[size];
        for (int i = 0; i < size; i++) {
            res[i] = readInt();
        }
        return res;
    }

    long readLong() throws IOException {
        return Long.parseLong(readString());
    }

    double readDouble() throws IOException {
        return Double.parseDouble(readString());
    }

    <T> List<T>[] createGraphList(int size) {
        List<T>[] list = new List[size];
        for (int i = 0; i < size; i++) {
            list[i] = new ArrayList<>();
        }
        return list;
    }

    public static void main(String[] args) {
        new Thread(null, new Template(), "", 1l * 200 * 1024 * 1024).start();
    }

    long timeBegin, timeEnd;

    void time() {
        timeEnd = System.currentTimeMillis();
        System.err.println("Time = " + (timeEnd - timeBegin));
    }

    long memoryTotal, memoryFree;

    void memory() {
        memoryFree = Runtime.getRuntime().freeMemory();
        System.err.println("Memory = " + ((memoryTotal - memoryFree) >> 10)
                + " KB");
    }

    public void run() {
        try {
            timeBegin = System.currentTimeMillis();
            memoryTotal = Runtime.getRuntime().freeMemory();
            init();
            solve();
            out.close();
            if (System.getProperty("ONLINE_JUDGE") == null) {
                time();
                memory();
            }
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(-1);
        }
    }

    void solve() throws IOException {
        int n = readInt();
        out.println((n + 1) / 2);
    }

}

import java.util.*;
import java.io.*;

public class Untitled {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in); int N = sc.nextInt();
		int g = 0; if(N==1) g = 1; else if(N%2 == 0) g = N/2; else g = (N/2) + 1;
		System.out.println(g);
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
import java.util.StringTokenizer;

public class Main{

	static PrintWriter writer = new PrintWriter(System.out,false);
	static boolean[] visited;
	static final int[] rowIncrement = {-1,0,0,1};   // possible moves in rows
	static final int[] colIncrement = {0,-1,1,0};
	static int count=0;
	static  ArrayList<Integer>[] al;
	static int a[];
	static int nodes[],ans=0;
	public static void main(String[] args) throws IOException{
		int n,m,t,k1,k2;
		Scanner s=new Scanner(System.in);
		n=s.nextInt();
		if(n==1)
			System.out.println(1);
		else
			System.out.println((int)Math.ceil(n/2.0));

	}
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;
/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Alex
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskA1 solver = new TaskA1();
        solver.solve(1, in, out);
        out.close();
    }
    static class TaskA1 {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            int n = in.readInt();
            out.printLine((n + 1) / 2);
        }
    }
    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;
        public InputReader(InputStream stream) {
            this.stream = stream;
        }
        public int read() {
            if (numChars == -1)
                throw new InputMismatchException();
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }
        public int readInt() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }
        public boolean isSpaceChar(int c) {
            if (filter != null)
                return filter.isSpaceChar(c);
            return isWhitespace(c);
        }
        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }
        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);
        }
    }
    static class OutputWriter {
        private final PrintWriter writer;
        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }
        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }
        public void close() {
            writer.close();
        }
        public void printLine(int i) {
            writer.println(i);
        }
    }
}

import java.util.*;
public class susbus{
   public static void main(String[] args){
      Scanner sc = new Scanner(System.in);
      int n = sc.nextInt();
      System.out.println((n-1)/2+1);
   }
}

import java.util.Scanner;

public class CollectiveMindsets {

	public static void main(String[] args) {

		Scanner sc = new Scanner(System.in);

		double a = sc.nextDouble();
		double ans = Math.ceil(a/2);

		System.out.printf("%.0f",ans);

	}

}

import java.util.Scanner;

public class Ques1 {

	public static void main(String[] args)
	{
		Scanner s = new Scanner(System.in);
		int N = s.nextInt();
		if(N%2==0)
		{
			System.out.println(N/2);
		}
		else
		{
			System.out.println(N/2+1);
		}
	}

}

import java.util.Scanner;

public class Main {
    public static void main(String [] args){
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        if(n%2!=0){
            n+=1;
        }
        n/=2;
        System.out.println(n);
    }
}

import java.util.*;
public class c{
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        System.out.println((int)Math.ceil(in.nextDouble()/2));
    }
}

import java.io.BufferedReader;
import java.io.Closeable;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class CollectiveMindsetsEasy implements Closeable {

    private InputReader in = new InputReader(System.in);
    private PrintWriter out = new PrintWriter(System.out);

    public void solve() {
        int n = in.ni();
        out.println(n % 2 == 0 ? n / 2 : (n + 1) / 2);
    }

    @Override
    public void close() throws IOException {
        in.close();
        out.close();
    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int ni() {
            return Integer.parseInt(next());
        }

        public long nl() {
            return Long.parseLong(next());
        }

        public void close() throws IOException {
            reader.close();
        }
    }

    public static void main(String[] args) throws IOException {
        try (CollectiveMindsetsEasy instance = new CollectiveMindsetsEasy()) {
            instance.solve();
        }
    }
}

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        if (n % 2 == 0) n /= 2;
        else n = n / 2 + 1;
        System.out.println(n);
    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Jaswant Singh[joney_000]
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastReader in = new FastReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA1 solver = new TaskA1();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA1 {
        FastReader in;
        PrintWriter out;

        void set(FastReader in, PrintWriter out) {
            this.in = in;
            this.out = out;
        }

        public void solve(int testNumber, FastReader in, PrintWriter out) {
            set(in, out);
            int n = i();//int m = i();
            long ans = (n + 1) / 2;
            out.write("" + ans + "");

        }

        int i() {
            //return Integer.parseInt(br.readLine().trim());
            return in.nextInt();
        }

    }

    static class FastReader {
        private InputStream stream;
        private byte[] buf = new byte[4 * 1024];
        private int curChar;
        private int numChars;
        private SpaceCharFilter filter;

        public FastReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int nextInt() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c == ',') {
                    c = read();
                }
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }
}

import java.util.Scanner;

public class A1_690 {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int N = in.nextInt();
        System.out.println((N+1)/2);
    }

}

import java.io.*;
import java.util.*;
import java.math.*;
import static java.lang.Math.*;
import static java.lang.Integer.parseInt;
import static java.lang.Long.parseLong;
import static java.lang.Double.parseDouble;
import static java.lang.String.*;
import java.util.stream.Collectors;

public class Main {

    public static void main(String[] args) throws IOException {
      //  BufferedReader in = new BufferedReader(new InputStreamReader(System.in));                                    //(new FileReader("input.in"));
       // StringBuilder out = new StringBuilder();
       // StringTokenizer tk;
      Scanner s = new Scanner(System.in);
       Reader.init(System.in);
        //tk = new StringTokenizer(in.readLine());
        int n =Reader.nextInt();
        System.out.println(n%2==0?n/2:n/2+1);

    }

}

//class Book {
//
//    String a;
//    int b, c,ind;
//
//    public Book(String x, int y) {
//        a = x;
//        b = y;
//
//
//    }
//
//    @Override
//    public boolean equals(Object object) {
//        boolean sameSame = false;
//
//        if (object != null && object instanceof Book) {
//            sameSame = (this.a == null ? ((Book) object).a == null : this.a.equals(((Book) object).a));
//        }
//        if (object != null && object instanceof Book) {
//            sameSame = this.b == ((Book) object).b;
//        }
//
//        return sameSame;
//    }
//}
//
//class MyComparator implements Comparator<Book> {
//
//    @Override
//    public int compare(Book o1, Book o2) {
//        if (o1.c > o2.c) {
//            return 1;
//        } else if (o1.c < o2.c) {
//            return -1;
//        }
//        return 0;
//    }
//
//}

class Reader {

    static StringTokenizer tokenizer;
    static BufferedReader reader;

    public static void init(InputStream input) throws UnsupportedEncodingException {
        reader = new BufferedReader(new InputStreamReader(input, "UTF-8"));
        tokenizer = new StringTokenizer("");
    }

    public static String next() throws IOException {
        while (!tokenizer.hasMoreTokens()) {
            tokenizer = new StringTokenizer(reader.readLine());
        }
        return tokenizer.nextToken();
    }

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

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

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

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

import java.io.*;
import java.util.Locale;
import java.util.StringTokenizer;

public class Main {
    public void solve() throws IOException {
        // write your code here
        int n = nextInt();
        if(n % 2 == 0) out.println(n / 2);
        else out.println((n + 1)/2);

        out.close ();

    }

    BufferedReader br;
    StringTokenizer sc;
    PrintWriter out;

    public String nextToken() throws IOException {
        while (sc == null || !sc.hasMoreTokens ()) {
            try {
                sc = new StringTokenizer (br.readLine ());
            } catch (Exception e) {
                return null;
            }
        }
        return sc.nextToken ();
    }

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

    public double nextDouble() throws IOException {
        return Double.parseDouble (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 ();
    }

    public void run() {
        try {
            br = new BufferedReader (new InputStreamReader (System.in));
            out = new PrintWriter (System.out);

            solve ();

            out.close ();
        } catch (IOException e) {
            e.printStackTrace ();
            System.exit (1);
        }
    }
}

import java.util.Scanner;
public class CodeForces {
 public static void main (String args[])
 {
	 double NumOfZombies;
	 Scanner scan = new Scanner(System.in);
	 NumOfZombies = scan.nextDouble();
	 int Answer = (int) Math.ceil( NumOfZombies/2);
	 System.out.println(Answer);

 }
}

import java.util.Scanner;

public class King {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        if (n % 2 == 0)
            System.out.print(n/2);
        else
            System.out.print(n/2+1);
    }
}

//package com.qwert2603.open_cv_3_1;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class q1 {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());
        System.out.println((n + 1) / 2);
    }
}

import java.io.*;
public class a1
{
	public static void main(String ar[])throws IOException
	{
		long n;
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		n=Long.parseLong(br.readLine());
		if(n%2==0)
			System.out.println(n/2);
		else
			System.out.println(n/2+1);

	}
}

import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.IOException;
import java.util.StringTokenizer;
import java.io.InputStream;
import java.io.InputStreamReader;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Igor Kraskevich
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		FastScanner in = new FastScanner(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskA1 solver = new TaskA1();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskA1 {
    public void solve(int testNumber, FastScanner in, PrintWriter out) {
        int n = in.nextInt();
        out.println((n + 1) / 2);
    }
}

class FastScanner {
    private StringTokenizer tokenizer;
    private BufferedReader reader;

    public FastScanner(InputStream inputStream) {
        reader = new BufferedReader(new InputStreamReader(inputStream));
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            String line = null;
            try {
                line = reader.readLine();
            } catch (IOException e) {
                }
            if (line == null)
                return null;
            tokenizer = new StringTokenizer(line);
        }
        return tokenizer.nextToken();
    }

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

}

import java.io.InputStream;
import java.util.ArrayList;
import java.util.Scanner;

public class OutputBasedSolver {
    public static void main(String[] args) {
        new OutputBasedSolver(false, System.in).solve();
    }

    public OutputBasedSolver(boolean hasMultipleTests, InputStream input) {
        scanner = new Scanner(input);
        numberOfTests = hasMultipleTests ? scanner.nextInt() : 1;
    }

    public ArrayList<String> solve() {
        preCompute();

        for (int i = 0; i < numberOfTests; ++i) {
            resetData();
            readInput();
            computeResult();
            addCurrentToResults();
            printResult();
        }

        return results;
    }

    private void addCurrentToResults() {
        results.add(String.valueOf(result));
    }

    private int numberOfTests;
    private Scanner scanner;
    private ArrayList<String> results = new ArrayList<>();

    private final int MOD = 1000000007;
    private long result;
    private long n;

    private void preCompute() {
    }

    private void resetData() {
        result = 0;
    }

    private void readInput() {
        n = scanner.nextInt();
    }

    private void printResult() {
        System.out.println(result);
    }

    private void computeResult() {
        result = (long) (Math.ceil((n - 2) / 2.0) + 1);
    }
}

import java.io.*;
public class Zombie{
	public static void main(String q[])throws Exception{
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

			int n=Integer.parseInt(br.readLine());
			if(n%2==0){
				System.out.println(n/2);
			}
			else{
				n=n/2+1;
				System.out.println(n);
			}

	}

}

/*
 * Solution_690_A1.java
 * Copyright (C) 2017 tri <tri@tri-K42F>
 *
 * Distributed under terms of the MIT license.
 */
import java.util.*;
import java.io.*;
public class Solution_690_A1
{
	private static String INPUT_FILE="690_A1.txt";
	public Solution_690_A1() {
	}
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		Integer totalNum = sc.nextInt();
		totalNum = (totalNum/2)+(totalNum%2);
		System.out.print(totalNum);
		return;
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class CollectiveMindsets {

	public static void main(String[] args) throws NumberFormatException, IOException {
		BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
		int n = Integer.parseInt(bf.readLine().trim());
		if(n%2==0){
			System.out.println(n/2);
		}else{
			System.out.println(n/2+1);
		}
	}

}

import java.util.*;
public class TestDemo
{
	public static void main(String args[])
	{
		Scanner input = new Scanner(System.in);
		int n = input.nextInt();
		System.out.print((n+1)/2);
		input.close();
	}
}

import java.util.Scanner;

public class zombiesAndBrainsA1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner console = new Scanner(System.in);
		int n = console.nextInt();
		System.out.println(n/2+n%2);

	}

}

import java.util.Scanner;

public class Solution {

	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int n = scan.nextInt();
		scan.close();
		System.out.println(n/2+1);
	}

}

/* package codechef; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */
public class Codechef
{
	public static void main (String[] args) throws java.lang.Exception
	{
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

		    float n=Integer.parseInt(br.readLine());
		    System.out.println((int)Math.ceil(n/(float)(2)));

	}
}

import java.lang.Math;
import java.io.*;

public class A1{
	public static void main(String[] args){

        try{
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

            int x = Integer.parseInt(br.readLine());
            System.out.println(Math.floor((x+1)/2.0));
        }
        catch(IOException e){

        }
	}
}

import java.util.Scanner;

public class collectiveMindset {
    static Scanner key = new Scanner (System.in);
    public static void main (String args[]){
        int input = key.nextInt();
        int output = 0;
        output = input/2;
        if (input==1)
            output=1;
        System.out.println (output);
    }
}

import java.io.*;
import java.util.*;

public class Ultimo {

    public static void main(String[] args) {
    	Scanner in = new Scanner(System.in);
        int n = Integer.parseInt(in.next());
        if(n > 1)
        	n /= 2;
        System.out.println(n);
    }
}

import java.util.*;

public class CF690A2 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		if (n%2==1)
			System.out.println(n/2);
		else
			System.out.println((n-(1<<power(n)))/2);
	}

	static int power(int n) {
		if (n<2) return 0;
		return 1 + power(n/2);
	}
}

//package olymp_prog;

import java.util.Scanner;

/**
 * Created by Максим on 15.12.2016.
 */
public class Brain {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int dead[] = new int[n];

        for (int i = 2; i <= n; i++) {
            for (int j = 0; j < n; j++) {
                int t = dead[j] + j + 1;
                if (i % 2 == 0) {
                    if (t + 1 > i / 2) {
                        dead[j] = 0;
                    } else {
                        dead[j]++;
                    }
                } else {
                    if (t > i / 2) {
                        dead[j] = 0;
                    } else {
                        dead[j]++;
                    }
                }
            }
//            System.out.print(i + " = ");
//            show(dead);
        }
        show(dead);
    }

    private static void show(int[] dead) {

        for (int i = 0; i < dead.length; i++) {
            if (dead[i] == 0) {
                System.out.println(i);
                return;
            } else {
                if (true)
                    continue;
            }
            System.out.print(dead[i] + " ");
        }
        System.out.println();
    }
}

//package olymp_prog;

import java.util.Scanner;

/**
 * Created by Максим on 15.12.2016.
 */
public class Brain {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        System.out.println(n == 1 ? 1 : n / 2);
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
import java.util.StringTokenizer;

public class Main{

	static PrintWriter writer = new PrintWriter(System.out,false);
	static boolean[] visited;
	static final int[] rowIncrement = {-1,0,0,1};   // possible moves in rows
	static final int[] colIncrement = {0,-1,1,0};
	static int count=0;
	static  ArrayList<Integer>[] al;
	static int a[];
	static int nodes[],ans=0;
	public static void main(String[] args) throws IOException{
		int n,m,t,k1,k2;
		Scanner s=new Scanner(System.in);
		n=s.nextInt();
		if(n==1)
			System.out.println(1);
		else
			System.out.println(Math.ceil(n/2.0));

	}
}

import java.util.*;
public class susbus{
   public static void main(String[] args){
      Scanner sc = new Scanner(System.in);
      int n = sc.nextInt();
      System.out.println(n/2);
   }
}

import java.util.Scanner;

public class Ques1 {

	public static void main(String[] args)
	{
		Scanner s = new Scanner(System.in);
		int N = s.nextInt();
		if(N%2==0)
		{
			if(N==2){
				System.out.println(0);
			}
			else
			{
				System.out.println(1);
			}
		}
		else
		{
			System.out.println(N/2);
		}
		//System.out.println(N/2);
	}
}

import java.util.*;
 public class c{
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        System.out.println(Math.ceil(in.nextDouble()/2));
    }
}

import java.io.InputStream;
import java.util.ArrayList;
import java.util.Scanner;

public class OutputBasedSolver {
    public static void main(String[] args) {
        new OutputBasedSolver(false, System.in).solve();
    }

    public OutputBasedSolver(boolean hasMultipleTests, InputStream input) {
        scanner = new Scanner(input);
        numberOfTests = hasMultipleTests ? scanner.nextInt() : 1;
    }

    public ArrayList<String> solve() {
        preCompute();

        for (int i = 0; i < numberOfTests; ++i) {
            resetData();
            readInput();
            computeResult();
            addCurrentToResults();
            printResult();
        }

        return results;
    }

    private void addCurrentToResults() {
        results.add(String.valueOf(result));
    }

    private int numberOfTests;
    private Scanner scanner;
    private ArrayList<String> results = new ArrayList<>();

    private final int MOD = 1000000007;
    private long result;
    private long n;

    private void preCompute() {
    }

    private void resetData() {
        result = 0;
    }

    private void readInput() {
        n = scanner.nextInt();
    }

    private void printResult() {
        System.out.println(result);
    }

    private void computeResult() {
        result = (n - 2) / 2 + 1;
    }
}