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):
n = int(input())
print(- (- n // 2))

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

print((N + 1) // 2)

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

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

Solution (Python):
from math import ceil
N = int(input())
print(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())

print(n//2+n%2)

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

Solution (Python):
import sys
sys.setrecursionlimit(10 ** 7)

N = int(input())

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

print(ans)

Solution (Python):
import math

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

    
main()

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

Solution (Python):
from sys import stdin
N = int(stdin.readline().rstrip())
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):
n = int(input())
print((n + 1) // 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):

import copy
import random
import bisect 
import fractions 
import math
import sys
import collections

mod = 10**9+7
sys.setrecursionlimit(mod) 

d = collections.deque()
def LI(): return list(map(int, sys.stdin.readline().split()))

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):
import sys
input = sys.stdin.readline

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

if __name__ == "__main__":
    main()

Solution (Python):
n=int(input())
print(n//2+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 sys

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

    return 0

if __name__ =="__main__":
    solve()

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

Solution (Python):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
from collections import deque

sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7

DR = [1, -1, 0, 0]
DC = [0, 0, 1, -1]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
     
def main():
    N = I()
    if N % 2 == 1:
        print(N//2 + 1)
    else:
        print(N//2)

main()

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

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

Solution (Python):

n = int(input())
print(n // 2 + n % 2)

Solution (Python):
N = int(input())
print(-(-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):
import math
n=int(input())
ans=math.ceil(n/2)
print(ans)

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

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

print((N+1)//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())
print( (n+1)//2 )

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

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

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

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

Solution (Python):

import sys


def solve(N: int):
    print(-(-N//2))
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  
    solve(N)

if __name__ == '__main__':
    main()

Solution (Python):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(500000)

n = int(read())

print((n + 1) // 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())

print(math.ceil(n/2))

Solution (Python):
def examA():
    N = I()
    ans = N//2 + N%2
    print(ans)
    return

def examB():
    ans = 0
    print(ans)
    return

def examC():
    ans = 0
    print(ans)
    return

def examD():
    ans = 0
    print(ans)
    return

def examE():
    ans = 0
    print(ans)
    return

def examF():
    ans = 0
    print(ans)
    return

import sys,copy,bisect,itertools,heapq,math,random
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
_ep = 10**(-12)
alphabet = [chr(ord('a') + i) for i in range(26)]

if __name__ == '__main__':
    examA()

"""

"""

Solution (Python):
import numpy as np


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



if __name__ == '__main__':
    main()

Solution (Python):
import sys

sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))

N = ir()
answer = (N+1) // 2
print(answer)

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

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):

N=int(input())

print(N//2+N%2)

Solution (Python):
from sys import stdin
import math
def input():
	return stdin.readline()[:-1]

def intput():
	return int(input().rstrip())

def sinput():
	return input().rstrip().split()

def intsput():
	return map(int, sinput())

def main():
	n = intput()
	print(n//2+(n%2))


if __name__ == '__main__':
	main()

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)
else:
    print(N // 2 + 1)

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

print(-(-n//2))

Solution (Python):

import sys
import math



n=int(input())



print((n+1)//2)

Solution (Python):
def main():

    N = int(input())
    return (N+1) // 2

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

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

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:
    print(N//2)
else:
    print(N//2+1)

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

if __name__ == '__main__':
    main()

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):
n = int(input())
print((n+1)//2)

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

print((N+1) // 2)

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

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



print((n+1)//2)

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

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

Solution (Python):
import sys
from math import floor, ceil
def get_ints(): return map(int, sys.stdin.readline().strip().split())
def get_array(): return list(map(int, sys.stdin.readline().strip().split()))
def input(): return sys.stdin.readline().strip()

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

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+n%2)

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

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

import math

print(math.ceil(N/2))

Solution (Python):
import math


print(math.ceil(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())
print((n + 1) // 2)

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

Solution (Python):
INT = lambda: int(input())
INTM = lambda: map(int,input().split())
STRM = lambda: map(str,input().split())
STR = lambda: str(input())
LIST = lambda: list(map(int,input().split()))
LISTS = lambda: list(map(str,input().split()))
def do(): 
    n=INT()
    print((n+1)//2)
if __name__ == '__main__':
    do()

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

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

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

Solution (Python):
import sys
sys.setrecursionlimit(10 ** 6)
input = sys.stdin.readline
N = int(input())
print(N // 2 + N % 2)

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

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

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

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

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())
print(math.ceil(N/2))

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

Solution (Python):
import math
import fractions
import bisect
import collections
import itertools
import heapq
import string
import sys
import copy
from collections import deque
sys.setrecursionlimit(10**7)
MOD = 10**9+7
def gcd(a,b):return fractions.gcd(a,b) 
def lcm(a,b):return (a*b) // fractions.gcd(a,b) 
def iin(): return int(input()) 
def ifn(): return float(input()) 
def isn(): return input().split() 
def imn(): return map(int, input().split()) 
def fmn(): return map(float, input().split()) 
def iln(): return list(map(int, input().split())) 
def iln_s(): return sorted(iln()) 
def iln_r(): return sorted(iln(), reverse=True) 
def fln(): return list(map(float, input().split())) 
def join(l, s=''): return s.join(l) 
def perm(l, n): return itertools.permutations(l, n) 
def perm_count(n, r): return math.factorial(n) // math.factorial(n-r) 
def comb(l, n): return itertools.combinations(l, n) 
def comb_count(n, r): return math.factorial(n) // (math.factorial(n-r) * math.factorial(r)) 
def two_distance(a, b, c, d): return ((c-a)**2 + (d-b)**2)**.5 
def m_add(a,b): return (a+b) % MOD

def sieves_of_e(n):
    is_prime = [True] * (n+1)
    is_prime[0] = False
    is_prime[1] = False
    for i in range(2, int(n**0.5)+1):
        if not is_prime[i]: continue
        for j in range(i * 2, n+1, i): is_prime[j] = False
    return is_prime

N = iin()

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 sys

stdin = sys.stdin

ns = lambda: stdin.readline().rstrip()
ni = lambda: int(stdin.readline().rstrip())
nm = lambda: map(int, stdin.readline().split())
nl = lambda: list(map(int, stdin.readline().split()))

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

Solution (Python):
import math
n = int(input())
print(math.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):
n=int(input())
print((n+1)//2)

Solution (Python):
from itertools import accumulate, permutations, combinations, product, combinations_with_replacement, groupby
from math import floor, ceil, sqrt, factorial, log
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict
from heapq import heappop, heappush, heappushpop
from itertools import product
import sys
stdin = sys.stdin
mod = 10**9 + 7


def ns(): return stdin.readline().rstrip()


def ni(): return int(ns())


def na(): return list(map(int, stdin.readline().split()))


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

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())
print((N+1)//2)

Solution (Python):


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

Solution (Python):
















n = int(input())


def ceil(a, b):
    return -(-a // b)


print(ceil(n, 2))

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

q, r = divmod(n, 2)
ans = q + r
print(ans)

Solution (Python):
N = int(input())
if N % 2 == 0:
    print(N // 2)
else:
    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 + 1) // 2)

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

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

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

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

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

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

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

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

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

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+n%2)

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

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

print ((N + 1) // 2)

Solution (Python):
import sys
import math
import collections
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())

ans = (N+2-1) // 2
print(ans)

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

Solution (Python):
n = int(input())
q, mod = divmod(n, 2)
print(q+mod)

Solution (Python):
import math,itertools,fractions,heapq,collections,bisect,sys,queue,copy

sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return input()

def main():
  n=I()
  return (n+1)//2


print(main())

Solution (Python):


import sys
from collections import Counter

def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7

N = INT()

print(ceil(N, 2))

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

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


if __name__ == '__main__':
    main()

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

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

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

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

print(math.ceil(N/2))

Solution (Python):
import sys
sys.setrecursionlimit(4100000)

import math

import logging

logging.basicConfig(level=logging.DEBUG)

logger = logging.getLogger(__name__)


def resolve():
    
    N = [int(x) for x in sys.stdin.readline().split()][0]  
    
    

    
    
    
    

    logger.debug('{}'.format([]))

    print(math.ceil(N / 2))


if __name__ == "__main__":
    resolve()





import sys
from io import StringIO
import unittest


class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)

    def test_入力例_1(self):
        input = """5"""
        output = """3"""
        self.assertIO(input, output)

    def test_入力例_2(self):
        input = """2"""
        output = """1"""
        self.assertIO(input, output)

    def test_入力例_3(self):
        input = """100"""
        output = """50"""
        self.assertIO(input, output)

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

print((N + 2 - 1) // 2)

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

Solution (Python):

import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub

sys.setrecursionlimit(100000)
input = sys.stdin.readline
INF = 2**62-1

def read_int():
    return int(input())


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


def read_float():
    return float(input())


def read_float_n():
    return list(map(float, input().split()))


def read_str():
    return input().strip()


def read_str_n():
    return list(map(str, input().split()))


def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(N):
    return -(-N//2)


def main():
    N = read_int()
    print(slv(N))


if __name__ == '__main__':
    main()

Solution (Python):
import math
print(math.ceil(int(input())/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):
import math
N=int(input())
print(math.ceil(N/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):
import sys
def input():
    return sys.stdin.readline()[:-1]

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



    ans = -(-N // 2)
    print(ans)

if __name__ == "__main__":
    main()

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

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

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

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

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

print((N+1)//2)

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


if __name__ == '__main__':
    resolve()

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

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

print(-(-n//2))

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

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

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 math

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

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

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

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

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())

def ceil(a, b):
   return a // b + (a % b > 0)

print(ceil(n,2))

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

Solution (Python):
from math import ceil
print(ceil(int(input())/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())

ans = -(-n//2)
print(ans)

Solution (Python):
print((int(input()) + 1) // 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())
print(n//2 + n%2)

Solution (Python):
import math

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

Solution (Python):
from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
import itertools
from itertools import permutations, combinations, accumulate
import sys
import bisect
import string
import math
import time


def I(): return int(input())


def S(): return input()


def MI(): return map(int, input().split())


def MS(): return map(str, input().split())


def LI(): return [int(i) for i in input().split()]


def LI_(): return [int(i)-1 for i in input().split()]


def StoI(): return [ord(i)-97 for i in input()]


def ItoS(nn): return chr(nn+97)


def input(): return sys.stdin.readline().rstrip()


def show(*inp, end='\n'):
    if show_flg:
        print(*inp, end=end)


YNL = {False: 'No', True: 'Yes'}
YNU = {False: 'NO', True: 'YES'}
MOD = 10**9+7
inf = float('inf')
IINF = 10**10
l_alp = string.ascii_lowercase
u_alp = string.ascii_uppercase
ts = time.time()
sys.setrecursionlimit(10**6)
nums = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']

show_flg = False



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


if __name__ == '__main__':
    main()

Solution (Python):
from math import ceil

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

Solution (Python):
import sys
from math import *
from collections import deque, Counter, defaultdict
from fractions import gcd
input = lambda: sys.stdin.readline().rstrip()

def eprint(s):
    sys.stderr.write('DEBUG: {}'.format(s))
    return

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

if __name__ == '__main__':
    main()

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

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

Solution (Python):
from math import ceil

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

Solution (Python):
N = int(input())
print(-(-N//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(math.ceil(N/2))

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

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 8)

input = sys.stdin.readline


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

if __name__ == '__main__':
    main()

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

Solution (Python):


import sys
 
stdin = sys.stdin
inf = 1 << 60
mod = 1000000007
 
ni = lambda: int(ns())
nin = lambda y: [ni() for _ in range(y)]
na = lambda: list(map(int, stdin.readline().split()))
nan = lambda y: [na() for _ in range(y)]
ns = lambda: stdin.readline().rstrip()
nsn = lambda y: [ns() for _ in range(y)]
ncl = lambda y: [list(ns()) for _ in range(y)]
nas = lambda: stdin.readline().split()

from math import ceil

n = ni()

print(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())
print((N + 1) // 2)

Solution (Python):
import math
from functools import reduce
from collections import deque
import sys
sys.setrecursionlimit(10**7)


def get_nums_l():
    return [ int(s) for s in input().split(" ")]


def get_nums_n(n):
    return [ int(input()) for _ in range(n)]


def get_all_int():
    return map(int, open(0).read().split())

def log(*args):
    print("DEBUG:", *args, file=sys.stderr)

n, = get_nums_l()

print((n+1)//2)

Solution (Python):
import sys
import math
def i():return int(sys.stdin.readline().replace("\n",""))
def i2():return map(int,sys.stdin.readline().replace("\n","").split())
def s():return str(sys.stdin.readline().replace("\n",""))
def l():return list(sys.stdin.readline().replace("\n",""))
def intl():return [int(k) for k in sys.stdin.readline().replace("\n","").split()]
def lx():return list(map(lambda x:int(x)*-1,sys.stdin.readline().replace("\n","").split()))
def t():return tuple(map(int,sys.stdin.readline().replace("\n","").split()))

if __name__ == "__main__":pass

n = i()
print(n//2 if n%2==0 else 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());print((N+1)//2)

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

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

Solution (Python):
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd
 
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
 
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

N = INT()
print(ceil(N/2))

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

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(math.ceil(n/2))

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

print(-1*(-1*n//2))

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

print((N+1)//2)

Solution (Python):
import sys

read = sys.stdin.read
readline = sys.stdin.readline

N = int(input())
print((N + 1) // 2)

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

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

print(-(-n//2))

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

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

if __name__ == "__main__":
    main()

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



print(-(-1*n//2))

Solution (Python):
from math import ceil, sqrt

from collections import defaultdict


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

Solution (Python):
n=int(input())
import math
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())

print((n+1)//2)

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

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):











import sys
sys.setrecursionlimit(10**6)
input=sys.stdin.readline
from math import floor,sqrt,factorial,hypot,log 
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from copy import deepcopy
from fractions import gcd
from random import randint
def ceil(a,b): return (a+b-1)//b
inf=float('inf')
mod = 10**9+7
def pprint(*A): 
    for a in A:     print(*a,sep='\n')
def INT_(n): return int(n)-1
def MI(): return map(int,input().split())
def MF(): return map(float, input().split())
def MI_(): return map(INT_,input().split())
def LI(): return list(MI())
def LI_(): return [int(x) - 1 for x in input().split()]
def LF(): return list(MF())
def LIN(n:int): return [I() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]
def LLIN_(n: int): return [LI_() for _ in range(n)]
def LLI(): return [list(map(int, l.split() )) for l in input()]
def I(): return int(input())
def F(): return float(input())
def ST(): return input().replace('\n', '')
def main():
    N=I()
    print(ceil(N,2))
if __name__ == '__main__':
    main()

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

Solution (Python):
def main():
    print((int( input())+1)//2)
if __name__ == '__main__':
    main()

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


def read_values():
    return map(int, input().split())


def read_index():
    return map(lambda x: x - 1, map(int, input().split()))


def read_list():
    return list(read_values())


def read_lists(N):
    return [read_list() for n in range(N)]


def functional(N, mod):
    F = [1] * (N + 1)
    for i in range(N):
        F[i + 1] = (i + 1) * F[i] % mod
    return F


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


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//2))

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

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

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

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


if __name__ == '__main__':
    main()

Solution (Python):


from collections import deque, defaultdict
import itertools as ite
import sys
import math
from decimal import *

sys.setrecursionlimit(1000000)

INF = 10 ** 18
MOD = 10 ** 9 + 7

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

Solution (Python):
import math
import itertools
import fractions
import heapq
import collections
import bisect
import sys
import copy

sys.setrecursionlimit(10**9)
mod = 10**7+9
inf = 10**20

def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()

n = I()
print(math.ceil(n/2))

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

print(math.ceil(N / 2))

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

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

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

Solution (Python):
import sys
from collections import *
import heapq
import math
import bisect
from itertools import permutations,accumulate,combinations,product
from fractions import gcd
def input():
    return sys.stdin.readline()[:-1]
def ruiseki(lst):
    return [0]+list(accumulate(lst))
mod=pow(10,9)+7

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