#include<bits/stdc++.h>
using namespace std;
struct pint{
    vector<int> digits;
    bool negative;

    pint():negative(false){}
    pint(const string& num){
        if(num.empty()){
        	return;
		}
        int start=0;
        if(num[0]=='-'){
            negative=true;
            start=1;
        }
		else{
            negative=false;
        }
        for(int i=num.size()-1;i>=start;i--){
            digits.push_back(num[i]-'0');
        }
    }
    friend ostream& operator<<(ostream& os,const pint& p){
        if(p.digits.empty()){
            os << 0;
            return os;
        }
        if(p.negative){
        	os << '-';
		}
        for(int i=p.digits.size()-1;i>=0;i--){
            os << p.digits[i];
        }
        return os;
    }
    friend istream& operator>>(istream& is,pint& p){
        string num;
        is >> num;
        p=pint(num);
        return is;
    }
    pint operator+(const pint& other) const{
        if(this->negative==other.negative){
            pint result;
            result.negative=this->negative;
            int carry=0;
            size_t n=max(this->digits.size(),other.digits.size());
            result.digits.resize(n,0);
            for(size_t i=0;i < n&&carry;++i){
                if(i < this->digits.size()){
                	carry += this->digits[i];
				}
                if(i < other.digits.size()){
                	carry += other.digits[i];
				}
                if(i>=result.digits.size()){
                	result.digits.push_back(0);
				}
                result.digits[i]=carry % 10;
                carry /= 10;
            }
            return result;
        }
        if(this->negative){
        	return other-pint(*this).negate();
		}
        return *this-pint(other).negate();
    }
    pint operator-(const pint& other) const{
    	pint z;
    	z.digits.push_back(0);
        if(!this->negative && !other.negative){
            if(*this < other){
            	return (other-*this).negate();
			}
            pint result;
            result.negative=false;
            int carry=0;
            result.digits.resize(max(this->digits.size(),other.digits.size()),0);
            for(size_t i=0;i < this->digits.size() || carry;++i){
                result.digits[i]=this->digits[i]-carry-(i < other.digits.size() ? other.digits[i]:0);
                carry=result.digits[i] < 0;
                if(carry){
                	result.digits[i] += 10;
				}
            }
            while (result.digits.size() > 1 && result.digits.back()==0){
            	result.digits.pop_back();
			}
            return result;
        }
        if(this->negative && other.negative){
        	return pint(other).negate()-pint(*this).negate();
		}
        if(this->negative){
        	return (pint(*this).negate() + other).negate();
		}
        return *this + pint(other).negate();
    }
    pint operator*(const pint& other) const{
        pint result;
        result.digits.resize(this->digits.size() + other.digits.size(),0);
        for(size_t i=0;i < this->digits.size();++i){
            for(size_t j=0;j < other.digits.size();++j){
                result.digits[i + j] += this->digits[i] * other.digits[j];
                if(result.digits[i + j]>=10){
                    result.digits[i + j + 1] += result.digits[i + j] / 10;
                    result.digits[i + j] %= 10;
                }
            }
        }
        while (result.digits.size() > 1 && result.digits.back()==0){
        	result.digits.pop_back();
		}
        result.negative=this->negative != other.negative;
        return result;
    }
    pint operator/(const pint& other) const{
        pint result,remainder;
        result.digits.resize(this->digits.size(),0);
        remainder.digits.resize(this->digits.size(),0);

        for(int i=this->digits.size()-1;i>=0;--i){
            remainder=remainder * 10 + this->digits[i];
            int div=0,left=0,right=10;
            while (left <= right){
                int mid=(left + right) / 2;
                if(other * mid <= remainder){
                    div=mid;
                    left=mid + 1;
                }
				else{
                    right=mid-1;
                }
            }
            result.digits[i]=div;
            remainder=remainder-other * div;
        }
        while (result.digits.size() > 1 && result.digits.back()==0){
        	result.digits.pop_back();
		}
        result.negative=this->negative != other.negative;
        return result;
    }
    pint negate() const{
        pint result(*this);
        result.negative=!this->negative;
        return result;
    }
    bool operator<(const pint& other) const{
        if(this->negative != other.negative){
        	return this->negative;
		}
        if(this->digits.size() != other.digits.size()){
            bool result=this->digits.size() < other.digits.size();
            return this->negative ? !result:result;
        }
        for(int i=this->digits.size()-1;i>=0;--i){
            if(this->digits[i] != other.digits[i]){
                bool result=this->digits[i] < other.digits[i];
                return this->negative ? !result:result;
            }
        }
        return false;
    }

    bool operator==(const pint& other) const{
        return this->negative==other.negative && this->digits==other.digits;
    }

    bool operator<=(const pint& other) const{
        return *this < other || *this==other;
    }
    pint operator*(int n) const{
        pint result;
        int carry=0;
        result.digits.resize(this->digits.size(),0);
        for(size_t i=0;i < this->digits.size() || carry;++i){
            if(i < this->digits.size()){
            	carry += this->digits[i] * n;
			}
            if(i>=result.digits.size()){
            	result.digits.push_back(0);
			}
            result.digits[i]=carry % 10;
            carry /= 10;
        }
        while (result.digits.size() > 1 && result.digits.back()==0){
        	result.digits.pop_back();
		}
        result.negative=this->negative != (n < 0);
        return result;
    }

    pint operator+(int n) const{
        return *this + pint(to_string(n));
    }

    pint operator-(int n) const{
        return *this-pint(to_string(n));
    }

    pint operator/(int n) const{
        return *this / pint(to_string(n));
    }

    pint operator%(const pint& other) const{
        pint quotient=*this / other;
        return *this-(quotient * other);
    }
};
#define int pint
signed main(){
    int a,b;
    cin>>a>>b;
    cout<<a+b;
}