// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#ifndef rr_Reactor_hpp
#define rr_Reactor_hpp

#include "Nucleus.hpp"
#include "Routine.hpp"
#include "Traits.hpp"

#include <cassert>
#include <cstddef>
#include <cstdio>
#include <limits>
#include <tuple>
#include <unordered_set>

#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();
}  // 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

#ifdef ENABLE_RR_PRINT
namespace rr {
int DebugPrintf(const char *format, ...);
}
#endif

namespace rr {

std::string BackendName();

struct Capabilities
{
	bool CoroutinesSupported;  // Support for rr::Coroutine<F>
};
extern const Capabilities Caps;

class Bool;
class Byte;
class SByte;
class Byte4;
class SByte4;
class Byte8;
class SByte8;
class Byte16;
class SByte16;
class Short;
class UShort;
class Short2;
class UShort2;
class Short4;
class UShort4;
class Short8;
class UShort8;
class Int;
class UInt;
class Int2;
class UInt2;
class Int4;
class UInt4;
class Long;
class Half;
class Float;
class Float2;
class Float4;

class Void
{
public:
	static Type *type();
};

template<class T>
class RValue;

template<class T>
class Pointer;

class Variable
{
	friend class Nucleus;

	Variable &operator=(const Variable &) = delete;

public:
	void materialize() const;

	Value *loadValue() const;
	Value *storeValue(Value *value) const;

	Value *getBaseAddress() const;
	Value *getElementPointer(Value *index, bool unsignedIndex) const;

	virtual Type *getType() const = 0;

protected:
	Variable();
	Variable(const Variable &) = default;

	virtual ~Variable();

private:
	static void materializeAll();
	static void killUnmaterialized();

	virtual Value *allocate() const;

	// This has to be a raw pointer because glibc 2.17 doesn't support __cxa_thread_atexit_impl
	// for destructing objects at exit. See crbug.com/1074222
	static thread_local std::unordered_set<const Variable *> *unmaterializedVariables;

	mutable Value *rvalue = nullptr;
	mutable Value *address = nullptr;
};

template<class T>
class LValue : public Variable
{
public:
	LValue();

	RValue<Pointer<T>> operator&();

	RValue<T> load() const
	{
		return RValue<T>(this->loadValue());
	}

	RValue<T> store(RValue<T> rvalue) const
	{
		this->storeValue(rvalue.value());

		return rvalue;
	}

	Type *getType() const override
	{
		return T::type();
	}

	// self() returns the this pointer to this LValue<T> object.
	// This function exists because operator&() is overloaded.
	inline LValue<T> *self() { return this; }
};

template<class T>
class Reference
{
public:
	using reference_underlying_type = T;

	explicit Reference(Value *pointer, int alignment = 1);

	RValue<T> operator=(RValue<T> rhs) const;
	RValue<T> operator=(const Reference<T> &ref) const;

	RValue<T> operator+=(RValue<T> rhs) const;

	RValue<Pointer<T>> operator&() const { return RValue<Pointer<T>>(address); }

	Value *loadValue() const;
	RValue<T> load() const;
	int getAlignment() const;

private:
	Value *address;

	const int alignment;
};

template<class T>
struct BoolLiteral
{
	struct type;
};

template<>
struct BoolLiteral<Bool>
{
	typedef bool type;
};

template<class T>
struct IntLiteral
{
	struct type;
};

template<>
struct IntLiteral<Int>
{
	typedef int type;
};

template<>
struct IntLiteral<UInt>
{
	typedef unsigned int type;
};

template<>
struct IntLiteral<Long>
{
	typedef int64_t type;
};

template<class T>
struct FloatLiteral
{
	struct type;
};

template<>
struct FloatLiteral<Float>
{
	typedef float type;
};

template<class T>
class RValue
{
public:
	using rvalue_underlying_type = T;

	explicit RValue(Value *rvalue);

	RValue(const RValue<T> &rvalue);
	RValue(const T &lvalue);
	RValue(typename BoolLiteral<T>::type i);
	RValue(typename IntLiteral<T>::type i);
	RValue(typename FloatLiteral<T>::type f);
	RValue(const Reference<T> &rhs);

	// Rvalues cannot be assigned to: "(a + b) = c;"
	RValue<T> &operator=(const RValue<T> &) = delete;

	Value *value() const { return val; }

private:
	Value *const val;
};

template<typename T>
class Argument
{
public:
	explicit Argument(Value *val)
	    : val(val)
	{}

	RValue<T> rvalue() const { return RValue<T>(val); }

private:
	Value *const val;
};

class Bool : public LValue<Bool>
{
public:
	Bool(Argument<Bool> argument);

	Bool() = default;
	Bool(bool x);
	Bool(RValue<Bool> rhs);
	Bool(const Bool &rhs);
	Bool(const Reference<Bool> &rhs);

	//	RValue<Bool> operator=(bool rhs);   // FIXME: Implement
	RValue<Bool> operator=(RValue<Bool> rhs);
	RValue<Bool> operator=(const Bool &rhs);
	RValue<Bool> operator=(const Reference<Bool> &rhs);

	static Type *type();
};

RValue<Bool> operator!(RValue<Bool> val);
RValue<Bool> operator&&(RValue<Bool> lhs, RValue<Bool> rhs);
RValue<Bool> operator||(RValue<Bool> lhs, RValue<Bool> rhs);
RValue<Bool> operator!=(RValue<Bool> lhs, RValue<Bool> rhs);
RValue<Bool> operator==(RValue<Bool> lhs, RValue<Bool> rhs);

class Byte : public LValue<Byte>
{
public:
	Byte(Argument<Byte> argument);

	explicit Byte(RValue<Int> cast);
	explicit Byte(RValue<UInt> cast);
	explicit Byte(RValue<UShort> cast);

	Byte() = default;
	Byte(int x);
	Byte(unsigned char x);
	Byte(RValue<Byte> rhs);
	Byte(const Byte &rhs);
	Byte(const Reference<Byte> &rhs);

	//	RValue<Byte> operator=(unsigned char rhs);   // FIXME: Implement
	RValue<Byte> operator=(RValue<Byte> rhs);
	RValue<Byte> operator=(const Byte &rhs);
	RValue<Byte> operator=(const Reference<Byte> &rhs);

	static Type *type();
};

RValue<Byte> operator+(RValue<Byte> lhs, RValue<Byte> rhs);
RValue<Byte> operator-(RValue<Byte> lhs, RValue<Byte> rhs);
RValue<Byte> operator*(RValue<Byte> lhs, RValue<Byte> rhs);
RValue<Byte> operator/(RValue<Byte> lhs, RValue<Byte> rhs);
RValue<Byte> operator%(RValue<Byte> lhs, RValue<Byte> rhs);
RValue<Byte> operator&(RValue<Byte> lhs, RValue<Byte> rhs);
RValue<Byte> operator|(RValue<Byte> lhs, RValue<Byte> rhs);
RValue<Byte> operator^(RValue<Byte> lhs, RValue<Byte> rhs);
RValue<Byte> operator<<(RValue<Byte> lhs, RValue<Byte> rhs);
RValue<Byte> operator>>(RValue<Byte> lhs, RValue<Byte> rhs);
RValue<Byte> operator+=(Byte &lhs, RValue<Byte> rhs);
RValue<Byte> operator-=(Byte &lhs, RValue<Byte> rhs);
RValue<Byte> operator*=(Byte &lhs, RValue<Byte> rhs);
RValue<Byte> operator/=(Byte &lhs, RValue<Byte> rhs);
RValue<Byte> operator%=(Byte &lhs, RValue<Byte> rhs);
RValue<Byte> operator&=(Byte &lhs, RValue<Byte> rhs);
RValue<Byte> operator|=(Byte &lhs, RValue<Byte> rhs);
RValue<Byte> operator^=(Byte &lhs, RValue<Byte> rhs);
RValue<Byte> operator<<=(Byte &lhs, RValue<Byte> rhs);
RValue<Byte> operator>>=(Byte &lhs, RValue<Byte> rhs);
RValue<Byte> operator+(RValue<Byte> val);
RValue<Byte> operator-(RValue<Byte> val);
RValue<Byte> operator~(RValue<Byte> val);
RValue<Byte> operator++(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);
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);

class SByte : public LValue<SByte>
{
public:
	SByte(Argument<SByte> argument);

	explicit SByte(RValue<Int> cast);
	explicit SByte(RValue<Short> cast);

	SByte() = default;
	SByte(signed char x);
	SByte(RValue<SByte> rhs);
	SByte(const SByte &rhs);
	SByte(const Reference<SByte> &rhs);

	//	RValue<SByte> operator=(signed char rhs);   // FIXME: Implement
	RValue<SByte> operator=(RValue<SByte> rhs);
	RValue<SByte> operator=(const SByte &rhs);
	RValue<SByte> operator=(const Reference<SByte> &rhs);

	static Type *type();
};

RValue<SByte> operator+(RValue<SByte> lhs, RValue<SByte> rhs);
RValue<SByte> operator-(RValue<SByte> lhs, RValue<SByte> rhs);
RValue<SByte> operator*(RValue<SByte> lhs, RValue<SByte> rhs);
RValue<SByte> operator/(RValue<SByte> lhs, RValue<SByte> rhs);
RValue<SByte> operator%(RValue<SByte> lhs, RValue<SByte> rhs);
RValue<SByte> operator&(RValue<SByte> lhs, RValue<SByte> rhs);
RValue<SByte> operator|(RValue<SByte> lhs, RValue<SByte> rhs);
RValue<SByte> operator^(RValue<SByte> lhs, RValue<SByte> rhs);
RValue<SByte> operator<<(RValue<SByte> lhs, RValue<SByte> rhs);
RValue<SByte> operator>>(RValue<SByte> lhs, RValue<SByte> rhs);
RValue<SByte> operator+=(SByte &lhs, RValue<SByte> rhs);
RValue<SByte> operator-=(SByte &lhs, RValue<SByte> rhs);
RValue<SByte> operator*=(SByte &lhs, RValue<SByte> rhs);
RValue<SByte> operator/=(SByte &lhs, RValue<SByte> rhs);
RValue<SByte> operator%=(SByte &lhs, RValue<SByte> rhs);
RValue<SByte> operator&=(SByte &lhs, RValue<SByte> rhs);
RValue<SByte> operator|=(SByte &lhs, RValue<SByte> rhs);
RValue<SByte> operator^=(SByte &lhs, RValue<SByte> rhs);
RValue<SByte> operator<<=(SByte &lhs, RValue<SByte> rhs);
RValue<SByte> operator>>=(SByte &lhs, RValue<SByte> rhs);
RValue<SByte> operator+(RValue<SByte> val);
RValue<SByte> operator-(RValue<SByte> val);
RValue<SByte> operator~(RValue<SByte> val);
RValue<SByte> operator++(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);
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);

class Short : public LValue<Short>
{
public:
	Short(Argument<Short> argument);

	explicit Short(RValue<Int> cast);

	Short() = default;
	Short(short x);
	Short(RValue<Short> rhs);
	Short(const Short &rhs);
	Short(const Reference<Short> &rhs);

	//	RValue<Short> operator=(short rhs);   // FIXME: Implement
	RValue<Short> operator=(RValue<Short> rhs);
	RValue<Short> operator=(const Short &rhs);
	RValue<Short> operator=(const Reference<Short> &rhs);

	static Type *type();
};

RValue<Short> operator+(RValue<Short> lhs, RValue<Short> rhs);
RValue<Short> operator-(RValue<Short> lhs, RValue<Short> rhs);
RValue<Short> operator*(RValue<Short> lhs, RValue<Short> rhs);
RValue<Short> operator/(RValue<Short> lhs, RValue<Short> rhs);
RValue<Short> operator%(RValue<Short> lhs, RValue<Short> rhs);
RValue<Short> operator&(RValue<Short> lhs, RValue<Short> rhs);
RValue<Short> operator|(RValue<Short> lhs, RValue<Short> rhs);
RValue<Short> operator^(RValue<Short> lhs, RValue<Short> rhs);
RValue<Short> operator<<(RValue<Short> lhs, RValue<Short> rhs);
RValue<Short> operator>>(RValue<Short> lhs, RValue<Short> rhs);
RValue<Short> operator+=(Short &lhs, RValue<Short> rhs);
RValue<Short> operator-=(Short &lhs, RValue<Short> rhs);
RValue<Short> operator*=(Short &lhs, RValue<Short> rhs);
RValue<Short> operator/=(Short &lhs, RValue<Short> rhs);
RValue<Short> operator%=(Short &lhs, RValue<Short> rhs);
RValue<Short> operator&=(Short &lhs, RValue<Short> rhs);
RValue<Short> operator|=(Short &lhs, RValue<Short> rhs);
RValue<Short> operator^=(Short &lhs, RValue<Short> rhs);
RValue<Short> operator<<=(Short &lhs, RValue<Short> rhs);
RValue<Short> operator>>=(Short &lhs, RValue<Short> rhs);
RValue<Short> operator+(RValue<Short> val);
RValue<Short> operator-(RValue<Short> val);
RValue<Short> operator~(RValue<Short> val);
RValue<Short> operator++(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);
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);

class UShort : public LValue<UShort>
{
public:
	UShort(Argument<UShort> argument);

	explicit UShort(RValue<UInt> cast);
	explicit UShort(RValue<Int> cast);

	UShort() = default;
	UShort(unsigned short x);
	UShort(RValue<UShort> rhs);
	UShort(const UShort &rhs);
	UShort(const Reference<UShort> &rhs);

	//	RValue<UShort> operator=(unsigned short rhs);   // FIXME: Implement
	RValue<UShort> operator=(RValue<UShort> rhs);
	RValue<UShort> operator=(const UShort &rhs);
	RValue<UShort> operator=(const Reference<UShort> &rhs);

	static Type *type();
};

RValue<UShort> operator+(RValue<UShort> lhs, RValue<UShort> rhs);
RValue<UShort> operator-(RValue<UShort> lhs, RValue<UShort> rhs);
RValue<UShort> operator*(RValue<UShort> lhs, RValue<UShort> rhs);
RValue<UShort> operator/(RValue<UShort> lhs, RValue<UShort> rhs);
RValue<UShort> operator%(RValue<UShort> lhs, RValue<UShort> rhs);
RValue<UShort> operator&(RValue<UShort> lhs, RValue<UShort> rhs);
RValue<UShort> operator|(RValue<UShort> lhs, RValue<UShort> rhs);
RValue<UShort> operator^(RValue<UShort> lhs, RValue<UShort> rhs);
RValue<UShort> operator<<(RValue<UShort> lhs, RValue<UShort> rhs);
RValue<UShort> operator>>(RValue<UShort> lhs, RValue<UShort> rhs);
RValue<UShort> operator+=(UShort &lhs, RValue<UShort> rhs);
RValue<UShort> operator-=(UShort &lhs, RValue<UShort> rhs);
RValue<UShort> operator*=(UShort &lhs, RValue<UShort> rhs);
RValue<UShort> operator/=(UShort &lhs, RValue<UShort> rhs);
RValue<UShort> operator%=(UShort &lhs, RValue<UShort> rhs);
RValue<UShort> operator&=(UShort &lhs, RValue<UShort> rhs);
RValue<UShort> operator|=(UShort &lhs, RValue<UShort> rhs);
RValue<UShort> operator^=(UShort &lhs, RValue<UShort> rhs);
RValue<UShort> operator<<=(UShort &lhs, RValue<UShort> rhs);
RValue<UShort> operator>>=(UShort &lhs, RValue<UShort> rhs);
RValue<UShort> operator+(RValue<UShort> val);
RValue<UShort> operator-(RValue<UShort> val);
RValue<UShort> operator~(RValue<UShort> val);
RValue<UShort> operator++(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);
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);

