diff --git a/src/Reactor/LLVMReactor.cpp b/src/Reactor/LLVMReactor.cpp
index fdc358a..ff00fd6 100644
--- a/src/Reactor/LLVMReactor.cpp
+++ b/src/Reactor/LLVMReactor.cpp
@@ -79,7 +79,6 @@
 
 	class Type : public llvm::Type {};
 	class Value : public llvm::Value {};
-	class Constant : public llvm::Constant {};
 	class BasicBlock : public llvm::BasicBlock {};
 
 	inline Type *T(llvm::Type *t)
@@ -97,11 +96,6 @@
 		return reinterpret_cast<std::vector<llvm::Type*>&>(t);
 	}
 
-	inline Constant *C(llvm::Constant *c)
-	{
-		return reinterpret_cast<Constant*>(c);
-	}
-
 	inline BasicBlock *B(llvm::BasicBlock *t)
 	{
 		return reinterpret_cast<BasicBlock*>(t);
@@ -433,11 +427,6 @@
 		return V(::builder->CreateXor(lhs, rhs));
 	}
 
-	Value *Nucleus::createAssign(Constant *constant)
-	{
-		return V(constant);
-	}
-
 	Value *Nucleus::createNeg(Value *v)
 	{
 		return V(::builder->CreateNeg(v));
@@ -466,13 +455,6 @@
 		return value;
 	}
 
-	Constant *Nucleus::createStore(Constant *constant, Value *ptr, Type *type, bool isVolatile, unsigned int align)
-	{
-		assert(ptr->getType()->getContainedType(0) == type);
-		::builder->Insert(new StoreInst(constant, ptr, isVolatile, align));
-		return constant;
-	}
-
 	Value *Nucleus::createGEP(Value *ptr, Type *type, Value *index)
 	{
 		assert(ptr->getType()->getContainedType(0) == type);
@@ -674,7 +656,7 @@
 
 		for(int i = 0; i < size; i++)
 		{
-			swizzle[i] = Nucleus::createConstantInt(select[i]);
+			swizzle[i] = llvm::ConstantInt::get(Type::getInt32Ty(*::context), select[i]);
 		}
 
 		llvm::Value *shuffle = llvm::ConstantVector::get(llvm::ArrayRef<llvm::Constant*>(swizzle, size));
@@ -737,13 +719,13 @@
 		return shuffle;
 	}
 
-	Constant *Nucleus::createConstantPointer(const void *address, Type *Ty, bool isConstant, unsigned int Align)
+	Value *Nucleus::createConstantPointer(const void *address, Type *Ty, bool isConstant, unsigned int Align)
 	{
 		const GlobalValue *existingGlobal = ::executionEngine->getGlobalValueAtAddress(const_cast<void*>(address));   // FIXME: Const
 
 		if(existingGlobal)
 		{
-			return (Constant*)existingGlobal;
+			return (Value*)existingGlobal;
 		}
 
 		llvm::GlobalValue *global = new llvm::GlobalVariable(*::module, Ty, isConstant, llvm::GlobalValue::ExternalLinkage, 0, "");
@@ -752,7 +734,7 @@
 
 		::executionEngine->addGlobalMapping(global, const_cast<void*>(address));
 
-		return C(global);
+		return V(global);
 	}
 
 	Type *Nucleus::getPointerType(Type *ElementType)
@@ -760,64 +742,89 @@
 		return T(llvm::PointerType::get(ElementType, 0));
 	}
 
-	Constant *Nucleus::createNullValue(Type *Ty)
+	Value *Nucleus::createNullValue(Type *Ty)
 	{
-		return C(llvm::Constant::getNullValue(Ty));
+		return V(llvm::Constant::getNullValue(Ty));
 	}
 
-	Constant *Nucleus::createConstantInt(int64_t i)
+	Value *Nucleus::createConstantLong(int64_t i)
 	{
-		return C(llvm::ConstantInt::get(Type::getInt64Ty(*::context), i, true));
+		return V(llvm::ConstantInt::get(Type::getInt64Ty(*::context), i, true));
 	}
 
-	Constant *Nucleus::createConstantInt(int i)
+	Value *Nucleus::createConstantInt(int i)
 	{
-		return C(llvm::ConstantInt::get(Type::getInt32Ty(*::context), i, true));
+		return V(llvm::ConstantInt::get(Type::getInt32Ty(*::context), i, true));
 	}
 
