#include<string>

#include<iostream>

#include<iosfwd>

#include<cmath>

#include<cstring>

#include<stdlib.h>

#include<stdio.h>

#include<cstring>

#define MAX_L 2005 //最大长度，可以修改

using namespace std;

class bign

{

public:

    int len, s[MAX_L];//数的长度，记录数组

//构造函数

    bign();

    bign(const char*);

    bign(int);

    bool sign;//符号 1正数 0负数

    string toStr() const;//转化为字符串，主要是便于输出

    friend istream& operator>>(istream &,bign &);//重载输入流

    friend ostream& operator<<(ostream &,bign &);//重载输出流

//重载复制

    bign operator=(const char*);

    bign operator=(int);

    bign operator=(const string);

//重载各种比较

    bool operator>(const bign &) const;

    bool operator>=(const bign &) const;

    bool operator<(const bign &) const;

    bool operator<=(const bign &) const;

    bool operator==(const bign &) const;

    bool operator!=(const bign &) const;

//重载四则运算

    bign operator+(const bign &) const;

    bign operator++();

    bign operator++(int);

    bign operator+=(const bign&);

    bign operator-(const bign &) const;

    bign operator--();

    bign operator--(int);

    bign operator-=(const bign&);

    bign operator*(const bign &)const;

    bign operator*(const int num)const;

    bign operator*=(const bign&);

    bign operator/(const bign&)const;

    bign operator/=(const bign&);

//四则运算的衍生运算

    bign operator%(const bign&)const;//取模（余数）

    bign factorial()const;//阶乘

    bign Sqrt()const;//整数开根（向下取整）

    bign pow(const bign&)const;//次方

//一些乱乱的函数

    void clean();

    ~bign();

};

#define max(a,b) a>b ? a : b

#define min(a,b) a<b ? a : b

bign::bign()

{

    memset(s, , sizeof(s));

    len = ;

    sign = ;

}

bign::bign(const char *num)

{

    *this = num;

}

bign::bign(int num)

{

    *this = num;

}

string bign::toStr() const

{

    string res;

    res = "";

    for (int i = ; i < len; i++)

        res = (char)(s[i] + '') + res;

    if (res == "")

        res = "";

    if (!sign&&res != "")

        res = "-" + res;

    return res;

}

istream &operator>>(istream &in, bign &num)

{

    string str;

    in>>str;

    num=str;

    return in;

}

ostream &operator<<(ostream &out, bign &num)

{

    out<<num.toStr();

    return out;

}

bign bign::operator=(const char *num)

{

    memset(s, , sizeof(s));

    char a[MAX_L] = "";

    if (num[] != '-')

        strcpy(a, num);

    else

        for (int i = ; i < strlen(num); i++)

            a[i - ] = num[i];

    sign = !(num[] == '-');

    len = strlen(a);

    for (int i = ; i < strlen(a); i++)

        s[i] = a[len - i - ] - ;

    return *this;

}

bign bign::operator=(int num)

{

    char temp[MAX_L];

    sprintf(temp, "%d", num);

    *this = temp;

    return *this;

}

bign bign::operator=(const string num)

{

    const char *tmp;

    tmp = num.c_str();

    *this = tmp;

    return *this;

}

bool bign::operator<(const bign &num) const

{

    if (sign^num.sign)

        return num.sign;

    if (len != num.len)

        return len < num.len;

    for (int i = len - ; i >= ; i--)

        if (s[i] != num.s[i])

            return sign ? (s[i] < num.s[i]) : (!(s[i] < num.s[i]));

    return !sign;

}

bool bign::operator>(const bign&num)const

{

    return num < *this;

}

bool bign::operator<=(const bign&num)const

{

    return !(*this>num);

}

bool bign::operator>=(const bign&num)const

{

    return !(*this<num);

}

bool bign::operator!=(const bign&num)const

{

    return *this > num || *this < num;

}

bool bign::operator==(const bign&num)const

{

    return !(num != *this);

}

bign bign::operator+(const bign &num) const

