diff --git a/src/Reactor/LLVMReactor.cpp b/src/Reactor/LLVMReactor.cpp
index 3ab0693..0a5aa66 100644
--- a/src/Reactor/LLVMReactor.cpp
+++ b/src/Reactor/LLVMReactor.cpp
@@ -864,14 +864,14 @@
 		storeValue(value);
 	}
 
-	RValue<Bool> Bool::operator=(RValue<Bool> rhs) const
+	RValue<Bool> Bool::operator=(RValue<Bool> rhs)
 	{
 		storeValue(rhs.value);
 
 		return rhs;
 	}
 
-	RValue<Bool> Bool::operator=(const Bool &rhs) const
+	RValue<Bool> Bool::operator=(const Bool &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -879,7 +879,7 @@
 		return RValue<Bool>(value);
 	}
 
-	RValue<Bool> Bool::operator=(const Reference<Bool> &rhs) const
+	RValue<Bool> Bool::operator=(const Reference<Bool> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -964,14 +964,14 @@
 		storeValue(value);
 	}
 
-	RValue<Byte> Byte::operator=(RValue<Byte> rhs) const
+	RValue<Byte> Byte::operator=(RValue<Byte> rhs)
 	{
 		storeValue(rhs.value);
 
 		return rhs;
 	}
 
-	RValue<Byte> Byte::operator=(const Byte &rhs) const
+	RValue<Byte> Byte::operator=(const Byte &rhs) 
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -979,7 +979,7 @@
 		return RValue<Byte>(value);
 	}
 
-	RValue<Byte> Byte::operator=(const Reference<Byte> &rhs) const
+	RValue<Byte> Byte::operator=(const Reference<Byte> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -1037,52 +1037,52 @@
 		return RValue<Byte>(Nucleus::createLShr(lhs.value, rhs.value));
 	}
 
-	RValue<Byte> operator+=(const Byte &lhs, RValue<Byte> rhs)
+	RValue<Byte> operator+=(Byte &lhs, RValue<Byte> rhs)
 	{
 		return lhs = lhs + rhs;
 	}
 
-	RValue<Byte> operator-=(const Byte &lhs, RValue<Byte> rhs)
+	RValue<Byte> operator-=(Byte &lhs, RValue<Byte> rhs)
 	{
 		return lhs = lhs - rhs;
 	}
 
-	RValue<Byte> operator*=(const Byte &lhs, RValue<Byte> rhs)
+	RValue<Byte> operator*=(Byte &lhs, RValue<Byte> rhs)
 	{
 		return lhs = lhs * rhs;
 	}
 
-	RValue<Byte> operator/=(const Byte &lhs, RValue<Byte> rhs)
+	RValue<Byte> operator/=(Byte &lhs, RValue<Byte> rhs)
 	{
 		return lhs = lhs / rhs;
 	}
 
-	RValue<Byte> operator%=(const Byte &lhs, RValue<Byte> rhs)
+	RValue<Byte> operator%=(Byte &lhs, RValue<Byte> rhs)
 	{
 		return lhs = lhs % rhs;
 	}
 
-	RValue<Byte> operator&=(const Byte &lhs, RValue<Byte> rhs)
+	RValue<Byte> operator&=(Byte &lhs, RValue<Byte> rhs)
 	{
 		return lhs = lhs & rhs;
 	}
 
-	RValue<Byte> operator|=(const Byte &lhs, RValue<Byte> rhs)
+	RValue<Byte> operator|=(Byte &lhs, RValue<Byte> rhs)
 	{
 		return lhs = lhs | rhs;
 	}
 
-	RValue<Byte> operator^=(const Byte &lhs, RValue<Byte> rhs)
+	RValue<Byte> operator^=(Byte &lhs, RValue<Byte> rhs)
 	{
 		return lhs = lhs ^ rhs;
 	}
 
-	RValue<Byte> operator<<=(const Byte &lhs, RValue<Byte> rhs)
+	RValue<Byte> operator<<=(Byte &lhs, RValue<Byte> rhs)
 	{
 		return lhs = lhs << rhs;
 	}
 
-	RValue<Byte> operator>>=(const Byte &lhs, RValue<Byte> rhs)
+	RValue<Byte> operator>>=(Byte &lhs, RValue<Byte> rhs)
 	{
 		return lhs = lhs >> rhs;
 	}
@@ -1102,7 +1102,7 @@
 		return RValue<Byte>(Nucleus::createNot(val.value));
 	}
 
-	RValue<Byte> operator++(const Byte &val, int)   // Post-increment
+	RValue<Byte> operator++(Byte &val, int)   // Post-increment
 	{
 		RValue<Byte> res = val;
 
@@ -1112,7 +1112,7 @@
 		return res;
 	}
 
-	const Byte &operator++(const Byte &val)   // Pre-increment
+	const Byte &operator++(Byte &val)   // Pre-increment
 	{
 		Value *inc = Nucleus::createAdd(val.loadValue(), V(Nucleus::createConstantByte((unsigned char)1)));
 		val.storeValue(inc);
@@ -1120,7 +1120,7 @@
 		return val;
 	}
 
-	RValue<Byte> operator--(const Byte &val, int)   // Post-decrement
+	RValue<Byte> operator--(Byte &val, int)   // Post-decrement
 	{
 		RValue<Byte> res = val;
 
@@ -1130,7 +1130,7 @@
 		return res;
 	}
 
-	const Byte &operator--(const Byte &val)   // Pre-decrement
+	const Byte &operator--(Byte &val)   // Pre-decrement
 	{
 		Value *inc = Nucleus::createSub(val.loadValue(), V(Nucleus::createConstantByte((unsigned char)1)));
 		val.storeValue(inc);
@@ -1218,14 +1218,14 @@
 		storeValue(value);
 	}
 
-	RValue<SByte> SByte::operator=(RValue<SByte> rhs) const
+	RValue<SByte> SByte::operator=(RValue<SByte> rhs)
 	{
 		storeValue(rhs.value);
 
 		return rhs;
 	}
 
-	RValue<SByte> SByte::operator=(const SByte &rhs) const
+	RValue<SByte> SByte::operator=(const SByte &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -1233,7 +1233,7 @@
 		return RValue<SByte>(value);
 	}
 
-	RValue<SByte> SByte::operator=(const Reference<SByte> &rhs) const
+	RValue<SByte> SByte::operator=(const Reference<SByte> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -1291,52 +1291,52 @@
 		return RValue<SByte>(Nucleus::createAShr(lhs.value, rhs.value));
 	}
 
-	RValue<SByte> operator+=(const SByte &lhs, RValue<SByte> rhs)
+	RValue<SByte> operator+=(SByte &lhs, RValue<SByte> rhs)
 	{
 		return lhs = lhs + rhs;
 	}
 
-	RValue<SByte> operator-=(const SByte &lhs, RValue<SByte> rhs)
+	RValue<SByte> operator-=(SByte &lhs, RValue<SByte> rhs)
 	{
 		return lhs = lhs - rhs;
 	}
 
-	RValue<SByte> operator*=(const SByte &lhs, RValue<SByte> rhs)
+	RValue<SByte> operator*=(SByte &lhs, RValue<SByte> rhs)
 	{
 		return lhs = lhs * rhs;
 	}
 
-	RValue<SByte> operator/=(const SByte &lhs, RValue<SByte> rhs)
+	RValue<SByte> operator/=(SByte &lhs, RValue<SByte> rhs)
 	{
 		return lhs = lhs / rhs;
 	}
 
-	RValue<SByte> operator%=(const SByte &lhs, RValue<SByte> rhs)
+	RValue<SByte> operator%=(SByte &lhs, RValue<SByte> rhs)
 	{
 		return lhs = lhs % rhs;
 	}
 
-	RValue<SByte> operator&=(const SByte &lhs, RValue<SByte> rhs)
+	RValue<SByte> operator&=(SByte &lhs, RValue<SByte> rhs)
 	{
 		return lhs = lhs & rhs;
 	}
 
-	RValue<SByte> operator|=(const SByte &lhs, RValue<SByte> rhs)
+	RValue<SByte> operator|=(SByte &lhs, RValue<SByte> rhs)
 	{
 		return lhs = lhs | rhs;
 	}
 
-	RValue<SByte> operator^=(const SByte &lhs, RValue<SByte> rhs)
+	RValue<SByte> operator^=(SByte &lhs, RValue<SByte> rhs)
 	{
 		return lhs = lhs ^ rhs;
 	}
 
-	RValue<SByte> operator<<=(const SByte &lhs, RValue<SByte> rhs)
+	RValue<SByte> operator<<=(SByte &lhs, RValue<SByte> rhs)
 	{
 		return lhs = lhs << rhs;
 	}
 
-	RValue<SByte> operator>>=(const SByte &lhs, RValue<SByte> rhs)
+	RValue<SByte> operator>>=(SByte &lhs, RValue<SByte> rhs)
 	{
 		return lhs = lhs >> rhs;
 	}
@@ -1356,7 +1356,7 @@
 		return RValue<SByte>(Nucleus::createNot(val.value));
 	}
 
-	RValue<SByte> operator++(const SByte &val, int)   // Post-increment
+	RValue<SByte> operator++(SByte &val, int)   // Post-increment
 	{
 		RValue<SByte> res = val;
 
@@ -1366,7 +1366,7 @@
 		return res;
 	}
 
-	const SByte &operator++(const SByte &val)   // Pre-increment
+	const SByte &operator++(SByte &val)   // Pre-increment
 	{
 		Value *inc = Nucleus::createAdd(val.loadValue(), V(Nucleus::createConstantByte((signed char)1)));
 		val.storeValue(inc);
@@ -1374,7 +1374,7 @@
 		return val;
 	}
 
-	RValue<SByte> operator--(const SByte &val, int)   // Post-decrement
+	RValue<SByte> operator--(SByte &val, int)   // Post-decrement
 	{
 		RValue<SByte> res = val;
 
@@ -1384,7 +1384,7 @@
 		return res;
 	}
 
-	const SByte &operator--(const SByte &val)   // Pre-decrement
+	const SByte &operator--(SByte &val)   // Pre-decrement
 	{
 		Value *inc = Nucleus::createSub(val.loadValue(), V(Nucleus::createConstantByte((signed char)1)));
 		val.storeValue(inc);
@@ -1465,14 +1465,14 @@
 		storeValue(value);
 	}
 
-	RValue<Short> Short::operator=(RValue<Short> rhs) const
+	RValue<Short> Short::operator=(RValue<Short> rhs)
 	{
 		storeValue(rhs.value);
 
 		return rhs;
 	}
 
-	RValue<Short> Short::operator=(const Short &rhs) const
+	RValue<Short> Short::operator=(const Short &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -1480,7 +1480,7 @@
 		return RValue<Short>(value);
 	}
 
-	RValue<Short> Short::operator=(const Reference<Short> &rhs) const
+	RValue<Short> Short::operator=(const Reference<Short> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -1538,52 +1538,52 @@
 		return RValue<Short>(Nucleus::createAShr(lhs.value, rhs.value));
 	}
 
-	RValue<Short> operator+=(const Short &lhs, RValue<Short> rhs)
+	RValue<Short> operator+=(Short &lhs, RValue<Short> rhs)
 	{
 		return lhs = lhs + rhs;
 	}
 
-	RValue<Short> operator-=(const Short &lhs, RValue<Short> rhs)
+	RValue<Short> operator-=(Short &lhs, RValue<Short> rhs)
 	{
 		return lhs = lhs - rhs;
 	}
 
-	RValue<Short> operator*=(const Short &lhs, RValue<Short> rhs)
+	RValue<Short> operator*=(Short &lhs, RValue<Short> rhs)
 	{
 		return lhs = lhs * rhs;
 	}
 
-	RValue<Short> operator/=(const Short &lhs, RValue<Short> rhs)
+	RValue<Short> operator/=(Short &lhs, RValue<Short> rhs)
 	{
 		return lhs = lhs / rhs;
 	}
 
-	RValue<Short> operator%=(const Short &lhs, RValue<Short> rhs)
+	RValue<Short> operator%=(Short &lhs, RValue<Short> rhs)
 	{
 		return lhs = lhs % rhs;
 	}
 
-	RValue<Short> operator&=(const Short &lhs, RValue<Short> rhs)
+	RValue<Short> operator&=(Short &lhs, RValue<Short> rhs)
 	{
 		return lhs = lhs & rhs;
 	}
 
-	RValue<Short> operator|=(const Short &lhs, RValue<Short> rhs)
+	RValue<Short> operator|=(Short &lhs, RValue<Short> rhs)
 	{
 		return lhs = lhs | rhs;
 	}
 
-	RValue<Short> operator^=(const Short &lhs, RValue<Short> rhs)
+	RValue<Short> operator^=(Short &lhs, RValue<Short> rhs)
 	{
 		return lhs = lhs ^ rhs;
 	}
 
-	RValue<Short> operator<<=(const Short &lhs, RValue<Short> rhs)
+	RValue<Short> operator<<=(Short &lhs, RValue<Short> rhs)
 	{
 		return lhs = lhs << rhs;
 	}
 
-	RValue<Short> operator>>=(const Short &lhs, RValue<Short> rhs)
+	RValue<Short> operator>>=(Short &lhs, RValue<Short> rhs)
 	{
 		return lhs = lhs >> rhs;
 	}
@@ -1603,7 +1603,7 @@
 		return RValue<Short>(Nucleus::createNot(val.value));
 	}
 
-	RValue<Short> operator++(const Short &val, int)   // Post-increment
+	RValue<Short> operator++(Short &val, int)   // Post-increment
 	{
 		RValue<Short> res = val;
 
@@ -1613,7 +1613,7 @@
 		return res;
 	}
 
-	const Short &operator++(const Short &val)   // Pre-increment
+	const Short &operator++(Short &val)   // Pre-increment
 	{
 		Value *inc = Nucleus::createAdd(val.loadValue(), V(Nucleus::createConstantShort((short)1)));
 		val.storeValue(inc);
@@ -1621,7 +1621,7 @@
 		return val;
 	}
 
-	RValue<Short> operator--(const Short &val, int)   // Post-decrement
+	RValue<Short> operator--(Short &val, int)   // Post-decrement
 	{
 		RValue<Short> res = val;
 
@@ -1631,7 +1631,7 @@
 		return res;
 	}
 
-	const Short &operator--(const Short &val)   // Pre-decrement
+	const Short &operator--(Short &val)   // Pre-decrement
 	{
 		Value *inc = Nucleus::createSub(val.loadValue(), V(Nucleus::createConstantShort((short)1)));
 		val.storeValue(inc);
@@ -1719,14 +1719,14 @@
 		storeValue(value);
 	}
 
-	RValue<UShort> UShort::operator=(RValue<UShort> rhs) const
+	RValue<UShort> UShort::operator=(RValue<UShort> rhs)
 	{
 		storeValue(rhs.value);
 
 		return rhs;
 	}
 
-	RValue<UShort> UShort::operator=(const UShort &rhs) const
+	RValue<UShort> UShort::operator=(const UShort &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -1734,7 +1734,7 @@
 		return RValue<UShort>(value);
 	}
 
-	RValue<UShort> UShort::operator=(const Reference<UShort> &rhs) const
+	RValue<UShort> UShort::operator=(const Reference<UShort> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -1792,52 +1792,52 @@
 		return RValue<UShort>(Nucleus::createLShr(lhs.value, rhs.value));
 	}
 
-	RValue<UShort> operator+=(const UShort &lhs, RValue<UShort> rhs)
+	RValue<UShort> operator+=(UShort &lhs, RValue<UShort> rhs)
 	{
 		return lhs = lhs + rhs;
 	}
 
-	RValue<UShort> operator-=(const UShort &lhs, RValue<UShort> rhs)
+	RValue<UShort> operator-=(UShort &lhs, RValue<UShort> rhs)
 	{
 		return lhs = lhs - rhs;
 	}
 
-	RValue<UShort> operator*=(const UShort &lhs, RValue<UShort> rhs)
+	RValue<UShort> operator*=(UShort &lhs, RValue<UShort> rhs)
 	{
 		return lhs = lhs * rhs;
 	}
 
-	RValue<UShort> operator/=(const UShort &lhs, RValue<UShort> rhs)
+	RValue<UShort> operator/=(UShort &lhs, RValue<UShort> rhs)
 	{
 		return lhs = lhs / rhs;
 	}
 
-	RValue<UShort> operator%=(const UShort &lhs, RValue<UShort> rhs)
+	RValue<UShort> operator%=(UShort &lhs, RValue<UShort> rhs)
 	{
 		return lhs = lhs % rhs;
 	}
 
-	RValue<UShort> operator&=(const UShort &lhs, RValue<UShort> rhs)
+	RValue<UShort> operator&=(UShort &lhs, RValue<UShort> rhs)
 	{
 		return lhs = lhs & rhs;
 	}
 
-	RValue<UShort> operator|=(const UShort &lhs, RValue<UShort> rhs)
+	RValue<UShort> operator|=(UShort &lhs, RValue<UShort> rhs)
 	{
 		return lhs = lhs | rhs;
 	}
 
-	RValue<UShort> operator^=(const UShort &lhs, RValue<UShort> rhs)
+	RValue<UShort> operator^=(UShort &lhs, RValue<UShort> rhs)
 	{
 		return lhs = lhs ^ rhs;
 	}
 
-	RValue<UShort> operator<<=(const UShort &lhs, RValue<UShort> rhs)
+	RValue<UShort> operator<<=(UShort &lhs, RValue<UShort> rhs)
 	{
 		return lhs = lhs << rhs;
 	}
 
-	RValue<UShort> operator>>=(const UShort &lhs, RValue<UShort> rhs)
+	RValue<UShort> operator>>=(UShort &lhs, RValue<UShort> rhs)
 	{
 		return lhs = lhs >> rhs;
 	}
@@ -1857,7 +1857,7 @@
 		return RValue<UShort>(Nucleus::createNot(val.value));
 	}
 
-	RValue<UShort> operator++(const UShort &val, int)   // Post-increment
+	RValue<UShort> operator++(UShort &val, int)   // Post-increment
 	{
 		RValue<UShort> res = val;
 
@@ -1867,7 +1867,7 @@
 		return res;
 	}
 
-	const UShort &operator++(const UShort &val)   // Pre-increment
+	const UShort &operator++(UShort &val)   // Pre-increment
 	{
 		Value *inc = Nucleus::createAdd(val.loadValue(), V(Nucleus::createConstantShort((unsigned short)1)));
 		val.storeValue(inc);
@@ -1875,7 +1875,7 @@
 		return val;
 	}
 
-	RValue<UShort> operator--(const UShort &val, int)   // Post-decrement
+	RValue<UShort> operator--(UShort &val, int)   // Post-decrement
 	{
 		RValue<UShort> res = val;
 
@@ -1885,7 +1885,7 @@
 		return res;
 	}
 
-	const UShort &operator--(const UShort &val)   // Pre-decrement
+	const UShort &operator--(UShort &val)   // Pre-decrement
 	{
 		Value *inc = Nucleus::createSub(val.loadValue(), V(Nucleus::createConstantShort((unsigned short)1)));
 		val.storeValue(inc);
@@ -1999,14 +1999,14 @@
 		storeValue(value);
 	}
 
-	RValue<Byte8> Byte8::operator=(RValue<Byte8> rhs) const
+	RValue<Byte8> Byte8::operator=(RValue<Byte8> rhs)
 	{
 		storeValue(rhs.value);
 
 		return rhs;
 	}
 
-	RValue<Byte8> Byte8::operator=(const Byte8 &rhs) const
+	RValue<Byte8> Byte8::operator=(const Byte8 &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -2014,7 +2014,7 @@
 		return RValue<Byte8>(value);
 	}
 
-	RValue<Byte8> Byte8::operator=(const Reference<Byte8> &rhs) const
+	RValue<Byte8> Byte8::operator=(const Reference<Byte8> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -2107,52 +2107,52 @@
 //		return RValue<Byte8>(Nucleus::createLShr(lhs.value, rhs.value));
 //	}
 
-	RValue<Byte8> operator+=(const Byte8 &lhs, RValue<Byte8> rhs)
+	RValue<Byte8> operator+=(Byte8 &lhs, RValue<Byte8> rhs)
 	{
 		return lhs = lhs + rhs;
 	}
 
-	RValue<Byte8> operator-=(const Byte8 &lhs, RValue<Byte8> rhs)
+	RValue<Byte8> operator-=(Byte8 &lhs, RValue<Byte8> rhs)
 	{
 		return lhs = lhs - rhs;
 	}
 
-//	RValue<Byte8> operator*=(const Byte8 &lhs, RValue<Byte8> rhs)
+//	RValue<Byte8> operator*=(Byte8 &lhs, RValue<Byte8> rhs)
 //	{
 //		return lhs = lhs * rhs;
 //	}
 
-//	RValue<Byte8> operator/=(const Byte8 &lhs, RValue<Byte8> rhs)
+//	RValue<Byte8> operator/=(Byte8 &lhs, RValue<Byte8> rhs)
 //	{
 //		return lhs = lhs / rhs;
 //	}
 
-//	RValue<Byte8> operator%=(const Byte8 &lhs, RValue<Byte8> rhs)
+//	RValue<Byte8> operator%=(Byte8 &lhs, RValue<Byte8> rhs)
 //	{
 //		return lhs = lhs % rhs;
 //	}
 
-	RValue<Byte8> operator&=(const Byte8 &lhs, RValue<Byte8> rhs)
+	RValue<Byte8> operator&=(Byte8 &lhs, RValue<Byte8> rhs)
 	{
 		return lhs = lhs & rhs;
 	}
 
-	RValue<Byte8> operator|=(const Byte8 &lhs, RValue<Byte8> rhs)
+	RValue<Byte8> operator|=(Byte8 &lhs, RValue<Byte8> rhs)
 	{
 		return lhs = lhs | rhs;
 	}
 
-	RValue<Byte8> operator^=(const Byte8 &lhs, RValue<Byte8> rhs)
+	RValue<Byte8> operator^=(Byte8 &lhs, RValue<Byte8> rhs)
 	{
 		return lhs = lhs ^ rhs;
 	}
 
-//	RValue<Byte8> operator<<=(const Byte8 &lhs, RValue<Byte8> rhs)
+//	RValue<Byte8> operator<<=(Byte8 &lhs, RValue<Byte8> rhs)
 //	{
 //		return lhs = lhs << rhs;
 //	}
 
-//	RValue<Byte8> operator>>=(const Byte8 &lhs, RValue<Byte8> rhs)
+//	RValue<Byte8> operator>>=(Byte8 &lhs, RValue<Byte8> rhs)
 //	{
 //		return lhs = lhs >> rhs;
 //	}
@@ -2292,14 +2292,14 @@
 		storeValue(value);
 	}
 
-	RValue<SByte8> SByte8::operator=(RValue<SByte8> rhs) const
+	RValue<SByte8> SByte8::operator=(RValue<SByte8> rhs)
 	{
 		storeValue(rhs.value);
 
 		return rhs;
 	}
 
-	RValue<SByte8> SByte8::operator=(const SByte8 &rhs) const
+	RValue<SByte8> SByte8::operator=(const SByte8 &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -2307,7 +2307,7 @@
 		return RValue<SByte8>(value);
 	}
 
-	RValue<SByte8> SByte8::operator=(const Reference<SByte8> &rhs) const
+	RValue<SByte8> SByte8::operator=(const Reference<SByte8> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -2379,52 +2379,52 @@
 //		return RValue<SByte8>(Nucleus::createAShr(lhs.value, rhs.value));
 //	}
 
-	RValue<SByte8> operator+=(const SByte8 &lhs, RValue<SByte8> rhs)
+	RValue<SByte8> operator+=(SByte8 &lhs, RValue<SByte8> rhs)
 	{
 		return lhs = lhs + rhs;
 	}
 
-	RValue<SByte8> operator-=(const SByte8 &lhs, RValue<SByte8> rhs)
+	RValue<SByte8> operator-=(SByte8 &lhs, RValue<SByte8> rhs)
 	{
 		return lhs = lhs - rhs;
 	}
 
-//	RValue<SByte8> operator*=(const SByte8 &lhs, RValue<SByte8> rhs)
+//	RValue<SByte8> operator*=(SByte8 &lhs, RValue<SByte8> rhs)
 //	{
 //		return lhs = lhs * rhs;
 //	}
 
-//	RValue<SByte8> operator/=(const SByte8 &lhs, RValue<SByte8> rhs)
+//	RValue<SByte8> operator/=(SByte8 &lhs, RValue<SByte8> rhs)
 //	{
 //		return lhs = lhs / rhs;
 //	}
 
-//	RValue<SByte8> operator%=(const SByte8 &lhs, RValue<SByte8> rhs)
+//	RValue<SByte8> operator%=(SByte8 &lhs, RValue<SByte8> rhs)
 //	{
 //		return lhs = lhs % rhs;
 //	}
 
-	RValue<SByte8> operator&=(const SByte8 &lhs, RValue<SByte8> rhs)
+	RValue<SByte8> operator&=(SByte8 &lhs, RValue<SByte8> rhs)
 	{
 		return lhs = lhs & rhs;
 	}
 
-	RValue<SByte8> operator|=(const SByte8 &lhs, RValue<SByte8> rhs)
+	RValue<SByte8> operator|=(SByte8 &lhs, RValue<SByte8> rhs)
 	{
 		return lhs = lhs | rhs;
 	}
 
-	RValue<SByte8> operator^=(const SByte8 &lhs, RValue<SByte8> rhs)
+	RValue<SByte8> operator^=(SByte8 &lhs, RValue<SByte8> rhs)
 	{
 		return lhs = lhs ^ rhs;
 	}
 
-//	RValue<SByte8> operator<<=(const SByte8 &lhs, RValue<SByte8> rhs)
+//	RValue<SByte8> operator<<=(SByte8 &lhs, RValue<SByte8> rhs)
 //	{
 //		return lhs = lhs << rhs;
 //	}
 
-//	RValue<SByte8> operator>>=(const SByte8 &lhs, RValue<SByte8> rhs)
+//	RValue<SByte8> operator>>=(SByte8 &lhs, RValue<SByte8> rhs)
 //	{
 //		return lhs = lhs >> rhs;
 //	}
@@ -2541,14 +2541,14 @@
 		storeValue(value);
 	}
 
-	RValue<Byte16> Byte16::operator=(RValue<Byte16> rhs) const
+	RValue<Byte16> Byte16::operator=(RValue<Byte16> rhs)
 	{
 		storeValue(rhs.value);
 
 		return rhs;
 	}
 
-	RValue<Byte16> Byte16::operator=(const Byte16 &rhs) const
+	RValue<Byte16> Byte16::operator=(const Byte16 &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -2556,7 +2556,7 @@
 		return RValue<Byte16>(value);
 	}
 
-	RValue<Byte16> Byte16::operator=(const Reference<Byte16> &rhs) const
+	RValue<Byte16> Byte16::operator=(const Reference<Byte16> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -2737,14 +2737,14 @@
 		storeValue(rhs.loadValue());
 	}
 
-	RValue<Short4> Short4::operator=(RValue<Short4> rhs) const
+	RValue<Short4> Short4::operator=(RValue<Short4> rhs)
 	{
 		storeValue(rhs.value);
 
 		return rhs;
 	}
 
-	RValue<Short4> Short4::operator=(const Short4 &rhs) const
+	RValue<Short4> Short4::operator=(const Short4 &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -2752,7 +2752,7 @@
 		return RValue<Short4>(value);
 	}
 
-	RValue<Short4> Short4::operator=(const Reference<Short4> &rhs) const
+	RValue<Short4> Short4::operator=(const Reference<Short4> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -2760,14 +2760,14 @@
 		return RValue<Short4>(value);
 	}
 
-	RValue<Short4> Short4::operator=(RValue<UShort4> rhs) const
+	RValue<Short4> Short4::operator=(RValue<UShort4> rhs)
 	{
 		storeValue(rhs.value);
 
 		return RValue<Short4>(rhs);
 	}
 
-	RValue<Short4> Short4::operator=(const UShort4 &rhs) const
+	RValue<Short4> Short4::operator=(const UShort4 &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -2775,7 +2775,7 @@
 		return RValue<Short4>(value);
 	}
 
-	RValue<Short4> Short4::operator=(const Reference<UShort4> &rhs) const
+	RValue<Short4> Short4::operator=(const Reference<UShort4> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -2893,62 +2893,62 @@
 		return x86::psraw(lhs, rhs);
 	}
 
-	RValue<Short4> operator+=(const Short4 &lhs, RValue<Short4> rhs)
+	RValue<Short4> operator+=(Short4 &lhs, RValue<Short4> rhs)
 	{
 		return lhs = lhs + rhs;
 	}
 
-	RValue<Short4> operator-=(const Short4 &lhs, RValue<Short4> rhs)
+	RValue<Short4> operator-=(Short4 &lhs, RValue<Short4> rhs)
 	{
 		return lhs = lhs - rhs;
 	}
 
-	RValue<Short4> operator*=(const Short4 &lhs, RValue<Short4> rhs)
+	RValue<Short4> operator*=(Short4 &lhs, RValue<Short4> rhs)
 	{
 		return lhs = lhs * rhs;
 	}
 
-//	RValue<Short4> operator/=(const Short4 &lhs, RValue<Short4> rhs)
+//	RValue<Short4> operator/=(Short4 &lhs, RValue<Short4> rhs)
 //	{
 //		return lhs = lhs / rhs;
 //	}
 
-//	RValue<Short4> operator%=(const Short4 &lhs, RValue<Short4> rhs)
+//	RValue<Short4> operator%=(Short4 &lhs, RValue<Short4> rhs)
 //	{
 //		return lhs = lhs % rhs;
 //	}
 
-	RValue<Short4> operator&=(const Short4 &lhs, RValue<Short4> rhs)
+	RValue<Short4> operator&=(Short4 &lhs, RValue<Short4> rhs)
 	{
 		return lhs = lhs & rhs;
 	}
 
-	RValue<Short4> operator|=(const Short4 &lhs, RValue<Short4> rhs)
+	RValue<Short4> operator|=(Short4 &lhs, RValue<Short4> rhs)
 	{
 		return lhs = lhs | rhs;
 	}
 
-	RValue<Short4> operator^=(const Short4 &lhs, RValue<Short4> rhs)
+	RValue<Short4> operator^=(Short4 &lhs, RValue<Short4> rhs)
 	{
 		return lhs = lhs ^ rhs;
 	}
 
-	RValue<Short4> operator<<=(const Short4 &lhs, unsigned char rhs)
+	RValue<Short4> operator<<=(Short4 &lhs, unsigned char rhs)
 	{
 		return lhs = lhs << rhs;
 	}
 
-	RValue<Short4> operator>>=(const Short4 &lhs, unsigned char rhs)
+	RValue<Short4> operator>>=(Short4 &lhs, unsigned char rhs)
 	{
 		return lhs = lhs >> rhs;
 	}
 
-	RValue<Short4> operator<<=(const Short4 &lhs, RValue<Long1> rhs)
+	RValue<Short4> operator<<=(Short4 &lhs, RValue<Long1> rhs)
 	{
 		return lhs = lhs << rhs;
 	}
 
-	RValue<Short4> operator>>=(const Short4 &lhs, RValue<Long1> rhs)
+	RValue<Short4> operator>>=(Short4 &lhs, RValue<Long1> rhs)
 	{
 		return lhs = lhs >> rhs;
 	}
@@ -3221,14 +3221,14 @@
 		storeValue(value);
 	}
 