-	Constant *Nucleus::createConstantInt(unsigned int i)
+	Value *Nucleus::createConstantInt(unsigned int i)
 	{
-		return C(llvm::ConstantInt::get(Type::getInt32Ty(*::context), i, false));
+		return V(llvm::ConstantInt::get(Type::getInt32Ty(*::context), i, false));
 	}
 
-	Constant *Nucleus::createConstantBool(bool b)
+	Value *Nucleus::createConstantBool(bool b)
 	{
-		return C(llvm::ConstantInt::get(Type::getInt1Ty(*::context), b));
+		return V(llvm::ConstantInt::get(Type::getInt1Ty(*::context), b));
 	}
 
-	Constant *Nucleus::createConstantByte(signed char i)
+	Value *Nucleus::createConstantByte(signed char i)
 	{
-		return C(llvm::ConstantInt::get(Type::getInt8Ty(*::context), i, true));
+		return V(llvm::ConstantInt::get(Type::getInt8Ty(*::context), i, true));
 	}
 
-	Constant *Nucleus::createConstantByte(unsigned char i)
+	Value *Nucleus::createConstantByte(unsigned char i)
 	{
-		return C(llvm::ConstantInt::get(Type::getInt8Ty(*::context), i, false));
+		return V(llvm::ConstantInt::get(Type::getInt8Ty(*::context), i, false));
 	}
 
-	Constant *Nucleus::createConstantShort(short i)
+	Value *Nucleus::createConstantShort(short i)
 	{
-		return C(llvm::ConstantInt::get(Type::getInt16Ty(*::context), i, true));
+		return V(llvm::ConstantInt::get(Type::getInt16Ty(*::context), i, true));
 	}
 
-	Constant *Nucleus::createConstantShort(unsigned short i)
+	Value *Nucleus::createConstantShort(unsigned short i)
 	{
-		return C(llvm::ConstantInt::get(Type::getInt16Ty(*::context), i, false));
+		return V(llvm::ConstantInt::get(Type::getInt16Ty(*::context), i, false));
 	}
 
-	Constant *Nucleus::createConstantFloat(float x)
+	Value *Nucleus::createConstantFloat(float x)
 	{
-		return C(ConstantFP::get(Float::getType(), x));
+		return V(llvm::ConstantFP::get(Float::getType(), x));
 	}
 
-	Constant *Nucleus::createNullPointer(Type *Ty)
+	Value *Nucleus::createNullPointer(Type *Ty)
 	{
-		return C(llvm::ConstantPointerNull::get(llvm::PointerType::get(Ty, 0)));
+		return V(llvm::ConstantPointerNull::get(llvm::PointerType::get(Ty, 0)));
 	}
 
-	Constant *Nucleus::createConstantVector(Constant *const *Vals, unsigned NumVals)
+	Value *Nucleus::createConstantVector(const int64_t *constants, Type *type)
 	{
-		return C(llvm::ConstantVector::get(llvm::ArrayRef<llvm::Constant*>(reinterpret_cast<llvm::Constant *const*>(Vals), NumVals)));
+		assert(llvm::isa<VectorType>(type));
+		const int numConstants = llvm::cast<VectorType>(type)->getNumElements();
+		assert(numConstants <= 16);
+		llvm::Constant *constantVector[16];
+
+		for(int i = 0; i < numConstants; i++)
+		{
+			constantVector[i] = llvm::ConstantInt::get(type->getContainedType(0), constants[i]);
+		}
+
+		return V(llvm::ConstantVector::get(llvm::ArrayRef<llvm::Constant*>(constantVector, numConstants)));
+	}
+
+	Value *Nucleus::createConstantVector(const double *constants, Type *type)
+	{
+		assert(llvm::isa<VectorType>(type));
+		const int numConstants = llvm::cast<VectorType>(type)->getNumElements();
+		assert(numConstants <= 8);
+		llvm::Constant *constantVector[8];
+
+		for(int i = 0; i < numConstants; i++)
+		{
+			constantVector[i] = llvm::ConstantFP::get(type->getContainedType(0), constants[i]);
+		}
+
+		return V(llvm::ConstantVector::get(llvm::ArrayRef<llvm::Constant*>(constantVector, numConstants)));
 	}
 
 	Type *Void::getType()
