c++高精度代码（基础比较/运算/位运算+gcd/lcm/pow）：

#include<iostream>
#include<vector>
#include<algorithm>
#include<ctime>
using namespace std;
string jia(string s1, string s2){
	string s3;
	for(int i=0;i<max(s1.size(), s2.size());i++){
		while(s3.size()<=i+1)s3.push_back('0');
		if(i<s1.size()){
			s3[i+1]=(s3[i]+s1[i]-0x60)/10+0x30;
			s3[i]=(s3[i]+s1[i]-0x60)%10+0x30;
		}
		if(i<s2.size()){
			s3[i+1]+=(s3[i]+s2[i]-0x60)/10;
			s3[i]=(s3[i]+s2[i]-0x60)%10+0x30;
		}
	}
	if(s3[s3.size()-1]=='0')s3.erase(s3.end()-1);
	return s3;
}
string jian(string s1, string s2){
	bool bo=0;
	string s3(s1.size(), '0');
	for(int i=0;i<s1.size();i++){
		if(bo)s1[i]--;
		if(s1[i]<s2[i]){
			bo=1;
			s1[i]+=10;
		}else bo=0;
		s3[i]=s1[i];
		if(i<s2.size())s3[i]-=s2[i]-'0';
	}
	while(s3.size()>1&&s3[s3.size()-1]=='0')s3.erase(s3.end()-1);
	return s3;
}
string chu2(string s1){
	string s3(s1.size(), '0');
	reverse(s1.begin(), s1.end());
	for(int i=0;i<s1.size();i++){
		s3[i]+=(s1[i]-'0')/2;
		if(i+1<s1.size())s3[i+1]+=(s1[i]-'0')%2*5;
	}
	reverse(s3.begin(), s3.end());
	if(s3.size()>1&&s3[s3.size()-1]=='0')s3.erase(s3.end()-1);
	return s3;
}
class bignum{
	vector<char>num;
public:
	
	bignum()=default;
	explicit bignum(long long n){
		num.clear();
		while(n){
			num.push_back(n&1);
			n>>=1;
		}
	}
	explicit bignum(long n){
		num.clear();
		while(n){
			num.push_back(n&1);
			n>>=1;
		}
	}
	explicit bignum(int n){
		num.clear();
		while(n){
			num.push_back(n&1);
			n>>=1;
		}
	}
	explicit bignum(short n){
		num.clear();
		while(n){
			num.push_back(n&1);
			n>>=1;
		}
	}
	explicit bignum(unsigned long long n){
		num.clear();
		while(n){
			num.push_back(n&1);
			n>>=1;
		}
	}
	explicit bignum(unsigned long n){
		num.clear();
		while(n){
			num.push_back(n&1);
			n>>=1;
		}
	}
	explicit bignum(unsigned int n){
		num.clear();
		while(n){
			num.push_back(n&1);
			n>>=1;
		}
	}
	explicit bignum(unsigned short n){
		num.clear();
		while(n){
			num.push_back(n&1);
			n>>=1;
		}
	}
	explicit bignum(bool n){
		num.clear();
		num.push_back(n);
	}
	
	explicit operator long long(){
		long long n=0;
		for(int i=0;i<(*this).size();i++)n+=num[i]*(1<<i);
		return n;
	}
	explicit operator long(){
		long n=0;
		for(int i=0;i<(*this).size();i++)n+=num[i]*(1<<i);
		return n;
	}
	explicit operator int(){
		int n=0;
		for(int i=0;i<(*this).size();i++)n+=num[i]*(1<<i);
		return n;
	}
	explicit operator short(){
		short n=0;
		for(int i=0;i<(*this).size();i++)n+=num[i]*(1<<i);
		return n;
	}
	explicit operator unsigned long long(){
		unsigned long long n=0;
		for(int i=0;i<(*this).size();i++)n+=num[i]*(1<<i);
		return n;
	}
	explicit operator unsigned long(){
		unsigned long n=0;
		for(int i=0;i<(*this).size();i++)n+=num[i]*(1<<i);
		return n;
	}
	explicit operator unsigned int(){
		unsigned int n=0;
		for(int i=0;i<(*this).size();i++)n+=num[i]*(1<<i);
		return n;
	}
	explicit operator unsigned short(){
		unsigned short n=0;
		for(int i=0;i<(*this).size();i++)n+=num[i]*(1<<i);
		return n;
	}
	explicit operator bool(){
		if((*this).size())return 1;
		else return 0;
	}
	
	friend istream& operator>>(istream &fin, bignum &b);
	friend ostream& operator<<(ostream &fout, bignum b);
	friend void qu0(bignum&);
	int size(){
		qu0(*this);
		return (int)(*this).size();
	}
	
	bignum operator=(bignum b){
		num=b.num;
		return *this;
	}
	bignum operator=(long long n){
		num.clear();
		while(n){
			num.push_back(n&1);
			n>>=1;
		}
		return *this;
	}
	bignum operator=(long n){
		num.clear();
		while(n){
			num.push_back(n&1);
			n>>=1;
		}
		return *this;
	}
	bignum operator=(int n){
		num.clear();
		while(n){
			num.push_back(n&1);
			n>>=1;
		}
		return *this;
	}
	bignum operator=(short n){
		num.clear();
		while(n){
			num.push_back(n&1);
			n>>=1;
		}
		return *this;
	}
	bignum operator=(unsigned long long n){
		num.clear();
		while(n){
			num.push_back(n&1);
			n>>=1;
		}
		return *this;
	}
	bignum operator=(unsigned long n){
		num.clear();
		while(n){
			num.push_back(n&1);
			n>>=1;
		}
		return *this;
	}
	bignum operator=(unsigned int n){
		num.clear();
		while(n){
			num.push_back(n&1);
			n>>=1;
		}
		return *this;
	}
	bignum operator=(unsigned short n){
		num.clear();
		while(n){
			num.push_back(n&1);
			n>>=1;
		}
		return *this;
	}
	bignum operator=(bool n){
		n=(*this!=(bignum)0);
		return *this;
	}
	
	char& operator[](long long n){
		while((*this).size()<=n)num.push_back(0);
		return num[n];
	}
	char& operator[](long n){
		while((*this).size()<=n)num.push_back(0);
		return num[n];
	}
	char& operator[](int n){
		while((*this).size()<=n)num.push_back(0);
		return num[n];
	}
	char& operator[](short n){
		while((*this).size()<=n)num.push_back(0);
		return num[n];
	}
	char& operator[](unsigned long long n){
		while((*this).size()<=n)num.push_back(0);
		return num[n];
	}
	char& operator[](unsigned long n){
		while((*this).size()<=n)num.push_back(0);
		return num[n];
	}
	char& operator[](unsigned int n){
		while((*this).size()<=n)num.push_back(0);
		return num[n];
	}
	char& operator[](unsigned short n){
		while((*this).size()<=n)num.push_back(0);
		return num[n];
	}
	char& operator[](bool n){
		if(n)return num[1];
		return num[0];
	}
	char& operator[](bignum b){
		int n(b);
		return (*this)[n];
	}
	
	bool operator<(bignum b)const{
		bignum oa=*this, ob=b;
		for(int i=max(oa.size(), ob.size())-1;i>=0;i--)if(oa[i]!=ob[i]){
			if(oa[i])return false;
			else return true;
		}
		return false;
	}
	bool operator<(long long b)const{
		return *this<(bignum)b;
	}
	bool operator<(long b)const{
		return *this<(bignum)b;
	}
	bool operator<(int b)const{
		return *this<(bignum)b;
	}
	bool operator<(short b)const{
		return *this<(bignum)b;
	}
	bool operator<(unsigned long long b)const{
		return *this<(bignum)b;
	}
	bool operator<(unsigned long b)const{
		return *this<(bignum)b;
	}
	bool operator<(unsigned int b)const{
		return *this<(bignum)b;
	}
	bool operator<(unsigned short b)const{
		return *this<(bignum)b;
	}
	bool operator<(bool b)const{
		return *this<(bignum)b;
	}
	friend bool operator<(long long, bignum);
	friend bool operator<(long, bignum);
	friend bool operator<(int, bignum);
	friend bool operator<(short, bignum);
	friend bool operator<(unsigned long long, bignum);
	friend bool operator<(unsigned long, bignum);
	friend bool operator<(unsigned int, bignum);
	friend bool operator<(unsigned short, bignum);
	friend bool operator<(bool, bignum);
	