-	RValue<UShort4> UShort4::operator=(RValue<UShort4> rhs) const
+	RValue<UShort4> UShort4::operator=(RValue<UShort4> rhs)
 	{
 		storeValue(rhs.value);
 
 		return rhs;
 	}
 
-	RValue<UShort4> UShort4::operator=(const UShort4 &rhs) const
+	RValue<UShort4> UShort4::operator=(const UShort4 &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -3236,7 +3236,7 @@
 		return RValue<UShort4>(value);
 	}
 
-	RValue<UShort4> UShort4::operator=(const Reference<UShort4> &rhs) const
+	RValue<UShort4> UShort4::operator=(const Reference<UShort4> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -3244,14 +3244,14 @@
 		return RValue<UShort4>(value);
 	}
 
-	RValue<UShort4> UShort4::operator=(RValue<Short4> rhs) const
+	RValue<UShort4> UShort4::operator=(RValue<Short4> rhs)
 	{
 		storeValue(rhs.value);
 
 		return RValue<UShort4>(rhs);
 	}
 
-	RValue<UShort4> UShort4::operator=(const Short4 &rhs) const
+	RValue<UShort4> UShort4::operator=(const Short4 &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -3259,7 +3259,7 @@
 		return RValue<UShort4>(value);
 	}
 
-	RValue<UShort4> UShort4::operator=(const Reference<Short4> &rhs) const
+	RValue<UShort4> UShort4::operator=(const Reference<Short4> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -3367,22 +3367,22 @@
 		return x86::psrlw(lhs, rhs);
 	}
 
-	RValue<UShort4> operator<<=(const UShort4 &lhs, unsigned char rhs)
+	RValue<UShort4> operator<<=(UShort4 &lhs, unsigned char rhs)
 	{
 		return lhs = lhs << rhs;
 	}
 
-	RValue<UShort4> operator>>=(const UShort4 &lhs, unsigned char rhs)
+	RValue<UShort4> operator>>=(UShort4 &lhs, unsigned char rhs)
 	{
 		return lhs = lhs >> rhs;
 	}
 
-	RValue<UShort4> operator<<=(const UShort4 &lhs, RValue<Long1> rhs)
+	RValue<UShort4> operator<<=(UShort4 &lhs, RValue<Long1> rhs)
 	{
 		return lhs = lhs << rhs;
 	}
 
-	RValue<UShort4> operator>>=(const UShort4 &lhs, RValue<Long1> rhs)
+	RValue<UShort4> operator>>=(UShort4 &lhs, RValue<Long1> rhs)
 	{
 		return lhs = lhs >> rhs;
 	}
@@ -3554,14 +3554,14 @@
 		storeValue(short8);
 	}
 
-	RValue<UShort8> UShort8::operator=(RValue<UShort8> rhs) const
+	RValue<UShort8> UShort8::operator=(RValue<UShort8> rhs)
 	{
 		storeValue(rhs.value);
 
 		return rhs;
 	}
 
-	RValue<UShort8> UShort8::operator=(const UShort8 &rhs) const
+	RValue<UShort8> UShort8::operator=(const UShort8 &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -3569,7 +3569,7 @@
 		return RValue<UShort8>(value);
 	}
 
-	RValue<UShort8> UShort8::operator=(const Reference<UShort8> &rhs) const
+	RValue<UShort8> UShort8::operator=(const Reference<UShort8> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -3602,7 +3602,7 @@
 		return RValue<UShort8>(Nucleus::createMul(lhs.value, rhs.value));
 	}
 
-	RValue<UShort8> operator+=(const UShort8 &lhs, RValue<UShort8> rhs)
+	RValue<UShort8> operator+=(UShort8 &lhs, RValue<UShort8> rhs)
 	{
 		return lhs = lhs + rhs;
 	}
@@ -3746,26 +3746,26 @@
 		storeValue(value);
 	}
 
-	RValue<Int> Int::operator=(int rhs) const
+	RValue<Int> Int::operator=(int rhs)
 	{
 		return RValue<Int>(storeValue(Nucleus::createConstantInt(rhs)));
 	}
 
-	RValue<Int> Int::operator=(RValue<Int> rhs) const
+	RValue<Int> Int::operator=(RValue<Int> rhs)
 	{
 		storeValue(rhs.value);
 
 		return rhs;
 	}
 
-	RValue<Int> Int::operator=(RValue<UInt> rhs) const
+	RValue<Int> Int::operator=(RValue<UInt> rhs)
 	{
 		storeValue(rhs.value);
 
 		return RValue<Int>(rhs);
 	}
 
-	RValue<Int> Int::operator=(const Int &rhs) const
+	RValue<Int> Int::operator=(const Int &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -3773,7 +3773,7 @@
 		return RValue<Int>(value);
 	}
 
-	RValue<Int> Int::operator=(const Reference<Int> &rhs) const
+	RValue<Int> Int::operator=(const Reference<Int> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -3781,7 +3781,7 @@
 		return RValue<Int>(value);
 	}
 
-	RValue<Int> Int::operator=(const UInt &rhs) const
+	RValue<Int> Int::operator=(const UInt &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -3789,7 +3789,7 @@
 		return RValue<Int>(value);
 	}
 
-	RValue<Int> Int::operator=(const Reference<UInt> &rhs) const
+	RValue<Int> Int::operator=(const Reference<UInt> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -3847,52 +3847,52 @@
 		return RValue<Int>(Nucleus::createAShr(lhs.value, rhs.value));
 	}
 
-	RValue<Int> operator+=(const Int &lhs, RValue<Int> rhs)
+	RValue<Int> operator+=(Int &lhs, RValue<Int> rhs)
 	{
 		return lhs = lhs + rhs;
 	}
 
-	RValue<Int> operator-=(const Int &lhs, RValue<Int> rhs)
+	RValue<Int> operator-=(Int &lhs, RValue<Int> rhs)
 	{
 		return lhs = lhs - rhs;
 	}
 
-	RValue<Int> operator*=(const Int &lhs, RValue<Int> rhs)
+	RValue<Int> operator*=(Int &lhs, RValue<Int> rhs)
 	{
 		return lhs = lhs * rhs;
 	}
 
-	RValue<Int> operator/=(const Int &lhs, RValue<Int> rhs)
+	RValue<Int> operator/=(Int &lhs, RValue<Int> rhs)
 	{
 		return lhs = lhs / rhs;
 	}
 
-	RValue<Int> operator%=(const Int &lhs, RValue<Int> rhs)
+	RValue<Int> operator%=(Int &lhs, RValue<Int> rhs)
 	{
 		return lhs = lhs % rhs;
 	}
 
-	RValue<Int> operator&=(const Int &lhs, RValue<Int> rhs)
+	RValue<Int> operator&=(Int &lhs, RValue<Int> rhs)
 	{
 		return lhs = lhs & rhs;
 	}
 
-	RValue<Int> operator|=(const Int &lhs, RValue<Int> rhs)
+	RValue<Int> operator|=(Int &lhs, RValue<Int> rhs)
 	{
 		return lhs = lhs | rhs;
 	}
 
-	RValue<Int> operator^=(const Int &lhs, RValue<Int> rhs)
+	RValue<Int> operator^=(Int &lhs, RValue<Int> rhs)
 	{
 		return lhs = lhs ^ rhs;
 	}
 
-	RValue<Int> operator<<=(const Int &lhs, RValue<Int> rhs)
+	RValue<Int> operator<<=(Int &lhs, RValue<Int> rhs)
 	{
 		return lhs = lhs << rhs;
 	}
 
-	RValue<Int> operator>>=(const Int &lhs, RValue<Int> rhs)
+	RValue<Int> operator>>=(Int &lhs, RValue<Int> rhs)
 	{
 		return lhs = lhs >> rhs;
 	}
@@ -3912,7 +3912,7 @@
 		return RValue<Int>(Nucleus::createNot(val.value));
 	}
 
-	RValue<Int> operator++(const Int &val, int)   // Post-increment
+	RValue<Int> operator++(Int &val, int)   // Post-increment
 	{
 		RValue<Int> res = val;
 
@@ -3922,7 +3922,7 @@
 		return res;
 	}
 
-	const Int &operator++(const Int &val)   // Pre-increment
+	const Int &operator++(Int &val)   // Pre-increment
 	{
 		Value *inc = Nucleus::createAdd(val.loadValue(), V(Nucleus::createConstantInt(1)));
 		val.storeValue(inc);
@@ -3930,7 +3930,7 @@
 		return val;
 	}
 
-	RValue<Int> operator--(const Int &val, int)   // Post-decrement
+	RValue<Int> operator--(Int &val, int)   // Post-decrement
 	{
 		RValue<Int> res = val;
 
@@ -3940,7 +3940,7 @@
 		return res;
 	}
 
-	const Int &operator--(const Int &val)   // Pre-decrement
+	const Int &operator--(Int &val)   // Pre-decrement
 	{
 		Value *inc = Nucleus::createSub(val.loadValue(), V(Nucleus::createConstantInt(1)));
 		val.storeValue(inc);
@@ -4028,19 +4028,19 @@
 		storeValue(rhs.value);
 	}
 
-	RValue<Long> Long::operator=(int64_t rhs) const
+	RValue<Long> Long::operator=(int64_t rhs)
 	{
 		return RValue<Long>(storeValue(Nucleus::createConstantLong(rhs)));
 	}
 
-	RValue<Long> Long::operator=(RValue<Long> rhs) const
+	RValue<Long> Long::operator=(RValue<Long> rhs)
 	{
 		storeValue(rhs.value);
 
 		return rhs;
 	}
 
-	RValue<Long> Long::operator=(const Long &rhs) const
+	RValue<Long> Long::operator=(const Long &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -4048,7 +4048,7 @@
 		return RValue<Long>(value);
 	}
 
-	RValue<Long> Long::operator=(const Reference<Long> &rhs) const
+	RValue<Long> Long::operator=(const Reference<Long> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -4066,12 +4066,12 @@
 		return RValue<Long>(Nucleus::createSub(lhs.value, rhs.value));
 	}
 
-	RValue<Long> operator+=(const Long &lhs, RValue<Long> rhs)
+	RValue<Long> operator+=(Long &lhs, RValue<Long> rhs)
 	{
 		return lhs = lhs + rhs;
 	}
 
-	RValue<Long> operator-=(const Long &lhs, RValue<Long> rhs)
+	RValue<Long> operator-=(Long &lhs, RValue<Long> rhs)
 	{
 		return lhs = lhs - rhs;
 	}
@@ -4197,26 +4197,26 @@
 		storeValue(value);
 	}
 
-	RValue<UInt> UInt::operator=(unsigned int rhs) const
+	RValue<UInt> UInt::operator=(unsigned int rhs)
 	{
 		return RValue<UInt>(storeValue(Nucleus::createConstantInt(rhs)));
 	}
 
-	RValue<UInt> UInt::operator=(RValue<UInt> rhs) const
+	RValue<UInt> UInt::operator=(RValue<UInt> rhs)
 	{
 		storeValue(rhs.value);
 
 		return rhs;
 	}
 
-	RValue<UInt> UInt::operator=(RValue<Int> rhs) const
+	RValue<UInt> UInt::operator=(RValue<Int> rhs)
 	{
 		storeValue(rhs.value);
 
 		return RValue<UInt>(rhs);
 	}
 
-	RValue<UInt> UInt::operator=(const UInt &rhs) const
+	RValue<UInt> UInt::operator=(const UInt &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -4224,7 +4224,7 @@
 		return RValue<UInt>(value);
 	}
 
-	RValue<UInt> UInt::operator=(const Reference<UInt> &rhs) const
+	RValue<UInt> UInt::operator=(const Reference<UInt> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -4232,7 +4232,7 @@
 		return RValue<UInt>(value);
 	}
 
-	RValue<UInt> UInt::operator=(const Int &rhs) const
+	RValue<UInt> UInt::operator=(const Int &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -4240,7 +4240,7 @@
 		return RValue<UInt>(value);
 	}
 
-	RValue<UInt> UInt::operator=(const Reference<Int> &rhs) const
+	RValue<UInt> UInt::operator=(const Reference<Int> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -4298,52 +4298,52 @@
 		return RValue<UInt>(Nucleus::createLShr(lhs.value, rhs.value));
 	}
 
-	RValue<UInt> operator+=(const UInt &lhs, RValue<UInt> rhs)
+	RValue<UInt> operator+=(UInt &lhs, RValue<UInt> rhs)
 	{
 		return lhs = lhs + rhs;
 	}
 
-	RValue<UInt> operator-=(const UInt &lhs, RValue<UInt> rhs)
+	RValue<UInt> operator-=(UInt &lhs, RValue<UInt> rhs)
 	{
 		return lhs = lhs - rhs;
 	}
 
-	RValue<UInt> operator*=(const UInt &lhs, RValue<UInt> rhs)
+	RValue<UInt> operator*=(UInt &lhs, RValue<UInt> rhs)
 	{
 		return lhs = lhs * rhs;
 	}
 
-	RValue<UInt> operator/=(const UInt &lhs, RValue<UInt> rhs)
+	RValue<UInt> operator/=(UInt &lhs, RValue<UInt> rhs)
 	{
 		return lhs = lhs / rhs;
 	}
 
-	RValue<UInt> operator%=(const UInt &lhs, RValue<UInt> rhs)
+	RValue<UInt> operator%=(UInt &lhs, RValue<UInt> rhs)
 	{
 		return lhs = lhs % rhs;
 	}
 
-	RValue<UInt> operator&=(const UInt &lhs, RValue<UInt> rhs)
+	RValue<UInt> operator&=(UInt &lhs, RValue<UInt> rhs)
 	{
 		return lhs = lhs & rhs;
 	}
 
-	RValue<UInt> operator|=(const UInt &lhs, RValue<UInt> rhs)
+	RValue<UInt> operator|=(UInt &lhs, RValue<UInt> rhs)
 	{
 		return lhs = lhs | rhs;
 	}
 
-	RValue<UInt> operator^=(const UInt &lhs, RValue<UInt> rhs)
+	RValue<UInt> operator^=(UInt &lhs, RValue<UInt> rhs)
 	{
 		return lhs = lhs ^ rhs;
 	}
 
-	RValue<UInt> operator<<=(const UInt &lhs, RValue<UInt> rhs)
+	RValue<UInt> operator<<=(UInt &lhs, RValue<UInt> rhs)
 	{
 		return lhs = lhs << rhs;
 	}
 
-	RValue<UInt> operator>>=(const UInt &lhs, RValue<UInt> rhs)
+	RValue<UInt> operator>>=(UInt &lhs, RValue<UInt> rhs)
 	{
 		return lhs = lhs >> rhs;
 	}
@@ -4363,7 +4363,7 @@
 		return RValue<UInt>(Nucleus::createNot(val.value));
 	}
 
-	RValue<UInt> operator++(const UInt &val, int)   // Post-increment
+	RValue<UInt> operator++(UInt &val, int)   // Post-increment
 	{
 		RValue<UInt> res = val;
 
@@ -4373,7 +4373,7 @@
 		return res;
 	}
 
-	const UInt &operator++(const UInt &val)   // Pre-increment
+	const UInt &operator++(UInt &val)   // Pre-increment
 	{
 		Value *inc = Nucleus::createAdd(val.loadValue(), V(Nucleus::createConstantInt(1)));
 		val.storeValue(inc);
@@ -4381,7 +4381,7 @@
 		return val;
 	}
 
-	RValue<UInt> operator--(const UInt &val, int)   // Post-decrement
+	RValue<UInt> operator--(UInt &val, int)   // Post-decrement
 	{
 		RValue<UInt> res = val;
 
@@ -4391,7 +4391,7 @@
 		return res;
 	}
 
-	const UInt &operator--(const UInt &val)   // Pre-decrement
+	const UInt &operator--(UInt &val)   // Pre-decrement
 	{
 		Value *inc = Nucleus::createSub(val.loadValue(), V(Nucleus::createConstantInt(1)));
 		val.storeValue(inc);
@@ -4532,14 +4532,14 @@
 		}
 	}
 
-	RValue<Int2> Int2::operator=(RValue<Int2> rhs) const
+	RValue<Int2> Int2::operator=(RValue<Int2> rhs)
 	{
 		storeValue(rhs.value);
 
 		return rhs;
 	}
 
-	RValue<Int2> Int2::operator=(const Int2 &rhs) const
+	RValue<Int2> Int2::operator=(const Int2 &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -4547,7 +4547,7 @@
 		return RValue<Int2>(value);
 	}
 
-	RValue<Int2> Int2::operator=(const Reference<Int2> &rhs) const
+	RValue<Int2> Int2::operator=(const Reference<Int2> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -4658,62 +4658,62 @@
 		return x86::psrad(lhs, rhs);
 	}
 
-	RValue<Int2> operator+=(const Int2 &lhs, RValue<Int2> rhs)
+	RValue<Int2> operator+=(Int2 &lhs, RValue<Int2> rhs)
 	{
 		return lhs = lhs + rhs;
 	}
 
-	RValue<Int2> operator-=(const Int2 &lhs, RValue<Int2> rhs)
+	RValue<Int2> operator-=(Int2 &lhs, RValue<Int2> rhs)
 	{
 		return lhs = lhs - rhs;
 	}
 
-//	RValue<Int2> operator*=(const Int2 &lhs, RValue<Int2> rhs)
+//	RValue<Int2> operator*=(Int2 &lhs, RValue<Int2> rhs)
 //	{
 //		return lhs = lhs * rhs;
 //	}
 
-//	RValue<Int2> operator/=(const Int2 &lhs, RValue<Int2> rhs)
+//	RValue<Int2> operator/=(Int2 &lhs, RValue<Int2> rhs)
 //	{
 //		return lhs = lhs / rhs;
 //	}
 
-//	RValue<Int2> operator%=(const Int2 &lhs, RValue<Int2> rhs)
+//	RValue<Int2> operator%=(Int2 &lhs, RValue<Int2> rhs)
 //	{
 //		return lhs = lhs % rhs;
 //	}
 
-	RValue<Int2> operator&=(const Int2 &lhs, RValue<Int2> rhs)
+	RValue<Int2> operator&=(Int2 &lhs, RValue<Int2> rhs)
 	{
 		return lhs = lhs & rhs;
 	}
 
-	RValue<Int2> operator|=(const Int2 &lhs, RValue<Int2> rhs)
+	RValue<Int2> operator|=(Int2 &lhs, RValue<Int2> rhs)
 	{
 		return lhs = lhs | rhs;
 	}
 
-	RValue<Int2> operator^=(const Int2 &lhs, RValue<Int2> rhs)
+	RValue<Int2> operator^=(Int2 &lhs, RValue<Int2> rhs)
 	{
 		return lhs = lhs ^ rhs;
 	}
 
-	RValue<Int2> operator<<=(const Int2 &lhs, unsigned char rhs)
+	RValue<Int2> operator<<=(Int2 &lhs, unsigned char rhs)
 	{
 		return lhs = lhs << rhs;
 	}
 
-	RValue<Int2> operator>>=(const Int2 &lhs, unsigned char rhs)
+	RValue<Int2> operator>>=(Int2 &lhs, unsigned char rhs)
 	{
 		return lhs = lhs >> rhs;
 	}
 
-	RValue<Int2> operator<<=(const Int2 &lhs, RValue<Long1> rhs)
+	RValue<Int2> operator<<=(Int2 &lhs, RValue<Long1> rhs)
 	{
 		return lhs = lhs << rhs;
 	}
 
-	RValue<Int2> operator>>=(const Int2 &lhs, RValue<Long1> rhs)
+	RValue<Int2> operator>>=(Int2 &lhs, RValue<Long1> rhs)
 	{
 		return lhs = lhs >> rhs;
 	}
@@ -4846,14 +4846,14 @@
 		storeValue(value);
 	}
 
-	RValue<UInt2> UInt2::operator=(RValue<UInt2> rhs) const
+	RValue<UInt2> UInt2::operator=(RValue<UInt2> rhs)
 	{
 		storeValue(rhs.value);
 
 		return rhs;
 	}
 
-	RValue<UInt2> UInt2::operator=(const UInt2 &rhs) const
+	RValue<UInt2> UInt2::operator=(const UInt2 &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -4861,7 +4861,7 @@
 		return RValue<UInt2>(value);
 	}
 
-	RValue<UInt2> UInt2::operator=(const Reference<UInt2> &rhs) const
+	RValue<UInt2> UInt2::operator=(const Reference<UInt2> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -4972,62 +4972,62 @@
 		return x86::psrld(lhs, rhs);
 	}
 
-	RValue<UInt2> operator+=(const UInt2 &lhs, RValue<UInt2> rhs)
+	RValue<UInt2> operator+=(UInt2 &lhs, RValue<UInt2> rhs)
 	{
 		return lhs = lhs + rhs;
 	}
 
-	RValue<UInt2> operator-=(const UInt2 &lhs, RValue<UInt2> rhs)
+	RValue<UInt2> operator-=(UInt2 &lhs, RValue<UInt2> rhs)
 	{
 		return lhs = lhs - rhs;
 	}
 
-//	RValue<UInt2> operator*=(const UInt2 &lhs, RValue<UInt2> rhs)
+//	RValue<UInt2> operator*=(UInt2 &lhs, RValue<UInt2> rhs)
 //	{
 //		return lhs = lhs * rhs;
 //	}
 
-//	RValue<UInt2> operator/=(const UInt2 &lhs, RValue<UInt2> rhs)
+//	RValue<UInt2> operator/=(UInt2 &lhs, RValue<UInt2> rhs)
 //	{
 //		return lhs = lhs / rhs;
 //	}
 
-//	RValue<UInt2> operator%=(const UInt2 &lhs, RValue<UInt2> rhs)
+//	RValue<UInt2> operator%=(UInt2 &lhs, RValue<UInt2> rhs)
 //	{
 //		return lhs = lhs % rhs;
 //	}
 
-	RValue<UInt2> operator&=(const UInt2 &lhs, RValue<UInt2> rhs)
+	RValue<UInt2> operator&=(UInt2 &lhs, RValue<UInt2> rhs)
 	{
 		return lhs = lhs & rhs;
 	}
 
-	RValue<UInt2> operator|=(const UInt2 &lhs, RValue<UInt2> rhs)
+	RValue<UInt2> operator|=(UInt2 &lhs, RValue<UInt2> rhs)
 	{
 		return lhs = lhs | rhs;
 	}
 
-	RValue<UInt2> operator^=(const UInt2 &lhs, RValue<UInt2> rhs)
+	RValue<UInt2> operator^=(UInt2 &lhs, RValue<UInt2> rhs)
 	{
 		return lhs = lhs ^ rhs;
 	}
 
-	RValue<UInt2> operator<<=(const UInt2 &lhs, unsigned char rhs)
+	RValue<UInt2> operator<<=(UInt2 &lhs, unsigned char rhs)
 	{
 		return lhs = lhs << rhs;
 	}
 
-	RValue<UInt2> operator>>=(const UInt2 &lhs, unsigned char rhs)
+	RValue<UInt2> operator>>=(UInt2 &lhs, unsigned char rhs)
 	{
 		return lhs = lhs >> rhs;
 	}
 
-	RValue<UInt2> operator<<=(const UInt2 &lhs, RValue<Long1> rhs)
+	RValue<UInt2> operator<<=(UInt2 &lhs, RValue<Long1> rhs)
 	{
 		return lhs = lhs << rhs;
 	}
 
-	RValue<UInt2> operator>>=(const UInt2 &lhs, RValue<Long1> rhs)
+	RValue<UInt2> operator>>=(UInt2 &lhs, RValue<Long1> rhs)
 	{
 		return lhs = lhs >> rhs;
 	}
@@ -5301,14 +5301,14 @@
 		*this = RValue<Int>(rhs.loadValue());
 	}
 
-	RValue<Int4> Int4::operator=(RValue<Int4> rhs) const
+	RValue<Int4> Int4::operator=(RValue<Int4> rhs)
 	{
 		storeValue(rhs.value);
 
 		return rhs;
 	}
 
-	RValue<Int4> Int4::operator=(const Int4 &rhs) const
+	RValue<Int4> Int4::operator=(const Int4 &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -5316,7 +5316,7 @@
 		return RValue<Int4>(value);
 	}
 
-	RValue<Int4> Int4::operator=(const Reference<Int4> &rhs) const
+	RValue<Int4> Int4::operator=(const Reference<Int4> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -5384,52 +5384,52 @@
 		return RValue<Int4>(Nucleus::createAShr(lhs.value, rhs.value));
 	}
 
-	RValue<Int4> operator+=(const Int4 &lhs, RValue<Int4> rhs)
+	RValue<Int4> operator+=(Int4 &lhs, RValue<Int4> rhs)
 	{
 		return lhs = lhs + rhs;
 	}
 
-	RValue<Int4> operator-=(const Int4 &lhs, RValue<Int4> rhs)
+	RValue<Int4> operator-=(Int4 &lhs, RValue<Int4> rhs)
 	{
 		return lhs = lhs - rhs;
 	}
 
-	RValue<Int4> operator*=(const Int4 &lhs, RValue<Int4> rhs)
+	RValue<Int4> operator*=(Int4 &lhs, RValue<Int4> rhs)
 	{
 		return lhs = lhs * rhs;
 	}
 
-//	RValue<Int4> operator/=(const Int4 &lhs, RValue<Int4> rhs)
+//	RValue<Int4> operator/=(Int4 &lhs, RValue<Int4> rhs)
 //	{
 //		return lhs = lhs / rhs;
 //	}
 
-//	RValue<Int4> operator%=(const Int4 &lhs, RValue<Int4> rhs)
+//	RValue<Int4> operator%=(Int4 &lhs, RValue<Int4> rhs)
 //	{
 //		return lhs = lhs % rhs;
 //	}
 
-	RValue<Int4> operator&=(const Int4 &lhs, RValue<Int4> rhs)
+	RValue<Int4> operator&=(Int4 &lhs, RValue<Int4> rhs)
 	{
 		return lhs = lhs & rhs;
 	}
 
-	RValue<Int4> operator|=(const Int4 &lhs, RValue<Int4> rhs)
+	RValue<Int4> operator|=(Int4 &lhs, RValue<Int4> rhs)
 	{
 		return lhs = lhs | rhs;
 	}
 
-	RValue<Int4> operator^=(const Int4 &lhs, RValue<Int4> rhs)
+	RValue<Int4> operator^=(Int4 &lhs, RValue<Int4> rhs)
 	{
 		return lhs = lhs ^ rhs;
 	}
 
-	RValue<Int4> operator<<=(const Int4 &lhs, unsigned char rhs)
+	RValue<Int4> operator<<=(Int4 &lhs, unsigned char rhs)
 	{
 		return lhs = lhs << rhs;
 	}
 
-	RValue<Int4> operator>>=(const Int4 &lhs, unsigned char rhs)
+	RValue<Int4> operator>>=(Int4 &lhs, unsigned char rhs)
 	{
 		return lhs = lhs >> rhs;
 	}
@@ -5662,14 +5662,14 @@
 		storeValue(uint4);
 	}
 
-	RValue<UInt4> UInt4::operator=(RValue<UInt4> rhs) const
+	RValue<UInt4> UInt4::operator=(RValue<UInt4> rhs)
 	{
 		storeValue(rhs.value);
 
 		return rhs;
 	}
 
-	RValue<UInt4> UInt4::operator=(const UInt4 &rhs) const
+	RValue<UInt4> UInt4::operator=(const UInt4 &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -5677,7 +5677,7 @@
 		return RValue<UInt4>(value);
 	}
 
-	RValue<UInt4> UInt4::operator=(const Reference<UInt4> &rhs) const
+	RValue<UInt4> UInt4::operator=(const Reference<UInt4> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -5745,52 +5745,52 @@
 		return RValue<UInt4>(Nucleus::createLShr(lhs.value, rhs.value));
 	}
 
-	RValue<UInt4> operator+=(const UInt4 &lhs, RValue<UInt4> rhs)
+	RValue<UInt4> operator+=(UInt4 &lhs, RValue<UInt4> rhs)
 	{
 		return lhs = lhs + rhs;
 	}
 
-	RValue<UInt4> operator-=(const UInt4 &lhs, RValue<UInt4> rhs)
+	RValue<UInt4> operator-=(UInt4 &lhs, RValue<UInt4> rhs)
 	{
 		return lhs = lhs - rhs;
 	}
 
-	RValue<UInt4> operator*=(const UInt4 &lhs, RValue<UInt4> rhs)
+	RValue<UInt4> operator*=(UInt4 &lhs, RValue<UInt4> rhs)
 	{
 		return lhs = lhs * rhs;
 	}
 
-//	RValue<UInt4> operator/=(const UInt4 &lhs, RValue<UInt4> rhs)
+//	RValue<UInt4> operator/=(UInt4 &lhs, RValue<UInt4> rhs)
 //	{
 //		return lhs = lhs / rhs;
 //	}
 
-//	RValue<UInt4> operator%=(const UInt4 &lhs, RValue<UInt4> rhs)
+//	RValue<UInt4> operator%=(UInt4 &lhs, RValue<UInt4> rhs)
 //	{
 //		return lhs = lhs % rhs;
 //	}
 
-	RValue<UInt4> operator&=(const UInt4 &lhs, RValue<UInt4> rhs)
+	RValue<UInt4> operator&=(UInt4 &lhs, RValue<UInt4> rhs)
 	{
 		return lhs = lhs & rhs;
 	}
 
-	RValue<UInt4> operator|=(const UInt4 &lhs, RValue<UInt4> rhs)
+	RValue<UInt4> operator|=(UInt4 &lhs, RValue<UInt4> rhs)
 	{
 		return lhs = lhs | rhs;
 	}
 
-	RValue<UInt4> operator^=(const UInt4 &lhs, RValue<UInt4> rhs)
+	RValue<UInt4> operator^=(UInt4 &lhs, RValue<UInt4> rhs)
 	{
 		return lhs = lhs ^ rhs;
 	}
 
-	RValue<UInt4> operator<<=(const UInt4 &lhs, unsigned char rhs)
+	RValue<UInt4> operator<<=(UInt4 &lhs, unsigned char rhs)
 	{
 		return lhs = lhs << rhs;
 	}
 
-	RValue<UInt4> operator>>=(const UInt4 &lhs, unsigned char rhs)
+	RValue<UInt4> operator>>=(UInt4 &lhs, unsigned char rhs)
 	{
 		return lhs = lhs >> rhs;
 	}
@@ -5919,14 +5919,14 @@
 		storeValue(value);
 	}
 
-	RValue<Float> Float::operator=(RValue<Float> rhs) const
+	RValue<Float> Float::operator=(RValue<Float> rhs)
 	{
 		storeValue(rhs.value);
 
 		return rhs;
 	}
 
-	RValue<Float> Float::operator=(const Float &rhs) const
+	RValue<Float> Float::operator=(const Float &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -5934,7 +5934,7 @@
 		return RValue<Float>(value);
 	}
 
-	RValue<Float> Float::operator=(const Reference<Float> &rhs) const
+	RValue<Float> Float::operator=(const Reference<Float> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -5962,22 +5962,22 @@
 		return RValue<Float>(Nucleus::createFDiv(lhs.value, rhs.value));
 	}
 
-	RValue<Float> operator+=(const Float &lhs, RValue<Float> rhs)
+	RValue<Float> operator+=(Float &lhs, RValue<Float> rhs)
 	{
 		return lhs = lhs + rhs;
 	}
 
-	RValue<Float> operator-=(const Float &lhs, RValue<Float> rhs)
+	RValue<Float> operator-=(Float &lhs, RValue<Float> rhs)
 	{
 		return lhs = lhs - rhs;
 	}
 
-	RValue<Float> operator*=(const Float &lhs, RValue<Float> rhs)
+	RValue<Float> operator*=(Float &lhs, RValue<Float> rhs)
 	{
 		return lhs = lhs * rhs;
 	}
 
-	RValue<Float> operator/=(const Float &lhs, RValue<Float> rhs)
+	RValue<Float> operator/=(Float &lhs, RValue<Float> rhs)
 	{
 		return lhs = lhs / rhs;
 	}
@@ -6323,19 +6323,19 @@
 		*this = RValue<Float>(rhs.loadValue());
 	}
 
-	RValue<Float4> Float4::operator=(float x) const
+	RValue<Float4> Float4::operator=(float x)
 	{
 		return *this = Float4(x, x, x, x);
 	}
 
-	RValue<Float4> Float4::operator=(RValue<Float4> rhs) const
+	RValue<Float4> Float4::operator=(RValue<Float4> rhs)
 	{
 		storeValue(rhs.value);
 
 		return rhs;
 	}
 
-	RValue<Float4> Float4::operator=(const Float4 &rhs) const
+	RValue<Float4> Float4::operator=(const Float4 &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -6343,7 +6343,7 @@
 		return RValue<Float4>(value);
 	}
 
-	RValue<Float4> Float4::operator=(const Reference<Float4> &rhs) const
+	RValue<Float4> Float4::operator=(const Reference<Float4> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -6351,17 +6351,17 @@
 		return RValue<Float4>(value);
 	}
 
-	RValue<Float4> Float4::operator=(RValue<Float> rhs) const
+	RValue<Float4> Float4::operator=(RValue<Float> rhs)
 	{
 		return *this = Float4(rhs);
 	}
 
-	RValue<Float4> Float4::operator=(const Float &rhs) const
+	RValue<Float4> Float4::operator=(const Float &rhs)
 	{
 		return *this = Float4(rhs);
 	}
 
-	RValue<Float4> Float4::operator=(const Reference<Float> &rhs) const
+	RValue<Float4> Float4::operator=(const Reference<Float> &rhs)
 	{
 		return *this = Float4(rhs);
 	}
@@ -6391,27 +6391,27 @@
 		return RValue<Float4>(Nucleus::createFRem(lhs.value, rhs.value));
 	}
 
-	RValue<Float4> operator+=(const Float4 &lhs, RValue<Float4> rhs)
+	RValue<Float4> operator+=(Float4 &lhs, RValue<Float4> rhs)
 	{
 		return lhs = lhs + rhs;
 	}
 
-	RValue<Float4> operator-=(const Float4 &lhs, RValue<Float4> rhs)
+	RValue<Float4> operator-=(Float4 &lhs, RValue<Float4> rhs)
 	{
 		return lhs = lhs - rhs;
 	}
 
-	RValue<Float4> operator*=(const Float4 &lhs, RValue<Float4> rhs)
+	RValue<Float4> operator*=(Float4 &lhs, RValue<Float4> rhs)
 	{
 		return lhs = lhs * rhs;
 	}
 
-	RValue<Float4> operator/=(const Float4 &lhs, RValue<Float4> rhs)
+	RValue<Float4> operator/=(Float4 &lhs, RValue<Float4> rhs)
 	{
 		return lhs = lhs / rhs;
 	}
 
-	RValue<Float4> operator%=(const Float4 &lhs, RValue<Float4> rhs)
+	RValue<Float4> operator%=(Float4 &lhs, RValue<Float4> rhs)
 	{
 		return lhs = lhs % rhs;
 	}
@@ -6641,17 +6641,17 @@
 		return RValue<Pointer<Byte>>(Nucleus::createGEP(lhs.value, Byte::getType(), offset.value));
 	}
 
-	RValue<Pointer<Byte>> operator+=(const Pointer<Byte> &lhs, int offset)
+	RValue<Pointer<Byte>> operator+=(Pointer<Byte> &lhs, int offset)
 	{
 		return lhs = lhs + offset;
 	}
 
-	RValue<Pointer<Byte>> operator+=(const Pointer<Byte> &lhs, RValue<Int> offset)
+	RValue<Pointer<Byte>> operator+=(Pointer<Byte> &lhs, RValue<Int> offset)
 	{
 		return lhs = lhs + offset;
 	}
 
-	RValue<Pointer<Byte>> operator+=(const Pointer<Byte> &lhs, RValue<UInt> offset)
+	RValue<Pointer<Byte>> operator+=(Pointer<Byte> &lhs, RValue<UInt> offset)
 	{
 		return lhs = lhs + offset;
 	}
@@ -6671,17 +6671,17 @@
 		return lhs + -offset;
 	}
 
-	RValue<Pointer<Byte>> operator-=(const Pointer<Byte> &lhs, int offset)
+	RValue<Pointer<Byte>> operator-=(Pointer<Byte> &lhs, int offset)
 	{
 		return lhs = lhs - offset;
 	}
 
-	RValue<Pointer<Byte>> operator-=(const Pointer<Byte> &lhs, RValue<Int> offset)
+	RValue<Pointer<Byte>> operator-=(Pointer<Byte> &lhs, RValue<Int> offset)
 	{
 		return lhs = lhs - offset;
 	}
 
-	RValue<Pointer<Byte>> operator-=(const Pointer<Byte> &lhs, RValue<UInt> offset)
+	RValue<Pointer<Byte>> operator-=(Pointer<Byte> &lhs, RValue<UInt> offset)
 	{
 		return lhs = lhs - offset;
 	}
diff --git a/src/Reactor/Reactor.hpp b/src/Reactor/Reactor.hpp
index 1e99bb8..812a748 100644
--- a/src/Reactor/Reactor.hpp
+++ b/src/Reactor/Reactor.hpp
@@ -184,10 +184,10 @@
 		Bool(const Bool &rhs);
 		Bool(const Reference<Bool> &rhs);
 
-	//	RValue<Bool> operator=(bool rhs) const;   // FIXME: Implement
-		RValue<Bool> operator=(RValue<Bool> rhs) const;
-		RValue<Bool> operator=(const Bool &rhs) const;
-		RValue<Bool> operator=(const Reference<Bool> &rhs) const;
+	//	RValue<Bool> operator=(bool rhs);   // FIXME: Implement
+		RValue<Bool> operator=(RValue<Bool> rhs);
+		RValue<Bool> operator=(const Bool &rhs);
+		RValue<Bool> operator=(const Reference<Bool> &rhs);
 
 		static Type *getType();
 	};
@@ -212,10 +212,10 @@
 		Byte(const Byte &rhs);
 		Byte(const Reference<Byte> &rhs);
 
-	//	RValue<Byte> operator=(unsigned char rhs) const;   // FIXME: Implement
-		RValue<Byte> operator=(RValue<Byte> rhs) const;
-		RValue<Byte> operator=(const Byte &rhs) const;
-		RValue<Byte> operator=(const Reference<Byte> &rhs) const;
+	//	RValue<Byte> operator=(unsigned char rhs);   // FIXME: Implement
+		RValue<Byte> operator=(RValue<Byte> rhs);
+		RValue<Byte> operator=(const Byte &rhs);
+		RValue<Byte> operator=(const Reference<Byte> &rhs);
 
 		static Type *getType();
 	};
@@ -230,23 +230,23 @@
 	RValue<Byte> operator^(RValue<Byte> lhs, RValue<Byte> rhs);
 	RValue<Byte> operator<<(RValue<Byte> lhs, RValue<Byte> rhs);
 	RValue<Byte> operator>>(RValue<Byte> lhs, RValue<Byte> rhs);
-	RValue<Byte> operator+=(const Byte &lhs, RValue<Byte> rhs);
-	RValue<Byte> operator-=(const Byte &lhs, RValue<Byte> rhs);
-	RValue<Byte> operator*=(const Byte &lhs, RValue<Byte> rhs);
-	RValue<Byte> operator/=(const Byte &lhs, RValue<Byte> rhs);
-	RValue<Byte> operator%=(const Byte &lhs, RValue<Byte> rhs);
-	RValue<Byte> operator&=(const Byte &lhs, RValue<Byte> rhs);
-	RValue<Byte> operator|=(const Byte &lhs, RValue<Byte> rhs);
-	RValue<Byte> operator^=(const Byte &lhs, RValue<Byte> rhs);
-	RValue<Byte> operator<<=(const Byte &lhs, RValue<Byte> rhs);
-	RValue<Byte> operator>>=(const Byte &lhs, RValue<Byte> rhs);
+	RValue<Byte> operator+=(Byte &lhs, RValue<Byte> rhs);
+	RValue<Byte> operator-=(Byte &lhs, RValue<Byte> rhs);
+	RValue<Byte> operator*=(Byte &lhs, RValue<Byte> rhs);
+	RValue<Byte> operator/=(Byte &lhs, RValue<Byte> rhs);
+	RValue<Byte> operator%=(Byte &lhs, RValue<Byte> rhs);
+	RValue<Byte> operator&=(Byte &lhs, RValue<Byte> rhs);
+	RValue<Byte> operator|=(Byte &lhs, RValue<Byte> rhs);
+	RValue<Byte> operator^=(Byte &lhs, RValue<Byte> rhs);
+	RValue<Byte> operator<<=(Byte &lhs, RValue<Byte> rhs);
+	RValue<Byte> operator>>=(Byte &lhs, RValue<Byte> rhs);
 	RValue<Byte> operator+(RValue<Byte> val);
 	RValue<Byte> operator-(RValue<Byte> val);
 	RValue<Byte> operator~(RValue<Byte> val);
-	RValue<Byte> operator++(const Byte &val, int);   // Post-increment
-	const Byte &operator++(const Byte &val);   // Pre-increment
-	RValue<Byte> operator--(const Byte &val, int);   // Post-decrement
-	const Byte &operator--(const Byte &val);   // Pre-decrement
+	RValue<Byte> operator++(Byte &val, int);   // Post-increment
+	const Byte &operator++(Byte &val);   // Pre-increment
+	RValue<Byte> operator--(Byte &val, int);   // Post-decrement
+	const Byte &operator--(Byte &val);   // Pre-decrement
 	RValue<Bool> operator<(RValue<Byte> lhs, RValue<Byte> rhs);
 	RValue<Bool> operator<=(RValue<Byte> lhs, RValue<Byte> rhs);
 	RValue<Bool> operator>(RValue<Byte> lhs, RValue<Byte> rhs);
@@ -268,10 +268,10 @@
 		SByte(const SByte &rhs);
 		SByte(const Reference<SByte> &rhs);
 
-	//	RValue<SByte> operator=(signed char rhs) const;   // FIXME: Implement
-		RValue<SByte> operator=(RValue<SByte> rhs) const;
-		RValue<SByte> operator=(const SByte &rhs) const;
-		RValue<SByte> operator=(const Reference<SByte> &rhs) const;
+	//	RValue<SByte> operator=(signed char rhs);   // FIXME: Implement
+		RValue<SByte> operator=(RValue<SByte> rhs);
+		RValue<SByte> operator=(const SByte &rhs);
+		RValue<SByte> operator=(const Reference<SByte> &rhs);
 
 		static Type *getType();
 	};
@@ -286,23 +286,23 @@
 	RValue<SByte> operator^(RValue<SByte> lhs, RValue<SByte> rhs);
 	RValue<SByte> operator<<(RValue<SByte> lhs, RValue<SByte> rhs);
 	RValue<SByte> operator>>(RValue<SByte> lhs, RValue<SByte> rhs);
-	RValue<SByte> operator+=(const SByte &lhs, RValue<SByte> rhs);
-	RValue<SByte> operator-=(const SByte &lhs, RValue<SByte> rhs);
-	RValue<SByte> operator*=(const SByte &lhs, RValue<SByte> rhs);
-	RValue<SByte> operator/=(const SByte &lhs, RValue<SByte> rhs);
-	RValue<SByte> operator%=(const SByte &lhs, RValue<SByte> rhs);
-	RValue<SByte> operator&=(const SByte &lhs, RValue<SByte> rhs);
-	RValue<SByte> operator|=(const SByte &lhs, RValue<SByte> rhs);
-	RValue<SByte> operator^=(const SByte &lhs, RValue<SByte> rhs);
-	RValue<SByte> operator<<=(const SByte &lhs, RValue<SByte> rhs);
-	RValue<SByte> operator>>=(const SByte &lhs, RValue<SByte> rhs);
+	RValue<SByte> operator+=(SByte &lhs, RValue<SByte> rhs);
+	RValue<SByte> operator-=(SByte &lhs, RValue<SByte> rhs);
+	RValue<SByte> operator*=(SByte &lhs, RValue<SByte> rhs);
+	RValue<SByte> operator/=(SByte &lhs, RValue<SByte> rhs);
+	RValue<SByte> operator%=(SByte &lhs, RValue<SByte> rhs);
+	RValue<SByte> operator&=(SByte &lhs, RValue<SByte> rhs);
+	RValue<SByte> operator|=(SByte &lhs, RValue<SByte> rhs);
+	RValue<SByte> operator^=(SByte &lhs, RValue<SByte> rhs);
+	RValue<SByte> operator<<=(SByte &lhs, RValue<SByte> rhs);
+	RValue<SByte> operator>>=(SByte &lhs, RValue<SByte> rhs);
 	RValue<SByte> operator+(RValue<SByte> val);
 	RValue<SByte> operator-(RValue<SByte> val);
 	RValue<SByte> operator~(RValue<SByte> val);
-	RValue<SByte> operator++(const SByte &val, int);   // Post-increment
-	const SByte &operator++(const SByte &val);   // Pre-increment
-	RValue<SByte> operator--(const SByte &val, int);   // Post-decrement
-	const SByte &operator--(const SByte &val);   // Pre-decrement
+	RValue<SByte> operator++(SByte &val, int);   // Post-increment
+	const SByte &operator++(SByte &val);   // Pre-increment
+	RValue<SByte> operator--(SByte &val, int);   // Post-decrement
+	const SByte &operator--(SByte &val);   // Pre-decrement
 	RValue<Bool> operator<(RValue<SByte> lhs, RValue<SByte> rhs);
 	RValue<Bool> operator<=(RValue<SByte> lhs, RValue<SByte> rhs);
 	RValue<Bool> operator>(RValue<SByte> lhs, RValue<SByte> rhs);
@@ -323,10 +323,10 @@
 		Short(const Short &rhs);
 		Short(const Reference<Short> &rhs);
 
-	//	RValue<Short> operator=(short rhs) const;   // FIXME: Implement
-		RValue<Short> operator=(RValue<Short> rhs) const;
-		RValue<Short> operator=(const Short &rhs) const;
-		RValue<Short> operator=(const Reference<Short> &rhs) const;
+	//	RValue<Short> operator=(short rhs);   // FIXME: Implement
+		RValue<Short> operator=(RValue<Short> rhs);
+		RValue<Short> operator=(const Short &rhs);
+		RValue<Short> operator=(const Reference<Short> &rhs);
 
 		static Type *getType();
 	};
@@ -341,23 +341,23 @@
 	RValue<Short> operator^(RValue<Short> lhs, RValue<Short> rhs);
 	RValue<Short> operator<<(RValue<Short> lhs, RValue<Short> rhs);
 	RValue<Short> operator>>(RValue<Short> lhs, RValue<Short> rhs);
-	RValue<Short> operator+=(const Short &lhs, RValue<Short> rhs);
-	RValue<Short> operator-=(const Short &lhs, RValue<Short> rhs);
-	RValue<Short> operator*=(const Short &lhs, RValue<Short> rhs);
-	RValue<Short> operator/=(const Short &lhs, RValue<Short> rhs);
-	RValue<Short> operator%=(const Short &lhs, RValue<Short> rhs);
-	RValue<Short> operator&=(const Short &lhs, RValue<Short> rhs);
-	RValue<Short> operator|=(const Short &lhs, RValue<Short> rhs);
-	RValue<Short> operator^=(const Short &lhs, RValue<Short> rhs);
-	RValue<Short> operator<<=(const Short &lhs, RValue<Short> rhs);
-	RValue<Short> operator>>=(const Short &lhs, RValue<Short> rhs);
+	RValue<Short> operator+=(Short &lhs, RValue<Short> rhs);
+	RValue<Short> operator-=(Short &lhs, RValue<Short> rhs);
+	RValue<Short> operator*=(Short &lhs, RValue<Short> rhs);
+	RValue<Short> operator/=(Short &lhs, RValue<Short> rhs);
+	RValue<Short> operator%=(Short &lhs, RValue<Short> rhs);
+	RValue<Short> operator&=(Short &lhs, RValue<Short> rhs);
+	RValue<Short> operator|=(Short &lhs, RValue<Short> rhs);
+	RValue<Short> operator^=(Short &lhs, RValue<Short> rhs);
+	RValue<Short> operator<<=(Short &lhs, RValue<Short> rhs);
+	RValue<Short> operator>>=(Short &lhs, RValue<Short> rhs);
 	RValue<Short> operator+(RValue<Short> val);
 	RValue<Short> operator-(RValue<Short> val);
 	RValue<Short> operator~(RValue<Short> val);
-	RValue<Short> operator++(const Short &val, int);   // Post-increment
-	const Short &operator++(const Short &val);   // Pre-increment
-	RValue<Short> operator--(const Short &val, int);   // Post-decrement
-	const Short &operator--(const Short &val);   // Pre-decrement
+	RValue<Short> operator++(Short &val, int);   // Post-increment
+	const Short &operator++(Short &val);   // Pre-increment
+	RValue<Short> operator--(Short &val, int);   // Post-decrement
+	const Short &operator--(Short &val);   // Pre-decrement
 	RValue<Bool> operator<(RValue<Short> lhs, RValue<Short> rhs);
 	RValue<Bool> operator<=(RValue<Short> lhs, RValue<Short> rhs);
 	RValue<Bool> operator>(RValue<Short> lhs, RValue<Short> rhs);
@@ -379,10 +379,10 @@
 		UShort(const UShort &rhs);
 		UShort(const Reference<UShort> &rhs);
 
-	//	RValue<UShort> operator=(unsigned short rhs) const;   // FIXME: Implement
-		RValue<UShort> operator=(RValue<UShort> rhs) const;
-		RValue<UShort> operator=(const UShort &rhs) const;
-		RValue<UShort> operator=(const Reference<UShort> &rhs) const;
+	//	RValue<UShort> operator=(unsigned short rhs);   // FIXME: Implement
+		RValue<UShort> operator=(RValue<UShort> rhs);
+		RValue<UShort> operator=(const UShort &rhs);
+		RValue<UShort> operator=(const Reference<UShort> &rhs);
 
 		static Type *getType();
 	};
@@ -397,23 +397,23 @@
 	RValue<UShort> operator^(RValue<UShort> lhs, RValue<UShort> rhs);
 	RValue<UShort> operator<<(RValue<UShort> lhs, RValue<UShort> rhs);
 	RValue<UShort> operator>>(RValue<UShort> lhs, RValue<UShort> rhs);
-	RValue<UShort> operator+=(const UShort &lhs, RValue<UShort> rhs);
-	RValue<UShort> operator-=(const UShort &lhs, RValue<UShort> rhs);
-	RValue<UShort> operator*=(const UShort &lhs, RValue<UShort> rhs);
-	RValue<UShort> operator/=(const UShort &lhs, RValue<UShort> rhs);
-	RValue<UShort> operator%=(const UShort &lhs, RValue<UShort> rhs);
-	RValue<UShort> operator&=(const UShort &lhs, RValue<UShort> rhs);
-	RValue<UShort> operator|=(const UShort &lhs, RValue<UShort> rhs);
-	RValue<UShort> operator^=(const UShort &lhs, RValue<UShort> rhs);
-	RValue<UShort> operator<<=(const UShort &lhs, RValue<UShort> rhs);
-	RValue<UShort> operator>>=(const UShort &lhs, RValue<UShort> rhs);
+	RValue<UShort> operator+=(UShort &lhs, RValue<UShort> rhs);
+	RValue<UShort> operator-=(UShort &lhs, RValue<UShort> rhs);
+	RValue<UShort> operator*=(UShort &lhs, RValue<UShort> rhs);
+	RValue<UShort> operator/=(UShort &lhs, RValue<UShort> rhs);
+	RValue<UShort> operator%=(UShort &lhs, RValue<UShort> rhs);
+	RValue<UShort> operator&=(UShort &lhs, RValue<UShort> rhs);
+	RValue<UShort> operator|=(UShort &lhs, RValue<UShort> rhs);
+	RValue<UShort> operator^=(UShort &lhs, RValue<UShort> rhs);
+	RValue<UShort> operator<<=(UShort &lhs, RValue<UShort> rhs);
+	RValue<UShort> operator>>=(UShort &lhs, RValue<UShort> rhs);
 	RValue<UShort> operator+(RValue<UShort> val);
 	RValue<UShort> operator-(RValue<UShort> val);
 	RValue<UShort> operator~(RValue<UShort> val);
-	RValue<UShort> operator++(const UShort &val, int);   // Post-increment
-	const UShort &operator++(const UShort &val);   // Pre-increment
-	RValue<UShort> operator--(const UShort &val, int);   // Post-decrement
-	const UShort &operator--(const UShort &val);   // Pre-decrement
+	RValue<UShort> operator++(UShort &val, int);   // Post-increment
+	const UShort &operator++(UShort &val);   // Pre-increment
+	RValue<UShort> operator--(UShort &val, int);   // Post-decrement
+	const UShort &operator--(UShort &val);   // Pre-decrement
 	RValue<Bool> operator<(RValue<UShort> lhs, RValue<UShort> rhs);
 	RValue<Bool> operator<=(RValue<UShort> lhs, RValue<UShort> rhs);
 	RValue<Bool> operator>(RValue<UShort> lhs, RValue<UShort> rhs);
@@ -432,9 +432,9 @@
 	//	Byte4(const Byte4 &rhs);
 		Byte4(const Reference<Byte4> &rhs);
 
-	//	RValue<Byte4> operator=(RValue<Byte4> rhs) const;
-	//	RValue<Byte4> operator=(const Byte4 &rhs) const;
-	//	RValue<Byte4> operator=(const Reference<Byte4> &rhs) const;
+	//	RValue<Byte4> operator=(RValue<Byte4> rhs);
+	//	RValue<Byte4> operator=(const Byte4 &rhs);
+	//	RValue<Byte4> operator=(const Reference<Byte4> &rhs);
 
 		static Type *getType();
 	};
@@ -449,23 +449,23 @@
 //	RValue<Byte4> operator^(RValue<Byte4> lhs, RValue<Byte4> rhs);
 //	RValue<Byte4> operator<<(RValue<Byte4> lhs, RValue<Byte4> rhs);
 //	RValue<Byte4> operator>>(RValue<Byte4> lhs, RValue<Byte4> rhs);
-//	RValue<Byte4> operator+=(const Byte4 &lhs, RValue<Byte4> rhs);
-//	RValue<Byte4> operator-=(const Byte4 &lhs, RValue<Byte4> rhs);
-//	RValue<Byte4> operator*=(const Byte4 &lhs, RValue<Byte4> rhs);
-//	RValue<Byte4> operator/=(const Byte4 &lhs, RValue<Byte4> rhs);
-//	RValue<Byte4> operator%=(const Byte4 &lhs, RValue<Byte4> rhs);
-//	RValue<Byte4> operator&=(const Byte4 &lhs, RValue<Byte4> rhs);
-//	RValue<Byte4> operator|=(const Byte4 &lhs, RValue<Byte4> rhs);
-//	RValue<Byte4> operator^=(const Byte4 &lhs, RValue<Byte4> rhs);
-//	RValue<Byte4> operator<<=(const Byte4 &lhs, RValue<Byte4> rhs);
-//	RValue<Byte4> operator>>=(const Byte4 &lhs, RValue<Byte4> rhs);
+//	RValue<Byte4> operator+=(Byte4 &lhs, RValue<Byte4> rhs);
+//	RValue<Byte4> operator-=(Byte4 &lhs, RValue<Byte4> rhs);
+//	RValue<Byte4> operator*=(Byte4 &lhs, RValue<Byte4> rhs);
+//	RValue<Byte4> operator/=(Byte4 &lhs, RValue<Byte4> rhs);
+//	RValue<Byte4> operator%=(Byte4 &lhs, RValue<Byte4> rhs);
+//	RValue<Byte4> operator&=(Byte4 &lhs, RValue<Byte4> rhs);
+//	RValue<Byte4> operator|=(Byte4 &lhs, RValue<Byte4> rhs);
+//	RValue<Byte4> operator^=(Byte4 &lhs, RValue<Byte4> rhs);
+//	RValue<Byte4> operator<<=(Byte4 &lhs, RValue<Byte4> rhs);
+//	RValue<Byte4> operator>>=(Byte4 &lhs, RValue<Byte4> rhs);
 //	RValue<Byte4> operator+(RValue<Byte4> val);
 //	RValue<Byte4> operator-(RValue<Byte4> val);
 //	RValue<Byte4> operator~(RValue<Byte4> val);
-//	RValue<Byte4> operator++(const Byte4 &val, int);   // Post-increment
-//	const Byte4 &operator++(const Byte4 &val);   // Pre-increment
-//	RValue<Byte4> operator--(const Byte4 &val, int);   // Post-decrement
-//	const Byte4 &operator--(const Byte4 &val);   // Pre-decrement
+//	RValue<Byte4> operator++(Byte4 &val, int);   // Post-increment
+//	const Byte4 &operator++(Byte4 &val);   // Pre-increment
+//	RValue<Byte4> operator--(Byte4 &val, int);   // Post-decrement
+//	const Byte4 &operator--(Byte4 &val);   // Pre-decrement
 
 	class SByte4 : public LValue<SByte4>
 	{
@@ -476,9 +476,9 @@
 	//	SByte4(const SByte4 &rhs);
 	//	SByte4(const Reference<SByte4> &rhs);
 
-	//	RValue<SByte4> operator=(RValue<SByte4> rhs) const;
-	//	RValue<SByte4> operator=(const SByte4 &rhs) const;
-	//	RValue<SByte4> operator=(const Reference<SByte4> &rhs) const;
+	//	RValue<SByte4> operator=(RValue<SByte4> rhs);
+	//	RValue<SByte4> operator=(const SByte4 &rhs);
+	//	RValue<SByte4> operator=(const Reference<SByte4> &rhs);
 
 		static Type *getType();
 	};
@@ -493,23 +493,23 @@
 //	RValue<SByte4> operator^(RValue<SByte4> lhs, RValue<SByte4> rhs);
 //	RValue<SByte4> operator<<(RValue<SByte4> lhs, RValue<SByte4> rhs);
 //	RValue<SByte4> operator>>(RValue<SByte4> lhs, RValue<SByte4> rhs);
-//	RValue<SByte4> operator+=(const SByte4 &lhs, RValue<SByte4> rhs);
-//	RValue<SByte4> operator-=(const SByte4 &lhs, RValue<SByte4> rhs);
-//	RValue<SByte4> operator*=(const SByte4 &lhs, RValue<SByte4> rhs);
-//	RValue<SByte4> operator/=(const SByte4 &lhs, RValue<SByte4> rhs);
-//	RValue<SByte4> operator%=(const SByte4 &lhs, RValue<SByte4> rhs);
-//	RValue<SByte4> operator&=(const SByte4 &lhs, RValue<SByte4> rhs);
-//	RValue<SByte4> operator|=(const SByte4 &lhs, RValue<SByte4> rhs);
-//	RValue<SByte4> operator^=(const SByte4 &lhs, RValue<SByte4> rhs);
-//	RValue<SByte4> operator<<=(const SByte4 &lhs, RValue<SByte4> rhs);
-//	RValue<SByte4> operator>>=(const SByte4 &lhs, RValue<SByte4> rhs);
+//	RValue<SByte4> operator+=(SByte4 &lhs, RValue<SByte4> rhs);
+//	RValue<SByte4> operator-=(SByte4 &lhs, RValue<SByte4> rhs);
+//	RValue<SByte4> operator*=(SByte4 &lhs, RValue<SByte4> rhs);
+//	RValue<SByte4> operator/=(SByte4 &lhs, RValue<SByte4> rhs);
+//	RValue<SByte4> operator%=(SByte4 &lhs, RValue<SByte4> rhs);
+//	RValue<SByte4> operator&=(SByte4 &lhs, RValue<SByte4> rhs);
+//	RValue<SByte4> operator|=(SByte4 &lhs, RValue<SByte4> rhs);
+//	RValue<SByte4> operator^=(SByte4 &lhs, RValue<SByte4> rhs);
+//	RValue<SByte4> operator<<=(SByte4 &lhs, RValue<SByte4> rhs);
+//	RValue<SByte4> operator>>=(SByte4 &lhs, RValue<SByte4> rhs);
 //	RValue<SByte4> operator+(RValue<SByte4> val);
 //	RValue<SByte4> operator-(RValue<SByte4> val);
 //	RValue<SByte4> operator~(RValue<SByte4> val);
-//	RValue<SByte4> operator++(const SByte4 &val, int);   // Post-increment
-//	const SByte4 &operator++(const SByte4 &val);   // Pre-increment
-//	RValue<SByte4> operator--(const SByte4 &val, int);   // Post-decrement
-//	const SByte4 &operator--(const SByte4 &val);   // Pre-decrement
+//	RValue<SByte4> operator++(SByte4 &val, int);   // Post-increment
+//	const SByte4 &operator++(SByte4 &val);   // Pre-increment
+//	RValue<SByte4> operator--(SByte4 &val, int);   // Post-decrement
+//	const SByte4 &operator--(SByte4 &val);   // Pre-decrement
 
 	class Byte8 : public LValue<Byte8>
 	{
@@ -520,9 +520,9 @@
 		Byte8(const Byte8 &rhs);
 		Byte8(const Reference<Byte8> &rhs);
 
-		RValue<Byte8> operator=(RValue<Byte8> rhs) const;
-		RValue<Byte8> operator=(const Byte8 &rhs) const;
-		RValue<Byte8> operator=(const Reference<Byte8> &rhs) const;
+		RValue<Byte8> operator=(RValue<Byte8> rhs);
+		RValue<Byte8> operator=(const Byte8 &rhs);
+		RValue<Byte8> operator=(const Reference<Byte8> &rhs);
 
 		static Type *getType();
 	};
@@ -537,23 +537,23 @@
 	RValue<Byte8> operator^(RValue<Byte8> lhs, RValue<Byte8> rhs);
 //	RValue<Byte8> operator<<(RValue<Byte8> lhs, RValue<Byte8> rhs);
 //	RValue<Byte8> operator>>(RValue<Byte8> lhs, RValue<Byte8> rhs);
-	RValue<Byte8> operator+=(const Byte8 &lhs, RValue<Byte8> rhs);
-	RValue<Byte8> operator-=(const Byte8 &lhs, RValue<Byte8> rhs);
-//	RValue<Byte8> operator*=(const Byte8 &lhs, RValue<Byte8> rhs);
-//	RValue<Byte8> operator/=(const Byte8 &lhs, RValue<Byte8> rhs);
-//	RValue<Byte8> operator%=(const Byte8 &lhs, RValue<Byte8> rhs);
-	RValue<Byte8> operator&=(const Byte8 &lhs, RValue<Byte8> rhs);
-	RValue<Byte8> operator|=(const Byte8 &lhs, RValue<Byte8> rhs);
-	RValue<Byte8> operator^=(const Byte8 &lhs, RValue<Byte8> rhs);
-//	RValue<Byte8> operator<<=(const Byte8 &lhs, RValue<Byte8> rhs);
-//	RValue<Byte8> operator>>=(const Byte8 &lhs, RValue<Byte8> rhs);
+	RValue<Byte8> operator+=(Byte8 &lhs, RValue<Byte8> rhs);
+	RValue<Byte8> operator-=(Byte8 &lhs, RValue<Byte8> rhs);
+//	RValue<Byte8> operator*=(Byte8 &lhs, RValue<Byte8> rhs);
+//	RValue<Byte8> operator/=(Byte8 &lhs, RValue<Byte8> rhs);
+//	RValue<Byte8> operator%=(Byte8 &lhs, RValue<Byte8> rhs);
+	RValue<Byte8> operator&=(Byte8 &lhs, RValue<Byte8> rhs);
+	RValue<Byte8> operator|=(Byte8 &lhs, RValue<Byte8> rhs);
+	RValue<Byte8> operator^=(Byte8 &lhs, RValue<Byte8> rhs);
+//	RValue<Byte8> operator<<=(Byte8 &lhs, RValue<Byte8> rhs);
+//	RValue<Byte8> operator>>=(Byte8 &lhs, RValue<Byte8> rhs);
 //	RValue<Byte8> operator+(RValue<Byte8> val);
 //	RValue<Byte8> operator-(RValue<Byte8> val);
 	RValue<Byte8> operator~(RValue<Byte8> val);
-//	RValue<Byte8> operator++(const Byte8 &val, int);   // Post-increment
-//	const Byte8 &operator++(const Byte8 &val);   // Pre-increment
-//	RValue<Byte8> operator--(const Byte8 &val, int);   // Post-decrement
-//	const Byte8 &operator--(const Byte8 &val);   // Pre-decrement
+//	RValue<Byte8> operator++(Byte8 &val, int);   // Post-increment
+//	const Byte8 &operator++(Byte8 &val);   // Pre-increment
+//	RValue<Byte8> operator--(Byte8 &val, int);   // Post-decrement
+//	const Byte8 &operator--(Byte8 &val);   // Pre-decrement
 
 	RValue<Byte8> AddSat(RValue<Byte8> x, RValue<Byte8> y);
 	RValue<Byte8> SubSat(RValue<Byte8> x, RValue<Byte8> y);
@@ -573,9 +573,9 @@
 		SByte8(const SByte8 &rhs);
 		SByte8(const Reference<SByte8> &rhs);
 
-		RValue<SByte8> operator=(RValue<SByte8> rhs) const;
-		RValue<SByte8> operator=(const SByte8 &rhs) const;
-		RValue<SByte8> operator=(const Reference<SByte8> &rhs) const;
+		RValue<SByte8> operator=(RValue<SByte8> rhs);
+		RValue<SByte8> operator=(const SByte8 &rhs);
+		RValue<SByte8> operator=(const Reference<SByte8> &rhs);
 
 		static Type *getType();
 	};
@@ -590,23 +590,23 @@
 	RValue<SByte8> operator^(RValue<SByte8> lhs, RValue<SByte8> rhs);
 //	RValue<SByte8> operator<<(RValue<SByte8> lhs, RValue<SByte8> rhs);
 //	RValue<SByte8> operator>>(RValue<SByte8> lhs, RValue<SByte8> rhs);
-	RValue<SByte8> operator+=(const SByte8 &lhs, RValue<SByte8> rhs);
-	RValue<SByte8> operator-=(const SByte8 &lhs, RValue<SByte8> rhs);
-//	RValue<SByte8> operator*=(const SByte8 &lhs, RValue<SByte8> rhs);
-//	RValue<SByte8> operator/=(const SByte8 &lhs, RValue<SByte8> rhs);
-//	RValue<SByte8> operator%=(const SByte8 &lhs, RValue<SByte8> rhs);
-	RValue<SByte8> operator&=(const SByte8 &lhs, RValue<SByte8> rhs);
-	RValue<SByte8> operator|=(const SByte8 &lhs, RValue<SByte8> rhs);
-	RValue<SByte8> operator^=(const SByte8 &lhs, RValue<SByte8> rhs);
-//	RValue<SByte8> operator<<=(const SByte8 &lhs, RValue<SByte8> rhs);
-//	RValue<SByte8> operator>>=(const SByte8 &lhs, RValue<SByte8> rhs);
+	RValue<SByte8> operator+=(SByte8 &lhs, RValue<SByte8> rhs);
+	RValue<SByte8> operator-=(SByte8 &lhs, RValue<SByte8> rhs);
+//	RValue<SByte8> operator*=(SByte8 &lhs, RValue<SByte8> rhs);
+//	RValue<SByte8> operator/=(SByte8 &lhs, RValue<SByte8> rhs);
+//	RValue<SByte8> operator%=(SByte8 &lhs, RValue<SByte8> rhs);
+	RValue<SByte8> operator&=(SByte8 &lhs, RValue<SByte8> rhs);
+	RValue<SByte8> operator|=(SByte8 &lhs, RValue<SByte8> rhs);
+	RValue<SByte8> operator^=(SByte8 &lhs, RValue<SByte8> rhs);
+//	RValue<SByte8> operator<<=(SByte8 &lhs, RValue<SByte8> rhs);
+//	RValue<SByte8> operator>>=(SByte8 &lhs, RValue<SByte8> rhs);
 //	RValue<SByte8> operator+(RValue<SByte8> val);
 //	RValue<SByte8> operator-(RValue<SByte8> val);
 	RValue<SByte8> operator~(RValue<SByte8> val);
-//	RValue<SByte8> operator++(const SByte8 &val, int);   // Post-increment
-//	const SByte8 &operator++(const SByte8 &val);   // Pre-increment
-//	RValue<SByte8> operator--(const SByte8 &val, int);   // Post-decrement
-//	const SByte8 &operator--(const SByte8 &val);   // Pre-decrement
+//	RValue<SByte8> operator++(SByte8 &val, int);   // Post-increment
+//	const SByte8 &operator++(SByte8 &val);   // Pre-increment
+//	RValue<SByte8> operator--(SByte8 &val, int);   // Post-decrement
+//	const SByte8 &operator--(SByte8 &val);   // Pre-decrement
 
 	RValue<SByte8> AddSat(RValue<SByte8> x, RValue<SByte8> y);
 	RValue<SByte8> SubSat(RValue<SByte8> x, RValue<SByte8> y);
@@ -625,9 +625,9 @@
 		Byte16(const Byte16 &rhs);
 		Byte16(const Reference<Byte16> &rhs);
 
-		RValue<Byte16> operator=(RValue<Byte16> rhs) const;
-		RValue<Byte16> operator=(const Byte16 &rhs) const;
-		RValue<Byte16> operator=(const Reference<Byte16> &rhs) const;
+		RValue<Byte16> operator=(RValue<Byte16> rhs);
+		RValue<Byte16> operator=(const Byte16 &rhs);
+		RValue<Byte16> operator=(const Reference<Byte16> &rhs);
 
 		static Type *getType();
 	};
@@ -642,23 +642,23 @@
 //	RValue<Byte16> operator^(RValue<Byte16> lhs, RValue<Byte16> rhs);
 //	RValue<Byte16> operator<<(RValue<Byte16> lhs, RValue<Byte16> rhs);
 //	RValue<Byte16> operator>>(RValue<Byte16> lhs, RValue<Byte16> rhs);
-//	RValue<Byte16> operator+=(const Byte16 &lhs, RValue<Byte16> rhs);
-//	RValue<Byte16> operator-=(const Byte16 &lhs, RValue<Byte16> rhs);
-//	RValue<Byte16> operator*=(const Byte16 &lhs, RValue<Byte16> rhs);
-//	RValue<Byte16> operator/=(const Byte16 &lhs, RValue<Byte16> rhs);
-//	RValue<Byte16> operator%=(const Byte16 &lhs, RValue<Byte16> rhs);
-//	RValue<Byte16> operator&=(const Byte16 &lhs, RValue<Byte16> rhs);
-//	RValue<Byte16> operator|=(const Byte16 &lhs, RValue<Byte16> rhs);
-//	RValue<Byte16> operator^=(const Byte16 &lhs, RValue<Byte16> rhs);
-//	RValue<Byte16> operator<<=(const Byte16 &lhs, RValue<Byte16> rhs);
-//	RValue<Byte16> operator>>=(const Byte16 &lhs, RValue<Byte16> rhs);
+//	RValue<Byte16> operator+=(Byte16 &lhs, RValue<Byte16> rhs);
+//	RValue<Byte16> operator-=(Byte16 &lhs, RValue<Byte16> rhs);
+//	RValue<Byte16> operator*=(Byte16 &lhs, RValue<Byte16> rhs);
+//	RValue<Byte16> operator/=(Byte16 &lhs, RValue<Byte16> rhs);
+//	RValue<Byte16> operator%=(Byte16 &lhs, RValue<Byte16> rhs);
+//	RValue<Byte16> operator&=(Byte16 &lhs, RValue<Byte16> rhs);
+//	RValue<Byte16> operator|=(Byte16 &lhs, RValue<Byte16> rhs);
+//	RValue<Byte16> operator^=(Byte16 &lhs, RValue<Byte16> rhs);
+//	RValue<Byte16> operator<<=(Byte16 &lhs, RValue<Byte16> rhs);
+//	RValue<Byte16> operator>>=(Byte16 &lhs, RValue<Byte16> rhs);
 //	RValue<Byte16> operator+(RValue<Byte16> val);
 //	RValue<Byte16> operator-(RValue<Byte16> val);
 //	RValue<Byte16> operator~(RValue<Byte16> val);
-//	RValue<Byte16> operator++(const Byte16 &val, int);   // Post-increment
-//	const Byte16 &operator++(const Byte16 &val);   // Pre-increment
-//	RValue<Byte16> operator--(const Byte16 &val, int);   // Post-decrement
-//	const Byte16 &operator--(const Byte16 &val);   // Pre-decrement
+//	RValue<Byte16> operator++(Byte16 &val, int);   // Post-increment
+//	const Byte16 &operator++(Byte16 &val);   // Pre-increment
+//	RValue<Byte16> operator--(Byte16 &val, int);   // Post-decrement
+//	const Byte16 &operator--(Byte16 &val);   // Pre-decrement
 
 	class SByte16 : public LValue<SByte16>
 	{
@@ -669,9 +669,9 @@
 	//	SByte16(const SByte16 &rhs);
 	//	SByte16(const Reference<SByte16> &rhs);
 
-	//	RValue<SByte16> operator=(RValue<SByte16> rhs) const;
-	//	RValue<SByte16> operator=(const SByte16 &rhs) const;
-	//	RValue<SByte16> operator=(const Reference<SByte16> &rhs) const;
+	//	RValue<SByte16> operator=(RValue<SByte16> rhs);
+	//	RValue<SByte16> operator=(const SByte16 &rhs);
+	//	RValue<SByte16> operator=(const Reference<SByte16> &rhs);
 
 		static Type *getType();
 	};
@@ -686,23 +686,23 @@
 //	RValue<SByte16> operator^(RValue<SByte16> lhs, RValue<SByte16> rhs);
 //	RValue<SByte16> operator<<(RValue<SByte16> lhs, RValue<SByte16> rhs);
 //	RValue<SByte16> operator>>(RValue<SByte16> lhs, RValue<SByte16> rhs);
-//	RValue<SByte16> operator+=(const SByte16 &lhs, RValue<SByte16> rhs);
-//	RValue<SByte16> operator-=(const SByte16 &lhs, RValue<SByte16> rhs);
-//	RValue<SByte16> operator*=(const SByte16 &lhs, RValue<SByte16> rhs);
-//	RValue<SByte16> operator/=(const SByte16 &lhs, RValue<SByte16> rhs);
-//	RValue<SByte16> operator%=(const SByte16 &lhs, RValue<SByte16> rhs);
-//	RValue<SByte16> operator&=(const SByte16 &lhs, RValue<SByte16> rhs);
-//	RValue<SByte16> operator|=(const SByte16 &lhs, RValue<SByte16> rhs);
-//	RValue<SByte16> operator^=(const SByte16 &lhs, RValue<SByte16> rhs);
-//	RValue<SByte16> operator<<=(const SByte16 &lhs, RValue<SByte16> rhs);
-//	RValue<SByte16> operator>>=(const SByte16 &lhs, RValue<SByte16> rhs);
+//	RValue<SByte16> operator+=(SByte16 &lhs, RValue<SByte16> rhs);
+//	RValue<SByte16> operator-=(SByte16 &lhs, RValue<SByte16> rhs);
+//	RValue<SByte16> operator*=(SByte16 &lhs, RValue<SByte16> rhs);
+//	RValue<SByte16> operator/=(SByte16 &lhs, RValue<SByte16> rhs);
+//	RValue<SByte16> operator%=(SByte16 &lhs, RValue<SByte16> rhs);
+//	RValue<SByte16> operator&=(SByte16 &lhs, RValue<SByte16> rhs);
+//	RValue<SByte16> operator|=(SByte16 &lhs, RValue<SByte16> rhs);
+//	RValue<SByte16> operator^=(SByte16 &lhs, RValue<SByte16> rhs);
+//	RValue<SByte16> operator<<=(SByte16 &lhs, RValue<SByte16> rhs);
+//	RValue<SByte16> operator>>=(SByte16 &lhs, RValue<SByte16> rhs);
 //	RValue<SByte16> operator+(RValue<SByte16> val);
 //	RValue<SByte16> operator-(RValue<SByte16> val);
 //	RValue<SByte16> operator~(RValue<SByte16> val);
-//	RValue<SByte16> operator++(const SByte16 &val, int);   // Post-increment
-//	const SByte16 &operator++(const SByte16 &val);   // Pre-increment
-//	RValue<SByte16> operator--(const SByte16 &val, int);   // Post-decrement
-//	const SByte16 &operator--(const SByte16 &val);   // Pre-decrement
+//	RValue<SByte16> operator++(SByte16 &val, int);   // Post-increment
+//	const SByte16 &operator++(SByte16 &val);   // Pre-increment
+//	RValue<SByte16> operator--(SByte16 &val, int);   // Post-decrement
+//	const SByte16 &operator--(SByte16 &val);   // Pre-decrement
 
 	class Short2 : public LValue<Short2>
 	{
@@ -738,12 +738,12 @@
 		Short4(const UShort4 &rhs);
 		Short4(const Reference<UShort4> &rhs);
 
-		RValue<Short4> operator=(RValue<Short4> rhs) const;
-		RValue<Short4> operator=(const Short4 &rhs) const;
-		RValue<Short4> operator=(const Reference<Short4> &rhs) const;
-		RValue<Short4> operator=(RValue<UShort4> rhs) const;
-		RValue<Short4> operator=(const UShort4 &rhs) const;
-		RValue<Short4> operator=(const Reference<UShort4> &rhs) const;
+		RValue<Short4> operator=(RValue<Short4> rhs);
+		RValue<Short4> operator=(const Short4 &rhs);
+		RValue<Short4> operator=(const Reference<Short4> &rhs);
+		RValue<Short4> operator=(RValue<UShort4> rhs);
+		RValue<Short4> operator=(const UShort4 &rhs);
+		RValue<Short4> operator=(const Reference<UShort4> &rhs);
 
 		static Type *getType();
 	};
@@ -760,25 +760,25 @@
 	RValue<Short4> operator>>(RValue<Short4> lhs, unsigned char rhs);
 	RValue<Short4> operator<<(RValue<Short4> lhs, RValue<Long1> rhs);
 	RValue<Short4> operator>>(RValue<Short4> lhs, RValue<Long1> rhs);
-	RValue<Short4> operator+=(const Short4 &lhs, RValue<Short4> rhs);
-	RValue<Short4> operator-=(const Short4 &lhs, RValue<Short4> rhs);
-	RValue<Short4> operator*=(const Short4 &lhs, RValue<Short4> rhs);
-//	RValue<Short4> operator/=(const Short4 &lhs, RValue<Short4> rhs);
-//	RValue<Short4> operator%=(const Short4 &lhs, RValue<Short4> rhs);
-	RValue<Short4> operator&=(const Short4 &lhs, RValue<Short4> rhs);
-	RValue<Short4> operator|=(const Short4 &lhs, RValue<Short4> rhs);
-	RValue<Short4> operator^=(const Short4 &lhs, RValue<Short4> rhs);
-	RValue<Short4> operator<<=(const Short4 &lhs, unsigned char rhs);
-	RValue<Short4> operator>>=(const Short4 &lhs, unsigned char rhs);
-	RValue<Short4> operator<<=(const Short4 &lhs, RValue<Long1> rhs);
-	RValue<Short4> operator>>=(const Short4 &lhs, RValue<Long1> rhs);
+	RValue<Short4> operator+=(Short4 &lhs, RValue<Short4> rhs);
+	RValue<Short4> operator-=(Short4 &lhs, RValue<Short4> rhs);
+	RValue<Short4> operator*=(Short4 &lhs, RValue<Short4> rhs);
+//	RValue<Short4> operator/=(Short4 &lhs, RValue<Short4> rhs);
+//	RValue<Short4> operator%=(Short4 &lhs, RValue<Short4> rhs);
+	RValue<Short4> operator&=(Short4 &lhs, RValue<Short4> rhs);
+	RValue<Short4> operator|=(Short4 &lhs, RValue<Short4> rhs);
+	RValue<Short4> operator^=(Short4 &lhs, RValue<Short4> rhs);
+	RValue<Short4> operator<<=(Short4 &lhs, unsigned char rhs);
+	RValue<Short4> operator>>=(Short4 &lhs, unsigned char rhs);
+	RValue<Short4> operator<<=(Short4 &lhs, RValue<Long1> rhs);
+	RValue<Short4> operator>>=(Short4 &lhs, RValue<Long1> rhs);
 //	RValue<Short4> operator+(RValue<Short4> val);
 	RValue<Short4> operator-(RValue<Short4> val);
 	RValue<Short4> operator~(RValue<Short4> val);
-//	RValue<Short4> operator++(const Short4 &val, int);   // Post-increment
-//	const Short4 &operator++(const Short4 &val);   // Pre-increment
-//	RValue<Short4> operator--(const Short4 &val, int);   // Post-decrement
-//	const Short4 &operator--(const Short4 &val);   // Pre-decrement
+//	RValue<Short4> operator++(Short4 &val, int);   // Post-increment
+//	const Short4 &operator++(Short4 &val);   // Pre-increment
+//	RValue<Short4> operator--(Short4 &val, int);   // Post-decrement
+//	const Short4 &operator--(Short4 &val);   // Pre-decrement
 //	RValue<Bool> operator<(RValue<Short4> lhs, RValue<Short4> rhs);
 //	RValue<Bool> operator<=(RValue<Short4> lhs, RValue<Short4> rhs);
 //	RValue<Bool> operator>(RValue<Short4> lhs, RValue<Short4> rhs);
@@ -818,12 +818,12 @@
 		UShort4(const Short4 &rhs);
 		UShort4(const Reference<Short4> &rhs);
 
-		RValue<UShort4> operator=(RValue<UShort4> rhs) const;
-		RValue<UShort4> operator=(const UShort4 &rhs) const;
-		RValue<UShort4> operator=(const Reference<UShort4> &rhs) const;
-		RValue<UShort4> operator=(RValue<Short4> rhs) const;
-		RValue<UShort4> operator=(const Short4 &rhs) const;
-		RValue<UShort4> operator=(const Reference<Short4> &rhs) const;
+		RValue<UShort4> operator=(RValue<UShort4> rhs);
+		RValue<UShort4> operator=(const UShort4 &rhs);
+		RValue<UShort4> operator=(const Reference<UShort4> &rhs);
+		RValue<UShort4> operator=(RValue<Short4> rhs);
+		RValue<UShort4> operator=(const Short4 &rhs);
+		RValue<UShort4> operator=(const Reference<Short4> &rhs);
 
 		static Type *getType();
 	};
@@ -840,25 +840,25 @@
 	RValue<UShort4> operator>>(RValue<UShort4> lhs, unsigned char rhs);
 	RValue<UShort4> operator<<(RValue<UShort4> lhs, RValue<Long1> rhs);
 	RValue<UShort4> operator>>(RValue<UShort4> lhs, RValue<Long1> rhs);
-//	RValue<UShort4> operator+=(const UShort4 &lhs, RValue<UShort4> rhs);
-//	RValue<UShort4> operator-=(const UShort4 &lhs, RValue<UShort4> rhs);
-//	RValue<UShort4> operator*=(const UShort4 &lhs, RValue<UShort4> rhs);
-//	RValue<UShort4> operator/=(const UShort4 &lhs, RValue<UShort4> rhs);
-//	RValue<UShort4> operator%=(const UShort4 &lhs, RValue<UShort4> rhs);
-//	RValue<UShort4> operator&=(const UShort4 &lhs, RValue<UShort4> rhs);
-//	RValue<UShort4> operator|=(const UShort4 &lhs, RValue<UShort4> rhs);
-//	RValue<UShort4> operator^=(const UShort4 &lhs, RValue<UShort4> rhs);
-	RValue<UShort4> operator<<=(const UShort4 &lhs, unsigned char rhs);
-	RValue<UShort4> operator>>=(const UShort4 &lhs, unsigned char rhs);
-	RValue<UShort4> operator<<=(const UShort4 &lhs, RValue<Long1> rhs);
-	RValue<UShort4> operator>>=(const UShort4 &lhs, RValue<Long1> rhs);
+//	RValue<UShort4> operator+=(UShort4 &lhs, RValue<UShort4> rhs);
+//	RValue<UShort4> operator-=(UShort4 &lhs, RValue<UShort4> rhs);
+//	RValue<UShort4> operator*=(UShort4 &lhs, RValue<UShort4> rhs);
+//	RValue<UShort4> operator/=(UShort4 &lhs, RValue<UShort4> rhs);
+//	RValue<UShort4> operator%=(UShort4 &lhs, RValue<UShort4> rhs);
+//	RValue<UShort4> operator&=(UShort4 &lhs, RValue<UShort4> rhs);
+//	RValue<UShort4> operator|=(UShort4 &lhs, RValue<UShort4> rhs);
+//	RValue<UShort4> operator^=(UShort4 &lhs, RValue<UShort4> rhs);
+	RValue<UShort4> operator<<=(UShort4 &lhs, unsigned char rhs);
+	RValue<UShort4> operator>>=(UShort4 &lhs, unsigned char rhs);
+	RValue<UShort4> operator<<=(UShort4 &lhs, RValue<Long1> rhs);
+	RValue<UShort4> operator>>=(UShort4 &lhs, RValue<Long1> rhs);
 //	RValue<UShort4> operator+(RValue<UShort4> val);
 //	RValue<UShort4> operator-(RValue<UShort4> val);
 	RValue<UShort4> operator~(RValue<UShort4> val);
-//	RValue<UShort4> operator++(const UShort4 &val, int);   // Post-increment
-//	const UShort4 &operator++(const UShort4 &val);   // Pre-increment
-//	RValue<UShort4> operator--(const UShort4 &val, int);   // Post-decrement
-//	const UShort4 &operator--(const UShort4 &val);   // Pre-decrement
+//	RValue<UShort4> operator++(UShort4 &val, int);   // Post-increment
+//	const UShort4 &operator++(UShort4 &val);   // Pre-increment
+//	RValue<UShort4> operator--(UShort4 &val, int);   // Post-decrement
+//	const UShort4 &operator--(UShort4 &val);   // Pre-decrement
 
 	RValue<UShort4> Max(RValue<UShort4> x, RValue<UShort4> y);
 	RValue<UShort4> Min(RValue<UShort4> x, RValue<UShort4> y);
@@ -878,9 +878,9 @@
 		Short8(const Reference<Short8> &rhs);
 		Short8(RValue<Short4> lo, RValue<Short4> hi);
 
-	//	RValue<Short8> operator=(RValue<Short8> rhs) const;
-	//	RValue<Short8> operator=(const Short8 &rhs) const;
-	//	RValue<Short8> operator=(const Reference<Short8> &rhs) const;
+	//	RValue<Short8> operator=(RValue<Short8> rhs);
+	//	RValue<Short8> operator=(const Short8 &rhs);
+	//	RValue<Short8> operator=(const Reference<Short8> &rhs);
 
 		static Type *getType();
 	};
@@ -897,23 +897,23 @@
 	RValue<Short8> operator>>(RValue<Short8> lhs, unsigned char rhs);
 //	RValue<Short8> operator<<(RValue<Short8> lhs, RValue<Short8> rhs);
 //	RValue<Short8> operator>>(RValue<Short8> lhs, RValue<Short8> rhs);
-//	RValue<Short8> operator+=(const Short8 &lhs, RValue<Short8> rhs);
-//	RValue<Short8> operator-=(const Short8 &lhs, RValue<Short8> rhs);
-//	RValue<Short8> operator*=(const Short8 &lhs, RValue<Short8> rhs);
-//	RValue<Short8> operator/=(const Short8 &lhs, RValue<Short8> rhs);
-//	RValue<Short8> operator%=(const Short8 &lhs, RValue<Short8> rhs);
-//	RValue<Short8> operator&=(const Short8 &lhs, RValue<Short8> rhs);
-//	RValue<Short8> operator|=(const Short8 &lhs, RValue<Short8> rhs);
-//	RValue<Short8> operator^=(const Short8 &lhs, RValue<Short8> rhs);
-//	RValue<Short8> operator<<=(const Short8 &lhs, RValue<Short8> rhs);
-//	RValue<Short8> operator>>=(const Short8 &lhs, RValue<Short8> rhs);
+//	RValue<Short8> operator+=(Short8 &lhs, RValue<Short8> rhs);
+//	RValue<Short8> operator-=(Short8 &lhs, RValue<Short8> rhs);
+//	RValue<Short8> operator*=(Short8 &lhs, RValue<Short8> rhs);
+//	RValue<Short8> operator/=(Short8 &lhs, RValue<Short8> rhs);
+//	RValue<Short8> operator%=(Short8 &lhs, RValue<Short8> rhs);
+//	RValue<Short8> operator&=(Short8 &lhs, RValue<Short8> rhs);
+//	RValue<Short8> operator|=(Short8 &lhs, RValue<Short8> rhs);
+//	RValue<Short8> operator^=(Short8 &lhs, RValue<Short8> rhs);
+//	RValue<Short8> operator<<=(Short8 &lhs, RValue<Short8> rhs);
+//	RValue<Short8> operator>>=(Short8 &lhs, RValue<Short8> rhs);
 //	RValue<Short8> operator+(RValue<Short8> val);
 //	RValue<Short8> operator-(RValue<Short8> val);
 //	RValue<Short8> operator~(RValue<Short8> val);
-//	RValue<Short8> operator++(const Short8 &val, int);   // Post-increment
-//	const Short8 &operator++(const Short8 &val);   // Pre-increment
-//	RValue<Short8> operator--(const Short8 &val, int);   // Post-decrement
-//	const Short8 &operator--(const Short8 &val);   // Pre-decrement
+//	RValue<Short8> operator++(Short8 &val, int);   // Post-increment
+//	const Short8 &operator++(Short8 &val);   // Pre-increment
+//	RValue<Short8> operator--(Short8 &val, int);   // Post-decrement
+//	const Short8 &operator--(Short8 &val);   // Pre-decrement
 //	RValue<Bool> operator<(RValue<Short8> lhs, RValue<Short8> rhs);
 //	RValue<Bool> operator<=(RValue<Short8> lhs, RValue<Short8> rhs);
 //	RValue<Bool> operator>(RValue<Short8> lhs, RValue<Short8> rhs);
@@ -935,9 +935,9 @@
 		UShort8(const Reference<UShort8> &rhs);
 		UShort8(RValue<UShort4> lo, RValue<UShort4> hi);
 
-		RValue<UShort8> operator=(RValue<UShort8> rhs) const;
-		RValue<UShort8> operator=(const UShort8 &rhs) const;
-		RValue<UShort8> operator=(const Reference<UShort8> &rhs) const;
+		RValue<UShort8> operator=(RValue<UShort8> rhs);
+		RValue<UShort8> operator=(const UShort8 &rhs);
+		RValue<UShort8> operator=(const Reference<UShort8> &rhs);
 
 		static Type *getType();
 	};
@@ -954,23 +954,23 @@
 	RValue<UShort8> operator>>(RValue<UShort8> lhs, unsigned char rhs);
 //	RValue<UShort8> operator<<(RValue<UShort8> lhs, RValue<UShort8> rhs);
 //	RValue<UShort8> operator>>(RValue<UShort8> lhs, RValue<UShort8> rhs);
-	RValue<UShort8> operator+=(const UShort8 &lhs, RValue<UShort8> rhs);
-//	RValue<UShort8> operator-=(const UShort8 &lhs, RValue<UShort8> rhs);
-//	RValue<UShort8> operator*=(const UShort8 &lhs, RValue<UShort8> rhs);
-//	RValue<UShort8> operator/=(const UShort8 &lhs, RValue<UShort8> rhs);
-//	RValue<UShort8> operator%=(const UShort8 &lhs, RValue<UShort8> rhs);
-//	RValue<UShort8> operator&=(const UShort8 &lhs, RValue<UShort8> rhs);
-//	RValue<UShort8> operator|=(const UShort8 &lhs, RValue<UShort8> rhs);
-//	RValue<UShort8> operator^=(const UShort8 &lhs, RValue<UShort8> rhs);
-//	RValue<UShort8> operator<<=(const UShort8 &lhs, RValue<UShort8> rhs);
-//	RValue<UShort8> operator>>=(const UShort8 &lhs, RValue<UShort8> rhs);
+	RValue<UShort8> operator+=(UShort8 &lhs, RValue<UShort8> rhs);
+//	RValue<UShort8> operator-=(UShort8 &lhs, RValue<UShort8> rhs);
+//	RValue<UShort8> operator*=(UShort8 &lhs, RValue<UShort8> rhs);
+//	RValue<UShort8> operator/=(UShort8 &lhs, RValue<UShort8> rhs);
+//	RValue<UShort8> operator%=(UShort8 &lhs, RValue<UShort8> rhs);
+//	RValue<UShort8> operator&=(UShort8 &lhs, RValue<UShort8> rhs);
+//	RValue<UShort8> operator|=(UShort8 &lhs, RValue<UShort8> rhs);
+//	RValue<UShort8> operator^=(UShort8 &lhs, RValue<UShort8> rhs);
+//	RValue<UShort8> operator<<=(UShort8 &lhs, RValue<UShort8> rhs);
+//	RValue<UShort8> operator>>=(UShort8 &lhs, RValue<UShort8> rhs);
 //	RValue<UShort8> operator+(RValue<UShort8> val);
 //	RValue<UShort8> operator-(RValue<UShort8> val);
 	RValue<UShort8> operator~(RValue<UShort8> val);
-//	RValue<UShort8> operator++(const UShort8 &val, int);   // Post-increment
-//	const UShort8 &operator++(const UShort8 &val);   // Pre-increment
-//	RValue<UShort8> operator--(const UShort8 &val, int);   // Post-decrement
-//	const UShort8 &operator--(const UShort8 &val);   // Pre-decrement
+//	RValue<UShort8> operator++(UShort8 &val, int);   // Post-increment
+//	const UShort8 &operator++(UShort8 &val);   // Pre-increment
+//	RValue<UShort8> operator--(UShort8 &val, int);   // Post-decrement
+//	const UShort8 &operator--(UShort8 &val);   // Pre-decrement
 //	RValue<Bool> operator<(RValue<UShort8> lhs, RValue<UShort8> rhs);
 //	RValue<Bool> operator<=(RValue<UShort8> lhs, RValue<UShort8> rhs);
 //	RValue<Bool> operator>(RValue<UShort8> lhs, RValue<UShort8> rhs);
@@ -1003,13 +1003,13 @@
 		Int(const Reference<Int> &rhs);
 		Int(const Reference<UInt> &rhs);
 
-		RValue<Int> operator=(int rhs) const;
-		RValue<Int> operator=(RValue<Int> rhs) const;
-		RValue<Int> operator=(RValue<UInt> rhs) const;
-		RValue<Int> operator=(const Int &rhs) const;
-		RValue<Int> operator=(const UInt &rhs) const;
-		RValue<Int> operator=(const Reference<Int> &rhs) const;
-		RValue<Int> operator=(const Reference<UInt> &rhs) const;
+		RValue<Int> operator=(int rhs);
+		RValue<Int> operator=(RValue<Int> rhs);
+		RValue<Int> operator=(RValue<UInt> rhs);
+		RValue<Int> operator=(const Int &rhs);
+		RValue<Int> operator=(const UInt &rhs);
+		RValue<Int> operator=(const Reference<Int> &rhs);
+		RValue<Int> operator=(const Reference<UInt> &rhs);
 
 		static Type *getType();
 	};
@@ -1024,23 +1024,23 @@
 	RValue<Int> operator^(RValue<Int> lhs, RValue<Int> rhs);
 	RValue<Int> operator<<(RValue<Int> lhs, RValue<Int> rhs);
 	RValue<Int> operator>>(RValue<Int> lhs, RValue<Int> rhs);
-	RValue<Int> operator+=(const Int &lhs, RValue<Int> rhs);
-	RValue<Int> operator-=(const Int &lhs, RValue<Int> rhs);
-	RValue<Int> operator*=(const Int &lhs, RValue<Int> rhs);
-	RValue<Int> operator/=(const Int &lhs, RValue<Int> rhs);
-	RValue<Int> operator%=(const Int &lhs, RValue<Int> rhs);
-	RValue<Int> operator&=(const Int &lhs, RValue<Int> rhs);
-	RValue<Int> operator|=(const Int &lhs, RValue<Int> rhs);
-	RValue<Int> operator^=(const Int &lhs, RValue<Int> rhs);
-	RValue<Int> operator<<=(const Int &lhs, RValue<Int> rhs);
-	RValue<Int> operator>>=(const Int &lhs, RValue<Int> rhs);
+	RValue<Int> operator+=(Int &lhs, RValue<Int> rhs);
+	RValue<Int> operator-=(Int &lhs, RValue<Int> rhs);
+	RValue<Int> operator*=(Int &lhs, RValue<Int> rhs);
+	RValue<Int> operator/=(Int &lhs, RValue<Int> rhs);
+	RValue<Int> operator%=(Int &lhs, RValue<Int> rhs);
+	RValue<Int> operator&=(Int &lhs, RValue<Int> rhs);
+	RValue<Int> operator|=(Int &lhs, RValue<Int> rhs);
+	RValue<Int> operator^=(Int &lhs, RValue<Int> rhs);
+	RValue<Int> operator<<=(Int &lhs, RValue<Int> rhs);
+	RValue<Int> operator>>=(Int &lhs, RValue<Int> rhs);
 	RValue<Int> operator+(RValue<Int> val);
 	RValue<Int> operator-(RValue<Int> val);
 	RValue<Int> operator~(RValue<Int> val);
-	RValue<Int> operator++(const Int &val, int);   // Post-increment
-	const Int &operator++(const Int &val);   // Pre-increment
-	RValue<Int> operator--(const Int &val, int);   // Post-decrement
-	const Int &operator--(const Int &val);   // Pre-decrement
+	RValue<Int> operator++(Int &val, int);   // Post-increment
+	const Int &operator++(Int &val);   // Pre-increment
+	RValue<Int> operator--(Int &val, int);   // Post-decrement
+	const Int &operator--(Int &val);   // Pre-decrement
 	RValue<Bool> operator<(RValue<Int> lhs, RValue<Int> rhs);
 	RValue<Bool> operator<=(RValue<Int> lhs, RValue<Int> rhs);
 	RValue<Bool> operator>(RValue<Int> lhs, RValue<Int> rhs);
@@ -1073,13 +1073,13 @@
 	//	Long(const ULong &rhs);
 	//	Long(const Reference<ULong> &rhs);
 
-		RValue<Long> operator=(int64_t rhs) const;
-		RValue<Long> operator=(RValue<Long> rhs) const;
-	//	RValue<Long> operator=(RValue<ULong> rhs) const;
-		RValue<Long> operator=(const Long &rhs) const;
-		RValue<Long> operator=(const Reference<Long> &rhs) const;
-	//	RValue<Long> operator=(const ULong &rhs) const;
-	//	RValue<Long> operator=(const Reference<ULong> &rhs) const;
+		RValue<Long> operator=(int64_t rhs);
+		RValue<Long> operator=(RValue<Long> rhs);
+	//	RValue<Long> operator=(RValue<ULong> rhs);
+		RValue<Long> operator=(const Long &rhs);
+		RValue<Long> operator=(const Reference<Long> &rhs);
+	//	RValue<Long> operator=(const ULong &rhs);
+	//	RValue<Long> operator=(const Reference<ULong> &rhs);
 
 		static Type *getType();
 	};
@@ -1094,23 +1094,23 @@
 //	RValue<Long> operator^(RValue<Long> lhs, RValue<Long> rhs);
 //	RValue<Long> operator<<(RValue<Long> lhs, RValue<Long> rhs);
 //	RValue<Long> operator>>(RValue<Long> lhs, RValue<Long> rhs);
-	RValue<Long> operator+=(const Long &lhs, RValue<Long> rhs);
-	RValue<Long> operator-=(const Long &lhs, RValue<Long> rhs);
-//	RValue<Long> operator*=(const Long &lhs, RValue<Long> rhs);
-//	RValue<Long> operator/=(const Long &lhs, RValue<Long> rhs);
-//	RValue<Long> operator%=(const Long &lhs, RValue<Long> rhs);
-//	RValue<Long> operator&=(const Long &lhs, RValue<Long> rhs);
-//	RValue<Long> operator|=(const Long &lhs, RValue<Long> rhs);
-//	RValue<Long> operator^=(const Long &lhs, RValue<Long> rhs);
-//	RValue<Long> operator<<=(const Long &lhs, RValue<Long> rhs);
-//	RValue<Long> operator>>=(const Long &lhs, RValue<Long> rhs);
+	RValue<Long> operator+=(Long &lhs, RValue<Long> rhs);
+	RValue<Long> operator-=(Long &lhs, RValue<Long> rhs);
+//	RValue<Long> operator*=(Long &lhs, RValue<Long> rhs);
+//	RValue<Long> operator/=(Long &lhs, RValue<Long> rhs);
+//	RValue<Long> operator%=(Long &lhs, RValue<Long> rhs);
+//	RValue<Long> operator&=(Long &lhs, RValue<Long> rhs);
+//	RValue<Long> operator|=(Long &lhs, RValue<Long> rhs);
+//	RValue<Long> operator^=(Long &lhs, RValue<Long> rhs);
+//	RValue<Long> operator<<=(Long &lhs, RValue<Long> rhs);
+//	RValue<Long> operator>>=(Long &lhs, RValue<Long> rhs);
 //	RValue<Long> operator+(RValue<Long> val);
 //	RValue<Long> operator-(RValue<Long> val);
 //	RValue<Long> operator~(RValue<Long> val);
-//	RValue<Long> operator++(const Long &val, int);   // Post-increment
-//	const Long &operator++(const Long &val);   // Pre-increment
-//	RValue<Long> operator--(const Long &val, int);   // Post-decrement
-//	const Long &operator--(const Long &val);   // Pre-decrement
+//	RValue<Long> operator++(Long &val, int);   // Post-increment
+//	const Long &operator++(Long &val);   // Pre-increment
+//	RValue<Long> operator--(Long &val, int);   // Post-decrement
+//	const Long &operator--(Long &val);   // Pre-decrement
 //	RValue<Bool> operator<(RValue<Long> lhs, RValue<Long> rhs);
 //	RValue<Bool> operator<=(RValue<Long> lhs, RValue<Long> rhs);
 //	RValue<Bool> operator>(RValue<Long> lhs, RValue<Long> rhs);
@@ -1141,13 +1141,13 @@
 	//	Long1(const ULong1 &rhs);
 	//	Long1(const Reference<ULong1> &rhs);
 
-	//	RValue<Long1> operator=(qword rhs) const;
-	//	RValue<Long1> operator=(RValue<Long1> rhs) const;
-	//	RValue<Long1> operator=(RValue<ULong1> rhs) const;
-	//	RValue<Long1> operator=(const Long1 &rhs) const;
-	//	RValue<Long1> operator=(const Reference<Long1> &rhs) const;
-	//	RValue<Long1> operator=(const ULong1 &rhs) const;
-	//	RValue<Long1> operator=(const Reference<ULong1> &rhs) const;
+	//	RValue<Long1> operator=(qword rhs);
+	//	RValue<Long1> operator=(RValue<Long1> rhs);
+	//	RValue<Long1> operator=(RValue<ULong1> rhs);
+	//	RValue<Long1> operator=(const Long1 &rhs);
+	//	RValue<Long1> operator=(const Reference<Long1> &rhs);
+	//	RValue<Long1> operator=(const ULong1 &rhs);
+	//	RValue<Long1> operator=(const Reference<ULong1> &rhs);
 
 		static Type *getType();
 	};
@@ -1162,23 +1162,23 @@
 //	RValue<Long1> operator^(RValue<Long1> lhs, RValue<Long1> rhs);
 //	RValue<Long1> operator<<(RValue<Long1> lhs, RValue<Long1> rhs);
 //	RValue<Long1> operator>>(RValue<Long1> lhs, RValue<Long1> rhs);
-//	RValue<Long1> operator+=(const Long1 &lhs, RValue<Long1> rhs);
-//	RValue<Long1> operator-=(const Long1 &lhs, RValue<Long1> rhs);
-//	RValue<Long1> operator*=(const Long1 &lhs, RValue<Long1> rhs);
-//	RValue<Long1> operator/=(const Long1 &lhs, RValue<Long1> rhs);
-//	RValue<Long1> operator%=(const Long1 &lhs, RValue<Long1> rhs);
-//	RValue<Long1> operator&=(const Long1 &lhs, RValue<Long1> rhs);
-//	RValue<Long1> operator|=(const Long1 &lhs, RValue<Long1> rhs);
-//	RValue<Long1> operator^=(const Long1 &lhs, RValue<Long1> rhs);
-//	RValue<Long1> operator<<=(const Long1 &lhs, RValue<Long1> rhs);
-//	RValue<Long1> operator>>=(const Long1 &lhs, RValue<Long1> rhs);
+//	RValue<Long1> operator+=(Long1 &lhs, RValue<Long1> rhs);
+//	RValue<Long1> operator-=(Long1 &lhs, RValue<Long1> rhs);
+//	RValue<Long1> operator*=(Long1 &lhs, RValue<Long1> rhs);
+//	RValue<Long1> operator/=(Long1 &lhs, RValue<Long1> rhs);
+//	RValue<Long1> operator%=(Long1 &lhs, RValue<Long1> rhs);
+//	RValue<Long1> operator&=(Long1 &lhs, RValue<Long1> rhs);
+//	RValue<Long1> operator|=(Long1 &lhs, RValue<Long1> rhs);
+//	RValue<Long1> operator^=(Long1 &lhs, RValue<Long1> rhs);
+//	RValue<Long1> operator<<=(Long1 &lhs, RValue<Long1> rhs);
+//	RValue<Long1> operator>>=(Long1 &lhs, RValue<Long1> rhs);
 //	RValue<Long1> operator+(RValue<Long1> val);
 //	RValue<Long1> operator-(RValue<Long1> val);
 //	RValue<Long1> operator~(RValue<Long1> val);
-//	RValue<Long1> operator++(const Long1 &val, int);   // Post-increment
-//	const Long1 &operator++(const Long1 &val);   // Pre-increment
-//	RValue<Long1> operator--(const Long1 &val, int);   // Post-decrement
-//	const Long1 &operator--(const Long1 &val);   // Pre-decrement
+//	RValue<Long1> operator++(Long1 &val, int);   // Post-increment
+//	const Long1 &operator++(Long1 &val);   // Pre-increment
+//	RValue<Long1> operator--(Long1 &val, int);   // Post-decrement
+//	const Long1 &operator--(Long1 &val);   // Pre-decrement
 //	RValue<Bool> operator<(RValue<Long1> lhs, RValue<Long1> rhs);
 //	RValue<Bool> operator<=(RValue<Long1> lhs, RValue<Long1> rhs);
 //	RValue<Bool> operator>(RValue<Long1> lhs, RValue<Long1> rhs);
@@ -1207,13 +1207,13 @@
 		UInt(const Reference<UInt> &rhs);
 		UInt(const Reference<Int> &rhs);
 
-		RValue<UInt> operator=(unsigned int rhs) const;
-		RValue<UInt> operator=(RValue<UInt> rhs) const;
-		RValue<UInt> operator=(RValue<Int> rhs) const;
-		RValue<UInt> operator=(const UInt &rhs) const;
-		RValue<UInt> operator=(const Int &rhs) const;
-		RValue<UInt> operator=(const Reference<UInt> &rhs) const;
-		RValue<UInt> operator=(const Reference<Int> &rhs) const;
+		RValue<UInt> operator=(unsigned int rhs);
+		RValue<UInt> operator=(RValue<UInt> rhs);
+		RValue<UInt> operator=(RValue<Int> rhs);
+		RValue<UInt> operator=(const UInt &rhs);
+		RValue<UInt> operator=(const Int &rhs);
+		RValue<UInt> operator=(const Reference<UInt> &rhs);
+		RValue<UInt> operator=(const Reference<Int> &rhs);
 
 		static Type *getType();
 	};
@@ -1228,23 +1228,23 @@
 	RValue<UInt> operator^(RValue<UInt> lhs, RValue<UInt> rhs);
 	RValue<UInt> operator<<(RValue<UInt> lhs, RValue<UInt> rhs);
 	RValue<UInt> operator>>(RValue<UInt> lhs, RValue<UInt> rhs);
-	RValue<UInt> operator+=(const UInt &lhs, RValue<UInt> rhs);
-	RValue<UInt> operator-=(const UInt &lhs, RValue<UInt> rhs);
-	RValue<UInt> operator*=(const UInt &lhs, RValue<UInt> rhs);
-	RValue<UInt> operator/=(const UInt &lhs, RValue<UInt> rhs);
-	RValue<UInt> operator%=(const UInt &lhs, RValue<UInt> rhs);
-	RValue<UInt> operator&=(const UInt &lhs, RValue<UInt> rhs);
-	RValue<UInt> operator|=(const UInt &lhs, RValue<UInt> rhs);
-	RValue<UInt> operator^=(const UInt &lhs, RValue<UInt> rhs);
-	RValue<UInt> operator<<=(const UInt &lhs, RValue<UInt> rhs);
-	RValue<UInt> operator>>=(const UInt &lhs, RValue<UInt> rhs);
+	RValue<UInt> operator+=(UInt &lhs, RValue<UInt> rhs);
+	RValue<UInt> operator-=(UInt &lhs, RValue<UInt> rhs);
+	RValue<UInt> operator*=(UInt &lhs, RValue<UInt> rhs);
+	RValue<UInt> operator/=(UInt &lhs, RValue<UInt> rhs);
+	RValue<UInt> operator%=(UInt &lhs, RValue<UInt> rhs);
+	RValue<UInt> operator&=(UInt &lhs, RValue<UInt> rhs);
+	RValue<UInt> operator|=(UInt &lhs, RValue<UInt> rhs);
+	RValue<UInt> operator^=(UInt &lhs, RValue<UInt> rhs);
+	RValue<UInt> operator<<=(UInt &lhs, RValue<UInt> rhs);
+	RValue<UInt> operator>>=(UInt &lhs, RValue<UInt> rhs);
 	RValue<UInt> operator+(RValue<UInt> val);
 	RValue<UInt> operator-(RValue<UInt> val);
 	RValue<UInt> operator~(RValue<UInt> val);
-	RValue<UInt> operator++(const UInt &val, int);   // Post-increment
-	const UInt &operator++(const UInt &val);   // Pre-increment
-	RValue<UInt> operator--(const UInt &val, int);   // Post-decrement
-	const UInt &operator--(const UInt &val);   // Pre-decrement
+	RValue<UInt> operator++(UInt &val, int);   // Post-increment
+	const UInt &operator++(UInt &val);   // Pre-increment
+	RValue<UInt> operator--(UInt &val, int);   // Post-decrement
+	const UInt &operator--(UInt &val);   // Pre-decrement
 	RValue<Bool> operator<(RValue<UInt> lhs, RValue<UInt> rhs);
 	RValue<Bool> operator<=(RValue<UInt> lhs, RValue<UInt> rhs);
 	RValue<Bool> operator>(RValue<UInt> lhs, RValue<UInt> rhs);
@@ -1270,9 +1270,9 @@
 		Int2(const Reference<Int2> &rhs);
 		Int2(RValue<Int> lo, RValue<Int> hi);
 
-		RValue<Int2> operator=(RValue<Int2> rhs) const;
-		RValue<Int2> operator=(const Int2 &rhs) const;
-		RValue<Int2> operator=(const Reference<Int2> &rhs) const;
+		RValue<Int2> operator=(RValue<Int2> rhs);
+		RValue<Int2> operator=(const Int2 &rhs);
+		RValue<Int2> operator=(const Reference<Int2> &rhs);
 
 		static Type *getType();
 	};
@@ -1289,25 +1289,25 @@
 	RValue<Int2> operator>>(RValue<Int2> lhs, unsigned char rhs);
 	RValue<Int2> operator<<(RValue<Int2> lhs, RValue<Long1> rhs);
 	RValue<Int2> operator>>(RValue<Int2> lhs, RValue<Long1> rhs);
-	RValue<Int2> operator+=(const Int2 &lhs, RValue<Int2> rhs);
-	RValue<Int2> operator-=(const Int2 &lhs, RValue<Int2> rhs);
-//	RValue<Int2> operator*=(const Int2 &lhs, RValue<Int2> rhs);
-//	RValue<Int2> operator/=(const Int2 &lhs, RValue<Int2> rhs);
-//	RValue<Int2> operator%=(const Int2 &lhs, RValue<Int2> rhs);
-	RValue<Int2> operator&=(const Int2 &lhs, RValue<Int2> rhs);
-	RValue<Int2> operator|=(const Int2 &lhs, RValue<Int2> rhs);
-	RValue<Int2> operator^=(const Int2 &lhs, RValue<Int2> rhs);
-	RValue<Int2> operator<<=(const Int2 &lhs, unsigned char rhs);
-	RValue<Int2> operator>>=(const Int2 &lhs, unsigned char rhs);
-	RValue<Int2> operator<<=(const Int2 &lhs, RValue<Long1> rhs);
-	RValue<Int2> operator>>=(const Int2 &lhs, RValue<Long1> rhs);
+	RValue<Int2> operator+=(Int2 &lhs, RValue<Int2> rhs);
+	RValue<Int2> operator-=(Int2 &lhs, RValue<Int2> rhs);
+//	RValue<Int2> operator*=(Int2 &lhs, RValue<Int2> rhs);
+//	RValue<Int2> operator/=(Int2 &lhs, RValue<Int2> rhs);
+//	RValue<Int2> operator%=(Int2 &lhs, RValue<Int2> rhs);
+	RValue<Int2> operator&=(Int2 &lhs, RValue<Int2> rhs);
+	RValue<Int2> operator|=(Int2 &lhs, RValue<Int2> rhs);
+	RValue<Int2> operator^=(Int2 &lhs, RValue<Int2> rhs);
+	RValue<Int2> operator<<=(Int2 &lhs, unsigned char rhs);
+	RValue<Int2> operator>>=(Int2 &lhs, unsigned char rhs);
+	RValue<Int2> operator<<=(Int2 &lhs, RValue<Long1> rhs);
+	RValue<Int2> operator>>=(Int2 &lhs, RValue<Long1> rhs);
 //	RValue<Int2> operator+(RValue<Int2> val);
 //	RValue<Int2> operator-(RValue<Int2> val);
 	RValue<Int2> operator~(RValue<Int2> val);
-//	RValue<Int2> operator++(const Int2 &val, int);   // Post-increment
-//	const Int2 &operator++(const Int2 &val);   // Pre-increment
-//	RValue<Int2> operator--(const Int2 &val, int);   // Post-decrement
-//	const Int2 &operator--(const Int2 &val);   // Pre-decrement
+//	RValue<Int2> operator++(Int2 &val, int);   // Post-increment
+//	const Int2 &operator++(Int2 &val);   // Pre-increment
+//	RValue<Int2> operator--(Int2 &val, int);   // Post-decrement
+//	const Int2 &operator--(Int2 &val);   // Pre-decrement
 //	RValue<Bool> operator<(RValue<Int2> lhs, RValue<Int2> rhs);
 //	RValue<Bool> operator<=(RValue<Int2> lhs, RValue<Int2> rhs);
 //	RValue<Bool> operator>(RValue<Int2> lhs, RValue<Int2> rhs);
@@ -1330,9 +1330,9 @@
 		UInt2(const UInt2 &rhs);
 		UInt2(const Reference<UInt2> &rhs);
 
-		RValue<UInt2> operator=(RValue<UInt2> rhs) const;
-		RValue<UInt2> operator=(const UInt2 &rhs) const;
-		RValue<UInt2> operator=(const Reference<UInt2> &rhs) const;
+		RValue<UInt2> operator=(RValue<UInt2> rhs);
+		RValue<UInt2> operator=(const UInt2 &rhs);
+		RValue<UInt2> operator=(const Reference<UInt2> &rhs);
 
 		static Type *getType();
 	};
@@ -1349,25 +1349,25 @@
 	RValue<UInt2> operator>>(RValue<UInt2> lhs, unsigned char rhs);
 	RValue<UInt2> operator<<(RValue<UInt2> lhs, RValue<Long1> rhs);
 	RValue<UInt2> operator>>(RValue<UInt2> lhs, RValue<Long1> rhs);
-	RValue<UInt2> operator+=(const UInt2 &lhs, RValue<UInt2> rhs);
-	RValue<UInt2> operator-=(const UInt2 &lhs, RValue<UInt2> rhs);
-//	RValue<UInt2> operator*=(const UInt2 &lhs, RValue<UInt2> rhs);
-//	RValue<UInt2> operator/=(const UInt2 &lhs, RValue<UInt2> rhs);
-//	RValue<UInt2> operator%=(const UInt2 &lhs, RValue<UInt2> rhs);
-	RValue<UInt2> operator&=(const UInt2 &lhs, RValue<UInt2> rhs);
-	RValue<UInt2> operator|=(const UInt2 &lhs, RValue<UInt2> rhs);
-	RValue<UInt2> operator^=(const UInt2 &lhs, RValue<UInt2> rhs);
-	RValue<UInt2> operator<<=(const UInt2 &lhs, unsigned char rhs);
-	RValue<UInt2> operator>>=(const UInt2 &lhs, unsigned char rhs);
-	RValue<UInt2> operator<<=(const UInt2 &lhs, RValue<Long1> rhs);
-	RValue<UInt2> operator>>=(const UInt2 &lhs, RValue<Long1> rhs);
+	RValue<UInt2> operator+=(UInt2 &lhs, RValue<UInt2> rhs);
+	RValue<UInt2> operator-=(UInt2 &lhs, RValue<UInt2> rhs);
+//	RValue<UInt2> operator*=(UInt2 &lhs, RValue<UInt2> rhs);
+//	RValue<UInt2> operator/=(UInt2 &lhs, RValue<UInt2> rhs);
+//	RValue<UInt2> operator%=(UInt2 &lhs, RValue<UInt2> rhs);
+	RValue<UInt2> operator&=(UInt2 &lhs, RValue<UInt2> rhs);
+	RValue<UInt2> operator|=(UInt2 &lhs, RValue<UInt2> rhs);
+	RValue<UInt2> operator^=(UInt2 &lhs, RValue<UInt2> rhs);
+	RValue<UInt2> operator<<=(UInt2 &lhs, unsigned char rhs);
+	RValue<UInt2> operator>>=(UInt2 &lhs, unsigned char rhs);
+	RValue<UInt2> operator<<=(UInt2 &lhs, RValue<Long1> rhs);
+	RValue<UInt2> operator>>=(UInt2 &lhs, RValue<Long1> rhs);
 //	RValue<UInt2> operator+(RValue<UInt2> val);
 //	RValue<UInt2> operator-(RValue<UInt2> val);
 	RValue<UInt2> operator~(RValue<UInt2> val);
-//	RValue<UInt2> operator++(const UInt2 &val, int);   // Post-increment
-//	const UInt2 &operator++(const UInt2 &val);   // Pre-increment
-//	RValue<UInt2> operator--(const UInt2 &val, int);   // Post-decrement
-//	const UInt2 &operator--(const UInt2 &val);   // Pre-decrement
+//	RValue<UInt2> operator++(UInt2 &val, int);   // Post-increment
+//	const UInt2 &operator++(UInt2 &val);   // Pre-increment
+//	RValue<UInt2> operator--(UInt2 &val, int);   // Post-decrement
+//	const UInt2 &operator--(UInt2 &val);   // Pre-decrement
 //	RValue<Bool> operator<(RValue<UInt2> lhs, RValue<UInt2> rhs);
 //	RValue<Bool> operator<=(RValue<UInt2> lhs, RValue<UInt2> rhs);
 //	RValue<Bool> operator>(RValue<UInt2> lhs, RValue<UInt2> rhs);
@@ -1402,9 +1402,9 @@
 		Int4(const Int &rhs);
 		Int4(const Reference<Int> &rhs);
 
-		RValue<Int4> operator=(RValue<Int4> rhs) const;
-		RValue<Int4> operator=(const Int4 &rhs) const;
-		RValue<Int4> operator=(const Reference<Int4> &rhs) const;
+		RValue<Int4> operator=(RValue<Int4> rhs);
+		RValue<Int4> operator=(const Int4 &rhs);
+		RValue<Int4> operator=(const Reference<Int4> &rhs);
 
 		static Type *getType();
 
@@ -1424,23 +1424,23 @@
 	RValue<Int4> operator>>(RValue<Int4> lhs, unsigned char rhs);
 	RValue<Int4> operator<<(RValue<Int4> lhs, RValue<Int4> rhs);
 	RValue<Int4> operator>>(RValue<Int4> lhs, RValue<Int4> rhs);
-	RValue<Int4> operator+=(const Int4 &lhs, RValue<Int4> rhs);
-	RValue<Int4> operator-=(const Int4 &lhs, RValue<Int4> rhs);
-	RValue<Int4> operator*=(const Int4 &lhs, RValue<Int4> rhs);
-//	RValue<Int4> operator/=(const Int4 &lhs, RValue<Int4> rhs);
-//	RValue<Int4> operator%=(const Int4 &lhs, RValue<Int4> rhs);
-	RValue<Int4> operator&=(const Int4 &lhs, RValue<Int4> rhs);
-	RValue<Int4> operator|=(const Int4 &lhs, RValue<Int4> rhs);
-	RValue<Int4> operator^=(const Int4 &lhs, RValue<Int4> rhs);
-	RValue<Int4> operator<<=(const Int4 &lhs, unsigned char rhs);
-	RValue<Int4> operator>>=(const Int4 &lhs, unsigned char rhs);
+	RValue<Int4> operator+=(Int4 &lhs, RValue<Int4> rhs);
+	RValue<Int4> operator-=(Int4 &lhs, RValue<Int4> rhs);
+	RValue<Int4> operator*=(Int4 &lhs, RValue<Int4> rhs);
+//	RValue<Int4> operator/=(Int4 &lhs, RValue<Int4> rhs);
+//	RValue<Int4> operator%=(Int4 &lhs, RValue<Int4> rhs);
+	RValue<Int4> operator&=(Int4 &lhs, RValue<Int4> rhs);
+	RValue<Int4> operator|=(Int4 &lhs, RValue<Int4> rhs);
+	RValue<Int4> operator^=(Int4 &lhs, RValue<Int4> rhs);
+	RValue<Int4> operator<<=(Int4 &lhs, unsigned char rhs);
+	RValue<Int4> operator>>=(Int4 &lhs, unsigned char rhs);
 	RValue<Int4> operator+(RValue<Int4> val);
 	RValue<Int4> operator-(RValue<Int4> val);
 	RValue<Int4> operator~(RValue<Int4> val);
-//	RValue<Int4> operator++(const Int4 &val, int);   // Post-increment
-//	const Int4 &operator++(const Int4 &val);   // Pre-increment
-//	RValue<Int4> operator--(const Int4 &val, int);   // Post-decrement
-//	const Int4 &operator--(const Int4 &val);   // Pre-decrement
+//	RValue<Int4> operator++(Int4 &val, int);   // Post-increment
+//	const Int4 &operator++(Int4 &val);   // Pre-increment
+//	RValue<Int4> operator--(Int4 &val, int);   // Post-decrement
+//	const Int4 &operator--(Int4 &val);   // Pre-decrement
 //	RValue<Bool> operator<(RValue<Int4> lhs, RValue<Int4> rhs);
 //	RValue<Bool> operator<=(RValue<Int4> lhs, RValue<Int4> rhs);
 //	RValue<Bool> operator>(RValue<Int4> lhs, RValue<Int4> rhs);
@@ -1482,9 +1482,9 @@
 		UInt4(const Reference<Int4> &rhs);
 		UInt4(RValue<UInt2> lo, RValue<UInt2> hi);
 
-		RValue<UInt4> operator=(RValue<UInt4> rhs) const;
-		RValue<UInt4> operator=(const UInt4 &rhs) const;
-		RValue<UInt4> operator=(const Reference<UInt4> &rhs) const;
+		RValue<UInt4> operator=(RValue<UInt4> rhs);
+		RValue<UInt4> operator=(const UInt4 &rhs);
+		RValue<UInt4> operator=(const Reference<UInt4> &rhs);
 
 		static Type *getType();
 
@@ -1504,23 +1504,23 @@
 	RValue<UInt4> operator>>(RValue<UInt4> lhs, unsigned char rhs);
 	RValue<UInt4> operator<<(RValue<UInt4> lhs, RValue<UInt4> rhs);
 	RValue<UInt4> operator>>(RValue<UInt4> lhs, RValue<UInt4> rhs);
-	RValue<UInt4> operator+=(const UInt4 &lhs, RValue<UInt4> rhs);
-	RValue<UInt4> operator-=(const UInt4 &lhs, RValue<UInt4> rhs);
-	RValue<UInt4> operator*=(const UInt4 &lhs, RValue<UInt4> rhs);
-//	RValue<UInt4> operator/=(const UInt4 &lhs, RValue<UInt4> rhs);
-//	RValue<UInt4> operator%=(const UInt4 &lhs, RValue<UInt4> rhs);
-	RValue<UInt4> operator&=(const UInt4 &lhs, RValue<UInt4> rhs);
-	RValue<UInt4> operator|=(const UInt4 &lhs, RValue<UInt4> rhs);
-	RValue<UInt4> operator^=(const UInt4 &lhs, RValue<UInt4> rhs);
-	RValue<UInt4> operator<<=(const UInt4 &lhs, unsigned char rhs);
-	RValue<UInt4> operator>>=(const UInt4 &lhs, unsigned char rhs);
+	RValue<UInt4> operator+=(UInt4 &lhs, RValue<UInt4> rhs);
+	RValue<UInt4> operator-=(UInt4 &lhs, RValue<UInt4> rhs);
+	RValue<UInt4> operator*=(UInt4 &lhs, RValue<UInt4> rhs);
+//	RValue<UInt4> operator/=(UInt4 &lhs, RValue<UInt4> rhs);
+//	RValue<UInt4> operator%=(UInt4 &lhs, RValue<UInt4> rhs);
+	RValue<UInt4> operator&=(UInt4 &lhs, RValue<UInt4> rhs);
+	RValue<UInt4> operator|=(UInt4 &lhs, RValue<UInt4> rhs);
+	RValue<UInt4> operator^=(UInt4 &lhs, RValue<UInt4> rhs);
+	RValue<UInt4> operator<<=(UInt4 &lhs, unsigned char rhs);
+	RValue<UInt4> operator>>=(UInt4 &lhs, unsigned char rhs);
 	RValue<UInt4> operator+(RValue<UInt4> val);
 	RValue<UInt4> operator-(RValue<UInt4> val);
 	RValue<UInt4> operator~(RValue<UInt4> val);
-//	RValue<UInt4> operator++(const UInt4 &val, int);   // Post-increment
-//	const UInt4 &operator++(const UInt4 &val);   // Pre-increment
-//	RValue<UInt4> operator--(const UInt4 &val, int);   // Post-decrement
-//	const UInt4 &operator--(const UInt4 &val);   // Pre-decrement
+//	RValue<UInt4> operator++(UInt4 &val, int);   // Post-increment
+//	const UInt4 &operator++(UInt4 &val);   // Pre-increment
+//	RValue<UInt4> operator--(UInt4 &val, int);   // Post-decrement
+//	const UInt4 &operator--(UInt4 &val);   // Pre-decrement
 //	RValue<Bool> operator<(RValue<UInt4> lhs, RValue<UInt4> rhs);
 //	RValue<Bool> operator<=(RValue<UInt4> lhs, RValue<UInt4> rhs);
 //	RValue<Bool> operator>(RValue<UInt4> lhs, RValue<UInt4> rhs);
@@ -1569,8 +1569,8 @@
 	public:
 		operator RValue<Float4>() const;
 
-		RValue<Float4> operator=(RValue<Float4> rhs) const;
-		RValue<Float4> operator=(RValue<Float> rhs) const;
+		RValue<Float4> operator=(RValue<Float4> rhs);
+		RValue<Float4> operator=(RValue<Float> rhs);
 
 	private:
 		Float4 *parent;
@@ -1583,9 +1583,9 @@
 		operator RValue<Float>() const;
 		operator RValue<Float4>() const;
 
-		RValue<Float4> operator=(float x) const;
-		RValue<Float4> operator=(RValue<Float4> rhs) const;
-		RValue<Float4> operator=(RValue<Float> rhs) const;
+		RValue<Float4> operator=(float x);
+		RValue<Float4> operator=(RValue<Float4> rhs);
+		RValue<Float4> operator=(RValue<Float> rhs);
 
 	private:
 		Float4 *parent;
@@ -1599,7 +1599,7 @@
 	public:
 		operator RValue<Float4>() const;
 
-		RValue<Float4> operator=(RValue<Float4> rhs) const;
+		RValue<Float4> operator=(RValue<Float4> rhs);
 
 	private:
 		Float4 *parent;
@@ -1619,13 +1619,13 @@
 		template<int T>
 		Float(const SwizzleMask1Float4<T> &rhs);
 
-	//	RValue<Float> operator=(float rhs) const;   // FIXME: Implement
-		RValue<Float> operator=(RValue<Float> rhs) const;
-		RValue<Float> operator=(const Float &rhs) const;
-		RValue<Float> operator=(const Reference<Float> &rhs) const;
+	//	RValue<Float> operator=(float rhs);   // FIXME: Implement
+		RValue<Float> operator=(RValue<Float> rhs);
+		RValue<Float> operator=(const Float &rhs);
+		RValue<Float> operator=(const Reference<Float> &rhs);
 
 		template<int T>
-		RValue<Float> operator=(const SwizzleMask1Float4<T> &rhs) const;
+		RValue<Float> operator=(const SwizzleMask1Float4<T> &rhs);
 
 		static Type *getType();
 	};
@@ -1634,10 +1634,10 @@
 	RValue<Float> operator-(RValue<Float> lhs, RValue<Float> rhs);
 	RValue<Float> operator*(RValue<Float> lhs, RValue<Float> rhs);
 	RValue<Float> operator/(RValue<Float> lhs, RValue<Float> rhs);
-	RValue<Float> operator+=(const Float &lhs, RValue<Float> rhs);
-	RValue<Float> operator-=(const Float &lhs, RValue<Float> rhs);
-	RValue<Float> operator*=(const Float &lhs, RValue<Float> rhs);
-	RValue<Float> operator/=(const Float &lhs, RValue<Float> rhs);
+	RValue<Float> operator+=(Float &lhs, RValue<Float> rhs);
+	RValue<Float> operator-=(Float &lhs, RValue<Float> rhs);
+	RValue<Float> operator*=(Float &lhs, RValue<Float> rhs);
+	RValue<Float> operator/=(Float &lhs, RValue<Float> rhs);
 	RValue<Float> operator+(RValue<Float> val);
 	RValue<Float> operator-(RValue<Float> val);
 	RValue<Bool> operator<(RValue<Float> lhs, RValue<Float> rhs);
@@ -1681,13 +1681,13 @@
 	//	template<int T>
 	//	Float2(const SwizzleMask1Float4<T> &rhs);
 
-	//	RValue<Float2> operator=(float replicate) const;
-	//	RValue<Float2> operator=(RValue<Float2> rhs) const;
-	//	RValue<Float2> operator=(const Float2 &rhs) const;
-	//	RValue<Float2> operator=(const Reference<Float2> &rhs) const;
-	//	RValue<Float2> operator=(RValue<Float> rhs) const;
-	//	RValue<Float2> operator=(const Float &rhs) const;
-	//	RValue<Float2> operator=(const Reference<Float> &rhs) const;
+	//	RValue<Float2> operator=(float replicate);
+	//	RValue<Float2> operator=(RValue<Float2> rhs);
+	//	RValue<Float2> operator=(const Float2 &rhs);
+	//	RValue<Float2> operator=(const Reference<Float2> &rhs);
+	//	RValue<Float2> operator=(RValue<Float> rhs);
+	//	RValue<Float2> operator=(const Float &rhs);
+	//	RValue<Float2> operator=(const Reference<Float> &rhs);
 
 	//	template<int T>
 	//	RValue<Float2> operator=(const SwizzleMask1Float4<T> &rhs);
@@ -1700,11 +1700,11 @@
 //	RValue<Float2> operator*(RValue<Float2> lhs, RValue<Float2> rhs);
 //	RValue<Float2> operator/(RValue<Float2> lhs, RValue<Float2> rhs);
 //	RValue<Float2> operator%(RValue<Float2> lhs, RValue<Float2> rhs);
-//	RValue<Float2> operator+=(const Float2 &lhs, RValue<Float2> rhs);
-//	RValue<Float2> operator-=(const Float2 &lhs, RValue<Float2> rhs);
-//	RValue<Float2> operator*=(const Float2 &lhs, RValue<Float2> rhs);
-//	RValue<Float2> operator/=(const Float2 &lhs, RValue<Float2> rhs);
-//	RValue<Float2> operator%=(const Float2 &lhs, RValue<Float2> rhs);
+//	RValue<Float2> operator+=(Float2 &lhs, RValue<Float2> rhs);
+//	RValue<Float2> operator-=(Float2 &lhs, RValue<Float2> rhs);
+//	RValue<Float2> operator*=(Float2 &lhs, RValue<Float2> rhs);
+//	RValue<Float2> operator/=(Float2 &lhs, RValue<Float2> rhs);
+//	RValue<Float2> operator%=(Float2 &lhs, RValue<Float2> rhs);
 //	RValue<Float2> operator+(RValue<Float2> val);
 //	RValue<Float2> operator-(RValue<Float2> val);
 
@@ -1749,13 +1749,13 @@
 		template<int X, int Y>
 		Float4(const SwizzleMask2Float4<X> &x, const SwizzleMask2Float4<Y> &y);
 
-		RValue<Float4> operator=(float replicate) const;
-		RValue<Float4> operator=(RValue<Float4> rhs) const;
-		RValue<Float4> operator=(const Float4 &rhs) const;
-		RValue<Float4> operator=(const Reference<Float4> &rhs) const;
-		RValue<Float4> operator=(RValue<Float> rhs) const;
-		RValue<Float4> operator=(const Float &rhs) const;
-		RValue<Float4> operator=(const Reference<Float> &rhs) const;
+		RValue<Float4> operator=(float replicate);
+		RValue<Float4> operator=(RValue<Float4> rhs);
+		RValue<Float4> operator=(const Float4 &rhs);
+		RValue<Float4> operator=(const Reference<Float4> &rhs);
+		RValue<Float4> operator=(RValue<Float> rhs);
+		RValue<Float4> operator=(const Float &rhs);
+		RValue<Float4> operator=(const Reference<Float> &rhs);
 
 		template<int T>
 		RValue<Float4> operator=(const SwizzleMask1Float4<T> &rhs);
@@ -2117,11 +2117,11 @@
 	RValue<Float4> operator*(RValue<Float4> lhs, RValue<Float4> rhs);
 	RValue<Float4> operator/(RValue<Float4> lhs, RValue<Float4> rhs);
 	RValue<Float4> operator%(RValue<Float4> lhs, RValue<Float4> rhs);
-	RValue<Float4> operator+=(const Float4 &lhs, RValue<Float4> rhs);
-	RValue<Float4> operator-=(const Float4 &lhs, RValue<Float4> rhs);
-	RValue<Float4> operator*=(const Float4 &lhs, RValue<Float4> rhs);
-	RValue<Float4> operator/=(const Float4 &lhs, RValue<Float4> rhs);
-	RValue<Float4> operator%=(const Float4 &lhs, RValue<Float4> rhs);
+	RValue<Float4> operator+=(Float4 &lhs, RValue<Float4> rhs);
+	RValue<Float4> operator-=(Float4 &lhs, RValue<Float4> rhs);
+	RValue<Float4> operator*=(Float4 &lhs, RValue<Float4> rhs);
+	RValue<Float4> operator/=(Float4 &lhs, RValue<Float4> rhs);
+	RValue<Float4> operator%=(Float4 &lhs, RValue<Float4> rhs);
 	RValue<Float4> operator+(RValue<Float4> val);
 	RValue<Float4> operator-(RValue<Float4> val);
 
@@ -2178,9 +2178,9 @@
 		Pointer(const Pointer<T> &rhs);
 		Pointer(const Reference<Pointer<T>> &rhs);
 
-		RValue<Pointer<T>> operator=(RValue<Pointer<T>> rhs) const;
-		RValue<Pointer<T>> operator=(const Pointer<T> &rhs) const;
-		RValue<Pointer<T>> operator=(const Reference<Pointer<T>> &rhs) const;
+		RValue<Pointer<T>> operator=(RValue<Pointer<T>> rhs);
+		RValue<Pointer<T>> operator=(const Pointer<T> &rhs);
+		RValue<Pointer<T>> operator=(const Reference<Pointer<T>> &rhs);
 
 		Reference<T> operator*();
 		Reference<T> operator[](int index);
@@ -2195,16 +2195,16 @@
 	RValue<Pointer<Byte>> operator+(RValue<Pointer<Byte>> lhs, int offset);
 	RValue<Pointer<Byte>> operator+(RValue<Pointer<Byte>> lhs, RValue<Int> offset);
 	RValue<Pointer<Byte>> operator+(RValue<Pointer<Byte>> lhs, RValue<UInt> offset);
-	RValue<Pointer<Byte>> operator+=(const Pointer<Byte> &lhs, int offset);
-	RValue<Pointer<Byte>> operator+=(const Pointer<Byte> &lhs, RValue<Int> offset);
-	RValue<Pointer<Byte>> operator+=(const Pointer<Byte> &lhs, RValue<UInt> offset);
+	RValue<Pointer<Byte>> operator+=(Pointer<Byte> &lhs, int offset);
+	RValue<Pointer<Byte>> operator+=(Pointer<Byte> &lhs, RValue<Int> offset);
+	RValue<Pointer<Byte>> operator+=(Pointer<Byte> &lhs, RValue<UInt> offset);
 
 	RValue<Pointer<Byte>> operator-(RValue<Pointer<Byte>> lhs, int offset);
 	RValue<Pointer<Byte>> operator-(RValue<Pointer<Byte>> lhs, RValue<Int> offset);
 	RValue<Pointer<Byte>> operator-(RValue<Pointer<Byte>> lhs, RValue<UInt> offset);
-	RValue<Pointer<Byte>> operator-=(const Pointer<Byte> &lhs, int offset);
-	RValue<Pointer<Byte>> operator-=(const Pointer<Byte> &lhs, RValue<Int> offset);
-	RValue<Pointer<Byte>> operator-=(const Pointer<Byte> &lhs, RValue<UInt> offset);
+	RValue<Pointer<Byte>> operator-=(Pointer<Byte> &lhs, int offset);
+	RValue<Pointer<Byte>> operator-=(Pointer<Byte> &lhs, RValue<Int> offset);
+	RValue<Pointer<Byte>> operator-=(Pointer<Byte> &lhs, RValue<UInt> offset);
 
 	template<class T, int S = 1>
 	class Array : public LValue<T>
@@ -2216,10 +2216,10 @@
 		Reference<T> operator[](RValue<Int> index);
 	};
 
-//	RValue<Array<T>> operator++(const Array<T> &val, int);   // Post-increment
-//	const Array<T> &operator++(const Array<T> &val);   // Pre-increment
-//	RValue<Array<T>> operator--(const Array<T> &val, int);   // Post-decrement
-//	const Array<T> &operator--(const Array<T> &val);   // Pre-decrement
+//	RValue<Array<T>> operator++(Array<T> &val, int);   // Post-increment
+//	const Array<T> &operator++(Array<T> &val);   // Pre-increment
+//	RValue<Array<T>> operator--(Array<T> &val, int);   // Post-decrement
+//	const Array<T> &operator--(Array<T> &val);   // Pre-decrement
 
 	bool branch(RValue<Bool> cmp, BasicBlock *bodyBB, BasicBlock *endBB);
 
@@ -2417,13 +2417,13 @@
 	}
 
 	template<int T>
-	RValue<Float4> SwizzleMaskFloat4<T>::operator=(RValue<Float4> rhs) const
+	RValue<Float4> SwizzleMaskFloat4<T>::operator=(RValue<Float4> rhs)
 	{
 		return Mask(*parent, rhs, T);
 	}
 
 	template<int T>
-	RValue<Float4> SwizzleMaskFloat4<T>::operator=(RValue<Float> rhs) const
+	RValue<Float4> SwizzleMaskFloat4<T>::operator=(RValue<Float> rhs)
 	{
 		return Mask(*parent, Float4(rhs), T);
 	}
@@ -2443,19 +2443,19 @@
 	}
 
 	template<int T>
-	RValue<Float4> SwizzleMask1Float4<T>::operator=(float x) const
+	RValue<Float4> SwizzleMask1Float4<T>::operator=(float x)
 	{
 		return *parent = Insert(*parent, Float(x), T & 0x3);
 	}
 
 	template<int T>
-	RValue<Float4> SwizzleMask1Float4<T>::operator=(RValue<Float4> rhs) const
+	RValue<Float4> SwizzleMask1Float4<T>::operator=(RValue<Float4> rhs)
 	{
 		return Mask(*parent, Float4(rhs), T);
 	}
 
 	template<int T>
-	RValue<Float4> SwizzleMask1Float4<T>::operator=(RValue<Float> rhs) const   // FIXME: Call a non-template function
+	RValue<Float4> SwizzleMask1Float4<T>::operator=(RValue<Float> rhs)   // FIXME: Call a non-template function
 	{
 		return *parent = Insert(*parent, rhs, T & 0x3);
 	}
@@ -2469,7 +2469,7 @@
 	}
 
 	template<int T>
-	RValue<Float4> SwizzleMask2Float4<T>::operator=(RValue<Float4> rhs) const
+	RValue<Float4> SwizzleMask2Float4<T>::operator=(RValue<Float4> rhs)
 	{
 		return Mask(*parent, Float4(rhs), T);
 	}
@@ -2481,7 +2481,7 @@
 	}
 
 	template<int T>
-	RValue<Float> Float::operator=(const SwizzleMask1Float4<T> &rhs) const
+	RValue<Float> Float::operator=(const SwizzleMask1Float4<T> &rhs)
 	{
 		return *this = rhs.operator RValue<Float>();
 	}
@@ -2587,7 +2587,7 @@
 	}
 
 	template<class T>
-	RValue<Pointer<T>> Pointer<T>::operator=(RValue<Pointer<T>> rhs) const
+	RValue<Pointer<T>> Pointer<T>::operator=(RValue<Pointer<T>> rhs)
 	{
 		LValue<Pointer<T>>::storeValue(rhs.value);
 
@@ -2595,7 +2595,7 @@
 	}
 
 	template<class T>
-	RValue<Pointer<T>> Pointer<T>::operator=(const Pointer<T> &rhs) const
+	RValue<Pointer<T>> Pointer<T>::operator=(const Pointer<T> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		LValue<Pointer<T>>::storeValue(value);
@@ -2604,7 +2604,7 @@
 	}
 
 	template<class T>
-	RValue<Pointer<T>> Pointer<T>::operator=(const Reference<Pointer<T>> &rhs) const
+	RValue<Pointer<T>> Pointer<T>::operator=(const Reference<Pointer<T>> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		LValue<Pointer<T>>::storeValue(value);
@@ -2662,25 +2662,25 @@
 	}
 
 //	template<class T>
-//	RValue<Array<T>> operator++(const Array<T> &val, int)
+//	RValue<Array<T>> operator++(Array<T> &val, int)
 //	{
 //		// FIXME: Requires storing the address of the array
 //	}
 
 //	template<class T>
-//	const Array<T> &operator++(const Array<T> &val)
+//	const Array<T> &operator++(Array<T> &val)
 //	{
 //		// FIXME: Requires storing the address of the array
 //	}
 
 //	template<class T>
-//	RValue<Array<T>> operator--(const Array<T> &val, int)
+//	RValue<Array<T>> operator--(Array<T> &val, int)
 //	{
 //		// FIXME: Requires storing the address of the array
 //	}
 
 //	template<class T>
-//	const Array<T> &operator--(const Array<T> &val)
+//	const Array<T> &operator--(Array<T> &val)
 //	{
 //		// FIXME: Requires storing the address of the array
 //	}
diff --git a/src/Reactor/SubzeroReactor.cpp b/src/Reactor/SubzeroReactor.cpp
index db2294a..eab0bf7 100644
--- a/src/Reactor/SubzeroReactor.cpp
+++ b/src/Reactor/SubzeroReactor.cpp
@@ -1318,14 +1318,14 @@
 		storeValue(value);
 	}
 
-	RValue<Bool> Bool::operator=(RValue<Bool> rhs) const
+	RValue<Bool> Bool::operator=(RValue<Bool> rhs)
 	{
 		storeValue(rhs.value);
 
 		return rhs;
 	}
 
-	RValue<Bool> Bool::operator=(const Bool &rhs) const
+	RValue<Bool> Bool::operator=(const Bool &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -1333,7 +1333,7 @@
 		return RValue<Bool>(value);
 	}
 
-	RValue<Bool> Bool::operator=(const Reference<Bool> &rhs) const
+	RValue<Bool> Bool::operator=(const Reference<Bool> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -1418,14 +1418,14 @@
 		storeValue(value);
 	}
 
-	RValue<Byte> Byte::operator=(RValue<Byte> rhs) const
+	RValue<Byte> Byte::operator=(RValue<Byte> rhs)
 	{
 		storeValue(rhs.value);
 
 		return rhs;
 	}
 
-	RValue<Byte> Byte::operator=(const Byte &rhs) const
+	RValue<Byte> Byte::operator=(const Byte &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -1433,7 +1433,7 @@
 		return RValue<Byte>(value);
 	}
 
-	RValue<Byte> Byte::operator=(const Reference<Byte> &rhs) const
+	RValue<Byte> Byte::operator=(const Reference<Byte> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -1491,52 +1491,52 @@
 		return RValue<Byte>(Nucleus::createLShr(lhs.value, rhs.value));
 	}
 
-	RValue<Byte> operator+=(const Byte &lhs, RValue<Byte> rhs)
+	RValue<Byte> operator+=(Byte &lhs, RValue<Byte> rhs)
 	{
 		return lhs = lhs + rhs;
 	}
 
-	RValue<Byte> operator-=(const Byte &lhs, RValue<Byte> rhs)
+	RValue<Byte> operator-=(Byte &lhs, RValue<Byte> rhs)
 	{
 		return lhs = lhs - rhs;
 	}
 
-	RValue<Byte> operator*=(const Byte &lhs, RValue<Byte> rhs)
+	RValue<Byte> operator*=(Byte &lhs, RValue<Byte> rhs)
 	{
 		return lhs = lhs * rhs;
 	}
 
-	RValue<Byte> operator/=(const Byte &lhs, RValue<Byte> rhs)
+	RValue<Byte> operator/=(Byte &lhs, RValue<Byte> rhs)
 	{
 		return lhs = lhs / rhs;
 	}
 
-	RValue<Byte> operator%=(const Byte &lhs, RValue<Byte> rhs)
+	RValue<Byte> operator%=(Byte &lhs, RValue<Byte> rhs)
 	{
 		return lhs = lhs % rhs;
 	}
 
-	RValue<Byte> operator&=(const Byte &lhs, RValue<Byte> rhs)
+	RValue<Byte> operator&=(Byte &lhs, RValue<Byte> rhs)
 	{
 		return lhs = lhs & rhs;
 	}
 
-	RValue<Byte> operator|=(const Byte &lhs, RValue<Byte> rhs)
+	RValue<Byte> operator|=(Byte &lhs, RValue<Byte> rhs)
 	{
 		return lhs = lhs | rhs;
 	}
 
-	RValue<Byte> operator^=(const Byte &lhs, RValue<Byte> rhs)
+	RValue<Byte> operator^=(Byte &lhs, RValue<Byte> rhs)
 	{
 		return lhs = lhs ^ rhs;
 	}
 
-	RValue<Byte> operator<<=(const Byte &lhs, RValue<Byte> rhs)
+	RValue<Byte> operator<<=(Byte &lhs, RValue<Byte> rhs)
 	{
 		return lhs = lhs << rhs;
 	}
 
-	RValue<Byte> operator>>=(const Byte &lhs, RValue<Byte> rhs)
+	RValue<Byte> operator>>=(Byte &lhs, RValue<Byte> rhs)
 	{
 		return lhs = lhs >> rhs;
 	}
@@ -1556,27 +1556,27 @@
 		return RValue<Byte>(Nucleus::createNot(val.value));
 	}
 
-	RValue<Byte> operator++(const Byte &val, int)   // Post-increment
+	RValue<Byte> operator++(Byte &val, int)   // Post-increment
 	{
 		RValue<Byte> res = val;
 		val += Byte(1);
 		return res;
 	}
 
-	const Byte &operator++(const Byte &val)   // Pre-increment
+	const Byte &operator++(Byte &val)   // Pre-increment
 	{
 		val += Byte(1);
 		return val;
 	}
 
-	RValue<Byte> operator--(const Byte &val, int)   // Post-decrement
+	RValue<Byte> operator--(Byte &val, int)   // Post-decrement
 	{
 		RValue<Byte> res = val;
 		val -= Byte(1);
 		return res;
 	}
 
-	const Byte &operator--(const Byte &val)   // Pre-decrement
+	const Byte &operator--(Byte &val)   // Pre-decrement
 	{
 		val -= Byte(1);
 		return val;
@@ -1662,14 +1662,14 @@
 		storeValue(value);
 	}
 
-	RValue<SByte> SByte::operator=(RValue<SByte> rhs) const
+	RValue<SByte> SByte::operator=(RValue<SByte> rhs)
 	{
 		storeValue(rhs.value);
 
 		return rhs;
 	}
 
-	RValue<SByte> SByte::operator=(const SByte &rhs) const
+	RValue<SByte> SByte::operator=(const SByte &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -1677,7 +1677,7 @@
 		return RValue<SByte>(value);
 	}
 
-	RValue<SByte> SByte::operator=(const Reference<SByte> &rhs) const
+	RValue<SByte> SByte::operator=(const Reference<SByte> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -1735,52 +1735,52 @@
 		return RValue<SByte>(Nucleus::createAShr(lhs.value, rhs.value));
 	}
 
-	RValue<SByte> operator+=(const SByte &lhs, RValue<SByte> rhs)
+	RValue<SByte> operator+=(SByte &lhs, RValue<SByte> rhs)
 	{
 		return lhs = lhs + rhs;
 	}
 
-	RValue<SByte> operator-=(const SByte &lhs, RValue<SByte> rhs)
+	RValue<SByte> operator-=(SByte &lhs, RValue<SByte> rhs)
 	{
 		return lhs = lhs - rhs;
 	}
 
-	RValue<SByte> operator*=(const SByte &lhs, RValue<SByte> rhs)
+	RValue<SByte> operator*=(SByte &lhs, RValue<SByte> rhs)
 	{
 		return lhs = lhs * rhs;
 	}
 
-	RValue<SByte> operator/=(const SByte &lhs, RValue<SByte> rhs)
+	RValue<SByte> operator/=(SByte &lhs, RValue<SByte> rhs)
 	{
 		return lhs = lhs / rhs;
 	}
 
-	RValue<SByte> operator%=(const SByte &lhs, RValue<SByte> rhs)
+	RValue<SByte> operator%=(SByte &lhs, RValue<SByte> rhs)
 	{
 		return lhs = lhs % rhs;
 	}
 
-	RValue<SByte> operator&=(const SByte &lhs, RValue<SByte> rhs)
+	RValue<SByte> operator&=(SByte &lhs, RValue<SByte> rhs)
 	{
 		return lhs = lhs & rhs;
 	}
 
-	RValue<SByte> operator|=(const SByte &lhs, RValue<SByte> rhs)
+	RValue<SByte> operator|=(SByte &lhs, RValue<SByte> rhs)
 	{
 		return lhs = lhs | rhs;
 	}
 
-	RValue<SByte> operator^=(const SByte &lhs, RValue<SByte> rhs)
+	RValue<SByte> operator^=(SByte &lhs, RValue<SByte> rhs)
 	{
 		return lhs = lhs ^ rhs;
 	}
 
-	RValue<SByte> operator<<=(const SByte &lhs, RValue<SByte> rhs)
+	RValue<SByte> operator<<=(SByte &lhs, RValue<SByte> rhs)
 	{
 		return lhs = lhs << rhs;
 	}
 
-	RValue<SByte> operator>>=(const SByte &lhs, RValue<SByte> rhs)
+	RValue<SByte> operator>>=(SByte &lhs, RValue<SByte> rhs)
 	{
 		return lhs = lhs >> rhs;
 	}
@@ -1800,27 +1800,27 @@
 		return RValue<SByte>(Nucleus::createNot(val.value));
 	}
 
-	RValue<SByte> operator++(const SByte &val, int)   // Post-increment
+	RValue<SByte> operator++(SByte &val, int)   // Post-increment
 	{
 		RValue<SByte> res = val;
 		val += SByte(1);
 		return res;
 	}
 
-	const SByte &operator++(const SByte &val)   // Pre-increment
+	const SByte &operator++(SByte &val)   // Pre-increment
 	{
 		val += SByte(1);
 		return val;
 	}
 
-	RValue<SByte> operator--(const SByte &val, int)   // Post-decrement
+	RValue<SByte> operator--(SByte &val, int)   // Post-decrement
 	{
 		RValue<SByte> res = val;
 		val -= SByte(1);
 		return res;
 	}
 
-	const SByte &operator--(const SByte &val)   // Pre-decrement
+	const SByte &operator--(SByte &val)   // Pre-decrement
 	{
 		val -= SByte(1);
 		return val;
@@ -1899,14 +1899,14 @@
 		storeValue(value);
 	}
 
-	RValue<Short> Short::operator=(RValue<Short> rhs) const
+	RValue<Short> Short::operator=(RValue<Short> rhs)
 	{
 		storeValue(rhs.value);
 
 		return rhs;
 	}
 
-	RValue<Short> Short::operator=(const Short &rhs) const
+	RValue<Short> Short::operator=(const Short &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -1914,7 +1914,7 @@
 		return RValue<Short>(value);
 	}
 
-	RValue<Short> Short::operator=(const Reference<Short> &rhs) const
+	RValue<Short> Short::operator=(const Reference<Short> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -1972,52 +1972,52 @@
 		return RValue<Short>(Nucleus::createAShr(lhs.value, rhs.value));
 	}
 
-	RValue<Short> operator+=(const Short &lhs, RValue<Short> rhs)
+	RValue<Short> operator+=(Short &lhs, RValue<Short> rhs)
 	{
 		return lhs = lhs + rhs;
 	}
 
-	RValue<Short> operator-=(const Short &lhs, RValue<Short> rhs)
+	RValue<Short> operator-=(Short &lhs, RValue<Short> rhs)
 	{
 		return lhs = lhs - rhs;
 	}
 
-	RValue<Short> operator*=(const Short &lhs, RValue<Short> rhs)
+	RValue<Short> operator*=(Short &lhs, RValue<Short> rhs)
 	{
 		return lhs = lhs * rhs;
 	}
 
-	RValue<Short> operator/=(const Short &lhs, RValue<Short> rhs)
+	RValue<Short> operator/=(Short &lhs, RValue<Short> rhs)
 	{
 		return lhs = lhs / rhs;
 	}
 
-	RValue<Short> operator%=(const Short &lhs, RValue<Short> rhs)
+	RValue<Short> operator%=(Short &lhs, RValue<Short> rhs)
 	{
 		return lhs = lhs % rhs;
 	}
 
-	RValue<Short> operator&=(const Short &lhs, RValue<Short> rhs)
+	RValue<Short> operator&=(Short &lhs, RValue<Short> rhs)
 	{
 		return lhs = lhs & rhs;
 	}
 
-	RValue<Short> operator|=(const Short &lhs, RValue<Short> rhs)
+	RValue<Short> operator|=(Short &lhs, RValue<Short> rhs)
 	{
 		return lhs = lhs | rhs;
 	}
 
-	RValue<Short> operator^=(const Short &lhs, RValue<Short> rhs)
+	RValue<Short> operator^=(Short &lhs, RValue<Short> rhs)
 	{
 		return lhs = lhs ^ rhs;
 	}
 
-	RValue<Short> operator<<=(const Short &lhs, RValue<Short> rhs)
+	RValue<Short> operator<<=(Short &lhs, RValue<Short> rhs)
 	{
 		return lhs = lhs << rhs;
 	}
 
-	RValue<Short> operator>>=(const Short &lhs, RValue<Short> rhs)
+	RValue<Short> operator>>=(Short &lhs, RValue<Short> rhs)
 	{
 		return lhs = lhs >> rhs;
 	}
@@ -2037,27 +2037,27 @@
 		return RValue<Short>(Nucleus::createNot(val.value));
 	}
 
-	RValue<Short> operator++(const Short &val, int)   // Post-increment
+	RValue<Short> operator++(Short &val, int)   // Post-increment
 	{
 		RValue<Short> res = val;
 		val += Short(1);
 		return res;
 	}
 
-	const Short &operator++(const Short &val)   // Pre-increment
+	const Short &operator++(Short &val)   // Pre-increment
 	{
 		val += Short(1);
 		return val;
 	}
 
-	RValue<Short> operator--(const Short &val, int)   // Post-decrement
+	RValue<Short> operator--(Short &val, int)   // Post-decrement
 	{
 		RValue<Short> res = val;
 		val -= Short(1);
 		return res;
 	}
 
-	const Short &operator--(const Short &val)   // Pre-decrement
+	const Short &operator--(Short &val)   // Pre-decrement
 	{
 		val -= Short(1);
 		return val;
@@ -2143,14 +2143,14 @@
 		storeValue(value);
 	}
 
-	RValue<UShort> UShort::operator=(RValue<UShort> rhs) const
+	RValue<UShort> UShort::operator=(RValue<UShort> rhs)
 	{
 		storeValue(rhs.value);
 
 		return rhs;
 	}
 
-	RValue<UShort> UShort::operator=(const UShort &rhs) const
+	RValue<UShort> UShort::operator=(const UShort &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -2158,7 +2158,7 @@
 		return RValue<UShort>(value);
 	}
 
-	RValue<UShort> UShort::operator=(const Reference<UShort> &rhs) const
+	RValue<UShort> UShort::operator=(const Reference<UShort> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -2216,52 +2216,52 @@
 		return RValue<UShort>(Nucleus::createLShr(lhs.value, rhs.value));
 	}
 
-	RValue<UShort> operator+=(const UShort &lhs, RValue<UShort> rhs)
+	RValue<UShort> operator+=(UShort &lhs, RValue<UShort> rhs)
 	{
 		return lhs = lhs + rhs;
 	}
 
-	RValue<UShort> operator-=(const UShort &lhs, RValue<UShort> rhs)
+	RValue<UShort> operator-=(UShort &lhs, RValue<UShort> rhs)
 	{
 		return lhs = lhs - rhs;
 	}
 
-	RValue<UShort> operator*=(const UShort &lhs, RValue<UShort> rhs)
+	RValue<UShort> operator*=(UShort &lhs, RValue<UShort> rhs)
 	{
 		return lhs = lhs * rhs;
 	}
 
-	RValue<UShort> operator/=(const UShort &lhs, RValue<UShort> rhs)
+	RValue<UShort> operator/=(UShort &lhs, RValue<UShort> rhs)
 	{
 		return lhs = lhs / rhs;
 	}
 
-	RValue<UShort> operator%=(const UShort &lhs, RValue<UShort> rhs)
+	RValue<UShort> operator%=(UShort &lhs, RValue<UShort> rhs)
 	{
 		return lhs = lhs % rhs;
 	}
 
-	RValue<UShort> operator&=(const UShort &lhs, RValue<UShort> rhs)
+	RValue<UShort> operator&=(UShort &lhs, RValue<UShort> rhs)
 	{
 		return lhs = lhs & rhs;
 	}
 
-	RValue<UShort> operator|=(const UShort &lhs, RValue<UShort> rhs)
+	RValue<UShort> operator|=(UShort &lhs, RValue<UShort> rhs)
 	{
 		return lhs = lhs | rhs;
 	}
 
-	RValue<UShort> operator^=(const UShort &lhs, RValue<UShort> rhs)
+	RValue<UShort> operator^=(UShort &lhs, RValue<UShort> rhs)
 	{
 		return lhs = lhs ^ rhs;
 	}
 
-	RValue<UShort> operator<<=(const UShort &lhs, RValue<UShort> rhs)
+	RValue<UShort> operator<<=(UShort &lhs, RValue<UShort> rhs)
 	{
 		return lhs = lhs << rhs;
 	}
 
-	RValue<UShort> operator>>=(const UShort &lhs, RValue<UShort> rhs)
+	RValue<UShort> operator>>=(UShort &lhs, RValue<UShort> rhs)
 	{
 		return lhs = lhs >> rhs;
 	}
@@ -2281,27 +2281,27 @@
 		return RValue<UShort>(Nucleus::createNot(val.value));
 	}
 
-	RValue<UShort> operator++(const UShort &val, int)   // Post-increment
+	RValue<UShort> operator++(UShort &val, int)   // Post-increment
 	{
 		RValue<UShort> res = val;
 		val += UShort(1);
 		return res;
 	}
 
-	const UShort &operator++(const UShort &val)   // Pre-increment
+	const UShort &operator++(UShort &val)   // Pre-increment
 	{
 		val += UShort(1);
 		return val;
 	}
 
-	RValue<UShort> operator--(const UShort &val, int)   // Post-decrement
+	RValue<UShort> operator--(UShort &val, int)   // Post-decrement
 	{
 		RValue<UShort> res = val;
 		val -= UShort(1);
 		return res;
 	}
 
-	const UShort &operator--(const UShort &val)   // Pre-decrement
+	const UShort &operator--(UShort &val)   // Pre-decrement
 	{
 		val -= UShort(1);
 		return val;
@@ -2394,14 +2394,14 @@
 		storeValue(value);
 	}
 
-	RValue<Byte8> Byte8::operator=(RValue<Byte8> rhs) const
+	RValue<Byte8> Byte8::operator=(RValue<Byte8> rhs)
 	{
 		storeValue(rhs.value);
 
 		return rhs;
 	}
 
-	RValue<Byte8> Byte8::operator=(const Byte8 &rhs) const
+	RValue<Byte8> Byte8::operator=(const Byte8 &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -2409,7 +2409,7 @@
 		return RValue<Byte8>(value);
 	}
 
-	RValue<Byte8> Byte8::operator=(const Reference<Byte8> &rhs) const
+	RValue<Byte8> Byte8::operator=(const Reference<Byte8> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -2467,52 +2467,52 @@
 //		return RValue<Byte8>(Nucleus::createLShr(lhs.value, C(::context->getConstantInt32(rhs))));
 //	}
 
-	RValue<Byte8> operator+=(const Byte8 &lhs, RValue<Byte8> rhs)
+	RValue<Byte8> operator+=(Byte8 &lhs, RValue<Byte8> rhs)
 	{
 		return lhs = lhs + rhs;
 	}
 
-	RValue<Byte8> operator-=(const Byte8 &lhs, RValue<Byte8> rhs)
+	RValue<Byte8> operator-=(Byte8 &lhs, RValue<Byte8> rhs)
 	{
 		return lhs = lhs - rhs;
 	}
 
-//	RValue<Byte8> operator*=(const Byte8 &lhs, RValue<Byte8> rhs)
+//	RValue<Byte8> operator*=(Byte8 &lhs, RValue<Byte8> rhs)
 //	{
 //		return lhs = lhs * rhs;
 //	}
 
-//	RValue<Byte8> operator/=(const Byte8 &lhs, RValue<Byte8> rhs)
+//	RValue<Byte8> operator/=(Byte8 &lhs, RValue<Byte8> rhs)
 //	{
 //		return lhs = lhs / rhs;
 //	}
 
-//	RValue<Byte8> operator%=(const Byte8 &lhs, RValue<Byte8> rhs)
+//	RValue<Byte8> operator%=(Byte8 &lhs, RValue<Byte8> rhs)
 //	{
 //		return lhs = lhs % rhs;
 //	}
 
-	RValue<Byte8> operator&=(const Byte8 &lhs, RValue<Byte8> rhs)
+	RValue<Byte8> operator&=(Byte8 &lhs, RValue<Byte8> rhs)
 	{
 		return lhs = lhs & rhs;
 	}
 
-	RValue<Byte8> operator|=(const Byte8 &lhs, RValue<Byte8> rhs)
+	RValue<Byte8> operator|=(Byte8 &lhs, RValue<Byte8> rhs)
 	{
 		return lhs = lhs | rhs;
 	}
 
-	RValue<Byte8> operator^=(const Byte8 &lhs, RValue<Byte8> rhs)
+	RValue<Byte8> operator^=(Byte8 &lhs, RValue<Byte8> rhs)
 	{
 		return lhs = lhs ^ rhs;
 	}
 
-//	RValue<Byte8> operator<<=(const Byte8 &lhs, RValue<Byte8> rhs)
+//	RValue<Byte8> operator<<=(Byte8 &lhs, RValue<Byte8> rhs)
 //	{
 //		return lhs = lhs << rhs;
 //	}
 
-//	RValue<Byte8> operator>>=(const Byte8 &lhs, RValue<Byte8> rhs)
+//	RValue<Byte8> operator>>=(Byte8 &lhs, RValue<Byte8> rhs)
 //	{
 //		return lhs = lhs >> rhs;
 //	}
@@ -2642,14 +2642,14 @@
 		storeValue(value);
 	}
 
-	RValue<SByte8> SByte8::operator=(RValue<SByte8> rhs) const
+	RValue<SByte8> SByte8::operator=(RValue<SByte8> rhs)
 	{
 		storeValue(rhs.value);
 
 		return rhs;
 	}
 
-	RValue<SByte8> SByte8::operator=(const SByte8 &rhs) const
+	RValue<SByte8> SByte8::operator=(const SByte8 &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -2657,7 +2657,7 @@
 		return RValue<SByte8>(value);
 	}
 
-	RValue<SByte8> SByte8::operator=(const Reference<SByte8> &rhs) const
+	RValue<SByte8> SByte8::operator=(const Reference<SByte8> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -2715,52 +2715,52 @@
 //		return RValue<SByte8>(Nucleus::createAShr(lhs.value, C(::context->getConstantInt32(rhs))));
 //	}
 
-	RValue<SByte8> operator+=(const SByte8 &lhs, RValue<SByte8> rhs)
+	RValue<SByte8> operator+=(SByte8 &lhs, RValue<SByte8> rhs)
 	{
 		return lhs = lhs + rhs;
 	}
 
-	RValue<SByte8> operator-=(const SByte8 &lhs, RValue<SByte8> rhs)
+	RValue<SByte8> operator-=(SByte8 &lhs, RValue<SByte8> rhs)
 	{
 		return lhs = lhs - rhs;
 	}
 
-//	RValue<SByte8> operator*=(const SByte8 &lhs, RValue<SByte8> rhs)
+//	RValue<SByte8> operator*=(SByte8 &lhs, RValue<SByte8> rhs)
 //	{
 //		return lhs = lhs * rhs;
 //	}
 
-//	RValue<SByte8> operator/=(const SByte8 &lhs, RValue<SByte8> rhs)
+//	RValue<SByte8> operator/=(SByte8 &lhs, RValue<SByte8> rhs)
 //	{
 //		return lhs = lhs / rhs;
 //	}
 
-//	RValue<SByte8> operator%=(const SByte8 &lhs, RValue<SByte8> rhs)
+//	RValue<SByte8> operator%=(SByte8 &lhs, RValue<SByte8> rhs)
 //	{
 //		return lhs = lhs % rhs;
 //	}
 
-	RValue<SByte8> operator&=(const SByte8 &lhs, RValue<SByte8> rhs)
+	RValue<SByte8> operator&=(SByte8 &lhs, RValue<SByte8> rhs)
 	{
 		return lhs = lhs & rhs;
 	}
 
-	RValue<SByte8> operator|=(const SByte8 &lhs, RValue<SByte8> rhs)
+	RValue<SByte8> operator|=(SByte8 &lhs, RValue<SByte8> rhs)
 	{
 		return lhs = lhs | rhs;
 	}
 
-	RValue<SByte8> operator^=(const SByte8 &lhs, RValue<SByte8> rhs)
+	RValue<SByte8> operator^=(SByte8 &lhs, RValue<SByte8> rhs)
 	{
 		return lhs = lhs ^ rhs;
 	}
 
-//	RValue<SByte8> operator<<=(const SByte8 &lhs, RValue<SByte8> rhs)
+//	RValue<SByte8> operator<<=(SByte8 &lhs, RValue<SByte8> rhs)
 //	{
 //		return lhs = lhs << rhs;
 //	}
 
-//	RValue<SByte8> operator>>=(const SByte8 &lhs, RValue<SByte8> rhs)
+//	RValue<SByte8> operator>>=(SByte8 &lhs, RValue<SByte8> rhs)
 //	{
 //		return lhs = lhs >> rhs;
 //	}
@@ -2869,14 +2869,14 @@
 		storeValue(value);
 	}
 
-	RValue<Byte16> Byte16::operator=(RValue<Byte16> rhs) const
+	RValue<Byte16> Byte16::operator=(RValue<Byte16> rhs)
 	{
 		storeValue(rhs.value);
 
 		return rhs;
 	}
 
-	RValue<Byte16> Byte16::operator=(const Byte16 &rhs) const
+	RValue<Byte16> Byte16::operator=(const Byte16 &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -2884,7 +2884,7 @@
 		return RValue<Byte16>(value);
 	}
 
-	RValue<Byte16> Byte16::operator=(const Reference<Byte16> &rhs) const
+	RValue<Byte16> Byte16::operator=(const Reference<Byte16> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -3017,14 +3017,14 @@
 		storeValue(rhs.loadValue());
 	}
 
-	RValue<Short4> Short4::operator=(RValue<Short4> rhs) const
+	RValue<Short4> Short4::operator=(RValue<Short4> rhs)
 	{
 		storeValue(rhs.value);
 
 		return rhs;
 	}
 
-	RValue<Short4> Short4::operator=(const Short4 &rhs) const
+	RValue<Short4> Short4::operator=(const Short4 &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -3032,7 +3032,7 @@
 		return RValue<Short4>(value);
 	}
 
-	RValue<Short4> Short4::operator=(const Reference<Short4> &rhs) const
+	RValue<Short4> Short4::operator=(const Reference<Short4> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -3040,14 +3040,14 @@
 		return RValue<Short4>(value);
 	}
 
-	RValue<Short4> Short4::operator=(RValue<UShort4> rhs) const
+	RValue<Short4> Short4::operator=(RValue<UShort4> rhs)
 	{
 		storeValue(rhs.value);
 
 		return RValue<Short4>(rhs);
 	}
 
-	RValue<Short4> Short4::operator=(const UShort4 &rhs) const
+	RValue<Short4> Short4::operator=(const UShort4 &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -3055,7 +3055,7 @@
 		return RValue<Short4>(value);
 	}
 
-	RValue<Short4> Short4::operator=(const Reference<UShort4> &rhs) const
+	RValue<Short4> Short4::operator=(const Reference<UShort4> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -3127,62 +3127,62 @@
 		assert(false && "UNIMPLEMENTED"); return RValue<Short4>(V(nullptr));
 	}
 
-	RValue<Short4> operator+=(const Short4 &lhs, RValue<Short4> rhs)
+	RValue<Short4> operator+=(Short4 &lhs, RValue<Short4> rhs)
 	{
 		return lhs = lhs + rhs;
 	}
 
-	RValue<Short4> operator-=(const Short4 &lhs, RValue<Short4> rhs)
+	RValue<Short4> operator-=(Short4 &lhs, RValue<Short4> rhs)
 	{
 		return lhs = lhs - rhs;
 	}
 
-	RValue<Short4> operator*=(const Short4 &lhs, RValue<Short4> rhs)
+	RValue<Short4> operator*=(Short4 &lhs, RValue<Short4> rhs)
 	{
 		return lhs = lhs * rhs;
 	}
 
-//	RValue<Short4> operator/=(const Short4 &lhs, RValue<Short4> rhs)
+//	RValue<Short4> operator/=(Short4 &lhs, RValue<Short4> rhs)
 //	{
 //		return lhs = lhs / rhs;
 //	}
 
-//	RValue<Short4> operator%=(const Short4 &lhs, RValue<Short4> rhs)
+//	RValue<Short4> operator%=(Short4 &lhs, RValue<Short4> rhs)
 //	{
 //		return lhs = lhs % rhs;
 //	}
 
-	RValue<Short4> operator&=(const Short4 &lhs, RValue<Short4> rhs)
+	RValue<Short4> operator&=(Short4 &lhs, RValue<Short4> rhs)
 	{
 		return lhs = lhs & rhs;
 	}
 
-	RValue<Short4> operator|=(const Short4 &lhs, RValue<Short4> rhs)
+	RValue<Short4> operator|=(Short4 &lhs, RValue<Short4> rhs)
 	{
 		return lhs = lhs | rhs;
 	}
 
-	RValue<Short4> operator^=(const Short4 &lhs, RValue<Short4> rhs)
+	RValue<Short4> operator^=(Short4 &lhs, RValue<Short4> rhs)
 	{
 		return lhs = lhs ^ rhs;
 	}
 
-	RValue<Short4> operator<<=(const Short4 &lhs, unsigned char rhs)
+	RValue<Short4> operator<<=(Short4 &lhs, unsigned char rhs)
 	{
 		return lhs = lhs << rhs;
 	}
 
-	RValue<Short4> operator>>=(const Short4 &lhs, unsigned char rhs)
+	RValue<Short4> operator>>=(Short4 &lhs, unsigned char rhs)
 	{
 		return lhs = lhs >> rhs;
 	}
 
-	RValue<Short4> operator<<=(const Short4 &lhs, RValue<Long1> rhs)
+	RValue<Short4> operator<<=(Short4 &lhs, RValue<Long1> rhs)
 	{
 		return lhs = lhs << rhs;
 	}
 
-	RValue<Short4> operator>>=(const Short4 &lhs, RValue<Long1> rhs)
+	RValue<Short4> operator>>=(Short4 &lhs, RValue<Long1> rhs)
 	{
 		return lhs = lhs >> rhs;
 	}
@@ -3447,14 +3447,14 @@
 		storeValue(value);
 	}
 
-	RValue<UShort4> UShort4::operator=(RValue<UShort4> rhs) const
+	RValue<UShort4> UShort4::operator=(RValue<UShort4> rhs)
 	{
 		storeValue(rhs.value);
 
 		return rhs;
 	}
 
-	RValue<UShort4> UShort4::operator=(const UShort4 &rhs) const
+	RValue<UShort4> UShort4::operator=(const UShort4 &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -3462,7 +3462,7 @@
 		return RValue<UShort4>(value);
 	}
 
-	RValue<UShort4> UShort4::operator=(const Reference<UShort4> &rhs) const
+	RValue<UShort4> UShort4::operator=(const Reference<UShort4> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -3470,14 +3470,14 @@
 		return RValue<UShort4>(value);
 	}
 
-	RValue<UShort4> UShort4::operator=(RValue<Short4> rhs) const
+	RValue<UShort4> UShort4::operator=(RValue<Short4> rhs)
 	{
 		storeValue(rhs.value);
 
 		return RValue<UShort4>(rhs);
 	}
 
-	RValue<UShort4> UShort4::operator=(const Short4 &rhs) const
+	RValue<UShort4> UShort4::operator=(const Short4 &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -3485,7 +3485,7 @@
 		return RValue<UShort4>(value);
 	}
 
-	RValue<UShort4> UShort4::operator=(const Reference<Short4> &rhs) const
+	RValue<UShort4> UShort4::operator=(const Reference<Short4> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -3543,22 +3543,22 @@
 		assert(false && "UNIMPLEMENTED"); return RValue<UShort4>(V(nullptr));
 	}
 
-	RValue<UShort4> operator<<=(const UShort4 &lhs, unsigned char rhs)
+	RValue<UShort4> operator<<=(UShort4 &lhs, unsigned char rhs)
 	{
 		return lhs = lhs << rhs;
 	}
 
-	RValue<UShort4> operator>>=(const UShort4 &lhs, unsigned char rhs)
+	RValue<UShort4> operator>>=(UShort4 &lhs, unsigned char rhs)
 	{
 		return lhs = lhs >> rhs;
 	}
 
-	RValue<UShort4> operator<<=(const UShort4 &lhs, RValue<Long1> rhs)
+	RValue<UShort4> operator<<=(UShort4 &lhs, RValue<Long1> rhs)
 	{
 		return lhs = lhs << rhs;
 	}
 
-	RValue<UShort4> operator>>=(const UShort4 &lhs, RValue<Long1> rhs)
+	RValue<UShort4> operator>>=(UShort4 &lhs, RValue<Long1> rhs)
 	{
 		return lhs = lhs >> rhs;
 	}
@@ -3747,14 +3747,14 @@
 		assert(false && "UNIMPLEMENTED");
 	}
 
-	RValue<UShort8> UShort8::operator=(RValue<UShort8> rhs) const
+	RValue<UShort8> UShort8::operator=(RValue<UShort8> rhs)
 	{
 		storeValue(rhs.value);
 
 		return rhs;
 	}
 
-	RValue<UShort8> UShort8::operator=(const UShort8 &rhs) const
+	RValue<UShort8> UShort8::operator=(const UShort8 &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -3762,7 +3762,7 @@
 		return RValue<UShort8>(value);
 	}
 
-	RValue<UShort8> UShort8::operator=(const Reference<UShort8> &rhs) const
+	RValue<UShort8> UShort8::operator=(const Reference<UShort8> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -3795,7 +3795,7 @@
 		return RValue<UShort8>(Nucleus::createMul(lhs.value, rhs.value));
 	}
 
-	RValue<UShort8> operator+=(const UShort8 &lhs, RValue<UShort8> rhs)
+	RValue<UShort8> operator+=(UShort8 &lhs, RValue<UShort8> rhs)
 	{
 		return lhs = lhs + rhs;
 	}
@@ -3921,26 +3921,26 @@
 		storeValue(value);
 	}
 
-	RValue<Int> Int::operator=(int rhs) const
+	RValue<Int> Int::operator=(int rhs)
 	{
 		return RValue<Int>(storeValue(Nucleus::createConstantInt(rhs)));
 	}
 
-	RValue<Int> Int::operator=(RValue<Int> rhs) const
+	RValue<Int> Int::operator=(RValue<Int> rhs)
 	{
 		storeValue(rhs.value);
 
 		return rhs;
 	}
 
-	RValue<Int> Int::operator=(RValue<UInt> rhs) const
+	RValue<Int> Int::operator=(RValue<UInt> rhs)
 	{
 		storeValue(rhs.value);
 
 		return RValue<Int>(rhs);
 	}
 
-	RValue<Int> Int::operator=(const Int &rhs) const
+	RValue<Int> Int::operator=(const Int &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -3948,7 +3948,7 @@
 		return RValue<Int>(value);
 	}
 
-	RValue<Int> Int::operator=(const Reference<Int> &rhs) const
+	RValue<Int> Int::operator=(const Reference<Int> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -3956,7 +3956,7 @@
 		return RValue<Int>(value);
 	}
 
-	RValue<Int> Int::operator=(const UInt &rhs) const
+	RValue<Int> Int::operator=(const UInt &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -3964,7 +3964,7 @@
 		return RValue<Int>(value);
 	}
 
-	RValue<Int> Int::operator=(const Reference<UInt> &rhs) const
+	RValue<Int> Int::operator=(const Reference<UInt> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -4022,52 +4022,52 @@
 		return RValue<Int>(Nucleus::createAShr(lhs.value, rhs.value));
 	}
 
-	RValue<Int> operator+=(const Int &lhs, RValue<Int> rhs)
+	RValue<Int> operator+=(Int &lhs, RValue<Int> rhs)
 	{
 		return lhs = lhs + rhs;
 	}
 
-	RValue<Int> operator-=(const Int &lhs, RValue<Int> rhs)
+	RValue<Int> operator-=(Int &lhs, RValue<Int> rhs)
 	{
 		return lhs = lhs - rhs;
 	}
 
-	RValue<Int> operator*=(const Int &lhs, RValue<Int> rhs)
+	RValue<Int> operator*=(Int &lhs, RValue<Int> rhs)
 	{
 		return lhs = lhs * rhs;
 	}
 
-	RValue<Int> operator/=(const Int &lhs, RValue<Int> rhs)
+	RValue<Int> operator/=(Int &lhs, RValue<Int> rhs)
 	{
 		return lhs = lhs / rhs;
 	}
 
-	RValue<Int> operator%=(const Int &lhs, RValue<Int> rhs)
+	RValue<Int> operator%=(Int &lhs, RValue<Int> rhs)
 	{
 		return lhs = lhs % rhs;
 	}
 
-	RValue<Int> operator&=(const Int &lhs, RValue<Int> rhs)
+	RValue<Int> operator&=(Int &lhs, RValue<Int> rhs)
 	{
 		return lhs = lhs & rhs;
 	}
 
-	RValue<Int> operator|=(const Int &lhs, RValue<Int> rhs)
+	RValue<Int> operator|=(Int &lhs, RValue<Int> rhs)
 	{
 		return lhs = lhs | rhs;
 	}
 
-	RValue<Int> operator^=(const Int &lhs, RValue<Int> rhs)
+	RValue<Int> operator^=(Int &lhs, RValue<Int> rhs)
 	{
 		return lhs = lhs ^ rhs;
 	}
 
-	RValue<Int> operator<<=(const Int &lhs, RValue<Int> rhs)
+	RValue<Int> operator<<=(Int &lhs, RValue<Int> rhs)
 	{
 		return lhs = lhs << rhs;
 	}
 
-	RValue<Int> operator>>=(const Int &lhs, RValue<Int> rhs)
+	RValue<Int> operator>>=(Int &lhs, RValue<Int> rhs)
 	{
 		return lhs = lhs >> rhs;
 	}
@@ -4087,27 +4087,27 @@
 		return RValue<Int>(Nucleus::createNot(val.value));
 	}
 
-	RValue<Int> operator++(const Int &val, int)   // Post-increment
+	RValue<Int> operator++(Int &val, int)   // Post-increment
 	{
 		RValue<UInt> res = val;
 		val += 1;
 		return res;
 	}
 
-	const Int &operator++(const Int &val)   // Pre-increment
+	const Int &operator++(Int &val)   // Pre-increment
 	{
 		val += 1;
 		return val;
 	}
 
-	RValue<Int> operator--(const Int &val, int)   // Post-decrement
+	RValue<Int> operator--(Int &val, int)   // Post-decrement
 	{
 		RValue<Int> res = val;
 		val -= 1;
 		return res;
 	}
 
-	const Int &operator--(const Int &val)   // Pre-decrement
+	const Int &operator--(Int &val)   // Pre-decrement
 	{
 		val -= 1;
 		return val;
@@ -4195,19 +4195,19 @@
 		storeValue(rhs.value);
 	}
 
-	RValue<Long> Long::operator=(int64_t rhs) const
+	RValue<Long> Long::operator=(int64_t rhs)
 	{
 		return RValue<Long>(storeValue(Nucleus::createConstantLong(rhs)));
 	}
 
-	RValue<Long> Long::operator=(RValue<Long> rhs) const
+	RValue<Long> Long::operator=(RValue<Long> rhs)
 	{
 		storeValue(rhs.value);
 
 		return rhs;
 	}
 
-	RValue<Long> Long::operator=(const Long &rhs) const
+	RValue<Long> Long::operator=(const Long &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -4215,7 +4215,7 @@
 		return RValue<Long>(value);
 	}
 
-	RValue<Long> Long::operator=(const Reference<Long> &rhs) const
+	RValue<Long> Long::operator=(const Reference<Long> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -4233,12 +4233,12 @@
 		return RValue<Long>(Nucleus::createSub(lhs.value, rhs.value));
 	}
 
-	RValue<Long> operator+=(const Long &lhs, RValue<Long> rhs)
+	RValue<Long> operator+=(Long &lhs, RValue<Long> rhs)
 	{
 		return lhs = lhs + rhs;
 	}
 
-	RValue<Long> operator-=(const Long &lhs, RValue<Long> rhs)
+	RValue<Long> operator-=(Long &lhs, RValue<Long> rhs)
 	{
 		return lhs = lhs - rhs;
 	}
@@ -4340,26 +4340,26 @@
 		storeValue(value);
 	}
 
-	RValue<UInt> UInt::operator=(unsigned int rhs) const
+	RValue<UInt> UInt::operator=(unsigned int rhs)
 	{
 		return RValue<UInt>(storeValue(Nucleus::createConstantInt(rhs)));
 	}
 
-	RValue<UInt> UInt::operator=(RValue<UInt> rhs) const
+	RValue<UInt> UInt::operator=(RValue<UInt> rhs)
 	{
 		storeValue(rhs.value);
 
 		return rhs;
 	}
 
-	RValue<UInt> UInt::operator=(RValue<Int> rhs) const
+	RValue<UInt> UInt::operator=(RValue<Int> rhs)
 	{
 		storeValue(rhs.value);
 
 		return RValue<UInt>(rhs);
 	}
 
-	RValue<UInt> UInt::operator=(const UInt &rhs) const
+	RValue<UInt> UInt::operator=(const UInt &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -4367,7 +4367,7 @@
 		return RValue<UInt>(value);
 	}
 
-	RValue<UInt> UInt::operator=(const Reference<UInt> &rhs) const
+	RValue<UInt> UInt::operator=(const Reference<UInt> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -4375,7 +4375,7 @@
 		return RValue<UInt>(value);
 	}
 
-	RValue<UInt> UInt::operator=(const Int &rhs) const
+	RValue<UInt> UInt::operator=(const Int &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -4383,7 +4383,7 @@
 		return RValue<UInt>(value);
 	}
 
-	RValue<UInt> UInt::operator=(const Reference<Int> &rhs) const
+	RValue<UInt> UInt::operator=(const Reference<Int> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -4441,52 +4441,52 @@
 		return RValue<UInt>(Nucleus::createLShr(lhs.value, rhs.value));
 	}
 
-	RValue<UInt> operator+=(const UInt &lhs, RValue<UInt> rhs)
+	RValue<UInt> operator+=(UInt &lhs, RValue<UInt> rhs)
 	{
 		return lhs = lhs + rhs;
 	}
 
-	RValue<UInt> operator-=(const UInt &lhs, RValue<UInt> rhs)
+	RValue<UInt> operator-=(UInt &lhs, RValue<UInt> rhs)
 	{
 		return lhs = lhs - rhs;
 	}
 
-	RValue<UInt> operator*=(const UInt &lhs, RValue<UInt> rhs)
+	RValue<UInt> operator*=(UInt &lhs, RValue<UInt> rhs)
 	{
 		return lhs = lhs * rhs;
 	}
 
-	RValue<UInt> operator/=(const UInt &lhs, RValue<UInt> rhs)
+	RValue<UInt> operator/=(UInt &lhs, RValue<UInt> rhs)
 	{
 		return lhs = lhs / rhs;
 	}
 
-	RValue<UInt> operator%=(const UInt &lhs, RValue<UInt> rhs)
+	RValue<UInt> operator%=(UInt &lhs, RValue<UInt> rhs)
 	{
 		return lhs = lhs % rhs;
 	}
 
-	RValue<UInt> operator&=(const UInt &lhs, RValue<UInt> rhs)
+	RValue<UInt> operator&=(UInt &lhs, RValue<UInt> rhs)
 	{
 		return lhs = lhs & rhs;
 	}
 
-	RValue<UInt> operator|=(const UInt &lhs, RValue<UInt> rhs)
+	RValue<UInt> operator|=(UInt &lhs, RValue<UInt> rhs)
 	{
 		return lhs = lhs | rhs;
 	}
 
-	RValue<UInt> operator^=(const UInt &lhs, RValue<UInt> rhs)
+	RValue<UInt> operator^=(UInt &lhs, RValue<UInt> rhs)
 	{
 		return lhs = lhs ^ rhs;
 	}
 
-	RValue<UInt> operator<<=(const UInt &lhs, RValue<UInt> rhs)
+	RValue<UInt> operator<<=(UInt &lhs, RValue<UInt> rhs)
 	{
 		return lhs = lhs << rhs;
 	}
 
