#include<iostream>
#include <algorithm>
#include<string>
#include <bitset>
#include <vector>
#include <functional>
#include <climits>
#include <iomanip>
#include <utility>
#include <string.h>
using namespace std;
using ll = long long;
typedef pair <int, int> pii;

int main()
{

	ll a = 0, b = 0, c = 0, d = 0, e = 0, f = 0, g = 0, h = 0, ans = 0;
	//cout << LONG_MAX << endl;
	//long long n, A[1000000000];
	//ll n, m, q;
	cin >> a;
	cin >> b;
	cout<<a+b/2<<endl;
	////std::cout << std::fixed;
	//cout << std::setprecision(20) << << endl;
	//cout << d+1 << endl;
	//cout << "" << endl;

	return 0;
}
//lower_bound(A, A + n, d)//配列のなかからd以上のなかの最小値を探して配列番号を返す関数
//#include<iostream>
//#include <algorithm>
//#include<string>
//#include <bitset>
//#include <vector>
//#include <functional>
//#include <climits>
//#include <iomanip>
//#include <utility>
//using namespace std;
//using ll = long long;
//typedef pair <int, int> pii;
//int main()
//{
//
//	//int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0, g = 0, h = 0, ans = 0;
//	ll a = 0, b = 0, c = 0, d = 0, e = 0, f = 0, g = 0, h = 0, i = 0, j = 0, k = 0, l = 0, ans = 0;
//	//cout << LONG_MAX << endl;
//	string s, t;
//	//long long n, A[1000000000];
//	int n, m, q;
//	//int   y[100001], z[100001], x[10001] = {};
//	//pii y[100001];
//	//pair<int, float> pii[100001];
//	ll A[100001];
//	cin >> s;
//	while (s.length() <= 9)
//	{
//		s.insert(0, "0");
//
//	}
//	cout << s.length() << endl;
//	cout << s << endl;
//	A[9] = 0;
//	for (A[0] = 0; A[0] < 2; A[0]++)
//	{
//		for (A[1] = 0; A[1] < 2; A[1]++)
//		{
//			for (A[2] = 0; A[2] < 2; A[2]++)
//			{
//				for (A[3] = 0; A[3] < 2; A[3]++)
//				{
//					for (A[4] = 0; A[4] < 2; A[4]++)
//					{
//						for (A[5] = 0; A[5] < 2; A[5]++)
//						{
//							for (A[6] = 0; A[6] < 2; A[6]++)
//							{
//								for (A[7] = 0; A[7] < 2; A[7]++)
//								{
//									for (A[8] = 0; A[8] < 2; A[8]++)
//									{
//										c = 1;
//										for ( b = 9; b >= 0; b--)
//										{
//											if (A[b]==0)
//											{
//												c = 1;
//											}
//											d += c*(s[b] - '0');
//											c *= 10;
//											cout << "c*(s[b] - '0')=" << c*(s[b] - '0') << endl;
//											cout << d << endl;
//										}
//										//if (b == 0)
//										//{
//										//	for (a = 0; a < 9; a++)
//										//	{
//										//		if (s.length() <= a)
//										//		{
//										//			A[a] = 2;
//										//			cout <<  a << endl;
//										//		}
//
//										//	}
//										//	b = 1;
//										//}
//										//for (i = 0; i < s.length(); i++)
//										//{
//										//	if (A[i] != 2)
//										//	{
//										//		t += s[i];
//										//		cout << t << endl;
//										//		t = "";
//
//										//		if (A[i])
//										//		{
//										//			// a+=strtol(t, NULL, 10);
//										//			a += stoll(t);
//										//			t = "";
//										//		}
//										//	}
//										//}
//									}
//								}
//							}
//						}
//					}
//				}
//			}
//		}
//	}
//	//c += l;
//	//d = l;
//	//while (d != 0)
//	//{
//	//	a++;
//	//	d /= 10;
//	//}
//	//d = 1;
//	//for (a = a; a > 0; a--)
//	//{
//	//	e = 1;
//	//	
//
//	//	f = (l / pow(10, a - 1));
//	//	f %= 10;
//	//	for (b = pow(10,a-2); b >= 1; b /= 10)
//	//	{
//	//		cout << b*e*d*f << endl;
//
//	//		c += b*e*d*f;
//	//		e *= 2;
//	//	}
//	//	d *= 2;
//	//}
//
//	/*while (l == 0)
//	{
//		a++;
//		l /= 10;
//	}
//	c += l;
//	if (a >= 2)
//	{
//		d = l;
//		e = 10;
//		for (b = 0; b < a-1; b++)
//		{
//			c += l / e;
//			c += l - (l / e)*e;
//			e *= 10;
//		}
//	}
//	if (a >= 3)
//	{
//		d = l;
//		e = 10;
//		for (b = 0; b < a-1; b++)
//		{
//			c += l / e;
//			c += l - (l / e)*e;
//
//			e *= 10;
//
//		}
//	}*/
//
//
//	////std::cout << std::fixed;
//	//cout << std::setprecision(20) << << endl;
//	//cout << d+1 << endl;
//	//cout << "" << endl;
//	cout << d << endl;
//
//
//	return 0;
//}
////lower_bound(A, A + n, d)//配列のなかからd以上のなかの最小値を探して配列番号を返す関数


//#include<iostream>
//#include <algorithm>
//#include<string>
//#include <bitset>
//#include <vector>
//#include <functional>
//#include <climits>
//#include <iomanip>
//#include <utility>
//#include <iomanip>
//using namespace std;
//typedef pair <int, int> pii;
//typedef long long ll;
//ll mul(ll a[2], ll b[2][2]) {
//ll(*mul22(ll a[][2], ll b[][2]))[2]{
//	ll c[2][2] = {}; //initialize(c, a.length(), b[0].length);
//for (ll i = 0; i < 2; i++) {
//	for (ll k = 0; k < 2; k++) {
//		for (ll j = 0; j < 2; j++) {
//			c[i][j] = (c[i][j] + a[i][k] * b[k][j]);
//		}
//	}
//}
//return c;
//}
//
//ll(*mul21(ll a[][2], ll b[][1]))[2]{
//	ll c[2][2] = {}; //initialize(c, a.length(), b[0].length);
//for (ll i = 0; i < 2; i++) {
//	for (ll k = 0; k < 2; k++) {
//		for (ll j = 0; j < 1; j++) {
//			c[i][j] = (c[i][j] + a[i][k] * b[k][j]);
//		}
//	}
//}
//return c;
//}



//ll result = fibonacci(10000000000);
//console.log(result);
//int main()
//{
//
//	//int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0, g = 0, h = 0, ans = 0;
//	long long  d = 0, e = 0, f = 0, g = 0, h = 0, i = 0, j = 0, k = 0, l = 0, ans = 0;
//	//cout << LONG_MAX << endl;
//	string s, t;
//	//long long n, A[1000000000];
//	long long n, m;
//	//int   y[100001], z[100001], x[10001] = {};
//	//pii y[100001];
//	//pair<int, float> pii[100001];
//	int x[1003];
//	cin >> n;
//	/*b = 1;
//	c = 0;
//	d = 0;
//	for (a = 0; a < n; a++)
//	{
//		d = b;
//		b = b + c;
//		c = d;
//		b %= 1000000007;
//		c %= 1000000007;
//	}*/
//	ll a[2][2] = { { 1,1 }, { 1,0 } };
//	ll b[2] = { 1,1 };
//	ll c[2][2] = {};
//	for (d = 1; d < 30; d++)
//	{
//		a[0][0] = 1;
//		a[0][1] = 1;
//		a[1][0] = 1;
//		a[1][1] = 0;
//		b[0] = 1;
//		b[1] = 1;
//		n = d;
//		while (n > 0) {
//			if (n & 1)
//			{
//				c[0][0] = 0;
//				c[0][1] = 0;
//				c[1][0] = 0;
//				c[1][1] = 0;
//				for (ll i = 0; i < 2; i++) {
//					for (ll k = 0; k < 2; k++) {
//						for (ll j = 0; j < 1; j++) {
//							c[i][j] = (c[i][j] + a[i][k] * b[k]);
//						}
//					}
//				}
//				b[0] = c[0][0];
//				b[1] = c[1][0];
//			}// ll(*b)[1] = mul21(a, b);
//
//			//a = mul22(a, a);
//			c[0][0] = 0;
//			c[0][1] = 0;
//			c[1][0] = 0;
//			c[1][1] = 0;
//			for (ll i = 0; i < 2; i++) {
//				for (ll k = 0; k < 2; k++) {
//					for (ll j = 0; j < 2; j++) {
//						c[i][j] = (c[i][j] + a[i][k] * b[k]);
//					}
//				}
//			}
//			a[0][0] = c[0][0];
//			a[0][1] = c[0][1];
//			a[1][0] = c[1][0];
//			a[1][1] = c[1][1];
//			n >>= 1;
//		}
//		cout << a[1][0] % 1000000007 << endl;
//
//	}
//
//	////std::cout << std::fixed;
//	//cout << std::setprecision(20) << << endl;
//	cout << a[1][0] % 1000000007 << endl;
//
//	return 0;
//}
//#include<iostream>
//#include <algorithm>
//#include<string>
//#include <bitset>
//#include <vector>
//#include <functional>
//#include <climits>
//#include <iomanip>
//#include <utility>
//using namespace std;
//typedef pair <int, int> pii;
//int main()
//{
//
//	//int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0, g = 0, h = 0, ans = 0;
//	int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0, g = 0, h = 0, i = 0, j = 0, k = 0, l = 0, ans = 0;
//	//cout << LONG_MAX << endl;
//	string s, t;
//	//long long n, A[1000000000];
//	long long n, m;
//	//int   y[100001], z[100001], x[10001] = {};
//	pii y[100001];
//	//pair<int, float> pii[100001];
//	cin >> n;
//	cin >> m;
//	for (a = 0; a < m; a++)
//	{
//		cin >>b;
//		cin >>c;
//		y[a] = pii(b, c);
//	}
//	sort(y, y + m);
//	//int temp;
//	//for (i = 0; i < m - 1; i++) {
//	//	for (j = m - 1; j > i; j--) {
//	//		if (y[j - 1] > y[j]) {
//	//			temp = y[j];        /* 交換する */
//	//			y[j] = y[j - 1];
//	//			y[j - 1] = temp;
//
//	//			temp = z[j];        /* 交換する */
//	//			z[j] = z[j - 1];
//	//			z[j - 1] = temp;
//	//		}
//	//	}
//	//}
//	//cin >> a;
//	//cin >> b;
//	//cin >> c;
//	//cin >> d;
//	//for (a = 0; a < m; a++)
//	//{
//	//	cout << y[a].first << endl;
//
//	//}for (a = 0; a < m; a++)
//	//{
//	//	cout << y[a].second << endl;
//
//	//}
//	//m = 0;
//	b = 100000000;
//	c = 0;
//	for (a = 0; a < m; a++)
//	{
//		c = y[a].second;
//		//cout << c << endl;
//
//		b = min(b,c);
//		
//		if (y[a].first >= b)
//		{
//			d++;
//			b = 100000000;
//			a--;
//		}
//	}
//	//for ( a = 1; a <= n; a++)
//	//{
//	//	for ( b = 0; b < m; b++)
//	//	{
//	//		if (a==y[b])
//	//		{
//	//			//c = 1;
//	//			y[b] = 0;
//	//			x[e] = b;
//	//			e++;
//	//			
//	//		}
//	//		if (a==z[b]&&y[b]==0)
//	//		{
//	//			while (e!=0)
//	//			{
//	//				e--;
//	//				y[x[e]] = 0;
//	//				z[x[e]] = 0;
//	//			}
//	//			/*for ( c = 0; c < m; c++)
//	//			{
//	//				if (y[c]==0)
//	//				{
//	//					y[c] = -1;
//	//					z[c] = -1;
//	//				}
//	//			}*/
//	//			d++;
//	//		}
//	//	}
//	//}
//	////std::cout << std::fixed;
//	//cout << std::setprecision(20) << << endl;
//	cout << d+1 << endl;
//
//	return 0;
//}


