#include <bits/stdc++.h>
using namespace std;
//#define INF MAX_INT
//copy(buf,n,str.c_str)//string转char
//sscanf(buf,"%d%d",&a,&b)//串输入处理
//sprintf(but,"%.2lf",n)//double转char *
//char *itoa(int value, char* string, int radix)//int转char* radix进制
////优读
//int read(){
// int x=0,f=1;
// char ch;
// while(ch<'0'||ch>'9') {if(ch=='-')f=-1;ch=getchar();}
// while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
// return f*x;
//}
//template<class T>void read(T &x){//read(n)
// x=0;int f=0;char ch=getchar();
// while(ch<'0'||ch>'9') {f|=(ch=='-');ch=getchar();}
// while(ch>='0'&&ch<='9'){x=(x<<1)+(x<<3)+(ch^48);ch=getchar();}
// x=f?-x:x;
// return;
//}
////大数乘法
//string mult(string s,int n){
// int i,len = s.length(),temp = 0;
// for(i = len - 1;i >= 0;i--)
// {
// temp = temp + (s[i] - '0')*n;
// s[i] = (temp%10)+'0';
// temp = temp/10;//进位
// }
// char c;
// while(temp)
// {
// c = (temp%10)+'0';
// s = c + s;
// temp /= 10;
// }
// return s;
//}
////大数除法
//string div(string a, long long b){//高精度a除以单精度b
// string r, ans;
// long long d = 0;
// if (a == "0") return a;//特判
// for (int i = 0; i<a.size(); i++)
// {
// r += (d * 10 + a[i] - '0') / b + '0';//求出商
// d = (d * 10 + (a[i] - '0')) % b;//求出余数
// }
// long long p = 0;
// for (int i = 0; i<r.size(); i++)
// if (r[i] != '0') { p = i; break; }
// return r.substr(p);
//}
////大数加法
//string add(string s1,string s2){
//
// if(s1 == ""&&s2 == "")return "0";
// if(s1 == "")return s2;
// if(s2 == "")return s1;
// string maxx = s1,minn = s2;
// if(s1.length() < s2.length())
// {
// maxx = s2;
// minn = s1;
// }
// int i,a = maxx.length()-1,b = minn.length()-1;
// for(i = b;i >=0 ;--i)
// {
// maxx[a--] += minn[i] - '0';
// }
// for(i = maxx.length() - 1;i > 0;--i)
// {
// if(maxx[i] > '9')
// {
// maxx[i] -= 10;
// maxx[i-1]++;
// }
// }
//
// if(maxx[0] > '9')
// {
// maxx[0] -= 10;
// maxx = '1'+maxx;
// }
//
// return maxx;
//}
////大数减法
//string bigIntegerSub(char *s1,char *s2){
// if(s1 == s2)
// return "0"; //相等
// int len1 = strlen(s1),len2 = strlen(s2);
// if(len1 > len2)
// return subInfo(s1,s2);
// else if(len1 < len2)
// return "-" + subInfo(s2,s1); //负数
// else { //长度相等时判断大小
// for(int i = 0; i < len1; i++){
// if(s1[i]-'0' > s2[i]-'0')
// return subInfo(s1,s2);
// else if(s1[i]-'0' < s2[i]-'0')
// return "-" + subInfo(s2,s1);
// }
// }
//}
////快速幂
//ll powermod(ll a,ll b){
// ll res = 1;
// while(b)
// {
// if(b&1) res *= a;
// a *= a;
// b >>=1;
// }
// return res;
//}
////矩阵快速幂
//struct Matrix {
// int m[N][N];
// Matrix(){}
//};
//void Init(Matrix &matrix){
// for(int i = 0;i < N; i++)scanf("%d",&matrix.m[0][i]);
// for(int i = 1;i < N; i++){
// for(int j = 0;j < N; j++){
// if(i == (j+1))matrix.m[i][j] = 1;
// else matrix.m[i][j] = 0;
// }
// }
//}
//Matrix Mul(Matrix &a,Matrix &b){//矩阵相乘
// Matrix c;
// for(int i = 0; i < N; i++){
// for(int j = 0;j < N; j++){
// c.m[i][j] = 0;
// for(int k = 0; k < N; k++)c.m[i][j] += a.m[i][k]*b.m[k][j];
// c.m[i][j] %= Mod;
// }
// }
// return c;
//}
//Matrix Pow(Matrix& matrix, int k) {//矩阵幂
// Matrix res;
// for (int i = 0; i < N; ++i)
// for (int j = 0; j < N; ++j)
// if (i == j) res.m[i][j] = 1;
// else res.m[i][j] = 0;
// while (k) {
// if (k & 1) res = Mul(matrix,res);
// k >>= 1;
// matrix = Mul(matrix,matrix);
// }
// return res;
//}
////线性筛
//int prime[maxn]; //标识
//int *p = new int[maxn/2+1];//素数数组
//int fun(){
// memset(prime,0,sizeof(int)*(maxn+1));
// memset(p,0,sizeof(int)*(maxn/2));
// int i,j,t = 0;
// for(i = 2;i <= maxn;i++)
// {
// if(prime[i] == 0)
// {
// p[t++] = i;
// }
// for(j = 0;j < t && i*p[j] <= maxn;j++)
// {
// prime[i*p[j]] = 1;
// if(i%p[j] == 0)break;
// }
// }
// return t;
//}
////gcd
//int gcd(int a,int b){
// if(b > a)swap(a,b);
// int temp;
// while(b != 0)
// {
// if(b > a)swap(a,b);
// temp = a % b;
// a = b;
// b = temp;
// }
// return a;
//}
////扩展gcd
//LL exgcd(LL a,LL b,LL &x,LL &y){
// if(b == 0){
// x = 1;
// y = 0;
// return a;
// }
// LL d = exgcd(b,a%b,x,y);
// LL t = x;
// x = y;
// y = t-(a/b)*y;
// return d;
//}
////欧拉函数
//int phi[maxn+1], phi_psum[maxn+1];
//int euler_phi(int n){
// int m = sqrt(n+0.5);
// int ans = n;
// for(int i = 2; i < m; i++)if(n % i == 0){
// ans = ans/i*(i-1);
// while(n % i == 0)n /= i;
// }
// if(n > 1)ans = ans/n*(n-1);
// return ans;
//}
//void phi_table(int n) {//筛素数的方法,求解1~n所有数的欧拉phi函数值
// phi[1] = 0; //这里不计算第一个1,1和1,1是重复的，等下直接2*phi_psum[n] + 1
// for(int i = 2; i <= n; i++) if(phi[i] == 0)
// for(int j = i; j <= n; j += i) {
// if(phi[j] == 0) phi[j] = j;
// phi[j] = phi[j] / i * (i-1);
// }
//}
////二分法
//int cmp(const void *a, const void *b) {
// return *(int *) a - *(int *) b;
//}
//int bs(int *arr,int L,int R,int target){//普通的二分查找
// while( L <= R){
// int mid = (L) + (R-L)/2;
// if(arr[mid] == target)
// return mid;
// if(arr[mid] > target)
// R = mid - 1;
// else
// L = mid + 1;
// }
// return -1; // not find
//}
//int firstEqual(int arr[], int L, int R, int target) {//求最小的i，使得a[i] = target，若不存在，则返回-1
// while (L < R) {
// int mid = L + (R - L) / 2;
// if (arr[mid] < target)
// L = mid + 1;
// else
// R = mid;
// }
// if (arr[L] == target)
// return L;
// return -1;
//}
//int lastEqualNext(int arr[], int L, int R, int target) {//求最大的i的下一个元素的下标(c++中的upperbound函数)，使得a[i] = target，若不存在，则返回-1
// while (L < R) {
// int m = L + (R - L) / 2;
// if (arr[m] <= target)
// L = m + 1;
// else
// R = m;
// }
// if (arr[L - 1] == target)
// return L;
// return -1;
//}
//int lastEqual(int arr[], int L, int R, int target) {//求最大的i，使得a[i] = target，若不存在，则返回-1
// while (L < R) {
// int mid = L + ((R + 1 - L) >> 1);//向上取整
// if (arr[mid] <= target)
// L = mid;
// else
// R = mid - 1;
// }
// if (arr[L] == target)
// return L;
// return -1;
//}
//int firstLarge(int arr[], int L, int R, int target) {//求最小的i，使得a[i] > target，若不存在，则返回-1
// while (L < R) {
// int m = L + ((R - L) >> 1);//向下取整
// if (arr[m] <= target)
// L = m + 1;
// else
// R = m;
// }
// if (arr[R] > target)
// return R;
// return -1;
//}
//int lastSmall(int arr[], int L, int R, int target) {//求最大的i，使得a[i] < target，若不存在，则返回-1
// while (L < R) {
// int m = L + ((R + 1 - L) >> 1);//向上取整
// if (arr[m] < target)
// L = m;
// else
// R = m - 1;
// }
// if (arr[L] < target)
// return L;
// return -1;
//}
////kmp
//void getNext(int *p,int next[]) { //优化后的求next数组的方法
// int len = m;
// next[0] = -1; //next 数组中的 最大长度值(前后缀的公共最大长度) 的第一个 赋值为 -1
// int k = -1,j = 0;
// while (j < len - 1) {
// if (k == -1 || p[j] == p[k]) { //p[k]表示前缀 p[j] 表示后缀
// k++; j++;
// if(p[j] != p[k])next[j] = k;
// else next[j] = next[k]; //因为不能出现p[j] = p[ next[j ]]，所以当出现时需要继续递归，k = next[k] = next[next[k]]
// }
// else k = next[k];
// }
//}
//int KMPSerach(int *s, int *p) {
// int sLen = n,pLen = m;
// int i = 0, j = 0;
// while (i < sLen && j < pLen) {
// if (j == -1 || s[i] == p[j])i++, j++;
// else j = nexts[j];
// }
// if (j == pLen)return i - j;
// else return -1;
//}
////揹包问题
//
////最大线段和
//int maxsum(int n,int b[]){
// int sum = 0,temp = 0;
// for(int i = 0;i < n;i++)
// {
// temp>0?temp+=b[i]:temp=b[i];
// if(temp > sum)sum = temp;
// }
// return sum;
//}
//int maxsum2(int m,int n,int **a){
// int *b = new int[n],sum = 0;
// for(int i = 0;i < m;i++)
// {
// for(int k = 0;k < n;k++)
// b[k] = 0;
// for(int j = i;j < m;j++)
// {
// for(int k = 0;k < n;k++)
// b[k] += a[j][k];
// int temp = maxsum(n,b);
// if(temp > sum)sum = temp;
// }
// }
// return sum;
//}
////全排列(去重)
//void permutation(int *arr,int *p,int n,int cur){
// if(cur == n){
// for(int i = 0; i < n; i++)
// printf("%d ",arr[i]);
// printf("\n");
// }else for(int i = 0; i < n; i++)if(!i || p[i] != p[i-1]){
// int c1 = 0, c2 = 0;
// for(int j = 0; j < n; j++)
// if(p[j] == p[i]) // 重复元素的个数
// c1++;
// for(int j = 0; j < cur; j++)
// if(arr[j] == p[i]) // 前面已经排列的重复元素的个数
// c2++;
// if(c2 < c1){
// arr[cur] = p[i];
// permutation(arr, p, n, cur+1);
// }
// }
//}
////全排列(函重)
//void permutation(int arr[], int cur, int n){
// if( cur == n){
// for(int i = 0; i < n; i++)
// printf("%d ", arr[i]);
// printf("\n");
// }
// else for(int i = cur; i < n; i++){
// swap(arr[i], arr[cur]);
// permutation(arr, cur+1, n);
// swap(arr[i], arr[cur]);
// }
//}
////n后排列
//int vis[n],path[n],count = 0;
//memset(path,0,sizeof(path));memset(vis,0,sizeof(vis));DFS(1);
//void DFS(int tmp){//tmp目前排了多少皇后，x目前排的列，path具体排法
// if (tmp == 9)
// { //8个行均排满
// count++;
// for (int i = 1; i <= 8; i++)
// {
// printf("%d ",path[i]);
// }
// printf(" %d\n",count);
// return;
// }
// for (int i = 1; i <= 8; i++)//8个列循环扫描
// {
// if (!vis[i])
// {
// bool flag = false;
// for (int j = 1; j < tmp; j++)
// {
// if (tmp - i == j - path[j] || tmp + i == path[j] + j)
// {
// flag = true;
// break;
// }
// }
// if (flag) continue;
// vis[i] = true;
// path[tmp] = i;//标记位置
// DFS(tmp + 1);//下一行
// vis[i] = false;
// path[tmp] = 0;
// }
// }
//}
////并查集
//int parent[maxn], rank[maxn]; //parent[]保存祖先,rank记录每个'树的高度'
//void init(){
// for(int i = 0; i < maxn; i++)parent[i] = i; //注意这里
// for(int i = 0; i < maxn; i++)rank[i] = 1;
//}
//int findRoot(int v){
// while(parent[v] != v){
// parent[v] = parent[parent[v]]; // 路径压缩
// v = parent[v];
// }
// return v;
//}
//void unions(int a, int b){
// int aRoot = findRoot(a);
// int bRoot = findRoot(b);
// if (aRoot == bRoot)
// return;
// if (rank[aRoot] < rank[bRoot])
// parent[aRoot] = bRoot;
// else if(rank[aRoot] > rank[bRoot]){
// parent[bRoot] = aRoot;
// }else{
// parent[aRoot] = bRoot;
// rank[bRoot]++;
// }
//}
//int is_same(int x,int y){ //检查是不是在同一个集合中
// return findRoot(x) == findRoot(y);
//}
////树状数组
//int lowbit(int x){//计算2^k
// return x&(-x);
//}
//void update(int i,int val){//更新数组的值
// while(i < maxn){ //注意这里是最大的x,没有记录所以用maxn,不能用n
// c[i] += val;
// i += lowbit(i); //不断的往上面更新
// }
//}
//int sum(int i){//查询
// int s = 0;
// while(i > 0){
// s += c[i];
// i -= lowbit(i); //不断的往下面加
// }
// return s;
//}
////LCS
//int LCS(char *s1,char *s2){
// int len1 = strlen(s1)-1,len2 = strlen(s2)-1;//注意例如 abcfbc的strlen(s1)为7,所以是strlen(s1) - 1
// for(int i = 0; i <= len1; i++) dp[i][0] = 0;
// for(int i = 0; i <= len2; i++) dp[0][i] = 0;
// for(int i = 1; i <= len1; i++){
// for(int j = 1; j <= len2; j++)
// if(s1[i] == s2[j]){
// dp[i][j] = dp[i-1][j-1] + 1;
// path[i][j] = 1;
// }
// else if(dp[i-1][j] >= dp[i][j-1]) {
// dp[i][j] = dp[i-1][j];
// path[i][j] = 2;
// }
// else {
// dp[i][j] = dp[i][j-1];
// path[i][j] = 3;
// }
// }
// return dp[len1][len2];
//}
////堆优化dijkstra
//struct Node{
// int v,w;
// Node(int v,int w):v(v),w(w){}
// bool operator < (const Node&rhs) const {
// return rhs.w < w;
// }
//};
//vector<Node>G[maxn];
//bool vis[maxn];
//int d[maxn];
//int n,m;
//void init(){
// for(int i = 0; i < maxn; i++)G[i].clear();
// for(int i = 0; i < maxn; i++)vis[i] = false;
// for(int i = 0; i < maxn; i++)d[i] = INF;
//}
//int dijkstra(int s,int e){ //传入起点终点
// priority_queue<Node>q;
// q.push(Node(s,0));
// d[s] = 0;
// while(!q.empty()){
// Node now = q.top(); q.pop();
// int v = now.v;
// if(vis[v])continue;
// vis[v] = true;
// for(int i = 0; i < G[v].size(); i++){
// int v2 = G[v][i].v;
// int w = G[v][i].w;
// if(!vis[v2] && d[v2] > w+d[v]){
// d[v2] = w+d[v];
// q.push(Node(v2,d[v2]));
// }
// }
// }
// return d[e];
//}
////用于最长非递减子序列种的lower_bound函数
//int cmp(int a,int b){
// return a <= b;
//}
////最长上升子序列
////dp[i]表示长度为i+1的上升子序列的最末尾元素 找到第一个比dp末尾大的来代替
//int LIS(int n){
// memset(dp, 0x3f, sizeof(dp));
// pos[0] = -1;
// int i,lpos;
// for (i = 0; i < n; ++i){
// dp[lpos = (lower_bound(dp, dp + n, a[i]) - dp)] = a[i];
// pos[lpos] = i; // *靠后打印
// fa[i] = (lpos ? pos[lpos - 1] : -1);
// }
// n = lower_bound(dp, dp + n, INF) - dp;
// for (i = pos[n - 1]; ~fa[i]; i = fa[i]) ans.push_back(a[i]);
// ans.push_back(a[i]);
// return n;
//}
////非递减的LIS
//int LISS(int n){
// memset(dp, 0x3f, sizeof(dp));
// pos[0] = -1;
// int i,lpos;
// for (i = 0; i < n; i++){
// dp[lpos = (lower_bound(dp, dp + n, a[i],cmp) - dp)] = a[i]; //注意这里cmp
// pos[lpos] = i; // *靠后打印
// fa[i] = (lpos ? pos[lpos - 1] : -1);
// }
// n = lower_bound(dp, dp + n, INF) - dp;
// for (i = pos[n - 1]; ~fa[i]; i = fa[i]) ans.push_back(a[i]);
// ans.push_back(a[i]);
// return n;
//}
int main()
{
int a,b;
cin >> a >> b;
cout << a+b << endl;
return 0;
}