{

    if (sign^num.sign)

    {

        bign tmp = sign ? num : *this;

        tmp.sign = ;

        return sign ? *this - tmp : num - tmp;

    }

    bign result;

    result.len = ;

    int temp = ;

    for (int i = ; temp || i < (max(len, num.len)); i++)

    {

        int t = s[i] + num.s[i] + temp;

        result.s[result.len++] = t % ;

        temp = t / ;

    }

    result.sign = sign;

    return result;

}

bign bign::operator++()

{

    *this = *this + ;

    return *this;

}

bign bign::operator++(int)

{

    bign old = *this;

    ++(*this);

    return old;

}

bign bign::operator+=(const bign &num)

{

    *this = *this + num;

    return *this;

}

bign bign::operator-(const bign &num) const

{

    bign b=num,a=*this;

    if (!num.sign && !sign)

    {

        b.sign=;

        a.sign=;

        return b-a;

    }

    if (!b.sign)

    {

        b.sign=;

        return a+b;

    }

    if (!a.sign)

    {

        a.sign=;

        b=bign()-(a+b);

        return b;

    }

    if (a<b)

    {

        bign c=(b-a);

        c.sign=false;

        return c;

    }

    bign result;

    result.len = ;

    for (int i = , g = ; i < a.len; i++)

    {

        int x = a.s[i] - g;

        if (i < b.len) x -= b.s[i];

        if (x >= ) g = ;

        else

        {

            g = ;

            x += ;

        }

        result.s[result.len++] = x;

    }

    result.clean();

    return result;

}

bign bign::operator * (const bign &num)const

{

    bign result;

    result.len = len + num.len;

    for (int i = ; i < len; i++)

        for (int j = ; j < num.len; j++)

            result.s[i + j] += s[i] * num.s[j];

    for (int i = ; i < result.len; i++)

    {

        result.s[i + ] += result.s[i] / ;

        result.s[i] %= ;

    }

    result.clean();

    result.sign = !(sign^num.sign);

    return result;

}

bign bign::operator*(const int num)const

{

    bign x = num;

    bign z = *this;

    return x*z;

}

bign bign::operator*=(const bign&num)

{

    *this = *this * num;

    return *this;

}

bign bign::operator /(const bign&num)const

{

    bign ans;

    ans.len = len - num.len + ;

    if (ans.len < )

    {

        ans.len = ;

        return ans;

    }

    bign divisor = *this, divid = num;

    divisor.sign = divid.sign = ;

    int k = ans.len - ;

    int j = len - ;

    while (k >= )

    {

        while (divisor.s[j] == ) j--;

        if (k > j) k = j;

        char z[MAX_L];

        memset(z, , sizeof(z));

        for (int i = j; i >= k; i--)

            z[j - i] = divisor.s[i] + '';

        bign dividend = z;

        if (dividend < divid) { k--; continue; }

        int key = ;

        while (divid*key <= dividend) key++;

        key--;

        ans.s[k] = key;

        bign temp = divid*key;

        for (int i = ; i < k; i++)

            temp = temp * ;

        divisor = divisor - temp;

        k--;

    }

    ans.clean();

    ans.sign = !(sign^num.sign);

    return ans;

}

bign bign::operator/=(const bign&num)

{

    *this = *this / num;

    return *this;

}

bign bign::operator%(const bign& num)const

{

    bign a = *this, b = num;

    a.sign = b.sign = ;

    bign result, temp = a / b*b;

    result = a - temp;

    result.sign = sign;

    return result;

}

bign bign::pow(const bign& num)const

{

    bign result = ;

    for (bign i = ; i < num; i++)

        result = result*(*this);

    return result;

}

bign bign::factorial()const

{

    bign result = ;

    for (bign i = ; i <= *this; i++)

        result *= i;

    return result;

}

void bign::clean()

{

    if (len == ) len++;

    while (len >  && s[len - ] == '\0')

        len--;

}

bign bign::Sqrt()const

{

    if(*this<)return -;

    if(*this<=)return *this;

    bign l=,r=*this,mid;

    while(r-l>)

    {

        mid=(l+r)/;

        if(mid*mid>*this)

            r=mid;

        else

            l=mid;

    }

    return l;

}

bign::~bign()

{

}

bign num0,num1,res;

int main() {

    num0 = , num1 = ;

    res=num0-num1;

    cout << res << endl;

    return ;

}