压位高精度模板

struct BigInteger {
	static const int BASE = 100000000;
	static const int WIDTH = 8;
	vector<int> s;

	BigInteger(long long num = 0) { *this = num; }
	BigInteger(const string& str) { *this = str; }
	BigInteger operator = (long long num) {
		s.clear();
		do {
			s.push_back(num % BASE);
			num /= BASE;
		} while (num > 0);
		return *this;
	}
	BigInteger operator = (const string& str) {
		s.clear();
		int x, len = (str.length() - 1) / WIDTH + 1;
		for (int i = 0; i < len; i++) {
			int end = str.length() - i * WIDTH;
			int start = max(0, end - WIDTH);
			sscanf(str.substr(start, end - start).c_str(), "%d", &x);
			s.push_back(x);
		}
		return *this;
	}

	bool operator < (const BigInteger& b) const {
		if (s.size() != b.s.size()) return s.size() < b.s.size();
		for (int i = s.size() - 1; i >= 0; i--)
			if (s[i] != b.s[i]) return s[i] < b.s[i];
		return false;
	}
	bool operator > (const BigInteger& b) const { return b < *this; }
	bool operator <= (const BigInteger& b) const { return !(b < *this); }
	bool operator >= (const BigInteger& b) const { return !(*this < b); }
	bool operator != (const BigInteger& b) const { return b < *this || *this < b; }
	bool operator == (const BigInteger& b) const { return !(b < *this) && !(*this < b); }

	BigInteger operator + (const BigInteger& b) const {
		BigInteger c;
		c.s.clear();
		for (int i = 0, g = 0; ; i++) {
			if (g == 0 && i >= s.size() && i >= b.s.size()) break;
			int x = g;
			if (i < s.size()) x += s[i];
			if (i < b.s.size()) x += b.s[i];
			c.s.push_back(x % BASE);
			g = x / BASE;
		}
		return c;
	}
	BigInteger operator - (const BigInteger& b) const {
		BigInteger c;
		c.s.clear();
		if (*this == b) {
			c.s.push_back(0);
		} else if (*this < b) {
			for (int i = 0, g = 0; ; i++) {
				if (g == 0 && i >= b.s.size() && i >= s.size()) {
					c.s[i - 1] = -c.s[i - 1]; break;
				}
				int x = g;
				if (i < b.s.size()) x += b.s[i];
				if (i < s.size()) x -= s[i];
				if (x < 0) {
					c.s.push_back(BASE + x % BASE);
					g = x / BASE - 1;
				} else {
					c.s.push_back(x % BASE);
					g = x / BASE;
				}
			}
		} else {
			for (int i = 0, g = 0; ; i++) {
				if (g == 0 && i >= s.size() && i >= b.s.size()) break;
				int x = g;
				if (i < s.size()) x += s[i];
				if (i < b.s.size()) x -= b.s[i];
				if (x < 0) {
					c.s.push_back(BASE + x % BASE);
					g = x / BASE - 1;
				} else {
					c.s.push_back(x % BASE);
					g = x / BASE;
				}
			}
		}
		return c;
	}

	BigInteger operator * (const BigInteger& b) const {
		BigInteger c; int len = s.size() + b.s.size(); bool flag = false; c.s.clear();
		if (*this == 0 || b == 0) {c.s.push_back(0); return 0;}
		if (*this < 0 && b > 0) flag = true;
		if (*this > 0 && b < 0) flag = true;
		for (int i = 0, g = 0; ; i++) {
			if (g == 0 && i >= len) break;
			int x = g;
			for (int u = 0, v = i, temp; v >= 0; u++, v--)
				if (u < s.size() && v < b.s.size()) {
					temp = s[u] * b.s[v];
					if (temp < 0) temp = -temp;
					x += temp;
				}
			c.s.push_back(x % BASE);
			g = x / BASE;
		}
		for (int i = c.s.size() - 1; i >= 0 && c.s[i] == 0; i--)
			c.s.pop_back();
		if (flag) c.s[c.s.size() - 1] = -c.s[c.s.size() - 1];
		return c;
	}

	inline void killzero() {
		while (s.back() == 0 && s.size() > 1) s.pop_back();
	}
	inline void reverse() {
		int len = s.size();
		for (int i = 0; i < len >> 1; ++i) swap(s[i], s[len - i - 1]);
	}

	BigInteger operator / (const BigInteger &b) const {
		BigInteger c, t;
		c.s.clear(); t.s.clear();
		for (int i = s.size() - 1; i >= 0; --i) {
			t.s.push_back(s[i]);
			int x = 0;
			while (b <= t) {t -= b; x++;}
			c.s.push_back(x);
		}
		c.reverse();
		c.killzero();
		return c;
	}
	BigInteger operator / (const int &b) const {

		BigInteger c;
		c.s.clear();

		int r = 0;
		for (int i = s.size() - 1; i >= 0; --i) {
			r = r * BASE + s[i];
			c.s.push_back(r / b);
			r %= b;
		}

		c.reverse();
		c.killzero();
		return c;
	}

	BigInteger operator += (const BigInteger& b) {
		*this = *this + b; return *this;
	}
	BigInteger operator ++ (int) {
		*this = *this + 1; return *this;
	}
	BigInteger operator ++ () {
		*this = *this + 1; return *this;
	}
	BigInteger operator -= (const BigInteger& b) {
		*this = *this - b; return *this;
	}
	BigInteger operator -- (int) {
		*this = *this - 1; return *this;
	}
	BigInteger operator -- () {
		*this = *this - 1; return *this;
	}
	BigInteger operator *= (const BigInteger& b) {
		*this = *this * b; return *this;
	}
	BigInteger operator /= (const BigInteger& b) {
		*this = *this / b; return *this;
	}
	friend ostream& operator << (ostream& out, const BigInteger& x) {
		out << x.s.back();
		for (int i = x.s.size() - 2; i >= 0; i--) {
			char buf[20];
			sprintf(buf, "%08d", x.s[i]);
			for (int j = 0; j < strlen(buf); j++) out << buf[j];
		}
		return out;
	}
	friend istream& operator >> (istream& in, BigInteger& x) {
		string s;
		if (!(in >> s)) return in;
		x = s;
		return in;
	}
};