@@ -1973,16 +1980,8 @@
 	{
 	//	xyzw.parent = this;
 
-		Constant *constantVector[8];
-		constantVector[0] = Nucleus::createConstantByte(x0);
-		constantVector[1] = Nucleus::createConstantByte(x1);
-		constantVector[2] = Nucleus::createConstantByte(x2);
-		constantVector[3] = Nucleus::createConstantByte(x3);
-		constantVector[4] = Nucleus::createConstantByte(x4);
-		constantVector[5] = Nucleus::createConstantByte(x5);
-		constantVector[6] = Nucleus::createConstantByte(x6);
-		constantVector[7] = Nucleus::createConstantByte(x7);
-		Value *vector = V(Nucleus::createConstantVector(constantVector, 8));
+		int64_t constantVector[8] = {x0, x1, x2, x3, x4, x5, x6, x7};
+		Value *vector = V(Nucleus::createConstantVector(constantVector, T(VectorType::get(Byte::getType(), 8))));
 
 		storeValue(Nucleus::createBitCast(vector, getType()));
 	}
@@ -2274,16 +2273,8 @@
 	{
 	//	xyzw.parent = this;
 
-		Constant *constantVector[8];
-		constantVector[0] = Nucleus::createConstantByte(x0);
-		constantVector[1] = Nucleus::createConstantByte(x1);
-		constantVector[2] = Nucleus::createConstantByte(x2);
-		constantVector[3] = Nucleus::createConstantByte(x3);
-		constantVector[4] = Nucleus::createConstantByte(x4);
-		constantVector[5] = Nucleus::createConstantByte(x5);
-		constantVector[6] = Nucleus::createConstantByte(x6);
-		constantVector[7] = Nucleus::createConstantByte(x7);
-		Value *vector = V(Nucleus::createConstantVector(constantVector, 8));
+		int64_t constantVector[8] = {x0, x1, x2, x3, x4, x5, x6, x7};
+		Value *vector = V(Nucleus::createConstantVector(constantVector, T(VectorType::get(SByte::getType(), 8))));
 
 		storeValue(Nucleus::createBitCast(vector, getType()));
 	}
@@ -2696,12 +2687,8 @@
 	{
 		//	xyzw.parent = this;
 
-		Constant *constantVector[4];
-		constantVector[0] = Nucleus::createConstantShort(xyzw);
-		constantVector[1] = Nucleus::createConstantShort(xyzw);
-		constantVector[2] = Nucleus::createConstantShort(xyzw);
-		constantVector[3] = Nucleus::createConstantShort(xyzw);
-		Value *vector = V(Nucleus::createConstantVector(constantVector, 4));
+		int64_t constantVector[4] = {xyzw, xyzw, xyzw, xyzw};
+		Value *vector = V(Nucleus::createConstantVector(constantVector, T(VectorType::get(Short::getType(), 4))));
 
 		storeValue(Nucleus::createBitCast(vector, getType()));
 	}
@@ -2710,12 +2697,8 @@
 	{
 	//	xyzw.parent = this;
 
-		Constant *constantVector[4];
-		constantVector[0] = Nucleus::createConstantShort(x);
-		constantVector[1] = Nucleus::createConstantShort(y);
-		constantVector[2] = Nucleus::createConstantShort(z);
-		constantVector[3] = Nucleus::createConstantShort(w);
-		Value *vector = V(Nucleus::createConstantVector(constantVector, 4));
+		int64_t constantVector[4] = {x, y, z, w};
+		Value *vector = V(Nucleus::createConstantVector(constantVector, T(VectorType::get(Short::getType(), 4))));
 
 		storeValue(Nucleus::createBitCast(vector, getType()));
 	}
@@ -3186,12 +3169,8 @@
 	{
 		//	xyzw.parent = this;
 
-		Constant *constantVector[4];
-		constantVector[0] = Nucleus::createConstantShort(xyzw);
-		constantVector[1] = Nucleus::createConstantShort(xyzw);
-		constantVector[2] = Nucleus::createConstantShort(xyzw);
-		constantVector[3] = Nucleus::createConstantShort(xyzw);
-		Value *vector = V(Nucleus::createConstantVector(constantVector, 4));
+		int64_t constantVector[4] = {xyzw, xyzw, xyzw, xyzw};
+		Value *vector = V(Nucleus::createConstantVector(constantVector, T(VectorType::get(UShort::getType(), 4))));
 
 		storeValue(Nucleus::createBitCast(vector, getType()));
 	}
