Submission #36293

#	Submission time	Handle	Problem	Language	Result	Execution time	Memory
36293	2017-12-07T05:52:12 Z	Kerim	Odd-even (IZhO11_oddeven)	C++14	Compilation error	0 ms	0 KB

oddeven

#include "bits/stdc++.h"
#define MAXN 100009
#define INF 1000000007
#define mp(x,y) make_pair(x,y)
#define all(v) v.begin(),v.end()
#define pb(x) push_back(x)
#define wr cout<<"----------------"<<endl;
#define ppb() pop_back()
#define tr(ii,c) for(__typeof((c).begin()) ii=(c).begin();ii!=(c).end();ii++)
#define ff first
#define ss second
#define my_little_dodge 46
#define debug(x)  cerr<< #x <<" = "<< x<<endl;
using namespace std;

typedef long long ll;
typedef pair<int,int> PII;
template<class T>bool umin(T& a,T b){if(a>b){a=b;return 1;}return 0;}
template<class T>bool umax(T& a,T b){if(a<b){a=b;return 1;}return 0;}
 	const int base = 1000000000;
	const int base_digits = 9;
	
	struct bigint {
	vector<int> z;
	int sign;
	
	bigint() :
	sign(1) {
	}
	
	bigint(long long v) {
	*this = v;
	}
	
	bigint(const string &s) {
	read(s);
	}
	
	void operator=(const bigint &v) {
	sign = v.sign;
	z = v.z;
	}
	
	void operator=(long long v) {
	sign = 1;
	if (v < 0)
	sign = -1, v = -v;
	z.clear();
	for (; v > 0; v = v / base)
	z.push_back(v % base);
	}
	
	bigint operator+(const bigint &v) const {
	if (sign == v.sign) {
	bigint res = v;
	
	for (int i = 0, carry = 0; i < (int) max(z.size(), v.z.size()) || carry; ++i) {
	if (i == (int) res.z.size())
	res.z.push_back(0);
	res.z[i] += carry + (i < (int) z.size() ? z[i] : 0);
	carry = res.z[i] >= base;
	if (carry)
	res.z[i] -= base;
	}
	return res;
	}
	return *this - (-v);
	}
	
	bigint operator-(const bigint &v) const {
	if (sign == v.sign) {
	if (abs() >= v.abs()) {
	bigint res = *this;
	for (int i = 0, carry = 0; i < (int) v.z.size() || carry; ++i) {
	res.z[i] -= carry + (i < (int) v.z.size() ? v.z[i] : 0);
	carry = res.z[i] < 0;
	if (carry)
	res.z[i] += base;
	}
	res.trim();
	return res;
	}
	return -(v - *this);
	}
	return *this + (-v);
	}
	
	void operator*=(int v) {
	if (v < 0)
	sign = -sign, v = -v;
	for (int i = 0, carry = 0; i < (int) z.size() || carry; ++i) {
	if (i == (int) z.size())
	z.push_back(0);
	long long cur = z[i] * (long long) v + carry;
	carry = (int) (cur / base);
	z[i] = (int) (cur % base);
	//asm("divl %%ecx" : "=a"(carry), "=d"(a[i]) : "A"(cur), "c"(base));
	}
	trim();
	}
	
	bigint operator*(int v) const {
	bigint res = *this;
	res *= v;
	return res;
	}
	
	friend pair<bigint, bigint> divmod(const bigint &a1, const bigint &b1) {
	int norm = base / (b1.z.back() + 1);
	bigint a = a1.abs() * norm;
	bigint b = b1.abs() * norm;
	bigint q, r;
	q.z.resize(a.z.size());
	
	for (int i = a.z.size() - 1; i >= 0; i--) {
	r *= base;
	r += a.z[i];
	int s1 = b.z.size() < r.z.size() ? r.z[b.z.size()] : 0;
	int s2 = b.z.size() - 1 < r.z.size() ? r.z[b.z.size() - 1] : 0;
	int d = ((long long) s1 * base + s2) / b.z.back();
	r -= b * d;
	while (r < 0)
	r += b, --d;
	q.z[i] = d;
	}
	
	q.sign = a1.sign * b1.sign;
	r.sign = a1.sign;
	q.trim();
	r.trim();
	return make_pair(q, r / norm);
	}
	
	friend bigint sqrt(const bigint &a1) {
	bigint a = a1;
	while (a.z.empty() || a.z.size() % 2 == 1)
	a.z.push_back(0);
	
	int n = a.z.size();
	
	int firstDigit = (int) sqrt((double) a.z[n - 1] * base + a.z[n - 2]);
	int norm = base / (firstDigit + 1);
	a *= norm;
	a *= norm;
	while (a.z.empty() || a.z.size() % 2 == 1)
	a.z.push_back(0);
	
	bigint r = (long long) a.z[n - 1] * base + a.z[n - 2];
	firstDigit = (int) sqrt((double) a.z[n - 1] * base + a.z[n - 2]);
	int q = firstDigit;
	bigint res;
	
	for(int j = n / 2 - 1; j >= 0; j--) {
	for(; ; --q) {
	bigint r1 = (r - (res * 2 * base + q) * q) * base * base + (j > 0 ? (long long) a.z[2 * j - 1] * base + a.z[2 * j - 2] : 0);
	if (r1 >= 0) {
	r = r1;
	break;
	}
	}
	res *= base;
	res += q;
	
	if (j > 0) {
	int d1 = res.z.size() + 2 < r.z.size() ? r.z[res.z.size() + 2] : 0;
	int d2 = res.z.size() + 1 < r.z.size() ? r.z[res.z.size() + 1] : 0;
	int d3 = res.z.size() < r.z.size() ? r.z[res.z.size()] : 0;
	q = ((long long) d1 * base * base + (long long) d2 * base + d3) / (firstDigit * 2);
	}
	}
	
	res.trim();
	return res / norm;
	}
	
	bigint operator/(const bigint &v) const {
	return divmod(*this, v).first;
	}
	
	bigint operator%(const bigint &v) const {
	return divmod(*this, v).second;
	}
	
	void operator/=(int v) {
	if (v < 0)
	sign = -sign, v = -v;
	for (int i = (int) z.size() - 1, rem = 0; i >= 0; --i) {
	long long cur = z[i] + rem * (long long) base;
	z[i] = (int) (cur / v);
	rem = (int) (cur % v);
	}
	trim();
	}
	
	bigint operator/(int v) const {
	bigint res = *this;
	res /= v;
	return res;
	}
	
	int operator%(int v) const {
	if (v < 0)
	v = -v;
	int m = 0;
	for (int i = z.size() - 1; i >= 0; --i)
	m = (z[i] + m * (long long) base) % v;
	return m * sign;
	}
	
	void operator+=(const bigint &v) {
	*this = *this + v;
	}
	void operator-=(const bigint &v) {
	*this = *this - v;
	}
	void operator*=(const bigint &v) {
	*this = *this * v;
	}
	void operator/=(const bigint &v) {
	*this = *this / v;
	}
	
	bool operator<(const bigint &v) const {
	if (sign != v.sign)
	return sign < v.sign;
	if (z.size() != v.z.size())
	return z.size() * sign < v.z.size() * v.sign;
	for (int i = z.size() - 1; i >= 0; i--)
	if (z[i] != v.z[i])
	return z[i] * sign < v.z[i] * sign;
	return false;
	}
	
	bool operator>(const bigint &v) const {
	return v < *this;
	}
	bool operator<=(const bigint &v) const {
	return !(v < *this);
	}
	bool operator>=(const bigint &v) const {
	return !(*this < v);
	}
	bool operator==(const bigint &v) const {
	return !(*this < v) && !(v < *this);
	}
	bool operator!=(const bigint &v) const {
	return *this < v || v < *this;
	}
	
	void trim() {
	while (!z.empty() && z.back() == 0)
	z.pop_back();
	if (z.empty())
	sign = 1;
	}
	
	bool isZero() const {
	return z.empty() || (z.size() == 1 && !z[0]);
	}
	
	bigint operator-() const {
	bigint res = *this;
	res.sign = -sign;
	return res;
	}
	
	bigint abs() const {
	bigint res = *this;
	res.sign *= res.sign;
	return res;
	}
	
	long long longValue() const {
	long long res = 0;
	for (int i = z.size() - 1; i >= 0; i--)
	res = res * base + z[i];
	return res * sign;
	}
	
	friend bigint gcd(const bigint &a, const bigint &b) {
	return b.isZero() ? a : gcd(b, a % b);
	}
	friend bigint lcm(const bigint &a, const bigint &b) {
	return a / gcd(a, b) * b;
	}
	
	void read(const string &s) {
	sign = 1;
	z.clear();
	int pos = 0;
	while (pos < (int) s.size() && (s[pos] == '-' || s[pos] == '+')) {
	if (s[pos] == '-')
	sign = -sign;
	++pos;
	}
	for (int i = s.size() - 1; i >= pos; i -= base_digits) {
	int x = 0;
	for (int j = max(pos, i - base_digits + 1); j <= i; j++)
	x = x * 10 + s[j] - '0';
	z.push_back(x);
	}
	trim();
	}
	
	friend istream& operator>>(istream &stream, bigint &v) {
	string s;
	stream >> s;
	v.read(s);
	return stream;
	}
	
	friend ostream& operator<<(ostream &stream, const bigint &v) {
	if (v.sign == -1)
	stream << '-';
	stream << (v.z.empty() ? 0 : v.z.back());
	for (int i = (int) v.z.size() - 2; i >= 0; --i)
	stream << setw(base_digits) << setfill('0') << v.z[i];
	return stream;
	}
	
	static vector<int> convert_base(const vector<int> &a, int old_digits, int new_digits) {
	vector<long long> p(max(old_digits, new_digits) + 1);
	p[0] = 1;
	for (int i = 1; i < (int) p.size(); i++)
	p[i] = p[i - 1] * 10;
	vector<int> res;
	long long cur = 0;
	int cur_digits = 0;
	for (int i = 0; i < (int) a.size(); i++) {
	cur += a[i] * p[cur_digits];
	cur_digits += old_digits;
	while (cur_digits >= new_digits) {
	res.push_back(int(cur % p[new_digits]));
	cur /= p[new_digits];
	cur_digits -= new_digits;
	}
	}
	res.push_back((int) cur);
	while (!res.empty() && res.back() == 0)
	res.pop_back();
	return res;
	}
	
	typedef vector<long long> vll;
	
	static vll karatsubaMultiply(const vll &a, const vll &b) {
	int n = a.size();
	vll res(n + n);
	if (n <= 32) {
	for (int i = 0; i < n; i++)
	for (int j = 0; j < n; j++)
	res[i + j] += a[i] * b[j];
	return res;
	}
	
	int k = n >> 1;
	vll a1(a.begin(), a.begin() + k);
	vll a2(a.begin() + k, a.end());
	vll b1(b.begin(), b.begin() + k);
	vll b2(b.begin() + k, b.end());
	
	vll a1b1 = karatsubaMultiply(a1, b1);
	vll a2b2 = karatsubaMultiply(a2, b2);
	
	for (int i = 0; i < k; i++)
	a2[i] += a1[i];
	for (int i = 0; i < k; i++)
	b2[i] += b1[i];
	
	vll r = karatsubaMultiply(a2, b2);
	for (int i = 0; i < (int) a1b1.size(); i++)
	r[i] -= a1b1[i];
	for (int i = 0; i < (int) a2b2.size(); i++)
	r[i] -= a2b2[i];
	
	for (int i = 0; i < (int) r.size(); i++)
	res[i + k] += r[i];
	for (int i = 0; i < (int) a1b1.size(); i++)
	res[i] += a1b1[i];
	for (int i = 0; i < (int) a2b2.size(); i++)
	res[i + n] += a2b2[i];
	return res;
	}
	
	bigint operator*(const bigint &v) const {
	vector<int> a6 = convert_base(this->z, base_digits, 6);
	vector<int> b6 = convert_base(v.z, base_digits, 6);
	vll a(a6.begin(), a6.end());
	vll b(b6.begin(), b6.end());
	while (a.size() < b.size())
	a.push_back(0);
	while (b.size() < a.size())
	b.push_back(0);
	while (a.size() & (a.size() - 1))
	a.push_back(0), b.push_back(0);
	vll c = karatsubaMultiply(a, b);
	bigint res;
	res.sign = sign * v.sign;
	for (int i = 0, carry = 0; i < (int) c.size(); i++) {
	long long cur = c[i] + carry;
	res.z.push_back((int) (cur % 1000000));
	carry = (int) (cur / 1000000);
	}
	res.z = convert_base(res.z, 6, base_digits);
	res.trim();
	return res;
	}
	};
	
	bigint random_bigint(int n) {
	string s;
	for (int i = 0; i < n; i++) {
	s += rand() % 10 + '0';
	}
	return bigint(s);
	}

int main(){
    //~ freopen("file.in", "r", stdin);
    bigint n;
    cin>>n;
	if(n==1){
		puts("1");
		return 0;
	}
	bigint st=0,en=1;
	while(en<=2*n){
		en*=10;
	}
	while(st+1<en){
		bigint mid=(st+en)/2;
		if(mid*mid<=2*n)
			st=mid;
		else
			en=mid;
	}
	bigint BLOK=st;
	if(en*en<=2*n)	
		BLOK=en;
	for(bigint i=BLOK;i>=0;i-=1)
		if(i*(i+1)/2+(i+1)<n){
			bigint ans=i*(i+1)+(i+1);
			n-=i*(i+1)/2+(i+1);
			if(n==1){
				cout<<ans+1<<endl;
				return 0;
			}n-=1;ans+=1;
			cout<<ans+n*2<<endl;
			return 0;
		}	
	return 0;
}

Compilation message

oddeven.cpp: In function 'int main()':
oddeven.cpp:427:13: error: no match for 'operator*' (operand types are 'int' and 'bigint')
  while(en<=2*n){
             ^
In file included from /usr/include/c++/5/ccomplex:38:0,
                 from /usr/include/x86_64-linux-gnu/c++/5/bits/stdc++.h:52,
                 from oddeven.cpp:1:
/usr/include/c++/5/complex:386:5: note: candidate: template<class _Tp> std::complex<_Tp> std::operator*(const std::complex<_Tp>&, const std::complex<_Tp>&)
     operator*(const complex<_Tp>& __x, const complex<_Tp>& __y)
     ^
/usr/include/c++/5/complex:386:5: note:   template argument deduction/substitution failed:
oddeven.cpp:427:14: note:   mismatched types 'const std::complex<_Tp>' and 'int'
  while(en<=2*n){
              ^
In file included from /usr/include/c++/5/ccomplex:38:0,
                 from /usr/include/x86_64-linux-gnu/c++/5/bits/stdc++.h:52,
                 from oddeven.cpp:1:
/usr/include/c++/5/complex:395:5: note: candidate: template<class _Tp> std::complex<_Tp> std::operator*(const std::complex<_Tp>&, const _Tp&)
     operator*(const complex<_Tp>& __x, const _Tp& __y)
     ^
/usr/include/c++/5/complex:395:5: note:   template argument deduction/substitution failed:
oddeven.cpp:427:14: note:   mismatched types 'const std::complex<_Tp>' and 'int'
  while(en<=2*n){
              ^
In file included from /usr/include/c++/5/ccomplex:38:0,
                 from /usr/include/x86_64-linux-gnu/c++/5/bits/stdc++.h:52,
                 from oddeven.cpp:1:
/usr/include/c++/5/complex:404:5: note: candidate: template<class _Tp> std::complex<_Tp> std::operator*(const _Tp&, const std::complex<_Tp>&)
     operator*(const _Tp& __x, const complex<_Tp>& __y)
     ^
/usr/include/c++/5/complex:404:5: note:   template argument deduction/substitution failed:
oddeven.cpp:427:14: note:   'bigint' is not derived from 'const std::complex<_Tp>'
  while(en<=2*n){
              ^
In file included from /usr/include/c++/5/valarray:587:0,
                 from /usr/include/x86_64-linux-gnu/c++/5/bits/stdc++.h:94,
                 from oddeven.cpp:1:
/usr/include/c++/5/bits/valarray_after.h:404:5: note: candidate: template<class _Dom1, class _Dom2> std::_Expr<std::_BinClos<std::__multiplies, std::_Expr, std::_Expr, _Dom1, _Dom2>, typename std::__fun<std::__multiplies, typename _Dom1::value_type>::result_type> std::operator*(const std::_Expr<_Dom1, typename _Dom1::value_type>&, const std::_Expr<_Dom2, typename _Dom2::value_type>&)
     _DEFINE_EXPR_BINARY_OPERATOR(*, __multiplies)
     ^
/usr/include/c++/5/bits/valarray_after.h:404:5: note:   template argument deduction/substitution failed:
oddeven.cpp:427:14: note:   mismatched types 'const std::_Expr<_Dom1, typename _Dom1::value_type>' and 'int'
  while(en<=2*n){
              ^
In file included from /usr/include/c++/5/valarray:587:0,
                 from /usr/include/x86_64-linux-gnu/c++/5/bits/stdc++.h:94,
                 from oddeven.cpp:1:
/usr/include/c++/5/bits/valarray_after.h:404:5: note: candidate: template<class _Dom> std::_Expr<std::_BinClos<std::__multiplies, std::_Expr, std::_Constant, _Dom, typename _Dom::value_type>, typename std::__fun<std::__multiplies, typename _Dom1::value_type>::result_type> std::operator*(const std::_Expr<_Dom1, typename _Dom1::value_type>&, const typename _Dom::value_type&)
     _DEFINE_EXPR_BINARY_OPERATOR(*, __multiplies)
     ^
/usr/include/c++/5/bits/valarray_after.h:404:5: note:   template argument deduction/substitution failed:
oddeven.cpp:427:14: note:   mismatched types 'const std::_Expr<_Dom1, typename _Dom1::value_type>' and 'int'
  while(en<=2*n){
              ^
In file included from /usr/include/c++/5/valarray:587:0,
                 from /usr/include/x86_64-linux-gnu/c++/5/bits/stdc++.h:94,
                 from oddeven.cpp:1:
/usr/include/c++/5/bits/valarray_after.h:404:5: note: candidate: template<class _Dom> std::_Expr<std::_BinClos<std::__multiplies, std::_Constant, std::_Expr, typename _Dom::value_type, _Dom>, typename std::__fun<std::__multiplies, typename _Dom1::value_type>::result_type> std::operator*(const typename _Dom::value_type&, const std::_Expr<_Dom1, typename _Dom1::value_type>&)
     _DEFINE_EXPR_BINARY_OPERATOR(*, __multiplies)
     ^
/usr/include/c++/5/bits/valarray_after.h:404:5: note:   template argument deduction/substitution failed:
oddeven.cpp:427:14: note:   'bigint' is not derived from 'const std::_Expr<_Dom1, typename _Dom1::value_type>'
  while(en<=2*n){
              ^
In file included from /usr/include/c++/5/valarray:587:0,
                 from /usr/include/x86_64-linux-gnu/c++/5/bits/stdc++.h:94,
                 from oddeven.cpp:1:
/usr/include/c++/5/bits/valarray_after.h:404:5: note: candidate: template<class _Dom> std::_Expr<std::_BinClos<std::__multiplies, std::_Expr, std::_ValArray, _Dom, typename _Dom::value_type>, typename std::__fun<std::__multiplies, typename _Dom1::value_type>::result_type> std::operator*(const std::_Expr<_Dom1, typename _Dom1::value_type>&, const std::valarray<typename _Dom::value_type>&)
     _DEFINE_EXPR_BINARY_OPERATOR(*, __multiplies)
     ^
/usr/include/c++/5/bits/valarray_after.h:404:5: note:   template argument deduction/substitution failed:
oddeven.cpp:427:14: note:   mismatched types 'const std::_Expr<_Dom1, typename _Dom1::value_type>' and 'int'
  while(en<=2*n){
              ^
In file included from /usr/include/c++/5/valarray:587:0,
                 from /usr/include/x86_64-linux-gnu/c++/5/bits/stdc++.h:94,
                 from oddeven.cpp:1:
/usr/include/c++/5/bits/valarray_after.h:404:5: note: candidate: template<class _Dom> std::_Expr<std::_BinClos<std::__multiplies, std::_ValArray, std::_Expr, typename _Dom::value_type, _Dom>, typename std::__fun<std::__multiplies, typename _Dom1::value_type>::result_type> std::operator*(const std::valarray<typename _Dom::value_type>&, const std::_Expr<_Dom1, typename _Dom1::value_type>&)
     _DEFINE_EXPR_BINARY_OPERATOR(*, __multiplies)
     ^
/usr/include/c++/5/bits/valarray_after.h:404:5: note:   template argument deduction/substitution failed:
oddeven.cpp:427:14: note:   'bigint' is not derived from 'const std::_Expr<_Dom1, typename _Dom1::value_type>'
  while(en<=2*n){
              ^
In file included from /usr/include/x86_64-linux-gnu/c++/5/bits/stdc++.h:94:0,
                 from oddeven.cpp:1:
/usr/include/c++/5/valarray:1169:1: note: candidate: template<class _Tp> std::_Expr<std::_BinClos<std::__multiplies, std::_ValArray, std::_ValArray, _Tp, _Tp>, typename std::__fun<std::__multiplies, _Tp>::result_type> std::operator*(const std::valarray<_Tp>&, const std::valarray<_Tp>&)
 _DEFINE_BINARY_OPERATOR(*, __multiplies)
 ^
/usr/include/c++/5/valarray:1169:1: note:   template argument deduction/substitution failed:
oddeven.cpp:427:14: note:   mismatched types 'const std::valarray<_Tp>' and 'int'
  while(en<=2*n){
              ^
In file included from /usr/include/x86_64-linux-gnu/c++/5/bits/stdc++.h:94:0,
                 from oddeven.cpp:1:
/usr/include/c++/5/valarray:1169:1: note: candidate: template<class _Tp> std::_Expr<std::_BinClos<std::__multiplies, std::_ValArray, std::_Constant, _Tp, _Tp>, typename std::__fun<std::__multiplies, _Tp>::result_type> std::operator*(const std::valarray<_Tp>&, const _Tp&)
 _DEFINE_BINARY_OPERATOR(*, __multiplies)
 ^
/usr/include/c++/5/valarray:1169:1: note:   template argument deduction/substitution failed:
oddeven.cpp:427:14: note:   mismatched types 'const std::valarray<_Tp>' and 'int'
  while(en<=2*n){
              ^
In file included from /usr/include/x86_64-linux-gnu/c++/5/bits/stdc++.h:94:0,
                 from oddeven.cpp:1:
/usr/include/c++/5/valarray:1169:1: note: candidate: template<class _Tp> std::_Expr<std::_BinClos<std::__multiplies, std::_Constant, std::_ValArray, _Tp, _Tp>, typename std::__fun<std::__multiplies, _Tp>::result_type> std::operator*(const _Tp&, const std::valarray<_Tp>&)
 _DEFINE_BINARY_OPERATOR(*, __multiplies)
 ^
/usr/include/c++/5/valarray:1169:1: note:   template argument deduction/substitution failed:
oddeven.cpp:427:14: note:   'bigint' is not derived from 'const std::valarray<_Tp>'
  while(en<=2*n){
              ^
oddeven.cpp:432:16: error: no match for 'operator*' (operand types are 'int' and 'bigint')
   if(mid*mid<=2*n)
                ^
In file included from /usr/include/c++/5/ccomplex:38:0,
                 from /usr/include/x86_64-linux-gnu/c++/5/bits/stdc++.h:52,
                 from oddeven.cpp:1:
/usr/include/c++/5/complex:386:5: note: candidate: template<class _Tp> std::complex<_Tp> std::operator*(const std::complex<_Tp>&, const std::complex<_Tp>&)
     operator*(const complex<_Tp>& __x, const complex<_Tp>& __y)
     ^
/usr/include/c++/5/complex:386:5: note:   template argument deduction/substitution failed:
oddeven.cpp:432:17: note:   mismatched types 'const std::complex<_Tp>' and 'int'
   if(mid*mid<=2*n)
                 ^
In file included from /usr/include/c++/5/ccomplex:38:0,
                 from /usr/include/x86_64-linux-gnu/c++/5/bits/stdc++.h:52,
                 from oddeven.cpp:1:
/usr/include/c++/5/complex:395:5: note: candidate: template<class _Tp> std::complex<_Tp> std::operator*(const std::complex<_Tp>&, const _Tp&)
     operator*(const complex<_Tp>& __x, const _Tp& __y)
     ^
/usr/include/c++/5/complex:395:5: note:   template argument deduction/substitution failed:
oddeven.cpp:432:17: note:   mismatched types 'const std::complex<_Tp>' and 'int'
   if(mid*mid<=2*n)
                 ^
In file included from /usr/include/c++/5/ccomplex:38:0,
                 from /usr/include/x86_64-linux-gnu/c++/5/bits/stdc++.h:52,
                 from oddeven.cpp:1:
/usr/include/c++/5/complex:404:5: note: candidate: template<class _Tp> std::complex<_Tp> std::operator*(const _Tp&, const std::complex<_Tp>&)
     operator*(const _Tp& __x, const complex<_Tp>& __y)
     ^
/usr/include/c++/5/complex:404:5: note:   template argument deduction/substitution failed:
oddeven.cpp:432:17: note:   'bigint' is not derived from 'const std::complex<_Tp>'
   if(mid*mid<=2*n)
                 ^
In file included from /usr/include/c++/5/valarray:587:0,
                 from /usr/include/x86_64-linux-gnu/c++/5/bits/stdc++.h:94,
                 from oddeven.cpp:1:
/usr/include/c++/5/bits/valarray_after.h:404:5: note: candidate: template<class _Dom1, class _Dom2> std::_Expr<std::_BinClos<std::__multiplies, std::_Expr, std::_Expr, _Dom1, _Dom2>, typename std::__fun<std::__multiplies, typename _Dom1::value_type>::result_type> std::operator*(const std::_Expr<_Dom1, typename _Dom1::value_type>&, const std::_Expr<_Dom2, typename _Dom2::value_type>&)
     _DEFINE_EXPR_BINARY_OPERATOR(*, __multiplies)
     ^
/usr/include/c++/5/bits/valarray_after.h:404:5: note:   template argument deduction/substitution failed:
oddeven.cpp:432:17: note:   mismatched types 'const std::_Expr<_Dom1, typename _Dom1::value_type>' and 'int'
   if(mid*mid<=2*n)
                 ^
In file included from /usr/include/c++/5/valarray:587:0,
                 from /usr/include/x86_64-linux-gnu/c++/5/bits/stdc++.h:94,
                 from oddeven.cpp:1:
/usr/include/c++/5/bits/valarray_after.h:404:5: note: candidate: template<class _Dom> std::_Expr<std::_BinClos<std::__multiplies, std::_Expr, std::_Constant, _Dom, typename _Dom::value_type>, typename std::__fun<std::__multiplies, typename _Dom1::value_type>::result_type> std::operator*(const std::_Expr<_Dom1, typename _Dom1::value_type>&, const typename _Dom::value_type&)
     _DEFINE_EXPR_BINARY_OPERATOR(*, __multiplies)
     ^
/usr/include/c++/5/bits/valarray_after.h:404:5: note:   template argument deduction/substitution failed:
oddeven.cpp:432:17: note:   mismatched types 'const std::_Expr<_Dom1, typename _Dom1::value_type>' and 'int'
   if(mid*mid<=2*n)
                 ^
In file included from /usr/include/c++/5/valarray:587:0,
                 from /usr/include/x86_64-linux-gnu/c++/5/bits/stdc++.h:94,
                 from oddeven.cpp:1:
/usr/include/c++/5/bits/valarray_after.h:404:5: note: candidate: template<class _Dom> std::_Expr<std::_BinClos<std::__multiplies, std::_Constant, std::_Expr, typename _Dom::value_type, _Dom>, typename std::__fun<std::__multiplies, typename _Dom1::value_type>::result_type> std::operator*(const typename _Dom::value_type&, const std::_Expr<_Dom1, typename _Dom1::value_type>&)
     _DEFINE_EXPR_BINARY_OPERATOR(*, __multiplies)
     ^
/usr/include/c++/5/bits/valarray_after.h:404:5: note:   template argument deduction/substitution failed:
oddeven.cpp:432:17: note:   'bigint' is not derived from 'const std::_Expr<_Dom1, typename _Dom1::value_type>'
   if(mid*mid<=2*n)
                 ^
In file included from /usr/include/c++/5/valarray:587:0,
                 from /usr/include/x86_64-linux-gnu/c++/5/bits/stdc++.h:94,
                 from oddeven.cpp:1:
/usr/include/c++/5/bits/valarray_after.h:404:5: note: candidate: template<class _Dom> std::_Expr<std::_BinClos<std::__multiplies, std::_Expr, std::_ValArray, _Dom, typename _Dom::value_type>, typename std::__fun<std::__multiplies, typename _Dom1::value_type>::result_type> std::operator*(const std::_Expr<_Dom1, typename _Dom1::value_type>&, const std::valarray<typename _Dom::value_type>&)
     _DEFINE_EXPR_BINARY_OPERATOR(*, __multiplies)
     ^
/usr/include/c++/5/bits/valarray_after.h:404:5: note:   template argument deduction/substitution failed:
oddeven.cpp:432:17: note:   mismatched types 'const std::_Expr<_Dom1, typename _Dom1::value_type>' and 'int'
   if(mid*mid<=2*n)
                 ^
In file included from /usr/include/c++/5/valarray:587:0,
                 from /usr/include/x86_64-linux-gnu/c++/5/bits/stdc++.h:94,
                 from oddeven.cpp:1:
/usr/include/c++/5/bits/valarray_after.h:404:5: note: candidate: template<class _Dom> std::_Expr<std::_BinClos<std::__multiplies, std::_ValArray, std::_Expr, typename _Dom::value_type, _Dom>, typename std::__fun<std::__multiplies, typename _Dom1::value_type>::result_type> std::operator*(const std::valarray<typename _Dom::value_type>&, const std::_Expr<_Dom1, typename _Dom1::value_type>&)
     _DEFINE_EXPR_BINARY_OPERATOR(*, __multiplies)
     ^
/usr/include/c++/5/bits/valarray_after.h:404:5: note:   template argument deduction/substitution failed:
oddeven.cpp:432:17: note:   'bigint' is not derived from 'const std::_Expr<_Dom1, typename _Dom1::value_type>'
   if(mid*mid<=2*n)
                 ^
In file included from /usr/include/x86_64-linux-gnu/c++/5/bits/stdc++.h:94:0,
                 from oddeven.cpp:1:
/usr/include/c++/5/valarray:1169:1: note: candidate: template<class _Tp> std::_Expr<std::_BinClos<std::__multiplies, std::_ValArray, std::_ValArray, _Tp, _Tp>, typename std::__fun<std::__multiplies, _Tp>::result_type> std::operator*(const std::valarray<_Tp>&, const std::valarray<_Tp>&)
 _DEFINE_BINARY_OPERATOR(*, __multiplies)
 ^
/usr/include/c++/5/valarray:1169:1: note:   template argument deduction/substitution failed:
oddeven.cpp:432:17: note:   mismatched types 'const std::valarray<_Tp>' and 'int'
   if(mid*mid<=2*n)
                 ^
In file included from /usr/include/x86_64-linux-gnu/c++/5/bits/stdc++.h:94:0,
                 from oddeven.cpp:1:
/usr/include/c++/5/valarray:1169:1: note: candidate: template<class _Tp> std::_Expr<std::_BinClos<std::__multiplies, std::_ValArray, std::_Constant, _Tp, _Tp>, typename std::__fun<std::__multiplies, _Tp>::result_type> std::operator*(const std::valarray<_Tp>&, const _Tp&)
 _DEFINE_BINARY_OPERATOR(*, __multiplies)
 ^
/usr/include/c++/5/valarray:1169:1: note:   template argument deduction/substitution failed:
oddeven.cpp:432:17: note:   mismatched types 'const std::valarray<_Tp>' and 'int'
   if(mid*mid<=2*n)
                 ^
In file included from /usr/include/x86_64-linux-gnu/c++/5/bits/stdc++.h:94:0,
                 from oddeven.cpp:1:
/usr/include/c++/5/valarray:1169:1: note: candidate: template<class _Tp> std::_Expr<std::_BinClos<std::__multiplies, std::_Constant, std::_ValArray, _Tp, _Tp>, typename std::__fun<std::__multiplies, _Tp>::result_type> std::operator*(const _Tp&, const std::valarray<_Tp>&)
 _DEFINE_BINARY_OPERATOR(*, __multiplies)
 ^
/usr/include/c++/5/valarray:1169:1: note:   template argument deduction/substitution failed:
oddeven.cpp:432:17: note:   'bigint' is not derived from 'const std::valarray<_Tp>'
   if(mid*mid<=2*n)
                 ^
oddeven.cpp:438:13: error: no match for 'operator*' (operand types are 'int' and 'bigint')
  if(en*en<=2*n) 
             ^
In file included from /usr/include/c++/5/ccomplex:38:0,
                 from /usr/include/x86_64-linux-gnu/c++/5/bits/stdc++.h:52,
                 from oddeven.cpp:1:
/usr/include/c++/5/complex:386:5: note: candidate: template<class _Tp> std::complex<_Tp> std::operator*(const std::complex<_Tp>&, const std::complex<_Tp>&)
     operator*(const complex<_Tp>& __x, const complex<_Tp>& __y)
     ^
/usr/include/c++/5/complex:386:5: note:   template argument deduction/substitution failed:
oddeven.cpp:438:14: note:   mismatched types 'const std::complex<_Tp>' and 'int'
  if(en*en<=2*n) 
              ^
In file included from /usr/include/c++/5/ccomplex:38:0,
                 from /usr/include/x86_64-linux-gnu/c++/5/bits/stdc++.h:52,
                 from oddeven.cpp:1:
/usr/include/c++/5/complex:395:5: note: candidate: template<class _Tp> std::complex<_Tp> std::operator*(const std::complex<_Tp>&, const _Tp&)
     operator*(const complex<_Tp>& __x, const _Tp& __y)
     ^
/usr/include/c++/5/complex:395:5: note:   template argument deduction/substitution failed:
oddeven.cpp:438:14: note:   mismatched types 'const std::complex<_Tp>' and 'int'
  if(en*en<=2*n) 
              ^
In file included from /usr/include/c++/5/ccomplex:38:0,
                 from /usr/include/x86_64-linux-gnu/c++/5/bits/stdc++.h:52,
                 from oddeven.cpp:1:
/usr/include/c++/5/complex:404:5: note: candidate: template<class _Tp> std::complex<_Tp> std::operator*(const _Tp&, const std::complex<_Tp>&)
     operator*(const _Tp& __x, const complex<_Tp>& __y)
     ^
/usr/include/c++/5/complex:404:5: note:   template argument deduction/substitution failed:
oddeven.cpp:438:14: note:   'bigint' is not derived from 'const std::complex<_Tp>'
  if(en*en<=2*n) 
              ^
In file included from /usr/include/c++/5/valarray:587:0,
                 from /usr/include/x86_64-linux-gnu/c++/5/bits/stdc++.h:94,
                 from oddeven.cpp:1:
/usr/include/c++/5/bits/valarray_after.h:404:5: note: candida