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

	}

}

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);
	}
}

/*
 * 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;
    }
}