//#include<iostream>
//#include <algorithm>
//#include<string>
//#include <bitset>
//#include <vector>
//#include <functional>
//#include <climits>
//#include <iomanip>
//using namespace std;
//int main()
//{
//
//	//int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0, g = 0, h = 0, ans = 0;
//	long a = 0, b = 0, c = 0, d = 0, e = 0, f = 0, g = 0, h = 0, i = 0, j = 0, k = 0, l = 0, ans = 0;
//	//cout << LONG_MAX << endl;
//	//string s[1001];
//	//long long n, A[1000000000];
//	long n, m;
//	//string s;
//	cin >> n;
//	cin >> m;
//	cin >> d;
//	std::cout << std::fixed;
//	cout << std::setprecision(20) << ((double)n-d)*n*(m-1)*m/(pow(n, m)) << endl;
//	return 0;
//}


//#include<iostream>
//#include <algorithm>
//#include<string>
//#include <bitset>
//#include <vector>
//#include <functional>
//#include <climits>
//#include <iomanip>
//using namespace std;
//int main()
//{
//
//	//int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0, g = 0, h = 0, ans = 0;
//	long long a = 0, b = 0, c = 0, d = 0, e = 0, f = 0, g = 0, h = 0, i = 0, j = 0, k = 0, l = 0, ans = 0;
//	//cout << LONG_MAX << endl;
//	//string s[1001];
//	//long long n, A[1000000000];
//	//string s;
//	long long n, q, r;
//	int X[100002] = {}, C, D;
//	//int X[101] = {}, C[101] = {}, D[101] = {};
//	cin >> n;
//	cin >> q;
//	for (a = 1; a <= n; a++)
//	{
//		cin >> X[a];
//	}
//	X[0] =    -9999999999999;
//	X[n + 1] = 9999999999999;
//	/*for (a = 0; a < n; a++)
//	{
//		cin >> X[a];
//	}*/
//	for (f = 0; f < q; f++)
//	{
//		cin >> C;
//		cin >> D;
//		d = n;
//		b = 0;
//		e = 0;
//		r = n + 1;
//		l = 0;
//		while (r - l >= 1)
//		{
//			a = (r + l) / 2;
//			if (X[a] < C - D&&X[a + 1] >= C - D)
//			{
//				break;
//			}
//			else if (X[a] >= C - D)
//			{
//				r = a;
//			}
//			else
//			{
//				l = a + 1;
//			}
//			//cout << l << "," << r << endl;
//			if (r==l)
//			{
//				a = r;
//			}
//		}
//		//cout << "a=" << a << endl;
//		r = n + 1;
//		l = 0;
//		while (r - l >= 1)
//		{
//			b = (r + l) / 2;
//			if (X[b-1] <= C + D&&X[b] > C + D)
//			{
//				break;
//			}
//			else if (X[b] >= C + D)
//			{
//				r = b;
//			}
//			else
//			{
//				l = b+1;
//			}
//			if (r == l)
//			{
//				b = r;
//			}
//			//cout << l << "," << r << endl;
//
//		}
//		//cout << "b=" << b << endl;
//
//		for (c = a+1; c < b; c++)
//		{
//			e += abs(X[c] - C);
//			d--;
//		}
//		e += d*D;
//		/*while (r - l >= 1)
//		{
//			a = (r + l) / 2;
//			if (X[a] < C - D&&X[a+1] >= C - D)
//			{
//				break;
//			}
//			else if (X[a] > C - D)
//			{
//				r = a;
//			}
//			else
//			{
//				l = a+1;
//			}
//			cout << l << "," << r << endl;
//
//		}
//		cout << "a=" << a << endl;
//		r = n + 1;
//		l = 0;
//		while (r - l >= 1)
//		{
//			b = (r + l) / 2;
//			if (X[b] <= C + D&&X[b+1] > C + D)
//			{
//				break;
//			}
//			else if (X[b] > C + D)
//			{
//				r = b + 1;
//			}
//			else
//			{
//				l = b;
//			}
//			cout << l << "," << r << endl;
//
//		}
//		cout << "b=" << b << endl;
//
//		for (c = a+1; c <= b; c++)
//		{
//			e += abs(X[c] - C);
//			d--;
//		}
//		e += d*D;*/
//		//while ((C-D)-X[b]>0)
//		//{
//		//	d--;
//		//	e += C - X[b];
//		//	b++;
//		//}
//		//b = n - 1;
//		//while (X[b]-(C+D)>0)
//		//{
//		//	d--;
//		//	e += X[b]-C;
//		//	b--;
//		//}
//		//e += d*D;
//		//cout << e << endl;
//		/*d = 0;
//		for ( b = 0; b < n; b++)
//		{
//			c = abs(C - X[b]);
//			if (c<=D)
//			{
//				d += c;
//			}
//			else
//			{
//				d += D;
//			}
//		}
//		cout << d<< endl;*/
//		cout << e << endl;
//
//	}
//
//
//	return 0;
//}

