diff --git a/src/Reactor/CPUID.cpp b/src/Reactor/CPUID.cpp
index f3b9024..12637a7 100644
--- a/src/Reactor/CPUID.cpp
+++ b/src/Reactor/CPUID.cpp
@@ -15,16 +15,16 @@
 #include "CPUID.hpp"
 
 #if defined(_WIN32)
-	#ifndef WIN32_LEAN_AND_MEAN
-		#define WIN32_LEAN_AND_MEAN
-	#endif
-	#include <windows.h>
-	#include <intrin.h>
-	#include <float.h>
+#	ifndef WIN32_LEAN_AND_MEAN
+#		define WIN32_LEAN_AND_MEAN
+#	endif
+#	include <windows.h>
+#	include <intrin.h>
+#	include <float.h>
 #else
-	#include <unistd.h>
-	#include <sched.h>
-	#include <sys/types.h>
+#	include <unistd.h>
+#	include <sched.h>
+#	include <sys/types.h>
 #endif
 
 namespace rr {
@@ -162,18 +162,20 @@
 
 static void cpuid(int registers[4], int info)
 {
-	#if defined(__i386__) || defined(__x86_64__)
-		#if defined(_WIN32)
-			__cpuid(registers, info);
-		#else
-			__asm volatile("cpuid": "=a" (registers[0]), "=b" (registers[1]), "=c" (registers[2]), "=d" (registers[3]): "a" (info));
-		#endif
-	#else
-		registers[0] = 0;
-		registers[1] = 0;
-		registers[2] = 0;
-		registers[3] = 0;
-	#endif
+#if defined(__i386__) || defined(__x86_64__)
+#	if defined(_WIN32)
+	__cpuid(registers, info);
+#	else
+	__asm volatile("cpuid"
+	               : "=a"(registers[0]), "=b"(registers[1]), "=c"(registers[2]), "=d"(registers[3])
+	               : "a"(info));
+#	endif
+#else
+	registers[0] = 0;
+	registers[1] = 0;
+	registers[2] = 0;
+	registers[3] = 0;
+#endif
 }
 
 bool CPUID::detectMMX()
diff --git a/src/Reactor/CPUID.hpp b/src/Reactor/CPUID.hpp
index 577e237..a97c6d4 100644
--- a/src/Reactor/CPUID.hpp
+++ b/src/Reactor/CPUID.hpp
@@ -18,11 +18,11 @@
 namespace rr {
 
 #if !defined(__i386__) && defined(_M_IX86)
-	#define __i386__ 1
+#	define __i386__ 1
 #endif
 
-#if !defined(__x86_64__) && (defined(_M_AMD64) || defined (_M_X64))
-	#define __x86_64__ 1
+#if !defined(__x86_64__) && (defined(_M_AMD64) || defined(_M_X64))
+#	define __x86_64__ 1
 #endif
 
 class CPUID
@@ -30,7 +30,7 @@
 public:
 	static bool supportsMMX();
 	static bool supportsCMOV();
-	static bool supportsMMX2();   // MMX instructions added by SSE: pshufw, pmulhuw, pmovmskb, pavgw/b, pextrw, pinsrw, pmaxsw/ub, etc.
+	static bool supportsMMX2();  // MMX instructions added by SSE: pshufw, pmulhuw, pmovmskb, pavgw/b, pextrw, pinsrw, pmaxsw/ub, etc.
 	static bool supportsSSE();
 	static bool supportsSSE2();
 	static bool supportsSSE3();
@@ -89,7 +89,7 @@
 
 inline bool CPUID::supportsMMX2()
 {
-	return supportsSSE();   // Coincides with 64-bit integer vector instructions supported by SSE
+	return supportsSSE();  // Coincides with 64-bit integer vector instructions supported by SSE
 }
 
 inline bool CPUID::supportsSSE()
@@ -119,4 +119,4 @@
 
 }  // namespace rr
 
-#endif   // rr_CPUID_hpp
+#endif  // rr_CPUID_hpp
diff --git a/src/Reactor/Coroutine.hpp b/src/Reactor/Coroutine.hpp
index 8bd601e..92ad2e3 100644
--- a/src/Reactor/Coroutine.hpp
+++ b/src/Reactor/Coroutine.hpp
@@ -17,7 +17,7 @@
 #include <memory>
 
 #ifndef rr_ReactorCoroutine_hpp
-#define rr_ReactorCoroutine_hpp
+#	define rr_ReactorCoroutine_hpp
 
 namespace rr {
 
@@ -26,17 +26,19 @@
 {
 protected:
 	StreamBase(const std::shared_ptr<Routine> &routine, Nucleus::CoroutineHandle handle)
-		: routine(routine), handle(handle) {}
+	    : routine(routine)
+	    , handle(handle)
+	{}
 
 	~StreamBase()
 	{
-		auto pfn = (Nucleus::CoroutineDestroy*)routine->getEntry(Nucleus::CoroutineEntryDestroy);
+		auto pfn = (Nucleus::CoroutineDestroy *)routine->getEntry(Nucleus::CoroutineEntryDestroy);
 		pfn(handle);
 	}
 
-	bool await(void* out)
+	bool await(void *out)
 	{
-		auto pfn = (Nucleus::CoroutineAwait*)routine->getEntry(Nucleus::CoroutineEntryAwait);
+		auto pfn = (Nucleus::CoroutineAwait *)routine->getEntry(Nucleus::CoroutineEntryAwait);
 		return pfn(handle, out);
 	}
 
@@ -53,13 +55,14 @@
 {
 public:
 	inline Stream(const std::shared_ptr<Routine> &routine, Nucleus::CoroutineHandle handle)
-		: StreamBase(routine, handle) {}
+	    : StreamBase(routine, handle)
+	{}
 
 	// await() retrieves the next yielded value from the coroutine.
 	// Returns true if the coroutine yieled a value and out was assigned a
 	// new value. If await() returns false, the coroutine has finished
 	// execution and await() will return false for all future calls.
-	inline bool await(T& out) { return StreamBase::await(&out); }
+	inline bool await(T &out) { return StreamBase::await(&out); }
 };
 
 template<typename FunctionType>
@@ -143,7 +146,7 @@
 protected:
 	std::unique_ptr<Nucleus> core;
 	std::shared_ptr<Routine> routine;
-	std::vector<Type*> arguments;
+	std::vector<Type *> arguments;
 };
 
 template<typename Return, typename... Arguments>
@@ -151,7 +154,7 @@
 {
 	core.reset(new Nucleus());
 
-	std::vector<Type*> types = {CToReactorT<Arguments>::getType()...};
+	std::vector<Type *> types = { CToReactorT<Arguments>::getType()... };
 	for(auto type : types)
 	{
 		if(type != Void::getType())
@@ -180,20 +183,23 @@
 	finalize();
 
 	using Sig = Nucleus::CoroutineBegin<Arguments...>;
-	auto pfn = (Sig*)routine->getEntry(Nucleus::CoroutineEntryBegin);
+	auto pfn = (Sig *)routine->getEntry(Nucleus::CoroutineEntryBegin);
 	auto handle = pfn(args...);
 	return std::unique_ptr<Stream<Return>>(new Stream<Return>(routine, handle));
 }
 
-#ifdef Yield // Defined in WinBase.h
-#undef Yield
-#endif
+#	ifdef Yield  // Defined in WinBase.h
+#		undef Yield
+#	endif
 
 // Suspends execution of the coroutine and yields val to the caller.
 // Execution of the coroutine will resume after val is retrieved.
 template<typename T>
-inline void Yield(const T &val) { Nucleus::yield(ValueOf(val)); }
+inline void Yield(const T &val)
+{
+	Nucleus::yield(ValueOf(val));
+}
 
-} // namespace rr
+}  // namespace rr
 
-#endif // rr_ReactorCoroutine_hpp
\ No newline at end of file
+#endif  // rr_ReactorCoroutine_hpp
\ No newline at end of file
diff --git a/src/Reactor/Debug.cpp b/src/Reactor/Debug.cpp
index df8e8fc..65a894f 100644
--- a/src/Reactor/Debug.cpp
+++ b/src/Reactor/Debug.cpp
@@ -14,8 +14,8 @@
 
 #include "Debug.hpp"
 
-#include <string>
 #include <stdarg.h>
+#include <string>
 
 namespace rr {
 
diff --git a/src/Reactor/Debug.hpp b/src/Reactor/Debug.hpp
index da8a48d..c0f3232 100644
--- a/src/Reactor/Debug.hpp
+++ b/src/Reactor/Debug.hpp
@@ -17,18 +17,18 @@
 #ifndef rr_DEBUG_H_
 #define rr_DEBUG_H_
 
-#include <stdlib.h>
 #include <assert.h>
 #include <stdio.h>
+#include <stdlib.h>
 
 #if !defined(TRACE_OUTPUT_FILE)
-#define TRACE_OUTPUT_FILE "debug.txt"
+#	define TRACE_OUTPUT_FILE "debug.txt"
 #endif
 
 #if defined(__GNUC__) || defined(__clang__)
-#define CHECK_PRINTF_ARGS __attribute__((format(printf, 1, 2)))
+#	define CHECK_PRINTF_ARGS __attribute__((format(printf, 1, 2)))
 #else
-#define CHECK_PRINTF_ARGS
+#	define CHECK_PRINTF_ARGS
 #endif
 
 namespace rr {
@@ -49,9 +49,9 @@
 // A macro to output a trace of a function call and its arguments to the
 // debugging log. Disabled if RR_DISABLE_TRACE is defined.
 #if defined(RR_DISABLE_TRACE)
-#define TRACE(message, ...) (void(0))
+#	define TRACE(message, ...) (void(0))
 #else
-#define TRACE(message, ...) rr::trace("%s:%d TRACE: " message "\n", __FILE__, __LINE__, ##__VA_ARGS__)
+#	define TRACE(message, ...) rr::trace("%s:%d TRACE: " message "\n", __FILE__, __LINE__, ##__VA_ARGS__)
 #endif
 
 // A macro to print a warning message to the debugging log and stderr to denote
@@ -75,26 +75,34 @@
 //   WARN() in release builds (NDEBUG && !DCHECK_ALWAYS_ON)
 #undef DABORT
 #if !defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)
-#define DABORT(message, ...) ABORT(message, ##__VA_ARGS__)
+#	define DABORT(message, ...) ABORT(message, ##__VA_ARGS__)
 #else
-#define DABORT(message, ...) WARN(message, ##__VA_ARGS__)
+#	define DABORT(message, ...) WARN(message, ##__VA_ARGS__)
 #endif
 
 // A macro asserting a condition.
 // If the condition fails, the condition and message is passed to DABORT().
 #undef ASSERT_MSG
-#define ASSERT_MSG(expression, format, ...) do { \
-	if(!(expression)) { \
-		DABORT("ASSERT(%s): " format "\n", #expression, ##__VA_ARGS__); \
-	} } while(0)
+#define ASSERT_MSG(expression, format, ...)                                 \
+	do                                                                      \
+	{                                                                       \
+		if(!(expression))                                                   \
+		{                                                                   \
+			DABORT("ASSERT(%s): " format "\n", #expression, ##__VA_ARGS__); \
+		}                                                                   \
+	} while(0)
 
 // A macro asserting a condition.
 // If the condition fails, the condition is passed to DABORT().
 #undef ASSERT
-#define ASSERT(expression) do { \
-	if(!(expression)) { \
-		DABORT("ASSERT(%s)\n", #expression); \
-	} } while(0)
+#define ASSERT(expression)                       \
+	do                                           \
+	{                                            \
+		if(!(expression))                        \
+		{                                        \
+			DABORT("ASSERT(%s)\n", #expression); \
+		}                                        \
+	} while(0)
 
 // A macro to indicate unimplemented functionality.
 #undef UNIMPLEMENTED
@@ -107,12 +115,16 @@
 // A macro asserting a condition and performing a return.
 #undef ASSERT_OR_RETURN
 #if !defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)
-#define ASSERT_OR_RETURN(expression) ASSERT(expression)
+#	define ASSERT_OR_RETURN(expression) ASSERT(expression)
 #else
-#define ASSERT_OR_RETURN(expression) do { \
-	if(!(expression)) { \
-		return; \
-	} } while(0)
+#	define ASSERT_OR_RETURN(expression) \
+		do                               \
+		{                                \
+			if(!(expression))            \
+			{                            \
+				return;                  \
+			}                            \
+		} while(0)
 #endif
 
-#endif   // rr_DEBUG_H_
+#endif  // rr_DEBUG_H_
diff --git a/src/Reactor/DebugAndroid.cpp b/src/Reactor/DebugAndroid.cpp
index 2a6569c..5194cc3 100644
--- a/src/Reactor/DebugAndroid.cpp
+++ b/src/Reactor/DebugAndroid.cpp
@@ -14,16 +14,16 @@
 
 #include "DebugAndroid.hpp"
 
-#include <stdlib.h>
-#include <unistd.h>
-#include <sys/types.h>
 #include <cutils/properties.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <unistd.h>
 
 void AndroidEnterDebugger()
 {
 	ALOGE(__FUNCTION__);
 #ifndef NDEBUG
-	static volatile int * const makefault = nullptr;
+	static volatile int *const makefault = nullptr;
 	char value[PROPERTY_VALUE_MAX];
 	property_get("debug.db.uid", value, "-1");
 	int debug_uid = atoi(value);
@@ -31,7 +31,8 @@
 	{
 		ALOGE("Waiting for debugger: gdbserver :${PORT} --attach %u. Look for thread %u", getpid(), gettid());
 		volatile int waiting = 1;
-		while(waiting) {
+		while(waiting)
+		{
 			sleep(1);
 		}
 	}
diff --git a/src/Reactor/DebugAndroid.hpp b/src/Reactor/DebugAndroid.hpp
index bb7451e..a8cbc9f 100644
--- a/src/Reactor/DebugAndroid.hpp
+++ b/src/Reactor/DebugAndroid.hpp
@@ -16,11 +16,11 @@
 #define DebugAndroid_hpp
 
 #if ANDROID_PLATFORM_SDK_VERSION < 27
-#include <cutils/log.h>
+#	include <cutils/log.h>
 #elif ANDROID_PLATFORM_SDK_VERSION >= 27
-#include <log/log.h>
+#	include <log/log.h>
 #else
-#error "ANDROID_PLATFORM_SDK_VERSION is not defined"
+#	error "ANDROID_PLATFORM_SDK_VERSION is not defined"
 #endif
 
 #include <cassert>
@@ -48,52 +48,61 @@
  */
 void AndroidEnterDebugger();
 
-#define ASSERT(E) do { \
-		if(!(E)) { \
-			ALOGE("badness: assertion_failed %s in %s at %s:%d", #E,	\
-				  __FUNCTION__, __FILE__, __LINE__);					\
-			AndroidEnterDebugger();										\
-		}																\
+#define ASSERT(E)                                                    \
+	do                                                               \
+	{                                                                \
+		if(!(E))                                                     \
+		{                                                            \
+			ALOGE("badness: assertion_failed %s in %s at %s:%d", #E, \
+			      __FUNCTION__, __FILE__, __LINE__);                 \
+			AndroidEnterDebugger();                                  \
+		}                                                            \
 	} while(0)
 
 #undef assert
 #define assert(E) ASSERT(E)
 
-#define ERR(format, ...)												\
-	do {																\
+#define ERR(format, ...)                                                    \
+	do                                                                      \
+	{                                                                       \
 		ALOGE("badness: err %s %s:%d (" format ")", __FUNCTION__, __FILE__, \
-			  __LINE__, ##__VA_ARGS__);									\
-		AndroidEnterDebugger();											\
+		      __LINE__, ##__VA_ARGS__);                                     \
+		AndroidEnterDebugger();                                             \
 	} while(0)
 
-#define FIXME(format, ...)												\
-	do {																\
+#define FIXME(format, ...)                                                    \
+	do                                                                        \
+	{                                                                         \
 		ALOGE("badness: fixme %s %s:%d (" format ")", __FUNCTION__, __FILE__, \
-			  __LINE__, ##__VA_ARGS__);									\
-		AndroidEnterDebugger();											\
+		      __LINE__, ##__VA_ARGS__);                                       \
+		AndroidEnterDebugger();                                               \
 	} while(0)
 
 // TODO: Handle __VA_ARGS__ (can be empty)
-#define UNIMPLEMENTED(...) do {						\
-		ALOGE("badness: unimplemented: %s %s:%d",	\
-			  __FUNCTION__, __FILE__, __LINE__);	\
-		AndroidEnterDebugger();						\
+#define UNIMPLEMENTED(...)                        \
+	do                                            \
+	{                                             \
+		ALOGE("badness: unimplemented: %s %s:%d", \
+		      __FUNCTION__, __FILE__, __LINE__);  \
+		AndroidEnterDebugger();                   \
 	} while(0)
 
-#define UNREACHABLE(value) do {                                         \
+#define UNREACHABLE(value)                                           \
+	do                                                               \
+	{                                                                \
 		ALOGE("badness: unreachable case reached: %s %s:%d. %s: %d", \
-			  __FUNCTION__, __FILE__, __LINE__, #value, value);			\
-		AndroidEnterDebugger();                                         \
+		      __FUNCTION__, __FILE__, __LINE__, #value, value);      \
+		AndroidEnterDebugger();                                      \
 	} while(0)
 
 #ifndef NDEBUG
-	#define TRACE(format, ...)								   \
+#	define TRACE(format, ...)                                 \
 		ALOGV("%s %s:%d (" format ")", __FUNCTION__, __FILE__, \
-			  __LINE__, ##__VA_ARGS__)
+		      __LINE__, ##__VA_ARGS__)
 #else
-	#define TRACE(...) ((void)0)
+#	define TRACE(...) ((void)0)
 #endif
 
 void trace(const char *format, ...);
 
-#endif   // DebugAndroid_hpp
+#endif  // DebugAndroid_hpp
diff --git a/src/Reactor/EmulatedReactor.cpp b/src/Reactor/EmulatedReactor.cpp
index 3740224..6fb7385 100644
--- a/src/Reactor/EmulatedReactor.cpp
+++ b/src/Reactor/EmulatedReactor.cpp
@@ -7,18 +7,18 @@
 namespace rr {
 namespace {
 
-template <typename T>
+template<typename T>
 struct UnderlyingType
 {
 	using Type = typename decltype(rr::Extract(std::declval<RValue<T>>(), 0))::rvalue_underlying_type;
 };
 
-template <typename T>
+template<typename T>
 using UnderlyingTypeT = typename UnderlyingType<T>::Type;
 
 // Call single arg function on a vector type
-template <typename Func, typename T>
-RValue<T> call4(Func func, const RValue<T>& x)
+template<typename Func, typename T>
+RValue<T> call4(Func func, const RValue<T> &x)
 {
 	T result;
 	result = Insert(result, Call(func, Extract(x, 0)), 0);
@@ -29,8 +29,8 @@
 }
 
 // Call two arg function on a vector type
-template <typename Func, typename T>
-RValue<T> call4(Func func, const RValue<T>& x, const RValue<T>& y)
+template<typename Func, typename T>
+RValue<T> call4(Func func, const RValue<T> &x, const RValue<T> &y)
 {
 	T result;
 	result = Insert(result, Call(func, Extract(x, 0), Extract(y, 0)), 0);
@@ -40,8 +40,8 @@
 	return result;
 }
 
-template <typename T, typename EL = UnderlyingTypeT<T>>
-void gather(T& out, RValue<Pointer<EL>> base, RValue<Int4> offsets, RValue<Int4> mask, unsigned int alignment, bool zeroMaskedLanes)
+template<typename T, typename EL = UnderlyingTypeT<T>>
+void gather(T &out, RValue<Pointer<EL>> base, RValue<Int4> offsets, RValue<Int4> mask, unsigned int alignment, bool zeroMaskedLanes)
 {
 	constexpr bool atomic = false;
 	constexpr std::memory_order order = std::memory_order_relaxed;
@@ -64,7 +64,7 @@
 	}
 }
 
-template <typename T, typename EL = UnderlyingTypeT<T>>
+template<typename T, typename EL = UnderlyingTypeT<T>>
 void scatter(RValue<Pointer<EL>> base, RValue<T> val, RValue<Int4> offsets, RValue<Int4> mask, unsigned int alignment)
 {
 	constexpr bool atomic = false;
diff --git a/src/Reactor/ExecutableMemory.cpp b/src/Reactor/ExecutableMemory.cpp
index b6cee9c..3fec84d 100644
--- a/src/Reactor/ExecutableMemory.cpp
+++ b/src/Reactor/ExecutableMemory.cpp
@@ -17,20 +17,20 @@
 #include "Debug.hpp"
 
 #if defined(_WIN32)
-	#ifndef WIN32_LEAN_AND_MEAN
-		#define WIN32_LEAN_AND_MEAN
-	#endif
-	#include <windows.h>
-	#include <intrin.h>
+#	ifndef WIN32_LEAN_AND_MEAN
+#		define WIN32_LEAN_AND_MEAN
+#	endif
+#	include <windows.h>
+#	include <intrin.h>
 #elif defined(__Fuchsia__)
-	#include <unistd.h>
-	#include <zircon/process.h>
-	#include <zircon/syscalls.h>
+#	include <unistd.h>
+#	include <zircon/process.h>
+#	include <zircon/syscalls.h>
 #else
-	#include <errno.h>
-	#include <sys/mman.h>
-	#include <stdlib.h>
-	#include <unistd.h>
+#	include <errno.h>
+#	include <sys/mman.h>
+#	include <stdlib.h>
+#	include <unistd.h>
 #endif
 
 #include <memory.h>
@@ -38,8 +38,8 @@
 #undef allocate
 #undef deallocate
 
-#if(defined(__i386__) || defined(_M_IX86) || defined(__x86_64__) || defined (_M_X64)) && !defined(__x86__)
-#define __x86__
+#if(defined(__i386__) || defined(_M_IX86) || defined(__x86_64__) || defined(_M_X64)) && !defined(__x86__)
+#	define __x86__
 #endif
 
 namespace rr {
@@ -47,61 +47,62 @@
 
 struct Allocation
 {
-//	size_t bytes;
+	//	size_t bytes;
 	unsigned char *block;
 };
 
 void *allocateRaw(size_t bytes, size_t alignment)
 {
-	ASSERT((alignment & (alignment - 1)) == 0);   // Power of 2 alignment.
+	ASSERT((alignment & (alignment - 1)) == 0);  // Power of 2 alignment.
 
-	#if defined(LINUX_ENABLE_NAMED_MMAP)
-		if(alignment < sizeof(void*))
+#if defined(LINUX_ENABLE_NAMED_MMAP)
+	if(alignment < sizeof(void *))
+	{
+		return malloc(bytes);
+	}
+	else
+	{
+		void *allocation;
+		int result = posix_memalign(&allocation, alignment, bytes);
+		if(result != 0)
 		{
-			return malloc(bytes);
+			errno = result;
+			allocation = nullptr;
 		}
-		else
-		{
-			void *allocation;
-			int result = posix_memalign(&allocation, alignment, bytes);
-			if(result != 0)
-			{
-				errno = result;
-				allocation = nullptr;
-			}
-			return allocation;
-		}
-	#else
-		unsigned char *block = new unsigned char[bytes + sizeof(Allocation) + alignment];
-		unsigned char *aligned = nullptr;
+		return allocation;
+	}
+#else
+	unsigned char *block = new unsigned char[bytes + sizeof(Allocation) + alignment];
+	unsigned char *aligned = nullptr;
 
-		if(block)
-		{
-			aligned = (unsigned char*)((uintptr_t)(block + sizeof(Allocation) + alignment - 1) & -(intptr_t)alignment);
-			Allocation *allocation = (Allocation*)(aligned - sizeof(Allocation));
+	if(block)
+	{
+		aligned = (unsigned char *)((uintptr_t)(block + sizeof(Allocation) + alignment - 1) & -(intptr_t)alignment);
+		Allocation *allocation = (Allocation *)(aligned - sizeof(Allocation));
 
 		//	allocation->bytes = bytes;
-			allocation->block = block;
-		}
+		allocation->block = block;
+	}
 
-		return aligned;
-	#endif
+	return aligned;
+#endif
 }
 
 #if defined(_WIN32)
 DWORD permissionsToProtectMode(int permissions)
 {
-	switch(permissions) {
+	switch(permissions)
+	{
 		case PERMISSION_READ:
-		  return PAGE_READONLY;
+			return PAGE_READONLY;
 		case PERMISSION_EXECUTE:
-		  return PAGE_EXECUTE;
+			return PAGE_EXECUTE;
 		case PERMISSION_READ | PERMISSION_WRITE:
-		  return PAGE_READWRITE;
+			return PAGE_READWRITE;
 		case PERMISSION_READ | PERMISSION_EXECUTE:
-		  return PAGE_EXECUTE_READ;
+			return PAGE_EXECUTE_READ;
 		case PERMISSION_READ | PERMISSION_WRITE | PERMISSION_EXECUTE:
-		  return PAGE_EXECUTE_READWRITE;
+			return PAGE_EXECUTE_READWRITE;
 	}
 	return PAGE_NOACCESS;
 }
@@ -131,26 +132,26 @@
 // Create a file descriptor for anonymous memory with the given
 // name. Returns -1 on failure.
 // TODO: remove once libc wrapper exists.
-int memfd_create(const char* name, unsigned int flags)
+int memfd_create(const char *name, unsigned int flags)
 {
-	#if __aarch64__
-	#define __NR_memfd_create 279
-	#elif __arm__
-	#define __NR_memfd_create 279
-	#elif __powerpc64__
-	#define __NR_memfd_create 360
-	#elif __i386__
-	#define __NR_memfd_create 356
-	#elif __x86_64__
-	#define __NR_memfd_create 319
-	#endif /* __NR_memfd_create__ */
-	#ifdef __NR_memfd_create
-		// In the event of no system call this returns -1 with errno set
-		// as ENOSYS.
-		return syscall(__NR_memfd_create, name, flags);
-	#else
-		return -1;
-	#endif
+#	if __aarch64__
+#		define __NR_memfd_create 279
+#	elif __arm__
+#		define __NR_memfd_create 279
+#	elif __powerpc64__
+#		define __NR_memfd_create 360
+#	elif __i386__
+#		define __NR_memfd_create 356
+#	elif __x86_64__
+#		define __NR_memfd_create 319
+#	endif /* __NR_memfd_create__ */
+#	ifdef __NR_memfd_create
+	// In the event of no system call this returns -1 with errno set
+	// as ENOSYS.
+	return syscall(__NR_memfd_create, name, flags);
+#	else
+	return -1;
+#	endif
 }
 
 // Returns a file descriptor for use with an anonymous mmap, if
@@ -175,7 +176,8 @@
 #endif  // defined(LINUX_ENABLE_NAMED_MMAP)
 
 #if defined(__Fuchsia__)
-zx_vm_option_t permissionsToZxVmOptions(int permissions) {
+zx_vm_option_t permissionsToZxVmOptions(int permissions)
+{
 	zx_vm_option_t result = 0;
 	if(permissions & PERMISSION_READ)
 	{
@@ -201,13 +203,13 @@
 
 	if(pageSize == 0)
 	{
-		#if defined(_WIN32)
-			SYSTEM_INFO systemInfo;
-			GetSystemInfo(&systemInfo);
-			pageSize = systemInfo.dwPageSize;
-		#else
-			pageSize = sysconf(_SC_PAGESIZE);
-		#endif
+#if defined(_WIN32)
+		SYSTEM_INFO systemInfo;
+		GetSystemInfo(&systemInfo);
+		pageSize = systemInfo.dwPageSize;
+#else
+		pageSize = sysconf(_SC_PAGESIZE);
+#endif
 	}
 
 	return pageSize;
@@ -227,23 +229,23 @@
 
 void deallocate(void *memory)
 {
-	#if defined(LINUX_ENABLE_NAMED_MMAP)
-		free(memory);
-	#else
-		if(memory)
-		{
-			unsigned char *aligned = (unsigned char*)memory;
-			Allocation *allocation = (Allocation*)(aligned - sizeof(Allocation));
+#if defined(LINUX_ENABLE_NAMED_MMAP)
+	free(memory);
+#else
+	if(memory)
+	{
+		unsigned char *aligned = (unsigned char *)memory;
+		Allocation *allocation = (Allocation *)(aligned - sizeof(Allocation));
 
-			delete[] allocation->block;
-		}
-	#endif
+		delete[] allocation->block;
+	}
+#endif
 }
 
 // Rounds |x| up to a multiple of |m|, where |m| is a power of 2.
 inline uintptr_t roundUp(uintptr_t x, uintptr_t m)
 {
-	ASSERT(m > 0 && (m & (m - 1)) == 0); // |m| must be a power of 2.
+	ASSERT(m > 0 && (m & (m - 1)) == 0);  // |m| must be a power of 2.
 	return (x + m - 1) & ~(m - 1);
 }
 
@@ -253,74 +255,76 @@
 	size_t length = roundUp(bytes, pageSize);
 	void *mapping = nullptr;
 
-	#if defined(LINUX_ENABLE_NAMED_MMAP)
-		int flags = MAP_PRIVATE;
+#if defined(LINUX_ENABLE_NAMED_MMAP)
+	int flags = MAP_PRIVATE;
 
-		// Try to name the memory region for the executable code,
-		// to aid profilers.
-		int anonFd = anonymousFd();
-		if(anonFd == -1)
-		{
-			flags |= MAP_ANONYMOUS;
-		}
-		else
-		{
-			ensureAnonFileSize(anonFd, length);
-		}
+	// Try to name the memory region for the executable code,
+	// to aid profilers.
+	int anonFd = anonymousFd();
+	if(anonFd == -1)
+	{
+		flags |= MAP_ANONYMOUS;
+	}
+	else
+	{
+		ensureAnonFileSize(anonFd, length);
+	}
 
-		mapping = mmap(
-			nullptr, length, permissionsToMmapProt(permissions), flags, anonFd, 0);
+	mapping = mmap(
+	    nullptr, length, permissionsToMmapProt(permissions), flags, anonFd, 0);
 
-		if(mapping == MAP_FAILED)
-		{
-			mapping = nullptr;
-		}
-	#elif defined(__Fuchsia__)
-		zx_handle_t vmo;
-		if(zx_vmo_create(length, 0, &vmo) != ZX_OK) {
-			return nullptr;
-		}
-		if(need_exec &&
-		    zx_vmo_replace_as_executable(vmo, ZX_HANDLE_INVALID, &vmo) != ZX_OK)
-		{
-			return nullptr;
-		}
-		zx_vaddr_t reservation;
-		zx_status_t status = zx_vmar_map(
-			zx_vmar_root_self(), permissionsToZxVmOptions(permissions), 0, vmo,
-			0, length, &reservation);
-		zx_handle_close(vmo);
-		if(status != ZX_OK) {
-			return nullptr;
-		}
+	if(mapping == MAP_FAILED)
+	{
+		mapping = nullptr;
+	}
+#elif defined(__Fuchsia__)
+	zx_handle_t vmo;
+	if(zx_vmo_create(length, 0, &vmo) != ZX_OK)
+	{
+		return nullptr;
+	}
+	if(need_exec &&
+	   zx_vmo_replace_as_executable(vmo, ZX_HANDLE_INVALID, &vmo) != ZX_OK)
+	{
+		return nullptr;
+	}
+	zx_vaddr_t reservation;
+	zx_status_t status = zx_vmar_map(
+	    zx_vmar_root_self(), permissionsToZxVmOptions(permissions), 0, vmo,
+	    0, length, &reservation);
+	zx_handle_close(vmo);
+	if(status != ZX_OK)
+	{
+		return nullptr;
+	}
 
-		// zx_vmar_map() returns page-aligned address.
-		ASSERT(roundUp(reservation, pageSize) == reservation);
+	// zx_vmar_map() returns page-aligned address.
+	ASSERT(roundUp(reservation, pageSize) == reservation);
 
-		mapping = reinterpret_cast<void*>(reservation);
-	#elif defined(__APPLE__)
-		int prot = permissionsToMmapProt(permissions);
-		int flags = MAP_PRIVATE | MAP_ANONYMOUS;
-		// On macOS 10.14 and higher, executables that are code signed with the
-		// "runtime" option cannot execute writable memory by default. They can opt
-		// into this capability by specifying the "com.apple.security.cs.allow-jit"
-		// code signing entitlement and allocating the region with the MAP_JIT flag.
-		mapping = mmap(nullptr, length, prot, flags | MAP_JIT, -1, 0);
+	mapping = reinterpret_cast<void *>(reservation);
+#elif defined(__APPLE__)
+	int prot = permissionsToMmapProt(permissions);
+	int flags = MAP_PRIVATE | MAP_ANONYMOUS;
+	// On macOS 10.14 and higher, executables that are code signed with the
+	// "runtime" option cannot execute writable memory by default. They can opt
+	// into this capability by specifying the "com.apple.security.cs.allow-jit"
+	// code signing entitlement and allocating the region with the MAP_JIT flag.
+	mapping = mmap(nullptr, length, prot, flags | MAP_JIT, -1, 0);
 
-		if(mapping == MAP_FAILED)
-		{
-			// Retry without MAP_JIT (for older macOS versions).
-			mapping = mmap(nullptr, length, prot, flags, -1, 0);
-		}
+	if(mapping == MAP_FAILED)
+	{
+		// Retry without MAP_JIT (for older macOS versions).
+		mapping = mmap(nullptr, length, prot, flags, -1, 0);
+	}
 
-		if(mapping == MAP_FAILED)
-		{
-			mapping = nullptr;
-		}
-	#else
-		mapping = allocate(length, pageSize);
-		protectMemoryPages(mapping, length, permissions);
-	#endif
+	if(mapping == MAP_FAILED)
+	{
+		mapping = nullptr;
+	}
+#else
+	mapping = allocate(length, pageSize);
+	protectMemoryPages(mapping, length, permissions);
+#endif
 
 	return mapping;
 }
@@ -331,48 +335,48 @@
 		return;
 	bytes = roundUp(bytes, memoryPageSize());
 
-	#if defined(_WIN32)
-		unsigned long oldProtection;
-		BOOL result =
-			VirtualProtect(memory, bytes, permissionsToProtectMode(permissions),
-			               &oldProtection);
-		ASSERT(result);
-	#elif defined(__Fuchsia__)
-		zx_status_t status = zx_vmar_protect(
-			zx_vmar_root_self(), permissionsToZxVmOptions(permissions),
-			reinterpret_cast<zx_vaddr_t>(memory), bytes);
-		ASSERT(status == ZX_OK);
-	#else
-		int result =
-			mprotect(memory, bytes, permissionsToMmapProt(permissions));
-		ASSERT(result == 0);
-	#endif
+#if defined(_WIN32)
+	unsigned long oldProtection;
+	BOOL result =
+	    VirtualProtect(memory, bytes, permissionsToProtectMode(permissions),
+	                   &oldProtection);
+	ASSERT(result);
+#elif defined(__Fuchsia__)
+	zx_status_t status = zx_vmar_protect(
+	    zx_vmar_root_self(), permissionsToZxVmOptions(permissions),
+	    reinterpret_cast<zx_vaddr_t>(memory), bytes);
+	ASSERT(status == ZX_OK);
+#else
+	int result =
+	    mprotect(memory, bytes, permissionsToMmapProt(permissions));
+	ASSERT(result == 0);
+#endif
 }
 
 void deallocateMemoryPages(void *memory, size_t bytes)
 {
-	#if defined(_WIN32)
-		unsigned long oldProtection;
-		BOOL result =
-			VirtualProtect(memory, bytes, PAGE_READWRITE, &oldProtection);
-		ASSERT(result);
-		deallocate(memory);
-	#elif defined(LINUX_ENABLE_NAMED_MMAP) || defined(__APPLE__)
-		size_t pageSize = memoryPageSize();
-		size_t length = (bytes + pageSize - 1) & ~(pageSize - 1);
-		int result = munmap(memory, length);
-		ASSERT(result == 0);
-	#elif defined(__Fuchsia__)
-		size_t pageSize = memoryPageSize();
-		size_t length = roundUp(bytes, pageSize);
-		zx_status_t status =  zx_vmar_unmap(
-			zx_vmar_root_self(), reinterpret_cast<zx_vaddr_t>(memory), length);
-		ASSERT(status == ZX_OK);
-	#else
-		int result = mprotect(memory, bytes, PROT_READ | PROT_WRITE);
-		ASSERT(result == 0);
-		deallocate(memory);
-	#endif
+#if defined(_WIN32)
+	unsigned long oldProtection;
+	BOOL result =
+	    VirtualProtect(memory, bytes, PAGE_READWRITE, &oldProtection);
+	ASSERT(result);
+	deallocate(memory);
+#elif defined(LINUX_ENABLE_NAMED_MMAP) || defined(__APPLE__)
+	size_t pageSize = memoryPageSize();
+	size_t length = (bytes + pageSize - 1) & ~(pageSize - 1);
+	int result = munmap(memory, length);
+	ASSERT(result == 0);
+#elif defined(__Fuchsia__)
+	size_t pageSize = memoryPageSize();
+	size_t length = roundUp(bytes, pageSize);
+	zx_status_t status = zx_vmar_unmap(
+	    zx_vmar_root_self(), reinterpret_cast<zx_vaddr_t>(memory), length);
+	ASSERT(status == ZX_OK);
+#else
+	int result = mprotect(memory, bytes, PROT_READ | PROT_WRITE);
+	ASSERT(result == 0);
+	deallocate(memory);
+#endif
 }
 
 }  // namespace rr
diff --git a/src/Reactor/ExecutableMemory.hpp b/src/Reactor/ExecutableMemory.hpp
index b0ca05e..dbbe32a 100644
--- a/src/Reactor/ExecutableMemory.hpp
+++ b/src/Reactor/ExecutableMemory.hpp
@@ -23,7 +23,8 @@
 
 size_t memoryPageSize();
 
-enum MemoryPermission  {
+enum MemoryPermission
+{
 	PERMISSION_READ = 1,
 	PERMISSION_WRITE = 2,
 	PERMISSION_EXECUTE = 4,
@@ -31,7 +32,7 @@
 
 // Allocates memory with the specified permissions. If |need_exec| is true then
 // the allocate memory can be made marked executable using protectMemoryPages().
-void* allocateMemoryPages(size_t bytes, int permissions, bool need_exec);
+void *allocateMemoryPages(size_t bytes, int permissions, bool need_exec);
 
 // Sets permissions for memory allocated with allocateMemoryPages().
 void protectMemoryPages(void *memory, size_t bytes, int permissions);
@@ -58,7 +59,9 @@
 class unaligned_ref
 {
 public:
-	explicit unaligned_ref(void *ptr) : ptr((P*)ptr) {}
+	explicit unaligned_ref(void *ptr)
+	    : ptr((P *)ptr)
+	{}
 
 	template<typename V>
 	P operator=(V value)
@@ -69,7 +72,7 @@
 
 	operator P()
 	{
-		return unaligned_read((P*)ptr);
+		return unaligned_read((P *)ptr);
 	}
 
 private:
@@ -83,7 +86,9 @@
 	friend class unaligned_ptr;
 
 public:
-	unaligned_ptr(P *ptr) : ptr(ptr) {}
+	unaligned_ptr(P *ptr)
+	    : ptr(ptr)
+	{}
 
 	unaligned_ref<P> operator*()
 	{
@@ -102,4 +107,4 @@
 
 }  // namespace rr
 
-#endif   // rr_ExecutableMemory_hpp
+#endif  // rr_ExecutableMemory_hpp
diff --git a/src/Reactor/LLVMReactor.cpp b/src/Reactor/LLVMReactor.cpp
index 4b6bb77..7b06cb4 100644
--- a/src/Reactor/LLVMReactor.cpp
+++ b/src/Reactor/LLVMReactor.cpp
@@ -12,16 +12,16 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "Reactor.hpp"
-#include "Debug.hpp"
 #include "LLVMReactor.hpp"
+#include "Debug.hpp"
 #include "LLVMReactorDebugInfo.hpp"
+#include "Reactor.hpp"
 
-#include "x86.hpp"
 #include "CPUID.hpp"
-#include "Thread.hpp"
 #include "ExecutableMemory.hpp"
 #include "MutexLock.hpp"
+#include "Thread.hpp"
+#include "x86.hpp"
 
 #undef min
 #undef max
@@ -29,13 +29,13 @@
 #if defined(__clang__)
 // LLVM has occurances of the extra-semi warning in its headers, which will be
 // treated as an error in SwiftShader targets.
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wextra-semi"
+#	pragma clang diagnostic push
+#	pragma clang diagnostic ignored "-Wextra-semi"
 #endif  // defined(__clang__)
 
 #ifdef _MSC_VER
 __pragma(warning(push))
-__pragma(warning(disable : 4146)) // unary minus operator applied to unsigned type, result still unsigned
+    __pragma(warning(disable : 4146))  // unary minus operator applied to unsigned type, result still unsigned
 #endif
 
 #include "llvm/Analysis/LoopPass.h"
@@ -51,10 +51,10 @@
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GlobalVariable.h"
-#include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/IRBuilder.h"
-#include "llvm/IR/LegacyPassManager.h"
+#include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/LLVMContext.h"
+#include "llvm/IR/LegacyPassManager.h"
 #include "llvm/IR/Mangler.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Verifier.h"
@@ -62,21 +62,24 @@
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Target/TargetOptions.h"
 #include "llvm/Transforms/Coroutines.h"
-#include "llvm/Transforms/InstCombine/InstCombine.h"
 #include "llvm/Transforms/IPO.h"
 #include "llvm/Transforms/IPO/PassManagerBuilder.h"
+#include "llvm/Transforms/InstCombine/InstCombine.h"
 #include "llvm/Transforms/Scalar.h"
 #include "llvm/Transforms/Scalar/GVN.h"
 
 #if defined(__clang__)
-#pragma clang diagnostic pop
-#endif // defined(__clang__)
+#	pragma clang diagnostic pop
+#endif  // defined(__clang__)
 
 #ifdef _MSC_VER
-__pragma(warning(pop))
+    __pragma(warning(pop))
 #endif
 
-#define ARGS(...) {__VA_ARGS__}
+#define ARGS(...)   \
+	{               \
+		__VA_ARGS__ \
+	}
 #define CreateCall2 CreateCall
 #define CreateCall3 CreateCall
 
@@ -89,27 +92,27 @@
 #include <thread>
 
 #if defined(__i386__) || defined(__x86_64__)
-#include <xmmintrin.h>
+#	include <xmmintrin.h>
 #endif
 
 #include <math.h>
 
 #if defined(__x86_64__) && defined(_WIN32)
-	extern "C" void X86CompilationCallback()
-	{
-		UNIMPLEMENTED("X86CompilationCallback");
-	}
+        extern "C" void X86CompilationCallback()
+{
+	UNIMPLEMENTED("X86CompilationCallback");
+}
 #endif
 
 #if defined(_WIN64)
-	extern "C" void __chkstk();
+extern "C" void __chkstk();
 #elif defined(_WIN32)
-	extern "C" void _chkstk();
+extern "C" void _chkstk();
 #endif
 
 namespace rr {
 
-void* resolveExternalSymbol(const char*);
+void *resolveExternalSymbol(const char *);
 
 }  // namespace rr
 
@@ -122,33 +125,34 @@
 	// This uses a static in a function to avoid the cost of a global static
 	// initializer. See http://neugierig.org/software/chromium/notes/2011/08/static-initializers.html
 	static rr::Config config = rr::Config::Edit()
-		.add(rr::Optimization::Pass::ScalarReplAggregates)
-		.add(rr::Optimization::Pass::InstructionCombining)
-		.apply({});
+	                               .add(rr::Optimization::Pass::ScalarReplAggregates)
+	                               .add(rr::Optimization::Pass::InstructionCombining)
+	                               .apply({});
 	return config;
 }
 
 // Cache provides a simple, thread-safe key-value store.
-template <typename KEY, typename VALUE>
+template<typename KEY, typename VALUE>
 class Cache
 {
 public:
 	Cache() = default;
-	Cache(const Cache& other);
+	Cache(const Cache &other);
 	VALUE getOrCreate(KEY key, std::function<VALUE()> create);
+
 private:
-	mutable std::mutex mutex; // mutable required for copy constructor.
+	mutable std::mutex mutex;  // mutable required for copy constructor.
 	std::unordered_map<KEY, VALUE> map;
 };
 
-template <typename KEY, typename VALUE>
-Cache<KEY, VALUE>::Cache(const Cache& other)
+template<typename KEY, typename VALUE>
+Cache<KEY, VALUE>::Cache(const Cache &other)
 {
 	std::unique_lock<std::mutex> lock(other.mutex);
 	map = other.map;
 }
 
-template <typename KEY, typename VALUE>
+template<typename KEY, typename VALUE>
 VALUE Cache<KEY, VALUE>::getOrCreate(KEY key, std::function<VALUE()> create)
 {
 	std::unique_lock<std::mutex> lock(mutex);
@@ -169,11 +173,11 @@
 public:
 	using TargetMachineSPtr = std::shared_ptr<llvm::TargetMachine>;
 
-	static JITGlobals * get();
+	static JITGlobals *get();
 
 	const std::string mcpu;
 	const std::vector<std::string> mattrs;
-	const char* const march;
+	const char *const march;
 	const llvm::TargetOptions targetOptions;
 	const llvm::DataLayout dataLayout;
 
@@ -187,7 +191,7 @@
 	           const char *march,
 	           const llvm::TargetOptions &targetOptions,
 	           const llvm::DataLayout &dataLayout);
-	JITGlobals(const JITGlobals&) = default;
+	JITGlobals(const JITGlobals &) = default;
 
 	// The cache key here is actually a rr::Optimization::Level. We use int
 	// as 'enum class' types do not provide builtin hash functions until
@@ -195,7 +199,7 @@
 	Cache<int, TargetMachineSPtr> targetMachines;
 };
 
-JITGlobals * JITGlobals::get()
+JITGlobals *JITGlobals::get()
 {
 	static JITGlobals instance = create();
 	return &instance;
@@ -206,15 +210,15 @@
 	return targetMachines.getOrCreate(static_cast<int>(optlevel), [&]() {
 		return TargetMachineSPtr(llvm::EngineBuilder()
 #ifdef ENABLE_RR_DEBUG_INFO
-			.setOptLevel(toLLVM(rr::Optimization::Level::None))
+		                             .setOptLevel(toLLVM(rr::Optimization::Level::None))
 #else
-			.setOptLevel(toLLVM(optlevel))
-#endif // ENABLE_RR_DEBUG_INFO
-			.setMCPU(mcpu)
-			.setMArch(march)
-			.setMAttrs(mattrs)
-			.setTargetOptions(targetOptions)
-			.selectTarget());
+		                                                                 .setOptLevel(toLLVM(optlevel))
+#endif  // ENABLE_RR_DEBUG_INFO
+		                             .setMCPU(mcpu)
+		                             .setMArch(march)
+		                             .setMAttrs(mattrs)
+		                             .setTargetOptions(targetOptions)
+		                             .selectTarget());
 	});
 }
 
@@ -237,10 +241,10 @@
 	bool ok = llvm::sys::getHostCPUFeatures(features);
 
 #if defined(__i386__) || defined(__x86_64__) || \
-(defined(__linux__) && (defined(__arm__) || defined(__aarch64__)))
+    (defined(__linux__) && (defined(__arm__) || defined(__aarch64__)))
 	ASSERT_MSG(ok, "llvm::sys::getHostCPUFeatures returned false");
 #else
-	(void) ok; // getHostCPUFeatures always returns false on other platforms
+	(void)ok;  // getHostCPUFeatures always returns false on other platforms
 #endif
 
 	std::vector<std::string> mattrs;
@@ -249,7 +253,7 @@
 		if(feature.second) { mattrs.push_back(feature.first()); }
 	}
 
-	const char* march = nullptr;
+	const char *march = nullptr;
 #if defined(__x86_64__)
 	march = "x86-64";
 #elif defined(__i386__)
@@ -259,28 +263,28 @@
 #elif defined(__arm__)
 	march = "arm";
 #elif defined(__mips__)
-#if defined(__mips64)
+#	if defined(__mips64)
 	march = "mips64el";
-#else
+#	else
 	march = "mipsel";
-#endif
+#	endif
 #elif defined(__powerpc64__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
 	march = "ppc64le";
 #else
-	#error "unknown architecture"
+#	error "unknown architecture"
 #endif
 
 	llvm::TargetOptions targetOptions;
 	targetOptions.UnsafeFPMath = false;
 
 	auto targetMachine = std::unique_ptr<llvm::TargetMachine>(
-		llvm::EngineBuilder()
-			.setOptLevel(llvm::CodeGenOpt::None)
-			.setMCPU(mcpu)
-			.setMArch(march)
-			.setMAttrs(mattrs)
-			.setTargetOptions(targetOptions)
-			.selectTarget());
+	    llvm::EngineBuilder()
+	        .setOptLevel(llvm::CodeGenOpt::None)
+	        .setMCPU(mcpu)
+	        .setMArch(march)
+	        .setMAttrs(mattrs)
+	        .setTargetOptions(targetOptions)
+	        .selectTarget());
 
 	auto dataLayout = targetMachine->createDataLayout();
 
@@ -291,25 +295,25 @@
 {
 	switch(level)
 	{
-		case rr::Optimization::Level::None:       return ::llvm::CodeGenOpt::None;
-		case rr::Optimization::Level::Less:       return ::llvm::CodeGenOpt::Less;
-		case rr::Optimization::Level::Default:    return ::llvm::CodeGenOpt::Default;
+		case rr::Optimization::Level::None: return ::llvm::CodeGenOpt::None;
+		case rr::Optimization::Level::Less: return ::llvm::CodeGenOpt::Less;
+		case rr::Optimization::Level::Default: return ::llvm::CodeGenOpt::Default;
 		case rr::Optimization::Level::Aggressive: return ::llvm::CodeGenOpt::Aggressive;
 		default: UNREACHABLE("Unknown Optimization Level %d", int(level));
 	}
 	return ::llvm::CodeGenOpt::Default;
 }
 
-JITGlobals::JITGlobals(const char* mcpu,
+JITGlobals::JITGlobals(const char *mcpu,
                        const std::vector<std::string> &mattrs,
-                       const char* march,
+                       const char *march,
                        const llvm::TargetOptions &targetOptions,
-                       const llvm::DataLayout &dataLayout) :
-		mcpu(mcpu),
-		mattrs(mattrs),
-		march(march),
-		targetOptions(targetOptions),
-		dataLayout(dataLayout)
+                       const llvm::DataLayout &dataLayout)
+    : mcpu(mcpu)
+    , mattrs(mattrs)
+    , march(march)
+    , targetOptions(targetOptions)
+    , dataLayout(dataLayout)
 {
 }
 
@@ -320,9 +324,10 @@
 	~MemoryMapper() final {}
 
 	llvm::sys::MemoryBlock allocateMappedMemory(
-			llvm::SectionMemoryManager::AllocationPurpose purpose,
-			size_t numBytes, const llvm::sys::MemoryBlock *const nearBlock,
-			unsigned flags, std::error_code &errorCode) final {
+	    llvm::SectionMemoryManager::AllocationPurpose purpose,
+	    size_t numBytes, const llvm::sys::MemoryBlock *const nearBlock,
+	    unsigned flags, std::error_code &errorCode) final
+	{
 		errorCode = std::error_code();
 
 		// Round up numBytes to page size.
@@ -330,37 +335,40 @@
 		numBytes = (numBytes + pageSize - 1) & ~(pageSize - 1);
 
 		bool need_exec =
-			purpose == llvm::SectionMemoryManager::AllocationPurpose::Code;
-		void* addr = rr::allocateMemoryPages(
-			numBytes, flagsToPermissions(flags), need_exec);
+		    purpose == llvm::SectionMemoryManager::AllocationPurpose::Code;
+		void *addr = rr::allocateMemoryPages(
+		    numBytes, flagsToPermissions(flags), need_exec);
 		if(!addr)
 			return llvm::sys::MemoryBlock();
 		return llvm::sys::MemoryBlock(addr, numBytes);
 	}
 
 	std::error_code protectMappedMemory(const llvm::sys::MemoryBlock &block,
-	                                    unsigned flags) {
+	                                    unsigned flags)
+	{
 		// Round down base address to align with a page boundary. This matches
 		// DefaultMMapper behavior.
-		void* addr = block.base();
+		void *addr = block.base();
 		size_t size = block.size();
 		size_t pageSize = rr::memoryPageSize();
-		addr = reinterpret_cast<void*>(
-			reinterpret_cast<uintptr_t>(addr) & ~(pageSize - 1));
+		addr = reinterpret_cast<void *>(
+		    reinterpret_cast<uintptr_t>(addr) & ~(pageSize - 1));
 		size += reinterpret_cast<uintptr_t>(block.base()) -
-			reinterpret_cast<uintptr_t>(addr);
+		        reinterpret_cast<uintptr_t>(addr);
 
 		rr::protectMemoryPages(addr, size, flagsToPermissions(flags));
 		return std::error_code();
 	}
 
-	std::error_code releaseMappedMemory(llvm::sys::MemoryBlock &block) {
+	std::error_code releaseMappedMemory(llvm::sys::MemoryBlock &block)
+	{
 		rr::deallocateMemoryPages(block.base(), block.size());
 		return std::error_code();
 	}
 
 private:
-	int flagsToPermissions(unsigned flags) {
+	int flagsToPermissions(unsigned flags)
+	{
 		int result = 0;
 		if(flags & llvm::sys::Memory::MF_READ)
 		{
@@ -376,7 +384,6 @@
 		}
 		return result;
 	}
-
 };
 
 // JITRoutine is a rr::Routine that holds a LLVM JIT session, compiler and
@@ -394,48 +401,47 @@
 
 public:
 	JITRoutine(
-			std::unique_ptr<llvm::Module> module,
-			llvm::Function **funcs,
-			size_t count,
-			const rr::Config &config) :
-		resolver(createLegacyLookupResolver(
-			session,
-			[&](const std::string &name) {
-				void *func = rr::resolveExternalSymbol(name.c_str());
-				if(func != nullptr)
-				{
-					return llvm::JITSymbol(
-						reinterpret_cast<uintptr_t>(func), llvm::JITSymbolFlags::Absolute);
-				}
-				return objLayer.findSymbol(name, true);
-			},
-			[](llvm::Error err) {
-				if(err)
-				{
-					// TODO: Log the symbol resolution errors.
-					return;
-				}
-			})),
-		targetMachine(JITGlobals::get()->getTargetMachine(config.getOptimization().getLevel())),
-		compileLayer(objLayer, llvm::orc::SimpleCompiler(*targetMachine)),
-		objLayer(
-			session,
-			[this](llvm::orc::VModuleKey) {
-				return ObjLayer::Resources{std::make_shared<llvm::SectionMemoryManager>(&memoryMapper), resolver};
-			},
-			ObjLayer::NotifyLoadedFtor(),
-			[](llvm::orc::VModuleKey, const llvm::object::ObjectFile &Obj, const llvm::RuntimeDyld::LoadedObjectInfo &L) {
+	    std::unique_ptr<llvm::Module> module,
+	    llvm::Function **funcs,
+	    size_t count,
+	    const rr::Config &config)
+	    : resolver(createLegacyLookupResolver(
+	          session,
+	          [&](const std::string &name) {
+		          void *func = rr::resolveExternalSymbol(name.c_str());
+		          if(func != nullptr)
+		          {
+			          return llvm::JITSymbol(
+			              reinterpret_cast<uintptr_t>(func), llvm::JITSymbolFlags::Absolute);
+		          }
+		          return objLayer.findSymbol(name, true);
+	          },
+	          [](llvm::Error err) {
+		          if(err)
+		          {
+			          // TODO: Log the symbol resolution errors.
+			          return;
+		          }
+	          }))
+	    , targetMachine(JITGlobals::get()->getTargetMachine(config.getOptimization().getLevel()))
+	    , compileLayer(objLayer, llvm::orc::SimpleCompiler(*targetMachine))
+	    , objLayer(
+	          session,
+	          [this](llvm::orc::VModuleKey) {
+		          return ObjLayer::Resources{ std::make_shared<llvm::SectionMemoryManager>(&memoryMapper), resolver };
+	          },
+	          ObjLayer::NotifyLoadedFtor(),
+	          [](llvm::orc::VModuleKey, const llvm::object::ObjectFile &Obj, const llvm::RuntimeDyld::LoadedObjectInfo &L) {
 #ifdef ENABLE_RR_DEBUG_INFO
-				rr::DebugInfo::NotifyObjectEmitted(Obj, L);
-#endif // ENABLE_RR_DEBUG_INFO
-			},
-			[](llvm::orc::VModuleKey, const llvm::object::ObjectFile &Obj) {
+		          rr::DebugInfo::NotifyObjectEmitted(Obj, L);
+#endif  // ENABLE_RR_DEBUG_INFO
+	          },
+	          [](llvm::orc::VModuleKey, const llvm::object::ObjectFile &Obj) {
 #ifdef ENABLE_RR_DEBUG_INFO
-				rr::DebugInfo::NotifyFreeingObject(Obj);
-#endif // ENABLE_RR_DEBUG_INFO
-			}
-		),
-		addresses(count)
+		          rr::DebugInfo::NotifyFreeingObject(Obj);
+#endif  // ENABLE_RR_DEBUG_INFO
+	          })
+	    , addresses(count)
 	{
 		std::vector<std::string> mangledNames(count);
 		for(size_t i = 0; i < count; i++)
@@ -490,10 +496,10 @@
 class JITBuilder
 {
 public:
-	JITBuilder(const rr::Config &config) :
-		config(config),
-		module(new llvm::Module("", context)),
-		builder(new llvm::IRBuilder<>(context))
+	JITBuilder(const rr::Config &config)
+	    : config(config)
+	    , module(new llvm::Module("", context))
+	    , builder(new llvm::IRBuilder<>(context))
 	{
 		module->setDataLayout(JITGlobals::get()->dataLayout);
 	}
@@ -504,30 +510,30 @@
 #ifdef ENABLE_RR_DEBUG_INFO
 		if(debugInfo != nullptr)
 		{
-			return; // Don't optimize if we're generating debug info.
+			return;  // Don't optimize if we're generating debug info.
 		}
-#endif // ENABLE_RR_DEBUG_INFO
+#endif  // ENABLE_RR_DEBUG_INFO
 
 		std::unique_ptr<llvm::legacy::PassManager> passManager(
-			new llvm::legacy::PassManager());
+		    new llvm::legacy::PassManager());
 
 		for(auto pass : cfg.getOptimization().getPasses())
 		{
 			switch(pass)
 			{
-			case rr::Optimization::Pass::Disabled:                                                                       break;
-			case rr::Optimization::Pass::CFGSimplification:    passManager->add(llvm::createCFGSimplificationPass());    break;
-			case rr::Optimization::Pass::LICM:                 passManager->add(llvm::createLICMPass());                 break;
-			case rr::Optimization::Pass::AggressiveDCE:        passManager->add(llvm::createAggressiveDCEPass());        break;
-			case rr::Optimization::Pass::GVN:                  passManager->add(llvm::createGVNPass());                  break;
-			case rr::Optimization::Pass::InstructionCombining: passManager->add(llvm::createInstructionCombiningPass()); break;
-			case rr::Optimization::Pass::Reassociate:          passManager->add(llvm::createReassociatePass());          break;
-			case rr::Optimization::Pass::DeadStoreElimination: passManager->add(llvm::createDeadStoreEliminationPass()); break;
-			case rr::Optimization::Pass::SCCP:                 passManager->add(llvm::createSCCPPass());                 break;
-			case rr::Optimization::Pass::ScalarReplAggregates: passManager->add(llvm::createSROAPass());                 break;
-			case rr::Optimization::Pass::EarlyCSEPass:         passManager->add(llvm::createEarlyCSEPass());             break;
-			default:
-				UNREACHABLE("pass: %d", int(pass));
+				case rr::Optimization::Pass::Disabled: break;
+				case rr::Optimization::Pass::CFGSimplification: passManager->add(llvm::createCFGSimplificationPass()); break;
+				case rr::Optimization::Pass::LICM: passManager->add(llvm::createLICMPass()); break;
+				case rr::Optimization::Pass::AggressiveDCE: passManager->add(llvm::createAggressiveDCEPass()); break;
+				case rr::Optimization::Pass::GVN: passManager->add(llvm::createGVNPass()); break;
+				case rr::Optimization::Pass::InstructionCombining: passManager->add(llvm::createInstructionCombiningPass()); break;
+				case rr::Optimization::Pass::Reassociate: passManager->add(llvm::createReassociatePass()); break;
+				case rr::Optimization::Pass::DeadStoreElimination: passManager->add(llvm::createDeadStoreEliminationPass()); break;
+				case rr::Optimization::Pass::SCCP: passManager->add(llvm::createSCCPPass()); break;
+				case rr::Optimization::Pass::ScalarReplAggregates: passManager->add(llvm::createSROAPass()); break;
+				case rr::Optimization::Pass::EarlyCSEPass: passManager->add(llvm::createEarlyCSEPass()); break;
+				default:
+					UNREACHABLE("pass: %d", int(pass));
 			}
 		}
 
@@ -570,38 +576,39 @@
 std::mutex codegenMutex;
 
 #ifdef ENABLE_RR_PRINT
-std::string replace(std::string str, const std::string& substr, const std::string& replacement)
+std::string replace(std::string str, const std::string &substr, const std::string &replacement)
 {
 	size_t pos = 0;
-	while((pos = str.find(substr, pos)) != std::string::npos) {
+	while((pos = str.find(substr, pos)) != std::string::npos)
+	{
 		str.replace(pos, substr.length(), replacement);
 		pos += replacement.length();
 	}
 	return str;
 }
-#endif // ENABLE_RR_PRINT
+#endif  // ENABLE_RR_PRINT
 
-template <typename T>
+template<typename T>
 T alignUp(T val, T alignment)
 {
 	return alignment * ((val + alignment - 1) / alignment);
 }
 
-void* alignedAlloc(size_t size, size_t alignment)
+void *alignedAlloc(size_t size, size_t alignment)
 {
 	ASSERT(alignment < 256);
 	auto allocation = new uint8_t[size + sizeof(uint8_t) + alignment];
 	auto aligned = allocation;
-	aligned += sizeof(uint8_t); // Make space for the base-address offset.
-	aligned = reinterpret_cast<uint8_t*>(alignUp(reinterpret_cast<uintptr_t>(aligned), alignment)); // align
+	aligned += sizeof(uint8_t);                                                                       // Make space for the base-address offset.
+	aligned = reinterpret_cast<uint8_t *>(alignUp(reinterpret_cast<uintptr_t>(aligned), alignment));  // align
 	auto offset = static_cast<uint8_t>(aligned - allocation);
 	aligned[-1] = offset;
 	return aligned;
 }
 
-void alignedFree(void* ptr)
+void alignedFree(void *ptr)
 {
-	auto aligned = reinterpret_cast<uint8_t*>(ptr);
+	auto aligned = reinterpret_cast<uint8_t *>(ptr);
 	auto offset = aligned[-1];
 	auto allocation = aligned - offset;
 	delete[] allocation;
@@ -612,7 +619,7 @@
 	llvm::VectorType *ty = llvm::cast<llvm::VectorType>(x->getType());
 
 	llvm::VectorType *extTy =
-		llvm::VectorType::getExtendedElementVectorType(ty);
+	    llvm::VectorType::getExtendedElementVectorType(ty);
 	x = jit->builder->CreateZExt(x, extTy);
 	y = jit->builder->CreateZExt(y, extTy);
 
@@ -670,7 +677,7 @@
 llvm::Value *lowerRound(llvm::Value *x)
 {
 	llvm::Function *nearbyint = llvm::Intrinsic::getDeclaration(
-		jit->module.get(), llvm::Intrinsic::nearbyint, {x->getType()});
+	    jit->module.get(), llvm::Intrinsic::nearbyint, { x->getType() });
 	return jit->builder->CreateCall(nearbyint, ARGS(x));
 }
 
@@ -682,14 +689,14 @@
 llvm::Value *lowerFloor(llvm::Value *x)
 {
 	llvm::Function *floor = llvm::Intrinsic::getDeclaration(
-		jit->module.get(), llvm::Intrinsic::floor, {x->getType()});
+	    jit->module.get(), llvm::Intrinsic::floor, { x->getType() });
 	return jit->builder->CreateCall(floor, ARGS(x));
 }
 
 llvm::Value *lowerTrunc(llvm::Value *x)
 {
 	llvm::Function *trunc = llvm::Intrinsic::getDeclaration(
-		jit->module.get(), llvm::Intrinsic::trunc, {x->getType()});
+	    jit->module.get(), llvm::Intrinsic::trunc, { x->getType() });
 	return jit->builder->CreateCall(trunc, ARGS(x));
 }
 
@@ -731,7 +738,7 @@
 llvm::Value *lowerSQRT(llvm::Value *x)
 {
 	llvm::Function *sqrt = llvm::Intrinsic::getDeclaration(
-		jit->module.get(), llvm::Intrinsic::sqrt, {x->getType()});
+	    jit->module.get(), llvm::Intrinsic::sqrt, { x->getType() });
 	return jit->builder->CreateCall(sqrt, ARGS(x));
 }
 
@@ -742,8 +749,8 @@
 	if(llvm::VectorType *vectorTy = llvm::dyn_cast<llvm::VectorType>(ty))
 	{
 		one = llvm::ConstantVector::getSplat(
-			vectorTy->getNumElements(),
-			llvm::ConstantFP::get(vectorTy->getElementType(), 1));
+		    vectorTy->getNumElements(),
+		    llvm::ConstantFP::get(vectorTy->getElementType(), 1));
 	}
 	else
 	{
@@ -761,8 +768,8 @@
 {
 	llvm::VectorType *ty = llvm::cast<llvm::VectorType>(x->getType());
 	llvm::Value *y = llvm::ConstantVector::getSplat(
-		ty->getNumElements(),
-		llvm::ConstantInt::get(ty->getElementType(), scalarY));
+	    ty->getNumElements(),
+	    llvm::ConstantInt::get(ty->getElementType(), scalarY));
 	return jit->builder->CreateShl(x, y);
 }
 
@@ -770,8 +777,8 @@
 {
 	llvm::VectorType *ty = llvm::cast<llvm::VectorType>(x->getType());
 	llvm::Value *y = llvm::ConstantVector::getSplat(
-		ty->getNumElements(),
-		llvm::ConstantInt::get(ty->getElementType(), scalarY));
+	    ty->getNumElements(),
+	    llvm::ConstantInt::get(ty->getElementType(), scalarY));
 	return jit->builder->CreateAShr(x, y);
 }
 
@@ -779,8 +786,8 @@
 {
 	llvm::VectorType *ty = llvm::cast<llvm::VectorType>(x->getType());
 	llvm::Value *y = llvm::ConstantVector::getSplat(
-		ty->getNumElements(),
-		llvm::ConstantInt::get(ty->getElementType(), scalarY));
+	    ty->getNumElements(),
+	    llvm::ConstantInt::get(ty->getElementType(), scalarY));
 	return jit->builder->CreateLShr(x, y);
 }
 
@@ -814,7 +821,7 @@
 	llvm::VectorType *dstTy = llvm::VectorType::getTruncatedElementVectorType(srcTy);
 
 	llvm::IntegerType *dstElemTy =
-		llvm::cast<llvm::IntegerType>(dstTy->getElementType());
+	    llvm::cast<llvm::IntegerType>(dstTy->getElementType());
 
 	uint64_t truncNumBits = dstElemTy->getIntegerBitWidth();
 	ASSERT_MSG(truncNumBits < 64, "shift 64 must be handled separately. truncNumBits: %d", int(truncNumBits));
@@ -851,11 +858,11 @@
 	llvm::Value *cmp = jit->builder->CreateICmpSLT(x, zero);
 
 	llvm::Value *ret = jit->builder->CreateZExt(
-		jit->builder->CreateExtractElement(cmp, static_cast<uint64_t>(0)), retTy);
+	    jit->builder->CreateExtractElement(cmp, static_cast<uint64_t>(0)), retTy);
 	for(uint64_t i = 1, n = ty->getNumElements(); i < n; ++i)
 	{
 		llvm::Value *elem = jit->builder->CreateZExt(
-			jit->builder->CreateExtractElement(cmp, i), retTy);
+		    jit->builder->CreateExtractElement(cmp, i), retTy);
 		ret = jit->builder->CreateOr(ret, jit->builder->CreateShl(elem, i));
 	}
 	return ret;
@@ -868,11 +875,11 @@
 	llvm::Value *cmp = jit->builder->CreateFCmpULT(x, zero);
 
 	llvm::Value *ret = jit->builder->CreateZExt(
-		jit->builder->CreateExtractElement(cmp, static_cast<uint64_t>(0)), retTy);
+	    jit->builder->CreateExtractElement(cmp, static_cast<uint64_t>(0)), retTy);
 	for(uint64_t i = 1, n = ty->getNumElements(); i < n; ++i)
 	{
 		llvm::Value *elem = jit->builder->CreateZExt(
-			jit->builder->CreateExtractElement(cmp, i), retTy);
+		    jit->builder->CreateExtractElement(cmp, i), retTy);
 		ret = jit->builder->CreateOr(ret, jit->builder->CreateShl(elem, i));
 	}
 	return ret;
@@ -882,38 +889,38 @@
 #if(LLVM_VERSION_MAJOR >= 8) || (!defined(__i386__) && !defined(__x86_64__))
 llvm::Value *lowerPUADDSAT(llvm::Value *x, llvm::Value *y)
 {
-	#if LLVM_VERSION_MAJOR >= 8
-		return jit->builder->CreateBinaryIntrinsic(llvm::Intrinsic::uadd_sat, x, y);
-	#else
-		return lowerPSAT(x, y, true, false);
-	#endif
+#	if LLVM_VERSION_MAJOR >= 8
+	return jit->builder->CreateBinaryIntrinsic(llvm::Intrinsic::uadd_sat, x, y);
+#	else
+	return lowerPSAT(x, y, true, false);
+#	endif
 }
 
 llvm::Value *lowerPSADDSAT(llvm::Value *x, llvm::Value *y)
 {
-	#if LLVM_VERSION_MAJOR >= 8
-		return jit->builder->CreateBinaryIntrinsic(llvm::Intrinsic::sadd_sat, x, y);
-	#else
-		return lowerPSAT(x, y, true, true);
-	#endif
+#	if LLVM_VERSION_MAJOR >= 8
+	return jit->builder->CreateBinaryIntrinsic(llvm::Intrinsic::sadd_sat, x, y);
+#	else
+	return lowerPSAT(x, y, true, true);
+#	endif
 }
 
 llvm::Value *lowerPUSUBSAT(llvm::Value *x, llvm::Value *y)
 {
-	#if LLVM_VERSION_MAJOR >= 8
-		return jit->builder->CreateBinaryIntrinsic(llvm::Intrinsic::usub_sat, x, y);
-	#else
-		return lowerPSAT(x, y, false, false);
-	#endif
+#	if LLVM_VERSION_MAJOR >= 8
+	return jit->builder->CreateBinaryIntrinsic(llvm::Intrinsic::usub_sat, x, y);
+#	else
+	return lowerPSAT(x, y, false, false);
+#	endif
 }
 
 llvm::Value *lowerPSSUBSAT(llvm::Value *x, llvm::Value *y)
 {
-	#if LLVM_VERSION_MAJOR >= 8
-		return jit->builder->CreateBinaryIntrinsic(llvm::Intrinsic::ssub_sat, x, y);
-	#else
-		return lowerPSAT(x, y, false, true);
-	#endif
+#	if LLVM_VERSION_MAJOR >= 8
+	return jit->builder->CreateBinaryIntrinsic(llvm::Intrinsic::ssub_sat, x, y);
+#	else
+	return lowerPSAT(x, y, false, true);
+#	endif
 }
 #endif  // (LLVM_VERSION_MAJOR >= 8) || (!defined(__i386__) && !defined(__x86_64__))
 
@@ -958,10 +965,10 @@
 	auto i8Base = jit->builder->CreatePointerCast(base, i8PtrTy);
 	auto i8Ptrs = jit->builder->CreateGEP(i8Base, offsets);
 	auto elPtrs = jit->builder->CreatePointerCast(i8Ptrs, elPtrVecTy);
-	auto i8Mask = jit->builder->CreateIntCast(mask, ::llvm::VectorType::get(i1Ty, numEls), false); // vec<int, int, ...> -> vec<bool, bool, ...>
+	auto i8Mask = jit->builder->CreateIntCast(mask, ::llvm::VectorType::get(i1Ty, numEls), false);  // vec<int, int, ...> -> vec<bool, bool, ...>
 	auto passthrough = zeroMaskedLanes ? ::llvm::Constant::getNullValue(elVecTy) : llvm::UndefValue::get(elVecTy);
 	auto align = ::llvm::ConstantInt::get(i32Ty, alignment);
-	auto func = ::llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::masked_gather, { elVecTy, elPtrVecTy } );
+	auto func = ::llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::masked_gather, { elVecTy, elPtrVecTy });
 	return jit->builder->CreateCall(func, { elPtrs, align, i8Mask, passthrough });
 }
 
@@ -984,32 +991,31 @@
 	auto i8Base = jit->builder->CreatePointerCast(base, i8PtrTy);
 	auto i8Ptrs = jit->builder->CreateGEP(i8Base, offsets);
 	auto elPtrs = jit->builder->CreatePointerCast(i8Ptrs, elPtrVecTy);
-	auto i8Mask = jit->builder->CreateIntCast(mask, ::llvm::VectorType::get(i1Ty, numEls), false); // vec<int, int, ...> -> vec<bool, bool, ...>
+	auto i8Mask = jit->builder->CreateIntCast(mask, ::llvm::VectorType::get(i1Ty, numEls), false);  // vec<int, int, ...> -> vec<bool, bool, ...>
 	auto align = ::llvm::ConstantInt::get(i32Ty, alignment);
-	auto func = ::llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::masked_scatter, { elVecTy, elPtrVecTy } );
+	auto func = ::llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::masked_scatter, { elVecTy, elPtrVecTy });
 	jit->builder->CreateCall(func, { val, elPtrs, align, i8Mask });
 }
-}
+}  // namespace
 
 namespace rr {
 
-const Capabilities Caps =
-{
-	true, // CoroutinesSupported
+const Capabilities Caps = {
+	true,  // CoroutinesSupported
 };
 
 static std::memory_order atomicOrdering(llvm::AtomicOrdering memoryOrder)
 {
 	switch(memoryOrder)
 	{
-	case llvm::AtomicOrdering::Monotonic: return std::memory_order_relaxed;  // https://llvm.org/docs/Atomics.html#monotonic
-	case llvm::AtomicOrdering::Acquire: return std::memory_order_acquire;
-	case llvm::AtomicOrdering::Release: return std::memory_order_release;
-	case llvm::AtomicOrdering::AcquireRelease: return std::memory_order_acq_rel;
-	case llvm::AtomicOrdering::SequentiallyConsistent: return std::memory_order_seq_cst;
-	default:
-		UNREACHABLE("memoryOrder: %d", int(memoryOrder));
-		return std::memory_order_acq_rel;
+		case llvm::AtomicOrdering::Monotonic: return std::memory_order_relaxed;  // https://llvm.org/docs/Atomics.html#monotonic
+		case llvm::AtomicOrdering::Acquire: return std::memory_order_acquire;
+		case llvm::AtomicOrdering::Release: return std::memory_order_release;
+		case llvm::AtomicOrdering::AcquireRelease: return std::memory_order_acq_rel;
+		case llvm::AtomicOrdering::SequentiallyConsistent: return std::memory_order_seq_cst;
+		default:
+			UNREACHABLE("memoryOrder: %d", int(memoryOrder));
+			return std::memory_order_acq_rel;
 	}
 }
 
@@ -1022,28 +1028,28 @@
 
 	switch(memoryOrder)
 	{
-	case std::memory_order_relaxed: return llvm::AtomicOrdering::Monotonic;  // https://llvm.org/docs/Atomics.html#monotonic
-	case std::memory_order_consume: return llvm::AtomicOrdering::Acquire;    // https://llvm.org/docs/Atomics.html#acquire: "It should also be used for C++11/C11 memory_order_consume."
-	case std::memory_order_acquire: return llvm::AtomicOrdering::Acquire;
-	case std::memory_order_release: return llvm::AtomicOrdering::Release;
-	case std::memory_order_acq_rel: return llvm::AtomicOrdering::AcquireRelease;
-	case std::memory_order_seq_cst: return llvm::AtomicOrdering::SequentiallyConsistent;
-	default:
-		UNREACHABLE("memoryOrder: %d", int(memoryOrder));
-		return llvm::AtomicOrdering::AcquireRelease;
+		case std::memory_order_relaxed: return llvm::AtomicOrdering::Monotonic;  // https://llvm.org/docs/Atomics.html#monotonic
+		case std::memory_order_consume: return llvm::AtomicOrdering::Acquire;    // https://llvm.org/docs/Atomics.html#acquire: "It should also be used for C++11/C11 memory_order_consume."
+		case std::memory_order_acquire: return llvm::AtomicOrdering::Acquire;
+		case std::memory_order_release: return llvm::AtomicOrdering::Release;
+		case std::memory_order_acq_rel: return llvm::AtomicOrdering::AcquireRelease;
+		case std::memory_order_seq_cst: return llvm::AtomicOrdering::SequentiallyConsistent;
+		default:
+			UNREACHABLE("memoryOrder: %d", int(memoryOrder));
+			return llvm::AtomicOrdering::AcquireRelease;
 	}
 }
 
-template <typename T>
+template<typename T>
 static void atomicLoad(void *ptr, void *ret, llvm::AtomicOrdering ordering)
 {
-	*reinterpret_cast<T*>(ret) = std::atomic_load_explicit<T>(reinterpret_cast<std::atomic<T>*>(ptr), atomicOrdering(ordering));
+	*reinterpret_cast<T *>(ret) = std::atomic_load_explicit<T>(reinterpret_cast<std::atomic<T> *>(ptr), atomicOrdering(ordering));
 }
 
-template <typename T>
+template<typename T>
 static void atomicStore(void *ptr, void *val, llvm::AtomicOrdering ordering)
 {
-	std::atomic_store_explicit<T>(reinterpret_cast<std::atomic<T>*>(ptr), *reinterpret_cast<T*>(val), atomicOrdering(ordering));
+	std::atomic_store_explicit<T>(reinterpret_cast<std::atomic<T> *>(ptr), *reinterpret_cast<T *>(val), atomicOrdering(ordering));
 }
 
 #ifdef __ANDROID__
@@ -1062,7 +1068,7 @@
 }
 #endif
 
-void* resolveExternalSymbol(const char* name)
+void *resolveExternalSymbol(const char *name)
 {
 	struct Atomic
 	{
@@ -1097,8 +1103,8 @@
 		static void nop() {}
 		static void neverCalled() { UNREACHABLE("Should never be called"); }
 
-		static void* coroutine_alloc_frame(size_t size) { return alignedAlloc(size, 16); }
-		static void coroutine_free_frame(void* ptr) { alignedFree(ptr); }
+		static void *coroutine_alloc_frame(size_t size) { return alignedAlloc(size, 16); }
+		static void coroutine_free_frame(void *ptr) { alignedFree(ptr); }
 
 #ifdef __ANDROID__
 		// forwarders since we can't take address of builtins
@@ -1111,10 +1117,22 @@
 		static uint32_t sync_lock_test_and_set_4(uint32_t *ptr, uint32_t val) { return __sync_lock_test_and_set_4(ptr, val); }
 		static uint32_t sync_val_compare_and_swap_4(uint32_t *ptr, uint32_t expected, uint32_t desired) { return __sync_val_compare_and_swap_4(ptr, expected, desired); }
 
-		static uint32_t sync_fetch_and_max_4(uint32_t *ptr, uint32_t val) { return sync_fetch_and_op(ptr, val, [](int32_t a, int32_t b) { return std::max(a,b);}); }
-		static uint32_t sync_fetch_and_min_4(uint32_t *ptr, uint32_t val) { return sync_fetch_and_op(ptr, val, [](int32_t a, int32_t b) { return std::min(a,b);}); }
-		static uint32_t sync_fetch_and_umax_4(uint32_t *ptr, uint32_t val) { return sync_fetch_and_op(ptr, val, [](uint32_t a, uint32_t b) { return std::max(a,b);}); }
-		static uint32_t sync_fetch_and_umin_4(uint32_t *ptr, uint32_t val) { return sync_fetch_and_op(ptr, val, [](uint32_t a, uint32_t b) { return std::min(a,b);}); }
+		static uint32_t sync_fetch_and_max_4(uint32_t *ptr, uint32_t val)
+		{
+			return sync_fetch_and_op(ptr, val, [](int32_t a, int32_t b) { return std::max(a, b); });
+		}
+		static uint32_t sync_fetch_and_min_4(uint32_t *ptr, uint32_t val)
+		{
+			return sync_fetch_and_op(ptr, val, [](int32_t a, int32_t b) { return std::min(a, b); });
+		}
+		static uint32_t sync_fetch_and_umax_4(uint32_t *ptr, uint32_t val)
+		{
+			return sync_fetch_and_op(ptr, val, [](uint32_t a, uint32_t b) { return std::max(a, b); });
+		}
+		static uint32_t sync_fetch_and_umin_4(uint32_t *ptr, uint32_t val)
+		{
+			return sync_fetch_and_op(ptr, val, [](uint32_t a, uint32_t b) { return std::min(a, b); });
+		}
 #endif
 	};
 
@@ -1127,81 +1145,81 @@
 
 		Resolver()
 		{
-			functions.emplace("nop", reinterpret_cast<void*>(F::nop));
-			functions.emplace("floorf", reinterpret_cast<void*>(floorf));
-			functions.emplace("nearbyintf", reinterpret_cast<void*>(nearbyintf));
-			functions.emplace("truncf", reinterpret_cast<void*>(truncf));
-			functions.emplace("printf", reinterpret_cast<void*>(printf));
-			functions.emplace("puts", reinterpret_cast<void*>(puts));
-			functions.emplace("fmodf", reinterpret_cast<void*>(fmodf));
+			functions.emplace("nop", reinterpret_cast<void *>(F::nop));
+			functions.emplace("floorf", reinterpret_cast<void *>(floorf));
+			functions.emplace("nearbyintf", reinterpret_cast<void *>(nearbyintf));
+			functions.emplace("truncf", reinterpret_cast<void *>(truncf));
+			functions.emplace("printf", reinterpret_cast<void *>(printf));
+			functions.emplace("puts", reinterpret_cast<void *>(puts));
+			functions.emplace("fmodf", reinterpret_cast<void *>(fmodf));
 
-			functions.emplace("sinf", reinterpret_cast<void*>(sinf));
-			functions.emplace("cosf", reinterpret_cast<void*>(cosf));
-			functions.emplace("asinf", reinterpret_cast<void*>(asinf));
-			functions.emplace("acosf", reinterpret_cast<void*>(acosf));
-			functions.emplace("atanf", reinterpret_cast<void*>(atanf));
-			functions.emplace("sinhf", reinterpret_cast<void*>(sinhf));
-			functions.emplace("coshf", reinterpret_cast<void*>(coshf));
-			functions.emplace("tanhf", reinterpret_cast<void*>(tanhf));
-			functions.emplace("asinhf", reinterpret_cast<void*>(asinhf));
-			functions.emplace("acoshf", reinterpret_cast<void*>(acoshf));
-			functions.emplace("atanhf", reinterpret_cast<void*>(atanhf));
-			functions.emplace("atan2f", reinterpret_cast<void*>(atan2f));
-			functions.emplace("powf", reinterpret_cast<void*>(powf));
-			functions.emplace("expf", reinterpret_cast<void*>(expf));
-			functions.emplace("logf", reinterpret_cast<void*>(logf));
-			functions.emplace("exp2f", reinterpret_cast<void*>(exp2f));
-			functions.emplace("log2f", reinterpret_cast<void*>(log2f));
+			functions.emplace("sinf", reinterpret_cast<void *>(sinf));
+			functions.emplace("cosf", reinterpret_cast<void *>(cosf));
+			functions.emplace("asinf", reinterpret_cast<void *>(asinf));
+			functions.emplace("acosf", reinterpret_cast<void *>(acosf));
+			functions.emplace("atanf", reinterpret_cast<void *>(atanf));
+			functions.emplace("sinhf", reinterpret_cast<void *>(sinhf));
+			functions.emplace("coshf", reinterpret_cast<void *>(coshf));
+			functions.emplace("tanhf", reinterpret_cast<void *>(tanhf));
+			functions.emplace("asinhf", reinterpret_cast<void *>(asinhf));
+			functions.emplace("acoshf", reinterpret_cast<void *>(acoshf));
+			functions.emplace("atanhf", reinterpret_cast<void *>(atanhf));
+			functions.emplace("atan2f", reinterpret_cast<void *>(atan2f));
+			functions.emplace("powf", reinterpret_cast<void *>(powf));
+			functions.emplace("expf", reinterpret_cast<void *>(expf));
+			functions.emplace("logf", reinterpret_cast<void *>(logf));
+			functions.emplace("exp2f", reinterpret_cast<void *>(exp2f));
+			functions.emplace("log2f", reinterpret_cast<void *>(log2f));
 
-			functions.emplace("sin", reinterpret_cast<void*>(static_cast<double(*)(double)>(sin)));
-			functions.emplace("cos", reinterpret_cast<void*>(static_cast<double(*)(double)>(cos)));
-			functions.emplace("asin", reinterpret_cast<void*>(static_cast<double(*)(double)>(asin)));
-			functions.emplace("acos", reinterpret_cast<void*>(static_cast<double(*)(double)>(acos)));
-			functions.emplace("atan", reinterpret_cast<void*>(static_cast<double(*)(double)>(atan)));
-			functions.emplace("sinh", reinterpret_cast<void*>(static_cast<double(*)(double)>(sinh)));
-			functions.emplace("cosh", reinterpret_cast<void*>(static_cast<double(*)(double)>(cosh)));
-			functions.emplace("tanh", reinterpret_cast<void*>(static_cast<double(*)(double)>(tanh)));
-			functions.emplace("asinh", reinterpret_cast<void*>(static_cast<double(*)(double)>(asinh)));
-			functions.emplace("acosh", reinterpret_cast<void*>(static_cast<double(*)(double)>(acosh)));
-			functions.emplace("atanh", reinterpret_cast<void*>(static_cast<double(*)(double)>(atanh)));
-			functions.emplace("atan2", reinterpret_cast<void*>(static_cast<double(*)(double,double)>(atan2)));
-			functions.emplace("pow", reinterpret_cast<void*>(static_cast<double(*)(double,double)>(pow)));
-			functions.emplace("exp", reinterpret_cast<void*>(static_cast<double(*)(double)>(exp)));
-			functions.emplace("log", reinterpret_cast<void*>(static_cast<double(*)(double)>(log)));
-			functions.emplace("exp2", reinterpret_cast<void*>(static_cast<double(*)(double)>(exp2)));
-			functions.emplace("log2", reinterpret_cast<void*>(static_cast<double(*)(double)>(log2)));
+			functions.emplace("sin", reinterpret_cast<void *>(static_cast<double (*)(double)>(sin)));
+			functions.emplace("cos", reinterpret_cast<void *>(static_cast<double (*)(double)>(cos)));
+			functions.emplace("asin", reinterpret_cast<void *>(static_cast<double (*)(double)>(asin)));
+			functions.emplace("acos", reinterpret_cast<void *>(static_cast<double (*)(double)>(acos)));
+			functions.emplace("atan", reinterpret_cast<void *>(static_cast<double (*)(double)>(atan)));
+			functions.emplace("sinh", reinterpret_cast<void *>(static_cast<double (*)(double)>(sinh)));
+			functions.emplace("cosh", reinterpret_cast<void *>(static_cast<double (*)(double)>(cosh)));
+			functions.emplace("tanh", reinterpret_cast<void *>(static_cast<double (*)(double)>(tanh)));
+			functions.emplace("asinh", reinterpret_cast<void *>(static_cast<double (*)(double)>(asinh)));
+			functions.emplace("acosh", reinterpret_cast<void *>(static_cast<double (*)(double)>(acosh)));
+			functions.emplace("atanh", reinterpret_cast<void *>(static_cast<double (*)(double)>(atanh)));
+			functions.emplace("atan2", reinterpret_cast<void *>(static_cast<double (*)(double, double)>(atan2)));
+			functions.emplace("pow", reinterpret_cast<void *>(static_cast<double (*)(double, double)>(pow)));
+			functions.emplace("exp", reinterpret_cast<void *>(static_cast<double (*)(double)>(exp)));
+			functions.emplace("log", reinterpret_cast<void *>(static_cast<double (*)(double)>(log)));
+			functions.emplace("exp2", reinterpret_cast<void *>(static_cast<double (*)(double)>(exp2)));
+			functions.emplace("log2", reinterpret_cast<void *>(static_cast<double (*)(double)>(log2)));
 
-			functions.emplace("atomic_load", reinterpret_cast<void*>(Atomic::load));
-			functions.emplace("atomic_store", reinterpret_cast<void*>(Atomic::store));
+			functions.emplace("atomic_load", reinterpret_cast<void *>(Atomic::load));
+			functions.emplace("atomic_store", reinterpret_cast<void *>(Atomic::store));
 
 			// FIXME (b/119409619): use an allocator here so we can control all memory allocations
-			functions.emplace("coroutine_alloc_frame", reinterpret_cast<void*>(F::coroutine_alloc_frame));
-			functions.emplace("coroutine_free_frame", reinterpret_cast<void*>(F::coroutine_free_frame));
+			functions.emplace("coroutine_alloc_frame", reinterpret_cast<void *>(F::coroutine_alloc_frame));
+			functions.emplace("coroutine_free_frame", reinterpret_cast<void *>(F::coroutine_free_frame));
 
 #ifdef __APPLE__
-			functions.emplace("sincosf_stret", reinterpret_cast<void*>(__sincosf_stret));
+			functions.emplace("sincosf_stret", reinterpret_cast<void *>(__sincosf_stret));
 #elif defined(__linux__)
-			functions.emplace("sincosf", reinterpret_cast<void*>(sincosf));
+			functions.emplace("sincosf", reinterpret_cast<void *>(sincosf));
 #elif defined(_WIN64)
-			functions.emplace("chkstk", reinterpret_cast<void*>(__chkstk));
+			functions.emplace("chkstk", reinterpret_cast<void *>(__chkstk));
 #elif defined(_WIN32)
-			functions.emplace("chkstk", reinterpret_cast<void*>(_chkstk));
+			functions.emplace("chkstk", reinterpret_cast<void *>(_chkstk));
 #endif
 
 #ifdef __ANDROID__
-			functions.emplace("aeabi_unwind_cpp_pr0", reinterpret_cast<void*>(F::neverCalled));
-			functions.emplace("sync_synchronize", reinterpret_cast<void*>(F::sync_synchronize));
-			functions.emplace("sync_fetch_and_add_4", reinterpret_cast<void*>(F::sync_fetch_and_add_4));
-			functions.emplace("sync_fetch_and_and_4", reinterpret_cast<void*>(F::sync_fetch_and_and_4));
-			functions.emplace("sync_fetch_and_or_4", reinterpret_cast<void*>(F::sync_fetch_and_or_4));
-			functions.emplace("sync_fetch_and_xor_4", reinterpret_cast<void*>(F::sync_fetch_and_xor_4));
-			functions.emplace("sync_fetch_and_sub_4", reinterpret_cast<void*>(F::sync_fetch_and_sub_4));
-			functions.emplace("sync_lock_test_and_set_4", reinterpret_cast<void*>(F::sync_lock_test_and_set_4));
-			functions.emplace("sync_val_compare_and_swap_4", reinterpret_cast<void*>(F::sync_val_compare_and_swap_4));
-			functions.emplace("sync_fetch_and_max_4", reinterpret_cast<void*>(F::sync_fetch_and_max_4));
-			functions.emplace("sync_fetch_and_min_4", reinterpret_cast<void*>(F::sync_fetch_and_min_4));
-			functions.emplace("sync_fetch_and_umax_4", reinterpret_cast<void*>(F::sync_fetch_and_umax_4));
-			functions.emplace("sync_fetch_and_umin_4", reinterpret_cast<void*>(F::sync_fetch_and_umin_4));
+			functions.emplace("aeabi_unwind_cpp_pr0", reinterpret_cast<void *>(F::neverCalled));
+			functions.emplace("sync_synchronize", reinterpret_cast<void *>(F::sync_synchronize));
+			functions.emplace("sync_fetch_and_add_4", reinterpret_cast<void *>(F::sync_fetch_and_add_4));
+			functions.emplace("sync_fetch_and_and_4", reinterpret_cast<void *>(F::sync_fetch_and_and_4));
+			functions.emplace("sync_fetch_and_or_4", reinterpret_cast<void *>(F::sync_fetch_and_or_4));
+			functions.emplace("sync_fetch_and_xor_4", reinterpret_cast<void *>(F::sync_fetch_and_xor_4));
+			functions.emplace("sync_fetch_and_sub_4", reinterpret_cast<void *>(F::sync_fetch_and_sub_4));
+			functions.emplace("sync_lock_test_and_set_4", reinterpret_cast<void *>(F::sync_lock_test_and_set_4));
+			functions.emplace("sync_val_compare_and_swap_4", reinterpret_cast<void *>(F::sync_val_compare_and_swap_4));
+			functions.emplace("sync_fetch_and_max_4", reinterpret_cast<void *>(F::sync_fetch_and_max_4));
+			functions.emplace("sync_fetch_and_min_4", reinterpret_cast<void *>(F::sync_fetch_and_min_4));
+			functions.emplace("sync_fetch_and_umax_4", reinterpret_cast<void *>(F::sync_fetch_and_umax_4));
+			functions.emplace("sync_fetch_and_umin_4", reinterpret_cast<void *>(F::sync_fetch_and_umin_4));
 #endif
 		}
 	};
@@ -1210,7 +1228,7 @@
 
 	// Trim off any underscores from the start of the symbol. LLVM likes
 	// to append these on macOS.
-	const char* trimmed = name;
+	const char *trimmed = name;
 	while(trimmed[0] == '_') { trimmed++; }
 
 	auto it = resolver.functions.find(trimmed);
@@ -1250,56 +1268,56 @@
 	// Use 128-bit vectors to implement logically shorter ones.
 	switch(asInternalType(t))
 	{
-	case Type_v2i32: return T(Int4::getType());
-	case Type_v4i16: return T(Short8::getType());
-	case Type_v2i16: return T(Short8::getType());
-	case Type_v8i8:  return T(Byte16::getType());
-	case Type_v4i8:  return T(Byte16::getType());
-	case Type_v2f32: return T(Float4::getType());
-	case Type_LLVM:  return reinterpret_cast<llvm::Type*>(t);
-	default:
-		UNREACHABLE("asInternalType(t): %d", int(asInternalType(t)));
-		return nullptr;
+		case Type_v2i32: return T(Int4::getType());
+		case Type_v4i16: return T(Short8::getType());
+		case Type_v2i16: return T(Short8::getType());
+		case Type_v8i8: return T(Byte16::getType());
+		case Type_v4i8: return T(Byte16::getType());
+		case Type_v2f32: return T(Float4::getType());
+		case Type_LLVM: return reinterpret_cast<llvm::Type *>(t);
+		default:
+			UNREACHABLE("asInternalType(t): %d", int(asInternalType(t)));
+			return nullptr;
 	}
 }
 
 Type *T(InternalType t)
 {
-	return reinterpret_cast<Type*>(t);
+	return reinterpret_cast<Type *>(t);
 }
 
-inline std::vector<llvm::Type*> &T(std::vector<Type*> &t)
+inline std::vector<llvm::Type *> &T(std::vector<Type *> &t)
 {
-	return reinterpret_cast<std::vector<llvm::Type*>&>(t);
+	return reinterpret_cast<std::vector<llvm::Type *> &>(t);
 }
 
 inline llvm::BasicBlock *B(BasicBlock *t)
 {
-	return reinterpret_cast<llvm::BasicBlock*>(t);
+	return reinterpret_cast<llvm::BasicBlock *>(t);
 }
 
 inline BasicBlock *B(llvm::BasicBlock *t)
 {
-	return reinterpret_cast<BasicBlock*>(t);
+	return reinterpret_cast<BasicBlock *>(t);
 }
 
 static size_t typeSize(Type *type)
 {
 	switch(asInternalType(type))
 	{
-	case Type_v2i32: return 8;
-	case Type_v4i16: return 8;
-	case Type_v2i16: return 4;
-	case Type_v8i8:  return 8;
-	case Type_v4i8:  return 4;
-	case Type_v2f32: return 8;
-	case Type_LLVM:
+		case Type_v2i32: return 8;
+		case Type_v4i16: return 8;
+		case Type_v2i16: return 4;
+		case Type_v8i8: return 8;
+		case Type_v4i8: return 4;
+		case Type_v2f32: return 8;
+		case Type_LLVM:
 		{
 			llvm::Type *t = T(type);
 
 			if(t->isPointerTy())
 			{
-				return sizeof(void*);
+				return sizeof(void *);
 			}
 
 			// At this point we should only have LLVM 'primitive' types.
@@ -1312,9 +1330,9 @@
 			return (bits + 7) / 8;
 		}
 		break;
-	default:
-		UNREACHABLE("asInternalType(type): %d", int(asInternalType(type)));
-		return 0;
+		default:
+			UNREACHABLE("asInternalType(type): %d", int(asInternalType(type)));
+			return 0;
 	}
 }
 
@@ -1322,20 +1340,20 @@
 {
 	switch(asInternalType(type))
 	{
-	case Type_v2i32: return 2;
-	case Type_v4i16: return 4;
-	case Type_v2i16: return 2;
-	case Type_v8i8:  return 8;
-	case Type_v4i8:  return 4;
-	case Type_v2f32: return 2;
-	case Type_LLVM:  return llvm::cast<llvm::VectorType>(T(type))->getNumElements();
-	default:
-		UNREACHABLE("asInternalType(type): %d", int(asInternalType(type)));
-		return 0;
+		case Type_v2i32: return 2;
+		case Type_v4i16: return 4;
+		case Type_v2i16: return 2;
+		case Type_v8i8: return 8;
+		case Type_v4i8: return 4;
+		case Type_v2f32: return 2;
+		case Type_LLVM: return llvm::cast<llvm::VectorType>(T(type))->getNumElements();
+		default:
+			UNREACHABLE("asInternalType(type): %d", int(asInternalType(type)));
+			return 0;
 	}
 }
 
-static ::llvm::Function* createFunction(const char *name, ::llvm::Type *retTy, const std::vector<::llvm::Type*> &params)
+static ::llvm::Function *createFunction(const char *name, ::llvm::Type *retTy, const std::vector<::llvm::Type *> &params)
 {
 	llvm::FunctionType *functionType = llvm::FunctionType::get(retTy, params, false);
 	auto func = llvm::Function::Create(functionType, llvm::GlobalValue::InternalLinkage, name, jit->module.get());
@@ -1346,7 +1364,7 @@
 
 Nucleus::Nucleus()
 {
-	::codegenMutex.lock();   // Reactor and LLVM are currently not thread safe
+	::codegenMutex.lock();  // Reactor and LLVM are currently not thread safe
 
 	ASSERT(jit == nullptr);
 	jit.reset(new JITBuilder(Nucleus::getDefaultConfig()));
@@ -1400,7 +1418,7 @@
 	{
 		jit->debugInfo->Finalize();
 	}
-#endif // ENABLE_RR_DEBUG_INFO
+#endif  // ENABLE_RR_DEBUG_INFO
 
 	if(false)
 	{
@@ -1415,7 +1433,7 @@
 		pm.add(llvm::createVerifierPass());
 		pm.run(*jit->module);
 	}
-#endif // defined(ENABLE_RR_LLVM_IR_VERIFICATION) || !defined(NDEBUG)
+#endif  // defined(ENABLE_RR_LLVM_IR_VERIFICATION) || !defined(NDEBUG)
 
 	jit->optimize(cfg);
 
@@ -1445,7 +1463,7 @@
 	}
 	else
 	{
-		declaration = new llvm::AllocaInst(T(type), 0, (llvm::Value*)nullptr);
+		declaration = new llvm::AllocaInst(T(type), 0, (llvm::Value *)nullptr);
 	}
 
 	entryBlock.getInstList().push_front(declaration);
@@ -1465,20 +1483,20 @@
 
 void Nucleus::setInsertBlock(BasicBlock *basicBlock)
 {
-//	assert(jit->builder->GetInsertBlock()->back().isTerminator());
+	//	assert(jit->builder->GetInsertBlock()->back().isTerminator());
 
 	Variable::materializeAll();
 
 	jit->builder->SetInsertPoint(B(basicBlock));
 }
 
-void Nucleus::createFunction(Type *ReturnType, std::vector<Type*> &Params)
+void Nucleus::createFunction(Type *ReturnType, std::vector<Type *> &Params)
 {
 	jit->function = rr::createFunction("", T(ReturnType), T(Params));
 
 #ifdef ENABLE_RR_DEBUG_INFO
 	jit->debugInfo = std::unique_ptr<DebugInfo>(new DebugInfo(jit->builder.get(), &jit->context, jit->module.get(), jit->function));
-#endif // ENABLE_RR_DEBUG_INFO
+#endif  // ENABLE_RR_DEBUG_INFO
 
 	jit->builder->SetInsertPoint(llvm::BasicBlock::Create(jit->context, "", jit->function));
 }
@@ -1670,28 +1688,28 @@
 	RR_DEBUG_INFO_UPDATE_LOC();
 	switch(asInternalType(type))
 	{
-	case Type_v2i32:
-	case Type_v4i16:
-	case Type_v8i8:
-	case Type_v2f32:
-		return createBitCast(
-			createInsertElement(
-				V(llvm::UndefValue::get(llvm::VectorType::get(T(Long::getType()), 2))),
-				createLoad(createBitCast(ptr, Pointer<Long>::getType()), Long::getType(), isVolatile, alignment, atomic, memoryOrder),
-				0),
-			type);
-	case Type_v2i16:
-	case Type_v4i8:
-		if(alignment != 0)   // Not a local variable (all vectors are 128-bit).
-		{
-			Value *u = V(llvm::UndefValue::get(llvm::VectorType::get(T(Long::getType()), 2)));
-			Value *i = createLoad(createBitCast(ptr, Pointer<Int>::getType()), Int::getType(), isVolatile, alignment, atomic, memoryOrder);
-			i = createZExt(i, Long::getType());
-			Value *v = createInsertElement(u, i, 0);
-			return createBitCast(v, type);
-		}
-		// Fallthrough to non-emulated case.
-	case Type_LLVM:
+		case Type_v2i32:
+		case Type_v4i16:
+		case Type_v8i8:
+		case Type_v2f32:
+			return createBitCast(
+			    createInsertElement(
+			        V(llvm::UndefValue::get(llvm::VectorType::get(T(Long::getType()), 2))),
+			        createLoad(createBitCast(ptr, Pointer<Long>::getType()), Long::getType(), isVolatile, alignment, atomic, memoryOrder),
+			        0),
+			    type);
+		case Type_v2i16:
+		case Type_v4i8:
+			if(alignment != 0)  // Not a local variable (all vectors are 128-bit).
+			{
+				Value *u = V(llvm::UndefValue::get(llvm::VectorType::get(T(Long::getType()), 2)));
+				Value *i = createLoad(createBitCast(ptr, Pointer<Int>::getType()), Int::getType(), isVolatile, alignment, atomic, memoryOrder);
+				i = createZExt(i, Long::getType());
+				Value *v = createInsertElement(u, i, 0);
+				return createBitCast(v, type);
+			}
+			// Fallthrough to non-emulated case.
+		case Type_LLVM:
 		{
 			auto elTy = T(type);
 			ASSERT(V(ptr)->getType()->getContainedType(0) == elTy);
@@ -1730,22 +1748,22 @@
 				auto i8Ty = ::llvm::Type::getInt8Ty(jit->context);
 				auto i8PtrTy = i8Ty->getPointerTo();
 				auto voidTy = ::llvm::Type::getVoidTy(jit->context);
-				auto funcTy = ::llvm::FunctionType::get(voidTy, {sizetTy, i8PtrTy, i8PtrTy, intTy}, false);
+				auto funcTy = ::llvm::FunctionType::get(voidTy, { sizetTy, i8PtrTy, i8PtrTy, intTy }, false);
 				auto func = jit->module->getOrInsertFunction("__atomic_load", funcTy);
 				auto size = jit->module->getDataLayout().getTypeStoreSize(elTy);
 				auto out = allocateStackVariable(type);
 				jit->builder->CreateCall(func, {
-					::llvm::ConstantInt::get(sizetTy, size),
-					jit->builder->CreatePointerCast(V(ptr), i8PtrTy),
-					jit->builder->CreatePointerCast(V(out), i8PtrTy),
-					::llvm::ConstantInt::get(intTy, uint64_t(atomicOrdering(true, memoryOrder))),
-				 });
-				 return V(jit->builder->CreateLoad(V(out)));
+				                                   ::llvm::ConstantInt::get(sizetTy, size),
+				                                   jit->builder->CreatePointerCast(V(ptr), i8PtrTy),
+				                                   jit->builder->CreatePointerCast(V(out), i8PtrTy),
+				                                   ::llvm::ConstantInt::get(intTy, uint64_t(atomicOrdering(true, memoryOrder))),
+				                               });
+				return V(jit->builder->CreateLoad(V(out)));
 			}
 		}
-	default:
-		UNREACHABLE("asInternalType(type): %d", int(asInternalType(type)));
-		return nullptr;
+		default:
+			UNREACHABLE("asInternalType(type): %d", int(asInternalType(type)));
+			return nullptr;
 	}
 }
 
@@ -1754,28 +1772,28 @@
 	RR_DEBUG_INFO_UPDATE_LOC();
 	switch(asInternalType(type))
 	{
-	case Type_v2i32:
-	case Type_v4i16:
-	case Type_v8i8:
-	case Type_v2f32:
-		createStore(
-			createExtractElement(
-				createBitCast(value, T(llvm::VectorType::get(T(Long::getType()), 2))), Long::getType(), 0),
-			createBitCast(ptr, Pointer<Long>::getType()),
-			Long::getType(), isVolatile, alignment, atomic, memoryOrder);
-		return value;
-	case Type_v2i16:
-	case Type_v4i8:
-		if(alignment != 0)   // Not a local variable (all vectors are 128-bit).
-		{
+		case Type_v2i32:
+		case Type_v4i16:
+		case Type_v8i8:
+		case Type_v2f32:
 			createStore(
-				createExtractElement(createBitCast(value, Int4::getType()), Int::getType(), 0),
-				createBitCast(ptr, Pointer<Int>::getType()),
-				Int::getType(), isVolatile, alignment, atomic, memoryOrder);
+			    createExtractElement(
+			        createBitCast(value, T(llvm::VectorType::get(T(Long::getType()), 2))), Long::getType(), 0),
+			    createBitCast(ptr, Pointer<Long>::getType()),
+			    Long::getType(), isVolatile, alignment, atomic, memoryOrder);
 			return value;
-		}
-		// Fallthrough to non-emulated case.
-	case Type_LLVM:
+		case Type_v2i16:
+		case Type_v4i8:
+			if(alignment != 0)  // Not a local variable (all vectors are 128-bit).
+			{
+				createStore(
+				    createExtractElement(createBitCast(value, Int4::getType()), Int::getType(), 0),
+				    createBitCast(ptr, Pointer<Int>::getType()),
+				    Int::getType(), isVolatile, alignment, atomic, memoryOrder);
+				return value;
+			}
+			// Fallthrough to non-emulated case.
+		case Type_LLVM:
 		{
 			auto elTy = T(type);
 			ASSERT(V(ptr)->getType()->getContainedType(0) == elTy);
@@ -1812,24 +1830,24 @@
 				auto i8Ty = ::llvm::Type::getInt8Ty(jit->context);
 				auto i8PtrTy = i8Ty->getPointerTo();
 				auto voidTy = ::llvm::Type::getVoidTy(jit->context);
-				auto funcTy = ::llvm::FunctionType::get(voidTy, {sizetTy, i8PtrTy, i8PtrTy, intTy}, false);
+				auto funcTy = ::llvm::FunctionType::get(voidTy, { sizetTy, i8PtrTy, i8PtrTy, intTy }, false);
 				auto func = jit->module->getOrInsertFunction("__atomic_store", funcTy);
 				auto size = jit->module->getDataLayout().getTypeStoreSize(elTy);
 				auto copy = allocateStackVariable(type);
 				jit->builder->CreateStore(V(value), V(copy));
 				jit->builder->CreateCall(func, {
-					::llvm::ConstantInt::get(sizetTy, size),
-					jit->builder->CreatePointerCast(V(ptr), i8PtrTy),
-					jit->builder->CreatePointerCast(V(copy), i8PtrTy),
-					::llvm::ConstantInt::get(intTy, uint64_t(atomicOrdering(true, memoryOrder))),
-				 });
+				                                   ::llvm::ConstantInt::get(sizetTy, size),
+				                                   jit->builder->CreatePointerCast(V(ptr), i8PtrTy),
+				                                   jit->builder->CreatePointerCast(V(copy), i8PtrTy),
+				                                   ::llvm::ConstantInt::get(intTy, uint64_t(atomicOrdering(true, memoryOrder))),
+				                               });
 			}
 
 			return value;
 		}
-	default:
-		UNREACHABLE("asInternalType(type): %d", int(asInternalType(type)));
-		return nullptr;
+		default:
+			UNREACHABLE("asInternalType(type): %d", int(asInternalType(type)));
+			return nullptr;
 	}
 }
 
@@ -1843,10 +1861,10 @@
 	auto i32Ty = ::llvm::Type::getInt32Ty(jit->context);
 	auto elVecTy = ::llvm::VectorType::get(T(elTy), numEls);
 	auto elVecPtrTy = elVecTy->getPointerTo();
-	auto i8Mask = jit->builder->CreateIntCast(V(mask), ::llvm::VectorType::get(i1Ty, numEls), false); // vec<int, int, ...> -> vec<bool, bool, ...>
+	auto i8Mask = jit->builder->CreateIntCast(V(mask), ::llvm::VectorType::get(i1Ty, numEls), false);  // vec<int, int, ...> -> vec<bool, bool, ...>
 	auto passthrough = zeroMaskedLanes ? ::llvm::Constant::getNullValue(elVecTy) : llvm::UndefValue::get(elVecTy);
 	auto align = ::llvm::ConstantInt::get(i32Ty, alignment);
-	auto func = ::llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::masked_load, { elVecTy, elVecPtrTy } );
+	auto func = ::llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::masked_load, { elVecTy, elVecPtrTy });
 	return V(jit->builder->CreateCall(func, { V(ptr), align, i8Mask, passthrough }));
 }
 
@@ -1861,9 +1879,9 @@
 	auto i32Ty = ::llvm::Type::getInt32Ty(jit->context);
 	auto elVecTy = V(val)->getType();
 	auto elVecPtrTy = elVecTy->getPointerTo();
-	auto i8Mask = jit->builder->CreateIntCast(V(mask), ::llvm::VectorType::get(i1Ty, numEls), false); // vec<int, int, ...> -> vec<bool, bool, ...>
+	auto i8Mask = jit->builder->CreateIntCast(V(mask), ::llvm::VectorType::get(i1Ty, numEls), false);  // vec<int, int, ...> -> vec<bool, bool, ...>
 	auto align = ::llvm::ConstantInt::get(i32Ty, alignment);
-	auto func = ::llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::masked_store, { elVecTy, elVecPtrTy } );
+	auto func = ::llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::masked_store, { elVecTy, elVecPtrTy });
 	jit->builder->CreateCall(func, { V(val), V(ptr), align, i8Mask });
 }
 
@@ -1896,7 +1914,7 @@
 {
 	RR_DEBUG_INFO_UPDATE_LOC();
 	ASSERT(V(ptr)->getType()->getContainedType(0) == T(type));
-	if(sizeof(void*) == 8)
+	if(sizeof(void *) == 8)
 	{
 		// LLVM manual: "When indexing into an array, pointer or vector,
 		// integers of any width are allowed, and they are not required to
@@ -1911,9 +1929,7 @@
 		// x86 supports automatic zero-extending of 32-bit registers to
 		// 64-bit. Thus when indexing into an array using a uint32 is
 		// actually faster than an int32.
-		index = unsignedIndex ?
-			createZExt(index, Long::getType()) :
-			createSExt(index, Long::getType());
+		index = unsignedIndex ? createZExt(index, Long::getType()) : createSExt(index, Long::getType());
 	}
 
 	// For non-emulated types we can rely on LLVM's GEP to calculate the
@@ -1925,15 +1941,13 @@
 
 	// For emulated types we have to multiply the index by the intended
 	// type size ourselves to obain the byte offset.
-	index = (sizeof(void*) == 8) ?
-		createMul(index, createConstantLong((int64_t)typeSize(type))) :
-		createMul(index, createConstantInt((int)typeSize(type)));
+	index = (sizeof(void *) == 8) ? createMul(index, createConstantLong((int64_t)typeSize(type))) : createMul(index, createConstantInt((int)typeSize(type)));
 
 	// Cast to a byte pointer, apply the byte offset, and cast back to the
 	// original pointer type.
 	return createBitCast(
-		V(jit->builder->CreateGEP(V(createBitCast(ptr, T(llvm::PointerType::get(T(Byte::getType()), 0)))), V(index))),
-		T(llvm::PointerType::get(T(type), 0)));
+	    V(jit->builder->CreateGEP(V(createBitCast(ptr, T(llvm::PointerType::get(T(Byte::getType()), 0)))), V(index))),
+	    T(llvm::PointerType::get(T(type), 0)));
 }
 
 Value *Nucleus::createAtomicAdd(Value *ptr, Value *value, std::memory_order memoryOrder)
@@ -1990,7 +2004,6 @@
 	return V(jit->builder->CreateAtomicRMW(llvm::AtomicRMWInst::UMax, V(ptr), V(value), atomicOrdering(true, memoryOrder)));
 }
 
-
 Value *Nucleus::createAtomicExchange(Value *ptr, Value *value, std::memory_order memoryOrder)
 {
 	RR_DEBUG_INFO_UPDATE_LOC();
@@ -2002,8 +2015,8 @@
 	RR_DEBUG_INFO_UPDATE_LOC();
 	// Note: AtomicCmpXchgInstruction returns a 2-member struct containing {result, success-flag}, not the result directly.
 	return V(jit->builder->CreateExtractValue(
-			jit->builder->CreateAtomicCmpXchg(V(ptr), V(compare), V(value), atomicOrdering(true, memoryOrderEqual), atomicOrdering(true, memoryOrderUnequal)),
-			llvm::ArrayRef<unsigned>(0u)));
+	    jit->builder->CreateAtomicCmpXchg(V(ptr), V(compare), V(value), atomicOrdering(true, memoryOrderEqual), atomicOrdering(true, memoryOrderUnequal)),
+	    llvm::ArrayRef<unsigned>(0u)));
 }
 
 Value *Nucleus::createTrunc(Value *v, Type *destType)
@@ -2255,7 +2268,7 @@
 		swizzle[i] = llvm::ConstantInt::get(llvm::Type::getInt32Ty(jit->context), select[i]);
 	}
 
-	llvm::Value *shuffle = llvm::ConstantVector::get(llvm::ArrayRef<llvm::Constant*>(swizzle, size));
+	llvm::Value *shuffle = llvm::ConstantVector::get(llvm::ArrayRef<llvm::Constant *>(swizzle, size));
 
 	return V(jit->builder->CreateShuffleVector(V(v1), V(v2), shuffle));
 }
@@ -2269,7 +2282,7 @@
 SwitchCases *Nucleus::createSwitch(Value *control, BasicBlock *defaultBranch, unsigned numCases)
 {
 	RR_DEBUG_INFO_UPDATE_LOC();
-	return reinterpret_cast<SwitchCases*>(jit->builder->CreateSwitch(V(control), B(defaultBranch), numCases));
+	return reinterpret_cast<SwitchCases *>(jit->builder->CreateSwitch(V(control), B(defaultBranch), numCases));
 }
 
 void Nucleus::addSwitchCase(SwitchCases *switchCases, int label, BasicBlock *branch)
@@ -2359,8 +2372,8 @@
 Value *Nucleus::createConstantVector(const int64_t *constants, Type *type)
 {
 	ASSERT(llvm::isa<llvm::VectorType>(T(type)));
-	const int numConstants = elementCount(type);                                       // Number of provided constants for the (emulated) type.
-	const int numElements = llvm::cast<llvm::VectorType>(T(type))->getNumElements();   // Number of elements of the underlying vector type.
+	const int numConstants = elementCount(type);                                      // Number of provided constants for the (emulated) type.
+	const int numElements = llvm::cast<llvm::VectorType>(T(type))->getNumElements();  // Number of elements of the underlying vector type.
 	ASSERT(numElements <= 16 && numConstants <= numElements);
 	llvm::Constant *constantVector[16];
 
@@ -2369,14 +2382,14 @@
 		constantVector[i] = llvm::ConstantInt::get(T(type)->getContainedType(0), constants[i % numConstants]);
 	}
 
-	return V(llvm::ConstantVector::get(llvm::ArrayRef<llvm::Constant*>(constantVector, numElements)));
+	return V(llvm::ConstantVector::get(llvm::ArrayRef<llvm::Constant *>(constantVector, numElements)));
 }
 
 Value *Nucleus::createConstantVector(const double *constants, Type *type)
 {
 	ASSERT(llvm::isa<llvm::VectorType>(T(type)));
-	const int numConstants = elementCount(type);                                       // Number of provided constants for the (emulated) type.
-	const int numElements = llvm::cast<llvm::VectorType>(T(type))->getNumElements();   // Number of elements of the underlying vector type.
+	const int numConstants = elementCount(type);                                      // Number of provided constants for the (emulated) type.
+	const int numElements = llvm::cast<llvm::VectorType>(T(type))->getNumElements();  // Number of elements of the underlying vector type.
 	ASSERT(numElements <= 8 && numConstants <= numElements);
 	llvm::Constant *constantVector[8];
 
@@ -2385,7 +2398,7 @@
 		constantVector[i] = llvm::ConstantFP::get(T(type)->getContainedType(0), constants[i % numConstants]);
 	}
 
-	return V(llvm::ConstantVector::get(llvm::ArrayRef<llvm::Constant*>(constantVector, numElements)));
+	return V(llvm::ConstantVector::get(llvm::ArrayRef<llvm::Constant *>(constantVector, numElements)));
 }
 
 Type *Void::getType()
@@ -2560,7 +2573,7 @@
 Short4::Short4(RValue<Int4> cast)
 {
 	RR_DEBUG_INFO_UPDATE_LOC();
-	int select[8] = {0, 2, 4, 6, 0, 2, 4, 6};
+	int select[8] = { 0, 2, 4, 6, 0, 2, 4, 6 };
 	Value *short8 = Nucleus::createBitCast(cast.value, Short8::getType());
 
 	Value *packed = Nucleus::createShuffleVector(short8, short8, select);
@@ -2591,7 +2604,7 @@
 {
 	RR_DEBUG_INFO_UPDATE_LOC();
 #if defined(__i386__) || defined(__x86_64__)
-//	return RValue<Short4>(Nucleus::createShl(lhs.value, rhs.value));
+	//	return RValue<Short4>(Nucleus::createShl(lhs.value, rhs.value));
 
 	return x86::psllw(lhs, rhs);
 #else
@@ -2724,7 +2737,7 @@
 #if defined(__i386__) || defined(__x86_64__)
 		if(CPUID::supportsSSE4_1())
 		{
-			Int4 int4(Min(cast, Float4(0xFFFF)));   // packusdw takes care of 0x0000 saturation
+			Int4 int4(Min(cast, Float4(0xFFFF)));  // packusdw takes care of 0x0000 saturation
 			*this = As<Short4>(PackUnsigned(int4, int4));
 		}
 		else
@@ -2743,7 +2756,7 @@
 {
 	RR_DEBUG_INFO_UPDATE_LOC();
 #if defined(__i386__) || defined(__x86_64__)
-//	return RValue<Short4>(Nucleus::createShl(lhs.value, rhs.value));
+	//	return RValue<Short4>(Nucleus::createShl(lhs.value, rhs.value));
 
 	return As<UShort4>(x86::psllw(As<Short4>(lhs), rhs));
 #else
@@ -2755,7 +2768,7 @@
 {
 	RR_DEBUG_INFO_UPDATE_LOC();
 #if defined(__i386__) || defined(__x86_64__)
-//	return RValue<Short4>(Nucleus::createLShr(lhs.value, rhs.value));
+	//	return RValue<Short4>(Nucleus::createLShr(lhs.value, rhs.value));
 
 	return x86::psrlw(lhs, rhs);
 #else
@@ -2879,7 +2892,7 @@
 {
 	RR_DEBUG_INFO_UPDATE_LOC();
 #if defined(__i386__) || defined(__x86_64__)
-	return x86::psrlw(lhs, rhs);   // FIXME: Fallback required
+	return x86::psrlw(lhs, rhs);  // FIXME: Fallback required
 #else
 	return As<UShort8>(V(lowerVectorLShr(V(lhs.value), rhs)));
 #endif
@@ -2888,8 +2901,7 @@
 RValue<UShort8> Swizzle(RValue<UShort8> x, char select0, char select1, char select2, char select3, char select4, char select5, char select6, char select7)
 {
 	RR_DEBUG_INFO_UPDATE_LOC();
-	int pshufb[16] =
-	{
+	int pshufb[16] = {
 		select0 + 0,
 		select0 + 1,
 		select1 + 0,
@@ -2930,7 +2942,7 @@
 	return T(llvm::VectorType::get(T(UShort::getType()), 8));
 }
 
-RValue<Int> operator++(Int &val, int)   // Post-increment
+RValue<Int> operator++(Int &val, int)  // Post-increment
 {
 	RR_DEBUG_INFO_UPDATE_LOC();
 	RValue<Int> res = val;
@@ -2941,7 +2953,7 @@
 	return res;
 }
 
-const Int &operator++(Int &val)   // Pre-increment
+const Int &operator++(Int &val)  // Pre-increment
 {
 	RR_DEBUG_INFO_UPDATE_LOC();
 	Value *inc = Nucleus::createAdd(val.loadValue(), Nucleus::createConstantInt(1));
@@ -2950,7 +2962,7 @@
 	return val;
 }
 
-RValue<Int> operator--(Int &val, int)   // Post-decrement
+RValue<Int> operator--(Int &val, int)  // Post-decrement
 {
 	RR_DEBUG_INFO_UPDATE_LOC();
 	RValue<Int> res = val;
@@ -2961,7 +2973,7 @@
 	return res;
 }
 
-const Int &operator--(Int &val)   // Pre-decrement
+const Int &operator--(Int &val)  // Pre-decrement
 {
 	RR_DEBUG_INFO_UPDATE_LOC();
 	Value *inc = Nucleus::createSub(val.loadValue(), Nucleus::createConstantInt(1));
@@ -2997,7 +3009,7 @@
 	storeValue(integer);
 }
 
-RValue<UInt> operator++(UInt &val, int)   // Post-increment
+RValue<UInt> operator++(UInt &val, int)  // Post-increment
 {
 	RR_DEBUG_INFO_UPDATE_LOC();
 	RValue<UInt> res = val;
@@ -3008,7 +3020,7 @@
 	return res;
 }
 
-const UInt &operator++(UInt &val)   // Pre-increment
+const UInt &operator++(UInt &val)  // Pre-increment
 {
 	RR_DEBUG_INFO_UPDATE_LOC();
 	Value *inc = Nucleus::createAdd(val.loadValue(), Nucleus::createConstantInt(1));
@@ -3017,7 +3029,7 @@
 	return val;
 }
 
-RValue<UInt> operator--(UInt &val, int)   // Post-decrement
+RValue<UInt> operator--(UInt &val, int)  // Post-decrement
 {
 	RR_DEBUG_INFO_UPDATE_LOC();
 	RValue<UInt> res = val;
@@ -3028,7 +3040,7 @@
 	return res;
 }
 
-const UInt &operator--(UInt &val)   // Pre-decrement
+const UInt &operator--(UInt &val)  // Pre-decrement
 {
 	RR_DEBUG_INFO_UPDATE_LOC();
 	Value *inc = Nucleus::createSub(val.loadValue(), Nucleus::createConstantInt(1));
@@ -3066,7 +3078,7 @@
 {
 	RR_DEBUG_INFO_UPDATE_LOC();
 #if defined(__i386__) || defined(__x86_64__)
-//	return RValue<Int2>(Nucleus::createShl(lhs.value, rhs.value));
+	//	return RValue<Int2>(Nucleus::createShl(lhs.value, rhs.value));
 
 	return x86::pslld(lhs, rhs);
 #else
@@ -3078,7 +3090,7 @@
 {
 	RR_DEBUG_INFO_UPDATE_LOC();
 #if defined(__i386__) || defined(__x86_64__)
-//	return RValue<Int2>(Nucleus::createAShr(lhs.value, rhs.value));
+	//	return RValue<Int2>(Nucleus::createAShr(lhs.value, rhs.value));
 
 	return x86::psrad(lhs, rhs);
 #else
@@ -3095,7 +3107,7 @@
 {
 	RR_DEBUG_INFO_UPDATE_LOC();
 #if defined(__i386__) || defined(__x86_64__)
-//	return RValue<UInt2>(Nucleus::createShl(lhs.value, rhs.value));
+	//	return RValue<UInt2>(Nucleus::createShl(lhs.value, rhs.value));
 
 	return As<UInt2>(x86::pslld(As<Int2>(lhs), rhs));
 #else
@@ -3107,7 +3119,7 @@
 {
 	RR_DEBUG_INFO_UPDATE_LOC();
 #if defined(__i386__) || defined(__x86_64__)
-//	return RValue<UInt2>(Nucleus::createLShr(lhs.value, rhs.value));
+	//	return RValue<UInt2>(Nucleus::createLShr(lhs.value, rhs.value));
 
 	return x86::psrld(lhs, rhs);
 #else
@@ -3120,7 +3132,8 @@
 	return T(Type_v2i32);
 }
 
-Int4::Int4(RValue<Byte4> cast) : XYZW(this)
+Int4::Int4(RValue<Byte4> cast)
+    : XYZW(this)
 {
 	RR_DEBUG_INFO_UPDATE_LOC();
 #if defined(__i386__) || defined(__x86_64__)
@@ -3131,11 +3144,11 @@
 	else
 #endif
 	{
-		int swizzle[16] = {0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23};
+		int swizzle[16] = { 0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23 };
 		Value *a = Nucleus::createBitCast(cast.value, Byte16::getType());
 		Value *b = Nucleus::createShuffleVector(a, Nucleus::createNullValue(Byte16::getType()), swizzle);
 
-		int swizzle2[8] = {0, 8, 1, 9, 2, 10, 3, 11};
+		int swizzle2[8] = { 0, 8, 1, 9, 2, 10, 3, 11 };
 		Value *c = Nucleus::createBitCast(b, Short8::getType());
 		Value *d = Nucleus::createShuffleVector(c, Nucleus::createNullValue(Short8::getType()), swizzle2);
 
@@ -3143,7 +3156,8 @@
 	}
 }
 
-Int4::Int4(RValue<SByte4> cast) : XYZW(this)
+Int4::Int4(RValue<SByte4> cast)
+    : XYZW(this)
 {
 	RR_DEBUG_INFO_UPDATE_LOC();
 #if defined(__i386__) || defined(__x86_64__)
@@ -3154,11 +3168,11 @@
 	else
 #endif
 	{
-		int swizzle[16] = {0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7};
+		int swizzle[16] = { 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7 };
 		Value *a = Nucleus::createBitCast(cast.value, Byte16::getType());
 		Value *b = Nucleus::createShuffleVector(a, a, swizzle);
 
-		int swizzle2[8] = {0, 0, 1, 1, 2, 2, 3, 3};
+		int swizzle2[8] = { 0, 0, 1, 1, 2, 2, 3, 3 };
 		Value *c = Nucleus::createBitCast(b, Short8::getType());
 		Value *d = Nucleus::createShuffleVector(c, c, swizzle2);
 
@@ -3166,7 +3180,8 @@
 	}
 }
 
-Int4::Int4(RValue<Short4> cast) : XYZW(this)
+Int4::Int4(RValue<Short4> cast)
+    : XYZW(this)
 {
 	RR_DEBUG_INFO_UPDATE_LOC();
 #if defined(__i386__) || defined(__x86_64__)
@@ -3177,13 +3192,14 @@
 	else
 #endif
 	{
-		int swizzle[8] = {0, 0, 1, 1, 2, 2, 3, 3};
+		int swizzle[8] = { 0, 0, 1, 1, 2, 2, 3, 3 };
 		Value *c = Nucleus::createShuffleVector(cast.value, cast.value, swizzle);
 		*this = As<Int4>(c) >> 16;
 	}
 }
 
-Int4::Int4(RValue<UShort4> cast) : XYZW(this)
+Int4::Int4(RValue<UShort4> cast)
+    : XYZW(this)
 {
 	RR_DEBUG_INFO_UPDATE_LOC();
 #if defined(__i386__) || defined(__x86_64__)
@@ -3194,19 +3210,20 @@
 	else
 #endif
 	{
-		int swizzle[8] = {0, 8, 1, 9, 2, 10, 3, 11};
+		int swizzle[8] = { 0, 8, 1, 9, 2, 10, 3, 11 };
 		Value *c = Nucleus::createShuffleVector(cast.value, Short8(0, 0, 0, 0, 0, 0, 0, 0).loadValue(), swizzle);
 		*this = As<Int4>(c);
 	}
 }
 
-Int4::Int4(RValue<Int> rhs) : XYZW(this)
+Int4::Int4(RValue<Int> rhs)
+    : XYZW(this)
 {
 	RR_DEBUG_INFO_UPDATE_LOC();
 	Value *vector = loadValue();
 	Value *insert = Nucleus::createInsertElement(vector, rhs.value, 0);
 
-	int swizzle[4] = {0, 0, 0, 0};
+	int swizzle[4] = { 0, 0, 0, 0 };
 	Value *replicate = Nucleus::createShuffleVector(insert, insert, swizzle);
 
 	storeValue(replicate);
@@ -3359,20 +3376,22 @@
 	return T(llvm::VectorType::get(T(Int::getType()), 4));
 }
 
-UInt4::UInt4(RValue<Float4> cast) : XYZW(this)
+UInt4::UInt4(RValue<Float4> cast)
+    : XYZW(this)
 {
 	RR_DEBUG_INFO_UPDATE_LOC();
 	Value *xyzw = Nucleus::createFPToUI(cast.value, UInt4::getType());
 	storeValue(xyzw);
 }
 
-UInt4::UInt4(RValue<UInt> rhs) : XYZW(this)
+UInt4::UInt4(RValue<UInt> rhs)
+    : XYZW(this)
 {
 	RR_DEBUG_INFO_UPDATE_LOC();
 	Value *vector = loadValue();
 	Value *insert = Nucleus::createInsertElement(vector, rhs.value, 0);
 
-	int swizzle[4] = {0, 0, 0, 0};
+	int swizzle[4] = { 0, 0, 0, 0 };
 	Value *replicate = Nucleus::createShuffleVector(insert, insert, swizzle);
 
 	storeValue(replicate);
@@ -3539,7 +3558,7 @@
 	}
 	else
 	{
-		return Float(Int(x));   // Rounded toward zero
+		return Float(Int(x));  // Rounded toward zero
 	}
 #else
 	return RValue<Float>(V(lowerTrunc(V(x.value))));
@@ -3609,23 +3628,24 @@
 
 RValue<Float> Exp2(RValue<Float> v)
 {
-	auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::exp2, { T(Float::getType()) } );
+	auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::exp2, { T(Float::getType()) });
 	return RValue<Float>(V(jit->builder->CreateCall(func, V(v.value))));
 }
 
 RValue<Float> Log2(RValue<Float> v)
 {
-	auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::log2, { T(Float::getType()) } );
+	auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::log2, { T(Float::getType()) });
 	return RValue<Float>(V(jit->builder->CreateCall(func, V(v.value))));
 }
 
-Float4::Float4(RValue<Float> rhs) : XYZW(this)
+Float4::Float4(RValue<Float> rhs)
+    : XYZW(this)
 {
 	RR_DEBUG_INFO_UPDATE_LOC();
 	Value *vector = loadValue();
 	Value *insert = Nucleus::createInsertElement(vector, rhs.value, 0);
 
-	int swizzle[4] = {0, 0, 0, 0};
+	int swizzle[4] = { 0, 0, 0, 0 };
 	Value *replicate = Nucleus::createShuffleVector(insert, insert, swizzle);
 
 	storeValue(replicate);
@@ -3700,42 +3720,42 @@
 RValue<Int4> CmpEQ(RValue<Float4> x, RValue<Float4> y)
 {
 	RR_DEBUG_INFO_UPDATE_LOC();
-//	return As<Int4>(x86::cmpeqps(x, y));
+	//	return As<Int4>(x86::cmpeqps(x, y));
 	return RValue<Int4>(Nucleus::createSExt(Nucleus::createFCmpOEQ(x.value, y.value), Int4::getType()));
 }
 
 RValue<Int4> CmpLT(RValue<Float4> x, RValue<Float4> y)
 {
 	RR_DEBUG_INFO_UPDATE_LOC();
-//	return As<Int4>(x86::cmpltps(x, y));
+	//	return As<Int4>(x86::cmpltps(x, y));
 	return RValue<Int4>(Nucleus::createSExt(Nucleus::createFCmpOLT(x.value, y.value), Int4::getType()));
 }
 
 RValue<Int4> CmpLE(RValue<Float4> x, RValue<Float4> y)
 {
 	RR_DEBUG_INFO_UPDATE_LOC();
-//	return As<Int4>(x86::cmpleps(x, y));
+	//	return As<Int4>(x86::cmpleps(x, y));
 	return RValue<Int4>(Nucleus::createSExt(Nucleus::createFCmpOLE(x.value, y.value), Int4::getType()));
 }
 
 RValue<Int4> CmpNEQ(RValue<Float4> x, RValue<Float4> y)
 {
 	RR_DEBUG_INFO_UPDATE_LOC();
-//	return As<Int4>(x86::cmpneqps(x, y));
+	//	return As<Int4>(x86::cmpneqps(x, y));
 	return RValue<Int4>(Nucleus::createSExt(Nucleus::createFCmpONE(x.value, y.value), Int4::getType()));
 }
 
 RValue<Int4> CmpNLT(RValue<Float4> x, RValue<Float4> y)
 {
 	RR_DEBUG_INFO_UPDATE_LOC();
-//	return As<Int4>(x86::cmpnltps(x, y));
+	//	return As<Int4>(x86::cmpnltps(x, y));
 	return RValue<Int4>(Nucleus::createSExt(Nucleus::createFCmpOGE(x.value, y.value), Int4::getType()));
 }
 
 RValue<Int4> CmpNLE(RValue<Float4> x, RValue<Float4> y)
 {
 	RR_DEBUG_INFO_UPDATE_LOC();
-//	return As<Int4>(x86::cmpnleps(x, y));
+	//	return As<Int4>(x86::cmpnleps(x, y));
 	return RValue<Int4>(Nucleus::createSExt(Nucleus::createFCmpOGT(x.value, y.value), Int4::getType()));
 }
 
@@ -3821,9 +3841,9 @@
 	}
 	else
 	{
-		frc = x - Float4(Int4(x));   // Signed fractional part.
+		frc = x - Float4(Int4(x));  // Signed fractional part.
 
-		frc += As<Float4>(As<Int4>(CmpNLE(Float4(0.0f), frc)) & As<Int4>(Float4(1.0f)));   // Add 1.0 if negative.
+		frc += As<Float4>(As<Int4>(CmpNLE(Float4(0.0f), frc)) & As<Int4>(Float4(1.0f)));  // Add 1.0 if negative.
 	}
 #else
 	frc = x - Floor(x);
@@ -3868,13 +3888,13 @@
 
 RValue<Float4> Sin(RValue<Float4> v)
 {
-	auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::sin, { V(v.value)->getType() } );
+	auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::sin, { V(v.value)->getType() });
 	return RValue<Float4>(V(jit->builder->CreateCall(func, V(v.value))));
 }
 
 RValue<Float4> Cos(RValue<Float4> v)
 {
-	auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::cos, { V(v.value)->getType() } );
+	auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::cos, { V(v.value)->getType() });
 	return RValue<Float4>(V(jit->builder->CreateCall(func, V(v.value))));
 }
 
@@ -3883,9 +3903,9 @@
 	return Sin(v) / Cos(v);
 }
 
-static RValue<Float4> TransformFloat4PerElement(RValue<Float4> v, const char* name)
+static RValue<Float4> TransformFloat4PerElement(RValue<Float4> v, const char *name)
 {
-	auto funcTy = ::llvm::FunctionType::get(T(Float::getType()), ::llvm::ArrayRef<llvm::Type*>(T(Float::getType())), false);
+	auto funcTy = ::llvm::FunctionType::get(T(Float::getType()), ::llvm::ArrayRef<llvm::Type *>(T(Float::getType())), false);
 	auto func = jit->module->getOrInsertFunction(name, funcTy);
 	llvm::Value *out = ::llvm::UndefValue::get(T(Float4::getType()));
 	for(uint64_t i = 0; i < 4; i++)
@@ -3943,7 +3963,7 @@
 
 RValue<Float4> Atan2(RValue<Float4> x, RValue<Float4> y)
 {
-	::llvm::SmallVector<::llvm::Type*, 2> paramTys;
+	::llvm::SmallVector<::llvm::Type *, 2> paramTys;
 	paramTys.push_back(T(Float::getType()));
 	paramTys.push_back(T(Float::getType()));
 	auto funcTy = ::llvm::FunctionType::get(T(Float::getType()), paramTys, false);
@@ -3952,9 +3972,8 @@
 	for(uint64_t i = 0; i < 4; i++)
 	{
 		auto el = jit->builder->CreateCall2(func, ARGS(
-				V(Nucleus::createExtractElement(x.value, Float::getType(), i)),
-				V(Nucleus::createExtractElement(y.value, Float::getType(), i))
-			));
+		                                              V(Nucleus::createExtractElement(x.value, Float::getType(), i)),
+		                                              V(Nucleus::createExtractElement(y.value, Float::getType(), i))));
 		out = V(Nucleus::createInsertElement(V(out), V(el), i));
 	}
 	return RValue<Float4>(V(out));
@@ -3968,62 +3987,58 @@
 
 RValue<Float4> Exp(RValue<Float4> v)
 {
-	auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::exp, { T(Float4::getType()) } );
+	auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::exp, { T(Float4::getType()) });
 	return RValue<Float4>(V(jit->builder->CreateCall(func, V(v.value))));
 }
 
 RValue<Float4> Log(RValue<Float4> v)
 {
-	auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::log, { T(Float4::getType()) } );
+	auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::log, { T(Float4::getType()) });
 	return RValue<Float4>(V(jit->builder->CreateCall(func, V(v.value))));
 }
 
 RValue<Float4> Exp2(RValue<Float4> v)
 {
-	auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::exp2, { T(Float4::getType()) } );
+	auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::exp2, { T(Float4::getType()) });
 	return RValue<Float4>(V(jit->builder->CreateCall(func, V(v.value))));
 }
 
 RValue<Float4> Log2(RValue<Float4> v)
 {
-	auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::log2, { T(Float4::getType()) } );
+	auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::log2, { T(Float4::getType()) });
 	return RValue<Float4>(V(jit->builder->CreateCall(func, V(v.value))));
 }
 
 RValue<UInt> Ctlz(RValue<UInt> v, bool isZeroUndef)
 {
-	auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::ctlz, { T(UInt::getType()) } );
+	auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::ctlz, { T(UInt::getType()) });
 	return RValue<UInt>(V(jit->builder->CreateCall2(func, ARGS(
-		V(v.value),
-		isZeroUndef ? ::llvm::ConstantInt::getTrue(jit->context) : ::llvm::ConstantInt::getFalse(jit->context)
-	))));
+	                                                          V(v.value),
+	                                                          isZeroUndef ? ::llvm::ConstantInt::getTrue(jit->context) : ::llvm::ConstantInt::getFalse(jit->context)))));
 }
 
 RValue<UInt4> Ctlz(RValue<UInt4> v, bool isZeroUndef)
 {
-	auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::ctlz, { T(UInt4::getType()) } );
+	auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::ctlz, { T(UInt4::getType()) });
 	return RValue<UInt4>(V(jit->builder->CreateCall2(func, ARGS(
-		V(v.value),
-		isZeroUndef ? ::llvm::ConstantInt::getTrue(jit->context) : ::llvm::ConstantInt::getFalse(jit->context)
-	))));
+	                                                           V(v.value),
+	                                                           isZeroUndef ? ::llvm::ConstantInt::getTrue(jit->context) : ::llvm::ConstantInt::getFalse(jit->context)))));
 }
 
 RValue<UInt> Cttz(RValue<UInt> v, bool isZeroUndef)
 {
-	auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::cttz, { T(UInt::getType()) } );
+	auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::cttz, { T(UInt::getType()) });
 	return RValue<UInt>(V(jit->builder->CreateCall2(func, ARGS(
-		V(v.value),
-		isZeroUndef ? ::llvm::ConstantInt::getTrue(jit->context) : ::llvm::ConstantInt::getFalse(jit->context)
-	))));
+	                                                          V(v.value),
+	                                                          isZeroUndef ? ::llvm::ConstantInt::getTrue(jit->context) : ::llvm::ConstantInt::getFalse(jit->context)))));
 }
 
 RValue<UInt4> Cttz(RValue<UInt4> v, bool isZeroUndef)
 {
-	auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::cttz, { T(UInt4::getType()) } );
+	auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::cttz, { T(UInt4::getType()) });
 	return RValue<UInt4>(V(jit->builder->CreateCall2(func, ARGS(
-		V(v.value),
-		isZeroUndef ? ::llvm::ConstantInt::getTrue(jit->context) : ::llvm::ConstantInt::getFalse(jit->context)
-	))));
+	                                                           V(v.value),
+	                                                           isZeroUndef ? ::llvm::ConstantInt::getTrue(jit->context) : ::llvm::ConstantInt::getFalse(jit->context)))));
 }
 
 Type *Float4::getType()
@@ -4039,7 +4054,7 @@
 	return RValue<Long>(V(jit->builder->CreateCall(rdtsc)));
 }
 
-RValue<Pointer<Byte>> ConstantPointer(void const * ptr)
+RValue<Pointer<Byte>> ConstantPointer(void const *ptr)
 {
 	// Note: this should work for 32-bit pointers as well because 'inttoptr'
 	// is defined to truncate (and zero extend) if necessary.
@@ -4047,23 +4062,23 @@
 	return RValue<Pointer<Byte>>(V(jit->builder->CreateIntToPtr(ptrAsInt, T(Pointer<Byte>::getType()))));
 }
 
-RValue<Pointer<Byte>> ConstantData(void const * data, size_t size)
+RValue<Pointer<Byte>> ConstantData(void const *data, size_t size)
 {
-	auto str = ::llvm::StringRef(reinterpret_cast<const char*>(data), size);
+	auto str = ::llvm::StringRef(reinterpret_cast<const char *>(data), size);
 	auto ptr = jit->builder->CreateGlobalStringPtr(str);
 	return RValue<Pointer<Byte>>(V(ptr));
 }
 
-Value* Call(RValue<Pointer<Byte>> fptr, Type* retTy, std::initializer_list<Value*> args, std::initializer_list<Type*> argTys)
+Value *Call(RValue<Pointer<Byte>> fptr, Type *retTy, std::initializer_list<Value *> args, std::initializer_list<Type *> argTys)
 {
-	::llvm::SmallVector<::llvm::Type*, 8> paramTys;
+	::llvm::SmallVector<::llvm::Type *, 8> paramTys;
 	for(auto ty : argTys) { paramTys.push_back(T(ty)); }
 	auto funcTy = ::llvm::FunctionType::get(T(retTy), paramTys, false);
 
 	auto funcPtrTy = funcTy->getPointerTo();
 	auto funcPtr = jit->builder->CreatePointerCast(V(fptr.value), funcPtrTy);
 
-	::llvm::SmallVector<::llvm::Value*, 8> arguments;
+	::llvm::SmallVector<::llvm::Value *, 8> arguments;
 	for(auto arg : args) { arguments.push_back(V(arg)); }
 	return V(jit->builder->CreateCall(funcPtr, arguments));
 }
@@ -4110,7 +4125,7 @@
 
 RValue<Float> sqrtss(RValue<Float> val)
 {
-	llvm::Function *sqrt = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::sqrt, {V(val.value)->getType()});
+	llvm::Function *sqrt = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::sqrt, { V(val.value)->getType() });
 	return RValue<Float>(V(jit->builder->CreateCall(sqrt, ARGS(V(val.value)))));
 }
 
@@ -4132,7 +4147,7 @@
 
 RValue<Float4> sqrtps(RValue<Float4> val)
 {
-	llvm::Function *sqrtps = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::sqrt, {V(val.value)->getType()});
+	llvm::Function *sqrtps = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::sqrt, { V(val.value)->getType() });
 
 	return RValue<Float4>(V(jit->builder->CreateCall(sqrtps, ARGS(V(val.value)))));
 }
@@ -4202,90 +4217,90 @@
 
 RValue<Short4> paddsw(RValue<Short4> x, RValue<Short4> y)
 {
-	#if LLVM_VERSION_MAJOR >= 8
-		return As<Short4>(V(lowerPSADDSAT(V(x.value), V(y.value))));
-	#else
-		llvm::Function *paddsw = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::x86_sse2_padds_w);
+#	if LLVM_VERSION_MAJOR >= 8
+	return As<Short4>(V(lowerPSADDSAT(V(x.value), V(y.value))));
+#	else
+	llvm::Function *paddsw = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::x86_sse2_padds_w);
 
-		return As<Short4>(V(jit->builder->CreateCall2(paddsw, ARGS(V(x.value), V(y.value)))));
-	#endif
+	return As<Short4>(V(jit->builder->CreateCall2(paddsw, ARGS(V(x.value), V(y.value)))));
+#	endif
 }
 
 RValue<Short4> psubsw(RValue<Short4> x, RValue<Short4> y)
 {
-	#if LLVM_VERSION_MAJOR >= 8
-		return As<Short4>(V(lowerPSSUBSAT(V(x.value), V(y.value))));
-	#else
-		llvm::Function *psubsw = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::x86_sse2_psubs_w);
+#	if LLVM_VERSION_MAJOR >= 8
+	return As<Short4>(V(lowerPSSUBSAT(V(x.value), V(y.value))));
+#	else
+	llvm::Function *psubsw = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::x86_sse2_psubs_w);
 
-		return As<Short4>(V(jit->builder->CreateCall2(psubsw, ARGS(V(x.value), V(y.value)))));
-	#endif
+	return As<Short4>(V(jit->builder->CreateCall2(psubsw, ARGS(V(x.value), V(y.value)))));
+#	endif
 }
 
 RValue<UShort4> paddusw(RValue<UShort4> x, RValue<UShort4> y)
 {
-	#if LLVM_VERSION_MAJOR >= 8
-		return As<UShort4>(V(lowerPUADDSAT(V(x.value), V(y.value))));
-	#else
-		llvm::Function *paddusw = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::x86_sse2_paddus_w);
+#	if LLVM_VERSION_MAJOR >= 8
+	return As<UShort4>(V(lowerPUADDSAT(V(x.value), V(y.value))));
+#	else
+	llvm::Function *paddusw = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::x86_sse2_paddus_w);
 
-		return As<UShort4>(V(jit->builder->CreateCall2(paddusw, ARGS(V(x.value), V(y.value)))));
-	#endif
+	return As<UShort4>(V(jit->builder->CreateCall2(paddusw, ARGS(V(x.value), V(y.value)))));
+#	endif
 }
 
 RValue<UShort4> psubusw(RValue<UShort4> x, RValue<UShort4> y)
 {
-	#if LLVM_VERSION_MAJOR >= 8
-		return As<UShort4>(V(lowerPUSUBSAT(V(x.value), V(y.value))));
-	#else
-		llvm::Function *psubusw = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::x86_sse2_psubus_w);
+#	if LLVM_VERSION_MAJOR >= 8
+	return As<UShort4>(V(lowerPUSUBSAT(V(x.value), V(y.value))));
+#	else
+	llvm::Function *psubusw = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::x86_sse2_psubus_w);
 
-		return As<UShort4>(V(jit->builder->CreateCall2(psubusw, ARGS(V(x.value), V(y.value)))));
-	#endif
+	return As<UShort4>(V(jit->builder->CreateCall2(psubusw, ARGS(V(x.value), V(y.value)))));
+#	endif
 }
 
 RValue<SByte8> paddsb(RValue<SByte8> x, RValue<SByte8> y)
 {
-	#if LLVM_VERSION_MAJOR >= 8
-		return As<SByte8>(V(lowerPSADDSAT(V(x.value), V(y.value))));
-	#else
-		llvm::Function *paddsb = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::x86_sse2_padds_b);
+#	if LLVM_VERSION_MAJOR >= 8
+	return As<SByte8>(V(lowerPSADDSAT(V(x.value), V(y.value))));
+#	else
+	llvm::Function *paddsb = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::x86_sse2_padds_b);
 
-		return As<SByte8>(V(jit->builder->CreateCall2(paddsb, ARGS(V(x.value), V(y.value)))));
-	#endif
+	return As<SByte8>(V(jit->builder->CreateCall2(paddsb, ARGS(V(x.value), V(y.value)))));
+#	endif
 }
 
 RValue<SByte8> psubsb(RValue<SByte8> x, RValue<SByte8> y)
 {
-	#if LLVM_VERSION_MAJOR >= 8
-		return As<SByte8>(V(lowerPSSUBSAT(V(x.value), V(y.value))));
-	#else
-		llvm::Function *psubsb = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::x86_sse2_psubs_b);
+#	if LLVM_VERSION_MAJOR >= 8
+	return As<SByte8>(V(lowerPSSUBSAT(V(x.value), V(y.value))));
+#	else
+	llvm::Function *psubsb = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::x86_sse2_psubs_b);
 
-		return As<SByte8>(V(jit->builder->CreateCall2(psubsb, ARGS(V(x.value), V(y.value)))));
-	#endif
+	return As<SByte8>(V(jit->builder->CreateCall2(psubsb, ARGS(V(x.value), V(y.value)))));
+#	endif
 }
 
 RValue<Byte8> paddusb(RValue<Byte8> x, RValue<Byte8> y)
 {
-	#if LLVM_VERSION_MAJOR >= 8
-		return As<Byte8>(V(lowerPUADDSAT(V(x.value), V(y.value))));
-	#else
-		llvm::Function *paddusb = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::x86_sse2_paddus_b);
+#	if LLVM_VERSION_MAJOR >= 8
+	return As<Byte8>(V(lowerPUADDSAT(V(x.value), V(y.value))));
+#	else
+	llvm::Function *paddusb = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::x86_sse2_paddus_b);
 
-		return As<Byte8>(V(jit->builder->CreateCall2(paddusb, ARGS(V(x.value), V(y.value)))));
-	#endif
+	return As<Byte8>(V(jit->builder->CreateCall2(paddusb, ARGS(V(x.value), V(y.value)))));
+#	endif
 }
 
 RValue<Byte8> psubusb(RValue<Byte8> x, RValue<Byte8> y)
 {
-	#if LLVM_VERSION_MAJOR >= 8
-		return As<Byte8>(V(lowerPUSUBSAT(V(x.value), V(y.value))));
-	#else
-		llvm::Function *psubusb = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::x86_sse2_psubus_b);
+#	if LLVM_VERSION_MAJOR >= 8
+	return As<Byte8>(V(lowerPUSUBSAT(V(x.value), V(y.value))));
+#	else
+	llvm::Function *psubusb = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::x86_sse2_psubus_b);
 
-		return As<Byte8>(V(jit->builder->CreateCall2(psubusb, ARGS(V(x.value), V(y.value)))));
-	#endif
+	return As<Byte8>(V(jit->builder->CreateCall2(psubusb, ARGS(V(x.value), V(y.value)))));
+#	endif
 }
 
 RValue<UShort4> pavgw(RValue<UShort4> x, RValue<UShort4> y)
@@ -4554,9 +4569,9 @@
 #ifdef ENABLE_RR_PRINT
 // extractAll returns a vector containing the extracted n scalar value of
 // the vector vec.
-static std::vector<Value*> extractAll(Value* vec, int n)
+static std::vector<Value *> extractAll(Value *vec, int n)
 {
-	std::vector<Value*> elements;
+	std::vector<Value *> elements;
 	elements.reserve(n);
 	for(int i = 0; i < n; i++)
 	{
@@ -4568,10 +4583,10 @@
 
 // toInt returns all the integer values in vals extended to a native width
 // integer.
-static std::vector<Value*> toInt(const std::vector<Value*>& vals, bool isSigned)
+static std::vector<Value *> toInt(const std::vector<Value *> &vals, bool isSigned)
 {
-	auto intTy = ::llvm::Type::getIntNTy(jit->context, sizeof(int) * 8); // Natural integer width.
-	std::vector<Value*> elements;
+	auto intTy = ::llvm::Type::getIntNTy(jit->context, sizeof(int) * 8);  // Natural integer width.
+	std::vector<Value *> elements;
 	elements.reserve(vals.size());
 	for(auto v : vals)
 	{
@@ -4588,10 +4603,10 @@
 }
 
 // toDouble returns all the float values in vals extended to doubles.
-static std::vector<Value*> toDouble(const std::vector<Value*>& vals)
+static std::vector<Value *> toDouble(const std::vector<Value *> &vals)
 {
 	auto doubleTy = ::llvm::Type::getDoubleTy(jit->context);
-	std::vector<Value*> elements;
+	std::vector<Value *> elements;
 	elements.reserve(vals.size());
 	for(auto v : vals)
 	{
@@ -4600,29 +4615,74 @@
 	return elements;
 }
 
-std::vector<Value*> PrintValue::Ty<Byte>::val(const RValue<Byte>& v) { return toInt({v.value}, false); }
-std::vector<Value*> PrintValue::Ty<Byte4>::val(const RValue<Byte4>& v) { return toInt(extractAll(v.value, 4), false); }
-std::vector<Value*> PrintValue::Ty<Int>::val(const RValue<Int>& v) { return toInt({v.value}, true); }
-std::vector<Value*> PrintValue::Ty<Int2>::val(const RValue<Int2>& v) { return toInt(extractAll(v.value, 2), true); }
-std::vector<Value*> PrintValue::Ty<Int4>::val(const RValue<Int4>& v) { return toInt(extractAll(v.value, 4), true); }
-std::vector<Value*> PrintValue::Ty<UInt>::val(const RValue<UInt>& v) { return toInt({v.value}, false); }
-std::vector<Value*> PrintValue::Ty<UInt2>::val(const RValue<UInt2>& v) { return toInt(extractAll(v.value, 2), false); }
-std::vector<Value*> PrintValue::Ty<UInt4>::val(const RValue<UInt4>& v) { return toInt(extractAll(v.value, 4), false); }
-std::vector<Value*> PrintValue::Ty<Short>::val(const RValue<Short>& v) { return toInt({v.value}, true); }
-std::vector<Value*> PrintValue::Ty<Short4>::val(const RValue<Short4>& v) { return toInt(extractAll(v.value, 4), true); }
-std::vector<Value*> PrintValue::Ty<UShort>::val(const RValue<UShort>& v) { return toInt({v.value}, false); }
-std::vector<Value*> PrintValue::Ty<UShort4>::val(const RValue<UShort4>& v) { return toInt(extractAll(v.value, 4), false); }
-std::vector<Value*> PrintValue::Ty<Float>::val(const RValue<Float>& v) { return toDouble({v.value}); }
-std::vector<Value*> PrintValue::Ty<Float4>::val(const RValue<Float4>& v) { return toDouble(extractAll(v.value, 4)); }
-std::vector<Value*> PrintValue::Ty<const char*>::val(const char* v) { return {V(jit->builder->CreateGlobalStringPtr(v))}; }
+std::vector<Value *> PrintValue::Ty<Byte>::val(const RValue<Byte> &v)
+{
+	return toInt({ v.value }, false);
+}
+std::vector<Value *> PrintValue::Ty<Byte4>::val(const RValue<Byte4> &v)
+{
+	return toInt(extractAll(v.value, 4), false);
+}
+std::vector<Value *> PrintValue::Ty<Int>::val(const RValue<Int> &v)
+{
+	return toInt({ v.value }, true);
+}
+std::vector<Value *> PrintValue::Ty<Int2>::val(const RValue<Int2> &v)
+{
+	return toInt(extractAll(v.value, 2), true);
+}
+std::vector<Value *> PrintValue::Ty<Int4>::val(const RValue<Int4> &v)
+{
+	return toInt(extractAll(v.value, 4), true);
+}
+std::vector<Value *> PrintValue::Ty<UInt>::val(const RValue<UInt> &v)
+{
+	return toInt({ v.value }, false);
+}
+std::vector<Value *> PrintValue::Ty<UInt2>::val(const RValue<UInt2> &v)
+{
+	return toInt(extractAll(v.value, 2), false);
+}
+std::vector<Value *> PrintValue::Ty<UInt4>::val(const RValue<UInt4> &v)
+{
+	return toInt(extractAll(v.value, 4), false);
+}
+std::vector<Value *> PrintValue::Ty<Short>::val(const RValue<Short> &v)
+{
+	return toInt({ v.value }, true);
+}
+std::vector<Value *> PrintValue::Ty<Short4>::val(const RValue<Short4> &v)
+{
+	return toInt(extractAll(v.value, 4), true);
+}
+std::vector<Value *> PrintValue::Ty<UShort>::val(const RValue<UShort> &v)
+{
+	return toInt({ v.value }, false);
+}
+std::vector<Value *> PrintValue::Ty<UShort4>::val(const RValue<UShort4> &v)
+{
+	return toInt(extractAll(v.value, 4), false);
+}
+std::vector<Value *> PrintValue::Ty<Float>::val(const RValue<Float> &v)
+{
+	return toDouble({ v.value });
+}
+std::vector<Value *> PrintValue::Ty<Float4>::val(const RValue<Float4> &v)
+{
+	return toDouble(extractAll(v.value, 4));
+}
+std::vector<Value *> PrintValue::Ty<const char *>::val(const char *v)
+{
+	return { V(jit->builder->CreateGlobalStringPtr(v)) };
+}
 
-void Printv(const char* function, const char* file, int line, const char* fmt, std::initializer_list<PrintValue> args)
+void Printv(const char *function, const char *file, int line, const char *fmt, std::initializer_list<PrintValue> args)
 {
 	// LLVM types used below.
 	auto i32Ty = ::llvm::Type::getInt32Ty(jit->context);
-	auto intTy = ::llvm::Type::getIntNTy(jit->context, sizeof(int) * 8); // Natural integer width.
+	auto intTy = ::llvm::Type::getIntNTy(jit->context, sizeof(int) * 8);  // Natural integer width.
 	auto i8PtrTy = ::llvm::Type::getInt8PtrTy(jit->context);
-	auto funcTy = ::llvm::FunctionType::get(i32Ty, {i8PtrTy}, true);
+	auto funcTy = ::llvm::FunctionType::get(i32Ty, { i8PtrTy }, true);
 
 	auto func = jit->module->getOrInsertFunction("printf", funcTy);
 
@@ -4635,12 +4695,12 @@
 	// Perform subsitution on all '{n}' bracketed indices in the format
 	// message.
 	int i = 0;
-	for(const PrintValue& arg : args)
+	for(const PrintValue &arg : args)
 	{
 		str = replace(str, "{" + std::to_string(i++) + "}", arg.format);
 	}
 
-	::llvm::SmallVector<::llvm::Value*, 8> vals;
+	::llvm::SmallVector<::llvm::Value *, 8> vals;
 
 	// The format message is always the first argument.
 	vals.push_back(jit->builder->CreateGlobalStringPtr(str));
@@ -4660,7 +4720,7 @@
 	}
 
 	// Add all format arguments.
-	for(const PrintValue& arg : args)
+	for(const PrintValue &arg : args)
 	{
 		for(auto val : arg.values)
 		{
@@ -4670,7 +4730,7 @@
 
 	jit->builder->CreateCall(func, vals);
 }
-#endif // ENABLE_RR_PRINT
+#endif  // ENABLE_RR_PRINT
 
 void Nop()
 {
@@ -4687,17 +4747,17 @@
 	{
 		jit->debugInfo->EmitLocation();
 	}
-#endif // ENABLE_RR_DEBUG_INFO
+#endif  // ENABLE_RR_DEBUG_INFO
 }
 
-void EmitDebugVariable(Value* value)
+void EmitDebugVariable(Value *value)
 {
 #ifdef ENABLE_RR_DEBUG_INFO
 	if(jit->debugInfo != nullptr)
 	{
 		jit->debugInfo->EmitVariable(value);
 	}
-#endif // ENABLE_RR_DEBUG_INFO
+#endif  // ENABLE_RR_DEBUG_INFO
 }
 
 void FlushDebug()
@@ -4707,7 +4767,7 @@
 	{
 		jit->debugInfo->Flush();
 	}
-#endif // ENABLE_RR_DEBUG_INFO
+#endif  // ENABLE_RR_DEBUG_INFO
 }
 
 }  // namespace rr
@@ -4740,7 +4800,7 @@
 
 	// LLVM intrinsics
 	auto coro_id = ::llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::coro_id);
-	auto coro_size = ::llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::coro_size, {i32Ty});
+	auto coro_size = ::llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::coro_size, { i32Ty });
 	auto coro_begin = ::llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::coro_begin);
 	auto coro_resume = ::llvm::Intrinsic::getDeclaration(jit->module.get(), ::llvm::Intrinsic::coro_resume);
 	auto coro_end = ::llvm::Intrinsic::getDeclaration(jit->module.get(), ::llvm::Intrinsic::coro_end);
@@ -4750,9 +4810,9 @@
 	auto coro_done = ::llvm::Intrinsic::getDeclaration(jit->module.get(), ::llvm::Intrinsic::coro_done);
 	auto coro_suspend = ::llvm::Intrinsic::getDeclaration(jit->module.get(), ::llvm::Intrinsic::coro_suspend);
 
-	auto allocFrameTy = ::llvm::FunctionType::get(i8PtrTy, {i32Ty}, false);
+	auto allocFrameTy = ::llvm::FunctionType::get(i8PtrTy, { i32Ty }, false);
 	auto allocFrame = jit->module->getOrInsertFunction("coroutine_alloc_frame", allocFrameTy);
-	auto freeFrameTy = ::llvm::FunctionType::get(voidTy, {i8PtrTy}, false);
+	auto freeFrameTy = ::llvm::FunctionType::get(voidTy, { i8PtrTy }, false);
 	auto freeFrame = jit->module->getOrInsertFunction("coroutine_free_frame", freeFrameTy);
 
 	auto oldInsertionPoint = jit->builder->saveIP();
@@ -4781,18 +4841,18 @@
 		auto doneBlock = llvm::BasicBlock::Create(jit->context, "done", jit->coroutine.await);
 		auto resumeBlock = llvm::BasicBlock::Create(jit->context, "resume", jit->coroutine.await);
 
-		auto done = jit->builder->CreateCall(coro_done, {handle}, "done");
+		auto done = jit->builder->CreateCall(coro_done, { handle }, "done");
 		jit->builder->CreateCondBr(done, doneBlock, resumeBlock);
 
 		jit->builder->SetInsertPoint(doneBlock);
 		jit->builder->CreateRet(::llvm::ConstantInt::getFalse(i1Ty));
 
 		jit->builder->SetInsertPoint(resumeBlock);
-		auto promiseAlignment = ::llvm::ConstantInt::get(i32Ty, 4); // TODO: Get correct alignment.
-		auto promisePtr = jit->builder->CreateCall(coro_promise, {handle, promiseAlignment, ::llvm::ConstantInt::get(i1Ty, 0)});
+		auto promiseAlignment = ::llvm::ConstantInt::get(i32Ty, 4);  // TODO: Get correct alignment.
+		auto promisePtr = jit->builder->CreateCall(coro_promise, { handle, promiseAlignment, ::llvm::ConstantInt::get(i1Ty, 0) });
 		auto promise = jit->builder->CreateLoad(jit->builder->CreatePointerCast(promisePtr, promisePtrTy));
 		jit->builder->CreateStore(promise, outPtr);
-		jit->builder->CreateCall(coro_resume, {handle});
+		jit->builder->CreateCall(coro_resume, { handle });
 		jit->builder->CreateRet(::llvm::ConstantInt::getTrue(i1Ty));
 	}
 
@@ -4806,7 +4866,7 @@
 	{
 		auto handle = jit->coroutine.destroy->arg_begin();
 		jit->builder->SetInsertPoint(llvm::BasicBlock::Create(jit->context, "", jit->coroutine.destroy));
-		jit->builder->CreateCall(coro_destroy, {handle});
+		jit->builder->CreateCall(coro_destroy, { handle });
 		jit->builder->CreateRetVoid();
 	}
 
@@ -4845,7 +4905,7 @@
 
 #ifdef ENABLE_RR_DEBUG_INFO
 	jit->debugInfo = std::unique_ptr<rr::DebugInfo>(new rr::DebugInfo(jit->builder.get(), &jit->context, jit->module.get(), jit->function));
-#endif // ENABLE_RR_DEBUG_INFO
+#endif  // ENABLE_RR_DEBUG_INFO
 
 	jit->coroutine.suspendBlock = llvm::BasicBlock::Create(jit->context, "suspend", jit->function);
 	jit->coroutine.endBlock = llvm::BasicBlock::Create(jit->context, "end", jit->function);
@@ -4854,45 +4914,45 @@
 	jit->builder->SetInsertPoint(jit->coroutine.entryBlock, jit->coroutine.entryBlock->begin());
 	jit->coroutine.promise = jit->builder->CreateAlloca(promiseTy, nullptr, "promise");
 	jit->coroutine.id = jit->builder->CreateCall(coro_id, {
-		::llvm::ConstantInt::get(i32Ty, 0),
-		jit->builder->CreatePointerCast(jit->coroutine.promise, i8PtrTy),
-		::llvm::ConstantPointerNull::get(i8PtrTy),
-		::llvm::ConstantPointerNull::get(i8PtrTy),
-	});
+	                                                          ::llvm::ConstantInt::get(i32Ty, 0),
+	                                                          jit->builder->CreatePointerCast(jit->coroutine.promise, i8PtrTy),
+	                                                          ::llvm::ConstantPointerNull::get(i8PtrTy),
+	                                                          ::llvm::ConstantPointerNull::get(i8PtrTy),
+	                                                      });
 	auto size = jit->builder->CreateCall(coro_size, {});
-	auto frame = jit->builder->CreateCall(allocFrame, {size});
-	jit->coroutine.handle = jit->builder->CreateCall(coro_begin, {jit->coroutine.id, frame});
+	auto frame = jit->builder->CreateCall(allocFrame, { size });
+	jit->coroutine.handle = jit->builder->CreateCall(coro_begin, { jit->coroutine.id, frame });
 
 	// Build the suspend block
 	jit->builder->SetInsertPoint(jit->coroutine.suspendBlock);
-	jit->builder->CreateCall(coro_end, {jit->coroutine.handle, ::llvm::ConstantInt::get(i1Ty, 0)});
+	jit->builder->CreateCall(coro_end, { jit->coroutine.handle, ::llvm::ConstantInt::get(i1Ty, 0) });
 	jit->builder->CreateRet(jit->coroutine.handle);
 
 	// Build the end block
 	jit->builder->SetInsertPoint(jit->coroutine.endBlock);
 	auto action = jit->builder->CreateCall(coro_suspend, {
-		::llvm::ConstantTokenNone::get(jit->context),
-		::llvm::ConstantInt::get(i1Ty, 1), // final: true
-	});
+	                                                         ::llvm::ConstantTokenNone::get(jit->context),
+	                                                         ::llvm::ConstantInt::get(i1Ty, 1),  // final: true
+	                                                     });
 	auto switch_ = jit->builder->CreateSwitch(action, jit->coroutine.suspendBlock, 3);
 	// switch_->addCase(::llvm::ConstantInt::get(i8Ty, SuspendActionResume), trapBlock); // TODO: Trap attempting to resume after final suspend
 	switch_->addCase(::llvm::ConstantInt::get(i8Ty, SuspendActionDestroy), jit->coroutine.destroyBlock);
 
 	// Build the destroy block
 	jit->builder->SetInsertPoint(jit->coroutine.destroyBlock);
-	auto memory = jit->builder->CreateCall(coro_free, {jit->coroutine.id, jit->coroutine.handle});
-	jit->builder->CreateCall(freeFrame, {memory});
+	auto memory = jit->builder->CreateCall(coro_free, { jit->coroutine.id, jit->coroutine.handle });
+	jit->builder->CreateCall(freeFrame, { memory });
 	jit->builder->CreateBr(jit->coroutine.suspendBlock);
 
 	// Switch back to original insert point to continue building the coroutine.
 	jit->builder->restoreIP(oldInsertionPoint);
 }
 
-} // anonymous namespace
+}  // anonymous namespace
 
 namespace rr {
 
-void Nucleus::createCoroutine(Type *YieldType, std::vector<Type*> &Params)
+void Nucleus::createCoroutine(Type *YieldType, std::vector<Type *> &Params)
 {
 	// Coroutines are initially created as a regular function.
 	// Upon the first call to Yield(), the function is promoted to a true
@@ -4906,15 +4966,15 @@
 	auto promisePtrTy = promiseTy->getPointerTo();
 
 	jit->function = rr::createFunction("coroutine_begin", handleTy, T(Params));
-	jit->coroutine.await = rr::createFunction("coroutine_await", boolTy, {handleTy, promisePtrTy});
-	jit->coroutine.destroy = rr::createFunction("coroutine_destroy", voidTy, {handleTy});
+	jit->coroutine.await = rr::createFunction("coroutine_await", boolTy, { handleTy, promisePtrTy });
+	jit->coroutine.destroy = rr::createFunction("coroutine_destroy", voidTy, { handleTy });
 	jit->coroutine.yieldType = promiseTy;
 	jit->coroutine.entryBlock = llvm::BasicBlock::Create(jit->context, "function", jit->function);
 
 	jit->builder->SetInsertPoint(jit->coroutine.entryBlock);
 }
 
-void Nucleus::yield(Value* val)
+void Nucleus::yield(Value *val)
 {
 	if(jit->coroutine.id == nullptr)
 	{
@@ -4955,9 +5015,9 @@
 	// Store the promise (yield value)
 	jit->builder->CreateStore(V(val), jit->coroutine.promise);
 	auto action = jit->builder->CreateCall(coro_suspend, {
-		::llvm::ConstantTokenNone::get(jit->context),
-		::llvm::ConstantInt::get(i1Ty, 0), // final: true
-	});
+	                                                         ::llvm::ConstantTokenNone::get(jit->context),
+	                                                         ::llvm::ConstantInt::get(i1Ty, 0),  // final: true
+	                                                     });
 	auto switch_ = jit->builder->CreateSwitch(action, jit->coroutine.suspendBlock, 3);
 	switch_->addCase(::llvm::ConstantInt::get(i8Ty, SuspendActionResume), resumeBlock);
 	switch_->addCase(::llvm::ConstantInt::get(i8Ty, SuspendActionDestroy), jit->coroutine.destroyBlock);
@@ -4992,7 +5052,7 @@
 	{
 		jit->debugInfo->Finalize();
 	}
-#endif // ENABLE_RR_DEBUG_INFO
+#endif  // ENABLE_RR_DEBUG_INFO
 
 	if(false)
 	{
@@ -5019,7 +5079,7 @@
 		pm.add(llvm::createVerifierPass());
 		pm.run(*jit->module);
 	}
-#endif // defined(ENABLE_RR_LLVM_IR_VERIFICATION) || !defined(NDEBUG)
+#endif  // defined(ENABLE_RR_LLVM_IR_VERIFICATION) || !defined(NDEBUG)
 
 	auto cfg = cfgEdit.apply(jit->config);
 	jit->optimize(cfg);
@@ -5041,4 +5101,4 @@
 	return routine;
 }
 
-} // namespace rr
\ No newline at end of file
+}  // namespace rr
\ No newline at end of file
diff --git a/src/Reactor/LLVMReactor.hpp b/src/Reactor/LLVMReactor.hpp
index bbf3332..0b91ef8 100644
--- a/src/Reactor/LLVMReactor.hpp
+++ b/src/Reactor/LLVMReactor.hpp
@@ -31,17 +31,17 @@
 
 inline Type *T(llvm::Type *t)
 {
-	return reinterpret_cast<Type*>(t);
+	return reinterpret_cast<Type *>(t);
 }
 
 inline llvm::Value *V(Value *t)
 {
-	return reinterpret_cast<llvm::Value*>(t);
+	return reinterpret_cast<llvm::Value *>(t);
 }
 
 inline Value *V(llvm::Value *t)
 {
-	return reinterpret_cast<Value*>(t);
+	return reinterpret_cast<Value *>(t);
 }
 
 // Emits a no-op instruction that will not be optimized away.
@@ -51,4 +51,4 @@
 
 }  // namespace rr
 
-#endif // rr_LLVMReactor_hpp
+#endif  // rr_LLVMReactor_hpp
diff --git a/src/Reactor/LLVMReactorDebugInfo.cpp b/src/Reactor/LLVMReactorDebugInfo.cpp
index db97080..0cf4723 100644
--- a/src/Reactor/LLVMReactorDebugInfo.cpp
+++ b/src/Reactor/LLVMReactorDebugInfo.cpp
@@ -16,52 +16,55 @@
 
 #ifdef ENABLE_RR_DEBUG_INFO
 
-#include "Reactor.hpp"
-#include "LLVMReactor.hpp"
+#	include "LLVMReactor.hpp"
+#	include "Reactor.hpp"
 
-#include "boost/stacktrace.hpp"
+#	include "boost/stacktrace.hpp"
 
-#include "llvm/Demangle/Demangle.h"
-#include "llvm/ExecutionEngine/JITEventListener.h"
-#include "llvm/IR/DIBuilder.h"
-#include "llvm/IR/Intrinsics.h"
-#include "llvm/IR/IRBuilder.h"
+#	include "llvm/Demangle/Demangle.h"
+#	include "llvm/ExecutionEngine/JITEventListener.h"
+#	include "llvm/IR/DIBuilder.h"
+#	include "llvm/IR/IRBuilder.h"
+#	include "llvm/IR/Intrinsics.h"
 
-#include <cctype>
-#include <fstream>
-#include <mutex>
-#include <regex>
-#include <sstream>
-#include <string>
+#	include <cctype>
+#	include <fstream>
+#	include <mutex>
+#	include <regex>
+#	include <sstream>
+#	include <string>
 
-#if 0
-#define LOG(msg, ...) printf(msg "\n", ##__VA_ARGS__)
-#else
-#define LOG(msg, ...)
-#endif
+#	if 0
+#		define LOG(msg, ...) printf(msg "\n", ##__VA_ARGS__)
+#	else
+#		define LOG(msg, ...)
+#	endif
 
 namespace {
 
-std::pair<llvm::StringRef, llvm::StringRef> splitPath(const char* path)
+std::pair<llvm::StringRef, llvm::StringRef> splitPath(const char *path)
 {
 	return llvm::StringRef(path).rsplit('/');
 }
 
 // Note: createGDBRegistrationListener() returns a pointer to a singleton.
 // Nothing is actually created.
-auto jitEventListener = llvm::JITEventListener::createGDBRegistrationListener(); // guarded by jitEventListenerMutex
+auto jitEventListener = llvm::JITEventListener::createGDBRegistrationListener();  // guarded by jitEventListenerMutex
 std::mutex jitEventListenerMutex;
 
-}  // anonymous namespaces
+}  // namespace
 
 namespace rr {
 
 DebugInfo::DebugInfo(
-		llvm::IRBuilder<> *builder,
-		llvm::LLVMContext *context,
-		llvm::Module *module,
-		llvm::Function *function)
-	: builder(builder), context(context), module(module), function(function)
+    llvm::IRBuilder<> *builder,
+    llvm::LLVMContext *context,
+    llvm::Module *module,
+    llvm::Function *function)
+    : builder(builder)
+    , context(context)
+    , module(module)
+    , function(function)
 {
 	using namespace ::llvm;
 
@@ -70,10 +73,10 @@
 	auto fileAndDir = splitPath(location.function.file.c_str());
 	diBuilder.reset(new llvm::DIBuilder(*module));
 	diCU = diBuilder->createCompileUnit(
-		llvm::dwarf::DW_LANG_C,
-		diBuilder->createFile(fileAndDir.first, fileAndDir.second),
-		"Reactor",
-		0, "", 0);
+	    llvm::dwarf::DW_LANG_C,
+	    diBuilder->createFile(fileAndDir.first, fileAndDir.second),
+	    "Reactor",
+	    0, "", 0);
 
 	registerBasicTypes();
 
@@ -82,17 +85,17 @@
 
 	auto file = getOrCreateFile(location.function.file.c_str());
 	auto sp = diBuilder->createFunction(
-		file,                   // scope
-		"ReactorFunction",      // function name
-		"ReactorFunction",      // linkage
-		file,                   // file
-		location.line,          // line
-		funcTy,                 // type
-		false,                  // internal linkage
-		true,                   // definition
-		location.line,          // scope line
-		DINode::FlagPrototyped, // flags
-		false                   // is optimized
+	    file,                    // scope
+	    "ReactorFunction",       // function name
+	    "ReactorFunction",       // linkage
+	    file,                    // file
+	    location.line,           // line
+	    funcTy,                  // type
+	    false,                   // internal linkage
+	    true,                    // definition
+	    location.line,           // scope line
+	    DINode::FlagPrototyped,  // flags
+	    false                    // is optimized
 	);
 	diSubprogram = sp;
 	function->setSubprogram(sp);
@@ -114,11 +117,11 @@
 
 void DebugInfo::EmitLocation()
 {
-	auto const& backtrace = getCallerBacktrace();
+	auto const &backtrace = getCallerBacktrace();
 	syncScope(backtrace);
 	builder->SetCurrentDebugLocation(getLocation(backtrace, backtrace.size() - 1));
 
-#ifdef ENABLE_RR_EMIT_PRINT_LOCATION
+#	ifdef ENABLE_RR_EMIT_PRINT_LOCATION
 	static Location lastLocation;
 	if(backtrace.size() == 0)
 	{
@@ -130,7 +133,7 @@
 		rr::Print("rr> {0} [{1}:{2}]\n", currLocation.function.name.c_str(), currLocation.function.file.c_str(), currLocation.line);
 		lastLocation = std::move(currLocation);
 	}
-#endif // ENABLE_RR_EMIT_PRINT_LOCATION
+#	endif  // ENABLE_RR_EMIT_PRINT_LOCATION
 }
 
 void DebugInfo::Flush()
@@ -138,17 +141,16 @@
 	emitPending(diScope.back(), builder);
 }
 
-void DebugInfo::syncScope(Backtrace const& backtrace)
+void DebugInfo::syncScope(Backtrace const &backtrace)
 {
-	auto shrink = [this](size_t newsize)
-	{
+	auto shrink = [this](size_t newsize) {
 		while(diScope.size() > newsize)
 		{
 			auto &scope = diScope.back();
 			LOG("- STACK(%d): di: %p, location: %s:%d",
-				int(diScope.size() - 1), scope.di,
-				scope.location.function.file.c_str(),
-				int(scope.location.line));
+			    int(diScope.size() - 1), scope.di,
+			    scope.location.function.file.c_str(),
+			    int(scope.location.line));
 			emitPending(scope, builder);
 			diScope.pop_back();
 		}
@@ -168,7 +170,7 @@
 		if(oldLocation.function != newLocation.function)
 		{
 			LOG("  STACK(%d): Changed function %s -> %s", int(i),
-				oldLocation.function.name.c_str(), newLocation.function.name.c_str());
+			    oldLocation.function.name.c_str(), newLocation.function.name.c_str());
 			shrink(i);
 			break;
 		}
@@ -179,10 +181,10 @@
 			auto file = getOrCreateFile(newLocation.function.file.c_str());
 			auto di = diBuilder->createLexicalBlock(scope.di, file, newLocation.line, 0);
 			LOG("  STACK(%d): Jumped backwards %d -> %d. di: %p -> %p", int(i),
-				oldLocation.line, newLocation.line, scope.di, di);
+			    oldLocation.line, newLocation.line, scope.di, di);
 			emitPending(scope, builder);
-			scope = {newLocation, di};
-			shrink(i+1);
+			scope = { newLocation, di };
+			shrink(i + 1);
 			break;
 		}
 
@@ -203,40 +205,39 @@
 		auto name = "jit!" + (status == 0 ? std::string(buf) : location.function.name);
 
 		auto func = diBuilder->createFunction(
-			file,                           // scope
-			name,                           // function name
-			"",                             // linkage
-			file,                           // file
-			location.line,                  // line
-			funcTy,                         // type
-			false,                          // internal linkage
-			true,                           // definition
-			location.line,                  // scope line
-			llvm::DINode::FlagPrototyped,   // flags
-			false                           // is optimized
+		    file,                          // scope
+		    name,                          // function name
+		    "",                            // linkage
+		    file,                          // file
+		    location.line,                 // line
+		    funcTy,                        // type
+		    false,                         // internal linkage
+		    true,                          // definition
+		    location.line,                 // scope line
+		    llvm::DINode::FlagPrototyped,  // flags
+		    false                          // is optimized
 		);
-		diScope.push_back({location, func});
+		diScope.push_back({ location, func });
 		LOG("+ STACK(%d): di: %p, location: %s:%d", int(i), di,
-			location.function.file.c_str(), int(location.line));
+		    location.function.file.c_str(), int(location.line));
 	}
 }
 
-llvm::DILocation* DebugInfo::getLocation(const Backtrace &backtrace, size_t i)
+llvm::DILocation *DebugInfo::getLocation(const Backtrace &backtrace, size_t i)
 {
 	if(backtrace.size() == 0) { return nullptr; }
 	assert(backtrace.size() == diScope.size());
 	return llvm::DILocation::get(
-		*context,
-		backtrace[i].line,
-		0,
-		diScope[i].di,
-		i > 0 ? getLocation(backtrace, i - 1) : diRootLocation
-	);
+	    *context,
+	    backtrace[i].line,
+	    0,
+	    diScope[i].di,
+	    i > 0 ? getLocation(backtrace, i - 1) : diRootLocation);
 }
 
 void DebugInfo::EmitVariable(Value *variable)
 {
-	auto const& backtrace = getCallerBacktrace();
+	auto const &backtrace = getCallerBacktrace();
 	syncScope(backtrace);
 
 	for(int i = backtrace.size() - 1; i >= 0; i--)
@@ -321,7 +322,7 @@
 	bool isAlloca = llvm::isa<llvm::AllocaInst>(pending.value);
 
 	LOG("  EMIT(%s): di: %p, location: %s:%d, isAlloca: %s", pending.name.c_str(), scope.di,
-		pending.location.function.file.c_str(), pending.location.line, isAlloca ? "true" : "false");
+	    pending.location.function.file.c_str(), pending.location.line, isAlloca ? "true" : "false");
 
 	auto value = pending.value;
 
@@ -367,12 +368,11 @@
 	if(pending.addNopOnNextLine)
 	{
 		builder->SetCurrentDebugLocation(llvm::DILocation::get(
-			*context,
-			pending.diLocation->getLine() + 1,
-			0,
-			pending.diLocation->getScope(),
-			pending.diLocation->getInlinedAt()
-		));
+		    *context,
+		    pending.diLocation->getLine() + 1,
+		    0,
+		    pending.diLocation->getScope(),
+		    pending.diLocation->getInlinedAt()));
 		Nop();
 	}
 
@@ -382,7 +382,7 @@
 void DebugInfo::NotifyObjectEmitted(const llvm::object::ObjectFile &Obj, const llvm::LoadedObjectInfo &L)
 {
 	std::unique_lock<std::mutex> lock(jitEventListenerMutex);
-	jitEventListener->NotifyObjectEmitted(Obj, static_cast<const llvm::RuntimeDyld::LoadedObjectInfo&>(L));
+	jitEventListener->NotifyObjectEmitted(Obj, static_cast<const llvm::RuntimeDyld::LoadedObjectInfo &>(L));
 }
 
 void DebugInfo::NotifyFreeingObject(const llvm::object::ObjectFile &Obj)
@@ -411,24 +411,24 @@
 	diTypes.emplace(T(Half::getType()), diBuilder->createBasicType("Half", 16, dwarf::DW_ATE_float));
 	diTypes.emplace(T(Float::getType()), diBuilder->createBasicType("Float", 32, dwarf::DW_ATE_float));
 
-	diTypes.emplace(T(Byte4::getType()), diBuilder->createVectorType(128, 128, diTypes[T(Byte::getType())], {vec16}));
-	diTypes.emplace(T(SByte4::getType()), diBuilder->createVectorType(128, 128, diTypes[T(SByte::getType())], {vec16}));
-	diTypes.emplace(T(Byte8::getType()), diBuilder->createVectorType(128, 128, diTypes[T(Byte::getType())], {vec16}));
-	diTypes.emplace(T(SByte8::getType()), diBuilder->createVectorType(128, 128, diTypes[T(SByte::getType())], {vec16}));
-	diTypes.emplace(T(Byte16::getType()), diBuilder->createVectorType(128, 128, diTypes[T(Byte::getType())], {vec16}));
-	diTypes.emplace(T(SByte16::getType()), diBuilder->createVectorType(128, 128, diTypes[T(SByte::getType())], {vec16}));
-	diTypes.emplace(T(Short2::getType()), diBuilder->createVectorType(128, 128, diTypes[T(Short::getType())], {vec8}));
-	diTypes.emplace(T(UShort2::getType()), diBuilder->createVectorType(128, 128, diTypes[T(UShort::getType())], {vec8}));
-	diTypes.emplace(T(Short4::getType()), diBuilder->createVectorType(128, 128, diTypes[T(Short::getType())], {vec8}));
-	diTypes.emplace(T(UShort4::getType()), diBuilder->createVectorType(128, 128, diTypes[T(UShort::getType())], {vec8}));
-	diTypes.emplace(T(Short8::getType()), diBuilder->createVectorType(128, 128, diTypes[T(Short::getType())], {vec8}));
-	diTypes.emplace(T(UShort8::getType()), diBuilder->createVectorType(128, 128, diTypes[T(UShort::getType())], {vec8}));
-	diTypes.emplace(T(Int2::getType()), diBuilder->createVectorType(128, 128, diTypes[T(Int::getType())], {vec4}));
-	diTypes.emplace(T(UInt2::getType()), diBuilder->createVectorType(128, 128, diTypes[T(UInt::getType())], {vec4}));
-	diTypes.emplace(T(Int4::getType()), diBuilder->createVectorType(128, 128, diTypes[T(Int::getType())], {vec4}));
-	diTypes.emplace(T(UInt4::getType()), diBuilder->createVectorType(128, 128, diTypes[T(UInt::getType())], {vec4}));
-	diTypes.emplace(T(Float2::getType()), diBuilder->createVectorType(128, 128, diTypes[T(Float::getType())], {vec4}));
-	diTypes.emplace(T(Float4::getType()), diBuilder->createVectorType(128, 128, diTypes[T(Float::getType())], {vec4}));
+	diTypes.emplace(T(Byte4::getType()), diBuilder->createVectorType(128, 128, diTypes[T(Byte::getType())], { vec16 }));
+	diTypes.emplace(T(SByte4::getType()), diBuilder->createVectorType(128, 128, diTypes[T(SByte::getType())], { vec16 }));
+	diTypes.emplace(T(Byte8::getType()), diBuilder->createVectorType(128, 128, diTypes[T(Byte::getType())], { vec16 }));
+	diTypes.emplace(T(SByte8::getType()), diBuilder->createVectorType(128, 128, diTypes[T(SByte::getType())], { vec16 }));
+	diTypes.emplace(T(Byte16::getType()), diBuilder->createVectorType(128, 128, diTypes[T(Byte::getType())], { vec16 }));
+	diTypes.emplace(T(SByte16::getType()), diBuilder->createVectorType(128, 128, diTypes[T(SByte::getType())], { vec16 }));
+	diTypes.emplace(T(Short2::getType()), diBuilder->createVectorType(128, 128, diTypes[T(Short::getType())], { vec8 }));
+	diTypes.emplace(T(UShort2::getType()), diBuilder->createVectorType(128, 128, diTypes[T(UShort::getType())], { vec8 }));
+	diTypes.emplace(T(Short4::getType()), diBuilder->createVectorType(128, 128, diTypes[T(Short::getType())], { vec8 }));
+	diTypes.emplace(T(UShort4::getType()), diBuilder->createVectorType(128, 128, diTypes[T(UShort::getType())], { vec8 }));
+	diTypes.emplace(T(Short8::getType()), diBuilder->createVectorType(128, 128, diTypes[T(Short::getType())], { vec8 }));
+	diTypes.emplace(T(UShort8::getType()), diBuilder->createVectorType(128, 128, diTypes[T(UShort::getType())], { vec8 }));
+	diTypes.emplace(T(Int2::getType()), diBuilder->createVectorType(128, 128, diTypes[T(Int::getType())], { vec4 }));
+	diTypes.emplace(T(UInt2::getType()), diBuilder->createVectorType(128, 128, diTypes[T(UInt::getType())], { vec4 }));
+	diTypes.emplace(T(Int4::getType()), diBuilder->createVectorType(128, 128, diTypes[T(Int::getType())], { vec4 }));
+	diTypes.emplace(T(UInt4::getType()), diBuilder->createVectorType(128, 128, diTypes[T(UInt::getType())], { vec4 }));
+	diTypes.emplace(T(Float2::getType()), diBuilder->createVectorType(128, 128, diTypes[T(Float::getType())], { vec4 }));
+	diTypes.emplace(T(Float4::getType()), diBuilder->createVectorType(128, 128, diTypes[T(Float::getType())], { vec4 }));
 }
 
 DebugInfo::Location DebugInfo::getCallerLocation() const
@@ -439,11 +439,11 @@
 DebugInfo::Backtrace DebugInfo::getCallerBacktrace(size_t limit /* = 0 */) const
 {
 	auto shouldSkipFile = [](llvm::StringRef fileSR) {
-			return fileSR.empty() ||
-				fileSR.endswith_lower("ReactorDebugInfo.cpp") ||
-				fileSR.endswith_lower("Reactor.cpp") ||
-				fileSR.endswith_lower("Reactor.hpp") ||
-				fileSR.endswith_lower("stacktrace.hpp");
+		return fileSR.empty() ||
+		       fileSR.endswith_lower("ReactorDebugInfo.cpp") ||
+		       fileSR.endswith_lower("Reactor.cpp") ||
+		       fileSR.endswith_lower("Reactor.hpp") ||
+		       fileSR.endswith_lower("stacktrace.hpp");
 	};
 
 	std::vector<DebugInfo::Location> locations;
@@ -475,7 +475,7 @@
 	return locations;
 }
 
-llvm::DIType *DebugInfo::getOrCreateType(llvm::Type* type)
+llvm::DIType *DebugInfo::getOrCreateType(llvm::Type *type)
 {
 	auto it = diTypes.find(type);
 	if(it != diTypes.end()) { return it->second; }
@@ -483,8 +483,8 @@
 	if(type->isPointerTy())
 	{
 		auto dbgTy = diBuilder->createPointerType(
-			getOrCreateType(type->getPointerElementType()),
-			sizeof(void*)*8, alignof(void*)*8);
+		    getOrCreateType(type->getPointerElementType()),
+		    sizeof(void *) * 8, alignof(void *) * 8);
 		diTypes.emplace(type, dbgTy);
 		return dbgTy;
 	}
@@ -493,7 +493,7 @@
 	return nullptr;
 }
 
-llvm::DIFile *DebugInfo::getOrCreateFile(const char* path)
+llvm::DIFile *DebugInfo::getOrCreateFile(const char *path)
 {
 	auto it = diFiles.find(path);
 	if(it != diFiles.end()) { return it->second; }
@@ -503,17 +503,17 @@
 	return file;
 }
 
-DebugInfo::LineTokens const *DebugInfo::getOrParseFileTokens(const char* path)
+DebugInfo::LineTokens const *DebugInfo::getOrParseFileTokens(const char *path)
 {
 	static std::regex reLocalDecl(
-		"^" // line start
-		"\\s*" // initial whitespace
-		"(?:For\\s*\\(\\s*)?" // optional 'For('
-		"((?:\\w+(?:<[^>]+>)?)(?:::\\w+(?:<[^>]+>)?)*)" // type (match group 1)
-		"\\s+" // whitespace between type and name
-		"(\\w+)" // identifier (match group 2)
-		"\\s*" // whitespace after identifier
-		"(\\[.*\\])?"); // optional array suffix (match group 3)
+	    "^"                                              // line start
+	    "\\s*"                                           // initial whitespace
+	    "(?:For\\s*\\(\\s*)?"                            // optional 'For('
+	    "((?:\\w+(?:<[^>]+>)?)(?:::\\w+(?:<[^>]+>)?)*)"  // type (match group 1)
+	    "\\s+"                                           // whitespace between type and name
+	    "(\\w+)"                                         // identifier (match group 2)
+	    "\\s*"                                           // whitespace after identifier
+	    "(\\[.*\\])?");                                  // optional array suffix (match group 3)
 
 	auto it = fileTokens.find(path);
 	if(it != fileTokens.end())
@@ -533,15 +533,15 @@
 		if(std::regex_search(line, match, reLocalDecl) && match.size() > 3)
 		{
 			bool isArray = match.str(3) != "";
-			if(!isArray) // Cannot deal with C-arrays of values.
+			if(!isArray)  // Cannot deal with C-arrays of values.
 			{
 				if(match.str(1) == "return")
 				{
-					(*tokens)[lineCount] = Token{Token::Return};
+					(*tokens)[lineCount] = Token{ Token::Return };
 				}
 				else
 				{
-					(*tokens)[lineCount] = Token{Token::Identifier, match.str(2)};
+					(*tokens)[lineCount] = Token{ Token::Identifier, match.str(2) };
 				}
 			}
 		}
@@ -554,4 +554,4 @@
 
 }  // namespace rr
 
-#endif // ENABLE_RR_DEBUG_INFO
+#endif  // ENABLE_RR_DEBUG_INFO
diff --git a/src/Reactor/LLVMReactorDebugInfo.hpp b/src/Reactor/LLVMReactorDebugInfo.hpp
index f97e3d0..6f320aa 100644
--- a/src/Reactor/LLVMReactorDebugInfo.hpp
+++ b/src/Reactor/LLVMReactorDebugInfo.hpp
@@ -19,10 +19,10 @@
 
 #ifdef ENABLE_RR_DEBUG_INFO
 
-#include <unordered_set>
-#include <unordered_map>
-#include <vector>
-#include <memory>
+#	include <memory>
+#	include <unordered_map>
+#	include <unordered_set>
+#	include <vector>
 
 // Forward declarations
 namespace llvm {
@@ -46,12 +46,12 @@
 class Type;
 class Value;
 
-namespace object
-{
-	class ObjectFile;
+namespace object {
+class ObjectFile;
 }
 
-template <typename T, typename Inserter> class IRBuilder;
+template<typename T, typename Inserter>
+class IRBuilder;
 
 }  // namespace llvm
 
@@ -68,9 +68,9 @@
 	using IRBuilder = llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>;
 
 	DebugInfo(IRBuilder *builder,
-			llvm::LLVMContext *context,
-			llvm::Module *module,
-			llvm::Function *function);
+	          llvm::LLVMContext *context,
+	          llvm::Module *module,
+	          llvm::Function *function);
 
 	~DebugInfo();
 
@@ -116,15 +116,15 @@
 		std::string name;
 		std::string file;
 
-		bool operator == (const FunctionLocation &rhs) const { return name == rhs.name && file == rhs.file; }
-		bool operator != (const FunctionLocation &rhs) const { return !(*this == rhs); }
+		bool operator==(const FunctionLocation &rhs) const { return name == rhs.name && file == rhs.file; }
+		bool operator!=(const FunctionLocation &rhs) const { return !(*this == rhs); }
 
 		struct Hash
 		{
 			std::size_t operator()(const FunctionLocation &l) const noexcept
 			{
 				return std::hash<std::string>()(l.file) * 31 +
-						std::hash<std::string>()(l.name);
+				       std::hash<std::string>()(l.name);
 			}
 		};
 	};
@@ -134,15 +134,15 @@
 		FunctionLocation function;
 		unsigned int line = 0;
 
-		bool operator == (const Location &rhs) const { return function == rhs.function && line == rhs.line; }
-		bool operator != (const Location &rhs) const { return !(*this == rhs); }
+		bool operator==(const Location &rhs) const { return function == rhs.function && line == rhs.line; }
+		bool operator!=(const Location &rhs) const { return !(*this == rhs); }
 
 		struct Hash
 		{
 			std::size_t operator()(const Location &l) const noexcept
 			{
 				return FunctionLocation::Hash()(l.function) * 31 +
-						std::hash<unsigned int>()(l.line);
+				       std::hash<unsigned int>()(l.line);
 			}
 		};
 	};
@@ -181,14 +181,14 @@
 	// frames will be returned.
 	Backtrace getCallerBacktrace(size_t limit = 0) const;
 
-	llvm::DILocation* getLocation(const Backtrace &backtrace, size_t i);
+	llvm::DILocation *getLocation(const Backtrace &backtrace, size_t i);
 
-	llvm::DIType *getOrCreateType(llvm::Type* type);
-	llvm::DIFile *getOrCreateFile(const char* path);
-	LineTokens const *getOrParseFileTokens(const char* path);
+	llvm::DIType *getOrCreateType(llvm::Type *type);
+	llvm::DIFile *getOrCreateFile(const char *path);
+	LineTokens const *getOrParseFileTokens(const char *path);
 
 	// Synchronizes diScope with the current backtrace.
-	void syncScope(Backtrace const& backtrace);
+	void syncScope(Backtrace const &backtrace);
 
 	IRBuilder *builder;
 	llvm::LLVMContext *context;
@@ -200,14 +200,14 @@
 	llvm::DISubprogram *diSubprogram;
 	llvm::DILocation *diRootLocation;
 	std::vector<Scope> diScope;
-	std::unordered_map<std::string, llvm::DIFile*> diFiles;
-	std::unordered_map<llvm::Type*, llvm::DIType*> diTypes;
+	std::unordered_map<std::string, llvm::DIFile *> diFiles;
+	std::unordered_map<llvm::Type *, llvm::DIType *> diTypes;
 	std::unordered_map<std::string, std::unique_ptr<LineTokens>> fileTokens;
-	std::vector<void const*> pushed;
+	std::vector<void const *> pushed;
 };
 
 }  // namespace rr
 
-#endif // ENABLE_RR_DEBUG_INFO
+#endif  // ENABLE_RR_DEBUG_INFO
 
-#endif // rr_LLVMReactorDebugInfo_hpp
+#endif  // rr_LLVMReactorDebugInfo_hpp
diff --git a/src/Reactor/MutexLock.hpp b/src/Reactor/MutexLock.hpp
index 000819a..94b37f0 100644
--- a/src/Reactor/MutexLock.hpp
+++ b/src/Reactor/MutexLock.hpp
@@ -20,7 +20,7 @@
 #if defined(__linux__)
 // Use a pthread mutex on Linux. Since many processes may use Reactor
 // at the same time it's best to just have the scheduler overhead.
-#include <pthread.h>
+#	include <pthread.h>
 
 namespace rr {
 
@@ -58,9 +58,9 @@
 
 }  // namespace rr
 
-#else   // !__linux__
+#else  // !__linux__
 
-#include <atomic>
+#	include <atomic>
 
 namespace rr {
 
@@ -174,6 +174,6 @@
 
 }  // namespace rr
 
-#endif   // !__linux__
+#endif  // !__linux__
 
-#endif   // rr_MutexLock_hpp
+#endif  // rr_MutexLock_hpp
diff --git a/src/Reactor/Nucleus.hpp b/src/Reactor/Nucleus.hpp
index 67e990f..4239973 100644
--- a/src/Reactor/Nucleus.hpp
+++ b/src/Reactor/Nucleus.hpp
@@ -23,7 +23,7 @@
 #include <vector>
 
 #ifdef None
-#undef None  // TODO(b/127920555)
+#	undef None  // TODO(b/127920555)
 #endif
 
 static_assert(sizeof(short) == 2, "Reactor's 'Short' type is 16-bit, and requires the C++ 'short' to match that.");
@@ -68,18 +68,19 @@
 
 	using Passes = std::vector<Pass>;
 
-	Optimization(Level level = Level::Default, const Passes& passes = {})
-		: level(level), passes(passes)
+	Optimization(Level level = Level::Default, const Passes &passes = {})
+	    : level(level)
+	    , passes(passes)
 	{
-		#if defined(REACTOR_DEFAULT_OPT_LEVEL)
+#if defined(REACTOR_DEFAULT_OPT_LEVEL)
 		{
 			this->level = Level::REACTOR_DEFAULT_OPT_LEVEL;
 		}
-		#endif
+#endif
 	}
 
 	Level getLevel() const { return level; }
-	const Passes & getPasses() const { return passes; }
+	const Passes &getPasses() const { return passes; }
 
 private:
 	Level level = Level::Default;
@@ -98,19 +99,41 @@
 	public:
 		static const Edit None;
 
-		Edit & set(Optimization::Level level) { optLevel = level; optLevelChanged = true; return *this; }
-		Edit & add(Optimization::Pass pass) { optPassEdits.push_back({ListEdit::Add, pass}); return *this; }
-		Edit & remove(Optimization::Pass pass) { optPassEdits.push_back({ListEdit::Remove, pass}); return *this; }
-		Edit & clearOptimizationPasses() { optPassEdits.push_back({ListEdit::Clear, Optimization::Pass::Disabled}); return *this; }
+		Edit &set(Optimization::Level level)
+		{
+			optLevel = level;
+			optLevelChanged = true;
+			return *this;
+		}
+		Edit &add(Optimization::Pass pass)
+		{
+			optPassEdits.push_back({ ListEdit::Add, pass });
+			return *this;
+		}
+		Edit &remove(Optimization::Pass pass)
+		{
+			optPassEdits.push_back({ ListEdit::Remove, pass });
+			return *this;
+		}
+		Edit &clearOptimizationPasses()
+		{
+			optPassEdits.push_back({ ListEdit::Clear, Optimization::Pass::Disabled });
+			return *this;
+		}
 
 		Config apply(const Config &cfg) const;
 
 	private:
-		enum class ListEdit { Add, Remove, Clear };
+		enum class ListEdit
+		{
+			Add,
+			Remove,
+			Clear
+		};
 		using OptPassesEdit = std::pair<ListEdit, Optimization::Pass>;
 
-		template <typename T>
-		void apply(const std::vector<std::pair<ListEdit, T>> & edits, std::vector<T>& list) const;
+		template<typename T>
+		void apply(const std::vector<std::pair<ListEdit, T>> &edits, std::vector<T> &list) const;
 
 		Optimization::Level optLevel;
 		bool optLevelChanged = false;
@@ -118,9 +141,11 @@
 	};
 
 	Config() = default;
-	Config(const Optimization & optimization) : optimization(optimization) {}
+	Config(const Optimization &optimization)
+	    : optimization(optimization)
+	{}
 
-	const Optimization & getOptimization() const { return optimization; }
+	const Optimization &getOptimization() const { return optimization; }
 
 private:
 	Optimization optimization;
@@ -146,15 +171,15 @@
 	static BasicBlock *getInsertBlock();
 	static void setInsertBlock(BasicBlock *basicBlock);
 
-	static void createFunction(Type *ReturnType, std::vector<Type*> &Params);
+	static void createFunction(Type *ReturnType, std::vector<Type *> &Params);
 	static Value *getArgument(unsigned int index);
 
 	// Coroutines
-	using CoroutineHandle = void*;
+	using CoroutineHandle = void *;
 
-	template <typename... ARGS>
+	template<typename... ARGS>
 	using CoroutineBegin = CoroutineHandle(ARGS...);
-	using CoroutineAwait = bool(CoroutineHandle, void* yieldValue);
+	using CoroutineAwait = bool(CoroutineHandle, void *yieldValue);
 	using CoroutineDestroy = void(CoroutineHandle);
 
 	enum CoroutineEntries
@@ -165,9 +190,9 @@
 		CoroutineEntryCount
 	};
 
-	static void createCoroutine(Type *ReturnType, std::vector<Type*> &Params);
+	static void createCoroutine(Type *ReturnType, std::vector<Type *> &Params);
 	std::shared_ptr<Routine> acquireCoroutine(const char *name, const Config::Edit &cfg = Config::Edit::None);
-	static void yield(Value*);
+	static void yield(Value *);
 
 	// Terminators
 	static void createRetVoid();
@@ -201,7 +226,7 @@
 	static Value *createNot(Value *V);
 
 	// Memory instructions
-	static Value *createLoad(Value *ptr, Type *type, bool isVolatile = false, unsigned int alignment = 0, bool atomic = false , std::memory_order memoryOrder = std::memory_order_relaxed);
+	static Value *createLoad(Value *ptr, Type *type, bool isVolatile = false, unsigned int alignment = 0, bool atomic = false, std::memory_order memoryOrder = std::memory_order_relaxed);
 	static Value *createStore(Value *value, Value *ptr, Type *type, bool isVolatile = false, unsigned int aligment = 0, bool atomic = false, std::memory_order memoryOrder = std::memory_order_relaxed);
 	static Value *createGEP(Value *ptr, Type *type, Value *index, bool unsignedIndex);
 
@@ -294,4 +319,4 @@
 
 }  // namespace rr
 
-#endif   // rr_Nucleus_hpp
+#endif  // rr_Nucleus_hpp
diff --git a/src/Reactor/Optimizer.cpp b/src/Reactor/Optimizer.cpp
index 8b74f82..86cface 100644
--- a/src/Reactor/Optimizer.cpp
+++ b/src/Reactor/Optimizer.cpp
@@ -50,45 +50,45 @@
 	Ice::Cfg *function;
 	Ice::GlobalContext *context;
 
-	struct Uses : std::vector<Ice::Inst*>
+	struct Uses : std::vector<Ice::Inst *>
 	{
 		bool areOnlyLoadStore() const;
 		void insert(Ice::Operand *value, Ice::Inst *instruction);
 		void erase(Ice::Inst *instruction);
 
-		std::vector<Ice::Inst*> loads;
-		std::vector<Ice::Inst*> stores;
+		std::vector<Ice::Inst *> loads;
+		std::vector<Ice::Inst *> stores;
 	};
 
 	struct LoadStoreInst
 	{
-		LoadStoreInst(Ice::Inst* inst, bool isStore)
-		  : inst(inst),
-		    address(isStore ? storeAddress(inst) : loadAddress(inst)),
-		    isStore(isStore)
+		LoadStoreInst(Ice::Inst *inst, bool isStore)
+		    : inst(inst)
+		    , address(isStore ? storeAddress(inst) : loadAddress(inst))
+		    , isStore(isStore)
 		{
 		}
 
-		Ice::Inst* inst;
+		Ice::Inst *inst;
 		Ice::Operand *address;
 		bool isStore;
 	};
 
-	Optimizer::Uses* getUses(Ice::Operand*);
-	void setUses(Ice::Operand*, Optimizer::Uses*);
-	bool hasUses(Ice::Operand*) const;
+	Optimizer::Uses *getUses(Ice::Operand *);
+	void setUses(Ice::Operand *, Optimizer::Uses *);
+	bool hasUses(Ice::Operand *) const;
 
-	Ice::CfgNode* getNode(Ice::Inst*);
-	void setNode(Ice::Inst*, Ice::CfgNode*);
+	Ice::CfgNode *getNode(Ice::Inst *);
+	void setNode(Ice::Inst *, Ice::CfgNode *);
 
-	Ice::Inst* getDefinition(Ice::Variable*);
-	void setDefinition(Ice::Variable*, Ice::Inst*);
+	Ice::Inst *getDefinition(Ice::Variable *);
+	void setDefinition(Ice::Variable *, Ice::Inst *);
 
-	const std::vector<LoadStoreInst>& getLoadStoreInsts(Ice::CfgNode*);
-	void setLoadStoreInsts(Ice::CfgNode*, std::vector<LoadStoreInst>*);
-	bool hasLoadStoreInsts(Ice::CfgNode* node) const;
+	const std::vector<LoadStoreInst> &getLoadStoreInsts(Ice::CfgNode *);
+	void setLoadStoreInsts(Ice::CfgNode *, std::vector<LoadStoreInst> *);
+	bool hasLoadStoreInsts(Ice::CfgNode *node) const;
 
-	std::vector<Optimizer::Uses*> allocatedUses;
+	std::vector<Optimizer::Uses *> allocatedUses;
 };
 
 void Optimizer::run(Ice::Cfg *function)
@@ -133,8 +133,7 @@
 				}
 			}
 		}
-	}
-	while(modified);
+	} while(modified);
 }
 
 void Optimizer::eliminateUnitializedLoads()
@@ -150,7 +149,7 @@
 
 		if(!llvm::isa<Ice::InstAlloca>(alloca))
 		{
-			break;   // Allocas are all at the top
+			break;  // Allocas are all at the top
 		}
 
 		Ice::Operand *address = alloca.getDest();
@@ -213,7 +212,7 @@
 
 		if(!llvm::isa<Ice::InstAlloca>(alloca))
 		{
-			break;   // Allocas are all at the top
+			break;  // Allocas are all at the top
 		}
 
 		Ice::Operand *address = alloca.getDest();
@@ -313,7 +312,7 @@
 {
 	Ice::CfgNode *entryBlock = function->getEntryNode();
 
-	std::vector<std::vector<LoadStoreInst>* > allocatedVectors;
+	std::vector<std::vector<LoadStoreInst> *> allocatedVectors;
 
 	for(Ice::Inst &alloca : entryBlock->getInsts())
 	{
@@ -324,7 +323,7 @@
 
 		if(!llvm::isa<Ice::InstAlloca>(alloca))
 		{
-			break;   // Allocas are all at the top
+			break;  // Allocas are all at the top
 		}
 
 		Ice::Operand *address = alloca.getDest();
@@ -357,7 +356,7 @@
 		{
 			if(!hasLoadStoreInsts(singleBasicBlock))
 			{
-				std::vector<LoadStoreInst>* loadStoreInstVector = new std::vector<LoadStoreInst>();
+				std::vector<LoadStoreInst> *loadStoreInstVector = new std::vector<LoadStoreInst>();
 				setLoadStoreInsts(singleBasicBlock, loadStoreInstVector);
 				allocatedVectors.push_back(loadStoreInstVector);
 				for(Ice::Inst &inst : singleBasicBlock->getInsts())
@@ -381,9 +380,9 @@
 			Ice::Operand *storeValue = nullptr;
 			bool unmatchedLoads = false;
 
-			for(auto& loadStoreInst : getLoadStoreInsts(singleBasicBlock))
+			for(auto &loadStoreInst : getLoadStoreInsts(singleBasicBlock))
 			{
-				Ice::Inst* inst = loadStoreInst.inst;
+				Ice::Inst *inst = loadStoreInst.inst;
 
 				if((loadStoreInst.address != address) || inst->isDeleted())
 				{
@@ -478,7 +477,7 @@
 	{
 		for(Ice::Inst *use : *getUses(oldValue))
 		{
-			assert(!use->isDeleted());   // Should have been removed from uses already
+			assert(!use->isDeleted());  // Should have been removed from uses already
 
 			for(Ice::SizeT i = 0; i < use->getSrcSize(); i++)
 			{
@@ -547,12 +546,12 @@
 			{
 				if(hasUses(address))
 				{
-					Optimizer::Uses* uses = getUses(address);
-					return uses->size() == uses->stores.size();   // Dead if all uses are stores
+					Optimizer::Uses *uses = getUses(address);
+					return uses->size() == uses->stores.size();  // Dead if all uses are stores
 				}
 				else
 				{
-					return true; // No uses
+					return true;  // No uses
 				}
 			}
 		}
@@ -700,16 +699,16 @@
 			// Check for matching type and sub-vector width.
 			return storeSubVector->getSrc(1)->getType() == loadSubVector->getDest()->getType() &&
 			       llvm::cast<Ice::ConstantInteger32>(storeSubVector->getSrc(3))->getValue() ==
-			       llvm::cast<Ice::ConstantInteger32>(loadSubVector->getSrc(2))->getValue();
+			           llvm::cast<Ice::ConstantInteger32>(loadSubVector->getSrc(2))->getValue();
 		}
 	}
 
 	return false;
 }
 
-Optimizer::Uses* Optimizer::getUses(Ice::Operand* operand)
+Optimizer::Uses *Optimizer::getUses(Ice::Operand *operand)
 {
-	Optimizer::Uses* uses = (Optimizer::Uses*)operand->Ice::Operand::getExternalData();
+	Optimizer::Uses *uses = (Optimizer::Uses *)operand->Ice::Operand::getExternalData();
 	if(!uses)
 	{
 		uses = new Optimizer::Uses;
@@ -719,47 +718,47 @@
 	return uses;
 }
 
-void Optimizer::setUses(Ice::Operand* operand, Optimizer::Uses* uses)
+void Optimizer::setUses(Ice::Operand *operand, Optimizer::Uses *uses)
 {
 	operand->Ice::Operand::setExternalData(uses);
 }
 
-bool Optimizer::hasUses(Ice::Operand* operand) const
+bool Optimizer::hasUses(Ice::Operand *operand) const
 {
 	return operand->Ice::Operand::getExternalData() != nullptr;
 }
 
-Ice::CfgNode* Optimizer::getNode(Ice::Inst* inst)
+Ice::CfgNode *Optimizer::getNode(Ice::Inst *inst)
 {
-	return (Ice::CfgNode*)inst->Ice::Inst::getExternalData();
+	return (Ice::CfgNode *)inst->Ice::Inst::getExternalData();
 }
 
-void Optimizer::setNode(Ice::Inst* inst, Ice::CfgNode* node)
+void Optimizer::setNode(Ice::Inst *inst, Ice::CfgNode *node)
 {
 	inst->Ice::Inst::setExternalData(node);
 }
 
-Ice::Inst* Optimizer::getDefinition(Ice::Variable* var)
+Ice::Inst *Optimizer::getDefinition(Ice::Variable *var)
 {
-	return (Ice::Inst*)var->Ice::Variable::getExternalData();
+	return (Ice::Inst *)var->Ice::Variable::getExternalData();
 }
 
-void Optimizer::setDefinition(Ice::Variable* var, Ice::Inst* inst)
+void Optimizer::setDefinition(Ice::Variable *var, Ice::Inst *inst)
 {
 	var->Ice::Variable::setExternalData(inst);
 }
 
-const std::vector<Optimizer::LoadStoreInst>& Optimizer::getLoadStoreInsts(Ice::CfgNode* node)
+const std::vector<Optimizer::LoadStoreInst> &Optimizer::getLoadStoreInsts(Ice::CfgNode *node)
 {
-	return *((const std::vector<LoadStoreInst>*)node->Ice::CfgNode::getExternalData());
+	return *((const std::vector<LoadStoreInst> *)node->Ice::CfgNode::getExternalData());
 }
 
-void Optimizer::setLoadStoreInsts(Ice::CfgNode* node, std::vector<LoadStoreInst>* insts)
+void Optimizer::setLoadStoreInsts(Ice::CfgNode *node, std::vector<LoadStoreInst> *insts)
 {
 	node->Ice::CfgNode::setExternalData(insts);
 }
 
-bool Optimizer::hasLoadStoreInsts(Ice::CfgNode* node) const
+bool Optimizer::hasLoadStoreInsts(Ice::CfgNode *node) const
 {
 	return node->Ice::CfgNode::getExternalData() != nullptr;
 }
@@ -825,7 +824,7 @@
 	}
 }
 
-}  // anonymous namespace 
+}  // anonymous namespace
 
 namespace rr {
 
diff --git a/src/Reactor/Optimizer.hpp b/src/Reactor/Optimizer.hpp
index 8aa2019..b51c74a 100644
--- a/src/Reactor/Optimizer.hpp
+++ b/src/Reactor/Optimizer.hpp
@@ -23,4 +23,4 @@
 
 }  // namespace rr
 
-#endif   // rr_Optimizer_hpp
+#endif  // rr_Optimizer_hpp
diff --git a/src/Reactor/Print.hpp b/src/Reactor/Print.hpp
index ff4ad81..a0dee69 100644
--- a/src/Reactor/Print.hpp
+++ b/src/Reactor/Print.hpp
@@ -16,15 +16,15 @@
 #define rr_Print_hpp
 
 #if !defined(NDEBUG)
-#define ENABLE_RR_PRINT 1 // Enables RR_PRINT(), RR_WATCH()
-#endif // !defined(NDEBUG)
+#	define ENABLE_RR_PRINT 1  // Enables RR_PRINT(), RR_WATCH()
+#endif                         // !defined(NDEBUG)
 
 #ifdef ENABLE_RR_PRINT
 
-#include "Reactor.hpp"
+#	include "Reactor.hpp"
 
-#include <string>
-#include <vector>
+#	include <string>
+#	include <vector>
 
 namespace rr {
 
@@ -45,16 +45,18 @@
 	//    printf format specifier.
 	//  * A 'static std::vector<rr::Value*> val(const T& v)' method that
 	//    returns all the printf format values.
-	template <typename T> struct Ty
+	template<typename T>
+	struct Ty
 	{
 		// static std::string fmt(const T& v);
 		// static std::vector<rr::Value*> val(const T& v);
 	};
 
 	// returns the printf values for all the values in the given array.
-	template <typename T>
-	static std::vector<Value*> val(const T* list, int count) {
-		std::vector<Value*> values;
+	template<typename T>
+	static std::vector<Value *> val(const T *list, int count)
+	{
+		std::vector<Value *> values;
 		values.reserve(count);
 		for(int i = 0; i < count; i++)
 		{
@@ -66,8 +68,8 @@
 
 	// fmt returns the comma-delimited list of printf format strings for
 	// every element in the provided list, all enclosed in square brackets.
-	template <typename T>
-	static std::string fmt(const T* list, int count)
+	template<typename T>
+	static std::string fmt(const T *list, int count)
 	{
 		std::string out = "[";
 		for(int i = 0; i < count; i++)
@@ -78,7 +80,7 @@
 		return out + "]";
 	}
 
-	static std::string addr(const void* ptr)
+	static std::string addr(const void *ptr)
 	{
 		char buf[32];
 		snprintf(buf, sizeof(buf), "%p", ptr);
@@ -87,36 +89,69 @@
 
 public:
 	const std::string format;
-	const std::vector<Value*> values;
+	const std::vector<Value *> values;
 
 	// Constructs a PrintValue for the given value.
-	template <typename T>
-	PrintValue(const T& v) : format(fmt(v)), values(val(v)) {}
+	template<typename T>
+	PrintValue(const T &v)
+	    : format(fmt(v))
+	    , values(val(v))
+	{}
 
 	// Constructs a PrintValue for the given static array.
-	template <typename T, int N>
-	PrintValue(const T (&v)[N]) : format(fmt(&v[0], N)), values(val(&v[0], N)) {}
+	template<typename T, int N>
+	PrintValue(const T (&v)[N])
+	    : format(fmt(&v[0], N))
+	    , values(val(&v[0], N))
+	{}
 
 	// Constructs a PrintValue for the given array starting at arr of length
 	// len.
-	template <typename T>
-	PrintValue(const T* arr, int len) : format(fmt(arr, len)), values(val(arr, len)) {}
+	template<typename T>
+	PrintValue(const T *arr, int len)
+	    : format(fmt(arr, len))
+	    , values(val(arr, len))
+	{}
 
 	// PrintValue constructors for plain-old-data values.
-	PrintValue(bool v) : format(v ? "true" : "false") {}
-	PrintValue(int8_t v) : format(std::to_string(v)) {}
-	PrintValue(uint8_t v) : format(std::to_string(v)) {}
-	PrintValue(int16_t v) : format(std::to_string(v)) {}
-	PrintValue(uint16_t v) : format(std::to_string(v)) {}
-	PrintValue(int32_t v) : format(std::to_string(v)) {}
-	PrintValue(uint32_t v) : format(std::to_string(v)) {}
-	PrintValue(int64_t v) : format(std::to_string(v)) {}
-	PrintValue(uint64_t v) : format(std::to_string(v)) {}
-	PrintValue(float v) : format(std::to_string(v)) {}
-	PrintValue(double v) : format(std::to_string(v)) {}
+	PrintValue(bool v)
+	    : format(v ? "true" : "false")
+	{}
+	PrintValue(int8_t v)
+	    : format(std::to_string(v))
+	{}
+	PrintValue(uint8_t v)
+	    : format(std::to_string(v))
+	{}
+	PrintValue(int16_t v)
+	    : format(std::to_string(v))
+	{}
+	PrintValue(uint16_t v)
+	    : format(std::to_string(v))
+	{}
+	PrintValue(int32_t v)
+	    : format(std::to_string(v))
+	{}
+	PrintValue(uint32_t v)
+	    : format(std::to_string(v))
+	{}
+	PrintValue(int64_t v)
+	    : format(std::to_string(v))
+	{}
+	PrintValue(uint64_t v)
+	    : format(std::to_string(v))
+	{}
+	PrintValue(float v)
+	    : format(std::to_string(v))
+	{}
+	PrintValue(double v)
+	    : format(std::to_string(v))
+	{}
 
-	template <typename T>
-	PrintValue(const T* v) : format(addr(v)) {}
+	template<typename T>
+	PrintValue(const T *v)
+	    : format(addr(v))
+	{}
 
 	// vals is a helper to build composite value lists.
 	// vals returns the full, sequential list of printf argument values used
@@ -144,12 +179,12 @@
 	//			}
 	//		};
 	//	}
-	template<typename ... ARGS>
-	static std::vector<Value*> vals(ARGS... v)
+	template<typename... ARGS>
+	static std::vector<Value *> vals(ARGS... v)
 	{
-		std::vector< std::vector<Value*> > lists = {val(v)...};
-		std::vector<Value*> joined;
-		for(const auto& list : lists)
+		std::vector<std::vector<Value *>> lists = { val(v)... };
+		std::vector<Value *> joined;
+		for(const auto &list : lists)
 		{
 			joined.insert(joined.end(), list.begin(), list.end());
 		}
@@ -158,128 +193,155 @@
 
 	// returns the printf format specifier for the given type via the
 	// PrintValue::Ty<T> specialization.
-	template <typename T>
-	static std::string fmt(const T& v) { return Ty<T>::fmt(v); }
+	template<typename T>
+	static std::string fmt(const T &v)
+	{
+		return Ty<T>::fmt(v);
+	}
 
 	// returns the printf value for the given type with a
 	// PrintValue::Ty<T> specialization.
-	template <typename T>
-	static std::vector<Value*> val(const T& v) { return Ty<T>::val(v); }
+	template<typename T>
+	static std::vector<Value *> val(const T &v)
+	{
+		return Ty<T>::val(v);
+	}
 };
 
 // PrintValue::Ty<T> specializations for basic types.
-template <> struct PrintValue::Ty<const char*>
+template<>
+struct PrintValue::Ty<const char *>
 {
-	static std::string fmt(const char* v) { return "%s"; }
-	static std::vector<Value*> val(const char* v);
+	static std::string fmt(const char *v) { return "%s"; }
+	static std::vector<Value *> val(const char *v);
 };
-template <> struct PrintValue::Ty<std::string>
+template<>
+struct PrintValue::Ty<std::string>
 {
-	static std::string fmt(const std::string& v) { return PrintValue::Ty<const char*>::fmt(v.c_str()); }
-	static std::vector<Value*> val(const std::string& v) { return PrintValue::Ty<const char*>::val(v.c_str()); }
+	static std::string fmt(const std::string &v) { return PrintValue::Ty<const char *>::fmt(v.c_str()); }
+	static std::vector<Value *> val(const std::string &v) { return PrintValue::Ty<const char *>::val(v.c_str()); }
 };
 
 // PrintValue::Ty<T> specializations for standard Reactor types.
-template <> struct PrintValue::Ty<Bool>
+template<>
+struct PrintValue::Ty<Bool>
 {
-	static std::string fmt(const RValue<Bool>& v) { return "%d"; }
-	static std::vector<Value*> val(const RValue<Bool>& v) { return {v.value}; }
+	static std::string fmt(const RValue<Bool> &v) { return "%d"; }
+	static std::vector<Value *> val(const RValue<Bool> &v) { return { v.value }; }
 };
-template <> struct PrintValue::Ty<Byte>
+template<>
+struct PrintValue::Ty<Byte>
 {
-	static std::string fmt(const RValue<Byte>& v) { return "%d"; }
-	static std::vector<Value*> val(const RValue<Byte>& v);
+	static std::string fmt(const RValue<Byte> &v) { return "%d"; }
+	static std::vector<Value *> val(const RValue<Byte> &v);
 };
-template <> struct PrintValue::Ty<Byte4>
+template<>
+struct PrintValue::Ty<Byte4>
 {
-	static std::string fmt(const RValue<Byte4>& v) { return "[%d, %d, %d, %d]"; }
-	static std::vector<Value*> val(const RValue<Byte4>& v);
+	static std::string fmt(const RValue<Byte4> &v) { return "[%d, %d, %d, %d]"; }
+	static std::vector<Value *> val(const RValue<Byte4> &v);
 };
-template <> struct PrintValue::Ty<Int>
+template<>
+struct PrintValue::Ty<Int>
 {
-	static std::string fmt(const RValue<Int>& v) { return "%d"; }
-	static std::vector<Value*> val(const RValue<Int>& v);
+	static std::string fmt(const RValue<Int> &v) { return "%d"; }
+	static std::vector<Value *> val(const RValue<Int> &v);
 };
-template <> struct PrintValue::Ty<Int2>
+template<>
+struct PrintValue::Ty<Int2>
 {
-	static std::string fmt(const RValue<Int>& v) { return "[%d, %d]"; }
-	static std::vector<Value*> val(const RValue<Int2>& v);
+	static std::string fmt(const RValue<Int> &v) { return "[%d, %d]"; }
+	static std::vector<Value *> val(const RValue<Int2> &v);
 };
-template <> struct PrintValue::Ty<Int4>
+template<>
+struct PrintValue::Ty<Int4>
 {
-	static std::string fmt(const RValue<Int4>& v) { return "[%d, %d, %d, %d]"; }
-	static std::vector<Value*> val(const RValue<Int4>& v);
+	static std::string fmt(const RValue<Int4> &v) { return "[%d, %d, %d, %d]"; }
+	static std::vector<Value *> val(const RValue<Int4> &v);
 };
-template <> struct PrintValue::Ty<UInt>
+template<>
+struct PrintValue::Ty<UInt>
 {
-	static std::string fmt(const RValue<UInt>& v) { return "%u"; }
-	static std::vector<Value*> val(const RValue<UInt>& v);
+	static std::string fmt(const RValue<UInt> &v) { return "%u"; }
+	static std::vector<Value *> val(const RValue<UInt> &v);
 };
-template <> struct PrintValue::Ty<UInt2>
+template<>
+struct PrintValue::Ty<UInt2>
 {
-	static std::string fmt(const RValue<UInt>& v) { return "[%u, %u]"; }
-	static std::vector<Value*> val(const RValue<UInt2>& v);
+	static std::string fmt(const RValue<UInt> &v) { return "[%u, %u]"; }
+	static std::vector<Value *> val(const RValue<UInt2> &v);
 };
-template <> struct PrintValue::Ty<UInt4>
+template<>
+struct PrintValue::Ty<UInt4>
 {
-	static std::string fmt(const RValue<UInt4>& v) { return "[%u, %u, %u, %u]"; }
-	static std::vector<Value*> val(const RValue<UInt4>& v);
+	static std::string fmt(const RValue<UInt4> &v) { return "[%u, %u, %u, %u]"; }
+	static std::vector<Value *> val(const RValue<UInt4> &v);
 };
-template <> struct PrintValue::Ty<Short>
+template<>
+struct PrintValue::Ty<Short>
 {
-	static std::string fmt(const RValue<Short>& v) { return "%d"; }
-	static std::vector<Value*> val(const RValue<Short>& v);
+	static std::string fmt(const RValue<Short> &v) { return "%d"; }
+	static std::vector<Value *> val(const RValue<Short> &v);
 };
-template <> struct PrintValue::Ty<Short4>
+template<>
+struct PrintValue::Ty<Short4>
 {
-	static std::string fmt(const RValue<Short4>& v) { return "[%d, %d, %d, %d]"; }
-	static std::vector<Value*> val(const RValue<Short4>& v);
+	static std::string fmt(const RValue<Short4> &v) { return "[%d, %d, %d, %d]"; }
+	static std::vector<Value *> val(const RValue<Short4> &v);
 };
-template <> struct PrintValue::Ty<UShort>
+template<>
+struct PrintValue::Ty<UShort>
 {
-	static std::string fmt(const RValue<UShort>& v) { return "%u"; }
-	static std::vector<Value*> val(const RValue<UShort>& v);
+	static std::string fmt(const RValue<UShort> &v) { return "%u"; }
+	static std::vector<Value *> val(const RValue<UShort> &v);
 };
-template <> struct PrintValue::Ty<UShort4>
+template<>
+struct PrintValue::Ty<UShort4>
 {
-	static std::string fmt(const RValue<UShort4>& v) { return "[%u, %u, %u, %u]"; }
-	static std::vector<Value*> val(const RValue<UShort4>& v);
+	static std::string fmt(const RValue<UShort4> &v) { return "[%u, %u, %u, %u]"; }
+	static std::vector<Value *> val(const RValue<UShort4> &v);
 };
-template <> struct PrintValue::Ty<Float>
+template<>
+struct PrintValue::Ty<Float>
 {
-	static std::string fmt(const RValue<Float>& v) { return "[%f]"; }
-	static std::vector<Value*> val(const RValue<Float>& v);
+	static std::string fmt(const RValue<Float> &v) { return "[%f]"; }
+	static std::vector<Value *> val(const RValue<Float> &v);
 };
-template <> struct PrintValue::Ty<Float4>
+template<>
+struct PrintValue::Ty<Float4>
 {
-	static std::string fmt(const RValue<Float4>& v) { return "[%f, %f, %f, %f]"; }
-	static std::vector<Value*> val(const RValue<Float4>& v);
+	static std::string fmt(const RValue<Float4> &v) { return "[%f, %f, %f, %f]"; }
+	static std::vector<Value *> val(const RValue<Float4> &v);
 };
-template <> struct PrintValue::Ty<Long>
+template<>
+struct PrintValue::Ty<Long>
 {
-	static std::string fmt(const RValue<Long>& v) { return "%lld"; }
-	static std::vector<Value*> val(const RValue<Long>& v) { return {v.value}; }
+	static std::string fmt(const RValue<Long> &v) { return "%lld"; }
+	static std::vector<Value *> val(const RValue<Long> &v) { return { v.value }; }
 };
-template <typename T> struct PrintValue::Ty< Pointer<T> >
+template<typename T>
+struct PrintValue::Ty<Pointer<T>>
 {
-	static std::string fmt(const RValue<Pointer<T>>& v) { return "%p"; }
-	static std::vector<Value*> val(const RValue<Pointer<T>>& v) { return {v.value}; }
+	static std::string fmt(const RValue<Pointer<T>> &v) { return "%p"; }
+	static std::vector<Value *> val(const RValue<Pointer<T>> &v) { return { v.value }; }
 };
-template <typename T> struct PrintValue::Ty< Reference<T> >
+template<typename T>
+struct PrintValue::Ty<Reference<T>>
 {
-	static std::string fmt(const Reference<T>& v) { return PrintValue::Ty<T>::fmt(v); }
-	static std::vector<Value*> val(const Reference<T>& v) { return PrintValue::Ty<T>::val(v); }
+	static std::string fmt(const Reference<T> &v) { return PrintValue::Ty<T>::fmt(v); }
+	static std::vector<Value *> val(const Reference<T> &v) { return PrintValue::Ty<T>::val(v); }
 };
-template <typename T> struct PrintValue::Ty< RValue<T> >
+template<typename T>
+struct PrintValue::Ty<RValue<T>>
 {
-	static std::string fmt(const RValue<T>& v) { return PrintValue::Ty<T>::fmt(v); }
-	static std::vector<Value*> val(const RValue<T>& v) { return PrintValue::Ty<T>::val(v); }
+	static std::string fmt(const RValue<T> &v) { return PrintValue::Ty<T>::fmt(v); }
+	static std::vector<Value *> val(const RValue<T> &v) { return PrintValue::Ty<T>::val(v); }
 };
 
 // Printv emits a call to printf() using the function, file and line,
 // message and optional values.
 // See Printv below.
-void Printv(const char* function, const char* file, int line, const char* msg, std::initializer_list<PrintValue> vals);
+void Printv(const char *function, const char *file, int line, const char *msg, std::initializer_list<PrintValue> vals);
 
 // Printv emits a call to printf() using the provided message and optional
 // values.
@@ -291,22 +353,25 @@
 //   "red and green"
 // Arguments can be indexed in any order.
 // Invalid indices are not substituted.
-inline void Printv(const char* msg, std::initializer_list<PrintValue> vals)
+inline void Printv(const char *msg, std::initializer_list<PrintValue> vals)
 {
 	Printv(nullptr, nullptr, 0, msg, vals);
 }
 
 // Print is a wrapper over Printv that wraps the variadic arguments into an
 // initializer_list before calling Printv.
-template <typename ... ARGS>
-void Print(const char* msg, const ARGS& ... vals) { Printv(msg, {vals...}); }
+template<typename... ARGS>
+void Print(const char *msg, const ARGS &... vals)
+{
+	Printv(msg, { vals... });
+}
 
 // Print is a wrapper over Printv that wraps the variadic arguments into an
 // initializer_list before calling Printv.
-template <typename ... ARGS>
-void Print(const char* function, const char* file, int line, const char* msg, const ARGS& ... vals)
+template<typename... ARGS>
+void Print(const char *function, const char *file, int line, const char *msg, const ARGS &... vals)
 {
-	Printv(function, file, line, msg, {vals...});
+	Printv(function, file, line, msg, { vals... });
 }
 
 // RR_LOG is a macro that calls Print(), automatically populating the
@@ -314,19 +379,19 @@
 //
 // RR_LOG() is intended to be used for debugging JIT compiled code, and is
 // not intended for production use.
-#if defined(_WIN32)
-	#define RR_LOG(msg, ...) Print(__FUNCSIG__, __FILE__, static_cast<int>(__LINE__), msg "\n", ##__VA_ARGS__)
-#else
-	#define RR_LOG(msg, ...) Print(__PRETTY_FUNCTION__, __FILE__, static_cast<int>(__LINE__), msg "\n", ##__VA_ARGS__)
-#endif
+#	if defined(_WIN32)
+#		define RR_LOG(msg, ...) Print(__FUNCSIG__, __FILE__, static_cast<int>(__LINE__), msg "\n", ##__VA_ARGS__)
+#	else
+#		define RR_LOG(msg, ...) Print(__PRETTY_FUNCTION__, __FILE__, static_cast<int>(__LINE__), msg "\n", ##__VA_ARGS__)
+#	endif
 
 // Macro magic to perform variadic dispatch.
 // See: https://renenyffenegger.ch/notes/development/languages/C-C-plus-plus/preprocessor/macros/__VA_ARGS__/count-arguments
 // Note, this doesn't attempt to use the ##__VA_ARGS__ trick to handle 0
-#define RR_MSVC_EXPAND_BUG(X) X // Helper macro to force expanding __VA_ARGS__ to satisfy MSVC compiler.
-#define RR_GET_NTH_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, N, ...) N
-#define RR_COUNT_ARGUMENTS(...) RR_MSVC_EXPAND_BUG(RR_GET_NTH_ARG(__VA_ARGS__, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0))
-static_assert(1 == RR_COUNT_ARGUMENTS(a), "RR_COUNT_ARGUMENTS broken"); // Sanity checks.
+#	define RR_MSVC_EXPAND_BUG(X) X  // Helper macro to force expanding __VA_ARGS__ to satisfy MSVC compiler.
+#	define RR_GET_NTH_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, N, ...) N
+#	define RR_COUNT_ARGUMENTS(...) RR_MSVC_EXPAND_BUG(RR_GET_NTH_ARG(__VA_ARGS__, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0))
+static_assert(1 == RR_COUNT_ARGUMENTS(a), "RR_COUNT_ARGUMENTS broken");  // Sanity checks.
 static_assert(2 == RR_COUNT_ARGUMENTS(a, b), "RR_COUNT_ARGUMENTS broken");
 static_assert(3 == RR_COUNT_ARGUMENTS(a, b, c), "RR_COUNT_ARGUMENTS broken");
 
@@ -336,21 +401,43 @@
 //
 // RR_WATCH_FMT(...) uses the RR_COUNT_ARGUMENTS helper macro to delegate to a
 // corresponding RR_WATCH_FMT_n specialization macro below.
-#define RR_WATCH_CONCAT(a, b) a ## b
-#define RR_WATCH_CONCAT2(a, b) RR_WATCH_CONCAT(a, b)
-#define RR_WATCH_FMT(...) RR_MSVC_EXPAND_BUG(RR_WATCH_CONCAT2(RR_WATCH_FMT_, RR_COUNT_ARGUMENTS(__VA_ARGS__))(__VA_ARGS__))
-#define RR_WATCH_FMT_1(_1) "\n  " #_1 ": {0}"
-#define RR_WATCH_FMT_2(_1, _2)                                             RR_WATCH_FMT_1(_1) "\n  " #_2 ": {1}"
-#define RR_WATCH_FMT_3(_1, _2, _3)                                         RR_WATCH_FMT_2(_1, _2) "\n  " #_3 ": {2}"
-#define RR_WATCH_FMT_4(_1, _2, _3, _4)                                     RR_WATCH_FMT_3(_1, _2, _3) "\n  " #_4 ": {3}"
-#define RR_WATCH_FMT_5(_1, _2, _3, _4, _5)                                 RR_WATCH_FMT_4(_1, _2, _3, _4) "\n  " #_5 ": {4}"
-#define RR_WATCH_FMT_6(_1, _2, _3, _4, _5, _6)                             RR_WATCH_FMT_5(_1, _2, _3, _4, _5) "\n  " #_6 ": {5}"
-#define RR_WATCH_FMT_7(_1, _2, _3, _4, _5, _6, _7)                         RR_WATCH_FMT_6(_1, _2, _3, _4, _5, _6) "\n  " #_7 ": {6}"
-#define RR_WATCH_FMT_8(_1, _2, _3, _4, _5, _6, _7, _8)                     RR_WATCH_FMT_7(_1, _2, _3, _4, _5, _6, _7) "\n  " #_8 ": {7}"
-#define RR_WATCH_FMT_9(_1, _2, _3, _4, _5, _6, _7, _8, _9)                 RR_WATCH_FMT_8(_1, _2, _3, _4, _5, _6, _7, _8) "\n  " #_9 ": {8}"
-#define RR_WATCH_FMT_10(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10)           RR_WATCH_FMT_9(_1, _2, _3, _4, _5, _6, _7, _8, _9) "\n  " #_10 ": {9}"
-#define RR_WATCH_FMT_11(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11)      RR_WATCH_FMT_10(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10) "\n  " #_11 ": {10}"
-#define RR_WATCH_FMT_12(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12) RR_WATCH_FMT_11(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11) "\n  " #_12 ": {11}"
+#	define RR_WATCH_CONCAT(a, b) a##b
+#	define RR_WATCH_CONCAT2(a, b) RR_WATCH_CONCAT(a, b)
+#	define RR_WATCH_FMT(...) RR_MSVC_EXPAND_BUG(RR_WATCH_CONCAT2(RR_WATCH_FMT_, RR_COUNT_ARGUMENTS(__VA_ARGS__))(__VA_ARGS__))
+#	define RR_WATCH_FMT_1(_1) "\n  " #    _1 ": {0}"
+#	define RR_WATCH_FMT_2(_1, _2) \
+		RR_WATCH_FMT_1(_1)         \
+		"\n  " #_2 ": {1}"
+#	define RR_WATCH_FMT_3(_1, _2, _3) \
+		RR_WATCH_FMT_2(_1, _2)         \
+		"\n  " #_3 ": {2}"
+#	define RR_WATCH_FMT_4(_1, _2, _3, _4) \
+		RR_WATCH_FMT_3(_1, _2, _3)         \
+		"\n  " #_4 ": {3}"
+#	define RR_WATCH_FMT_5(_1, _2, _3, _4, _5) \
+		RR_WATCH_FMT_4(_1, _2, _3, _4)         \
+		"\n  " #_5 ": {4}"
+#	define RR_WATCH_FMT_6(_1, _2, _3, _4, _5, _6) \
+		RR_WATCH_FMT_5(_1, _2, _3, _4, _5)         \
+		"\n  " #_6 ": {5}"
+#	define RR_WATCH_FMT_7(_1, _2, _3, _4, _5, _6, _7) \
+		RR_WATCH_FMT_6(_1, _2, _3, _4, _5, _6)         \
+		"\n  " #_7 ": {6}"
+#	define RR_WATCH_FMT_8(_1, _2, _3, _4, _5, _6, _7, _8) \
+		RR_WATCH_FMT_7(_1, _2, _3, _4, _5, _6, _7)         \
+		"\n  " #_8 ": {7}"
+#	define RR_WATCH_FMT_9(_1, _2, _3, _4, _5, _6, _7, _8, _9) \
+		RR_WATCH_FMT_8(_1, _2, _3, _4, _5, _6, _7, _8)         \
+		"\n  " #_9 ": {8}"
+#	define RR_WATCH_FMT_10(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10) \
+		RR_WATCH_FMT_9(_1, _2, _3, _4, _5, _6, _7, _8, _9)           \
+		"\n  " #_10 ": {9}"
+#	define RR_WATCH_FMT_11(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11) \
+		RR_WATCH_FMT_10(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10)          \
+		"\n  " #_11 ": {10}"
+#	define RR_WATCH_FMT_12(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12) \
+		RR_WATCH_FMT_11(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11)          \
+		"\n  " #_12 ": {11}"
 
 // RR_WATCH() is a helper that prints the name and value of all the supplied
 // arguments.
@@ -362,7 +449,7 @@
 //
 // RR_WATCH() is intended to be used for debugging JIT compiled code, and
 // is not intended for production use.
-#define RR_WATCH(...) RR_LOG(RR_WATCH_FMT(__VA_ARGS__), __VA_ARGS__)
+#	define RR_WATCH(...) RR_LOG(RR_WATCH_FMT(__VA_ARGS__), __VA_ARGS__)
 
 }  // namespace rr
 
diff --git a/src/Reactor/Reactor.cpp b/src/Reactor/Reactor.cpp
index c088e7b..fe8e103 100644
--- a/src/Reactor/Reactor.cpp
+++ b/src/Reactor/Reactor.cpp
@@ -20,19 +20,21 @@
 // Define REACTOR_MATERIALIZE_LVALUES_ON_DEFINITION to non-zero to ensure all
 // variables have a stack location obtained throuch alloca().
 #ifndef REACTOR_MATERIALIZE_LVALUES_ON_DEFINITION
-#define REACTOR_MATERIALIZE_LVALUES_ON_DEFINITION 0
+#	define REACTOR_MATERIALIZE_LVALUES_ON_DEFINITION 0
 #endif
 
 namespace {
 
 // Introduced in C++20.
-template <class ForwardIterator, class UnaryPredicate>
+template<class ForwardIterator, class UnaryPredicate>
 ForwardIterator remove_if(ForwardIterator first, ForwardIterator last,
-							UnaryPredicate pred)
+                          UnaryPredicate pred)
 {
 	ForwardIterator result = first;
-	while(first!=last) {
-		if(!pred(*first)) {
+	while(first != last)
+	{
+		if(!pred(*first))
+		{
 			*result = std::move(*first);
 			++result;
 		}
@@ -54,39 +56,41 @@
 	auto level = optLevelChanged ? optLevel : cfg.optimization.getLevel();
 	auto passes = cfg.optimization.getPasses();
 	apply(optPassEdits, passes);
-	return Config{ Optimization{level, passes} };
+	return Config{ Optimization{ level, passes } };
 }
 
-template <typename T>
-void rr::Config::Edit::apply(const std::vector<std::pair<ListEdit, T>> & edits, std::vector<T>& list) const
+template<typename T>
+void rr::Config::Edit::apply(const std::vector<std::pair<ListEdit, T>> &edits, std::vector<T> &list) const
 {
-	for(auto & edit : edits)
+	for(auto &edit : edits)
 	{
 		switch(edit.first)
 		{
-		case ListEdit::Add:
-			list.push_back(edit.second);
-			break;
-		case ListEdit::Remove:
-			::remove_if(list.begin(), list.end(), [&](T item) { return item == edit.second; });
-			break;
-		case ListEdit::Clear:
-			list.clear();
-			break;
+			case ListEdit::Add:
+				list.push_back(edit.second);
+				break;
+			case ListEdit::Remove:
+				::remove_if(list.begin(), list.end(), [&](T item) { return item == edit.second; });
+				break;
+			case ListEdit::Clear:
+				list.clear();
+				break;
 		}
 	}
 }
 
 // Set of variables that do not have a stack location yet.
-std::unordered_set<Variable*> Variable::unmaterializedVariables;
+std::unordered_set<Variable *> Variable::unmaterializedVariables;
 
-Variable::Variable(Type *type, int arraySize) : arraySize(arraySize), type(type)
+Variable::Variable(Type *type, int arraySize)
+    : arraySize(arraySize)
+    , type(type)
 {
-	#if REACTOR_MATERIALIZE_LVALUES_ON_DEFINITION
-		materialize();
-	#else
-		unmaterializedVariables.emplace(this);
-	#endif
+#if REACTOR_MATERIALIZE_LVALUES_ON_DEFINITION
+	materialize();
+#else
+	unmaterializedVariables.emplace(this);
+#endif
 }
 
 Variable::~Variable()
@@ -126,12 +130,11 @@
 //
 static Value *createBlend4(Value *lhs, Value *rhs, uint16_t select)
 {
-	int swizzle[4] =
-	{
+	int swizzle[4] = {
 		(select >> 12) & 0x07,
-		(select >> 8)  & 0x07,
-		(select >> 4)  & 0x07,
-		(select >> 0)  & 0x07,
+		(select >> 8) & 0x07,
+		(select >> 4) & 0x07,
+		(select >> 0) & 0x07,
 	};
 
 	return Nucleus::createShuffleVector(lhs, rhs, swizzle);
@@ -153,12 +156,11 @@
 //
 static Value *createSwizzle4(Value *val, uint16_t select)
 {
-	int swizzle[4] =
-	{
+	int swizzle[4] = {
 		(select >> 12) & 0x03,
-		(select >> 8)  & 0x03,
-		(select >> 4)  & 0x03,
-		(select >> 0)  & 0x03,
+		(select >> 8) & 0x03,
+		(select >> 4) & 0x03,
+		(select >> 0) & 0x03,
 	};
 
 	return Nucleus::createShuffleVector(val, val, swizzle);
@@ -166,15 +168,14 @@
 
 static Value *createMask4(Value *lhs, Value *rhs, uint16_t select)
 {
-	bool mask[4] = {false, false, false, false};
+	bool mask[4] = { false, false, false, false };
 
 	mask[(select >> 12) & 0x03] = true;
-	mask[(select >> 8)  & 0x03] = true;
-	mask[(select >> 4)  & 0x03] = true;
-	mask[(select >> 0)  & 0x03] = true;
+	mask[(select >> 8) & 0x03] = true;
+	mask[(select >> 4) & 0x03] = true;
+	mask[(select >> 0) & 0x03] = true;
 
-	int swizzle[4] =
-	{
+	int swizzle[4] = {
 		mask[0] ? 4 : 0,
 		mask[1] ? 5 : 1,
 		mask[2] ? 6 : 2,
@@ -450,7 +451,7 @@
 	return RValue<Byte>(Nucleus::createNot(val.value));
 }
 
-RValue<Byte> operator++(Byte &val, int)   // Post-increment
+RValue<Byte> operator++(Byte &val, int)  // Post-increment
 {
 	RValue<Byte> res = val;
 
@@ -460,7 +461,7 @@
 	return res;
 }
 
-const Byte &operator++(Byte &val)   // Pre-increment
+const Byte &operator++(Byte &val)  // Pre-increment
 {
 	Value *inc = Nucleus::createAdd(val.loadValue(), Nucleus::createConstantByte((unsigned char)1));
 	val.storeValue(inc);
@@ -468,7 +469,7 @@
 	return val;
 }
 
-RValue<Byte> operator--(Byte &val, int)   // Post-decrement
+RValue<Byte> operator--(Byte &val, int)  // Post-decrement
 {
 	RValue<Byte> res = val;
 
@@ -478,7 +479,7 @@
 	return res;
 }
 
-const Byte &operator--(Byte &val)   // Pre-decrement
+const Byte &operator--(Byte &val)  // Pre-decrement
 {
 	Value *inc = Nucleus::createSub(val.loadValue(), Nucleus::createConstantByte((unsigned char)1));
 	val.storeValue(inc);
@@ -695,7 +696,7 @@
 	return RValue<SByte>(Nucleus::createNot(val.value));
 }
 
-RValue<SByte> operator++(SByte &val, int)   // Post-increment
+RValue<SByte> operator++(SByte &val, int)  // Post-increment
 {
 	RValue<SByte> res = val;
 
@@ -705,7 +706,7 @@
 	return res;
 }
 
-const SByte &operator++(SByte &val)   // Pre-increment
+const SByte &operator++(SByte &val)  // Pre-increment
 {
 	Value *inc = Nucleus::createAdd(val.loadValue(), Nucleus::createConstantByte((signed char)1));
 	val.storeValue(inc);
@@ -713,7 +714,7 @@
 	return val;
 }
 
-RValue<SByte> operator--(SByte &val, int)   // Post-decrement
+RValue<SByte> operator--(SByte &val, int)  // Post-decrement
 {
 	RValue<SByte> res = val;
 
@@ -723,7 +724,7 @@
 	return res;
 }
 
-const SByte &operator--(SByte &val)   // Pre-decrement
+const SByte &operator--(SByte &val)  // Pre-decrement
 {
 	Value *inc = Nucleus::createSub(val.loadValue(), Nucleus::createConstantByte((signed char)1));
 	val.storeValue(inc);
@@ -933,7 +934,7 @@
 	return RValue<Short>(Nucleus::createNot(val.value));
 }
 
-RValue<Short> operator++(Short &val, int)   // Post-increment
+RValue<Short> operator++(Short &val, int)  // Post-increment
 {
 	RValue<Short> res = val;
 
@@ -943,7 +944,7 @@
 	return res;
 }
 
-const Short &operator++(Short &val)   // Pre-increment
+const Short &operator++(Short &val)  // Pre-increment
 {
 	Value *inc = Nucleus::createAdd(val.loadValue(), Nucleus::createConstantShort((short)1));
 	val.storeValue(inc);
@@ -951,7 +952,7 @@
 	return val;
 }
 
-RValue<Short> operator--(Short &val, int)   // Post-decrement
+RValue<Short> operator--(Short &val, int)  // Post-decrement
 {
 	RValue<Short> res = val;
 
@@ -961,7 +962,7 @@
 	return res;
 }
 
-const Short &operator--(Short &val)   // Pre-decrement
+const Short &operator--(Short &val)  // Pre-decrement
 {
 	Value *inc = Nucleus::createSub(val.loadValue(), Nucleus::createConstantShort((short)1));
 	val.storeValue(inc);
@@ -1178,7 +1179,7 @@
 	return RValue<UShort>(Nucleus::createNot(val.value));
 }
 
-RValue<UShort> operator++(UShort &val, int)   // Post-increment
+RValue<UShort> operator++(UShort &val, int)  // Post-increment
 {
 	RValue<UShort> res = val;
 
@@ -1188,7 +1189,7 @@
 	return res;
 }
 
-const UShort &operator++(UShort &val)   // Pre-increment
+const UShort &operator++(UShort &val)  // Pre-increment
 {
 	Value *inc = Nucleus::createAdd(val.loadValue(), Nucleus::createConstantShort((unsigned short)1));
 	val.storeValue(inc);
@@ -1196,7 +1197,7 @@
 	return val;
 }
 
-RValue<UShort> operator--(UShort &val, int)   // Post-decrement
+RValue<UShort> operator--(UShort &val, int)  // Post-decrement
 {
 	RValue<UShort> res = val;
 
@@ -1206,7 +1207,7 @@
 	return res;
 }
 
-const UShort &operator--(UShort &val)   // Pre-decrement
+const UShort &operator--(UShort &val)  // Pre-decrement
 {
 	Value *inc = Nucleus::createSub(val.loadValue(), Nucleus::createConstantShort((unsigned short)1));
 	val.storeValue(inc);
@@ -1257,7 +1258,7 @@
 
 Byte8::Byte8(uint8_t x0, uint8_t x1, uint8_t x2, uint8_t x3, uint8_t x4, uint8_t x5, uint8_t x6, uint8_t x7)
 {
-	int64_t constantVector[8] = {x0, x1, x2, x3, x4, x5, x6, x7};
+	int64_t constantVector[8] = { x0, x1, x2, x3, x4, x5, x6, x7 };
 	storeValue(Nucleus::createConstantVector(constantVector, getType()));
 }
 
@@ -1418,7 +1419,7 @@
 
 RValue<Short4> Unpack(RValue<Byte4> x)
 {
-	int shuffle[16] = {0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7};   // Real type is v16i8
+	int shuffle[16] = { 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7 };  // Real type is v16i8
 	return As<Short4>(Nucleus::createShuffleVector(x.value, x.value, shuffle));
 }
 
@@ -1429,20 +1430,20 @@
 
 RValue<Short4> UnpackLow(RValue<Byte8> x, RValue<Byte8> y)
 {
-	int shuffle[16] = {0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23};   // Real type is v16i8
+	int shuffle[16] = { 0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23 };  // Real type is v16i8
 	return As<Short4>(Nucleus::createShuffleVector(x.value, y.value, shuffle));
 }
 
 RValue<Short4> UnpackHigh(RValue<Byte8> x, RValue<Byte8> y)
 {
-	int shuffle[16] = {0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23};   // Real type is v16i8
+	int shuffle[16] = { 0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23 };  // Real type is v16i8
 	auto lowHigh = RValue<Byte16>(Nucleus::createShuffleVector(x.value, y.value, shuffle));
 	return As<Short4>(Swizzle(As<Int4>(lowHigh), 0x2323));
 }
 
 SByte8::SByte8(uint8_t x0, uint8_t x1, uint8_t x2, uint8_t x3, uint8_t x4, uint8_t x5, uint8_t x6, uint8_t x7)
 {
-	int64_t constantVector[8] = {x0, x1, x2, x3, x4, x5, x6, x7};
+	int64_t constantVector[8] = { x0, x1, x2, x3, x4, x5, x6, x7 };
 	Value *vector = Nucleus::createConstantVector(constantVector, getType());
 
 	storeValue(Nucleus::createBitCast(vector, getType()));
@@ -1605,13 +1606,13 @@
 
 RValue<Short4> UnpackLow(RValue<SByte8> x, RValue<SByte8> y)
 {
-	int shuffle[16] = {0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23};   // Real type is v16i8
+	int shuffle[16] = { 0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23 };  // Real type is v16i8
 	return As<Short4>(Nucleus::createShuffleVector(x.value, y.value, shuffle));
 }
 
 RValue<Short4> UnpackHigh(RValue<SByte8> x, RValue<SByte8> y)
 {
-	int shuffle[16] = {0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23};   // Real type is v16i8
+	int shuffle[16] = { 0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23 };  // Real type is v16i8
 	auto lowHigh = RValue<Byte16>(Nucleus::createShuffleVector(x.value, y.value, shuffle));
 	return As<Short4>(Swizzle(As<Int4>(lowHigh), 0x2323));
 }
@@ -1682,13 +1683,13 @@
 
 Short4::Short4(short xyzw)
 {
-	int64_t constantVector[4] = {xyzw, xyzw, xyzw, xyzw};
+	int64_t constantVector[4] = { xyzw, xyzw, xyzw, xyzw };
 	storeValue(Nucleus::createConstantVector(constantVector, getType()));
 }
 
 Short4::Short4(short x, short y, short z, short w)
 {
-	int64_t constantVector[4] = {x, y, z, w};
+	int64_t constantVector[4] = { x, y, z, w };
 	storeValue(Nucleus::createConstantVector(constantVector, getType()));
 }
 
@@ -1883,13 +1884,13 @@
 
 RValue<Int2> UnpackLow(RValue<Short4> x, RValue<Short4> y)
 {
-	int shuffle[8] = {0, 8, 1, 9, 2, 10, 3, 11};   // Real type is v8i16
+	int shuffle[8] = { 0, 8, 1, 9, 2, 10, 3, 11 };  // Real type is v8i16
 	return As<Int2>(Nucleus::createShuffleVector(x.value, y.value, shuffle));
 }
 
 RValue<Int2> UnpackHigh(RValue<Short4> x, RValue<Short4> y)
 {
-	int shuffle[8] = {0, 8, 1, 9, 2, 10, 3, 11};   // Real type is v8i16
+	int shuffle[8] = { 0, 8, 1, 9, 2, 10, 3, 11 };  // Real type is v8i16
 	auto lowHigh = RValue<Short8>(Nucleus::createShuffleVector(x.value, y.value, shuffle));
 	return As<Int2>(Swizzle(As<Int4>(lowHigh), 0x2323));
 }
@@ -1897,16 +1898,15 @@
 RValue<Short4> Swizzle(RValue<Short4> x, uint16_t select)
 {
 	// Real type is v8i16
-	int shuffle[8] =
-	{
+	int shuffle[8] = {
 		(select >> 12) & 0x03,
-		(select >>  8) & 0x03,
-		(select >>  4) & 0x03,
-		(select >>  0) & 0x03,
+		(select >> 8) & 0x03,
+		(select >> 4) & 0x03,
+		(select >> 0) & 0x03,
 		(select >> 12) & 0x03,
-		(select >>  8) & 0x03,
-		(select >>  4) & 0x03,
-		(select >>  0) & 0x03,
+		(select >> 8) & 0x03,
+		(select >> 4) & 0x03,
+		(select >> 0) & 0x03,
 	};
 
 	return As<Short4>(Nucleus::createShuffleVector(x.value, x.value, shuffle));
@@ -1929,13 +1929,13 @@
 
 UShort4::UShort4(unsigned short xyzw)
 {
-	int64_t constantVector[4] = {xyzw, xyzw, xyzw, xyzw};
+	int64_t constantVector[4] = { xyzw, xyzw, xyzw, xyzw };
 	storeValue(Nucleus::createConstantVector(constantVector, getType()));
 }
 
 UShort4::UShort4(unsigned short x, unsigned short y, unsigned short z, unsigned short w)
 {
-	int64_t constantVector[4] = {x, y, z, w};
+	int64_t constantVector[4] = { x, y, z, w };
 	storeValue(Nucleus::createConstantVector(constantVector, getType()));
 }
 
@@ -2066,13 +2066,13 @@
 
 Short8::Short8(short c)
 {
-	int64_t constantVector[8] = {c, c, c, c, c, c, c, c};
+	int64_t constantVector[8] = { c, c, c, c, c, c, c, c };
 	storeValue(Nucleus::createConstantVector(constantVector, getType()));
 }
 
 Short8::Short8(short c0, short c1, short c2, short c3, short c4, short c5, short c6, short c7)
 {
-	int64_t constantVector[8] = {c0, c1, c2, c3, c4, c5, c6, c7};
+	int64_t constantVector[8] = { c0, c1, c2, c3, c4, c5, c6, c7 };
 	storeValue(Nucleus::createConstantVector(constantVector, getType()));
 }
 
@@ -2089,7 +2089,7 @@
 
 Short8::Short8(RValue<Short4> lo, RValue<Short4> hi)
 {
-	int shuffle[8] = {0, 1, 2, 3, 8, 9, 10, 11};   // Real type is v8i16
+	int shuffle[8] = { 0, 1, 2, 3, 8, 9, 10, 11 };  // Real type is v8i16
 	Value *packed = Nucleus::createShuffleVector(lo.value, hi.value, shuffle);
 
 	storeValue(packed);
@@ -2137,13 +2137,13 @@
 
 UShort8::UShort8(unsigned short c)
 {
-	int64_t constantVector[8] = {c, c, c, c, c, c, c, c};
+	int64_t constantVector[8] = { c, c, c, c, c, c, c, c };
 	storeValue(Nucleus::createConstantVector(constantVector, getType()));
 }
 
 UShort8::UShort8(unsigned short c0, unsigned short c1, unsigned short c2, unsigned short c3, unsigned short c4, unsigned short c5, unsigned short c6, unsigned short c7)
 {
-	int64_t constantVector[8] = {c0, c1, c2, c3, c4, c5, c6, c7};
+	int64_t constantVector[8] = { c0, c1, c2, c3, c4, c5, c6, c7 };
 	storeValue(Nucleus::createConstantVector(constantVector, getType()));
 }
 
@@ -2160,7 +2160,7 @@
 
 UShort8::UShort8(RValue<UShort4> lo, RValue<UShort4> hi)
 {
-	int shuffle[8] = {0, 1, 2, 3, 8, 9, 10, 11};   // Real type is v8i16
+	int shuffle[8] = { 0, 1, 2, 3, 8, 9, 10, 11 };  // Real type is v8i16
 	Value *packed = Nucleus::createShuffleVector(lo.value, hi.value, shuffle);
 
 	storeValue(packed);
@@ -2593,62 +2593,62 @@
 	return lhs = lhs - rhs;
 }
 
-RValue<Long> AddAtomic(RValue<Pointer<Long> > x, RValue<Long> y)
+RValue<Long> AddAtomic(RValue<Pointer<Long>> x, RValue<Long> y)
 {
 	return RValue<Long>(Nucleus::createAtomicAdd(x.value, y.value));
 }
 
-RValue<UInt> AddAtomic(RValue<Pointer<UInt> > x, RValue<UInt> y, std::memory_order memoryOrder)
+RValue<UInt> AddAtomic(RValue<Pointer<UInt>> x, RValue<UInt> y, std::memory_order memoryOrder)
 {
 	return RValue<UInt>(Nucleus::createAtomicAdd(x.value, y.value, memoryOrder));
 }
 
-RValue<UInt> SubAtomic(RValue<Pointer<UInt> > x, RValue<UInt> y, std::memory_order memoryOrder)
+RValue<UInt> SubAtomic(RValue<Pointer<UInt>> x, RValue<UInt> y, std::memory_order memoryOrder)
 {
 	return RValue<UInt>(Nucleus::createAtomicSub(x.value, y.value, memoryOrder));
 }
 
-RValue<UInt> AndAtomic(RValue<Pointer<UInt> > x, RValue<UInt> y, std::memory_order memoryOrder)
+RValue<UInt> AndAtomic(RValue<Pointer<UInt>> x, RValue<UInt> y, std::memory_order memoryOrder)
 {
 	return RValue<UInt>(Nucleus::createAtomicAnd(x.value, y.value, memoryOrder));
 }
 
-RValue<UInt> OrAtomic(RValue<Pointer<UInt> > x, RValue<UInt> y, std::memory_order memoryOrder)
+RValue<UInt> OrAtomic(RValue<Pointer<UInt>> x, RValue<UInt> y, std::memory_order memoryOrder)
 {
 	return RValue<UInt>(Nucleus::createAtomicOr(x.value, y.value, memoryOrder));
 }
 
-RValue<UInt> XorAtomic(RValue<Pointer<UInt> > x, RValue<UInt> y, std::memory_order memoryOrder)
+RValue<UInt> XorAtomic(RValue<Pointer<UInt>> x, RValue<UInt> y, std::memory_order memoryOrder)
 {
 	return RValue<UInt>(Nucleus::createAtomicXor(x.value, y.value, memoryOrder));
 }
 
-RValue<Int> MinAtomic(RValue<Pointer<Int> > x, RValue<Int> y, std::memory_order memoryOrder)
+RValue<Int> MinAtomic(RValue<Pointer<Int>> x, RValue<Int> y, std::memory_order memoryOrder)
 {
 	return RValue<Int>(Nucleus::createAtomicMin(x.value, y.value, memoryOrder));
 }
 
-RValue<UInt> MinAtomic(RValue<Pointer<UInt> > x, RValue<UInt> y, std::memory_order memoryOrder)
+RValue<UInt> MinAtomic(RValue<Pointer<UInt>> x, RValue<UInt> y, std::memory_order memoryOrder)
 {
 	return RValue<UInt>(Nucleus::createAtomicUMin(x.value, y.value, memoryOrder));
 }
 
-RValue<Int> MaxAtomic(RValue<Pointer<Int> > x, RValue<Int> y, std::memory_order memoryOrder)
+RValue<Int> MaxAtomic(RValue<Pointer<Int>> x, RValue<Int> y, std::memory_order memoryOrder)
 {
 	return RValue<Int>(Nucleus::createAtomicMax(x.value, y.value, memoryOrder));
 }
 
-RValue<UInt> MaxAtomic(RValue<Pointer<UInt> > x, RValue<UInt> y, std::memory_order memoryOrder)
+RValue<UInt> MaxAtomic(RValue<Pointer<UInt>> x, RValue<UInt> y, std::memory_order memoryOrder)
 {
 	return RValue<UInt>(Nucleus::createAtomicUMax(x.value, y.value, memoryOrder));
 }
 
-RValue<UInt> ExchangeAtomic(RValue<Pointer<UInt> > x, RValue<UInt> y, std::memory_order memoryOrder)
+RValue<UInt> ExchangeAtomic(RValue<Pointer<UInt>> x, RValue<UInt> y, std::memory_order memoryOrder)
 {
 	return RValue<UInt>(Nucleus::createAtomicExchange(x.value, y.value, memoryOrder));
 }
 
-RValue<UInt> CompareExchangeAtomic(RValue<Pointer<UInt> > x, RValue<UInt> y, RValue<UInt> compare, std::memory_order memoryOrderEqual, std::memory_order memoryOrderUnequal)
+RValue<UInt> CompareExchangeAtomic(RValue<Pointer<UInt>> x, RValue<UInt> y, RValue<UInt> compare, std::memory_order memoryOrderEqual, std::memory_order memoryOrderUnequal)
 {
 	return RValue<UInt>(Nucleus::createAtomicCompareExchange(x.value, y.value, compare.value, memoryOrderEqual, memoryOrderUnequal));
 }
@@ -2934,7 +2934,7 @@
 
 Int2::Int2(int x, int y)
 {
-	int64_t constantVector[2] = {x, y};
+	int64_t constantVector[2] = { x, y };
 	storeValue(Nucleus::createConstantVector(constantVector, getType()));
 }
 
@@ -2957,7 +2957,7 @@
 
 Int2::Int2(RValue<Int> lo, RValue<Int> hi)
 {
-	int shuffle[4] = {0, 4, 1, 5};
+	int shuffle[4] = { 0, 4, 1, 5 };
 	Value *packed = Nucleus::createShuffleVector(Int4(lo).loadValue(), Int4(hi).loadValue(), shuffle);
 
 	storeValue(Nucleus::createBitCast(packed, Int2::getType()));
@@ -3093,13 +3093,13 @@
 
 RValue<Short4> UnpackLow(RValue<Int2> x, RValue<Int2> y)
 {
-	int shuffle[4] = {0, 4, 1, 5};   // Real type is v4i32
+	int shuffle[4] = { 0, 4, 1, 5 };  // Real type is v4i32
 	return As<Short4>(Nucleus::createShuffleVector(x.value, y.value, shuffle));
 }
 
 RValue<Short4> UnpackHigh(RValue<Int2> x, RValue<Int2> y)
 {
-	int shuffle[4] = {0, 4, 1, 5};   // Real type is v4i32
+	int shuffle[4] = { 0, 4, 1, 5 };  // Real type is v4i32
 	auto lowHigh = RValue<Int4>(Nucleus::createShuffleVector(x.value, y.value, shuffle));
 	return As<Short4>(Swizzle(lowHigh, 0x2323));
 }
@@ -3116,7 +3116,7 @@
 
 UInt2::UInt2(unsigned int x, unsigned int y)
 {
-	int64_t constantVector[2] = {x, y};
+	int64_t constantVector[2] = { x, y };
 	storeValue(Nucleus::createConstantVector(constantVector, getType()));
 }
 
@@ -3275,91 +3275,106 @@
 	return RValue<UInt2>(Nucleus::createInsertElement(val.value, element.value, i));
 }
 
-Int4::Int4() : XYZW(this)
+Int4::Int4()
+    : XYZW(this)
 {
 }
 
-Int4::Int4(RValue<Float4> cast) : XYZW(this)
+Int4::Int4(RValue<Float4> cast)
+    : XYZW(this)
 {
 	Value *xyzw = Nucleus::createFPToSI(cast.value, Int4::getType());
 
 	storeValue(xyzw);
 }
 
-Int4::Int4(int xyzw) : XYZW(this)
+Int4::Int4(int xyzw)
+    : XYZW(this)
 {
 	constant(xyzw, xyzw, xyzw, xyzw);
 }
 
-Int4::Int4(int x, int yzw) : XYZW(this)
+Int4::Int4(int x, int yzw)
+    : XYZW(this)
 {
 	constant(x, yzw, yzw, yzw);
 }
 
-Int4::Int4(int x, int y, int zw) : XYZW(this)
+Int4::Int4(int x, int y, int zw)
+    : XYZW(this)
 {
 	constant(x, y, zw, zw);
 }
 
-Int4::Int4(int x, int y, int z, int w) : XYZW(this)
+Int4::Int4(int x, int y, int z, int w)
+    : XYZW(this)
 {
 	constant(x, y, z, w);
 }
 
 void Int4::constant(int x, int y, int z, int w)
 {
-	int64_t constantVector[4] = {x, y, z, w};
+	int64_t constantVector[4] = { x, y, z, w };
 	storeValue(Nucleus::createConstantVector(constantVector, getType()));
 }
 
-Int4::Int4(RValue<Int4> rhs) : XYZW(this)
+Int4::Int4(RValue<Int4> rhs)
+    : XYZW(this)
 {
 	storeValue(rhs.value);
 }
 
-Int4::Int4(const Int4 &rhs) : XYZW(this)
+Int4::Int4(const Int4 &rhs)
+    : XYZW(this)
 {
 	Value *value = rhs.loadValue();
 	storeValue(value);
 }
 
-Int4::Int4(const Reference<Int4> &rhs) : XYZW(this)
+Int4::Int4(const Reference<Int4> &rhs)
+    : XYZW(this)
 {
 	Value *value = rhs.loadValue();
 	storeValue(value);
 }
 
-Int4::Int4(RValue<UInt4> rhs) : XYZW(this)
+Int4::Int4(RValue<UInt4> rhs)
+    : XYZW(this)
 {
 	storeValue(rhs.value);
 }
 
-Int4::Int4(const UInt4 &rhs) : XYZW(this)
+Int4::Int4(const UInt4 &rhs)
+    : XYZW(this)
 {
 	Value *value = rhs.loadValue();
 	storeValue(value);
 }
 
-Int4::Int4(const Reference<UInt4> &rhs) : XYZW(this)
+Int4::Int4(const Reference<UInt4> &rhs)
+    : XYZW(this)
 {
 	Value *value = rhs.loadValue();
 	storeValue(value);
 }
 
-Int4::Int4(RValue<Int2> lo, RValue<Int2> hi) : XYZW(this)
+Int4::Int4(RValue<Int2> lo, RValue<Int2> hi)
+    : XYZW(this)
 {
-	int shuffle[4] = {0, 1, 4, 5};   // Real type is v4i32
+	int shuffle[4] = { 0, 1, 4, 5 };  // Real type is v4i32
 	Value *packed = Nucleus::createShuffleVector(lo.value, hi.value, shuffle);
 
 	storeValue(packed);
 }
 
-Int4::Int4(const Int &rhs) : XYZW(this)
+Int4::Int4(const Int &rhs)
+    : XYZW(this)
 {
 	*this = RValue<Int>(rhs.loadValue());
 }
 
-Int4::Int4(const Reference<Int> &rhs) : XYZW(this)
+Int4::Int4(const Reference<Int> &rhs)
+    : XYZW(this)
 {
 	*this = RValue<Int>(rhs.loadValue());
 }
@@ -3522,84 +3537,98 @@
 	return RValue<Int4>(createBlend4(x.value, y.value, select));
 }
 
-UInt4::UInt4() : XYZW(this)
+UInt4::UInt4()
+    : XYZW(this)
 {
 }
 
-UInt4::UInt4(int xyzw) : XYZW(this)
+UInt4::UInt4(int xyzw)
+    : XYZW(this)
 {
 	constant(xyzw, xyzw, xyzw, xyzw);
 }
 
-UInt4::UInt4(int x, int yzw) : XYZW(this)
+UInt4::UInt4(int x, int yzw)
+    : XYZW(this)
 {
 	constant(x, yzw, yzw, yzw);
 }
 
-UInt4::UInt4(int x, int y, int zw) : XYZW(this)
+UInt4::UInt4(int x, int y, int zw)
+    : XYZW(this)
 {
 	constant(x, y, zw, zw);
 }
 
-UInt4::UInt4(int x, int y, int z, int w) : XYZW(this)
+UInt4::UInt4(int x, int y, int z, int w)
+    : XYZW(this)
 {
 	constant(x, y, z, w);
 }
 
 void UInt4::constant(int x, int y, int z, int w)
 {
-	int64_t constantVector[4] = {x, y, z, w};
+	int64_t constantVector[4] = { x, y, z, w };
 	storeValue(Nucleus::createConstantVector(constantVector, getType()));
 }
 
-UInt4::UInt4(RValue<UInt4> rhs) : XYZW(this)
+UInt4::UInt4(RValue<UInt4> rhs)
+    : XYZW(this)
 {
 	storeValue(rhs.value);
 }
 
-UInt4::UInt4(const UInt4 &rhs) : XYZW(this)
+UInt4::UInt4(const UInt4 &rhs)
+    : XYZW(this)
 {
 	Value *value = rhs.loadValue();
 	storeValue(value);
 }
 
-UInt4::UInt4(const Reference<UInt4> &rhs) : XYZW(this)
+UInt4::UInt4(const Reference<UInt4> &rhs)
+    : XYZW(this)
 {
 	Value *value = rhs.loadValue();
 	storeValue(value);
 }
 
-UInt4::UInt4(RValue<Int4> rhs) : XYZW(this)
+UInt4::UInt4(RValue<Int4> rhs)
+    : XYZW(this)
 {
 	storeValue(rhs.value);
 }
 
-UInt4::UInt4(const Int4 &rhs) : XYZW(this)
+UInt4::UInt4(const Int4 &rhs)
+    : XYZW(this)
 {
 	Value *value = rhs.loadValue();
 	storeValue(value);
 }
 
-UInt4::UInt4(const Reference<Int4> &rhs) : XYZW(this)
+UInt4::UInt4(const Reference<Int4> &rhs)
+    : XYZW(this)
 {
 	Value *value = rhs.loadValue();
 	storeValue(value);
 }
 
-UInt4::UInt4(RValue<UInt2> lo, RValue<UInt2> hi) : XYZW(this)
+UInt4::UInt4(RValue<UInt2> lo, RValue<UInt2> hi)
+    : XYZW(this)
 {
-	int shuffle[4] = {0, 1, 4, 5};   // Real type is v4i32
+	int shuffle[4] = { 0, 1, 4, 5 };  // Real type is v4i32
 	Value *packed = Nucleus::createShuffleVector(lo.value, hi.value, shuffle);
 
 	storeValue(packed);
 }
 
-UInt4::UInt4(const UInt &rhs) : XYZW(this)
+UInt4::UInt4(const UInt &rhs)
+    : XYZW(this)
 {
 	*this = RValue<UInt>(rhs.loadValue());
 }
 
-UInt4::UInt4(const Reference<UInt> &rhs) : XYZW(this)
+UInt4::UInt4(const Reference<UInt> &rhs)
+    : XYZW(this)
 {
 	*this = RValue<UInt>(rhs.loadValue());
 }
@@ -3766,15 +3795,15 @@
 {
 	UInt fp32i = As<UInt>(cast);
 	UInt abs = fp32i & 0x7FFFFFFF;
-	UShort fp16i((fp32i & 0x80000000) >> 16); // sign
+	UShort fp16i((fp32i & 0x80000000) >> 16);  // sign
 
-	If(abs > 0x47FFEFFF) // Infinity
+	If(abs > 0x47FFEFFF)  // Infinity
 	{
 		fp16i |= UShort(0x7FFF);
 	}
 	Else
 	{
-		If(abs < 0x38800000) // Denormal
+		If(abs < 0x38800000)  // Denormal
 		{
 			Int mantissa = (abs & 0x007FFFFF) | 0x00800000;
 			Int e = 113 - (abs >> 23);
@@ -4004,7 +4033,8 @@
 	storeValue(Nucleus::createBitCast(cast.value, getType()));
 }
 
-Float4::Float4(RValue<Byte4> cast) : XYZW(this)
+Float4::Float4(RValue<Byte4> cast)
+    : XYZW(this)
 {
 	Value *a = Int4(cast).loadValue();
 	Value *xyzw = Nucleus::createSIToFP(a, Float4::getType());
@@ -4012,7 +4042,8 @@
 	storeValue(xyzw);
 }
 
-Float4::Float4(RValue<SByte4> cast) : XYZW(this)
+Float4::Float4(RValue<SByte4> cast)
+    : XYZW(this)
 {
 	Value *a = Int4(cast).loadValue();
 	Value *xyzw = Nucleus::createSIToFP(a, Float4::getType());
@@ -4020,26 +4051,30 @@
 	storeValue(xyzw);
 }
 
-Float4::Float4(RValue<Short4> cast) : XYZW(this)
+Float4::Float4(RValue<Short4> cast)
+    : XYZW(this)
 {
 	Int4 c(cast);
 	storeValue(Nucleus::createSIToFP(RValue<Int4>(c).value, Float4::getType()));
 }
 
-Float4::Float4(RValue<UShort4> cast) : XYZW(this)
+Float4::Float4(RValue<UShort4> cast)
+    : XYZW(this)
 {
 	Int4 c(cast);
 	storeValue(Nucleus::createSIToFP(RValue<Int4>(c).value, Float4::getType()));
 }
 
-Float4::Float4(RValue<Int4> cast) : XYZW(this)
+Float4::Float4(RValue<Int4> cast)
+    : XYZW(this)
 {
 	Value *xyzw = Nucleus::createSIToFP(cast.value, Float4::getType());
 
 	storeValue(xyzw);
 }
 
-Float4::Float4(RValue<UInt4> cast) : XYZW(this)
+Float4::Float4(RValue<UInt4> cast)
+    : XYZW(this)
 {
 	RValue<Float4> result = Float4(Int4(cast & UInt4(0x7FFFFFFF))) +
 	                        As<Float4>((As<Int4>(cast) >> 31) & As<Int4>(Float4(0x80000000u)));
@@ -4047,26 +4082,31 @@
 	storeValue(result.value);
 }
 
-Float4::Float4() : XYZW(this)
+Float4::Float4()
+    : XYZW(this)
 {
 }
 
-Float4::Float4(float xyzw) : XYZW(this)
+Float4::Float4(float xyzw)
+    : XYZW(this)
 {
 	constant(xyzw, xyzw, xyzw, xyzw);
 }
 
-Float4::Float4(float x, float yzw) : XYZW(this)
+Float4::Float4(float x, float yzw)
+    : XYZW(this)
 {
 	constant(x, yzw, yzw, yzw);
 }
 
-Float4::Float4(float x, float y, float zw) : XYZW(this)
+Float4::Float4(float x, float y, float zw)
+    : XYZW(this)
 {
 	constant(x, y, zw, zw);
 }
 
-Float4::Float4(float x, float y, float z, float w) : XYZW(this)
+Float4::Float4(float x, float y, float z, float w)
+    : XYZW(this)
 {
 	constant(x, y, z, w);
 }
@@ -4088,7 +4128,7 @@
 void Float4::infinity_constant(bool negative)
 {
 	double inf = negative ? -INFINITY : INFINITY;
-	double constantVector[4] = {inf, inf, inf, inf};
+	double constantVector[4] = { inf, inf, inf, inf };
 	storeValue(Nucleus::createConstantVector(constantVector, getType()));
 }
 
@@ -4097,33 +4137,38 @@
 	// See Float(float) constructor for the rationale behind this assert.
 	ASSERT(std::isfinite(x) && std::isfinite(y) && std::isfinite(z) && std::isfinite(w));
 
-	double constantVector[4] = {x, y, z, w};
+	double constantVector[4] = { x, y, z, w };
 	storeValue(Nucleus::createConstantVector(constantVector, getType()));
 }
 
-Float4::Float4(RValue<Float4> rhs) : XYZW(this)
+Float4::Float4(RValue<Float4> rhs)
+    : XYZW(this)
 {
 	storeValue(rhs.value);
 }
 
-Float4::Float4(const Float4 &rhs) : XYZW(this)
+Float4::Float4(const Float4 &rhs)
+    : XYZW(this)
 {
 	Value *value = rhs.loadValue();
 	storeValue(value);
 }
 
-Float4::Float4(const Reference<Float4> &rhs) : XYZW(this)
+Float4::Float4(const Reference<Float4> &rhs)
+    : XYZW(this)
 {
 	Value *value = rhs.loadValue();
 	storeValue(value);
 }
 
-Float4::Float4(const Float &rhs) : XYZW(this)
+Float4::Float4(const Float &rhs)
+    : XYZW(this)
 {
 	*this = RValue<Float>(rhs.loadValue());
 }
 
-Float4::Float4(const Reference<Float> &rhs) : XYZW(this)
+Float4::Float4(const Reference<Float> &rhs)
+    : XYZW(this)
 {
 	*this = RValue<Float>(rhs.loadValue());
 }
@@ -4235,7 +4280,7 @@
 {
 	// TODO: Optimize.
 	Value *vector = Nucleus::createBitCast(x.value, Int4::getType());
-	int64_t constantVector[4] = {0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF};
+	int64_t constantVector[4] = { 0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF };
 	Value *result = Nucleus::createAnd(vector, Nucleus::createConstantVector(constantVector, Int4::getType()));
 
 	return As<Float4>(result);
@@ -4263,12 +4308,11 @@
 
 RValue<Float4> ShuffleLowHigh(RValue<Float4> x, RValue<Float4> y, uint16_t imm)
 {
-	int shuffle[4] =
-	{
+	int shuffle[4] = {
 		((imm >> 12) & 0x03) + 0,
-		((imm >>  8) & 0x03) + 0,
-		((imm >>  4) & 0x03) + 4,
-		((imm >>  0) & 0x03) + 4,
+		((imm >> 8) & 0x03) + 0,
+		((imm >> 4) & 0x03) + 4,
+		((imm >> 0) & 0x03) + 4,
 	};
 
 	return RValue<Float4>(Nucleus::createShuffleVector(x.value, y.value, shuffle));
@@ -4276,13 +4320,13 @@
 
 RValue<Float4> UnpackLow(RValue<Float4> x, RValue<Float4> y)
 {
-	int shuffle[4] = {0, 4, 1, 5};
+	int shuffle[4] = { 0, 4, 1, 5 };
 	return RValue<Float4>(Nucleus::createShuffleVector(x.value, y.value, shuffle));
 }
 
 RValue<Float4> UnpackHigh(RValue<Float4> x, RValue<Float4> y)
 {
-	int shuffle[4] = {2, 6, 3, 7};
+	int shuffle[4] = { 2, 6, 3, 7 };
 	return RValue<Float4>(Nucleus::createShuffleVector(x.value, y.value, shuffle));
 }
 
@@ -4401,22 +4445,49 @@
 void Fence(std::memory_order memoryOrder)
 {
 	ASSERT_MSG(memoryOrder == std::memory_order_acquire ||
-		memoryOrder == std::memory_order_release ||
-		memoryOrder == std::memory_order_acq_rel ||
-		memoryOrder == std::memory_order_seq_cst,
-		"Unsupported memoryOrder: %d", int(memoryOrder));
+	               memoryOrder == std::memory_order_release ||
+	               memoryOrder == std::memory_order_acq_rel ||
+	               memoryOrder == std::memory_order_seq_cst,
+	           "Unsupported memoryOrder: %d", int(memoryOrder));
 	Nucleus::createFence(memoryOrder);
 }
 
-Bool          CToReactor<bool>::cast(bool v)               { return type(v); }
-Byte          CToReactor<uint8_t>::cast(uint8_t v)         { return type(v); }
-SByte         CToReactor<int8_t>::cast(int8_t v)           { return type(v); }
-Short         CToReactor<int16_t>::cast(int16_t v)         { return type(v); }
-UShort        CToReactor<uint16_t>::cast(uint16_t v)       { return type(v); }
-Int           CToReactor<int32_t>::cast(int32_t v)         { return type(v); }
-UInt          CToReactor<uint32_t>::cast(uint32_t v)       { return type(v); }
-Float         CToReactor<float>::cast(float v)             { return type(v); }
-Float4        CToReactor<float[4]>::cast(float v[4])       { return type(v[0], v[1], v[2], v[3]); }
+Bool CToReactor<bool>::cast(bool v)
+{
+	return type(v);
+}
+Byte CToReactor<uint8_t>::cast(uint8_t v)
+{
+	return type(v);
+}
+SByte CToReactor<int8_t>::cast(int8_t v)
+{
+	return type(v);
+}
+Short CToReactor<int16_t>::cast(int16_t v)
+{
+	return type(v);
+}
+UShort CToReactor<uint16_t>::cast(uint16_t v)
+{
+	return type(v);
+}
+Int CToReactor<int32_t>::cast(int32_t v)
+{
+	return type(v);
+}
+UInt CToReactor<uint32_t>::cast(uint32_t v)
+{
+	return type(v);
+}
+Float CToReactor<float>::cast(float v)
+{
+	return type(v);
+}
+Float4 CToReactor<float[4]>::cast(float v[4])
+{
+	return type(v[0], v[1], v[2], v[3]);
+}
 
 // TODO: Long has no constructor that takes a uint64_t
 // Long          CToReactor<uint64_t>::cast(uint64_t v)       { return type(v); }
diff --git a/src/Reactor/Reactor.hpp b/src/Reactor/Reactor.hpp
index fc55c51..59b3d0a 100644
--- a/src/Reactor/Reactor.hpp
+++ b/src/Reactor/Reactor.hpp
@@ -26,34 +26,33 @@
 #include <tuple>
 #include <unordered_set>
 
-#undef Bool // b/127920555
+#undef Bool  // b/127920555
 
 #ifdef ENABLE_RR_DEBUG_INFO
-	// Functions used for generating JIT debug info.
-	// See docs/ReactorDebugInfo.md for more information.
-	namespace rr
-	{
-		// Update the current source location for debug.
-		void EmitDebugLocation();
-		// Bind value to its symbolic name taken from the backtrace.
-		void EmitDebugVariable(class Value* value);
-		// Flush any pending variable bindings before the line ends.
-		void FlushDebug();
-	}
-	#define RR_DEBUG_INFO_UPDATE_LOC()    rr::EmitDebugLocation()
-	#define RR_DEBUG_INFO_EMIT_VAR(value) rr::EmitDebugVariable(value)
-	#define RR_DEBUG_INFO_FLUSH()         rr::FlushDebug()
+// Functions used for generating JIT debug info.
+// See docs/ReactorDebugInfo.md for more information.
+namespace rr {
+// Update the current source location for debug.
+void EmitDebugLocation();
+// Bind value to its symbolic name taken from the backtrace.
+void EmitDebugVariable(class Value *value);
+// Flush any pending variable bindings before the line ends.
+void FlushDebug();
+}  // namespace rr
+#	define RR_DEBUG_INFO_UPDATE_LOC() rr::EmitDebugLocation()
+#	define RR_DEBUG_INFO_EMIT_VAR(value) rr::EmitDebugVariable(value)
+#	define RR_DEBUG_INFO_FLUSH() rr::FlushDebug()
 #else
-	#define RR_DEBUG_INFO_UPDATE_LOC()
-	#define RR_DEBUG_INFO_EMIT_VAR(value)
-	#define RR_DEBUG_INFO_FLUSH()
-#endif // ENABLE_RR_DEBUG_INFO
+#	define RR_DEBUG_INFO_UPDATE_LOC()
+#	define RR_DEBUG_INFO_EMIT_VAR(value)
+#	define RR_DEBUG_INFO_FLUSH()
+#endif  // ENABLE_RR_DEBUG_INFO
 
 namespace rr {
 
 struct Capabilities
 {
-	bool CoroutinesSupported; // Support for rr::Coroutine<F>
+	bool CoroutinesSupported;  // Support for rr::Coroutine<F>
 };
 extern const Capabilities Caps;
 
@@ -109,7 +108,7 @@
 	friend class PrintValue;
 
 	Variable() = delete;
-	Variable &operator=(const Variable&) = delete;
+	Variable &operator=(const Variable &) = delete;
 
 public:
 	void materialize() const;
@@ -122,7 +121,7 @@
 
 protected:
 	Variable(Type *type, int arraySize);
-	Variable(const Variable&) = default;
+	Variable(const Variable &) = default;
 
 	~Variable();
 
@@ -132,7 +131,7 @@
 	static void materializeAll();
 	static void killUnmaterialized();
 
-	static std::unordered_set<Variable*> unmaterializedVariables;
+	static std::unordered_set<Variable *> unmaterializedVariables;
 
 	Type *const type;
 	mutable Value *rvalue = nullptr;
@@ -154,7 +153,7 @@
 
 	// self() returns the this pointer to this LValue<T> object.
 	// This function exists because operator&() is overloaded.
-	inline LValue<T>* self() { return this; }
+	inline LValue<T> *self() { return this; }
 };
 
 template<class T>
@@ -239,7 +238,7 @@
 
 #ifdef ENABLE_RR_DEBUG_INFO
 	RValue(const RValue<T> &rvalue);
-#endif // ENABLE_RR_DEBUG_INFO
+#endif  // ENABLE_RR_DEBUG_INFO
 
 	RValue(const T &lvalue);
 	RValue(typename BoolLiteral<T>::type i);
@@ -247,15 +246,17 @@
 	RValue(typename FloatLiteral<T>::type f);
 	RValue(const Reference<T> &rhs);
 
-	RValue<T> &operator=(const RValue<T>&) = delete;
+	RValue<T> &operator=(const RValue<T> &) = delete;
 
-	Value *value;   // FIXME: Make private
+	Value *value;  // FIXME: Make private
 };
 
 template<typename T>
 struct Argument
 {
-	explicit Argument(Value *value) : value(value) {}
+	explicit Argument(Value *value)
+	    : value(value)
+	{}
 
 	Value *value;
 };
@@ -271,7 +272,7 @@
 	Bool(const Bool &rhs);
 	Bool(const Reference<Bool> &rhs);
 
-//	RValue<Bool> operator=(bool rhs);   // FIXME: Implement
+	//	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);
@@ -301,7 +302,7 @@
 	Byte(const Byte &rhs);
 	Byte(const Reference<Byte> &rhs);
 
-//	RValue<Byte> operator=(unsigned char rhs);   // FIXME: Implement
+	//	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);
@@ -332,10 +333,10 @@
 RValue<Byte> operator+(RValue<Byte> val);
 RValue<Byte> operator-(RValue<Byte> val);
 RValue<Byte> operator~(RValue<Byte> val);
-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<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);
@@ -357,7 +358,7 @@
 	SByte(const SByte &rhs);
 	SByte(const Reference<SByte> &rhs);
 
-//	RValue<SByte> operator=(signed char rhs);   // FIXME: Implement
+	//	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);
@@ -388,10 +389,10 @@
 RValue<SByte> operator+(RValue<SByte> val);
 RValue<SByte> operator-(RValue<SByte> val);
 RValue<SByte> operator~(RValue<SByte> val);
-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<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);
@@ -412,7 +413,7 @@
 	Short(const Short &rhs);
 	Short(const Reference<Short> &rhs);
 
-//	RValue<Short> operator=(short rhs);   // FIXME: Implement
+	//	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);
@@ -443,10 +444,10 @@
 RValue<Short> operator+(RValue<Short> val);
 RValue<Short> operator-(RValue<Short> val);
 RValue<Short> operator~(RValue<Short> val);
-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<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);
@@ -468,7 +469,7 @@
 	UShort(const UShort &rhs);
 	UShort(const Reference<UShort> &rhs);
 
-//	RValue<UShort> operator=(unsigned short rhs);   // FIXME: Implement
+	//	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);
@@ -499,10 +500,10 @@
 RValue<UShort> operator+(RValue<UShort> val);
 RValue<UShort> operator-(RValue<UShort> val);
 RValue<UShort> operator~(RValue<UShort> val);
-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<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);
@@ -516,14 +517,14 @@
 	explicit Byte4(RValue<Byte8> cast);
 
 	Byte4() = default;
-//	Byte4(int x, int y, int z, int w);
-//	Byte4(RValue<Byte4> rhs);
-//	Byte4(const Byte4 &rhs);
+	//	Byte4(int x, int y, int z, int w);
+	//	Byte4(RValue<Byte4> rhs);
+	//	Byte4(const Byte4 &rhs);
 	Byte4(const Reference<Byte4> &rhs);
 
-//	RValue<Byte4> operator=(RValue<Byte4> rhs);
-//	RValue<Byte4> operator=(const Byte4 &rhs);
-//	RValue<Byte4> operator=(const Reference<Byte4> &rhs);
+	//	RValue<Byte4> operator=(RValue<Byte4> rhs);
+	//	RValue<Byte4> operator=(const Byte4 &rhs);
+	//	RValue<Byte4> operator=(const Reference<Byte4> &rhs);
 
 	static Type *getType();
 };
@@ -560,14 +561,14 @@
 {
 public:
 	SByte4() = default;
-//	SByte4(int x, int y, int z, int w);
-//	SByte4(RValue<SByte4> rhs);
-//	SByte4(const SByte4 &rhs);
-//	SByte4(const Reference<SByte4> &rhs);
+	//	SByte4(int x, int y, int z, int w);
+	//	SByte4(RValue<SByte4> rhs);
+	//	SByte4(const SByte4 &rhs);
+	//	SByte4(const Reference<SByte4> &rhs);
 
-//	RValue<SByte4> operator=(RValue<SByte4> rhs);
-//	RValue<SByte4> operator=(const SByte4 &rhs);
-//	RValue<SByte4> operator=(const Reference<SByte4> &rhs);
+	//	RValue<SByte4> operator=(RValue<SByte4> rhs);
+	//	RValue<SByte4> operator=(const SByte4 &rhs);
+	//	RValue<SByte4> operator=(const Reference<SByte4> &rhs);
 
 	static Type *getType();
 };
@@ -710,7 +711,7 @@
 {
 public:
 	Byte16() = default;
-//	Byte16(int x, int y, int z, int w);
+	//	Byte16(int x, int y, int z, int w);
 	Byte16(RValue<Byte16> rhs);
 	Byte16(const Byte16 &rhs);
 	Byte16(const Reference<Byte16> &rhs);
@@ -754,14 +755,14 @@
 {
 public:
 	SByte16() = default;
-//	SByte16(int x, int y, int z, int w);
-//	SByte16(RValue<SByte16> rhs);
-//	SByte16(const SByte16 &rhs);
-//	SByte16(const Reference<SByte16> &rhs);
+	//	SByte16(int x, int y, int z, int w);
+	//	SByte16(RValue<SByte16> rhs);
+	//	SByte16(const SByte16 &rhs);
+	//	SByte16(const Reference<SByte16> &rhs);
 
-//	RValue<SByte16> operator=(RValue<SByte16> rhs);
-//	RValue<SByte16> operator=(const SByte16 &rhs);
-//	RValue<SByte16> operator=(const Reference<SByte16> &rhs);
+	//	RValue<SByte16> operator=(RValue<SByte16> rhs);
+	//	RValue<SByte16> operator=(const SByte16 &rhs);
+	//	RValue<SByte16> operator=(const Reference<SByte16> &rhs);
 
 	static Type *getType();
 };
@@ -815,7 +816,7 @@
 public:
 	explicit Short4(RValue<Int> cast);
 	explicit Short4(RValue<Int4> cast);
-//	explicit Short4(RValue<Float> cast);
+	//	explicit Short4(RValue<Float> cast);
 	explicit Short4(RValue<Float4> cast);
 
 	Short4() = default;
@@ -957,7 +958,7 @@
 	Short8(short c);
 	Short8(short c0, short c1, short c2, short c3, short c4, short c5, short c6, short c7);
 	Short8(RValue<Short8> rhs);
-//	Short8(const Short8 &rhs);
+	//	Short8(const Short8 &rhs);
 	Short8(const Reference<Short8> &rhs);
 	Short8(RValue<Short4> lo, RValue<Short4> hi);
 
@@ -1015,7 +1016,7 @@
 	UShort8(unsigned short c);
 	UShort8(unsigned short c0, unsigned short c1, unsigned short c2, unsigned short c3, unsigned short c4, unsigned short c5, unsigned short c6, unsigned short c7);
 	UShort8(RValue<UShort8> rhs);
-//	UShort8(const UShort8 &rhs);
+	//	UShort8(const UShort8 &rhs);
 	UShort8(const Reference<UShort8> &rhs);
 	UShort8(RValue<UShort4> lo, RValue<UShort4> hi);
 
@@ -1121,10 +1122,10 @@
 RValue<Int> operator+(RValue<Int> val);
 RValue<Int> operator-(RValue<Int> val);
 RValue<Int> operator~(RValue<Int> val);
-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<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);
@@ -1140,30 +1141,30 @@
 class Long : public LValue<Long>
 {
 public:
-//	Long(Argument<Long> argument);
+	//	Long(Argument<Long> argument);
 
-//	explicit Long(RValue<Short> cast);
-//	explicit Long(RValue<UShort> cast);
+	//	explicit Long(RValue<Short> cast);
+	//	explicit Long(RValue<UShort> cast);
 	explicit Long(RValue<Int> cast);
 	explicit Long(RValue<UInt> cast);
-//	explicit Long(RValue<Float> cast);
+	//	explicit Long(RValue<Float> cast);
 
 	Long() = default;
-//	Long(qword x);
+	//	Long(qword x);
 	Long(RValue<Long> rhs);
-//	Long(RValue<ULong> rhs);
-//	Long(const Long &rhs);
-//	Long(const Reference<Long> &rhs);
-//	Long(const ULong &rhs);
-//	Long(const Reference<ULong> &rhs);
+	//	Long(RValue<ULong> rhs);
+	//	Long(const Long &rhs);
+	//	Long(const Reference<Long> &rhs);
+	//	Long(const ULong &rhs);
+	//	Long(const Reference<ULong> &rhs);
 
 	RValue<Long> operator=(int64_t rhs);
 	RValue<Long> operator=(RValue<Long> rhs);
-//	RValue<Long> operator=(RValue<ULong> 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);
+	//	RValue<Long> operator=(const ULong &rhs);
+	//	RValue<Long> operator=(const Reference<ULong> &rhs);
 
 	static Type *getType();
 };
@@ -1203,7 +1204,7 @@
 //	RValue<Bool> operator==(RValue<Long> lhs, RValue<Long> rhs);
 
 //	RValue<Long> RoundLong(RValue<Float> cast);
-RValue<Long> AddAtomic( RValue<Pointer<Long>> x, RValue<Long> y);
+RValue<Long> AddAtomic(RValue<Pointer<Long>> x, RValue<Long> y);
 
 class UInt : public LValue<UInt>
 {
@@ -1258,10 +1259,10 @@
 RValue<UInt> operator+(RValue<UInt> val);
 RValue<UInt> operator-(RValue<UInt> val);
 RValue<UInt> operator~(RValue<UInt> val);
-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<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);
@@ -1290,7 +1291,7 @@
 class Int2 : public LValue<Int2>
 {
 public:
-//	explicit Int2(RValue<Int> cast);
+	//	explicit Int2(RValue<Int> cast);
 	explicit Int2(RValue<Int4> cast);
 
 	Int2() = default;
@@ -1509,342 +1510,342 @@
 		SwizzleMask1<Vector4, 0x1111> y;
 		SwizzleMask1<Vector4, 0x2222> z;
 		SwizzleMask1<Vector4, 0x3333> w;
-		Swizzle2<Vector4, 0x0000>     xx;
-		Swizzle2<Vector4, 0x1000>     yx;
-		Swizzle2<Vector4, 0x2000>     zx;
-		Swizzle2<Vector4, 0x3000>     wx;
+		Swizzle2<Vector4, 0x0000> xx;
+		Swizzle2<Vector4, 0x1000> yx;
+		Swizzle2<Vector4, 0x2000> zx;
+		Swizzle2<Vector4, 0x3000> wx;
 		SwizzleMask2<Vector4, 0x0111> xy;
-		Swizzle2<Vector4, 0x1111>     yy;
-		Swizzle2<Vector4, 0x2111>     zy;
-		Swizzle2<Vector4, 0x3111>     wy;
+		Swizzle2<Vector4, 0x1111> yy;
+		Swizzle2<Vector4, 0x2111> zy;
+		Swizzle2<Vector4, 0x3111> wy;
 		SwizzleMask2<Vector4, 0x0222> xz;
 		SwizzleMask2<Vector4, 0x1222> yz;
-		Swizzle2<Vector4, 0x2222>     zz;
-		Swizzle2<Vector4, 0x3222>     wz;
+		Swizzle2<Vector4, 0x2222> zz;
+		Swizzle2<Vector4, 0x3222> wz;
 		SwizzleMask2<Vector4, 0x0333> xw;
 		SwizzleMask2<Vector4, 0x1333> yw;
 		SwizzleMask2<Vector4, 0x2333> zw;
-		Swizzle2<Vector4, 0x3333>     ww;
-		Swizzle4<Vector4, 0x0000>     xxx;
-		Swizzle4<Vector4, 0x1000>     yxx;
-		Swizzle4<Vector4, 0x2000>     zxx;
-		Swizzle4<Vector4, 0x3000>     wxx;
-		Swizzle4<Vector4, 0x0100>     xyx;
-		Swizzle4<Vector4, 0x1100>     yyx;
-		Swizzle4<Vector4, 0x2100>     zyx;
-		Swizzle4<Vector4, 0x3100>     wyx;
-		Swizzle4<Vector4, 0x0200>     xzx;
-		Swizzle4<Vector4, 0x1200>     yzx;
-		Swizzle4<Vector4, 0x2200>     zzx;
-		Swizzle4<Vector4, 0x3200>     wzx;
-		Swizzle4<Vector4, 0x0300>     xwx;
-		Swizzle4<Vector4, 0x1300>     ywx;
-		Swizzle4<Vector4, 0x2300>     zwx;
-		Swizzle4<Vector4, 0x3300>     wwx;
-		Swizzle4<Vector4, 0x0011>     xxy;
-		Swizzle4<Vector4, 0x1011>     yxy;
-		Swizzle4<Vector4, 0x2011>     zxy;
-		Swizzle4<Vector4, 0x3011>     wxy;
-		Swizzle4<Vector4, 0x0111>     xyy;
-		Swizzle4<Vector4, 0x1111>     yyy;
-		Swizzle4<Vector4, 0x2111>     zyy;
-		Swizzle4<Vector4, 0x3111>     wyy;
-		Swizzle4<Vector4, 0x0211>     xzy;
-		Swizzle4<Vector4, 0x1211>     yzy;
-		Swizzle4<Vector4, 0x2211>     zzy;
-		Swizzle4<Vector4, 0x3211>     wzy;
-		Swizzle4<Vector4, 0x0311>     xwy;
-		Swizzle4<Vector4, 0x1311>     ywy;
-		Swizzle4<Vector4, 0x2311>     zwy;
-		Swizzle4<Vector4, 0x3311>     wwy;
-		Swizzle4<Vector4, 0x0022>     xxz;
-		Swizzle4<Vector4, 0x1022>     yxz;
-		Swizzle4<Vector4, 0x2022>     zxz;
-		Swizzle4<Vector4, 0x3022>     wxz;
+		Swizzle2<Vector4, 0x3333> ww;
+		Swizzle4<Vector4, 0x0000> xxx;
+		Swizzle4<Vector4, 0x1000> yxx;
+		Swizzle4<Vector4, 0x2000> zxx;
+		Swizzle4<Vector4, 0x3000> wxx;
+		Swizzle4<Vector4, 0x0100> xyx;
+		Swizzle4<Vector4, 0x1100> yyx;
+		Swizzle4<Vector4, 0x2100> zyx;
+		Swizzle4<Vector4, 0x3100> wyx;
+		Swizzle4<Vector4, 0x0200> xzx;
+		Swizzle4<Vector4, 0x1200> yzx;
+		Swizzle4<Vector4, 0x2200> zzx;
+		Swizzle4<Vector4, 0x3200> wzx;
+		Swizzle4<Vector4, 0x0300> xwx;
+		Swizzle4<Vector4, 0x1300> ywx;
+		Swizzle4<Vector4, 0x2300> zwx;
+		Swizzle4<Vector4, 0x3300> wwx;
+		Swizzle4<Vector4, 0x0011> xxy;
+		Swizzle4<Vector4, 0x1011> yxy;
+		Swizzle4<Vector4, 0x2011> zxy;
+		Swizzle4<Vector4, 0x3011> wxy;
+		Swizzle4<Vector4, 0x0111> xyy;
+		Swizzle4<Vector4, 0x1111> yyy;
+		Swizzle4<Vector4, 0x2111> zyy;
+		Swizzle4<Vector4, 0x3111> wyy;
+		Swizzle4<Vector4, 0x0211> xzy;
+		Swizzle4<Vector4, 0x1211> yzy;
+		Swizzle4<Vector4, 0x2211> zzy;
+		Swizzle4<Vector4, 0x3211> wzy;
+		Swizzle4<Vector4, 0x0311> xwy;
+		Swizzle4<Vector4, 0x1311> ywy;
+		Swizzle4<Vector4, 0x2311> zwy;
+		Swizzle4<Vector4, 0x3311> wwy;
+		Swizzle4<Vector4, 0x0022> xxz;
+		Swizzle4<Vector4, 0x1022> yxz;
+		Swizzle4<Vector4, 0x2022> zxz;
+		Swizzle4<Vector4, 0x3022> wxz;
 		SwizzleMask4<Vector4, 0x0122> xyz;
-		Swizzle4<Vector4, 0x1122>     yyz;
-		Swizzle4<Vector4, 0x2122>     zyz;
-		Swizzle4<Vector4, 0x3122>     wyz;
-		Swizzle4<Vector4, 0x0222>     xzz;
-		Swizzle4<Vector4, 0x1222>     yzz;
-		Swizzle4<Vector4, 0x2222>     zzz;
-		Swizzle4<Vector4, 0x3222>     wzz;
-		Swizzle4<Vector4, 0x0322>     xwz;
-		Swizzle4<Vector4, 0x1322>     ywz;
-		Swizzle4<Vector4, 0x2322>     zwz;
-		Swizzle4<Vector4, 0x3322>     wwz;
-		Swizzle4<Vector4, 0x0033>     xxw;
-		Swizzle4<Vector4, 0x1033>     yxw;
-		Swizzle4<Vector4, 0x2033>     zxw;
-		Swizzle4<Vector4, 0x3033>     wxw;
+		Swizzle4<Vector4, 0x1122> yyz;
+		Swizzle4<Vector4, 0x2122> zyz;
+		Swizzle4<Vector4, 0x3122> wyz;
+		Swizzle4<Vector4, 0x0222> xzz;
+		Swizzle4<Vector4, 0x1222> yzz;
+		Swizzle4<Vector4, 0x2222> zzz;
+		Swizzle4<Vector4, 0x3222> wzz;
+		Swizzle4<Vector4, 0x0322> xwz;
+		Swizzle4<Vector4, 0x1322> ywz;
+		Swizzle4<Vector4, 0x2322> zwz;
+		Swizzle4<Vector4, 0x3322> wwz;
+		Swizzle4<Vector4, 0x0033> xxw;
+		Swizzle4<Vector4, 0x1033> yxw;
+		Swizzle4<Vector4, 0x2033> zxw;
+		Swizzle4<Vector4, 0x3033> wxw;
 		SwizzleMask4<Vector4, 0x0133> xyw;
-		Swizzle4<Vector4, 0x1133>     yyw;
-		Swizzle4<Vector4, 0x2133>     zyw;
-		Swizzle4<Vector4, 0x3133>     wyw;
+		Swizzle4<Vector4, 0x1133> yyw;
+		Swizzle4<Vector4, 0x2133> zyw;
+		Swizzle4<Vector4, 0x3133> wyw;
 		SwizzleMask4<Vector4, 0x0233> xzw;
 		SwizzleMask4<Vector4, 0x1233> yzw;
-		Swizzle4<Vector4, 0x2233>     zzw;
-		Swizzle4<Vector4, 0x3233>     wzw;
-		Swizzle4<Vector4, 0x0333>     xww;
-		Swizzle4<Vector4, 0x1333>     yww;
-		Swizzle4<Vector4, 0x2333>     zww;
-		Swizzle4<Vector4, 0x3333>     www;
-		Swizzle4<Vector4, 0x0000>     xxxx;
-		Swizzle4<Vector4, 0x1000>     yxxx;
-		Swizzle4<Vector4, 0x2000>     zxxx;
-		Swizzle4<Vector4, 0x3000>     wxxx;
-		Swizzle4<Vector4, 0x0100>     xyxx;
-		Swizzle4<Vector4, 0x1100>     yyxx;
-		Swizzle4<Vector4, 0x2100>     zyxx;
-		Swizzle4<Vector4, 0x3100>     wyxx;
-		Swizzle4<Vector4, 0x0200>     xzxx;
-		Swizzle4<Vector4, 0x1200>     yzxx;
-		Swizzle4<Vector4, 0x2200>     zzxx;
-		Swizzle4<Vector4, 0x3200>     wzxx;
-		Swizzle4<Vector4, 0x0300>     xwxx;
-		Swizzle4<Vector4, 0x1300>     ywxx;
-		Swizzle4<Vector4, 0x2300>     zwxx;
-		Swizzle4<Vector4, 0x3300>     wwxx;
-		Swizzle4<Vector4, 0x0010>     xxyx;
-		Swizzle4<Vector4, 0x1010>     yxyx;
-		Swizzle4<Vector4, 0x2010>     zxyx;
-		Swizzle4<Vector4, 0x3010>     wxyx;
-		Swizzle4<Vector4, 0x0110>     xyyx;
-		Swizzle4<Vector4, 0x1110>     yyyx;
-		Swizzle4<Vector4, 0x2110>     zyyx;
-		Swizzle4<Vector4, 0x3110>     wyyx;
-		Swizzle4<Vector4, 0x0210>     xzyx;
-		Swizzle4<Vector4, 0x1210>     yzyx;
-		Swizzle4<Vector4, 0x2210>     zzyx;
-		Swizzle4<Vector4, 0x3210>     wzyx;
-		Swizzle4<Vector4, 0x0310>     xwyx;
-		Swizzle4<Vector4, 0x1310>     ywyx;
-		Swizzle4<Vector4, 0x2310>     zwyx;
-		Swizzle4<Vector4, 0x3310>     wwyx;
-		Swizzle4<Vector4, 0x0020>     xxzx;
-		Swizzle4<Vector4, 0x1020>     yxzx;
-		Swizzle4<Vector4, 0x2020>     zxzx;
-		Swizzle4<Vector4, 0x3020>     wxzx;
-		Swizzle4<Vector4, 0x0120>     xyzx;
-		Swizzle4<Vector4, 0x1120>     yyzx;
-		Swizzle4<Vector4, 0x2120>     zyzx;
-		Swizzle4<Vector4, 0x3120>     wyzx;
-		Swizzle4<Vector4, 0x0220>     xzzx;
-		Swizzle4<Vector4, 0x1220>     yzzx;
-		Swizzle4<Vector4, 0x2220>     zzzx;
-		Swizzle4<Vector4, 0x3220>     wzzx;
-		Swizzle4<Vector4, 0x0320>     xwzx;
-		Swizzle4<Vector4, 0x1320>     ywzx;
-		Swizzle4<Vector4, 0x2320>     zwzx;
-		Swizzle4<Vector4, 0x3320>     wwzx;
-		Swizzle4<Vector4, 0x0030>     xxwx;
-		Swizzle4<Vector4, 0x1030>     yxwx;
-		Swizzle4<Vector4, 0x2030>     zxwx;
-		Swizzle4<Vector4, 0x3030>     wxwx;
-		Swizzle4<Vector4, 0x0130>     xywx;
-		Swizzle4<Vector4, 0x1130>     yywx;
-		Swizzle4<Vector4, 0x2130>     zywx;
-		Swizzle4<Vector4, 0x3130>     wywx;
-		Swizzle4<Vector4, 0x0230>     xzwx;
-		Swizzle4<Vector4, 0x1230>     yzwx;
-		Swizzle4<Vector4, 0x2230>     zzwx;
-		Swizzle4<Vector4, 0x3230>     wzwx;
-		Swizzle4<Vector4, 0x0330>     xwwx;
-		Swizzle4<Vector4, 0x1330>     ywwx;
-		Swizzle4<Vector4, 0x2330>     zwwx;
-		Swizzle4<Vector4, 0x3330>     wwwx;
-		Swizzle4<Vector4, 0x0001>     xxxy;
-		Swizzle4<Vector4, 0x1001>     yxxy;
-		Swizzle4<Vector4, 0x2001>     zxxy;
-		Swizzle4<Vector4, 0x3001>     wxxy;
-		Swizzle4<Vector4, 0x0101>     xyxy;
-		Swizzle4<Vector4, 0x1101>     yyxy;
-		Swizzle4<Vector4, 0x2101>     zyxy;
-		Swizzle4<Vector4, 0x3101>     wyxy;
-		Swizzle4<Vector4, 0x0201>     xzxy;
-		Swizzle4<Vector4, 0x1201>     yzxy;
-		Swizzle4<Vector4, 0x2201>     zzxy;
-		Swizzle4<Vector4, 0x3201>     wzxy;
-		Swizzle4<Vector4, 0x0301>     xwxy;
-		Swizzle4<Vector4, 0x1301>     ywxy;
-		Swizzle4<Vector4, 0x2301>     zwxy;
-		Swizzle4<Vector4, 0x3301>     wwxy;
-		Swizzle4<Vector4, 0x0011>     xxyy;
-		Swizzle4<Vector4, 0x1011>     yxyy;
-		Swizzle4<Vector4, 0x2011>     zxyy;
-		Swizzle4<Vector4, 0x3011>     wxyy;
-		Swizzle4<Vector4, 0x0111>     xyyy;
-		Swizzle4<Vector4, 0x1111>     yyyy;
-		Swizzle4<Vector4, 0x2111>     zyyy;
-		Swizzle4<Vector4, 0x3111>     wyyy;
-		Swizzle4<Vector4, 0x0211>     xzyy;
-		Swizzle4<Vector4, 0x1211>     yzyy;
-		Swizzle4<Vector4, 0x2211>     zzyy;
-		Swizzle4<Vector4, 0x3211>     wzyy;
-		Swizzle4<Vector4, 0x0311>     xwyy;
-		Swizzle4<Vector4, 0x1311>     ywyy;
-		Swizzle4<Vector4, 0x2311>     zwyy;
-		Swizzle4<Vector4, 0x3311>     wwyy;
-		Swizzle4<Vector4, 0x0021>     xxzy;
-		Swizzle4<Vector4, 0x1021>     yxzy;
-		Swizzle4<Vector4, 0x2021>     zxzy;
-		Swizzle4<Vector4, 0x3021>     wxzy;
-		Swizzle4<Vector4, 0x0121>     xyzy;
-		Swizzle4<Vector4, 0x1121>     yyzy;
-		Swizzle4<Vector4, 0x2121>     zyzy;
-		Swizzle4<Vector4, 0x3121>     wyzy;
-		Swizzle4<Vector4, 0x0221>     xzzy;
-		Swizzle4<Vector4, 0x1221>     yzzy;
-		Swizzle4<Vector4, 0x2221>     zzzy;
-		Swizzle4<Vector4, 0x3221>     wzzy;
-		Swizzle4<Vector4, 0x0321>     xwzy;
-		Swizzle4<Vector4, 0x1321>     ywzy;
-		Swizzle4<Vector4, 0x2321>     zwzy;
-		Swizzle4<Vector4, 0x3321>     wwzy;
-		Swizzle4<Vector4, 0x0031>     xxwy;
-		Swizzle4<Vector4, 0x1031>     yxwy;
-		Swizzle4<Vector4, 0x2031>     zxwy;
-		Swizzle4<Vector4, 0x3031>     wxwy;
-		Swizzle4<Vector4, 0x0131>     xywy;
-		Swizzle4<Vector4, 0x1131>     yywy;
-		Swizzle4<Vector4, 0x2131>     zywy;
-		Swizzle4<Vector4, 0x3131>     wywy;
-		Swizzle4<Vector4, 0x0231>     xzwy;
-		Swizzle4<Vector4, 0x1231>     yzwy;
-		Swizzle4<Vector4, 0x2231>     zzwy;
-		Swizzle4<Vector4, 0x3231>     wzwy;
-		Swizzle4<Vector4, 0x0331>     xwwy;
-		Swizzle4<Vector4, 0x1331>     ywwy;
-		Swizzle4<Vector4, 0x2331>     zwwy;
-		Swizzle4<Vector4, 0x3331>     wwwy;
-		Swizzle4<Vector4, 0x0002>     xxxz;
-		Swizzle4<Vector4, 0x1002>     yxxz;
-		Swizzle4<Vector4, 0x2002>     zxxz;
-		Swizzle4<Vector4, 0x3002>     wxxz;
-		Swizzle4<Vector4, 0x0102>     xyxz;
-		Swizzle4<Vector4, 0x1102>     yyxz;
-		Swizzle4<Vector4, 0x2102>     zyxz;
-		Swizzle4<Vector4, 0x3102>     wyxz;
-		Swizzle4<Vector4, 0x0202>     xzxz;
-		Swizzle4<Vector4, 0x1202>     yzxz;
-		Swizzle4<Vector4, 0x2202>     zzxz;
-		Swizzle4<Vector4, 0x3202>     wzxz;
-		Swizzle4<Vector4, 0x0302>     xwxz;
-		Swizzle4<Vector4, 0x1302>     ywxz;
-		Swizzle4<Vector4, 0x2302>     zwxz;
-		Swizzle4<Vector4, 0x3302>     wwxz;
-		Swizzle4<Vector4, 0x0012>     xxyz;
-		Swizzle4<Vector4, 0x1012>     yxyz;
-		Swizzle4<Vector4, 0x2012>     zxyz;
-		Swizzle4<Vector4, 0x3012>     wxyz;
-		Swizzle4<Vector4, 0x0112>     xyyz;
-		Swizzle4<Vector4, 0x1112>     yyyz;
-		Swizzle4<Vector4, 0x2112>     zyyz;
-		Swizzle4<Vector4, 0x3112>     wyyz;
-		Swizzle4<Vector4, 0x0212>     xzyz;
-		Swizzle4<Vector4, 0x1212>     yzyz;
-		Swizzle4<Vector4, 0x2212>     zzyz;
-		Swizzle4<Vector4, 0x3212>     wzyz;
-		Swizzle4<Vector4, 0x0312>     xwyz;
-		Swizzle4<Vector4, 0x1312>     ywyz;
-		Swizzle4<Vector4, 0x2312>     zwyz;
-		Swizzle4<Vector4, 0x3312>     wwyz;
-		Swizzle4<Vector4, 0x0022>     xxzz;
-		Swizzle4<Vector4, 0x1022>     yxzz;
-		Swizzle4<Vector4, 0x2022>     zxzz;
-		Swizzle4<Vector4, 0x3022>     wxzz;
-		Swizzle4<Vector4, 0x0122>     xyzz;
-		Swizzle4<Vector4, 0x1122>     yyzz;
-		Swizzle4<Vector4, 0x2122>     zyzz;
-		Swizzle4<Vector4, 0x3122>     wyzz;
-		Swizzle4<Vector4, 0x0222>     xzzz;
-		Swizzle4<Vector4, 0x1222>     yzzz;
-		Swizzle4<Vector4, 0x2222>     zzzz;
-		Swizzle4<Vector4, 0x3222>     wzzz;
-		Swizzle4<Vector4, 0x0322>     xwzz;
-		Swizzle4<Vector4, 0x1322>     ywzz;
-		Swizzle4<Vector4, 0x2322>     zwzz;
-		Swizzle4<Vector4, 0x3322>     wwzz;
-		Swizzle4<Vector4, 0x0032>     xxwz;
-		Swizzle4<Vector4, 0x1032>     yxwz;
-		Swizzle4<Vector4, 0x2032>     zxwz;
-		Swizzle4<Vector4, 0x3032>     wxwz;
-		Swizzle4<Vector4, 0x0132>     xywz;
-		Swizzle4<Vector4, 0x1132>     yywz;
-		Swizzle4<Vector4, 0x2132>     zywz;
-		Swizzle4<Vector4, 0x3132>     wywz;
-		Swizzle4<Vector4, 0x0232>     xzwz;
-		Swizzle4<Vector4, 0x1232>     yzwz;
-		Swizzle4<Vector4, 0x2232>     zzwz;
-		Swizzle4<Vector4, 0x3232>     wzwz;
-		Swizzle4<Vector4, 0x0332>     xwwz;
-		Swizzle4<Vector4, 0x1332>     ywwz;
-		Swizzle4<Vector4, 0x2332>     zwwz;
-		Swizzle4<Vector4, 0x3332>     wwwz;
-		Swizzle4<Vector4, 0x0003>     xxxw;
-		Swizzle4<Vector4, 0x1003>     yxxw;
-		Swizzle4<Vector4, 0x2003>     zxxw;
-		Swizzle4<Vector4, 0x3003>     wxxw;
-		Swizzle4<Vector4, 0x0103>     xyxw;
-		Swizzle4<Vector4, 0x1103>     yyxw;
-		Swizzle4<Vector4, 0x2103>     zyxw;
-		Swizzle4<Vector4, 0x3103>     wyxw;
-		Swizzle4<Vector4, 0x0203>     xzxw;
-		Swizzle4<Vector4, 0x1203>     yzxw;
-		Swizzle4<Vector4, 0x2203>     zzxw;
-		Swizzle4<Vector4, 0x3203>     wzxw;
-		Swizzle4<Vector4, 0x0303>     xwxw;
-		Swizzle4<Vector4, 0x1303>     ywxw;
-		Swizzle4<Vector4, 0x2303>     zwxw;
-		Swizzle4<Vector4, 0x3303>     wwxw;
-		Swizzle4<Vector4, 0x0013>     xxyw;
-		Swizzle4<Vector4, 0x1013>     yxyw;
-		Swizzle4<Vector4, 0x2013>     zxyw;
-		Swizzle4<Vector4, 0x3013>     wxyw;
-		Swizzle4<Vector4, 0x0113>     xyyw;
-		Swizzle4<Vector4, 0x1113>     yyyw;
-		Swizzle4<Vector4, 0x2113>     zyyw;
-		Swizzle4<Vector4, 0x3113>     wyyw;
-		Swizzle4<Vector4, 0x0213>     xzyw;
-		Swizzle4<Vector4, 0x1213>     yzyw;
-		Swizzle4<Vector4, 0x2213>     zzyw;
-		Swizzle4<Vector4, 0x3213>     wzyw;
-		Swizzle4<Vector4, 0x0313>     xwyw;
-		Swizzle4<Vector4, 0x1313>     ywyw;
-		Swizzle4<Vector4, 0x2313>     zwyw;
-		Swizzle4<Vector4, 0x3313>     wwyw;
-		Swizzle4<Vector4, 0x0023>     xxzw;
-		Swizzle4<Vector4, 0x1023>     yxzw;
-		Swizzle4<Vector4, 0x2023>     zxzw;
-		Swizzle4<Vector4, 0x3023>     wxzw;
+		Swizzle4<Vector4, 0x2233> zzw;
+		Swizzle4<Vector4, 0x3233> wzw;
+		Swizzle4<Vector4, 0x0333> xww;
+		Swizzle4<Vector4, 0x1333> yww;
+		Swizzle4<Vector4, 0x2333> zww;
+		Swizzle4<Vector4, 0x3333> www;
+		Swizzle4<Vector4, 0x0000> xxxx;
+		Swizzle4<Vector4, 0x1000> yxxx;
+		Swizzle4<Vector4, 0x2000> zxxx;
+		Swizzle4<Vector4, 0x3000> wxxx;
+		Swizzle4<Vector4, 0x0100> xyxx;
+		Swizzle4<Vector4, 0x1100> yyxx;
+		Swizzle4<Vector4, 0x2100> zyxx;
+		Swizzle4<Vector4, 0x3100> wyxx;
+		Swizzle4<Vector4, 0x0200> xzxx;
+		Swizzle4<Vector4, 0x1200> yzxx;
+		Swizzle4<Vector4, 0x2200> zzxx;
+		Swizzle4<Vector4, 0x3200> wzxx;
+		Swizzle4<Vector4, 0x0300> xwxx;
+		Swizzle4<Vector4, 0x1300> ywxx;
+		Swizzle4<Vector4, 0x2300> zwxx;
+		Swizzle4<Vector4, 0x3300> wwxx;
+		Swizzle4<Vector4, 0x0010> xxyx;
+		Swizzle4<Vector4, 0x1010> yxyx;
+		Swizzle4<Vector4, 0x2010> zxyx;
+		Swizzle4<Vector4, 0x3010> wxyx;
+		Swizzle4<Vector4, 0x0110> xyyx;
+		Swizzle4<Vector4, 0x1110> yyyx;
+		Swizzle4<Vector4, 0x2110> zyyx;
+		Swizzle4<Vector4, 0x3110> wyyx;
+		Swizzle4<Vector4, 0x0210> xzyx;
+		Swizzle4<Vector4, 0x1210> yzyx;
+		Swizzle4<Vector4, 0x2210> zzyx;
+		Swizzle4<Vector4, 0x3210> wzyx;
+		Swizzle4<Vector4, 0x0310> xwyx;
+		Swizzle4<Vector4, 0x1310> ywyx;
+		Swizzle4<Vector4, 0x2310> zwyx;
+		Swizzle4<Vector4, 0x3310> wwyx;
+		Swizzle4<Vector4, 0x0020> xxzx;
+		Swizzle4<Vector4, 0x1020> yxzx;
+		Swizzle4<Vector4, 0x2020> zxzx;
+		Swizzle4<Vector4, 0x3020> wxzx;
+		Swizzle4<Vector4, 0x0120> xyzx;
+		Swizzle4<Vector4, 0x1120> yyzx;
+		Swizzle4<Vector4, 0x2120> zyzx;
+		Swizzle4<Vector4, 0x3120> wyzx;
+		Swizzle4<Vector4, 0x0220> xzzx;
+		Swizzle4<Vector4, 0x1220> yzzx;
+		Swizzle4<Vector4, 0x2220> zzzx;
+		Swizzle4<Vector4, 0x3220> wzzx;
+		Swizzle4<Vector4, 0x0320> xwzx;
+		Swizzle4<Vector4, 0x1320> ywzx;
+		Swizzle4<Vector4, 0x2320> zwzx;
+		Swizzle4<Vector4, 0x3320> wwzx;
+		Swizzle4<Vector4, 0x0030> xxwx;
+		Swizzle4<Vector4, 0x1030> yxwx;
+		Swizzle4<Vector4, 0x2030> zxwx;
+		Swizzle4<Vector4, 0x3030> wxwx;
+		Swizzle4<Vector4, 0x0130> xywx;
+		Swizzle4<Vector4, 0x1130> yywx;
+		Swizzle4<Vector4, 0x2130> zywx;
+		Swizzle4<Vector4, 0x3130> wywx;
+		Swizzle4<Vector4, 0x0230> xzwx;
+		Swizzle4<Vector4, 0x1230> yzwx;
+		Swizzle4<Vector4, 0x2230> zzwx;
+		Swizzle4<Vector4, 0x3230> wzwx;
+		Swizzle4<Vector4, 0x0330> xwwx;
+		Swizzle4<Vector4, 0x1330> ywwx;
+		Swizzle4<Vector4, 0x2330> zwwx;
+		Swizzle4<Vector4, 0x3330> wwwx;
+		Swizzle4<Vector4, 0x0001> xxxy;
+		Swizzle4<Vector4, 0x1001> yxxy;
+		Swizzle4<Vector4, 0x2001> zxxy;
+		Swizzle4<Vector4, 0x3001> wxxy;
+		Swizzle4<Vector4, 0x0101> xyxy;
+		Swizzle4<Vector4, 0x1101> yyxy;
+		Swizzle4<Vector4, 0x2101> zyxy;
+		Swizzle4<Vector4, 0x3101> wyxy;
+		Swizzle4<Vector4, 0x0201> xzxy;
+		Swizzle4<Vector4, 0x1201> yzxy;
+		Swizzle4<Vector4, 0x2201> zzxy;
+		Swizzle4<Vector4, 0x3201> wzxy;
+		Swizzle4<Vector4, 0x0301> xwxy;
+		Swizzle4<Vector4, 0x1301> ywxy;
+		Swizzle4<Vector4, 0x2301> zwxy;
+		Swizzle4<Vector4, 0x3301> wwxy;
+		Swizzle4<Vector4, 0x0011> xxyy;
+		Swizzle4<Vector4, 0x1011> yxyy;
+		Swizzle4<Vector4, 0x2011> zxyy;
+		Swizzle4<Vector4, 0x3011> wxyy;
+		Swizzle4<Vector4, 0x0111> xyyy;
+		Swizzle4<Vector4, 0x1111> yyyy;
+		Swizzle4<Vector4, 0x2111> zyyy;
+		Swizzle4<Vector4, 0x3111> wyyy;
+		Swizzle4<Vector4, 0x0211> xzyy;
+		Swizzle4<Vector4, 0x1211> yzyy;
+		Swizzle4<Vector4, 0x2211> zzyy;
+		Swizzle4<Vector4, 0x3211> wzyy;
+		Swizzle4<Vector4, 0x0311> xwyy;
+		Swizzle4<Vector4, 0x1311> ywyy;
+		Swizzle4<Vector4, 0x2311> zwyy;
+		Swizzle4<Vector4, 0x3311> wwyy;
+		Swizzle4<Vector4, 0x0021> xxzy;
+		Swizzle4<Vector4, 0x1021> yxzy;
+		Swizzle4<Vector4, 0x2021> zxzy;
+		Swizzle4<Vector4, 0x3021> wxzy;
+		Swizzle4<Vector4, 0x0121> xyzy;
+		Swizzle4<Vector4, 0x1121> yyzy;
+		Swizzle4<Vector4, 0x2121> zyzy;
+		Swizzle4<Vector4, 0x3121> wyzy;
+		Swizzle4<Vector4, 0x0221> xzzy;
+		Swizzle4<Vector4, 0x1221> yzzy;
+		Swizzle4<Vector4, 0x2221> zzzy;
+		Swizzle4<Vector4, 0x3221> wzzy;
+		Swizzle4<Vector4, 0x0321> xwzy;
+		Swizzle4<Vector4, 0x1321> ywzy;
+		Swizzle4<Vector4, 0x2321> zwzy;
+		Swizzle4<Vector4, 0x3321> wwzy;
+		Swizzle4<Vector4, 0x0031> xxwy;
+		Swizzle4<Vector4, 0x1031> yxwy;
+		Swizzle4<Vector4, 0x2031> zxwy;
+		Swizzle4<Vector4, 0x3031> wxwy;
+		Swizzle4<Vector4, 0x0131> xywy;
+		Swizzle4<Vector4, 0x1131> yywy;
+		Swizzle4<Vector4, 0x2131> zywy;
+		Swizzle4<Vector4, 0x3131> wywy;
+		Swizzle4<Vector4, 0x0231> xzwy;
+		Swizzle4<Vector4, 0x1231> yzwy;
+		Swizzle4<Vector4, 0x2231> zzwy;
+		Swizzle4<Vector4, 0x3231> wzwy;
+		Swizzle4<Vector4, 0x0331> xwwy;
+		Swizzle4<Vector4, 0x1331> ywwy;
+		Swizzle4<Vector4, 0x2331> zwwy;
+		Swizzle4<Vector4, 0x3331> wwwy;
+		Swizzle4<Vector4, 0x0002> xxxz;
+		Swizzle4<Vector4, 0x1002> yxxz;
+		Swizzle4<Vector4, 0x2002> zxxz;
+		Swizzle4<Vector4, 0x3002> wxxz;
+		Swizzle4<Vector4, 0x0102> xyxz;
+		Swizzle4<Vector4, 0x1102> yyxz;
+		Swizzle4<Vector4, 0x2102> zyxz;
+		Swizzle4<Vector4, 0x3102> wyxz;
+		Swizzle4<Vector4, 0x0202> xzxz;
+		Swizzle4<Vector4, 0x1202> yzxz;
+		Swizzle4<Vector4, 0x2202> zzxz;
+		Swizzle4<Vector4, 0x3202> wzxz;
+		Swizzle4<Vector4, 0x0302> xwxz;
+		Swizzle4<Vector4, 0x1302> ywxz;
+		Swizzle4<Vector4, 0x2302> zwxz;
+		Swizzle4<Vector4, 0x3302> wwxz;
+		Swizzle4<Vector4, 0x0012> xxyz;
+		Swizzle4<Vector4, 0x1012> yxyz;
+		Swizzle4<Vector4, 0x2012> zxyz;
+		Swizzle4<Vector4, 0x3012> wxyz;
+		Swizzle4<Vector4, 0x0112> xyyz;
+		Swizzle4<Vector4, 0x1112> yyyz;
+		Swizzle4<Vector4, 0x2112> zyyz;
+		Swizzle4<Vector4, 0x3112> wyyz;
+		Swizzle4<Vector4, 0x0212> xzyz;
+		Swizzle4<Vector4, 0x1212> yzyz;
+		Swizzle4<Vector4, 0x2212> zzyz;
+		Swizzle4<Vector4, 0x3212> wzyz;
+		Swizzle4<Vector4, 0x0312> xwyz;
+		Swizzle4<Vector4, 0x1312> ywyz;
+		Swizzle4<Vector4, 0x2312> zwyz;
+		Swizzle4<Vector4, 0x3312> wwyz;
+		Swizzle4<Vector4, 0x0022> xxzz;
+		Swizzle4<Vector4, 0x1022> yxzz;
+		Swizzle4<Vector4, 0x2022> zxzz;
+		Swizzle4<Vector4, 0x3022> wxzz;
+		Swizzle4<Vector4, 0x0122> xyzz;
+		Swizzle4<Vector4, 0x1122> yyzz;
+		Swizzle4<Vector4, 0x2122> zyzz;
+		Swizzle4<Vector4, 0x3122> wyzz;
+		Swizzle4<Vector4, 0x0222> xzzz;
+		Swizzle4<Vector4, 0x1222> yzzz;
+		Swizzle4<Vector4, 0x2222> zzzz;
+		Swizzle4<Vector4, 0x3222> wzzz;
+		Swizzle4<Vector4, 0x0322> xwzz;
+		Swizzle4<Vector4, 0x1322> ywzz;
+		Swizzle4<Vector4, 0x2322> zwzz;
+		Swizzle4<Vector4, 0x3322> wwzz;
+		Swizzle4<Vector4, 0x0032> xxwz;
+		Swizzle4<Vector4, 0x1032> yxwz;
+		Swizzle4<Vector4, 0x2032> zxwz;
+		Swizzle4<Vector4, 0x3032> wxwz;
+		Swizzle4<Vector4, 0x0132> xywz;
+		Swizzle4<Vector4, 0x1132> yywz;
+		Swizzle4<Vector4, 0x2132> zywz;
+		Swizzle4<Vector4, 0x3132> wywz;
+		Swizzle4<Vector4, 0x0232> xzwz;
+		Swizzle4<Vector4, 0x1232> yzwz;
+		Swizzle4<Vector4, 0x2232> zzwz;
+		Swizzle4<Vector4, 0x3232> wzwz;
+		Swizzle4<Vector4, 0x0332> xwwz;
+		Swizzle4<Vector4, 0x1332> ywwz;
+		Swizzle4<Vector4, 0x2332> zwwz;
+		Swizzle4<Vector4, 0x3332> wwwz;
+		Swizzle4<Vector4, 0x0003> xxxw;
+		Swizzle4<Vector4, 0x1003> yxxw;
+		Swizzle4<Vector4, 0x2003> zxxw;
+		Swizzle4<Vector4, 0x3003> wxxw;
+		Swizzle4<Vector4, 0x0103> xyxw;
+		Swizzle4<Vector4, 0x1103> yyxw;
+		Swizzle4<Vector4, 0x2103> zyxw;
+		Swizzle4<Vector4, 0x3103> wyxw;
+		Swizzle4<Vector4, 0x0203> xzxw;
+		Swizzle4<Vector4, 0x1203> yzxw;
+		Swizzle4<Vector4, 0x2203> zzxw;
+		Swizzle4<Vector4, 0x3203> wzxw;
+		Swizzle4<Vector4, 0x0303> xwxw;
+		Swizzle4<Vector4, 0x1303> ywxw;
+		Swizzle4<Vector4, 0x2303> zwxw;
+		Swizzle4<Vector4, 0x3303> wwxw;
+		Swizzle4<Vector4, 0x0013> xxyw;
+		Swizzle4<Vector4, 0x1013> yxyw;
+		Swizzle4<Vector4, 0x2013> zxyw;
+		Swizzle4<Vector4, 0x3013> wxyw;
+		Swizzle4<Vector4, 0x0113> xyyw;
+		Swizzle4<Vector4, 0x1113> yyyw;
+		Swizzle4<Vector4, 0x2113> zyyw;
+		Swizzle4<Vector4, 0x3113> wyyw;
+		Swizzle4<Vector4, 0x0213> xzyw;
+		Swizzle4<Vector4, 0x1213> yzyw;
+		Swizzle4<Vector4, 0x2213> zzyw;
+		Swizzle4<Vector4, 0x3213> wzyw;
+		Swizzle4<Vector4, 0x0313> xwyw;
+		Swizzle4<Vector4, 0x1313> ywyw;
+		Swizzle4<Vector4, 0x2313> zwyw;
+		Swizzle4<Vector4, 0x3313> wwyw;
+		Swizzle4<Vector4, 0x0023> xxzw;
+		Swizzle4<Vector4, 0x1023> yxzw;
+		Swizzle4<Vector4, 0x2023> zxzw;
+		Swizzle4<Vector4, 0x3023> wxzw;
 		SwizzleMask4<Vector4, 0x0123> xyzw;
-		Swizzle4<Vector4, 0x1123>     yyzw;
-		Swizzle4<Vector4, 0x2123>     zyzw;
-		Swizzle4<Vector4, 0x3123>     wyzw;
-		Swizzle4<Vector4, 0x0223>     xzzw;
-		Swizzle4<Vector4, 0x1223>     yzzw;
-		Swizzle4<Vector4, 0x2223>     zzzw;
-		Swizzle4<Vector4, 0x3223>     wzzw;
-		Swizzle4<Vector4, 0x0323>     xwzw;
-		Swizzle4<Vector4, 0x1323>     ywzw;
-		Swizzle4<Vector4, 0x2323>     zwzw;
-		Swizzle4<Vector4, 0x3323>     wwzw;
-		Swizzle4<Vector4, 0x0033>     xxww;
-		Swizzle4<Vector4, 0x1033>     yxww;
-		Swizzle4<Vector4, 0x2033>     zxww;
-		Swizzle4<Vector4, 0x3033>     wxww;
-		Swizzle4<Vector4, 0x0133>     xyww;
-		Swizzle4<Vector4, 0x1133>     yyww;
-		Swizzle4<Vector4, 0x2133>     zyww;
-		Swizzle4<Vector4, 0x3133>     wyww;
-		Swizzle4<Vector4, 0x0233>     xzww;
-		Swizzle4<Vector4, 0x1233>     yzww;
-		Swizzle4<Vector4, 0x2233>     zzww;
-		Swizzle4<Vector4, 0x3233>     wzww;
-		Swizzle4<Vector4, 0x0333>     xwww;
-		Swizzle4<Vector4, 0x1333>     ywww;
-		Swizzle4<Vector4, 0x2333>     zwww;
-		Swizzle4<Vector4, 0x3333>     wwww;
+		Swizzle4<Vector4, 0x1123> yyzw;
+		Swizzle4<Vector4, 0x2123> zyzw;
+		Swizzle4<Vector4, 0x3123> wyzw;
+		Swizzle4<Vector4, 0x0223> xzzw;
+		Swizzle4<Vector4, 0x1223> yzzw;
+		Swizzle4<Vector4, 0x2223> zzzw;
+		Swizzle4<Vector4, 0x3223> wzzw;
+		Swizzle4<Vector4, 0x0323> xwzw;
+		Swizzle4<Vector4, 0x1323> ywzw;
+		Swizzle4<Vector4, 0x2323> zwzw;
+		Swizzle4<Vector4, 0x3323> wwzw;
+		Swizzle4<Vector4, 0x0033> xxww;
+		Swizzle4<Vector4, 0x1033> yxww;
+		Swizzle4<Vector4, 0x2033> zxww;
+		Swizzle4<Vector4, 0x3033> wxww;
+		Swizzle4<Vector4, 0x0133> xyww;
+		Swizzle4<Vector4, 0x1133> yyww;
+		Swizzle4<Vector4, 0x2133> zyww;
+		Swizzle4<Vector4, 0x3133> wyww;
+		Swizzle4<Vector4, 0x0233> xzww;
+		Swizzle4<Vector4, 0x1233> yzww;
+		Swizzle4<Vector4, 0x2233> zzww;
+		Swizzle4<Vector4, 0x3233> wzww;
+		Swizzle4<Vector4, 0x0333> xwww;
+		Swizzle4<Vector4, 0x1333> ywww;
+		Swizzle4<Vector4, 0x2333> zwww;
+		Swizzle4<Vector4, 0x3333> wwww;
 	};
 };
 
@@ -1935,8 +1936,14 @@
 RValue<Int4> CmpNEQ(RValue<Int4> x, RValue<Int4> y);
 RValue<Int4> CmpNLT(RValue<Int4> x, RValue<Int4> y);
 RValue<Int4> CmpNLE(RValue<Int4> x, RValue<Int4> y);
-inline RValue<Int4> CmpGT(RValue<Int4> x, RValue<Int4> y) { return CmpNLE(x, y); }
-inline RValue<Int4> CmpGE(RValue<Int4> x, RValue<Int4> y) { return CmpNLT(x, y); }
+inline RValue<Int4> CmpGT(RValue<Int4> x, RValue<Int4> y)
+{
+	return CmpNLE(x, y);
+}
+inline RValue<Int4> CmpGE(RValue<Int4> x, RValue<Int4> y)
+{
+	return CmpNLT(x, y);
+}
 RValue<Int4> Max(RValue<Int4> x, RValue<Int4> y);
 RValue<Int4> Min(RValue<Int4> x, RValue<Int4> y);
 RValue<Int4> RoundInt(RValue<Float4> cast);
@@ -2022,8 +2029,14 @@
 RValue<UInt4> CmpNEQ(RValue<UInt4> x, RValue<UInt4> y);
 RValue<UInt4> CmpNLT(RValue<UInt4> x, RValue<UInt4> y);
 RValue<UInt4> CmpNLE(RValue<UInt4> x, RValue<UInt4> y);
-inline RValue<UInt4> CmpGT(RValue<UInt4> x, RValue<UInt4> y) { return CmpNLE(x, y); }
-inline RValue<UInt4> CmpGE(RValue<UInt4> x, RValue<UInt4> y) { return CmpNLT(x, y); }
+inline RValue<UInt4> CmpGT(RValue<UInt4> x, RValue<UInt4> y)
+{
+	return CmpNLE(x, y);
+}
+inline RValue<UInt4> CmpGE(RValue<UInt4> x, RValue<UInt4> y)
+{
+	return CmpNLT(x, y);
+}
 RValue<UInt4> Max(RValue<UInt4> x, RValue<UInt4> y);
 RValue<UInt4> Min(RValue<UInt4> x, RValue<UInt4> y);
 RValue<UInt4> MulHigh(RValue<UInt4> x, RValue<UInt4> y);
@@ -2058,7 +2071,7 @@
 	template<int T>
 	Float(const SwizzleMask1<Float4, T> &rhs);
 
-//	RValue<Float> operator=(float rhs);   // FIXME: Implement
+	//	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);
@@ -2128,35 +2141,35 @@
 class Float2 : public LValue<Float2>
 {
 public:
-//	explicit Float2(RValue<Byte2> cast);
-//	explicit Float2(RValue<Short2> cast);
-//	explicit Float2(RValue<UShort2> cast);
-//	explicit Float2(RValue<Int2> cast);
-//	explicit Float2(RValue<UInt2> cast);
+	//	explicit Float2(RValue<Byte2> cast);
+	//	explicit Float2(RValue<Short2> cast);
+	//	explicit Float2(RValue<UShort2> cast);
+	//	explicit Float2(RValue<Int2> cast);
+	//	explicit Float2(RValue<UInt2> cast);
 	explicit Float2(RValue<Float4> cast);
 
 	Float2() = default;
-//	Float2(float x, float y);
-//	Float2(RValue<Float2> rhs);
-//	Float2(const Float2 &rhs);
-//	Float2(const Reference<Float2> &rhs);
-//	Float2(RValue<Float> rhs);
-//	Float2(const Float &rhs);
-//	Float2(const Reference<Float> &rhs);
+	//	Float2(float x, float y);
+	//	Float2(RValue<Float2> rhs);
+	//	Float2(const Float2 &rhs);
+	//	Float2(const Reference<Float2> &rhs);
+	//	Float2(RValue<Float> rhs);
+	//	Float2(const Float &rhs);
+	//	Float2(const Reference<Float> &rhs);
 
-//	template<int T>
-//	Float2(const SwizzleMask1<T> &rhs);
+	//	template<int T>
+	//	Float2(const SwizzleMask1<T> &rhs);
 
-//	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);
+	//	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 SwizzleMask1<T> &rhs);
+	//	template<int T>
+	//	RValue<Float2> operator=(const SwizzleMask1<T> &rhs);
 
 	static Type *getType();
 };
@@ -2231,6 +2244,7 @@
 	static Type *getType();
 	static Float4 negative_inf();
 	static Float4 positive_inf();
+
 private:
 	void constant(float x, float y, float z, float w);
 	void infinity_constant(bool negative);
@@ -2272,8 +2286,14 @@
 RValue<Int4> CmpNEQ(RValue<Float4> x, RValue<Float4> y);
 RValue<Int4> CmpNLT(RValue<Float4> x, RValue<Float4> y);
 RValue<Int4> CmpNLE(RValue<Float4> x, RValue<Float4> y);
-inline RValue<Int4> CmpGT(RValue<Float4> x, RValue<Float4> y) { return CmpNLE(x, y); }
-inline RValue<Int4> CmpGE(RValue<Float4> x, RValue<Float4> y) { return CmpNLT(x, y); }
+inline RValue<Int4> CmpGT(RValue<Float4> x, RValue<Float4> y)
+{
+	return CmpNLE(x, y);
+}
+inline RValue<Int4> CmpGE(RValue<Float4> x, RValue<Float4> y)
+{
+	return CmpNLT(x, y);
+}
 
 // Unordered comparison functions
 RValue<Int4> CmpUEQ(RValue<Float4> x, RValue<Float4> y);
@@ -2282,8 +2302,14 @@
 RValue<Int4> CmpUNEQ(RValue<Float4> x, RValue<Float4> y);
 RValue<Int4> CmpUNLT(RValue<Float4> x, RValue<Float4> y);
 RValue<Int4> CmpUNLE(RValue<Float4> x, RValue<Float4> y);
-inline RValue<Int4> CmpUGT(RValue<Float4> x, RValue<Float4> y) { return CmpUNLE(x, y); }
-inline RValue<Int4> CmpUGE(RValue<Float4> x, RValue<Float4> y) { return CmpUNLT(x, y); }
+inline RValue<Int4> CmpUGT(RValue<Float4> x, RValue<Float4> y)
+{
+	return CmpUNLE(x, y);
+}
+inline RValue<Int4> CmpUGE(RValue<Float4> x, RValue<Float4> y)
+{
+	return CmpUNLT(x, y);
+}
 
 RValue<Int4> IsInf(RValue<Float4> x);
 RValue<Int4> IsNan(RValue<Float4> x);
@@ -2337,14 +2363,16 @@
 {
 public:
 	template<class S>
-	Pointer(RValue<Pointer<S>> pointerS, int alignment = 1) : alignment(alignment)
+	Pointer(RValue<Pointer<S>> pointerS, int alignment = 1)
+	    : alignment(alignment)
 	{
 		Value *pointerT = Nucleus::createBitCast(pointerS.value, Nucleus::getPointerType(T::getType()));
 		LValue<Pointer<T>>::storeValue(pointerT);
 	}
 
 	template<class S>
-	Pointer(const Pointer<S> &pointer, int alignment = 1) : alignment(alignment)
+	Pointer(const Pointer<S> &pointer, int alignment = 1)
+	    : alignment(alignment)
 	{
 		Value *pointerS = pointer.loadValue();
 		Value *pointerT = Nucleus::createBitCast(pointerS, Nucleus::getPointerType(T::getType()));
@@ -2390,7 +2418,7 @@
 RValue<Pointer<Byte>> operator-=(Pointer<Byte> &lhs, RValue<Int> offset);
 RValue<Pointer<Byte>> operator-=(Pointer<Byte> &lhs, RValue<UInt> offset);
 
-template <typename T>
+template<typename T>
 RValue<Bool> operator==(const Pointer<T> &lhs, const Pointer<T> &rhs)
 {
 	return RValue<Bool>(Nucleus::createPtrEQ(lhs.loadValue(), rhs.loadValue()));
@@ -2456,7 +2484,7 @@
 
 	// self() returns the this pointer to this Array object.
 	// This function exists because operator&() is overloaded by LValue<T>.
-	inline Array* self() { return this; }
+	inline Array *self() { return this; }
 };
 
 //	RValue<Array<T>> operator++(Array<T> &val, int);   // Post-increment
@@ -2468,8 +2496,8 @@
 
 // ValueOf returns a rr::Value* for the given C-type, RValue<T>, LValue<T>
 // or Reference<T>.
-template <typename T>
-inline Value* ValueOf(const T &v)
+template<typename T>
+inline Value *ValueOf(const T &v)
 {
 	return ReactorType<T>::cast(v).loadValue();
 }
@@ -2479,7 +2507,7 @@
 template<class T>
 void Return(const T &ret)
 {
-	static_assert(CanBeUsedAsReturn< ReactorTypeT<T> >::value, "Unsupported type for Return()");
+	static_assert(CanBeUsedAsReturn<ReactorTypeT<T>>::value, "Unsupported type for Return()");
 	Nucleus::createRet(ValueOf<T>(ret));
 	// Place any unreachable instructions in an unreferenced block.
 	Nucleus::setInsertBlock(Nucleus::createBasicBlock());
@@ -2513,7 +2541,7 @@
 
 protected:
 	Nucleus *core;
-	std::vector<Type*> arguments;
+	std::vector<Type *> arguments;
 };
 
 template<typename Return>
@@ -2543,12 +2571,12 @@
 
 	// Hide base implementations of operator()
 
-	RoutineType operator()(const char* name, ...)
+	RoutineType operator()(const char *name, ...)
 	{
 		return RoutineType(BaseType::operator()(name));
 	}
 
-	RoutineType operator()(const Config::Edit& cfg, const char* name, ...)
+	RoutineType operator()(const Config::Edit &cfg, const char *name, ...)
 	{
 		return RoutineType(BaseType::operator()(cfg, name));
 	}
@@ -2563,11 +2591,12 @@
 namespace rr {
 
 template<class T>
-LValue<T>::LValue(int arraySize) : Variable(T::getType(), arraySize)
+LValue<T>::LValue(int arraySize)
+    : Variable(T::getType(), arraySize)
 {
 #ifdef ENABLE_RR_DEBUG_INFO
 	materialize();
-#endif // ENABLE_RR_DEBUG_INFO
+#endif  // ENABLE_RR_DEBUG_INFO
 }
 
 inline void Variable::materialize() const
@@ -2632,7 +2661,8 @@
 }
 
 template<class T>
-Reference<T>::Reference(Value *pointer, int alignment) : alignment(alignment)
+Reference<T>::Reference(Value *pointer, int alignment)
+    : alignment(alignment)
 {
 	address = pointer;
 }
@@ -2674,16 +2704,17 @@
 
 #ifdef ENABLE_RR_DEBUG_INFO
 template<class T>
-RValue<T>::RValue(const RValue<T> &rvalue) : value(rvalue.value)
+RValue<T>::RValue(const RValue<T> &rvalue)
+    : value(rvalue.value)
 {
 	RR_DEBUG_INFO_EMIT_VAR(value);
 }
-#endif // ENABLE_RR_DEBUG_INFO
+#endif  // ENABLE_RR_DEBUG_INFO
 
 template<class T>
 RValue<T>::RValue(Value *rvalue)
 {
-	assert(Nucleus::createBitCast(rvalue, T::getType()) == rvalue);   // Run-time type should match T, so bitcast is no-op.
+	assert(Nucleus::createBitCast(rvalue, T::getType()) == rvalue);  // Run-time type should match T, so bitcast is no-op.
 
 	value = rvalue;
 	RR_DEBUG_INFO_EMIT_VAR(value);
@@ -2766,7 +2797,7 @@
 }
 
 template<class Vector4, int T>
-SwizzleMask1<Vector4, T>::operator RValue<typename Scalar<Vector4>::Type>() const   // FIXME: Call a non-template function
+SwizzleMask1<Vector4, T>::operator RValue<typename Scalar<Vector4>::Type>() const  // FIXME: Call a non-template function
 {
 	RR_DEBUG_INFO_UPDATE_LOC();
 	return Extract(*parent, T & 0x3);
@@ -2796,7 +2827,7 @@
 }
 
 template<class Vector4, int T>
-RValue<Vector4> SwizzleMask1<Vector4, T>::operator=(RValue<typename Scalar<Vector4>::Type> rhs)   // FIXME: Call a non-template function
+RValue<Vector4> SwizzleMask1<Vector4, T>::operator=(RValue<typename Scalar<Vector4>::Type> rhs)  // FIXME: Call a non-template function
 {
 	RR_DEBUG_INFO_UPDATE_LOC();
 	return *parent = Insert(*parent, rhs, T & 0x3);
@@ -2831,40 +2862,46 @@
 }
 
 template<int T>
-Float4::Float4(const SwizzleMask1<Float4, T> &rhs) : XYZW(this)
+Float4::Float4(const SwizzleMask1<Float4, T> &rhs)
+    : XYZW(this)
 {
 	*this = rhs.operator RValue<Float4>();
 }
 
 template<int T>
-Float4::Float4(const Swizzle4<Float4, T> &rhs) : XYZW(this)
+Float4::Float4(const Swizzle4<Float4, T> &rhs)
+    : XYZW(this)
 {
 	*this = rhs.operator RValue<Float4>();
 }
 
 template<int X, int Y>
-Float4::Float4(const Swizzle2<Float4, X> &x, const Swizzle2<Float4, Y> &y) : XYZW(this)
+Float4::Float4(const Swizzle2<Float4, X> &x, const Swizzle2<Float4, Y> &y)
+    : XYZW(this)
 {
 	RR_DEBUG_INFO_UPDATE_LOC();
 	*this = ShuffleLowHigh(*x.parent, *y.parent, (uint16_t(X) & 0xFF00u) | (uint16_t(Y >> 8) & 0x00FFu));
 }
 
 template<int X, int Y>
-Float4::Float4(const SwizzleMask2<Float4, X> &x, const Swizzle2<Float4, Y> &y) : XYZW(this)
+Float4::Float4(const SwizzleMask2<Float4, X> &x, const Swizzle2<Float4, Y> &y)
+    : XYZW(this)
 {
 	RR_DEBUG_INFO_UPDATE_LOC();
 	*this = ShuffleLowHigh(*x.parent, *y.parent, (uint16_t(X) & 0xFF00u) | (uint16_t(Y >> 8) & 0x00FFu));
 }
 
 template<int X, int Y>
-Float4::Float4(const Swizzle2<Float4, X> &x, const SwizzleMask2<Float4, Y> &y) : XYZW(this)
+Float4::Float4(const Swizzle2<Float4, X> &x, const SwizzleMask2<Float4, Y> &y)
+    : XYZW(this)
 {
 	RR_DEBUG_INFO_UPDATE_LOC();
 	*this = ShuffleLowHigh(*x.parent, *y.parent, (uint16_t(X) & 0xFF00u) | (uint16_t(Y >> 8) & 0x00FFu));
 }
 
 template<int X, int Y>
-Float4::Float4(const SwizzleMask2<Float4, X> &x, const SwizzleMask2<Float4, Y> &y) : XYZW(this)
+Float4::Float4(const SwizzleMask2<Float4, X> &x, const SwizzleMask2<Float4, Y> &y)
+    : XYZW(this)
 {
 	RR_DEBUG_INFO_UPDATE_LOC();
 	*this = ShuffleLowHigh(*x.parent, *y.parent, (uint16_t(X) & 0xFF00u) | (uint16_t(Y >> 8) & 0x00FFu));
@@ -2883,42 +2920,49 @@
 }
 
 // Returns a reactor pointer to the fixed-address ptr.
-RValue<Pointer<Byte>> ConstantPointer(void const * ptr);
+RValue<Pointer<Byte>> ConstantPointer(void const *ptr);
 
 // Returns a reactor pointer to an immutable copy of the data of size bytes.
-RValue<Pointer<Byte>> ConstantData(void const * data, size_t size);
+RValue<Pointer<Byte>> ConstantData(void const *data, size_t size);
 
 template<class T>
-Pointer<T>::Pointer(Argument<Pointer<T>> argument) : alignment(1)
+Pointer<T>::Pointer(Argument<Pointer<T>> argument)
+    : alignment(1)
 {
 	LValue<Pointer<T>>::storeValue(argument.value);
 }
 
 template<class T>
-Pointer<T>::Pointer() : alignment(1) {}
+Pointer<T>::Pointer()
+    : alignment(1)
+{}
 
 template<class T>
-Pointer<T>::Pointer(RValue<Pointer<T>> rhs) : alignment(1)
+Pointer<T>::Pointer(RValue<Pointer<T>> rhs)
+    : alignment(1)
 {
 	LValue<Pointer<T>>::storeValue(rhs.value);
 }
 
 template<class T>
-Pointer<T>::Pointer(const Pointer<T> &rhs) : alignment(rhs.alignment)
+Pointer<T>::Pointer(const Pointer<T> &rhs)
+    : alignment(rhs.alignment)
 {
 	Value *value = rhs.loadValue();
 	LValue<Pointer<T>>::storeValue(value);
 }
 
 template<class T>
-Pointer<T>::Pointer(const Reference<Pointer<T>> &rhs) : alignment(rhs.getAlignment())
+Pointer<T>::Pointer(const Reference<Pointer<T>> &rhs)
+    : alignment(rhs.getAlignment())
 {
 	Value *value = rhs.loadValue();
 	LValue<Pointer<T>>::storeValue(value);
 }
 
 template<class T>
-Pointer<T>::Pointer(std::nullptr_t) : alignment(1)
+Pointer<T>::Pointer(std::nullptr_t)
+    : alignment(1)
 {
 	Value *value = Nucleus::createNullPointer(T::getType());
 	LValue<Pointer<T>>::storeValue(value);
@@ -3008,7 +3052,8 @@
 }
 
 template<class T, int S>
-Array<T, S>::Array(int size) : LValue<T>(size)
+Array<T, S>::Array(int size)
+    : LValue<T>(size)
 {
 }
 
@@ -3110,7 +3155,7 @@
 {
 	core = new Nucleus();
 
-	Type *types[] = {Arguments::getType()...};
+	Type *types[] = { Arguments::getType()... };
 	for(Type *type : types)
 	{
 		if(type != Void::getType())
@@ -3204,12 +3249,13 @@
 // Calls the function pointer fptr with the given arguments, return type
 // and parameter types. Returns the call's return value if the function has
 // a non-void return type.
-Value* Call(RValue<Pointer<Byte>> fptr, Type* retTy, std::initializer_list<Value*> args, std::initializer_list<Type*> paramTys);
+Value *Call(RValue<Pointer<Byte>> fptr, Type *retTy, std::initializer_list<Value *> args, std::initializer_list<Type *> paramTys);
 
-template <typename F>
-class CallHelper {};
+template<typename F>
+class CallHelper
+{};
 
-template<typename Return, typename ... Arguments>
+template<typename Return, typename... Arguments>
 class CallHelper<Return(Arguments...)>
 {
 public:
@@ -3218,74 +3264,77 @@
 	static inline RReturn Call(Return(fptr)(Arguments...), CToReactorT<Arguments>... args)
 	{
 		return RValue<RReturn>(rr::Call(
-			ConstantPointer(reinterpret_cast<void*>(fptr)),
-			RReturn::getType(),
-			{ ValueOf(args) ... },
-			{ CToReactorT<Arguments>::getType() ... }));
+		    ConstantPointer(reinterpret_cast<void *>(fptr)),
+		    RReturn::getType(),
+		    { ValueOf(args)... },
+		    { CToReactorT<Arguments>::getType()... }));
 	}
 
 	static inline RReturn Call(Pointer<Byte> fptr, CToReactorT<Arguments>... args)
 	{
 		return RValue<RReturn>(rr::Call(
-			fptr,
-			RReturn::getType(),
-			{ ValueOf(args) ... },
-			{ CToReactorT<Arguments>::getType() ... }));
+		    fptr,
+		    RReturn::getType(),
+		    { ValueOf(args)... },
+		    { CToReactorT<Arguments>::getType()... }));
 	}
 };
 
-template<typename ... Arguments>
+template<typename... Arguments>
 class CallHelper<void(Arguments...)>
 {
 public:
 	static inline void Call(void(fptr)(Arguments...), CToReactorT<Arguments>... args)
 	{
-		rr::Call(ConstantPointer(reinterpret_cast<void*>(fptr)),
-			Void::getType(),
-			{ ValueOf(args) ... },
-			{ CToReactorT<Arguments>::getType() ... });
+		rr::Call(ConstantPointer(reinterpret_cast<void *>(fptr)),
+		         Void::getType(),
+		         { ValueOf(args)... },
+		         { CToReactorT<Arguments>::getType()... });
 	}
 
 	static inline void Call(Pointer<Byte> fptr, CToReactorT<Arguments>... args)
 	{
 		rr::Call(fptr,
-			Void::getType(),
-			{ ValueOf(args) ... },
-			{ CToReactorT<Arguments>::getType() ... });
+		         Void::getType(),
+		         { ValueOf(args)... },
+		         { CToReactorT<Arguments>::getType()... });
 	}
 };
 
-template <typename T>
-inline ReactorTypeT<T> CastToReactor(const T& v) { return ReactorType<T>::cast(v); }
+template<typename T>
+inline ReactorTypeT<T> CastToReactor(const T &v)
+{
+	return ReactorType<T>::cast(v);
+}
 
 // Calls the static function pointer fptr with the given arguments args.
-template<typename Return, typename ... CArgs, typename ... RArgs>
-inline CToReactorT<Return> Call(Return(fptr)(CArgs...), RArgs&&... args)
+template<typename Return, typename... CArgs, typename... RArgs>
+inline CToReactorT<Return> Call(Return(fptr)(CArgs...), RArgs &&... args)
 {
 	return CallHelper<Return(CArgs...)>::Call(fptr, CastToReactor(std::forward<RArgs>(args))...);
 }
 
 // Calls the static function pointer fptr with the given arguments args.
 // Overload for calling functions with void return type.
-template<typename ... CArgs, typename ... RArgs>
-inline void Call(void(fptr)(CArgs...), RArgs&&... args)
+template<typename... CArgs, typename... RArgs>
+inline void Call(void(fptr)(CArgs...), RArgs &&... args)
 {
 	CallHelper<void(CArgs...)>::Call(fptr, CastToReactor(std::forward<RArgs>(args))...);
 }
 
 // Calls the member function pointer fptr with the given arguments args.
 // object can be a Class*, or a Pointer<Byte>.
-template<typename Return, typename Class, typename C, typename ... CArgs, typename ... RArgs>
-inline CToReactorT<Return> Call(Return(Class::* fptr)(CArgs...), C&& object, RArgs&&... args)
+template<typename Return, typename Class, typename C, typename... CArgs, typename... RArgs>
+inline CToReactorT<Return> Call(Return (Class::*fptr)(CArgs...), C &&object, RArgs &&... args)
 {
-	using Helper = CallHelper<Return(Class*, void*, CArgs...)>;
+	using Helper = CallHelper<Return(Class *, void *, CArgs...)>;
 	using fptrTy = decltype(fptr);
 
 	struct Static
 	{
-		static inline Return Call(Class* object, void* fptrptr, CArgs... args)
+		static inline Return Call(Class *object, void *fptrptr, CArgs... args)
 		{
-			auto fptr = *reinterpret_cast<fptrTy*>(fptrptr);
+			auto fptr = *reinterpret_cast<fptrTy *>(fptrptr);
 			return (object->*fptr)(std::forward<CArgs>(args)...);
 		}
 	};
@@ -3299,17 +3348,17 @@
 // Calls the member function pointer fptr with the given arguments args.
 // Overload for calling functions with void return type.
 // object can be a Class*, or a Pointer<Byte>.
-template<typename Class, typename C, typename ... CArgs, typename ... RArgs>
-inline void Call(void(Class::* fptr)(CArgs...), C&& object, RArgs&&... args)
+template<typename Class, typename C, typename... CArgs, typename... RArgs>
+inline void Call(void (Class::*fptr)(CArgs...), C &&object, RArgs &&... args)
 {
-	using Helper = CallHelper<void(Class*, void*, CArgs...)>;
+	using Helper = CallHelper<void(Class *, void *, CArgs...)>;
 	using fptrTy = decltype(fptr);
 
 	struct Static
 	{
-		static inline void Call(Class* object, void* fptrptr, CArgs... args)
+		static inline void Call(Class *object, void *fptrptr, CArgs... args)
 		{
-			auto fptr = *reinterpret_cast<fptrTy*>(fptrptr);
+			auto fptr = *reinterpret_cast<fptrTy *>(fptrptr);
 			(object->*fptr)(std::forward<CArgs>(args)...);
 		}
 	};
@@ -3322,8 +3371,8 @@
 
 // Calls the Reactor function pointer fptr with the signature
 // FUNCTION_SIGNATURE and arguments.
-template<typename FUNCTION_SIGNATURE, typename ... RArgs>
-inline void Call(Pointer<Byte> fptr, RArgs&& ... args)
+template<typename FUNCTION_SIGNATURE, typename... RArgs>
+inline void Call(Pointer<Byte> fptr, RArgs &&... args)
 {
 	CallHelper<FUNCTION_SIGNATURE>::Call(fptr, CastToReactor(std::forward<RArgs>(args))...);
 }
@@ -3335,7 +3384,8 @@
 class ForData
 {
 public:
-	ForData(bool init) : loopOnce(init)
+	ForData(bool init)
+	    : loopOnce(init)
 	{
 	}
 
@@ -3391,7 +3441,8 @@
 class IfElseData
 {
 public:
-	IfElseData(RValue<Bool> cmp) : iteration(0)
+	IfElseData(RValue<Bool> cmp)
+	    : iteration(0)
 	{
 		condition = cmp.value;
 
@@ -3442,39 +3493,48 @@
 	int iteration;
 };
 
-#define For(init, cond, inc) \
-for(ForData for__ = true; for__; for__ = false) \
-for(init; for__.setup() && for__.test(cond); inc, for__.end())
+#define For(init, cond, inc)                        \
+	for(ForData for__ = true; for__; for__ = false) \
+		for(init; for__.setup() && for__.test(cond); inc, for__.end())
 
 #define While(cond) For((void)0, cond, (void)0)
 
-#define Do                                            \
-{                                                     \
-	BasicBlock *body__ = Nucleus::createBasicBlock(); \
-	Nucleus::createBr(body__);                        \
-	Nucleus::setInsertBlock(body__);
+#define Do                                                \
+	{                                                     \
+		BasicBlock *body__ = Nucleus::createBasicBlock(); \
+		Nucleus::createBr(body__);                        \
+		Nucleus::setInsertBlock(body__);
 
 #define Until(cond)                                     \
 	BasicBlock *end__ = Nucleus::createBasicBlock();    \
 	Nucleus::createCondBr((cond).value, end__, body__); \
 	Nucleus::setInsertBlock(end__);                     \
-} do {} while(false) // Require a semi-colon at the end of the Until()
+	}                                                   \
+	do                                                  \
+	{                                                   \
+	} while(false)  // Require a semi-colon at the end of the Until()
 
-enum {IF_BLOCK__, ELSE_CLAUSE__, ELSE_BLOCK__, IFELSE_NUM__};
+enum
+{
+	IF_BLOCK__,
+	ELSE_CLAUSE__,
+	ELSE_BLOCK__,
+	IFELSE_NUM__
+};
 
-#define If(cond)                                                    \
-for(IfElseData ifElse__(cond); ifElse__ < IFELSE_NUM__; ++ifElse__) \
-if(ifElse__ == IF_BLOCK__)
+#define If(cond)                                                        \
+	for(IfElseData ifElse__(cond); ifElse__ < IFELSE_NUM__; ++ifElse__) \
+		if(ifElse__ == IF_BLOCK__)
 
-#define Else                       \
-else if(ifElse__ == ELSE_CLAUSE__) \
-{                                  \
-	ifElse__.elseClause();         \
-}                                  \
-else  // ELSE_BLOCK__
+#define Else                           \
+	else if(ifElse__ == ELSE_CLAUSE__) \
+	{                                  \
+		ifElse__.elseClause();         \
+	}                                  \
+	else  // ELSE_BLOCK__
 
 }  // namespace rr
 
 #include "Traits.inl"
 
-#endif   // rr_Reactor_hpp
+#endif  // rr_Reactor_hpp
diff --git a/src/Reactor/ReactorUnitTests.cpp b/src/Reactor/ReactorUnitTests.cpp
index 8ffeb7c..ff69d2f 100644
--- a/src/Reactor/ReactorUnitTests.cpp
+++ b/src/Reactor/ReactorUnitTests.cpp
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "Reactor.hpp"
 #include "Coroutine.hpp"
+#include "Reactor.hpp"
 
 #include "gtest/gtest.h"
 
@@ -30,8 +30,12 @@
 struct float4_value
 {
 	float4_value() = default;
-	explicit float4_value(float rep) : v{ rep, rep, rep, rep } {}
-	float4_value(float x, float y, float z, float w) : v{ x, y, z, w } {}
+	explicit float4_value(float rep)
+	    : v{ rep, rep, rep, rep }
+	{}
+	float4_value(float x, float y, float z, float w)
+	    : v{ x, y, z, w }
+	{}
 
 	bool operator==(const float4_value &rhs) const
 	{
@@ -39,7 +43,8 @@
 	}
 
 	// For gtest printing
-	friend std::ostream& operator<<(std::ostream& os, const float4_value& value) {
+	friend std::ostream &operator<<(std::ostream &os, const float4_value &value)
+	{
 		return os << "[" << value.v[0] << ", " << value.v[1] << ", " << value.v[2] << ", " << value.v[3] << "]";
 	}
 
@@ -47,26 +52,25 @@
 };
 
 // For gtest printing of pairs
-namespace std
+namespace std {
+template<typename T, typename U>
+std::ostream &operator<<(std::ostream &os, const std::pair<T, U> &value)
 {
-	template <typename T, typename U>
-	std::ostream& operator<<(std::ostream& os, const std::pair<T, U>& value) {
-		return os << "{ " << value.first << ", " << value.second << " }";
-	}
+	return os << "{ " << value.first << ", " << value.second << " }";
 }
-
+}  // namespace std
 
 // Invoke a void(float4*) routine on &v.v, returning wrapped result in v
-template <typename RoutineType>
-float4_value invokeRoutine(RoutineType& routine, float4_value v)
+template<typename RoutineType>
+float4_value invokeRoutine(RoutineType &routine, float4_value v)
 {
 	routine(&v.v);
 	return v;
 }
 
 // Invoke a void(float4*, float4*) routine on &v1.v, &v2.v returning wrapped result in v1
-template <typename RoutineType>
-float4_value invokeRoutine(RoutineType& routine, float4_value v1, float4_value v2)
+template<typename RoutineType>
+float4_value invokeRoutine(RoutineType &routine, float4_value v1, float4_value v2)
 {
 	routine(&v1.v, &v2.v);
 	return v1;
@@ -89,7 +93,7 @@
 
 TEST(ReactorUnitTests, Sample)
 {
-	FunctionT<int(int*, int)> function;
+	FunctionT<int(int *, int)> function;
 	{
 		Pointer<Int> p = function.Arg<0>();
 		Int x = p[-1];
@@ -114,7 +118,7 @@
 
 	if(routine)
 	{
-		int one[2] = {1, 0};
+		int one[2] = { 1, 0 };
 		int result = routine(&one[1], 2);
 		EXPECT_EQ(result, reference(&one[1], 2));
 	}
@@ -146,7 +150,7 @@
 	if(routine)
 	{
 		int result = routine();
-		EXPECT_EQ(result, result);   // Anything is fine, just don't crash
+		EXPECT_EQ(result, result);  // Anything is fine, just don't crash
 	}
 }
 
@@ -197,15 +201,15 @@
 
 TEST(ReactorUnitTests, SubVectorLoadStore)
 {
-	FunctionT<int(void*, void*)> function;
+	FunctionT<int(void *, void *)> function;
 	{
 		Pointer<Byte> in = function.Arg<0>();
 		Pointer<Byte> out = function.Arg<1>();
 
-		*Pointer<Int4>(out + 16 * 0)   = *Pointer<Int4>(in + 16 * 0);
+		*Pointer<Int4>(out + 16 * 0) = *Pointer<Int4>(in + 16 * 0);
 		*Pointer<Short4>(out + 16 * 1) = *Pointer<Short4>(in + 16 * 1);
-		*Pointer<Byte8>(out + 16 * 2)  = *Pointer<Byte8>(in + 16 * 2);
-		*Pointer<Byte4>(out + 16 * 3)  = *Pointer<Byte4>(in + 16 * 3);
+		*Pointer<Byte8>(out + 16 * 2) = *Pointer<Byte8>(in + 16 * 2);
+		*Pointer<Byte4>(out + 16 * 3) = *Pointer<Byte4>(in + 16 * 3);
 		*Pointer<Short2>(out + 16 * 4) = *Pointer<Short2>(in + 16 * 4);
 
 		Return(0);
@@ -215,17 +219,17 @@
 
 	if(routine)
 	{
-		int8_t in[16 * 5] = {1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16,
-			                    17, 18, 19, 20, 21, 22, 23, 24,  0,  0,  0,  0,  0,  0,  0,  0,
-			                    25, 26, 27, 28, 29, 30, 31, 32,  0,  0,  0,  0,  0,  0,  0,  0,
-			                    33, 34, 35, 36,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-			                    37, 38, 39, 40,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0};
+		int8_t in[16 * 5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
+			                  17, 18, 19, 20, 21, 22, 23, 24, 0, 0, 0, 0, 0, 0, 0, 0,
+			                  25, 26, 27, 28, 29, 30, 31, 32, 0, 0, 0, 0, 0, 0, 0, 0,
+			                  33, 34, 35, 36, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+			                  37, 38, 39, 40, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 
-		int8_t out[16 * 5] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-			                    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-			                    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-			                    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-			                    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
+		int8_t out[16 * 5] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+			                   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+			                   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+			                   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+			                   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 };
 
 		routine(in, out);
 
@@ -235,9 +239,9 @@
 			{
 				int i = row * 16 + col;
 
-				if(in[i] ==  0)
+				if(in[i] == 0)
 				{
-					EXPECT_EQ(out[i], -1) << "Row " << row << " column " << col <<  " not left untouched.";
+					EXPECT_EQ(out[i], -1) << "Row " << row << " column " << col << " not left untouched.";
 				}
 				else
 				{
@@ -250,7 +254,7 @@
 
 TEST(ReactorUnitTests, VectorConstant)
 {
-	FunctionT<int(void*)> function;
+	FunctionT<int(void *)> function;
 	{
 		Pointer<Byte> out = function.Arg<0>();
 
@@ -266,15 +270,15 @@
 
 	if(routine)
 	{
-		int8_t out[16 * 4] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-			                    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-			                    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-			                    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
+		int8_t out[16 * 4] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+			                   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+			                   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+			                   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 };
 
-		int8_t exp[16 * 4] = {1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,
-			                    17, 18, 19, 20, 21, 22, 23, 24, -1, -1, -1, -1, -1, -1, -1, -1,
-			                    25, 26, 27, 28, 29, 30, 31, 32, -1, -1, -1, -1, -1, -1, -1, -1,
-			                    33, 34, 35, 36, 37, 38, 39, 40, -1, -1, -1, -1, -1, -1, -1, -1};
+		int8_t exp[16 * 4] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
+			                   17, 18, 19, 20, 21, 22, 23, 24, -1, -1, -1, -1, -1, -1, -1, -1,
+			                   25, 26, 27, 28, 29, 30, 31, 32, -1, -1, -1, -1, -1, -1, -1, -1,
+			                   33, 34, 35, 36, 37, 38, 39, 40, -1, -1, -1, -1, -1, -1, -1, -1 };
 
 		routine(out);
 
@@ -292,11 +296,11 @@
 
 TEST(ReactorUnitTests, Concatenate)
 {
-	FunctionT<int(void*)> function;
+	FunctionT<int(void *)> function;
 	{
 		Pointer<Byte> out = function.Arg<0>();
 
-		*Pointer<Int4>(out + 16 * 0)   = Int4(Int2(0x04030201, 0x08070605), Int2(0x0C0B0A09, 0x100F0E0D));
+		*Pointer<Int4>(out + 16 * 0) = Int4(Int2(0x04030201, 0x08070605), Int2(0x0C0B0A09, 0x100F0E0D));
 		*Pointer<Short8>(out + 16 * 1) = Short8(Short4(0x0201, 0x0403, 0x0605, 0x0807), Short4(0x0A09, 0x0C0B, 0x0E0D, 0x100F));
 
 		Return(0);
@@ -306,11 +310,11 @@
 
 	if(routine)
 	{
-		int8_t ref[16 * 5] = {1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16,
-			                    1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16};
+		int8_t ref[16 * 5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
+			                   1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
 
-		int8_t out[16 * 5] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-			                    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
+		int8_t out[16 * 5] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+			                   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 };
 
 		routine(out);
 
@@ -328,8 +332,7 @@
 
 TEST(ReactorUnitTests, Swizzle)
 {
-	auto swizzleCode = [](int i) -> uint16_t
-	{
+	auto swizzleCode = [](int i) -> uint16_t {
 		auto x = (i >> 0) & 0x03;
 		auto y = (i >> 2) & 0x03;
 		auto z = (i >> 4) & 0x03;
@@ -338,7 +341,7 @@
 	};
 
 	{
-		FunctionT<int(void*)> function;
+		FunctionT<int(void *)> function;
 		{
 			Pointer<Byte> out = function.Arg<0>();
 
@@ -362,13 +365,13 @@
 			for(int i = 0; i < 256; i++)
 			{
 				*Pointer<Short4>(out + 16 * (512 + 6) + (8 * i)) =
-                                    Swizzle(Short4(1, 2, 3, 4), swizzleCode(i));
+				    Swizzle(Short4(1, 2, 3, 4), swizzleCode(i));
 			}
 
 			for(int i = 0; i < 256; i++)
 			{
 				*Pointer<Int4>(out + 16 * (512 + 6 + i) + (8 * 256)) =
-                                    Swizzle(Int4(1, 2, 3, 4), swizzleCode(i));
+				    Swizzle(Int4(1, 2, 3, 4), swizzleCode(i));
 			}
 
 			Return(0);
@@ -436,14 +439,14 @@
 
 			for(int i = 0; i < 256; i++)
 			{
-				EXPECT_EQ(out.i[4 + i/2][0 + (i%2) * 2] & 0xFFFF,
-                                          ((i >> 0) & 0x03) + 1);
-				EXPECT_EQ(out.i[4 + i/2][0 + (i%2) * 2] >> 16,
-                                          ((i >> 2) & 0x03) + 1);
-				EXPECT_EQ(out.i[4 + i/2][1 + (i%2) * 2] & 0xFFFF,
-                                          ((i >> 4) & 0x03) + 1);
-				EXPECT_EQ(out.i[4 + i/2][1 + (i%2) * 2] >> 16,
-                                          ((i >> 6) & 0x03) + 1);
+				EXPECT_EQ(out.i[4 + i / 2][0 + (i % 2) * 2] & 0xFFFF,
+				          ((i >> 0) & 0x03) + 1);
+				EXPECT_EQ(out.i[4 + i / 2][0 + (i % 2) * 2] >> 16,
+				          ((i >> 2) & 0x03) + 1);
+				EXPECT_EQ(out.i[4 + i / 2][1 + (i % 2) * 2] & 0xFFFF,
+				          ((i >> 4) & 0x03) + 1);
+				EXPECT_EQ(out.i[4 + i / 2][1 + (i % 2) * 2] >> 16,
+				          ((i >> 6) & 0x03) + 1);
 			}
 
 			for(int i = 0; i < 256; i++)
@@ -483,14 +486,13 @@
 
 		auto rangeIndexToSelect = [](int i) {
 			return static_cast<unsigned short>(
-				(((i >> 9) & 7) << 0) |
-				(((i >> 6) & 7) << 4) |
-				(((i >> 3) & 7) << 8) |
-				(((i >> 0) & 7) << 12)
-			);
+			    (((i >> 9) & 7) << 0) |
+			    (((i >> 6) & 7) << 4) |
+			    (((i >> 3) & 7) << 8) |
+			    (((i >> 0) & 7) << 12));
 		};
 
-		FunctionT<int(void*)> function;
+		FunctionT<int(void *)> function;
 		{
 			Pointer<Byte> out = function.Arg<0>();
 
@@ -554,7 +556,6 @@
 			}
 		}
 	}
-
 }
 
 TEST(ReactorUnitTests, Branching)
@@ -583,24 +584,23 @@
 			}
 
 			For(Int i = 0, i < 5, i++)
-				x += 10000;
+			    x += 10000;
 		}
 
-		For(Int i = 0, i < 10, i++)
-			for(int i = 0; i < 10; i++)
-				For(Int i = 0, i < 10, i++)
-				{
-					x += 1000000;
-				}
+		For(Int i = 0, i < 10, i++) for(int i = 0; i < 10; i++)
+		    For(Int i = 0, i < 10, i++)
+		{
+			x += 1000000;
+		}
 
 		For(Int i = 0, i < 2, i++)
-			If(x == 1000402222)
-			{
-				If(x != 1000402222)
-					x += 1000000000;
-			}
-			Else
-				x = -5;
+		    If(x == 1000402222)
+		{
+			If(x != 1000402222)
+			    x += 1000000000;
+		}
+		Else
+		    x = -5;
 
 		Return(x);
 	}
@@ -613,12 +613,11 @@
 
 		EXPECT_EQ(result, 1000402222);
 	}
-
 }
 
 TEST(ReactorUnitTests, MinMax)
 {
-	FunctionT<int(void*)> function;
+	FunctionT<int(void *)> function;
 	{
 		Pointer<Byte> out = function.Arg<0>();
 
@@ -702,7 +701,7 @@
 
 TEST(ReactorUnitTests, NotNeg)
 {
-	FunctionT<int(void*)> function;
+	FunctionT<int(void *)> function;
 	{
 		Pointer<Byte> out = function.Arg<0>();
 
@@ -780,13 +779,13 @@
 
 TEST(ReactorUnitTests, FPtoUI)
 {
-	FunctionT<int(void*)> function;
+	FunctionT<int(void *)> function;
 	{
 		Pointer<Byte> out = function.Arg<0>();
 
-		*Pointer<UInt>(out + 0)  = UInt(Float(0xF0000000u));
-		*Pointer<UInt>(out + 4)  = UInt(Float(0xC0000000u));
-		*Pointer<UInt>(out + 8)  = UInt(Float(0x00000001u));
+		*Pointer<UInt>(out + 0) = UInt(Float(0xF0000000u));
+		*Pointer<UInt>(out + 4) = UInt(Float(0xC0000000u));
+		*Pointer<UInt>(out + 8) = UInt(Float(0x00000001u));
 		*Pointer<UInt>(out + 12) = UInt(Float(0xF000F000u));
 
 		*Pointer<UInt4>(out + 16) = UInt4(Float4(0xF0000000u, 0x80000000u, 0x00000000u, 0xCCCC0000u));
@@ -818,7 +817,7 @@
 
 TEST(ReactorUnitTests, VectorCompare)
 {
-	FunctionT<int(void*)> function;
+	FunctionT<int(void *)> function;
 	{
 		Pointer<Byte> out = function.Arg<0>();
 
@@ -873,52 +872,52 @@
 
 TEST(ReactorUnitTests, SaturatedAddAndSubtract)
 {
-	FunctionT<int(void*)> function;
+	FunctionT<int(void *)> function;
 	{
 		Pointer<Byte> out = function.Arg<0>();
 
 		*Pointer<Byte8>(out + 8 * 0) =
-			AddSat(Byte8(1, 2, 3, 4, 5, 6, 7, 8),
-				    Byte8(7, 6, 5, 4, 3, 2, 1, 0));
+		    AddSat(Byte8(1, 2, 3, 4, 5, 6, 7, 8),
+		           Byte8(7, 6, 5, 4, 3, 2, 1, 0));
 		*Pointer<Byte8>(out + 8 * 1) =
-			AddSat(Byte8(0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE),
-				    Byte8(7, 6, 5, 4, 3, 2, 1, 0));
+		    AddSat(Byte8(0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE),
+		           Byte8(7, 6, 5, 4, 3, 2, 1, 0));
 		*Pointer<Byte8>(out + 8 * 2) =
-			SubSat(Byte8(1, 2, 3, 4, 5, 6, 7, 8),
-				    Byte8(7, 6, 5, 4, 3, 2, 1, 0));
+		    SubSat(Byte8(1, 2, 3, 4, 5, 6, 7, 8),
+		           Byte8(7, 6, 5, 4, 3, 2, 1, 0));
 
 		*Pointer<SByte8>(out + 8 * 3) =
-			AddSat(SByte8(1, 2, 3, 4, 5, 6, 7, 8),
-				    SByte8(7, 6, 5, 4, 3, 2, 1, 0));
+		    AddSat(SByte8(1, 2, 3, 4, 5, 6, 7, 8),
+		           SByte8(7, 6, 5, 4, 3, 2, 1, 0));
 		*Pointer<SByte8>(out + 8 * 4) =
-			AddSat(SByte8(0x7E, 0x7E, 0x7E, 0x7E, 0x7E, 0x7E, 0x7E, 0x7E),
-				    SByte8(7, 6, 5, 4, 3, 2, 1, 0));
+		    AddSat(SByte8(0x7E, 0x7E, 0x7E, 0x7E, 0x7E, 0x7E, 0x7E, 0x7E),
+		           SByte8(7, 6, 5, 4, 3, 2, 1, 0));
 		*Pointer<SByte8>(out + 8 * 5) =
-			AddSat(SByte8(0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88),
-				    SByte8(-7, -6, -5, -4, -3, -2, -1, -0));
+		    AddSat(SByte8(0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88),
+		           SByte8(-7, -6, -5, -4, -3, -2, -1, -0));
 		*Pointer<SByte8>(out + 8 * 6) =
-			SubSat(SByte8(0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88),
-				    SByte8(7, 6, 5, 4, 3, 2, 1, 0));
+		    SubSat(SByte8(0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88),
+		           SByte8(7, 6, 5, 4, 3, 2, 1, 0));
 
 		*Pointer<Short4>(out + 8 * 7) =
-			AddSat(Short4(1, 2, 3, 4), Short4(3, 2, 1, 0));
+		    AddSat(Short4(1, 2, 3, 4), Short4(3, 2, 1, 0));
 		*Pointer<Short4>(out + 8 * 8) =
-			AddSat(Short4(0x7FFE, 0x7FFE, 0x7FFE, 0x7FFE),
-				    Short4(3, 2, 1, 0));
+		    AddSat(Short4(0x7FFE, 0x7FFE, 0x7FFE, 0x7FFE),
+		           Short4(3, 2, 1, 0));
 		*Pointer<Short4>(out + 8 * 9) =
-			AddSat(Short4(0x8001, 0x8002, 0x8003, 0x8004),
-				    Short4(-3, -2, -1, -0));
+		    AddSat(Short4(0x8001, 0x8002, 0x8003, 0x8004),
+		           Short4(-3, -2, -1, -0));
 		*Pointer<Short4>(out + 8 * 10) =
-			SubSat(Short4(0x8001, 0x8002, 0x8003, 0x8004),
-				    Short4(3, 2, 1, 0));
+		    SubSat(Short4(0x8001, 0x8002, 0x8003, 0x8004),
+		           Short4(3, 2, 1, 0));
 
 		*Pointer<UShort4>(out + 8 * 11) =
-			AddSat(UShort4(1, 2, 3, 4), UShort4(3, 2, 1, 0));
+		    AddSat(UShort4(1, 2, 3, 4), UShort4(3, 2, 1, 0));
 		*Pointer<UShort4>(out + 8 * 12) =
-			AddSat(UShort4(0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE),
-				    UShort4(3, 2, 1, 0));
+		    AddSat(UShort4(0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE),
+		           UShort4(3, 2, 1, 0));
 		*Pointer<UShort4>(out + 8 * 13) =
-			SubSat(UShort4(1, 2, 3, 4), UShort4(3, 2, 1, 0));
+		    SubSat(UShort4(1, 2, 3, 4), UShort4(3, 2, 1, 0));
 
 		Return(0);
 	}
@@ -979,7 +978,7 @@
 
 TEST(ReactorUnitTests, Unpack)
 {
-	FunctionT<int(void*, void*)> function;
+	FunctionT<int(void *, void *)> function;
 	{
 		Pointer<Byte> in = function.Arg<0>();
 		Pointer<Byte> out = function.Arg<1>();
@@ -988,7 +987,7 @@
 		Byte4 test_byte_b = *Pointer<Byte4>(in + 4 * 1);
 
 		*Pointer<Short4>(out + 8 * 0) =
-			Unpack(test_byte_a, test_byte_b);
+		    Unpack(test_byte_a, test_byte_b);
 
 		*Pointer<Short4>(out + 8 * 1) = Unpack(test_byte_a);
 
@@ -1019,25 +1018,25 @@
 
 TEST(ReactorUnitTests, Pack)
 {
-	FunctionT<int(void*)> function;
+	FunctionT<int(void *)> function;
 	{
 		Pointer<Byte> out = function.Arg<0>();
 
 		*Pointer<SByte8>(out + 8 * 0) =
-			PackSigned(Short4(-1, -2, 1, 2),
-					Short4(3, 4, -3, -4));
+		    PackSigned(Short4(-1, -2, 1, 2),
+		               Short4(3, 4, -3, -4));
 
 		*Pointer<Byte8>(out + 8 * 1) =
-			PackUnsigned(Short4(-1, -2, 1, 2),
-					    Short4(3, 4, -3, -4));
+		    PackUnsigned(Short4(-1, -2, 1, 2),
+		                 Short4(3, 4, -3, -4));
 
 		*Pointer<Short8>(out + 8 * 2) =
-			PackSigned(Int4(-1, -2, 1, 2),
-					Int4(3, 4, -3, -4));
+		    PackSigned(Int4(-1, -2, 1, 2),
+		               Int4(3, 4, -3, -4));
 
 		*Pointer<UShort8>(out + 8 * 4) =
-			PackUnsigned(Int4(-1, -2, 1, 2),
-					    Int4(3, 4, -3, -4));
+		    PackUnsigned(Int4(-1, -2, 1, 2),
+		                 Int4(3, 4, -3, -4));
 
 		Return(0);
 	}
@@ -1074,30 +1073,30 @@
 
 TEST(ReactorUnitTests, MulHigh)
 {
-	FunctionT<int(void*)> function;
+	FunctionT<int(void *)> function;
 	{
 		Pointer<Byte> out = function.Arg<0>();
 
 		*Pointer<Short4>(out + 16 * 0) =
-			MulHigh(Short4(0x01AA, 0x02DD, 0x03EE, 0xF422),
-				    Short4(0x01BB, 0x02CC, 0x03FF, 0xF411));
+		    MulHigh(Short4(0x01AA, 0x02DD, 0x03EE, 0xF422),
+		            Short4(0x01BB, 0x02CC, 0x03FF, 0xF411));
 		*Pointer<UShort4>(out + 16 * 1) =
-			MulHigh(UShort4(0x01AA, 0x02DD, 0x03EE, 0xF422),
-				    UShort4(0x01BB, 0x02CC, 0x03FF, 0xF411));
+		    MulHigh(UShort4(0x01AA, 0x02DD, 0x03EE, 0xF422),
+		            UShort4(0x01BB, 0x02CC, 0x03FF, 0xF411));
 
 		*Pointer<Int4>(out + 16 * 2) =
-			MulHigh(Int4(0x000001AA, 0x000002DD, 0xC8000000, 0xF8000000),
-				    Int4(0x000001BB, 0x84000000, 0x000003EE, 0xD7000000));
+		    MulHigh(Int4(0x000001AA, 0x000002DD, 0xC8000000, 0xF8000000),
+		            Int4(0x000001BB, 0x84000000, 0x000003EE, 0xD7000000));
 		*Pointer<UInt4>(out + 16 * 3) =
-			MulHigh(UInt4(0x000001AAu, 0x000002DDu, 0xC8000000u, 0xD8000000u),
-				    UInt4(0x000001BBu, 0x84000000u, 0x000003EEu, 0xD7000000u));
+		    MulHigh(UInt4(0x000001AAu, 0x000002DDu, 0xC8000000u, 0xD8000000u),
+		            UInt4(0x000001BBu, 0x84000000u, 0x000003EEu, 0xD7000000u));
 
 		*Pointer<Int4>(out + 16 * 4) =
-			MulHigh(Int4(0x7FFFFFFF, 0x7FFFFFFF, 0x80008000, 0xFFFFFFFF),
-				    Int4(0x7FFFFFFF, 0x80000000, 0x80008000, 0xFFFFFFFF));
+		    MulHigh(Int4(0x7FFFFFFF, 0x7FFFFFFF, 0x80008000, 0xFFFFFFFF),
+		            Int4(0x7FFFFFFF, 0x80000000, 0x80008000, 0xFFFFFFFF));
 		*Pointer<UInt4>(out + 16 * 5) =
-			MulHigh(UInt4(0x7FFFFFFFu, 0x7FFFFFFFu, 0x80008000u, 0xFFFFFFFFu),
-				    UInt4(0x7FFFFFFFu, 0x80000000u, 0x80008000u, 0xFFFFFFFFu));
+		    MulHigh(UInt4(0x7FFFFFFFu, 0x7FFFFFFFu, 0x80008000u, 0xFFFFFFFFu),
+		            UInt4(0x7FFFFFFFu, 0x80000000u, 0x80008000u, 0xFFFFFFFFu));
 
 		// (U)Short8 variants currently unimplemented.
 
@@ -1144,13 +1143,13 @@
 
 TEST(ReactorUnitTests, MulAdd)
 {
-	FunctionT<int(void*)> function;
+	FunctionT<int(void *)> function;
 	{
 		Pointer<Byte> out = function.Arg<0>();
 
 		*Pointer<Int2>(out + 8 * 0) =
-			MulAdd(Short4(0x1aa, 0x2dd, 0x3ee, 0xF422),
-				    Short4(0x1bb, 0x2cc, 0x3ff, 0xF411));
+		    MulAdd(Short4(0x1aa, 0x2dd, 0x3ee, 0xF422),
+		           Short4(0x1bb, 0x2cc, 0x3ff, 0xF411));
 
 		// (U)Short8 variant is mentioned but unimplemented
 		Return(0);
@@ -1173,7 +1172,7 @@
 
 TEST(ReactorUnitTests, PointersEqual)
 {
-	FunctionT<int(void*, void*)> function;
+	FunctionT<int(void *, void *)> function;
 	{
 		Pointer<Byte> ptrA = function.Arg<0>();
 		Pointer<Byte> ptrB = function.Arg<1>();
@@ -1188,9 +1187,9 @@
 	}
 
 	auto routine = function("one");
-	int* a = reinterpret_cast<int*>(uintptr_t(0x0000000000000000));
-	int* b = reinterpret_cast<int*>(uintptr_t(0x00000000F0000000));
-	int* c = reinterpret_cast<int*>(uintptr_t(0xF000000000000000));
+	int *a = reinterpret_cast<int *>(uintptr_t(0x0000000000000000));
+	int *b = reinterpret_cast<int *>(uintptr_t(0x00000000F0000000));
+	int *c = reinterpret_cast<int *>(uintptr_t(0xF000000000000000));
 	EXPECT_EQ(routine(&a, &a), 1);
 	EXPECT_EQ(routine(&b, &b), 1);
 	EXPECT_EQ(routine(&c, &c), 1);
@@ -1299,7 +1298,7 @@
 		float f = 0.0f;
 	};
 
-	FunctionT<int(void*)> function;
+	FunctionT<int(void *)> function;
 	{
 		Pointer<Byte> c = function.Arg<0>();
 		auto res = Call(Class::Callback, c, 10, 20.0f);
@@ -1361,7 +1360,7 @@
 		float f = 0.0f;
 	};
 
-	FunctionT<int(void*)> function;
+	FunctionT<int(void *)> function;
 	{
 		Pointer<Byte> c = function.Arg<0>();
 		auto res = Call(&Class::Callback, c, 10, 20.0f);
@@ -1381,14 +1380,14 @@
 {
 	struct Class
 	{
-		static void Callback(Class *c, const char* s)
+		static void Callback(Class *c, const char *s)
 		{
 			c->str = s;
 		}
 		std::string str;
 	};
 
-	FunctionT<void(Class *c, const char *s)> function;
+	FunctionT<void(Class * c, const char *s)> function;
 	{
 		Pointer<Byte> c = function.Arg<0>();
 		Pointer<Byte> s = function.Arg<1>();
@@ -1487,7 +1486,7 @@
 {
 	struct Class
 	{
-		static int Func(int a, float b, int* c, float* d, int e, float f, int* g, float* h)
+		static int Func(int a, float b, int *c, float *d, int e, float f, int *g, float *h)
 		{
 			return a + b + *c + *d + e + f + *g + *h;
 		}
@@ -1542,7 +1541,6 @@
 	}
 }
 
-
 TEST(ReactorUnitTests, CallExternalCallRoutine)
 {
 	// routine1 calls Class::Func, passing it a pointer to routine2, and Class::Func calls routine2
@@ -1559,15 +1557,15 @@
 
 	struct Class
 	{
-		static float Func(void* p, float a, int b)
+		static float Func(void *p, float a, int b)
 		{
-			auto funcToCall = reinterpret_cast<float(*)(float, int)>(p);
+			auto funcToCall = reinterpret_cast<float (*)(float, int)>(p);
 			return funcToCall(a, b);
 		}
 	};
 
 	auto routine1 = [] {
-		FunctionT<float(void*, float, int)> function;
+		FunctionT<float(void *, float, int)> function;
 		{
 			Pointer<Byte> funcToCall = function.Arg<0>();
 			Float a = function.Arg<1>();
@@ -1578,7 +1576,7 @@
 		return function("one");
 	}();
 
-	float result = routine1((void*)routine2.getEntry(), 12.f, 13);
+	float result = routine1((void *)routine2.getEntry(), 12.f, 13);
 	EXPECT_EQ(result, 25.f);
 }
 
@@ -1590,80 +1588,80 @@
 // It's necessary to inspect the registers in a debugger to actually verify.)
 TEST(ReactorUnitTests, PreserveXMMRegisters)
 {
-    FunctionT<void(void*, void*)> function;
-    {
-        Pointer<Byte> in = function.Arg<0>();
-        Pointer<Byte> out = function.Arg<1>();
+	FunctionT<void(void *, void *)> function;
+	{
+		Pointer<Byte> in = function.Arg<0>();
+		Pointer<Byte> out = function.Arg<1>();
 
-        Float4 a = *Pointer<Float4>(in + 16 * 0);
-        Float4 b = *Pointer<Float4>(in + 16 * 1);
-        Float4 c = *Pointer<Float4>(in + 16 * 2);
-        Float4 d = *Pointer<Float4>(in + 16 * 3);
-        Float4 e = *Pointer<Float4>(in + 16 * 4);
-        Float4 f = *Pointer<Float4>(in + 16 * 5);
-        Float4 g = *Pointer<Float4>(in + 16 * 6);
-        Float4 h = *Pointer<Float4>(in + 16 * 7);
-        Float4 i = *Pointer<Float4>(in + 16 * 8);
-        Float4 j = *Pointer<Float4>(in + 16 * 9);
-        Float4 k = *Pointer<Float4>(in + 16 * 10);
-        Float4 l = *Pointer<Float4>(in + 16 * 11);
-        Float4 m = *Pointer<Float4>(in + 16 * 12);
-        Float4 n = *Pointer<Float4>(in + 16 * 13);
-        Float4 o = *Pointer<Float4>(in + 16 * 14);
-        Float4 p = *Pointer<Float4>(in + 16 * 15);
+		Float4 a = *Pointer<Float4>(in + 16 * 0);
+		Float4 b = *Pointer<Float4>(in + 16 * 1);
+		Float4 c = *Pointer<Float4>(in + 16 * 2);
+		Float4 d = *Pointer<Float4>(in + 16 * 3);
+		Float4 e = *Pointer<Float4>(in + 16 * 4);
+		Float4 f = *Pointer<Float4>(in + 16 * 5);
+		Float4 g = *Pointer<Float4>(in + 16 * 6);
+		Float4 h = *Pointer<Float4>(in + 16 * 7);
+		Float4 i = *Pointer<Float4>(in + 16 * 8);
+		Float4 j = *Pointer<Float4>(in + 16 * 9);
+		Float4 k = *Pointer<Float4>(in + 16 * 10);
+		Float4 l = *Pointer<Float4>(in + 16 * 11);
+		Float4 m = *Pointer<Float4>(in + 16 * 12);
+		Float4 n = *Pointer<Float4>(in + 16 * 13);
+		Float4 o = *Pointer<Float4>(in + 16 * 14);
+		Float4 p = *Pointer<Float4>(in + 16 * 15);
 
-        Float4 ab = a + b;
-        Float4 cd = c + d;
-        Float4 ef = e + f;
-        Float4 gh = g + h;
-        Float4 ij = i + j;
-        Float4 kl = k + l;
-        Float4 mn = m + n;
-        Float4 op = o + p;
+		Float4 ab = a + b;
+		Float4 cd = c + d;
+		Float4 ef = e + f;
+		Float4 gh = g + h;
+		Float4 ij = i + j;
+		Float4 kl = k + l;
+		Float4 mn = m + n;
+		Float4 op = o + p;
 
-        Float4 abcd = ab + cd;
-        Float4 efgh = ef + gh;
-        Float4 ijkl = ij + kl;
-        Float4 mnop = mn + op;
+		Float4 abcd = ab + cd;
+		Float4 efgh = ef + gh;
+		Float4 ijkl = ij + kl;
+		Float4 mnop = mn + op;
 
-        Float4 abcdefgh = abcd + efgh;
-        Float4 ijklmnop = ijkl + mnop;
-        Float4 sum = abcdefgh + ijklmnop;
-        *Pointer<Float4>(out) = sum;
-        Return();
-    }
+		Float4 abcdefgh = abcd + efgh;
+		Float4 ijklmnop = ijkl + mnop;
+		Float4 sum = abcdefgh + ijklmnop;
+		*Pointer<Float4>(out) = sum;
+		Return();
+	}
 
-    auto routine = function("one");
-    assert(routine);
+	auto routine = function("one");
+	assert(routine);
 
-    float input[64] = { 1.0f,  0.0f,   0.0f, 0.0f,
-                        -1.0f,  1.0f,  -1.0f, 0.0f,
-                        1.0f,  2.0f,  -2.0f, 0.0f,
-                        -1.0f,  3.0f,  -3.0f, 0.0f,
-                        1.0f,  4.0f,  -4.0f, 0.0f,
-                        -1.0f,  5.0f,  -5.0f, 0.0f,
-                        1.0f,  6.0f,  -6.0f, 0.0f,
-                        -1.0f,  7.0f,  -7.0f, 0.0f,
-                        1.0f,  8.0f,  -8.0f, 0.0f,
-                        -1.0f,  9.0f,  -9.0f, 0.0f,
-                        1.0f, 10.0f, -10.0f, 0.0f,
-                        -1.0f, 11.0f, -11.0f, 0.0f,
-                        1.0f, 12.0f, -12.0f, 0.0f,
-                        -1.0f, 13.0f, -13.0f, 0.0f,
-                        1.0f, 14.0f, -14.0f, 0.0f,
-                        -1.0f, 15.0f, -15.0f, 0.0f };
+	float input[64] = { 1.0f, 0.0f, 0.0f, 0.0f,
+		                -1.0f, 1.0f, -1.0f, 0.0f,
+		                1.0f, 2.0f, -2.0f, 0.0f,
+		                -1.0f, 3.0f, -3.0f, 0.0f,
+		                1.0f, 4.0f, -4.0f, 0.0f,
+		                -1.0f, 5.0f, -5.0f, 0.0f,
+		                1.0f, 6.0f, -6.0f, 0.0f,
+		                -1.0f, 7.0f, -7.0f, 0.0f,
+		                1.0f, 8.0f, -8.0f, 0.0f,
+		                -1.0f, 9.0f, -9.0f, 0.0f,
+		                1.0f, 10.0f, -10.0f, 0.0f,
+		                -1.0f, 11.0f, -11.0f, 0.0f,
+		                1.0f, 12.0f, -12.0f, 0.0f,
+		                -1.0f, 13.0f, -13.0f, 0.0f,
+		                1.0f, 14.0f, -14.0f, 0.0f,
+		                -1.0f, 15.0f, -15.0f, 0.0f };
 
-    float result[4];
+	float result[4];
 
-    routine(input, result);
+	routine(input, result);
 
-    EXPECT_EQ(result[0], 0.0f);
-    EXPECT_EQ(result[1], 120.0f);
-    EXPECT_EQ(result[2], -120.0f);
-    EXPECT_EQ(result[3], 0.0f);
+	EXPECT_EQ(result[0], 0.0f);
+	EXPECT_EQ(result[1], 120.0f);
+	EXPECT_EQ(result[2], -120.0f);
+	EXPECT_EQ(result[3], 0.0f);
 }
 
-template <typename T>
+template<typename T>
 class CToReactorTCastTest : public ::testing::Test
 {
 public:
@@ -1671,17 +1669,15 @@
 	using ReactorType = typename std::tuple_element<1, T>::type;
 };
 
-using CToReactorTCastTestTypes = ::testing::Types
-	< // Subset of types that can be used as arguments.
-	//	std::pair<bool,         Bool>,    FIXME(capn): Not supported as argument type by Subzero.
-	//	std::pair<uint8_t,      Byte>,    FIXME(capn): Not supported as argument type by Subzero.
-	//	std::pair<int8_t,       SByte>,   FIXME(capn): Not supported as argument type by Subzero.
-	//	std::pair<int16_t,      Short>,   FIXME(capn): Not supported as argument type by Subzero.
-	//	std::pair<uint16_t,     UShort>,  FIXME(capn): Not supported as argument type by Subzero.
-		std::pair<int,          Int>,
-		std::pair<unsigned int, UInt>,
-		std::pair<float,        Float>
-	>;
+using CToReactorTCastTestTypes = ::testing::Types<  // Subset of types that can be used as arguments.
+                                                    //	std::pair<bool,         Bool>,    FIXME(capn): Not supported as argument type by Subzero.
+                                                    //	std::pair<uint8_t,      Byte>,    FIXME(capn): Not supported as argument type by Subzero.
+                                                    //	std::pair<int8_t,       SByte>,   FIXME(capn): Not supported as argument type by Subzero.
+                                                    //	std::pair<int16_t,      Short>,   FIXME(capn): Not supported as argument type by Subzero.
+                                                    //	std::pair<uint16_t,     UShort>,  FIXME(capn): Not supported as argument type by Subzero.
+    std::pair<int, Int>,
+    std::pair<unsigned int, UInt>,
+    std::pair<float, Float>>;
 
 TYPED_TEST_SUITE(CToReactorTCastTest, CToReactorTCastTestTypes);
 
@@ -1693,28 +1689,27 @@
 	std::shared_ptr<Routine> routine;
 
 	{
-		Function< Int(ReactorType) > function;
+		Function<Int(ReactorType)> function;
 		{
 			ReactorType a = function.template Arg<0>();
 			ReactorType b = CType{};
 			RValue<ReactorType> c = RValue<ReactorType>(CType{});
 			Bool same = (a == b) && (a == c);
-			Return(IfThenElse(same, Int(1), Int(0))); // TODO: Ability to use Bools as return values.
+			Return(IfThenElse(same, Int(1), Int(0)));  // TODO: Ability to use Bools as return values.
 		}
 
 		routine = function("one");
 
 		if(routine)
 		{
-			auto callable = (int(*)(CType))routine->getEntry();
+			auto callable = (int (*)(CType))routine->getEntry();
 			CType in = {};
 			EXPECT_EQ(callable(in), 1);
 		}
 	}
-
 }
 
-template <typename T>
+template<typename T>
 class GEPTest : public ::testing::Test
 {
 public:
@@ -1722,37 +1717,35 @@
 	using ReactorType = typename std::tuple_element<1, T>::type;
 };
 
-using GEPTestTypes = ::testing::Types
-	<
-		std::pair<bool,        Bool>,
-		std::pair<int8_t,      Byte>,
-		std::pair<int8_t,      SByte>,
-		std::pair<int8_t[4],   Byte4>,
-		std::pair<int8_t[4],   SByte4>,
-		std::pair<int8_t[8],   Byte8>,
-		std::pair<int8_t[8],   SByte8>,
-		std::pair<int8_t[16],  Byte16>,
-		std::pair<int8_t[16],  SByte16>,
-		std::pair<int16_t,     Short>,
-		std::pair<int16_t,     UShort>,
-		std::pair<int16_t[2],  Short2>,
-		std::pair<int16_t[2],  UShort2>,
-		std::pair<int16_t[4],  Short4>,
-		std::pair<int16_t[4],  UShort4>,
-		std::pair<int16_t[8],  Short8>,
-		std::pair<int16_t[8],  UShort8>,
-		std::pair<int,         Int>,
-		std::pair<int,         UInt>,
-		std::pair<int[2],      Int2>,
-		std::pair<int[2],      UInt2>,
-		std::pair<int[4],      Int4>,
-		std::pair<int[4],      UInt4>,
-		std::pair<int64_t,     Long>,
-		std::pair<int16_t,     Half>,
-		std::pair<float,       Float>,
-		std::pair<float[2],    Float2>,
-		std::pair<float[4],    Float4>
-	>;
+using GEPTestTypes = ::testing::Types<
+    std::pair<bool, Bool>,
+    std::pair<int8_t, Byte>,
+    std::pair<int8_t, SByte>,
+    std::pair<int8_t[4], Byte4>,
+    std::pair<int8_t[4], SByte4>,
+    std::pair<int8_t[8], Byte8>,
+    std::pair<int8_t[8], SByte8>,
+    std::pair<int8_t[16], Byte16>,
+    std::pair<int8_t[16], SByte16>,
+    std::pair<int16_t, Short>,
+    std::pair<int16_t, UShort>,
+    std::pair<int16_t[2], Short2>,
+    std::pair<int16_t[2], UShort2>,
+    std::pair<int16_t[4], Short4>,
+    std::pair<int16_t[4], UShort4>,
+    std::pair<int16_t[8], Short8>,
+    std::pair<int16_t[8], UShort8>,
+    std::pair<int, Int>,
+    std::pair<int, UInt>,
+    std::pair<int[2], Int2>,
+    std::pair<int[2], UInt2>,
+    std::pair<int[4], Int4>,
+    std::pair<int[4], UInt4>,
+    std::pair<int64_t, Long>,
+    std::pair<int16_t, Half>,
+    std::pair<float, Float>,
+    std::pair<float[2], Float2>,
+    std::pair<float[4], Float4>>;
 
 TYPED_TEST_SUITE(GEPTest, GEPTestTypes);
 
@@ -1764,7 +1757,7 @@
 	std::shared_ptr<Routine> routine;
 
 	{
-		Function< Pointer<ReactorType>(Pointer<ReactorType>, Int) > function;
+		Function<Pointer<ReactorType>(Pointer<ReactorType>, Int)> function;
 		{
 			Pointer<ReactorType> pointer = function.template Arg<0>();
 			Int index = function.template Arg<1>();
@@ -1775,10 +1768,11 @@
 
 		if(routine)
 		{
-			auto callable = (CType*(*)(CType*, unsigned int))routine->getEntry();
+			auto callable = (CType * (*)(CType *, unsigned int)) routine->getEntry();
 
-			union PtrInt {
-				CType* p;
+			union PtrInt
+			{
+				CType *p;
 				size_t i;
 			};
 
@@ -1800,7 +1794,6 @@
 			}
 		}
 	}
-
 }
 
 TEST(ReactorUnitTests, Coroutines_Fibonacci)
@@ -1817,7 +1810,8 @@
 		Yield(Int(1));
 		Int current = 1;
 		Int next = 1;
-		While(true) {
+		While(true)
+		{
 			Yield(next);
 			auto tmp = current + next;
 			current = next;
@@ -1827,10 +1821,35 @@
 
 	auto coroutine = function();
 
-	int32_t expected[] =
-	{
-		0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597,
-		2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418,
+	int32_t expected[] = {
+		0,
+		1,
+		1,
+		2,
+		3,
+		5,
+		8,
+		13,
+		21,
+		34,
+		55,
+		89,
+		144,
+		233,
+		377,
+		610,
+		987,
+		1597,
+		2584,
+		4181,
+		6765,
+		10946,
+		17711,
+		28657,
+		46368,
+		75025,
+		121393,
+		196418,
 		317811,
 	};
 
@@ -1852,7 +1871,7 @@
 		return;
 	}
 
-	Coroutine<uint8_t(uint8_t* data, int count)> function;
+	Coroutine<uint8_t(uint8_t * data, int count)> function;
 	{
 		Pointer<Byte> data = function.Arg<0>();
 		Int count = function.Arg<1>();
@@ -1863,29 +1882,31 @@
 		}
 	}
 
-	uint8_t data[] = {10, 20, 30};
+	uint8_t data[] = { 10, 20, 30 };
 	auto coroutine = function(&data[0], 3);
 
 	uint8_t out = 0;
 	EXPECT_EQ(coroutine->await(out), true);
-	EXPECT_EQ(out, 10); out = 0;
+	EXPECT_EQ(out, 10);
+	out = 0;
 	EXPECT_EQ(coroutine->await(out), true);
-	EXPECT_EQ(out, 20); out = 0;
+	EXPECT_EQ(out, 20);
+	out = 0;
 	EXPECT_EQ(coroutine->await(out), true);
-	EXPECT_EQ(out, 30); out = 99;
+	EXPECT_EQ(out, 30);
+	out = 99;
 	EXPECT_EQ(coroutine->await(out), false);
 	EXPECT_EQ(out, 99);
 	EXPECT_EQ(coroutine->await(out), false);
 	EXPECT_EQ(out, 99);
 }
 
-
-template <typename TestFuncType, typename RefFuncType, typename TestValueType>
+template<typename TestFuncType, typename RefFuncType, typename TestValueType>
 struct IntrinsicTestParams
 {
-	std::function<TestFuncType> testFunc;  // Function we're testing (Reactor)
-	std::function<RefFuncType> refFunc;    // Reference function to test against (C)
-	std::vector<TestValueType> testValues; // Values to input to functions
+	std::function<TestFuncType> testFunc;   // Function we're testing (Reactor)
+	std::function<RefFuncType> refFunc;     // Reference function to test against (C)
+	std::vector<TestValueType> testValues;  // Values to input to functions
 };
 
 using IntrinsicTestParams_Float = IntrinsicTestParams<RValue<Float>(RValue<Float>), float(float), float>;
@@ -1903,7 +1924,7 @@
 
 		auto routine = function("one");
 
-		for(auto&& v : GetParam().testValues)
+		for(auto &&v : GetParam().testValues)
 		{
 			SCOPED_TRACE(v);
 			EXPECT_FLOAT_EQ(routine(v), GetParam().refFunc(v));
@@ -1915,7 +1936,7 @@
 {
 	void test()
 	{
-		FunctionT<void(float4*)> function;
+		FunctionT<void(float4 *)> function;
 		{
 			Pointer<Float4> a = function.Arg<0>();
 			*a = GetParam().testFunc(*a);
@@ -1924,7 +1945,7 @@
 
 		auto routine = function("one");
 
-		for(auto&& v : GetParam().testValues)
+		for(auto &&v : GetParam().testValues)
 		{
 			SCOPED_TRACE(v);
 			float4_value result = invokeRoutine(routine, float4_value{ v });
@@ -1941,7 +1962,7 @@
 {
 	void test()
 	{
-		FunctionT<void(float4*, float4*)> function;
+		FunctionT<void(float4 *, float4 *)> function;
 		{
 			Pointer<Float4> a = function.Arg<0>();
 			Pointer<Float4> b = function.Arg<1>();
@@ -1951,7 +1972,7 @@
 
 		auto routine = function("one");
 
-		for(auto&& v : GetParam().testValues)
+		for(auto &&v : GetParam().testValues)
 		{
 			SCOPED_TRACE(v);
 			float4_value result = invokeRoutine(routine, float4_value{ v.first }, float4_value{ v.second });
@@ -1964,40 +1985,24 @@
 	}
 };
 
-INSTANTIATE_TEST_SUITE_P(IntrinsicTestParams_Float, IntrinsicTest_Float, testing::Values(
-	IntrinsicTestParams_Float{ [](Float v) { return rr::Exp2(v); }, exp2f, {0.f, 1.f, 12345.f} },
-	IntrinsicTestParams_Float{ [](Float v) { return rr::Log2(v); }, log2f, {0.f, 1.f, 12345.f} },
-	IntrinsicTestParams_Float{ [](Float v) { return rr::Sqrt(v); }, sqrtf, {0.f, 1.f, 12345.f} }
-));
+INSTANTIATE_TEST_SUITE_P(IntrinsicTestParams_Float, IntrinsicTest_Float, testing::Values(IntrinsicTestParams_Float{ [](Float v) { return rr::Exp2(v); }, exp2f, { 0.f, 1.f, 12345.f } }, IntrinsicTestParams_Float{ [](Float v) { return rr::Log2(v); }, log2f, { 0.f, 1.f, 12345.f } }, IntrinsicTestParams_Float{ [](Float v) { return rr::Sqrt(v); }, sqrtf, { 0.f, 1.f, 12345.f } }));
 
-INSTANTIATE_TEST_SUITE_P(IntrinsicTestParams_Float4, IntrinsicTest_Float4, testing::Values(
-	IntrinsicTestParams_Float4{ [](RValue<Float4> v) { return rr::Sin(v); },   sinf,   {0.f, 1.f, PI, 12345.f}  },
-	IntrinsicTestParams_Float4{ [](RValue<Float4> v) { return rr::Cos(v); },   cosf,   {0.f, 1.f, PI, 12345.f}  },
-	IntrinsicTestParams_Float4{ [](RValue<Float4> v) { return rr::Tan(v); },   tanf,   {0.f, 1.f, PI, 12345.f}  },
-	IntrinsicTestParams_Float4{ [](RValue<Float4> v) { return rr::Asin(v); },  asinf,  {0.f, 1.f, -1.f}  },
-	IntrinsicTestParams_Float4{ [](RValue<Float4> v) { return rr::Acos(v); },  acosf,  {0.f, 1.f, -1.f}  },
-	IntrinsicTestParams_Float4{ [](RValue<Float4> v) { return rr::Atan(v); },  atanf,  {0.f, 1.f, PI, 12345.f}  },
-	IntrinsicTestParams_Float4{ [](RValue<Float4> v) { return rr::Sinh(v); },  sinhf,  {0.f, 1.f, PI, 12345.f}  },
-	IntrinsicTestParams_Float4{ [](RValue<Float4> v) { return rr::Cosh(v); },  coshf,  {0.f, 1.f, PI, 12345.f}  },
-	IntrinsicTestParams_Float4{ [](RValue<Float4> v) { return rr::Tanh(v); },  tanhf,  {0.f, 1.f, PI, 12345.f}  },
-	IntrinsicTestParams_Float4{ [](RValue<Float4> v) { return rr::Asinh(v); }, asinhf, {0.f, 1.f, PI, 12345.f}  },
-	IntrinsicTestParams_Float4{ [](RValue<Float4> v) { return rr::Acosh(v); }, acoshf, {     1.f, PI, 12345.f}  },
-	IntrinsicTestParams_Float4{ [](RValue<Float4> v) { return rr::Atanh(v); }, atanhf, {0.f, 1.f, -1.f}  },
-	IntrinsicTestParams_Float4{ [](RValue<Float4> v) { return rr::Exp(v); },   expf,   {0.f, 1.f, PI, 12345.f}  },
-	IntrinsicTestParams_Float4{ [](RValue<Float4> v) { return rr::Log(v); },   logf,   {0.f, 1.f, PI, 12345.f}  },
-	IntrinsicTestParams_Float4{ [](RValue<Float4> v) { return rr::Exp2(v); },  exp2f,  {0.f, 1.f, PI, 12345.f}  },
-	IntrinsicTestParams_Float4{ [](RValue<Float4> v) { return rr::Log2(v); },  log2f,  {0.f, 1.f, PI, 12345.f}  },
-	IntrinsicTestParams_Float4{ [](RValue<Float4> v) { return rr::Sqrt(v); },  sqrtf,  {0.f, 1.f, PI, 12345.f}  }
-));
+INSTANTIATE_TEST_SUITE_P(IntrinsicTestParams_Float4, IntrinsicTest_Float4, testing::Values(IntrinsicTestParams_Float4{ [](RValue<Float4> v) { return rr::Sin(v); }, sinf, { 0.f, 1.f, PI, 12345.f } }, IntrinsicTestParams_Float4{ [](RValue<Float4> v) { return rr::Cos(v); }, cosf, { 0.f, 1.f, PI, 12345.f } }, IntrinsicTestParams_Float4{ [](RValue<Float4> v) { return rr::Tan(v); }, tanf, { 0.f, 1.f, PI, 12345.f } }, IntrinsicTestParams_Float4{ [](RValue<Float4> v) { return rr::Asin(v); }, asinf, { 0.f, 1.f, -1.f } }, IntrinsicTestParams_Float4{ [](RValue<Float4> v) { return rr::Acos(v); }, acosf, { 0.f, 1.f, -1.f } }, IntrinsicTestParams_Float4{ [](RValue<Float4> v) { return rr::Atan(v); }, atanf, { 0.f, 1.f, PI, 12345.f } }, IntrinsicTestParams_Float4{ [](RValue<Float4> v) { return rr::Sinh(v); }, sinhf, { 0.f, 1.f, PI, 12345.f } }, IntrinsicTestParams_Float4{ [](RValue<Float4> v) { return rr::Cosh(v); }, coshf, { 0.f, 1.f, PI, 12345.f } }, IntrinsicTestParams_Float4{ [](RValue<Float4> v) { return rr::Tanh(v); }, tanhf, { 0.f, 1.f, PI, 12345.f } }, IntrinsicTestParams_Float4{ [](RValue<Float4> v) { return rr::Asinh(v); }, asinhf, { 0.f, 1.f, PI, 12345.f } }, IntrinsicTestParams_Float4{ [](RValue<Float4> v) { return rr::Acosh(v); }, acoshf, { 1.f, PI, 12345.f } }, IntrinsicTestParams_Float4{ [](RValue<Float4> v) { return rr::Atanh(v); }, atanhf, { 0.f, 1.f, -1.f } }, IntrinsicTestParams_Float4{ [](RValue<Float4> v) { return rr::Exp(v); }, expf, { 0.f, 1.f, PI, 12345.f } }, IntrinsicTestParams_Float4{ [](RValue<Float4> v) { return rr::Log(v); }, logf, { 0.f, 1.f, PI, 12345.f } }, IntrinsicTestParams_Float4{ [](RValue<Float4> v) { return rr::Exp2(v); }, exp2f, { 0.f, 1.f, PI, 12345.f } }, IntrinsicTestParams_Float4{ [](RValue<Float4> v) { return rr::Log2(v); }, log2f, { 0.f, 1.f, PI, 12345.f } }, IntrinsicTestParams_Float4{ [](RValue<Float4> v) { return rr::Sqrt(v); }, sqrtf, { 0.f, 1.f, PI, 12345.f } }));
 
-INSTANTIATE_TEST_SUITE_P(IntrinsicTestParams_Float4_Float4, IntrinsicTest_Float4_Float4, testing::Values(
-	IntrinsicTestParams_Float4_Float4{ [](RValue<Float4> v1, RValue<Float4> v2) { return Atan2(v1, v2); }, atan2f, { {0.f, 0.f}, {0.f, -1.f}, {-1.f, 0.f}, {12345.f, 12345.f} } },
-	IntrinsicTestParams_Float4_Float4{ [](RValue<Float4> v1, RValue<Float4> v2) { return Pow(v1, v2); },   powf,   { {0.f, 0.f}, {0.f, -1.f}, {-1.f, 0.f}, {12345.f, 12345.f} } }
-));
+INSTANTIATE_TEST_SUITE_P(IntrinsicTestParams_Float4_Float4, IntrinsicTest_Float4_Float4, testing::Values(IntrinsicTestParams_Float4_Float4{ [](RValue<Float4> v1, RValue<Float4> v2) { return Atan2(v1, v2); }, atan2f, { { 0.f, 0.f }, { 0.f, -1.f }, { -1.f, 0.f }, { 12345.f, 12345.f } } }, IntrinsicTestParams_Float4_Float4{ [](RValue<Float4> v1, RValue<Float4> v2) { return Pow(v1, v2); }, powf, { { 0.f, 0.f }, { 0.f, -1.f }, { -1.f, 0.f }, { 12345.f, 12345.f } } }));
 
-TEST_P(IntrinsicTest_Float, Test) { test(); }
-TEST_P(IntrinsicTest_Float4, Test) { test(); }
-TEST_P(IntrinsicTest_Float4_Float4, Test) { test(); }
+TEST_P(IntrinsicTest_Float, Test)
+{
+	test();
+}
+TEST_P(IntrinsicTest_Float4, Test)
+{
+	test();
+}
+TEST_P(IntrinsicTest_Float4_Float4, Test)
+{
+	test();
+}
 
 TEST(ReactorUnitTests, Intrinsics_Ctlz)
 {
@@ -2012,8 +2017,8 @@
 		auto routine = function("one");
 		auto callable = (uint32_t(*)(uint32_t))routine->getEntry();
 
-
-		for(uint32_t i = 0; i < 31; ++i) {
+		for(uint32_t i = 0; i < 31; ++i)
+		{
 			uint32_t result = callable(1 << i);
 			EXPECT_EQ(result, 31 - i);
 		}
@@ -2033,11 +2038,12 @@
 			*out = rr::Ctlz(UInt4(x), false);
 		}
 		auto routine = function("one");
-		auto callable = (void(*)(uint32_t*, uint32_t))routine->getEntry();
+		auto callable = (void (*)(uint32_t *, uint32_t))routine->getEntry();
 
 		uint32_t x[4];
 
-		for(uint32_t i = 0; i < 31; ++i) {
+		for(uint32_t i = 0; i < 31; ++i)
+		{
 			callable(x, 1 << i);
 			EXPECT_EQ(x[0], 31 - i);
 			EXPECT_EQ(x[1], 31 - i);
@@ -2069,8 +2075,8 @@
 		auto routine = function("one");
 		auto callable = (uint32_t(*)(uint32_t))routine->getEntry();
 
-
-		for(uint32_t i = 0; i < 31; ++i) {
+		for(uint32_t i = 0; i < 31; ++i)
+		{
 			uint32_t result = callable(1 << i);
 			EXPECT_EQ(result, i);
 		}
@@ -2090,11 +2096,12 @@
 			*out = rr::Cttz(UInt4(x), false);
 		}
 		auto routine = function("one");
-		auto callable = (void(*)(uint32_t*, uint32_t))routine->getEntry();
+		auto callable = (void (*)(uint32_t *, uint32_t))routine->getEntry();
 
 		uint32_t x[4];
 
-		for(uint32_t i = 0; i < 31; ++i) {
+		for(uint32_t i = 0; i < 31; ++i)
+		{
 			callable(x, 1 << i);
 			EXPECT_EQ(x[0], i);
 			EXPECT_EQ(x[1], i);
@@ -2126,22 +2133,21 @@
 		Scatter(base, *val, *offsets, mask, alignment);
 	}
 
-	float buffer[16] = {0};
+	float buffer[16] = { 0 };
 
 	constexpr auto elemSize = sizeof(buffer[0]);
 
-	int offsets[] =
-	{
-		1 *elemSize,
-		6 *elemSize,
-		11 *elemSize,
-		13 *elemSize
+	int offsets[] = {
+		1 * elemSize,
+		6 * elemSize,
+		11 * elemSize,
+		13 * elemSize
 	};
 
-	float val[4] = {10, 60, 110, 130};
+	float val[4] = { 10, 60, 110, 130 };
 
 	auto routine = function("one");
-	auto entry = (void(*)(float*, float*, int*))routine->getEntry();
+	auto entry = (void (*)(float *, float *, int *))routine->getEntry();
 
 	entry(buffer, val, offsets);
 
@@ -2165,8 +2171,7 @@
 		*result = Gather(base, *offsets, mask, alignment, zeroMaskedLanes);
 	}
 
-	float buffer[] =
-	{
+	float buffer[] = {
 		0, 10, 20, 30,
 		40, 50, 60, 70,
 		80, 90, 100, 110,
@@ -2175,16 +2180,15 @@
 
 	constexpr auto elemSize = sizeof(buffer[0]);
 
-	int offsets[] =
-	{
-		1 *elemSize,
-		6 *elemSize,
-		11 *elemSize,
-		13 *elemSize
+	int offsets[] = {
+		1 * elemSize,
+		6 * elemSize,
+		11 * elemSize,
+		13 * elemSize
 	};
 
 	auto routine = function("one");
-	auto entry = (void(*)(float*, int*, float*))routine->getEntry();
+	auto entry = (void (*)(float *, int *, float *))routine->getEntry();
 
 	float result[4] = {};
 	entry(buffer, offsets, result);
@@ -2222,7 +2226,7 @@
 	}
 
 	auto routine = function("one");
-	auto entry = (void(*)(int*, int*))routine->getEntry();
+	auto entry = (void (*)(int *, int *))routine->getEntry();
 
 	int v[4] = { 42, 42, 42, 42 };
 	int result[4] = { 99, 99, 99, 99 };
@@ -2244,36 +2248,37 @@
 ////////////////////////////////
 
 // Assert CToReactorT resolves to expected types.
-static_assert(std::is_same<CToReactorT<void>,     Void>::value, "");
-static_assert(std::is_same<CToReactorT<bool>,     Bool>::value, "");
-static_assert(std::is_same<CToReactorT<uint8_t>,  Byte>::value, "");
-static_assert(std::is_same<CToReactorT<int8_t>,   SByte>::value, "");
-static_assert(std::is_same<CToReactorT<int16_t>,  Short>::value, "");
+static_assert(std::is_same<CToReactorT<void>, Void>::value, "");
+static_assert(std::is_same<CToReactorT<bool>, Bool>::value, "");
+static_assert(std::is_same<CToReactorT<uint8_t>, Byte>::value, "");
+static_assert(std::is_same<CToReactorT<int8_t>, SByte>::value, "");
+static_assert(std::is_same<CToReactorT<int16_t>, Short>::value, "");
 static_assert(std::is_same<CToReactorT<uint16_t>, UShort>::value, "");
-static_assert(std::is_same<CToReactorT<int32_t>,  Int>::value, "");
+static_assert(std::is_same<CToReactorT<int32_t>, Int>::value, "");
 static_assert(std::is_same<CToReactorT<uint64_t>, Long>::value, "");
 static_assert(std::is_same<CToReactorT<uint32_t>, UInt>::value, "");
-static_assert(std::is_same<CToReactorT<float>,    Float>::value, "");
+static_assert(std::is_same<CToReactorT<float>, Float>::value, "");
 
 // Assert CToReactorT for known pointer types resolves to expected types.
-static_assert(std::is_same<CToReactorT<void*>,     Pointer<Byte>>::value, "");
-static_assert(std::is_same<CToReactorT<bool*>,     Pointer<Bool>>::value, "");
-static_assert(std::is_same<CToReactorT<uint8_t*>,  Pointer<Byte>>::value, "");
-static_assert(std::is_same<CToReactorT<int8_t*>,   Pointer<SByte>>::value, "");
-static_assert(std::is_same<CToReactorT<int16_t*>,  Pointer<Short>>::value, "");
-static_assert(std::is_same<CToReactorT<uint16_t*>, Pointer<UShort>>::value, "");
-static_assert(std::is_same<CToReactorT<int32_t*>,  Pointer<Int>>::value, "");
-static_assert(std::is_same<CToReactorT<uint64_t*>, Pointer<Long>>::value, "");
-static_assert(std::is_same<CToReactorT<uint32_t*>, Pointer<UInt>>::value, "");
-static_assert(std::is_same<CToReactorT<float*>,    Pointer<Float>>::value, "");
-static_assert(std::is_same<CToReactorT<uint16_t**>, Pointer<Pointer<UShort>>>::value, "");
-static_assert(std::is_same<CToReactorT<uint16_t***>, Pointer<Pointer<Pointer<UShort>>>>::value, "");
+static_assert(std::is_same<CToReactorT<void *>, Pointer<Byte>>::value, "");
+static_assert(std::is_same<CToReactorT<bool *>, Pointer<Bool>>::value, "");
+static_assert(std::is_same<CToReactorT<uint8_t *>, Pointer<Byte>>::value, "");
+static_assert(std::is_same<CToReactorT<int8_t *>, Pointer<SByte>>::value, "");
+static_assert(std::is_same<CToReactorT<int16_t *>, Pointer<Short>>::value, "");
+static_assert(std::is_same<CToReactorT<uint16_t *>, Pointer<UShort>>::value, "");
+static_assert(std::is_same<CToReactorT<int32_t *>, Pointer<Int>>::value, "");
+static_assert(std::is_same<CToReactorT<uint64_t *>, Pointer<Long>>::value, "");
+static_assert(std::is_same<CToReactorT<uint32_t *>, Pointer<UInt>>::value, "");
+static_assert(std::is_same<CToReactorT<float *>, Pointer<Float>>::value, "");
+static_assert(std::is_same<CToReactorT<uint16_t **>, Pointer<Pointer<UShort>>>::value, "");
+static_assert(std::is_same<CToReactorT<uint16_t ***>, Pointer<Pointer<Pointer<UShort>>>>::value, "");
 
 // Assert CToReactorT for unknown pointer types resolves to Pointer<Byte>.
-struct S{};
-static_assert(std::is_same<CToReactorT<S*>, Pointer<Byte>>::value, "");
-static_assert(std::is_same<CToReactorT<S**>, Pointer<Pointer<Byte>>>::value, "");
-static_assert(std::is_same<CToReactorT<S***>, Pointer<Pointer<Pointer<Byte>>>>::value, "");
+struct S
+{};
+static_assert(std::is_same<CToReactorT<S *>, Pointer<Byte>>::value, "");
+static_assert(std::is_same<CToReactorT<S **>, Pointer<Pointer<Byte>>>::value, "");
+static_assert(std::is_same<CToReactorT<S ***>, Pointer<Pointer<Pointer<Byte>>>>::value, "");
 
 // Assert IsRValue<> resolves true for RValue<> types.
 static_assert(IsRValue<RValue<Void>>::value, "");
diff --git a/src/Reactor/Routine.hpp b/src/Reactor/Routine.hpp
index f8083b1..1c0ae1f 100644
--- a/src/Reactor/Routine.hpp
+++ b/src/Reactor/Routine.hpp
@@ -38,12 +38,12 @@
 public:
 	RoutineT() = default;
 
-	explicit RoutineT(const std::shared_ptr<Routine>& routine)
-		: routine(routine)
+	explicit RoutineT(const std::shared_ptr<Routine> &routine)
+	    : routine(routine)
 	{
 		if(routine)
 		{
-			callable = reinterpret_cast<CallableType>(const_cast<void*>(routine->getEntry(0)));
+			callable = reinterpret_cast<CallableType>(const_cast<void *>(routine->getEntry(0)));
 		}
 	}
 
@@ -52,23 +52,23 @@
 		return callable != nullptr;
 	}
 
-	template <typename... Args>
-	Return operator()(Args&&... args) const
+	template<typename... Args>
+	Return operator()(Args &&... args) const
 	{
 		return callable(std::forward<Args>(args)...);
 	}
 
-	const void* getEntry() const
+	const void *getEntry() const
 	{
-		return reinterpret_cast<void*>(callable);
+		return reinterpret_cast<void *>(callable);
 	}
 
 private:
 	std::shared_ptr<Routine> routine;
-	using CallableType = Return(*)(Arguments...);
+	using CallableType = Return (*)(Arguments...);
 	CallableType callable = nullptr;
 };
 
 }  // namespace rr
 
-#endif   // rr_Routine_hpp
+#endif  // rr_Routine_hpp
diff --git a/src/Reactor/SubzeroReactor.cpp b/src/Reactor/SubzeroReactor.cpp
index 6201ab1..2f3e9ee 100644
--- a/src/Reactor/SubzeroReactor.cpp
+++ b/src/Reactor/SubzeroReactor.cpp
@@ -12,44 +12,46 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "Reactor.hpp"
 #include "Debug.hpp"
 #include "EmulatedReactor.hpp"
+#include "Reactor.hpp"
 
-#include "Optimizer.hpp"
 #include "ExecutableMemory.hpp"
+#include "Optimizer.hpp"
 
-#include "src/IceTypes.h"
 #include "src/IceCfg.h"
-#include "src/IceELFStreamer.h"
-#include "src/IceGlobalContext.h"
 #include "src/IceCfgNode.h"
 #include "src/IceELFObjectWriter.h"
+#include "src/IceELFStreamer.h"
+#include "src/IceGlobalContext.h"
 #include "src/IceGlobalInits.h"
+#include "src/IceTypes.h"
 
+#include "llvm/Support/Compiler.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/raw_os_ostream.h"
-#include "llvm/Support/Compiler.h"
 
 #if __has_feature(memory_sanitizer)
-#include <sanitizer/msan_interface.h>
+#	include <sanitizer/msan_interface.h>
 #endif
 
 #if defined(_WIN32)
-#ifndef WIN32_LEAN_AND_MEAN
-#define WIN32_LEAN_AND_MEAN
-#endif // !WIN32_LEAN_AND_MEAN
-#ifndef NOMINMAX
-#define NOMINMAX
-#endif // !NOMINMAX
-#include <Windows.h>
+#	ifndef WIN32_LEAN_AND_MEAN
+#		define WIN32_LEAN_AND_MEAN
+#	endif  // !WIN32_LEAN_AND_MEAN
+#	ifndef NOMINMAX
+#		define NOMINMAX
+#	endif  // !NOMINMAX
+#	include <Windows.h>
 #endif
 
-#include <mutex>
-#include <limits>
 #include <iostream>
+#include <limits>
+#include <mutex>
 
-namespace rr { class ELFMemoryStreamer; }
+namespace rr {
+class ELFMemoryStreamer;
+}
 
 namespace {
 
@@ -60,7 +62,7 @@
 	// This uses a static in a function to avoid the cost of a global static
 	// initializer. See http://neugierig.org/software/chromium/notes/2011/08/static-initializers.html
 	static rr::Config config = rr::Config::Edit()
-		.apply({});
+	                               .apply({});
 	return config;
 }
 
@@ -80,11 +82,11 @@
 namespace {
 
 #if !defined(__i386__) && defined(_M_IX86)
-	#define __i386__ 1
+#	define __i386__ 1
 #endif
 
-#if !defined(__x86_64__) && (defined(_M_AMD64) || defined (_M_X64))
-	#define __x86_64__ 1
+#if !defined(__x86_64__) && (defined(_M_AMD64) || defined(_M_X64))
+#	define __x86_64__ 1
 #endif
 
 static Ice::OptLevel toIce(rr::Optimization::Level level)
@@ -92,9 +94,9 @@
 	switch(level)
 	{
 		// Note that Opt_0 and Opt_1 are not implemented by Subzero
-		case rr::Optimization::Level::None:       return Ice::Opt_m1;
-		case rr::Optimization::Level::Less:       return Ice::Opt_m1;
-		case rr::Optimization::Level::Default:    return Ice::Opt_2;
+		case rr::Optimization::Level::None: return Ice::Opt_m1;
+		case rr::Optimization::Level::Less: return Ice::Opt_m1;
+		case rr::Optimization::Level::Default: return Ice::Opt_2;
 		case rr::Optimization::Level::Aggressive: return Ice::Opt_2;
 		default: UNREACHABLE("Unknown Optimization Level %d", int(level));
 	}
@@ -110,42 +112,44 @@
 private:
 	static void cpuid(int registers[4], int info)
 	{
-		#if defined(__i386__) || defined(__x86_64__)
-			#if defined(_WIN32)
-				__cpuid(registers, info);
-			#else
-				__asm volatile("cpuid": "=a" (registers[0]), "=b" (registers[1]), "=c" (registers[2]), "=d" (registers[3]): "a" (info));
-			#endif
-		#else
-			registers[0] = 0;
-			registers[1] = 0;
-			registers[2] = 0;
-			registers[3] = 0;
-		#endif
+#if defined(__i386__) || defined(__x86_64__)
+#	if defined(_WIN32)
+		__cpuid(registers, info);
+#	else
+		__asm volatile("cpuid"
+		               : "=a"(registers[0]), "=b"(registers[1]), "=c"(registers[2]), "=d"(registers[3])
+		               : "a"(info));
+#	endif
+#else
+		registers[0] = 0;
+		registers[1] = 0;
+		registers[2] = 0;
+		registers[3] = 0;
+#endif
 	}
 
 	static bool detectARM()
 	{
-		#if defined(__arm__) || defined(__aarch64__)
-			return true;
-		#elif defined(__i386__) || defined(__x86_64__)
-			return false;
-		#elif defined(__mips__)
-			return false;
-		#else
-			#error "Unknown architecture"
-		#endif
+#if defined(__arm__) || defined(__aarch64__)
+		return true;
+#elif defined(__i386__) || defined(__x86_64__)
+		return false;
+#elif defined(__mips__)
+		return false;
+#else
+#	error "Unknown architecture"
+#endif
 	}
 
 	static bool detectSSE4_1()
 	{
-		#if defined(__i386__) || defined(__x86_64__)
-			int registers[4];
-			cpuid(registers, 1);
-			return (registers[2] & 0x00080000) != 0;
-		#else
-			return false;
-		#endif
+#if defined(__i386__) || defined(__x86_64__)
+		int registers[4];
+		cpuid(registers, 1);
+		return (registers[2] & 0x00080000) != 0;
+#else
+		return false;
+#endif
 	}
 };
 
@@ -166,9 +170,8 @@
 
 namespace rr {
 
-const Capabilities Caps =
-{
-	false, // CoroutinesSupported
+const Capabilities Caps = {
+	false,  // CoroutinesSupported
 };
 
 enum EmulatedType
@@ -182,14 +185,17 @@
 	Type_v2i32 = Ice::IceType_v4i32 | EmulatedV2,
 	Type_v4i16 = Ice::IceType_v8i16 | EmulatedV4,
 	Type_v2i16 = Ice::IceType_v8i16 | EmulatedV2,
-	Type_v8i8 =  Ice::IceType_v16i8 | EmulatedV8,
-	Type_v4i8 =  Ice::IceType_v16i8 | EmulatedV4,
+	Type_v8i8 = Ice::IceType_v16i8 | EmulatedV8,
+	Type_v4i8 = Ice::IceType_v16i8 | EmulatedV4,
 	Type_v2f32 = Ice::IceType_v4f32 | EmulatedV2,
 };
 
-class Value : public Ice::Operand {};
-class SwitchCases : public Ice::InstSwitch {};
-class BasicBlock : public Ice::CfgNode {};
+class Value : public Ice::Operand
+{};
+class SwitchCases : public Ice::InstSwitch
+{};
+class BasicBlock : public Ice::CfgNode
+{};
 
 Ice::Type T(Type *t)
 {
@@ -199,22 +205,22 @@
 
 Type *T(Ice::Type t)
 {
-	return reinterpret_cast<Type*>(t);
+	return reinterpret_cast<Type *>(t);
 }
 
 Type *T(EmulatedType t)
 {
-	return reinterpret_cast<Type*>(t);
+	return reinterpret_cast<Type *>(t);
 }
 
 Value *V(Ice::Operand *v)
 {
-	return reinterpret_cast<Value*>(v);
+	return reinterpret_cast<Value *>(v);
 }
 
 BasicBlock *B(Ice::CfgNode *b)
 {
-	return reinterpret_cast<BasicBlock*>(b);
+	return reinterpret_cast<BasicBlock *>(b);
 }
 
 static size_t typeSize(Type *type)
@@ -223,25 +229,25 @@
 	{
 		switch(reinterpret_cast<std::intptr_t>(type))
 		{
-		case Type_v2i32: return 8;
-		case Type_v4i16: return 8;
-		case Type_v2i16: return 4;
-		case Type_v8i8:  return 8;
-		case Type_v4i8:  return 4;
-		case Type_v2f32: return 8;
-		default: ASSERT(false);
+			case Type_v2i32: return 8;
+			case Type_v4i16: return 8;
+			case Type_v2i16: return 4;
+			case Type_v8i8: return 8;
+			case Type_v4i8: return 4;
+			case Type_v2f32: return 8;
+			default: ASSERT(false);
 		}
 	}
 
 	return Ice::typeWidthInBytes(T(type));
 }
 
-using ElfHeader = std::conditional<sizeof(void*) == 8, Elf64_Ehdr, Elf32_Ehdr>::type;
-using SectionHeader = std::conditional<sizeof(void*) == 8, Elf64_Shdr, Elf32_Shdr>::type;
+using ElfHeader = std::conditional<sizeof(void *) == 8, Elf64_Ehdr, Elf32_Ehdr>::type;
+using SectionHeader = std::conditional<sizeof(void *) == 8, Elf64_Shdr, Elf32_Shdr>::type;
 
 inline const SectionHeader *sectionHeader(const ElfHeader *elfHeader)
 {
-	return reinterpret_cast<const SectionHeader*>((intptr_t)elfHeader + elfHeader->e_shoff);
+	return reinterpret_cast<const SectionHeader *>((intptr_t)elfHeader + elfHeader->e_shoff);
 }
 
 inline const SectionHeader *elfSection(const ElfHeader *elfHeader, int index)
@@ -270,13 +276,13 @@
 		}
 
 		intptr_t symbolAddress = (intptr_t)elfHeader + symbolTable->sh_offset;
-		Elf32_Sym &symbol = ((Elf32_Sym*)symbolAddress)[index];
+		Elf32_Sym &symbol = ((Elf32_Sym *)symbolAddress)[index];
 		uint16_t section = symbol.st_shndx;
 
 		if(section != SHN_UNDEF && section < SHN_LORESERVE)
 		{
 			const SectionHeader *target = elfSection(elfHeader, symbol.st_shndx);
-			symbolValue = reinterpret_cast<void*>((intptr_t)elfHeader + symbol.st_value + target->sh_offset);
+			symbolValue = reinterpret_cast<void *>((intptr_t)elfHeader + symbol.st_value + target->sh_offset);
 		}
 		else
 		{
@@ -285,49 +291,49 @@
 	}
 
 	intptr_t address = (intptr_t)elfHeader + target->sh_offset;
-	unaligned_ptr<int32_t> patchSite = (int32_t*)(address + relocation.r_offset);
+	unaligned_ptr<int32_t> patchSite = (int32_t *)(address + relocation.r_offset);
 
 	if(CPUID::ARM)
 	{
 		switch(relocation.getType())
 		{
-		case R_ARM_NONE:
-			// No relocation
-			break;
-		case R_ARM_MOVW_ABS_NC:
+			case R_ARM_NONE:
+				// No relocation
+				break;
+			case R_ARM_MOVW_ABS_NC:
 			{
-				uint32_t thumb = 0;   // Calls to Thumb code not supported.
+				uint32_t thumb = 0;  // Calls to Thumb code not supported.
 				uint32_t lo = (uint32_t)(intptr_t)symbolValue | thumb;
 				*patchSite = (*patchSite & 0xFFF0F000) | ((lo & 0xF000) << 4) | (lo & 0x0FFF);
 			}
 			break;
-		case R_ARM_MOVT_ABS:
+			case R_ARM_MOVT_ABS:
 			{
 				uint32_t hi = (uint32_t)(intptr_t)(symbolValue) >> 16;
 				*patchSite = (*patchSite & 0xFFF0F000) | ((hi & 0xF000) << 4) | (hi & 0x0FFF);
 			}
 			break;
-		default:
-			ASSERT(false && "Unsupported relocation type");
-			return nullptr;
+			default:
+				ASSERT(false && "Unsupported relocation type");
+				return nullptr;
 		}
 	}
 	else
 	{
 		switch(relocation.getType())
 		{
-		case R_386_NONE:
-			// No relocation
-			break;
-		case R_386_32:
-			*patchSite = (int32_t)((intptr_t)symbolValue + *patchSite);
-			break;
-		case R_386_PC32:
-			*patchSite = (int32_t)((intptr_t)symbolValue + *patchSite - (intptr_t)patchSite);
-			break;
-		default:
-			ASSERT(false && "Unsupported relocation type");
-			return nullptr;
+			case R_386_NONE:
+				// No relocation
+				break;
+			case R_386_32:
+				*patchSite = (int32_t)((intptr_t)symbolValue + *patchSite);
+				break;
+			case R_386_PC32:
+				*patchSite = (int32_t)((intptr_t)symbolValue + *patchSite - (intptr_t)patchSite);
+				break;
+			default:
+				ASSERT(false && "Unsupported relocation type");
+				return nullptr;
 		}
 	}
 
@@ -355,13 +361,13 @@
 		}
 
 		intptr_t symbolAddress = (intptr_t)elfHeader + symbolTable->sh_offset;
-		Elf64_Sym &symbol = ((Elf64_Sym*)symbolAddress)[index];
+		Elf64_Sym &symbol = ((Elf64_Sym *)symbolAddress)[index];
 		uint16_t section = symbol.st_shndx;
 
 		if(section != SHN_UNDEF && section < SHN_LORESERVE)
 		{
 			const SectionHeader *target = elfSection(elfHeader, symbol.st_shndx);
-			symbolValue = reinterpret_cast<void*>((intptr_t)elfHeader + symbol.st_value + target->sh_offset);
+			symbolValue = reinterpret_cast<void *>((intptr_t)elfHeader + symbol.st_value + target->sh_offset);
 		}
 		else
 		{
@@ -370,26 +376,26 @@
 	}
 
 	intptr_t address = (intptr_t)elfHeader + target->sh_offset;
-	unaligned_ptr<int32_t> patchSite32 = (int32_t*)(address + relocation.r_offset);
-	unaligned_ptr<int64_t> patchSite64 = (int64_t*)(address + relocation.r_offset);
+	unaligned_ptr<int32_t> patchSite32 = (int32_t *)(address + relocation.r_offset);
+	unaligned_ptr<int64_t> patchSite64 = (int64_t *)(address + relocation.r_offset);
 
 	switch(relocation.getType())
 	{
-	case R_X86_64_NONE:
-		// No relocation
-		break;
-	case R_X86_64_64:
-		*patchSite64 = (int64_t)((intptr_t)symbolValue + *patchSite64 + relocation.r_addend);
-		break;
-	case R_X86_64_PC32:
-		*patchSite32 = (int32_t)((intptr_t)symbolValue + *patchSite32 - (intptr_t)patchSite32 + relocation.r_addend);
-		break;
-	case R_X86_64_32S:
-		*patchSite32 = (int32_t)((intptr_t)symbolValue + *patchSite32 + relocation.r_addend);
-		break;
-	default:
-		ASSERT(false && "Unsupported relocation type");
-		return nullptr;
+		case R_X86_64_NONE:
+			// No relocation
+			break;
+		case R_X86_64_64:
+			*patchSite64 = (int64_t)((intptr_t)symbolValue + *patchSite64 + relocation.r_addend);
+			break;
+		case R_X86_64_PC32:
+			*patchSite32 = (int32_t)((intptr_t)symbolValue + *patchSite32 - (intptr_t)patchSite32 + relocation.r_addend);
+			break;
+		case R_X86_64_32S:
+			*patchSite32 = (int32_t)((intptr_t)symbolValue + *patchSite32 + relocation.r_addend);
+			break;
+		default:
+			ASSERT(false && "Unsupported relocation type");
+			return nullptr;
 	}
 
 	return symbolValue;
@@ -397,7 +403,7 @@
 
 void *loadImage(uint8_t *const elfImage, size_t &codeSize)
 {
-	ElfHeader *elfHeader = (ElfHeader*)elfImage;
+	ElfHeader *elfHeader = (ElfHeader *)elfImage;
 
 	if(!elfHeader->checkMagic())
 	{
@@ -405,22 +411,22 @@
 	}
 
 	// Expect ELF bitness to match platform
-	ASSERT(sizeof(void*) == 8 ? elfHeader->getFileClass() == ELFCLASS64 : elfHeader->getFileClass() == ELFCLASS32);
-	#if defined(__i386__)
-		ASSERT(sizeof(void*) == 4 && elfHeader->e_machine == EM_386);
-	#elif defined(__x86_64__)
-		ASSERT(sizeof(void*) == 8 && elfHeader->e_machine == EM_X86_64);
-	#elif defined(__arm__)
-		ASSERT(sizeof(void*) == 4 && elfHeader->e_machine == EM_ARM);
-	#elif defined(__aarch64__)
-		ASSERT(sizeof(void*) == 8 && elfHeader->e_machine == EM_AARCH64);
-	#elif defined(__mips__)
-		ASSERT(sizeof(void*) == 4 && elfHeader->e_machine == EM_MIPS);
-	#else
-		#error "Unsupported platform"
-	#endif
+	ASSERT(sizeof(void *) == 8 ? elfHeader->getFileClass() == ELFCLASS64 : elfHeader->getFileClass() == ELFCLASS32);
+#if defined(__i386__)
+	ASSERT(sizeof(void *) == 4 && elfHeader->e_machine == EM_386);
+#elif defined(__x86_64__)
+	ASSERT(sizeof(void *) == 8 && elfHeader->e_machine == EM_X86_64);
+#elif defined(__arm__)
+	ASSERT(sizeof(void *) == 4 && elfHeader->e_machine == EM_ARM);
+#elif defined(__aarch64__)
+	ASSERT(sizeof(void *) == 8 && elfHeader->e_machine == EM_AARCH64);
+#elif defined(__mips__)
+	ASSERT(sizeof(void *) == 4 && elfHeader->e_machine == EM_MIPS);
+#else
+#	error "Unsupported platform"
+#endif
 
-	SectionHeader *sectionHeader = (SectionHeader*)(elfImage + elfHeader->e_shoff);
+	SectionHeader *sectionHeader = (SectionHeader *)(elfImage + elfHeader->e_shoff);
 	void *entry = nullptr;
 
 	for(int i = 0; i < elfHeader->e_shnum; i++)
@@ -435,21 +441,21 @@
 		}
 		else if(sectionHeader[i].sh_type == SHT_REL)
 		{
-			ASSERT(sizeof(void*) == 4 && "UNIMPLEMENTED");   // Only expected/implemented for 32-bit code
+			ASSERT(sizeof(void *) == 4 && "UNIMPLEMENTED");  // Only expected/implemented for 32-bit code
 
 			for(Elf32_Word index = 0; index < sectionHeader[i].sh_size / sectionHeader[i].sh_entsize; index++)
 			{
-				const Elf32_Rel &relocation = ((const Elf32_Rel*)(elfImage + sectionHeader[i].sh_offset))[index];
+				const Elf32_Rel &relocation = ((const Elf32_Rel *)(elfImage + sectionHeader[i].sh_offset))[index];
 				relocateSymbol(elfHeader, relocation, sectionHeader[i]);
 			}
 		}
 		else if(sectionHeader[i].sh_type == SHT_RELA)
 		{
-			ASSERT(sizeof(void*) == 8 && "UNIMPLEMENTED");   // Only expected/implemented for 64-bit code
+			ASSERT(sizeof(void *) == 8 && "UNIMPLEMENTED");  // Only expected/implemented for 64-bit code
 
 			for(Elf32_Word index = 0; index < sectionHeader[i].sh_size / sectionHeader[i].sh_entsize; index++)
 			{
-				const Elf64_Rela &relocation = ((const Elf64_Rela*)(elfImage + sectionHeader[i].sh_offset))[index];
+				const Elf64_Rela &relocation = ((const Elf64_Rela *)(elfImage + sectionHeader[i].sh_offset))[index];
 				relocateSymbol(elfHeader, relocation, sectionHeader[i]);
 			}
 		}
@@ -462,15 +468,17 @@
 struct ExecutableAllocator
 {
 	ExecutableAllocator() {}
-	template<class U> ExecutableAllocator(const ExecutableAllocator<U> &other) {}
+	template<class U>
+	ExecutableAllocator(const ExecutableAllocator<U> &other)
+	{}
 
 	using value_type = T;
 	using size_type = std::size_t;
 
 	T *allocate(size_type n)
 	{
-		return (T*)allocateMemoryPages(
-			sizeof(T) * n, PERMISSION_READ | PERMISSION_WRITE, true);
+		return (T *)allocateMemoryPages(
+		    sizeof(T) * n, PERMISSION_READ | PERMISSION_WRITE, true);
 	}
 
 	void deallocate(T *p, size_type n)
@@ -485,7 +493,8 @@
 	ELFMemoryStreamer &operator=(const ELFMemoryStreamer &) = delete;
 
 public:
-	ELFMemoryStreamer() : Routine()
+	ELFMemoryStreamer()
+	    : Routine()
 	{
 		position = 0;
 		buffer.reserve(0x1000);
@@ -507,7 +516,8 @@
 			buffer[position] = Value;
 			position++;
 		}
-		else ASSERT(false && "UNIMPLEMENTED");
+		else
+			ASSERT(false && "UNIMPLEMENTED");
 	}
 
 	void writeBytes(llvm::StringRef Bytes) override
@@ -522,9 +532,9 @@
 
 	void seek(uint64_t Off) override { position = Off; }
 
-	const void* finalizeEntryBegin()
+	const void *finalizeEntryBegin()
 	{
-		position = std::numeric_limits<std::size_t>::max();   // Can't stream more data after this
+		position = std::numeric_limits<std::size_t>::max();  // Can't stream more data after this
 
 		size_t codeSize = 0;
 		const void *entry = loadImage(&buffer[0], codeSize);
@@ -533,12 +543,12 @@
 #if defined(_WIN32)
 		FlushInstructionCache(GetCurrentProcess(), NULL, 0);
 #else
-		__builtin___clear_cache((char*)entry, (char*)entry + codeSize);
+		__builtin___clear_cache((char *)entry, (char *)entry + codeSize);
 #endif
 		return entry;
 	}
 
-	void setEntry(int index, const void* func)
+	void setEntry(int index, const void *func)
 	{
 		ASSERT(func);
 		funcs[index] = func;
@@ -550,7 +560,7 @@
 		return funcs[index];
 	}
 
-	const void* addConstantData(const void* data, size_t size)
+	const void *addConstantData(const void *data, size_t size)
 	{
 		auto buf = std::unique_ptr<uint8_t[]>(new uint8_t[size]);
 		memcpy(buf.get(), data, size);
@@ -560,7 +570,7 @@
 	}
 
 private:
-	std::array<const void*, Nucleus::CoroutineEntryCount> funcs = {};
+	std::array<const void *, Nucleus::CoroutineEntryCount> funcs = {};
 	std::vector<uint8_t, ExecutableAllocator<uint8_t>> buffer;
 	std::size_t position;
 	std::vector<std::unique_ptr<uint8_t[]>> constantData;
@@ -568,21 +578,21 @@
 
 Nucleus::Nucleus()
 {
-	::codegenMutex.lock();   // Reactor is currently not thread safe
+	::codegenMutex.lock();  // Reactor is currently not thread safe
 
 	Ice::ClFlags &Flags = Ice::ClFlags::Flags;
 	Ice::ClFlags::getParsedClFlags(Flags);
 
-	#if defined(__arm__)
-		Flags.setTargetArch(Ice::Target_ARM32);
-		Flags.setTargetInstructionSet(Ice::ARM32InstructionSet_HWDivArm);
-	#elif defined(__mips__)
-		Flags.setTargetArch(Ice::Target_MIPS32);
-		Flags.setTargetInstructionSet(Ice::BaseInstructionSet);
-	#else   // x86
-		Flags.setTargetArch(sizeof(void*) == 8 ? Ice::Target_X8664 : Ice::Target_X8632);
-		Flags.setTargetInstructionSet(CPUID::SSE4_1 ? Ice::X86InstructionSet_SSE4_1 : Ice::X86InstructionSet_SSE2);
-	#endif
+#if defined(__arm__)
+	Flags.setTargetArch(Ice::Target_ARM32);
+	Flags.setTargetInstructionSet(Ice::ARM32InstructionSet_HWDivArm);
+#elif defined(__mips__)
+	Flags.setTargetArch(Ice::Target_MIPS32);
+	Flags.setTargetInstructionSet(Ice::BaseInstructionSet);
+#else  // x86
+	Flags.setTargetArch(sizeof(void *) == 8 ? Ice::Target_X8664 : Ice::Target_X8632);
+	Flags.setTargetInstructionSet(CPUID::SSE4_1 ? Ice::X86InstructionSet_SSE4_1 : Ice::X86InstructionSet_SSE2);
+#endif
 	Flags.setOutFileType(Ice::FT_Elf);
 	Flags.setOptLevel(toIce(getDefaultConfig().getOptimization().getLevel()));
 	Flags.setApplicationBinaryInterface(Ice::ABI_Platform);
@@ -598,7 +608,7 @@
 		Flags.setDecorateAsm(true);
 	}
 
-	if(false)   // Write out to a file
+	if(false)  // Write out to a file
 	{
 		std::error_code errorCode;
 		::out = new Ice::Fdstream("out.o", errorCode, llvm::sys::fs::F_None);
@@ -694,7 +704,7 @@
 	objectWriter->setUndefinedSyms(::context->getConstantExternSyms());
 	objectWriter->writeNonUserSections();
 
-	const void* entryBegin = ::routine->finalizeEntryBegin();
+	const void *entryBegin = ::routine->finalizeEntryBegin();
 	::routine->setEntry(Nucleus::CoroutineEntryBegin, entryBegin);
 
 	Routine *handoffRoutine = ::routine;
@@ -729,14 +739,14 @@
 
 void Nucleus::setInsertBlock(BasicBlock *basicBlock)
 {
-//	ASSERT(::basicBlock->getInsts().back().getTerminatorEdges().size() >= 0 && "Previous basic block must have a terminator");
+	//	ASSERT(::basicBlock->getInsts().back().getTerminatorEdges().size() >= 0 && "Previous basic block must have a terminator");
 
 	Variable::materializeAll();
 
 	::basicBlock = basicBlock;
 }
 
-void Nucleus::createFunction(Type *ReturnType, std::vector<Type*> &Params)
+void Nucleus::createFunction(Type *ReturnType, std::vector<Type *> &Params)
 {
 	uint32_t sequenceNumber = 0;
 	::function = Ice::Cfg::create(::context, sequenceNumber).release();
@@ -800,16 +810,16 @@
 {
 	switch(op)
 	{
-	case Ice::InstArithmetic::Add:
-	case Ice::InstArithmetic::Fadd:
-	case Ice::InstArithmetic::Mul:
-	case Ice::InstArithmetic::Fmul:
-	case Ice::InstArithmetic::And:
-	case Ice::InstArithmetic::Or:
-	case Ice::InstArithmetic::Xor:
-		return true;
-	default:
-		return false;
+		case Ice::InstArithmetic::Add:
+		case Ice::InstArithmetic::Fadd:
+		case Ice::InstArithmetic::Mul:
+		case Ice::InstArithmetic::Fmul:
+		case Ice::InstArithmetic::And:
+		case Ice::InstArithmetic::Or:
+		case Ice::InstArithmetic::Xor:
+			return true;
+		default:
+			return false;
 	}
 }
 
@@ -923,10 +933,8 @@
 
 Value *Nucleus::createFNeg(Value *v)
 {
-	double c[4] = {-0.0, -0.0, -0.0, -0.0};
-	Value *negativeZero = Ice::isVectorType(v->getType()) ?
-	                      createConstantVector(c, T(v->getType())) :
-	                      V(::context->getConstantFloat(-0.0f));
+	double c[4] = { -0.0, -0.0, -0.0, -0.0 };
+	Value *negativeZero = Ice::isVectorType(v->getType()) ? createConstantVector(c, T(v->getType())) : V(::context->getConstantFloat(-0.0f));
 
 	return createFSub(negativeZero, v);
 }
@@ -937,22 +945,22 @@
 	{
 		return createXor(v, V(::context->getConstantInt(v->getType(), -1)));
 	}
-	else   // Vector
+	else  // Vector
 	{
-		int64_t c[16] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
+		int64_t c[16] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 };
 		return createXor(v, createConstantVector(c, T(v->getType())));
 	}
 }
 
 Value *Nucleus::createLoad(Value *ptr, Type *type, bool isVolatile, unsigned int align, bool atomic, std::memory_order memoryOrder)
 {
-	ASSERT(!atomic);  // Unimplemented
+	ASSERT(!atomic);                                   // Unimplemented
 	ASSERT(memoryOrder == std::memory_order_relaxed);  // Unimplemented
 
 	int valueType = (int)reinterpret_cast<intptr_t>(type);
 	Ice::Variable *result = ::function->makeVariable(T(type));
 
-	if((valueType & EmulatedBits) && (align != 0))   // Narrow vector not stored on stack.
+	if((valueType & EmulatedBits) && (align != 0))  // Narrow vector not stored on stack.
 	{
 		if(emulateIntrinsics)
 		{
@@ -980,11 +988,12 @@
 				auto bitcast = Ice::InstCast::create(::function, Ice::InstCast::Bitcast, result, vector.loadValue());
 				::basicBlock->appendInst(bitcast);
 			}
-			else UNREACHABLE("typeSize(type): %d", int(typeSize(type)));
+			else
+				UNREACHABLE("typeSize(type): %d", int(typeSize(type)));
 		}
 		else
 		{
-			const Ice::Intrinsics::IntrinsicInfo intrinsic = {Ice::Intrinsics::LoadSubVector, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F};
+			const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::LoadSubVector, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
 			auto target = ::context->getConstantUndef(Ice::IceType_i32);
 			auto load = Ice::InstIntrinsicCall::create(::function, 2, result, target, intrinsic);
 			load->addArg(ptr);
@@ -1003,23 +1012,23 @@
 
 Value *Nucleus::createStore(Value *value, Value *ptr, Type *type, bool isVolatile, unsigned int align, bool atomic, std::memory_order memoryOrder)
 {
-	ASSERT(!atomic);  // Unimplemented
+	ASSERT(!atomic);                                   // Unimplemented
 	ASSERT(memoryOrder == std::memory_order_relaxed);  // Unimplemented
 
-	#if __has_feature(memory_sanitizer)
-		// Mark all (non-stack) memory writes as initialized by calling __msan_unpoison
-		if(align != 0)
-		{
-			auto call = Ice::InstCall::create(::function, 2, nullptr, ::context->getConstantInt64(reinterpret_cast<intptr_t>(__msan_unpoison)), false);
-			call->addArg(ptr);
-			call->addArg(::context->getConstantInt64(typeSize(type)));
-			::basicBlock->appendInst(call);
-		}
-	#endif
+#if __has_feature(memory_sanitizer)
+	    // Mark all (non-stack) memory writes as initialized by calling __msan_unpoison
+	if(align != 0)
+	{
+		auto call = Ice::InstCall::create(::function, 2, nullptr, ::context->getConstantInt64(reinterpret_cast<intptr_t>(__msan_unpoison)), false);
+		call->addArg(ptr);
+		call->addArg(::context->getConstantInt64(typeSize(type)));
+		::basicBlock->appendInst(call);
+	}
+#endif
 
 	int valueType = (int)reinterpret_cast<intptr_t>(type);
 
-	if((valueType & EmulatedBits) && (align != 0))   // Narrow vector not stored on stack.
+	if((valueType & EmulatedBits) && (align != 0))  // Narrow vector not stored on stack.
 	{
 		if(emulateIntrinsics)
 		{
@@ -1049,11 +1058,12 @@
 				Int y = Extract(v, 1);
 				*Pointer<Int>(pointer + 4) = y;
 			}
-			else UNREACHABLE("typeSize(type): %d", int(typeSize(type)));
+			else
+				UNREACHABLE("typeSize(type): %d", int(typeSize(type)));
 		}
 		else
 		{
-			const Ice::Intrinsics::IntrinsicInfo intrinsic = {Ice::Intrinsics::StoreSubVector, Ice::Intrinsics::SideEffects_T, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_T};
+			const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::StoreSubVector, Ice::Intrinsics::SideEffects_T, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_T };
 			auto target = ::context->getConstantUndef(Ice::IceType_i32);
 			auto store = Ice::InstIntrinsicCall::create(::function, 3, nullptr, target, intrinsic);
 			store->addArg(value);
@@ -1094,7 +1104,7 @@
 		index = createMul(index, createConstantInt((int)typeSize(type)));
 	}
 
-	if(sizeof(void*) == 8)
+	if(sizeof(void *) == 8)
 	{
 		if(unsignedIndex)
 		{
@@ -1453,7 +1463,7 @@
 	auto switchInst = Ice::InstSwitch::create(::function, numCases, control, defaultBranch);
 	::basicBlock->appendInst(switchInst);
 
-	return reinterpret_cast<SwitchCases*>(switchInst);
+	return reinterpret_cast<SwitchCases *>(switchInst);
 }
 
 void Nucleus::addSwitchCase(SwitchCases *switchCases, int label, BasicBlock *branch)
@@ -1469,7 +1479,7 @@
 
 Type *Nucleus::getPointerType(Type *ElementType)
 {
-	if(sizeof(void*) == 8)
+	if(sizeof(void *) == 8)
 	{
 		return T(Ice::IceType_i64);
 	}
@@ -1484,7 +1494,7 @@
 	if(Ice::isVectorType(T(Ty)))
 	{
 		ASSERT(Ice::typeNumElements(T(Ty)) <= 16);
-		int64_t c[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+		int64_t c[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 		return createConstantVector(c, Ty);
 	}
 	else
@@ -1540,7 +1550,7 @@
 
 Value *Nucleus::createNullPointer(Type *Ty)
 {
-	return createNullValue(T(sizeof(void*) == 8 ? Ice::IceType_i64 : Ice::IceType_i32));
+	return createNullValue(T(sizeof(void *) == 8 ? Ice::IceType_i64 : Ice::IceType_i32));
 }
 
 Value *Nucleus::createConstantVector(const int64_t *constants, Type *type)
@@ -1551,79 +1561,79 @@
 	auto globalPool = ::function->getGlobalPool();
 
 	const int64_t *i = constants;
-	const double *f = reinterpret_cast<const double*>(constants);
+	const double *f = reinterpret_cast<const double *>(constants);
 	Ice::VariableDeclaration::DataInitializer *dataInitializer = nullptr;
 
 	switch((int)reinterpret_cast<intptr_t>(type))
 	{
-	case Ice::IceType_v4i32:
-	case Ice::IceType_v4i1:
+		case Ice::IceType_v4i32:
+		case Ice::IceType_v4i1:
 		{
-			const int initializer[4] = {(int)i[0], (int)i[1], (int)i[2], (int)i[3]};
+			const int initializer[4] = { (int)i[0], (int)i[1], (int)i[2], (int)i[3] };
 			static_assert(sizeof(initializer) == vectorSize, "!");
-			dataInitializer = Ice::VariableDeclaration::DataInitializer::create(globalPool, (const char*)initializer, vectorSize);
+			dataInitializer = Ice::VariableDeclaration::DataInitializer::create(globalPool, (const char *)initializer, vectorSize);
 		}
 		break;
-	case Ice::IceType_v4f32:
+		case Ice::IceType_v4f32:
 		{
-			const float initializer[4] = {(float)f[0], (float)f[1], (float)f[2], (float)f[3]};
+			const float initializer[4] = { (float)f[0], (float)f[1], (float)f[2], (float)f[3] };
 			static_assert(sizeof(initializer) == vectorSize, "!");
-			dataInitializer = Ice::VariableDeclaration::DataInitializer::create(globalPool, (const char*)initializer, vectorSize);
+			dataInitializer = Ice::VariableDeclaration::DataInitializer::create(globalPool, (const char *)initializer, vectorSize);
 		}
 		break;
-	case Ice::IceType_v8i16:
-	case Ice::IceType_v8i1:
+		case Ice::IceType_v8i16:
+		case Ice::IceType_v8i1:
 		{
-			const short initializer[8] = {(short)i[0], (short)i[1], (short)i[2], (short)i[3], (short)i[4], (short)i[5], (short)i[6], (short)i[7]};
+			const short initializer[8] = { (short)i[0], (short)i[1], (short)i[2], (short)i[3], (short)i[4], (short)i[5], (short)i[6], (short)i[7] };
 			static_assert(sizeof(initializer) == vectorSize, "!");
-			dataInitializer = Ice::VariableDeclaration::DataInitializer::create(globalPool, (const char*)initializer, vectorSize);
+			dataInitializer = Ice::VariableDeclaration::DataInitializer::create(globalPool, (const char *)initializer, vectorSize);
 		}
 		break;
-	case Ice::IceType_v16i8:
-	case Ice::IceType_v16i1:
+		case Ice::IceType_v16i8:
+		case Ice::IceType_v16i1:
 		{
-			const char initializer[16] = {(char)i[0], (char)i[1], (char)i[2], (char)i[3], (char)i[4], (char)i[5], (char)i[6], (char)i[7], (char)i[8], (char)i[9], (char)i[10], (char)i[11], (char)i[12], (char)i[13], (char)i[14], (char)i[15]};
+			const char initializer[16] = { (char)i[0], (char)i[1], (char)i[2], (char)i[3], (char)i[4], (char)i[5], (char)i[6], (char)i[7], (char)i[8], (char)i[9], (char)i[10], (char)i[11], (char)i[12], (char)i[13], (char)i[14], (char)i[15] };
 			static_assert(sizeof(initializer) == vectorSize, "!");
-			dataInitializer = Ice::VariableDeclaration::DataInitializer::create(globalPool, (const char*)initializer, vectorSize);
+			dataInitializer = Ice::VariableDeclaration::DataInitializer::create(globalPool, (const char *)initializer, vectorSize);
 		}
 		break;
-	case Type_v2i32:
+		case Type_v2i32:
 		{
-			const int initializer[4] = {(int)i[0], (int)i[1], (int)i[0], (int)i[1]};
+			const int initializer[4] = { (int)i[0], (int)i[1], (int)i[0], (int)i[1] };
 			static_assert(sizeof(initializer) == vectorSize, "!");
-			dataInitializer = Ice::VariableDeclaration::DataInitializer::create(globalPool, (const char*)initializer, vectorSize);
+			dataInitializer = Ice::VariableDeclaration::DataInitializer::create(globalPool, (const char *)initializer, vectorSize);
 		}
 		break;
-	case Type_v2f32:
+		case Type_v2f32:
 		{
-			const float initializer[4] = {(float)f[0], (float)f[1], (float)f[0], (float)f[1]};
+			const float initializer[4] = { (float)f[0], (float)f[1], (float)f[0], (float)f[1] };
 			static_assert(sizeof(initializer) == vectorSize, "!");
-			dataInitializer = Ice::VariableDeclaration::DataInitializer::create(globalPool, (const char*)initializer, vectorSize);
+			dataInitializer = Ice::VariableDeclaration::DataInitializer::create(globalPool, (const char *)initializer, vectorSize);
 		}
 		break;
-	case Type_v4i16:
+		case Type_v4i16:
 		{
-			const short initializer[8] = {(short)i[0], (short)i[1], (short)i[2], (short)i[3], (short)i[0], (short)i[1], (short)i[2], (short)i[3]};
+			const short initializer[8] = { (short)i[0], (short)i[1], (short)i[2], (short)i[3], (short)i[0], (short)i[1], (short)i[2], (short)i[3] };
 			static_assert(sizeof(initializer) == vectorSize, "!");
-			dataInitializer = Ice::VariableDeclaration::DataInitializer::create(globalPool, (const char*)initializer, vectorSize);
+			dataInitializer = Ice::VariableDeclaration::DataInitializer::create(globalPool, (const char *)initializer, vectorSize);
 		}
 		break;
-	case Type_v8i8:
+		case Type_v8i8:
 		{
-			const char initializer[16] = {(char)i[0], (char)i[1], (char)i[2], (char)i[3], (char)i[4], (char)i[5], (char)i[6], (char)i[7], (char)i[0], (char)i[1], (char)i[2], (char)i[3], (char)i[4], (char)i[5], (char)i[6], (char)i[7]};
+			const char initializer[16] = { (char)i[0], (char)i[1], (char)i[2], (char)i[3], (char)i[4], (char)i[5], (char)i[6], (char)i[7], (char)i[0], (char)i[1], (char)i[2], (char)i[3], (char)i[4], (char)i[5], (char)i[6], (char)i[7] };
 			static_assert(sizeof(initializer) == vectorSize, "!");
-			dataInitializer = Ice::VariableDeclaration::DataInitializer::create(globalPool, (const char*)initializer, vectorSize);
+			dataInitializer = Ice::VariableDeclaration::DataInitializer::create(globalPool, (const char *)initializer, vectorSize);
 		}
 		break;
-	case Type_v4i8:
+		case Type_v4i8:
 		{
-			const char initializer[16] = {(char)i[0], (char)i[1], (char)i[2], (char)i[3], (char)i[0], (char)i[1], (char)i[2], (char)i[3], (char)i[0], (char)i[1], (char)i[2], (char)i[3], (char)i[0], (char)i[1], (char)i[2], (char)i[3]};
+			const char initializer[16] = { (char)i[0], (char)i[1], (char)i[2], (char)i[3], (char)i[0], (char)i[1], (char)i[2], (char)i[3], (char)i[0], (char)i[1], (char)i[2], (char)i[3], (char)i[0], (char)i[1], (char)i[2], (char)i[3] };
 			static_assert(sizeof(initializer) == vectorSize, "!");
-			dataInitializer = Ice::VariableDeclaration::DataInitializer::create(globalPool, (const char*)initializer, vectorSize);
+			dataInitializer = Ice::VariableDeclaration::DataInitializer::create(globalPool, (const char *)initializer, vectorSize);
 		}
 		break;
-	default:
-		UNREACHABLE("Unknown constant vector type: %d", (int)reinterpret_cast<intptr_t>(type));
+		default:
+			UNREACHABLE("Unknown constant vector type: %d", (int)reinterpret_cast<intptr_t>(type));
 	}
 
 	auto name = Ice::GlobalString::createWithoutString(::context);
@@ -1647,7 +1657,7 @@
 
 Value *Nucleus::createConstantVector(const double *constants, Type *type)
 {
-	return createConstantVector((const int64_t*)constants, type);
+	return createConstantVector((const int64_t *)constants, type);
 }
 
 Type *Void::getType()
@@ -1690,24 +1700,23 @@
 	return T(Type_v4i8);
 }
 
-namespace
+namespace {
+RValue<Byte> SaturateUnsigned(RValue<Short> x)
 {
-	RValue<Byte> SaturateUnsigned(RValue<Short> x)
-	{
-		return Byte(IfThenElse(Int(x) > 0xFF, Int(0xFF), IfThenElse(Int(x) < 0, Int(0), Int(x))));
-	}
-
-	RValue<Byte> Extract(RValue<Byte8> val, int i)
-	{
-		return RValue<Byte>(Nucleus::createExtractElement(val.value, Byte::getType(), i));
-	}
-
-	RValue<Byte8> Insert(RValue<Byte8> val, RValue<Byte> element, int i)
-	{
-		return RValue<Byte8>(Nucleus::createInsertElement(val.value, element.value, i));
-	}
+	return Byte(IfThenElse(Int(x) > 0xFF, Int(0xFF), IfThenElse(Int(x) < 0, Int(0), Int(x))));
 }
 
+RValue<Byte> Extract(RValue<Byte8> val, int i)
+{
+	return RValue<Byte>(Nucleus::createExtractElement(val.value, Byte::getType(), i));
+}
+
+RValue<Byte8> Insert(RValue<Byte8> val, RValue<Byte> element, int i)
+{
+	return RValue<Byte8>(Nucleus::createInsertElement(val.value, element.value, i));
+}
+}  // namespace
+
 RValue<Byte8> AddSat(RValue<Byte8> x, RValue<Byte8> y)
 {
 	if(emulateIntrinsics)
@@ -1727,7 +1736,7 @@
 	else
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_v16i8);
-		const Ice::Intrinsics::IntrinsicInfo intrinsic = {Ice::Intrinsics::AddSaturateUnsigned, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F};
+		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::AddSaturateUnsigned, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
 		auto target = ::context->getConstantUndef(Ice::IceType_i32);
 		auto paddusb = Ice::InstIntrinsicCall::create(::function, 2, result, target, intrinsic);
 		paddusb->addArg(x.value);
@@ -1757,7 +1766,7 @@
 	else
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_v16i8);
-		const Ice::Intrinsics::IntrinsicInfo intrinsic = {Ice::Intrinsics::SubtractSaturateUnsigned, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F};
+		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::SubtractSaturateUnsigned, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
 		auto target = ::context->getConstantUndef(Ice::IceType_i32);
 		auto psubusw = Ice::InstIntrinsicCall::create(::function, 2, result, target, intrinsic);
 		psubusw->addArg(x.value);
@@ -1796,15 +1805,15 @@
 	}
 	else
 	{
-		#if defined(__i386__) || defined(__x86_64__)
-			// SSE2 doesn't support byte vector shifts, so shift as shorts and recombine.
-			RValue<Short4> hi = (As<Short4>(lhs) >> rhs) & Short4(0xFF00u);
-			RValue<Short4> lo = As<Short4>(As<UShort4>((As<Short4>(lhs) << 8) >> rhs) >> 8);
+#if defined(__i386__) || defined(__x86_64__)
+		// SSE2 doesn't support byte vector shifts, so shift as shorts and recombine.
+		RValue<Short4> hi = (As<Short4>(lhs) >> rhs) & Short4(0xFF00u);
+		RValue<Short4> lo = As<Short4>(As<UShort4>((As<Short4>(lhs) << 8) >> rhs) >> 8);
 
-			return As<SByte8>(hi | lo);
-		#else
-			return RValue<SByte8>(Nucleus::createAShr(lhs.value, V(::context->getConstantInt32(rhs))));
-		#endif
+		return As<SByte8>(hi | lo);
+#else
+		return RValue<SByte8>(Nucleus::createAShr(lhs.value, V(::context->getConstantInt32(rhs))));
+#endif
 	}
 }
 
@@ -1818,7 +1827,7 @@
 	else
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_i32);
-		const Ice::Intrinsics::IntrinsicInfo intrinsic = {Ice::Intrinsics::SignMask, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F};
+		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::SignMask, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
 		auto target = ::context->getConstantUndef(Ice::IceType_i32);
 		auto movmsk = Ice::InstIntrinsicCall::create(::function, 1, result, target, intrinsic);
 		movmsk->addArg(x.value);
@@ -1877,7 +1886,7 @@
 	else
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_v16i8);
-		const Ice::Intrinsics::IntrinsicInfo intrinsic = {Ice::Intrinsics::AddSaturateSigned, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F};
+		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::AddSaturateSigned, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
 		auto target = ::context->getConstantUndef(Ice::IceType_i32);
 		auto paddsb = Ice::InstIntrinsicCall::create(::function, 2, result, target, intrinsic);
 		paddsb->addArg(x.value);
@@ -1907,7 +1916,7 @@
 	else
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_v16i8);
-		const Ice::Intrinsics::IntrinsicInfo intrinsic = {Ice::Intrinsics::SubtractSaturateSigned, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F};
+		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::SubtractSaturateSigned, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
 		auto target = ::context->getConstantUndef(Ice::IceType_i32);
 		auto psubsb = Ice::InstIntrinsicCall::create(::function, 2, result, target, intrinsic);
 		psubsb->addArg(x.value);
@@ -1928,7 +1937,7 @@
 	else
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_i32);
-		const Ice::Intrinsics::IntrinsicInfo intrinsic = {Ice::Intrinsics::SignMask, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F};
+		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::SignMask, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
 		auto target = ::context->getConstantUndef(Ice::IceType_i32);
 		auto movmsk = Ice::InstIntrinsicCall::create(::function, 1, result, target, intrinsic);
 		movmsk->addArg(x.value);
@@ -1975,7 +1984,7 @@
 
 Short4::Short4(RValue<Int4> cast)
 {
-	int select[8] = {0, 2, 4, 6, 0, 2, 4, 6};
+	int select[8] = { 0, 2, 4, 6, 0, 2, 4, 6 };
 	Value *short8 = Nucleus::createBitCast(cast.value, Short8::getType());
 	Value *packed = Nucleus::createShuffleVector(short8, short8, select);
 
@@ -2076,7 +2085,7 @@
 	else
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_v8i16);
-		const Ice::Intrinsics::IntrinsicInfo intrinsic = {Ice::Intrinsics::AddSaturateSigned, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F};
+		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::AddSaturateSigned, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
 		auto target = ::context->getConstantUndef(Ice::IceType_i32);
 		auto paddsw = Ice::InstIntrinsicCall::create(::function, 2, result, target, intrinsic);
 		paddsw->addArg(x.value);
@@ -2102,7 +2111,7 @@
 	else
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_v8i16);
-		const Ice::Intrinsics::IntrinsicInfo intrinsic = {Ice::Intrinsics::SubtractSaturateSigned, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F};
+		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::SubtractSaturateSigned, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
 		auto target = ::context->getConstantUndef(Ice::IceType_i32);
 		auto psubsw = Ice::InstIntrinsicCall::create(::function, 2, result, target, intrinsic);
 		psubsw->addArg(x.value);
@@ -2128,7 +2137,7 @@
 	else
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_v8i16);
-		const Ice::Intrinsics::IntrinsicInfo intrinsic = {Ice::Intrinsics::MultiplyHighSigned, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F};
+		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::MultiplyHighSigned, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
 		auto target = ::context->getConstantUndef(Ice::IceType_i32);
 		auto pmulhw = Ice::InstIntrinsicCall::create(::function, 2, result, target, intrinsic);
 		pmulhw->addArg(x.value);
@@ -2152,7 +2161,7 @@
 	else
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_v8i16);
-		const Ice::Intrinsics::IntrinsicInfo intrinsic = {Ice::Intrinsics::MultiplyAddPairs, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F};
+		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::MultiplyAddPairs, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
 		auto target = ::context->getConstantUndef(Ice::IceType_i32);
 		auto pmaddwd = Ice::InstIntrinsicCall::create(::function, 2, result, target, intrinsic);
 		pmaddwd->addArg(x.value);
@@ -2182,7 +2191,7 @@
 	else
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_v16i8);
-		const Ice::Intrinsics::IntrinsicInfo intrinsic = {Ice::Intrinsics::VectorPackSigned, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F};
+		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::VectorPackSigned, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
 		auto target = ::context->getConstantUndef(Ice::IceType_i32);
 		auto pack = Ice::InstIntrinsicCall::create(::function, 2, result, target, intrinsic);
 		pack->addArg(x.value);
@@ -2212,7 +2221,7 @@
 	else
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_v16i8);
-		const Ice::Intrinsics::IntrinsicInfo intrinsic = {Ice::Intrinsics::VectorPackUnsigned, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F};
+		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::VectorPackUnsigned, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
 		auto target = ::context->getConstantUndef(Ice::IceType_i32);
 		auto pack = Ice::InstIntrinsicCall::create(::function, 2, result, target, intrinsic);
 		pack->addArg(x.value);
@@ -2358,7 +2367,7 @@
 	else
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_v8i16);
-		const Ice::Intrinsics::IntrinsicInfo intrinsic = {Ice::Intrinsics::AddSaturateUnsigned, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F};
+		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::AddSaturateUnsigned, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
 		auto target = ::context->getConstantUndef(Ice::IceType_i32);
 		auto paddusw = Ice::InstIntrinsicCall::create(::function, 2, result, target, intrinsic);
 		paddusw->addArg(x.value);
@@ -2384,7 +2393,7 @@
 	else
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_v8i16);
-		const Ice::Intrinsics::IntrinsicInfo intrinsic = {Ice::Intrinsics::SubtractSaturateUnsigned, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F};
+		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::SubtractSaturateUnsigned, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
 		auto target = ::context->getConstantUndef(Ice::IceType_i32);
 		auto psubusw = Ice::InstIntrinsicCall::create(::function, 2, result, target, intrinsic);
 		psubusw->addArg(x.value);
@@ -2410,7 +2419,7 @@
 	else
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_v8i16);
-		const Ice::Intrinsics::IntrinsicInfo intrinsic = {Ice::Intrinsics::MultiplyHighUnsigned, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F};
+		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::MultiplyHighUnsigned, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
 		auto target = ::context->getConstantUndef(Ice::IceType_i32);
 		auto pmulhuw = Ice::InstIntrinsicCall::create(::function, 2, result, target, intrinsic);
 		pmulhuw->addArg(x.value);
@@ -2626,27 +2635,27 @@
 	return T(Ice::IceType_v8i16);
 }
 
-RValue<Int> operator++(Int &val, int)   // Post-increment
+RValue<Int> operator++(Int &val, int)  // Post-increment
 {
 	RValue<Int> res = val;
 	val += 1;
 	return res;
 }
 
-const Int &operator++(Int &val)   // Pre-increment
+const Int &operator++(Int &val)  // Pre-increment
 {
 	val += 1;
 	return val;
 }
 
-RValue<Int> operator--(Int &val, int)   // Post-decrement
+RValue<Int> operator--(Int &val, int)  // Post-decrement
 {
 	RValue<Int> res = val;
 	val -= 1;
 	return res;
 }
 
-const Int &operator--(Int &val)   // Pre-decrement
+const Int &operator--(Int &val)  // Pre-decrement
 {
 	val -= 1;
 	return val;
@@ -2662,7 +2671,7 @@
 	else
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_i32);
-		const Ice::Intrinsics::IntrinsicInfo intrinsic = {Ice::Intrinsics::Nearbyint, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F};
+		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::Nearbyint, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
 		auto target = ::context->getConstantUndef(Ice::IceType_i32);
 		auto nearbyint = Ice::InstIntrinsicCall::create(::function, 1, result, target, intrinsic);
 		nearbyint->addArg(cast.value);
@@ -2690,35 +2699,36 @@
 
 	// If the value is negative, store 0, otherwise store the result of the conversion
 	storeValue((~(As<Int>(cast) >> 31) &
-	// Check if the value can be represented as an Int
-		IfThenElse(cast >= ustartf,
-	// If the value is too large, subtract ustart and re-add it after conversion.
-			As<Int>(As<UInt>(Int(cast - Float(ustartf))) + UInt(ustart)),
-	// Otherwise, just convert normally
-			Int(cast))).value);
+	            // Check if the value can be represented as an Int
+	            IfThenElse(cast >= ustartf,
+	                       // If the value is too large, subtract ustart and re-add it after conversion.
+	                       As<Int>(As<UInt>(Int(cast - Float(ustartf))) + UInt(ustart)),
+	                       // Otherwise, just convert normally
+	                       Int(cast)))
+	               .value);
 }
 
-RValue<UInt> operator++(UInt &val, int)   // Post-increment
+RValue<UInt> operator++(UInt &val, int)  // Post-increment
 {
 	RValue<UInt> res = val;
 	val += 1;
 	return res;
 }
 
-const UInt &operator++(UInt &val)   // Pre-increment
+const UInt &operator++(UInt &val)  // Pre-increment
 {
 	val += 1;
 	return val;
 }
 
-RValue<UInt> operator--(UInt &val, int)   // Post-decrement
+RValue<UInt> operator--(UInt &val, int)  // Post-decrement
 {
 	RValue<UInt> res = val;
 	val -= 1;
 	return res;
 }
 
-const UInt &operator--(UInt &val)   // Pre-decrement
+const UInt &operator--(UInt &val)  // Pre-decrement
 {
 	val -= 1;
 	return val;
@@ -2822,17 +2832,18 @@
 	return T(Type_v2i32);
 }
 
-Int4::Int4(RValue<Byte4> cast) : XYZW(this)
+Int4::Int4(RValue<Byte4> cast)
+    : XYZW(this)
 {
 	Value *x = Nucleus::createBitCast(cast.value, Int::getType());
 	Value *a = Nucleus::createInsertElement(loadValue(), x, 0);
 
 	Value *e;
-	int swizzle[16] = {0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23};
+	int swizzle[16] = { 0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23 };
 	Value *b = Nucleus::createBitCast(a, Byte16::getType());
 	Value *c = Nucleus::createShuffleVector(b, V(Nucleus::createNullValue(Byte16::getType())), swizzle);
 
-	int swizzle2[8] = {0, 8, 1, 9, 2, 10, 3, 11};
+	int swizzle2[8] = { 0, 8, 1, 9, 2, 10, 3, 11 };
 	Value *d = Nucleus::createBitCast(c, Short8::getType());
 	e = Nucleus::createShuffleVector(d, V(Nucleus::createNullValue(Short8::getType())), swizzle2);
 
@@ -2840,43 +2851,47 @@
 	storeValue(f);
 }
 
-Int4::Int4(RValue<SByte4> cast) : XYZW(this)
+Int4::Int4(RValue<SByte4> cast)
+    : XYZW(this)
 {
 	Value *x = Nucleus::createBitCast(cast.value, Int::getType());
 	Value *a = Nucleus::createInsertElement(loadValue(), x, 0);
 
-	int swizzle[16] = {0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7};
+	int swizzle[16] = { 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7 };
 	Value *b = Nucleus::createBitCast(a, Byte16::getType());
 	Value *c = Nucleus::createShuffleVector(b, b, swizzle);
 
-	int swizzle2[8] = {0, 0, 1, 1, 2, 2, 3, 3};
+	int swizzle2[8] = { 0, 0, 1, 1, 2, 2, 3, 3 };
 	Value *d = Nucleus::createBitCast(c, Short8::getType());
 	Value *e = Nucleus::createShuffleVector(d, d, swizzle2);
 
 	*this = As<Int4>(e) >> 24;
 }
 
-Int4::Int4(RValue<Short4> cast) : XYZW(this)
+Int4::Int4(RValue<Short4> cast)
+    : XYZW(this)
 {
-	int swizzle[8] = {0, 0, 1, 1, 2, 2, 3, 3};
+	int swizzle[8] = { 0, 0, 1, 1, 2, 2, 3, 3 };
 	Value *c = Nucleus::createShuffleVector(cast.value, cast.value, swizzle);
 
 	*this = As<Int4>(c) >> 16;
 }
 
-Int4::Int4(RValue<UShort4> cast) : XYZW(this)
+Int4::Int4(RValue<UShort4> cast)
+    : XYZW(this)
 {
-	int swizzle[8] = {0, 8, 1, 9, 2, 10, 3, 11};
+	int swizzle[8] = { 0, 8, 1, 9, 2, 10, 3, 11 };
 	Value *c = Nucleus::createShuffleVector(cast.value, Short8(0, 0, 0, 0, 0, 0, 0, 0).loadValue(), swizzle);
 	Value *d = Nucleus::createBitCast(c, Int4::getType());
 	storeValue(d);
 }
 
-Int4::Int4(RValue<Int> rhs) : XYZW(this)
+Int4::Int4(RValue<Int> rhs)
+    : XYZW(this)
 {
 	Value *vector = Nucleus::createBitCast(rhs.value, Int4::getType());
 
-	int swizzle[4] = {0, 0, 0, 0};
+	int swizzle[4] = { 0, 0, 0, 0 };
 	Value *replicate = Nucleus::createShuffleVector(vector, vector, swizzle);
 
 	storeValue(replicate);
@@ -2984,7 +2999,7 @@
 	else
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_v4i32);
-		const Ice::Intrinsics::IntrinsicInfo intrinsic = {Ice::Intrinsics::Nearbyint, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F};
+		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::Nearbyint, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
 		auto target = ::context->getConstantUndef(Ice::IceType_i32);
 		auto nearbyint = Ice::InstIntrinsicCall::create(::function, 1, result, target, intrinsic);
 		nearbyint->addArg(cast.value);
@@ -3013,7 +3028,7 @@
 	else
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_v8i16);
-		const Ice::Intrinsics::IntrinsicInfo intrinsic = {Ice::Intrinsics::VectorPackSigned, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F};
+		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::VectorPackSigned, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
 		auto target = ::context->getConstantUndef(Ice::IceType_i32);
 		auto pack = Ice::InstIntrinsicCall::create(::function, 2, result, target, intrinsic);
 		pack->addArg(x.value);
@@ -3039,7 +3054,7 @@
 	else
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_v8i16);
-		const Ice::Intrinsics::IntrinsicInfo intrinsic = {Ice::Intrinsics::VectorPackUnsigned, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F};
+		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::VectorPackUnsigned, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
 		auto target = ::context->getConstantUndef(Ice::IceType_i32);
 		auto pack = Ice::InstIntrinsicCall::create(::function, 2, result, target, intrinsic);
 		pack->addArg(x.value);
@@ -3060,7 +3075,7 @@
 	else
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_i32);
-		const Ice::Intrinsics::IntrinsicInfo intrinsic = {Ice::Intrinsics::SignMask, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F};
+		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::SignMask, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
 		auto target = ::context->getConstantUndef(Ice::IceType_i32);
 		auto movmsk = Ice::InstIntrinsicCall::create(::function, 1, result, target, intrinsic);
 		movmsk->addArg(x.value);
@@ -3075,7 +3090,8 @@
 	return T(Ice::IceType_v4i32);
 }
 
-UInt4::UInt4(RValue<Float4> cast) : XYZW(this)
+UInt4::UInt4(RValue<Float4> cast)
+    : XYZW(this)
 {
 	// Smallest positive value representable in UInt, but not in Int
 	const unsigned int ustart = 0x80000000u;
@@ -3085,17 +3101,18 @@
 	Int4 uiValue = CmpNLT(cast, Float4(ustartf));
 	// If the value is too large, subtract ustart and re-add it after conversion.
 	uiValue = (uiValue & As<Int4>(As<UInt4>(Int4(cast - Float4(ustartf))) + UInt4(ustart))) |
-	// Otherwise, just convert normally
+	          // Otherwise, just convert normally
 	          (~uiValue & Int4(cast));
 	// If the value is negative, store 0, otherwise store the result of the conversion
 	storeValue((~(As<Int4>(cast) >> 31) & uiValue).value);
 }
 
-UInt4::UInt4(RValue<UInt> rhs) : XYZW(this)
+UInt4::UInt4(RValue<UInt> rhs)
+    : XYZW(this)
 {
 	Value *vector = Nucleus::createBitCast(rhs.value, UInt4::getType());
 
-	int swizzle[4] = {0, 0, 0, 0};
+	int swizzle[4] = { 0, 0, 0, 0 };
 	Value *replicate = Nucleus::createShuffleVector(vector, vector, swizzle);
 
 	storeValue(replicate);
@@ -3216,7 +3233,7 @@
 RValue<Float> Sqrt(RValue<Float> x)
 {
 	Ice::Variable *result = ::function->makeVariable(Ice::IceType_f32);
-	const Ice::Intrinsics::IntrinsicInfo intrinsic = {Ice::Intrinsics::Sqrt, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F};
+	const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::Sqrt, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
 	auto target = ::context->getConstantUndef(Ice::IceType_i32);
 	auto sqrt = Ice::InstIntrinsicCall::create(::function, 1, result, target, intrinsic);
 	sqrt->addArg(x.value);
@@ -3260,11 +3277,12 @@
 	return T(Type_v2f32);
 }
 
-Float4::Float4(RValue<Float> rhs) : XYZW(this)
+Float4::Float4(RValue<Float> rhs)
+    : XYZW(this)
 {
 	Value *vector = Nucleus::createBitCast(rhs.value, Float4::getType());
 
-	int swizzle[4] = {0, 0, 0, 0};
+	int swizzle[4] = { 0, 0, 0, 0 };
 	Value *replicate = Nucleus::createShuffleVector(vector, vector, swizzle);
 
 	storeValue(replicate);
@@ -3321,7 +3339,7 @@
 	else
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_v4f32);
-		const Ice::Intrinsics::IntrinsicInfo intrinsic = {Ice::Intrinsics::Sqrt, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F};
+		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::Sqrt, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
 		auto target = ::context->getConstantUndef(Ice::IceType_i32);
 		auto sqrt = Ice::InstIntrinsicCall::create(::function, 1, result, target, intrinsic);
 		sqrt->addArg(x.value);
@@ -3341,7 +3359,7 @@
 	else
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_i32);
-		const Ice::Intrinsics::IntrinsicInfo intrinsic = {Ice::Intrinsics::SignMask, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F};
+		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::SignMask, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
 		auto target = ::context->getConstantUndef(Ice::IceType_i32);
 		auto movmsk = Ice::InstIntrinsicCall::create(::function, 1, result, target, intrinsic);
 		movmsk->addArg(x.value);
@@ -3421,7 +3439,7 @@
 	else if(CPUID::SSE4_1)
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_v4f32);
-		const Ice::Intrinsics::IntrinsicInfo intrinsic = {Ice::Intrinsics::Round, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F};
+		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::Round, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
 		auto target = ::context->getConstantUndef(Ice::IceType_i32);
 		auto round = Ice::InstIntrinsicCall::create(::function, 2, result, target, intrinsic);
 		round->addArg(x.value);
@@ -3441,7 +3459,7 @@
 	if(CPUID::SSE4_1)
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_v4f32);
-		const Ice::Intrinsics::IntrinsicInfo intrinsic = {Ice::Intrinsics::Round, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F};
+		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::Round, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
 		auto target = ::context->getConstantUndef(Ice::IceType_i32);
 		auto round = Ice::InstIntrinsicCall::create(::function, 2, result, target, intrinsic);
 		round->addArg(x.value);
@@ -3466,9 +3484,9 @@
 	}
 	else
 	{
-		frc = x - Float4(Int4(x));   // Signed fractional part.
+		frc = x - Float4(Int4(x));  // Signed fractional part.
 
-		frc += As<Float4>(As<Int4>(CmpNLE(Float4(0.0f), frc)) & As<Int4>(Float4(1, 1, 1, 1)));   // Add 1.0 if negative.
+		frc += As<Float4>(As<Int4>(CmpNLE(Float4(0.0f), frc)) & As<Int4>(Float4(1, 1, 1, 1)));  // Add 1.0 if negative.
 	}
 
 	// x - floor(x) can be 1.0 for very small negative x.
@@ -3481,7 +3499,7 @@
 	if(CPUID::SSE4_1)
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_v4f32);
-		const Ice::Intrinsics::IntrinsicInfo intrinsic = {Ice::Intrinsics::Round, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F};
+		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::Round, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
 		auto target = ::context->getConstantUndef(Ice::IceType_i32);
 		auto round = Ice::InstIntrinsicCall::create(::function, 2, result, target, intrinsic);
 		round->addArg(x.value);
@@ -3501,7 +3519,7 @@
 	if(CPUID::SSE4_1)
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_v4f32);
-		const Ice::Intrinsics::IntrinsicInfo intrinsic = {Ice::Intrinsics::Round, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F};
+		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::Round, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
 		auto target = ::context->getConstantUndef(Ice::IceType_i32);
 		auto round = Ice::InstIntrinsicCall::create(::function, 2, result, target, intrinsic);
 		round->addArg(x.value);
@@ -3527,9 +3545,9 @@
 	return Long(Int(0));
 }
 
-RValue<Pointer<Byte>> ConstantPointer(void const * ptr)
+RValue<Pointer<Byte>> ConstantPointer(void const *ptr)
 {
-	if(sizeof(void*) == 8)
+	if(sizeof(void *) == 8)
 	{
 		return RValue<Pointer<Byte>>(V(::context->getConstantInt64(reinterpret_cast<intptr_t>(ptr))));
 	}
@@ -3539,14 +3557,14 @@
 	}
 }
 
-RValue<Pointer<Byte>> ConstantData(void const * data, size_t size)
+RValue<Pointer<Byte>> ConstantData(void const *data, size_t size)
 {
 	// TODO: Try to use Ice::VariableDeclaration::DataInitializer and
 	// getConstantSym instead of tagging data on the routine.
 	return ConstantPointer(::routine->addConstantData(data, size));
 }
 
-Value* Call(RValue<Pointer<Byte>> fptr, Type* retTy, std::initializer_list<Value*> args, std::initializer_list<Type*> argTys)
+Value *Call(RValue<Pointer<Byte>> fptr, Type *retTy, std::initializer_list<Value *> args, std::initializer_list<Type *> argTys)
 {
 	Ice::Variable *ret = nullptr;
 	if(retTy != nullptr)
@@ -3564,15 +3582,25 @@
 
 void Breakpoint()
 {
-	const Ice::Intrinsics::IntrinsicInfo intrinsic = {Ice::Intrinsics::Trap, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F};
+	const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::Trap, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
 	auto target = ::context->getConstantUndef(Ice::IceType_i32);
 	auto trap = Ice::InstIntrinsicCall::create(::function, 0, nullptr, target, intrinsic);
 	::basicBlock->appendInst(trap);
 }
 
-void Nucleus::createFence(std::memory_order memoryOrder) { UNIMPLEMENTED("Subzero createFence()"); }
-Value *Nucleus::createMaskedLoad(Value *ptr, Type *elTy, Value *mask, unsigned int alignment, bool zeroMaskedLanes) { UNIMPLEMENTED("Subzero createMaskedLoad()"); return nullptr; }
-void Nucleus::createMaskedStore(Value *ptr, Value *val, Value *mask, unsigned int alignment) { UNIMPLEMENTED("Subzero createMaskedStore()"); }
+void Nucleus::createFence(std::memory_order memoryOrder)
+{
+	UNIMPLEMENTED("Subzero createFence()");
+}
+Value *Nucleus::createMaskedLoad(Value *ptr, Type *elTy, Value *mask, unsigned int alignment, bool zeroMaskedLanes)
+{
+	UNIMPLEMENTED("Subzero createMaskedLoad()");
+	return nullptr;
+}
+void Nucleus::createMaskedStore(Value *ptr, Value *val, Value *mask, unsigned int alignment)
+{
+	UNIMPLEMENTED("Subzero createMaskedStore()");
+}
 
 RValue<Float4> Gather(RValue<Pointer<Float>> base, RValue<Int4> offsets, RValue<Int4> mask, unsigned int alignment, bool zeroMaskedLanes /* = false */)
 {
@@ -3698,11 +3726,12 @@
 {
 	if(emulateIntrinsics)
 	{
-		UNIMPLEMENTED("Subzero Ctlz()"); return UInt(0);
+		UNIMPLEMENTED("Subzero Ctlz()");
+		return UInt(0);
 	}
 	else
 	{
-		Ice::Variable* result = ::function->makeVariable(Ice::IceType_i32);
+		Ice::Variable *result = ::function->makeVariable(Ice::IceType_i32);
 		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::Ctlz, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
 		auto target = ::context->getConstantUndef(Ice::IceType_i32);
 		auto ctlz = Ice::InstIntrinsicCall::create(::function, 1, result, target, intrinsic);
@@ -3717,7 +3746,8 @@
 {
 	if(emulateIntrinsics)
 	{
-		UNIMPLEMENTED("Subzero Ctlz()"); return UInt4(0);
+		UNIMPLEMENTED("Subzero Ctlz()");
+		return UInt4(0);
 	}
 	else
 	{
@@ -3735,11 +3765,12 @@
 {
 	if(emulateIntrinsics)
 	{
-		UNIMPLEMENTED("Subzero Cttz()"); return UInt(0);
+		UNIMPLEMENTED("Subzero Cttz()");
+		return UInt(0);
 	}
 	else
 	{
-		Ice::Variable* result = ::function->makeVariable(Ice::IceType_i32);
+		Ice::Variable *result = ::function->makeVariable(Ice::IceType_i32);
 		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::Cttz, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
 		auto target = ::context->getConstantUndef(Ice::IceType_i32);
 		auto ctlz = Ice::InstIntrinsicCall::create(::function, 1, result, target, intrinsic);
@@ -3754,7 +3785,8 @@
 {
 	if(emulateIntrinsics)
 	{
-		UNIMPLEMENTED("Subzero Cttz()"); return UInt4(0);
+		UNIMPLEMENTED("Subzero Cttz()");
+		return UInt4(0);
 	}
 	else
 	{
@@ -3769,16 +3801,19 @@
 }
 
 void EmitDebugLocation() {}
-void EmitDebugVariable(Value* value) {}
+void EmitDebugVariable(Value *value) {}
 void FlushDebug() {}
 
-void Nucleus::createCoroutine(Type *YieldType, std::vector<Type*> &Params)
+void Nucleus::createCoroutine(Type *YieldType, std::vector<Type *> &Params)
 {
 	// Subzero currently only supports coroutines as functions (i.e. that do not yield)
 	createFunction(YieldType, Params);
 }
 
-static bool coroutineEntryAwaitStub(Nucleus::CoroutineHandle, void* yieldValue) { return false; }
+static bool coroutineEntryAwaitStub(Nucleus::CoroutineHandle, void *yieldValue)
+{
+	return false;
+}
 static void coroutineEntryDestroyStub(Nucleus::CoroutineHandle) {}
 
 std::shared_ptr<Routine> Nucleus::acquireCoroutine(const char *name, const Config::Edit &cfgEdit /* = Config::Edit::None */)
@@ -3788,12 +3823,15 @@
 
 	// For now, set the await and destroy entries to stubs, until we add proper coroutine support to the Subzero backend
 	auto routine = std::static_pointer_cast<ELFMemoryStreamer>(coroutineEntry);
-	routine->setEntry(Nucleus::CoroutineEntryAwait, reinterpret_cast<const void*>(&coroutineEntryAwaitStub));
-	routine->setEntry(Nucleus::CoroutineEntryDestroy, reinterpret_cast<const void*>(&coroutineEntryDestroyStub));
+	routine->setEntry(Nucleus::CoroutineEntryAwait, reinterpret_cast<const void *>(&coroutineEntryAwaitStub));
+	routine->setEntry(Nucleus::CoroutineEntryDestroy, reinterpret_cast<const void *>(&coroutineEntryDestroyStub));
 
 	return coroutineEntry;
 }
 
-void Nucleus::yield(Value* val) { UNIMPLEMENTED("Yield"); }
+void Nucleus::yield(Value *val)
+{
+	UNIMPLEMENTED("Yield");
+}
 
 }  // namespace rr
diff --git a/src/Reactor/Thread.cpp b/src/Reactor/Thread.cpp
index 46f3550..069c197 100644
--- a/src/Reactor/Thread.cpp
+++ b/src/Reactor/Thread.cpp
@@ -19,74 +19,74 @@
 Thread::Thread(void (*threadFunction)(void *parameters), void *parameters)
 {
 	Event init;
-	Entry entry = {threadFunction, parameters, &init};
+	Entry entry = { threadFunction, parameters, &init };
 
-	#if defined(_WIN32)
-		handle = CreateThread(NULL, 1024 * 1024, startFunction, &entry, 0, NULL);
-	#else
-		pthread_create(&handle, NULL, startFunction, &entry);
-	#endif
+#if defined(_WIN32)
+	handle = CreateThread(NULL, 1024 * 1024, startFunction, &entry, 0, NULL);
+#else
+	pthread_create(&handle, NULL, startFunction, &entry);
+#endif
 
 	init.wait();
 }
 
 Thread::~Thread()
 {
-	join();   // Make threads exit before deleting them to not block here
+	join();  // Make threads exit before deleting them to not block here
 }
 
 void Thread::join()
 {
 	if(!hasJoined)
 	{
-		#if defined(_WIN32)
-			WaitForSingleObject(handle, INFINITE);
-			CloseHandle(handle);
-		#else
-			pthread_join(handle, NULL);
-		#endif
+#if defined(_WIN32)
+		WaitForSingleObject(handle, INFINITE);
+		CloseHandle(handle);
+#else
+		pthread_join(handle, NULL);
+#endif
 
 		hasJoined = true;
 	}
 }
 
 #if defined(_WIN32)
-	unsigned long __stdcall Thread::startFunction(void *parameters)
-	{
-		Entry entry = *(Entry*)parameters;
-		entry.init->signal();
-		entry.threadFunction(entry.threadParameters);
-		return 0;
-	}
+unsigned long __stdcall Thread::startFunction(void *parameters)
+{
+	Entry entry = *(Entry *)parameters;
+	entry.init->signal();
+	entry.threadFunction(entry.threadParameters);
+	return 0;
+}
 #else
-	void *Thread::startFunction(void *parameters)
-	{
-		Entry entry = *(Entry*)parameters;
-		entry.init->signal();
-		entry.threadFunction(entry.threadParameters);
-		return nullptr;
-	}
+void *Thread::startFunction(void *parameters)
+{
+	Entry entry = *(Entry *)parameters;
+	entry.init->signal();
+	entry.threadFunction(entry.threadParameters);
+	return nullptr;
+}
 #endif
 
 Event::Event()
 {
-	#if defined(_WIN32)
-		handle = CreateEvent(NULL, FALSE, FALSE, NULL);
-	#else
-		pthread_cond_init(&handle, NULL);
-		pthread_mutex_init(&mutex, NULL);
-		signaled = false;
-	#endif
+#if defined(_WIN32)
+	handle = CreateEvent(NULL, FALSE, FALSE, NULL);
+#else
+	pthread_cond_init(&handle, NULL);
+	pthread_mutex_init(&mutex, NULL);
+	signaled = false;
+#endif
 }
 
 Event::~Event()
 {
-	#if defined(_WIN32)
-		CloseHandle(handle);
-	#else
-		pthread_cond_destroy(&handle);
-		pthread_mutex_destroy(&mutex);
-	#endif
+#if defined(_WIN32)
+	CloseHandle(handle);
+#else
+	pthread_cond_destroy(&handle);
+	pthread_mutex_destroy(&mutex);
+#endif
 }
 
 }  // namespace rr
diff --git a/src/Reactor/Thread.hpp b/src/Reactor/Thread.hpp
index 7feb61e..a42e624 100644
--- a/src/Reactor/Thread.hpp
+++ b/src/Reactor/Thread.hpp
@@ -16,31 +16,31 @@
 #define rr_Thread_hpp
 
 #if defined(_WIN32)
-	#ifndef WIN32_LEAN_AND_MEAN
-		#define WIN32_LEAN_AND_MEAN
-	#endif
-	#include <windows.h>
-	#include <intrin.h>
+#	ifndef WIN32_LEAN_AND_MEAN
+#		define WIN32_LEAN_AND_MEAN
+#	endif
+#	include <windows.h>
+#	include <intrin.h>
 #else
-	#include <pthread.h>
-	#include <sched.h>
-	#include <unistd.h>
-	#define TLS_OUT_OF_INDEXES (pthread_key_t)(~0)
+#	include <pthread.h>
+#	include <sched.h>
+#	include <unistd.h>
+#	define TLS_OUT_OF_INDEXES (pthread_key_t)(~0)
 #endif
 
 #include <stdlib.h>
 
 #if defined(__clang__)
-#if __has_include(<atomic>) // clang has an explicit check for the availability of atomic
-#define USE_STD_ATOMIC 1
-#endif
+#	if __has_include(<atomic>)  // clang has an explicit check for the availability of atomic
+#		define USE_STD_ATOMIC 1
+#	endif
 // atomic is available in C++11 or newer, and in Visual Studio 2012 or newer
-#elif (defined(_MSC_VER) && (_MSC_VER >= 1700)) || (__cplusplus >= 201103L)
-#define USE_STD_ATOMIC 1
+#elif(defined(_MSC_VER) && (_MSC_VER >= 1700)) || (__cplusplus >= 201103L)
+#	define USE_STD_ATOMIC 1
 #endif
 
 #if USE_STD_ATOMIC
-#include <atomic>
+#	include <atomic>
 #endif
 
 namespace rr {
@@ -59,11 +59,11 @@
 	static void yield();
 	static void sleep(int milliseconds);
 
-	#if defined(_WIN32)
-		typedef DWORD LocalStorageKey;
-	#else
-		typedef pthread_key_t LocalStorageKey;
-	#endif
+#if defined(_WIN32)
+	typedef DWORD LocalStorageKey;
+#else
+	typedef pthread_key_t LocalStorageKey;
+#endif
 
 	static LocalStorageKey allocateLocalStorageKey(void (*destructor)(void *storage) = free);
 	static void freeLocalStorageKey(LocalStorageKey key);
@@ -79,13 +79,13 @@
 		Event *init;
 	};
 
-	#if defined(_WIN32)
-		static unsigned long __stdcall startFunction(void *parameters);
-		HANDLE handle;
-	#else
-		static void *startFunction(void *parameters);
-		pthread_t handle;
-	#endif
+#if defined(_WIN32)
+	static unsigned long __stdcall startFunction(void *parameters);
+	HANDLE handle;
+#else
+	static void *startFunction(void *parameters);
+	pthread_t handle;
+#endif
 
 	bool hasJoined = false;
 };
@@ -103,13 +103,13 @@
 	void wait();
 
 private:
-	#if defined(_WIN32)
-		HANDLE handle;
-	#else
-		pthread_cond_t handle;
-		pthread_mutex_t mutex;
-		volatile bool signaled;
-	#endif
+#if defined(_WIN32)
+	HANDLE handle;
+#else
+	pthread_cond_t handle;
+	pthread_mutex_t mutex;
+	volatile bool signaled;
+#endif
 };
 
 #if PERF_PROFILE
@@ -130,42 +130,42 @@
 
 inline void Thread::yield()
 {
-	#if defined(_WIN32)
-		Sleep(0);
-	#elif defined(__APPLE__)
-		pthread_yield_np();
-	#else
-		sched_yield();
-	#endif
+#if defined(_WIN32)
+	Sleep(0);
+#elif defined(__APPLE__)
+	pthread_yield_np();
+#else
+	sched_yield();
+#endif
 }
 
 inline void Thread::sleep(int milliseconds)
 {
-	#if defined(_WIN32)
-		Sleep(milliseconds);
-	#else
-		usleep(1000 * milliseconds);
-	#endif
+#if defined(_WIN32)
+	Sleep(milliseconds);
+#else
+	usleep(1000 * milliseconds);
+#endif
 }
 
 inline Thread::LocalStorageKey Thread::allocateLocalStorageKey(void (*destructor)(void *storage))
 {
-	#if defined(_WIN32)
-		return TlsAlloc();
-	#else
-		LocalStorageKey key;
-		pthread_key_create(&key, destructor);
-		return key;
-	#endif
+#if defined(_WIN32)
+	return TlsAlloc();
+#else
+	LocalStorageKey key;
+	pthread_key_create(&key, destructor);
+	return key;
+#endif
 }
 
 inline void Thread::freeLocalStorageKey(LocalStorageKey key)
 {
-	#if defined(_WIN32)
-		TlsFree(key);
-	#else
-		pthread_key_delete(key);   // Using an invalid key is an error but not undefined behavior.
-	#endif
+#if defined(_WIN32)
+	TlsFree(key);
+#else
+	pthread_key_delete(key);  // Using an invalid key is an error but not undefined behavior.
+#endif
 }
 
 inline void *Thread::allocateLocalStorage(LocalStorageKey key, size_t size)
@@ -179,164 +179,178 @@
 
 	void *storage = malloc(size);
 
-	#if defined(_WIN32)
-		TlsSetValue(key, storage);
-	#else
-		pthread_setspecific(key, storage);
-	#endif
+#if defined(_WIN32)
+	TlsSetValue(key, storage);
+#else
+	pthread_setspecific(key, storage);
+#endif
 
 	return storage;
 }
 
 inline void *Thread::getLocalStorage(LocalStorageKey key)
 {
-	#if defined(_WIN32)
-		return TlsGetValue(key);
-	#else
-		if(key == TLS_OUT_OF_INDEXES)   // Avoid undefined behavior.
-		{
-			return nullptr;
-		}
+#if defined(_WIN32)
+	return TlsGetValue(key);
+#else
+	if(key == TLS_OUT_OF_INDEXES)  // Avoid undefined behavior.
+	{
+		return nullptr;
+	}
 
-		return pthread_getspecific(key);
-	#endif
+	return pthread_getspecific(key);
+#endif
 }
 
 inline void Thread::freeLocalStorage(LocalStorageKey key)
 {
 	free(getLocalStorage(key));
 
-	#if defined(_WIN32)
-		TlsSetValue(key, nullptr);
-	#else
-		pthread_setspecific(key, nullptr);
-	#endif
+#if defined(_WIN32)
+	TlsSetValue(key, nullptr);
+#else
+	pthread_setspecific(key, nullptr);
+#endif
 }
 
 inline void Event::signal()
 {
-	#if defined(_WIN32)
-		SetEvent(handle);
-	#else
-		pthread_mutex_lock(&mutex);
-		signaled = true;
-		pthread_cond_signal(&handle);
-		pthread_mutex_unlock(&mutex);
-	#endif
+#if defined(_WIN32)
+	SetEvent(handle);
+#else
+	pthread_mutex_lock(&mutex);
+	signaled = true;
+	pthread_cond_signal(&handle);
+	pthread_mutex_unlock(&mutex);
+#endif
 }
 
 inline void Event::wait()
 {
-	#if defined(_WIN32)
-		WaitForSingleObject(handle, INFINITE);
-	#else
-		pthread_mutex_lock(&mutex);
-		while(!signaled) pthread_cond_wait(&handle, &mutex);
-		signaled = false;
-		pthread_mutex_unlock(&mutex);
-	#endif
+#if defined(_WIN32)
+	WaitForSingleObject(handle, INFINITE);
+#else
+	pthread_mutex_lock(&mutex);
+	while(!signaled) pthread_cond_wait(&handle, &mutex);
+	signaled = false;
+	pthread_mutex_unlock(&mutex);
+#endif
 }
 
 #if PERF_PROFILE
 inline int64_t atomicExchange(volatile int64_t *target, int64_t value)
 {
-	#if defined(_WIN32)
-		return InterlockedExchange64(target, value);
-	#else
-		int ret;
-		__asm__ __volatile__("lock; xchg8 %x0,(%x1)" : "=r" (ret) :"r" (target), "0" (value) : "memory" );
-		return ret;
-	#endif
+#	if defined(_WIN32)
+	return InterlockedExchange64(target, value);
+#	else
+	int ret;
+	__asm__ __volatile__("lock; xchg8 %x0,(%x1)"
+	                     : "=r"(ret)
+	                     : "r"(target), "0"(value)
+	                     : "memory");
+	return ret;
+#	endif
 }
 
 inline int atomicExchange(volatile int *target, int value)
 {
-	#if defined(_WIN32)
-		return InterlockedExchange((volatile long*)target, (long)value);
-	#else
-		int ret;
-		__asm__ __volatile__("lock; xchgl %x0,(%x1)" : "=r" (ret) :"r" (target), "0" (value) : "memory" );
-		return ret;
-	#endif
+#	if defined(_WIN32)
+	return InterlockedExchange((volatile long *)target, (long)value);
+#	else
+	int ret;
+	__asm__ __volatile__("lock; xchgl %x0,(%x1)"
+	                     : "=r"(ret)
+	                     : "r"(target), "0"(value)
+	                     : "memory");
+	return ret;
+#	endif
 }
 #endif
 
 inline int atomicIncrement(volatile int *value)
 {
-	#if defined(_WIN32)
-		return InterlockedIncrement((volatile long*)value);
-	#else
-		return __sync_add_and_fetch(value, 1);
-	#endif
+#if defined(_WIN32)
+	return InterlockedIncrement((volatile long *)value);
+#else
+	return __sync_add_and_fetch(value, 1);
+#endif
 }
 
 inline int atomicDecrement(volatile int *value)
 {
-	#if defined(_WIN32)
-		return InterlockedDecrement((volatile long*)value);
-	#else
-		return __sync_sub_and_fetch(value, 1);
-	#endif
+#if defined(_WIN32)
+	return InterlockedDecrement((volatile long *)value);
+#else
+	return __sync_sub_and_fetch(value, 1);
+#endif
 }
 
-inline int atomicAdd(volatile int* target, int value)
+inline int atomicAdd(volatile int *target, int value)
 {
-	#if defined(_WIN32)
-		return InterlockedExchangeAdd((volatile long*)target, value) + value;
-	#else
-		return __sync_add_and_fetch(target, value);
-	#endif
+#if defined(_WIN32)
+	return InterlockedExchangeAdd((volatile long *)target, value) + value;
+#else
+	return __sync_add_and_fetch(target, value);
+#endif
 }
 
 inline void nop()
 {
-	#if defined(_WIN32)
-		__nop();
-	#else
-		__asm__ __volatile__ ("nop");
-	#endif
+#if defined(_WIN32)
+	__nop();
+#else
+	__asm__ __volatile__("nop");
+#endif
 }
 
 #if USE_STD_ATOMIC
-	class AtomicInt
-	{
-	public:
-		AtomicInt() : ai() {}
-		AtomicInt(int i) : ai(i) {}
+class AtomicInt
+{
+public:
+	AtomicInt()
+	    : ai()
+	{}
+	AtomicInt(int i)
+	    : ai(i)
+	{}
 
-		inline operator int() const { return ai.load(std::memory_order_acquire); }
-		inline void operator=(const AtomicInt& i) { ai.store(i.ai.load(std::memory_order_acquire), std::memory_order_release); }
-		inline void operator=(int i) { ai.store(i, std::memory_order_release); }
-		inline void operator--() { ai.fetch_sub(1, std::memory_order_acq_rel); }
-		inline void operator++() { ai.fetch_add(1, std::memory_order_acq_rel); }
-		inline int operator--(int) { return ai.fetch_sub(1, std::memory_order_acq_rel) - 1; }
-		inline int operator++(int) { return ai.fetch_add(1, std::memory_order_acq_rel) + 1; }
-		inline void operator-=(int i) { ai.fetch_sub(i, std::memory_order_acq_rel); }
-		inline void operator+=(int i) { ai.fetch_add(i, std::memory_order_acq_rel); }
-	private:
-		std::atomic<int> ai;
-	};
+	inline operator int() const { return ai.load(std::memory_order_acquire); }
+	inline void operator=(const AtomicInt &i) { ai.store(i.ai.load(std::memory_order_acquire), std::memory_order_release); }
+	inline void operator=(int i) { ai.store(i, std::memory_order_release); }
+	inline void operator--() { ai.fetch_sub(1, std::memory_order_acq_rel); }
+	inline void operator++() { ai.fetch_add(1, std::memory_order_acq_rel); }
+	inline int operator--(int) { return ai.fetch_sub(1, std::memory_order_acq_rel) - 1; }
+	inline int operator++(int) { return ai.fetch_add(1, std::memory_order_acq_rel) + 1; }
+	inline void operator-=(int i) { ai.fetch_sub(i, std::memory_order_acq_rel); }
+	inline void operator+=(int i) { ai.fetch_add(i, std::memory_order_acq_rel); }
+
+private:
+	std::atomic<int> ai;
+};
 #else
-	class AtomicInt
-	{
-	public:
-		AtomicInt() {}
-		AtomicInt(int i) : vi(i) {}
+class AtomicInt
+{
+public:
+	AtomicInt() {}
+	AtomicInt(int i)
+	    : vi(i)
+	{}
 
-		inline operator int() const { return vi; } // Note: this isn't a guaranteed atomic operation
-		inline void operator=(const AtomicInt& i) { atomicExchange(&vi, i.vi); }
-		inline void operator=(int i) { atomicExchange(&vi, i); }
-		inline void operator--() { atomicDecrement(&vi); }
-		inline void operator++() { atomicIncrement(&vi); }
-		inline int operator--(int) { return atomicDecrement(&vi); }
-		inline int operator++(int) { return atomicIncrement(&vi); }
-		inline void operator-=(int i) { atomicAdd(&vi, -i); }
-		inline void operator+=(int i) { atomicAdd(&vi, i); }
-	private:
-		volatile int vi;
-	};
+	inline operator int() const { return vi; }  // Note: this isn't a guaranteed atomic operation
+	inline void operator=(const AtomicInt &i) { atomicExchange(&vi, i.vi); }
+	inline void operator=(int i) { atomicExchange(&vi, i); }
+	inline void operator--() { atomicDecrement(&vi); }
+	inline void operator++() { atomicIncrement(&vi); }
+	inline int operator--(int) { return atomicDecrement(&vi); }
+	inline int operator++(int) { return atomicIncrement(&vi); }
+	inline void operator-=(int i) { atomicAdd(&vi, -i); }
+	inline void operator+=(int i) { atomicAdd(&vi, i); }
+
+private:
+	volatile int vi;
+};
 #endif
 
 }  // namespace rr
 
-#endif   // rr_Thread_hpp
+#endif  // rr_Thread_hpp
diff --git a/src/Reactor/Traits.hpp b/src/Reactor/Traits.hpp
index 53f36f0..fc7dfa7 100644
--- a/src/Reactor/Traits.hpp
+++ b/src/Reactor/Traits.hpp
@@ -19,7 +19,7 @@
 #include <type_traits>
 
 #ifdef Bool
-#undef Bool // b/127920555
+#	undef Bool  // b/127920555
 #endif
 
 namespace rr {
@@ -40,9 +40,12 @@
 class Float;
 class Float4;
 
-template<class T> class Pointer;
-template<class T> class LValue;
-template<class T> class RValue;
+template<class T>
+class Pointer;
+template<class T>
+class LValue;
+template<class T>
+class RValue;
 
 // enabled_if_t is identical to C++14's std::enable_if_t.
 // std::enable_if_t was introduced in C++14, but Reactor must support
@@ -51,19 +54,19 @@
 using enable_if_t = typename std::enable_if<Condition, TrueType>::type;
 
 // IsDefined<T>::value is true if T is a valid type, otherwise false.
-template <typename T, typename Enable = void>
+template<typename T, typename Enable = void>
 struct IsDefined
 {
 	static constexpr bool value = false;
 };
 
-template <typename T>
-struct IsDefined<T, enable_if_t<(sizeof(T)>0)> >
+template<typename T>
+struct IsDefined<T, enable_if_t<(sizeof(T) > 0)>>
 {
 	static constexpr bool value = true;
 };
 
-template <>
+template<>
 struct IsDefined<void>
 {
 	static constexpr bool value = true;
@@ -71,144 +74,273 @@
 
 // CToReactorT<T> resolves to the corresponding Reactor type for the given C
 // template type T.
-template<typename T, typename ENABLE = void> struct CToReactor;
-template<typename T> using CToReactorT = typename CToReactor<T>::type;
+template<typename T, typename ENABLE = void>
+struct CToReactor;
+template<typename T>
+using CToReactorT = typename CToReactor<T>::type;
 
 // CToReactor specializations for POD types.
-template<> struct CToReactor<void>    	{ using type = Void; };
-template<> struct CToReactor<bool>    	{ using type = Bool;   static Bool   cast(bool);     };
-template<> struct CToReactor<uint8_t> 	{ using type = Byte;   static Byte   cast(uint8_t);  };
-template<> struct CToReactor<int8_t>  	{ using type = SByte;  static SByte  cast(int8_t);   };
-template<> struct CToReactor<int16_t> 	{ using type = Short;  static Short  cast(int16_t);  };
-template<> struct CToReactor<uint16_t>	{ using type = UShort; static UShort cast(uint16_t); };
-template<> struct CToReactor<int32_t> 	{ using type = Int;    static Int    cast(int32_t);  };
-template<> struct CToReactor<uint32_t>	{ using type = UInt;   static UInt   cast(uint32_t); };
-template<> struct CToReactor<float>   	{ using type = Float;  static Float  cast(float);    };
-template<> struct CToReactor<float[4]>	{ using type = Float4; static Float4 cast(float[4]); };
+template<>
+struct CToReactor<void>
+{
+	using type = Void;
+};
+template<>
+struct CToReactor<bool>
+{
+	using type = Bool;
+	static Bool cast(bool);
+};
+template<>
+struct CToReactor<uint8_t>
+{
+	using type = Byte;
+	static Byte cast(uint8_t);
+};
+template<>
+struct CToReactor<int8_t>
+{
+	using type = SByte;
+	static SByte cast(int8_t);
+};
+template<>
+struct CToReactor<int16_t>
+{
+	using type = Short;
+	static Short cast(int16_t);
+};
+template<>
+struct CToReactor<uint16_t>
+{
+	using type = UShort;
+	static UShort cast(uint16_t);
+};
+template<>
+struct CToReactor<int32_t>
+{
+	using type = Int;
+	static Int cast(int32_t);
+};
+template<>
+struct CToReactor<uint32_t>
+{
+	using type = UInt;
+	static UInt cast(uint32_t);
+};
+template<>
+struct CToReactor<float>
+{
+	using type = Float;
+	static Float cast(float);
+};
+template<>
+struct CToReactor<float[4]>
+{
+	using type = Float4;
+	static Float4 cast(float[4]);
+};
 
 // TODO: Long has no constructor that takes a uint64_t
-template<> struct CToReactor<uint64_t>	{ using type = Long;  /* static Long   cast(uint64_t); */ };
+template<>
+struct CToReactor<uint64_t>
+{
+	using type = Long; /* static Long   cast(uint64_t); */
+};
 
 // HasReactorType<T>::value resolves to true iff there exists a
 // CToReactorT specialization for type T.
 template<typename T>
-using HasReactorType = IsDefined< CToReactorT<T> >;
+using HasReactorType = IsDefined<CToReactorT<T>>;
 
 // CToReactorPtr<T>::type resolves to the corresponding Reactor Pointer<>
 // type for T*.
 // For T types that have a CToReactorT<> specialization,
 // CToReactorPtr<T>::type resolves to Pointer< CToReactorT<T> >, otherwise
 // CToReactorPtr<T>::type resolves to Pointer<Byte>.
-template<typename T, typename ENABLE = void> struct CToReactorPtr
+template<typename T, typename ENABLE = void>
+struct CToReactorPtr
 {
 	using type = Pointer<Byte>;
-	static inline type cast(const T* v); // implemented in Traits.inl
+	static inline type cast(const T *v);  // implemented in Traits.inl
 };
 
 // CToReactorPtr specialization for T types that have a CToReactorT<>
 // specialization.
-template<typename T> struct CToReactorPtr<T, enable_if_t< HasReactorType<T>::value > >
+template<typename T>
+struct CToReactorPtr<T, enable_if_t<HasReactorType<T>::value>>
 {
-	using type = Pointer< CToReactorT<T> >;
-	static inline type cast(const T* v); // implemented in Traits.inl
+	using type = Pointer<CToReactorT<T>>;
+	static inline type cast(const T *v);  // implemented in Traits.inl
 };
 
 // CToReactorPtr specialization for void*.
 // Maps to Pointer<Byte> instead of Pointer<Void>.
-template<> struct CToReactorPtr<void, void>
+template<>
+struct CToReactorPtr<void, void>
 {
 	using type = Pointer<Byte>;
-	static inline type cast(const void* v); // implemented in Traits.inl
+	static inline type cast(const void *v);  // implemented in Traits.inl
 };
 
 // CToReactorPtr specialization for function pointer types.
 // Maps to Pointer<Byte>.
 // Drops the 'const' qualifier from the cast() method to avoid warnings
 // about const having no meaning for function types.
-template<typename T> struct CToReactorPtr<T, enable_if_t< std::is_function<T>::value > >
+template<typename T>
+struct CToReactorPtr<T, enable_if_t<std::is_function<T>::value>>
 {
 	using type = Pointer<Byte>;
-	static inline type cast(T* v); // implemented in Traits.inl
+	static inline type cast(T *v);  // implemented in Traits.inl
 };
 
-template<typename T> using CToReactorPtrT = typename CToReactorPtr<T>::type;
+template<typename T>
+using CToReactorPtrT = typename CToReactorPtr<T>::type;
 
 // CToReactor specialization for pointer types.
 // For T types that have a CToReactorT<> specialization,
 // CToReactorT<T*>::type resolves to Pointer< CToReactorT<T> >, otherwise
 // CToReactorT<T*>::type resolves to Pointer<Byte>.
 template<typename T>
-struct CToReactor<T, enable_if_t<std::is_pointer<T>::value> >
+struct CToReactor<T, enable_if_t<std::is_pointer<T>::value>>
 {
 	using elem = typename std::remove_pointer<T>::type;
 	using type = CToReactorPtrT<elem>;
-	static inline type cast(T v); // implemented in Traits.inl
+	static inline type cast(T v);  // implemented in Traits.inl
 };
 
 // CToReactor specialization for enum types.
 template<typename T>
-struct CToReactor<T, enable_if_t<std::is_enum<T>::value> >
+struct CToReactor<T, enable_if_t<std::is_enum<T>::value>>
 {
 	using underlying = typename std::underlying_type<T>::type;
 	using type = CToReactorT<underlying>;
-	static type cast(T v); // implemented in Traits.inl
+	static type cast(T v);  // implemented in Traits.inl
 };
 
 // IsRValue::value is true if T is of type RValue<X>, where X is any type.
-template <typename T, typename Enable = void> struct IsRValue { static constexpr bool value = false; };
-template <typename T> struct IsRValue<T, enable_if_t<IsDefined<typename T::rvalue_underlying_type>::value> > { static constexpr bool value = true; };
+template<typename T, typename Enable = void>
+struct IsRValue
+{
+	static constexpr bool value = false;
+};
+template<typename T>
+struct IsRValue<T, enable_if_t<IsDefined<typename T::rvalue_underlying_type>::value>>
+{
+	static constexpr bool value = true;
+};
 
 // IsLValue::value is true if T is of, or derives from type LValue<T>.
-template <typename T> struct IsLValue { static constexpr bool value = std::is_base_of<LValue<T>, T>::value; };
+template<typename T>
+struct IsLValue
+{
+	static constexpr bool value = std::is_base_of<LValue<T>, T>::value;
+};
 
 // IsReference::value is true if T is of type Reference<X>, where X is any type.
-template <typename T, typename Enable = void> struct IsReference { static constexpr bool value = false; };
-template <typename T> struct IsReference<T, enable_if_t<IsDefined<typename T::reference_underlying_type>::value> > { static constexpr bool value = true; };
+template<typename T, typename Enable = void>
+struct IsReference
+{
+	static constexpr bool value = false;
+};
+template<typename T>
+struct IsReference<T, enable_if_t<IsDefined<typename T::reference_underlying_type>::value>>
+{
+	static constexpr bool value = true;
+};
 
 // ReactorTypeT<T> returns the LValue Reactor type for T.
 // T can be a C-type, RValue or LValue.
-template<typename T, typename ENABLE = void> struct ReactorType;
-template<typename T> using ReactorTypeT = typename ReactorType<T>::type;
-template<typename T> struct ReactorType<T, enable_if_t<IsDefined<CToReactorT<T>>::value> >
+template<typename T, typename ENABLE = void>
+struct ReactorType;
+template<typename T>
+using ReactorTypeT = typename ReactorType<T>::type;
+template<typename T>
+struct ReactorType<T, enable_if_t<IsDefined<CToReactorT<T>>::value>>
 {
 	using type = CToReactorT<T>;
 	static type cast(T v) { return CToReactor<T>::cast(v); }
 };
-template<typename T> struct ReactorType<T, enable_if_t<IsRValue<T>::value> >
+template<typename T>
+struct ReactorType<T, enable_if_t<IsRValue<T>::value>>
 {
 	using type = typename T::rvalue_underlying_type;
 	static type cast(T v) { return type(v); }
 };
-template<typename T> struct ReactorType<T, enable_if_t<IsLValue<T>::value> >
+template<typename T>
+struct ReactorType<T, enable_if_t<IsLValue<T>::value>>
 {
 	using type = T;
 	static type cast(T v) { return type(v); }
 };
-template<typename T> struct ReactorType<T, enable_if_t<IsReference<T>::value> >
+template<typename T>
+struct ReactorType<T, enable_if_t<IsReference<T>::value>>
 {
 	using type = T;
 	static type cast(T v) { return type(v); }
 };
 
-
 // Reactor types that can be used as a return type for a function.
-template <typename T> struct CanBeUsedAsReturn { static constexpr bool value = false; };
-template <> struct CanBeUsedAsReturn<Void>     { static constexpr bool value = true; };
-template <> struct CanBeUsedAsReturn<Int>      { static constexpr bool value = true; };
-template <> struct CanBeUsedAsReturn<UInt>     { static constexpr bool value = true; };
-template <> struct CanBeUsedAsReturn<Float>    { static constexpr bool value = true; };
-template <typename T> struct CanBeUsedAsReturn<Pointer<T>> { static constexpr bool value = true; };
+template<typename T>
+struct CanBeUsedAsReturn
+{
+	static constexpr bool value = false;
+};
+template<>
+struct CanBeUsedAsReturn<Void>
+{
+	static constexpr bool value = true;
+};
+template<>
+struct CanBeUsedAsReturn<Int>
+{
+	static constexpr bool value = true;
+};
+template<>
+struct CanBeUsedAsReturn<UInt>
+{
+	static constexpr bool value = true;
+};
+template<>
+struct CanBeUsedAsReturn<Float>
+{
+	static constexpr bool value = true;
+};
+template<typename T>
+struct CanBeUsedAsReturn<Pointer<T>>
+{
+	static constexpr bool value = true;
+};
 
 // Reactor types that can be used as a parameter types for a function.
-template <typename T> struct CanBeUsedAsParameter { static constexpr bool value = false; };
-template <> struct CanBeUsedAsParameter<Int>      { static constexpr bool value = true; };
-template <> struct CanBeUsedAsParameter<UInt>     { static constexpr bool value = true; };
-template <> struct CanBeUsedAsParameter<Float>    { static constexpr bool value = true; };
-template <typename T> struct CanBeUsedAsParameter<Pointer<T>> { static constexpr bool value = true; };
+template<typename T>
+struct CanBeUsedAsParameter
+{
+	static constexpr bool value = false;
+};
+template<>
+struct CanBeUsedAsParameter<Int>
+{
+	static constexpr bool value = true;
+};
+template<>
+struct CanBeUsedAsParameter<UInt>
+{
+	static constexpr bool value = true;
+};
+template<>
+struct CanBeUsedAsParameter<Float>
+{
+	static constexpr bool value = true;
+};
+template<typename T>
+struct CanBeUsedAsParameter<Pointer<T>>
+{
+	static constexpr bool value = true;
+};
 
 // AssertParameterTypeIsValid statically asserts that all template parameter
 // types can be used as a Reactor function parameter.
-template<typename T, typename ... other>
+template<typename T, typename... other>
 struct AssertParameterTypeIsValid : AssertParameterTypeIsValid<other...>
 {
 	static_assert(CanBeUsedAsParameter<T>::value, "Invalid parameter type");
@@ -224,7 +356,8 @@
 template<typename Return, typename... Arguments>
 class AssertFunctionSignatureIsValid;
 template<typename Return>
-class AssertFunctionSignatureIsValid<Return(Void)> {};
+class AssertFunctionSignatureIsValid<Return(Void)>
+{};
 template<typename Return, typename... Arguments>
 class AssertFunctionSignatureIsValid<Return(Arguments...)>
 {
@@ -234,4 +367,4 @@
 
 }  // namespace rr
 
-#endif // rr_Traits_hpp
+#endif  // rr_Traits_hpp
diff --git a/src/Reactor/Traits.inl b/src/Reactor/Traits.inl
index 23a5941..d13ddc2 100644
--- a/src/Reactor/Traits.inl
+++ b/src/Reactor/Traits.inl
@@ -20,7 +20,7 @@
 // Non-specialized implementation of CToReactorPtr::cast() defaults to
 // returning a ConstantPointer for v.
 template<typename T, typename ENABLE>
-Pointer<Byte> CToReactorPtr<T, ENABLE>::cast(const T* v)
+Pointer<Byte> CToReactorPtr<T, ENABLE>::cast(const T *v)
 {
 	return ConstantPointer(v);
 }
@@ -29,13 +29,13 @@
 // specialization.
 template<typename T>
 Pointer<CToReactorT<T>>
-CToReactorPtr<T, enable_if_t< HasReactorType<T>::value > >::cast(const T* v)
+CToReactorPtr<T, enable_if_t<HasReactorType<T>::value>>::cast(const T *v)
 {
 	return type(v);
 }
 
 // CToReactorPtr specialization for void*.
-Pointer<Byte> CToReactorPtr<void, void>::cast(const void* v)
+Pointer<Byte> CToReactorPtr<void, void>::cast(const void *v)
 {
 	return ConstantPointer(v);
 }
@@ -43,7 +43,7 @@
 // CToReactorPtrT specialization for function pointer types.
 template<typename T>
 Pointer<Byte>
-CToReactorPtr<T, enable_if_t< std::is_function<T>::value > >::cast(T* v)
+CToReactorPtr<T, enable_if_t<std::is_function<T>::value>>::cast(T *v)
 {
 	return ConstantPointer(v);
 }
@@ -51,7 +51,7 @@
 // CToReactor specialization for pointer types.
 template<typename T>
 CToReactorPtrT<typename std::remove_pointer<T>::type>
-CToReactor<T, enable_if_t<std::is_pointer<T>::value> >::cast(T v)
+CToReactor<T, enable_if_t<std::is_pointer<T>::value>>::cast(T v)
 {
 	return CToReactorPtr<elem>::cast(v);
 }
@@ -59,11 +59,11 @@
 // CToReactor specialization for enum types.
 template<typename T>
 CToReactorT<typename std::underlying_type<T>::type>
-CToReactor<T, enable_if_t<std::is_enum<T>::value> >::cast(T v)
+CToReactor<T, enable_if_t<std::is_enum<T>::value>>::cast(T v)
 {
 	return CToReactor<underlying>::cast(v);
 }
 
 }  // namespace rr
 
-#endif // rr_Traits_inl
+#endif  // rr_Traits_inl
diff --git a/src/Reactor/x86.hpp b/src/Reactor/x86.hpp
index dd98173..474ec40 100644
--- a/src/Reactor/x86.hpp
+++ b/src/Reactor/x86.hpp
@@ -106,4 +106,4 @@
 }  // namespace x86
 }  // namespace rr
 
-#endif   // rr_x86_hpp
\ No newline at end of file
+#endif  // rr_x86_hpp
\ No newline at end of file