1// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//    http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15#ifndef sw_Reactor_hpp
16#define sw_Reactor_hpp
17
18#include "Nucleus.hpp"
19#include "Routine.hpp"
20
21#include <cassert>
22#include <cstddef>
23#include <cwchar>
24#undef Bool
25
26namespace sw
27{
28	class Bool;
29	class Byte;
30	class SByte;
31	class Byte4;
32	class SByte4;
33	class Byte8;
34	class SByte8;
35	class Byte16;
36	class SByte16;
37	class Short;
38	class UShort;
39	class Short2;
40	class UShort2;
41	class Short4;
42	class UShort4;
43	class Short8;
44	class UShort8;
45	class Int;
46	class UInt;
47	class Int2;
48	class UInt2;
49	class Int4;
50	class UInt4;
51	class Long;
52	class Float;
53	class Float2;
54	class Float4;
55
56	class Void
57	{
58	public:
59		static Type *getType();
60
61		static bool isVoid()
62		{
63			return true;
64		}
65	};
66
67	template<class T>
68	class RValue;
69
70	template<class T>
71	class Pointer;
72
73	class Variable
74	{
75	protected:
76		Value *address;
77	};
78
79	template<class T>
80	class LValue : public Variable
81	{
82	public:
83		LValue(int arraySize = 0);
84
85		RValue<Pointer<T>> operator&();
86
87		static bool isVoid()
88		{
89			return false;
90		}
91
92		Value *loadValue() const;
93		Value *storeValue(Value *value) const;
94		Value *getAddress(Value *index, bool unsignedIndex) const;
95	};
96
97	template<class T>
98	class Reference
99	{
100	public:
101		explicit Reference(Value *pointer, int alignment = 1);
102
103		RValue<T> operator=(RValue<T> rhs) const;
104		RValue<T> operator=(const Reference<T> &ref) const;
105
106		RValue<T> operator+=(RValue<T> rhs) const;
107
108		Value *loadValue() const;
109		int getAlignment() const;
110
111	private:
112		Value *address;
113
114		const int alignment;
115	};
116
117	template<class T>
118	struct IntLiteral
119	{
120		struct type;
121	};
122
123	template<>
124	struct IntLiteral<Bool>
125	{
126		typedef bool type;
127	};
128
129	template<>
130	struct IntLiteral<Int>
131	{
132		typedef int type;
133	};
134
135	template<>
136	struct IntLiteral<UInt>
137	{
138		typedef unsigned int type;
139	};
140
141	template<>
142	struct IntLiteral<Long>
143	{
144		typedef int64_t type;
145	};
146
147	template<class T>
148	struct FloatLiteral
149	{
150		struct type;
151	};
152
153	template<>
154	struct FloatLiteral<Float>
155	{
156		typedef float type;
157	};
158
159	template<class T>
160	class RValue
161	{
162	public:
163		explicit RValue(Value *rvalue);
164
165		RValue(const T &lvalue);
166		RValue(typename IntLiteral<T>::type i);
167		RValue(typename FloatLiteral<T>::type f);
168		RValue(const Reference<T> &rhs);
169
170		RValue<T> &operator=(const RValue<T>&) = delete;
171
172		Value *value;   // FIXME: Make private
173	};
174
175	template<typename T>
176	struct Argument
177	{
178		explicit Argument(Value *value) : value(value) {}
179
180		Value *value;
181	};
182
183	class Bool : public LValue<Bool>
184	{
185	public:
186		Bool(Argument<Bool> argument);
187
188		Bool() = default;
189		Bool(bool x);
190		Bool(RValue<Bool> rhs);
191		Bool(const Bool &rhs);
192		Bool(const Reference<Bool> &rhs);
193
194	//	RValue<Bool> operator=(bool rhs);   // FIXME: Implement
195		RValue<Bool> operator=(RValue<Bool> rhs);
196		RValue<Bool> operator=(const Bool &rhs);
197		RValue<Bool> operator=(const Reference<Bool> &rhs);
198
199		static Type *getType();
200	};
201
202	RValue<Bool> operator!(RValue<Bool> val);
203	RValue<Bool> operator&&(RValue<Bool> lhs, RValue<Bool> rhs);
204	RValue<Bool> operator||(RValue<Bool> lhs, RValue<Bool> rhs);
205
206	class Byte : public LValue<Byte>
207	{
208	public:
209		Byte(Argument<Byte> argument);
210
211		explicit Byte(RValue<Int> cast);
212		explicit Byte(RValue<UInt> cast);
213		explicit Byte(RValue<UShort> cast);
214
215		Byte() = default;
216		Byte(int x);
217		Byte(unsigned char x);
218		Byte(RValue<Byte> rhs);
219		Byte(const Byte &rhs);
220		Byte(const Reference<Byte> &rhs);
221
222	//	RValue<Byte> operator=(unsigned char rhs);   // FIXME: Implement
223		RValue<Byte> operator=(RValue<Byte> rhs);
224		RValue<Byte> operator=(const Byte &rhs);
225		RValue<Byte> operator=(const Reference<Byte> &rhs);
226
227		static Type *getType();
228	};
229
230	RValue<Byte> operator+(RValue<Byte> lhs, RValue<Byte> rhs);
231	RValue<Byte> operator-(RValue<Byte> lhs, RValue<Byte> rhs);
232	RValue<Byte> operator*(RValue<Byte> lhs, RValue<Byte> rhs);
233	RValue<Byte> operator/(RValue<Byte> lhs, RValue<Byte> rhs);
234	RValue<Byte> operator%(RValue<Byte> lhs, RValue<Byte> rhs);
235	RValue<Byte> operator&(RValue<Byte> lhs, RValue<Byte> rhs);
236	RValue<Byte> operator|(RValue<Byte> lhs, RValue<Byte> rhs);
237	RValue<Byte> operator^(RValue<Byte> lhs, RValue<Byte> rhs);
238	RValue<Byte> operator<<(RValue<Byte> lhs, RValue<Byte> rhs);
239	RValue<Byte> operator>>(RValue<Byte> lhs, RValue<Byte> rhs);
240	RValue<Byte> operator+=(Byte &lhs, RValue<Byte> rhs);
241	RValue<Byte> operator-=(Byte &lhs, RValue<Byte> rhs);
242	RValue<Byte> operator*=(Byte &lhs, RValue<Byte> rhs);
243	RValue<Byte> operator/=(Byte &lhs, RValue<Byte> rhs);
244	RValue<Byte> operator%=(Byte &lhs, RValue<Byte> rhs);
245	RValue<Byte> operator&=(Byte &lhs, RValue<Byte> rhs);
246	RValue<Byte> operator|=(Byte &lhs, RValue<Byte> rhs);
247	RValue<Byte> operator^=(Byte &lhs, RValue<Byte> rhs);
248	RValue<Byte> operator<<=(Byte &lhs, RValue<Byte> rhs);
249	RValue<Byte> operator>>=(Byte &lhs, RValue<Byte> rhs);
250	RValue<Byte> operator+(RValue<Byte> val);
251	RValue<Byte> operator-(RValue<Byte> val);
252	RValue<Byte> operator~(RValue<Byte> val);
253	RValue<Byte> operator++(Byte &val, int);   // Post-increment
254	const Byte &operator++(Byte &val);   // Pre-increment
255	RValue<Byte> operator--(Byte &val, int);   // Post-decrement
256	const Byte &operator--(Byte &val);   // Pre-decrement
257	RValue<Bool> operator<(RValue<Byte> lhs, RValue<Byte> rhs);
258	RValue<Bool> operator<=(RValue<Byte> lhs, RValue<Byte> rhs);
259	RValue<Bool> operator>(RValue<Byte> lhs, RValue<Byte> rhs);
260	RValue<Bool> operator>=(RValue<Byte> lhs, RValue<Byte> rhs);
261	RValue<Bool> operator!=(RValue<Byte> lhs, RValue<Byte> rhs);
262	RValue<Bool> operator==(RValue<Byte> lhs, RValue<Byte> rhs);
263
264	class SByte : public LValue<SByte>
265	{
266	public:
267		SByte(Argument<SByte> argument);
268
269		explicit SByte(RValue<Int> cast);
270		explicit SByte(RValue<Short> cast);
271
272		SByte() = default;
273		SByte(signed char x);
274		SByte(RValue<SByte> rhs);
275		SByte(const SByte &rhs);
276		SByte(const Reference<SByte> &rhs);
277
278	//	RValue<SByte> operator=(signed char rhs);   // FIXME: Implement
279		RValue<SByte> operator=(RValue<SByte> rhs);
280		RValue<SByte> operator=(const SByte &rhs);
281		RValue<SByte> operator=(const Reference<SByte> &rhs);
282
283		static Type *getType();
284	};
285
286	RValue<SByte> operator+(RValue<SByte> lhs, RValue<SByte> rhs);
287	RValue<SByte> operator-(RValue<SByte> lhs, RValue<SByte> rhs);
288	RValue<SByte> operator*(RValue<SByte> lhs, RValue<SByte> rhs);
289	RValue<SByte> operator/(RValue<SByte> lhs, RValue<SByte> rhs);
290	RValue<SByte> operator%(RValue<SByte> lhs, RValue<SByte> rhs);
291	RValue<SByte> operator&(RValue<SByte> lhs, RValue<SByte> rhs);
292	RValue<SByte> operator|(RValue<SByte> lhs, RValue<SByte> rhs);
293	RValue<SByte> operator^(RValue<SByte> lhs, RValue<SByte> rhs);
294	RValue<SByte> operator<<(RValue<SByte> lhs, RValue<SByte> rhs);
295	RValue<SByte> operator>>(RValue<SByte> lhs, RValue<SByte> rhs);
296	RValue<SByte> operator+=(SByte &lhs, RValue<SByte> rhs);
297	RValue<SByte> operator-=(SByte &lhs, RValue<SByte> rhs);
298	RValue<SByte> operator*=(SByte &lhs, RValue<SByte> rhs);
299	RValue<SByte> operator/=(SByte &lhs, RValue<SByte> rhs);
300	RValue<SByte> operator%=(SByte &lhs, RValue<SByte> rhs);
301	RValue<SByte> operator&=(SByte &lhs, RValue<SByte> rhs);
302	RValue<SByte> operator|=(SByte &lhs, RValue<SByte> rhs);
303	RValue<SByte> operator^=(SByte &lhs, RValue<SByte> rhs);
304	RValue<SByte> operator<<=(SByte &lhs, RValue<SByte> rhs);
305	RValue<SByte> operator>>=(SByte &lhs, RValue<SByte> rhs);
306	RValue<SByte> operator+(RValue<SByte> val);
307	RValue<SByte> operator-(RValue<SByte> val);
308	RValue<SByte> operator~(RValue<SByte> val);
309	RValue<SByte> operator++(SByte &val, int);   // Post-increment
310	const SByte &operator++(SByte &val);   // Pre-increment
311	RValue<SByte> operator--(SByte &val, int);   // Post-decrement
312	const SByte &operator--(SByte &val);   // Pre-decrement
313	RValue<Bool> operator<(RValue<SByte> lhs, RValue<SByte> rhs);
314	RValue<Bool> operator<=(RValue<SByte> lhs, RValue<SByte> rhs);
315	RValue<Bool> operator>(RValue<SByte> lhs, RValue<SByte> rhs);
316	RValue<Bool> operator>=(RValue<SByte> lhs, RValue<SByte> rhs);
317	RValue<Bool> operator!=(RValue<SByte> lhs, RValue<SByte> rhs);
318	RValue<Bool> operator==(RValue<SByte> lhs, RValue<SByte> rhs);
319
320	class Short : public LValue<Short>
321	{
322	public:
323		Short(Argument<Short> argument);
324
325		explicit Short(RValue<Int> cast);
326
327		Short() = default;
328		Short(short x);
329		Short(RValue<Short> rhs);
330		Short(const Short &rhs);
331		Short(const Reference<Short> &rhs);
332
333	//	RValue<Short> operator=(short rhs);   // FIXME: Implement
334		RValue<Short> operator=(RValue<Short> rhs);
335		RValue<Short> operator=(const Short &rhs);
336		RValue<Short> operator=(const Reference<Short> &rhs);
337
338		static Type *getType();
339	};
340
341	RValue<Short> operator+(RValue<Short> lhs, RValue<Short> rhs);
342	RValue<Short> operator-(RValue<Short> lhs, RValue<Short> rhs);
343	RValue<Short> operator*(RValue<Short> lhs, RValue<Short> rhs);
344	RValue<Short> operator/(RValue<Short> lhs, RValue<Short> rhs);
345	RValue<Short> operator%(RValue<Short> lhs, RValue<Short> rhs);
346	RValue<Short> operator&(RValue<Short> lhs, RValue<Short> rhs);
347	RValue<Short> operator|(RValue<Short> lhs, RValue<Short> rhs);
348	RValue<Short> operator^(RValue<Short> lhs, RValue<Short> rhs);
349	RValue<Short> operator<<(RValue<Short> lhs, RValue<Short> rhs);
350	RValue<Short> operator>>(RValue<Short> lhs, RValue<Short> rhs);
351	RValue<Short> operator+=(Short &lhs, RValue<Short> rhs);
352	RValue<Short> operator-=(Short &lhs, RValue<Short> rhs);
353	RValue<Short> operator*=(Short &lhs, RValue<Short> rhs);
354	RValue<Short> operator/=(Short &lhs, RValue<Short> rhs);
355	RValue<Short> operator%=(Short &lhs, RValue<Short> rhs);
356	RValue<Short> operator&=(Short &lhs, RValue<Short> rhs);
357	RValue<Short> operator|=(Short &lhs, RValue<Short> rhs);
358	RValue<Short> operator^=(Short &lhs, RValue<Short> rhs);
359	RValue<Short> operator<<=(Short &lhs, RValue<Short> rhs);
360	RValue<Short> operator>>=(Short &lhs, RValue<Short> rhs);
361	RValue<Short> operator+(RValue<Short> val);
362	RValue<Short> operator-(RValue<Short> val);
363	RValue<Short> operator~(RValue<Short> val);
364	RValue<Short> operator++(Short &val, int);   // Post-increment
365	const Short &operator++(Short &val);   // Pre-increment
366	RValue<Short> operator--(Short &val, int);   // Post-decrement
367	const Short &operator--(Short &val);   // Pre-decrement
368	RValue<Bool> operator<(RValue<Short> lhs, RValue<Short> rhs);
369	RValue<Bool> operator<=(RValue<Short> lhs, RValue<Short> rhs);
370	RValue<Bool> operator>(RValue<Short> lhs, RValue<Short> rhs);
371	RValue<Bool> operator>=(RValue<Short> lhs, RValue<Short> rhs);
372	RValue<Bool> operator!=(RValue<Short> lhs, RValue<Short> rhs);
373	RValue<Bool> operator==(RValue<Short> lhs, RValue<Short> rhs);
374
375	class UShort : public LValue<UShort>
376	{
377	public:
378		UShort(Argument<UShort> argument);
379
380		explicit UShort(RValue<UInt> cast);
381		explicit UShort(RValue<Int> cast);
382
383		UShort() = default;
384		UShort(unsigned short x);
385		UShort(RValue<UShort> rhs);
386		UShort(const UShort &rhs);
387		UShort(const Reference<UShort> &rhs);
388
389	//	RValue<UShort> operator=(unsigned short rhs);   // FIXME: Implement
390		RValue<UShort> operator=(RValue<UShort> rhs);
391		RValue<UShort> operator=(const UShort &rhs);
392		RValue<UShort> operator=(const Reference<UShort> &rhs);
393
394		static Type *getType();
395	};
396
397	RValue<UShort> operator+(RValue<UShort> lhs, RValue<UShort> rhs);
398	RValue<UShort> operator-(RValue<UShort> lhs, RValue<UShort> rhs);
399	RValue<UShort> operator*(RValue<UShort> lhs, RValue<UShort> rhs);
400	RValue<UShort> operator/(RValue<UShort> lhs, RValue<UShort> rhs);
401	RValue<UShort> operator%(RValue<UShort> lhs, RValue<UShort> rhs);
402	RValue<UShort> operator&(RValue<UShort> lhs, RValue<UShort> rhs);
403	RValue<UShort> operator|(RValue<UShort> lhs, RValue<UShort> rhs);
404	RValue<UShort> operator^(RValue<UShort> lhs, RValue<UShort> rhs);
405	RValue<UShort> operator<<(RValue<UShort> lhs, RValue<UShort> rhs);
406	RValue<UShort> operator>>(RValue<UShort> lhs, RValue<UShort> rhs);
407	RValue<UShort> operator+=(UShort &lhs, RValue<UShort> rhs);
408	RValue<UShort> operator-=(UShort &lhs, RValue<UShort> rhs);
409	RValue<UShort> operator*=(UShort &lhs, RValue<UShort> rhs);
410	RValue<UShort> operator/=(UShort &lhs, RValue<UShort> rhs);
411	RValue<UShort> operator%=(UShort &lhs, RValue<UShort> rhs);
412	RValue<UShort> operator&=(UShort &lhs, RValue<UShort> rhs);
413	RValue<UShort> operator|=(UShort &lhs, RValue<UShort> rhs);
414	RValue<UShort> operator^=(UShort &lhs, RValue<UShort> rhs);
415	RValue<UShort> operator<<=(UShort &lhs, RValue<UShort> rhs);
416	RValue<UShort> operator>>=(UShort &lhs, RValue<UShort> rhs);
417	RValue<UShort> operator+(RValue<UShort> val);
418	RValue<UShort> operator-(RValue<UShort> val);
419	RValue<UShort> operator~(RValue<UShort> val);
420	RValue<UShort> operator++(UShort &val, int);   // Post-increment
421	const UShort &operator++(UShort &val);   // Pre-increment
422	RValue<UShort> operator--(UShort &val, int);   // Post-decrement
423	const UShort &operator--(UShort &val);   // Pre-decrement
424	RValue<Bool> operator<(RValue<UShort> lhs, RValue<UShort> rhs);
425	RValue<Bool> operator<=(RValue<UShort> lhs, RValue<UShort> rhs);
426	RValue<Bool> operator>(RValue<UShort> lhs, RValue<UShort> rhs);
427	RValue<Bool> operator>=(RValue<UShort> lhs, RValue<UShort> rhs);
428	RValue<Bool> operator!=(RValue<UShort> lhs, RValue<UShort> rhs);
429	RValue<Bool> operator==(RValue<UShort> lhs, RValue<UShort> rhs);
430
431	class Byte4 : public LValue<Byte4>
432	{
433	public:
434		explicit Byte4(RValue<Byte8> cast);
435
436		Byte4() = default;
437	//	Byte4(int x, int y, int z, int w);
438	//	Byte4(RValue<Byte4> rhs);
439	//	Byte4(const Byte4 &rhs);
440		Byte4(const Reference<Byte4> &rhs);
441
442	//	RValue<Byte4> operator=(RValue<Byte4> rhs);
443	//	RValue<Byte4> operator=(const Byte4 &rhs);
444	//	RValue<Byte4> operator=(const Reference<Byte4> &rhs);
445
446		static Type *getType();
447	};
448
449//	RValue<Byte4> operator+(RValue<Byte4> lhs, RValue<Byte4> rhs);
450//	RValue<Byte4> operator-(RValue<Byte4> lhs, RValue<Byte4> rhs);
451//	RValue<Byte4> operator*(RValue<Byte4> lhs, RValue<Byte4> rhs);
452//	RValue<Byte4> operator/(RValue<Byte4> lhs, RValue<Byte4> rhs);
453//	RValue<Byte4> operator%(RValue<Byte4> lhs, RValue<Byte4> rhs);
454//	RValue<Byte4> operator&(RValue<Byte4> lhs, RValue<Byte4> rhs);
455//	RValue<Byte4> operator|(RValue<Byte4> lhs, RValue<Byte4> rhs);
456//	RValue<Byte4> operator^(RValue<Byte4> lhs, RValue<Byte4> rhs);
457//	RValue<Byte4> operator<<(RValue<Byte4> lhs, RValue<Byte4> rhs);
458//	RValue<Byte4> operator>>(RValue<Byte4> lhs, RValue<Byte4> rhs);
459//	RValue<Byte4> operator+=(Byte4 &lhs, RValue<Byte4> rhs);
460//	RValue<Byte4> operator-=(Byte4 &lhs, RValue<Byte4> rhs);
461//	RValue<Byte4> operator*=(Byte4 &lhs, RValue<Byte4> rhs);
462//	RValue<Byte4> operator/=(Byte4 &lhs, RValue<Byte4> rhs);
463//	RValue<Byte4> operator%=(Byte4 &lhs, RValue<Byte4> rhs);
464//	RValue<Byte4> operator&=(Byte4 &lhs, RValue<Byte4> rhs);
465//	RValue<Byte4> operator|=(Byte4 &lhs, RValue<Byte4> rhs);
466//	RValue<Byte4> operator^=(Byte4 &lhs, RValue<Byte4> rhs);
467//	RValue<Byte4> operator<<=(Byte4 &lhs, RValue<Byte4> rhs);
468//	RValue<Byte4> operator>>=(Byte4 &lhs, RValue<Byte4> rhs);
469//	RValue<Byte4> operator+(RValue<Byte4> val);
470//	RValue<Byte4> operator-(RValue<Byte4> val);
471//	RValue<Byte4> operator~(RValue<Byte4> val);
472//	RValue<Byte4> operator++(Byte4 &val, int);   // Post-increment
473//	const Byte4 &operator++(Byte4 &val);   // Pre-increment
474//	RValue<Byte4> operator--(Byte4 &val, int);   // Post-decrement
475//	const Byte4 &operator--(Byte4 &val);   // Pre-decrement
476
477	class SByte4 : public LValue<SByte4>
478	{
479	public:
480		SByte4() = default;
481	//	SByte4(int x, int y, int z, int w);
482	//	SByte4(RValue<SByte4> rhs);
483	//	SByte4(const SByte4 &rhs);
484	//	SByte4(const Reference<SByte4> &rhs);
485
486	//	RValue<SByte4> operator=(RValue<SByte4> rhs);
487	//	RValue<SByte4> operator=(const SByte4 &rhs);
488	//	RValue<SByte4> operator=(const Reference<SByte4> &rhs);
489
490		static Type *getType();
491	};
492
493//	RValue<SByte4> operator+(RValue<SByte4> lhs, RValue<SByte4> rhs);
494//	RValue<SByte4> operator-(RValue<SByte4> lhs, RValue<SByte4> rhs);
495//	RValue<SByte4> operator*(RValue<SByte4> lhs, RValue<SByte4> rhs);
496//	RValue<SByte4> operator/(RValue<SByte4> lhs, RValue<SByte4> rhs);
497//	RValue<SByte4> operator%(RValue<SByte4> lhs, RValue<SByte4> rhs);
498//	RValue<SByte4> operator&(RValue<SByte4> lhs, RValue<SByte4> rhs);
499//	RValue<SByte4> operator|(RValue<SByte4> lhs, RValue<SByte4> rhs);
500//	RValue<SByte4> operator^(RValue<SByte4> lhs, RValue<SByte4> rhs);
501//	RValue<SByte4> operator<<(RValue<SByte4> lhs, RValue<SByte4> rhs);
502//	RValue<SByte4> operator>>(RValue<SByte4> lhs, RValue<SByte4> rhs);
503//	RValue<SByte4> operator+=(SByte4 &lhs, RValue<SByte4> rhs);
504//	RValue<SByte4> operator-=(SByte4 &lhs, RValue<SByte4> rhs);
505//	RValue<SByte4> operator*=(SByte4 &lhs, RValue<SByte4> rhs);
506//	RValue<SByte4> operator/=(SByte4 &lhs, RValue<SByte4> rhs);
507//	RValue<SByte4> operator%=(SByte4 &lhs, RValue<SByte4> rhs);
508//	RValue<SByte4> operator&=(SByte4 &lhs, RValue<SByte4> rhs);
509//	RValue<SByte4> operator|=(SByte4 &lhs, RValue<SByte4> rhs);
510//	RValue<SByte4> operator^=(SByte4 &lhs, RValue<SByte4> rhs);
511//	RValue<SByte4> operator<<=(SByte4 &lhs, RValue<SByte4> rhs);
512//	RValue<SByte4> operator>>=(SByte4 &lhs, RValue<SByte4> rhs);
513//	RValue<SByte4> operator+(RValue<SByte4> val);
514//	RValue<SByte4> operator-(RValue<SByte4> val);
515//	RValue<SByte4> operator~(RValue<SByte4> val);
516//	RValue<SByte4> operator++(SByte4 &val, int);   // Post-increment
517//	const SByte4 &operator++(SByte4 &val);   // Pre-increment
518//	RValue<SByte4> operator--(SByte4 &val, int);   // Post-decrement
519//	const SByte4 &operator--(SByte4 &val);   // Pre-decrement
520
521	class Byte8 : public LValue<Byte8>
522	{
523	public:
524		Byte8() = default;
525		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);
526		Byte8(RValue<Byte8> rhs);
527		Byte8(const Byte8 &rhs);
528		Byte8(const Reference<Byte8> &rhs);
529
530		RValue<Byte8> operator=(RValue<Byte8> rhs);
531		RValue<Byte8> operator=(const Byte8 &rhs);
532		RValue<Byte8> operator=(const Reference<Byte8> &rhs);
533
534		static Type *getType();
535	};
536
537	RValue<Byte8> operator+(RValue<Byte8> lhs, RValue<Byte8> rhs);
538	RValue<Byte8> operator-(RValue<Byte8> lhs, RValue<Byte8> rhs);
539//	RValue<Byte8> operator*(RValue<Byte8> lhs, RValue<Byte8> rhs);
540//	RValue<Byte8> operator/(RValue<Byte8> lhs, RValue<Byte8> rhs);
541//	RValue<Byte8> operator%(RValue<Byte8> lhs, RValue<Byte8> rhs);
542	RValue<Byte8> operator&(RValue<Byte8> lhs, RValue<Byte8> rhs);
543	RValue<Byte8> operator|(RValue<Byte8> lhs, RValue<Byte8> rhs);
544	RValue<Byte8> operator^(RValue<Byte8> lhs, RValue<Byte8> rhs);
545//	RValue<Byte8> operator<<(RValue<Byte8> lhs, RValue<Byte8> rhs);
546//	RValue<Byte8> operator>>(RValue<Byte8> lhs, RValue<Byte8> rhs);
547	RValue<Byte8> operator+=(Byte8 &lhs, RValue<Byte8> rhs);
548	RValue<Byte8> operator-=(Byte8 &lhs, RValue<Byte8> rhs);
549//	RValue<Byte8> operator*=(Byte8 &lhs, RValue<Byte8> rhs);
550//	RValue<Byte8> operator/=(Byte8 &lhs, RValue<Byte8> rhs);
551//	RValue<Byte8> operator%=(Byte8 &lhs, RValue<Byte8> rhs);
552	RValue<Byte8> operator&=(Byte8 &lhs, RValue<Byte8> rhs);
553	RValue<Byte8> operator|=(Byte8 &lhs, RValue<Byte8> rhs);
554	RValue<Byte8> operator^=(Byte8 &lhs, RValue<Byte8> rhs);
555//	RValue<Byte8> operator<<=(Byte8 &lhs, RValue<Byte8> rhs);
556//	RValue<Byte8> operator>>=(Byte8 &lhs, RValue<Byte8> rhs);
557//	RValue<Byte8> operator+(RValue<Byte8> val);
558//	RValue<Byte8> operator-(RValue<Byte8> val);
559	RValue<Byte8> operator~(RValue<Byte8> val);
560//	RValue<Byte8> operator++(Byte8 &val, int);   // Post-increment
561//	const Byte8 &operator++(Byte8 &val);   // Pre-increment
562//	RValue<Byte8> operator--(Byte8 &val, int);   // Post-decrement
563//	const Byte8 &operator--(Byte8 &val);   // Pre-decrement
564
565	RValue<Byte8> AddSat(RValue<Byte8> x, RValue<Byte8> y);
566	RValue<Byte8> SubSat(RValue<Byte8> x, RValue<Byte8> y);
567	RValue<Short4> Unpack(RValue<Byte4> x);
568	RValue<Short4> Unpack(RValue<Byte4> x, RValue<Byte4> y);
569	RValue<Short4> UnpackLow(RValue<Byte8> x, RValue<Byte8> y);
570	RValue<Short4> UnpackHigh(RValue<Byte8> x, RValue<Byte8> y);
571	RValue<Int> SignMask(RValue<Byte8> x);
572//	RValue<Byte8> CmpGT(RValue<Byte8> x, RValue<Byte8> y);
573	RValue<Byte8> CmpEQ(RValue<Byte8> x, RValue<Byte8> y);
574
575	class SByte8 : public LValue<SByte8>
576	{
577	public:
578		SByte8() = default;
579		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);
580		SByte8(RValue<SByte8> rhs);
581		SByte8(const SByte8 &rhs);
582		SByte8(const Reference<SByte8> &rhs);
583
584		RValue<SByte8> operator=(RValue<SByte8> rhs);
585		RValue<SByte8> operator=(const SByte8 &rhs);
586		RValue<SByte8> operator=(const Reference<SByte8> &rhs);
587
588		static Type *getType();
589	};
590
591	RValue<SByte8> operator+(RValue<SByte8> lhs, RValue<SByte8> rhs);
592	RValue<SByte8> operator-(RValue<SByte8> lhs, RValue<SByte8> rhs);
593//	RValue<SByte8> operator*(RValue<SByte8> lhs, RValue<SByte8> rhs);
594//	RValue<SByte8> operator/(RValue<SByte8> lhs, RValue<SByte8> rhs);
595//	RValue<SByte8> operator%(RValue<SByte8> lhs, RValue<SByte8> rhs);
596	RValue<SByte8> operator&(RValue<SByte8> lhs, RValue<SByte8> rhs);
597	RValue<SByte8> operator|(RValue<SByte8> lhs, RValue<SByte8> rhs);
598	RValue<SByte8> operator^(RValue<SByte8> lhs, RValue<SByte8> rhs);
599//	RValue<SByte8> operator<<(RValue<SByte8> lhs, RValue<SByte8> rhs);
600//	RValue<SByte8> operator>>(RValue<SByte8> lhs, RValue<SByte8> rhs);
601	RValue<SByte8> operator+=(SByte8 &lhs, RValue<SByte8> rhs);
602	RValue<SByte8> operator-=(SByte8 &lhs, RValue<SByte8> rhs);
603//	RValue<SByte8> operator*=(SByte8 &lhs, RValue<SByte8> rhs);
604//	RValue<SByte8> operator/=(SByte8 &lhs, RValue<SByte8> rhs);
605//	RValue<SByte8> operator%=(SByte8 &lhs, RValue<SByte8> rhs);
606	RValue<SByte8> operator&=(SByte8 &lhs, RValue<SByte8> rhs);
607	RValue<SByte8> operator|=(SByte8 &lhs, RValue<SByte8> rhs);
608	RValue<SByte8> operator^=(SByte8 &lhs, RValue<SByte8> rhs);
609//	RValue<SByte8> operator<<=(SByte8 &lhs, RValue<SByte8> rhs);
610//	RValue<SByte8> operator>>=(SByte8 &lhs, RValue<SByte8> rhs);
611//	RValue<SByte8> operator+(RValue<SByte8> val);
612//	RValue<SByte8> operator-(RValue<SByte8> val);
613	RValue<SByte8> operator~(RValue<SByte8> val);
614//	RValue<SByte8> operator++(SByte8 &val, int);   // Post-increment
615//	const SByte8 &operator++(SByte8 &val);   // Pre-increment
616//	RValue<SByte8> operator--(SByte8 &val, int);   // Post-decrement
617//	const SByte8 &operator--(SByte8 &val);   // Pre-decrement
618
619	RValue<SByte8> AddSat(RValue<SByte8> x, RValue<SByte8> y);
620	RValue<SByte8> SubSat(RValue<SByte8> x, RValue<SByte8> y);
621	RValue<Short4> UnpackLow(RValue<SByte8> x, RValue<SByte8> y);
622	RValue<Short4> UnpackHigh(RValue<SByte8> x, RValue<SByte8> y);
623	RValue<Int> SignMask(RValue<SByte8> x);
624	RValue<Byte8> CmpGT(RValue<SByte8> x, RValue<SByte8> y);
625	RValue<Byte8> CmpEQ(RValue<SByte8> x, RValue<SByte8> y);
626
627	class Byte16 : public LValue<Byte16>
628	{
629	public:
630		Byte16() = default;
631	//	Byte16(int x, int y, int z, int w);
632		Byte16(RValue<Byte16> rhs);
633		Byte16(const Byte16 &rhs);
634		Byte16(const Reference<Byte16> &rhs);
635
636		RValue<Byte16> operator=(RValue<Byte16> rhs);
637		RValue<Byte16> operator=(const Byte16 &rhs);
638		RValue<Byte16> operator=(const Reference<Byte16> &rhs);
639
640		static Type *getType();
641	};
642
643//	RValue<Byte16> operator+(RValue<Byte16> lhs, RValue<Byte16> rhs);
644//	RValue<Byte16> operator-(RValue<Byte16> lhs, RValue<Byte16> rhs);
645//	RValue<Byte16> operator*(RValue<Byte16> lhs, RValue<Byte16> rhs);
646//	RValue<Byte16> operator/(RValue<Byte16> lhs, RValue<Byte16> rhs);
647//	RValue<Byte16> operator%(RValue<Byte16> lhs, RValue<Byte16> rhs);
648//	RValue<Byte16> operator&(RValue<Byte16> lhs, RValue<Byte16> rhs);
649//	RValue<Byte16> operator|(RValue<Byte16> lhs, RValue<Byte16> rhs);
650//	RValue<Byte16> operator^(RValue<Byte16> lhs, RValue<Byte16> rhs);
651//	RValue<Byte16> operator<<(RValue<Byte16> lhs, RValue<Byte16> rhs);
652//	RValue<Byte16> operator>>(RValue<Byte16> lhs, RValue<Byte16> rhs);
653//	RValue<Byte16> operator+=(Byte16 &lhs, RValue<Byte16> rhs);
654//	RValue<Byte16> operator-=(Byte16 &lhs, RValue<Byte16> rhs);
655//	RValue<Byte16> operator*=(Byte16 &lhs, RValue<Byte16> rhs);
656//	RValue<Byte16> operator/=(Byte16 &lhs, RValue<Byte16> rhs);
657//	RValue<Byte16> operator%=(Byte16 &lhs, RValue<Byte16> rhs);
658//	RValue<Byte16> operator&=(Byte16 &lhs, RValue<Byte16> rhs);
659//	RValue<Byte16> operator|=(Byte16 &lhs, RValue<Byte16> rhs);
660//	RValue<Byte16> operator^=(Byte16 &lhs, RValue<Byte16> rhs);
661//	RValue<Byte16> operator<<=(Byte16 &lhs, RValue<Byte16> rhs);
662//	RValue<Byte16> operator>>=(Byte16 &lhs, RValue<Byte16> rhs);
663//	RValue<Byte16> operator+(RValue<Byte16> val);
664//	RValue<Byte16> operator-(RValue<Byte16> val);
665//	RValue<Byte16> operator~(RValue<Byte16> val);
666//	RValue<Byte16> operator++(Byte16 &val, int);   // Post-increment
667//	const Byte16 &operator++(Byte16 &val);   // Pre-increment
668//	RValue<Byte16> operator--(Byte16 &val, int);   // Post-decrement
669//	const Byte16 &operator--(Byte16 &val);   // Pre-decrement
670
671	class SByte16 : public LValue<SByte16>
672	{
673	public:
674		SByte16() = default;
675	//	SByte16(int x, int y, int z, int w);
676	//	SByte16(RValue<SByte16> rhs);
677	//	SByte16(const SByte16 &rhs);
678	//	SByte16(const Reference<SByte16> &rhs);
679
680	//	RValue<SByte16> operator=(RValue<SByte16> rhs);
681	//	RValue<SByte16> operator=(const SByte16 &rhs);
682	//	RValue<SByte16> operator=(const Reference<SByte16> &rhs);
683
684		static Type *getType();
685	};
686
687//	RValue<SByte16> operator+(RValue<SByte16> lhs, RValue<SByte16> rhs);
688//	RValue<SByte16> operator-(RValue<SByte16> lhs, RValue<SByte16> rhs);
689//	RValue<SByte16> operator*(RValue<SByte16> lhs, RValue<SByte16> rhs);
690//	RValue<SByte16> operator/(RValue<SByte16> lhs, RValue<SByte16> rhs);
691//	RValue<SByte16> operator%(RValue<SByte16> lhs, RValue<SByte16> rhs);
692//	RValue<SByte16> operator&(RValue<SByte16> lhs, RValue<SByte16> rhs);
693//	RValue<SByte16> operator|(RValue<SByte16> lhs, RValue<SByte16> rhs);
694//	RValue<SByte16> operator^(RValue<SByte16> lhs, RValue<SByte16> rhs);
695//	RValue<SByte16> operator<<(RValue<SByte16> lhs, RValue<SByte16> rhs);
696//	RValue<SByte16> operator>>(RValue<SByte16> lhs, RValue<SByte16> rhs);
697//	RValue<SByte16> operator+=(SByte16 &lhs, RValue<SByte16> rhs);
698//	RValue<SByte16> operator-=(SByte16 &lhs, RValue<SByte16> rhs);
699//	RValue<SByte16> operator*=(SByte16 &lhs, RValue<SByte16> rhs);
700//	RValue<SByte16> operator/=(SByte16 &lhs, RValue<SByte16> rhs);
701//	RValue<SByte16> operator%=(SByte16 &lhs, RValue<SByte16> rhs);
702//	RValue<SByte16> operator&=(SByte16 &lhs, RValue<SByte16> rhs);
703//	RValue<SByte16> operator|=(SByte16 &lhs, RValue<SByte16> rhs);
704//	RValue<SByte16> operator^=(SByte16 &lhs, RValue<SByte16> rhs);
705//	RValue<SByte16> operator<<=(SByte16 &lhs, RValue<SByte16> rhs);
706//	RValue<SByte16> operator>>=(SByte16 &lhs, RValue<SByte16> rhs);
707//	RValue<SByte16> operator+(RValue<SByte16> val);
708//	RValue<SByte16> operator-(RValue<SByte16> val);
709//	RValue<SByte16> operator~(RValue<SByte16> val);
710//	RValue<SByte16> operator++(SByte16 &val, int);   // Post-increment
711//	const SByte16 &operator++(SByte16 &val);   // Pre-increment
712//	RValue<SByte16> operator--(SByte16 &val, int);   // Post-decrement
713//	const SByte16 &operator--(SByte16 &val);   // Pre-decrement
714
715	class Short2 : public LValue<Short2>
716	{
717	public:
718		explicit Short2(RValue<Short4> cast);
719
720		static Type *getType();
721	};
722
723	class UShort2 : public LValue<UShort2>
724	{
725	public:
726		explicit UShort2(RValue<UShort4> cast);
727
728		static Type *getType();
729	};
730
731	class Short4 : public LValue<Short4>
732	{
733	public:
734		explicit Short4(RValue<Int> cast);
735		explicit Short4(RValue<Int4> cast);
736	//	explicit Short4(RValue<Float> cast);
737		explicit Short4(RValue<Float4> cast);
738
739		Short4() = default;
740		Short4(short xyzw);
741		Short4(short x, short y, short z, short w);
742		Short4(RValue<Short4> rhs);
743		Short4(const Short4 &rhs);
744		Short4(const Reference<Short4> &rhs);
745		Short4(RValue<UShort4> rhs);
746		Short4(const UShort4 &rhs);
747		Short4(const Reference<UShort4> &rhs);
748
749		RValue<Short4> operator=(RValue<Short4> rhs);
750		RValue<Short4> operator=(const Short4 &rhs);
751		RValue<Short4> operator=(const Reference<Short4> &rhs);
752		RValue<Short4> operator=(RValue<UShort4> rhs);
753		RValue<Short4> operator=(const UShort4 &rhs);
754		RValue<Short4> operator=(const Reference<UShort4> &rhs);
755
756		static Type *getType();
757	};
758
759	RValue<Short4> operator+(RValue<Short4> lhs, RValue<Short4> rhs);
760	RValue<Short4> operator-(RValue<Short4> lhs, RValue<Short4> rhs);
761	RValue<Short4> operator*(RValue<Short4> lhs, RValue<Short4> rhs);
762//	RValue<Short4> operator/(RValue<Short4> lhs, RValue<Short4> rhs);
763//	RValue<Short4> operator%(RValue<Short4> lhs, RValue<Short4> rhs);
764	RValue<Short4> operator&(RValue<Short4> lhs, RValue<Short4> rhs);
765	RValue<Short4> operator|(RValue<Short4> lhs, RValue<Short4> rhs);
766	RValue<Short4> operator^(RValue<Short4> lhs, RValue<Short4> rhs);
767	RValue<Short4> operator<<(RValue<Short4> lhs, unsigned char rhs);
768	RValue<Short4> operator>>(RValue<Short4> lhs, unsigned char rhs);
769	RValue<Short4> operator+=(Short4 &lhs, RValue<Short4> rhs);
770	RValue<Short4> operator-=(Short4 &lhs, RValue<Short4> rhs);
771	RValue<Short4> operator*=(Short4 &lhs, RValue<Short4> rhs);
772//	RValue<Short4> operator/=(Short4 &lhs, RValue<Short4> rhs);
773//	RValue<Short4> operator%=(Short4 &lhs, RValue<Short4> rhs);
774	RValue<Short4> operator&=(Short4 &lhs, RValue<Short4> rhs);
775	RValue<Short4> operator|=(Short4 &lhs, RValue<Short4> rhs);
776	RValue<Short4> operator^=(Short4 &lhs, RValue<Short4> rhs);
777	RValue<Short4> operator<<=(Short4 &lhs, unsigned char rhs);
778	RValue<Short4> operator>>=(Short4 &lhs, unsigned char rhs);
779//	RValue<Short4> operator+(RValue<Short4> val);
780	RValue<Short4> operator-(RValue<Short4> val);
781	RValue<Short4> operator~(RValue<Short4> val);
782//	RValue<Short4> operator++(Short4 &val, int);   // Post-increment
783//	const Short4 &operator++(Short4 &val);   // Pre-increment
784//	RValue<Short4> operator--(Short4 &val, int);   // Post-decrement
785//	const Short4 &operator--(Short4 &val);   // Pre-decrement
786//	RValue<Bool> operator<(RValue<Short4> lhs, RValue<Short4> rhs);
787//	RValue<Bool> operator<=(RValue<Short4> lhs, RValue<Short4> rhs);
788//	RValue<Bool> operator>(RValue<Short4> lhs, RValue<Short4> rhs);
789//	RValue<Bool> operator>=(RValue<Short4> lhs, RValue<Short4> rhs);
790//	RValue<Bool> operator!=(RValue<Short4> lhs, RValue<Short4> rhs);
791//	RValue<Bool> operator==(RValue<Short4> lhs, RValue<Short4> rhs);
792
793	RValue<Short4> RoundShort4(RValue<Float4> cast);
794	RValue<Short4> Max(RValue<Short4> x, RValue<Short4> y);
795	RValue<Short4> Min(RValue<Short4> x, RValue<Short4> y);
796	RValue<Short4> AddSat(RValue<Short4> x, RValue<Short4> y);
797	RValue<Short4> SubSat(RValue<Short4> x, RValue<Short4> y);
798	RValue<Short4> MulHigh(RValue<Short4> x, RValue<Short4> y);
799	RValue<Int2> MulAdd(RValue<Short4> x, RValue<Short4> y);
800	RValue<SByte8> Pack(RValue<Short4> x, RValue<Short4> y);
801	RValue<Int2> UnpackLow(RValue<Short4> x, RValue<Short4> y);
802	RValue<Int2> UnpackHigh(RValue<Short4> x, RValue<Short4> y);
803	RValue<Short4> Swizzle(RValue<Short4> x, unsigned char select);
804	RValue<Short4> Insert(RValue<Short4> val, RValue<Short> element, int i);
805	RValue<Short> Extract(RValue<Short4> val, int i);
806	RValue<Short4> CmpGT(RValue<Short4> x, RValue<Short4> y);
807	RValue<Short4> CmpEQ(RValue<Short4> x, RValue<Short4> y);
808
809	class UShort4 : public LValue<UShort4>
810	{
811	public:
812		explicit UShort4(RValue<Int4> cast);
813		explicit UShort4(RValue<Float4> cast, bool saturate = false);
814
815		UShort4() = default;
816		UShort4(unsigned short xyzw);
817		UShort4(unsigned short x, unsigned short y, unsigned short z, unsigned short w);
818		UShort4(RValue<UShort4> rhs);
819		UShort4(const UShort4 &rhs);
820		UShort4(const Reference<UShort4> &rhs);
821		UShort4(RValue<Short4> rhs);
822		UShort4(const Short4 &rhs);
823		UShort4(const Reference<Short4> &rhs);
824
825		RValue<UShort4> operator=(RValue<UShort4> rhs);
826		RValue<UShort4> operator=(const UShort4 &rhs);
827		RValue<UShort4> operator=(const Reference<UShort4> &rhs);
828		RValue<UShort4> operator=(RValue<Short4> rhs);
829		RValue<UShort4> operator=(const Short4 &rhs);
830		RValue<UShort4> operator=(const Reference<Short4> &rhs);
831
832		static Type *getType();
833	};
834
835	RValue<UShort4> operator+(RValue<UShort4> lhs, RValue<UShort4> rhs);
836	RValue<UShort4> operator-(RValue<UShort4> lhs, RValue<UShort4> rhs);
837	RValue<UShort4> operator*(RValue<UShort4> lhs, RValue<UShort4> rhs);
838//	RValue<UShort4> operator/(RValue<UShort4> lhs, RValue<UShort4> rhs);
839//	RValue<UShort4> operator%(RValue<UShort4> lhs, RValue<UShort4> rhs);
840	RValue<UShort4> operator&(RValue<UShort4> lhs, RValue<UShort4> rhs);
841	RValue<UShort4> operator|(RValue<UShort4> lhs, RValue<UShort4> rhs);
842	RValue<UShort4> operator^(RValue<UShort4> lhs, RValue<UShort4> rhs);
843	RValue<UShort4> operator<<(RValue<UShort4> lhs, unsigned char rhs);
844	RValue<UShort4> operator>>(RValue<UShort4> lhs, unsigned char rhs);
845//	RValue<UShort4> operator+=(UShort4 &lhs, RValue<UShort4> rhs);
846//	RValue<UShort4> operator-=(UShort4 &lhs, RValue<UShort4> rhs);
847//	RValue<UShort4> operator*=(UShort4 &lhs, RValue<UShort4> rhs);
848//	RValue<UShort4> operator/=(UShort4 &lhs, RValue<UShort4> rhs);
849//	RValue<UShort4> operator%=(UShort4 &lhs, RValue<UShort4> rhs);
850//	RValue<UShort4> operator&=(UShort4 &lhs, RValue<UShort4> rhs);
851//	RValue<UShort4> operator|=(UShort4 &lhs, RValue<UShort4> rhs);
852//	RValue<UShort4> operator^=(UShort4 &lhs, RValue<UShort4> rhs);
853	RValue<UShort4> operator<<=(UShort4 &lhs, unsigned char rhs);
854	RValue<UShort4> operator>>=(UShort4 &lhs, unsigned char rhs);
855//	RValue<UShort4> operator+(RValue<UShort4> val);
856//	RValue<UShort4> operator-(RValue<UShort4> val);
857	RValue<UShort4> operator~(RValue<UShort4> val);
858//	RValue<UShort4> operator++(UShort4 &val, int);   // Post-increment
859//	const UShort4 &operator++(UShort4 &val);   // Pre-increment
860//	RValue<UShort4> operator--(UShort4 &val, int);   // Post-decrement
861//	const UShort4 &operator--(UShort4 &val);   // Pre-decrement
862
863	RValue<UShort4> Max(RValue<UShort4> x, RValue<UShort4> y);
864	RValue<UShort4> Min(RValue<UShort4> x, RValue<UShort4> y);
865	RValue<UShort4> AddSat(RValue<UShort4> x, RValue<UShort4> y);
866	RValue<UShort4> SubSat(RValue<UShort4> x, RValue<UShort4> y);
867	RValue<UShort4> MulHigh(RValue<UShort4> x, RValue<UShort4> y);
868	RValue<UShort4> Average(RValue<UShort4> x, RValue<UShort4> y);
869	RValue<Byte8> Pack(RValue<UShort4> x, RValue<UShort4> y);
870
871	class Short8 : public LValue<Short8>
872	{
873	public:
874		Short8() = default;
875		Short8(short c);
876		Short8(short c0, short c1, short c2, short c3, short c4, short c5, short c6, short c7);
877		Short8(RValue<Short8> rhs);
878	//	Short8(const Short8 &rhs);
879		Short8(const Reference<Short8> &rhs);
880		Short8(RValue<Short4> lo, RValue<Short4> hi);
881
882	//	RValue<Short8> operator=(RValue<Short8> rhs);
883	//	RValue<Short8> operator=(const Short8 &rhs);
884	//	RValue<Short8> operator=(const Reference<Short8> &rhs);
885
886		static Type *getType();
887	};
888
889	RValue<Short8> operator+(RValue<Short8> lhs, RValue<Short8> rhs);
890//	RValue<Short8> operator-(RValue<Short8> lhs, RValue<Short8> rhs);
891//	RValue<Short8> operator*(RValue<Short8> lhs, RValue<Short8> rhs);
892//	RValue<Short8> operator/(RValue<Short8> lhs, RValue<Short8> rhs);
893//	RValue<Short8> operator%(RValue<Short8> lhs, RValue<Short8> rhs);
894	RValue<Short8> operator&(RValue<Short8> lhs, RValue<Short8> rhs);
895//	RValue<Short8> operator|(RValue<Short8> lhs, RValue<Short8> rhs);
896//	RValue<Short8> operator^(RValue<Short8> lhs, RValue<Short8> rhs);
897	RValue<Short8> operator<<(RValue<Short8> lhs, unsigned char rhs);
898	RValue<Short8> operator>>(RValue<Short8> lhs, unsigned char rhs);
899//	RValue<Short8> operator<<(RValue<Short8> lhs, RValue<Short8> rhs);
900//	RValue<Short8> operator>>(RValue<Short8> lhs, RValue<Short8> rhs);
901//	RValue<Short8> operator+=(Short8 &lhs, RValue<Short8> rhs);
902//	RValue<Short8> operator-=(Short8 &lhs, RValue<Short8> rhs);
903//	RValue<Short8> operator*=(Short8 &lhs, RValue<Short8> rhs);
904//	RValue<Short8> operator/=(Short8 &lhs, RValue<Short8> rhs);
905//	RValue<Short8> operator%=(Short8 &lhs, RValue<Short8> rhs);
906//	RValue<Short8> operator&=(Short8 &lhs, RValue<Short8> rhs);
907//	RValue<Short8> operator|=(Short8 &lhs, RValue<Short8> rhs);
908//	RValue<Short8> operator^=(Short8 &lhs, RValue<Short8> rhs);
909//	RValue<Short8> operator<<=(Short8 &lhs, RValue<Short8> rhs);
910//	RValue<Short8> operator>>=(Short8 &lhs, RValue<Short8> rhs);
911//	RValue<Short8> operator+(RValue<Short8> val);
912//	RValue<Short8> operator-(RValue<Short8> val);
913//	RValue<Short8> operator~(RValue<Short8> val);
914//	RValue<Short8> operator++(Short8 &val, int);   // Post-increment
915//	const Short8 &operator++(Short8 &val);   // Pre-increment
916//	RValue<Short8> operator--(Short8 &val, int);   // Post-decrement
917//	const Short8 &operator--(Short8 &val);   // Pre-decrement
918//	RValue<Bool> operator<(RValue<Short8> lhs, RValue<Short8> rhs);
919//	RValue<Bool> operator<=(RValue<Short8> lhs, RValue<Short8> rhs);
920//	RValue<Bool> operator>(RValue<Short8> lhs, RValue<Short8> rhs);
921//	RValue<Bool> operator>=(RValue<Short8> lhs, RValue<Short8> rhs);
922//	RValue<Bool> operator!=(RValue<Short8> lhs, RValue<Short8> rhs);
923//	RValue<Bool> operator==(RValue<Short8> lhs, RValue<Short8> rhs);
924
925	RValue<Short8> MulHigh(RValue<Short8> x, RValue<Short8> y);
926	RValue<Int4> MulAdd(RValue<Short8> x, RValue<Short8> y);
927	RValue<Int4> Abs(RValue<Int4> x);
928
929	class UShort8 : public LValue<UShort8>
930	{
931	public:
932		UShort8() = default;
933		UShort8(unsigned short c);
934		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);
935		UShort8(RValue<UShort8> rhs);
936	//	UShort8(const UShort8 &rhs);
937		UShort8(const Reference<UShort8> &rhs);
938		UShort8(RValue<UShort4> lo, RValue<UShort4> hi);
939
940		RValue<UShort8> operator=(RValue<UShort8> rhs);
941		RValue<UShort8> operator=(const UShort8 &rhs);
942		RValue<UShort8> operator=(const Reference<UShort8> &rhs);
943
944		static Type *getType();
945	};
946
947	RValue<UShort8> operator+(RValue<UShort8> lhs, RValue<UShort8> rhs);
948//	RValue<UShort8> operator-(RValue<UShort8> lhs, RValue<UShort8> rhs);
949	RValue<UShort8> operator*(RValue<UShort8> lhs, RValue<UShort8> rhs);
950//	RValue<UShort8> operator/(RValue<UShort8> lhs, RValue<UShort8> rhs);
951//	RValue<UShort8> operator%(RValue<UShort8> lhs, RValue<UShort8> rhs);
952	RValue<UShort8> operator&(RValue<UShort8> lhs, RValue<UShort8> rhs);
953//	RValue<UShort8> operator|(RValue<UShort8> lhs, RValue<UShort8> rhs);
954//	RValue<UShort8> operator^(RValue<UShort8> lhs, RValue<UShort8> rhs);
955	RValue<UShort8> operator<<(RValue<UShort8> lhs, unsigned char rhs);
956	RValue<UShort8> operator>>(RValue<UShort8> lhs, unsigned char rhs);
957//	RValue<UShort8> operator<<(RValue<UShort8> lhs, RValue<UShort8> rhs);
958//	RValue<UShort8> operator>>(RValue<UShort8> lhs, RValue<UShort8> rhs);
959	RValue<UShort8> operator+=(UShort8 &lhs, RValue<UShort8> rhs);
960//	RValue<UShort8> operator-=(UShort8 &lhs, RValue<UShort8> rhs);
961//	RValue<UShort8> operator*=(UShort8 &lhs, RValue<UShort8> rhs);
962//	RValue<UShort8> operator/=(UShort8 &lhs, RValue<UShort8> rhs);
963//	RValue<UShort8> operator%=(UShort8 &lhs, RValue<UShort8> rhs);
964//	RValue<UShort8> operator&=(UShort8 &lhs, RValue<UShort8> rhs);
965//	RValue<UShort8> operator|=(UShort8 &lhs, RValue<UShort8> rhs);
966//	RValue<UShort8> operator^=(UShort8 &lhs, RValue<UShort8> rhs);
967//	RValue<UShort8> operator<<=(UShort8 &lhs, RValue<UShort8> rhs);
968//	RValue<UShort8> operator>>=(UShort8 &lhs, RValue<UShort8> rhs);
969//	RValue<UShort8> operator+(RValue<UShort8> val);
970//	RValue<UShort8> operator-(RValue<UShort8> val);
971	RValue<UShort8> operator~(RValue<UShort8> val);
972//	RValue<UShort8> operator++(UShort8 &val, int);   // Post-increment
973//	const UShort8 &operator++(UShort8 &val);   // Pre-increment
974//	RValue<UShort8> operator--(UShort8 &val, int);   // Post-decrement
975//	const UShort8 &operator--(UShort8 &val);   // Pre-decrement
976//	RValue<Bool> operator<(RValue<UShort8> lhs, RValue<UShort8> rhs);
977//	RValue<Bool> operator<=(RValue<UShort8> lhs, RValue<UShort8> rhs);
978//	RValue<Bool> operator>(RValue<UShort8> lhs, RValue<UShort8> rhs);
979//	RValue<Bool> operator>=(RValue<UShort8> lhs, RValue<UShort8> rhs);
980//	RValue<Bool> operator!=(RValue<UShort8> lhs, RValue<UShort8> rhs);
981//	RValue<Bool> operator==(RValue<UShort8> lhs, RValue<UShort8> rhs);
982
983	RValue<UShort8> Swizzle(RValue<UShort8> x, char select0, char select1, char select2, char select3, char select4, char select5, char select6, char select7);
984	RValue<UShort8> MulHigh(RValue<UShort8> x, RValue<UShort8> y);
985
986	class Int : public LValue<Int>
987	{
988	public:
989		Int(Argument<Int> argument);
990
991		explicit Int(RValue<Byte> cast);
992		explicit Int(RValue<SByte> cast);
993		explicit Int(RValue<Short> cast);
994		explicit Int(RValue<UShort> cast);
995		explicit Int(RValue<Int2> cast);
996		explicit Int(RValue<Long> cast);
997		explicit Int(RValue<Float> cast);
998
999		Int() = default;
1000		Int(int x);
1001		Int(RValue<Int> rhs);
1002		Int(RValue<UInt> rhs);
1003		Int(const Int &rhs);
1004		Int(const UInt &rhs);
1005		Int(const Reference<Int> &rhs);
1006		Int(const Reference<UInt> &rhs);
1007
1008		RValue<Int> operator=(int rhs);
1009		RValue<Int> operator=(RValue<Int> rhs);
1010		RValue<Int> operator=(RValue<UInt> rhs);
1011		RValue<Int> operator=(const Int &rhs);
1012		RValue<Int> operator=(const UInt &rhs);
1013		RValue<Int> operator=(const Reference<Int> &rhs);
1014		RValue<Int> operator=(const Reference<UInt> &rhs);
1015
1016		static Type *getType();
1017	};
1018
1019	RValue<Int> operator+(RValue<Int> lhs, RValue<Int> rhs);
1020	RValue<Int> operator-(RValue<Int> lhs, RValue<Int> rhs);
1021	RValue<Int> operator*(RValue<Int> lhs, RValue<Int> rhs);
1022	RValue<Int> operator/(RValue<Int> lhs, RValue<Int> rhs);
1023	RValue<Int> operator%(RValue<Int> lhs, RValue<Int> rhs);
1024	RValue<Int> operator&(RValue<Int> lhs, RValue<Int> rhs);
1025	RValue<Int> operator|(RValue<Int> lhs, RValue<Int> rhs);
1026	RValue<Int> operator^(RValue<Int> lhs, RValue<Int> rhs);
1027	RValue<Int> operator<<(RValue<Int> lhs, RValue<Int> rhs);
1028	RValue<Int> operator>>(RValue<Int> lhs, RValue<Int> rhs);
1029	RValue<Int> operator+=(Int &lhs, RValue<Int> rhs);
1030	RValue<Int> operator-=(Int &lhs, RValue<Int> rhs);
1031	RValue<Int> operator*=(Int &lhs, RValue<Int> rhs);
1032	RValue<Int> operator/=(Int &lhs, RValue<Int> rhs);
1033	RValue<Int> operator%=(Int &lhs, RValue<Int> rhs);
1034	RValue<Int> operator&=(Int &lhs, RValue<Int> rhs);
1035	RValue<Int> operator|=(Int &lhs, RValue<Int> rhs);
1036	RValue<Int> operator^=(Int &lhs, RValue<Int> rhs);
1037	RValue<Int> operator<<=(Int &lhs, RValue<Int> rhs);
1038	RValue<Int> operator>>=(Int &lhs, RValue<Int> rhs);
1039	RValue<Int> operator+(RValue<Int> val);
1040	RValue<Int> operator-(RValue<Int> val);
1041	RValue<Int> operator~(RValue<Int> val);
1042	RValue<Int> operator++(Int &val, int);   // Post-increment
1043	const Int &operator++(Int &val);   // Pre-increment
1044	RValue<Int> operator--(Int &val, int);   // Post-decrement
1045	const Int &operator--(Int &val);   // Pre-decrement
1046	RValue<Bool> operator<(RValue<Int> lhs, RValue<Int> rhs);
1047	RValue<Bool> operator<=(RValue<Int> lhs, RValue<Int> rhs);
1048	RValue<Bool> operator>(RValue<Int> lhs, RValue<Int> rhs);
1049	RValue<Bool> operator>=(RValue<Int> lhs, RValue<Int> rhs);
1050	RValue<Bool> operator!=(RValue<Int> lhs, RValue<Int> rhs);
1051	RValue<Bool> operator==(RValue<Int> lhs, RValue<Int> rhs);
1052
1053	RValue<Int> Max(RValue<Int> x, RValue<Int> y);
1054	RValue<Int> Min(RValue<Int> x, RValue<Int> y);
1055	RValue<Int> Clamp(RValue<Int> x, RValue<Int> min, RValue<Int> max);
1056	RValue<Int> RoundInt(RValue<Float> cast);
1057
1058	class Long : public LValue<Long>
1059	{
1060	public:
1061	//	Long(Argument<Long> argument);
1062
1063	//	explicit Long(RValue<Short> cast);
1064	//	explicit Long(RValue<UShort> cast);
1065		explicit Long(RValue<Int> cast);
1066		explicit Long(RValue<UInt> cast);
1067	//	explicit Long(RValue<Float> cast);
1068
1069		Long() = default;
1070	//	Long(qword x);
1071		Long(RValue<Long> rhs);
1072	//	Long(RValue<ULong> rhs);
1073	//	Long(const Long &rhs);
1074	//	Long(const Reference<Long> &rhs);
1075	//	Long(const ULong &rhs);
1076	//	Long(const Reference<ULong> &rhs);
1077
1078		RValue<Long> operator=(int64_t rhs);
1079		RValue<Long> operator=(RValue<Long> rhs);
1080	//	RValue<Long> operator=(RValue<ULong> rhs);
1081		RValue<Long> operator=(const Long &rhs);
1082		RValue<Long> operator=(const Reference<Long> &rhs);
1083	//	RValue<Long> operator=(const ULong &rhs);
1084	//	RValue<Long> operator=(const Reference<ULong> &rhs);
1085
1086		static Type *getType();
1087	};
1088
1089	RValue<Long> operator+(RValue<Long> lhs, RValue<Long> rhs);
1090	RValue<Long> operator-(RValue<Long> lhs, RValue<Long> rhs);
1091//	RValue<Long> operator*(RValue<Long> lhs, RValue<Long> rhs);
1092//	RValue<Long> operator/(RValue<Long> lhs, RValue<Long> rhs);
1093//	RValue<Long> operator%(RValue<Long> lhs, RValue<Long> rhs);
1094//	RValue<Long> operator&(RValue<Long> lhs, RValue<Long> rhs);
1095//	RValue<Long> operator|(RValue<Long> lhs, RValue<Long> rhs);
1096//	RValue<Long> operator^(RValue<Long> lhs, RValue<Long> rhs);
1097//	RValue<Long> operator<<(RValue<Long> lhs, RValue<Long> rhs);
1098//	RValue<Long> operator>>(RValue<Long> lhs, RValue<Long> rhs);
1099	RValue<Long> operator+=(Long &lhs, RValue<Long> rhs);
1100	RValue<Long> operator-=(Long &lhs, RValue<Long> rhs);
1101//	RValue<Long> operator*=(Long &lhs, RValue<Long> rhs);
1102//	RValue<Long> operator/=(Long &lhs, RValue<Long> rhs);
1103//	RValue<Long> operator%=(Long &lhs, RValue<Long> rhs);
1104//	RValue<Long> operator&=(Long &lhs, RValue<Long> rhs);
1105//	RValue<Long> operator|=(Long &lhs, RValue<Long> rhs);
1106//	RValue<Long> operator^=(Long &lhs, RValue<Long> rhs);
1107//	RValue<Long> operator<<=(Long &lhs, RValue<Long> rhs);
1108//	RValue<Long> operator>>=(Long &lhs, RValue<Long> rhs);
1109//	RValue<Long> operator+(RValue<Long> val);
1110//	RValue<Long> operator-(RValue<Long> val);
1111//	RValue<Long> operator~(RValue<Long> val);
1112//	RValue<Long> operator++(Long &val, int);   // Post-increment
1113//	const Long &operator++(Long &val);   // Pre-increment
1114//	RValue<Long> operator--(Long &val, int);   // Post-decrement
1115//	const Long &operator--(Long &val);   // Pre-decrement
1116//	RValue<Bool> operator<(RValue<Long> lhs, RValue<Long> rhs);
1117//	RValue<Bool> operator<=(RValue<Long> lhs, RValue<Long> rhs);
1118//	RValue<Bool> operator>(RValue<Long> lhs, RValue<Long> rhs);
1119//	RValue<Bool> operator>=(RValue<Long> lhs, RValue<Long> rhs);
1120//	RValue<Bool> operator!=(RValue<Long> lhs, RValue<Long> rhs);
1121//	RValue<Bool> operator==(RValue<Long> lhs, RValue<Long> rhs);
1122
1123//	RValue<Long> RoundLong(RValue<Float> cast);
1124	RValue<Long> AddAtomic( RValue<Pointer<Long>> x, RValue<Long> y);
1125
1126	class UInt : public LValue<UInt>
1127	{
1128	public:
1129		UInt(Argument<UInt> argument);
1130
1131		explicit UInt(RValue<UShort> cast);
1132		explicit UInt(RValue<Long> cast);
1133		explicit UInt(RValue<Float> cast);
1134
1135		UInt() = default;
1136		UInt(int x);
1137		UInt(unsigned int x);
1138		UInt(RValue<UInt> rhs);
1139		UInt(RValue<Int> rhs);
1140		UInt(const UInt &rhs);
1141		UInt(const Int &rhs);
1142		UInt(const Reference<UInt> &rhs);
1143		UInt(const Reference<Int> &rhs);
1144
1145		RValue<UInt> operator=(unsigned int rhs);
1146		RValue<UInt> operator=(RValue<UInt> rhs);
1147		RValue<UInt> operator=(RValue<Int> rhs);
1148		RValue<UInt> operator=(const UInt &rhs);
1149		RValue<UInt> operator=(const Int &rhs);
1150		RValue<UInt> operator=(const Reference<UInt> &rhs);
1151		RValue<UInt> operator=(const Reference<Int> &rhs);
1152
1153		static Type *getType();
1154	};
1155
1156	RValue<UInt> operator+(RValue<UInt> lhs, RValue<UInt> rhs);
1157	RValue<UInt> operator-(RValue<UInt> lhs, RValue<UInt> rhs);
1158	RValue<UInt> operator*(RValue<UInt> lhs, RValue<UInt> rhs);
1159	RValue<UInt> operator/(RValue<UInt> lhs, RValue<UInt> rhs);
1160	RValue<UInt> operator%(RValue<UInt> lhs, RValue<UInt> rhs);
1161	RValue<UInt> operator&(RValue<UInt> lhs, RValue<UInt> rhs);
1162	RValue<UInt> operator|(RValue<UInt> lhs, RValue<UInt> rhs);
1163	RValue<UInt> operator^(RValue<UInt> lhs, RValue<UInt> rhs);
1164	RValue<UInt> operator<<(RValue<UInt> lhs, RValue<UInt> rhs);
1165	RValue<UInt> operator>>(RValue<UInt> lhs, RValue<UInt> rhs);
1166	RValue<UInt> operator+=(UInt &lhs, RValue<UInt> rhs);
1167	RValue<UInt> operator-=(UInt &lhs, RValue<UInt> rhs);
1168	RValue<UInt> operator*=(UInt &lhs, RValue<UInt> rhs);
1169	RValue<UInt> operator/=(UInt &lhs, RValue<UInt> rhs);
1170	RValue<UInt> operator%=(UInt &lhs, RValue<UInt> rhs);
1171	RValue<UInt> operator&=(UInt &lhs, RValue<UInt> rhs);
1172	RValue<UInt> operator|=(UInt &lhs, RValue<UInt> rhs);
1173	RValue<UInt> operator^=(UInt &lhs, RValue<UInt> rhs);
1174	RValue<UInt> operator<<=(UInt &lhs, RValue<UInt> rhs);
1175	RValue<UInt> operator>>=(UInt &lhs, RValue<UInt> rhs);
1176	RValue<UInt> operator+(RValue<UInt> val);
1177	RValue<UInt> operator-(RValue<UInt> val);
1178	RValue<UInt> operator~(RValue<UInt> val);
1179	RValue<UInt> operator++(UInt &val, int);   // Post-increment
1180	const UInt &operator++(UInt &val);   // Pre-increment
1181	RValue<UInt> operator--(UInt &val, int);   // Post-decrement
1182	const UInt &operator--(UInt &val);   // Pre-decrement
1183	RValue<Bool> operator<(RValue<UInt> lhs, RValue<UInt> rhs);
1184	RValue<Bool> operator<=(RValue<UInt> lhs, RValue<UInt> rhs);
1185	RValue<Bool> operator>(RValue<UInt> lhs, RValue<UInt> rhs);
1186	RValue<Bool> operator>=(RValue<UInt> lhs, RValue<UInt> rhs);
1187	RValue<Bool> operator!=(RValue<UInt> lhs, RValue<UInt> rhs);
1188	RValue<Bool> operator==(RValue<UInt> lhs, RValue<UInt> rhs);
1189
1190	RValue<UInt> Max(RValue<UInt> x, RValue<UInt> y);
1191	RValue<UInt> Min(RValue<UInt> x, RValue<UInt> y);
1192	RValue<UInt> Clamp(RValue<UInt> x, RValue<UInt> min, RValue<UInt> max);
1193//	RValue<UInt> RoundUInt(RValue<Float> cast);
1194
1195	class Int2 : public LValue<Int2>
1196	{
1197	public:
1198	//	explicit Int2(RValue<Int> cast);
1199		explicit Int2(RValue<Int4> cast);
1200
1201		Int2() = default;
1202		Int2(int x, int y);
1203		Int2(RValue<Int2> rhs);
1204		Int2(const Int2 &rhs);
1205		Int2(const Reference<Int2> &rhs);
1206		Int2(RValue<Int> lo, RValue<Int> hi);
1207
1208		RValue<Int2> operator=(RValue<Int2> rhs);
1209		RValue<Int2> operator=(const Int2 &rhs);
1210		RValue<Int2> operator=(const Reference<Int2> &rhs);
1211
1212		static Type *getType();
1213	};
1214
1215	RValue<Int2> operator+(RValue<Int2> lhs, RValue<Int2> rhs);
1216	RValue<Int2> operator-(RValue<Int2> lhs, RValue<Int2> rhs);
1217//	RValue<Int2> operator*(RValue<Int2> lhs, RValue<Int2> rhs);
1218//	RValue<Int2> operator/(RValue<Int2> lhs, RValue<Int2> rhs);
1219//	RValue<Int2> operator%(RValue<Int2> lhs, RValue<Int2> rhs);
1220	RValue<Int2> operator&(RValue<Int2> lhs, RValue<Int2> rhs);
1221	RValue<Int2> operator|(RValue<Int2> lhs, RValue<Int2> rhs);
1222	RValue<Int2> operator^(RValue<Int2> lhs, RValue<Int2> rhs);
1223	RValue<Int2> operator<<(RValue<Int2> lhs, unsigned char rhs);
1224	RValue<Int2> operator>>(RValue<Int2> lhs, unsigned char rhs);
1225	RValue<Int2> operator+=(Int2 &lhs, RValue<Int2> rhs);
1226	RValue<Int2> operator-=(Int2 &lhs, RValue<Int2> rhs);
1227//	RValue<Int2> operator*=(Int2 &lhs, RValue<Int2> rhs);
1228//	RValue<Int2> operator/=(Int2 &lhs, RValue<Int2> rhs);
1229//	RValue<Int2> operator%=(Int2 &lhs, RValue<Int2> rhs);
1230	RValue<Int2> operator&=(Int2 &lhs, RValue<Int2> rhs);
1231	RValue<Int2> operator|=(Int2 &lhs, RValue<Int2> rhs);
1232	RValue<Int2> operator^=(Int2 &lhs, RValue<Int2> rhs);
1233	RValue<Int2> operator<<=(Int2 &lhs, unsigned char rhs);
1234	RValue<Int2> operator>>=(Int2 &lhs, unsigned char rhs);
1235//	RValue<Int2> operator+(RValue<Int2> val);
1236//	RValue<Int2> operator-(RValue<Int2> val);
1237	RValue<Int2> operator~(RValue<Int2> val);
1238//	RValue<Int2> operator++(Int2 &val, int);   // Post-increment
1239//	const Int2 &operator++(Int2 &val);   // Pre-increment
1240//	RValue<Int2> operator--(Int2 &val, int);   // Post-decrement
1241//	const Int2 &operator--(Int2 &val);   // Pre-decrement
1242//	RValue<Bool> operator<(RValue<Int2> lhs, RValue<Int2> rhs);
1243//	RValue<Bool> operator<=(RValue<Int2> lhs, RValue<Int2> rhs);
1244//	RValue<Bool> operator>(RValue<Int2> lhs, RValue<Int2> rhs);
1245//	RValue<Bool> operator>=(RValue<Int2> lhs, RValue<Int2> rhs);
1246//	RValue<Bool> operator!=(RValue<Int2> lhs, RValue<Int2> rhs);
1247//	RValue<Bool> operator==(RValue<Int2> lhs, RValue<Int2> rhs);
1248
1249//	RValue<Int2> RoundInt(RValue<Float4> cast);
1250	RValue<Short4> UnpackLow(RValue<Int2> x, RValue<Int2> y);
1251	RValue<Short4> UnpackHigh(RValue<Int2> x, RValue<Int2> y);
1252	RValue<Int> Extract(RValue<Int2> val, int i);
1253	RValue<Int2> Insert(RValue<Int2> val, RValue<Int> element, int i);
1254
1255	class UInt2 : public LValue<UInt2>
1256	{
1257	public:
1258		UInt2() = default;
1259		UInt2(unsigned int x, unsigned int y);
1260		UInt2(RValue<UInt2> rhs);
1261		UInt2(const UInt2 &rhs);
1262		UInt2(const Reference<UInt2> &rhs);
1263
1264		RValue<UInt2> operator=(RValue<UInt2> rhs);
1265		RValue<UInt2> operator=(const UInt2 &rhs);
1266		RValue<UInt2> operator=(const Reference<UInt2> &rhs);
1267
1268		static Type *getType();
1269	};
1270
1271	RValue<UInt2> operator+(RValue<UInt2> lhs, RValue<UInt2> rhs);
1272	RValue<UInt2> operator-(RValue<UInt2> lhs, RValue<UInt2> rhs);
1273//	RValue<UInt2> operator*(RValue<UInt2> lhs, RValue<UInt2> rhs);
1274//	RValue<UInt2> operator/(RValue<UInt2> lhs, RValue<UInt2> rhs);
1275//	RValue<UInt2> operator%(RValue<UInt2> lhs, RValue<UInt2> rhs);
1276	RValue<UInt2> operator&(RValue<UInt2> lhs, RValue<UInt2> rhs);
1277	RValue<UInt2> operator|(RValue<UInt2> lhs, RValue<UInt2> rhs);
1278	RValue<UInt2> operator^(RValue<UInt2> lhs, RValue<UInt2> rhs);
1279	RValue<UInt2> operator<<(RValue<UInt2> lhs, unsigned char rhs);
1280	RValue<UInt2> operator>>(RValue<UInt2> lhs, unsigned char rhs);
1281	RValue<UInt2> operator+=(UInt2 &lhs, RValue<UInt2> rhs);
1282	RValue<UInt2> operator-=(UInt2 &lhs, RValue<UInt2> rhs);
1283//	RValue<UInt2> operator*=(UInt2 &lhs, RValue<UInt2> rhs);
1284//	RValue<UInt2> operator/=(UInt2 &lhs, RValue<UInt2> rhs);
1285//	RValue<UInt2> operator%=(UInt2 &lhs, RValue<UInt2> rhs);
1286	RValue<UInt2> operator&=(UInt2 &lhs, RValue<UInt2> rhs);
1287	RValue<UInt2> operator|=(UInt2 &lhs, RValue<UInt2> rhs);
1288	RValue<UInt2> operator^=(UInt2 &lhs, RValue<UInt2> rhs);
1289	RValue<UInt2> operator<<=(UInt2 &lhs, unsigned char rhs);
1290	RValue<UInt2> operator>>=(UInt2 &lhs, unsigned char rhs);
1291//	RValue<UInt2> operator+(RValue<UInt2> val);
1292//	RValue<UInt2> operator-(RValue<UInt2> val);
1293	RValue<UInt2> operator~(RValue<UInt2> val);
1294//	RValue<UInt2> operator++(UInt2 &val, int);   // Post-increment
1295//	const UInt2 &operator++(UInt2 &val);   // Pre-increment
1296//	RValue<UInt2> operator--(UInt2 &val, int);   // Post-decrement
1297//	const UInt2 &operator--(UInt2 &val);   // Pre-decrement
1298//	RValue<Bool> operator<(RValue<UInt2> lhs, RValue<UInt2> rhs);
1299//	RValue<Bool> operator<=(RValue<UInt2> lhs, RValue<UInt2> rhs);
1300//	RValue<Bool> operator>(RValue<UInt2> lhs, RValue<UInt2> rhs);
1301//	RValue<Bool> operator>=(RValue<UInt2> lhs, RValue<UInt2> rhs);
1302//	RValue<Bool> operator!=(RValue<UInt2> lhs, RValue<UInt2> rhs);
1303//	RValue<Bool> operator==(RValue<UInt2> lhs, RValue<UInt2> rhs);
1304
1305//	RValue<UInt2> RoundInt(RValue<Float4> cast);
1306
1307	template<class T>
1308	struct Scalar;
1309
1310	template<class Vector4>
1311	struct XYZW;
1312
1313	template<class Vector4, int T>
1314	class Swizzle2
1315	{
1316		friend Vector4;
1317
1318	public:
1319		operator RValue<Vector4>() const;
1320
1321	private:
1322		Vector4 *parent;
1323	};
1324
1325	template<class Vector4, int T>
1326	class Swizzle4
1327	{
1328	public:
1329		operator RValue<Vector4>() const;
1330
1331	private:
1332		Vector4 *parent;
1333	};
1334
1335	template<class Vector4, int T>
1336	class SwizzleMask4
1337	{
1338		friend XYZW<Vector4>;
1339
1340	public:
1341		operator RValue<Vector4>() const;
1342
1343		RValue<Vector4> operator=(RValue<Vector4> rhs);
1344		RValue<Vector4> operator=(RValue<typename Scalar<Vector4>::Type> rhs);
1345
1346	private:
1347		Vector4 *parent;
1348	};
1349
1350	template<>
1351	struct Scalar<Float4>
1352	{
1353		using Type = Float;
1354	};
1355
1356	template<>
1357	struct Scalar<Int4>
1358	{
1359		using Type = Int;
1360	};
1361
1362	template<>
1363	struct Scalar<UInt4>
1364	{
1365		using Type = UInt;
1366	};
1367
1368	template<class Vector4, int T>
1369	class SwizzleMask1
1370	{
1371	public:
1372		operator RValue<typename Scalar<Vector4>::Type>() const;
1373		operator RValue<Vector4>() const;
1374
1375		RValue<Vector4> operator=(float x);
1376		RValue<Vector4> operator=(RValue<Vector4> rhs);
1377		RValue<Vector4> operator=(RValue<typename Scalar<Vector4>::Type> rhs);
1378
1379	private:
1380		Float4 *parent;
1381	};
1382
1383	template<class Vector4, int T>
1384	class SwizzleMask2
1385	{
1386		friend class Float4;
1387
1388	public:
1389		operator RValue<Vector4>() const;
1390
1391		RValue<Vector4> operator=(RValue<Vector4> rhs);
1392
1393	private:
1394		Float4 *parent;
1395	};
1396
1397	template<class Vector4>
1398	struct XYZW
1399	{
1400		friend Vector4;
1401
1402	private:
1403		XYZW(Vector4 *parent)
1404		{
1405			xyzw.parent = parent;
1406		}
1407
1408	public:
1409		union
1410		{
1411			SwizzleMask1<Vector4, 0x00> x;
1412			SwizzleMask1<Vector4, 0x55> y;
1413			SwizzleMask1<Vector4, 0xAA> z;
1414			SwizzleMask1<Vector4, 0xFF> w;
1415			Swizzle2<Vector4, 0x00>     xx;
1416			Swizzle2<Vector4, 0x01>     yx;
1417			Swizzle2<Vector4, 0x02>     zx;
1418			Swizzle2<Vector4, 0x03>     wx;
1419			SwizzleMask2<Vector4, 0x54> xy;
1420			Swizzle2<Vector4, 0x55>     yy;
1421			Swizzle2<Vector4, 0x56>     zy;
1422			Swizzle2<Vector4, 0x57>     wy;
1423			SwizzleMask2<Vector4, 0xA8> xz;
1424			SwizzleMask2<Vector4, 0xA9> yz;
1425			Swizzle2<Vector4, 0xAA>     zz;
1426			Swizzle2<Vector4, 0xAB>     wz;
1427			SwizzleMask2<Vector4, 0xFC> xw;
1428			SwizzleMask2<Vector4, 0xFD> yw;
1429			SwizzleMask2<Vector4, 0xFE> zw;
1430			Swizzle2<Vector4, 0xFF>     ww;
1431			Swizzle4<Vector4, 0x00>     xxx;
1432			Swizzle4<Vector4, 0x01>     yxx;
1433			Swizzle4<Vector4, 0x02>     zxx;
1434			Swizzle4<Vector4, 0x03>     wxx;
1435			Swizzle4<Vector4, 0x04>     xyx;
1436			Swizzle4<Vector4, 0x05>     yyx;
1437			Swizzle4<Vector4, 0x06>     zyx;
1438			Swizzle4<Vector4, 0x07>     wyx;
1439			Swizzle4<Vector4, 0x08>     xzx;
1440			Swizzle4<Vector4, 0x09>     yzx;
1441			Swizzle4<Vector4, 0x0A>     zzx;
1442			Swizzle4<Vector4, 0x0B>     wzx;
1443			Swizzle4<Vector4, 0x0C>     xwx;
1444			Swizzle4<Vector4, 0x0D>     ywx;
1445			Swizzle4<Vector4, 0x0E>     zwx;
1446			Swizzle4<Vector4, 0x0F>     wwx;
1447			Swizzle4<Vector4, 0x50>     xxy;
1448			Swizzle4<Vector4, 0x51>     yxy;
1449			Swizzle4<Vector4, 0x52>     zxy;
1450			Swizzle4<Vector4, 0x53>     wxy;
1451			Swizzle4<Vector4, 0x54>     xyy;
1452			Swizzle4<Vector4, 0x55>     yyy;
1453			Swizzle4<Vector4, 0x56>     zyy;
1454			Swizzle4<Vector4, 0x57>     wyy;
1455			Swizzle4<Vector4, 0x58>     xzy;
1456			Swizzle4<Vector4, 0x59>     yzy;
1457			Swizzle4<Vector4, 0x5A>     zzy;
1458			Swizzle4<Vector4, 0x5B>     wzy;
1459			Swizzle4<Vector4, 0x5C>     xwy;
1460			Swizzle4<Vector4, 0x5D>     ywy;
1461			Swizzle4<Vector4, 0x5E>     zwy;
1462			Swizzle4<Vector4, 0x5F>     wwy;
1463			Swizzle4<Vector4, 0xA0>     xxz;
1464			Swizzle4<Vector4, 0xA1>     yxz;
1465			Swizzle4<Vector4, 0xA2>     zxz;
1466			Swizzle4<Vector4, 0xA3>     wxz;
1467			SwizzleMask4<Vector4, 0xA4> xyz;
1468			Swizzle4<Vector4, 0xA5>     yyz;
1469			Swizzle4<Vector4, 0xA6>     zyz;
1470			Swizzle4<Vector4, 0xA7>     wyz;
1471			Swizzle4<Vector4, 0xA8>     xzz;
1472			Swizzle4<Vector4, 0xA9>     yzz;
1473			Swizzle4<Vector4, 0xAA>     zzz;
1474			Swizzle4<Vector4, 0xAB>     wzz;
1475			Swizzle4<Vector4, 0xAC>     xwz;
1476			Swizzle4<Vector4, 0xAD>     ywz;
1477			Swizzle4<Vector4, 0xAE>     zwz;
1478			Swizzle4<Vector4, 0xAF>     wwz;
1479			Swizzle4<Vector4, 0xF0>     xxw;
1480			Swizzle4<Vector4, 0xF1>     yxw;
1481			Swizzle4<Vector4, 0xF2>     zxw;
1482			Swizzle4<Vector4, 0xF3>     wxw;
1483			SwizzleMask4<Vector4, 0xF4> xyw;
1484			Swizzle4<Vector4, 0xF5>     yyw;
1485			Swizzle4<Vector4, 0xF6>     zyw;
1486			Swizzle4<Vector4, 0xF7>     wyw;
1487			SwizzleMask4<Vector4, 0xF8> xzw;
1488			SwizzleMask4<Vector4, 0xF9> yzw;
1489			Swizzle4<Vector4, 0xFA>     zzw;
1490			Swizzle4<Vector4, 0xFB>     wzw;
1491			Swizzle4<Vector4, 0xFC>     xww;
1492			Swizzle4<Vector4, 0xFD>     yww;
1493			Swizzle4<Vector4, 0xFE>     zww;
1494			Swizzle4<Vector4, 0xFF>     www;
1495			Swizzle4<Vector4, 0x00>     xxxx;
1496			Swizzle4<Vector4, 0x01>     yxxx;
1497			Swizzle4<Vector4, 0x02>     zxxx;
1498			Swizzle4<Vector4, 0x03>     wxxx;
1499			Swizzle4<Vector4, 0x04>     xyxx;
1500			Swizzle4<Vector4, 0x05>     yyxx;
1501			Swizzle4<Vector4, 0x06>     zyxx;
1502			Swizzle4<Vector4, 0x07>     wyxx;
1503			Swizzle4<Vector4, 0x08>     xzxx;
1504			Swizzle4<Vector4, 0x09>     yzxx;
1505			Swizzle4<Vector4, 0x0A>     zzxx;
1506			Swizzle4<Vector4, 0x0B>     wzxx;
1507			Swizzle4<Vector4, 0x0C>     xwxx;
1508			Swizzle4<Vector4, 0x0D>     ywxx;
1509			Swizzle4<Vector4, 0x0E>     zwxx;
1510			Swizzle4<Vector4, 0x0F>     wwxx;
1511			Swizzle4<Vector4, 0x10>     xxyx;
1512			Swizzle4<Vector4, 0x11>     yxyx;
1513			Swizzle4<Vector4, 0x12>     zxyx;
1514			Swizzle4<Vector4, 0x13>     wxyx;
1515			Swizzle4<Vector4, 0x14>     xyyx;
1516			Swizzle4<Vector4, 0x15>     yyyx;
1517			Swizzle4<Vector4, 0x16>     zyyx;
1518			Swizzle4<Vector4, 0x17>     wyyx;
1519			Swizzle4<Vector4, 0x18>     xzyx;
1520			Swizzle4<Vector4, 0x19>     yzyx;
1521			Swizzle4<Vector4, 0x1A>     zzyx;
1522			Swizzle4<Vector4, 0x1B>     wzyx;
1523			Swizzle4<Vector4, 0x1C>     xwyx;
1524			Swizzle4<Vector4, 0x1D>     ywyx;
1525			Swizzle4<Vector4, 0x1E>     zwyx;
1526			Swizzle4<Vector4, 0x1F>     wwyx;
1527			Swizzle4<Vector4, 0x20>     xxzx;
1528			Swizzle4<Vector4, 0x21>     yxzx;
1529			Swizzle4<Vector4, 0x22>     zxzx;
1530			Swizzle4<Vector4, 0x23>     wxzx;
1531			Swizzle4<Vector4, 0x24>     xyzx;
1532			Swizzle4<Vector4, 0x25>     yyzx;
1533			Swizzle4<Vector4, 0x26>     zyzx;
1534			Swizzle4<Vector4, 0x27>     wyzx;
1535			Swizzle4<Vector4, 0x28>     xzzx;
1536			Swizzle4<Vector4, 0x29>     yzzx;
1537			Swizzle4<Vector4, 0x2A>     zzzx;
1538			Swizzle4<Vector4, 0x2B>     wzzx;
1539			Swizzle4<Vector4, 0x2C>     xwzx;
1540			Swizzle4<Vector4, 0x2D>     ywzx;
1541			Swizzle4<Vector4, 0x2E>     zwzx;
1542			Swizzle4<Vector4, 0x2F>     wwzx;
1543			Swizzle4<Vector4, 0x30>     xxwx;
1544			Swizzle4<Vector4, 0x31>     yxwx;
1545			Swizzle4<Vector4, 0x32>     zxwx;
1546			Swizzle4<Vector4, 0x33>     wxwx;
1547			Swizzle4<Vector4, 0x34>     xywx;
1548			Swizzle4<Vector4, 0x35>     yywx;
1549			Swizzle4<Vector4, 0x36>     zywx;
1550			Swizzle4<Vector4, 0x37>     wywx;
1551			Swizzle4<Vector4, 0x38>     xzwx;
1552			Swizzle4<Vector4, 0x39>     yzwx;
1553			Swizzle4<Vector4, 0x3A>     zzwx;
1554			Swizzle4<Vector4, 0x3B>     wzwx;
1555			Swizzle4<Vector4, 0x3C>     xwwx;
1556			Swizzle4<Vector4, 0x3D>     ywwx;
1557			Swizzle4<Vector4, 0x3E>     zwwx;
1558			Swizzle4<Vector4, 0x3F>     wwwx;
1559			Swizzle4<Vector4, 0x40>     xxxy;
1560			Swizzle4<Vector4, 0x41>     yxxy;
1561			Swizzle4<Vector4, 0x42>     zxxy;
1562			Swizzle4<Vector4, 0x43>     wxxy;
1563			Swizzle4<Vector4, 0x44>     xyxy;
1564			Swizzle4<Vector4, 0x45>     yyxy;
1565			Swizzle4<Vector4, 0x46>     zyxy;
1566			Swizzle4<Vector4, 0x47>     wyxy;
1567			Swizzle4<Vector4, 0x48>     xzxy;
1568			Swizzle4<Vector4, 0x49>     yzxy;
1569			Swizzle4<Vector4, 0x4A>     zzxy;
1570			Swizzle4<Vector4, 0x4B>     wzxy;
1571			Swizzle4<Vector4, 0x4C>     xwxy;
1572			Swizzle4<Vector4, 0x4D>     ywxy;
1573			Swizzle4<Vector4, 0x4E>     zwxy;
1574			Swizzle4<Vector4, 0x4F>     wwxy;
1575			Swizzle4<Vector4, 0x50>     xxyy;
1576			Swizzle4<Vector4, 0x51>     yxyy;
1577			Swizzle4<Vector4, 0x52>     zxyy;
1578			Swizzle4<Vector4, 0x53>     wxyy;
1579			Swizzle4<Vector4, 0x54>     xyyy;
1580			Swizzle4<Vector4, 0x55>     yyyy;
1581			Swizzle4<Vector4, 0x56>     zyyy;
1582			Swizzle4<Vector4, 0x57>     wyyy;
1583			Swizzle4<Vector4, 0x58>     xzyy;
1584			Swizzle4<Vector4, 0x59>     yzyy;
1585			Swizzle4<Vector4, 0x5A>     zzyy;
1586			Swizzle4<Vector4, 0x5B>     wzyy;
1587			Swizzle4<Vector4, 0x5C>     xwyy;
1588			Swizzle4<Vector4, 0x5D>     ywyy;
1589			Swizzle4<Vector4, 0x5E>     zwyy;
1590			Swizzle4<Vector4, 0x5F>     wwyy;
1591			Swizzle4<Vector4, 0x60>     xxzy;
1592			Swizzle4<Vector4, 0x61>     yxzy;
1593			Swizzle4<Vector4, 0x62>     zxzy;
1594			Swizzle4<Vector4, 0x63>     wxzy;
1595			Swizzle4<Vector4, 0x64>     xyzy;
1596			Swizzle4<Vector4, 0x65>     yyzy;
1597			Swizzle4<Vector4, 0x66>     zyzy;
1598			Swizzle4<Vector4, 0x67>     wyzy;
1599			Swizzle4<Vector4, 0x68>     xzzy;
1600			Swizzle4<Vector4, 0x69>     yzzy;
1601			Swizzle4<Vector4, 0x6A>     zzzy;
1602			Swizzle4<Vector4, 0x6B>     wzzy;
1603			Swizzle4<Vector4, 0x6C>     xwzy;
1604			Swizzle4<Vector4, 0x6D>     ywzy;
1605			Swizzle4<Vector4, 0x6E>     zwzy;
1606			Swizzle4<Vector4, 0x6F>     wwzy;
1607			Swizzle4<Vector4, 0x70>     xxwy;
1608			Swizzle4<Vector4, 0x71>     yxwy;
1609			Swizzle4<Vector4, 0x72>     zxwy;
1610			Swizzle4<Vector4, 0x73>     wxwy;
1611			Swizzle4<Vector4, 0x74>     xywy;
1612			Swizzle4<Vector4, 0x75>     yywy;
1613			Swizzle4<Vector4, 0x76>     zywy;
1614			Swizzle4<Vector4, 0x77>     wywy;
1615			Swizzle4<Vector4, 0x78>     xzwy;
1616			Swizzle4<Vector4, 0x79>     yzwy;
1617			Swizzle4<Vector4, 0x7A>     zzwy;
1618			Swizzle4<Vector4, 0x7B>     wzwy;
1619			Swizzle4<Vector4, 0x7C>     xwwy;
1620			Swizzle4<Vector4, 0x7D>     ywwy;
1621			Swizzle4<Vector4, 0x7E>     zwwy;
1622			Swizzle4<Vector4, 0x7F>     wwwy;
1623			Swizzle4<Vector4, 0x80>     xxxz;
1624			Swizzle4<Vector4, 0x81>     yxxz;
1625			Swizzle4<Vector4, 0x82>     zxxz;
1626			Swizzle4<Vector4, 0x83>     wxxz;
1627			Swizzle4<Vector4, 0x84>     xyxz;
1628			Swizzle4<Vector4, 0x85>     yyxz;
1629			Swizzle4<Vector4, 0x86>     zyxz;
1630			Swizzle4<Vector4, 0x87>     wyxz;
1631			Swizzle4<Vector4, 0x88>     xzxz;
1632			Swizzle4<Vector4, 0x89>     yzxz;
1633			Swizzle4<Vector4, 0x8A>     zzxz;
1634			Swizzle4<Vector4, 0x8B>     wzxz;
1635			Swizzle4<Vector4, 0x8C>     xwxz;
1636			Swizzle4<Vector4, 0x8D>     ywxz;
1637			Swizzle4<Vector4, 0x8E>     zwxz;
1638			Swizzle4<Vector4, 0x8F>     wwxz;
1639			Swizzle4<Vector4, 0x90>     xxyz;
1640			Swizzle4<Vector4, 0x91>     yxyz;
1641			Swizzle4<Vector4, 0x92>     zxyz;
1642			Swizzle4<Vector4, 0x93>     wxyz;
1643			Swizzle4<Vector4, 0x94>     xyyz;
1644			Swizzle4<Vector4, 0x95>     yyyz;
1645			Swizzle4<Vector4, 0x96>     zyyz;
1646			Swizzle4<Vector4, 0x97>     wyyz;
1647			Swizzle4<Vector4, 0x98>     xzyz;
1648			Swizzle4<Vector4, 0x99>     yzyz;
1649			Swizzle4<Vector4, 0x9A>     zzyz;
1650			Swizzle4<Vector4, 0x9B>     wzyz;
1651			Swizzle4<Vector4, 0x9C>     xwyz;
1652			Swizzle4<Vector4, 0x9D>     ywyz;
1653			Swizzle4<Vector4, 0x9E>     zwyz;
1654			Swizzle4<Vector4, 0x9F>     wwyz;
1655			Swizzle4<Vector4, 0xA0>     xxzz;
1656			Swizzle4<Vector4, 0xA1>     yxzz;
1657			Swizzle4<Vector4, 0xA2>     zxzz;
1658			Swizzle4<Vector4, 0xA3>     wxzz;
1659			Swizzle4<Vector4, 0xA4>     xyzz;
1660			Swizzle4<Vector4, 0xA5>     yyzz;
1661			Swizzle4<Vector4, 0xA6>     zyzz;
1662			Swizzle4<Vector4, 0xA7>     wyzz;
1663			Swizzle4<Vector4, 0xA8>     xzzz;
1664			Swizzle4<Vector4, 0xA9>     yzzz;
1665			Swizzle4<Vector4, 0xAA>     zzzz;
1666			Swizzle4<Vector4, 0xAB>     wzzz;
1667			Swizzle4<Vector4, 0xAC>     xwzz;
1668			Swizzle4<Vector4, 0xAD>     ywzz;
1669			Swizzle4<Vector4, 0xAE>     zwzz;
1670			Swizzle4<Vector4, 0xAF>     wwzz;
1671			Swizzle4<Vector4, 0xB0>     xxwz;
1672			Swizzle4<Vector4, 0xB1>     yxwz;
1673			Swizzle4<Vector4, 0xB2>     zxwz;
1674			Swizzle4<Vector4, 0xB3>     wxwz;
1675			Swizzle4<Vector4, 0xB4>     xywz;
1676			Swizzle4<Vector4, 0xB5>     yywz;
1677			Swizzle4<Vector4, 0xB6>     zywz;
1678			Swizzle4<Vector4, 0xB7>     wywz;
1679			Swizzle4<Vector4, 0xB8>     xzwz;
1680			Swizzle4<Vector4, 0xB9>     yzwz;
1681			Swizzle4<Vector4, 0xBA>     zzwz;
1682			Swizzle4<Vector4, 0xBB>     wzwz;
1683			Swizzle4<Vector4, 0xBC>     xwwz;
1684			Swizzle4<Vector4, 0xBD>     ywwz;
1685			Swizzle4<Vector4, 0xBE>     zwwz;
1686			Swizzle4<Vector4, 0xBF>     wwwz;
1687			Swizzle4<Vector4, 0xC0>     xxxw;
1688			Swizzle4<Vector4, 0xC1>     yxxw;
1689			Swizzle4<Vector4, 0xC2>     zxxw;
1690			Swizzle4<Vector4, 0xC3>     wxxw;
1691			Swizzle4<Vector4, 0xC4>     xyxw;
1692			Swizzle4<Vector4, 0xC5>     yyxw;
1693			Swizzle4<Vector4, 0xC6>     zyxw;
1694			Swizzle4<Vector4, 0xC7>     wyxw;
1695			Swizzle4<Vector4, 0xC8>     xzxw;
1696			Swizzle4<Vector4, 0xC9>     yzxw;
1697			Swizzle4<Vector4, 0xCA>     zzxw;
1698			Swizzle4<Vector4, 0xCB>     wzxw;
1699			Swizzle4<Vector4, 0xCC>     xwxw;
1700			Swizzle4<Vector4, 0xCD>     ywxw;
1701			Swizzle4<Vector4, 0xCE>     zwxw;
1702			Swizzle4<Vector4, 0xCF>     wwxw;
1703			Swizzle4<Vector4, 0xD0>     xxyw;
1704			Swizzle4<Vector4, 0xD1>     yxyw;
1705			Swizzle4<Vector4, 0xD2>     zxyw;
1706			Swizzle4<Vector4, 0xD3>     wxyw;
1707			Swizzle4<Vector4, 0xD4>     xyyw;
1708			Swizzle4<Vector4, 0xD5>     yyyw;
1709			Swizzle4<Vector4, 0xD6>     zyyw;
1710			Swizzle4<Vector4, 0xD7>     wyyw;
1711			Swizzle4<Vector4, 0xD8>     xzyw;
1712			Swizzle4<Vector4, 0xD9>     yzyw;
1713			Swizzle4<Vector4, 0xDA>     zzyw;
1714			Swizzle4<Vector4, 0xDB>     wzyw;
1715			Swizzle4<Vector4, 0xDC>     xwyw;
1716			Swizzle4<Vector4, 0xDD>     ywyw;
1717			Swizzle4<Vector4, 0xDE>     zwyw;
1718			Swizzle4<Vector4, 0xDF>     wwyw;
1719			Swizzle4<Vector4, 0xE0>     xxzw;
1720			Swizzle4<Vector4, 0xE1>     yxzw;
1721			Swizzle4<Vector4, 0xE2>     zxzw;
1722			Swizzle4<Vector4, 0xE3>     wxzw;
1723			SwizzleMask4<Vector4, 0xE4> xyzw;
1724			Swizzle4<Vector4, 0xE5>     yyzw;
1725			Swizzle4<Vector4, 0xE6>     zyzw;
1726			Swizzle4<Vector4, 0xE7>     wyzw;
1727			Swizzle4<Vector4, 0xE8>     xzzw;
1728			Swizzle4<Vector4, 0xE9>     yzzw;
1729			Swizzle4<Vector4, 0xEA>     zzzw;
1730			Swizzle4<Vector4, 0xEB>     wzzw;
1731			Swizzle4<Vector4, 0xEC>     xwzw;
1732			Swizzle4<Vector4, 0xED>     ywzw;
1733			Swizzle4<Vector4, 0xEE>     zwzw;
1734			Swizzle4<Vector4, 0xEF>     wwzw;
1735			Swizzle4<Vector4, 0xF0>     xxww;
1736			Swizzle4<Vector4, 0xF1>     yxww;
1737			Swizzle4<Vector4, 0xF2>     zxww;
1738			Swizzle4<Vector4, 0xF3>     wxww;
1739			Swizzle4<Vector4, 0xF4>     xyww;
1740			Swizzle4<Vector4, 0xF5>     yyww;
1741			Swizzle4<Vector4, 0xF6>     zyww;
1742			Swizzle4<Vector4, 0xF7>     wyww;
1743			Swizzle4<Vector4, 0xF8>     xzww;
1744			Swizzle4<Vector4, 0xF9>     yzww;
1745			Swizzle4<Vector4, 0xFA>     zzww;
1746			Swizzle4<Vector4, 0xFB>     wzww;
1747			Swizzle4<Vector4, 0xFC>     xwww;
1748			Swizzle4<Vector4, 0xFD>     ywww;
1749			Swizzle4<Vector4, 0xFE>     zwww;
1750			Swizzle4<Vector4, 0xFF>     wwww;
1751		};
1752	};
1753
1754	class Int4 : public LValue<Int4>, public XYZW<Int4>
1755	{
1756	public:
1757		explicit Int4(RValue<Byte4> cast);
1758		explicit Int4(RValue<SByte4> cast);
1759		explicit Int4(RValue<Float4> cast);
1760		explicit Int4(RValue<Short4> cast);
1761		explicit Int4(RValue<UShort4> cast);
1762
1763		Int4();
1764		Int4(int xyzw);
1765		Int4(int x, int yzw);
1766		Int4(int x, int y, int zw);
1767		Int4(int x, int y, int z, int w);
1768		Int4(RValue<Int4> rhs);
1769		Int4(const Int4 &rhs);
1770		Int4(const Reference<Int4> &rhs);
1771		Int4(RValue<UInt4> rhs);
1772		Int4(const UInt4 &rhs);
1773		Int4(const Reference<UInt4> &rhs);
1774		Int4(RValue<Int2> lo, RValue<Int2> hi);
1775		Int4(RValue<Int> rhs);
1776		Int4(const Int &rhs);
1777		Int4(const Reference<Int> &rhs);
1778
1779		RValue<Int4> operator=(RValue<Int4> rhs);
1780		RValue<Int4> operator=(const Int4 &rhs);
1781		RValue<Int4> operator=(const Reference<Int4> &rhs);
1782
1783		static Type *getType();
1784
1785	private:
1786		void constant(int x, int y, int z, int w);
1787	};
1788
1789	RValue<Int4> operator+(RValue<Int4> lhs, RValue<Int4> rhs);
1790	RValue<Int4> operator-(RValue<Int4> lhs, RValue<Int4> rhs);
1791	RValue<Int4> operator*(RValue<Int4> lhs, RValue<Int4> rhs);
1792	RValue<Int4> operator/(RValue<Int4> lhs, RValue<Int4> rhs);
1793	RValue<Int4> operator%(RValue<Int4> lhs, RValue<Int4> rhs);
1794	RValue<Int4> operator&(RValue<Int4> lhs, RValue<Int4> rhs);
1795	RValue<Int4> operator|(RValue<Int4> lhs, RValue<Int4> rhs);
1796	RValue<Int4> operator^(RValue<Int4> lhs, RValue<Int4> rhs);
1797	RValue<Int4> operator<<(RValue<Int4> lhs, unsigned char rhs);
1798	RValue<Int4> operator>>(RValue<Int4> lhs, unsigned char rhs);
1799	RValue<Int4> operator<<(RValue<Int4> lhs, RValue<Int4> rhs);
1800	RValue<Int4> operator>>(RValue<Int4> lhs, RValue<Int4> rhs);
1801	RValue<Int4> operator+=(Int4 &lhs, RValue<Int4> rhs);
1802	RValue<Int4> operator-=(Int4 &lhs, RValue<Int4> rhs);
1803	RValue<Int4> operator*=(Int4 &lhs, RValue<Int4> rhs);
1804//	RValue<Int4> operator/=(Int4 &lhs, RValue<Int4> rhs);
1805//	RValue<Int4> operator%=(Int4 &lhs, RValue<Int4> rhs);
1806	RValue<Int4> operator&=(Int4 &lhs, RValue<Int4> rhs);
1807	RValue<Int4> operator|=(Int4 &lhs, RValue<Int4> rhs);
1808	RValue<Int4> operator^=(Int4 &lhs, RValue<Int4> rhs);
1809	RValue<Int4> operator<<=(Int4 &lhs, unsigned char rhs);
1810	RValue<Int4> operator>>=(Int4 &lhs, unsigned char rhs);
1811	RValue<Int4> operator+(RValue<Int4> val);
1812	RValue<Int4> operator-(RValue<Int4> val);
1813	RValue<Int4> operator~(RValue<Int4> val);
1814//	RValue<Int4> operator++(Int4 &val, int);   // Post-increment
1815//	const Int4 &operator++(Int4 &val);   // Pre-increment
1816//	RValue<Int4> operator--(Int4 &val, int);   // Post-decrement
1817//	const Int4 &operator--(Int4 &val);   // Pre-decrement
1818//	RValue<Bool> operator<(RValue<Int4> lhs, RValue<Int4> rhs);
1819//	RValue<Bool> operator<=(RValue<Int4> lhs, RValue<Int4> rhs);
1820//	RValue<Bool> operator>(RValue<Int4> lhs, RValue<Int4> rhs);
1821//	RValue<Bool> operator>=(RValue<Int4> lhs, RValue<Int4> rhs);
1822//	RValue<Bool> operator!=(RValue<Int4> lhs, RValue<Int4> rhs);
1823//	RValue<Bool> operator==(RValue<Int4> lhs, RValue<Int4> rhs);
1824
1825	RValue<Int4> CmpEQ(RValue<Int4> x, RValue<Int4> y);
1826	RValue<Int4> CmpLT(RValue<Int4> x, RValue<Int4> y);
1827	RValue<Int4> CmpLE(RValue<Int4> x, RValue<Int4> y);
1828	RValue<Int4> CmpNEQ(RValue<Int4> x, RValue<Int4> y);
1829	RValue<Int4> CmpNLT(RValue<Int4> x, RValue<Int4> y);
1830	RValue<Int4> CmpNLE(RValue<Int4> x, RValue<Int4> y);
1831	RValue<Int4> Max(RValue<Int4> x, RValue<Int4> y);
1832	RValue<Int4> Min(RValue<Int4> x, RValue<Int4> y);
1833	RValue<Int4> RoundInt(RValue<Float4> cast);
1834	RValue<Short8> Pack(RValue<Int4> x, RValue<Int4> y);
1835	RValue<Int> Extract(RValue<Int4> val, int i);
1836	RValue<Int4> Insert(RValue<Int4> val, RValue<Int> element, int i);
1837	RValue<Int> SignMask(RValue<Int4> x);
1838	RValue<Int4> Swizzle(RValue<Int4> x, unsigned char select);
1839
1840	class UInt4 : public LValue<UInt4>, public XYZW<UInt4>
1841	{
1842	public:
1843		explicit UInt4(RValue<Float4> cast);
1844
1845		UInt4();
1846		UInt4(int xyzw);
1847		UInt4(int x, int yzw);
1848		UInt4(int x, int y, int zw);
1849		UInt4(int x, int y, int z, int w);
1850		UInt4(unsigned int x, unsigned int y, unsigned int z, unsigned int w);
1851		UInt4(RValue<UInt4> rhs);
1852		UInt4(const UInt4 &rhs);
1853		UInt4(const Reference<UInt4> &rhs);
1854		UInt4(RValue<Int4> rhs);
1855		UInt4(const Int4 &rhs);
1856		UInt4(const Reference<Int4> &rhs);
1857		UInt4(RValue<UInt2> lo, RValue<UInt2> hi);
1858
1859		RValue<UInt4> operator=(RValue<UInt4> rhs);
1860		RValue<UInt4> operator=(const UInt4 &rhs);
1861		RValue<UInt4> operator=(const Reference<UInt4> &rhs);
1862
1863		static Type *getType();
1864
1865	private:
1866		void constant(int x, int y, int z, int w);
1867	};
1868
1869	RValue<UInt4> operator+(RValue<UInt4> lhs, RValue<UInt4> rhs);
1870	RValue<UInt4> operator-(RValue<UInt4> lhs, RValue<UInt4> rhs);
1871	RValue<UInt4> operator*(RValue<UInt4> lhs, RValue<UInt4> rhs);
1872	RValue<UInt4> operator/(RValue<UInt4> lhs, RValue<UInt4> rhs);
1873	RValue<UInt4> operator%(RValue<UInt4> lhs, RValue<UInt4> rhs);
1874	RValue<UInt4> operator&(RValue<UInt4> lhs, RValue<UInt4> rhs);
1875	RValue<UInt4> operator|(RValue<UInt4> lhs, RValue<UInt4> rhs);
1876	RValue<UInt4> operator^(RValue<UInt4> lhs, RValue<UInt4> rhs);
1877	RValue<UInt4> operator<<(RValue<UInt4> lhs, unsigned char rhs);
1878	RValue<UInt4> operator>>(RValue<UInt4> lhs, unsigned char rhs);
1879	RValue<UInt4> operator<<(RValue<UInt4> lhs, RValue<UInt4> rhs);
1880	RValue<UInt4> operator>>(RValue<UInt4> lhs, RValue<UInt4> rhs);
1881	RValue<UInt4> operator+=(UInt4 &lhs, RValue<UInt4> rhs);
1882	RValue<UInt4> operator-=(UInt4 &lhs, RValue<UInt4> rhs);
1883	RValue<UInt4> operator*=(UInt4 &lhs, RValue<UInt4> rhs);
1884//	RValue<UInt4> operator/=(UInt4 &lhs, RValue<UInt4> rhs);
1885//	RValue<UInt4> operator%=(UInt4 &lhs, RValue<UInt4> rhs);
1886	RValue<UInt4> operator&=(UInt4 &lhs, RValue<UInt4> rhs);
1887	RValue<UInt4> operator|=(UInt4 &lhs, RValue<UInt4> rhs);
1888	RValue<UInt4> operator^=(UInt4 &lhs, RValue<UInt4> rhs);
1889	RValue<UInt4> operator<<=(UInt4 &lhs, unsigned char rhs);
1890	RValue<UInt4> operator>>=(UInt4 &lhs, unsigned char rhs);
1891	RValue<UInt4> operator+(RValue<UInt4> val);
1892	RValue<UInt4> operator-(RValue<UInt4> val);
1893	RValue<UInt4> operator~(RValue<UInt4> val);
1894//	RValue<UInt4> operator++(UInt4 &val, int);   // Post-increment
1895//	const UInt4 &operator++(UInt4 &val);   // Pre-increment
1896//	RValue<UInt4> operator--(UInt4 &val, int);   // Post-decrement
1897//	const UInt4 &operator--(UInt4 &val);   // Pre-decrement
1898//	RValue<Bool> operator<(RValue<UInt4> lhs, RValue<UInt4> rhs);
1899//	RValue<Bool> operator<=(RValue<UInt4> lhs, RValue<UInt4> rhs);
1900//	RValue<Bool> operator>(RValue<UInt4> lhs, RValue<UInt4> rhs);
1901//	RValue<Bool> operator>=(RValue<UInt4> lhs, RValue<UInt4> rhs);
1902//	RValue<Bool> operator!=(RValue<UInt4> lhs, RValue<UInt4> rhs);
1903//	RValue<Bool> operator==(RValue<UInt4> lhs, RValue<UInt4> rhs);
1904
1905	RValue<UInt4> CmpEQ(RValue<UInt4> x, RValue<UInt4> y);
1906	RValue<UInt4> CmpLT(RValue<UInt4> x, RValue<UInt4> y);
1907	RValue<UInt4> CmpLE(RValue<UInt4> x, RValue<UInt4> y);
1908	RValue<UInt4> CmpNEQ(RValue<UInt4> x, RValue<UInt4> y);
1909	RValue<UInt4> CmpNLT(RValue<UInt4> x, RValue<UInt4> y);
1910	RValue<UInt4> CmpNLE(RValue<UInt4> x, RValue<UInt4> y);
1911	RValue<UInt4> Max(RValue<UInt4> x, RValue<UInt4> y);
1912	RValue<UInt4> Min(RValue<UInt4> x, RValue<UInt4> y);
1913//	RValue<UInt4> RoundInt(RValue<Float4> cast);
1914	RValue<UShort8> Pack(RValue<UInt4> x, RValue<UInt4> y);
1915
1916	class Float : public LValue<Float>
1917	{
1918	public:
1919		explicit Float(RValue<Int> cast);
1920		explicit Float(RValue<UInt> cast);
1921
1922		Float() = default;
1923		Float(float x);
1924		Float(RValue<Float> rhs);
1925		Float(const Float &rhs);
1926		Float(const Reference<Float> &rhs);
1927
1928		template<int T>
1929		Float(const SwizzleMask1<Float4, T> &rhs);
1930
1931	//	RValue<Float> operator=(float rhs);   // FIXME: Implement
1932		RValue<Float> operator=(RValue<Float> rhs);
1933		RValue<Float> operator=(const Float &rhs);
1934		RValue<Float> operator=(const Reference<Float> &rhs);
1935
1936		template<int T>
1937		RValue<Float> operator=(const SwizzleMask1<Float4, T> &rhs);
1938
1939		static Type *getType();
1940	};
1941
1942	RValue<Float> operator+(RValue<Float> lhs, RValue<Float> rhs);
1943	RValue<Float> operator-(RValue<Float> lhs, RValue<Float> rhs);
1944	RValue<Float> operator*(RValue<Float> lhs, RValue<Float> rhs);
1945	RValue<Float> operator/(RValue<Float> lhs, RValue<Float> rhs);
1946	RValue<Float> operator+=(Float &lhs, RValue<Float> rhs);
1947	RValue<Float> operator-=(Float &lhs, RValue<Float> rhs);
1948	RValue<Float> operator*=(Float &lhs, RValue<Float> rhs);
1949	RValue<Float> operator/=(Float &lhs, RValue<Float> rhs);
1950	RValue<Float> operator+(RValue<Float> val);
1951	RValue<Float> operator-(RValue<Float> val);
1952	RValue<Bool> operator<(RValue<Float> lhs, RValue<Float> rhs);
1953	RValue<Bool> operator<=(RValue<Float> lhs, RValue<Float> rhs);
1954	RValue<Bool> operator>(RValue<Float> lhs, RValue<Float> rhs);
1955	RValue<Bool> operator>=(RValue<Float> lhs, RValue<Float> rhs);
1956	RValue<Bool> operator!=(RValue<Float> lhs, RValue<Float> rhs);
1957	RValue<Bool> operator==(RValue<Float> lhs, RValue<Float> rhs);
1958
1959	RValue<Float> Abs(RValue<Float> x);
1960	RValue<Float> Max(RValue<Float> x, RValue<Float> y);
1961	RValue<Float> Min(RValue<Float> x, RValue<Float> y);
1962	RValue<Float> Rcp_pp(RValue<Float> val, bool exactAtPow2 = false);
1963	RValue<Float> RcpSqrt_pp(RValue<Float> val);
1964	RValue<Float> Sqrt(RValue<Float> x);
1965	RValue<Float> Round(RValue<Float> val);
1966	RValue<Float> Trunc(RValue<Float> val);
1967	RValue<Float> Frac(RValue<Float> val);
1968	RValue<Float> Floor(RValue<Float> val);
1969	RValue<Float> Ceil(RValue<Float> val);
1970
1971	class Float2 : public LValue<Float2>
1972	{
1973	public:
1974	//	explicit Float2(RValue<Byte2> cast);
1975	//	explicit Float2(RValue<Short2> cast);
1976	//	explicit Float2(RValue<UShort2> cast);
1977	//	explicit Float2(RValue<Int2> cast);
1978	//	explicit Float2(RValue<UInt2> cast);
1979		explicit Float2(RValue<Float4> cast);
1980
1981		Float2() = default;
1982	//	Float2(float x, float y);
1983	//	Float2(RValue<Float2> rhs);
1984	//	Float2(const Float2 &rhs);
1985	//	Float2(const Reference<Float2> &rhs);
1986	//	Float2(RValue<Float> rhs);
1987	//	Float2(const Float &rhs);
1988	//	Float2(const Reference<Float> &rhs);
1989
1990	//	template<int T>
1991	//	Float2(const SwizzleMask1<T> &rhs);
1992
1993	//	RValue<Float2> operator=(float replicate);
1994	//	RValue<Float2> operator=(RValue<Float2> rhs);
1995	//	RValue<Float2> operator=(const Float2 &rhs);
1996	//	RValue<Float2> operator=(const Reference<Float2> &rhs);
1997	//	RValue<Float2> operator=(RValue<Float> rhs);
1998	//	RValue<Float2> operator=(const Float &rhs);
1999	//	RValue<Float2> operator=(const Reference<Float> &rhs);
2000
2001	//	template<int T>
2002	//	RValue<Float2> operator=(const SwizzleMask1<T> &rhs);
2003
2004		static Type *getType();
2005	};
2006
2007//	RValue<Float2> operator+(RValue<Float2> lhs, RValue<Float2> rhs);
2008//	RValue<Float2> operator-(RValue<Float2> lhs, RValue<Float2> rhs);
2009//	RValue<Float2> operator*(RValue<Float2> lhs, RValue<Float2> rhs);
2010//	RValue<Float2> operator/(RValue<Float2> lhs, RValue<Float2> rhs);
2011//	RValue<Float2> operator%(RValue<Float2> lhs, RValue<Float2> rhs);
2012//	RValue<Float2> operator+=(Float2 &lhs, RValue<Float2> rhs);
2013//	RValue<Float2> operator-=(Float2 &lhs, RValue<Float2> rhs);
2014//	RValue<Float2> operator*=(Float2 &lhs, RValue<Float2> rhs);
2015//	RValue<Float2> operator/=(Float2 &lhs, RValue<Float2> rhs);
2016//	RValue<Float2> operator%=(Float2 &lhs, RValue<Float2> rhs);
2017//	RValue<Float2> operator+(RValue<Float2> val);
2018//	RValue<Float2> operator-(RValue<Float2> val);
2019
2020//	RValue<Float2> Abs(RValue<Float2> x);
2021//	RValue<Float2> Max(RValue<Float2> x, RValue<Float2> y);
2022//	RValue<Float2> Min(RValue<Float2> x, RValue<Float2> y);
2023//	RValue<Float2> Swizzle(RValue<Float2> x, unsigned char select);
2024//	RValue<Float2> Mask(Float2 &lhs, RValue<Float2> rhs, unsigned char select);
2025
2026	class Float4 : public LValue<Float4>, public XYZW<Float4>
2027	{
2028	public:
2029		explicit Float4(RValue<Byte4> cast);
2030		explicit Float4(RValue<SByte4> cast);
2031		explicit Float4(RValue<Short4> cast);
2032		explicit Float4(RValue<UShort4> cast);
2033		explicit Float4(RValue<Int4> cast);
2034		explicit Float4(RValue<UInt4> cast);
2035
2036		Float4();
2037		Float4(float xyzw);
2038		Float4(float x, float yzw);
2039		Float4(float x, float y, float zw);
2040		Float4(float x, float y, float z, float w);
2041		Float4(RValue<Float4> rhs);
2042		Float4(const Float4 &rhs);
2043		Float4(const Reference<Float4> &rhs);
2044		Float4(RValue<Float> rhs);
2045		Float4(const Float &rhs);
2046		Float4(const Reference<Float> &rhs);
2047
2048		template<int T>
2049		Float4(const SwizzleMask1<Float4, T> &rhs);
2050		template<int T>
2051		Float4(const Swizzle4<Float4, T> &rhs);
2052		template<int X, int Y>
2053		Float4(const Swizzle2<Float4, X> &x, const Swizzle2<Float4, Y> &y);
2054		template<int X, int Y>
2055		Float4(const SwizzleMask2<Float4, X> &x, const Swizzle2<Float4, Y> &y);
2056		template<int X, int Y>
2057		Float4(const Swizzle2<Float4, X> &x, const SwizzleMask2<Float4, Y> &y);
2058		template<int X, int Y>
2059		Float4(const SwizzleMask2<Float4, X> &x, const SwizzleMask2<Float4, Y> &y);
2060
2061		RValue<Float4> operator=(float replicate);
2062		RValue<Float4> operator=(RValue<Float4> rhs);
2063		RValue<Float4> operator=(const Float4 &rhs);
2064		RValue<Float4> operator=(const Reference<Float4> &rhs);
2065		RValue<Float4> operator=(RValue<Float> rhs);
2066		RValue<Float4> operator=(const Float &rhs);
2067		RValue<Float4> operator=(const Reference<Float> &rhs);
2068
2069		template<int T>
2070		RValue<Float4> operator=(const SwizzleMask1<Float4, T> &rhs);
2071		template<int T>
2072		RValue<Float4> operator=(const Swizzle4<Float4, T> &rhs);
2073
2074		static Type *getType();
2075
2076	private:
2077		void constant(float x, float y, float z, float w);
2078	};
2079
2080	RValue<Float4> operator+(RValue<Float4> lhs, RValue<Float4> rhs);
2081	RValue<Float4> operator-(RValue<Float4> lhs, RValue<Float4> rhs);
2082	RValue<Float4> operator*(RValue<Float4> lhs, RValue<Float4> rhs);
2083	RValue<Float4> operator/(RValue<Float4> lhs, RValue<Float4> rhs);
2084	RValue<Float4> operator%(RValue<Float4> lhs, RValue<Float4> rhs);
2085	RValue<Float4> operator+=(Float4 &lhs, RValue<Float4> rhs);
2086	RValue<Float4> operator-=(Float4 &lhs, RValue<Float4> rhs);
2087	RValue<Float4> operator*=(Float4 &lhs, RValue<Float4> rhs);
2088	RValue<Float4> operator/=(Float4 &lhs, RValue<Float4> rhs);
2089	RValue<Float4> operator%=(Float4 &lhs, RValue<Float4> rhs);
2090	RValue<Float4> operator+(RValue<Float4> val);
2091	RValue<Float4> operator-(RValue<Float4> val);
2092
2093	RValue<Float4> Abs(RValue<Float4> x);
2094	RValue<Float4> Max(RValue<Float4> x, RValue<Float4> y);
2095	RValue<Float4> Min(RValue<Float4> x, RValue<Float4> y);
2096	RValue<Float4> Rcp_pp(RValue<Float4> val, bool exactAtPow2 = false);
2097	RValue<Float4> RcpSqrt_pp(RValue<Float4> val);
2098	RValue<Float4> Sqrt(RValue<Float4> x);
2099	RValue<Float4> Insert(RValue<Float4> val, RValue<Float> element, int i);
2100	RValue<Float> Extract(RValue<Float4> x, int i);
2101	RValue<Float4> Swizzle(RValue<Float4> x, unsigned char select);
2102	RValue<Float4> ShuffleLowHigh(RValue<Float4> x, RValue<Float4> y, unsigned char imm);
2103	RValue<Float4> UnpackLow(RValue<Float4> x, RValue<Float4> y);
2104	RValue<Float4> UnpackHigh(RValue<Float4> x, RValue<Float4> y);
2105	RValue<Float4> Mask(Float4 &lhs, RValue<Float4> rhs, unsigned char select);
2106	RValue<Int> SignMask(RValue<Float4> x);
2107	RValue<Int4> CmpEQ(RValue<Float4> x, RValue<Float4> y);
2108	RValue<Int4> CmpLT(RValue<Float4> x, RValue<Float4> y);
2109	RValue<Int4> CmpLE(RValue<Float4> x, RValue<Float4> y);
2110	RValue<Int4> CmpNEQ(RValue<Float4> x, RValue<Float4> y);
2111	RValue<Int4> CmpNLT(RValue<Float4> x, RValue<Float4> y);
2112	RValue<Int4> CmpNLE(RValue<Float4> x, RValue<Float4> y);
2113	RValue<Float4> Round(RValue<Float4> x);
2114	RValue<Float4> Trunc(RValue<Float4> x);
2115	RValue<Float4> Frac(RValue<Float4> x);
2116	RValue<Float4> Floor(RValue<Float4> x);
2117	RValue<Float4> Ceil(RValue<Float4> x);
2118
2119	template<class T>
2120	class Pointer : public LValue<Pointer<T>>
2121	{
2122	public:
2123		template<class S>
2124		Pointer(RValue<Pointer<S>> pointerS, int alignment = 1) : alignment(alignment)
2125		{
2126			Value *pointerT = Nucleus::createBitCast(pointerS.value, Nucleus::getPointerType(T::getType()));
2127			LValue<Pointer<T>>::storeValue(pointerT);
2128		}
2129
2130		template<class S>
2131		Pointer(const Pointer<S> &pointer, int alignment = 1) : alignment(alignment)
2132		{
2133			Value *pointerS = pointer.loadValue();
2134			Value *pointerT = Nucleus::createBitCast(pointerS, Nucleus::getPointerType(T::getType()));
2135			LValue<Pointer<T>>::storeValue(pointerT);
2136		}
2137
2138		Pointer(Argument<Pointer<T>> argument);
2139
2140		Pointer();
2141		Pointer(RValue<Pointer<T>> rhs);
2142		Pointer(const Pointer<T> &rhs);
2143		Pointer(const Reference<Pointer<T>> &rhs);
2144
2145		RValue<Pointer<T>> operator=(RValue<Pointer<T>> rhs);
2146		RValue<Pointer<T>> operator=(const Pointer<T> &rhs);
2147		RValue<Pointer<T>> operator=(const Reference<Pointer<T>> &rhs);
2148
2149		Reference<T> operator*();
2150		Reference<T> operator[](int index);
2151		Reference<T> operator[](unsigned int index);
2152		Reference<T> operator[](RValue<Int> index);
2153		Reference<T> operator[](RValue<UInt> index);
2154
2155		static Type *getType();
2156
2157	private:
2158		const int alignment;
2159	};
2160
2161	RValue<Pointer<Byte>> operator+(RValue<Pointer<Byte>> lhs, int offset);
2162	RValue<Pointer<Byte>> operator+(RValue<Pointer<Byte>> lhs, RValue<Int> offset);
2163	RValue<Pointer<Byte>> operator+(RValue<Pointer<Byte>> lhs, RValue<UInt> offset);
2164	RValue<Pointer<Byte>> operator+=(Pointer<Byte> &lhs, int offset);
2165	RValue<Pointer<Byte>> operator+=(Pointer<Byte> &lhs, RValue<Int> offset);
2166	RValue<Pointer<Byte>> operator+=(Pointer<Byte> &lhs, RValue<UInt> offset);
2167
2168	RValue<Pointer<Byte>> operator-(RValue<Pointer<Byte>> lhs, int offset);
2169	RValue<Pointer<Byte>> operator-(RValue<Pointer<Byte>> lhs, RValue<Int> offset);
2170	RValue<Pointer<Byte>> operator-(RValue<Pointer<Byte>> lhs, RValue<UInt> offset);
2171	RValue<Pointer<Byte>> operator-=(Pointer<Byte> &lhs, int offset);
2172	RValue<Pointer<Byte>> operator-=(Pointer<Byte> &lhs, RValue<Int> offset);
2173	RValue<Pointer<Byte>> operator-=(Pointer<Byte> &lhs, RValue<UInt> offset);
2174
2175	template<class T, int S = 1>
2176	class Array : public LValue<T>
2177	{
2178	public:
2179		Array(int size = S);
2180
2181		Reference<T> operator[](int index);
2182		Reference<T> operator[](unsigned int index);
2183		Reference<T> operator[](RValue<Int> index);
2184		Reference<T> operator[](RValue<UInt> index);
2185	};
2186
2187//	RValue<Array<T>> operator++(Array<T> &val, int);   // Post-increment
2188//	const Array<T> &operator++(Array<T> &val);   // Pre-increment
2189//	RValue<Array<T>> operator--(Array<T> &val, int);   // Post-decrement
2190//	const Array<T> &operator--(Array<T> &val);   // Pre-decrement
2191
2192	void branch(RValue<Bool> cmp, BasicBlock *bodyBB, BasicBlock *endBB);
2193
2194	void Return();
2195	void Return(RValue<Int> ret);
2196
2197	template<class T>
2198	void Return(const Pointer<T> &ret);
2199
2200	template<class T>
2201	void Return(RValue<Pointer<T>> ret);
2202
2203	template<unsigned int index, typename... Arguments>
2204	struct ArgI;
2205
2206	template<typename Arg0, typename... Arguments>
2207	struct ArgI<0, Arg0, Arguments...>
2208	{
2209		typedef Arg0 Type;
2210	};
2211
2212	template<unsigned int index, typename Arg0, typename... Arguments>
2213	struct ArgI<index, Arg0, Arguments...>
2214	{
2215		typedef typename ArgI<index - 1, Arguments...>::Type Type;
2216	};
2217
2218	// Generic template, leave undefined!
2219	template<typename FunctionType>
2220	class Function;
2221
2222	// Specialized for function types
2223	template<typename Return, typename... Arguments>
2224	class Function<Return(Arguments...)>
2225	{
2226	public:
2227		Function();
2228
2229		virtual ~Function();
2230
2231		template<int index>
2232		Argument<typename ArgI<index, Arguments...>::Type> Arg() const
2233		{
2234			Value *arg = Nucleus::getArgument(index);
2235			return Argument<typename ArgI<index, Arguments...>::Type>(arg);
2236		}
2237
2238		Routine *operator()(const wchar_t *name, ...);
2239
2240	protected:
2241		Nucleus *core;
2242		std::vector<Type*> arguments;
2243	};
2244
2245	template<typename Return>
2246	class Function<Return()> : public Function<Return(Void)>
2247	{
2248	};
2249
2250	template<int index, typename Return, typename... Arguments>
2251	Argument<typename ArgI<index, Arguments...>::Type> Arg(Function<Return(Arguments...)> &function)
2252	{
2253		return Argument<typename ArgI<index, Arguments...>::Type>(function.arg(index));
2254	}
2255
2256	RValue<Long> Ticks();
2257}
2258
2259namespace sw
2260{
2261	template<class T>
2262	LValue<T>::LValue(int arraySize)
2263	{
2264		address = Nucleus::allocateStackVariable(T::getType(), arraySize);
2265	}
2266
2267	template<class T>
2268	Value *LValue<T>::loadValue() const
2269	{
2270		return Nucleus::createLoad(address, T::getType(), false, 0);
2271	}
2272
2273	template<class T>
2274	Value *LValue<T>::storeValue(Value *value) const
2275	{
2276		return Nucleus::createStore(value, address, T::getType(), false, 0);
2277	}
2278
2279	template<class T>
2280	Value *LValue<T>::getAddress(Value *index, bool unsignedIndex) const
2281	{
2282		return Nucleus::createGEP(address, T::getType(), index, unsignedIndex);
2283	}
2284
2285	template<class T>
2286	RValue<Pointer<T>> LValue<T>::operator&()
2287	{
2288		return RValue<Pointer<T>>(address);
2289	}
2290
2291	template<class T>
2292	Reference<T>::Reference(Value *pointer, int alignment) : alignment(alignment)
2293	{
2294		address = pointer;
2295	}
2296
2297	template<class T>
2298	RValue<T> Reference<T>::operator=(RValue<T> rhs) const
2299	{
2300		Nucleus::createStore(rhs.value, address, T::getType(), false, alignment);
2301
2302		return rhs;
2303	}
2304
2305	template<class T>
2306	RValue<T> Reference<T>::operator=(const Reference<T> &ref) const
2307	{
2308		Value *tmp = Nucleus::createLoad(ref.address, T::getType(), false, ref.alignment);
2309		Nucleus::createStore(tmp, address, T::getType(), false, alignment);
2310
2311		return RValue<T>(tmp);
2312	}
2313
2314	template<class T>
2315	RValue<T> Reference<T>::operator+=(RValue<T> rhs) const
2316	{
2317		return *this = *this + rhs;
2318	}
2319
2320	template<class T>
2321	Value *Reference<T>::loadValue() const
2322	{
2323		return Nucleus::createLoad(address, T::getType(), false, alignment);
2324	}
2325
2326	template<class T>
2327	int Reference<T>::getAlignment() const
2328	{
2329		return alignment;
2330	}
2331
2332	template<class T>
2333	RValue<T>::RValue(Value *rvalue)
2334	{
2335		assert(Nucleus::createBitCast(rvalue, T::getType()) == rvalue);   // Run-time type should match T, so bitcast is no-op.
2336
2337		value = rvalue;
2338	}
2339
2340	template<class T>
2341	RValue<T>::RValue(const T &lvalue)
2342	{
2343		value = lvalue.loadValue();
2344	}
2345
2346	template<class T>
2347	RValue<T>::RValue(typename IntLiteral<T>::type i)
2348	{
2349		value = Nucleus::createConstantInt(i);
2350	}
2351
2352	template<class T>
2353	RValue<T>::RValue(typename FloatLiteral<T>::type f)
2354	{
2355		value = Nucleus::createConstantFloat(f);
2356	}
2357
2358	template<class T>
2359	RValue<T>::RValue(const Reference<T> &ref)
2360	{
2361		value = ref.loadValue();
2362	}
2363
2364	template<class Vector4, int T>
2365	Swizzle2<Vector4, T>::operator RValue<Vector4>() const
2366	{
2367		Value *vector = parent->loadValue();
2368
2369		return Swizzle(RValue<Vector4>(vector), T);
2370	}
2371
2372	template<class Vector4, int T>
2373	Swizzle4<Vector4, T>::operator RValue<Vector4>() const
2374	{
2375		Value *vector = parent->loadValue();
2376
2377		return Swizzle(RValue<Vector4>(vector), T);
2378	}
2379
2380	template<class Vector4, int T>
2381	SwizzleMask4<Vector4, T>::operator RValue<Vector4>() const
2382	{
2383		Value *vector = parent->loadValue();
2384
2385		return Swizzle(RValue<Vector4>(vector), T);
2386	}
2387
2388	template<class Vector4, int T>
2389	RValue<Vector4> SwizzleMask4<Vector4, T>::operator=(RValue<Vector4> rhs)
2390	{
2391		return Mask(*parent, rhs, T);
2392	}
2393
2394	template<class Vector4, int T>
2395	RValue<Vector4> SwizzleMask4<Vector4, T>::operator=(RValue<typename Scalar<Vector4>::Type> rhs)
2396	{
2397		return Mask(*parent, Vector4(rhs), T);
2398	}
2399
2400	template<class Vector4, int T>
2401	SwizzleMask1<Vector4, T>::operator RValue<typename Scalar<Vector4>::Type>() const   // FIXME: Call a non-template function
2402	{
2403		return Extract(*parent, T & 0x3);
2404	}
2405
2406	template<class Vector4, int T>
2407	SwizzleMask1<Vector4, T>::operator RValue<Vector4>() const
2408	{
2409		Value *vector = parent->loadValue();
2410
2411		return Swizzle(RValue<Vector4>(vector), T);
2412	}
2413
2414	template<class Vector4, int T>
2415	RValue<Vector4> SwizzleMask1<Vector4, T>::operator=(float x)
2416	{
2417		return *parent = Insert(*parent, Float(x), T & 0x3);
2418	}
2419
2420	template<class Vector4, int T>
2421	RValue<Vector4> SwizzleMask1<Vector4, T>::operator=(RValue<Vector4> rhs)
2422	{
2423		return Mask(*parent, Float4(rhs), T);
2424	}
2425
2426	template<class Vector4, int T>
2427	RValue<Vector4> SwizzleMask1<Vector4, T>::operator=(RValue<typename Scalar<Vector4>::Type> rhs)   // FIXME: Call a non-template function
2428	{
2429		return *parent = Insert(*parent, rhs, T & 0x3);
2430	}
2431
2432	template<class Vector4, int T>
2433	SwizzleMask2<Vector4, T>::operator RValue<Vector4>() const
2434	{
2435		Value *vector = parent->loadValue();
2436
2437		return Swizzle(RValue<Float4>(vector), T);
2438	}
2439
2440	template<class Vector4, int T>
2441	RValue<Vector4> SwizzleMask2<Vector4, T>::operator=(RValue<Vector4> rhs)
2442	{
2443		return Mask(*parent, Float4(rhs), T);
2444	}
2445
2446	template<int T>
2447	Float::Float(const SwizzleMask1<Float4, T> &rhs)
2448	{
2449		*this = rhs.operator RValue<Float>();
2450	}
2451
2452	template<int T>
2453	RValue<Float> Float::operator=(const SwizzleMask1<Float4, T> &rhs)
2454	{
2455		return *this = rhs.operator RValue<Float>();
2456	}
2457
2458	template<int T>
2459	Float4::Float4(const SwizzleMask1<Float4, T> &rhs) : XYZW(this)
2460	{
2461		*this = rhs.operator RValue<Float4>();
2462	}
2463
2464	template<int T>
2465	Float4::Float4(const Swizzle4<Float4, T> &rhs) : XYZW(this)
2466	{
2467		*this = rhs.operator RValue<Float4>();
2468	}
2469
2470	template<int X, int Y>
2471	Float4::Float4(const Swizzle2<Float4, X> &x, const Swizzle2<Float4, Y> &y) : XYZW(this)
2472	{
2473		*this = ShuffleLowHigh(*x.parent, *y.parent, (X & 0xF) | (Y & 0xF) << 4);
2474	}
2475
2476	template<int X, int Y>
2477	Float4::Float4(const SwizzleMask2<Float4, X> &x, const Swizzle2<Float4, Y> &y) : XYZW(this)
2478	{
2479		*this = ShuffleLowHigh(*x.parent, *y.parent, (X & 0xF) | (Y & 0xF) << 4);
2480	}
2481
2482	template<int X, int Y>
2483	Float4::Float4(const Swizzle2<Float4, X> &x, const SwizzleMask2<Float4, Y> &y) : XYZW(this)
2484	{
2485		*this = ShuffleLowHigh(*x.parent, *y.parent, (X & 0xF) | (Y & 0xF) << 4);
2486	}
2487
2488	template<int X, int Y>
2489	Float4::Float4(const SwizzleMask2<Float4, X> &x, const SwizzleMask2<Float4, Y> &y) : XYZW(this)
2490	{
2491		*this = ShuffleLowHigh(*x.parent, *y.parent, (X & 0xF) | (Y & 0xF) << 4);
2492	}
2493
2494	template<int T>
2495	RValue<Float4> Float4::operator=(const SwizzleMask1<Float4, T> &rhs)
2496	{
2497		return *this = rhs.operator RValue<Float4>();
2498	}
2499
2500	template<int T>
2501	RValue<Float4> Float4::operator=(const Swizzle4<Float4, T> &rhs)
2502	{
2503		return *this = rhs.operator RValue<Float4>();
2504	}
2505
2506	template<class T>
2507	Pointer<T>::Pointer(Argument<Pointer<T>> argument) : alignment(1)
2508	{
2509		LValue<Pointer<T>>::storeValue(argument.value);
2510	}
2511
2512	template<class T>
2513	Pointer<T>::Pointer() : alignment(1)
2514	{
2515		LValue<Pointer<T>>::storeValue(Nucleus::createNullPointer(T::getType()));
2516	}
2517
2518	template<class T>
2519	Pointer<T>::Pointer(RValue<Pointer<T>> rhs) : alignment(1)
2520	{
2521		LValue<Pointer<T>>::storeValue(rhs.value);
2522	}
2523
2524	template<class T>
2525	Pointer<T>::Pointer(const Pointer<T> &rhs) : alignment(rhs.alignment)
2526	{
2527		Value *value = rhs.loadValue();
2528		LValue<Pointer<T>>::storeValue(value);
2529	}
2530
2531	template<class T>
2532	Pointer<T>::Pointer(const Reference<Pointer<T>> &rhs) : alignment(rhs.getAlignment())
2533	{
2534		Value *value = rhs.loadValue();
2535		LValue<Pointer<T>>::storeValue(value);
2536	}
2537
2538	template<class T>
2539	RValue<Pointer<T>> Pointer<T>::operator=(RValue<Pointer<T>> rhs)
2540	{
2541		LValue<Pointer<T>>::storeValue(rhs.value);
2542
2543		return rhs;
2544	}
2545
2546	template<class T>
2547	RValue<Pointer<T>> Pointer<T>::operator=(const Pointer<T> &rhs)
2548	{
2549		Value *value = rhs.loadValue();
2550		LValue<Pointer<T>>::storeValue(value);
2551
2552		return RValue<Pointer<T>>(value);
2553	}
2554
2555	template<class T>
2556	RValue<Pointer<T>> Pointer<T>::operator=(const Reference<Pointer<T>> &rhs)
2557	{
2558		Value *value = rhs.loadValue();
2559		LValue<Pointer<T>>::storeValue(value);
2560
2561		return RValue<Pointer<T>>(value);
2562	}
2563
2564	template<class T>
2565	Reference<T> Pointer<T>::operator*()
2566	{
2567		return Reference<T>(LValue<Pointer<T>>::loadValue(), alignment);
2568	}
2569
2570	template<class T>
2571	Reference<T> Pointer<T>::operator[](int index)
2572	{
2573		Value *element = Nucleus::createGEP(LValue<Pointer<T>>::loadValue(), T::getType(), Nucleus::createConstantInt(index), false);
2574
2575		return Reference<T>(element, alignment);
2576	}
2577
2578	template<class T>
2579	Reference<T> Pointer<T>::operator[](unsigned int index)
2580	{
2581		Value *element = Nucleus::createGEP(LValue<Pointer<T>>::loadValue(), T::getType(), Nucleus::createConstantInt(index), true);
2582
2583		return Reference<T>(element, alignment);
2584	}
2585
2586	template<class T>
2587	Reference<T> Pointer<T>::operator[](RValue<Int> index)
2588	{
2589		Value *element = Nucleus::createGEP(LValue<Pointer<T>>::loadValue(), T::getType(), index.value, false);
2590
2591		return Reference<T>(element, alignment);
2592	}
2593
2594	template<class T>
2595	Reference<T> Pointer<T>::operator[](RValue<UInt> index)
2596	{
2597		Value *element = Nucleus::createGEP(LValue<Pointer<T>>::loadValue(), T::getType(), index.value, true);
2598
2599		return Reference<T>(element, alignment);
2600	}
2601
2602	template<class T>
2603	Type *Pointer<T>::getType()
2604	{
2605		return Nucleus::getPointerType(T::getType());
2606	}
2607
2608	template<class T, int S>
2609	Array<T, S>::Array(int size) : LValue<T>(size)
2610	{
2611	}
2612
2613	template<class T, int S>
2614	Reference<T> Array<T, S>::operator[](int index)
2615	{
2616		Value *element = LValue<T>::getAddress(Nucleus::createConstantInt(index), false);
2617
2618		return Reference<T>(element);
2619	}
2620
2621	template<class T, int S>
2622	Reference<T> Array<T, S>::operator[](unsigned int index)
2623	{
2624		Value *element = LValue<T>::getAddress(Nucleus::createConstantInt(index), true);
2625
2626		return Reference<T>(element);
2627	}
2628
2629	template<class T, int S>
2630	Reference<T> Array<T, S>::operator[](RValue<Int> index)
2631	{
2632		Value *element = LValue<T>::getAddress(index.value, false);
2633
2634		return Reference<T>(element);
2635	}
2636
2637	template<class T, int S>
2638	Reference<T> Array<T, S>::operator[](RValue<UInt> index)
2639	{
2640		Value *element = LValue<T>::getAddress(index.value, true);
2641
2642		return Reference<T>(element);
2643	}
2644
2645//	template<class T>
2646//	RValue<Array<T>> operator++(Array<T> &val, int)
2647//	{
2648//		// FIXME: Requires storing the address of the array
2649//	}
2650
2651//	template<class T>
2652//	const Array<T> &operator++(Array<T> &val)
2653//	{
2654//		// FIXME: Requires storing the address of the array
2655//	}
2656
2657//	template<class T>
2658//	RValue<Array<T>> operator--(Array<T> &val, int)
2659//	{
2660//		// FIXME: Requires storing the address of the array
2661//	}
2662
2663//	template<class T>
2664//	const Array<T> &operator--(Array<T> &val)
2665//	{
2666//		// FIXME: Requires storing the address of the array
2667//	}
2668
2669	template<class T>
2670	RValue<T> IfThenElse(RValue<Bool> condition, RValue<T> ifTrue, RValue<T> ifFalse)
2671	{
2672		return RValue<T>(Nucleus::createSelect(condition.value, ifTrue.value, ifFalse.value));
2673	}
2674
2675	template<class T>
2676	RValue<T> IfThenElse(RValue<Bool> condition, const T &ifTrue, RValue<T> ifFalse)
2677	{
2678		Value *trueValue = ifTrue.loadValue();
2679
2680		return RValue<T>(Nucleus::createSelect(condition.value, trueValue, ifFalse.value));
2681	}
2682
2683	template<class T>
2684	RValue<T> IfThenElse(RValue<Bool> condition, RValue<T> ifTrue, const T &ifFalse)
2685	{
2686		Value *falseValue = ifFalse.loadValue();
2687
2688		return RValue<T>(Nucleus::createSelect(condition.value, ifTrue.value, falseValue));
2689	}
2690
2691	template<class T>
2692	RValue<T> IfThenElse(RValue<Bool> condition, const T &ifTrue, const T &ifFalse)
2693	{
2694		Value *trueValue = ifTrue.loadValue();
2695		Value *falseValue = ifFalse.loadValue();
2696
2697		return RValue<T>(Nucleus::createSelect(condition.value, trueValue, falseValue));
2698	}
2699
2700	template<class T>
2701	void Return(const Pointer<T> &ret)
2702	{
2703		Nucleus::createRet(Nucleus::createLoad(ret.address, Pointer<T>::getType()));
2704		Nucleus::setInsertBlock(Nucleus::createBasicBlock());
2705	}
2706
2707	template<class T>
2708	void Return(RValue<Pointer<T>> ret)
2709	{
2710		Nucleus::createRet(ret.value);
2711		Nucleus::setInsertBlock(Nucleus::createBasicBlock());
2712	}
2713
2714	template<typename Return, typename... Arguments>
2715	Function<Return(Arguments...)>::Function()
2716	{
2717		core = new Nucleus();
2718
2719		Type *types[] = {Arguments::getType()...};
2720		for(Type *type : types)
2721		{
2722			if(type != Void::getType())
2723			{
2724				arguments.push_back(type);
2725			}
2726		}
2727
2728		Nucleus::createFunction(Return::getType(), arguments);
2729	}
2730
2731	template<typename Return, typename... Arguments>
2732	Function<Return(Arguments...)>::~Function()
2733	{
2734		delete core;
2735	}
2736
2737	template<typename Return, typename... Arguments>
2738	Routine *Function<Return(Arguments...)>::operator()(const wchar_t *name, ...)
2739	{
2740		wchar_t fullName[1024 + 1];
2741
2742		va_list vararg;
2743		va_start(vararg, name);
2744		vswprintf(fullName, 1024, name, vararg);
2745		va_end(vararg);
2746
2747		return core->acquireRoutine(fullName, true);
2748	}
2749
2750	template<class T, class S>
2751	RValue<T> ReinterpretCast(RValue<S> val)
2752	{
2753		return RValue<T>(Nucleus::createBitCast(val.value, T::getType()));
2754	}
2755
2756	template<class T, class S>
2757	RValue<T> ReinterpretCast(const LValue<S> &var)
2758	{
2759		Value *val = var.loadValue();
2760
2761		return RValue<T>(Nucleus::createBitCast(val, T::getType()));
2762	}
2763
2764	template<class T, class S>
2765	RValue<T> ReinterpretCast(const Reference<S> &var)
2766	{
2767		return ReinterpretCast<T>(RValue<S>(var));
2768	}
2769
2770	template<class T>
2771	RValue<T> As(Value *val)
2772	{
2773		return RValue<T>(Nucleus::createBitCast(val, T::getType()));
2774	}
2775
2776	template<class T, class S>
2777	RValue<T> As(RValue<S> val)
2778	{
2779		return ReinterpretCast<T>(val);
2780	}
2781
2782	template<class T, class S>
2783	RValue<T> As(const LValue<S> &var)
2784	{
2785		return ReinterpretCast<T>(var);
2786	}
2787
2788	template<class T, class S>
2789	RValue<T> As(const Reference<S> &val)
2790	{
2791		return ReinterpretCast<T>(val);
2792	}
2793
2794	class ForData
2795	{
2796	public:
2797		ForData(bool init) : loopOnce(init)
2798		{
2799		}
2800
2801		operator bool()
2802		{
2803			return loopOnce;
2804		}
2805
2806		bool operator=(bool value)
2807		{
2808			return loopOnce = value;
2809		}
2810
2811		bool setup()
2812		{
2813			if(Nucleus::getInsertBlock() != endBB)
2814			{
2815				testBB = Nucleus::createBasicBlock();
2816
2817				Nucleus::createBr(testBB);
2818				Nucleus::setInsertBlock(testBB);
2819
2820				return true;
2821			}
2822
2823			return false;
2824		}
2825
2826		bool test(RValue<Bool> cmp)
2827		{
2828			BasicBlock *bodyBB = Nucleus::createBasicBlock();
2829			endBB = Nucleus::createBasicBlock();
2830
2831			Nucleus::createCondBr(cmp.value, bodyBB, endBB);
2832			Nucleus::setInsertBlock(bodyBB);
2833
2834			return true;
2835		}
2836
2837		void end()
2838		{
2839			Nucleus::createBr(testBB);
2840			Nucleus::setInsertBlock(endBB);
2841		}
2842
2843	private:
2844		BasicBlock *testBB = nullptr;
2845		BasicBlock *endBB = nullptr;
2846		bool loopOnce = true;
2847	};
2848
2849	class IfElseData
2850	{
2851	public:
2852		IfElseData(RValue<Bool> cmp) : iteration(0)
2853		{
2854			condition = cmp.value;
2855
2856			beginBB = Nucleus::getInsertBlock();
2857			trueBB = Nucleus::createBasicBlock();
2858			falseBB = nullptr;
2859			endBB = Nucleus::createBasicBlock();
2860
2861			Nucleus::setInsertBlock(trueBB);
2862		}
2863
2864		~IfElseData()
2865		{
2866			Nucleus::createBr(endBB);
2867
2868			Nucleus::setInsertBlock(beginBB);
2869			Nucleus::createCondBr(condition, trueBB, falseBB ? falseBB : endBB);
2870
2871			Nucleus::setInsertBlock(endBB);
2872		}
2873
2874		operator int()
2875		{
2876			return iteration;
2877		}
2878
2879		IfElseData &operator++()
2880		{
2881			++iteration;
2882
2883			return *this;
2884		}
2885
2886		void elseClause()
2887		{
2888			Nucleus::createBr(endBB);
2889
2890			falseBB = Nucleus::createBasicBlock();
2891			Nucleus::setInsertBlock(falseBB);
2892		}
2893
2894	private:
2895		Value *condition;
2896		BasicBlock *beginBB;
2897		BasicBlock *trueBB;
2898		BasicBlock *falseBB;
2899		BasicBlock *endBB;
2900		int iteration;
2901	};
2902
2903	#define For(init, cond, inc) \
2904	for(ForData for__ = true; for__; for__ = false) \
2905	for(init; for__.setup() && for__.test(cond); inc, for__.end())
2906
2907	#define While(cond) For((void)0, cond, (void)0)
2908
2909	#define Do                                            \
2910	{                                                     \
2911		BasicBlock *body__ = Nucleus::createBasicBlock(); \
2912		Nucleus::createBr(body__);                        \
2913		Nucleus::setInsertBlock(body__);
2914
2915	#define Until(cond)                                     \
2916		BasicBlock *end__ = Nucleus::createBasicBlock();    \
2917		Nucleus::createCondBr((cond).value, end__, body__); \
2918		Nucleus::setInsertBlock(end__);                     \
2919	}
2920
2921	enum {IF_BLOCK__, ELSE_CLAUSE__, ELSE_BLOCK__, IFELSE_NUM__};
2922
2923	#define If(cond)                                                    \
2924	for(IfElseData ifElse__(cond); ifElse__ < IFELSE_NUM__; ++ifElse__) \
2925	if(ifElse__ == IF_BLOCK__)
2926
2927	#define Else                       \
2928	else if(ifElse__ == ELSE_CLAUSE__) \
2929	{                                  \
2930		 ifElse__.elseClause();        \
2931	}                                  \
2932	else   // ELSE_BLOCK__
2933}
2934
2935#endif   // sw_Reactor_hpp
2936