	bool operator>(bignum b)const{
		bignum oa=*this, ob=b;
		for(int i=max(oa.size(), ob.size())-1;i>=0;i--)if(oa[i]!=ob[i]){
			if(oa[i])return true;
			else return false;
		}
		return false;
	}
	bool operator>(long long b)const{
		return *this>(bignum)b;
	}
	bool operator>(long b)const{
		return *this>(bignum)b;
	}
	bool operator>(int b)const{
		return *this>(bignum)b;
	}
	bool operator>(short b)const{
		return *this>(bignum)b;
	}
	bool operator>(unsigned long long b)const{
		return *this>(bignum)b;
	}
	bool operator>(unsigned long b)const{
		return *this>(bignum)b;
	}
	bool operator>(unsigned int b)const{
		return *this>(bignum)b;
	}
	bool operator>(unsigned short b)const{
		return *this>(bignum)b;
	}
	bool operator>(bool b)const{
		return *this>(bignum)b;
	}
	friend bool operator>(long long, bignum);
	friend bool operator>(long, bignum);
	friend bool operator>(int, bignum);
	friend bool operator>(short, bignum);
	friend bool operator>(unsigned long long, bignum);
	friend bool operator>(unsigned long, bignum);
	friend bool operator>(unsigned int, bignum);
	friend bool operator>(unsigned short, bignum);
	friend bool operator>(bool, bignum);
	
	bool operator==(bignum b)const{
		bignum oa=*this, ob=b;
		for(int i=0;i<max(oa.size(), ob.size());i++)if(oa[i]!=ob[i])return false;
		return true;
	}
	bool operator==(long long b)const{
		return *this==(bignum)b;
	}
	bool operator==(long b)const{
		return *this==(bignum)b;
	}
	bool operator==(int b)const{
		return *this==(bignum)b;
	}
	bool operator==(short b)const{
		return *this==(bignum)b;
	}
	bool operator==(unsigned long long b)const{
		return *this==(bignum)b;
	}
	bool operator==(unsigned long b)const{
		return *this==(bignum)b;
	}
	bool operator==(unsigned int b)const{
		return *this==(bignum)b;
	}
	bool operator==(unsigned short b)const{
		return *this==(bignum)b;
	}
	bool operator==(bool b)const{
		return *this==(bignum)b;
	}
	friend bool operator==(long long, bignum);
	friend bool operator==(long, bignum);
	friend bool operator==(int, bignum);
	friend bool operator==(short, bignum);
	friend bool operator==(unsigned long long, bignum);
	friend bool operator==(unsigned long, bignum);
	friend bool operator==(unsigned int, bignum);
	friend bool operator==(unsigned short, bignum);
	friend bool operator==(bool, bignum);
	
	bool operator!=(bignum b)const{
		return !(*this==b);
	}
	bool operator!=(long long b)const{
		return *this!=(bignum)b;
	}
	bool operator!=(long b)const{
		return *this!=(bignum)b;
	}
	bool operator!=(int b)const{
		return *this!=(bignum)b;
	}
	bool operator!=(short b)const{
		return *this!=(bignum)b;
	}
	bool operator!=(unsigned long long b)const{
		return *this!=(bignum)b;
	}
	bool operator!=(unsigned long b)const{
		return *this!=(bignum)b;
	}
	bool operator!=(unsigned int b)const{
		return *this!=(bignum)b;
	}
	bool operator!=(unsigned short b)const{
		return *this!=(bignum)b;
	}
	bool operator!=(bool b)const{
		return *this!=(bignum)b;
	}
	friend bool operator!=(long long, bignum);
	friend bool operator!=(long, bignum);
	friend bool operator!=(int, bignum);
	friend bool operator!=(short, bignum);
	friend bool operator!=(unsigned long long, bignum);
	friend bool operator!=(unsigned long, bignum);
	friend bool operator!=(unsigned int, bignum);
	friend bool operator!=(unsigned short, bignum);
	friend bool operator!=(bool, bignum);
	
	bool operator<=(bignum b)const{
		return !(*this>b);
	}
	bool operator<=(long long b)const{
		return *this<=(bignum)b;
	}
	bool operator<=(long b)const{
		return *this<=(bignum)b;
	}
	bool operator<=(int b)const{
		return *this<=(bignum)b;
	}
	bool operator<=(short b)const{
		return *this<=(bignum)b;
	}
	bool operator<=(unsigned long long b)const{
		return *this<=(bignum)b;
	}
	bool operator<=(unsigned long b)const{
		return *this<=(bignum)b;
	}
	bool operator<=(unsigned int b)const{
		return *this<=(bignum)b;
	}
	bool operator<=(unsigned short b)const{
		return *this<=(bignum)b;
	}
	bool operator<=(bool b)const{
		return *this<=(bignum)b;
	}
	friend bool operator<=(long long, bignum);
	friend bool operator<=(long, bignum);
	friend bool operator<=(int, bignum);
	friend bool operator<=(short, bignum);
	friend bool operator<=(unsigned long long, bignum);
	friend bool operator<=(unsigned long, bignum);
	friend bool operator<=(unsigned int, bignum);
	friend bool operator<=(unsigned short, bignum);
	friend bool operator<=(bool, bignum);
	
	bool operator>=(bignum b)const{
		return !(*this<b);
	}
	bool operator>=(long long b)const{
		return *this>=(bignum)b;
	}
	bool operator>=(long b)const{
		return *this>=(bignum)b;
	}
	bool operator>=(int b)const{
		return *this>=(bignum)b;
	}
	bool operator>=(short b)const{
		return *this>=(bignum)b;
	}
	bool operator>=(unsigned long long b)const{
		return *this>=(bignum)b;
	}
	bool operator>=(unsigned long b)const{
		return *this>=(bignum)b;
	}
	bool operator>=(unsigned int b)const{
		return *this>=(bignum)b;
	}
	bool operator>=(unsigned short b)const{
		return *this>=(bignum)b;
	}
	bool operator>=(bool b)const{
		return *this>=(bignum)b;
	}
	friend bool operator>=(long long, bignum);
	friend bool operator>=(long, bignum);
	friend bool operator>=(int, bignum);
	friend bool operator>=(short, bignum);
	friend bool operator>=(unsigned long long, bignum);
	friend bool operator>=(unsigned long, bignum);
	friend bool operator>=(unsigned int, bignum);
	friend bool operator>=(unsigned short, bignum);
	friend bool operator>=(bool, bignum);
	
	bignum operator+(bignum b){
		bignum ans;
		for(int i=0;i<max((*this).size(), b.size());i++){
			if(i<(*this).size()&&num[i]==1){
				if(ans[i]==1){
					ans[i+1]=1;
					ans[i]=0;
				}else ans[i]=1;
			}
			if(i<b.size()&&b.num[i]==1){
				if(ans[i]==1){
					ans[i+1]=1;
					ans[i]=0;
				}else ans[i]=1;
			}
		}
		qu0(ans);
		return ans;
	}
	bignum operator+(long long b){
		return *this+(bignum)b;
	}
	bignum operator+(long b){
		return *this+(bignum)b;
	}
	bignum operator+(int b){
		return *this+(bignum)b;
	}
	bignum operator+(short b){
		return *this+(bignum)b;
	}
	bignum operator+(unsigned long long b){
		return *this+(bignum)b;
	}
	bignum operator+(unsigned long b){
		return *this+(bignum)b;
	}
	bignum operator+(unsigned int b){
		return *this+(bignum)b;
	}
	bignum operator+(unsigned short b){
		return *this+(bignum)b;
	}
	bignum operator+(bool b){
		return *this+(bignum)b;
	}
	friend bignum operator+(long long, bignum);
	friend bignum operator+(long, bignum);
	friend bignum operator+(int, bignum);
	friend bignum operator+(short, bignum);
	friend bignum operator+(unsigned long long, bignum);
	friend bignum operator+(unsigned long, bignum);
	friend bignum operator+(unsigned int, bignum);
	friend bignum operator+(unsigned short, bignum);
	friend bignum operator+(bool, bignum);
	
	bignum operator-(bignum b){
		bignum ans, ob=b, oa=*this;
		for(int i=0;i<oa.size();i++){
			if(oa[i]<ob[i]){
				oa[i+1]--;
				oa[i]+=2;
			}
			ans[i]=oa[i]-ob[i];
		}
		qu0(ans);
		return ans;
	}
	bignum operator-(long long b){
		return *this-(bignum)b;
	}
	bignum operator-(long b){
		return *this-(bignum)b;
	}
	bignum operator-(int b){
		return *this-(bignum)b;
	}
	bignum operator-(short b){
		return *this-(bignum)b;
	}
	bignum operator-(unsigned long long b){
		return *this-(bignum)b;
	}
	bignum operator-(unsigned long b){
		return *this-(bignum)b;
	}
	bignum operator-(unsigned int b){
		return *this-(bignum)b;
	}
	bignum operator-(unsigned short b){
		return *this-(bignum)b;
	}
	bignum operator-(bool b){
		return *this-(bignum)b;
	}
	friend bignum operator-(long long, bignum);
	friend bignum operator-(long, bignum);
	friend bignum operator-(int, bignum);
	friend bignum operator-(short, bignum);
	friend bignum operator-(unsigned long long, bignum);
	friend bignum operator-(unsigned long, bignum);
	friend bignum operator-(unsigned int, bignum);
	friend bignum operator-(unsigned short, bignum);
	friend bignum operator-(bool, bignum);
	
	bignum operator+=(bignum b){
		return *this=*this+b;
	}
	bignum operator+=(long long b){
		return *this+=(bignum)b;
	}
	bignum operator+=(long b){
		return *this+=(bignum)b;
	}
	bignum operator+=(int b){
		return *this+=(bignum)b;
	}
	bignum operator+=(short b){
		return *this+=(bignum)b;
	}
	bignum operator+=(unsigned long long b){
		return *this+=(bignum)b;
	}
	bignum operator+=(unsigned long b){
		return *this+=(bignum)b;
	}
	bignum operator+=(unsigned int b){
		return *this+=(bignum)b;
	}
	bignum operator+=(unsigned short b){
		return *this+=(bignum)b;
	}
	bignum operator+=(bool b){
		return *this+=(bignum)b;
	}
	friend bignum operator+=(long long, bignum);
	friend bignum operator+=(long, bignum);
	friend bignum operator+=(int, bignum);
	friend bignum operator+=(short, bignum);
	friend bignum operator+=(unsigned long long, bignum);
	friend bignum operator+=(unsigned long, bignum);
	friend bignum operator+=(unsigned int, bignum);
	friend bignum operator+=(unsigned short, bignum);
	friend bignum operator+=(bool, bignum);
	
	bignum operator-=(bignum b){
		return *this=*this-b;
	}
	bignum operator-=(long long b){
		return *this-=(bignum)b;
	}
	bignum operator-=(long b){
		return *this-=(bignum)b;
	}
	bignum operator-=(int b){
		return *this-=(bignum)b;
	}
	bignum operator-=(short b){
		return *this-=(bignum)b;
	}
	bignum operator-=(unsigned long long b){
		return *this-=(bignum)b;
	}
	bignum operator-=(unsigned long b){
		return *this-=(bignum)b;
	}
	bignum operator-=(unsigned int b){
		return *this-=(bignum)b;
	}
	bignum operator-=(unsigned short b){
		return *this-=(bignum)b;
	}
	bignum operator-=(bool b){
		return *this-=(bignum)b;
	}
	friend bignum operator-=(long long, bignum);
	friend bignum operator-=(long, bignum);
	friend bignum operator-=(int, bignum);
	friend bignum operator-=(short, bignum);
	friend bignum operator-=(unsigned long long, bignum);
	friend bignum operator-=(unsigned long, bignum);
	friend bignum operator-=(unsigned int, bignum);
	friend bignum operator-=(unsigned short, bignum);
	friend bignum operator-=(bool, bignum);
	
	bignum operator++(){
		*this+=1;
		return *this;
	}
	bignum operator++(int){
		*this+=1;
		return *this-1;
	}
	
	bignum operator--(){
		*this-=1;
		return *this;
	}
	bignum operator--(int){
		*this-=1;
		return *this+1;
	}
	bignum operator|(bignum b){
		bignum ans=b;
		for(int i=0;i<(*this).size();i++)ans[i]=ans[i]||num[i];
		qu0(ans);
		return ans;
	}
	bignum operator|(long long b){
		return *this|(bignum)b;
	}
	bignum operator|(long b){
		return *this|(bignum)b;
	}
	bignum operator|(int b){
		return *this|(bignum)b;
	}
	bignum operator|(short b){
		return *this|(bignum)b;
	}
	bignum operator|(unsigned long long b){
		return *this|(bignum)b;
	}
	bignum operator|(unsigned long b){
		return *this|(bignum)b;
	}
	bignum operator|(unsigned int b){
		return *this|(bignum)b;
	}
	bignum operator|(unsigned short b){
		return *this|(bignum)b;
	}
	bignum operator|(bool b){
		return *this|(bignum)b;
	}
	friend bignum operator|(long long, bignum);
	friend bignum operator|(long, bignum);
	friend bignum operator|(int, bignum);
	friend bignum operator|(short, bignum);
	friend bignum operator|(unsigned long long, bignum);
	friend bignum operator|(unsigned long, bignum);
	friend bignum operator|(unsigned int, bignum);
	friend bignum operator|(unsigned short, bignum);
	friend bignum operator|(bool, bignum);
	
	bignum operator&(bignum b){
		bignum ans=b;
		for(int i=0;i<(*this).size();i++)ans[i]=ans[i]&&num[i];
		qu0(ans);
		return ans;
	}
	bignum operator&(long long b){
		return *this&(bignum)b;
	}
	bignum operator&(long b){
		return *this&(bignum)b;
	}
	bignum operator&(int b){
		return *this&(bignum)b;
	}
	bignum operator&(short b){
		return *this&(bignum)b;
	}
	bignum operator&(unsigned long long b){
		return *this&(bignum)b;
	}
	bignum operator&(unsigned long b){
		return *this&(bignum)b;
	}
	bignum operator&(unsigned int b){
		return *this&(bignum)b;
	}
	bignum operator&(unsigned short b){
		return *this&(bignum)b;
	}
	bignum operator&(bool b){
		return *this&(bignum)b;
	}
	friend bignum operator&(long long, bignum);
	friend bignum operator&(long, bignum);
	friend bignum operator&(int, bignum);
	friend bignum operator&(short, bignum);
	friend bignum operator&(unsigned long long, bignum);
	friend bignum operator&(unsigned long, bignum);
	friend bignum operator&(unsigned int, bignum);
	friend bignum operator&(unsigned short, bignum);
	friend bignum operator&(bool, bignum);
	
	bignum operator^(bignum b){
		bignum ans=b;
		for(int i=0;i<(*this).size();i++)ans[i]=(ans[i]!=num[i]);
		qu0(ans);
		return ans;
	}
	bignum operator^(long long b){
		return *this^(bignum)b;
	}
	bignum operator^(long b){
		return *this^(bignum)b;
	}
	bignum operator^(int b){
		return *this^(bignum)b;
	}
	bignum operator^(short b){
		return *this^(bignum)b;
	}
	bignum operator^(unsigned long long b){
		return *this^(bignum)b;
	}
	bignum operator^(unsigned long b){
		return *this^(bignum)b;
	}
	bignum operator^(unsigned int b){
		return *this^(bignum)b;
	}
	bignum operator^(unsigned short b){
		return *this^(bignum)b;
	}
	bignum operator^(bool b){
		return *this^(bignum)b;
	}
	friend bignum operator^(long long, bignum);
	friend bignum operator^(long, bignum);
	friend bignum operator^(int, bignum);
	friend bignum operator^(short, bignum);
	friend bignum operator^(unsigned long long, bignum);
	friend bignum operator^(unsigned long, bignum);
	friend bignum operator^(unsigned int, bignum);
	friend bignum operator^(unsigned short, bignum);
	friend bignum operator^(bool, bignum);
	
