#include<algorithm>
#include<bitset>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<deque>
#include<fstream>
#include<iostream>
#include<map>
#include<queue>
#include<set>
#include<stack>
#include<utility>
#include<vector>

using namespace std;

#define dbg(x) (cout<<#x<<" = "<<(x)<<'\n')

typedef long long int lld;
typedef pair<int,int> PII;

const int INF = (1<<31)-1;
const lld LINF = (1LL<<63)-1;

/* Work In Progress*/

struct Huge
{
    vector<int> cifre;
    // numere negative - WIIIIIIP

    Huge()
    {
        cifre.resize(0);
    }

    /*
     * Atribuire
     */

    void operator=(int b)
    {
        cifre.resize(0);
        while(b)
        {
            cifre.push_back(b%10);
            b/=10;
        }
    }

    void operator=(Huge B)
    {
        cifre=B.cifre;
    }

    /*
     * Adunare
     */

    Huge operator+(int b)
    {
        int i,a,c,t=b;
        Huge C;
        for(i=0; i<cifre.size(); i++)
        {
            a=cifre[i];
            c=a+t;
            C.cifre.push_back(c%10);
            t=c/10;
        }
        while(t)
        {
            C.cifre.push_back(t%10);
            t/=10;
        }
        return C;
    }

    Huge operator+(Huge B)
    {
        int i,a,b,c,t=0;
        Huge C;
        for(i=0; i<max(cifre.size(),B.cifre.size()); i++)
        {
            if(i>=cifre.size()) a=0;
            else a=cifre[i];
            if(i>=B.cifre.size()) b=0;
            else b=B.cifre[i];
            c=a+b+t;
            C.cifre.push_back(c%10);
            t=c/10;
        }
        while(t)
        {
            C.cifre.push_back(t%10);
            t/=10;
        }
        return C;
    }

    /*
     * Scadere
     */

    Huge operator-(int b)
    {
        int i,a,c,t=-b;
        Huge C;
        for(i=0; i<cifre.size(); i++)
        {
            a=cifre[i];
            c=a+t;
            C.cifre.push_back(c%10);
            t=c/10;
            if(C.cifre.back()<0) C.cifre.back()+=10,t--;
        }
        while(C.cifre.back()==0)
        {
            C.cifre.pop_back();
        }
        return C;
    }

    Huge operator-(Huge B)
    {
        int i,a,b,c,t=0;
        Huge C;
        for(i=0; i<max(cifre.size(),B.cifre.size()); i++)
        {
            if(i>=cifre.size()) a=0;
            else a=cifre[i];
            if(i>=B.cifre.size()) b=0;
            else b=-B.cifre[i];
            c=a+b+t;
            C.cifre.push_back(c%10);
            t=c/10;
            if(C.cifre.back()<0) C.cifre.back()+=10,t--;
        }
        while(C.cifre.back()==0)
        {
            C.cifre.pop_back();
        }
        return C;
    }

    /*
     * Inmultire
     */

    Huge operator*(int b)
    {
        int i,a,c,t=0;
        Huge C;
        for(i=0; i<cifre.size(); i++)
        {
            a=cifre[i];
            c=(a*b)+t;
            C.cifre.push_back(c%10);
            t=c/10;
        }
        while(t)
        {
            C.cifre.push_back(t%10);
            t/=10;
        }
        return C;
    }

    // WIIIIIIP
    Huge operator*(Huge B)
    {
        Huge C;
        return C;
    }

    /*
     * Impartire intreaga
     */

    // WIIIIIIP
    Huge operator/(int b)
    {
        Huge C;
        return C;
    }

    // WIIIIIIP
    Huge operator/(Huge B)
    {
        Huge C;
        return C;
    }

    /*
     * Modulo
     */

    // WIIIIIIP
    Huge operator%(int b)
    {
        Huge C;
        return C;
    }

    // WIIIIIIP
    Huge operator%(Huge B)
    {
        Huge C;
        return C;
    }

    /*
     * Operatori logici
     */

    bool operator<(Huge B)
    {
        if(cifre.size()<B.cifre.size()) return 1;
        if(cifre.size()>B.cifre.size()) return 0;
        vector<int>::reverse_iterator it,jt;
        for(it=cifre.rbegin(),jt=B.cifre.rbegin(); it!=cifre.rend() && jt!=B.cifre.rend(); it++,jt++)
            if(*it<*jt) return 1;
            else if(*it>*jt) return 0;
        return 0;
    }

    bool operator>(Huge B)
    {
        if(cifre.size()<B.cifre.size()) return 0;
        if(cifre.size()>B.cifre.size()) return 1;
        vector<int>::reverse_iterator it,jt;
        for(it=cifre.rbegin(),jt=B.cifre.rbegin(); it!=cifre.rend() && jt!=B.cifre.rend(); it++,jt++)
            if(*it<*jt) return 0;
            else if(*it>*jt) return 1;
        return 0;
    }

    bool operator==(Huge B)
    {
        if(cifre.size()!=B.cifre.size()) return 0;
        vector<int>::reverse_iterator it,jt;
        for(it=cifre.rbegin(),jt=B.cifre.rbegin(); it!=cifre.rend() && jt!=B.cifre.rend(); it++,jt++)
            if(*it!=*jt) return 0;
        return 1;
    }

    bool operator<=(Huge B)
    {
        if(cifre.size()<B.cifre.size()) return 1;
        if(cifre.size()>B.cifre.size()) return 0;
        vector<int>::reverse_iterator it,jt;
        for(it=cifre.rbegin(),jt=B.cifre.rbegin(); it!=cifre.rend() && jt!=B.cifre.rend(); it++,jt++)
            if(*it<*jt) return 1;
            else if(*it>*jt) return 0;
        return 1;
    }

    bool operator>=(Huge B)
    {
        if(cifre.size()<B.cifre.size()) return 0;
        if(cifre.size()>B.cifre.size()) return 1;
        vector<int>::reverse_iterator it,jt;
        for(it=cifre.rbegin(),jt=B.cifre.rbegin(); it!=cifre.rend() && jt!=B.cifre.rend(); it++,jt++)
            if(*it<*jt) return 0;
            else if(*it>*jt) return 1;
        return 1;
    }

    /*
     * Afisare
     */

    void wrt()
    {
        vector<int>::reverse_iterator it;
        for(it=cifre.rbegin(); it!=cifre.rend(); it++)
            printf("%d",*it);
        if(!cifre.size()) printf("0");
    }

    void wrtendl()
    {
        vector<int>::reverse_iterator it;
        for(it=cifre.rbegin(); it!=cifre.rend(); it++)
            printf("%d",*it);
        if(!cifre.size()) printf("0");
        printf("\n");
    }
};

int main()
{
    int a,b;

#ifndef ONLINE_JUDGE
    freopen("adunare.in","r",stdin);
    freopen("adunare.out","w",stdout);
#endif

    scanf("%d%d",&a,&b);
    printf("%d\n",a+b);

    return 0;
}