Addition of Big Integers

Given two integers $A$ and $B$, compute the sum, $A + B$.

Input

Two integers $A$ and $B$ separated by a space character are given in a line.

Output

Print the sum in a line.

Constraints

* $-1 \times 10^{100000} \leq A, B \leq 10^{100000}$



Sample Input 1


5 8


Sample Output 1


13


Sample Input 2


100 25


Sample Output 2


125


Sample Input 3


-1 1


Sample Output 3


0


Sample Input 4


12 -3


Sample Output 4


9






Example

Input

5 8


Output

13
#include <iostream>
#include <vector>
#include <limits>
#include <string>
using namespace std;

template<int Size>
struct Largenum{
    vector<long long> num;
    long long p;
    int sign;
    Largenum(){
        num = vector<long long>(Size,0);
        p = 1000000000;
        sign = 0;
    }
    Largenum<Size>(long long _num){
        num = vector<long long>(Size,0);
        p = 1000000000;
        if(_num){
            if(_num > 0){
                sign = 1;
            }
            else{
                sign = -1;
            }
        }
        else{
            sign = 0;
        }
        num[0] = _num % p;
        num[1] = _num /p;
    }
    Largenum(string _num){
        num = vector<long long> (Size,0);
        int base = 0;
        p = 1000000000;
        if(_num == "0"){
            sign = 0;
        }
        else if(_num[0] == '-'){
            base = 1;
            sign = -1;
        }
        else{
            sign = 1;
        }
        int size = _num.size();
        for(int i = base;i < size;i++){
            num[(size - i - 1)/9] *= 10;
            num[(size - i - 1)/9] += _num[i] - '0';
        }
    }
    void output(){
        if(sign == 0){
            printf("0");
            return;
        }
        if (sign == -1){
            printf("-");
        }
        int lim = Size - 1;
        while(lim > -1){
            if(num[lim] != 0){
                break;
            }
            lim--;
        }
        printf("%lld",num[lim]);
        for(int i = lim - 1;i >= 0;i--){
            printf("%09lld",num[i]);
        }
    }
    bool compa(const vector<long long> &left, const vector<long long> &right){
        for(int i = Size - 1;i >= 0;i--){
            if(left[i] != right[i]){
                return (left[i] > right[i]);
            }
        }
        return false;
    }
    bool operator>(const Largenum<Size> &other){
        if(sign != other.sign){
            return sign > other.sign;
        }
        return compa(num, other.num);
    }
    bool operator<(const Largenum<Size> &other){
        if(sign != other.sign){
            return sign < other.sign;
        }
        return compa(other.num, num);
    }
    bool operator<=(const Largenum<Size> &other){
        if(sign != other.sign){
            return sign <= other.sign;
        }
        return !compa(num, other.num);
    }
    bool operator>=(const Largenum<Size> &other){
        if(sign != other.sign){
            return sign >= other.sign;
        }
        return !compa(other.num, num);
    }
    void add(const vector<long long> &left, const vector<long long> &right){
        vector<long long> ret(Size, 0);
        for(int i = 0;i < Size;i ++){
            if(i){
                ret[i] += ret[i - 1] / p;
                ret[i - 1] %= p;
            }
            ret[i] += left[i] + right[i];
        }
        num = ret;
    }
    void dif(const vector<long long> &left, const vector<long long> &right){
        vector<long long> ret(Size, 0);
        int base = 0;
        for(int i = 0;i < Size;i++){
            ret[i] = (left[i] - right[i] -base + p) % p;
            if(left[i] - base < right[i]){
                base = 1;
            }
            else{
                base = 0;
            }
        }
        num = ret;
    }
    Largenum<Size> operator+(const Largenum<Size> &other){
        Largenum<Size> ret;
        if(sign == 0 && other.sign == 0){
            return ret;
        }
        else if(sign == 0 || other.sign == 0){
            ret.sign = sign + other.sign;
            ret.add(num, other.num);
        }
        else if(sign == other.sign){
            ret.sign = sign;
            ret.add(num, other.num);
        }
        else if(num == other.num){
            return ret;
        }
        else if(compa(num, other.num)){
            ret.sign = sign;
            ret.dif(num, other.num);
        }
        else{
            ret.sign = other.sign;
            ret.dif(other.num, num);
        }
        return ret;
    }
};


template<typename T>
void vdeb(vector<T> &da){
    int size=da.size();
    for(int i=0;i<size;i++){
        if(i==size-1){
            cout << da[i] << endl;
        }
        else{
            cout << da[i] << ' ';
        }
    }
}

template<typename T>
void vvdeb(vector<T> &da){
    int size=da.size();
    for(int i=0;i<size;i++){
        vdeb(da[i]);
    }
}

int main(){
    string s,t;
    cin >> s >> t;
    Largenum<12000> S(s),T(t);
    //vdeb(S.num);
    //vdeb(T.num);
    (S + T).output();
    cout << endl;
}

