const double pai=3.1415926535897;
struct xushu{
	double sb,xb;
	xushu qq() {
		sb=xb=0;
		return *this;
	}
	xushu (double _sb=0,double _xb=0) {sb=_sb,xb=_xb;}
	xushu operator += (const xushu &x){
		sb+=x.sb;
		xb+=x.xb;
		return *this;
	}
	const xushu operator + (const xushu &_x){
		return (xushu){sb+_x.sb,xb+_x.xb};
	}
	const xushu operator * (const xushu &_x){
		return (xushu){sb*_x.sb-xb*_x.xb,sb*_x.xb+xb*_x.sb};
	}
	xushu operator *= (const xushu &_x){
		return *this=(xushu){sb*_x.sb-xb*_x.xb,sb*_x.xb+xb*_x.sb};
	}
	const xushu operator - (const xushu &_x){
		return (xushu){sb-_x.sb,xb-_x.xb};
	}
	xushu operator -= (const xushu &_x){
			return *this=(xushu){sb-_x.sb,xb-_x.xb};
	}
};
const xushu I=(xushu){0,1};
xushu make_xushu(double _sb,double _xb){
	xushu _x;
	return _x.sb=_sb,_x.xb=_xb,_x;
}
//extern void FFT(xushu [],int,bool) __asm__ ("FFT"); 
xushu FX[200000];
int _tr[200000];
void FFT(xushu _f[],int __len,bool lx){
	for(int _i=0;_i<__len;++_i)
		if(_i<_tr[_i]) swap(_f[_i],_f[_tr[_i]]);
	for(int _p=2;_p<=__len;_p<<=1)
	{
		int len=_p>>1;
		xushu _xx(cos(pai/len),sin(pai/len));
		if(!lx) _xx.xb*=-1;
		for(int _k=0;_k<__len;_k+=_p)
		{
			xushu _wn(1,0);
			for(int _l=_k;_l<_k+len;++_l)
			{
				xushu _xxx=_wn*_f[len+_l];
				_f[len+_l]=_f[_l]-_xxx;
				_f[_l]+=_xxx;
				_wn*=_xx;
			}
		}
	}
}

struct __Int256{
	//typedef unsigned long long _ULL;
	//typedef __Int256 _ll;
	//const unsigned long long _p=1000000000;
	char _num[10000];
	//string _num="";
	int _len;
	bool _neg;
	__Int256 qq(){return memset(_num,'\0',sizeof(_num)),_len=0,_neg=0,*this;}
	/*__Int256 operator = (const long long &_x)
	{
		int __x=_x;
		this->qq();
		if(__x<0) __x=-__x,_neg=1;
		char _a[20];
		do{_a[_len++]=__x%10,__x/=10;}while(__x);
		for(int _i=_len-1;_i>=0;--_i)
		{
			_num[_i]=_a[_len-1-_i];
		}
		return *this;
	}*/
	__Int256 (const long long _x=0)
	{
		long long __x=_x;
		//_num="";
		this->qq();
		_len=0,_neg=0;
		if(__x<0) __x=-__x,_neg=1;
		//char _a[1000000];
		while(__x){_num[_len++]=__x%10,__x/=10;}
		//return *this;
	}
	char& operator [] (const int &_x)
	{
		return _num[_x];
	}
	void get()
	{
		this->qq();
		//char _a[100000];
		char _ch=getchar();
		//int cnt=0;
		while(_ch<'0'||_ch>'9') {if(_ch=='-') _neg=1;_ch=getchar();}
		while(_ch>='0'&&_ch<='9') {_num[_len++]=(_ch^48);_ch=getchar();}
		int _i=0,_j=_len-1;
		while(_i<_j)
		{
			swap(_num[_i],_num[_j]);
			++_i,--_j;
		}
		//return *this;
	}
	void pp(){
		if(!_len) {
			putchar('0');
			return ;
		}
		if(_neg) putchar('-');
		for(int _i=_len-1;_i>=0;--_i) putchar(_num[_i]+'0');
	}
	friend __Int256 abs(__Int256 _x)
	{
		_x._neg=0;
		return _x;
	}
	__Int256 operator - ()
	{
		__Int256 _x=*this;
		return _x._neg^=1,_x;
	}
	const bool operator == (const __Int256 _x) const 
	{
		if((_x._neg^_neg)||(_len!=_x._len)) return false;
		for(int _i=0;_i<_len;++_i)
		{
			if(_num[_i]!=_x._num[_i]) return false;
		}
		return true;
	}
	const bool operator > (const __Int256 _x) const 
	{
		if(_x._neg^_neg) return _x._neg; 
		if(_len!=_x._len) return _len>_x._len;
		for(int _i=_len-1;_i>=0;--_i)
		{
			if(_num[_i]!=_x._num[_i]) return (_num[_i]>_x._num[_i])^_neg;
		}
		return false;
	}
	const bool operator < (const __Int256 _x) const 
	{
		if(_x._neg^_neg) return _neg;
		if(_len!=_x._len) return _len<_x._len;
		for(int _i=_len-1;_i>=0;--_i)
		{
			if(_num[_i]!=_x._num[_i]) return (_num[_i]<_x._num[_i])^_neg;
		}
		return false;
	}
	const bool operator >= (const __Int256 _x) const 
	{
		if(_x._neg^_neg) return _x._neg;
		if(_len!=_x._len) return _len>_x._len;
		for(int _i=_len-1;_i>=0;--_i)
		{
			if(_num[_i]!=_x._num[_i]) return (_num[_i]>_x._num[_i])^_neg;
		}
		return true;
	}
	const bool operator <= (const __Int256 _x) const 
	{
		if(_x._neg^_neg) return _neg;
		if(_len!=_x._len) return _len<_x._len;
		for(int _i=_len-1;_i>=0;--_i)
		{
			if(_num[_i]!=_x._num[_i]) return (_num[_i]<_x._num[_i])^_neg;
		}
		return true;
	}
	const bool operator != (const __Int256 _x) const
	{
		if(_x._neg^_neg) return true;
		if(_len!=_x._len) return true;
		for(int _i=_len-1;_i>=0;--_i)
		{
			if(_num[_i]!=_x._num[_i]) return true;
		}
		return false;
	}
	const __Int256 operator + (const __Int256 _x)
	{
		__Int256 _a=*this,_b=_x;
		/*_a._num=_num,_b._num=_x._num;
		_a._len=_len,_b._len=_x._len;
		_a._neg=_neg,_b._neg=_x._neg;*/
		const int _mxl=(_a._len>_b._len)?(_a._len):(_b._len);
		if(_a._neg&&!_b._neg)
		{
			_a._neg=_b._neg=0;
			if(_a<=_b)
			{
				for(int _i=0;_i<_mxl;++_i)
				{
					if(_a._num[_i]>_b._num[_i])
					{
						_b._num[_i]+=10;
						++_a._num[_i+1];
					}
					_a._num[_i]=_b._num[_i]-_a._num[_i];
				}
				_a._len=_mxl+_a._num[_mxl];
				while(_a._len>=0&&!_a._num[_a._len])
				{
					--_a._len;
				}
				return _a._neg=0,++_a._len,_a;
			}
			else
			{
				for(int _i=0;_i<_mxl;++_i)
				{
					if(_b._num[_i]>_a._num[_i])
					{
						_a._num[_i]+=10;
						++_b._num[_i+1];
					}
					_b._num[_i]=_a._num[_i]-_b._num[_i];
				}
				_b._len=_mxl+_b._num[_mxl];
				while(_b._len>=0&&!_b._num[_b._len])
				{
					--_b._len;
				}
				return _b._neg=1,++_b._len,_b;
			}
		}
		else if(!_a._neg&&_b._neg)
		{
			_a._neg=_b._neg=0;
			if(_a>=_b)
			{
				for(int _i=0;_i<_mxl;++_i)
				{
					if(_b._num[_i]>_a._num[_i])
					{
						_a._num[_i]+=10;
						++_b._num[_i+1];
					}
					_b._num[_i]=_a._num[_i]-_b._num[_i];
				}
				_b._len=_mxl+_b._num[_mxl];
				while(_b._len>=0&&!_b._num[_b._len])
				{
					--_b._len;
				}
				return _b._neg=0,++_b._len,_b;
			}
			else
			{
				for(int _i=0;_i<_mxl;++_i)
				{
					if(_a._num[_i]>_b._num[_i])
					{
						_b._num[_i]+=10;
						++_a._num[_i+1];
					}
					_a._num[_i]=_b._num[_i]-_a._num[_i];
				}
				_a._len=_mxl+_a._num[_mxl];
				while(_a._len>=0&&!_a._num[_a._len])
				{
					--_a._len;
				}
				return _a._neg=1,++_a._len,_a;
			}
		}
		else if(_neg==_x._neg)
		{
			for(int _i=0;_i<_mxl;++_i)
			{
				_a._num[_i]+=_b._num[_i];
				if(_a._num[_i]>9)
				{
					_a._num[_i]-=10;
					++_a._num[_i+1];
				}
			}
			_a._len=_mxl+_a._num[_mxl];
			while(_a._len>=0&&!_a._num[_a._len])
			{
				--_a._len;
			}
			return _a._neg=_neg,++_a._len,_a;
		}
		return *this;
	}
	const __Int256 operator - (const __Int256 _x)
	{
		__Int256 __x=_x;
		__x._neg^=1;
		return *this+__x;
	}
	__Int256& operator += (const __Int256 _x)
	{
		return (*this=*this+_x),*this;
	}
	__Int256& operator -= (const __Int256 _x)
	{
		return (*this=*this-_x),*this;
	}
	const __Int256 operator * (const __Int256 _x)
	{
		__Int256 _c;
		_c.qq();
		if(_x._len==0) return _c;
		if(_x._len==1)
		{
			int _xx=_x._num[0];
			for(int _i=0;_i<_len;++_i)
			{
				_c._num[_i]+=_num[_i]*_xx;
				_c._num[_i+1]+=_c._num[_i]/10;
				_c._num[_i]%=10;
			}
			_c._len=_len+1;
			while(_c._len>=0&&!_c._num[_c._len]) --_c._len;
			++_c._len;
			return _c;
		}
		//xushu X[(_len+_x._len)<<1|1];
		memset(FX,0,sizeof (FX) );
		for(int _i=0;_i<_len;++_i)
			{
				FX[_i].sb=_num[_i];
			}
			for(int _i=0;_i<_x._len;++_i)
			{
				FX[_i].xb=_x._num[_i];
			}
			int __len=1;
			while(__len<=_len+_x._len) __len<<=1;
			memset(_tr,0,sizeof(_tr));
			for(int _i=0;_i<__len;++_i)
			{
				_tr[_i]=(_tr[_i>>1]>>1)|((_i&1)?(__len>>1):0);
			}
			FFT(FX,__len,1);
			for(int _i=0;_i<=__len;++_i)
			{
				FX[_i]*=FX[_i];
			}
			FFT(FX,__len,0);
			for(int _i=0;_i<=_len+_x._len+1;++_i)
			{
				int _xx=(FX[_i].xb/2.0/__len+0.5);
				int _j=_i;
				while(_xx)
				{
					_c._num[_j]+=_xx%10;
					_xx/=10;
					_c._num[_j+1]+=_c._num[_j]/10;
					_c._num[_j]%=10;
					++_j;
				}
			}
			_c._neg=(_neg^_x._neg);
			int _i=_len+_x._len+1;
			while(_i--)
			{
				if(_c._num[_i])
				{
					_c._len=_i+1;
					break;
				}
			}
			return _c;
	}
	__Int256& operator *= (const __Int256 _x)
	{
		return *this=*this*_x,*this;
	}
	friend istream& operator >> (istream &in,__Int256 &_x)
	{
		_x.get();
		return in;
	}
	friend ostream& operator << (ostream &out,const __Int256 _x)
	{
		if(!_x._len) return putchar('0'),out;
		if(_x._neg) putchar('-');
		for(int _i=_x._len-1;_i>=0;--_i) putchar(_x._num[_i]^48);
		return out;
	}
	const __Int256 operator / (const __Int256 _x)
	{
		if(!_x._len) return puts("FUCK"),0;
		__Int256 _c;
		__Int256 _a=*this;
		_a._neg=0;
		_c.qq();
		if(*this<_x) return _c;
		_c._len=_a._len-_x._len+1;
		for(int _i=_c._len+1;_i>=0;--_i)
		{
		    __Int256 _t;_t.qq();
		    _t._len=_x._len+_i;
			for(int j=_t._len-1;j>=_i;--j)
			{
				_t._num[j]=_x._num[j-_i];
			}
	        while(_a>=_t)
		    {
		    	//puts("hhh");
		        ++_c._num[_i];
		        _a=_a-_t;
		        //if(_a==_t) break;
				//while(_a._len>0&&!_a._num[_a._len-1]) --_a._len;
		    }
		    if(_a._len==0) break;
		}
		while (_c._len>=0&&!_c._num[_c._len]) --_c._len;
		++_c._len;
	    return _c._neg=(_neg^_x._neg),_c;
	}
	const __Int256 operator % (const __Int256 _x)
	{
		//__Int256 _c;
		__Int256 _a=*this;
		//_c.qq();
		if(*this<_x) return *this;
		if(*this == _x|| _x==0 ) return _a.qq();
		//_c._len=_a._len-_x._len+1;
		for(int _i=_a._len-_x._len+1;_i>=0;--_i)
		{
			__Int256 _t;_t.qq();
			_t._len=_x._len+_i;
			for(int j=_t._len-1;j>=_i;--j)
			{
				_t._num[j]=_x._num[j-_i];
			}
		    while(_a>=_t)
			{
			    //++_c._num[_i];
			    _a=_a-_t;
		        //if(_a==_t) break;
				//while(_a._len>0&&!_a._num[_a._len-1]) --_a._len;
			}
		    if(_a._len==0) break;
		}
		//while (_c._len>0&&!_c._num[_c._len-1]) --_c._len;
		return _a;
	}
	__Int256& operator %= (const __Int256 _x)
	{
		return *this=*this%_x,*this;
	}
	__Int256& operator /= (const __Int256 _x)
	{
		return *this=*this/_x,*this;
	}
};
const __Int256 operator / (const long long _x,const __Int256 _y)
{
	return __Int256(_x)/_y;
}
const __Int256 operator + (const long long _x,const __Int256 _y)
{
	return __Int256(_x)+_y;
}
const __Int256 operator - (const long long _x,const __Int256 _y)
{
	return __Int256(_x)-_y;
}
const __Int256 operator * (const long long _x,const __Int256 _y)
{
	return __Int256(_x)*_y;
}

蒟蒻不会快速的高精除QWQ