Problem:
 Score : 100 points    Problem Statement Takahashi wants to print a document with N pages double-sided, where two pages of data can be printed on one sheet of paper.  At least how many sheets of paper does he need?      Constraints  N is an integer.  1 \leq N \leq 100         Input Input is given from Standard Input in the following format:  N       Output Print the answer.        Sample Input 1 5      Sample Output 1 3  By printing the 1 -st, 2 -nd pages on the 1 -st sheet, 3 -rd and 4 -th pages on the 2 -nd sheet, and 5 -th page on the 3 -rd sheet, we can print all the data on 3 sheets of paper.       Sample Input 2 2      Sample Output 2 1       Sample Input 3 100      Sample Output 3 50

Solution (Python):

from math import ceil
N = int(input())
print(ceil(N / 2))

Solution (Python):

def main():
    N = int(input())
    print((N + 1) // 2)


if __name__ == "__main__":
    main()

Solution (Python):
n = int(input())

if n%2 == 0:
    print(n//2)
elif n%2 == 1:
    print(n//2+1)

Solution (Python):
from sys import stdin
n = int(stdin.readline().rstrip())
print((n+1)//2)

Solution (Python):
n=int(input())
c=0
if n%2==1:c=1
print(n//2+c)

Solution (Python):
N = input()
N = int(N)
num_paper = int(N / 2)
if (N % 2) > 0:
  num_paper += 1
else:
  pass

print(num_paper)

Solution (Python):
from math import ceil
n = int(input())
print(ceil(n/2))

Solution (Python):
print((int(input())+1)//2)

Solution (Python):


from sys import stdin, stderr

def main():
   N = int(stdin.readline())
   res = (N+1)//2
   print(res)

   return 0

if __name__ == '__main__': main()

Solution (Python):
n = input()
if n % 2 == 0:
  print n /2
else:
  print (n / 2) + 1

Solution (Python):
n = int(input())
if n % 2 == 0:
    print(n // 2)
else:
    print(n // 2 + 1)

Solution (Python):
n = int(input())
a=int(-(-n//2))
print(a)

Solution (Python):
import math
N = int(input())
min_page = math.ceil(N/2)
print(min_page)

Solution (Python):
n = int(input())
print(n//2 + n%2)

Solution (Python):
print((int(input())+1)//2)

Solution (Python):
n = int(input())
print(n//2+n%2)

Solution (Python):
import math

N = int(input())

print(math.ceil(N /  2))

Solution (Python):
N = int(input())
print((N+1)//2)

Solution (Python):
a = int(input())
b = int(a/2)
if a%2==0:
  print(b)
else:
  print(b+1)

Solution (Python):
print(int(input())+1>>1)

Solution (Python):
print(int(input())+1>>1)

Solution (Python):
n=int(input())
print((n-1)//2+1)

Solution (Python):
num = int(input())
num = num//2 + num%2
print(num)

Solution (Python):
n=int(input())
if n%2==0:
  print(n//2)
else:
  print(n//2+1)

Solution (Python):
N = int(input())
if N%2 ==0:
 print(N//2)
if N%2 ==1:
 N = N//2+1
 print(N)

Solution (Python):
print((int(input())+1)//2)

Solution (Python):
page = int(input())
if page%2 == 1:
	page+=1

answer = page/2
print('{:.0f}'.format(answer))

Solution (Python):
p = int(input())
print((p+1)//2)

Solution (Python):
n=int(input())
ans=(n+1)//2
print(ans)

Solution (Python):
N = int(input())

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

Solution (Python):
import math
N = int(input())
print(math.ceil(N/2))

Solution (Python):
n = int(input())
print(n // 2 + (n % 2 != 0))

Solution (Python):
N=int(input())
print(N//2+1)if N%2==1 else print(N//2)

Solution (Python):
N=int(input())
if N/2.0>int(N/2.0):
    print(int(N/2.0)+1)
else: print(int((N/2.0)))

Solution (Python):
import math


def main():
    N = int(input())
    a = math.ceil(N/2.0)
    print(a)


if __name__ == '__main__':
    main()

Solution (Python):
n = int(input())
if n%2 == 0:
    print(n//2)
else:
    print(n//2 + 1)

Solution (Python):
N = int(input())
print((N+1)//2)

Solution (Python):
print(int((int(input())+1)/2))

Solution (Python):
import math
n = int(input())
print(math.ceil(n/2))

Solution (Python):
n=int(input());print(n//2+n%2)

Solution (Python):
N=int(input())
print((N+1)//2)

Solution (Python):
import math
print(math.ceil(int(input())/2))

Solution (Python):
n=int(input())
print((n//2)) if n%2==0 else print(n//2+1)

Solution (Python):
pages = int(input())

extra = pages%2
print(pages//2 + extra)

Solution (Python):
n = int(input())
print((n+1)//2)

Solution (Python):
N = int(input())
print(N//2+(N & 1))

Solution (Python):
import sys

read = sys.stdin.buffer.read
input = sys.stdin.buffer.readline
inputs = sys.stdin.buffer.readlines






def main():
	print((int(input())+1)//2)






	

if __name__ == "__main__":
	main()

Solution (Python):
N=int(input())
if N%2==0:
    print(int(N/2))
else:
    print(int((N+1)/2))

Solution (Python):
n = int(input())
if n % 2 <= 0 :
    print(n//2)
elif n % 2 >= 1 :
    print(n//2 +1)

Solution (Python):
N=int(input())
if N%2==0:
    print(N//2)
else:
    print((N+1)//2)

Solution (Python):
from math import ceil

n = int(input())
print(ceil(n / 2))

Solution (Python):
n = int(input())
ans = (n+1)//2
print(ans)

Solution (Python):
N=int(input())
print((N+1)//2)

Solution (Python):
import sys,math

sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
printV = lambda x: print(*x, sep="\n")
printH = lambda x: print(" ".join(map(str,x)))
def IS(): return sys.stdin.readline()[:-1]
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI1(): return list(map(int1, sys.stdin.readline().split()))
def LII(rows_number): return [II() for _ in range(rows_number)]
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def LLI1(rows_number): return [LI1() for _ in range(rows_number)]

def main():
	N = II()
	print(math.ceil(N/2))

if __name__ == '__main__':
	main()

Solution (Python):
print(((int(input()))+1)//2)

Solution (Python):
n = int(input())
print(n//2+1 if n % 2 == 1 else n // 2)

Solution (Python):
print(-(- int(input()) // 2))

Solution (Python):
N = int(input())

if N % 2 == 0:
    print(N//2)
else:
    print(N//2 + 1)

Solution (Python):
import sys
import math
input = sys.stdin.readline

N = int(input())

print(math.ceil(N / 2))

Solution (Python):
N = int(input())
print((N+2-1) // 2)

Solution (Python):
import sys
import os


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")


    a = int(sys.stdin.readline().rstrip())
    print(a // 2 if a % 2 == 0 else a // 2 + 1)


if __name__ == '__main__':
    main()

Solution (Python):
import math
print(int(math.ceil(int(input())/2)))

Solution (Python):
from math import ceil

N = int(input())
print(ceil(N / 2))

Solution (Python):
print(-~int(input())//2)

Solution (Python):
a=int(input())
if a%2==0:
  print(a//2)
else:
  print((a//2)+1)

Solution (Python):
N = int(input())

if N % 2 == 0:
    print(N//2)
else:
    print(N//2+1)

Solution (Python):
N = int(input())

ans = (N + 1) // 2

print(ans)

Solution (Python):
n=int(input())
print((n+1)//2)

Solution (Python):
"""
A
"""
N=int(input())
print((N+1)//2)

Solution (Python):
import sys
stdin = sys.stdin
sys.setrecursionlimit(10**9)
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
nn = lambda: list(stdin.readline().split())
ns = lambda: stdin.readline().rstrip()

n = ni()
print((n+1)//2)

Solution (Python):
N = int(input())
print((N+1)//2)

Solution (Python):
N = int(input())
if N % 2 == 0:
    print(int(N / 2))
else:
    print(int((N - 1) / 2 + 1))

Solution (Python):
N = int(input())
if N % 2 == 0:
    print(N//2)
else:
    print(1 + N//2)

Solution (Python):
N = int(input())

if N % 2 == 0:
    print(N//2)
else:
    print(N//2+1)

Solution (Python):
print(-~int(input())//2)

Solution (Python):
N = int(input())
if N % 2 == 0:
  print(int(N/2))
else:
  print(int(1+N/2))

Solution (Python):
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce
import pprint
sys.setrecursionlimit(10 ** 9)


INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007




n = I()
print(n // 2 + n % 2)

Solution (Python):
import math
N = int(input())

print(math.ceil((N/2)))

Solution (Python):
a = int(input())
if a % 2 == 0:
    print(int(a / 2))
else:
    print(int(a / 2) + 1)

Solution (Python):
N=int(input())
if (N%2) == 1:
   S=int((N+1)/2)
else:
     S=int(N/2)
print(S)

Solution (Python):


a=int(input())
if a%2==0:
    print(int(a/2))
else:
    print(a//2+1)

Solution (Python):


n=int(input())

if n%2==0:
  ans=n/2
else:
  ans=(n/2)+1

print(int(ans))

Solution (Python):
n=int(input())
if n%2==0:
  print(int(n/2))
else:
  print(int(n//2+1))

Solution (Python):
n = int(input())

if n%2 == 0:
    a = n//2
else:
    a = n//2 + 1
print(int(a))

Solution (Python):
n = int(input())

if n % 2 == 0:
    print(n//2)
else:
    print(n//2+1)

Solution (Python):
N = int(input())

if N % 2 == 0:
    print(N//2)
else:
    print(N//2+1)

Solution (Python):
N = input()
N =int(N)

if 1<= N and N<=100:
    if N%2 ==0:
        n = N/2
    else:
        n = N/2+1
  
print(int(n))

Solution (Python):
import math
n = int(input())
print(math.ceil(n / 2.0))

Solution (Python):
N = int(input())

if N % 2 == 0:
    print(int(N/2))
else:
    print(int((N/2) + 1))

Solution (Python):
N = input()
if int(N) % 2 == 0:
  print(round(int(N) / 2))
else:
  print(round(int(N) / 2 + 0.5))

Solution (Python):
x=int(input())
print((x+1)//2)

Solution (Python):
print(-(-int(input()) // 2))

Solution (Python):
def s_in():
    return input()

def n_in():
    return int(input())

def l_in():
    return list(map(int, input().split()))

class Interval():
    def __init__(self, li):
        self.li = li
        self.n = len(li)
        self.sum_li = [li[0]]
        for i in range(1, self.n):
            self.sum_li.append(self.sum_li[i-1] + li[i])

    def sum(self, a, b=None):
        if b is None:
            return self.sum(0, a)

        res = self.sum_li[min(self.n-1, b-1)]
        if a > 0:
            res -= self.sum_li[a-1]
        return res

import math
N= n_in()
print(math.ceil(N/2))

Solution (Python):
N = int(input())
if N % 2 == 1:
    print(int((N+1)/2))
else:
    print(int(N/2))

Solution (Python):
import math
n = int(input())
print(math.ceil(n/2))

Solution (Python):
N = int(input())

if 1<=N<=100:
    Quotient = N//2
    Remainder = N%2
    print(Quotient+Remainder)

Solution (Python):
N = int(input())
ans=int(N/2+0.5)
print(ans)

Solution (Python):

from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LI_(): return list(map(lambda x: int(x)-1, input().split()))
def II(): return int(input())
def IF(): return float(input())
def LS(): return list(map(list, input().split()))
def S(): return list(input().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float('INF')


def solve():
    n = II()
    print((n+1)//2)
    return



if __name__ == '__main__':
    solve()

Solution (Python):
N = int(input())
print(-(-N//2))

Solution (Python):
n=int(input())
print(-(-n//2))

Solution (Python):




a = int(input())

print(-(-a//2))

Solution (Python):
import math
x = int(input())
print(math.ceil(x/2))

Solution (Python):

import numpy as np
from functools import *
import sys
sys.setrecursionlimit(100000)



def acinput():
    return list(map(int, input().split(" ")))


def II():
    return int(input())

directions=np.array([[1,0],[0,1],[-1,0],[0,-1]])
directions = list(map(np.array, directions))

mod = 10**9+7


def factorial(n):
    fact = 1
    for integer in range(1, n + 1):
        fact *= integer
    return fact



def serch(x, count):
    
            

    for d in directions:
        nx = d+x
        
        if np.all(0 <= nx) and np.all(nx < (H, W)):
            if field[nx[0]][nx[1]] == "E":
                count += 1 
                field[nx[0]][nx[1]] = "V"
                count = serch(nx, count)  
                continue
            if field[nx[0]][nx[1]] == "
                field[nx[0]][nx[1]] = "V"
                count = serch(nx, count)    
                 
    return count

N=II()

print((N//2) +N%2)

Solution (Python):
n= int(input())
print(n//2 if n%2==0 else n//2+1)

Solution (Python):
import sys
input=sys.stdin.readline


def main():
	
	
	N=int(input())
	
	
	
	
	print(-(-N//2))
	
main()

Solution (Python):
n = int(input())
m = n % 2
if m == 0:
    print(n//2)
else:
    print(n//2+1)

Solution (Python):
from math import ceil
n = int(input())
print(ceil(n/2))

Solution (Python):
n = int(input())
m = n % 2
if m == 0:
    print(n//2)
else:
    print(n//2+1)

Solution (Python):
n=int(input())
print(n//2 if n%2==0 else n//2+1)

Solution (Python):
N = int(input())
if N % 2 != 0:
    ans = (N//2)+1
if N % 2 == 0:
    ans = (N//2)
print(round(ans,N))

Solution (Python):
import math
print(math.ceil(int(input())/2))

Solution (Python):
N = int(input())
output = 0

for i in range(1, N+1, 2):
    output += 1

print(output)

Solution (Python):
n = int(input())
if n % 2 == 0:
  print(n // 2)
else:
  print(n // 2 + 1)

Solution (Python):
num = int(input())
res = int(num / 2)
if num % 2 == 1:
    print(res + 1)
else:
    print(res)

Solution (Python):
N = int(input())
print(int((N+1)/2))

Solution (Python):
N = int(input())
print(-(-N//2))

Solution (Python):
N=int(input())
if N%2!=0:
  p=int(N//2+1)
else:
  p=int(N/2)
print(p)

Solution (Python):
N = int(input())
print((N+1)//2)

Solution (Python):
N = int(input())
print((N+1)//2)

Solution (Python):

import math
n = int(input())

print(math.ceil(n/2))

Solution (Python):
import math
N = int(input())

print(int(math.ceil(N/2)))

Solution (Python):
N=int(input())
ans=-(-N//2)
print(ans)

Solution (Python):
import math
N = int(input())

if N == 1:
    print(N)
elif N%2 == 0:
    print(math.floor(N/2))
else:
    print(math.floor(N/2)+ 1)

Solution (Python):
print((int(input())+1)//2)

Solution (Python):
n = int(input())
ans = int(n / 2 + 0.5)
print(ans)

Solution (Python):
import math as m
print( m.ceil(int(input())/2) )

Solution (Python):
def main():
    hoge = int(input())
    print(-(-hoge // 2))

if __name__ == '__main__':
    main()

Solution (Python):
import sys;

N = input()
N = int(N)

if N % 2 == 1:
    print(str(N // 2 + 1))
else:
    print(str(N // 2))

Solution (Python):
n = int(input())

print(int((n+1)/2))

Solution (Python):
import math
page = int(input())
print(math.ceil(page / 2))

Solution (Python):
N = int(input())
print(int(N/2+0.5))

Solution (Python):
print(-(-int(input())//2))

Solution (Python):
n=int(input())
nn=(n-1)//2+1
print(nn)

Solution (Python):
n = int(input())
print(n//2+n % 2)

Solution (Python):
N = int(input())
if N % 2 == 0:
    p = N // 2
else:
    p = (N // 2) + 1
print(p)

Solution (Python):
N = int(input())
div, mod = divmod(N, 2)

if mod > 0:
    div = div + 1

print(div)

Solution (Python):
N = int(input())

if N % 2 == 0:
    print(N//2)
else:
    print(N//2+1)

Solution (Python):
n = int(input())
print(n // 2 if n % 2 == 0 else n // 2 + 1)

Solution (Python):
a = int(input())
if a ==1:
    print(1)
elif a%2==0:
    print(int(a/2))
else:
    print(int(a/2+1))

Solution (Python):
n=int(input())
sei=int(n/2)
tmp=n%2
if tmp==0:
    sei=sei
else:
    sei=sei+1
print(sei)

Solution (Python):
N = int(input())
print(-(-N // 2))

Solution (Python):
import math

n = int(input())
print(math.ceil(n/2))

Solution (Python):
import math

N = int(input())

M = math.floor(N / 2)
if N % 2 != 0:
    M = M+1
print(M)

Solution (Python):
import math
N=int(input())

print(math.ceil(N/2.))

Solution (Python):
print(-(-int(input())//2))

Solution (Python):
N = int(input())

if N % 2 == 0:
    print(N//2)
else:
    print(N//2+1)

Solution (Python):
N = int(input())
output = 0

for i in range(1, N+1, 2):
    output += 1

print(output)

Solution (Python):
N = int(input())

if N % 2 == 0:
    print(N//2)
else:
    print(N//2+1)

Solution (Python):
N = int(input())
output = 0

for i in range(1, N+1, 2):
    output += 1

print(output)

Solution (Python):
N = int(input())
I = N // 2
mod = N % 2
print(I + mod)

Solution (Python):
N = int(input())

if N % 2 == 0:
    print(N//2)
else:
    print(N//2+1)

Solution (Python):
n= int(input())
if n % 2 == 0:
    print(n//2)
else:
    print(n//2 + 1)

Solution (Python):
n = int(input())
if n%2 == 1:
	print(n//2+1)
else:
	print(n//2)

Solution (Python):
"""
// Author : snape_here - Susanta Mukherjee
     
"""
 
from __future__ import division, print_function
 
import os,sys
from io import BytesIO, IOBase
 
if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip
 
 
def ii(): return int(input())
def si(): return input()
def mi(): return map(int,input().split())
def li(): return list(mi())
 
 
def gcd(x, y):
    while y:
        x, y = y, x % y
    return x
    
 
def read():
    sys.stdin = open('input.txt', 'r')  
    sys.stdout = open('output.txt', 'w') 
 
 
import math

from itertools import permutations

mod=100000007 

def main():

    n=ii()
    print(int(math.ceil(n/2)))
        


 
BUFSIZE = 8192
 
 
class FastIO(IOBase):
    newlines = 0
 
    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None
 
    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()
 
    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()
 
    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)
 
 
class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")
 
 
def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()
 
 
if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
 
input = lambda: sys.stdin.readline().rstrip("\r\n")
 

 
 
if __name__ == "__main__":
    
    main()

Solution (Python):
N = int(input())

a = int((N+1)/ 2)

print(a)

Solution (Python):
N = int(input())
if N % 2 == 0:
  N = N / 2
else:
  N  = (N + 1) / 2
print(int(N))

Solution (Python):
N = int(input())
if N%2==0:
  print(N//2)
else:
  print(N//2+1)

Solution (Python):
N=int(input())
print((N+1)//2)

Solution (Python):
a=int(input())
import math
print(math.ceil(a/2))

Solution (Python):
from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
import itertools
from functools import *
from itertools import permutations,combinations,groupby
import sys
import bisect
import string
import math
import time
import random
def Golf():
    *a,=map(int,open(0))
def S_():
    return input()
def IS():
    return input().split()
def LS():
    return [i for i in input().split()]
def I():
    return int(input())
def MI():
    return map(int,input().split())
def LI():
    return [int(i) for i in input().split()]
def LI_():
    return [int(i)-1 for i in input().split()]
def NI(n):
    return [int(input()) for i in range(n)]
def NI_(n):
    return [int(input())-1 for i in range(n)]
def StoI():
    return [ord(i)-97 for i in input()]
def ItoS(nn):
    return chr(nn+97)
def LtoS(ls):
    return ''.join([chr(i+97) for i in ls])
def GI(V,E,Directed=False,index=0):
    org_inp=[]
    g=[[] for i in range(n)]
    for i in range(E):
        inp=LI()
        org_inp.append(inp)
        if index==0:
            inp[0]-=1
            inp[1]-=1
        if len(inp)==2:
            a,b=inp
            g[a].append(b)
            if not Directed:
                g[b].append(a)
        elif len(inp)==3:
            a,b,c=inp
            aa=(inp[0],inp[2])
            bb=(inp[1],inp[2])
            g[a].append(bb)
            if not Directed:
                g[b].append(aa)
    return g,org_inp
def GGI(h,w,search=None,replacement_of_found='.',mp_def={'

    mp=[1]*(w+2)
    found={}
    for i in range(h):
        s=input()
        for char in search:
            if char in s:
                found[char]=((i+1)*(w+2)+s.index(char)+1)
                mp_def[char]=mp_def[replacement_of_found]
        mp+=[1]+[mp_def[j] for j in s]+[1]
    mp+=[1]*(w+2)
    return h+2,w+2,mp,found
def bit_combination(k,n=2):
    rt=[]
    for tb in range(n**k):
        s=[tb//(n**bt)%n for bt in range(k)]
        rt+=[s]
    return rt
def show(*inp,end='\n'):
    if show_flg:
        print(*inp,end=end)
YN=['YES','NO']
Yn=['Yes','No']
 
mo=10**9+7
inf=float('inf')
l_alp=string.ascii_lowercase
u_alp=string.ascii_uppercase


input=lambda: sys.stdin.readline().rstrip()
 
def ran_input():
    import random
    n=random.randint(4,16)
    rmin,rmax=1,10
    a=[random.randint(rmin,rmax) for _ in range(n)]
    return n,a

def ran_input():
    import random
    n=random.randint(4,16)
    rmin,rmax=1,10
    a=[random.randint(rmin,rmax) for _ in range(n)]
    return n,a


class UnionFind:
    def __init__(self, n):
        
        
        self.table = [-1] * n
        self.cnt = [1] * n
 
    def _root(self, x):
        if self.table[x] < 0:
            return x
        else:
            
            self.table[x] = self._root(self.table[x])
            return self.table[x]
 
    def find(self, x, y):
        return self._root(x) == self._root(y)
 
    def union(self, x, y):
        r1 = self._root(x)
        r2 = self._root(y)
        if r1 == r2:
            return
        
        d1 = self.table[r1]
        d2 = self.table[r2]
        if d1 <= d2:
            self.table[r2] = r1
            self.cnt[r1]+=self.cnt[r2]
            if d1 == d2:
                self.table[r1] -= 1
                
        else:
            self.table[r1] = r2
            self.cnt[r2]+=self.cnt[r1]
    
    def __str__(self):
        rt=[i if j<0 else j for i,j in enumerate(self.table)]
        return str(rt)

show_flg=False
show_flg=True

n=I()


print((1+n)//2)

Solution (Python):
import math
N = int(input())
print(math.ceil(N/2))

Solution (Python):
N = int(input())
if N % 2 == 0:
  print( N // 2)
else:
  print( N // 2 + 1)

Solution (Python):

n = int(input())
if n%2 == 0:
    print(n//2)
else:
    print(n//2+1)

Solution (Python):
N = int(input())

if N%2==0:
  print(N//2)
else:
  print(N//2+1)

Solution (Python):
n=int(input())
if n%2==0 :
  print(n//2)
else :
  print((n//2)+1)

Solution (Python):
input_line = int(input())

if input_line % 2 == 0:
    result = input_line // 2
    print(result)
else:
    result = input_line // 2
    print(result + 1)

Solution (Python):
n=int(input())
print((n+1)//2)

Solution (Python):
n=int(input())
if n % 2 == 0:
    print(n//2)
else:
    print(n//2+1)

Solution (Python):
n = int(input())
ans = 0
if n % 2 == 1:
    ans = n // 2 + 1
else:
    ans = n // 2
print(ans)

Solution (Python):
a = int(input())
print((a + 1)//2)

Solution (Python):
inputs = list(map(int, (input().split())))

a = inputs[0]

b = a % 2
c = int(a / 2)

print(b + c)

Solution (Python):
N = int(input())

if N % 2 == 0:
    print(int(N/2))
else :
    print(1+int(N/2) )

Solution (Python):
n = int(input())

if n % 2 == 0:
    print(int(n/2))
else:
    print(int(n//2 + 1))

Solution (Python):
N = int(input())

if N % 2 == 0:
    print(N//2)
else:
    print(N//2+1)

Solution (Python):
N = int(input())
sheet = 0
while N > 0:
    if N % 2 >= 0:
        sheet += 1
    N -= 2
print(sheet)

Solution (Python):
N = int(input())
A = N%2
B = int((N+A)/2)
print(B)

Solution (Python):

"""
Created on Fri Jan 24 14:37:00 2020

@author: matsui
"""

N=int(input())
ans=N//2+N%2
print(int(ans))

Solution (Python):
n = int(input())
print(-(-1*n//2))

Solution (Python):
n = int(input())
print(-(-n//2))

Solution (Python):
n = int(input())

if int(n/2) == n/2:
    print(int(n/2))
else:
    print(int(n/2)+1)

Solution (Python):
n=int(input())
if n%2==0:
  print(int(n/2))
else:
  print(int((n+1)/2))

Solution (Python):
N = int(input())
S = -(-N // 2)
print (S)

Solution (Python):
from math import ceil
n = int(input())
print(ceil(n/2))

Solution (Python):
n = int(input())

if n % 2 == 0:
  a = n / 2
  print(int(a))
  
else:
  b = n / 2 + 1
  print(int(b))

Solution (Python):
import math

N = int(input())
P = math.ceil(N/2)

print(P)

Solution (Python):
N = int(input())
if N%2==0:
    print(N//2)
else:
    print(N//2+1)

Solution (Python):
N = int(input())
if N % 2 == 1:
    print(int(N / 2) + 1)
else:
    print(int(N / 2))

Solution (Python):
n=int(input())
if n%2==0:
  print(n//2)
else:
  print((n+1)//2)

Solution (Python):
N = int(input())
print((N+1)//2)

Solution (Python):
N = int(input())
print(N//2 + N % 2)

Solution (Python):
n=input()
N=float(n)
k=N%2
if k==0:
    print(round(N/2.0))
else:
    print(round(N/2+1/2.0))

Solution (Python):
try:
  N = int(input())
  if N % 2 == 0:
    print(N // 2)
  else:
    print(N // 2 + 1)
    
except EOFError:
  pass

Solution (Python):


N=int(input())

print(N//2+N%2)

Solution (Python):
N = int(input())

a = (N + 1) // 2

print(a)

Solution (Python):
n = int(input())

p = int(n / 2)
if n % 2 > 0:
    p = p + 1

print(p)

Solution (Python):
line = input()
line = int(line)
ans = line % 2
q = line / 2
print(int(q + ans))

Solution (Python):
import math

if __name__ == "__main__":
    n = int(input())
    a = n%2
    b = math.floor(n/2)
    if a==0:
        print(b)
    else:
        print(b + 1)

Solution (Python):
N = input()
intN=int(N)
if intN%2 == 0:
    print(intN//2)
else:
    print(intN//2 +1)

Solution (Python):
num = input()
num = int(num)

page = int(num/2)

if num%2 != 0:
  page += 1

print(page)

Solution (Python):

n=int(input())
if n%2 ==0:
    print(int(n/2))
else:
    print(int(n/2) +1)

Solution (Python):

n = int(input())

if n % 2 == 0:
    print(int(n/2))
else:
    n+=1
    print(int(n/2))

Solution (Python):
n=int(input())

if n/2==0:
    print(n//2)
else:
    print((n+1)//2)

Solution (Python):
n = int(input())

a = - ( -n // 2)

print(a)

Solution (Python):
import math

N = int(input())

print(math.ceil(N/2))

Solution (Python):
N = int(input())

if N%2 == 0:
    print(N//2)
else:
    print(N//2 + 1)

Solution (Python):

num = input()
if int(num) % 2 == 0:
  print(int(num) // 2)
else:
  print(int(num) // 2 + 1)

Solution (Python):
n = int(input())
print(n // 2  + (n % 2))

Solution (Python):
N = int(input())
if N%2 ==1:
    N += 1
print(int(N/2))

Solution (Python):
N = int(input())
ans = 0
if N %2 == 0:
    ans = int(N/2)
else:
    ans = int(N/2) + 1

print(ans)

Solution (Python):
def main():
	n=int(input())
	if n%2==0:
		print(n//2)
	else:
		print(n//2+1)
main()

Solution (Python):
N = int(input())

if N % 2 == 1:
  print(int(N/2+1))
elif N % 2 == 0:
  print(int(N/2))

Solution (Python):
import math
n = int(input())
res = n / 2

print(math.ceil(res))

Solution (Python):
N = int(input())
if N % 2 == 1:
    N = N+1
N = int(N / 2)
print(N)

Solution (Python):



from math import ceil

def main():
  n = int(input())
  print(ceil(n/2))

if __name__=='__main__':
  main()

Solution (Python):
n = int(input())
if n % 2 == 1:
    print(n//2 + 1)
else: print(n//2)

Solution (Python):
N = int(input())
print(-(-N // 2))

Solution (Python):
N = int(input())

if N % 2 == 0:
    print(N//2)
else:
    print(N//2+1)

Solution (Python):
n=int(input())

print((n+1)//2)

Solution (Python):
import math
N = int(input())
print(int(math.ceil(N/2)))

Solution (Python):
N=int(input())
if N%2==0:
  print(int(N/2))
else:
  print(int(N//2+1))

Solution (Python):
n = int(input())
if n%2==0:
  print(n//2)
else:
  print(n//2+1)

Solution (Python):
import math

a=int(input())
s=a/2
print(math.ceil(s))

Solution (Python):
n = int(input())
re = (n + 1) // 2
print(re)

Solution (Python):


def solve():
    return str((int(input())+1)//2)

if __name__ == '__main__':
    print(solve())

Solution (Python):
n=int(input())
print((n+1)//2)

Solution (Python):
n = int(input())

if n%2==0:
  print(n//2)
else:
  print(n//2+1)

Solution (Python):
n=int(input())
print(n//2+n%2)

Solution (Python):
import math
N = input()
n = int(N)
print(math.ceil(n/2))

Solution (Python):
N = int(input())

if N % 2 == 0:
    print(N//2)
else:
    print(N//2+1)

Solution (Python):
import math
N = int(input())
if(1<=N<=100):
    if(N%2==0):
        print(int(N/2))
    else:
        print(math.ceil(N/2))

Solution (Python):
a = int(input())

if a % 2 == 0:
    print(a//2)
else:
    print(a //2 +1)

Solution (Python):
n=int(input())
if n%2:
    print(n//2+1)
else:
    print(n//2)

Solution (Python):
N=int(input())

print((N//2)+N%2)

Solution (Python):
import sys
import math

for line in sys.stdin.readlines():
    n = float(line)
    ans = math.ceil(n / 2)
    print(ans, end="")
    break

Solution (Python):
import math
print(math.ceil(int(input())/2))

Solution (Python):
print((int(input())+1)//2)

Solution (Python):
n = int(input())
print(n // 2 + n % 2)

Solution (Python):
N = int(input())

if N == 1 or N == 2:
    print(1)

elif N % 2 == 0:
    print(N//2)

else:
    print(-(-N//2))

Solution (Python):
N = int(input())
  
if N % 2 == 0:
  print(N // 2)
else:
  print(N//2 + 1)

Solution (Python):
N = int(input())

if N%2 == 0:
  print(int(N/2))
else:
  print(int((N/2))+1)

Solution (Python):
def Main(N):
    return N//2+1 if N%2 else N//2

def main():
    N = int(input())
    print(Main(N))

if __name__ == '__main__':
    main()

Solution (Python):
n = int(input())
if n / 2 > n // 2:
    print(n // 2 + 1)
else:
    print(n // 2)

Solution (Python):
i = int(input())
j= i/2
if (i%2==0):
    print(int(j))
elif (i%2 !=0):
    print(int(j+1))

Solution (Python):
n=int(input())
print(n//2+n%2)