class Byte4 : public LValue<Byte4>
{
public:
	explicit Byte4(RValue<Byte8> cast);
	explicit Byte4(RValue<UShort4> cast);
	explicit Byte4(RValue<Short4> cast);
	explicit Byte4(RValue<UInt4> cast);
	explicit Byte4(RValue<Int4> cast);

	Byte4() = default;
	//	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);

	static Type *type();
};

//	RValue<Byte4> operator+(RValue<Byte4> lhs, RValue<Byte4> rhs);
//	RValue<Byte4> operator-(RValue<Byte4> lhs, RValue<Byte4> rhs);
//	RValue<Byte4> operator*(RValue<Byte4> lhs, RValue<Byte4> rhs);
//	RValue<Byte4> operator/(RValue<Byte4> lhs, RValue<Byte4> rhs);
//	RValue<Byte4> operator%(RValue<Byte4> lhs, RValue<Byte4> rhs);
//	RValue<Byte4> operator&(RValue<Byte4> lhs, RValue<Byte4> rhs);
//	RValue<Byte4> operator|(RValue<Byte4> lhs, RValue<Byte4> rhs);
//	RValue<Byte4> operator^(RValue<Byte4> lhs, RValue<Byte4> rhs);
//	RValue<Byte4> operator<<(RValue<Byte4> lhs, RValue<Byte4> rhs);
//	RValue<Byte4> operator>>(RValue<Byte4> lhs, RValue<Byte4> rhs);
//	RValue<Byte4> operator+=(Byte4 &lhs, RValue<Byte4> rhs);
//	RValue<Byte4> operator-=(Byte4 &lhs, RValue<Byte4> rhs);
//	RValue<Byte4> operator*=(Byte4 &lhs, RValue<Byte4> rhs);
//	RValue<Byte4> operator/=(Byte4 &lhs, RValue<Byte4> rhs);
//	RValue<Byte4> operator%=(Byte4 &lhs, RValue<Byte4> rhs);
//	RValue<Byte4> operator&=(Byte4 &lhs, RValue<Byte4> rhs);
//	RValue<Byte4> operator|=(Byte4 &lhs, RValue<Byte4> rhs);
//	RValue<Byte4> operator^=(Byte4 &lhs, RValue<Byte4> rhs);
//	RValue<Byte4> operator<<=(Byte4 &lhs, RValue<Byte4> rhs);
//	RValue<Byte4> operator>>=(Byte4 &lhs, RValue<Byte4> rhs);
//	RValue<Byte4> operator+(RValue<Byte4> val);
//	RValue<Byte4> operator-(RValue<Byte4> val);
//	RValue<Byte4> operator~(RValue<Byte4> val);
//	RValue<Byte4> operator++(Byte4 &val, int);   // Post-increment
//	const Byte4 &operator++(Byte4 &val);   // Pre-increment
//	RValue<Byte4> operator--(Byte4 &val, int);   // Post-decrement
//	const Byte4 &operator--(Byte4 &val);   // Pre-decrement

class SByte4 : public LValue<SByte4>
{
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);

	//	RValue<SByte4> operator=(RValue<SByte4> rhs);
	//	RValue<SByte4> operator=(const SByte4 &rhs);
	//	RValue<SByte4> operator=(const Reference<SByte4> &rhs);

	static Type *type();
};

//	RValue<SByte4> operator+(RValue<SByte4> lhs, RValue<SByte4> rhs);
//	RValue<SByte4> operator-(RValue<SByte4> lhs, RValue<SByte4> rhs);
//	RValue<SByte4> operator*(RValue<SByte4> lhs, RValue<SByte4> rhs);
//	RValue<SByte4> operator/(RValue<SByte4> lhs, RValue<SByte4> rhs);
//	RValue<SByte4> operator%(RValue<SByte4> lhs, RValue<SByte4> rhs);
//	RValue<SByte4> operator&(RValue<SByte4> lhs, RValue<SByte4> rhs);
//	RValue<SByte4> operator|(RValue<SByte4> lhs, RValue<SByte4> rhs);
//	RValue<SByte4> operator^(RValue<SByte4> lhs, RValue<SByte4> rhs);
//	RValue<SByte4> operator<<(RValue<SByte4> lhs, RValue<SByte4> rhs);
//	RValue<SByte4> operator>>(RValue<SByte4> lhs, RValue<SByte4> rhs);
//	RValue<SByte4> operator+=(SByte4 &lhs, RValue<SByte4> rhs);
//	RValue<SByte4> operator-=(SByte4 &lhs, RValue<SByte4> rhs);
//	RValue<SByte4> operator*=(SByte4 &lhs, RValue<SByte4> rhs);
//	RValue<SByte4> operator/=(SByte4 &lhs, RValue<SByte4> rhs);
//	RValue<SByte4> operator%=(SByte4 &lhs, RValue<SByte4> rhs);
//	RValue<SByte4> operator&=(SByte4 &lhs, RValue<SByte4> rhs);
//	RValue<SByte4> operator|=(SByte4 &lhs, RValue<SByte4> rhs);
//	RValue<SByte4> operator^=(SByte4 &lhs, RValue<SByte4> rhs);
//	RValue<SByte4> operator<<=(SByte4 &lhs, RValue<SByte4> rhs);
//	RValue<SByte4> operator>>=(SByte4 &lhs, RValue<SByte4> rhs);
//	RValue<SByte4> operator+(RValue<SByte4> val);
//	RValue<SByte4> operator-(RValue<SByte4> val);
//	RValue<SByte4> operator~(RValue<SByte4> val);
//	RValue<SByte4> operator++(SByte4 &val, int);   // Post-increment
//	const SByte4 &operator++(SByte4 &val);   // Pre-increment
//	RValue<SByte4> operator--(SByte4 &val, int);   // Post-decrement
//	const SByte4 &operator--(SByte4 &val);   // Pre-decrement

class Byte8 : public LValue<Byte8>
{
public:
	Byte8() = default;
	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);
	Byte8(RValue<Byte8> rhs);
	Byte8(const Byte8 &rhs);
	Byte8(const Reference<Byte8> &rhs);

	RValue<Byte8> operator=(RValue<Byte8> rhs);
	RValue<Byte8> operator=(const Byte8 &rhs);
	RValue<Byte8> operator=(const Reference<Byte8> &rhs);

	static Type *type();
};

RValue<Byte8> operator+(RValue<Byte8> lhs, RValue<Byte8> rhs);
RValue<Byte8> operator-(RValue<Byte8> lhs, RValue<Byte8> rhs);
//	RValue<Byte8> operator*(RValue<Byte8> lhs, RValue<Byte8> rhs);
//	RValue<Byte8> operator/(RValue<Byte8> lhs, RValue<Byte8> rhs);
//	RValue<Byte8> operator%(RValue<Byte8> lhs, RValue<Byte8> rhs);
RValue<Byte8> operator&(RValue<Byte8> lhs, RValue<Byte8> rhs);
RValue<Byte8> operator|(RValue<Byte8> lhs, RValue<Byte8> rhs);
RValue<Byte8> operator^(RValue<Byte8> lhs, RValue<Byte8> rhs);
//	RValue<Byte8> operator<<(RValue<Byte8> lhs, RValue<Byte8> rhs);
//	RValue<Byte8> operator>>(RValue<Byte8> lhs, RValue<Byte8> rhs);
RValue<Byte8> operator+=(Byte8 &lhs, RValue<Byte8> rhs);
RValue<Byte8> operator-=(Byte8 &lhs, RValue<Byte8> rhs);
//	RValue<Byte8> operator*=(Byte8 &lhs, RValue<Byte8> rhs);
//	RValue<Byte8> operator/=(Byte8 &lhs, RValue<Byte8> rhs);
//	RValue<Byte8> operator%=(Byte8 &lhs, RValue<Byte8> rhs);
RValue<Byte8> operator&=(Byte8 &lhs, RValue<Byte8> rhs);
RValue<Byte8> operator|=(Byte8 &lhs, RValue<Byte8> rhs);
RValue<Byte8> operator^=(Byte8 &lhs, RValue<Byte8> rhs);
//	RValue<Byte8> operator<<=(Byte8 &lhs, RValue<Byte8> rhs);
//	RValue<Byte8> operator>>=(Byte8 &lhs, RValue<Byte8> rhs);
//	RValue<Byte8> operator+(RValue<Byte8> val);
//	RValue<Byte8> operator-(RValue<Byte8> val);
RValue<Byte8> operator~(RValue<Byte8> val);
//	RValue<Byte8> operator++(Byte8 &val, int);   // Post-increment
//	const Byte8 &operator++(Byte8 &val);   // Pre-increment
//	RValue<Byte8> operator--(Byte8 &val, int);   // Post-decrement
//	const Byte8 &operator--(Byte8 &val);   // Pre-decrement

RValue<Byte8> AddSat(RValue<Byte8> x, RValue<Byte8> y);
RValue<Byte8> SubSat(RValue<Byte8> x, RValue<Byte8> y);
RValue<Short4> Unpack(RValue<Byte4> x);
RValue<Short4> Unpack(RValue<Byte4> x, RValue<Byte4> y);
RValue<Short4> UnpackLow(RValue<Byte8> x, RValue<Byte8> y);
RValue<Short4> UnpackHigh(RValue<Byte8> x, RValue<Byte8> y);
RValue<Int> SignMask(RValue<Byte8> x);
//	RValue<Byte8> CmpGT(RValue<Byte8> x, RValue<Byte8> y);
RValue<Byte8> CmpEQ(RValue<Byte8> x, RValue<Byte8> y);
RValue<Byte8> Swizzle(RValue<Byte8> x, uint32_t select);

class SByte8 : public LValue<SByte8>
{
public:
	SByte8() = default;
	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);
	SByte8(RValue<SByte8> rhs);
	SByte8(const SByte8 &rhs);
	SByte8(const Reference<SByte8> &rhs);

	RValue<SByte8> operator=(RValue<SByte8> rhs);
	RValue<SByte8> operator=(const SByte8 &rhs);
	RValue<SByte8> operator=(const Reference<SByte8> &rhs);

	static Type *type();
};

RValue<SByte8> operator+(RValue<SByte8> lhs, RValue<SByte8> rhs);
RValue<SByte8> operator-(RValue<SByte8> lhs, RValue<SByte8> rhs);
//	RValue<SByte8> operator*(RValue<SByte8> lhs, RValue<SByte8> rhs);
//	RValue<SByte8> operator/(RValue<SByte8> lhs, RValue<SByte8> rhs);
//	RValue<SByte8> operator%(RValue<SByte8> lhs, RValue<SByte8> rhs);
RValue<SByte8> operator&(RValue<SByte8> lhs, RValue<SByte8> rhs);
RValue<SByte8> operator|(RValue<SByte8> lhs, RValue<SByte8> rhs);
RValue<SByte8> operator^(RValue<SByte8> lhs, RValue<SByte8> rhs);
//	RValue<SByte8> operator<<(RValue<SByte8> lhs, RValue<SByte8> rhs);
//	RValue<SByte8> operator>>(RValue<SByte8> lhs, RValue<SByte8> rhs);
RValue<SByte8> operator+=(SByte8 &lhs, RValue<SByte8> rhs);
RValue<SByte8> operator-=(SByte8 &lhs, RValue<SByte8> rhs);
//	RValue<SByte8> operator*=(SByte8 &lhs, RValue<SByte8> rhs);
//	RValue<SByte8> operator/=(SByte8 &lhs, RValue<SByte8> rhs);
//	RValue<SByte8> operator%=(SByte8 &lhs, RValue<SByte8> rhs);
RValue<SByte8> operator&=(SByte8 &lhs, RValue<SByte8> rhs);
RValue<SByte8> operator|=(SByte8 &lhs, RValue<SByte8> rhs);
RValue<SByte8> operator^=(SByte8 &lhs, RValue<SByte8> rhs);
//	RValue<SByte8> operator<<=(SByte8 &lhs, RValue<SByte8> rhs);
//	RValue<SByte8> operator>>=(SByte8 &lhs, RValue<SByte8> rhs);
//	RValue<SByte8> operator+(RValue<SByte8> val);
//	RValue<SByte8> operator-(RValue<SByte8> val);
RValue<SByte8> operator~(RValue<SByte8> val);
//	RValue<SByte8> operator++(SByte8 &val, int);   // Post-increment
//	const SByte8 &operator++(SByte8 &val);   // Pre-increment
//	RValue<SByte8> operator--(SByte8 &val, int);   // Post-decrement
//	const SByte8 &operator--(SByte8 &val);   // Pre-decrement

RValue<SByte8> AddSat(RValue<SByte8> x, RValue<SByte8> y);
RValue<SByte8> SubSat(RValue<SByte8> x, RValue<SByte8> y);
RValue<Short4> UnpackLow(RValue<SByte8> x, RValue<SByte8> y);
RValue<Short4> UnpackHigh(RValue<SByte8> x, RValue<SByte8> y);
RValue<Int> SignMask(RValue<SByte8> x);
RValue<Byte8> CmpGT(RValue<SByte8> x, RValue<SByte8> y);
RValue<Byte8> CmpEQ(RValue<SByte8> x, RValue<SByte8> y);

class Byte16 : public LValue<Byte16>
{
public:
	Byte16() = default;
	Byte16(RValue<Byte16> rhs);
	Byte16(const Byte16 &rhs);
	Byte16(const Reference<Byte16> &rhs);

	RValue<Byte16> operator=(RValue<Byte16> rhs);
	RValue<Byte16> operator=(const Byte16 &rhs);
	RValue<Byte16> operator=(const Reference<Byte16> &rhs);

	static Type *type();
};

//	RValue<Byte16> operator+(RValue<Byte16> lhs, RValue<Byte16> rhs);
//	RValue<Byte16> operator-(RValue<Byte16> lhs, RValue<Byte16> rhs);
//	RValue<Byte16> operator*(RValue<Byte16> lhs, RValue<Byte16> rhs);
//	RValue<Byte16> operator/(RValue<Byte16> lhs, RValue<Byte16> rhs);
//	RValue<Byte16> operator%(RValue<Byte16> lhs, RValue<Byte16> rhs);
//	RValue<Byte16> operator&(RValue<Byte16> lhs, RValue<Byte16> rhs);
//	RValue<Byte16> operator|(RValue<Byte16> lhs, RValue<Byte16> rhs);
//	RValue<Byte16> operator^(RValue<Byte16> lhs, RValue<Byte16> rhs);
//	RValue<Byte16> operator<<(RValue<Byte16> lhs, RValue<Byte16> rhs);
//	RValue<Byte16> operator>>(RValue<Byte16> lhs, RValue<Byte16> rhs);
//	RValue<Byte16> operator+=(Byte16 &lhs, RValue<Byte16> rhs);
//	RValue<Byte16> operator-=(Byte16 &lhs, RValue<Byte16> rhs);
//	RValue<Byte16> operator*=(Byte16 &lhs, RValue<Byte16> rhs);
//	RValue<Byte16> operator/=(Byte16 &lhs, RValue<Byte16> rhs);
//	RValue<Byte16> operator%=(Byte16 &lhs, RValue<Byte16> rhs);
//	RValue<Byte16> operator&=(Byte16 &lhs, RValue<Byte16> rhs);
//	RValue<Byte16> operator|=(Byte16 &lhs, RValue<Byte16> rhs);
//	RValue<Byte16> operator^=(Byte16 &lhs, RValue<Byte16> rhs);
//	RValue<Byte16> operator<<=(Byte16 &lhs, RValue<Byte16> rhs);
//	RValue<Byte16> operator>>=(Byte16 &lhs, RValue<Byte16> rhs);
//	RValue<Byte16> operator+(RValue<Byte16> val);
//	RValue<Byte16> operator-(RValue<Byte16> val);
//	RValue<Byte16> operator~(RValue<Byte16> val);
//	RValue<Byte16> operator++(Byte16 &val, int);   // Post-increment
//	const Byte16 &operator++(Byte16 &val);   // Pre-increment
//	RValue<Byte16> operator--(Byte16 &val, int);   // Post-decrement
//	const Byte16 &operator--(Byte16 &val);   // Pre-decrement
RValue<Byte16> Swizzle(RValue<Byte16> x, uint64_t select);