@@ -3200,12 +3179,8 @@
 	{
 	//	xyzw.parent = this;
 
-		Constant *constantVector[4];
-		constantVector[0] = Nucleus::createConstantShort(x);
-		constantVector[1] = Nucleus::createConstantShort(y);
-		constantVector[2] = Nucleus::createConstantShort(z);
-		constantVector[3] = Nucleus::createConstantShort(w);
-		Value *vector = V(Nucleus::createConstantVector(constantVector, 4));
+		int64_t constantVector[4] = {x, y, z, w};
+		Value *vector = V(Nucleus::createConstantVector(constantVector, T(VectorType::get(UShort::getType(), 4))));
 
 		storeValue(Nucleus::createBitCast(vector, getType()));
 	}
@@ -3485,17 +3460,8 @@
 	{
 	//	xyzw.parent = this;
 
-		Constant *constantVector[8];
-		constantVector[0] = Nucleus::createConstantShort(c0);
-		constantVector[1] = Nucleus::createConstantShort(c1);
-		constantVector[2] = Nucleus::createConstantShort(c2);
-		constantVector[3] = Nucleus::createConstantShort(c3);
-		constantVector[4] = Nucleus::createConstantShort(c4);
-		constantVector[5] = Nucleus::createConstantShort(c5);
-		constantVector[6] = Nucleus::createConstantShort(c6);
-		constantVector[7] = Nucleus::createConstantShort(c7);
-
-		storeValue(Nucleus::createConstantVector(constantVector, 8));
+		int64_t constantVector[8] = {c0, c1, c2, c3, c4, c5, c6, c7};
+		storeValue(Nucleus::createConstantVector(constantVector, getType()));
 	}
 
 	Short8::Short8(RValue<Short8> rhs)
@@ -3578,17 +3544,8 @@
 	{
 	//	xyzw.parent = this;
 
-		Constant *constantVector[8];
-		constantVector[0] = Nucleus::createConstantShort(c0);
-		constantVector[1] = Nucleus::createConstantShort(c1);
-		constantVector[2] = Nucleus::createConstantShort(c2);
-		constantVector[3] = Nucleus::createConstantShort(c3);
-		constantVector[4] = Nucleus::createConstantShort(c4);
-		constantVector[5] = Nucleus::createConstantShort(c5);
-		constantVector[6] = Nucleus::createConstantShort(c6);
-		constantVector[7] = Nucleus::createConstantShort(c7);
-
-		storeValue(Nucleus::createConstantVector(constantVector, 8));
+		int64_t constantVector[8] = {c0, c1, c2, c3, c4, c5, c6, c7};
+		storeValue(Nucleus::createConstantVector(constantVector, getType()));
 	}
 
 	UShort8::UShort8(RValue<UShort8> rhs)
@@ -4095,7 +4052,7 @@
 
 	RValue<Long> Long::operator=(int64_t rhs) const
 	{
-		return RValue<Long>(storeValue(Nucleus::createConstantInt(rhs)));
+		return RValue<Long>(storeValue(Nucleus::createConstantLong(rhs)));
 	}
 
 	RValue<Long> Long::operator=(RValue<Long> rhs) const
@@ -4563,10 +4520,8 @@
 	{
 	//	xy.parent = this;
 
-		Constant *constantVector[2];
-		constantVector[0] = Nucleus::createConstantInt(x);
-		constantVector[1] = Nucleus::createConstantInt(y);
-		Value *vector = V(Nucleus::createConstantVector(constantVector, 2));
+		int64_t constantVector[2] = {x, y};
+		Value *vector = V(Nucleus::createConstantVector(constantVector, T(VectorType::get(Int::getType(), 2))));
 
 		storeValue(Nucleus::createBitCast(vector, getType()));
 	}
@@ -4897,10 +4852,8 @@
 	{
 	//	xy.parent = this;
 
-		Constant *constantVector[2];
-		constantVector[0] = Nucleus::createConstantInt(x);
-		constantVector[1] = Nucleus::createConstantInt(y);
-		Value *vector = V(Nucleus::createConstantVector(constantVector, 2));
+		int64_t constantVector[2] = {x, y};
+		Value *vector = V(Nucleus::createConstantVector(constantVector, T(VectorType::get(UInt::getType(), 2))));
 
 		storeValue(Nucleus::createBitCast(vector, getType()));
 	}