//#include<iostream>
//#include <algorithm>
//#include<string>
//#include <bitset>
//#include <vector>
//#include <functional>
//#include <climits>
//#include <iomanip>
//using namespace std;
//int main()
//{
//
//	//int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0, g = 0, h = 0, ans = 0;
//	long long a = 0, b = 0, c = 0, d = 0, e = 0, f = 0, g = 0, h = 0, i = 0, j = 0, k = 0, l = 0, ans = 0;
//	//cout << LONG_MAX << endl;
//	//string s[1001];
//	//long long n, A[1000000000];
//	int  w;
//	cin >> h;
//	cin >> w;
//	string p[51];
//	for (a = 1; a <= h; a++)
//	{
//		cin >> p[a];
//
//	}
//	long double dis, mini = 0;
//	cout << mini * 2 << endl;
//
//	mini = 10000000000;
//	std::cout << std::setprecision(10) << mini * 2 << endl; // "3.1"
//
//	//int hnow, wnow;
//	for (a = 0; a <= h + 1; a++)
//	{
//		for (b = 0; b <= w + 1; b++)
//		{
//			dis = 0;
//
//			if ((a == 0 || a == h + 1 || b == 0 || b == w + 1) && (!(a == h && b == 0)) && (!(a == h && b == w)))
//			{
//				for (c = 1; c <= h; c++)
//				{
//					for (d = 1; d <= w; d++)
//					{
//						if (p[c][d] == '1')
//						{
//							g = (a - c)*(a - c) + (b - d)*(b - d);
//							dis += sqrt(static_cast<long double>(g));
//
//							//dis += (long double)sqrtl((long double)((a - c)*(a - c) + (b - d)*(b - d)));
//						}
//
//					}
//				}
//				cout << a << endl;
//				cout << b << endl;
//				cout << dis*2 << endl;
//
//				mini = min(mini, dis);
//				/*if (f>e)
//				{
//					f = e;
//					i = a;
//					j = b;
//				}*/
//			}
//		}
//	}
//	std::cout << std::setprecision(10) << mini * 2 << endl; // "3.1"
//	cout << mini * 2 << endl;
//	return 0;
//}