-	RValue<UInt> operator>>=(const UInt &lhs, RValue<UInt> rhs)
+	RValue<UInt> operator>>=(UInt &lhs, RValue<UInt> rhs)
 	{
 		return lhs = lhs >> rhs;
 	}
@@ -4506,27 +4506,27 @@
 		return RValue<UInt>(Nucleus::createNot(val.value));
 	}
 
-	RValue<UInt> operator++(const UInt &val, int)   // Post-increment
+	RValue<UInt> operator++(UInt &val, int)   // Post-increment
 	{
 		RValue<UInt> res = val;
 		val += 1;
 		return res;
 	}
 
-	const UInt &operator++(const UInt &val)   // Pre-increment
+	const UInt &operator++(UInt &val)   // Pre-increment
 	{
 		val += 1;
 		return val;
 	}
 
-	RValue<UInt> operator--(const UInt &val, int)   // Post-decrement
+	RValue<UInt> operator--(UInt &val, int)   // Post-decrement
 	{
 		RValue<UInt> res = val;
 		val -= 1;
 		return res;
 	}
 
-	const UInt &operator--(const UInt &val)   // Pre-decrement
+	const UInt &operator--(UInt &val)   // Pre-decrement
 	{
 		val -= 1;
 		return val;
@@ -4650,14 +4650,14 @@
 		storeValue(Nucleus::createBitCast(packed, Int2::getType()));
 	}
 
-	RValue<Int2> Int2::operator=(RValue<Int2> rhs) const
+	RValue<Int2> Int2::operator=(RValue<Int2> rhs)
 	{
 		storeValue(rhs.value);
 
 		return rhs;
 	}
 
-	RValue<Int2> Int2::operator=(const Int2 &rhs) const
+	RValue<Int2> Int2::operator=(const Int2 &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -4665,7 +4665,7 @@
 		return RValue<Int2>(value);
 	}
 
-	RValue<Int2> Int2::operator=(const Reference<Int2> &rhs) const
+	RValue<Int2> Int2::operator=(const Reference<Int2> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -4733,62 +4733,62 @@
 		assert(false && "UNIMPLEMENTED"); return RValue<Int2>(V(nullptr));
 	}
 
-	RValue<Int2> operator+=(const Int2 &lhs, RValue<Int2> rhs)
+	RValue<Int2> operator+=(Int2 &lhs, RValue<Int2> rhs)
 	{
 		return lhs = lhs + rhs;
 	}
 
-	RValue<Int2> operator-=(const Int2 &lhs, RValue<Int2> rhs)
+	RValue<Int2> operator-=(Int2 &lhs, RValue<Int2> rhs)
 	{
 		return lhs = lhs - rhs;
 	}
 
-//	RValue<Int2> operator*=(const Int2 &lhs, RValue<Int2> rhs)
+//	RValue<Int2> operator*=(Int2 &lhs, RValue<Int2> rhs)
 //	{
 //		return lhs = lhs * rhs;
 //	}
 
-//	RValue<Int2> operator/=(const Int2 &lhs, RValue<Int2> rhs)
+//	RValue<Int2> operator/=(Int2 &lhs, RValue<Int2> rhs)
 //	{
 //		return lhs = lhs / rhs;
 //	}
 
-//	RValue<Int2> operator%=(const Int2 &lhs, RValue<Int2> rhs)
+//	RValue<Int2> operator%=(Int2 &lhs, RValue<Int2> rhs)
 //	{
 //		return lhs = lhs % rhs;
 //	}
 
-	RValue<Int2> operator&=(const Int2 &lhs, RValue<Int2> rhs)
+	RValue<Int2> operator&=(Int2 &lhs, RValue<Int2> rhs)
 	{
 		return lhs = lhs & rhs;
 	}
 
-	RValue<Int2> operator|=(const Int2 &lhs, RValue<Int2> rhs)
+	RValue<Int2> operator|=(Int2 &lhs, RValue<Int2> rhs)
 	{
 		return lhs = lhs | rhs;
 	}
 
-	RValue<Int2> operator^=(const Int2 &lhs, RValue<Int2> rhs)
+	RValue<Int2> operator^=(Int2 &lhs, RValue<Int2> rhs)
 	{
 		return lhs = lhs ^ rhs;
 	}
 
-	RValue<Int2> operator<<=(const Int2 &lhs, unsigned char rhs)
+	RValue<Int2> operator<<=(Int2 &lhs, unsigned char rhs)
 	{
 		return lhs = lhs << rhs;
 	}
 
-	RValue<Int2> operator>>=(const Int2 &lhs, unsigned char rhs)
+	RValue<Int2> operator>>=(Int2 &lhs, unsigned char rhs)
 	{
 		return lhs = lhs >> rhs;
 	}
 
-	RValue<Int2> operator<<=(const Int2 &lhs, RValue<Long1> rhs)
+	RValue<Int2> operator<<=(Int2 &lhs, RValue<Long1> rhs)
 	{
 		return lhs = lhs << rhs;
 	}
 
-	RValue<Int2> operator>>=(const Int2 &lhs, RValue<Long1> rhs)
+	RValue<Int2> operator>>=(Int2 &lhs, RValue<Long1> rhs)
 	{
 		return lhs = lhs >> rhs;
 	}
@@ -4869,14 +4869,14 @@
 		storeValue(value);
 	}
 
-	RValue<UInt2> UInt2::operator=(RValue<UInt2> rhs) const
+	RValue<UInt2> UInt2::operator=(RValue<UInt2> rhs)
 	{
 		storeValue(rhs.value);
 
 		return rhs;
 	}
 
-	RValue<UInt2> UInt2::operator=(const UInt2 &rhs) const
+	RValue<UInt2> UInt2::operator=(const UInt2 &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -4884,7 +4884,7 @@
 		return RValue<UInt2>(value);
 	}
 
-	RValue<UInt2> UInt2::operator=(const Reference<UInt2> &rhs) const
+	RValue<UInt2> UInt2::operator=(const Reference<UInt2> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -4952,62 +4952,62 @@
 		assert(false && "UNIMPLEMENTED"); return RValue<UInt2>(V(nullptr));
 	}
 
-	RValue<UInt2> operator+=(const UInt2 &lhs, RValue<UInt2> rhs)
+	RValue<UInt2> operator+=(UInt2 &lhs, RValue<UInt2> rhs)
 	{
 		return lhs = lhs + rhs;
 	}
 
-	RValue<UInt2> operator-=(const UInt2 &lhs, RValue<UInt2> rhs)
+	RValue<UInt2> operator-=(UInt2 &lhs, RValue<UInt2> rhs)
 	{
 		return lhs = lhs - rhs;
 	}
 
-//	RValue<UInt2> operator*=(const UInt2 &lhs, RValue<UInt2> rhs)
+//	RValue<UInt2> operator*=(UInt2 &lhs, RValue<UInt2> rhs)
 //	{
 //		return lhs = lhs * rhs;
 //	}
 
-//	RValue<UInt2> operator/=(const UInt2 &lhs, RValue<UInt2> rhs)
+//	RValue<UInt2> operator/=(UInt2 &lhs, RValue<UInt2> rhs)
 //	{
 //		return lhs = lhs / rhs;
 //	}
 
-//	RValue<UInt2> operator%=(const UInt2 &lhs, RValue<UInt2> rhs)
+//	RValue<UInt2> operator%=(UInt2 &lhs, RValue<UInt2> rhs)
 //	{
 //		return lhs = lhs % rhs;
 //	}
 
-	RValue<UInt2> operator&=(const UInt2 &lhs, RValue<UInt2> rhs)
+	RValue<UInt2> operator&=(UInt2 &lhs, RValue<UInt2> rhs)
 	{
 		return lhs = lhs & rhs;
 	}
 
-	RValue<UInt2> operator|=(const UInt2 &lhs, RValue<UInt2> rhs)
+	RValue<UInt2> operator|=(UInt2 &lhs, RValue<UInt2> rhs)
 	{
 		return lhs = lhs | rhs;
 	}
 
-	RValue<UInt2> operator^=(const UInt2 &lhs, RValue<UInt2> rhs)
+	RValue<UInt2> operator^=(UInt2 &lhs, RValue<UInt2> rhs)
 	{
 		return lhs = lhs ^ rhs;
 	}
 
-	RValue<UInt2> operator<<=(const UInt2 &lhs, unsigned char rhs)
+	RValue<UInt2> operator<<=(UInt2 &lhs, unsigned char rhs)
 	{
 		return lhs = lhs << rhs;
 	}
 
-	RValue<UInt2> operator>>=(const UInt2 &lhs, unsigned char rhs)
+	RValue<UInt2> operator>>=(UInt2 &lhs, unsigned char rhs)
 	{
 		return lhs = lhs >> rhs;
 	}
 
-	RValue<UInt2> operator<<=(const UInt2 &lhs, RValue<Long1> rhs)
+	RValue<UInt2> operator<<=(UInt2 &lhs, RValue<Long1> rhs)
 	{
 		return lhs = lhs << rhs;
 	}
 
-	RValue<UInt2> operator>>=(const UInt2 &lhs, RValue<Long1> rhs)
+	RValue<UInt2> operator>>=(UInt2 &lhs, RValue<Long1> rhs)
 	{
 		return lhs = lhs >> rhs;
 	}
@@ -5206,14 +5206,14 @@
 		*this = RValue<Int>(rhs.loadValue());
 	}
 
-	RValue<Int4> Int4::operator=(RValue<Int4> rhs) const
+	RValue<Int4> Int4::operator=(RValue<Int4> rhs)
 	{
 		storeValue(rhs.value);
 
 		return rhs;
 	}
 
-	RValue<Int4> Int4::operator=(const Int4 &rhs) const
+	RValue<Int4> Int4::operator=(const Int4 &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -5221,7 +5221,7 @@
 		return RValue<Int4>(value);
 	}
 
-	RValue<Int4> Int4::operator=(const Reference<Int4> &rhs) const
+	RValue<Int4> Int4::operator=(const Reference<Int4> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -5289,52 +5289,52 @@
 		return RValue<Int4>(Nucleus::createAShr(lhs.value, rhs.value));
 	}
 
-	RValue<Int4> operator+=(const Int4 &lhs, RValue<Int4> rhs)
+	RValue<Int4> operator+=(Int4 &lhs, RValue<Int4> rhs)
 	{
 		return lhs = lhs + rhs;
 	}
 
-	RValue<Int4> operator-=(const Int4 &lhs, RValue<Int4> rhs)
+	RValue<Int4> operator-=(Int4 &lhs, RValue<Int4> rhs)
 	{
 		return lhs = lhs - rhs;
 	}
 
-	RValue<Int4> operator*=(const Int4 &lhs, RValue<Int4> rhs)
+	RValue<Int4> operator*=(Int4 &lhs, RValue<Int4> rhs)
 	{
 		return lhs = lhs * rhs;
 	}
 
-//	RValue<Int4> operator/=(const Int4 &lhs, RValue<Int4> rhs)
+//	RValue<Int4> operator/=(Int4 &lhs, RValue<Int4> rhs)
 //	{
 //		return lhs = lhs / rhs;
 //	}
 
-//	RValue<Int4> operator%=(const Int4 &lhs, RValue<Int4> rhs)
+//	RValue<Int4> operator%=(Int4 &lhs, RValue<Int4> rhs)
 //	{
 //		return lhs = lhs % rhs;
 //	}
 
-	RValue<Int4> operator&=(const Int4 &lhs, RValue<Int4> rhs)
+	RValue<Int4> operator&=(Int4 &lhs, RValue<Int4> rhs)
 	{
 		return lhs = lhs & rhs;
 	}
 
-	RValue<Int4> operator|=(const Int4 &lhs, RValue<Int4> rhs)
+	RValue<Int4> operator|=(Int4 &lhs, RValue<Int4> rhs)
 	{
 		return lhs = lhs | rhs;
 	}
 
-	RValue<Int4> operator^=(const Int4 &lhs, RValue<Int4> rhs)
+	RValue<Int4> operator^=(Int4 &lhs, RValue<Int4> rhs)
 	{
 		return lhs = lhs ^ rhs;
 	}
 
-	RValue<Int4> operator<<=(const Int4 &lhs, unsigned char rhs)
+	RValue<Int4> operator<<=(Int4 &lhs, unsigned char rhs)
 	{
 		return lhs = lhs << rhs;
 	}
 
-	RValue<Int4> operator>>=(const Int4 &lhs, unsigned char rhs)
+	RValue<Int4> operator>>=(Int4 &lhs, unsigned char rhs)
 	{
 		return lhs = lhs >> rhs;
 	}
@@ -5555,14 +5555,14 @@
 		assert(false && "UNIMPLEMENTED");
 	}
 
-	RValue<UInt4> UInt4::operator=(RValue<UInt4> rhs) const
+	RValue<UInt4> UInt4::operator=(RValue<UInt4> rhs)
 	{
 		storeValue(rhs.value);
 
 		return rhs;
 	}
 
-	RValue<UInt4> UInt4::operator=(const UInt4 &rhs) const
+	RValue<UInt4> UInt4::operator=(const UInt4 &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -5570,7 +5570,7 @@
 		return RValue<UInt4>(value);
 	}
 
-	RValue<UInt4> UInt4::operator=(const Reference<UInt4> &rhs) const
+	RValue<UInt4> UInt4::operator=(const Reference<UInt4> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -5638,52 +5638,52 @@
 		return RValue<UInt4>(Nucleus::createLShr(lhs.value, rhs.value));
 	}
 
-	RValue<UInt4> operator+=(const UInt4 &lhs, RValue<UInt4> rhs)
+	RValue<UInt4> operator+=(UInt4 &lhs, RValue<UInt4> rhs)
 	{
 		return lhs = lhs + rhs;
 	}
 
-	RValue<UInt4> operator-=(const UInt4 &lhs, RValue<UInt4> rhs)
+	RValue<UInt4> operator-=(UInt4 &lhs, RValue<UInt4> rhs)
 	{
 		return lhs = lhs - rhs;
 	}
 
-	RValue<UInt4> operator*=(const UInt4 &lhs, RValue<UInt4> rhs)
+	RValue<UInt4> operator*=(UInt4 &lhs, RValue<UInt4> rhs)
 	{
 		return lhs = lhs * rhs;
 	}
 
-//	RValue<UInt4> operator/=(const UInt4 &lhs, RValue<UInt4> rhs)
+//	RValue<UInt4> operator/=(UInt4 &lhs, RValue<UInt4> rhs)
 //	{
 //		return lhs = lhs / rhs;
 //	}
 
-//	RValue<UInt4> operator%=(const UInt4 &lhs, RValue<UInt4> rhs)
+//	RValue<UInt4> operator%=(UInt4 &lhs, RValue<UInt4> rhs)
 //	{
 //		return lhs = lhs % rhs;
 //	}
 
-	RValue<UInt4> operator&=(const UInt4 &lhs, RValue<UInt4> rhs)
+	RValue<UInt4> operator&=(UInt4 &lhs, RValue<UInt4> rhs)
 	{
 		return lhs = lhs & rhs;
 	}
 
-	RValue<UInt4> operator|=(const UInt4 &lhs, RValue<UInt4> rhs)
+	RValue<UInt4> operator|=(UInt4 &lhs, RValue<UInt4> rhs)
 	{
 		return lhs = lhs | rhs;
 	}
 
-	RValue<UInt4> operator^=(const UInt4 &lhs, RValue<UInt4> rhs)
+	RValue<UInt4> operator^=(UInt4 &lhs, RValue<UInt4> rhs)
 	{
 		return lhs = lhs ^ rhs;
 	}
 
-	RValue<UInt4> operator<<=(const UInt4 &lhs, unsigned char rhs)
+	RValue<UInt4> operator<<=(UInt4 &lhs, unsigned char rhs)
 	{
 		return lhs = lhs << rhs;
 	}
 
-	RValue<UInt4> operator>>=(const UInt4 &lhs, unsigned char rhs)
+	RValue<UInt4> operator>>=(UInt4 &lhs, unsigned char rhs)
 	{
 		return lhs = lhs >> rhs;
 	}
@@ -5810,14 +5810,14 @@
 		storeValue(value);
 	}
 
-	RValue<Float> Float::operator=(RValue<Float> rhs) const
+	RValue<Float> Float::operator=(RValue<Float> rhs)
 	{
 		storeValue(rhs.value);
 
 		return rhs;
 	}
 
-	RValue<Float> Float::operator=(const Float &rhs) const
+	RValue<Float> Float::operator=(const Float &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -5825,7 +5825,7 @@
 		return RValue<Float>(value);
 	}
 
-	RValue<Float> Float::operator=(const Reference<Float> &rhs) const
+	RValue<Float> Float::operator=(const Reference<Float> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -5853,22 +5853,22 @@
 		return RValue<Float>(Nucleus::createFDiv(lhs.value, rhs.value));
 	}
 
-	RValue<Float> operator+=(const Float &lhs, RValue<Float> rhs)
+	RValue<Float> operator+=(Float &lhs, RValue<Float> rhs)
 	{
 		return lhs = lhs + rhs;
 	}
 
-	RValue<Float> operator-=(const Float &lhs, RValue<Float> rhs)
+	RValue<Float> operator-=(Float &lhs, RValue<Float> rhs)
 	{
 		return lhs = lhs - rhs;
 	}
 
-	RValue<Float> operator*=(const Float &lhs, RValue<Float> rhs)
+	RValue<Float> operator*=(Float &lhs, RValue<Float> rhs)
 	{
 		return lhs = lhs * rhs;
 	}
 
-	RValue<Float> operator/=(const Float &lhs, RValue<Float> rhs)
+	RValue<Float> operator/=(Float &lhs, RValue<Float> rhs)
 	{
 		return lhs = lhs / rhs;
 	}
@@ -6127,19 +6127,19 @@
 		*this = RValue<Float>(rhs.loadValue());
 	}
 
-	RValue<Float4> Float4::operator=(float x) const
+	RValue<Float4> Float4::operator=(float x)
 	{
 		return *this = Float4(x, x, x, x);
 	}
 
-	RValue<Float4> Float4::operator=(RValue<Float4> rhs) const
+	RValue<Float4> Float4::operator=(RValue<Float4> rhs)
 	{
 		storeValue(rhs.value);
 
 		return rhs;
 	}
 
-	RValue<Float4> Float4::operator=(const Float4 &rhs) const
+	RValue<Float4> Float4::operator=(const Float4 &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -6147,7 +6147,7 @@
 		return RValue<Float4>(value);
 	}
 
-	RValue<Float4> Float4::operator=(const Reference<Float4> &rhs) const
+	RValue<Float4> Float4::operator=(const Reference<Float4> &rhs)
 	{
 		Value *value = rhs.loadValue();
 		storeValue(value);
@@ -6155,17 +6155,17 @@
 		return RValue<Float4>(value);
 	}
 
-	RValue<Float4> Float4::operator=(RValue<Float> rhs) const
+	RValue<Float4> Float4::operator=(RValue<Float> rhs)
 	{
 		return *this = Float4(rhs);
 	}
 
-	RValue<Float4> Float4::operator=(const Float &rhs) const
+	RValue<Float4> Float4::operator=(const Float &rhs)
 	{
 		return *this = Float4(rhs);
 	}
 
-	RValue<Float4> Float4::operator=(const Reference<Float> &rhs) const
+	RValue<Float4> Float4::operator=(const Reference<Float> &rhs)
 	{
 		return *this = Float4(rhs);
 	}
@@ -6195,27 +6195,27 @@
 		return RValue<Float4>(Nucleus::createFRem(lhs.value, rhs.value));
 	}
 
-	RValue<Float4> operator+=(const Float4 &lhs, RValue<Float4> rhs)
+	RValue<Float4> operator+=(Float4 &lhs, RValue<Float4> rhs)
 	{
 		return lhs = lhs + rhs;
 	}
 
-	RValue<Float4> operator-=(const Float4 &lhs, RValue<Float4> rhs)
+	RValue<Float4> operator-=(Float4 &lhs, RValue<Float4> rhs)
 	{
 		return lhs = lhs - rhs;
 	}
 
-	RValue<Float4> operator*=(const Float4 &lhs, RValue<Float4> rhs)
+	RValue<Float4> operator*=(Float4 &lhs, RValue<Float4> rhs)
 	{
 		return lhs = lhs * rhs;
 	}
 
-	RValue<Float4> operator/=(const Float4 &lhs, RValue<Float4> rhs)
+	RValue<Float4> operator/=(Float4 &lhs, RValue<Float4> rhs)
 	{
 		return lhs = lhs / rhs;
 	}
 
-	RValue<Float4> operator%=(const Float4 &lhs, RValue<Float4> rhs)
+	RValue<Float4> operator%=(Float4 &lhs, RValue<Float4> rhs)
 	{
 		return lhs = lhs % rhs;
 	}
@@ -6455,17 +6455,17 @@
 		return RValue<Pointer<Byte>>(Nucleus::createGEP(lhs.value, Byte::getType(), offset.value));
 	}
 
-	RValue<Pointer<Byte>> operator+=(const Pointer<Byte> &lhs, int offset)
+	RValue<Pointer<Byte>> operator+=(Pointer<Byte> &lhs, int offset)
 	{
 		return lhs = lhs + offset;
 	}
 
-	RValue<Pointer<Byte>> operator+=(const Pointer<Byte> &lhs, RValue<Int> offset)
+	RValue<Pointer<Byte>> operator+=(Pointer<Byte> &lhs, RValue<Int> offset)
 	{
 		return lhs = lhs + offset;
 	}
 
-	RValue<Pointer<Byte>> operator+=(const Pointer<Byte> &lhs, RValue<UInt> offset)
+	RValue<Pointer<Byte>> operator+=(Pointer<Byte> &lhs, RValue<UInt> offset)
 	{
 		return lhs = lhs + offset;
 	}
@@ -6485,17 +6485,17 @@
 		return lhs + -offset;
 	}
 
-	RValue<Pointer<Byte>> operator-=(const Pointer<Byte> &lhs, int offset)
+	RValue<Pointer<Byte>> operator-=(Pointer<Byte> &lhs, int offset)
 	{
 		return lhs = lhs - offset;
 	}
 
-	RValue<Pointer<Byte>> operator-=(const Pointer<Byte> &lhs, RValue<Int> offset)
+	RValue<Pointer<Byte>> operator-=(Pointer<Byte> &lhs, RValue<Int> offset)
 	{
 		return lhs = lhs - offset;
 	}
 
-	RValue<Pointer<Byte>> operator-=(const Pointer<Byte> &lhs, RValue<UInt> offset)
+	RValue<Pointer<Byte>> operator-=(Pointer<Byte> &lhs, RValue<UInt> offset)
 	{
 		return lhs = lhs - offset;
 	}
diff --git a/src/Renderer/Rasterizer.hpp b/src/Renderer/Rasterizer.hpp
index 3c746c8..8d0b4fb 100644
--- a/src/Renderer/Rasterizer.hpp
+++ b/src/Renderer/Rasterizer.hpp
@@ -29,10 +29,10 @@
 		virtual ~Rasterizer() {};
 
 	protected:
-		const Pointer<Byte> primitive;
-		const Int count;
-		const Int cluster;
-		const Pointer<Byte> data;
+		Pointer<Byte> primitive;
+		Int count;
+		Int cluster;
+		Pointer<Byte> data;
 	};
 }
 
diff --git a/src/Shader/PixelRoutine.cpp b/src/Shader/PixelRoutine.cpp
index 2025da7..7e6c943 100644
--- a/src/Shader/PixelRoutine.cpp
+++ b/src/Shader/PixelRoutine.cpp
@@ -868,7 +868,7 @@
 		}
 	}
 
-	void PixelRoutine::blendFactor(const Vector4s &blendFactor, const Vector4s &current, const Vector4s &pixel, BlendFactor blendFactorActive)
+	void PixelRoutine::blendFactor(Vector4s &blendFactor, const Vector4s &current, const Vector4s &pixel, BlendFactor blendFactorActive)
 	{
 		switch(blendFactorActive)
 		{
@@ -949,7 +949,7 @@
 		}
 	}
 
-	void PixelRoutine::blendFactorAlpha(const Vector4s &blendFactor, const Vector4s &current, const Vector4s &pixel, BlendFactor blendFactorAlphaActive)
+	void PixelRoutine::blendFactorAlpha(Vector4s &blendFactor, const Vector4s &current, const Vector4s &pixel, BlendFactor blendFactorAlphaActive)
 	{
 		switch(blendFactorAlphaActive)
 		{
@@ -1899,7 +1899,7 @@
 		}
 	}
 
-	void PixelRoutine::blendFactor(const Vector4f &blendFactor, const Vector4f &oC, const Vector4f &pixel, BlendFactor blendFactorActive)
+	void PixelRoutine::blendFactor(Vector4f &blendFactor, const Vector4f &oC, const Vector4f &pixel, BlendFactor blendFactorActive)
 	{
 		switch(blendFactorActive)
 		{
@@ -1970,7 +1970,7 @@
 		}
 	}
 
-	void PixelRoutine::blendFactorAlpha(const Vector4f &blendFactor, const Vector4f &oC, const Vector4f &pixel, BlendFactor blendFactorAlphaActive)
+	void PixelRoutine::blendFactorAlpha(Vector4f &blendFactor, const Vector4f &oC, const Vector4f &pixel, BlendFactor blendFactorAlphaActive)
 	{
 		switch(blendFactorAlphaActive)
 		{
diff --git a/src/Shader/PixelRoutine.hpp b/src/Shader/PixelRoutine.hpp
index ba692c3..d57f2cb 100644
--- a/src/Shader/PixelRoutine.hpp
+++ b/src/Shader/PixelRoutine.hpp
@@ -76,11 +76,11 @@
 		Bool depthTest(Pointer<Byte> &zBuffer, int q, Int &x, Float4 &z, Int &sMask, Int &zMask, Int &cMask);
 
 		// Raster operations
-		void blendFactor(const Vector4s &blendFactor, const Vector4s &current, const Vector4s &pixel, BlendFactor blendFactorActive);
-		void blendFactorAlpha(const Vector4s &blendFactor, const Vector4s &current, const Vector4s &pixel, BlendFactor blendFactorAlphaActive);
+		void blendFactor(Vector4s &blendFactor, const Vector4s &current, const Vector4s &pixel, BlendFactor blendFactorActive);
+		void blendFactorAlpha(Vector4s &blendFactor, const Vector4s &current, const Vector4s &pixel, BlendFactor blendFactorAlphaActive);
 		void readPixel(int index, Pointer<Byte> &cBuffer, Int &x, Vector4s &pixel);
-		void blendFactor(const Vector4f &blendFactor, const Vector4f &oC, const Vector4f &pixel, BlendFactor blendFactorActive);
-		void blendFactorAlpha(const Vector4f &blendFactor, const Vector4f &oC, const Vector4f &pixel, BlendFactor blendFactorAlphaActive);
+		void blendFactor(Vector4f &blendFactor, const Vector4f &oC, const Vector4f &pixel, BlendFactor blendFactorActive);
+		void blendFactorAlpha(Vector4f &blendFactor, const Vector4f &oC, const Vector4f &pixel, BlendFactor blendFactorAlphaActive);
 		void writeStencil(Pointer<Byte> &sBuffer, int q, Int &x, Int &sMask, Int &zMask, Int &cMask);
 		void writeDepth(Pointer<Byte> &zBuffer, int q, Int &x, Float4 &z, Int &zMask);
 
diff --git a/src/Shader/SetupRoutine.cpp b/src/Shader/SetupRoutine.cpp
index 1845047..c31bbec 100644
--- a/src/Shader/SetupRoutine.cpp
+++ b/src/Shader/SetupRoutine.cpp
@@ -555,25 +555,23 @@
 		}
 	}
 
-	void SetupRoutine::edge(Pointer<Byte> &primitive, Pointer<Byte> &data, const Int &X1, const Int &Y1, const Int &X2, const Int &Y2, Int &q)
+	void SetupRoutine::edge(Pointer<Byte> &primitive, Pointer<Byte> &data, const Int &Xa, const Int &Ya, const Int &Xb, const Int &Yb, Int &q)
 	{
-		If(Y1 != Y2)
+		If(Ya != Yb)
 		{
 			Int xMin = *Pointer<Int>(data + OFFSET(DrawData,scissorX0));
 			Int xMax = *Pointer<Int>(data + OFFSET(DrawData,scissorX1));
 
-			Bool swap = Y2 < Y1;
+			Bool swap = Yb < Ya;
 
 			Pointer<Byte> leftEdge = primitive + q * sizeof(Primitive) + OFFSET(Primitive,outline->left);
 			Pointer<Byte> rightEdge = primitive + q * sizeof(Primitive) + OFFSET(Primitive,outline->right);
 			Pointer<Byte> edge = IfThenElse(swap, rightEdge, leftEdge);
 
-			Int X0 = X1;
-			Int Y0 = Y1;
-			X1 = IfThenElse(swap, X2, X1);
-			X2 = IfThenElse(swap, X0, X2);
-			Y1 = IfThenElse(swap, Y2, Y1);
-			Y2 = IfThenElse(swap, Y0, Y2);
+			Int X1 = IfThenElse(swap, Xb, Xa);
+			Int X2 = IfThenElse(swap, Xa, Xb);
+			Int Y1 = IfThenElse(swap, Yb, Ya);
+			Int Y2 = IfThenElse(swap, Ya, Yb);
 
 			Int y1 = Max((Y1 + 0x0000000F) >> 4, *Pointer<Int>(data + OFFSET(DrawData,scissorY0)));
 			Int y2 = Min((Y2 + 0x0000000F) >> 4, *Pointer<Int>(data + OFFSET(DrawData,scissorY1)));
diff --git a/src/Shader/SetupRoutine.hpp b/src/Shader/SetupRoutine.hpp
index ac31299..ebcc080 100644
--- a/src/Shader/SetupRoutine.hpp
+++ b/src/Shader/SetupRoutine.hpp
@@ -34,7 +34,7 @@
 
 	private:
 		void setupGradient(Pointer<Byte> &primitive, Pointer<Byte> &triangle, Float4 &w012, Float4 (&m)[3], Pointer<Byte> &v0, Pointer<Byte> &v1, Pointer<Byte> &v2, int attribute, int planeEquation, bool flatShading, bool sprite, bool perspective, bool wrap, int component);
-		void edge(Pointer<Byte> &primitive, Pointer<Byte> &data, const Int &X1, const Int &Y1, const Int &X2, const Int &Y2, Int &q);
+		void edge(Pointer<Byte> &primitive, Pointer<Byte> &data, const Int &Xa, const Int &Ya, const Int &Xb, const Int &Yb, Int &q);
 		void conditionalRotate1(Bool condition, Pointer<Byte> &v0, Pointer<Byte> &v1, Pointer<Byte> &v2);
 		void conditionalRotate2(Bool condition, Pointer<Byte> &v0, Pointer<Byte> &v1, Pointer<Byte> &v2);
 
diff --git a/src/Shader/VertexRoutine.hpp b/src/Shader/VertexRoutine.hpp
index 4aec45f..dd4bf13 100644
--- a/src/Shader/VertexRoutine.hpp
+++ b/src/Shader/VertexRoutine.hpp
@@ -29,10 +29,10 @@
 		virtual ~VertexRoutinePrototype() {};
 
 	protected:
-		const Pointer<Byte> vertex;
-		const Pointer<Byte> batch;
-		const Pointer<Byte> task;
-		const Pointer<Byte> data;
+		Pointer<Byte> vertex;
+		Pointer<Byte> batch;
+		Pointer<Byte> task;
+		Pointer<Byte> data;
 	};
 
 	class VertexRoutine : public VertexRoutinePrototype