@@ -5291,13 +5244,8 @@
 	{
 	//	xyzw.parent = this;
 
-		Constant *constantVector[4];
-		constantVector[0] = Nucleus::createConstantInt(x);
-		constantVector[1] = Nucleus::createConstantInt(y);
-		constantVector[2] = Nucleus::createConstantInt(z);
-		constantVector[3] = Nucleus::createConstantInt(w);
-
-		storeValue(Nucleus::createConstantVector(constantVector, 4));
+		int64_t constantVector[4] = {x, y, z, w};
+		storeValue(Nucleus::createConstantVector(constantVector, getType()));
 	}
 
 	Int4::Int4(RValue<Int4> rhs)
@@ -5686,13 +5634,8 @@
 	{
 	//	xyzw.parent = this;
 
-		Constant *constantVector[4];
-		constantVector[0] = Nucleus::createConstantInt(x);
-		constantVector[1] = Nucleus::createConstantInt(y);
-		constantVector[2] = Nucleus::createConstantInt(z);
-		constantVector[3] = Nucleus::createConstantInt(w);
-
-		storeValue(Nucleus::createConstantVector(constantVector, 4));
+		int64_t constantVector[4] = {x, y, z, w};
+		storeValue(Nucleus::createConstantVector(constantVector, getType()));
 	}
 
 	UInt4::UInt4(RValue<UInt4> rhs)
@@ -6361,13 +6304,8 @@
 	{
 		xyzw.parent = this;
 
-		Constant *constantVector[4];
-		constantVector[0] = Nucleus::createConstantFloat(x);
-		constantVector[1] = Nucleus::createConstantFloat(y);
-		constantVector[2] = Nucleus::createConstantFloat(z);
-		constantVector[3] = Nucleus::createConstantFloat(w);
-
-		storeValue(Nucleus::createConstantVector(constantVector, 4));
+		double constantVector[4] = {x, y, z, w};
+		storeValue(Nucleus::createConstantVector(constantVector, getType()));
 	}
 
 	Float4::Float4(RValue<Float4> rhs)
@@ -6526,14 +6464,8 @@
 	RValue<Float4> Abs(RValue<Float4> x)
 	{
 		Value *vector = Nucleus::createBitCast(x.value, Int4::getType());
-
-		Constant *constantVector[4];
-		constantVector[0] = Nucleus::createConstantInt(0x7FFFFFFF);
-		constantVector[1] = Nucleus::createConstantInt(0x7FFFFFFF);
-		constantVector[2] = Nucleus::createConstantInt(0x7FFFFFFF);
-		constantVector[3] = Nucleus::createConstantInt(0x7FFFFFFF);
-
-		Value *result = Nucleus::createAnd(vector, V(Nucleus::createConstantVector(constantVector, 4)));
+		int64_t constantVector[4] = {0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF};
+		Value *result = Nucleus::createAnd(vector, V(Nucleus::createConstantVector(constantVector, Int4::getType())));
 
 		return RValue<Float4>(Nucleus::createBitCast(result, Float4::getType()));
 	}
diff --git a/src/Reactor/Nucleus.hpp b/src/Reactor/Nucleus.hpp
index ed265e6..51c041b 100644
--- a/src/Reactor/Nucleus.hpp
+++ b/src/Reactor/Nucleus.hpp
@@ -23,7 +23,6 @@
 {
 	class Type;
 	class Value;
-	class Constant;
 	class BasicBlock;
 	class Routine;
 
@@ -90,7 +89,6 @@
 		static Value *createXor(Value *lhs, Value *rhs);
 
 		// Unary operators
-		static Value *createAssign(Constant *c);
 		static Value *createNeg(Value *V);
 		static Value *createFNeg(Value *V);
 		static Value *createNot(Value *V);
@@ -98,7 +96,6 @@
 		// Memory instructions
 		static Value *createLoad(Value *ptr, Type *type, bool isVolatile = false, unsigned int align = 0);
 		static Value *createStore(Value *value, Value *ptr, Type *type, bool isVolatile = false, unsigned int align = 0);
-		static Constant *createStore(Constant *constant, Value *ptr, Type *type, bool isVolatile = false, unsigned int align = 0);
 		static Value *createGEP(Value *ptr, Type *type, Value *index);
 
 		// Atomic instructions
@@ -154,21 +151,22 @@
 		static void createUnreachable();
 
 		// Constant values
-		static Constant *createNullValue(Type *Ty);
-		static Constant *createConstantInt(int64_t i);
-		static Constant *createConstantInt(int i);
-		static Constant *createConstantInt(unsigned int i);
-		static Constant *createConstantBool(bool b);
-		static Constant *createConstantByte(signed char i);
-		static Constant *createConstantByte(unsigned char i);
-		static Constant *createConstantShort(short i);
-		static Constant *createConstantShort(unsigned short i);
-		static Constant *createConstantFloat(float x);
-		static Constant *createNullPointer(Type *Ty);
-		static Constant *createConstantVector(Constant *const *Vals, unsigned NumVals);
-		static Constant *createConstantPointer(const void *external, Type *Ty, bool isConstant, unsigned int Align);
+		static Value *createNullValue(Type *type);
+		static Value *createConstantLong(int64_t i);
+		static Value *createConstantInt(int i);
+		static Value *createConstantInt(unsigned int i);
+		static Value *createConstantBool(bool b);
+		static Value *createConstantByte(signed char i);
+		static Value *createConstantByte(unsigned char i);
+		static Value *createConstantShort(short i);
+		static Value *createConstantShort(unsigned short i);
+		static Value *createConstantFloat(float x);
+		static Value *createNullPointer(Type *type);
+		static Value *createConstantVector(const int64_t *constants, Type *type);
+		static Value *createConstantVector(const double *constants, Type *type);
+		static Value *createConstantPointer(const void *external, Type *type, bool isConstant, unsigned int align);
 
-		static Type *getPointerType(Type *ElementType);
+		static Type *getPointerType(Type *elementType);
 
 	private:
 		void optimize();
diff --git a/src/Reactor/Reactor.hpp b/src/Reactor/Reactor.hpp
index cbef855..79433f5 100644
--- a/src/Reactor/Reactor.hpp
+++ b/src/Reactor/Reactor.hpp
@@ -83,7 +83,6 @@
 
 		Value *loadValue(unsigned int alignment = 0) const;
 		Value *storeValue(Value *value, unsigned int alignment = 0) const;
-		Constant *storeValue(Constant *constant, unsigned int alignment = 0) const;
 		Value *getAddress(Value *index) const;
 
 	protected:
@@ -160,7 +159,6 @@
 	{
 	public:
 		explicit RValue(Value *rvalue);
-		explicit RValue(Constant *constant);
 
 		RValue(const T &lvalue);
 		RValue(typename IntLiteral<T>::type i);
@@ -2382,12 +2380,6 @@
 	}
 
 	template<class T>
-	Constant *LValue<T>::storeValue(Constant *constant, unsigned int alignment) const
-	{
-		return Nucleus::createStore(constant, address, T::getType(), false, alignment);
-	}
-
-	template<class T>
 	Value *LValue<T>::getAddress(Value *index) const
 	{
 		return Nucleus::createGEP(address, T::getType(), index);
@@ -2452,12 +2444,6 @@
 	}
 
 	template<class T>
-	RValue<T>::RValue(Constant *constant)
-	{
-		value = Nucleus::createAssign(constant);
-	}
-
-	template<class T>
 	RValue<T>::RValue(const T &lvalue)
 	{
 		value = lvalue.loadValue();
@@ -2644,7 +2630,7 @@
 	template<class T>
 	Pointer<T>::Pointer(const void *external) : alignment((intptr_t)external & 0x0000000F ? 1 : 16)
 	{
-		Constant *globalPointer = Nucleus::createConstantPointer(external, T::getType(), false, alignment);
+		Value *globalPointer = Nucleus::createConstantPointer(external, T::getType(), false, alignment);
 
 		LValue<Pointer<T>>::storeValue(globalPointer);
 	}
diff --git a/src/Reactor/SubzeroReactor.cpp b/src/Reactor/SubzeroReactor.cpp
index ee3b323..df16d79 100644
--- a/src/Reactor/SubzeroReactor.cpp
+++ b/src/Reactor/SubzeroReactor.cpp
@@ -68,7 +68,6 @@
 	};
 
 	class Value : public Ice::Variable {};
-	class Constant : public Ice::Constant {};
 	class BasicBlock : public Ice::CfgNode {};
 
 	Ice::Type T(Type *t)
@@ -92,11 +91,6 @@
 		return reinterpret_cast<Value*>(v);
 	}
 
