Language: C++

#ifndef TBBLINT_H
#define TBBLINT_H
#include <iostream> //LInt.h version:2.4.1
//头文件省略
typedef unsigned long long u64;
typedef long long i64;
typedef unsigned u32;
namespace tbb   {
    const double Pi= 3.14159265358979323846;
    //using std::cin...
    void Fast_out(u32 a)    {
        if(a==0) {
            putchar('0');
            return;
        }
        if(a>9) {
            Fast_out(a/10);
            putchar('0'+a%10);
        } else  putchar('0'+a);
    }
    inline void Fast_0_out(u32 a, int len= 4)   {
        if(len>=2)  if(a<10)    putchar('0');
        if(len>=3)  if(a<100)   putchar('0');
        if(len>=4)  if(a<1000)  putchar('0');
        Fast_out(a);
    }
    int Log_2(int base) {
        int i;
        for(i=0; ((1<<i)<base) & (i<32) ;i++);
        return i;
    }
    // template<typename T, size_T> FFT(const std::array<T, N> &X, bool flag) {
    std::vector<std::complex<double> > FFT(const std::vector<std::complex<double> > &X, bool flag) {
        //flag -> inverse flag
        using std::complex;
        using std::vector;
        typedef complex<double> cmxd;
        int L=X.size();
        if(L==1)    return X;
        static const int vol= 262144;
        static bool pre_init= true;
        static cmxd root[vol+1];
        if(pre_init)    {
            for(int i=0; i<=vol; i++) root[i]= exp(cmxd(0, 2*Pi/vol*i));
            pre_init= false;
        }
        int* rev;   rev= new int [L];   rev[0]= 0, rev[1]= L/2;
        {for(int i=2; i<L; i++)  rev[i]=(rev[i&1])|(rev[i>>1]>>1);}
        vector< complex<double> > A(L);
        for(int i=0; i<L; i++)  A[i]= X[rev[i]];
        for(int size=2; size<=L; size<<=1)  {
            for(int k=0; k<L; k+=size)  {
                for(int i=0; i<size/2; i++) {
                    cmxd R= (!flag)? root[vol/size*i]: root[vol- vol/size*i];
                    cmxd p= A[k+i], q= A[k+size/2+i]* R;
                    A[k+i]= p+q;    A[k+size/2+i]= p-q;
                }
            }
        }
        if(flag)    for(int i=0; i<L; i++)  A[i]/=L;
        delete rev;
        return A;
    }
    inline int s2i(const char *begin, const char *end) {//converse string to int
        int tmp= 0, sig= 1;
        if(*begin=='+'||*begin=='-')    sig= (*(begin++)=='+')?1:-1;
        for(const char *t= end-1; t>= begin; t--)   tmp= tmp*10+ (*t-'0');
        return tmp*sig;
    }
    struct LInt {
    //elements
        short sign;
        int d;
        u32 *num;
    //define function/initial
        LInt (void ):sign(0),d(0),num(0){}
        LInt (bool b, int code= 0):sign(0),d(0) {
            if(b)   {num=new u32[0];}
            else    {
                num= 0;
                if(code== 1)    sign= 2;
                if(code== -1)   sign= -2;
            }
        }
        //本题中用不到的转换函数
        LInt (const char* inString) {
            int i, len;
            bool flag=true, minus=false;
            if(inString[0]=='-')    {minus=true; inString++;}
            else    if(inString[0]=='+')    {minus=false;   inString++;}
            len=strlen(inString);
            //check string is +/- inf whether or not
            if(strcmp(inString, "inf")==0)  {sign= minus? -2: 2;    d=0;    num=0;  return ;}
            //check string is full of numbers or not
            for(i=0; i<len&&flag; i++)  flag= flag&&('0'<=inString[i]&&inString[i]<='9');
            if(!flag||len== 0)  {d=sign=0;  num=0; return ;}
            //ignore all 0 at the begin of string
            for(; *inString=='0'; inString++, len--);
            if(*inString=='\0') {d=sign=0;  num= new u32[0]; return ;}
            //string is a normal number
            d= (len+3)/4;   num= new u32[d]();
            sign= minus? -1: 1;
            int j, temp;
            for(temp=0, i=len, j=0; j<len; j++) {
                temp= temp*10 + inString[j]-'0';
                i-=1;
                if(i%4==0)  num[i/4]= temp, temp= 0;
            }
        }
        LInt (const string &inString_):num(0)   {
            *this= inString_.c_str();
        }
        LInt (const LInt &A):sign(A.sign), d(A.d)   {
            num= new u32[d];
            for(int i=0; i<d; i++)  num[i]= A.num[i];
        }
        LInt (const u32 *inNum, int k):sign(1){
            while(k>0 && inNum[k-1]==0) k--, inNum++;
            d=k;    num= new u32[k];
            memset(num,0,k*sizeof(u32));
            for(int i=0; i<k; i++)  num[i]= inNum[i];
            this->sho();
        }
    //undo function
        virtual ~LInt() {if(num!=0) delete[] num;}
    //assignment operator
        LInt & operator=(const LInt &B) {
            sign=B.sign;    d=B.d;
            if(num!=0)  delete[] num;
            if(B.isNaN())   num= 0;
            else    {num= new u32[d];   for(int i=0; i<d; i++)  num[i]=B.num[i];}
            return *this;
        }
        LInt & operator=(const char *inString) {
            LInt temp(inString);
            d= temp.d; sign= temp.sign;
            if(num!=0)  delete[] num;
            num= temp.num; temp.num=0;
            return *this;
        }
        inline LInt & operator=(bool b)  {return *this=LInt(b);}
        inline LInt & operator=(int i)  {return *this= LInt(i);}
        inline LInt & operator=(i64 i)  {return *this= LInt(i);}
        inline LInt & operator=(u64 u)  {return *this= LInt(u);}
    //compare operator
        bool operator<(const LInt &B) const {

            const LInt &A= *this;
            if(A.isNaN()||B.isNaN())    return false;
            if(A.sign<B.sign)   return true;
            if(A.sign>B.sign)   return false;
            if(sign==2||sign==-2||sign==0)  return false;
            if(sign==-1)    {
                if(A.d!=B.d)    return !(A.d<B.d);
                for(int i=d-1; i>=0; i--)   if(A.num[i]!=B.num[i])  return !(A.num[i]<B.num[i]);
                return false;
            }
            if(sign==1) {
                if(A.d!=B.d)    return A.d<B.d;
                for(int i=d-1; i>=0; i--)   if(A.num[i]!=B.num[i])  return A.num[i]<B.num[i];
                return false;
            }
            return false;
        }
        //这里是大小比较的代码，省略了
    //functions
        LInt abs()  const {
            LInt ans(*this);
            if(ans.sign<0)  ans.sign=-ans.sign;
            return ans;
        }
        inline LInt abs(const LInt &b) const    {return b.abs();}
        void sho()  {
            if(sign==2||sign==-2)   {
                d=0;
                if(num!=0)  {delete[] num;  num=0;}
                return ;
            }
            if(sign==0) {
                d=0;
                if(num!=0)  {delete[] num;  num= new u32[0];}
                return ;
            }
            int i=this->d-1;
            while(i>=0&&num[i]==0)  i--;
            if(i<0) {
                if(num) delete[] num;
                num=new u32[0]; sign=d=0;
                return;
            }
            this->d=i+1;
            u32 *pre=this->num;
            num=new u32[this->d];
            for(int j=0; j<this->d; j++)    num[j]=pre[j];
            delete [] pre;
            return;
        }
        void print() const  {
            if(sign==2||sign==-2)   {
                if(sign==-2)    putchar('-');
                printf("inf");
                return ;
            }
            if(sign==0) {
                if(num==0)  printf("NaN");
                else    putchar('0');
                return;
            }
            if(sign==-1)    putchar('-');
            Fast_out(num[d-1]);
            for(int i=d-2; i>=0; i--)   Fast_0_out(num[i]);
        }
        string print_str()  const   {
            if(sign==0) return num==0?string("NaN"):string("0");
            if(sign==2||sign==-2)   return sign==-2?string("-inf"):string("inf");
            string ans(0);
            if(sign==-1)    ans+='-';
            ans+=num[d-1];
            for(int i=d-2; i>=0; i--)   {
                if(num[i]<10)   ans+='0';
                if(num[i]<100)  ans+='0';
                if(num[i]<1000) ans+='0';
                ans+=num[i];
            }
            return ans;
        }
        inline bool isNaN() const   {return (num==0)&&(d==0)&&(sign==0);}
        inline bool positive()  const   {return sign>0;}
        inline bool negative()  const   {return sign<0;}
        inline bool isinf() const   {return sign==2||sign==-2;}
        inline bool zero()  const   {return sign==0&&num!=0;}
        inline bool meanless()  const   {return isNaN()||isinf();}
        inline bool abnormal()  const   {return zero()||isinf()||isNaN();}
        friend void swap(LInt &A, LInt &B)  {
            int temp_d; short temp_sign;    u32* temp_num;
            temp_d= A.d;    A.d= B.d;   B.d= temp_d;
            temp_sign= A.sign;  A.sign= B.sign; B.sign= temp_sign;
            temp_num= A.num;    A.num= B.num;   B.num= temp_num;
        }
    private://get 10000^2d/A while A >=0
        //这里是辅助计算除法的代码，省略了
    public:
        //特别地，对除2进行优化，然而本题用不上
    //Operator Function
        const LInt operator<<(int k) const {
            if(abnormal())  return *this;
            if(k<0) return LInt(false);
            if(*this==0)    return LInt(0);
            LInt ans(false);
            u32 *_num = new u32[d+k]();
            for(int i=0; i<d; i++)  _num[i+k]=num[i];
            ans.num=_num;   ans.d=d+k;  ans.sign=sign;
            return ans;
        }
        const LInt operator>>(int k) const {
            if(abnormal())  return *this;
            if(k<0) return LInt(false);
            if(d<=k)    return LInt(0);
            LInt ans(false);
            u32 *_num = new u32[d-k];
            for(int i=0; i<d-k; i++)    _num[i]=num[i+k];
            ans.num=_num;   ans.d=d-k;  ans.sign=sign;
            return ans;
        }
        //这里是加减和前置负号的实现代码，省略了
        const LInt operator*(const LInt &B) const {
            const LInt &A= *this;
            if(A.isNaN()||B.isNaN())    return false;
            if((A.zero()&&B.isinf())||(A.isinf()&&B.zero()))    return false;
            if(A.isinf())   return (B.sign>0)?A:-A;
            if(B.isinf())   return (A.sign>0)?B:-B;
            if(A.zero()||B.zero())  return 0;
            using std::complex;
            using std::vector;
            LInt ans;
            int x,y;
            int N=1<<(Log_2(A.d+B.d-1));
            ans.d=N+2;  ans.num= new u32[ans.d]();
            ans.sign=A.sign*B.sign;
            vector< complex<double> > pA(N,0),aA(N,0);
            for(x=0;x<A.d;x++)  pA[x].real(A.num[x]);
            for(y=0;y<B.d;y++)  pA[y].imag(B.num[y]);
            aA=FFT(pA,false);
            for(int i=0; i<N; i++)  aA[i]*= aA[i];
            pA=FFT(aA,true);
            double carry=0.0;
            for(int i=0; i<N; i++)  {
                double temp=round(pA[i].imag()/2+carry);
                carry=round(temp/10000);
                int base=(int)round(temp-carry*10000);
                if(base<0)  base+=10000,carry-=1.0;
                ans.num[i]=base;
            }
            ans.num[N]=unsigned(carry);
            ans.sho();
            return ans;
        }
        const LInt operator/(int B) const   {
            if(B==2)    return this->div2();
            const LInt &A= *this;
            if(A.isNaN())   return false;
            if(A==0&&B==0)  return false;
            if(A==0)    return 0;
            if(B==0)    return A.positive()?"inf":"-inf";
            if(A.isinf())   return (B>=0)?A:-A;

            LInt ans;   ans.d=d;
            ans.sign= A.sign* (B>0?1:-1);
            ans.num= new u32[d]();
            u32 abs_B=(B<0?-B:B);   u64 temp=0;
            for(int i=d-1; i>=0; i--)   {
                temp*= 10000;
                temp+= num[i];
                ans.num[i]= temp/abs_B;
                temp%= abs_B;
            }
            ans.sho();
            return ans;
        }
        //这里是除法的实现代码，但我省略了
        //这里是求余数的实现代码，但我省略了
        //这里是操作后赋值代码，省略了
        //这里是自增和自减的代码，省略了
        inline u32 & operator[](int k) const    {
            return num[k];
        }
    //Friend Function for Other Classical Class
        friend LInt operator+(int A, const LInt &B) {
            return B+LInt(A);
        }
        friend LInt operator-(int A, const LInt &B) {
            return -B+LInt(A);
        }
        friend LInt operator*(int A, const LInt &B) {
             return B*A;
        }
        friend std::ostream & operator<<(std::ostream &os, const LInt &A)   {
            if(A.sign==0)   {
                if(A.num==0)    os.write("NaN",3);
                else    os.put('0');
            }   else    {
                if(A.sign<0)    os.put('-');
                if(A.isinf())   os.write("inf",3);
                else    {
                    os<<A.num[A.d-1];
                    for(int i=A.d-2; i>=0; i--) {
                        if(A.num[i]<10) os.put('0');
                        if(A.num[i]<100)    os.put('0');
                        if(A.num[i]<1000)   os.put('0');
                        os<<A.num[i];
                    }
                }
            }
            return os;
        }
        friend std::istream & operator>>(std::istream &is, LInt &A) {
            using std::isdigit;
            is>>std::ws;
            {
                if(is.peek()==-1)   {is.setstate(std::ios_base::eofbit);    A= 0;   return is;}
                if(!is) {is.setstate(std::ios_base::failbit);   A= 0;   return is;}
                char t= is.peek();
                while(t!='-'&&!isdigit(t)&&t!=-1)   {
                    is.get();   t= is.peek();
                }
                if(t==-1)   {is.setstate(std::ios_base::failbit);   A= 0;   return is;}
            }
            char sign= is.peek();
            if(sign=='-'||sign=='+')    is.get();
            else    sign= '0';
            // NaN or inf?  //No. Like the input of float, refuse NaN
            //just no any suitable input?
            if(!isdigit(is.peek())) {
                if(sign=='+'||sign=='-')    is.unget();
                A= 0;   is.setstate(std::ios_base::failbit);
                return is;
            }
            string in_s(1, sign);
            while(isdigit(is.peek()))   in_s+= is.get();
            A= in_s;
            return is;
        }
    // converse to other classical type
    #if __cplusplus >= 201103L
        explicit operator bool() const  {
            return isinf()||isNaN();
        }
        explicit operator int() const   {
            int temp= 0;
            for(int i=0; i<d ;i++)  temp= temp* 10000+ num[i];
            if(sign<0)  temp= -temp;
            return temp;
        }
    #endif
    };
    //这里是以10为底的乘法代码，省略了
}
#endif
// #define debug
#ifdef debug
#include "LFloat.h"
#endif

#ifndef TBBLMAT_H //LMath.h ver:3.1.1
#define TBBLMAT_H
namespace tbb {
    const LInt powrt(const LInt&, int);
    LInt abs(const LInt &B) {
        LInt ans(B);
        if (B.sign<0) ans.sign=-B.sign;
        return ans;
    };
    //get 10000^2k/sqrt(A) when A has 2k or 2k-1 bits
    //这里是计算sqrt和对应的辅助函数的代码，省略了
    const LInt pow(const LInt &A, int k)  {
        if((A==0&&k==0)||A.isNaN())  return false;
        if(A.isinf()&&k>=0)   {
            if(k==0)    return false;
            if(A.sign==2&&k>0)   return A;
            return (k%2==0)?(-A):A;
        }
        if(k<0)    return 0;
        if(k==0||A==1)    return LInt(1);
        if(A.num[0]==0) {
            int lnz=0;  //lnz=the lower bit where is not 0
            for(lnz=0; lnz<A.d&&A.num[lnz]==0; lnz++);
            return pow(A>>lnz,k)<<(lnz*k);
        }
        LInt S= 1, temp= A;
        for(int i=1; i<=k; i<<=1)   {
            temp= (i==1)?A: temp*temp;
            if(i&k) S*= temp;
        }
        return S;
    }
    int cmp(const LInt &lhs, int m) {
        if(lhs.d<=m)    return -1;
        if(lhs.d>m+1)   return 1;
        for(int i=0; i<m; i++)  if(lhs[i]>0)    return 1;
        return (lhs==1)? 0: 1;
    }
    inline const LInt recip_m(const LInt &A, int m)    {
        if(A.abnormal())    return A;
        int n= (A.d+m-1)/m;
        if(n<=2)  return (powrt(A, m)<<(n*m))/A;
        int k= n/2+1;
        LInt Ak(A.num+m*(n-k), A.d-m*(n-k));
        LInt _Ak= recip_m(Ak, m)-1;
        _Ak-=_Ak>>(A.d-1);  _Ak<<= n-k;
        LInt _AN= pow(A, m-1);
        LInt _A= (m+1)*_Ak/m- ((_AN* pow(_Ak, m+1)/ m)>>(n*m*m));
        LInt delta= 1;
        if(cmp(_AN* pow(_A, m), n*m*m)==-1)   for(;;delta*=2)    {
            LInt _Ap= _A+ delta;
            if(cmp(_AN* pow(_A, m), n*m*m)==1)  break;
            swap(_A, _Ap);
        }   else    for(;;delta*=2)    {
            _A-= delta;
            if(cmp(_AN* pow(_A, m), n*m*m)<=0)  break;
        }
        do {
            delta/=2;
            LInt _Ap= _A+ delta;
            if(cmp(_AN* pow(_A, m), n*m*m)==1)  continue;
            swap(_A, _Ap);
        } while(delta>0);
        return _A;
    }
    const LInt powrt(const LInt &A, int m)  {
        if(A.isNaN()||m<=0)   return false;
        if(A.zero())    return 0;
        if(A.negative()&&m%2==0)  return false;
        if(A.isinf()) return A;
        if(A.negative()&&m%2==1)    return -powrt(-A, m);
        if(A==1)    return 1;
        if(A.d<=2*m)  {
            int up= 100000000, down= 1, mid= (up+down)/2;
            while(up-down>1) {
                LInt a= pow(LInt(mid), m);
                if(a==A)    return mid;
                (a<A? down: up)= mid;
                mid= (up+down)/2;
            }
            return down;
        }
        int n= (A.d+m-1)/m;
        LInt ans= (A* recip_m(A, m))>>(n*m);
        LInt delta= 1;
        for(delta=1; ; delta*=2)  {
            if(pow(ans+delta, m)>A) break;
            ans+= delta;
        }
        for(;delta>0 ; delta/=2)   {
            if(pow(ans+delta, m)>A) continue;
            ans+= delta;
        }
        return ans;
    }
    //最大公约数和最小公倍数的实现代码，省略了
    #ifdef TBBLFLT_H
        const LFloat sqrt(const LFloat& A) {
            if(A.negative()) return LFloat(LInt(false), 0);
            if(A.abnormal()) return A;
            const int n= tbb::_LFloat_prec;
            LInt u= A.base; i64 t= A.pow;
            t-=(2*n-u.d);   u<<=(2*n-u.d);
            if(t%2!=0)  t++, u>>=1;
            return LFloat(sqrt(u), t/2);
        }
    #endif
}
#endif
#include <iostream> //version:2.3
//其它头文件省略
#define SHOW    putchar('s')
#define EL  putchar('\n')
using namespace tbb;
using namespace std;
int main()  {
    LInt A,B,C;
    cin>>A>>B>>C;
    if(powrt(A,2)+powrt(B,2)<powrt(C,2))
    puts("Yes");
    else
    puts("No");
    return 0;
}

Compiler output:
a.cc:33:10: error: 'vector' in namespace 'std' does not name a template type
   33 |     std::vector<std::complex<double> > FFT(const std::vector<std::complex<double> > &X, bool flag) {
      |          ^~~~~~
a.cc:4:1: note: 'std::vector' is defined in header '<vector>'; this is probably fixable by adding '#include <vector>'
    3 | #include <iostream> //LInt.h version:2.4.1
  +++ |+#include <vector>
    4 | //头文件省略
a.cc:110:21: error: 'string' does not name a type; did you mean 'stdin'?
  110 |         LInt (const string &inString_):num(0)   {
      |                     ^~~~~~
      |                     stdin
a.cc:213:9: error: 'string' does not name a type; did you mean 'stdin'?
  213 |         string print_str()  const   {
      |         ^~~~~~
      |         stdin
a.cc: In constructor 'tbb::LInt::LInt(const char*)':
a.cc:91:17: error: 'strlen' was not declared in this scope
   91 |             len=strlen(inString);
      |                 ^~~~~~
a.cc:4:1: note: 'strlen' is defined in header '<cstring>'; this is probably fixable by adding '#include <cstring>'
    3 | #include <iostream> //LInt.h version:2.4.1
  +++ |+#include <cstring>
    4 | //头文件省略
a.cc:93:16: error: 'strcmp' was not declared in this scope
   93 |             if(strcmp(inString, "inf")==0)  {sign= minus? -2: 2;    d=0;    num=0;  return ;}
      |                ^~~~~~
a.cc:93:16: note: 'strcmp' is defined in header '<cstring>'; this is probably fixable by adding '#include <cstring>'
a.cc: In constructor 'tbb::LInt::LInt(const int&)':
a.cc:111:30: error: request for member 'c_str' in 'inString_', which is of non-class type 'const int'
  111 |             *this= inString_.c_str();
      |                              ^~~~~
a.cc: In constructor 'tbb::LInt::LInt(const u32*, int)':
a.cc:120:13: error: 'memset' was not declared in this scope
  120 |             memset(num,0,k*sizeof(u32));
      |             ^~~~~~
a.cc:120:13: note: 'memset' is defined in header '<cstring>'; this is probably fixable by adding '#include <cstring>'
a.cc: In member function 'tbb::LInt& tbb::LInt::operator=(i64)':
a.cc:143:62: error: call of overloaded 'LInt(i64&)' is ambiguous
  143 |         inline LInt & operator=(i64 i)  {return *this= LInt(i);}
      |                                                              ^
a.cc:113:9: note: candidate: 'tbb::LInt::LInt(const tbb::LInt&)'
  113 |         LInt (const LInt &A):sign(A.sign), d(A.d)   {
      |         ^~~~
a.cc:110:9: note: candidate: 'tbb::LInt::LInt(const int&)'
  110 |         LInt (const string &inString_):num(0)   {
      |         ^~~~
a.cc:77:9: note: candidate: 'tbb::LInt::LInt(bool, int)'
   77 |         LInt (bool b, int code= 0):sign(0),d(0) {
      |         ^~~~
a.cc: In member function 'tbb::LInt& tbb::LInt::operator=(u64)':
a.cc:144:62: error: call of overloaded 'LInt(u64&)' is ambiguous
  144 |         inline LInt & operator=(u64 u)  {return *this= LInt(u);}
      |                                                              ^
a.cc:113:9: note: candidate: 'tbb::LInt::LInt(const tbb::LInt&)'
  113 |         LInt (const LInt &A):sign(A.sign), d(A.d)   {
      |         ^~~~
a.cc:110:9: note: candidate: 'tbb::LInt::LInt(const int&)'
  110 |         LInt (const string &inString_):num(0)   {
      |         ^~~~
a.cc:77:9: note: candidate: 'tbb::LInt::LInt(bool, int)'
   77 |         LInt (bool b, int code= 0):sign(0),d(0) {
      |         ^~~~
a.cc: In member function 'const tbb::LInt tbb::LInt::operator<<(int) const':
a.cc:248:21: error: no match for 'operator==' (operand types are 'const tbb::LInt' and 'int')
  248 |             if(*this==0)    return LInt(0);
      |                ~~~~~^~~
      |                |      |
      |                |      int
      |                const tbb::LInt
a.cc:248:21: note: candidate: 'operator==(int, int)' (built-in)
  248 |             if(*this==0)    return LInt(0);
      |                ~~~~~^~~
a.cc:248:21: note:   no known conversion for argument 1 from 'const tbb::LInt' to 'int'
a.cc: In member function 'const tbb::LInt tbb::LInt::operator*(const tbb::LInt&) const':
a.cc:270:49: error: no match for 'operator-' (operand type is 'const tbb::LInt')
  270 |             if(A.isinf())   return (B.sign>0)?A:-A;
      |                                                 ^~
a.cc:270:49: note: candidate: 'operator-(int)' (built-in)
a.cc:270:49: note:   no known conversion for argument 1 from 'const tbb::LInt' to 'int'
a.cc:331:21: note: candidate: 'tbb::LInt tbb::operator-(int, const LInt&)'
  331 |         friend LInt operator-(int A, const LInt &B) {
      |                     ^~~~~~~~
a.cc:331:21: note:   candidate expects 2 arguments, 1 provided
a.cc:271:49: error: no match for 'operator-' (operand type is 'const tbb::LInt')
  271 |             if(B.isinf())   return (A.sign>0)?B:-B;
      |                                                 ^~
a.cc:271:49: note: candidate: 'operator-(int)' (built-in)
a.cc:271:49: note:   no known conversion for argument 1 from 'const tbb::LInt' to 'int'
a.cc:331:21: note: candidate: 'tbb::LInt tbb::operator-(int, const LInt&)'
  331 |         friend LInt operator-(int A, const LInt &B) {
      |                     ^~~~~~~~
a.cc:331:21: note:   candidate expects 2 arguments, 1 provided
a.cc:273:24: error: 'complex' has not been declared in 'std'
  273 |             using std::complex;
      |                        ^~~~~~~
a.cc:274:24: error: 'vector' has not been declared in 'std'
  274 |             using std::vector;
      |                        ^~~~~~
a.cc:280:13: error: 'vector' was not declared in this scope
  280 |             vector< complex<double> > pA(N,0),aA(N,0);
      |             ^~~~~~
a.cc:280:21: error: 'complex' was not declared in this scope
  280 |             vector< complex<double> > pA(N,0),aA(N,0);
      |                     ^~~~~~~
a.cc:280:29: error: expected primary-expression before 'double'
  280 |             vector< complex<double> > pA(N,0),aA(N,0);
      |                             ^~~~~~
a.cc:281:33: error: 'pA' was not declared in this scope; did you mean 'A'?
  281 |             for(x=0;x<A.d;x++)  pA[x].real(A.num[x]);
      |                                 ^~
      |                                 A
a.cc:282:33: error: 'pA' was not declared in this scope; did you mean 'A'?
  282 |             for(y=0;y<B.d;y++)  pA[y].imag(B.num[y]);
      |                                 ^~
      |                                 A
a.cc:283:13: error: 'aA' was not declared in this scope; did you mean 'A'?
  283 |             aA=FFT(pA,false);
      |             ^~
      |             A
a.cc:283:20: error: 'pA' was not declared in this scope; did you mean 'A'?
  283 |             aA=FFT(pA,false);
      |                    ^~
      |                    A
a.cc:283:16: error: 'FFT' was not declared in this scope
  283 |             aA=FFT(pA,false);
      |                ^~~
a.cc:288:29: error: 'round' was not declared in this scope
  288 |                 double temp=round(pA[i].imag()/2+carry);
      |                             ^~~~~
a.cc: In member function 'const tbb::LInt tbb::LInt::operator/(int) const':
a.cc:299:38: error: 'const struct tbb::LInt' has no member named 'div2'
  299 |             if(B==2)    return this->div2();
      |                                      ^~~~
a.cc:302:17: error: no match for 'operator==' (operand types are 'const tbb::LInt' and 'int')
  302 |             if(A==0&&B==0)  return false;
      |                ~^~~
      |                |  |
      |                |  int
      |                const tbb::LInt
a.cc:302:17: note: candidate: 'operator==(int, int)' (built-in)
  302 |             if(A==0&&B==0)  return false;
      |                ~^~~
a.cc:302:17: note:   no known conversion for argument 1 from 'const tbb::LInt' to 'int'
a.cc:303:17: error: no match for 'operator==' (operand types are 'const tbb::LInt' and 'int')
  303 |             if(A==0)    return 0;
      |                ~^~~
      |                |  |
      |                |  int
      |                const tbb::LInt
a.cc:303:17: note: candidate: 'operator==(int, int)' (built-in)
  303 |             if(A==0)    return 0;
      |                ~^~~
a.cc:303:17: note:   no known conversion for argument 1 from 'const tbb::LInt' to 'int'
a.cc:305:45: error: no match for 'operator-' (operand type is 'const tbb::LInt')
  305 |             if(A.isinf())   return (B>=0)?A:-A;
      |                                             ^~
a.cc:305:45: note: candidate: 'operator-(int)' (built-in)
a.cc:305:45: note:   no known conversion for argument 1 from 'const tbb::LInt' to 'int'
a.cc:331:21: note: candidate: 'tbb::LInt tbb::operator-(int, const LInt&)'
  331 |         friend LInt operator-(int A, const LInt &B) {
      |                     ^~~~~~~~
a.cc:331:21: note:   candidate expects 2 arguments, 1 provided
a.cc: In function 'tbb::LInt tbb::operator+(int, const LInt&)':
a.cc:329:21: error: no match for 'operator+' (operand types are 'const tbb::LInt' and 'tbb::LInt')
  329 |             return B+LInt(A);
      |                    ~^~~~~~~~
      |                    | |
      |                    | tbb::LInt
      |                    const tbb::LInt
a.cc:329:21: note: candidate: 'operator+(int, int)' (built-in)
  329 |             return B+LInt(A);
      |                    ~^~~~~~~~
a.cc:329:21: note:   no known conversion for argument 2 from 'tbb::LInt' to 'int'
a.cc:328:21: note: candidate: 'tbb::LInt tbb::operator+(int, const LInt&)'
  328 |         friend LInt operator+(int A, const LInt &B) {
      |                     ^~~~~~~~
a.cc:328:35: note:   no known conversion for argument 1 from 'const tbb::LInt' to 'int'
  328 |         friend LInt operator+(int A, const LInt &B) {
      |                               ~~~~^
a.cc: In function 'tbb::LInt tbb::operator-(int, const LInt&)':
a.cc:332:20: error: no match for 'operator-' (operand type is 'const tbb::LInt')
  332 |             return -B+LInt(A);
      |                    ^~
a.cc:332:20: note: candidate: 'operator-(int)' (built-in)
a.cc:332:20: note:   no known conversion for argument 1 from 'const tbb::LInt' to 'int'
a.cc:331:21: