#include <fstream>
#include <list>
#include <set>
#include <vector>
using namespace std;

class InParser {
private:
	FILE *fin;
	char *buff;
	int sp;

	char read_ch() {
		++sp;
		if (sp == 4096) {
			sp = 0;
			fread(buff, 1, 4096, fin);
		}
		return buff[sp];
	}

public:
	InParser(const char* nume) {
		fin = fopen(nume, "r");
		buff = new char[4096]();
		sp = 4095;
	}

	InParser& operator >> (int &n) {
		char c;
		while (!isdigit(c = read_ch()) && c != '-');
		int sgn = 1;
		if (c == '-') {
			n = 0;
			sgn = -1;
		} else {
			n = c - '0';
		}
		while (isdigit(c = read_ch())) {
			n = 10 * n + c - '0';
		}
		n *= sgn;
		return *this;
	}

	InParser& operator >> (long long &n) {
		char c;
		n = 0;
		while (!isdigit(c = read_ch()) && c != '-');
		long long sgn = 1;
		if (c == '-') {
			n = 0;
			sgn = -1;
		} else {
			n = c - '0';
		}
		while (isdigit(c = read_ch())) {
			n = 10 * n + c - '0';
		}
		n *= sgn;
		return *this;
	}
};
InParser cin("adunare.in");

ofstream cout("adunare.out");



struct ura{
    long double x,y;
}v[100001];
long double sol = 0;

void aria(){
    int n,i;
    //cin >> n;
    for(i = 1;i <= n;i++){
        //cin >> v[i].x >> v[i].y;
    }
    v[n + 1].x = v[1].x;
    v[n + 1].y = v[1].y;
    for(i = 1;i <= n;i++){
        sol += (v[i].x * v[i + 1].y - v[i+1].x * v[i].y);
    }
    sol /= 2;
    //cout <<fixed<<setprecision(10)<< sol;
}

struct Edge
{
    long long u;
    long long v;
    long long weight;
};
 class Graph
{
    long long V ;
    list < pair <long long, long long > >*adj;

    vector < Edge > edge;

public :
    Graph( long long V )
    {
        this->V = V ;
        adj = new list < pair <long long, long long > >[V];
    }

    void addEdge ( long long u, long long v, long long w );
    void removeEdge( long long u, long long v, long long w );
    long long  ShortestPath (long long u, long long v );
    void RemoveEdge( long long u, long long v );
    long long FindMinimumCycle ();

};

void Graph :: addEdge ( long long u, long long v, long long w )
{
    adj[u].push_back( make_pair( v, w ));
    adj[v].push_back( make_pair( u, w ));

    Edge e { u, v, w };
    edge.push_back (  e );
}
 void Graph :: removeEdge ( long long u, long long v, long long w )
{
    adj[u].remove(make_pair( v, w ));
    adj[v].remove(make_pair(u, w ));
}
long long Graph :: ShortestPath ( long long u, long long v )
{

    set< pair<long long, long long> > setds;


    vector<long long> dist(V, INT_MAX);
    setds.insert(make_pair(0, u));
    dist[u] = 0;

    while (!setds.empty())
    {

        pair<long long, long long> tmp = *(setds.begin());
        setds.erase(setds.begin());
        long long u = tmp.second;

        list< pair<long long, long long> >::iterator i;
        for (i = adj[u].begin(); i != adj[u].end(); ++i)
        {
            long long v = (*i).first;
            long long weight = (*i).second;

            if (dist[v] > dist[u] + weight)
            {
                if (dist[v] != INT_MAX)
                    setds.erase(setds.find(make_pair(dist[v], v)));

                dist[v] = dist[u] + weight;
                setds.insert(make_pair(dist[v], v));
            }
        }
    }

    return dist[v] ;
}
 long long Graph :: FindMinimumCycle ( )
{
    long long min_cycle = INT_MAX;
    long long E = edge.size();
    for ( long long i = 0 ; i < E  ; i++ )
    {
        Edge e = edge[i];


        removeEdge( e.u, e.v, e.weight ) ;

        long long vistance = ShortestPath( e.u, e.v );

        min_cycle = min( min_cycle, vistance + e.weight );

        addEdge( e.u, e.v, e.weight );
    }

    return min_cycle ;
}
int main()
{
    long long a,b;
    cin >> a >> b;
    cout << a + b;
    return 0;
}