-	Constant *C(Ice::Constant *c)
-	{
-		return reinterpret_cast<Constant*>(c);
-	}
-
 	BasicBlock *B(Ice::CfgNode *b)
 	{
 		return reinterpret_cast<BasicBlock*>(b);
@@ -456,7 +450,7 @@
 		return createArithmetic(Ice::InstArithmetic::Xor, lhs, rhs);
 	}
 
-	Value *Nucleus::createAssign(Constant *constant)
+	static Value *createAssign(Ice::Constant *constant)
 	{
 		Ice::Variable *value = ::function->makeVariable(constant->getType());
 		auto assign = Ice::InstAssign::create(::function, value, constant);
@@ -571,20 +565,13 @@
 		return value;
 	}
 
-	Constant *Nucleus::createStore(Constant *constant, Value *ptr, Type *type, bool isVolatile, unsigned int align)
-	{
-		auto store = Ice::InstStore::create(::function, constant, ptr, align);
-		::basicBlock->appendInst(store);
-		return constant;
-	}
-
 	Value *Nucleus::createGEP(Value *ptr, Type *type, Value *index)
 	{
 		assert(index->getType() == Ice::IceType_i32);
 
 		if(!Ice::isByteSizedType(T(type)))
 		{
-			index = createMul(index, createAssign(createConstantInt((int)Ice::typeWidthInBytes(T(type)))));
+			index = createMul(index, createConstantInt((int)Ice::typeWidthInBytes(T(type))));
 		}
 
 		if(sizeof(void*) == 8)
@@ -864,7 +851,7 @@
 		assert(false && "UNIMPLEMENTED"); return nullptr;
 	}
 
-	Constant *Nucleus::createConstantPointer(const void *address, Type *Ty, bool isConstant, unsigned int Align)
+	Value *Nucleus::createConstantPointer(const void *address, Type *Ty, bool isConstant, unsigned int Align)
 	{
 		assert(false && "UNIMPLEMENTED"); return nullptr;
 	}
@@ -881,62 +868,67 @@
 		}
 	}
 
-	Constant *Nucleus::createNullValue(Type *Ty)
+	Value *Nucleus::createNullValue(Type *Ty)
 	{
 		assert(false && "UNIMPLEMENTED"); return nullptr;
 	}
 
-	Constant *Nucleus::createConstantInt(int64_t i)
+	Value *Nucleus::createConstantLong(int64_t i)
 	{
 		assert(false && "UNIMPLEMENTED"); return nullptr;
 	}
 
-	Constant *Nucleus::createConstantInt(int i)
+	Value *Nucleus::createConstantInt(int i)
 	{
-		return C(::context->getConstantInt32(i));
+		return createAssign(::context->getConstantInt32(i));
 	}
 
-	Constant *Nucleus::createConstantInt(unsigned int i)
+	Value *Nucleus::createConstantInt(unsigned int i)
 	{
 		assert(false && "UNIMPLEMENTED"); return nullptr;
 	}
 
-	Constant *Nucleus::createConstantBool(bool b)
+	Value *Nucleus::createConstantBool(bool b)
 	{
 		assert(false && "UNIMPLEMENTED"); return nullptr;
 	}
 
-	Constant *Nucleus::createConstantByte(signed char i)
+	Value *Nucleus::createConstantByte(signed char i)
 	{
 		assert(false && "UNIMPLEMENTED"); return nullptr;
 	}
 
-	Constant *Nucleus::createConstantByte(unsigned char i)
+	Value *Nucleus::createConstantByte(unsigned char i)
 	{
 		assert(false && "UNIMPLEMENTED"); return nullptr;
 	}
 
-	Constant *Nucleus::createConstantShort(short i)
+	Value *Nucleus::createConstantShort(short i)
 	{
 		assert(false && "UNIMPLEMENTED"); return nullptr;
 	}
 
-	Constant *Nucleus::createConstantShort(unsigned short i)
+	Value *Nucleus::createConstantShort(unsigned short i)
 	{
 		assert(false && "UNIMPLEMENTED"); return nullptr;
 	}
 
