/* please kill me */
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/detail/standard_policies.hpp>
using namespace std;
using namespace __gnu_pbds;
#pragma GCC optimize("Ofast,unroll-loops")
#pragma GCC target("avx,avx2,fma")
#define ios ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define ordered_set tree<pair<long long, long long>, null_type,less<pair<long long, long long>>, rb_tree_tag,tree_order_statistics_node_update>
#define mp(a, b) make_pair(a, b)
#define emplace(a) emplace_back(a)
#define sqrt(a) sqrtl(a)
#define ll long long
#define ulli unsigned long long int
#define all(v) v.begin(), v.end()
#define pii pair<int, int>
#define plli pair<ll, int>
#define s second
#define f first
const ll mod = 1e9 + 7;
/* ADDITIONAL
ulli factorial(ulli x){
ulli ans = 1;
FOR(i, 2, x){
ans *= i;
}
return ans;
}
ulli binocoeff(ulli n, ulli x){
ulli ans = 1;
for(int i = n - x + 1; i <= n; i++){
ans *= i;
}
ans /= factorial(x);
return ans;
}
ll binpow(ll a, ll b, ll m){
if(b == 0) return 1;
if(b % 2 == 1) return a * binpow(a, b - 1, m) % m;
else return binpow(a * a % m, b / 2, m);
}
void primeSieve(long n){
bool prime[1000001];//<-
//initalize in global
prime[1] = false;
prime[2] = true;
for(long i = 3; i <= n; i += 2){
prime[i] = true;
}
for(long i = 2; i * i <= n; i++){
if(prime[i]){
for(long j = i * i; j <= n; j += 2 * i){
prime[j] = false;
}
}
}
}
long gcd(long a, long b){
return b == 0 ? a : gcd(b, a % b);
}
long lcm(long a, long b){
return ((a * b) / gcd(a, b));
}
void lcs(ll n, ll m, ll x){
ll A[101], B[101], C[101];//in global
ll dp[n + 1][m + 1][x + 1];
FOR(i, 1, n + 1){
FOR(j, 1, m + 1){
FOR(k, 1, x + 1){
if(i == 0 || j == 0 || k == 0) dp[i][j][k] = 0;
else if(A[i - 1] == B[j - 1]) dp[i][j][k] = dp[i - 1][j - 1][k - 1] + 1;
else dp[i][j][k] = max(dp[i - 1][j][k], max(dp[i][j - 1][k], dp[i][j][k - 1]));
}
}
}
cout << dp[n][m][x] << "\n";
}
void LIS(vector<int> const& a){
int n = a.size();
vector<int> d(n, 1);
for (int i = 0; i < n; i++) {
for (int j = 0; j < i; j++) {
if (a[j] < a[i])
d[i] = max(d[i], d[j] + 1);
}
}
int ans = d[0];
for (int i = 1; i < n; i++) {
ans = max(ans, d[i]);
}
cout << ans;
}
void bfs(int node){
q.push(node);
visited[node] = 1;
while(!q.empty()){
curr = q.front();
q.pop();
for(auto i : arr[curr]){
if(!visited[i]){
q.push(i);
visited[i] = 1;
ancs[i] = curr;
}
}
}
}
void printPath(int v){
if(v == 0){
cout << cnt - 1 << "\n";
return;
}
cnt++;
printPath(ancs[v]);
cout << v << " ";
}
void dfs(int node){
visited[node] = 1;
for(auto i : v[node]){
if(!visited[i]){
dfs(i);
}
}
}
int frsLower(vector<int>&v, int x){
int l = 0, r = v.size() - 1, best = -1;
while(l <= r){
int mid = l + (r - l) / 2;
if(v[mid] <= x){
best = mid;
l = mid + 1;
}else r = mid - 1;
}
return best;
}
void dijkstra(int s, vector<int> & d, vector<int> & p) {
///const int INF = 1000000000; < --------
///vector<vector<pair<int, int>>> adj; <- INITIALIZE IN GLOBAL
int n = adj.size();
d.assign(n, INF);
p.assign(n, -1);
vector<bool> u(n, false);
d[s] = 0;
for (int i = 0; i < n; i++) {
int v = -1;
for (int j = 0; j < n; j++) {
if (!u[j] && (v == -1 || d[j] < d[v]))
v = j;
}
if (d[v] == INF)
break;
u[v] = true;
for (auto edge : adj[v]) {
int to = edge.first;
int len = edge.second;
if (d[v] + len < d[to]) {
d[to] = d[v] + len;
p[to] = v;
}
}
}
}
void bellmanford()
{
vector<int> d(n, INF);
d[v] = 0;
vector<int> p(n, -1);
for (;;) {
bool any = false;
for (Edge e : edges)
if (d[e.a] < INF)
if (d[e.b] > d[e.a] + e.cost) {
d[e.b] = d[e.a] + e.cost;
p[e.b] = e.a;
any = true;
}
if (!any)
break;
}
if (d[t] == INF)
cout << "No path from " << v << " to " << t << ".";
else {
vector<int> path;
for (int cur = t; cur != -1; cur = p[cur])
path.push_back(cur);
reverse(path.begin(), path.end());
cout << "Path from " << v << " to " << t << ": ";
for (int u : path)
cout << u << ' ';
}
}
*/
/* SEGMENT TREE
int arr[100005], st[400005];
long gcd(long a, long b){
return b == 0 ? a : gcd(b, a % b);
}
void build(int v, int l, int r){
if(l == r) st[v] = arr[l];
else{
long long m = (l + r) / 2;
build(2 * v, l, m);
build(2 * v + 1, m + 1, r);
st[v] = gcd(st[2 * v], st[2 * v + 1]);///<-
///dont forget to change above ------------\
}
}
void update(int v, int l, int r, int qind, int val){
if(l == r) st[v] = val;
else{
long long m = (l + r) / 2;
if(qind <= m) update(2 * v, l, m, qind, val);
else update(2 * v + 1, m + 1, r, qind, val);
st[v] = gcd(st[2 * v], st[2 * v + 1]);
}
}
int find_gcd(int v, int l, int r, int ql, int qr){
if(l > qr || r < ql) return 1;
if(ql <= l && r <= qr) return st[v];
long long m = (l + r) /2;
int fr = find_gcd(2 * v, l, m, ql, qr);
int sc = find_gcd(2 * v + 1, m + 1, r, ql, qr);
return gcd(fr, sc);
}
int find_min(int v, int l, int r, int ql, int qr){
if(l > qr || r < ql) return INT_MAX;
if(ql <= l && r <= qr) return st[v];
long long m = (l + r) /2;
int fr = find_min(2 * v, l, m, ql, qr);
int sc = find_min(2 * v + 1, m + 1, r, ql, qr);
return min(fr, sc);
}
int find_max(int v, int l, int r, int ql, int qr){
if(l > qr || r < ql) return INT_MIN;
if(ql <= l && r <= qr) return st[v];
long long m = (l + r) /2;
int fr = find_max(2 * v, l, m, ql, qr);
int sc = find_max(2 * v + 1, m + 1, r, ql, qr);
return max(fr, sc);
}*/
/* LAZY SEGMENT TREE
int a[1001], st[4004], lazy[4004];
void build(int v, int l, int r){
if(l == r) st[v] = a[l];
else{
ll mid = (l + r) / 2;
build(2 * v, l, mid);
build(2 * v + 1, mid + 1, r);
st[v] = st[2 * v] + st[2 * v + 1];
}
}
void push(int v, int l, int r){
if(lazy[v] == -1) return;
ll mid = (l + r) / 2;
st[2 * v] += (mid - l + 1) * lazy[v];
st[2 * v + 1] += (r - mid) * lazy[v];
lazy[2 * v] = lazy[2 * v + 1] = lazy[v];
lazy[v] = -1;
}
void lazy_update(int v, int l, int r, int ql, int qr, int val){
if(qr < l || r < ql) return;
if(l != r) push(v, l, r);
if(ql <= l && r <= qr){
lazy[v] = val;
st[v] += val * (r - l + 1);
return;
}
ll mid = (l + r) / 2;
lazy_update(2 * v, l, mid, ql, qr, val);
lazy_update(2 * v + 1, mid + 1, r, ql, qr, val);
st[v] = st[2 * v] + st[2 * v + 1];
}
int query(int v, int l, int r, int ql, int qr){
if(qr < l || r < ql) return 0;
if(ql <= l && r <= qr) return st[v];
else{
ll mid = (l + r) / 2;
int fr = query(2 * v, l, mid, ql, qr);
int sc = query(2 * v + 1, mid + 1, r, ql, qr);
return (fr + sc);
}
}
///DONT FORGOR TO MEMSET LAZY ARR WITH -1
}*/
/* SPARSE TABLE
const int K = 25;
int st[K + 1][100001];
int log2_floor(unsigned long long i) {
return i ? __builtin_clzll(1) - __builtin_clzll(i) : -1;
}
void STBuildRMQ(){
for(int i = 1; i <= K; i++){
for(int j = 1; j + (1 << i) < 7; j++){
st[i][j] = min(st[i - 1][j], st[i - 1][j + (1 << (i - 1))]);
}
}
}
*/
/* INT128 FUNCS
__int128 read() {
__int128 x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
void print(__int128 shit){
if (shit < 0) {
putchar('-');
shit = -shit;
}
if (shit > 9) print(shit / 10);
putchar(shit % 10 + '0');
}
_int128 binpow(_int128 a, __int128 b, __int128 m){
if(b == 0) return 1;
if(b % 2 == 1) return a * binpow(a, b - 1, m) % m;
else return binpow(a * a % m, b / 2, m);
}
bool cmp(__int128 x, __int128 y) { return x > y; }
*/
void solve(){
int a, b;
cin >> a >> b;
cout << a + b;
}
int main(){
ios;
int t = 1;
//cin >> t;
while(t--) solve();
}