class SByte16 : public LValue<SByte16>
{
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);

	//	RValue<SByte16> operator=(RValue<SByte16> rhs);
	//	RValue<SByte16> operator=(const SByte16 &rhs);
	//	RValue<SByte16> operator=(const Reference<SByte16> &rhs);

	static Type *type();
};

//	RValue<SByte16> operator+(RValue<SByte16> lhs, RValue<SByte16> rhs);
//	RValue<SByte16> operator-(RValue<SByte16> lhs, RValue<SByte16> rhs);
//	RValue<SByte16> operator*(RValue<SByte16> lhs, RValue<SByte16> rhs);
//	RValue<SByte16> operator/(RValue<SByte16> lhs, RValue<SByte16> rhs);
//	RValue<SByte16> operator%(RValue<SByte16> lhs, RValue<SByte16> rhs);
//	RValue<SByte16> operator&(RValue<SByte16> lhs, RValue<SByte16> rhs);
//	RValue<SByte16> operator|(RValue<SByte16> lhs, RValue<SByte16> rhs);
//	RValue<SByte16> operator^(RValue<SByte16> lhs, RValue<SByte16> rhs);
//	RValue<SByte16> operator<<(RValue<SByte16> lhs, RValue<SByte16> rhs);
//	RValue<SByte16> operator>>(RValue<SByte16> lhs, RValue<SByte16> rhs);
//	RValue<SByte16> operator+=(SByte16 &lhs, RValue<SByte16> rhs);
//	RValue<SByte16> operator-=(SByte16 &lhs, RValue<SByte16> rhs);
//	RValue<SByte16> operator*=(SByte16 &lhs, RValue<SByte16> rhs);
//	RValue<SByte16> operator/=(SByte16 &lhs, RValue<SByte16> rhs);
//	RValue<SByte16> operator%=(SByte16 &lhs, RValue<SByte16> rhs);
//	RValue<SByte16> operator&=(SByte16 &lhs, RValue<SByte16> rhs);
//	RValue<SByte16> operator|=(SByte16 &lhs, RValue<SByte16> rhs);
//	RValue<SByte16> operator^=(SByte16 &lhs, RValue<SByte16> rhs);
//	RValue<SByte16> operator<<=(SByte16 &lhs, RValue<SByte16> rhs);
//	RValue<SByte16> operator>>=(SByte16 &lhs, RValue<SByte16> rhs);
//	RValue<SByte16> operator+(RValue<SByte16> val);
//	RValue<SByte16> operator-(RValue<SByte16> val);
//	RValue<SByte16> operator~(RValue<SByte16> val);
//	RValue<SByte16> operator++(SByte16 &val, int);   // Post-increment
//	const SByte16 &operator++(SByte16 &val);   // Pre-increment
//	RValue<SByte16> operator--(SByte16 &val, int);   // Post-decrement
//	const SByte16 &operator--(SByte16 &val);   // Pre-decrement

class Short2 : public LValue<Short2>
{
public:
	explicit Short2(RValue<Short4> cast);

	static Type *type();
};

class UShort2 : public LValue<UShort2>
{
public:
	explicit UShort2(RValue<UShort4> cast);

	static Type *type();
};

class Short4 : public LValue<Short4>
{
public:
	explicit Short4(RValue<Int> cast);
	explicit Short4(RValue<Int4> cast);
	//	explicit Short4(RValue<Float> cast);
	explicit Short4(RValue<Float4> cast);

	Short4() = default;
	Short4(short xyzw);
	Short4(short x, short y, short z, short w);
	Short4(RValue<Short4> rhs);
	Short4(const Short4 &rhs);
	Short4(const Reference<Short4> &rhs);
	Short4(RValue<UShort4> rhs);
	Short4(const UShort4 &rhs);
	Short4(const Reference<UShort4> &rhs);

	RValue<Short4> operator=(RValue<Short4> rhs);
	RValue<Short4> operator=(const Short4 &rhs);
	RValue<Short4> operator=(const Reference<Short4> &rhs);
	RValue<Short4> operator=(RValue<UShort4> rhs);
	RValue<Short4> operator=(const UShort4 &rhs);
	RValue<Short4> operator=(const Reference<UShort4> &rhs);

	static Type *type();
};

RValue<Short4> operator+(RValue<Short4> lhs, RValue<Short4> rhs);
RValue<Short4> operator-(RValue<Short4> lhs, RValue<Short4> rhs);
RValue<Short4> operator*(RValue<Short4> lhs, RValue<Short4> rhs);
//	RValue<Short4> operator/(RValue<Short4> lhs, RValue<Short4> rhs);
//	RValue<Short4> operator%(RValue<Short4> lhs, RValue<Short4> rhs);
RValue<Short4> operator&(RValue<Short4> lhs, RValue<Short4> rhs);
RValue<Short4> operator|(RValue<Short4> lhs, RValue<Short4> rhs);
RValue<Short4> operator^(RValue<Short4> lhs, RValue<Short4> rhs);
RValue<Short4> operator<<(RValue<Short4> lhs, unsigned char rhs);
RValue<Short4> operator>>(RValue<Short4> lhs, unsigned char rhs);
RValue<Short4> operator+=(Short4 &lhs, RValue<Short4> rhs);
RValue<Short4> operator-=(Short4 &lhs, RValue<Short4> rhs);
RValue<Short4> operator*=(Short4 &lhs, RValue<Short4> rhs);
//	RValue<Short4> operator/=(Short4 &lhs, RValue<Short4> rhs);
//	RValue<Short4> operator%=(Short4 &lhs, RValue<Short4> rhs);
RValue<Short4> operator&=(Short4 &lhs, RValue<Short4> rhs);
RValue<Short4> operator|=(Short4 &lhs, RValue<Short4> rhs);
RValue<Short4> operator^=(Short4 &lhs, RValue<Short4> rhs);
RValue<Short4> operator<<=(Short4 &lhs, unsigned char rhs);
RValue<Short4> operator>>=(Short4 &lhs, unsigned char rhs);
//	RValue<Short4> operator+(RValue<Short4> val);
RValue<Short4> operator-(RValue<Short4> val);
RValue<Short4> operator~(RValue<Short4> val);
//	RValue<Short4> operator++(Short4 &val, int);   // Post-increment
//	const Short4 &operator++(Short4 &val);   // Pre-increment
//	RValue<Short4> operator--(Short4 &val, int);   // Post-decrement
//	const Short4 &operator--(Short4 &val);   // Pre-decrement
//	RValue<Bool> operator<(RValue<Short4> lhs, RValue<Short4> rhs);
//	RValue<Bool> operator<=(RValue<Short4> lhs, RValue<Short4> rhs);
//	RValue<Bool> operator>(RValue<Short4> lhs, RValue<Short4> rhs);
//	RValue<Bool> operator>=(RValue<Short4> lhs, RValue<Short4> rhs);
//	RValue<Bool> operator!=(RValue<Short4> lhs, RValue<Short4> rhs);
//	RValue<Bool> operator==(RValue<Short4> lhs, RValue<Short4> rhs);

RValue<Short4> RoundShort4(RValue<Float4> cast);
RValue<Short4> Max(RValue<Short4> x, RValue<Short4> y);
RValue<Short4> Min(RValue<Short4> x, RValue<Short4> y);
RValue<Short4> AddSat(RValue<Short4> x, RValue<Short4> y);
RValue<Short4> SubSat(RValue<Short4> x, RValue<Short4> y);
RValue<Short4> MulHigh(RValue<Short4> x, RValue<Short4> y);
RValue<Int2> MulAdd(RValue<Short4> x, RValue<Short4> y);
RValue<SByte8> PackSigned(RValue<Short4> x, RValue<Short4> y);
RValue<Byte8> PackUnsigned(RValue<Short4> x, RValue<Short4> y);
RValue<Int2> UnpackLow(RValue<Short4> x, RValue<Short4> y);
RValue<Int2> UnpackHigh(RValue<Short4> x, RValue<Short4> y);
RValue<Short4> Swizzle(RValue<Short4> x, uint16_t select);
RValue<Short4> Insert(RValue<Short4> val, RValue<Short> element, int i);
RValue<Short> Extract(RValue<Short4> val, int i);
RValue<Short4> CmpGT(RValue<Short4> x, RValue<Short4> y);
RValue<Short4> CmpEQ(RValue<Short4> x, RValue<Short4> y);

class UShort4 : public LValue<UShort4>
{
public:
	explicit UShort4(RValue<Int4> cast);
	explicit UShort4(RValue<Float4> cast, bool saturate = false);

	UShort4() = default;
	UShort4(unsigned short xyzw);
	UShort4(unsigned short x, unsigned short y, unsigned short z, unsigned short w);
	UShort4(RValue<UShort4> rhs);
	UShort4(const UShort4 &rhs);
	UShort4(const Reference<UShort4> &rhs);
	UShort4(RValue<Short4> rhs);
	UShort4(const Short4 &rhs);
	UShort4(const Reference<Short4> &rhs);

	RValue<UShort4> operator=(RValue<UShort4> rhs);
	RValue<UShort4> operator=(const UShort4 &rhs);
	RValue<UShort4> operator=(const Reference<UShort4> &rhs);
	RValue<UShort4> operator=(RValue<Short4> rhs);
	RValue<UShort4> operator=(const Short4 &rhs);
	RValue<UShort4> operator=(const Reference<Short4> &rhs);

	static Type *type();
};

RValue<UShort4> operator+(RValue<UShort4> lhs, RValue<UShort4> rhs);
RValue<UShort4> operator-(RValue<UShort4> lhs, RValue<UShort4> rhs);
RValue<UShort4> operator*(RValue<UShort4> lhs, RValue<UShort4> rhs);
//	RValue<UShort4> operator/(RValue<UShort4> lhs, RValue<UShort4> rhs);
//	RValue<UShort4> operator%(RValue<UShort4> lhs, RValue<UShort4> rhs);
RValue<UShort4> operator&(RValue<UShort4> lhs, RValue<UShort4> rhs);
RValue<UShort4> operator|(RValue<UShort4> lhs, RValue<UShort4> rhs);
RValue<UShort4> operator^(RValue<UShort4> lhs, RValue<UShort4> rhs);
RValue<UShort4> operator<<(RValue<UShort4> lhs, unsigned char rhs);
RValue<UShort4> operator>>(RValue<UShort4> lhs, unsigned char rhs);
//	RValue<UShort4> operator+=(UShort4 &lhs, RValue<UShort4> rhs);
//	RValue<UShort4> operator-=(UShort4 &lhs, RValue<UShort4> rhs);
//	RValue<UShort4> operator*=(UShort4 &lhs, RValue<UShort4> rhs);
//	RValue<UShort4> operator/=(UShort4 &lhs, RValue<UShort4> rhs);
//	RValue<UShort4> operator%=(UShort4 &lhs, RValue<UShort4> rhs);
//	RValue<UShort4> operator&=(UShort4 &lhs, RValue<UShort4> rhs);
//	RValue<UShort4> operator|=(UShort4 &lhs, RValue<UShort4> rhs);
//	RValue<UShort4> operator^=(UShort4 &lhs, RValue<UShort4> rhs);
RValue<UShort4> operator<<=(UShort4 &lhs, unsigned char rhs);
RValue<UShort4> operator>>=(UShort4 &lhs, unsigned char rhs);
//	RValue<UShort4> operator+(RValue<UShort4> val);
//	RValue<UShort4> operator-(RValue<UShort4> val);
RValue<UShort4> operator~(RValue<UShort4> val);
//	RValue<UShort4> operator++(UShort4 &val, int);   // Post-increment
//	const UShort4 &operator++(UShort4 &val);   // Pre-increment
//	RValue<UShort4> operator--(UShort4 &val, int);   // Post-decrement
//	const UShort4 &operator--(UShort4 &val);   // Pre-decrement

RValue<UShort4> Max(RValue<UShort4> x, RValue<UShort4> y);
RValue<UShort4> Min(RValue<UShort4> x, RValue<UShort4> y);
RValue<UShort4> AddSat(RValue<UShort4> x, RValue<UShort4> y);
RValue<UShort4> SubSat(RValue<UShort4> x, RValue<UShort4> y);
RValue<UShort4> MulHigh(RValue<UShort4> x, RValue<UShort4> y);
RValue<UShort4> Average(RValue<UShort4> x, RValue<UShort4> y);

class Short8 : public LValue<Short8>
{
public:
	Short8() = default;
	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 Reference<Short8> &rhs);
	Short8(RValue<Short4> lo, RValue<Short4> hi);

	RValue<Short8> operator=(RValue<Short8> rhs);
	RValue<Short8> operator=(const Short8 &rhs);
	RValue<Short8> operator=(const Reference<Short8> &rhs);

	static Type *type();
};

RValue<Short8> operator+(RValue<Short8> lhs, RValue<Short8> rhs);
//	RValue<Short8> operator-(RValue<Short8> lhs, RValue<Short8> rhs);
//	RValue<Short8> operator*(RValue<Short8> lhs, RValue<Short8> rhs);
//	RValue<Short8> operator/(RValue<Short8> lhs, RValue<Short8> rhs);
//	RValue<Short8> operator%(RValue<Short8> lhs, RValue<Short8> rhs);
RValue<Short8> operator&(RValue<Short8> lhs, RValue<Short8> rhs);
//	RValue<Short8> operator|(RValue<Short8> lhs, RValue<Short8> rhs);
//	RValue<Short8> operator^(RValue<Short8> lhs, RValue<Short8> rhs);
RValue<Short8> operator<<(RValue<Short8> lhs, unsigned char rhs);
RValue<Short8> operator>>(RValue<Short8> lhs, unsigned char rhs);
//	RValue<Short8> operator<<(RValue<Short8> lhs, RValue<Short8> rhs);
//	RValue<Short8> operator>>(RValue<Short8> lhs, RValue<Short8> rhs);
//	RValue<Short8> operator+=(Short8 &lhs, RValue<Short8> rhs);
//	RValue<Short8> operator-=(Short8 &lhs, RValue<Short8> rhs);
//	RValue<Short8> operator*=(Short8 &lhs, RValue<Short8> rhs);
//	RValue<Short8> operator/=(Short8 &lhs, RValue<Short8> rhs);
//	RValue<Short8> operator%=(Short8 &lhs, RValue<Short8> rhs);
//	RValue<Short8> operator&=(Short8 &lhs, RValue<Short8> rhs);
//	RValue<Short8> operator|=(Short8 &lhs, RValue<Short8> rhs);
//	RValue<Short8> operator^=(Short8 &lhs, RValue<Short8> rhs);
//	RValue<Short8> operator<<=(Short8 &lhs, RValue<Short8> rhs);
//	RValue<Short8> operator>>=(Short8 &lhs, RValue<Short8> rhs);
//	RValue<Short8> operator+(RValue<Short8> val);
//	RValue<Short8> operator-(RValue<Short8> val);
//	RValue<Short8> operator~(RValue<Short8> val);
//	RValue<Short8> operator++(Short8 &val, int);   // Post-increment
//	const Short8 &operator++(Short8 &val);   // Pre-increment
//	RValue<Short8> operator--(Short8 &val, int);   // Post-decrement
//	const Short8 &operator--(Short8 &val);   // Pre-decrement
//	RValue<Bool> operator<(RValue<Short8> lhs, RValue<Short8> rhs);
//	RValue<Bool> operator<=(RValue<Short8> lhs, RValue<Short8> rhs);
//	RValue<Bool> operator>(RValue<Short8> lhs, RValue<Short8> rhs);
//	RValue<Bool> operator>=(RValue<Short8> lhs, RValue<Short8> rhs);
//	RValue<Bool> operator!=(RValue<Short8> lhs, RValue<Short8> rhs);
//	RValue<Bool> operator==(RValue<Short8> lhs, RValue<Short8> rhs);

