diff --git a/third_party/bigint/BigInteger.cc b/third_party/bigint/BigInteger.cc
index 93b57e4..476f3e6 100644
--- a/third_party/bigint/BigInteger.cc
+++ b/third_party/bigint/BigInteger.cc
@@ -6,14 +6,15 @@
 
 #include "BigInteger.hh"
 
-void BigInteger::operator =(const BigInteger &x) {
+BigInteger& BigInteger::operator =(const BigInteger &x) {
 	// Calls like a = a have no effect
 	if (this == &x)
-		return;
+		return *this;
 	// Copy sign
 	sign = x.sign;
 	// Copy the rest
 	mag = x.mag;
+	return *this;
 }
 
 BigInteger::BigInteger(const Blk *b, Index blen, Sign s) : mag(b, blen) {
@@ -374,7 +375,7 @@
 // INCREMENT/DECREMENT OPERATORS
 
 // Prefix increment
-void BigInteger::operator ++() {
+BigInteger& BigInteger::operator ++() {
 	if (sign == negative) {
 		mag--;
 		if (mag == 0)
@@ -383,15 +384,18 @@
 		mag++;
 		sign = positive; // if not already
 	}
+	return *this;
 }
 
-// Postfix increment: same as prefix
-void BigInteger::operator ++(int) {
+// Postfix increment
+BigInteger BigInteger::operator ++(int) {
+	BigInteger temp(*this);
 	operator ++();
+	return temp;
 }
 
 // Prefix decrement
-void BigInteger::operator --() {
+BigInteger& BigInteger::operator --() {
 	if (sign == positive) {
 		mag--;
 		if (mag == 0)
@@ -400,10 +404,13 @@
 		mag++;
 		sign = negative;
 	}
+	return *this;
 }
 
-// Postfix decrement: same as prefix
-void BigInteger::operator --(int) {
+// Postfix decrement
+BigInteger BigInteger::operator --(int) {
+	BigInteger temp(*this);
 	operator --();
+	return temp;
 }
 
diff --git a/third_party/bigint/BigInteger.hh b/third_party/bigint/BigInteger.hh
index 35a2b6b..b5d3518 100644
--- a/third_party/bigint/BigInteger.hh
+++ b/third_party/bigint/BigInteger.hh
@@ -41,7 +41,7 @@
 	BigInteger(const BigInteger &x) : sign(x.sign), mag(x.mag) {}
 
 	// Assignment operator
-	void operator=(const BigInteger &x);
+	BigInteger& operator=(const BigInteger &x);
 
 	// Constructor that copies from a given array of blocks with a sign.
 	BigInteger(const Blk *b, Index blen, Sign s);
@@ -129,18 +129,18 @@
 	BigInteger operator %(const BigInteger &x) const;
 	BigInteger operator -() const;
 
-	void operator +=(const BigInteger &x);
-	void operator -=(const BigInteger &x);
-	void operator *=(const BigInteger &x);
-	void operator /=(const BigInteger &x);
-	void operator %=(const BigInteger &x);
+	BigInteger& operator +=(const BigInteger &x);
+	BigInteger& operator -=(const BigInteger &x);
+	BigInteger& operator *=(const BigInteger &x);
+	BigInteger& operator /=(const BigInteger &x);
+	BigInteger& operator %=(const BigInteger &x);
 	void flipSign();
 
 	// INCREMENT/DECREMENT OPERATORS
-	void operator ++(   );
-	void operator ++(int);
-	void operator --(   );
-	void operator --(int);
+	BigInteger& operator ++(   );
+	BigInteger operator ++(int);
+	BigInteger& operator --(   );
+	BigInteger operator --(int);
 };
 
 // NORMAL OPERATORS
@@ -191,16 +191,19 @@
  * belongs to the put-here operations.  See Assignment Operators in
  * BigUnsigned.hh.
  */
-inline void BigInteger::operator +=(const BigInteger &x) {
+inline BigInteger& BigInteger::operator +=(const BigInteger &x) {
 	add(*this, x);
+	return *this;
 }
-inline void BigInteger::operator -=(const BigInteger &x) {
+inline BigInteger& BigInteger::operator -=(const BigInteger &x) {
 	subtract(*this, x);
+	return *this;
 }
-inline void BigInteger::operator *=(const BigInteger &x) {
+inline BigInteger& BigInteger::operator *=(const BigInteger &x) {
 	multiply(*this, x);
+	return *this;
 }
-inline void BigInteger::operator /=(const BigInteger &x) {
+inline BigInteger& BigInteger::operator /=(const BigInteger &x) {
 	if (x.isZero())
         abort();
 	/* The following technique is slightly faster than copying *this first
@@ -209,13 +212,15 @@
 	divideWithRemainder(x, q);
 	// *this contains the remainder, but we overwrite it with the quotient.
 	*this = q;
+	return *this;
 }
-inline void BigInteger::operator %=(const BigInteger &x) {
+inline BigInteger& BigInteger::operator %=(const BigInteger &x) {
 	if (x.isZero())
         abort();
 	BigInteger q;
 	// Mods *this by x.  Don't care about quotient left in q.
 	divideWithRemainder(x, q);
+	return *this;
 }
 // This one is trivial
 inline void BigInteger::flipSign() {
diff --git a/third_party/bigint/BigUnsigned.cc b/third_party/bigint/BigUnsigned.cc
index e38e4aa..0713632 100644
--- a/third_party/bigint/BigUnsigned.cc
+++ b/third_party/bigint/BigUnsigned.cc
@@ -659,7 +659,7 @@
 // INCREMENT/DECREMENT OPERATORS
 
 // Prefix increment
-void BigUnsigned::operator ++() {
+BigUnsigned& BigUnsigned::operator ++() {
 	Index i;
 	bool carry = true;
 	for (i = 0; i < len && carry; i++) {
@@ -672,15 +672,18 @@
 		len++;
 		blk[i] = 1;
 	}
+	return *this;
 }
 
-// Postfix increment: same as prefix
-void BigUnsigned::operator ++(int) {
+// Postfix increment
+BigUnsigned BigUnsigned::operator ++(int) {
+	BigUnsigned temp(*this);
 	operator ++();
+	return temp;
 }
 
 // Prefix decrement
-void BigUnsigned::operator --() {
+BigUnsigned& BigUnsigned::operator --() {
 	if (len == 0)
         abort();
 	Index i;
@@ -692,9 +695,12 @@
 	// Zap possible leading zero (there can only be one)
 	if (blk[len - 1] == 0)
 		len--;
+	return *this;
 }
 
-// Postfix decrement: same as prefix
-void BigUnsigned::operator --(int) {
+// Postfix decrement
+BigUnsigned BigUnsigned::operator --(int) {
+	BigUnsigned temp(*this);
 	operator --();
+	return temp;
 }
diff --git a/third_party/bigint/BigUnsigned.hh b/third_party/bigint/BigUnsigned.hh
index de4c18e..56da651 100644
--- a/third_party/bigint/BigUnsigned.hh
+++ b/third_party/bigint/BigUnsigned.hh
@@ -46,8 +46,9 @@
 	BigUnsigned(const BigUnsigned &x) : NumberlikeArray<Blk>(x) {}
 
 	// Assignment operator
-	void operator=(const BigUnsigned &x) {
+	BigUnsigned& operator=(const BigUnsigned &x) {
 		NumberlikeArray<Blk>::operator =(x);
+		return *this;
 	}
 
 	// Constructor that copies from a given array of blocks.
@@ -218,24 +219,24 @@
 	BigUnsigned operator >>(int b) const;
 
 	// OVERLOADED ASSIGNMENT OPERATORS
-	void operator +=(const BigUnsigned &x);
-	void operator -=(const BigUnsigned &x);
-	void operator *=(const BigUnsigned &x);
-	void operator /=(const BigUnsigned &x);
-	void operator %=(const BigUnsigned &x);
-	void operator &=(const BigUnsigned &x);
-	void operator |=(const BigUnsigned &x);
-	void operator ^=(const BigUnsigned &x);
-	void operator <<=(int b);
-	void operator >>=(int b);
+	BigUnsigned& operator +=(const BigUnsigned &x);
+	BigUnsigned& operator -=(const BigUnsigned &x);
+	BigUnsigned& operator *=(const BigUnsigned &x);
+	BigUnsigned& operator /=(const BigUnsigned &x);
+	BigUnsigned& operator %=(const BigUnsigned &x);
+	BigUnsigned& operator &=(const BigUnsigned &x);
+	BigUnsigned& operator |=(const BigUnsigned &x);
+	BigUnsigned& operator ^=(const BigUnsigned &x);
+	BigUnsigned& operator <<=(int b);
+	BigUnsigned& operator >>=(int b);
 
 	/* INCREMENT/DECREMENT OPERATORS
 	 * To discourage messy coding, these do not return *this, so prefix
 	 * and postfix behave the same. */
-	void operator ++(   );
-	void operator ++(int);
-	void operator --(   );
-	void operator --(int);
+	BigUnsigned& operator ++(   );
+	BigUnsigned operator ++(int);
+	BigUnsigned& operator --(   );
+	BigUnsigned operator --(int);
 
 	// Helper function that needs access to BigUnsigned internals
 	friend Blk getShiftedBlock(const BigUnsigned &num, Index x,
@@ -307,16 +308,19 @@
 	return ans;
 }
 
-inline void BigUnsigned::operator +=(const BigUnsigned &x) {
+inline BigUnsigned& BigUnsigned::operator +=(const BigUnsigned &x) {
 	add(*this, x);
+	return *this;
 }
-inline void BigUnsigned::operator -=(const BigUnsigned &x) {
+inline BigUnsigned& BigUnsigned::operator -=(const BigUnsigned &x) {
 	subtract(*this, x);
+	return *this;
 }
-inline void BigUnsigned::operator *=(const BigUnsigned &x) {
+inline BigUnsigned& BigUnsigned::operator *=(const BigUnsigned &x) {
 	multiply(*this, x);
+	return *this;
 }
-inline void BigUnsigned::operator /=(const BigUnsigned &x) {
+inline BigUnsigned& BigUnsigned::operator /=(const BigUnsigned &x) {
 	if (x.isZero())
         abort();
 	/* The following technique is slightly faster than copying *this first
@@ -325,28 +329,35 @@
 	divideWithRemainder(x, q);
 	// *this contains the remainder, but we overwrite it with the quotient.
 	*this = q;
+	return *this;
 }
-inline void BigUnsigned::operator %=(const BigUnsigned &x) {
+inline BigUnsigned& BigUnsigned::operator %=(const BigUnsigned &x) {
 	if (x.isZero())
         abort();
 	BigUnsigned q;
 	// Mods *this by x.  Don't care about quotient left in q.
 	divideWithRemainder(x, q);
+	return *this;
 }
-inline void BigUnsigned::operator &=(const BigUnsigned &x) {
+inline BigUnsigned& BigUnsigned::operator &=(const BigUnsigned &x) {
 	bitAnd(*this, x);
+	return *this;
 }
-inline void BigUnsigned::operator |=(const BigUnsigned &x) {
+inline BigUnsigned& BigUnsigned::operator |=(const BigUnsigned &x) {
 	bitOr(*this, x);
+	return *this;
 }
-inline void BigUnsigned::operator ^=(const BigUnsigned &x) {
+inline BigUnsigned& BigUnsigned::operator ^=(const BigUnsigned &x) {
 	bitXor(*this, x);
+	return *this;
 }
-inline void BigUnsigned::operator <<=(int b) {
+inline BigUnsigned& BigUnsigned::operator <<=(int b) {
 	bitShiftLeft(*this, b);
+	return *this;
 }
-inline void BigUnsigned::operator >>=(int b) {
+inline BigUnsigned& BigUnsigned::operator >>=(int b) {
 	bitShiftRight(*this, b);
+	return *this;
 }
 
 /* Templates for conversions of BigUnsigned to and from primitive integers.
diff --git a/third_party/bigint/NumberlikeArray.hh b/third_party/bigint/NumberlikeArray.hh
index f791780..df58dae 100644
--- a/third_party/bigint/NumberlikeArray.hh
+++ b/third_party/bigint/NumberlikeArray.hh
@@ -70,7 +70,7 @@
 	NumberlikeArray(const NumberlikeArray<Blk> &x);
 
 	// Assignment operator
-	void operator=(const NumberlikeArray<Blk> &x);
+	NumberlikeArray<Blk>& operator=(const NumberlikeArray<Blk> &x);
 
 	// Constructor that copies from a given array of blocks
 	NumberlikeArray(const Blk *b, Index blen);
@@ -139,11 +139,11 @@
 }
 
 template <class Blk>
-void NumberlikeArray<Blk>::operator=(const NumberlikeArray<Blk> &x) {
+NumberlikeArray<Blk>& NumberlikeArray<Blk>::operator=(const NumberlikeArray<Blk> &x) {
 	/* Calls like a = a have no effect; catch them before the aliasing
 	 * causes a problem */
 	if (this == &x)
-		return;
+		return *this;
 	// Copy length
 	len = x.len;
 	// Expand array if necessary
@@ -152,6 +152,7 @@
 	Index i;
 	for (i = 0; i < len; i++)
 		blk[i] = x.blk[i];
+	return *this;
 }
 
 template <class Blk>