You are given two positive integers a and b.
Let x be the average of a and b.
Print x rounded up to the nearest integer.

-----Constraints-----
 - a and b are integers.
 - 1 \leq a, b \leq 100

-----Input-----
Input is given from Standard Input in the following format:
a b

-----Output-----
Print x rounded up to the nearest integer.

-----Sample Input-----
1 3

-----Sample Output-----
2

The average of 1 and 3 is 2.0, and it will be rounded up to the nearest integer, 2.

Difficulty: EASY

Solutions:
(a, b) = map(int, input().split())
print((a + b + (2 - 1)) // 2)


import bisect, collections, copy, heapq, itertools, math, string
import sys

def I():
	return int(sys.stdin.readline().rstrip())

def LI():
	return list(map(int, sys.stdin.readline().rstrip().split()))

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

def LS():
	return list(sys.stdin.readline().rstrip().split())
(a, b) = LI()
x = a + b
if x % 2 == 0:
	print(x // 2)
else:
	print((x + 1) // 2)


import math
(a, b) = map(int, input().split())
print(math.ceil((a + b) / 2))


import decimal
(a, b) = list(map(int, input().split()))
num = decimal.Decimal((a + b) / 2)
ans = int(num)
if num % 1 != 0:
	ans += 1
print(ans)


import math

def mapt(fn, *args):
	return tuple(map(fn, *args))

def Input():
	return mapt(int, input().split(' '))

def main():
	(a, b) = Input()
	print(math.ceil((a + b) / 2))
main()


(a, b) = list(map(int, input().split()))
v = (a + b) // 2
mod = (a + b) % 2
if mod == 0:
	print(v)
else:
	print(v + 1)


(a, b) = map(int, input().split())
x = a + b
if x % 2 == 0:
	print(int(x / 2))
else:
	print(int((x + 1) / 2))


(a, b) = map(int, input().split())
if a % 2 == 0 and b % 2 == 0 or (a % 2 == 1 and b % 2 == 1):
	print((a + b) // 2)
else:
	print((a + b) // 2 + 1)


(a, b) = map(int, input().split())
ans = -(a + b) // 2
print(-ans)


import math
(x, y) = map(int, input().split())
print(math.ceil((x + y) / 2))


lst = input().split()
a = int(lst[0])
b = int(lst[1])
v1 = (a + b) / 2
v2 = (a + b) // 2
if v1 == v2:
	print(v2)
else:
	print(v2 + 1)


(a, b) = map(int, input().split())
print(abs(-(a + b) // 2))


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


import math
import sys
sys.setrecursionlimit(10 ** 6)
(a, b) = list(map(int, input().split()))
print(math.ceil((a + b) / 2))


(a, b) = map(int, input().split())
ans = (a + b) // 2
print(ans if a + b & 1 != 1 else ans + 1)


print((sum(map(int, input().split())) - 1) // 2 + 1)


(a, b) = list(map(int, input().split()))
c = (a + b) / 2
if c % 1 > 0:
	print(int(c + 1))
else:
	print(int(c))


import math
(a, b) = list(map(int, input().split()))
sum_ceil = math.ceil((a + b) / 2)
print(sum_ceil)


import numpy as np
X = np.array([int(x) for x in input().split()])
ans = np.ceil(np.mean(X))
print(int(ans))


(A, B) = map(int, input().split())
if (A + B) % 2 == 1:
	print((A + B) // 2 + 1)
else:
	print((A + B) // 2)


import math as mt
(a, b) = map(int, input().split())
print(mt.ceil((a + b) / 2))


import re
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque, Counter
from decimal import Decimal
import functools

def v():
	return input()

def k():
	return int(input())

def S():
	return input().split()

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

def X():
	return list(input())

def L():
	return list(input().split())

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

def lcm(a, b):
	return a * b // math.gcd(a, b)
sys.setrecursionlimit(10 ** 6)
mod = 10 ** 9 + 7
cnt = 0
ans = 0
inf = float('inf')
al = 'abcdefghijklmnopqrstuvwxyz'
AL = al.upper()
(a, b) = I()
print(math.ceil((a + b) / 2))


import math
(e1, e2) = list(map(int, input().split()))
print(math.ceil((e1 + e2) / 2))


import math
(a, b) = (int(t) for t in input().split())
x = (a + b) / 2
print(math.ceil(x))


from numpy import average
(a, b) = map(int, input().split())
print((a + b - 1) // 2 + 1)


(a, b) = list(map(int, input().split()))
print(-(-(a + b) // 2))


(a, b) = map(int, input().split())
if (a + b) % 2 == 0:
	print('{:.0f}'.format((a + b) / 2))
else:
	print('{:.0f}'.format((a + b) / 2 - 0.5 + 1))


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 = '1 3'
		output = '2'
		self.assertIO(input, output)

	def test_入力例_2(self):
		input = '7 4'
		output = '6'
		self.assertIO(input, output)

	def test_入力例_3(self):
		input = '5 5'
		output = '5'
		self.assertIO(input, output)

def resolve():
	(a, b) = list(map(int, input().split()))
	print((a + b + 1) // 2)

def __starting_point():
	resolve()
__starting_point()


import math

def main():
	(a, b) = map(int, input().split())
	print(math.ceil((a + b) / 2))

def __starting_point():
	main()
__starting_point()


(a, b) = list(map(int, input().split()))
res = (a + b + 2 - 1) // 2
print(res)


import sys
import math
sys.setrecursionlimit(10 ** 8)
ini = lambda : int(sys.stdin.readline())
inl = lambda : [int(x) for x in sys.stdin.readline().split()]
ins = lambda : sys.stdin.readline().rstrip()
debug = lambda *a, **kw: print('\x1b[33m', *a, '\x1b[0m', **dict(file=sys.stderr, **kw))
(a, b) = inl()
x = (a + b + 1) // 2
print(x)


import math
(a, b) = map(int, input().split())
multi = math.ceil((a + b) / 2)
print(str(multi))