//#include<iostream>
//#include <algorithm>
//#include<string>
//#include <bitset>
//#include <vector>
//#include <functional>
//#include <climits>
//using namespace std;
////int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0, g = 0, h = 0, ans = 0;
//long long a = 0, b = 0, c = 0, d = 0, e = 0, f = 0, g = 0, h = 0, i = 0, j = 0, k = 0, l = 0, ans = 0;
////cout << LONG_MAX << endl;
////string s[1001];
//long long n, m;
//long long x[1001] = {}, y[1001] = {}, z[1001] = {}, num[1001] = {};
//long long xx[1001] = {}, yy[1001] = {}, zz[1001] = {};
//
//void BubSort()
//{
//	long long i, j, temp;
//
//	for (i = 0; i < n - 1; i++) {
//		for (j = n - 1; j > i; j--) {
//			if (num[j - 1] < num[j]) {
//				temp = num[j];        /* 交換する */
//				num[j] = num[j - 1];
//				num[j - 1] = temp;
//
//				temp = x[j];        /* 交換する */
//				x[j] = x[j - 1];
//				x[j - 1] = temp;
//
//				temp = y[j];        /* 交換する */
//				y[j] = y[j - 1];
//				y[j - 1] = temp;
//
//				temp = z[j];        /* 交換する */
//				z[j] = z[j - 1];
//				z[j - 1] = temp;
//			}
//		}
//	}
//}
//int main()
//{
//	cin >> n;
//	cin >> m;
//	for (a = 0; a < n; a++)
//	{
//		cin >> xx[a];
//		cin >> yy[a];
//		cin >> zz[a];
//	}
//	ans = LLONG_MIN;
//	int sign[2];
//	sign[0] = 1;
//	sign[1] = -1;
//	for (a = 0; a < n; a++)
//	{
//		x[a] = xx[a];
//		y[a] = yy[a];
//		z[a] = zz[a];
//	}
//	for (e = 0; e < 2; e++)
//	{
//		for (f = 0; f < 2; f++)
//		{
//			for (g = 0; g < 2; g++)
//			{
//				/*for (a = 0; a < n; a++)
//				{
//				x[a] = xx[a];
//				y[a] = yy[a];
//				z[a] = zz[a];
//				}*/
//				for (a = 0; a < n; a++)
//				{
//					num[a] = sign[e] * x[a] + sign[f] * y[a] + sign[g] * z[a];
//				}
//				BubSort();
//				b = 0;
//				c = 0;
//				d = 0;
//				for (a = 0; a < m; a++)
//				{
//					b += x[a];
//					c += y[a];
//					d += z[a];
//				}
//				ans = max(ans, abs(b) + abs(c) + abs(d));
//				b = 0;
//				c = 0;
//				d = 0;
//				for (a = n - 1; a > n - m - 1; a--)
//				{
//					b += x[a];
//					c += y[a];
//					d += z[a];
//				}
//				ans = max(ans, abs(b) + abs(c) + abs(d));
//			}
//		}
//	}
//	cout << ans << endl;
//	return 0;
//}

Measured memory_bytes: 256