RValue<Short8> MulHigh(RValue<Short8> x, RValue<Short8> y);
RValue<Int4> MulAdd(RValue<Short8> x, RValue<Short8> y);
RValue<Int4> Abs(RValue<Int4> x);

class UShort8 : public LValue<UShort8>
{
public:
	UShort8() = default;
	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 Reference<UShort8> &rhs);
	UShort8(RValue<UShort4> lo, RValue<UShort4> hi);

	RValue<UShort8> operator=(RValue<UShort8> rhs);
	RValue<UShort8> operator=(const UShort8 &rhs);
	RValue<UShort8> operator=(const Reference<UShort8> &rhs);

	static Type *type();
};

RValue<UShort8> operator+(RValue<UShort8> lhs, RValue<UShort8> rhs);
//	RValue<UShort8> operator-(RValue<UShort8> lhs, RValue<UShort8> rhs);
RValue<UShort8> operator*(RValue<UShort8> lhs, RValue<UShort8> rhs);
//	RValue<UShort8> operator/(RValue<UShort8> lhs, RValue<UShort8> rhs);
//	RValue<UShort8> operator%(RValue<UShort8> lhs, RValue<UShort8> rhs);
RValue<UShort8> operator&(RValue<UShort8> lhs, RValue<UShort8> rhs);
//	RValue<UShort8> operator|(RValue<UShort8> lhs, RValue<UShort8> rhs);
//	RValue<UShort8> operator^(RValue<UShort8> lhs, RValue<UShort8> rhs);
RValue<UShort8> operator<<(RValue<UShort8> lhs, unsigned char rhs);
RValue<UShort8> operator>>(RValue<UShort8> lhs, unsigned char rhs);
//	RValue<UShort8> operator<<(RValue<UShort8> lhs, RValue<UShort8> rhs);
//	RValue<UShort8> operator>>(RValue<UShort8> lhs, RValue<UShort8> rhs);
RValue<UShort8> operator+=(UShort8 &lhs, RValue<UShort8> rhs);
//	RValue<UShort8> operator-=(UShort8 &lhs, RValue<UShort8> rhs);
//	RValue<UShort8> operator*=(UShort8 &lhs, RValue<UShort8> rhs);
//	RValue<UShort8> operator/=(UShort8 &lhs, RValue<UShort8> rhs);
//	RValue<UShort8> operator%=(UShort8 &lhs, RValue<UShort8> rhs);
//	RValue<UShort8> operator&=(UShort8 &lhs, RValue<UShort8> rhs);
//	RValue<UShort8> operator|=(UShort8 &lhs, RValue<UShort8> rhs);
//	RValue<UShort8> operator^=(UShort8 &lhs, RValue<UShort8> rhs);
//	RValue<UShort8> operator<<=(UShort8 &lhs, RValue<UShort8> rhs);
//	RValue<UShort8> operator>>=(UShort8 &lhs, RValue<UShort8> rhs);
//	RValue<UShort8> operator+(RValue<UShort8> val);
//	RValue<UShort8> operator-(RValue<UShort8> val);
RValue<UShort8> operator~(RValue<UShort8> val);
//	RValue<UShort8> operator++(UShort8 &val, int);   // Post-increment
//	const UShort8 &operator++(UShort8 &val);   // Pre-increment
//	RValue<UShort8> operator--(UShort8 &val, int);   // Post-decrement
//	const UShort8 &operator--(UShort8 &val);   // Pre-decrement
//	RValue<Bool> operator<(RValue<UShort8> lhs, RValue<UShort8> rhs);
//	RValue<Bool> operator<=(RValue<UShort8> lhs, RValue<UShort8> rhs);
//	RValue<Bool> operator>(RValue<UShort8> lhs, RValue<UShort8> rhs);
//	RValue<Bool> operator>=(RValue<UShort8> lhs, RValue<UShort8> rhs);
//	RValue<Bool> operator!=(RValue<UShort8> lhs, RValue<UShort8> rhs);
//	RValue<Bool> operator==(RValue<UShort8> lhs, RValue<UShort8> rhs);

RValue<UShort8> Swizzle(RValue<UShort8> x, uint32_t select);
RValue<UShort8> MulHigh(RValue<UShort8> x, RValue<UShort8> y);

class Int : public LValue<Int>
{
public:
	Int(Argument<Int> argument);

	explicit Int(RValue<Byte> cast);
	explicit Int(RValue<SByte> cast);
	explicit Int(RValue<Short> cast);
	explicit Int(RValue<UShort> cast);
	explicit Int(RValue<Int2> cast);
	explicit Int(RValue<Long> cast);
	explicit Int(RValue<Float> cast);

	Int() = default;
	Int(int x);
	Int(RValue<Int> rhs);
	Int(RValue<UInt> rhs);
	Int(const Int &rhs);
	Int(const UInt &rhs);
	Int(const Reference<Int> &rhs);
	Int(const Reference<UInt> &rhs);

	RValue<Int> operator=(int rhs);
	RValue<Int> operator=(RValue<Int> rhs);
	RValue<Int> operator=(RValue<UInt> rhs);
	RValue<Int> operator=(const Int &rhs);
	RValue<Int> operator=(const UInt &rhs);
	RValue<Int> operator=(const Reference<Int> &rhs);
	RValue<Int> operator=(const Reference<UInt> &rhs);

	static Type *type();
};

RValue<Int> operator+(RValue<Int> lhs, RValue<Int> rhs);
RValue<Int> operator-(RValue<Int> lhs, RValue<Int> rhs);
RValue<Int> operator*(RValue<Int> lhs, RValue<Int> rhs);
RValue<Int> operator/(RValue<Int> lhs, RValue<Int> rhs);
RValue<Int> operator%(RValue<Int> lhs, RValue<Int> rhs);
RValue<Int> operator&(RValue<Int> lhs, RValue<Int> rhs);
RValue<Int> operator|(RValue<Int> lhs, RValue<Int> rhs);
RValue<Int> operator^(RValue<Int> lhs, RValue<Int> rhs);
RValue<Int> operator<<(RValue<Int> lhs, RValue<Int> rhs);
RValue<Int> operator>>(RValue<Int> lhs, RValue<Int> rhs);
RValue<Int> operator+=(Int &lhs, RValue<Int> rhs);
RValue<Int> operator-=(Int &lhs, RValue<Int> rhs);
RValue<Int> operator*=(Int &lhs, RValue<Int> rhs);
RValue<Int> operator/=(Int &lhs, RValue<Int> rhs);
RValue<Int> operator%=(Int &lhs, RValue<Int> rhs);
RValue<Int> operator&=(Int &lhs, RValue<Int> rhs);
RValue<Int> operator|=(Int &lhs, RValue<Int> rhs);
RValue<Int> operator^=(Int &lhs, RValue<Int> rhs);
RValue<Int> operator<<=(Int &lhs, RValue<Int> rhs);
RValue<Int> operator>>=(Int &lhs, RValue<Int> rhs);
RValue<Int> operator+(RValue<Int> val);
RValue<Int> operator-(RValue<Int> val);
RValue<Int> operator~(RValue<Int> val);
RValue<Int> operator++(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);
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);

RValue<Int> Max(RValue<Int> x, RValue<Int> y);
RValue<Int> Min(RValue<Int> x, RValue<Int> y);
RValue<Int> Clamp(RValue<Int> x, RValue<Int> min, RValue<Int> max);
RValue<Int> RoundInt(RValue<Float> cast);

class Long : public LValue<Long>
{
public:
	//	Long(Argument<Long> argument);

	//	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);

	Long() = default;
	//	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);

	RValue<Long> operator=(int64_t rhs);
	RValue<Long> operator=(RValue<Long> rhs);
	//	RValue<Long> operator=(RValue<ULong> rhs);
	RValue<Long> operator=(const Long &rhs);
	RValue<Long> operator=(const Reference<Long> &rhs);
	//	RValue<Long> operator=(const ULong &rhs);
	//	RValue<Long> operator=(const Reference<ULong> &rhs);

	static Type *type();
};

RValue<Long> operator+(RValue<Long> lhs, RValue<Long> rhs);
RValue<Long> operator-(RValue<Long> lhs, RValue<Long> rhs);
RValue<Long> operator*(RValue<Long> lhs, RValue<Long> rhs);
//	RValue<Long> operator/(RValue<Long> lhs, RValue<Long> rhs);
//	RValue<Long> operator%(RValue<Long> lhs, RValue<Long> rhs);
//	RValue<Long> operator&(RValue<Long> lhs, RValue<Long> rhs);
//	RValue<Long> operator|(RValue<Long> lhs, RValue<Long> rhs);
//	RValue<Long> operator^(RValue<Long> lhs, RValue<Long> rhs);
//	RValue<Long> operator<<(RValue<Long> lhs, RValue<Long> rhs);
RValue<Long> operator>>(RValue<Long> lhs, RValue<Long> rhs);
RValue<Long> operator+=(Long &lhs, RValue<Long> rhs);
RValue<Long> operator-=(Long &lhs, RValue<Long> rhs);
//	RValue<Long> operator*=(Long &lhs, RValue<Long> rhs);
//	RValue<Long> operator/=(Long &lhs, RValue<Long> rhs);
//	RValue<Long> operator%=(Long &lhs, RValue<Long> rhs);
//	RValue<Long> operator&=(Long &lhs, RValue<Long> rhs);
//	RValue<Long> operator|=(Long &lhs, RValue<Long> rhs);
//	RValue<Long> operator^=(Long &lhs, RValue<Long> rhs);
//	RValue<Long> operator<<=(Long &lhs, RValue<Long> rhs);
//	RValue<Long> operator>>=(Long &lhs, RValue<Long> rhs);
//	RValue<Long> operator+(RValue<Long> val);
//	RValue<Long> operator-(RValue<Long> val);
//	RValue<Long> operator~(RValue<Long> val);
//	RValue<Long> operator++(Long &val, int);   // Post-increment
//	const Long &operator++(Long &val);   // Pre-increment
//	RValue<Long> operator--(Long &val, int);   // Post-decrement
//	const Long &operator--(Long &val);   // Pre-decrement
//	RValue<Bool> operator<(RValue<Long> lhs, RValue<Long> rhs);
//	RValue<Bool> operator<=(RValue<Long> lhs, RValue<Long> rhs);
//	RValue<Bool> operator>(RValue<Long> lhs, RValue<Long> rhs);
//	RValue<Bool> operator>=(RValue<Long> lhs, RValue<Long> rhs);
//	RValue<Bool> operator!=(RValue<Long> lhs, RValue<Long> rhs);
//	RValue<Bool> operator==(RValue<Long> lhs, RValue<Long> rhs);

//	RValue<Long> RoundLong(RValue<Float> cast);
RValue<Long> AddAtomic(RValue<Pointer<Long>> x, RValue<Long> y);

class UInt : public LValue<UInt>
{
public:
	UInt(Argument<UInt> argument);

	explicit UInt(RValue<UShort> cast);
	explicit UInt(RValue<Long> cast);
	explicit UInt(RValue<Float> cast);

	UInt() = default;
	UInt(int x);
	UInt(unsigned int x);
	UInt(RValue<UInt> rhs);
	UInt(RValue<Int> rhs);
	UInt(const UInt &rhs);
	UInt(const Int &rhs);
	UInt(const Reference<UInt> &rhs);
	UInt(const Reference<Int> &rhs);

	RValue<UInt> operator=(unsigned int rhs);
	RValue<UInt> operator=(RValue<UInt> rhs);
	RValue<UInt> operator=(RValue<Int> rhs);
	RValue<UInt> operator=(const UInt &rhs);
	RValue<UInt> operator=(const Int &rhs);
	RValue<UInt> operator=(const Reference<UInt> &rhs);
	RValue<UInt> operator=(const Reference<Int> &rhs);

	static Type *type();
};

RValue<UInt> operator+(RValue<UInt> lhs, RValue<UInt> rhs);
RValue<UInt> operator-(RValue<UInt> lhs, RValue<UInt> rhs);
RValue<UInt> operator*(RValue<UInt> lhs, RValue<UInt> rhs);
RValue<UInt> operator/(RValue<UInt> lhs, RValue<UInt> rhs);
RValue<UInt> operator%(RValue<UInt> lhs, RValue<UInt> rhs);
RValue<UInt> operator&(RValue<UInt> lhs, RValue<UInt> rhs);
RValue<UInt> operator|(RValue<UInt> lhs, RValue<UInt> rhs);
RValue<UInt> operator^(RValue<UInt> lhs, RValue<UInt> rhs);
RValue<UInt> operator<<(RValue<UInt> lhs, RValue<UInt> rhs);
RValue<UInt> operator>>(RValue<UInt> lhs, RValue<UInt> rhs);
RValue<UInt> operator+=(UInt &lhs, RValue<UInt> rhs);
RValue<UInt> operator-=(UInt &lhs, RValue<UInt> rhs);
RValue<UInt> operator*=(UInt &lhs, RValue<UInt> rhs);
RValue<UInt> operator/=(UInt &lhs, RValue<UInt> rhs);
RValue<UInt> operator%=(UInt &lhs, RValue<UInt> rhs);
RValue<UInt> operator&=(UInt &lhs, RValue<UInt> rhs);
RValue<UInt> operator|=(UInt &lhs, RValue<UInt> rhs);
RValue<UInt> operator^=(UInt &lhs, RValue<UInt> rhs);
RValue<UInt> operator<<=(UInt &lhs, RValue<UInt> rhs);
RValue<UInt> operator>>=(UInt &lhs, RValue<UInt> rhs);
RValue<UInt> operator+(RValue<UInt> val);
RValue<UInt> operator-(RValue<UInt> val);
RValue<UInt> operator~(RValue<UInt> val);
RValue<UInt> operator++(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);
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);

RValue<UInt> Max(RValue<UInt> x, RValue<UInt> y);
RValue<UInt> Min(RValue<UInt> x, RValue<UInt> y);
RValue<UInt> Clamp(RValue<UInt> x, RValue<UInt> min, RValue<UInt> max);

RValue<UInt> AddAtomic(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);
RValue<UInt> AndAtomic(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);
RValue<UInt> XorAtomic(RValue<Pointer<UInt>> x, RValue<UInt> y, std::memory_order memoryOrder);
RValue<Int> MinAtomic(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);
RValue<UInt> MinAtomic(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);
RValue<UInt> ExchangeAtomic(RValue<Pointer<UInt>> x, RValue<UInt> y, std::memory_order memoryOrder);
RValue<UInt> CompareExchangeAtomic(RValue<Pointer<UInt>> x, RValue<UInt> y, RValue<UInt> compare, std::memory_order memoryOrderEqual, std::memory_order memoryOrderUnequal);

//	RValue<UInt> RoundUInt(RValue<Float> cast);

class Int2 : public LValue<Int2>
{
public:
	//	explicit Int2(RValue<Int> cast);
	explicit Int2(RValue<Int4> cast);

	Int2() = default;
	Int2(int x, int y);
	Int2(RValue<Int2> rhs);
	Int2(const Int2 &rhs);
	Int2(const Reference<Int2> &rhs);
	Int2(RValue<Int> lo, RValue<Int> hi);

	RValue<Int2> operator=(RValue<Int2> rhs);
	RValue<Int2> operator=(const Int2 &rhs);
	RValue<Int2> operator=(const Reference<Int2> &rhs);

	static Type *type();
};

RValue<Int2> operator+(RValue<Int2> lhs, RValue<Int2> rhs);
RValue<Int2> operator-(RValue<Int2> lhs, RValue<Int2> rhs);
//	RValue<Int2> operator*(RValue<Int2> lhs, RValue<Int2> rhs);
//	RValue<Int2> operator/(RValue<Int2> lhs, RValue<Int2> rhs);
//	RValue<Int2> operator%(RValue<Int2> lhs, RValue<Int2> rhs);
RValue<Int2> operator&(RValue<Int2> lhs, RValue<Int2> rhs);
RValue<Int2> operator|(RValue<Int2> lhs, RValue<Int2> rhs);
RValue<Int2> operator^(RValue<Int2> lhs, RValue<Int2> rhs);
RValue<Int2> operator<<(RValue<Int2> lhs, unsigned char rhs);
RValue<Int2> operator>>(RValue<Int2> lhs, unsigned char rhs);
RValue<Int2> operator+=(Int2 &lhs, RValue<Int2> rhs);
RValue<Int2> operator-=(Int2 &lhs, RValue<Int2> rhs);
//	RValue<Int2> operator*=(Int2 &lhs, RValue<Int2> rhs);
//	RValue<Int2> operator/=(Int2 &lhs, RValue<Int2> rhs);
//	RValue<Int2> operator%=(Int2 &lhs, RValue<Int2> rhs);
RValue<Int2> operator&=(Int2 &lhs, RValue<Int2> rhs);
RValue<Int2> operator|=(Int2 &lhs, RValue<Int2> rhs);
RValue<Int2> operator^=(Int2 &lhs, RValue<Int2> rhs);
RValue<Int2> operator<<=(Int2 &lhs, unsigned char rhs);
RValue<Int2> operator>>=(Int2 &lhs, unsigned char rhs);
//	RValue<Int2> operator+(RValue<Int2> val);
//	RValue<Int2> operator-(RValue<Int2> val);
RValue<Int2> operator~(RValue<Int2> val);
//	RValue<Int2> operator++(Int2 &val, int);   // Post-increment
//	const Int2 &operator++(Int2 &val);   // Pre-increment
//	RValue<Int2> operator--(Int2 &val, int);   // Post-decrement
//	const Int2 &operator--(Int2 &val);   // Pre-decrement
//	RValue<Bool> operator<(RValue<Int2> lhs, RValue<Int2> rhs);
//	RValue<Bool> operator<=(RValue<Int2> lhs, RValue<Int2> rhs);
//	RValue<Bool> operator>(RValue<Int2> lhs, RValue<Int2> rhs);
//	RValue<Bool> operator>=(RValue<Int2> lhs, RValue<Int2> rhs);
//	RValue<Bool> operator!=(RValue<Int2> lhs, RValue<Int2> rhs);
//	RValue<Bool> operator==(RValue<Int2> lhs, RValue<Int2> rhs);

//	RValue<Int2> RoundInt(RValue<Float4> cast);
RValue<Short4> UnpackLow(RValue<Int2> x, RValue<Int2> y);
RValue<Short4> UnpackHigh(RValue<Int2> x, RValue<Int2> y);
RValue<Int> Extract(RValue<Int2> val, int i);
RValue<Int2> Insert(RValue<Int2> val, RValue<Int> element, int i);

class UInt2 : public LValue<UInt2>
{
public:
	UInt2() = default;
	UInt2(unsigned int x, unsigned int y);
	UInt2(RValue<UInt2> rhs);
	UInt2(const UInt2 &rhs);
	UInt2(const Reference<UInt2> &rhs);

	RValue<UInt2> operator=(RValue<UInt2> rhs);
	RValue<UInt2> operator=(const UInt2 &rhs);
	RValue<UInt2> operator=(const Reference<UInt2> &rhs);

	static Type *type();
};

RValue<UInt2> operator+(RValue<UInt2> lhs, RValue<UInt2> rhs);
RValue<UInt2> operator-(RValue<UInt2> lhs, RValue<UInt2> rhs);
//	RValue<UInt2> operator*(RValue<UInt2> lhs, RValue<UInt2> rhs);
//	RValue<UInt2> operator/(RValue<UInt2> lhs, RValue<UInt2> rhs);
//	RValue<UInt2> operator%(RValue<UInt2> lhs, RValue<UInt2> rhs);
RValue<UInt2> operator&(RValue<UInt2> lhs, RValue<UInt2> rhs);
RValue<UInt2> operator|(RValue<UInt2> lhs, RValue<UInt2> rhs);
RValue<UInt2> operator^(RValue<UInt2> lhs, RValue<UInt2> rhs);
RValue<UInt2> operator<<(RValue<UInt2> lhs, unsigned char rhs);
RValue<UInt2> operator>>(RValue<UInt2> lhs, unsigned char rhs);
RValue<UInt2> operator+=(UInt2 &lhs, RValue<UInt2> rhs);
RValue<UInt2> operator-=(UInt2 &lhs, RValue<UInt2> rhs);
//	RValue<UInt2> operator*=(UInt2 &lhs, RValue<UInt2> rhs);
//	RValue<UInt2> operator/=(UInt2 &lhs, RValue<UInt2> rhs);
//	RValue<UInt2> operator%=(UInt2 &lhs, RValue<UInt2> rhs);
RValue<UInt2> operator&=(UInt2 &lhs, RValue<UInt2> rhs);
RValue<UInt2> operator|=(UInt2 &lhs, RValue<UInt2> rhs);
RValue<UInt2> operator^=(UInt2 &lhs, RValue<UInt2> rhs);
RValue<UInt2> operator<<=(UInt2 &lhs, unsigned char rhs);
RValue<UInt2> operator>>=(UInt2 &lhs, unsigned char rhs);
//	RValue<UInt2> operator+(RValue<UInt2> val);
//	RValue<UInt2> operator-(RValue<UInt2> val);
RValue<UInt2> operator~(RValue<UInt2> val);
//	RValue<UInt2> operator++(UInt2 &val, int);   // Post-increment
//	const UInt2 &operator++(UInt2 &val);   // Pre-increment
//	RValue<UInt2> operator--(UInt2 &val, int);   // Post-decrement
//	const UInt2 &operator--(UInt2 &val);   // Pre-decrement
//	RValue<Bool> operator<(RValue<UInt2> lhs, RValue<UInt2> rhs);
//	RValue<Bool> operator<=(RValue<UInt2> lhs, RValue<UInt2> rhs);
//	RValue<Bool> operator>(RValue<UInt2> lhs, RValue<UInt2> rhs);
//	RValue<Bool> operator>=(RValue<UInt2> lhs, RValue<UInt2> rhs);
//	RValue<Bool> operator!=(RValue<UInt2> lhs, RValue<UInt2> rhs);
//	RValue<Bool> operator==(RValue<UInt2> lhs, RValue<UInt2> rhs);

//	RValue<UInt2> RoundInt(RValue<Float4> cast);
RValue<UInt> Extract(RValue<UInt2> val, int i);
RValue<UInt2> Insert(RValue<UInt2> val, RValue<UInt> element, int i);

template<class T>
struct Scalar;

template<class Vector4>
struct XYZW;

template<class Vector4, int T>
class Swizzle2
{
	friend Vector4;

public:
	operator RValue<Vector4>() const;

private:
	Vector4 *parent;
};

template<class Vector4, int T>
class Swizzle4
{
public:
	operator RValue<Vector4>() const;

private:
	Vector4 *parent;
};

template<class Vector4, int T>
class SwizzleMask4
{
	friend XYZW<Vector4>;

public:
	operator RValue<Vector4>() const;

	RValue<Vector4> operator=(RValue<Vector4> rhs);
	RValue<Vector4> operator=(RValue<typename Scalar<Vector4>::Type> rhs);

private:
	Vector4 *parent;
};

template<>
struct Scalar<Float4>
{
	using Type = Float;
};

template<>
struct Scalar<Int4>
{
	using Type = Int;
};

template<>
struct Scalar<UInt4>
{
	using Type = UInt;
};

template<class Vector4, int T>
class SwizzleMask1
{
public:
	operator RValue<typename Scalar<Vector4>::Type>() const;
	operator RValue<Vector4>() const;

	RValue<Vector4> operator=(float x);
	RValue<Vector4> operator=(RValue<Vector4> rhs);
	RValue<Vector4> operator=(RValue<typename Scalar<Vector4>::Type> rhs);

private:
	Vector4 *parent;
};

template<class Vector4, int T>
class SwizzleMask2
{
	friend class Float4;

public:
	operator RValue<Vector4>() const;

	RValue<Vector4> operator=(RValue<Vector4> rhs);

private:
	Float4 *parent;
};

template<class Vector4>
struct XYZW
{
	friend Vector4;

private:
	XYZW(Vector4 *parent)
	{
		xyzw.parent = parent;
	}

public:
	union
	{
		SwizzleMask1<Vector4, 0x0000> x;
		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;
		SwizzleMask2<Vector4, 0x0111> xy;
		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;
		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;
		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;
		SwizzleMask4<Vector4, 0x0133> xyw;
		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;
		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;
	};
};

class Int4 : public LValue<Int4>, public XYZW<Int4>
{
public:
	explicit Int4(RValue<Byte4> cast);
	explicit Int4(RValue<SByte4> cast);
	explicit Int4(RValue<Float4> cast);
	explicit Int4(RValue<Short4> cast);
	explicit Int4(RValue<UShort4> cast);

	Int4();
	Int4(int xyzw);
	Int4(int x, int yzw);
	Int4(int x, int y, int zw);
	Int4(int x, int y, int z, int w);
	Int4(RValue<Int4> rhs);
	Int4(const Int4 &rhs);
	Int4(const Reference<Int4> &rhs);
	Int4(RValue<UInt4> rhs);
	Int4(const UInt4 &rhs);
	Int4(const Reference<UInt4> &rhs);
	Int4(RValue<Int2> lo, RValue<Int2> hi);
	Int4(RValue<Int> rhs);
	Int4(const Int &rhs);
	Int4(const Reference<Int> &rhs);

	RValue<Int4> operator=(RValue<Int4> rhs);
	RValue<Int4> operator=(const Int4 &rhs);
	RValue<Int4> operator=(const Reference<Int4> &rhs);

	static Type *type();

private:
	void constant(int x, int y, int z, int w);
};

RValue<Int4> operator+(RValue<Int4> lhs, RValue<Int4> rhs);
RValue<Int4> operator-(RValue<Int4> lhs, RValue<Int4> rhs);
RValue<Int4> operator*(RValue<Int4> lhs, RValue<Int4> rhs);
RValue<Int4> operator/(RValue<Int4> lhs, RValue<Int4> rhs);
RValue<Int4> operator%(RValue<Int4> lhs, RValue<Int4> rhs);
RValue<Int4> operator&(RValue<Int4> lhs, RValue<Int4> rhs);
RValue<Int4> operator|(RValue<Int4> lhs, RValue<Int4> rhs);
RValue<Int4> operator^(RValue<Int4> lhs, RValue<Int4> rhs);
RValue<Int4> operator<<(RValue<Int4> lhs, unsigned char rhs);
RValue<Int4> operator>>(RValue<Int4> lhs, unsigned char rhs);
RValue<Int4> operator<<(RValue<Int4> lhs, RValue<Int4> rhs);
RValue<Int4> operator>>(RValue<Int4> lhs, RValue<Int4> rhs);
RValue<Int4> operator+=(Int4 &lhs, RValue<Int4> rhs);
RValue<Int4> operator-=(Int4 &lhs, RValue<Int4> rhs);
RValue<Int4> operator*=(Int4 &lhs, RValue<Int4> rhs);
//	RValue<Int4> operator/=(Int4 &lhs, RValue<Int4> rhs);
//	RValue<Int4> operator%=(Int4 &lhs, RValue<Int4> rhs);
RValue<Int4> operator&=(Int4 &lhs, RValue<Int4> rhs);
RValue<Int4> operator|=(Int4 &lhs, RValue<Int4> rhs);
RValue<Int4> operator^=(Int4 &lhs, RValue<Int4> rhs);
RValue<Int4> operator<<=(Int4 &lhs, unsigned char rhs);
RValue<Int4> operator>>=(Int4 &lhs, unsigned char rhs);
RValue<Int4> operator+(RValue<Int4> val);
RValue<Int4> operator-(RValue<Int4> val);
RValue<Int4> operator~(RValue<Int4> val);
//	RValue<Int4> operator++(Int4 &val, int);   // Post-increment
//	const Int4 &operator++(Int4 &val);   // Pre-increment
//	RValue<Int4> operator--(Int4 &val, int);   // Post-decrement
//	const Int4 &operator--(Int4 &val);   // Pre-decrement
//	RValue<Bool> operator<(RValue<Int4> lhs, RValue<Int4> rhs);
//	RValue<Bool> operator<=(RValue<Int4> lhs, RValue<Int4> rhs);
//	RValue<Bool> operator>(RValue<Int4> lhs, RValue<Int4> rhs);
//	RValue<Bool> operator>=(RValue<Int4> lhs, RValue<Int4> rhs);
//	RValue<Bool> operator!=(RValue<Int4> lhs, RValue<Int4> rhs);
//	RValue<Bool> operator==(RValue<Int4> lhs, RValue<Int4> rhs);

inline RValue<Int4> operator+(RValue<Int> lhs, RValue<Int4> rhs)
{
	return Int4(lhs) + rhs;
}

inline RValue<Int4> operator+(RValue<Int4> lhs, RValue<Int> rhs)
{
	return lhs + Int4(rhs);
}

RValue<Int4> CmpEQ(RValue<Int4> x, RValue<Int4> y);
RValue<Int4> CmpLT(RValue<Int4> x, RValue<Int4> y);
RValue<Int4> CmpLE(RValue<Int4> x, RValue<Int4> y);
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);
}
RValue<Int4> Max(RValue<Int4> x, RValue<Int4> y);
RValue<Int4> Min(RValue<Int4> x, RValue<Int4> y);
RValue<Int4> RoundInt(RValue<Float4> cast);
RValue<Short8> PackSigned(RValue<Int4> x, RValue<Int4> y);
RValue<UShort8> PackUnsigned(RValue<Int4> x, RValue<Int4> y);
RValue<Int> Extract(RValue<Int4> val, int i);
RValue<Int4> Insert(RValue<Int4> val, RValue<Int> element, int i);
RValue<Int> SignMask(RValue<Int4> x);
RValue<Int4> Swizzle(RValue<Int4> x, uint16_t select);
RValue<Int4> Shuffle(RValue<Int4> x, RValue<Int4> y, uint16_t select);
RValue<Int4> MulHigh(RValue<Int4> x, RValue<Int4> y);

class UInt4 : public LValue<UInt4>, public XYZW<UInt4>
{
public:
	explicit UInt4(RValue<Float4> cast);

	UInt4();
	UInt4(int xyzw);
	UInt4(int x, int yzw);
	UInt4(int x, int y, int zw);
	UInt4(int x, int y, int z, int w);
	UInt4(RValue<UInt4> rhs);
	UInt4(const UInt4 &rhs);
	UInt4(const Reference<UInt4> &rhs);
	UInt4(RValue<Int4> rhs);
	UInt4(const Int4 &rhs);
	UInt4(const Reference<Int4> &rhs);
	UInt4(RValue<UInt2> lo, RValue<UInt2> hi);
	UInt4(RValue<UInt> rhs);
	UInt4(const UInt &rhs);
	UInt4(const Reference<UInt> &rhs);

	RValue<UInt4> operator=(RValue<UInt4> rhs);
	RValue<UInt4> operator=(const UInt4 &rhs);
	RValue<UInt4> operator=(const Reference<UInt4> &rhs);

	static Type *type();

private:
	void constant(int x, int y, int z, int w);
};

RValue<UInt4> operator+(RValue<UInt4> lhs, RValue<UInt4> rhs);
RValue<UInt4> operator-(RValue<UInt4> lhs, RValue<UInt4> rhs);
RValue<UInt4> operator*(RValue<UInt4> lhs, RValue<UInt4> rhs);
RValue<UInt4> operator/(RValue<UInt4> lhs, RValue<UInt4> rhs);
RValue<UInt4> operator%(RValue<UInt4> lhs, RValue<UInt4> rhs);
RValue<UInt4> operator&(RValue<UInt4> lhs, RValue<UInt4> rhs);
RValue<UInt4> operator|(RValue<UInt4> lhs, RValue<UInt4> rhs);
RValue<UInt4> operator^(RValue<UInt4> lhs, RValue<UInt4> rhs);
RValue<UInt4> operator<<(RValue<UInt4> lhs, unsigned char rhs);
RValue<UInt4> operator>>(RValue<UInt4> lhs, unsigned char rhs);
RValue<UInt4> operator<<(RValue<UInt4> lhs, RValue<UInt4> rhs);
RValue<UInt4> operator>>(RValue<UInt4> lhs, RValue<UInt4> rhs);
RValue<UInt4> operator+=(UInt4 &lhs, RValue<UInt4> rhs);
RValue<UInt4> operator-=(UInt4 &lhs, RValue<UInt4> rhs);
RValue<UInt4> operator*=(UInt4 &lhs, RValue<UInt4> rhs);
//	RValue<UInt4> operator/=(UInt4 &lhs, RValue<UInt4> rhs);
//	RValue<UInt4> operator%=(UInt4 &lhs, RValue<UInt4> rhs);
RValue<UInt4> operator&=(UInt4 &lhs, RValue<UInt4> rhs);
RValue<UInt4> operator|=(UInt4 &lhs, RValue<UInt4> rhs);
RValue<UInt4> operator^=(UInt4 &lhs, RValue<UInt4> rhs);
RValue<UInt4> operator<<=(UInt4 &lhs, unsigned char rhs);
RValue<UInt4> operator>>=(UInt4 &lhs, unsigned char rhs);
RValue<UInt4> operator+(RValue<UInt4> val);
RValue<UInt4> operator-(RValue<UInt4> val);
RValue<UInt4> operator~(RValue<UInt4> val);
//	RValue<UInt4> operator++(UInt4 &val, int);   // Post-increment
//	const UInt4 &operator++(UInt4 &val);   // Pre-increment
//	RValue<UInt4> operator--(UInt4 &val, int);   // Post-decrement
//	const UInt4 &operator--(UInt4 &val);   // Pre-decrement
//	RValue<Bool> operator<(RValue<UInt4> lhs, RValue<UInt4> rhs);
//	RValue<Bool> operator<=(RValue<UInt4> lhs, RValue<UInt4> rhs);
//	RValue<Bool> operator>(RValue<UInt4> lhs, RValue<UInt4> rhs);
//	RValue<Bool> operator>=(RValue<UInt4> lhs, RValue<UInt4> rhs);
//	RValue<Bool> operator!=(RValue<UInt4> lhs, RValue<UInt4> rhs);
//	RValue<Bool> operator==(RValue<UInt4> lhs, RValue<UInt4> rhs);

RValue<UInt4> CmpEQ(RValue<UInt4> x, RValue<UInt4> y);
RValue<UInt4> CmpLT(RValue<UInt4> x, RValue<UInt4> y);
RValue<UInt4> CmpLE(RValue<UInt4> x, RValue<UInt4> y);
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);
}
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);
RValue<UInt> Extract(RValue<UInt4> val, int i);
RValue<UInt4> Insert(RValue<UInt4> val, RValue<UInt> element, int i);
//	RValue<UInt4> RoundInt(RValue<Float4> cast);
RValue<UInt4> Swizzle(RValue<UInt4> x, uint16_t select);
RValue<UInt4> Shuffle(RValue<UInt4> x, RValue<UInt4> y, uint16_t select);

class Half : public LValue<Half>
{
public:
	explicit Half(RValue<Float> cast);

	static Type *type();
};

class Float : public LValue<Float>
{
public:
	explicit Float(RValue<Int> cast);
	explicit Float(RValue<UInt> cast);
	explicit Float(RValue<Half> cast);

	Float() = default;
	Float(float x);
	Float(RValue<Float> rhs);
	Float(const Float &rhs);
	Float(const Reference<Float> &rhs);
	Float(Argument<Float> argument);

	template<int T>
	Float(const SwizzleMask1<Float4, T> &rhs);

	RValue<Float> operator=(float rhs);
	RValue<Float> operator=(RValue<Float> rhs);
	RValue<Float> operator=(const Float &rhs);
	RValue<Float> operator=(const Reference<Float> &rhs);

	template<int T>
	RValue<Float> operator=(const SwizzleMask1<Float4, T> &rhs);

	static Float infinity();

	static Type *type();
};

RValue<Float> operator+(RValue<Float> lhs, RValue<Float> rhs);
RValue<Float> operator-(RValue<Float> lhs, RValue<Float> rhs);
RValue<Float> operator*(RValue<Float> lhs, RValue<Float> rhs);
RValue<Float> operator/(RValue<Float> lhs, RValue<Float> rhs);
RValue<Float> operator+=(Float &lhs, RValue<Float> rhs);
RValue<Float> operator-=(Float &lhs, RValue<Float> rhs);
RValue<Float> operator*=(Float &lhs, RValue<Float> rhs);
RValue<Float> operator/=(Float &lhs, RValue<Float> rhs);
RValue<Float> operator+(RValue<Float> val);
RValue<Float> operator-(RValue<Float> val);
RValue<Bool> operator<(RValue<Float> lhs, RValue<Float> rhs);
RValue<Bool> operator<=(RValue<Float> lhs, RValue<Float> rhs);
RValue<Bool> operator>(RValue<Float> lhs, RValue<Float> rhs);
RValue<Bool> operator>=(RValue<Float> lhs, RValue<Float> rhs);
RValue<Bool> operator!=(RValue<Float> lhs, RValue<Float> rhs);
RValue<Bool> operator==(RValue<Float> lhs, RValue<Float> rhs);

RValue<Float> Abs(RValue<Float> x);
RValue<Float> Max(RValue<Float> x, RValue<Float> y);
RValue<Float> Min(RValue<Float> x, RValue<Float> y);
RValue<Float> Rcp_pp(RValue<Float> val, bool exactAtPow2 = false);
RValue<Float> RcpSqrt_pp(RValue<Float> val);
RValue<Float> Sqrt(RValue<Float> x);

//	RValue<Int4> IsInf(RValue<Float> x);
//	RValue<Int4> IsNan(RValue<Float> x);
RValue<Float> Round(RValue<Float> x);
RValue<Float> Trunc(RValue<Float> x);
RValue<Float> Frac(RValue<Float> x);
RValue<Float> Floor(RValue<Float> x);
RValue<Float> Ceil(RValue<Float> x);

// Trigonometric functions
// TODO: Currently unimplemented for Subzero.
//	RValue<Float> Sin(RValue<Float> x);
//	RValue<Float> Cos(RValue<Float> x);
//	RValue<Float> Tan(RValue<Float> x);
//	RValue<Float> Asin(RValue<Float> x);
//	RValue<Float> Acos(RValue<Float> x);
//	RValue<Float> Atan(RValue<Float> x);
//	RValue<Float> Sinh(RValue<Float> x);
//	RValue<Float> Cosh(RValue<Float> x);
//	RValue<Float> Tanh(RValue<Float> x);
//	RValue<Float> Asinh(RValue<Float> x);
//	RValue<Float> Acosh(RValue<Float> x);
//	RValue<Float> Atanh(RValue<Float> x);
//	RValue<Float> Atan2(RValue<Float> x, RValue<Float> y);

// Exponential functions
// TODO: Currently unimplemented for Subzero.
//	RValue<Float> Pow(RValue<Float> x, RValue<Float> y);
//	RValue<Float> Exp(RValue<Float> x);
//	RValue<Float> Log(RValue<Float> x);
RValue<Float> Exp2(RValue<Float> x);
RValue<Float> Log2(RValue<Float> x);

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<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);

	//	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);

	//	template<int T>
	//	RValue<Float2> operator=(const SwizzleMask1<T> &rhs);

	static Type *type();
};

//	RValue<Float2> operator+(RValue<Float2> lhs, RValue<Float2> rhs);
//	RValue<Float2> operator-(RValue<Float2> lhs, RValue<Float2> rhs);
//	RValue<Float2> operator*(RValue<Float2> lhs, RValue<Float2> rhs);
//	RValue<Float2> operator/(RValue<Float2> lhs, RValue<Float2> rhs);
//	RValue<Float2> operator%(RValue<Float2> lhs, RValue<Float2> rhs);
//	RValue<Float2> operator+=(Float2 &lhs, RValue<Float2> rhs);
//	RValue<Float2> operator-=(Float2 &lhs, RValue<Float2> rhs);
//	RValue<Float2> operator*=(Float2 &lhs, RValue<Float2> rhs);
//	RValue<Float2> operator/=(Float2 &lhs, RValue<Float2> rhs);
//	RValue<Float2> operator%=(Float2 &lhs, RValue<Float2> rhs);
//	RValue<Float2> operator+(RValue<Float2> val);
//	RValue<Float2> operator-(RValue<Float2> val);

//	RValue<Float2> Abs(RValue<Float2> x);
//	RValue<Float2> Max(RValue<Float2> x, RValue<Float2> y);
//	RValue<Float2> Min(RValue<Float2> x, RValue<Float2> y);
//	RValue<Float2> Swizzle(RValue<Float2> x, uint16_t select);
//	RValue<Float2> Mask(Float2 &lhs, RValue<Float2> rhs, uint16_t select);

class Float4 : public LValue<Float4>, public XYZW<Float4>
{
public:
	explicit Float4(RValue<Byte4> cast);
	explicit Float4(RValue<SByte4> cast);
	explicit Float4(RValue<Short4> cast);
	explicit Float4(RValue<UShort4> cast);
	explicit Float4(RValue<Int4> cast);
	explicit Float4(RValue<UInt4> cast);

	Float4();
	Float4(float xyzw);
	Float4(float x, float yzw);
	Float4(float x, float y, float zw);
	Float4(float x, float y, float z, float w);
	Float4(RValue<Float4> rhs);
	Float4(const Float4 &rhs);
	Float4(const Reference<Float4> &rhs);
	Float4(RValue<Float> rhs);
	Float4(const Float &rhs);
	Float4(const Reference<Float> &rhs);

	template<int T>
	Float4(const SwizzleMask1<Float4, T> &rhs);
	template<int T>
	Float4(const Swizzle4<Float4, T> &rhs);
	template<int X, int Y>
	Float4(const Swizzle2<Float4, X> &x, const Swizzle2<Float4, Y> &y);
	template<int X, int Y>
	Float4(const SwizzleMask2<Float4, X> &x, const Swizzle2<Float4, Y> &y);
	template<int X, int Y>
	Float4(const Swizzle2<Float4, X> &x, const SwizzleMask2<Float4, Y> &y);
	template<int X, int Y>
	Float4(const SwizzleMask2<Float4, X> &x, const SwizzleMask2<Float4, Y> &y);
	Float4(RValue<Float2> lo, RValue<Float2> hi);

	RValue<Float4> operator=(float replicate);
	RValue<Float4> operator=(RValue<Float4> rhs);
	RValue<Float4> operator=(const Float4 &rhs);
	RValue<Float4> operator=(const Reference<Float4> &rhs);
	RValue<Float4> operator=(RValue<Float> rhs);
	RValue<Float4> operator=(const Float &rhs);
	RValue<Float4> operator=(const Reference<Float> &rhs);

	template<int T>
	RValue<Float4> operator=(const SwizzleMask1<Float4, T> &rhs);
	template<int T>
	RValue<Float4> operator=(const Swizzle4<Float4, T> &rhs);

	static Float4 infinity();

	static Type *type();

private:
	void constant(float x, float y, float z, float w);
};

RValue<Float4> operator+(RValue<Float4> lhs, RValue<Float4> rhs);
RValue<Float4> operator-(RValue<Float4> lhs, RValue<Float4> rhs);
RValue<Float4> operator*(RValue<Float4> lhs, RValue<Float4> rhs);
RValue<Float4> operator/(RValue<Float4> lhs, RValue<Float4> rhs);
RValue<Float4> operator%(RValue<Float4> lhs, RValue<Float4> rhs);
RValue<Float4> operator+=(Float4 &lhs, RValue<Float4> rhs);
RValue<Float4> operator-=(Float4 &lhs, RValue<Float4> rhs);
RValue<Float4> operator*=(Float4 &lhs, RValue<Float4> rhs);
RValue<Float4> operator/=(Float4 &lhs, RValue<Float4> rhs);
RValue<Float4> operator%=(Float4 &lhs, RValue<Float4> rhs);
RValue<Float4> operator+(RValue<Float4> val);
RValue<Float4> operator-(RValue<Float4> val);

RValue<Float4> Abs(RValue<Float4> x);
RValue<Float4> Max(RValue<Float4> x, RValue<Float4> y);
RValue<Float4> Min(RValue<Float4> x, RValue<Float4> y);
RValue<Float4> Rcp_pp(RValue<Float4> val, bool exactAtPow2 = false);
RValue<Float4> RcpSqrt_pp(RValue<Float4> val);
RValue<Float4> Sqrt(RValue<Float4> x);
RValue<Float4> Insert(RValue<Float4> val, RValue<Float> element, int i);
RValue<Float> Extract(RValue<Float4> x, int i);
RValue<Float4> Swizzle(RValue<Float4> x, uint16_t select);
RValue<Float4> Shuffle(RValue<Float4> x, RValue<Float4> y, uint16_t select);
RValue<Float4> ShuffleLowHigh(RValue<Float4> x, RValue<Float4> y, uint16_t imm);
RValue<Float4> UnpackLow(RValue<Float4> x, RValue<Float4> y);
RValue<Float4> UnpackHigh(RValue<Float4> x, RValue<Float4> y);
RValue<Float4> Mask(Float4 &lhs, RValue<Float4> rhs, uint16_t select);
RValue<Int> SignMask(RValue<Float4> x);

// Ordered comparison functions
RValue<Int4> CmpEQ(RValue<Float4> x, RValue<Float4> y);
RValue<Int4> CmpLT(RValue<Float4> x, RValue<Float4> y);
RValue<Int4> CmpLE(RValue<Float4> x, RValue<Float4> y);
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);
}

// Unordered comparison functions
RValue<Int4> CmpUEQ(RValue<Float4> x, RValue<Float4> y);
RValue<Int4> CmpULT(RValue<Float4> x, RValue<Float4> y);
RValue<Int4> CmpULE(RValue<Float4> x, RValue<Float4> y);
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);
}

RValue<Int4> IsInf(RValue<Float4> x);
RValue<Int4> IsNan(RValue<Float4> x);
RValue<Float4> Round(RValue<Float4> x);
RValue<Float4> Trunc(RValue<Float4> x);
RValue<Float4> Frac(RValue<Float4> x);
RValue<Float4> Floor(RValue<Float4> x);
RValue<Float4> Ceil(RValue<Float4> x);

enum class Precision
{
	Full,
	Relaxed,
	//Half,
};

// Trigonometric functions
// TODO: Currently unimplemented for Subzero.
RValue<Float4> Sin(RValue<Float4> x);
RValue<Float4> Cos(RValue<Float4> x);
RValue<Float4> Tan(RValue<Float4> x);
RValue<Float4> Asin(RValue<Float4> x, Precision p);
RValue<Float4> Acos(RValue<Float4> x, Precision p);
RValue<Float4> Atan(RValue<Float4> x);
RValue<Float4> Sinh(RValue<Float4> x);
RValue<Float4> Cosh(RValue<Float4> x);
RValue<Float4> Tanh(RValue<Float4> x);
RValue<Float4> Asinh(RValue<Float4> x);
RValue<Float4> Acosh(RValue<Float4> x);
RValue<Float4> Atanh(RValue<Float4> x);
RValue<Float4> Atan2(RValue<Float4> x, RValue<Float4> y);

// Exponential functions
// TODO: Currently unimplemented for Subzero.
RValue<Float4> Pow(RValue<Float4> x, RValue<Float4> y);
RValue<Float4> Exp(RValue<Float4> x);
RValue<Float4> Log(RValue<Float4> x);
RValue<Float4> Exp2(RValue<Float4> x);
RValue<Float4> Log2(RValue<Float4> x);

// Bit Manipulation functions.
// TODO: Currently unimplemented for Subzero.

// Count leading zeros.
// Returns 32 when: !isZeroUndef && x == 0.
// Returns an undefined value when: isZeroUndef && x == 0.
RValue<UInt> Ctlz(RValue<UInt> x, bool isZeroUndef);
RValue<UInt4> Ctlz(RValue<UInt4> x, bool isZeroUndef);

// Count trailing zeros.
// Returns 32 when: !isZeroUndef && x == 0.
// Returns an undefined value when: isZeroUndef && x == 0.
RValue<UInt> Cttz(RValue<UInt> x, bool isZeroUndef);
RValue<UInt4> Cttz(RValue<UInt4> x, bool isZeroUndef);

template<class T>
class Pointer : public LValue<Pointer<T>>
{
public:
	template<class S>
	Pointer(RValue<Pointer<S>> pointerS, int alignment = 1)
	    : alignment(alignment)
	{
		Value *pointerT = Nucleus::createBitCast(pointerS.value(), Nucleus::getPointerType(T::type()));
		this->storeValue(pointerT);
	}

	template<class S>
	Pointer(const Pointer<S> &pointer, int alignment = 1)
	    : alignment(alignment)
	{
		Value *pointerS = pointer.loadValue();
		Value *pointerT = Nucleus::createBitCast(pointerS, Nucleus::getPointerType(T::type()));
		this->storeValue(pointerT);
	}

	Pointer(Argument<Pointer<T>> argument);

	Pointer();
	Pointer(RValue<Pointer<T>> rhs);
	Pointer(const Pointer<T> &rhs);
	Pointer(const Reference<Pointer<T>> &rhs);
	Pointer(std::nullptr_t);

	RValue<Pointer<T>> operator=(RValue<Pointer<T>> rhs);
	RValue<Pointer<T>> operator=(const Pointer<T> &rhs);
	RValue<Pointer<T>> operator=(const Reference<Pointer<T>> &rhs);
	RValue<Pointer<T>> operator=(std::nullptr_t);

	Reference<T> operator*();
	Reference<T> operator[](int index);
	Reference<T> operator[](unsigned int index);
	Reference<T> operator[](RValue<Int> index);
	Reference<T> operator[](RValue<UInt> index);

	static Type *type();

private:
	const int alignment;
};

RValue<Pointer<Byte>> operator+(RValue<Pointer<Byte>> lhs, int offset);
RValue<Pointer<Byte>> operator+(RValue<Pointer<Byte>> lhs, RValue<Int> offset);
RValue<Pointer<Byte>> operator+(RValue<Pointer<Byte>> lhs, RValue<UInt> offset);
RValue<Pointer<Byte>> operator+=(Pointer<Byte> &lhs, int offset);
RValue<Pointer<Byte>> operator+=(Pointer<Byte> &lhs, RValue<Int> offset);
RValue<Pointer<Byte>> operator+=(Pointer<Byte> &lhs, RValue<UInt> offset);

RValue<Pointer<Byte>> operator-(RValue<Pointer<Byte>> lhs, int offset);
RValue<Pointer<Byte>> operator-(RValue<Pointer<Byte>> lhs, RValue<Int> offset);
RValue<Pointer<Byte>> operator-(RValue<Pointer<Byte>> lhs, RValue<UInt> offset);
RValue<Pointer<Byte>> operator-=(Pointer<Byte> &lhs, int offset);
RValue<Pointer<Byte>> operator-=(Pointer<Byte> &lhs, RValue<Int> offset);
RValue<Pointer<Byte>> operator-=(Pointer<Byte> &lhs, RValue<UInt> offset);

template<typename T>
RValue<Bool> operator==(const Pointer<T> &lhs, const Pointer<T> &rhs)
{
	return RValue<Bool>(Nucleus::createPtrEQ(lhs.loadValue(), rhs.loadValue()));
}

template<typename T>
RValue<T> Load(RValue<Pointer<T>> pointer, unsigned int alignment, bool atomic, std::memory_order memoryOrder)
{
	return RValue<T>(Nucleus::createLoad(pointer.value(), T::type(), false, alignment, atomic, memoryOrder));
}

template<typename T>
RValue<T> Load(Pointer<T> pointer, unsigned int alignment, bool atomic, std::memory_order memoryOrder)
{
	return Load(RValue<Pointer<T>>(pointer), alignment, atomic, memoryOrder);
}

// TODO: Use SIMD to template these.
RValue<Float4> MaskedLoad(RValue<Pointer<Float4>> base, RValue<Int4> mask, unsigned int alignment, bool zeroMaskedLanes = false);
RValue<Int4> MaskedLoad(RValue<Pointer<Int4>> base, RValue<Int4> mask, unsigned int alignment, bool zeroMaskedLanes = false);
void MaskedStore(RValue<Pointer<Float4>> base, RValue<Float4> val, RValue<Int4> mask, unsigned int alignment);
void MaskedStore(RValue<Pointer<Int4>> base, RValue<Int4> val, RValue<Int4> mask, unsigned int alignment);

RValue<Float4> Gather(RValue<Pointer<Float>> base, RValue<Int4> offsets, RValue<Int4> mask, unsigned int alignment, bool zeroMaskedLanes = false);
RValue<Int4> Gather(RValue<Pointer<Int>> base, RValue<Int4> offsets, RValue<Int4> mask, unsigned int alignment, bool zeroMaskedLanes = false);
void Scatter(RValue<Pointer<Float>> base, RValue<Float4> val, RValue<Int4> offsets, RValue<Int4> mask, unsigned int alignment);
void Scatter(RValue<Pointer<Int>> base, RValue<Int4> val, RValue<Int4> offsets, RValue<Int4> mask, unsigned int alignment);

template<typename T>
void Store(RValue<T> value, RValue<Pointer<T>> pointer, unsigned int alignment, bool atomic, std::memory_order memoryOrder)
{
	Nucleus::createStore(value.value(), pointer.value(), T::type(), false, alignment, atomic, memoryOrder);
}

template<typename T>
void Store(RValue<T> value, Pointer<T> pointer, unsigned int alignment, bool atomic, std::memory_order memoryOrder)
{
	Store(value, RValue<Pointer<T>>(pointer), alignment, atomic, memoryOrder);
}

template<typename T>
void Store(T value, Pointer<T> pointer, unsigned int alignment, bool atomic, std::memory_order memoryOrder)
{
	Store(RValue<T>(value), RValue<Pointer<T>>(pointer), alignment, atomic, memoryOrder);
}

// Fence adds a memory barrier that enforces ordering constraints on memory
// operations. memoryOrder can only be one of:
// std::memory_order_acquire, std::memory_order_release,
// std::memory_order_acq_rel, or std::memory_order_seq_cst.
void Fence(std::memory_order memoryOrder);

template<class T, int S = 1>
class Array : public LValue<T>
{
public:
	Array(int size = S);

	Reference<T> operator[](int index);
	Reference<T> operator[](unsigned int index);
	Reference<T> operator[](RValue<Int> index);
	Reference<T> operator[](RValue<UInt> index);

	// self() returns the this pointer to this Array object.
	// This function exists because operator&() is overloaded by LValue<T>.
	inline Array *self() { return this; }

private:
	Value *allocate() const override;

	const int arraySize;
};

//	RValue<Array<T>> operator++(Array<T> &val, int);   // Post-increment
//	const Array<T> &operator++(Array<T> &val);   // Pre-increment
//	RValue<Array<T>> operator--(Array<T> &val, int);   // Post-decrement
//	const Array<T> &operator--(Array<T> &val);   // Pre-decrement

void branch(RValue<Bool> cmp, BasicBlock *bodyBB, BasicBlock *endBB);

// 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)
{
	return ReactorType<T>::cast(v).loadValue();
}

void Return();

template<class T>
void Return(const T &ret)
{
	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());
}

// Generic template, leave undefined!
template<typename FunctionType>
class Function;

// Specialized for function types
template<typename Return, typename... Arguments>
class Function<Return(Arguments...)>
{
	// Static assert that the function signature is valid.
	static_assert(sizeof(AssertFunctionSignatureIsValid<Return(Arguments...)>) >= 0, "Invalid function signature");

public:
	Function();

	virtual ~Function();

	template<int index>
	Argument<typename std::tuple_element<index, std::tuple<Arguments...>>::type> Arg() const
	{
		Value *arg = Nucleus::getArgument(index);
		return Argument<typename std::tuple_element<index, std::tuple<Arguments...>>::type>(arg);
	}

	std::shared_ptr<Routine> operator()(const char *name, ...);
	std::shared_ptr<Routine> operator()(const Config::Edit &cfg, const char *name, ...);

protected:
	Nucleus *core;
	std::vector<Type *> arguments;
};

template<typename Return>
class Function<Return()> : public Function<Return(Void)>
{
};

// FunctionT accepts a C-style function type template argument, allowing it to return a type-safe RoutineT wrapper
template<typename FunctionType>
class FunctionT;

template<typename Return, typename... Arguments>
class FunctionT<Return(Arguments...)> : public Function<CToReactorT<Return>(CToReactorT<Arguments>...)>
{
public:
	// Type of base class
	using BaseType = Function<CToReactorT<Return>(CToReactorT<Arguments>...)>;

	// Function type, e.g. void(int,float)
	using CFunctionType = Return(Arguments...);

	// Reactor function type, e.g. Void(Int, Float)
	using ReactorFunctionType = CToReactorT<Return>(CToReactorT<Arguments>...);

	// Returned RoutineT type
	using RoutineType = RoutineT<CFunctionType>;

	// Hide base implementations of operator()

	RoutineType operator()(const char *name, ...)
	{
		return RoutineType(BaseType::operator()(name));
	}

	RoutineType operator()(const Config::Edit &cfg, const char *name, ...)
	{
		return RoutineType(BaseType::operator()(cfg, name));
	}
};

RValue<Long> Ticks();

}  // namespace rr

/* Inline implementations */

namespace rr {

template<class T>
LValue<T>::LValue()
{
#ifdef ENABLE_RR_DEBUG_INFO
	materialize();
#endif  // ENABLE_RR_DEBUG_INFO
}

template<class T>
RValue<Pointer<T>> LValue<T>::operator&()
{
	return RValue<Pointer<T>>(this->getBaseAddress());
}

template<class T>
Reference<T>::Reference(Value *pointer, int alignment)
    : alignment(alignment)
{
	address = pointer;
}

template<class T>
RValue<T> Reference<T>::operator=(RValue<T> rhs) const
{
	Nucleus::createStore(rhs.value(), address, T::type(), false, alignment);

	return rhs;
}

template<class T>
RValue<T> Reference<T>::operator=(const Reference<T> &ref) const
{
	Value *tmp = Nucleus::createLoad(ref.address, T::type(), false, ref.alignment);
	Nucleus::createStore(tmp, address, T::type(), false, alignment);

	return RValue<T>(tmp);
}

template<class T>
RValue<T> Reference<T>::operator+=(RValue<T> rhs) const
{
	return *this = *this + rhs;
}

template<class T>
Value *Reference<T>::loadValue() const
{
	return Nucleus::createLoad(address, T::type(), false, alignment);
}

template<class T>
RValue<T> Reference<T>::load() const
{
	return RValue<T>(loadValue());
}

template<class T>
int Reference<T>::getAlignment() const
{
	return alignment;
}

template<class T>
RValue<T>::RValue(const RValue<T> &rvalue)
    : val(rvalue.val)
{
	RR_DEBUG_INFO_EMIT_VAR(val);
}

template<class T>
RValue<T>::RValue(Value *value)
    : val(value)
{
	assert(Nucleus::createBitCast(value, T::type()) == value);  // Run-time type should match T, so bitcast is no-op.
	RR_DEBUG_INFO_EMIT_VAR(val);
}

template<class T>
RValue<T>::RValue(const T &lvalue)
    : val(lvalue.loadValue())
{
	RR_DEBUG_INFO_EMIT_VAR(val);
}

template<class T>
RValue<T>::RValue(typename BoolLiteral<T>::type i)
    : val(Nucleus::createConstantBool(i))
{
	RR_DEBUG_INFO_EMIT_VAR(val);
}

template<class T>
RValue<T>::RValue(typename IntLiteral<T>::type i)
    : val(Nucleus::createConstantInt(i))
{
	RR_DEBUG_INFO_EMIT_VAR(val);
}

template<class T>
RValue<T>::RValue(typename FloatLiteral<T>::type f)
    : val(Nucleus::createConstantFloat(f))
{
	RR_DEBUG_INFO_EMIT_VAR(val);
}

template<class T>
RValue<T>::RValue(const Reference<T> &ref)
    : val(ref.loadValue())
{
	RR_DEBUG_INFO_EMIT_VAR(val);
}

template<class Vector4, int T>
Swizzle2<Vector4, T>::operator RValue<Vector4>() const
{
	RR_DEBUG_INFO_UPDATE_LOC();
	Value *vector = parent->loadValue();

	return Swizzle(RValue<Vector4>(vector), T);
}

template<class Vector4, int T>
Swizzle4<Vector4, T>::operator RValue<Vector4>() const
{
	RR_DEBUG_INFO_UPDATE_LOC();
	Value *vector = parent->loadValue();

	return Swizzle(RValue<Vector4>(vector), T);
}

template<class Vector4, int T>
SwizzleMask4<Vector4, T>::operator RValue<Vector4>() const
{
	RR_DEBUG_INFO_UPDATE_LOC();
	Value *vector = parent->loadValue();

	return Swizzle(RValue<Vector4>(vector), T);
}

template<class Vector4, int T>
RValue<Vector4> SwizzleMask4<Vector4, T>::operator=(RValue<Vector4> rhs)
{
	RR_DEBUG_INFO_UPDATE_LOC();
	return Mask(*parent, rhs, T);
}

template<class Vector4, int T>
RValue<Vector4> SwizzleMask4<Vector4, T>::operator=(RValue<typename Scalar<Vector4>::Type> rhs)
{
	RR_DEBUG_INFO_UPDATE_LOC();
	return Mask(*parent, Vector4(rhs), T);
}

template<class Vector4, int T>
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);
}

template<class Vector4, int T>
SwizzleMask1<Vector4, T>::operator RValue<Vector4>() const
{
	RR_DEBUG_INFO_UPDATE_LOC();
	Value *vector = parent->loadValue();

	return Swizzle(RValue<Vector4>(vector), T);
}

template<class Vector4, int T>
RValue<Vector4> SwizzleMask1<Vector4, T>::operator=(float x)
{
	RR_DEBUG_INFO_UPDATE_LOC();
	return *parent = Insert(*parent, Float(x), T & 0x3);
}

template<class Vector4, int T>
RValue<Vector4> SwizzleMask1<Vector4, T>::operator=(RValue<Vector4> rhs)
{
	RR_DEBUG_INFO_UPDATE_LOC();
	return Mask(*parent, Float4(rhs), T);
}

template<class Vector4, int T>
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);
}

template<class Vector4, int T>
SwizzleMask2<Vector4, T>::operator RValue<Vector4>() const
{
	RR_DEBUG_INFO_UPDATE_LOC();
	Value *vector = parent->loadValue();

	return Swizzle(RValue<Float4>(vector), T);
}

template<class Vector4, int T>
RValue<Vector4> SwizzleMask2<Vector4, T>::operator=(RValue<Vector4> rhs)
{
	RR_DEBUG_INFO_UPDATE_LOC();
	return Mask(*parent, Float4(rhs), T);
}

template<int T>
Float::Float(const SwizzleMask1<Float4, T> &rhs)
{
	*this = rhs.operator RValue<Float>();
}

template<int T>
RValue<Float> Float::operator=(const SwizzleMask1<Float4, T> &rhs)
{
	return *this = rhs.operator RValue<Float>();
}

template<int T>
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)
{
	*this = rhs.operator RValue<Float4>();
}

template<int X, int Y>
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)
{
	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)
{
	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)
{
	RR_DEBUG_INFO_UPDATE_LOC();
	*this = ShuffleLowHigh(*x.parent, *y.parent, (uint16_t(X) & 0xFF00u) | (uint16_t(Y >> 8) & 0x00FFu));
}

template<int T>
RValue<Float4> Float4::operator=(const SwizzleMask1<Float4, T> &rhs)
{
	return *this = rhs.operator RValue<Float4>();
}

template<int T>
RValue<Float4> Float4::operator=(const Swizzle4<Float4, T> &rhs)
{
	return *this = rhs.operator RValue<Float4>();
}

// Returns a reactor pointer to the fixed-address 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);

template<class T>
Pointer<T>::Pointer(Argument<Pointer<T>> argument)
    : alignment(1)
{
	this->store(argument.rvalue());
}

template<class T>
Pointer<T>::Pointer()
    : alignment(1)
{}

template<class T>
Pointer<T>::Pointer(RValue<Pointer<T>> rhs)
    : alignment(1)
{
	this->store(rhs);
}

template<class T>
Pointer<T>::Pointer(const Pointer<T> &rhs)
    : alignment(rhs.alignment)
{
	this->store(rhs.load());
}

template<class T>
Pointer<T>::Pointer(const Reference<Pointer<T>> &rhs)
    : alignment(rhs.getAlignment())
{
	this->store(rhs.load());
}

template<class T>
Pointer<T>::Pointer(std::nullptr_t)
    : alignment(1)
{
	Value *value = Nucleus::createNullPointer(T::type());
	this->storeValue(value);
}

template<class T>
RValue<Pointer<T>> Pointer<T>::operator=(RValue<Pointer<T>> rhs)
{
	return this->store(rhs);
}

template<class T>
RValue<Pointer<T>> Pointer<T>::operator=(const Pointer<T> &rhs)
{
	return this->store(rhs.load());
}

template<class T>
RValue<Pointer<T>> Pointer<T>::operator=(const Reference<Pointer<T>> &rhs)
{
	return this->store(rhs.load());
}

template<class T>
RValue<Pointer<T>> Pointer<T>::operator=(std::nullptr_t)
{
	Value *value = Nucleus::createNullPointer(T::type());
	this->storeValue(value);

	return RValue<Pointer<T>>(this);
}

template<class T>
Reference<T> Pointer<T>::operator*()
{
	return Reference<T>(this->loadValue(), alignment);
}

template<class T>
Reference<T> Pointer<T>::operator[](int index)
{
	RR_DEBUG_INFO_UPDATE_LOC();
	Value *element = Nucleus::createGEP(this->loadValue(), T::type(), Nucleus::createConstantInt(index), false);

	return Reference<T>(element, alignment);
}

template<class T>
Reference<T> Pointer<T>::operator[](unsigned int index)
{
	RR_DEBUG_INFO_UPDATE_LOC();
	Value *element = Nucleus::createGEP(this->loadValue(), T::type(), Nucleus::createConstantInt(index), true);

	return Reference<T>(element, alignment);
}

template<class T>
Reference<T> Pointer<T>::operator[](RValue<Int> index)
{
	RR_DEBUG_INFO_UPDATE_LOC();
	Value *element = Nucleus::createGEP(this->loadValue(), T::type(), index.value(), false);

	return Reference<T>(element, alignment);
}

template<class T>
Reference<T> Pointer<T>::operator[](RValue<UInt> index)
{
	RR_DEBUG_INFO_UPDATE_LOC();
	Value *element = Nucleus::createGEP(this->loadValue(), T::type(), index.value(), true);

	return Reference<T>(element, alignment);
}

template<class T>
Type *Pointer<T>::type()
{
	return Nucleus::getPointerType(T::type());
}

template<class T, int S>
Array<T, S>::Array(int size)
    : arraySize(size)
{
}

template<class T, int S>
Value *Array<T, S>::allocate() const
{
	return Nucleus::allocateStackVariable(T::type(), arraySize);
}

template<class T, int S>
Reference<T> Array<T, S>::operator[](int index)
{
	assert(index < arraySize);
	Value *element = this->getElementPointer(Nucleus::createConstantInt(index), false);

	return Reference<T>(element);
}

template<class T, int S>
Reference<T> Array<T, S>::operator[](unsigned int index)
{
	assert(index < static_cast<unsigned int>(arraySize));
	Value *element = this->getElementPointer(Nucleus::createConstantInt(index), true);

	return Reference<T>(element);
}

template<class T, int S>
Reference<T> Array<T, S>::operator[](RValue<Int> index)
{
	Value *element = this->getElementPointer(index.value(), false);

	return Reference<T>(element);
}

template<class T, int S>
Reference<T> Array<T, S>::operator[](RValue<UInt> index)
{
	Value *element = this->getElementPointer(index.value(), true);

	return Reference<T>(element);
}

//	template<class T>
//	RValue<Array<T>> operator++(Array<T> &val, int)
//	{
//		// FIXME: Requires storing the address of the array
//	}

//	template<class T>
//	const Array<T> &operator++(Array<T> &val)
//	{
//		// FIXME: Requires storing the address of the array
//	}

//	template<class T>
//	RValue<Array<T>> operator--(Array<T> &val, int)
//	{
//		// FIXME: Requires storing the address of the array
//	}

//	template<class T>
//	const Array<T> &operator--(Array<T> &val)
//	{
//		// FIXME: Requires storing the address of the array
//	}

template<class T>
RValue<T> IfThenElse(RValue<Bool> condition, RValue<T> ifTrue, RValue<T> ifFalse)
{
	RR_DEBUG_INFO_UPDATE_LOC();
	return RValue<T>(Nucleus::createSelect(condition.value(), ifTrue.value(), ifFalse.value()));
}

template<class T>
RValue<T> IfThenElse(RValue<Bool> condition, const T &ifTrue, RValue<T> ifFalse)
{
	RR_DEBUG_INFO_UPDATE_LOC();
	Value *trueValue = ifTrue.loadValue();

	return RValue<T>(Nucleus::createSelect(condition.value(), trueValue, ifFalse.value()));
}

template<class T>
RValue<T> IfThenElse(RValue<Bool> condition, RValue<T> ifTrue, const T &ifFalse)
{
	RR_DEBUG_INFO_UPDATE_LOC();
	Value *falseValue = ifFalse.loadValue();

	return RValue<T>(Nucleus::createSelect(condition.value(), ifTrue.value(), falseValue));
}

template<class T>
RValue<T> IfThenElse(RValue<Bool> condition, const T &ifTrue, const T &ifFalse)
{
	RR_DEBUG_INFO_UPDATE_LOC();
	Value *trueValue = ifTrue.loadValue();
	Value *falseValue = ifFalse.loadValue();

	return RValue<T>(Nucleus::createSelect(condition.value(), trueValue, falseValue));
}

template<typename Return, typename... Arguments>
Function<Return(Arguments...)>::Function()
{
	core = new Nucleus();

	Type *types[] = { Arguments::type()... };
	for(Type *type : types)
	{
		if(type != Void::type())
		{
			arguments.push_back(type);
		}
	}

	Nucleus::createFunction(Return::type(), arguments);
}

template<typename Return, typename... Arguments>
Function<Return(Arguments...)>::~Function()
{
	delete core;
}

template<typename Return, typename... Arguments>
std::shared_ptr<Routine> Function<Return(Arguments...)>::operator()(const char *name, ...)
{
	char fullName[1024 + 1];

	va_list vararg;
	va_start(vararg, name);
	vsnprintf(fullName, 1024, name, vararg);
	va_end(vararg);

	return core->acquireRoutine(fullName, Config::Edit::None);
}

template<typename Return, typename... Arguments>
std::shared_ptr<Routine> Function<Return(Arguments...)>::operator()(const Config::Edit &cfg, const char *name, ...)
{
	char fullName[1024 + 1];

	va_list vararg;
	va_start(vararg, name);
	vsnprintf(fullName, 1024, name, vararg);
	va_end(vararg);

	return core->acquireRoutine(fullName, cfg);
}

template<class T, class S>
RValue<T> ReinterpretCast(RValue<S> val)
{
	RR_DEBUG_INFO_UPDATE_LOC();
	return RValue<T>(Nucleus::createBitCast(val.value(), T::type()));
}

template<class T, class S>
RValue<T> ReinterpretCast(const LValue<S> &var)
{
	RR_DEBUG_INFO_UPDATE_LOC();
	Value *val = var.loadValue();

	return RValue<T>(Nucleus::createBitCast(val, T::type()));
}

template<class T, class S>
RValue<T> ReinterpretCast(const Reference<S> &var)
{
	return ReinterpretCast<T>(RValue<S>(var));
}

template<class T>
RValue<T> As(Value *val)
{
	RR_DEBUG_INFO_UPDATE_LOC();
	return RValue<T>(Nucleus::createBitCast(val, T::type()));
}

template<class T, class S>
RValue<T> As(RValue<S> val)
{
	return ReinterpretCast<T>(val);
}

template<class T, class S>
RValue<T> As(const LValue<S> &var)
{
	return ReinterpretCast<T>(var);
}

template<class T, class S>
RValue<T> As(const Reference<S> &val)
{
	return ReinterpretCast<T>(val);
}

// 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);

template<typename F>
class CallHelper
{};

template<typename Return, typename... Arguments>
class CallHelper<Return(Arguments...)>
{
public:
	using RReturn = CToReactorT<Return>;

	static inline RReturn Call(Return(fptr)(Arguments...), CToReactorT<Arguments>... args)
	{
		return RValue<RReturn>(rr::Call(
		    ConstantPointer(reinterpret_cast<void *>(fptr)),
		    RReturn::type(),
		    { ValueOf(args)... },
		    { CToReactorT<Arguments>::type()... }));
	}

	static inline RReturn Call(Pointer<Byte> fptr, CToReactorT<Arguments>... args)
	{
		return RValue<RReturn>(rr::Call(
		    fptr,
		    RReturn::type(),
		    { ValueOf(args)... },
		    { CToReactorT<Arguments>::type()... }));
	}
};

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::type(),
		         { ValueOf(args)... },
		         { CToReactorT<Arguments>::type()... });
	}

	static inline void Call(Pointer<Byte> fptr, CToReactorT<Arguments>... args)
	{
		rr::Call(fptr,
		         Void::type(),
		         { ValueOf(args)... },
		         { CToReactorT<Arguments>::type()... });
	}
};

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)
{
	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)
{
	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)
{
	using Helper = CallHelper<Return(Class *, void *, CArgs...)>;
	using fptrTy = decltype(fptr);

	struct Static
	{
		static inline Return Call(Class *object, void *fptrptr, CArgs... args)
		{
			auto fptr = *reinterpret_cast<fptrTy *>(fptrptr);
			return (object->*fptr)(std::forward<CArgs>(args)...);
		}
	};

	return Helper::Call(&Static::Call,
	                    CastToReactor(object),
	                    ConstantData(&fptr, sizeof(fptr)),
	                    CastToReactor(std::forward<RArgs>(args))...);
}

// 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)
{
	using Helper = CallHelper<void(Class *, void *, CArgs...)>;
	using fptrTy = decltype(fptr);

	struct Static
	{
		static inline void Call(Class *object, void *fptrptr, CArgs... args)
		{
			auto fptr = *reinterpret_cast<fptrTy *>(fptrptr);
			(object->*fptr)(std::forward<CArgs>(args)...);
		}
	};

	Helper::Call(&Static::Call,
	             CastToReactor(object),
	             ConstantData(&fptr, sizeof(fptr)),
	             CastToReactor(std::forward<RArgs>(args))...);
}

// 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)
{
	CallHelper<FUNCTION_SIGNATURE>::Call(fptr, CastToReactor(std::forward<RArgs>(args))...);
}

// Breakpoint emits an instruction that will cause the application to trap.
// This can be used to stop an attached debugger at the given call.
void Breakpoint();

class ForData
{
public:
	ForData(bool init)
	    : loopOnce(init)
	{
	}

	operator bool()
	{
		return loopOnce;
	}

	bool operator=(bool value)
	{
		return loopOnce = value;
	}

	bool setup()
	{
		RR_DEBUG_INFO_FLUSH();
		if(Nucleus::getInsertBlock() != endBB)
		{
			testBB = Nucleus::createBasicBlock();

			Nucleus::createBr(testBB);
			Nucleus::setInsertBlock(testBB);

			return true;
		}

		return false;
	}

	bool test(RValue<Bool> cmp)
	{
		BasicBlock *bodyBB = Nucleus::createBasicBlock();
		endBB = Nucleus::createBasicBlock();

		Nucleus::createCondBr(cmp.value(), bodyBB, endBB);
		Nucleus::setInsertBlock(bodyBB);

		return true;
	}

	void end()
	{
		Nucleus::createBr(testBB);
		Nucleus::setInsertBlock(endBB);
	}

private:
	BasicBlock *testBB = nullptr;
	BasicBlock *endBB = nullptr;
	bool loopOnce = true;
};

class IfElseData
{
public:
	IfElseData(RValue<Bool> cmp)
	    : iteration(0)
	{
		condition = cmp.value();

		beginBB = Nucleus::getInsertBlock();
		trueBB = Nucleus::createBasicBlock();
		falseBB = nullptr;
		endBB = Nucleus::createBasicBlock();

		Nucleus::setInsertBlock(trueBB);
	}

	~IfElseData()
	{
		Nucleus::createBr(endBB);

		Nucleus::setInsertBlock(beginBB);
		Nucleus::createCondBr(condition, trueBB, falseBB ? falseBB : endBB);

		Nucleus::setInsertBlock(endBB);
	}

	operator int()
	{
		return iteration;
	}

	IfElseData &operator++()
	{
		++iteration;

		return *this;
	}

	void elseClause()
	{
		Nucleus::createBr(endBB);

		falseBB = Nucleus::createBasicBlock();
		Nucleus::setInsertBlock(falseBB);
	}

private:
	Value *condition;
	BasicBlock *beginBB;
	BasicBlock *trueBB;
	BasicBlock *falseBB;
	BasicBlock *endBB;
	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 While(cond) For((void)0, cond, (void)0)

#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()

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 Else                           \
	else if(ifElse__ == ELSE_CLAUSE__) \
	{                                  \
		ifElse__.elseClause();         \
	}                                  \
	else  // ELSE_BLOCK__

// The OFFSET macro is a generalization of the offsetof() macro defined in <cstddef>.
// It allows e.g. getting the offset of array elements, even when indexed dynamically.
// We cast the address '32' and subtract it again, because null-dereference is undefined behavior.
#define OFFSET(s, m) ((int)(size_t) & reinterpret_cast<const volatile char &>((((s *)32)->m)) - 32)

}  // namespace rr

#include "Traits.inl"

#endif  // rr_Reactor_hpp