	bignum operator<<(bignum n){
		bignum ans;
		for(int i=0;i<n;i++)ans[i]=0;
		for(int i=0;i<(*this).size();i++)ans[i+n]=(*this)[i];
		qu0(ans);
		return ans;
	}
	bignum operator<<(long long b){
		return *this<<(bignum)b;
	}
	bignum operator<<(long b){
		return *this<<(bignum)b;
	}
	bignum operator<<(int b){
		return *this<<(bignum)b;
	}
	bignum operator<<(short b){
		return *this<<(bignum)b;
	}
	bignum operator<<(unsigned long long b){
		return *this<<(bignum)b;
	}
	bignum operator<<(unsigned long b){
		return *this<<(bignum)b;
	}
	bignum operator<<(unsigned int b){
		return *this<<(bignum)b;
	}
	bignum operator<<(unsigned short b){
		return *this<<(bignum)b;
	}
	bignum operator<<(bool b){
		return *this<<(bignum)b;
	}
	friend bignum operator<<(long long, bignum);
	friend bignum operator<<(long, bignum);
	friend bignum operator<<(int, bignum);
	friend bignum operator<<(short, bignum);
	friend bignum operator<<(unsigned long long, bignum);
	friend bignum operator<<(unsigned long, bignum);
	friend bignum operator<<(unsigned int, bignum);
	friend bignum operator<<(unsigned short, bignum);
	friend bignum operator<<(bool, bignum);
	
	bignum operator>>(bignum n){
		bignum on=*this, ans;
		for(int i(n);i<(*this).size();i++)ans[i-n]=on[i];
		qu0(ans);
		return ans;
	}
	bignum operator>>(long long b){
		return *this>>(bignum)b;
	}
	bignum operator>>(long b){
		return *this>>(bignum)b;
	}
	bignum operator>>(int b){
		return *this>>(bignum)b;
	}
	bignum operator>>(short b){
		return *this>>(bignum)b;
	}
	bignum operator>>(unsigned long long b){
		return *this>>(bignum)b;
	}
	bignum operator>>(unsigned long b){
		return *this>>(bignum)b;
	}
	bignum operator>>(unsigned int b){
		return *this>>(bignum)b;
	}
	bignum operator>>(unsigned short b){
		return *this>>(bignum)b;
	}
	bignum operator>>(bool b){
		return *this>>(bignum)b;
	}
	friend bignum operator>>(long long, bignum);
	friend bignum operator>>(long, bignum);
	friend bignum operator>>(int, bignum);
	friend bignum operator>>(short, bignum);
	friend bignum operator>>(unsigned long long, bignum);
	friend bignum operator>>(unsigned long, bignum);
	friend bignum operator>>(unsigned int, bignum);
	friend bignum operator>>(unsigned short, bignum);
	friend bignum operator>>(bool, bignum);
	
	bignum operator~(){
		bignum ans;
		for(int i=0;i<(*this).size();i++)ans[i]=!(*this)[i];
		return ans;
	}
	
	bignum operator|=(bignum b){
		return *this=*this|b;
	}
	bignum operator|=(long long b){
		return *this|=(bignum)b;
	}
	bignum operator|=(long b){
		return *this|=(bignum)b;
	}
	bignum operator|=(int b){
		return *this|=(bignum)b;
	}
	bignum operator|=(short b){
		return *this|=(bignum)b;
	}
	bignum operator|=(unsigned long long b){
		return *this|=(bignum)b;
	}
	bignum operator|=(unsigned long b){
		return *this|=(bignum)b;
	}
	bignum operator|=(unsigned int b){
		return *this|=(bignum)b;
	}
	bignum operator|=(unsigned short b){
		return *this|=(bignum)b;
	}
	bignum operator|=(bool b){
		return *this|=(bignum)b;
	}
	friend bignum operator|=(long long, bignum);
	friend bignum operator|=(long, bignum);
	friend bignum operator|=(int, bignum);
	friend bignum operator|=(short, bignum);
	friend bignum operator|=(unsigned long long, bignum);
	friend bignum operator|=(unsigned long, bignum);
	friend bignum operator|=(unsigned int, bignum);
	friend bignum operator|=(unsigned short, bignum);
	friend bignum operator|=(bool, bignum);
	
	bignum operator&=(bignum b){
		return *this=*this&b;
	}
	bignum operator&=(long long b){
		return *this&=(bignum)b;
	}
	bignum operator&=(long b){
		return *this&=(bignum)b;
	}
	bignum operator&=(int b){
		return *this&=(bignum)b;
	}
	bignum operator&=(short b){
		return *this&=(bignum)b;
	}
	bignum operator&=(unsigned long long b){
		return *this&=(bignum)b;
	}
	bignum operator&=(unsigned long b){
		return *this&=(bignum)b;
	}
	bignum operator&=(unsigned int b){
		return *this&=(bignum)b;
	}
	bignum operator&=(unsigned short b){
		return *this&=(bignum)b;
	}
	bignum operator&=(bool b){
		return *this&=(bignum)b;
	}
	friend bignum operator&=(long long, bignum);
	friend bignum operator&=(long, bignum);
	friend bignum operator&=(int, bignum);
	friend bignum operator&=(short, bignum);
	friend bignum operator&=(unsigned long long, bignum);
	friend bignum operator&=(unsigned long, bignum);
	friend bignum operator&=(unsigned int, bignum);
	friend bignum operator&=(unsigned short, bignum);
	friend bignum operator&=(bool, bignum);
	
	bignum operator^=(bignum b){
		return *this=*this^b;
	}
	bignum operator^=(long long b){
		return *this^=(bignum)b;
	}
	bignum operator^=(long b){
		return *this^=(bignum)b;
	}
	bignum operator^=(int b){
		return *this^=(bignum)b;
	}
	bignum operator^=(short b){
		return *this^=(bignum)b;
	}
	bignum operator^=(unsigned long long b){
		return *this^=(bignum)b;
	}
	bignum operator^=(unsigned long b){
		return *this^=(bignum)b;
	}
	bignum operator^=(unsigned int b){
		return *this^=(bignum)b;
	}
	bignum operator^=(unsigned short b){
		return *this^=(bignum)b;
	}
	bignum operator^=(bool b){
		return *this^=(bignum)b;
	}
	friend bignum operator^=(long long, bignum);
	friend bignum operator^=(long, bignum);
	friend bignum operator^=(int, bignum);
	friend bignum operator^=(short, bignum);
	friend bignum operator^=(unsigned long long, bignum);
	friend bignum operator^=(unsigned long, bignum);
	friend bignum operator^=(unsigned int, bignum);
	friend bignum operator^=(unsigned short, bignum);
	friend bignum operator^=(bool, bignum);
	
	bignum operator<<=(bignum b){
		return *this=*this<<b;
	}
	bignum operator<<=(long long b){
		return *this<<=(bignum)b;
	}
	bignum operator<<=(long b){
		return *this<<=(bignum)b;
	}
	bignum operator<<=(int b){
		return *this<<=(bignum)b;
	}
	bignum operator<<=(short b){
		return *this<<=(bignum)b;
	}
	bignum operator<<=(unsigned long long b){
		return *this<<=(bignum)b;
	}
	bignum operator<<=(unsigned long b){
		return *this<<=(bignum)b;
	}
	bignum operator<<=(unsigned int b){
		return *this<<=(bignum)b;
	}
	bignum operator<<=(unsigned short b){
		return *this<<=(bignum)b;
	}
	bignum operator<<=(bool b){
		return *this<<=(bignum)b;
	}
	friend bignum operator<<=(long long, bignum);
	friend bignum operator<<=(long, bignum);
	friend bignum operator<<=(int, bignum);
	friend bignum operator<<=(short, bignum);
	friend bignum operator<<=(unsigned long long, bignum);
	friend bignum operator<<=(unsigned long, bignum);
	friend bignum operator<<=(unsigned int, bignum);
	friend bignum operator<<=(unsigned short, bignum);
	friend bignum operator<<=(bool, bignum);
	
	bignum operator>>=(bignum b){
		return *this=*this>>b;
	}
	bignum operator>>=(long long b){
		return *this>>=(bignum)b;
	}
	bignum operator>>=(long b){
		return *this>>=(bignum)b;
	}
	bignum operator>>=(int b){
		return *this>>=(bignum)b;
	}
	bignum operator>>=(short b){
		return *this>>=(bignum)b;
	}
	bignum operator>>=(unsigned long long b){
		return *this>>=(bignum)b;
	}
	bignum operator>>=(unsigned long b){
		return *this>>=(bignum)b;
	}
	bignum operator>>=(unsigned int b){
		return *this>>=(bignum)b;
	}
	bignum operator>>=(unsigned short b){
		return *this>>=(bignum)b;
	}
	bignum operator>>=(bool b){
		return *this>>=(bignum)b;
	}
	friend bignum operator>>=(long long, bignum);
	friend bignum operator>>=(long, bignum);
	friend bignum operator>>=(int, bignum);
	friend bignum operator>>=(short, bignum);
	friend bignum operator>>=(unsigned long long, bignum);
	friend bignum operator>>=(unsigned long, bignum);
	friend bignum operator>>=(unsigned int, bignum);
	friend bignum operator>>=(unsigned short, bignum);
	friend bignum operator>>=(bool, bignum);
	
	
	bignum operator*(bignum b){
		bignum ans;
		for(int i=0;i<(*this).size();i++)if(num[i])ans+=b<<i;
		qu0(ans);
		return ans;
	}
	bignum operator*(long long b){
		return *this*(bignum)b;
	}
	bignum operator*(long b){
		return *this*(bignum)b;
	}
	bignum operator*(int b){
		return *this*(bignum)b;
	}
	bignum operator*(short b){
		return *this*(bignum)b;
	}
	bignum operator*(unsigned long long b){
		return *this*(bignum)b;
	}
	bignum operator*(unsigned long b){
		return *this*(bignum)b;
	}
	bignum operator*(unsigned int b){
		return *this*(bignum)b;
	}
	bignum operator*(unsigned short b){
		return *this*(bignum)b;
	}
	bignum operator*(bool b){
		return *this*(bignum)b;
	}
	friend bignum operator*(long long, bignum);
	friend bignum operator*(long, bignum);
	friend bignum operator*(int, bignum);
	friend bignum operator*(short, bignum);
	friend bignum operator*(unsigned long long, bignum);
	friend bignum operator*(unsigned long, bignum);
	friend bignum operator*(unsigned int, bignum);
	friend bignum operator*(unsigned short, bignum);
	friend bignum operator*(bool, bignum);
	
	bignum operator/(bignum b){
		int i=0;
		bignum oa=*this, ob=b, ans;
		for(i;ob<=oa;i++)ob<<=1;
		if(!i)return(bignum)0;
		i--;
		ob>>=1;
		for(i;i>=0;i--){
			if(ob<=oa){
				ans[i]=1;
				oa-=ob;
			}
			ob>>=1;
		}
		qu0(ans);
		return ans;
	}
	bignum operator/(long long b){
		return *this/(bignum)b;
	}
	bignum operator/(long b){
		return *this/(bignum)b;
	}
	bignum operator/(int b){
		return *this/(bignum)b;
	}
	bignum operator/(short b){
		return *this/(bignum)b;
	}
	bignum operator/(unsigned long long b){
		return *this/(bignum)b;
	}
	bignum operator/(unsigned long b){
		return *this/(bignum)b;
	}
	bignum operator/(unsigned int b){
		return *this/(bignum)b;
	}
	bignum operator/(unsigned short b){
		return *this/(bignum)b;
	}
	bignum operator/(bool b){
		return *this/(bignum)b;
	}
	friend bignum operator/(long long, bignum);
	friend bignum operator/(long, bignum);
	friend bignum operator/(int, bignum);
	friend bignum operator/(short, bignum);
	friend bignum operator/(unsigned long long, bignum);
	friend bignum operator/(unsigned long, bignum);
	friend bignum operator/(unsigned int, bignum);
	friend bignum operator/(unsigned short, bignum);
	friend bignum operator/(bool, bignum);
	
	bignum operator%(bignum b){
		bignum ans=*this-*this/b*b;
		qu0(ans);
		return ans;
	}
	bignum operator%(long long b){
		return *this%(bignum)b;
	}
	bignum operator%(long b){
		return *this%(bignum)b;
	}
	bignum operator%(int b){
		return *this%(bignum)b;
	}
	bignum operator%(short b){
		return *this%(bignum)b;
	}
	bignum operator%(unsigned long long b){
		return *this%(bignum)b;
	}
	bignum operator%(unsigned long b){
		return *this%(bignum)b;
	}
	bignum operator%(unsigned int b){
		return *this%(bignum)b;
	}
	bignum operator%(unsigned short b){
		return *this%(bignum)b;
	}
	bignum operator%(bool b){
		return *this%(bignum)b;
	}
	friend bignum operator%(long long, bignum);
	friend bignum operator%(long, bignum);
	friend bignum operator%(int, bignum);
	friend bignum operator%(short, bignum);
	friend bignum operator%(unsigned long long, bignum);
	friend bignum operator%(unsigned long, bignum);
	friend bignum operator%(unsigned int, bignum);
	friend bignum operator%(unsigned short, bignum);
	friend bignum operator%(bool, bignum);
	
	bignum operator*=(bignum b){
		return *this=*this*b;
	}
	bignum operator*=(long long b){
		return *this*=(bignum)b;
	}
	bignum operator*=(long b){
		return *this*=(bignum)b;
	}
	bignum operator*=(int b){
		return *this*=(bignum)b;
	}
	bignum operator*=(short b){
		return *this*=(bignum)b;
	}
	bignum operator*=(unsigned long long b){
		return *this*=(bignum)b;
	}
	bignum operator*=(unsigned long b){
		return *this*=(bignum)b;
	}
	bignum operator*=(unsigned int b){
		return *this*=(bignum)b;
	}
	bignum operator*=(unsigned short b){
		return *this*=(bignum)b;
	}
	bignum operator*=(bool b){
		return *this*=(bignum)b;
	}
	friend bignum operator*=(long long, bignum);
	friend bignum operator*=(long, bignum);
	friend bignum operator*=(int, bignum);
	friend bignum operator*=(short, bignum);
	friend bignum operator*=(unsigned long long, bignum);
	friend bignum operator*=(unsigned long, bignum);
	friend bignum operator*=(unsigned int, bignum);
	friend bignum operator*=(unsigned short, bignum);
	friend bignum operator*=(bool, bignum);
	
	bignum operator/=(bignum b){
		return *this=*this/b;
	}
	bignum operator/=(long long b){
		return *this/=(bignum)b;
	}
	bignum operator/=(long b){
		return *this/=(bignum)b;
	}
	bignum operator/=(int b){
		return *this/=(bignum)b;
	}
	bignum operator/=(short b){
		return *this/=(bignum)b;
	}
	bignum operator/=(unsigned long long b){
		return *this/=(bignum)b;
	}
	bignum operator/=(unsigned long b){
		return *this/=(bignum)b;
	}
	bignum operator/=(unsigned int b){
		return *this/=(bignum)b;
	}
	bignum operator/=(unsigned short b){
		return *this/=(bignum)b;
	}
	bignum operator/=(bool b){
		return *this/=(bignum)b;
	}
	friend bignum operator/=(long long, bignum);
	friend bignum operator/=(long, bignum);
	friend bignum operator/=(int, bignum);
	friend bignum operator/=(short, bignum);
	friend bignum operator/=(unsigned long long, bignum);
	friend bignum operator/=(unsigned long, bignum);
	friend bignum operator/=(unsigned int, bignum);
	friend bignum operator/=(unsigned short, bignum);
	friend bignum operator/=(bool, bignum);
	
	bignum operator%=(bignum b){
		return *this=*this%b;
	}
	bignum operator%=(long long b){
		return *this%=(bignum)b;
	}
	bignum operator%=(long b){
		return *this%=(bignum)b;
	}
	bignum operator%=(int b){
		return *this%=(bignum)b;
	}
	bignum operator%=(short b){
		return *this%=(bignum)b;
	}
	bignum operator%=(unsigned long long b){
		return *this%=(bignum)b;
	}
	bignum operator%=(unsigned long b){
		return *this%=(bignum)b;
	}
	bignum operator%=(unsigned int b){
		return *this%=(bignum)b;
	}
	bignum operator%=(unsigned short b){
		return *this%=(bignum)b;
	}
	bignum operator%=(bool b){
		return *this%=(bignum)b;
	}
	friend bignum operator%=(long long, bignum);
	friend bignum operator%=(long, bignum);
	friend bignum operator%=(int, bignum);
	friend bignum operator%=(short, bignum);
	friend bignum operator%=(unsigned long long, bignum);
	friend bignum operator%=(unsigned long, bignum);
	friend bignum operator%=(unsigned int, bignum);
	friend bignum operator%=(unsigned short, bignum);
	friend bignum operator%=(bool, bignum);
	
};
istream& operator>>(istream& fin, bignum &b){
	b.num.clear();
	string s;
	fin >> s;
//	time_t be=clock(), en;
	reverse(s.begin(), s.end());
	while(s!="0"){
		b.num.push_back(s[0]%2);
		s=chu2(s);
	}
//	en=clock();
//	cout << "\n[input] : " << (int)(en-be) << "ms\n[input] : " << s << "\n\n";
	return fin;
}
ostream& operator<<(ostream &fout, bignum b){
//	time_t be=clock(), en;
	string s="0", k="1";
	for(auto x:b.num){
		if(x==1)s=jia(s, k);
		k=jia(k, k);
	}
	reverse(s.begin(), s.end());
//	en=clock();
//	cout << "\n[output] : " << (int)(en-be) << "ms\n[output] : " << s << "\n\n";
	fout << s;
	return fout;
}
void qu0(bignum& b){
	while(b.size()>1&&!b[b.size()-1])b.num.erase(b.num.end()-1);
}

bool operator<(long long n, bignum b){
	return (bignum)n<b;
}
bool operator<(long n, bignum b){
	return (bignum)n<b;
}
bool operator<(int n, bignum b){
	return (bignum)n<b;
}
bool operator<(short n, bignum b){
	return (bignum)n<b;
}
bool operator<(unsigned long long n, bignum b){
	return (bignum)n<b;
}
bool operator<(unsigned long n, bignum b){
	return (bignum)n<b;
}
bool operator<(unsigned int n, bignum b){
	return (bignum)n<b;
}
bool operator<(unsigned short n, bignum b){
	return (bignum)n<b;
}
bool operator<(bool n, bignum b){
	return (bignum)n<b;
}

bool operator>(long long n, bignum b){
	return (bignum)n>b;
}
bool operator>(long n, bignum b){
	return (bignum)n>b;
}
bool operator>(int n, bignum b){
	return (bignum)n>b;
}
bool operator>(short n, bignum b){
	return (bignum)n>b;
}
bool operator>(unsigned long long n, bignum b){
	return (bignum)n>b;
}
bool operator>(unsigned long n, bignum b){
	return (bignum)n>b;
}
bool operator>(unsigned int n, bignum b){
	return (bignum)n>b;
}
bool operator>(unsigned short n, bignum b){
	return (bignum)n>b;
}
bool operator>(bool n, bignum b){
	return (bignum)n>b;
}

bool operator==(long long n, bignum b){
	return (bignum)n==b;
}
bool operator==(long n, bignum b){
	return (bignum)n==b;
}
bool operator==(int n, bignum b){
	return (bignum)n==b;
}
bool operator==(short n, bignum b){
	return (bignum)n==b;
} 
bool operator==(unsigned long long n, bignum b){
	return (bignum)n==b;
}
bool operator==(unsigned long n, bignum b){
	return (bignum)n==b;
}
bool operator==(unsigned int n, bignum b){
	return (bignum)n==b;
}
bool operator==(unsigned short n, bignum b){
	return (bignum)n==b;
}
bool operator==(bool n, bignum b){
	return (bignum)n==b;
}

bool operator!=(long long n, bignum b){
	return (bignum)n!=b;
}
bool operator!=(long n, bignum b){
	return (bignum)n!=b;
}
bool operator!=(int n, bignum b){
	return (bignum)n!=b;
}
bool operator!=(short n, bignum b){
	return (bignum)n!=b;
} 
bool operator!=(unsigned long long n, bignum b){
	return (bignum)n!=b;
}
bool operator!=(unsigned long n, bignum b){
	return (bignum)n!=b;
}
bool operator!=(unsigned int n, bignum b){
	return (bignum)n!=b;
}
bool operator!=(unsigned short n, bignum b){
	return (bignum)n!=b;
}
bool operator!=(bool n, bignum b){
	return (bignum)n!=b;
}

bool operator<=(long long n, bignum b){
	return (bignum)n<=b;
}
bool operator<=(long n, bignum b){
	return (bignum)n<=b;
}
bool operator<=(int n, bignum b){
	return (bignum)n<=b;
}
bool operator<=(short n, bignum b){
	return (bignum)n<=b;
} 
bool operator<=(unsigned long long n, bignum b){
	return (bignum)n<=b;
}
bool operator<=(unsigned long n, bignum b){
	return (bignum)n<=b;
}
bool operator<=(unsigned int n, bignum b){
	return (bignum)n<=b;
}
bool operator<=(unsigned short n, bignum b){
	return (bignum)n<=b;
}
bool operator<=(bool n, bignum b){
	return (bignum)n<=b;
}

bool operator>=(long long n, bignum b){
	return (bignum)n>=b;
}
bool operator>=(long n, bignum b){
	return (bignum)n>=b;
}
bool operator>=(int n, bignum b){
	return (bignum)n>=b;
}
bool operator>=(short n, bignum b){
	return (bignum)n>=b;
}
bool operator>=(unsigned long long n, bignum b){
	return (bignum)n>=b;
}
bool operator>=(unsigned long n, bignum b){
	return (bignum)n>=b;
}
bool operator>=(unsigned int n, bignum b){
	return (bignum)n>=b;
}
bool operator>=(unsigned short n, bignum b){
	return (bignum)n>=b;
}
bool operator>=(bool n, bignum b){
	return (bignum)n>=b;
}

bignum operator+(long long n, bignum b){
	return (bignum)n+b;
}
bignum operator+(long n, bignum b){
	return (bignum)n+b;
}
bignum operator+(int n, bignum b){
	return (bignum)n+b;
}
bignum operator+(short n, bignum b){
	return (bignum)n+b;
}
bignum operator+(unsigned long long n, bignum b){
	return (bignum)n+b;
}
bignum operator+(unsigned long n, bignum b){
	return (bignum)n+b;
}
bignum operator+(unsigned int n, bignum b){
	return (bignum)n+b;
}
bignum operator+(unsigned short n, bignum b){
	return (bignum)n+b;
}
bignum operator+(bool n, bignum b){
	return (bignum)n+b;
}

bignum operator-(long long n, bignum b){
	return (bignum)n-b;
}
bignum operator-(long n, bignum b){
	return (bignum)n-b;
}
bignum operator-(int n, bignum b){
	return (bignum)n-b;
}
bignum operator-(short n, bignum b){
	return (bignum)n-b;
}
bignum operator-(unsigned long long n, bignum b){
	return (bignum)n-b;
}
bignum operator-(unsigned long n, bignum b){
	return (bignum)n-b;
}
bignum operator-(unsigned int n, bignum b){
	return (bignum)n-b;
}
bignum operator-(unsigned short n, bignum b){
	return (bignum)n-b;
}
bignum operator-(bool n, bignum b){
	return (bignum)n-b;
}

bignum operator+=(long long n, bignum b){
	return (bignum)n+=b;
}
bignum operator+=(long n, bignum b){
	return (bignum)n+=b;
}
bignum operator+=(int n, bignum b){
	return (bignum)n+=b;
}
bignum operator+=(short n, bignum b){
	return (bignum)n+=b;
}
bignum operator+=(unsigned long long n, bignum b){
	return (bignum)n+=b;
}
bignum operator+=(unsigned long n, bignum b){
	return (bignum)n+=b;
}
bignum operator+=(unsigned int n, bignum b){
	return (bignum)n+=b;
}
bignum operator+=(unsigned short n, bignum b){
	return (bignum)n+=b;
}
bignum operator+=(bool n, bignum b){
	return (bignum)n+=b;
}

bignum operator-=(long long n, bignum b){
	return (bignum)n-=b;
}
bignum operator-=(long n, bignum b){
	return (bignum)n-=b;
}
bignum operator-=(int n, bignum b){
	return (bignum)n-=b;
}
bignum operator-=(short n, bignum b){
	return (bignum)n-=b;
}
bignum operator-=(unsigned long long n, bignum b){
	return (bignum)n-=b;
}
bignum operator-=(unsigned long n, bignum b){
	return (bignum)n-=b;
}
bignum operator-=(unsigned int n, bignum b){
	return (bignum)n-=b;
}
bignum operator-=(unsigned short n, bignum b){
	return (bignum)n-=b;
}
bignum operator-=(bool n, bignum b){
	return (bignum)n-=b;
}

bignum operator|(long long n, bignum b){
	return (bignum)n|b;
}
bignum operator|(long n, bignum b){
	return (bignum)n|b;
}
bignum operator|(int n, bignum b){
	return (bignum)n|b;
}
bignum operator|(short n, bignum b){
	return (bignum)n|b;
}
bignum operator|(unsigned long long n, bignum b){
	return (bignum)n|b;
}
bignum operator|(unsigned long n, bignum b){
	return (bignum)n|b;
}
bignum operator|(unsigned int n, bignum b){
	return (bignum)n|b;
}
bignum operator|(unsigned short n, bignum b){
	return (bignum)n|b;
}
bignum operator|(bool n, bignum b){
	return (bignum)n|b;
}

bignum operator&(long long n, bignum b){
	return (bignum)n&b;
}
bignum operator&(long n, bignum b){
	return (bignum)n&b;
}
bignum operator&(int n, bignum b){
	return (bignum)n&b;
}
bignum operator&(short n, bignum b){
	return (bignum)n&b;
}
bignum operator&(unsigned long long n, bignum b){
	return (bignum)n&b;
}
bignum operator&(unsigned long n, bignum b){
	return (bignum)n&b;
}
bignum operator&(unsigned int n, bignum b){
	return (bignum)n&b;
}
bignum operator&(unsigned short n, bignum b){
	return (bignum)n&b;
}
bignum operator&(bool n, bignum b){
	return (bignum)n&b;
}

bignum operator^(long long n, bignum b){
	return (bignum)n^b;
}
bignum operator^(long n, bignum b){
	return (bignum)n^b;
}
bignum operator^(int n, bignum b){
	return (bignum)n^b;
}
bignum operator^(short n, bignum b){
	return (bignum)n^b;
}
bignum operator^(unsigned long long n, bignum b){
	return (bignum)n^b;
}
bignum operator^(unsigned long n, bignum b){
	return (bignum)n^b;
}
bignum operator^(unsigned int n, bignum b){
	return (bignum)n^b;
}
bignum operator^(unsigned short n, bignum b){
	return (bignum)n^b;
}
bignum operator^(bool n, bignum b){
	return (bignum)n^b;
}

bignum operator<<(long long n, bignum b){
	return (bignum)n<<b;
}
bignum operator<<(long n, bignum b){
	return (bignum)n<<b;
}
bignum operator<<(int n, bignum b){
	return (bignum)n<<b;
}
bignum operator<<(short n, bignum b){
	return (bignum)n<<b;
}
bignum operator<<(unsigned long long n, bignum b){
	return (bignum)n<<b;
}
bignum operator<<(unsigned long n, bignum b){
	return (bignum)n<<b;
}
bignum operator<<(unsigned int n, bignum b){
	return (bignum)n<<b;
}
bignum operator<<(unsigned short n, bignum b){
	return (bignum)n<<b;
}
bignum operator<<(bool n, bignum b){
	return (bignum)n<<b;
}

bignum operator>>(long long n, bignum b){
	return (bignum)n>>b;
}
bignum operator>>(long n, bignum b){
	return (bignum)n>>b;
}
bignum operator>>(int n, bignum b){
	return (bignum)n>>b;
}
bignum operator>>(short n, bignum b){
	return (bignum)n>>b;
}
bignum operator>>(unsigned long long n, bignum b){
	return (bignum)n>>b;
}
bignum operator>>(unsigned long n, bignum b){
	return (bignum)n>>b;
}
bignum operator>>(unsigned int n, bignum b){
	return (bignum)n>>b;
}
bignum operator>>(unsigned short n, bignum b){
	return (bignum)n>>b;
}
bignum operator>>(bool n, bignum b){
	return (bignum)n>>b;
}

bignum operator|=(long long n, bignum b){
	return (bignum)n|=b;
}
bignum operator|=(long n, bignum b){
	return (bignum)n|=b;
}
bignum operator|=(int n, bignum b){
	return (bignum)n|=b;
}
bignum operator|=(short n, bignum b){
	return (bignum)n|=b;
}
bignum operator|=(unsigned long long n, bignum b){
	return (bignum)n|=b;
}
bignum operator|=(unsigned long n, bignum b){
	return (bignum)n|=b;
}
bignum operator|=(unsigned int n, bignum b){
	return (bignum)n|=b;
}
bignum operator|=(unsigned short n, bignum b){
	return (bignum)n|=b;
}
bignum operator|=(bool n, bignum b){
	return (bignum)n|=b;
}

bignum operator&=(long long n, bignum b){
	return (bignum)n&=b;
}
bignum operator&=(long n, bignum b){
	return (bignum)n&=b;
}
bignum operator&=(int n, bignum b){
	return (bignum)n&=b;
}
bignum operator&=(short n, bignum b){
	return (bignum)n&=b;
}
bignum operator&=(unsigned long long n, bignum b){
	return (bignum)n&=b;
}
bignum operator&=(unsigned long n, bignum b){
	return (bignum)n&=b;
}
bignum operator&=(unsigned int n, bignum b){
	return (bignum)n&=b;
}
bignum operator&=(unsigned short n, bignum b){
	return (bignum)n&=b;
}
bignum operator&=(bool n, bignum b){
	return (bignum)n&=b;
}

bignum operator^=(long long n, bignum b){
	return (bignum)n^=b;
}
bignum operator^=(long n, bignum b){
	return (bignum)n^=b;
}
bignum operator^=(int n, bignum b){
	return (bignum)n^=b;
}
bignum operator^=(short n, bignum b){
	return (bignum)n^=b;
}
bignum operator^=(unsigned long long n, bignum b){
	return (bignum)n^=b;
}
bignum operator^=(unsigned long n, bignum b){
	return (bignum)n^=b;
}
bignum operator^=(unsigned int n, bignum b){
	return (bignum)n^=b;
}
bignum operator^=(unsigned short n, bignum b){
	return (bignum)n^=b;
}
bignum operator^=(bool n, bignum b){
	return (bignum)n^=b;
}

bignum operator<<=(long long n, bignum b){
	return (bignum)n<<=b;
}
bignum operator<<=(long n, bignum b){
	return (bignum)n<<=b;
}
bignum operator<<=(int n, bignum b){
	return (bignum)n<<=b;
}
bignum operator<<=(short n, bignum b){
	return (bignum)n<<=b;
}
bignum operator<<=(unsigned long long n, bignum b){
	return (bignum)n<<=b;
}
bignum operator<<=(unsigned long n, bignum b){
	return (bignum)n<<=b;
}
bignum operator<<=(unsigned int n, bignum b){
	return (bignum)n<<=b;
}
bignum operator<<=(unsigned short n, bignum b){
	return (bignum)n<<=b;
}
bignum operator<<=(bool n, bignum b){
	return (bignum)n<<=b;
}

bignum operator>>=(long long n, bignum b){
	return (bignum)n>>=b;
}
bignum operator>>=(long n, bignum b){
	return (bignum)n>>=b;
}
bignum operator>>=(int n, bignum b){
	return (bignum)n>>=b;
}
bignum operator>>=(short n, bignum b){
	return (bignum)n>>=b;
}
bignum operator>>=(unsigned long long n, bignum b){
	return (bignum)n>>=b;
}
bignum operator>>=(unsigned long n, bignum b){
	return (bignum)n>>=b;
}
bignum operator>>=(unsigned int n, bignum b){
	return (bignum)n>>=b;
}
bignum operator>>=(unsigned short n, bignum b){
	return (bignum)n>>=b;
}
bignum operator>>=(bool n, bignum b){
	return (bignum)n>>=b;
}

bignum operator*(long long n, bignum b){
	return (bignum)n*b;
}
bignum operator*(long n, bignum b){
	return (bignum)n*b;
}
bignum operator*(int n, bignum b){
	return (bignum)n*b;
}
bignum operator*(short n, bignum b){
	return (bignum)n*b;
}
bignum operator*(unsigned long long n, bignum b){
	return (bignum)n*b;
}
bignum operator*(unsigned long n, bignum b){
	return (bignum)n*b;
}
bignum operator*(unsigned int n, bignum b){
	return (bignum)n*b;
}
bignum operator*(unsigned short n, bignum b){
	return (bignum)n*b;
}
bignum operator*(bool n, bignum b){
	return (bignum)n*b;
}

bignum operator/(long long n, bignum b){
	return (bignum)n/b;
}
bignum operator/(long n, bignum b){
	return (bignum)n/b;
}
bignum operator/(int n, bignum b){
	return (bignum)n/b;
}
bignum operator/(short n, bignum b){
	return (bignum)n/b;
}
bignum operator/(unsigned long long n, bignum b){
	return (bignum)n/b;
}
bignum operator/(unsigned long n, bignum b){
	return (bignum)n/b;
}
bignum operator/(unsigned int n, bignum b){
	return (bignum)n/b;
}
bignum operator/(unsigned short n, bignum b){
	return (bignum)n/b;
}
bignum operator/(bool n, bignum b){
	return (bignum)n/b;
}

bignum operator%(long long n, bignum b){
	return (bignum)n%b;
}
bignum operator%(long n, bignum b){
	return (bignum)n%b;
}
bignum operator%(int n, bignum b){
	return (bignum)n%b;
}
bignum operator%(short n, bignum b){
	return (bignum)n%b;
}
bignum operator%(unsigned long long n, bignum b){
	return (bignum)n%b;
}
bignum operator%(unsigned long n, bignum b){
	return (bignum)n%b;
}
bignum operator%(unsigned int n, bignum b){
	return (bignum)n%b;
}
bignum operator%(unsigned short n, bignum b){
	return (bignum)n%b;
}
bignum operator%(bool n, bignum b){
	return (bignum)n%b;
}

bignum operator*=(long long n, bignum b){
	return (bignum)n*=b;
}
bignum operator*=(long n, bignum b){
	return (bignum)n*=b;
}
bignum operator*=(int n, bignum b){
	return (bignum)n*=b;
}
bignum operator*=(short n, bignum b){
	return (bignum)n*=b;
}
bignum operator*=(unsigned long long n, bignum b){
	return (bignum)n*=b;
}
bignum operator*=(unsigned long n, bignum b){
	return (bignum)n*=b;
}
bignum operator*=(unsigned int n, bignum b){
	return (bignum)n*=b;
}
bignum operator*=(unsigned short n, bignum b){
	return (bignum)n*=b;
}
bignum operator*=(bool n, bignum b){
	return (bignum)n*=b;
}

bignum operator/=(long long n, bignum b){
	return (bignum)n/=b;
}
bignum operator/=(long n, bignum b){
	return (bignum)n/=b;
}
bignum operator/=(int n, bignum b){
	return (bignum)n/=b;
}
bignum operator/=(short n, bignum b){
	return (bignum)n/=b;
}
bignum operator/=(unsigned long long n, bignum b){
	return (bignum)n/=b;
}
bignum operator/=(unsigned long n, bignum b){
	return (bignum)n/=b;
}
bignum operator/=(unsigned int n, bignum b){
	return (bignum)n/=b;
}
bignum operator/=(unsigned short n, bignum b){
	return (bignum)n/=b;
}
bignum operator/=(bool n, bignum b){
	return (bignum)n/=b;
}

bignum operator%=(long long n, bignum b){
	return (bignum)n%=b;
}
bignum operator%=(long n, bignum b){
	return (bignum)n%=b;
}
bignum operator%=(int n, bignum b){
	return (bignum)n%=b;
}
bignum operator%=(short n, bignum b){
	return (bignum)n%=b;
}
bignum operator%=(unsigned long long n, bignum b){
	return (bignum)n%=b;
}
bignum operator%=(unsigned long n, bignum b){
	return (bignum)n%=b;
}
bignum operator%=(unsigned int n, bignum b){
	return (bignum)n%=b;
}
bignum operator%=(unsigned short n, bignum b){
	return (bignum)n%=b;
}
bignum operator%=(bool n, bignum b){
	return (bignum)n%=b;
}

bignum gcd(bignum n, bignum b){
	if(n<b)swap(n, b);
	bignum num=n%b;
	while(num!=0){
		n=b;
		b=num;
		num=n%b;
	}
	return b;
}
bignum gcd(bignum n, long long b){
	return gcd(n, (bignum)b);
}
bignum gcd(bignum n, long b){
	return gcd(n, (bignum)b);
}
bignum gcd(bignum n, int b){
	return gcd(n, (bignum)b);
}
bignum gcd(bignum n, short b){
	return gcd(n, (bignum)b);
}
bignum gcd(bignum n, unsigned long long b){
	return gcd(n, (bignum)b);
}
bignum gcd(bignum n, unsigned long b){
	return gcd(n, (bignum)b);
}
bignum gcd(bignum n, unsigned int b){
	return gcd(n, (bignum)b);
}
bignum gcd(bignum n, unsigned short b){
	return gcd(n, (bignum)b);
}
bignum gcd(bignum n, bool b){
	return gcd(n, (bignum)b);
}
bignum gcd(long long n, bignum b){
	return gcd((bignum)n, b);
}
bignum gcd(long n, bignum b){
	return gcd((bignum)n, b);
}
bignum gcd(int n, bignum b){
	return gcd((bignum)n, b);
}
bignum gcd(short n, bignum b){
	return gcd((bignum)n, b);
}
bignum gcd(unsigned long long n, bignum b){
	return gcd((bignum)n, b);
}
bignum gcd(unsigned long n, bignum b){
	return gcd((bignum)n, b);
}
bignum gcd(unsigned int n, bignum b){
	return gcd((bignum)n, b);
}
bignum gcd(unsigned short n, bignum b){
	return gcd((bignum)n, b);
}
bignum gcd(bool n, bignum b){
	return gcd((bignum)n, b);
}

bignum lcm(bignum n, bignum b){
	return n/gcd(n, b)*b;
}
bignum lcm(bignum n, long long b){
	return lcm(n, (bignum)b);
}
bignum lcm(bignum n, long b){
	return lcm(n, (bignum)b);
}
bignum lcm(bignum n, int b){
	return lcm(n, (bignum)b);
}
bignum lcm(bignum n, short b){
	return lcm(n, (bignum)b);
}
bignum lcm(bignum n, unsigned long long b){
	return lcm(n, (bignum)b);
}
bignum lcm(bignum n, unsigned long b){
	return lcm(n, (bignum)b);
}
bignum lcm(bignum n, unsigned int b){
	return lcm(n, (bignum)b);
}
bignum lcm(bignum n, unsigned short b){
	return lcm(n, (bignum)b);
}
bignum lcm(bignum n, bool b){
	return lcm(n, (bignum)b);
}
bignum lcm(long long n, bignum b){
	return lcm((bignum)n, b);
}
bignum lcm(long n, bignum b){
	return lcm((bignum)n, b);
}
bignum lcm(int n, bignum b){
	return lcm((bignum)n, b);
}
bignum lcm(short n, bignum b){
	return lcm((bignum)n, b);
}
bignum lcm(unsigned long long n, bignum b){
	return lcm((bignum)n, b);
}
bignum lcm(unsigned long n, bignum b){
	return lcm((bignum)n, b);
}
bignum lcm(unsigned int n, bignum b){
	return lcm((bignum)n, b);
}
bignum lcm(unsigned short n, bignum b){
	return lcm((bignum)n, b);
}
bignum lcm(bool n, bignum b){
	return lcm((bignum)n, b);
}

bignum pow(bignum n, bignum b){
	bignum ans(1), mul=n, ob=b;
	for(bignum i(0);(ob>>i)>0;i++){
		if(((ob>>i)&1)==1)ans*=mul;
		mul*=mul;
	}
	return ans;
}
bignum pow(bignum n, long long b){
	return pow(n, (bignum)b);
}
bignum pow(bignum n, long b){
	return pow(n, (bignum)b);
}
bignum pow(bignum n, int b){
	return pow(n, (bignum)b);
}
bignum pow(bignum n, short b){
	return pow(n, (bignum)b);
}
bignum pow(bignum n, unsigned long long b){
	return pow(n, (bignum)b);
}
bignum pow(bignum n, unsigned long b){
	return pow(n, (bignum)b);
}
bignum pow(bignum n, unsigned int b){
	return pow(n, (bignum)b);
}
bignum pow(bignum n, unsigned short b){
	return pow(n, (bignum)b);
}
bignum pow(bignum n, bool b){
	return pow(n, (bignum)b);
}
bignum pow(long long n, bignum b){
	return pow((bignum)n, b);
}
bignum pow(long n, bignum b){
	return pow((bignum)n, b);
}
bignum pow(int n, bignum b){
	return pow((bignum)n, b);
}
bignum pow(short n, bignum b){
	return pow((bignum)n, b);
}
bignum pow(unsigned long long n, bignum b){
	return pow((bignum)n, b);
}
bignum pow(unsigned long n, bignum b){
	return pow((bignum)n, b);
}
bignum pow(unsigned int n, bignum b){
	return pow((bignum)n, b);
}
bignum pow(unsigned short n, bignum b){
	return pow((bignum)n, b);
}
bignum pow(bool n, bignum b){
	return pow((bignum)n, b);
}