-	Constant *Nucleus::createConstantFloat(float x)
+	Value *Nucleus::createConstantFloat(float x)
 	{
 		assert(false && "UNIMPLEMENTED"); return nullptr;
 	}
 
-	Constant *Nucleus::createNullPointer(Type *Ty)
+	Value *Nucleus::createNullPointer(Type *Ty)
 	{
 		assert(false && "UNIMPLEMENTED"); return nullptr;
 	}
 
-	Constant *Nucleus::createConstantVector(Constant *const *Vals, unsigned NumVals)
+	Value *Nucleus::createConstantVector(const int64_t *constants, Type *type)
+	{
+		assert(false && "UNIMPLEMENTED"); return nullptr;
+	}
+
+	Value *Nucleus::createConstantVector(const double *constants, Type *type)
 	{
 		assert(false && "UNIMPLEMENTED"); return nullptr;
 	}
@@ -3697,7 +3689,7 @@
 
 	RValue<Long> Long::operator=(int64_t rhs) const
 	{
-		return RValue<Long>(storeValue(Nucleus::createConstantInt(rhs)));
+		return RValue<Long>(storeValue(Nucleus::createConstantLong(rhs)));
 	}
 
 	RValue<Long> Long::operator=(RValue<Long> rhs) const
@@ -4593,13 +4585,8 @@
 	{
 	//	xyzw.parent = this;
 
-		Constant *constantVector[4];
-		constantVector[0] = Nucleus::createConstantInt(x);
-		constantVector[1] = Nucleus::createConstantInt(y);
-		constantVector[2] = Nucleus::createConstantInt(z);
-		constantVector[3] = Nucleus::createConstantInt(w);
-
-		storeValue(Nucleus::createConstantVector(constantVector, 4));
+		int64_t constantVector[4] = {x, y, z, w};
+		storeValue(Nucleus::createConstantVector(constantVector, Int4::getType()));
 	}
 
 	Int4::Int4(RValue<Int4> rhs)
@@ -4933,13 +4920,8 @@
 	{
 	//	xyzw.parent = this;
 
-		Constant *constantVector[4];
-		constantVector[0] = Nucleus::createConstantInt(x);
-		constantVector[1] = Nucleus::createConstantInt(y);
-		constantVector[2] = Nucleus::createConstantInt(z);
-		constantVector[3] = Nucleus::createConstantInt(w);
-
-		storeValue(Nucleus::createConstantVector(constantVector, 4));
+		int64_t constantVector[4] = {x, y, z, w};
+		storeValue(Nucleus::createConstantVector(constantVector, UInt4::getType()));
 	}
 
 	UInt4::UInt4(RValue<UInt4> rhs)
@@ -5480,13 +5462,8 @@
 	{
 		xyzw.parent = this;
 
-		Constant *constantVector[4];
-		constantVector[0] = Nucleus::createConstantFloat(x);
-		constantVector[1] = Nucleus::createConstantFloat(y);
-		constantVector[2] = Nucleus::createConstantFloat(z);
-		constantVector[3] = Nucleus::createConstantFloat(w);
-
-		storeValue(Nucleus::createConstantVector(constantVector, 4));
+		double constantVector[4] = {x, y, z, w};
+		storeValue(Nucleus::createConstantVector(constantVector, Float4::getType()));
 	}
 
 	Float4::Float4(RValue<Float4> rhs)
diff --git a/src/SwiftShader/SwiftShader.vcxproj b/src/SwiftShader/SwiftShader.vcxproj
index d76c155..30f26cf 100644
--- a/src/SwiftShader/SwiftShader.vcxproj
+++ b/src/SwiftShader/SwiftShader.vcxproj
@@ -447,11 +447,6 @@
   <ItemGroup>
     <ProjectReference Include="..\Reactor\Reactor.vcxproj">
       <Project>{28fd076d-10b5-4bd8-a4cf-f44c7002a803}</Project>
-      <Private>true</Private>
-      <ReferenceOutputAssembly>true</ReferenceOutputAssembly>
-      <CopyLocalSatelliteAssemblies>false</CopyLocalSatelliteAssemblies>
-      <LinkLibraryDependencies>true</LinkLibraryDependencies>
-      <UseLibraryDependencyInputs>true</UseLibraryDependencyInputs>
     </ProjectReference>
   </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />