4coder-non-source/test_data/lots_of_files/amp_short_vectors.h

/***
* ==++==
*
* Copyright (c) Microsoft Corporation.  All rights reserved.
*
* ==--==
* =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
*
* amp_short_vectors.h
*
* C++ AMP Short Vector Types
*
* =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
****/


// !!! DO NOT HAND EDIT !!!
// This file was generated.

#pragma once

#pragma warning(push)
#pragma warning(disable : 4100)
#include <amp.h>
#define _AMP_SHORT_VECTORS_H
namespace Concurrency
{
    namespace graphics
    {
        class unorm;
        class norm;

        /// <summary>
        ///     Represent a unorm number.
        ///     Each element is a floating point number in the range of [0.0f, 1.0f].
        /// </summary>
        class unorm
        {
            friend class norm;
        private:
            float _Value;
            void _Set(float _Val) __CPU_ONLY
            {
                _Val = _Val < 0.0f ? 0.0f : _Val;
                _Val = _Val > 1.0f ? 1.0f : _Val;
                _Value = _Val;
            }

            void _Set(float _Val) __GPU_ONLY
            {
                _Value = Concurrency::direct3d::clamp(_Val, 0.0f, 1.0f);
            }
        public:

            /// <summary>
            ///     Default constructor. Initialize to 0.0f.
            /// </summary>
            unorm(void) __GPU
            {
                _Value = 0.0f;
            }

            /// <summary>
            ///     Constructor. Initialize by clamping _V to the range of [0.0f, 1.0f].
            /// </summary>
            /// <param name="_V">
            ///     The value used to initialize.
            /// </param>
            explicit unorm(float _V) __GPU
            {
                _Set(_V);
            }

            /// <summary>
            ///     Constructor. Initialize by casting _V to float, then clamping to the range of [0.0f, 1.0f].
            /// </summary>
            /// <param name="_V">
            ///     The value used to initialize.
            /// </param>
            explicit unorm(unsigned int _V) __GPU
            {
                _Set(static_cast<float>(_V));
            }

            /// <summary>
            ///     Constructor. Initialize by casting _V to float, then clamping to the range of [0.0f, 1.0f].
            /// </summary>
            /// <param name="_V">
            ///     The value used to initialize.
            /// </param>
            explicit unorm(int _V) __GPU
            {
                _Set(static_cast<float>(_V));
            }

            /// <summary>
            ///     Constructor. Initialize by casting _V to float, then clamping to the range of [0.0f, 1.0f].
            /// </summary>
            /// <param name="_V">
            ///     The value used to initialize.
            /// </param>
            explicit unorm(double _V) __GPU
            {
                _Set(static_cast<float>(_V));
            }

            /// <summary>
            ///     Copy constructor.
            /// </summary>
            /// <param name="_Other">
            ///     The object to copy from.
            /// </param>
            unorm(const unorm& _Other) __GPU
            {
                _Value = _Other._Value;
            }

            /// <summary>
            ///     Constructor. Initialize by clamping _Other to the range of [0.0f, 1.0f].
            /// </summary>
            /// <param name="_Other">
            ///     The norm object used to initialize.
            /// </param>
            inline explicit unorm(const norm& _Other) __GPU;

            unorm& operator=(const unorm& _Other) __GPU
            {
                _Value = _Other._Value;
                return *this;
            }

            /// <summary>
            ///     Conversion operator. Convert the unorm number to a floating point value.
            /// </summary>
            operator float(void) const __GPU
            {
                return _Value;
            }

            unorm& operator+=(const unorm& _Other) __GPU
            {
                float _Res = _Value;
                _Res += _Other._Value;
                _Set(_Res);
                return *this;
            }

            unorm& operator-=(const unorm& _Other) __GPU
            {
                float _Res = _Value;
                _Res -= _Other._Value;
                _Set(_Res);
                return *this;
            }

            unorm& operator*=(const unorm& _Other) __GPU
            {
                float _Res = _Value;
                _Res *= _Other._Value;
                _Set(_Res);
                return *this;
            }

            unorm& operator/=(const unorm& _Other) __GPU
            {
                float _Res = _Value;
                _Res /= _Other._Value;
                _Set(_Res);
                return *this;
            }

            unorm& operator++() __GPU
            {
                float _Res = _Value;
                ++_Res;
                _Set(_Res);
                return *this;
            }

            unorm operator++(int) __GPU
            {
                unorm _Res = *this;
                ++(*this);
                return _Res;
            }

            unorm& operator--() __GPU
            {
                float _Res = _Value;
                --_Res;
                _Set(_Res);
                return *this;
            }

            unorm operator--(int) __GPU
            {
                unorm _Res = *this;
                --(*this);
                return _Res;
            }

        };

        /// <summary>
        ///     Represent a norm number.
        ///     Each element is a floating point number in the range of [-1.0f, 1.0f].
        /// </summary>
        class norm
        {
            friend class unorm;
        private:
            float _Value;
            void _Set(float _Val) __CPU_ONLY
            {
                _Val = _Val < -1.0f ? -1.0f : _Val;
                _Val = _Val > 1.0f ? 1.0f : _Val;
                _Value = _Val;
            }

            void _Set(float _Val) __GPU_ONLY
            {
                _Value = Concurrency::direct3d::clamp(_Val, -1.0f, 1.0f);
            }
        public:

            /// <summary>
            ///     Default constructor. Initialize to 0.0f.
            /// </summary>
            norm(void) __GPU
            {
                _Value = 0.0f;
            }

            /// <summary>
            ///     Constructor. Initialize by clamping _V to the range of [-1.0f, 1.0f].
            /// </summary>
            /// <param name="_V">
            ///     The value used to initialize.
            /// </param>
            explicit norm(float _V) __GPU
            {
                _Set(_V);
            }

            /// <summary>
            ///     Constructor. Initialize by casting _V to float, then clamping to the range of [-1.0f, 1.0f].
            /// </summary>
            /// <param name="_V">
            ///     The value used to initialize.
            /// </param>
            explicit norm(unsigned int _V) __GPU
            {
                _Set(static_cast<float>(_V));
            }

            /// <summary>
            ///     Constructor. Initialize by casting _V to float, then clamping to the range of [-1.0f, 1.0f].
            /// </summary>
            /// <param name="_V">
            ///     The value used to initialize.
            /// </param>
            explicit norm(int _V) __GPU
            {
                _Set(static_cast<float>(_V));
            }

            /// <summary>
            ///     Constructor. Initialize by casting _V to float, then clamping to the range of [-1.0f, 1.0f].
            /// </summary>
            /// <param name="_V">
            ///     The value used to initialize.
            /// </param>
            explicit norm(double _V) __GPU
            {
                _Set(static_cast<float>(_V));
            }

            /// <summary>
            ///     Copy constructor.
            /// </summary>
            /// <param name="_Other">
            ///     The object to copy from.
            /// </param>
            norm(const norm& _Other) __GPU
            {
                _Value = _Other._Value;
            }

            /// <summary>
            ///     Constructor.
            /// </summary>
            /// <param name="_Other">
            ///     The object used to initialize.
            /// </param>
            norm(const unorm& _Other) __GPU
            {
                _Value = _Other._Value;
            }

            norm& operator=(const norm& _Other) __GPU
            {
                _Value = _Other._Value;
                return *this;
            }

            /// <summary>
            ///     Conversion operator. Convert the norm number to a floating point value.
            /// </summary>
            operator float(void) const __GPU
            {
                return _Value;
            }

            norm& operator+=(const norm& _Other) __GPU
            {
                float _Res = _Value;
                _Res += _Other._Value;
                _Set(_Res);
                return *this;
            }

            norm& operator-=(const norm& _Other) __GPU
            {
                float _Res = _Value;
                _Res -= _Other._Value;
                _Set(_Res);
                return *this;
            }

            norm& operator*=(const norm& _Other) __GPU
            {
                float _Res = _Value;
                _Res *= _Other._Value;
                _Set(_Res);
                return *this;
            }

            norm& operator/=(const norm& _Other) __GPU
            {
                float _Res = _Value;
                _Res /= _Other._Value;
                _Set(_Res);
                return *this;
            }

            norm& operator++() __GPU
            {
                float _Res = _Value;
                ++_Res;
                _Set(_Res);
                return *this;
            }

            norm operator++(int) __GPU
            {
                norm _Res = *this;
                ++(*this);
                return _Res;
            }

            norm& operator--() __GPU
            {
                float _Res = _Value;
                --_Res;
                _Set(_Res);
                return *this;
            }

            norm operator--(int) __GPU
            {
                norm _Res = *this;
                --(*this);
                return _Res;
            }

            norm operator-(void) const __GPU
            {
                norm _Ret;
                _Ret._Value = -_Value;
                return _Ret;
            }

        };

        unorm::unorm(const norm& _Other) __GPU
        {
            _Set(_Other._Value);
        }

        inline unorm operator+(const unorm& _Lhs, const unorm& _Rhs) __GPU
        {
            return unorm(float(_Lhs) + float(_Rhs));
        }

        inline norm operator+(const norm& _Lhs, const norm& _Rhs) __GPU
        {
            return norm(float(_Lhs) + float(_Rhs));
        }

        inline unorm operator-(const unorm& _Lhs, const unorm& _Rhs) __GPU
        {
            return unorm(float(_Lhs) - float(_Rhs));
        }

        inline norm operator-(const norm& _Lhs, const norm& _Rhs) __GPU
        {
            return norm(float(_Lhs) - float(_Rhs));
        }

        inline unorm operator*(const unorm& _Lhs, const unorm& _Rhs) __GPU
        {
            return unorm(float(_Lhs) * float(_Rhs));
        }

        inline norm operator*(const norm& _Lhs, const norm& _Rhs) __GPU
        {
            return norm(float(_Lhs) * float(_Rhs));
        }

        inline unorm operator/(const unorm& _Lhs, const unorm& _Rhs) __GPU
        {
            return unorm(float(_Lhs) / float(_Rhs));
        }

        inline norm operator/(const norm& _Lhs, const norm& _Rhs) __GPU
        {
            return norm(float(_Lhs) / float(_Rhs));
        }

        inline bool operator==(const unorm& _Lhs, const unorm& _Rhs) __GPU
        {
            return float(_Lhs) == float(_Rhs);
        }

        inline bool operator==(const norm& _Lhs, const norm& _Rhs) __GPU
        {
            return float(_Lhs) == float(_Rhs);
        }

        inline bool operator!=(const unorm& _Lhs, const unorm& _Rhs) __GPU
        {
            return float(_Lhs) != float(_Rhs);
        }

        inline bool operator!=(const norm& _Lhs, const norm& _Rhs) __GPU
        {
            return float(_Lhs) != float(_Rhs);
        }

        inline bool operator>(const unorm& _Lhs, const unorm& _Rhs) __GPU
        {
            return float(_Lhs) > float(_Rhs);
        }

        inline bool operator>(const norm& _Lhs, const norm& _Rhs) __GPU
        {
            return float(_Lhs) > float(_Rhs);
        }

        inline bool operator<(const unorm& _Lhs, const unorm& _Rhs) __GPU
        {
            return float(_Lhs) < float(_Rhs);
        }

        inline bool operator<(const norm& _Lhs, const norm& _Rhs) __GPU
        {
            return float(_Lhs) < float(_Rhs);
        }

        inline bool operator>=(const unorm& _Lhs, const unorm& _Rhs) __GPU
        {
            return float(_Lhs) >= float(_Rhs);
        }

        inline bool operator>=(const norm& _Lhs, const norm& _Rhs) __GPU
        {
            return float(_Lhs) >= float(_Rhs);
        }

        inline bool operator<=(const unorm& _Lhs, const unorm& _Rhs) __GPU
        {
            return float(_Lhs) <= float(_Rhs);
        }

        inline bool operator<=(const norm& _Lhs, const norm& _Rhs) __GPU
        {
            return float(_Lhs) <= float(_Rhs);
        }

#define UNORM_ZERO ((concurrency::graphics::unorm)0.0f)
#define UNORM_MIN ((concurrency::graphics::unorm)0.0f)
#define UNORM_MAX ((concurrency::graphics::unorm)1.0f)
#define NORM_ZERO ((concurrency::graphics::norm)0.0f)
#define NORM_MIN  ((concurrency::graphics::norm)-1.0f)
#define NORM_MAX  ((concurrency::graphics::norm)1.0f)


        typedef unsigned int uint;
        // Forward Declarations
        class uint_2;
        class uint_3;
        class uint_4;
        class int_2;
        class int_3;
        class int_4;
        class float_2;
        class float_3;
        class float_4;
        class unorm_2;
        class unorm_3;
        class unorm_4;
        class norm_2;
        class norm_3;
        class norm_4;
        class double_2;
        class double_3;
        class double_4;

        /// <summary>
        ///    Represent a short vector of 2 unsigned int's.
        /// </summary>
        class uint_2
        {
        public:
            typedef unsigned int value_type;
            static const int size = 2;
        private:
            static const _Short_vector_base_type_id _Base_type_id = _Uint_type;
        private:
            value_type _M_x;
            value_type _M_y;

        public:
            /// <summary>
            ///     Property for accessing element 0 of this uint_2 as an unsigned int.
            /// </summary>
            __declspec( property( get=get_x, put=set_x) ) unsigned int x;
            /// <summary>
            ///     Property for accessing element 0 of this uint_2 as an unsigned int.
            /// </summary>
            __declspec( property( get=get_x, put=set_x) ) unsigned int r;

            /// <summary>
            ///     Returns element 0 of this uint_2.
            /// </summary>
            /// <returns>
            ///     Element 0 of this uint_2.
            /// </returns>
            unsigned int get_x() const __GPU {
                return _M_x;
            }

            /// <summary>
            ///     Returns reference to element 0 of this uint_2.
            /// </summary>
            /// <returns>
            ///     Reference to element 0 of this uint_2.
            /// </returns>
            unsigned int& ref_x() __GPU {
                return _M_x;
            }

            /// <summary>
            ///     Returns reference to element 0 of this uint_2.
            /// </summary>
            /// <returns>
            ///     Reference to element 0 of this uint_2.
            /// </returns>
            unsigned int& ref_r() __GPU {
                return _M_x;
            }

            /// <summary>
            ///     Set element 0 of this uint_2 with an unsigned int.
            /// </summary>
            /// <param name="_Value">
            ///     an unsigned int value.
            /// </param>
            void set_x(unsigned int _Value) __GPU
            {
                _M_x = _Value;
            }

            /// <summary>
            ///     Property for accessing element 1 of this uint_2 as an unsigned int.
            /// </summary>
            __declspec( property( get=get_y, put=set_y) ) unsigned int y;
            /// <summary>
            ///     Property for accessing element 1 of this uint_2 as an unsigned int.
            /// </summary>
            __declspec( property( get=get_y, put=set_y) ) unsigned int g;

            /// <summary>
            ///     Returns element 1 of this uint_2.
            /// </summary>
            /// <returns>
            ///     Element 1 of this uint_2.
            /// </returns>
            unsigned int get_y() const __GPU {
                return _M_y;
            }

            /// <summary>
            ///     Returns reference to element 1 of this uint_2.
            /// </summary>
            /// <returns>
            ///     Reference to element 1 of this uint_2.
            /// </returns>
            unsigned int& ref_y() __GPU {
                return _M_y;
            }

            /// <summary>
            ///     Returns reference to element 1 of this uint_2.
            /// </summary>
            /// <returns>
            ///     Reference to element 1 of this uint_2.
            /// </returns>
            unsigned int& ref_g() __GPU {
                return _M_y;
            }

            /// <summary>
            ///     Set element 1 of this uint_2 with an unsigned int.
            /// </summary>
            /// <param name="_Value">
            ///     an unsigned int value.
            /// </param>
            void set_y(unsigned int _Value) __GPU
            {
                _M_y = _Value;
            }

        public:
            /// <summary>
            ///     Default constructor, initializes all elements with 0.
            /// </summary>
            uint_2() __GPU
            {
                _M_x = 0;
                _M_y = 0;
            }

            /// <summary>
            ///     Constructor.
            /// </summary>
            /// <param name="_V0">
            ///     The value to initialize element 0.
            /// </param>
            /// <param name="_V1">
            ///     The value to initialize element 1.
            /// </param>
            uint_2(unsigned int _V0, unsigned int _V1) __GPU
            {
                _M_x = _V0;
                _M_y = _V1;
            }

            /// <summary>
            ///     Constructor.
            /// </summary>
            /// <param name="_V">
            ///     The value for initialization.
            /// </param>
            uint_2(unsigned int _V) __GPU
            {
                _M_x = _V;
                _M_y = _V;
            }

            /// <summary>
            ///     Constructor.
            ///     Each element is initialized by casting from the corresponding element in _Other.
            /// </summary>
            /// <param name="_Other">
            ///     The object used to initialize.
            /// </param>
            explicit inline uint_2(const int_2& _Other) __GPU;

            /// <summary>
            ///     Constructor.
            ///     Each element is initialized by casting from the corresponding element in _Other.
            /// </summary>
            /// <param name="_Other">
            ///     The object used to initialize.
            /// </param>
            explicit inline uint_2(const float_2& _Other) __GPU;

            /// <summary>
            ///     Constructor.
            ///     Each element is initialized by casting from the corresponding element in _Other.
            /// </summary>
            /// <param name="_Other">
            ///     The object used to initialize.
            /// </param>
            explicit inline uint_2(const unorm_2& _Other) __GPU;

            /// <summary>
            ///     Constructor.
            ///     Each element is initialized by casting from the corresponding element in _Other.
            /// </summary>
            /// <param name="_Other">
            ///     The object used to initialize.
            /// </param>
            explicit inline uint_2(const norm_2& _Other) __GPU;

            /// <summary>
            ///     Constructor.
            ///     Each element is initialized by casting from the corresponding element in _Other.
            /// </summary>
            /// <param name="_Other">
            ///     The object used to initialize.
            /// </param>
            explicit inline uint_2(const double_2& _Other) __GPU;

            uint_2 operator~() const __GPU
            {
                uint_2 _Value = *this;
                return uint_2(~_Value.x, ~_Value.y);
            }

            uint_2& operator++() __GPU
            {
                uint_2 _Value = *this;
                ++_Value._M_x;
                ++_Value._M_y;
                *this = _Value;
                return *this;
            }

            uint_2 operator++(int) __GPU
            {
                uint_2 _Result = *this;
                ++(*this);
                return _Result;
            }

            uint_2& operator--() __GPU
            {
                uint_2 _Value = *this;
                --_Value._M_x;
                --_Value._M_y;
                *this = _Value;
                return *this;
            }

            uint_2 operator--(int) __GPU
            {
                uint_2 _Result = *this;
                --(*this);
                return _Result;
            }

            uint_2& operator+=(const uint_2& _Other) __GPU
            {
                uint_2 _Value1 = *this;
                uint_2 _Value2 = _Other;
                _Value1.x += _Value2.x;
                _Value1.y += _Value2.y;
                *this = _Value1;
                return *this;
            }

            uint_2& operator-=(const uint_2& _Other) __GPU
            {
                uint_2 _Value1 = *this;
                uint_2 _Value2 = _Other;
                _Value1.x -= _Value2.x;
                _Value1.y -= _Value2.y;
                *this = _Value1;
                return *this;
            }

            uint_2& operator*=(const uint_2& _Other) __GPU
            {
                uint_2 _Value1 = *this;
                uint_2 _Value2 = _Other;
                _Value1.x *= _Value2.x;
                _Value1.y *= _Value2.y;
                *this = _Value1;
                return *this;
            }

            uint_2& operator/=(const uint_2& _Other) __GPU
            {
                uint_2 _Value1 = *this;
                uint_2 _Value2 = _Other;
                _Value1.x /= _Value2.x;
                _Value1.y /= _Value2.y;
                *this = _Value1;
                return *this;
            }

            uint_2& operator%=(const uint_2& _Other) __GPU
            {
                uint_2 _Value1 = *this;
                uint_2 _Value2 = _Other;
                _Value1.x %= _Value2.x;
                _Value1.y %= _Value2.y;
                *this = _Value1;
                return *this;
            }

            uint_2& operator^=(const uint_2& _Other) __GPU
            {
                uint_2 _Value1 = *this;
                uint_2 _Value2 = _Other;
                _Value1.x ^= _Value2.x;
                _Value1.y ^= _Value2.y;
                *this = _Value1;
                return *this;
            }

            uint_2& operator|=(const uint_2& _Other) __GPU
            {
                uint_2 _Value1 = *this;
                uint_2 _Value2 = _Other;
                _Value1.x |= _Value2.x;
                _Value1.y |= _Value2.y;
                *this = _Value1;
                return *this;
            }

            uint_2& operator&=(const uint_2& _Other) __GPU
            {
                uint_2 _Value1 = *this;
                uint_2 _Value2 = _Other;
                _Value1.x &= _Value2.x;
                _Value1.y &= _Value2.y;
                *this = _Value1;
                return *this;
            }

            uint_2& operator>>=(const uint_2& _Other) __GPU
            {
                uint_2 _Value1 = *this;
                uint_2 _Value2 = _Other;
                _Value1.x >>= _Value2.x;
                _Value1.y >>= _Value2.y;
                *this = _Value1;
                return *this;
            }

            uint_2& operator<<=(const uint_2& _Other) __GPU
            {
                uint_2 _Value1 = *this;
                uint_2 _Value2 = _Other;
                _Value1.x <<= _Value2.x;
                _Value1.y <<= _Value2.y;
                *this = _Value1;
                return *this;
            }

        public:
            /// <summary>
            ///     Property for accessing element 0, and 1 of this uint_2 as a uint_2.
            /// </summary>
            __declspec( property( get=get_xy, put=set_xy) ) uint_2 xy;
            /// <summary>
            ///     Property for accessing element 0, and 1 of this uint_2 as a uint_2.
            /// </summary>
            __declspec( property( get=get_xy, put=set_xy) ) uint_2 rg;

            /// <summary>
            ///     Returns a uint_2 that is composed of element 0, and element 1 of this uint_2.
            /// </summary>
            /// <returns>
            ///     a uint_2.
            /// </returns>
            uint_2 get_xy() const __GPU {
                return uint_2(_M_x,_M_y);
            }

            /// <summary>
            ///     Set element 0, and 1 of this uint_2 with a uint_2.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_2 value.
            /// </param>
            void set_xy(const uint_2& _Value) __GPU
            {
                uint_2 _Val = _Value;
                _M_x = _Val.x;
                _M_y = _Val.y;
            }

            /// <summary>
            ///     Property for accessing element 1, and 0 of this uint_2 as a uint_2.
            /// </summary>
            __declspec( property( get=get_yx, put=set_yx) ) uint_2 yx;
            /// <summary>
            ///     Property for accessing element 1, and 0 of this uint_2 as a uint_2.
            /// </summary>
            __declspec( property( get=get_yx, put=set_yx) ) uint_2 gr;

            /// <summary>
            ///     Returns a uint_2 that is composed of element 1, and element 0 of this uint_2.
            /// </summary>
            /// <returns>
            ///     a uint_2.
            /// </returns>
            uint_2 get_yx() const __GPU {
                return uint_2(_M_y,_M_x);
            }

            /// <summary>
            ///     Set element 1, and 0 of this uint_2 with a uint_2.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_2 value.
            /// </param>
            void set_yx(const uint_2& _Value) __GPU
            {
                uint_2 _Val = _Value;
                _M_y = _Val.x;
                _M_x = _Val.y;
            }

        };

        /// <summary>
        ///    Represent a short vector of 3 unsigned int's.
        /// </summary>
        class uint_3
        {
        public:
            typedef unsigned int value_type;
            static const int size = 3;
        private:
            static const _Short_vector_base_type_id _Base_type_id = _Uint_type;
        private:
            value_type _M_x;
            value_type _M_y;
            value_type _M_z;

        public:
            /// <summary>
            ///     Property for accessing element 0 of this uint_3 as an unsigned int.
            /// </summary>
            __declspec( property( get=get_x, put=set_x) ) unsigned int x;
            /// <summary>
            ///     Property for accessing element 0 of this uint_3 as an unsigned int.
            /// </summary>
            __declspec( property( get=get_x, put=set_x) ) unsigned int r;

            /// <summary>
            ///     Returns element 0 of this uint_3.
            /// </summary>
            /// <returns>
            ///     Element 0 of this uint_3.
            /// </returns>
            unsigned int get_x() const __GPU {
                return _M_x;
            }

            /// <summary>
            ///     Returns reference to element 0 of this uint_3.
            /// </summary>
            /// <returns>
            ///     Reference to element 0 of this uint_3.
            /// </returns>
            unsigned int& ref_x() __GPU {
                return _M_x;
            }

            /// <summary>
            ///     Returns reference to element 0 of this uint_3.
            /// </summary>
            /// <returns>
            ///     Reference to element 0 of this uint_3.
            /// </returns>
            unsigned int& ref_r() __GPU {
                return _M_x;
            }

            /// <summary>
            ///     Set element 0 of this uint_3 with an unsigned int.
            /// </summary>
            /// <param name="_Value">
            ///     an unsigned int value.
            /// </param>
            void set_x(unsigned int _Value) __GPU
            {
                _M_x = _Value;
            }

            /// <summary>
            ///     Property for accessing element 1 of this uint_3 as an unsigned int.
            /// </summary>
            __declspec( property( get=get_y, put=set_y) ) unsigned int y;
            /// <summary>
            ///     Property for accessing element 1 of this uint_3 as an unsigned int.
            /// </summary>
            __declspec( property( get=get_y, put=set_y) ) unsigned int g;

            /// <summary>
            ///     Returns element 1 of this uint_3.
            /// </summary>
            /// <returns>
            ///     Element 1 of this uint_3.
            /// </returns>
            unsigned int get_y() const __GPU {
                return _M_y;
            }

            /// <summary>
            ///     Returns reference to element 1 of this uint_3.
            /// </summary>
            /// <returns>
            ///     Reference to element 1 of this uint_3.
            /// </returns>
            unsigned int& ref_y() __GPU {
                return _M_y;
            }

            /// <summary>
            ///     Returns reference to element 1 of this uint_3.
            /// </summary>
            /// <returns>
            ///     Reference to element 1 of this uint_3.
            /// </returns>
            unsigned int& ref_g() __GPU {
                return _M_y;
            }

            /// <summary>
            ///     Set element 1 of this uint_3 with an unsigned int.
            /// </summary>
            /// <param name="_Value">
            ///     an unsigned int value.
            /// </param>
            void set_y(unsigned int _Value) __GPU
            {
                _M_y = _Value;
            }

            /// <summary>
            ///     Property for accessing element 2 of this uint_3 as an unsigned int.
            /// </summary>
            __declspec( property( get=get_z, put=set_z) ) unsigned int z;
            /// <summary>
            ///     Property for accessing element 2 of this uint_3 as an unsigned int.
            /// </summary>
            __declspec( property( get=get_z, put=set_z) ) unsigned int b;

            /// <summary>
            ///     Returns element 2 of this uint_3.
            /// </summary>
            /// <returns>
            ///     Element 2 of this uint_3.
            /// </returns>
            unsigned int get_z() const __GPU {
                return _M_z;
            }

            /// <summary>
            ///     Returns reference to element 2 of this uint_3.
            /// </summary>
            /// <returns>
            ///     Reference to element 2 of this uint_3.
            /// </returns>
            unsigned int& ref_z() __GPU {
                return _M_z;
            }

            /// <summary>
            ///     Returns reference to element 2 of this uint_3.
            /// </summary>
            /// <returns>
            ///     Reference to element 2 of this uint_3.
            /// </returns>
            unsigned int& ref_b() __GPU {
                return _M_z;
            }

            /// <summary>
            ///     Set element 2 of this uint_3 with an unsigned int.
            /// </summary>
            /// <param name="_Value">
            ///     an unsigned int value.
            /// </param>
            void set_z(unsigned int _Value) __GPU
            {
                _M_z = _Value;
            }

        public:
            /// <summary>
            ///     Default constructor, initializes all elements with 0.
            /// </summary>
            uint_3() __GPU
            {
                _M_x = 0;
                _M_y = 0;
                _M_z = 0;
            }

            /// <summary>
            ///     Constructor.
            /// </summary>
            /// <param name="_V0">
            ///     The value to initialize element 0.
            /// </param>
            /// <param name="_V1">
            ///     The value to initialize element 1.
            /// </param>
            /// <param name="_V2">
            ///     The value to initialize element 2.
            /// </param>
            uint_3(unsigned int _V0, unsigned int _V1, unsigned int _V2) __GPU
            {
                _M_x = _V0;
                _M_y = _V1;
                _M_z = _V2;
            }

            /// <summary>
            ///     Constructor.
            /// </summary>
            /// <param name="_V">
            ///     The value for initialization.
            /// </param>
            uint_3(unsigned int _V) __GPU
            {
                _M_x = _V;
                _M_y = _V;
                _M_z = _V;
            }

            /// <summary>
            ///     Constructor.
            ///     Each element is initialized by casting from the corresponding element in _Other.
            /// </summary>
            /// <param name="_Other">
            ///     The object used to initialize.
            /// </param>
            explicit inline uint_3(const int_3& _Other) __GPU;

            /// <summary>
            ///     Constructor.
            ///     Each element is initialized by casting from the corresponding element in _Other.
            /// </summary>
            /// <param name="_Other">
            ///     The object used to initialize.
            /// </param>
            explicit inline uint_3(const float_3& _Other) __GPU;

            /// <summary>
            ///     Constructor.
            ///     Each element is initialized by casting from the corresponding element in _Other.
            /// </summary>
            /// <param name="_Other">
            ///     The object used to initialize.
            /// </param>
            explicit inline uint_3(const unorm_3& _Other) __GPU;

            /// <summary>
            ///     Constructor.
            ///     Each element is initialized by casting from the corresponding element in _Other.
            /// </summary>
            /// <param name="_Other">
            ///     The object used to initialize.
            /// </param>
            explicit inline uint_3(const norm_3& _Other) __GPU;

            /// <summary>
            ///     Constructor.
            ///     Each element is initialized by casting from the corresponding element in _Other.
            /// </summary>
            /// <param name="_Other">
            ///     The object used to initialize.
            /// </param>
            explicit inline uint_3(const double_3& _Other) __GPU;

            uint_3 operator~() const __GPU
            {
                uint_3 _Value = *this;
                return uint_3(~_Value.x, ~_Value.y, ~_Value.z);
            }

            uint_3& operator++() __GPU
            {
                uint_3 _Value = *this;
                ++_Value._M_x;
                ++_Value._M_y;
                ++_Value._M_z;
                *this = _Value;
                return *this;
            }

            uint_3 operator++(int) __GPU
            {
                uint_3 _Result = *this;
                ++(*this);
                return _Result;
            }

            uint_3& operator--() __GPU
            {
                uint_3 _Value = *this;
                --_Value._M_x;
                --_Value._M_y;
                --_Value._M_z;
                *this = _Value;
                return *this;
            }

            uint_3 operator--(int) __GPU
            {
                uint_3 _Result = *this;
                --(*this);
                return _Result;
            }

            uint_3& operator+=(const uint_3& _Other) __GPU
            {
                uint_3 _Value1 = *this;
                uint_3 _Value2 = _Other;
                _Value1.x += _Value2.x;
                _Value1.y += _Value2.y;
                _Value1.z += _Value2.z;
                *this = _Value1;
                return *this;
            }

            uint_3& operator-=(const uint_3& _Other) __GPU
            {
                uint_3 _Value1 = *this;
                uint_3 _Value2 = _Other;
                _Value1.x -= _Value2.x;
                _Value1.y -= _Value2.y;
                _Value1.z -= _Value2.z;
                *this = _Value1;
                return *this;
            }

            uint_3& operator*=(const uint_3& _Other) __GPU
            {
                uint_3 _Value1 = *this;
                uint_3 _Value2 = _Other;
                _Value1.x *= _Value2.x;
                _Value1.y *= _Value2.y;
                _Value1.z *= _Value2.z;
                *this = _Value1;
                return *this;
            }

            uint_3& operator/=(const uint_3& _Other) __GPU
            {
                uint_3 _Value1 = *this;
                uint_3 _Value2 = _Other;
                _Value1.x /= _Value2.x;
                _Value1.y /= _Value2.y;
                _Value1.z /= _Value2.z;
                *this = _Value1;
                return *this;
            }

            uint_3& operator%=(const uint_3& _Other) __GPU
            {
                uint_3 _Value1 = *this;
                uint_3 _Value2 = _Other;
                _Value1.x %= _Value2.x;
                _Value1.y %= _Value2.y;
                _Value1.z %= _Value2.z;
                *this = _Value1;
                return *this;
            }

            uint_3& operator^=(const uint_3& _Other) __GPU
            {
                uint_3 _Value1 = *this;
                uint_3 _Value2 = _Other;
                _Value1.x ^= _Value2.x;
                _Value1.y ^= _Value2.y;
                _Value1.z ^= _Value2.z;
                *this = _Value1;
                return *this;
            }

            uint_3& operator|=(const uint_3& _Other) __GPU
            {
                uint_3 _Value1 = *this;
                uint_3 _Value2 = _Other;
                _Value1.x |= _Value2.x;
                _Value1.y |= _Value2.y;
                _Value1.z |= _Value2.z;
                *this = _Value1;
                return *this;
            }

            uint_3& operator&=(const uint_3& _Other) __GPU
            {
                uint_3 _Value1 = *this;
                uint_3 _Value2 = _Other;
                _Value1.x &= _Value2.x;
                _Value1.y &= _Value2.y;
                _Value1.z &= _Value2.z;
                *this = _Value1;
                return *this;
            }

            uint_3& operator>>=(const uint_3& _Other) __GPU
            {
                uint_3 _Value1 = *this;
                uint_3 _Value2 = _Other;
                _Value1.x >>= _Value2.x;
                _Value1.y >>= _Value2.y;
                _Value1.z >>= _Value2.z;
                *this = _Value1;
                return *this;
            }

            uint_3& operator<<=(const uint_3& _Other) __GPU
            {
                uint_3 _Value1 = *this;
                uint_3 _Value2 = _Other;
                _Value1.x <<= _Value2.x;
                _Value1.y <<= _Value2.y;
                _Value1.z <<= _Value2.z;
                *this = _Value1;
                return *this;
            }

        public:
            /// <summary>
            ///     Property for accessing element 0, and 1 of this uint_3 as a uint_2.
            /// </summary>
            __declspec( property( get=get_xy, put=set_xy) ) uint_2 xy;
            /// <summary>
            ///     Property for accessing element 0, and 1 of this uint_3 as a uint_2.
            /// </summary>
            __declspec( property( get=get_xy, put=set_xy) ) uint_2 rg;

            /// <summary>
            ///     Returns a uint_2 that is composed of element 0, and element 1 of this uint_3.
            /// </summary>
            /// <returns>
            ///     a uint_2.
            /// </returns>
            uint_2 get_xy() const __GPU {
                return uint_2(_M_x,_M_y);
            }

            /// <summary>
            ///     Set element 0, and 1 of this uint_3 with a uint_2.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_2 value.
            /// </param>
            void set_xy(const uint_2& _Value) __GPU
            {
                uint_2 _Val = _Value;
                _M_x = _Val.x;
                _M_y = _Val.y;
            }

            /// <summary>
            ///     Property for accessing element 0, and 2 of this uint_3 as a uint_2.
            /// </summary>
            __declspec( property( get=get_xz, put=set_xz) ) uint_2 xz;
            /// <summary>
            ///     Property for accessing element 0, and 2 of this uint_3 as a uint_2.
            /// </summary>
            __declspec( property( get=get_xz, put=set_xz) ) uint_2 rb;

            /// <summary>
            ///     Returns a uint_2 that is composed of element 0, and element 2 of this uint_3.
            /// </summary>
            /// <returns>
            ///     a uint_2.
            /// </returns>
            uint_2 get_xz() const __GPU {
                return uint_2(_M_x,_M_z);
            }

            /// <summary>
            ///     Set element 0, and 2 of this uint_3 with a uint_2.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_2 value.
            /// </param>
            void set_xz(const uint_2& _Value) __GPU
            {
                uint_2 _Val = _Value;
                _M_x = _Val.x;
                _M_z = _Val.y;
            }

            /// <summary>
            ///     Property for accessing element 1, and 0 of this uint_3 as a uint_2.
            /// </summary>
            __declspec( property( get=get_yx, put=set_yx) ) uint_2 yx;
            /// <summary>
            ///     Property for accessing element 1, and 0 of this uint_3 as a uint_2.
            /// </summary>
            __declspec( property( get=get_yx, put=set_yx) ) uint_2 gr;

            /// <summary>
            ///     Returns a uint_2 that is composed of element 1, and element 0 of this uint_3.
            /// </summary>
            /// <returns>
            ///     a uint_2.
            /// </returns>
            uint_2 get_yx() const __GPU {
                return uint_2(_M_y,_M_x);
            }

            /// <summary>
            ///     Set element 1, and 0 of this uint_3 with a uint_2.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_2 value.
            /// </param>
            void set_yx(const uint_2& _Value) __GPU
            {
                uint_2 _Val = _Value;
                _M_y = _Val.x;
                _M_x = _Val.y;
            }

            /// <summary>
            ///     Property for accessing element 1, and 2 of this uint_3 as a uint_2.
            /// </summary>
            __declspec( property( get=get_yz, put=set_yz) ) uint_2 yz;
            /// <summary>
            ///     Property for accessing element 1, and 2 of this uint_3 as a uint_2.
            /// </summary>
            __declspec( property( get=get_yz, put=set_yz) ) uint_2 gb;

            /// <summary>
            ///     Returns a uint_2 that is composed of element 1, and element 2 of this uint_3.
            /// </summary>
            /// <returns>
            ///     a uint_2.
            /// </returns>
            uint_2 get_yz() const __GPU {
                return uint_2(_M_y,_M_z);
            }

            /// <summary>
            ///     Set element 1, and 2 of this uint_3 with a uint_2.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_2 value.
            /// </param>
            void set_yz(const uint_2& _Value) __GPU
            {
                uint_2 _Val = _Value;
                _M_y = _Val.x;
                _M_z = _Val.y;
            }

            /// <summary>
            ///     Property for accessing element 2, and 0 of this uint_3 as a uint_2.
            /// </summary>
            __declspec( property( get=get_zx, put=set_zx) ) uint_2 zx;
            /// <summary>
            ///     Property for accessing element 2, and 0 of this uint_3 as a uint_2.
            /// </summary>
            __declspec( property( get=get_zx, put=set_zx) ) uint_2 br;

            /// <summary>
            ///     Returns a uint_2 that is composed of element 2, and element 0 of this uint_3.
            /// </summary>
            /// <returns>
            ///     a uint_2.
            /// </returns>
            uint_2 get_zx() const __GPU {
                return uint_2(_M_z,_M_x);
            }

            /// <summary>
            ///     Set element 2, and 0 of this uint_3 with a uint_2.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_2 value.
            /// </param>
            void set_zx(const uint_2& _Value) __GPU
            {
                uint_2 _Val = _Value;
                _M_z = _Val.x;
                _M_x = _Val.y;
            }

            /// <summary>
            ///     Property for accessing element 2, and 1 of this uint_3 as a uint_2.
            /// </summary>
            __declspec( property( get=get_zy, put=set_zy) ) uint_2 zy;
            /// <summary>
            ///     Property for accessing element 2, and 1 of this uint_3 as a uint_2.
            /// </summary>
            __declspec( property( get=get_zy, put=set_zy) ) uint_2 bg;

            /// <summary>
            ///     Returns a uint_2 that is composed of element 2, and element 1 of this uint_3.
            /// </summary>
            /// <returns>
            ///     a uint_2.
            /// </returns>
            uint_2 get_zy() const __GPU {
                return uint_2(_M_z,_M_y);
            }

            /// <summary>
            ///     Set element 2, and 1 of this uint_3 with a uint_2.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_2 value.
            /// </param>
            void set_zy(const uint_2& _Value) __GPU
            {
                uint_2 _Val = _Value;
                _M_z = _Val.x;
                _M_y = _Val.y;
            }

            /// <summary>
            ///     Property for accessing element 0, 1, and 2 of this uint_3 as a uint_3.
            /// </summary>
            __declspec( property( get=get_xyz, put=set_xyz) ) uint_3 xyz;
            /// <summary>
            ///     Property for accessing element 0, 1, and 2 of this uint_3 as a uint_3.
            /// </summary>
            __declspec( property( get=get_xyz, put=set_xyz) ) uint_3 rgb;

            /// <summary>
            ///     Returns a uint_3 that is composed of element 0, element 1, and element 2 of this uint_3.
            /// </summary>
            /// <returns>
            ///     a uint_3.
            /// </returns>
            uint_3 get_xyz() const __GPU {
                return uint_3(_M_x,_M_y,_M_z);
            }

            /// <summary>
            ///     Set element 0, 1, and 2 of this uint_3 with a uint_3.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_3 value.
            /// </param>
            void set_xyz(const uint_3& _Value) __GPU
            {
                uint_3 _Val = _Value;
                _M_x = _Val.x;
                _M_y = _Val.y;
                _M_z = _Val.z;
            }

            /// <summary>
            ///     Property for accessing element 0, 2, and 1 of this uint_3 as a uint_3.
            /// </summary>
            __declspec( property( get=get_xzy, put=set_xzy) ) uint_3 xzy;
            /// <summary>
            ///     Property for accessing element 0, 2, and 1 of this uint_3 as a uint_3.
            /// </summary>
            __declspec( property( get=get_xzy, put=set_xzy) ) uint_3 rbg;

            /// <summary>
            ///     Returns a uint_3 that is composed of element 0, element 2, and element 1 of this uint_3.
            /// </summary>
            /// <returns>
            ///     a uint_3.
            /// </returns>
            uint_3 get_xzy() const __GPU {
                return uint_3(_M_x,_M_z,_M_y);
            }

            /// <summary>
            ///     Set element 0, 2, and 1 of this uint_3 with a uint_3.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_3 value.
            /// </param>
            void set_xzy(const uint_3& _Value) __GPU
            {
                uint_3 _Val = _Value;
                _M_x = _Val.x;
                _M_z = _Val.y;
                _M_y = _Val.z;
            }

            /// <summary>
            ///     Property for accessing element 1, 0, and 2 of this uint_3 as a uint_3.
            /// </summary>
            __declspec( property( get=get_yxz, put=set_yxz) ) uint_3 yxz;
            /// <summary>
            ///     Property for accessing element 1, 0, and 2 of this uint_3 as a uint_3.
            /// </summary>
            __declspec( property( get=get_yxz, put=set_yxz) ) uint_3 grb;

            /// <summary>
            ///     Returns a uint_3 that is composed of element 1, element 0, and element 2 of this uint_3.
            /// </summary>
            /// <returns>
            ///     a uint_3.
            /// </returns>
            uint_3 get_yxz() const __GPU {
                return uint_3(_M_y,_M_x,_M_z);
            }

            /// <summary>
            ///     Set element 1, 0, and 2 of this uint_3 with a uint_3.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_3 value.
            /// </param>
            void set_yxz(const uint_3& _Value) __GPU
            {
                uint_3 _Val = _Value;
                _M_y = _Val.x;
                _M_x = _Val.y;
                _M_z = _Val.z;
            }

            /// <summary>
            ///     Property for accessing element 1, 2, and 0 of this uint_3 as a uint_3.
            /// </summary>
            __declspec( property( get=get_yzx, put=set_yzx) ) uint_3 yzx;
            /// <summary>
            ///     Property for accessing element 1, 2, and 0 of this uint_3 as a uint_3.
            /// </summary>
            __declspec( property( get=get_yzx, put=set_yzx) ) uint_3 gbr;

            /// <summary>
            ///     Returns a uint_3 that is composed of element 1, element 2, and element 0 of this uint_3.
            /// </summary>
            /// <returns>
            ///     a uint_3.
            /// </returns>
            uint_3 get_yzx() const __GPU {
                return uint_3(_M_y,_M_z,_M_x);
            }

            /// <summary>
            ///     Set element 1, 2, and 0 of this uint_3 with a uint_3.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_3 value.
            /// </param>
            void set_yzx(const uint_3& _Value) __GPU
            {
                uint_3 _Val = _Value;
                _M_y = _Val.x;
                _M_z = _Val.y;
                _M_x = _Val.z;
            }

            /// <summary>
            ///     Property for accessing element 2, 0, and 1 of this uint_3 as a uint_3.
            /// </summary>
            __declspec( property( get=get_zxy, put=set_zxy) ) uint_3 zxy;
            /// <summary>
            ///     Property for accessing element 2, 0, and 1 of this uint_3 as a uint_3.
            /// </summary>
            __declspec( property( get=get_zxy, put=set_zxy) ) uint_3 brg;

            /// <summary>
            ///     Returns a uint_3 that is composed of element 2, element 0, and element 1 of this uint_3.
            /// </summary>
            /// <returns>
            ///     a uint_3.
            /// </returns>
            uint_3 get_zxy() const __GPU {
                return uint_3(_M_z,_M_x,_M_y);
            }

            /// <summary>
            ///     Set element 2, 0, and 1 of this uint_3 with a uint_3.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_3 value.
            /// </param>
            void set_zxy(const uint_3& _Value) __GPU
            {
                uint_3 _Val = _Value;
                _M_z = _Val.x;
                _M_x = _Val.y;
                _M_y = _Val.z;
            }

            /// <summary>
            ///     Property for accessing element 2, 1, and 0 of this uint_3 as a uint_3.
            /// </summary>
            __declspec( property( get=get_zyx, put=set_zyx) ) uint_3 zyx;
            /// <summary>
            ///     Property for accessing element 2, 1, and 0 of this uint_3 as a uint_3.
            /// </summary>
            __declspec( property( get=get_zyx, put=set_zyx) ) uint_3 bgr;

            /// <summary>
            ///     Returns a uint_3 that is composed of element 2, element 1, and element 0 of this uint_3.
            /// </summary>
            /// <returns>
            ///     a uint_3.
            /// </returns>
            uint_3 get_zyx() const __GPU {
                return uint_3(_M_z,_M_y,_M_x);
            }

            /// <summary>
            ///     Set element 2, 1, and 0 of this uint_3 with a uint_3.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_3 value.
            /// </param>
            void set_zyx(const uint_3& _Value) __GPU
            {
                uint_3 _Val = _Value;
                _M_z = _Val.x;
                _M_y = _Val.y;
                _M_x = _Val.z;
            }

        };

        /// <summary>
        ///    Represent a short vector of 4 unsigned int's.
        /// </summary>
        class uint_4
        {
        public:
            typedef unsigned int value_type;
            static const int size = 4;
        private:
            static const _Short_vector_base_type_id _Base_type_id = _Uint_type;
        private:
            value_type _M_x;
            value_type _M_y;
            value_type _M_z;
            value_type _M_w;

        public:
            /// <summary>
            ///     Property for accessing element 0 of this uint_4 as an unsigned int.
            /// </summary>
            __declspec( property( get=get_x, put=set_x) ) unsigned int x;
            /// <summary>
            ///     Property for accessing element 0 of this uint_4 as an unsigned int.
            /// </summary>
            __declspec( property( get=get_x, put=set_x) ) unsigned int r;

            /// <summary>
            ///     Returns element 0 of this uint_4.
            /// </summary>
            /// <returns>
            ///     Element 0 of this uint_4.
            /// </returns>
            unsigned int get_x() const __GPU {
                return _M_x;
            }

            /// <summary>
            ///     Returns reference to element 0 of this uint_4.
            /// </summary>
            /// <returns>
            ///     Reference to element 0 of this uint_4.
            /// </returns>
            unsigned int& ref_x() __GPU {
                return _M_x;
            }

            /// <summary>
            ///     Returns reference to element 0 of this uint_4.
            /// </summary>
            /// <returns>
            ///     Reference to element 0 of this uint_4.
            /// </returns>
            unsigned int& ref_r() __GPU {
                return _M_x;
            }

            /// <summary>
            ///     Set element 0 of this uint_4 with an unsigned int.
            /// </summary>
            /// <param name="_Value">
            ///     an unsigned int value.
            /// </param>
            void set_x(unsigned int _Value) __GPU
            {
                _M_x = _Value;
            }

            /// <summary>
            ///     Property for accessing element 1 of this uint_4 as an unsigned int.
            /// </summary>
            __declspec( property( get=get_y, put=set_y) ) unsigned int y;
            /// <summary>
            ///     Property for accessing element 1 of this uint_4 as an unsigned int.
            /// </summary>
            __declspec( property( get=get_y, put=set_y) ) unsigned int g;

            /// <summary>
            ///     Returns element 1 of this uint_4.
            /// </summary>
            /// <returns>
            ///     Element 1 of this uint_4.
            /// </returns>
            unsigned int get_y() const __GPU {
                return _M_y;
            }

            /// <summary>
            ///     Returns reference to element 1 of this uint_4.
            /// </summary>
            /// <returns>
            ///     Reference to element 1 of this uint_4.
            /// </returns>
            unsigned int& ref_y() __GPU {
                return _M_y;
            }

            /// <summary>
            ///     Returns reference to element 1 of this uint_4.
            /// </summary>
            /// <returns>
            ///     Reference to element 1 of this uint_4.
            /// </returns>
            unsigned int& ref_g() __GPU {
                return _M_y;
            }

            /// <summary>
            ///     Set element 1 of this uint_4 with an unsigned int.
            /// </summary>
            /// <param name="_Value">
            ///     an unsigned int value.
            /// </param>
            void set_y(unsigned int _Value) __GPU
            {
                _M_y = _Value;
            }

            /// <summary>
            ///     Property for accessing element 2 of this uint_4 as an unsigned int.
            /// </summary>
            __declspec( property( get=get_z, put=set_z) ) unsigned int z;
            /// <summary>
            ///     Property for accessing element 2 of this uint_4 as an unsigned int.
            /// </summary>
            __declspec( property( get=get_z, put=set_z) ) unsigned int b;

            /// <summary>
            ///     Returns element 2 of this uint_4.
            /// </summary>
            /// <returns>
            ///     Element 2 of this uint_4.
            /// </returns>
            unsigned int get_z() const __GPU {
                return _M_z;
            }

            /// <summary>
            ///     Returns reference to element 2 of this uint_4.
            /// </summary>
            /// <returns>
            ///     Reference to element 2 of this uint_4.
            /// </returns>
            unsigned int& ref_z() __GPU {
                return _M_z;
            }

            /// <summary>
            ///     Returns reference to element 2 of this uint_4.
            /// </summary>
            /// <returns>
            ///     Reference to element 2 of this uint_4.
            /// </returns>
            unsigned int& ref_b() __GPU {
                return _M_z;
            }

            /// <summary>
            ///     Set element 2 of this uint_4 with an unsigned int.
            /// </summary>
            /// <param name="_Value">
            ///     an unsigned int value.
            /// </param>
            void set_z(unsigned int _Value) __GPU
            {
                _M_z = _Value;
            }

            /// <summary>
            ///     Property for accessing element 3 of this uint_4 as an unsigned int.
            /// </summary>
            __declspec( property( get=get_w, put=set_w) ) unsigned int w;
            /// <summary>
            ///     Property for accessing element 3 of this uint_4 as an unsigned int.
            /// </summary>
            __declspec( property( get=get_w, put=set_w) ) unsigned int a;

            /// <summary>
            ///     Returns element 3 of this uint_4.
            /// </summary>
            /// <returns>
            ///     Element 3 of this uint_4.
            /// </returns>
            unsigned int get_w() const __GPU {
                return _M_w;
            }

            /// <summary>
            ///     Returns reference to element 3 of this uint_4.
            /// </summary>
            /// <returns>
            ///     Reference to element 3 of this uint_4.
            /// </returns>
            unsigned int& ref_w() __GPU {
                return _M_w;
            }

            /// <summary>
            ///     Returns reference to element 3 of this uint_4.
            /// </summary>
            /// <returns>
            ///     Reference to element 3 of this uint_4.
            /// </returns>
            unsigned int& ref_a() __GPU {
                return _M_w;
            }

            /// <summary>
            ///     Set element 3 of this uint_4 with an unsigned int.
            /// </summary>
            /// <param name="_Value">
            ///     an unsigned int value.
            /// </param>
            void set_w(unsigned int _Value) __GPU
            {
                _M_w = _Value;
            }

        public:
            /// <summary>
            ///     Default constructor, initializes all elements with 0.
            /// </summary>
            uint_4() __GPU
            {
                _M_x = 0;
                _M_y = 0;
                _M_z = 0;
                _M_w = 0;
            }

            /// <summary>
            ///     Constructor.
            /// </summary>
            /// <param name="_V0">
            ///     The value to initialize element 0.
            /// </param>
            /// <param name="_V1">
            ///     The value to initialize element 1.
            /// </param>
            /// <param name="_V2">
            ///     The value to initialize element 2.
            /// </param>
            /// <param name="_V3">
            ///     The value to initialize element 3.
            /// </param>
            uint_4(unsigned int _V0, unsigned int _V1, unsigned int _V2, unsigned int _V3) __GPU
            {
                _M_x = _V0;
                _M_y = _V1;
                _M_z = _V2;
                _M_w = _V3;
            }

            /// <summary>
            ///     Constructor.
            /// </summary>
            /// <param name="_V">
            ///     The value for initialization.
            /// </param>
            uint_4(unsigned int _V) __GPU
            {
                _M_x = _V;
                _M_y = _V;
                _M_z = _V;
                _M_w = _V;
            }

            /// <summary>
            ///     Constructor.
            ///     Each element is initialized by casting from the corresponding element in _Other.
            /// </summary>
            /// <param name="_Other">
            ///     The object used to initialize.
            /// </param>
            explicit inline uint_4(const int_4& _Other) __GPU;

            /// <summary>
            ///     Constructor.
            ///     Each element is initialized by casting from the corresponding element in _Other.
            /// </summary>
            /// <param name="_Other">
            ///     The object used to initialize.
            /// </param>
            explicit inline uint_4(const float_4& _Other) __GPU;

            /// <summary>
            ///     Constructor.
            ///     Each element is initialized by casting from the corresponding element in _Other.
            /// </summary>
            /// <param name="_Other">
            ///     The object used to initialize.
            /// </param>
            explicit inline uint_4(const unorm_4& _Other) __GPU;

            /// <summary>
            ///     Constructor.
            ///     Each element is initialized by casting from the corresponding element in _Other.
            /// </summary>
            /// <param name="_Other">
            ///     The object used to initialize.
            /// </param>
            explicit inline uint_4(const norm_4& _Other) __GPU;

            /// <summary>
            ///     Constructor.
            ///     Each element is initialized by casting from the corresponding element in _Other.
            /// </summary>
            /// <param name="_Other">
            ///     The object used to initialize.
            /// </param>
            explicit inline uint_4(const double_4& _Other) __GPU;

            uint_4 operator~() const __GPU
            {
                uint_4 _Value = *this;
                return uint_4(~_Value.x, ~_Value.y, ~_Value.z, ~_Value.w);
            }

            uint_4& operator++() __GPU
            {
                uint_4 _Value = *this;
                ++_Value._M_x;
                ++_Value._M_y;
                ++_Value._M_z;
                ++_Value._M_w;
                *this = _Value;
                return *this;
            }

            uint_4 operator++(int) __GPU
            {
                uint_4 _Result = *this;
                ++(*this);
                return _Result;
            }

            uint_4& operator--() __GPU
            {
                uint_4 _Value = *this;
                --_Value._M_x;
                --_Value._M_y;
                --_Value._M_z;
                --_Value._M_w;
                *this = _Value;
                return *this;
            }

            uint_4 operator--(int) __GPU
            {
                uint_4 _Result = *this;
                --(*this);
                return _Result;
            }

            uint_4& operator+=(const uint_4& _Other) __GPU
            {
                uint_4 _Value1 = *this;
                uint_4 _Value2 = _Other;
                _Value1.x += _Value2.x;
                _Value1.y += _Value2.y;
                _Value1.z += _Value2.z;
                _Value1.w += _Value2.w;
                *this = _Value1;
                return *this;
            }

            uint_4& operator-=(const uint_4& _Other) __GPU
            {
                uint_4 _Value1 = *this;
                uint_4 _Value2 = _Other;
                _Value1.x -= _Value2.x;
                _Value1.y -= _Value2.y;
                _Value1.z -= _Value2.z;
                _Value1.w -= _Value2.w;
                *this = _Value1;
                return *this;
            }

            uint_4& operator*=(const uint_4& _Other) __GPU
            {
                uint_4 _Value1 = *this;
                uint_4 _Value2 = _Other;
                _Value1.x *= _Value2.x;
                _Value1.y *= _Value2.y;
                _Value1.z *= _Value2.z;
                _Value1.w *= _Value2.w;
                *this = _Value1;
                return *this;
            }

            uint_4& operator/=(const uint_4& _Other) __GPU
            {
                uint_4 _Value1 = *this;
                uint_4 _Value2 = _Other;
                _Value1.x /= _Value2.x;
                _Value1.y /= _Value2.y;
                _Value1.z /= _Value2.z;
                _Value1.w /= _Value2.w;
                *this = _Value1;
                return *this;
            }

            uint_4& operator%=(const uint_4& _Other) __GPU
            {
                uint_4 _Value1 = *this;
                uint_4 _Value2 = _Other;
                _Value1.x %= _Value2.x;
                _Value1.y %= _Value2.y;
                _Value1.z %= _Value2.z;
                _Value1.w %= _Value2.w;
                *this = _Value1;
                return *this;
            }

            uint_4& operator^=(const uint_4& _Other) __GPU
            {
                uint_4 _Value1 = *this;
                uint_4 _Value2 = _Other;
                _Value1.x ^= _Value2.x;
                _Value1.y ^= _Value2.y;
                _Value1.z ^= _Value2.z;
                _Value1.w ^= _Value2.w;
                *this = _Value1;
                return *this;
            }

            uint_4& operator|=(const uint_4& _Other) __GPU
            {
                uint_4 _Value1 = *this;
                uint_4 _Value2 = _Other;
                _Value1.x |= _Value2.x;
                _Value1.y |= _Value2.y;
                _Value1.z |= _Value2.z;
                _Value1.w |= _Value2.w;
                *this = _Value1;
                return *this;
            }

            uint_4& operator&=(const uint_4& _Other) __GPU
            {
                uint_4 _Value1 = *this;
                uint_4 _Value2 = _Other;
                _Value1.x &= _Value2.x;
                _Value1.y &= _Value2.y;
                _Value1.z &= _Value2.z;
                _Value1.w &= _Value2.w;
                *this = _Value1;
                return *this;
            }

            uint_4& operator>>=(const uint_4& _Other) __GPU
            {
                uint_4 _Value1 = *this;
                uint_4 _Value2 = _Other;
                _Value1.x >>= _Value2.x;
                _Value1.y >>= _Value2.y;
                _Value1.z >>= _Value2.z;
                _Value1.w >>= _Value2.w;
                *this = _Value1;
                return *this;
            }

            uint_4& operator<<=(const uint_4& _Other) __GPU
            {
                uint_4 _Value1 = *this;
                uint_4 _Value2 = _Other;
                _Value1.x <<= _Value2.x;
                _Value1.y <<= _Value2.y;
                _Value1.z <<= _Value2.z;
                _Value1.w <<= _Value2.w;
                *this = _Value1;
                return *this;
            }

        public:
            /// <summary>
            ///     Property for accessing element 0, and 1 of this uint_4 as a uint_2.
            /// </summary>
            __declspec( property( get=get_xy, put=set_xy) ) uint_2 xy;
            /// <summary>
            ///     Property for accessing element 0, and 1 of this uint_4 as a uint_2.
            /// </summary>
            __declspec( property( get=get_xy, put=set_xy) ) uint_2 rg;

            /// <summary>
            ///     Returns a uint_2 that is composed of element 0, and element 1 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_2.
            /// </returns>
            uint_2 get_xy() const __GPU {
                return uint_2(_M_x,_M_y);
            }

            /// <summary>
            ///     Set element 0, and 1 of this uint_4 with a uint_2.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_2 value.
            /// </param>
            void set_xy(const uint_2& _Value) __GPU
            {
                uint_2 _Val = _Value;
                _M_x = _Val.x;
                _M_y = _Val.y;
            }

            /// <summary>
            ///     Property for accessing element 0, and 2 of this uint_4 as a uint_2.
            /// </summary>
            __declspec( property( get=get_xz, put=set_xz) ) uint_2 xz;
            /// <summary>
            ///     Property for accessing element 0, and 2 of this uint_4 as a uint_2.
            /// </summary>
            __declspec( property( get=get_xz, put=set_xz) ) uint_2 rb;

            /// <summary>
            ///     Returns a uint_2 that is composed of element 0, and element 2 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_2.
            /// </returns>
            uint_2 get_xz() const __GPU {
                return uint_2(_M_x,_M_z);
            }

            /// <summary>
            ///     Set element 0, and 2 of this uint_4 with a uint_2.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_2 value.
            /// </param>
            void set_xz(const uint_2& _Value) __GPU
            {
                uint_2 _Val = _Value;
                _M_x = _Val.x;
                _M_z = _Val.y;
            }

            /// <summary>
            ///     Property for accessing element 0, and 3 of this uint_4 as a uint_2.
            /// </summary>
            __declspec( property( get=get_xw, put=set_xw) ) uint_2 xw;
            /// <summary>
            ///     Property for accessing element 0, and 3 of this uint_4 as a uint_2.
            /// </summary>
            __declspec( property( get=get_xw, put=set_xw) ) uint_2 ra;

            /// <summary>
            ///     Returns a uint_2 that is composed of element 0, and element 3 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_2.
            /// </returns>
            uint_2 get_xw() const __GPU {
                return uint_2(_M_x,_M_w);
            }

            /// <summary>
            ///     Set element 0, and 3 of this uint_4 with a uint_2.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_2 value.
            /// </param>
            void set_xw(const uint_2& _Value) __GPU
            {
                uint_2 _Val = _Value;
                _M_x = _Val.x;
                _M_w = _Val.y;
            }

            /// <summary>
            ///     Property for accessing element 1, and 0 of this uint_4 as a uint_2.
            /// </summary>
            __declspec( property( get=get_yx, put=set_yx) ) uint_2 yx;
            /// <summary>
            ///     Property for accessing element 1, and 0 of this uint_4 as a uint_2.
            /// </summary>
            __declspec( property( get=get_yx, put=set_yx) ) uint_2 gr;

            /// <summary>
            ///     Returns a uint_2 that is composed of element 1, and element 0 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_2.
            /// </returns>
            uint_2 get_yx() const __GPU {
                return uint_2(_M_y,_M_x);
            }

            /// <summary>
            ///     Set element 1, and 0 of this uint_4 with a uint_2.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_2 value.
            /// </param>
            void set_yx(const uint_2& _Value) __GPU
            {
                uint_2 _Val = _Value;
                _M_y = _Val.x;
                _M_x = _Val.y;
            }

            /// <summary>
            ///     Property for accessing element 1, and 2 of this uint_4 as a uint_2.
            /// </summary>
            __declspec( property( get=get_yz, put=set_yz) ) uint_2 yz;
            /// <summary>
            ///     Property for accessing element 1, and 2 of this uint_4 as a uint_2.
            /// </summary>
            __declspec( property( get=get_yz, put=set_yz) ) uint_2 gb;

            /// <summary>
            ///     Returns a uint_2 that is composed of element 1, and element 2 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_2.
            /// </returns>
            uint_2 get_yz() const __GPU {
                return uint_2(_M_y,_M_z);
            }

            /// <summary>
            ///     Set element 1, and 2 of this uint_4 with a uint_2.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_2 value.
            /// </param>
            void set_yz(const uint_2& _Value) __GPU
            {
                uint_2 _Val = _Value;
                _M_y = _Val.x;
                _M_z = _Val.y;
            }

            /// <summary>
            ///     Property for accessing element 1, and 3 of this uint_4 as a uint_2.
            /// </summary>
            __declspec( property( get=get_yw, put=set_yw) ) uint_2 yw;
            /// <summary>
            ///     Property for accessing element 1, and 3 of this uint_4 as a uint_2.
            /// </summary>
            __declspec( property( get=get_yw, put=set_yw) ) uint_2 ga;

            /// <summary>
            ///     Returns a uint_2 that is composed of element 1, and element 3 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_2.
            /// </returns>
            uint_2 get_yw() const __GPU {
                return uint_2(_M_y,_M_w);
            }

            /// <summary>
            ///     Set element 1, and 3 of this uint_4 with a uint_2.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_2 value.
            /// </param>
            void set_yw(const uint_2& _Value) __GPU
            {
                uint_2 _Val = _Value;
                _M_y = _Val.x;
                _M_w = _Val.y;
            }

            /// <summary>
            ///     Property for accessing element 2, and 0 of this uint_4 as a uint_2.
            /// </summary>
            __declspec( property( get=get_zx, put=set_zx) ) uint_2 zx;
            /// <summary>
            ///     Property for accessing element 2, and 0 of this uint_4 as a uint_2.
            /// </summary>
            __declspec( property( get=get_zx, put=set_zx) ) uint_2 br;

            /// <summary>
            ///     Returns a uint_2 that is composed of element 2, and element 0 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_2.
            /// </returns>
            uint_2 get_zx() const __GPU {
                return uint_2(_M_z,_M_x);
            }

            /// <summary>
            ///     Set element 2, and 0 of this uint_4 with a uint_2.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_2 value.
            /// </param>
            void set_zx(const uint_2& _Value) __GPU
            {
                uint_2 _Val = _Value;
                _M_z = _Val.x;
                _M_x = _Val.y;
            }

            /// <summary>
            ///     Property for accessing element 2, and 1 of this uint_4 as a uint_2.
            /// </summary>
            __declspec( property( get=get_zy, put=set_zy) ) uint_2 zy;
            /// <summary>
            ///     Property for accessing element 2, and 1 of this uint_4 as a uint_2.
            /// </summary>
            __declspec( property( get=get_zy, put=set_zy) ) uint_2 bg;

            /// <summary>
            ///     Returns a uint_2 that is composed of element 2, and element 1 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_2.
            /// </returns>
            uint_2 get_zy() const __GPU {
                return uint_2(_M_z,_M_y);
            }

            /// <summary>
            ///     Set element 2, and 1 of this uint_4 with a uint_2.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_2 value.
            /// </param>
            void set_zy(const uint_2& _Value) __GPU
            {
                uint_2 _Val = _Value;
                _M_z = _Val.x;
                _M_y = _Val.y;
            }

            /// <summary>
            ///     Property for accessing element 2, and 3 of this uint_4 as a uint_2.
            /// </summary>
            __declspec( property( get=get_zw, put=set_zw) ) uint_2 zw;
            /// <summary>
            ///     Property for accessing element 2, and 3 of this uint_4 as a uint_2.
            /// </summary>
            __declspec( property( get=get_zw, put=set_zw) ) uint_2 ba;

            /// <summary>
            ///     Returns a uint_2 that is composed of element 2, and element 3 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_2.
            /// </returns>
            uint_2 get_zw() const __GPU {
                return uint_2(_M_z,_M_w);
            }

            /// <summary>
            ///     Set element 2, and 3 of this uint_4 with a uint_2.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_2 value.
            /// </param>
            void set_zw(const uint_2& _Value) __GPU
            {
                uint_2 _Val = _Value;
                _M_z = _Val.x;
                _M_w = _Val.y;
            }

            /// <summary>
            ///     Property for accessing element 3, and 0 of this uint_4 as a uint_2.
            /// </summary>
            __declspec( property( get=get_wx, put=set_wx) ) uint_2 wx;
            /// <summary>
            ///     Property for accessing element 3, and 0 of this uint_4 as a uint_2.
            /// </summary>
            __declspec( property( get=get_wx, put=set_wx) ) uint_2 ar;

            /// <summary>
            ///     Returns a uint_2 that is composed of element 3, and element 0 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_2.
            /// </returns>
            uint_2 get_wx() const __GPU {
                return uint_2(_M_w,_M_x);
            }

            /// <summary>
            ///     Set element 3, and 0 of this uint_4 with a uint_2.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_2 value.
            /// </param>
            void set_wx(const uint_2& _Value) __GPU
            {
                uint_2 _Val = _Value;
                _M_w = _Val.x;
                _M_x = _Val.y;
            }

            /// <summary>
            ///     Property for accessing element 3, and 1 of this uint_4 as a uint_2.
            /// </summary>
            __declspec( property( get=get_wy, put=set_wy) ) uint_2 wy;
            /// <summary>
            ///     Property for accessing element 3, and 1 of this uint_4 as a uint_2.
            /// </summary>
            __declspec( property( get=get_wy, put=set_wy) ) uint_2 ag;

            /// <summary>
            ///     Returns a uint_2 that is composed of element 3, and element 1 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_2.
            /// </returns>
            uint_2 get_wy() const __GPU {
                return uint_2(_M_w,_M_y);
            }

            /// <summary>
            ///     Set element 3, and 1 of this uint_4 with a uint_2.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_2 value.
            /// </param>
            void set_wy(const uint_2& _Value) __GPU
            {
                uint_2 _Val = _Value;
                _M_w = _Val.x;
                _M_y = _Val.y;
            }

            /// <summary>
            ///     Property for accessing element 3, and 2 of this uint_4 as a uint_2.
            /// </summary>
            __declspec( property( get=get_wz, put=set_wz) ) uint_2 wz;
            /// <summary>
            ///     Property for accessing element 3, and 2 of this uint_4 as a uint_2.
            /// </summary>
            __declspec( property( get=get_wz, put=set_wz) ) uint_2 ab;

            /// <summary>
            ///     Returns a uint_2 that is composed of element 3, and element 2 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_2.
            /// </returns>
            uint_2 get_wz() const __GPU {
                return uint_2(_M_w,_M_z);
            }

            /// <summary>
            ///     Set element 3, and 2 of this uint_4 with a uint_2.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_2 value.
            /// </param>
            void set_wz(const uint_2& _Value) __GPU
            {
                uint_2 _Val = _Value;
                _M_w = _Val.x;
                _M_z = _Val.y;
            }

            /// <summary>
            ///     Property for accessing element 0, 1, and 2 of this uint_4 as a uint_3.
            /// </summary>
            __declspec( property( get=get_xyz, put=set_xyz) ) uint_3 xyz;
            /// <summary>
            ///     Property for accessing element 0, 1, and 2 of this uint_4 as a uint_3.
            /// </summary>
            __declspec( property( get=get_xyz, put=set_xyz) ) uint_3 rgb;

            /// <summary>
            ///     Returns a uint_3 that is composed of element 0, element 1, and element 2 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_3.
            /// </returns>
            uint_3 get_xyz() const __GPU {
                return uint_3(_M_x,_M_y,_M_z);
            }

            /// <summary>
            ///     Set element 0, 1, and 2 of this uint_4 with a uint_3.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_3 value.
            /// </param>
            void set_xyz(const uint_3& _Value) __GPU
            {
                uint_3 _Val = _Value;
                _M_x = _Val.x;
                _M_y = _Val.y;
                _M_z = _Val.z;
            }

            /// <summary>
            ///     Property for accessing element 0, 1, and 3 of this uint_4 as a uint_3.
            /// </summary>
            __declspec( property( get=get_xyw, put=set_xyw) ) uint_3 xyw;
            /// <summary>
            ///     Property for accessing element 0, 1, and 3 of this uint_4 as a uint_3.
            /// </summary>
            __declspec( property( get=get_xyw, put=set_xyw) ) uint_3 rga;

            /// <summary>
            ///     Returns a uint_3 that is composed of element 0, element 1, and element 3 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_3.
            /// </returns>
            uint_3 get_xyw() const __GPU {
                return uint_3(_M_x,_M_y,_M_w);
            }

            /// <summary>
            ///     Set element 0, 1, and 3 of this uint_4 with a uint_3.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_3 value.
            /// </param>
            void set_xyw(const uint_3& _Value) __GPU
            {
                uint_3 _Val = _Value;
                _M_x = _Val.x;
                _M_y = _Val.y;
                _M_w = _Val.z;
            }

            /// <summary>
            ///     Property for accessing element 0, 2, and 1 of this uint_4 as a uint_3.
            /// </summary>
            __declspec( property( get=get_xzy, put=set_xzy) ) uint_3 xzy;
            /// <summary>
            ///     Property for accessing element 0, 2, and 1 of this uint_4 as a uint_3.
            /// </summary>
            __declspec( property( get=get_xzy, put=set_xzy) ) uint_3 rbg;

            /// <summary>
            ///     Returns a uint_3 that is composed of element 0, element 2, and element 1 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_3.
            /// </returns>
            uint_3 get_xzy() const __GPU {
                return uint_3(_M_x,_M_z,_M_y);
            }

            /// <summary>
            ///     Set element 0, 2, and 1 of this uint_4 with a uint_3.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_3 value.
            /// </param>
            void set_xzy(const uint_3& _Value) __GPU
            {
                uint_3 _Val = _Value;
                _M_x = _Val.x;
                _M_z = _Val.y;
                _M_y = _Val.z;
            }

            /// <summary>
            ///     Property for accessing element 0, 2, and 3 of this uint_4 as a uint_3.
            /// </summary>
            __declspec( property( get=get_xzw, put=set_xzw) ) uint_3 xzw;
            /// <summary>
            ///     Property for accessing element 0, 2, and 3 of this uint_4 as a uint_3.
            /// </summary>
            __declspec( property( get=get_xzw, put=set_xzw) ) uint_3 rba;

            /// <summary>
            ///     Returns a uint_3 that is composed of element 0, element 2, and element 3 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_3.
            /// </returns>
            uint_3 get_xzw() const __GPU {
                return uint_3(_M_x,_M_z,_M_w);
            }

            /// <summary>
            ///     Set element 0, 2, and 3 of this uint_4 with a uint_3.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_3 value.
            /// </param>
            void set_xzw(const uint_3& _Value) __GPU
            {
                uint_3 _Val = _Value;
                _M_x = _Val.x;
                _M_z = _Val.y;
                _M_w = _Val.z;
            }

            /// <summary>
            ///     Property for accessing element 0, 3, and 1 of this uint_4 as a uint_3.
            /// </summary>
            __declspec( property( get=get_xwy, put=set_xwy) ) uint_3 xwy;
            /// <summary>
            ///     Property for accessing element 0, 3, and 1 of this uint_4 as a uint_3.
            /// </summary>
            __declspec( property( get=get_xwy, put=set_xwy) ) uint_3 rag;

            /// <summary>
            ///     Returns a uint_3 that is composed of element 0, element 3, and element 1 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_3.
            /// </returns>
            uint_3 get_xwy() const __GPU {
                return uint_3(_M_x,_M_w,_M_y);
            }

            /// <summary>
            ///     Set element 0, 3, and 1 of this uint_4 with a uint_3.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_3 value.
            /// </param>
            void set_xwy(const uint_3& _Value) __GPU
            {
                uint_3 _Val = _Value;
                _M_x = _Val.x;
                _M_w = _Val.y;
                _M_y = _Val.z;
            }

            /// <summary>
            ///     Property for accessing element 0, 3, and 2 of this uint_4 as a uint_3.
            /// </summary>
            __declspec( property( get=get_xwz, put=set_xwz) ) uint_3 xwz;
            /// <summary>
            ///     Property for accessing element 0, 3, and 2 of this uint_4 as a uint_3.
            /// </summary>
            __declspec( property( get=get_xwz, put=set_xwz) ) uint_3 rab;

            /// <summary>
            ///     Returns a uint_3 that is composed of element 0, element 3, and element 2 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_3.
            /// </returns>
            uint_3 get_xwz() const __GPU {
                return uint_3(_M_x,_M_w,_M_z);
            }

            /// <summary>
            ///     Set element 0, 3, and 2 of this uint_4 with a uint_3.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_3 value.
            /// </param>
            void set_xwz(const uint_3& _Value) __GPU
            {
                uint_3 _Val = _Value;
                _M_x = _Val.x;
                _M_w = _Val.y;
                _M_z = _Val.z;
            }

            /// <summary>
            ///     Property for accessing element 1, 0, and 2 of this uint_4 as a uint_3.
            /// </summary>
            __declspec( property( get=get_yxz, put=set_yxz) ) uint_3 yxz;
            /// <summary>
            ///     Property for accessing element 1, 0, and 2 of this uint_4 as a uint_3.
            /// </summary>
            __declspec( property( get=get_yxz, put=set_yxz) ) uint_3 grb;

            /// <summary>
            ///     Returns a uint_3 that is composed of element 1, element 0, and element 2 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_3.
            /// </returns>
            uint_3 get_yxz() const __GPU {
                return uint_3(_M_y,_M_x,_M_z);
            }

            /// <summary>
            ///     Set element 1, 0, and 2 of this uint_4 with a uint_3.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_3 value.
            /// </param>
            void set_yxz(const uint_3& _Value) __GPU
            {
                uint_3 _Val = _Value;
                _M_y = _Val.x;
                _M_x = _Val.y;
                _M_z = _Val.z;
            }

            /// <summary>
            ///     Property for accessing element 1, 0, and 3 of this uint_4 as a uint_3.
            /// </summary>
            __declspec( property( get=get_yxw, put=set_yxw) ) uint_3 yxw;
            /// <summary>
            ///     Property for accessing element 1, 0, and 3 of this uint_4 as a uint_3.
            /// </summary>
            __declspec( property( get=get_yxw, put=set_yxw) ) uint_3 gra;

            /// <summary>
            ///     Returns a uint_3 that is composed of element 1, element 0, and element 3 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_3.
            /// </returns>
            uint_3 get_yxw() const __GPU {
                return uint_3(_M_y,_M_x,_M_w);
            }

            /// <summary>
            ///     Set element 1, 0, and 3 of this uint_4 with a uint_3.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_3 value.
            /// </param>
            void set_yxw(const uint_3& _Value) __GPU
            {
                uint_3 _Val = _Value;
                _M_y = _Val.x;
                _M_x = _Val.y;
                _M_w = _Val.z;
            }

            /// <summary>
            ///     Property for accessing element 1, 2, and 0 of this uint_4 as a uint_3.
            /// </summary>
            __declspec( property( get=get_yzx, put=set_yzx) ) uint_3 yzx;
            /// <summary>
            ///     Property for accessing element 1, 2, and 0 of this uint_4 as a uint_3.
            /// </summary>
            __declspec( property( get=get_yzx, put=set_yzx) ) uint_3 gbr;

            /// <summary>
            ///     Returns a uint_3 that is composed of element 1, element 2, and element 0 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_3.
            /// </returns>
            uint_3 get_yzx() const __GPU {
                return uint_3(_M_y,_M_z,_M_x);
            }

            /// <summary>
            ///     Set element 1, 2, and 0 of this uint_4 with a uint_3.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_3 value.
            /// </param>
            void set_yzx(const uint_3& _Value) __GPU
            {
                uint_3 _Val = _Value;
                _M_y = _Val.x;
                _M_z = _Val.y;
                _M_x = _Val.z;
            }

            /// <summary>
            ///     Property for accessing element 1, 2, and 3 of this uint_4 as a uint_3.
            /// </summary>
            __declspec( property( get=get_yzw, put=set_yzw) ) uint_3 yzw;
            /// <summary>
            ///     Property for accessing element 1, 2, and 3 of this uint_4 as a uint_3.
            /// </summary>
            __declspec( property( get=get_yzw, put=set_yzw) ) uint_3 gba;

            /// <summary>
            ///     Returns a uint_3 that is composed of element 1, element 2, and element 3 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_3.
            /// </returns>
            uint_3 get_yzw() const __GPU {
                return uint_3(_M_y,_M_z,_M_w);
            }

            /// <summary>
            ///     Set element 1, 2, and 3 of this uint_4 with a uint_3.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_3 value.
            /// </param>
            void set_yzw(const uint_3& _Value) __GPU
            {
                uint_3 _Val = _Value;
                _M_y = _Val.x;
                _M_z = _Val.y;
                _M_w = _Val.z;
            }

            /// <summary>
            ///     Property for accessing element 1, 3, and 0 of this uint_4 as a uint_3.
            /// </summary>
            __declspec( property( get=get_ywx, put=set_ywx) ) uint_3 ywx;
            /// <summary>
            ///     Property for accessing element 1, 3, and 0 of this uint_4 as a uint_3.
            /// </summary>
            __declspec( property( get=get_ywx, put=set_ywx) ) uint_3 gar;

            /// <summary>
            ///     Returns a uint_3 that is composed of element 1, element 3, and element 0 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_3.
            /// </returns>
            uint_3 get_ywx() const __GPU {
                return uint_3(_M_y,_M_w,_M_x);
            }

            /// <summary>
            ///     Set element 1, 3, and 0 of this uint_4 with a uint_3.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_3 value.
            /// </param>
            void set_ywx(const uint_3& _Value) __GPU
            {
                uint_3 _Val = _Value;
                _M_y = _Val.x;
                _M_w = _Val.y;
                _M_x = _Val.z;
            }

            /// <summary>
            ///     Property for accessing element 1, 3, and 2 of this uint_4 as a uint_3.
            /// </summary>
            __declspec( property( get=get_ywz, put=set_ywz) ) uint_3 ywz;
            /// <summary>
            ///     Property for accessing element 1, 3, and 2 of this uint_4 as a uint_3.
            /// </summary>
            __declspec( property( get=get_ywz, put=set_ywz) ) uint_3 gab;

            /// <summary>
            ///     Returns a uint_3 that is composed of element 1, element 3, and element 2 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_3.
            /// </returns>
            uint_3 get_ywz() const __GPU {
                return uint_3(_M_y,_M_w,_M_z);
            }

            /// <summary>
            ///     Set element 1, 3, and 2 of this uint_4 with a uint_3.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_3 value.
            /// </param>
            void set_ywz(const uint_3& _Value) __GPU
            {
                uint_3 _Val = _Value;
                _M_y = _Val.x;
                _M_w = _Val.y;
                _M_z = _Val.z;
            }

            /// <summary>
            ///     Property for accessing element 2, 0, and 1 of this uint_4 as a uint_3.
            /// </summary>
            __declspec( property( get=get_zxy, put=set_zxy) ) uint_3 zxy;
            /// <summary>
            ///     Property for accessing element 2, 0, and 1 of this uint_4 as a uint_3.
            /// </summary>
            __declspec( property( get=get_zxy, put=set_zxy) ) uint_3 brg;

            /// <summary>
            ///     Returns a uint_3 that is composed of element 2, element 0, and element 1 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_3.
            /// </returns>
            uint_3 get_zxy() const __GPU {
                return uint_3(_M_z,_M_x,_M_y);
            }

            /// <summary>
            ///     Set element 2, 0, and 1 of this uint_4 with a uint_3.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_3 value.
            /// </param>
            void set_zxy(const uint_3& _Value) __GPU
            {
                uint_3 _Val = _Value;
                _M_z = _Val.x;
                _M_x = _Val.y;
                _M_y = _Val.z;
            }

            /// <summary>
            ///     Property for accessing element 2, 0, and 3 of this uint_4 as a uint_3.
            /// </summary>
            __declspec( property( get=get_zxw, put=set_zxw) ) uint_3 zxw;
            /// <summary>
            ///     Property for accessing element 2, 0, and 3 of this uint_4 as a uint_3.
            /// </summary>
            __declspec( property( get=get_zxw, put=set_zxw) ) uint_3 bra;

            /// <summary>
            ///     Returns a uint_3 that is composed of element 2, element 0, and element 3 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_3.
            /// </returns>
            uint_3 get_zxw() const __GPU {
                return uint_3(_M_z,_M_x,_M_w);
            }

            /// <summary>
            ///     Set element 2, 0, and 3 of this uint_4 with a uint_3.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_3 value.
            /// </param>
            void set_zxw(const uint_3& _Value) __GPU
            {
                uint_3 _Val = _Value;
                _M_z = _Val.x;
                _M_x = _Val.y;
                _M_w = _Val.z;
            }

            /// <summary>
            ///     Property for accessing element 2, 1, and 0 of this uint_4 as a uint_3.
            /// </summary>
            __declspec( property( get=get_zyx, put=set_zyx) ) uint_3 zyx;
            /// <summary>
            ///     Property for accessing element 2, 1, and 0 of this uint_4 as a uint_3.
            /// </summary>
            __declspec( property( get=get_zyx, put=set_zyx) ) uint_3 bgr;

            /// <summary>
            ///     Returns a uint_3 that is composed of element 2, element 1, and element 0 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_3.
            /// </returns>
            uint_3 get_zyx() const __GPU {
                return uint_3(_M_z,_M_y,_M_x);
            }

            /// <summary>
            ///     Set element 2, 1, and 0 of this uint_4 with a uint_3.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_3 value.
            /// </param>
            void set_zyx(const uint_3& _Value) __GPU
            {
                uint_3 _Val = _Value;
                _M_z = _Val.x;
                _M_y = _Val.y;
                _M_x = _Val.z;
            }

            /// <summary>
            ///     Property for accessing element 2, 1, and 3 of this uint_4 as a uint_3.
            /// </summary>
            __declspec( property( get=get_zyw, put=set_zyw) ) uint_3 zyw;
            /// <summary>
            ///     Property for accessing element 2, 1, and 3 of this uint_4 as a uint_3.
            /// </summary>
            __declspec( property( get=get_zyw, put=set_zyw) ) uint_3 bga;

            /// <summary>
            ///     Returns a uint_3 that is composed of element 2, element 1, and element 3 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_3.
            /// </returns>
            uint_3 get_zyw() const __GPU {
                return uint_3(_M_z,_M_y,_M_w);
            }

            /// <summary>
            ///     Set element 2, 1, and 3 of this uint_4 with a uint_3.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_3 value.
            /// </param>
            void set_zyw(const uint_3& _Value) __GPU
            {
                uint_3 _Val = _Value;
                _M_z = _Val.x;
                _M_y = _Val.y;
                _M_w = _Val.z;
            }

            /// <summary>
            ///     Property for accessing element 2, 3, and 0 of this uint_4 as a uint_3.
            /// </summary>
            __declspec( property( get=get_zwx, put=set_zwx) ) uint_3 zwx;
            /// <summary>
            ///     Property for accessing element 2, 3, and 0 of this uint_4 as a uint_3.
            /// </summary>
            __declspec( property( get=get_zwx, put=set_zwx) ) uint_3 bar;

            /// <summary>
            ///     Returns a uint_3 that is composed of element 2, element 3, and element 0 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_3.
            /// </returns>
            uint_3 get_zwx() const __GPU {
                return uint_3(_M_z,_M_w,_M_x);
            }

            /// <summary>
            ///     Set element 2, 3, and 0 of this uint_4 with a uint_3.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_3 value.
            /// </param>
            void set_zwx(const uint_3& _Value) __GPU
            {
                uint_3 _Val = _Value;
                _M_z = _Val.x;
                _M_w = _Val.y;
                _M_x = _Val.z;
            }

            /// <summary>
            ///     Property for accessing element 2, 3, and 1 of this uint_4 as a uint_3.
            /// </summary>
            __declspec( property( get=get_zwy, put=set_zwy) ) uint_3 zwy;
            /// <summary>
            ///     Property for accessing element 2, 3, and 1 of this uint_4 as a uint_3.
            /// </summary>
            __declspec( property( get=get_zwy, put=set_zwy) ) uint_3 bag;

            /// <summary>
            ///     Returns a uint_3 that is composed of element 2, element 3, and element 1 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_3.
            /// </returns>
            uint_3 get_zwy() const __GPU {
                return uint_3(_M_z,_M_w,_M_y);
            }

            /// <summary>
            ///     Set element 2, 3, and 1 of this uint_4 with a uint_3.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_3 value.
            /// </param>
            void set_zwy(const uint_3& _Value) __GPU
            {
                uint_3 _Val = _Value;
                _M_z = _Val.x;
                _M_w = _Val.y;
                _M_y = _Val.z;
            }

            /// <summary>
            ///     Property for accessing element 3, 0, and 1 of this uint_4 as a uint_3.
            /// </summary>
            __declspec( property( get=get_wxy, put=set_wxy) ) uint_3 wxy;
            /// <summary>
            ///     Property for accessing element 3, 0, and 1 of this uint_4 as a uint_3.
            /// </summary>
            __declspec( property( get=get_wxy, put=set_wxy) ) uint_3 arg;

            /// <summary>
            ///     Returns a uint_3 that is composed of element 3, element 0, and element 1 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_3.
            /// </returns>
            uint_3 get_wxy() const __GPU {
                return uint_3(_M_w,_M_x,_M_y);
            }

            /// <summary>
            ///     Set element 3, 0, and 1 of this uint_4 with a uint_3.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_3 value.
            /// </param>
            void set_wxy(const uint_3& _Value) __GPU
            {
                uint_3 _Val = _Value;
                _M_w = _Val.x;
                _M_x = _Val.y;
                _M_y = _Val.z;
            }

            /// <summary>
            ///     Property for accessing element 3, 0, and 2 of this uint_4 as a uint_3.
            /// </summary>
            __declspec( property( get=get_wxz, put=set_wxz) ) uint_3 wxz;
            /// <summary>
            ///     Property for accessing element 3, 0, and 2 of this uint_4 as a uint_3.
            /// </summary>
            __declspec( property( get=get_wxz, put=set_wxz) ) uint_3 arb;

            /// <summary>
            ///     Returns a uint_3 that is composed of element 3, element 0, and element 2 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_3.
            /// </returns>
            uint_3 get_wxz() const __GPU {
                return uint_3(_M_w,_M_x,_M_z);
            }

            /// <summary>
            ///     Set element 3, 0, and 2 of this uint_4 with a uint_3.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_3 value.
            /// </param>
            void set_wxz(const uint_3& _Value) __GPU
            {
                uint_3 _Val = _Value;
                _M_w = _Val.x;
                _M_x = _Val.y;
                _M_z = _Val.z;
            }

            /// <summary>
            ///     Property for accessing element 3, 1, and 0 of this uint_4 as a uint_3.
            /// </summary>
            __declspec( property( get=get_wyx, put=set_wyx) ) uint_3 wyx;
            /// <summary>
            ///     Property for accessing element 3, 1, and 0 of this uint_4 as a uint_3.
            /// </summary>
            __declspec( property( get=get_wyx, put=set_wyx) ) uint_3 agr;

            /// <summary>
            ///     Returns a uint_3 that is composed of element 3, element 1, and element 0 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_3.
            /// </returns>
            uint_3 get_wyx() const __GPU {
                return uint_3(_M_w,_M_y,_M_x);
            }

            /// <summary>
            ///     Set element 3, 1, and 0 of this uint_4 with a uint_3.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_3 value.
            /// </param>
            void set_wyx(const uint_3& _Value) __GPU
            {
                uint_3 _Val = _Value;
                _M_w = _Val.x;
                _M_y = _Val.y;
                _M_x = _Val.z;
            }

            /// <summary>
            ///     Property for accessing element 3, 1, and 2 of this uint_4 as a uint_3.
            /// </summary>
            __declspec( property( get=get_wyz, put=set_wyz) ) uint_3 wyz;
            /// <summary>
            ///     Property for accessing element 3, 1, and 2 of this uint_4 as a uint_3.
            /// </summary>
            __declspec( property( get=get_wyz, put=set_wyz) ) uint_3 agb;

            /// <summary>
            ///     Returns a uint_3 that is composed of element 3, element 1, and element 2 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_3.
            /// </returns>
            uint_3 get_wyz() const __GPU {
                return uint_3(_M_w,_M_y,_M_z);
            }

            /// <summary>
            ///     Set element 3, 1, and 2 of this uint_4 with a uint_3.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_3 value.
            /// </param>
            void set_wyz(const uint_3& _Value) __GPU
            {
                uint_3 _Val = _Value;
                _M_w = _Val.x;
                _M_y = _Val.y;
                _M_z = _Val.z;
            }

            /// <summary>
            ///     Property for accessing element 3, 2, and 0 of this uint_4 as a uint_3.
            /// </summary>
            __declspec( property( get=get_wzx, put=set_wzx) ) uint_3 wzx;
            /// <summary>
            ///     Property for accessing element 3, 2, and 0 of this uint_4 as a uint_3.
            /// </summary>
            __declspec( property( get=get_wzx, put=set_wzx) ) uint_3 abr;

            /// <summary>
            ///     Returns a uint_3 that is composed of element 3, element 2, and element 0 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_3.
            /// </returns>
            uint_3 get_wzx() const __GPU {
                return uint_3(_M_w,_M_z,_M_x);
            }

            /// <summary>
            ///     Set element 3, 2, and 0 of this uint_4 with a uint_3.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_3 value.
            /// </param>
            void set_wzx(const uint_3& _Value) __GPU
            {
                uint_3 _Val = _Value;
                _M_w = _Val.x;
                _M_z = _Val.y;
                _M_x = _Val.z;
            }

            /// <summary>
            ///     Property for accessing element 3, 2, and 1 of this uint_4 as a uint_3.
            /// </summary>
            __declspec( property( get=get_wzy, put=set_wzy) ) uint_3 wzy;
            /// <summary>
            ///     Property for accessing element 3, 2, and 1 of this uint_4 as a uint_3.
            /// </summary>
            __declspec( property( get=get_wzy, put=set_wzy) ) uint_3 abg;

            /// <summary>
            ///     Returns a uint_3 that is composed of element 3, element 2, and element 1 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_3.
            /// </returns>
            uint_3 get_wzy() const __GPU {
                return uint_3(_M_w,_M_z,_M_y);
            }

            /// <summary>
            ///     Set element 3, 2, and 1 of this uint_4 with a uint_3.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_3 value.
            /// </param>
            void set_wzy(const uint_3& _Value) __GPU
            {
                uint_3 _Val = _Value;
                _M_w = _Val.x;
                _M_z = _Val.y;
                _M_y = _Val.z;
            }

            /// <summary>
            ///     Property for accessing element 0, 1, 2, and 3 of this uint_4 as a uint_4.
            /// </summary>
            __declspec( property( get=get_xyzw, put=set_xyzw) ) uint_4 xyzw;
            /// <summary>
            ///     Property for accessing element 0, 1, 2, and 3 of this uint_4 as a uint_4.
            /// </summary>
            __declspec( property( get=get_xyzw, put=set_xyzw) ) uint_4 rgba;

            /// <summary>
            ///     Returns a uint_4 that is composed of element 0, element 1, element 2, and element 3 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_4.
            /// </returns>
            uint_4 get_xyzw() const __GPU {
                return uint_4(_M_x,_M_y,_M_z,_M_w);
            }

            /// <summary>
            ///     Set element 0, 1, 2, and 3 of this uint_4 with a uint_4.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_4 value.
            /// </param>
            void set_xyzw(const uint_4& _Value) __GPU
            {
                uint_4 _Val = _Value;
                _M_x = _Val.x;
                _M_y = _Val.y;
                _M_z = _Val.z;
                _M_w = _Val.w;
            }

            /// <summary>
            ///     Property for accessing element 0, 1, 3, and 2 of this uint_4 as a uint_4.
            /// </summary>
            __declspec( property( get=get_xywz, put=set_xywz) ) uint_4 xywz;
            /// <summary>
            ///     Property for accessing element 0, 1, 3, and 2 of this uint_4 as a uint_4.
            /// </summary>
            __declspec( property( get=get_xywz, put=set_xywz) ) uint_4 rgab;

            /// <summary>
            ///     Returns a uint_4 that is composed of element 0, element 1, element 3, and element 2 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_4.
            /// </returns>
            uint_4 get_xywz() const __GPU {
                return uint_4(_M_x,_M_y,_M_w,_M_z);
            }

            /// <summary>
            ///     Set element 0, 1, 3, and 2 of this uint_4 with a uint_4.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_4 value.
            /// </param>
            void set_xywz(const uint_4& _Value) __GPU
            {
                uint_4 _Val = _Value;
                _M_x = _Val.x;
                _M_y = _Val.y;
                _M_w = _Val.z;
                _M_z = _Val.w;
            }

            /// <summary>
            ///     Property for accessing element 0, 2, 1, and 3 of this uint_4 as a uint_4.
            /// </summary>
            __declspec( property( get=get_xzyw, put=set_xzyw) ) uint_4 xzyw;
            /// <summary>
            ///     Property for accessing element 0, 2, 1, and 3 of this uint_4 as a uint_4.
            /// </summary>
            __declspec( property( get=get_xzyw, put=set_xzyw) ) uint_4 rbga;

            /// <summary>
            ///     Returns a uint_4 that is composed of element 0, element 2, element 1, and element 3 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_4.
            /// </returns>
            uint_4 get_xzyw() const __GPU {
                return uint_4(_M_x,_M_z,_M_y,_M_w);
            }

            /// <summary>
            ///     Set element 0, 2, 1, and 3 of this uint_4 with a uint_4.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_4 value.
            /// </param>
            void set_xzyw(const uint_4& _Value) __GPU
            {
                uint_4 _Val = _Value;
                _M_x = _Val.x;
                _M_z = _Val.y;
                _M_y = _Val.z;
                _M_w = _Val.w;
            }

            /// <summary>
            ///     Property for accessing element 0, 2, 3, and 1 of this uint_4 as a uint_4.
            /// </summary>
            __declspec( property( get=get_xzwy, put=set_xzwy) ) uint_4 xzwy;
            /// <summary>
            ///     Property for accessing element 0, 2, 3, and 1 of this uint_4 as a uint_4.
            /// </summary>
            __declspec( property( get=get_xzwy, put=set_xzwy) ) uint_4 rbag;

            /// <summary>
            ///     Returns a uint_4 that is composed of element 0, element 2, element 3, and element 1 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_4.
            /// </returns>
            uint_4 get_xzwy() const __GPU {
                return uint_4(_M_x,_M_z,_M_w,_M_y);
            }

            /// <summary>
            ///     Set element 0, 2, 3, and 1 of this uint_4 with a uint_4.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_4 value.
            /// </param>
            void set_xzwy(const uint_4& _Value) __GPU
            {
                uint_4 _Val = _Value;
                _M_x = _Val.x;
                _M_z = _Val.y;
                _M_w = _Val.z;
                _M_y = _Val.w;
            }

            /// <summary>
            ///     Property for accessing element 0, 3, 1, and 2 of this uint_4 as a uint_4.
            /// </summary>
            __declspec( property( get=get_xwyz, put=set_xwyz) ) uint_4 xwyz;
            /// <summary>
            ///     Property for accessing element 0, 3, 1, and 2 of this uint_4 as a uint_4.
            /// </summary>
            __declspec( property( get=get_xwyz, put=set_xwyz) ) uint_4 ragb;

            /// <summary>
            ///     Returns a uint_4 that is composed of element 0, element 3, element 1, and element 2 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_4.
            /// </returns>
            uint_4 get_xwyz() const __GPU {
                return uint_4(_M_x,_M_w,_M_y,_M_z);
            }

            /// <summary>
            ///     Set element 0, 3, 1, and 2 of this uint_4 with a uint_4.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_4 value.
            /// </param>
            void set_xwyz(const uint_4& _Value) __GPU
            {
                uint_4 _Val = _Value;
                _M_x = _Val.x;
                _M_w = _Val.y;
                _M_y = _Val.z;
                _M_z = _Val.w;
            }

            /// <summary>
            ///     Property for accessing element 0, 3, 2, and 1 of this uint_4 as a uint_4.
            /// </summary>
            __declspec( property( get=get_xwzy, put=set_xwzy) ) uint_4 xwzy;
            /// <summary>
            ///     Property for accessing element 0, 3, 2, and 1 of this uint_4 as a uint_4.
            /// </summary>
            __declspec( property( get=get_xwzy, put=set_xwzy) ) uint_4 rabg;

            /// <summary>
            ///     Returns a uint_4 that is composed of element 0, element 3, element 2, and element 1 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_4.
            /// </returns>
            uint_4 get_xwzy() const __GPU {
                return uint_4(_M_x,_M_w,_M_z,_M_y);
            }

            /// <summary>
            ///     Set element 0, 3, 2, and 1 of this uint_4 with a uint_4.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_4 value.
            /// </param>
            void set_xwzy(const uint_4& _Value) __GPU
            {
                uint_4 _Val = _Value;
                _M_x = _Val.x;
                _M_w = _Val.y;
                _M_z = _Val.z;
                _M_y = _Val.w;
            }

            /// <summary>
            ///     Property for accessing element 1, 0, 2, and 3 of this uint_4 as a uint_4.
            /// </summary>
            __declspec( property( get=get_yxzw, put=set_yxzw) ) uint_4 yxzw;
            /// <summary>
            ///     Property for accessing element 1, 0, 2, and 3 of this uint_4 as a uint_4.
            /// </summary>
            __declspec( property( get=get_yxzw, put=set_yxzw) ) uint_4 grba;

            /// <summary>
            ///     Returns a uint_4 that is composed of element 1, element 0, element 2, and element 3 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_4.
            /// </returns>
            uint_4 get_yxzw() const __GPU {
                return uint_4(_M_y,_M_x,_M_z,_M_w);
            }

            /// <summary>
            ///     Set element 1, 0, 2, and 3 of this uint_4 with a uint_4.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_4 value.
            /// </param>
            void set_yxzw(const uint_4& _Value) __GPU
            {
                uint_4 _Val = _Value;
                _M_y = _Val.x;
                _M_x = _Val.y;
                _M_z = _Val.z;
                _M_w = _Val.w;
            }

            /// <summary>
            ///     Property for accessing element 1, 0, 3, and 2 of this uint_4 as a uint_4.
            /// </summary>
            __declspec( property( get=get_yxwz, put=set_yxwz) ) uint_4 yxwz;
            /// <summary>
            ///     Property for accessing element 1, 0, 3, and 2 of this uint_4 as a uint_4.
            /// </summary>
            __declspec( property( get=get_yxwz, put=set_yxwz) ) uint_4 grab;

            /// <summary>
            ///     Returns a uint_4 that is composed of element 1, element 0, element 3, and element 2 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_4.
            /// </returns>
            uint_4 get_yxwz() const __GPU {
                return uint_4(_M_y,_M_x,_M_w,_M_z);
            }

            /// <summary>
            ///     Set element 1, 0, 3, and 2 of this uint_4 with a uint_4.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_4 value.
            /// </param>
            void set_yxwz(const uint_4& _Value) __GPU
            {
                uint_4 _Val = _Value;
                _M_y = _Val.x;
                _M_x = _Val.y;
                _M_w = _Val.z;
                _M_z = _Val.w;
            }

            /// <summary>
            ///     Property for accessing element 1, 2, 0, and 3 of this uint_4 as a uint_4.
            /// </summary>
            __declspec( property( get=get_yzxw, put=set_yzxw) ) uint_4 yzxw;
            /// <summary>
            ///     Property for accessing element 1, 2, 0, and 3 of this uint_4 as a uint_4.
            /// </summary>
            __declspec( property( get=get_yzxw, put=set_yzxw) ) uint_4 gbra;

            /// <summary>
            ///     Returns a uint_4 that is composed of element 1, element 2, element 0, and element 3 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_4.
            /// </returns>
            uint_4 get_yzxw() const __GPU {
                return uint_4(_M_y,_M_z,_M_x,_M_w);
            }

            /// <summary>
            ///     Set element 1, 2, 0, and 3 of this uint_4 with a uint_4.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_4 value.
            /// </param>
            void set_yzxw(const uint_4& _Value) __GPU
            {
                uint_4 _Val = _Value;
                _M_y = _Val.x;
                _M_z = _Val.y;
                _M_x = _Val.z;
                _M_w = _Val.w;
            }

            /// <summary>
            ///     Property for accessing element 1, 2, 3, and 0 of this uint_4 as a uint_4.
            /// </summary>
            __declspec( property( get=get_yzwx, put=set_yzwx) ) uint_4 yzwx;
            /// <summary>
            ///     Property for accessing element 1, 2, 3, and 0 of this uint_4 as a uint_4.
            /// </summary>
            __declspec( property( get=get_yzwx, put=set_yzwx) ) uint_4 gbar;

            /// <summary>
            ///     Returns a uint_4 that is composed of element 1, element 2, element 3, and element 0 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_4.
            /// </returns>
            uint_4 get_yzwx() const __GPU {
                return uint_4(_M_y,_M_z,_M_w,_M_x);
            }

            /// <summary>
            ///     Set element 1, 2, 3, and 0 of this uint_4 with a uint_4.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_4 value.
            /// </param>
            void set_yzwx(const uint_4& _Value) __GPU
            {
                uint_4 _Val = _Value;
                _M_y = _Val.x;
                _M_z = _Val.y;
                _M_w = _Val.z;
                _M_x = _Val.w;
            }

            /// <summary>
            ///     Property for accessing element 1, 3, 0, and 2 of this uint_4 as a uint_4.
            /// </summary>
            __declspec( property( get=get_ywxz, put=set_ywxz) ) uint_4 ywxz;
            /// <summary>
            ///     Property for accessing element 1, 3, 0, and 2 of this uint_4 as a uint_4.
            /// </summary>
            __declspec( property( get=get_ywxz, put=set_ywxz) ) uint_4 garb;

            /// <summary>
            ///     Returns a uint_4 that is composed of element 1, element 3, element 0, and element 2 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_4.
            /// </returns>
            uint_4 get_ywxz() const __GPU {
                return uint_4(_M_y,_M_w,_M_x,_M_z);
            }

            /// <summary>
            ///     Set element 1, 3, 0, and 2 of this uint_4 with a uint_4.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_4 value.
            /// </param>
            void set_ywxz(const uint_4& _Value) __GPU
            {
                uint_4 _Val = _Value;
                _M_y = _Val.x;
                _M_w = _Val.y;
                _M_x = _Val.z;
                _M_z = _Val.w;
            }

            /// <summary>
            ///     Property for accessing element 1, 3, 2, and 0 of this uint_4 as a uint_4.
            /// </summary>
            __declspec( property( get=get_ywzx, put=set_ywzx) ) uint_4 ywzx;
            /// <summary>
            ///     Property for accessing element 1, 3, 2, and 0 of this uint_4 as a uint_4.
            /// </summary>
            __declspec( property( get=get_ywzx, put=set_ywzx) ) uint_4 gabr;

            /// <summary>
            ///     Returns a uint_4 that is composed of element 1, element 3, element 2, and element 0 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_4.
            /// </returns>
            uint_4 get_ywzx() const __GPU {
                return uint_4(_M_y,_M_w,_M_z,_M_x);
            }

            /// <summary>
            ///     Set element 1, 3, 2, and 0 of this uint_4 with a uint_4.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_4 value.
            /// </param>
            void set_ywzx(const uint_4& _Value) __GPU
            {
                uint_4 _Val = _Value;
                _M_y = _Val.x;
                _M_w = _Val.y;
                _M_z = _Val.z;
                _M_x = _Val.w;
            }

            /// <summary>
            ///     Property for accessing element 2, 0, 1, and 3 of this uint_4 as a uint_4.
            /// </summary>
            __declspec( property( get=get_zxyw, put=set_zxyw) ) uint_4 zxyw;
            /// <summary>
            ///     Property for accessing element 2, 0, 1, and 3 of this uint_4 as a uint_4.
            /// </summary>
            __declspec( property( get=get_zxyw, put=set_zxyw) ) uint_4 brga;

            /// <summary>
            ///     Returns a uint_4 that is composed of element 2, element 0, element 1, and element 3 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_4.
            /// </returns>
            uint_4 get_zxyw() const __GPU {
                return uint_4(_M_z,_M_x,_M_y,_M_w);
            }

            /// <summary>
            ///     Set element 2, 0, 1, and 3 of this uint_4 with a uint_4.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_4 value.
            /// </param>
            void set_zxyw(const uint_4& _Value) __GPU
            {
                uint_4 _Val = _Value;
                _M_z = _Val.x;
                _M_x = _Val.y;
                _M_y = _Val.z;
                _M_w = _Val.w;
            }

            /// <summary>
            ///     Property for accessing element 2, 0, 3, and 1 of this uint_4 as a uint_4.
            /// </summary>
            __declspec( property( get=get_zxwy, put=set_zxwy) ) uint_4 zxwy;
            /// <summary>
            ///     Property for accessing element 2, 0, 3, and 1 of this uint_4 as a uint_4.
            /// </summary>
            __declspec( property( get=get_zxwy, put=set_zxwy) ) uint_4 brag;

            /// <summary>
            ///     Returns a uint_4 that is composed of element 2, element 0, element 3, and element 1 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_4.
            /// </returns>
            uint_4 get_zxwy() const __GPU {
                return uint_4(_M_z,_M_x,_M_w,_M_y);
            }

            /// <summary>
            ///     Set element 2, 0, 3, and 1 of this uint_4 with a uint_4.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_4 value.
            /// </param>
            void set_zxwy(const uint_4& _Value) __GPU
            {
                uint_4 _Val = _Value;
                _M_z = _Val.x;
                _M_x = _Val.y;
                _M_w = _Val.z;
                _M_y = _Val.w;
            }

            /// <summary>
            ///     Property for accessing element 2, 1, 0, and 3 of this uint_4 as a uint_4.
            /// </summary>
            __declspec( property( get=get_zyxw, put=set_zyxw) ) uint_4 zyxw;
            /// <summary>
            ///     Property for accessing element 2, 1, 0, and 3 of this uint_4 as a uint_4.
            /// </summary>
            __declspec( property( get=get_zyxw, put=set_zyxw) ) uint_4 bgra;

            /// <summary>
            ///     Returns a uint_4 that is composed of element 2, element 1, element 0, and element 3 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_4.
            /// </returns>
            uint_4 get_zyxw() const __GPU {
                return uint_4(_M_z,_M_y,_M_x,_M_w);
            }

            /// <summary>
            ///     Set element 2, 1, 0, and 3 of this uint_4 with a uint_4.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_4 value.
            /// </param>
            void set_zyxw(const uint_4& _Value) __GPU
            {
                uint_4 _Val = _Value;
                _M_z = _Val.x;
                _M_y = _Val.y;
                _M_x = _Val.z;
                _M_w = _Val.w;
            }

            /// <summary>
            ///     Property for accessing element 2, 1, 3, and 0 of this uint_4 as a uint_4.
            /// </summary>
            __declspec( property( get=get_zywx, put=set_zywx) ) uint_4 zywx;
            /// <summary>
            ///     Property for accessing element 2, 1, 3, and 0 of this uint_4 as a uint_4.
            /// </summary>
            __declspec( property( get=get_zywx, put=set_zywx) ) uint_4 bgar;

            /// <summary>
            ///     Returns a uint_4 that is composed of element 2, element 1, element 3, and element 0 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_4.
            /// </returns>
            uint_4 get_zywx() const __GPU {
                return uint_4(_M_z,_M_y,_M_w,_M_x);
            }

            /// <summary>
            ///     Set element 2, 1, 3, and 0 of this uint_4 with a uint_4.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_4 value.
            /// </param>
            void set_zywx(const uint_4& _Value) __GPU
            {
                uint_4 _Val = _Value;
                _M_z = _Val.x;
                _M_y = _Val.y;
                _M_w = _Val.z;
                _M_x = _Val.w;
            }

            /// <summary>
            ///     Property for accessing element 2, 3, 0, and 1 of this uint_4 as a uint_4.
            /// </summary>
            __declspec( property( get=get_zwxy, put=set_zwxy) ) uint_4 zwxy;
            /// <summary>
            ///     Property for accessing element 2, 3, 0, and 1 of this uint_4 as a uint_4.
            /// </summary>
            __declspec( property( get=get_zwxy, put=set_zwxy) ) uint_4 barg;

            /// <summary>
            ///     Returns a uint_4 that is composed of element 2, element 3, element 0, and element 1 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_4.
            /// </returns>
            uint_4 get_zwxy() const __GPU {
                return uint_4(_M_z,_M_w,_M_x,_M_y);
            }

            /// <summary>
            ///     Set element 2, 3, 0, and 1 of this uint_4 with a uint_4.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_4 value.
            /// </param>
            void set_zwxy(const uint_4& _Value) __GPU
            {
                uint_4 _Val = _Value;
                _M_z = _Val.x;
                _M_w = _Val.y;
                _M_x = _Val.z;
                _M_y = _Val.w;
            }

            /// <summary>
            ///     Property for accessing element 2, 3, 1, and 0 of this uint_4 as a uint_4.
            /// </summary>
            __declspec( property( get=get_zwyx, put=set_zwyx) ) uint_4 zwyx;
            /// <summary>
            ///     Property for accessing element 2, 3, 1, and 0 of this uint_4 as a uint_4.
            /// </summary>
            __declspec( property( get=get_zwyx, put=set_zwyx) ) uint_4 bagr;

            /// <summary>
            ///     Returns a uint_4 that is composed of element 2, element 3, element 1, and element 0 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_4.
            /// </returns>
            uint_4 get_zwyx() const __GPU {
                return uint_4(_M_z,_M_w,_M_y,_M_x);
            }

            /// <summary>
            ///     Set element 2, 3, 1, and 0 of this uint_4 with a uint_4.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_4 value.
            /// </param>
            void set_zwyx(const uint_4& _Value) __GPU
            {
                uint_4 _Val = _Value;
                _M_z = _Val.x;
                _M_w = _Val.y;
                _M_y = _Val.z;
                _M_x = _Val.w;
            }

            /// <summary>
            ///     Property for accessing element 3, 0, 1, and 2 of this uint_4 as a uint_4.
            /// </summary>
            __declspec( property( get=get_wxyz, put=set_wxyz) ) uint_4 wxyz;
            /// <summary>
            ///     Property for accessing element 3, 0, 1, and 2 of this uint_4 as a uint_4.
            /// </summary>
            __declspec( property( get=get_wxyz, put=set_wxyz) ) uint_4 argb;

            /// <summary>
            ///     Returns a uint_4 that is composed of element 3, element 0, element 1, and element 2 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_4.
            /// </returns>
            uint_4 get_wxyz() const __GPU {
                return uint_4(_M_w,_M_x,_M_y,_M_z);
            }

            /// <summary>
            ///     Set element 3, 0, 1, and 2 of this uint_4 with a uint_4.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_4 value.
            /// </param>
            void set_wxyz(const uint_4& _Value) __GPU
            {
                uint_4 _Val = _Value;
                _M_w = _Val.x;
                _M_x = _Val.y;
                _M_y = _Val.z;
                _M_z = _Val.w;
            }

            /// <summary>
            ///     Property for accessing element 3, 0, 2, and 1 of this uint_4 as a uint_4.
            /// </summary>
            __declspec( property( get=get_wxzy, put=set_wxzy) ) uint_4 wxzy;
            /// <summary>
            ///     Property for accessing element 3, 0, 2, and 1 of this uint_4 as a uint_4.
            /// </summary>
            __declspec( property( get=get_wxzy, put=set_wxzy) ) uint_4 arbg;

            /// <summary>
            ///     Returns a uint_4 that is composed of element 3, element 0, element 2, and element 1 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_4.
            /// </returns>
            uint_4 get_wxzy() const __GPU {
                return uint_4(_M_w,_M_x,_M_z,_M_y);
            }

            /// <summary>
            ///     Set element 3, 0, 2, and 1 of this uint_4 with a uint_4.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_4 value.
            /// </param>
            void set_wxzy(const uint_4& _Value) __GPU
            {
                uint_4 _Val = _Value;
                _M_w = _Val.x;
                _M_x = _Val.y;
                _M_z = _Val.z;
                _M_y = _Val.w;
            }

            /// <summary>
            ///     Property for accessing element 3, 1, 0, and 2 of this uint_4 as a uint_4.
            /// </summary>
            __declspec( property( get=get_wyxz, put=set_wyxz) ) uint_4 wyxz;
            /// <summary>
            ///     Property for accessing element 3, 1, 0, and 2 of this uint_4 as a uint_4.
            /// </summary>
            __declspec( property( get=get_wyxz, put=set_wyxz) ) uint_4 agrb;

            /// <summary>
            ///     Returns a uint_4 that is composed of element 3, element 1, element 0, and element 2 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_4.
            /// </returns>
            uint_4 get_wyxz() const __GPU {
                return uint_4(_M_w,_M_y,_M_x,_M_z);
            }

            /// <summary>
            ///     Set element 3, 1, 0, and 2 of this uint_4 with a uint_4.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_4 value.
            /// </param>
            void set_wyxz(const uint_4& _Value) __GPU
            {
                uint_4 _Val = _Value;
                _M_w = _Val.x;
                _M_y = _Val.y;
                _M_x = _Val.z;
                _M_z = _Val.w;
            }

            /// <summary>
            ///     Property for accessing element 3, 1, 2, and 0 of this uint_4 as a uint_4.
            /// </summary>
            __declspec( property( get=get_wyzx, put=set_wyzx) ) uint_4 wyzx;
            /// <summary>
            ///     Property for accessing element 3, 1, 2, and 0 of this uint_4 as a uint_4.
            /// </summary>
            __declspec( property( get=get_wyzx, put=set_wyzx) ) uint_4 agbr;

            /// <summary>
            ///     Returns a uint_4 that is composed of element 3, element 1, element 2, and element 0 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_4.
            /// </returns>
            uint_4 get_wyzx() const __GPU {
                return uint_4(_M_w,_M_y,_M_z,_M_x);
            }

            /// <summary>
            ///     Set element 3, 1, 2, and 0 of this uint_4 with a uint_4.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_4 value.
            /// </param>
            void set_wyzx(const uint_4& _Value) __GPU
            {
                uint_4 _Val = _Value;
                _M_w = _Val.x;
                _M_y = _Val.y;
                _M_z = _Val.z;
                _M_x = _Val.w;
            }

            /// <summary>
            ///     Property for accessing element 3, 2, 0, and 1 of this uint_4 as a uint_4.
            /// </summary>
            __declspec( property( get=get_wzxy, put=set_wzxy) ) uint_4 wzxy;
            /// <summary>
            ///     Property for accessing element 3, 2, 0, and 1 of this uint_4 as a uint_4.
            /// </summary>
            __declspec( property( get=get_wzxy, put=set_wzxy) ) uint_4 abrg;

            /// <summary>
            ///     Returns a uint_4 that is composed of element 3, element 2, element 0, and element 1 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_4.
            /// </returns>
            uint_4 get_wzxy() const __GPU {
                return uint_4(_M_w,_M_z,_M_x,_M_y);
            }

            /// <summary>
            ///     Set element 3, 2, 0, and 1 of this uint_4 with a uint_4.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_4 value.
            /// </param>
            void set_wzxy(const uint_4& _Value) __GPU
            {
                uint_4 _Val = _Value;
                _M_w = _Val.x;
                _M_z = _Val.y;
                _M_x = _Val.z;
                _M_y = _Val.w;
            }

            /// <summary>
            ///     Property for accessing element 3, 2, 1, and 0 of this uint_4 as a uint_4.
            /// </summary>
            __declspec( property( get=get_wzyx, put=set_wzyx) ) uint_4 wzyx;
            /// <summary>
            ///     Property for accessing element 3, 2, 1, and 0 of this uint_4 as a uint_4.
            /// </summary>
            __declspec( property( get=get_wzyx, put=set_wzyx) ) uint_4 abgr;

            /// <summary>
            ///     Returns a uint_4 that is composed of element 3, element 2, element 1, and element 0 of this uint_4.
            /// </summary>
            /// <returns>
            ///     a uint_4.
            /// </returns>
            uint_4 get_wzyx() const __GPU {
                return uint_4(_M_w,_M_z,_M_y,_M_x);
            }

            /// <summary>
            ///     Set element 3, 2, 1, and 0 of this uint_4 with a uint_4.
            /// </summary>
            /// <param name="_Value">
            ///     a uint_4 value.
            /// </param>
            void set_wzyx(const uint_4& _Value) __GPU
            {
                uint_4 _Val = _Value;
                _M_w = _Val.x;
                _M_z = _Val.y;
                _M_y = _Val.z;
                _M_x = _Val.w;
            }

        };

        /// <summary>
        ///    Represent a short vector of 2 int's.
        /// </summary>
        class int_2
        {
        public:
            typedef int value_type;
            static const int size = 2;
        private:
            static const _Short_vector_base_type_id _Base_type_id = _Int_type;
        private:
            value_type _M_x;
            value_type _M_y;

        public:
            /// <summary>
            ///     Property for accessing element 0 of this int_2 as an int.
            /// </summary>
            __declspec( property( get=get_x, put=set_x) ) int x;
            /// <summary>
            ///     Property for accessing element 0 of this int_2 as an int.
            /// </summary>
            __declspec( property( get=get_x, put=set_x) ) int r;

            /// <summary>
            ///     Returns element 0 of this int_2.
            /// </summary>
            /// <returns>
            ///     Element 0 of this int_2.
            /// </returns>
            int get_x() const __GPU {
                return _M_x;
            }

            /// <summary>
            ///     Returns reference to element 0 of this int_2.
            /// </summary>
            /// <returns>
            ///     Reference to element 0 of this int_2.
            /// </returns>
            int& ref_x() __GPU {
                return _M_x;
            }

            /// <summary>
            ///     Returns reference to element 0 of this int_2.
            /// </summary>
            /// <returns>
            ///     Reference to element 0 of this int_2.
            /// </returns>
            int& ref_r() __GPU {
                return _M_x;
            }

            /// <summary>
            ///     Set element 0 of this int_2 with an int.
            /// </summary>
            /// <param name="_Value">
            ///     an int value.
            /// </param>
            void set_x(int _Value) __GPU
            {
                _M_x = _Value;
            }

            /// <summary>
            ///     Property for accessing element 1 of this int_2 as an int.
            /// </summary>
            __declspec( property( get=get_y, put=set_y) ) int y;
            /// <summary>
            ///     Property for accessing element 1 of this int_2 as an int.
            /// </summary>
            __declspec( property( get=get_y, put=set_y) ) int g;

            /// <summary>
            ///     Returns element 1 of this int_2.
            /// </summary>
            /// <returns>
            ///     Element 1 of this int_2.
            /// </returns>
            int get_y() const __GPU {
                return _M_y;
            }

            /// <summary>
            ///     Returns reference to element 1 of this int_2.
            /// </summary>
            /// <returns>
            ///     Reference to element 1 of this int_2.
            /// </returns>
            int& ref_y() __GPU {
                return _M_y;
            }

            /// <summary>
            ///     Returns reference to element 1 of this int_2.
            /// </summary>
            /// <returns>
            ///     Reference to element 1 of this int_2.
            /// </returns>
            int& ref_g() __GPU {
                return _M_y;
            }

            /// <summary>
            ///     Set element 1 of this int_2 with an int.
            /// </summary>
            /// <param name="_Value">
            ///     an int value.
            /// </param>
            void set_y(int _Value) __GPU
            {
                _M_y = _Value;
            }

        public:
            /// <summary>
            ///     Default constructor, initializes all elements with 0.
            /// </summary>
            int_2() __GPU
            {
                _M_x = 0;
                _M_y = 0;
            }

            /// <summary>
            ///     Constructor.
            /// </summary>
            /// <param name="_V0">
            ///     The value to initialize element 0.
            /// </param>
            /// <param name="_V1">
            ///     The value to initialize element 1.
            /// </param>
            int_2(int _V0, int _V1) __GPU
            {
                _M_x = _V0;
                _M_y = _V1;
            }

            /// <summary>
            ///     Constructor.
            /// </summary>
            /// <param name="_V">
            ///     The value for initialization.
            /// </param>
            int_2(int _V) __GPU
            {
                _M_x = _V;
                _M_y = _V;
            }

            /// <summary>
            ///     Constructor.
            ///     Each element is initialized by casting from the corresponding element in _Other.
            /// </summary>
            /// <param name="_Other">
            ///     The object used to initialize.
            /// </param>
            explicit inline int_2(const uint_2& _Other) __GPU;

            /// <summary>
            ///     Constructor.
            ///     Each element is initialized by casting from the corresponding element in _Other.
            /// </summary>
            /// <param name="_Other">
            ///     The object used to initialize.
            /// </param>
            explicit inline int_2(const float_2& _Other) __GPU;

            /// <summary>
            ///     Constructor.
            ///     Each element is initialized by casting from the corresponding element in _Other.
            /// </summary>
            /// <param name="_Other">
            ///     The object used to initialize.
            /// </param>
            explicit inline int_2(const unorm_2& _Other) __GPU;

            /// <summary>
            ///     Constructor.
            ///     Each element is initialized by casting from the corresponding element in _Other.
            /// </summary>
            /// <param name="_Other">
            ///     The object used to initialize.
            /// </param>
            explicit inline int_2(const norm_2& _Other) __GPU;

            /// <summary>
            ///     Constructor.
            ///     Each element is initialized by casting from the corresponding element in _Other.
            /// </summary>
            /// <param name="_Other">
            ///     The object used to initialize.
            /// </param>
            explicit inline int_2(const double_2& _Other) __GPU;

            int_2 operator~() const __GPU
            {
                int_2 _Value = *this;
                return int_2(~_Value.x, ~_Value.y);
            }

            int_2 operator-() const __GPU
            {
                int_2 _Value = *this;
                return int_2(-_Value.x, -_Value.y);
            }

            int_2& operator++() __GPU
            {
                int_2 _Value = *this;
                ++_Value._M_x;
                ++_Value._M_y;
                *this = _Value;
                return *this;
            }

            int_2 operator++(int) __GPU
            {
                int_2 _Result = *this;
                ++(*this);
                return _Result;
            }

            int_2& operator--() __GPU
            {
                int_2 _Value = *this;
                --_Value._M_x;
                --_Value._M_y;
                *this = _Value;
                return *this;
            }

            int_2 operator--(int) __GPU
            {
                int_2 _Result = *this;
                --(*this);
                return _Result;
            }

            int_2& operator+=(const int_2& _Other) __GPU
            {
                int_2 _Value1 = *this;
                int_2 _Value2 = _Other;
                _Value1.x += _Value2.x;
                _Value1.y += _Value2.y;
                *this = _Value1;
                return *this;
            }

            int_2& operator-=(const int_2& _Other) __GPU
            {
                int_2 _Value1 = *this;
                int_2 _Value2 = _Other;
                _Value1.x -= _Value2.x;
                _Value1.y -= _Value2.y;
                *this = _Value1;
                return *this;
            }

            int_2& operator*=(const int_2& _Other) __GPU
            {
                int_2 _Value1 = *this;
                int_2 _Value2 = _Other;
                _Value1.x *= _Value2.x;
                _Value1.y *= _Value2.y;
                *this = _Value1;
                return *this;
            }

            int_2& operator/=(const int_2& _Other) __GPU
            {
                int_2 _Value1 = *this;
                int_2 _Value2 = _Other;
                _Value1.x /= _Value2.x;
                _Value1.y /= _Value2.y;
                *this = _Value1;
                return *this;
            }

            int_2& operator%=(const int_2& _Other) __GPU
            {
                int_2 _Value1 = *this;
                int_2 _Value2 = _Other;
                _Value1.x %= _Value2.x;
                _Value1.y %= _Value2.y;
                *this = _Value1;
                return *this;
            }

            int_2& operator^=(const int_2& _Other) __GPU
            {
                int_2 _Value1 = *this;
                int_2 _Value2 = _Other;
                _Value1.x ^= _Value2.x;
                _Value1.y ^= _Value2.y;
                *this = _Value1;
                return *this;
            }

            int_2& operator|=(const int_2& _Other) __GPU
            {
                int_2 _Value1 = *this;
                int_2 _Value2 = _Other;
                _Value1.x |= _Value2.x;
                _Value1.y |= _Value2.y;
                *this = _Value1;
                return *this;
            }

            int_2& operator&=(const int_2& _Other) __GPU
            {
                int_2 _Value1 = *this;
                int_2 _Value2 = _Other;
                _Value1.x &= _Value2.x;
                _Value1.y &= _Value2.y;
                *this = _Value1;
                return *this;
            }

            int_2& operator>>=(const int_2& _Other) __GPU
            {
                int_2 _Value1 = *this;
                int_2 _Value2 = _Other;
                _Value1.x >>= _Value2.x;
                _Value1.y >>= _Value2.y;
                *this = _Value1;
                return *this;
            }

            int_2& operator<<=(const int_2& _Other) __GPU
            {
                int_2 _Value1 = *this;
                int_2 _Value2 = _Other;
                _Value1.x <<= _Value2.x;
                _Value1.y <<= _Value2.y;
                *this = _Value1;
                return *this;
            }

        public:
            /// <summary>
            ///     Property for accessing element 0, and 1 of this int_2 as an int_2.
            /// </summary>
            __declspec( property( get=get_xy, put=set_xy) ) int_2 xy;
            /// <summary>
            ///     Property for accessing element 0, and 1 of this int_2 as an int_2.
            /// </summary>
            __declspec( property( get=get_xy, put=set_xy) ) int_2 rg;

            /// <summary>
            ///     Returns an int_2 that is composed of element 0, and element 1 of this int_2.
            /// </summary>
            /// <returns>
            ///     an int_2.
            /// </returns>
            int_2 get_xy() const __GPU {
                return int_2(_M_x,_M_y);
            }

            /// <summary>
            ///     Set element 0, and 1 of this int_2 with an int_2.
            /// </summary>
            /// <param name="_Value">
            ///     an int_2 value.
            /// </param>
            void set_xy(const int_2& _Value) __GPU
            {
                int_2 _Val = _Value;
                _M_x = _Val.x;
                _M_y = _Val.y;
            }

            /// <summary>
            ///     Property for accessing element 1, and 0 of this int_2 as an int_2.
            /// </summary>
            __declspec( property( get=get_yx, put=set_yx) ) int_2 yx;
            /// <summary>
            ///     Property for accessing element 1, and 0 of this int_2 as an int_2.
            /// </summary>
            __declspec( property( get=get_yx, put=set_yx) ) int_2 gr;

            /// <summary>
            ///     Returns an int_2 that is composed of element 1, and element 0 of this int_2.
            /// </summary>
            /// <returns>
            ///     an int_2.
            /// </returns>
            int_2 get_yx() const __GPU {
                return int_2(_M_y,_M_x);
            }

            /// <summary>
            ///     Set element 1, and 0 of this int_2 with an int_2.
            /// </summary>
            /// <param name="_Value">
            ///     an int_2 value.
            /// </param>
            void set_yx(const int_2& _Value) __GPU
            {
                int_2 _Val = _Value;
                _M_y = _Val.x;
                _M_x = _Val.y;
            }

        };

        /// <summary>
        ///    Represent a short vector of 3 int's.
        /// </summary>
        class int_3
        {
        public:
            typedef int value_type;
            static const int size = 3;
        private:
            static const _Short_vector_base_type_id _Base_type_id = _Int_type;
        private:
            value_type _M_x;
            value_type _M_y;
            value_type _M_z;

        public:
            /// <summary>
            ///     Property for accessing element 0 of this int_3 as an int.
            /// </summary>
            __declspec( property( get=get_x, put=set_x) ) int x;
            /// <summary>
            ///     Property for accessing element 0 of this int_3 as an int.
            /// </summary>
            __declspec( property( get=get_x, put=set_x) ) int r;

            /// <summary>
            ///     Returns element 0 of this int_3.
            /// </summary>
            /// <returns>
            ///     Element 0 of this int_3.
            /// </returns>
            int get_x() const __GPU {
                return _M_x;
            }

            /// <summary>
            ///     Returns reference to element 0 of this int_3.
            /// </summary>
            /// <returns>
            ///     Reference to element 0 of this int_3.
            /// </returns>
            int& ref_x() __GPU {
                return _M_x;
            }

            /// <summary>
            ///     Returns reference to element 0 of this int_3.
            /// </summary>
            /// <returns>
            ///     Reference to element 0 of this int_3.
            /// </returns>
            int& ref_r() __GPU {
                return _M_x;
            }

            /// <summary>
            ///     Set element 0 of this int_3 with an int.
            /// </summary>
            /// <param name="_Value">
            ///     an int value.
            /// </param>
            void set_x(int _Value) __GPU
            {
                _M_x = _Value;
            }

            /// <summary>
            ///     Property for accessing element 1 of this int_3 as an int.
            /// </summary>
            __declspec( property( get=get_y, put=set_y) ) int y;
            /// <summary>
            ///     Property for accessing element 1 of this int_3 as an int.
            /// </summary>
            __declspec( property( get=get_y, put=set_y) ) int g;

            /// <summary>
            ///     Returns element 1 of this int_3.
            /// </summary>
            /// <returns>
            ///     Element 1 of this int_3.
            /// </returns>
            int get_y() const __GPU {
                return _M_y;
            }

            /// <summary>
            ///     Returns reference to element 1 of this int_3.
            /// </summary>
            /// <returns>
            ///     Reference to element 1 of this int_3.
            /// </returns>
            int& ref_y() __GPU {
                return _M_y;
            }

            /// <summary>
            ///     Returns reference to element 1 of this int_3.
            /// </summary>
            /// <returns>
            ///     Reference to element 1 of this int_3.
            /// </returns>
            int& ref_g() __GPU {
                return _M_y;
            }

            /// <summary>
            ///     Set element 1 of this int_3 with an int.
            /// </summary>
            /// <param name="_Value">
            ///     an int value.
            /// </param>
            void set_y(int _Value) __GPU
            {
                _M_y = _Value;
            }

            /// <summary>
            ///     Property for accessing element 2 of this int_3 as an int.
            /// </summary>
            __declspec( property( get=get_z, put=set_z) ) int z;
            /// <summary>
            ///     Property for accessing element 2 of this int_3 as an int.
            /// </summary>
            __declspec( property( get=get_z, put=set_z) ) int b;

            /// <summary>
            ///     Returns element 2 of this int_3.
            /// </summary>
            /// <returns>
            ///     Element 2 of this int_3.
            /// </returns>
            int get_z() const __GPU {
                return _M_z;
            }

            /// <summary>
            ///     Returns reference to element 2 of this int_3.
            /// </summary>
            /// <returns>
            ///     Reference to element 2 of this int_3.
            /// </returns>
            int& ref_z() __GPU {
                return _M_z;
            }

            /// <summary>
            ///     Returns reference to element 2 of this int_3.
            /// </summary>
            /// <returns>
            ///     Reference to element 2 of this int_3.
            /// </returns>
            int& ref_b() __GPU {
                return _M_z;
            }

            /// <summary>
            ///     Set element 2 of this int_3 with an int.
            /// </summary>
            /// <param name="_Value">
            ///     an int value.
            /// </param>
            void set_z(int _Value) __GPU
            {
                _M_z = _Value;
            }

        public:
            /// <summary>
            ///     Default constructor, initializes all elements with 0.
            /// </summary>
            int_3() __GPU
            {
                _M_x = 0;
                _M_y = 0;
                _M_z = 0;
            }

            /// <summary>
            ///     Constructor.
            /// </summary>
            /// <param name="_V0">
            ///     The value to initialize element 0.
            /// </param>
            /// <param name="_V1">
            ///     The value to initialize element 1.
            /// </param>
            /// <param name="_V2">
            ///     The value to initialize element 2.
            /// </param>
            int_3(int _V0, int _V1, int _V2) __GPU
            {
                _M_x = _V0;
                _M_y = _V1;
                _M_z = _V2;
            }

            /// <summary>
            ///     Constructor.
            /// </summary>
            /// <param name="_V">
            ///     The value for initialization.
            /// </param>
            int_3(int _V) __GPU
            {
                _M_x = _V;
                _M_y = _V;
                _M_z = _V;
            }

            /// <summary>
            ///     Constructor.
            ///     Each element is initialized by casting from the corresponding element in _Other.
            /// </summary>
            /// <param name="_Other">
            ///     The object used to initialize.
            /// </param>
            explicit inline int_3(const uint_3& _Other) __GPU;

            /// <summary>
            ///     Constructor.
            ///     Each element is initialized by casting from the corresponding element in _Other.
            /// </summary>
            /// <param name="_Other">
            ///     The object used to initialize.
            /// </param>
            explicit inline int_3(const float_3& _Other) __GPU;

            /// <summary>
            ///     Constructor.
            ///     Each element is initialized by casting from the corresponding element in _Other.
            /// </summary>
            /// <param name="_Other">
            ///     The object used to initialize.
            /// </param>
            explicit inline int_3(const unorm_3& _Other) __GPU;

            /// <summary>
            ///     Constructor.
            ///     Each element is initialized by casting from the corresponding element in _Other.
            /// </summary>
            /// <param name="_Other">
            ///     The object used to initialize.
            /// </param>
            explicit inline int_3(const norm_3& _Other) __GPU;

            /// <summary>
            ///     Constructor.
            ///     Each element is initialized by casting from the corresponding element in _Other.
            /// </summary>
            /// <param name="_Other">
            ///     The object used to initialize.
            /// </param>
            explicit inline int_3(const double_3& _Other) __GPU;

            int_3 operator~() const __GPU
            {
                int_3 _Value = *this;
                return int_3(~_Value.x, ~_Value.y, ~_Value.z);
            }

            int_3 operator-() const __GPU
            {
                int_3 _Value = *this;
                return int_3(-_Value.x, -_Value.y, -_Value.z);
            }

            int_3& operator++() __GPU
            {
                int_3 _Value = *this;
                ++_Value._M_x;
                ++_Value._M_y;
                ++_Value._M_z;
                *this = _Value;
                return *this;
            }

            int_3 operator++(int) __GPU
            {
                int_3 _Result = *this;
                ++(*this);
                return _Result;
            }

            int_3& operator--() __GPU
            {
                int_3 _Value = *this;
                --_Value._M_x;
                --_Value._M_y;
                --_Value._M_z;
                *this = _Value;
                return *this;
            }

            int_3 operator--(int) __GPU
            {
                int_3 _Result = *this;
                --(*this);
                return _Result;
            }

            int_3& operator+=(const int_3& _Other) __GPU
            {
                int_3 _Value1 = *this;
                int_3 _Value2 = _Other;
                _Value1.x += _Value2.x;
                _Value1.y += _Value2.y;
                _Value1.z += _Value2.z;
                *this = _Value1;
                return *this;
            }

            int_3& operator-=(const int_3& _Other) __GPU
            {
                int_3 _Value1 = *this;
                int_3 _Value2 = _Other;
                _Value1.x -= _Value2.x;
                _Value1.y -= _Value2.y;
                _Value1.z -= _Value2.z;
                *this = _Value1;
                return *this;
            }

            int_3& operator*=(const int_3& _Other) __GPU
            {
                int_3 _Value1 = *this;
                int_3 _Value2 = _Other;
                _Value1.x *= _Value2.x;
                _Value1.y *= _Value2.y;
                _Value1.z *= _Value2.z;
                *this = _Value1;
                return *this;
            }

            int_3& operator/=(const int_3& _Other) __GPU
            {
                int_3 _Value1 = *this;
                int_3 _Value2 = _Other;
                _Value1.x /= _Value2.x;
                _Value1.y /= _Value2.y;
                _Value1.z /= _Value2.z;
                *this = _Value1;
                return *this;
            }

            int_3& operator%=(const int_3& _Other) __GPU
            {
                int_3 _Value1 = *this;
                int_3 _Value2 = _Other;
                _Value1.x %= _Value2.x;
                _Value1.y %= _Value2.y;
                _Value1.z %= _Value2.z;
                *this = _Value1;
                return *this;
            }

            int_3& operator^=(const int_3& _Other) __GPU
            {
                int_3 _Value1 = *this;
                int_3 _Value2 = _Other;
                _Value1.x ^= _Value2.x;
                _Value1.y ^= _Value2.y;
                _Value1.z ^= _Value2.z;
                *this = _Value1;
                return *this;
            }

            int_3& operator|=(const int_3& _Other) __GPU
            {
                int_3 _Value1 = *this;
                int_3 _Value2 = _Other;
                _Value1.x |= _Value2.x;
                _Value1.y |= _Value2.y;
                _Value1.z |= _Value2.z;
                *this = _Value1;
                return *this;
            }

            int_3& operator&=(const int_3& _Other) __GPU
            {
                int_3 _Value1 = *this;
                int_3 _Value2 = _Other;
                _Value1.x &= _Value2.x;
                _Value1.y &= _Value2.y;
                _Value1.z &= _Value2.z;
                *this = _Value1;
                return *this;
            }

            int_3& operator>>=(const int_3& _Other) __GPU
            {
                int_3 _Value1 = *this;
                int_3 _Value2 = _Other;
                _Value1.x >>= _Value2.x;
                _Value1.y >>= _Value2.y;
                _Value1.z >>= _Value2.z;
                *this = _Value1;
                return *this;
            }

            int_3& operator<<=(const int_3& _Other) __GPU
            {
                int_3 _Value1 = *this;
                int_3 _Value2 = _Other;
                _Value1.x <<= _Value2.x;
                _Value1.y <<= _Value2.y;
                _Value1.z <<= _Value2.z;
                *this = _Value1;
                return *this;
            }

        public:
            /// <summary>
            ///     Property for accessing element 0, and 1 of this int_3 as an int_2.
            /// </summary>
            __declspec( property( get=get_xy, put=set_xy) ) int_2 xy;
            /// <summary>
            ///     Property for accessing element 0, and 1 of this int_3 as an int_2.
            /// </summary>
            __declspec( property( get=get_xy, put=set_xy) ) int_2 rg;

            /// <summary>
            ///     Returns an int_2 that is composed of element 0, and element 1 of this int_3.
            /// </summary>
            /// <returns>
            ///     an int_2.
            /// </returns>
            int_2 get_xy() const __GPU {
                return int_2(_M_x,_M_y);
            }

            /// <summary>
            ///     Set element 0, and 1 of this int_3 with an int_2.
            /// </summary>
            /// <param name="_Value">
            ///     an int_2 value.
            /// </param>
            void set_xy(const int_2& _Value) __GPU
            {
                int_2 _Val = _Value;
                _M_x = _Val.x;
                _M_y = _Val.y;
            }

            /// <summary>
            ///     Property for accessing element 0, and 2 of this int_3 as an int_2.
            /// </summary>
            __declspec( property( get=get_xz, put=set_xz) ) int_2 xz;
            /// <summary>
            ///     Property for accessing element 0, and 2 of this int_3 as an int_2.
            /// </summary>
            __declspec( property( get=get_xz, put=set_xz) ) int_2 rb;

            /// <summary>
            ///     Returns an int_2 that is composed of element 0, and element 2 of this int_3.
            /// </summary>
            /// <returns>
            ///     an int_2.
            /// </returns>
            int_2 get_xz() const __GPU {
                return int_2(_M_x,_M_z);
            }

            /// <summary>
            ///     Set element 0, and 2 of this int_3 with an int_2.
            /// </summary>
            /// <param name="_Value">
            ///     an int_2 value.
            /// </param>
            void set_xz(const int_2& _Value) __GPU
            {
                int_2 _Val = _Value;
                _M_x = _Val.x;
                _M_z = _Val.y;
            }

            /// <summary>
            ///     Property for accessing element 1, and 0 of this int_3 as an int_2.
            /// </summary>
            __declspec( property( get=get_yx, put=set_yx) ) int_2 yx;
            /// <summary>
            ///     Property for accessing element 1, and 0 of this int_3 as an int_2.
            /// </summary>
            __declspec( property( get=get_yx, put=set_yx) ) int_2 gr;

            /// <summary>
            ///     Returns an int_2 that is composed of element 1, and element 0 of this int_3.
            /// </summary>
            /// <returns>
            ///     an int_2.
            /// </returns>
            int_2 get_yx() const __GPU {
                return int_2(_M_y,_M_x);
            }

            /// <summary>
            ///     Set element 1, and 0 of this int_3 with an int_2.
            /// </summary>
            /// <param name="_Value">
            ///     an int_2 value.
            /// </param>
            void set_yx(const int_2& _Value) __GPU
            {
                int_2 _Val = _Value;
                _M_y = _Val.x;
                _M_x = _Val.y;
            }

            /// <summary>
            ///     Property for accessing element 1, and 2 of this int_3 as an int_2.
            /// </summary>
            __declspec( property( get=get_yz, put=set_yz) ) int_2 yz;
            /// <summary>
            ///     Property for accessing element 1, and 2 of this int_3 as an int_2.
            /// </summary>
            __declspec( property( get=get_yz, put=set_yz) ) int_2 gb;

            /// <summary>
            ///     Returns an int_2 that is composed of element 1, and element 2 of this int_3.
            /// </summary>
            /// <returns>
            ///     an int_2.
            /// </returns>
            int_2 get_yz() const __GPU {
                return int_2(_M_y,_M_z);
            }

            /// <summary>
            ///     Set element 1, and 2 of this int_3 with an int_2.
            /// </summary>
            /// <param name="_Value">
            ///     an int_2 value.
            /// </param>
            void set_yz(const int_2& _Value) __GPU
            {
                int_2 _Val = _Value;
                _M_y = _Val.x;
                _M_z = _Val.y;
            }

            /// <summary>
            ///     Property for accessing element 2, and 0 of this int_3 as an int_2.
            /// </summary>
            __declspec( property( get=get_zx, put=set_zx) ) int_2 zx;
            /// <summary>
            ///     Property for accessing element 2, and 0 of this int_3 as an int_2.
            /// </summary>
            __declspec( property( get=get_zx, put=set_zx) ) int_2 br;

            /// <summary>
            ///     Returns an int_2 that is composed of element 2, and element 0 of this int_3.
            /// </summary>
            /// <returns>
            ///     an int_2.
            /// </returns>
            int_2 get_zx() const __GPU {
                return int_2(_M_z,_M_x);
            }

            /// <summary>
            ///     Set element 2, and 0 of this int_3 with an int_2.
            /// </summary>
            /// <param name="_Value">
            ///     an int_2 value.
            /// </param>
            void set_zx(const int_2& _Value) __GPU
            {
                int_2 _Val = _Value;
                _M_z = _Val.x;
                _M_x = _Val.y;
            }

            /// <summary>
            ///     Property for accessing element 2, and 1 of this int_3 as an int_2.
            /// </summary>
            __declspec( property( get=get_zy, put=set_zy) ) int_2 zy;
            /// <summary>
            ///     Property for accessing element 2, and 1 of this int_3 as an int_2.
            /// </summary>
            __declspec( property( get=get_zy, put=set_zy) ) int_2 bg;

            /// <summary>
            ///     Returns an int_2 that is composed of element 2, and element 1 of this int_3.
            /// </summary>
            /// <returns>
            ///     an int_2.
            /// </returns>
            int_2 get_zy() const __GPU {
                return int_2(_M_z,_M_y);
            }

            /// <summary>
            ///     Set element 2, and 1 of this int_3 with an int_2.
            /// </summary>
            /// <param name="_Value">
            ///     an int_2 value.
            /// </param>
            void set_zy(const int_2& _Value) __GPU
            {
                int_2 _Val = _Value;
                _M_z = _Val.x;
                _M_y = _Val.y;
            }

            /// <summary>
            ///     Property for accessing element 0, 1, and 2 of this int_3 as an int_3.
            /// </summary>
            __declspec( property( get=get_xyz, put=set_xyz) ) int_3 xyz;
            /// <summary>
            ///     Property for accessing element 0, 1, and 2 of this int_3 as an int_3.
            /// </summary>
            __declspec( property( get=get_xyz, put=set_xyz) ) int_3 rgb;

            /// <summary>
            ///     Returns an int_3 that is composed of element 0, element 1, and element 2 of this int_3.
            /// </summary>
            /// <returns>
            ///     an int_3.
            /// </returns>
            int_3 get_xyz() const __GPU {
                return int_3(_M_x,_M_y,_M_z);
            }

            /// <summary>
            ///     Set element 0, 1, and 2 of this int_3 with an int_3.
            /// </summary>
            /// <param name="_Value">
            ///     an int_3 value.
            /// </param>
            void set_xyz(const int_3& _Value) __GPU
            {
                int_3 _Val = _Value;
                _M_x = _Val.x;
                _M_y = _Val.y;
                _M_z = _Val.z;
            }

            /// <summary>
            ///     Property for accessing element 0, 2, and 1 of this int_3 as an int_3.
            /// </summary>
            __declspec( property( get=get_xzy, put=set_xzy) ) int_3 xzy;
            /// <summary>
            ///     Property for accessing element 0, 2, and 1 of this int_3 as an int_3.
            /// </summary>
            __declspec( property( get=get_xzy, put=set_xzy) ) int_3 rbg;

            /// <summary>
            ///     Returns an int_3 that is composed of element 0, element 2, and element 1 of this int_3.
            /// </summary>
            /// <returns>
            ///     an int_3.
            /// </returns>
            int_3 get_xzy() const __GPU {
                return int_3(_M_x,_M_z,_M_y);
            }

            /// <summary>
            ///     Set element 0, 2, and 1 of this int_3 with an int_3.
            /// </summary>
            /// <param name="_Value">
            ///     an int_3 value.
            /// </param>
            void set_xzy(const int_3& _Value) __GPU
            {
                int_3 _Val = _Value;
                _M_x = _Val.x;
                _M_z = _Val.y;
                _M_y = _Val.z;
            }

            /// <summary>
            ///     Property for accessing element 1, 0, and 2 of this int_3 as an int_3.
            /// </summary>
            __declspec( property( get=get_yxz, put=set_yxz) ) int_3 yxz;
            /// <summary>
            ///     Property for accessing element 1, 0, and 2 of this int_3 as an int_3.
            /// </summary>
            __declspec( property( get=get_yxz, put=set_yxz) ) int_3 grb;

            /// <summary>
            ///     Returns an int_3 that is composed of element 1, element 0, and element 2 of this int_3.
            /// </summary>
            /// <returns>
            ///     an int_3.
            /// </returns>
            int_3 get_yxz() const __GPU {
                return int_3(_M_y,_M_x,_M_z);
            }

            /// <summary>
            ///     Set element 1, 0, and 2 of this int_3 with an int_3.
            /// </summary>
            /// <param name="_Value">
            ///     an int_3 value.
            /// </param>
            void set_yxz(const int_3& _Value) __GPU
            {
                int_3 _Val = _Value;
                _M_y = _Val.x;
                _M_x = _Val.y;
                _M_z = _Val.z;
            }

            /// <summary>
            ///     Property for accessing element 1, 2, and 0 of this int_3 as an int_3.
            /// </summary>
            __declspec( property( get=get_yzx, put=set_yzx) ) int_3 yzx;
            /// <summary>
            ///     Property for accessing element 1, 2, and 0 of this int_3 as an int_3.
            /// </summary>
            __declspec( property( get=get_yzx, put=set_yzx) ) int_3 gbr;

            /// <summary>
            ///     Returns an int_3 that is composed of element 1, element 2, and element 0 of this int_3.
            /// </summary>
            /// <returns>
            ///     an int_3.
            /// </returns>
            int_3 get_yzx() const __GPU {
                return int_3(_M_y,_M_z,_M_x);
            }

            /// <summary>
            ///     Set element 1, 2, and 0 of this int_3 with an int_3.
            /// </summary>
            /// <param name="_Value">
            ///     an int_3 value.
            /// </param>
            void set_yzx(const int_3& _Value) __GPU
            {
                int_3 _Val = _Value;
                _M_y = _Val.x;
                _M_z = _Val.y;
                _M_x = _Val.z;
            }

            /// <summary>
            ///     Property for accessing element 2, 0, and 1 of this int_3 as an int_3.
            /// </summary>
            __declspec( property( get=get_zxy, put=set_zxy) ) int_3 zxy;
            /// <summary>
            ///     Property for accessing element 2, 0, and 1 of this int_3 as an int_3.
            /// </summary>
            __declspec( property( get=get_zxy, put=set_zxy) ) int_3 brg;

            /// <summary>
            ///     Returns an int_3 that is composed of element 2, element 0, and element 1 of this int_3.
            /// </summary>
            /// <returns>
            ///     an int_3.
            /// </returns>
            int_3 get_zxy() const __GPU {
                return int_3(_M_z,_M_x,_M_y);
            }

            /// <summary>
            ///     Set element 2, 0, and 1 of this int_3 with an int_3.
            /// </summary>
            /// <param name="_Value">
            ///     an int_3 value.
            /// </param>
            void set_zxy(const int_3& _Value) __GPU
            {
                int_3 _Val = _Value;
                _M_z = _Val.x;
                _M_x = _Val.y;
                _M_y = _Val.z;
            }

            /// <summary>
            ///     Property for accessing element 2, 1, and 0 of this int_3 as an int_3.
            /// </summary>
            __declspec( property( get=get_zyx, put=set_zyx) ) int_3 zyx;
            /// <summary>
            ///     Property for accessing element 2, 1, and 0 of this int_3 as an int_3.
            /// </summary>
            __declspec( property( get=get_zyx, put=set_zyx) ) int_3 bgr;

            /// <summary>
            ///     Returns an int_3 that is composed of element 2, element 1, and element 0 of this int_3.
            /// </summary>
            /// <returns>
            ///     an int_3.
            /// </returns>
            int_3 get_zyx() const __GPU {
                return int_3(_M_z,_M_y,_M_x);
            }

            /// <summary>
            ///     Set element 2, 1, and 0 of this int_3 with an int_3.
            /// </summary>
            /// <param name="_Value">
            ///     an int_3 value.
            /// </param>
            void set_zyx(const int_3& _Value) __GPU
            {
                int_3 _Val = _Value;
                _M_z = _Val.x;
                _M_y = _Val.y;
                _M_x = _Val.z;
            }

        };

        /// <summary>
        ///    Represent a short vector of 4 int's.
        /// </summary>
        class int_4
        {
        public:
            typedef int value_type;
            static const int size = 4;
        private:
            static const _Short_vector_base_type_id _Base_type_id = _Int_type;
        private:
            value_type _M_x;
            value_type _M_y;
            value_type _M_z;
            value_type _M_w;

        public:
            /// <summary>
            ///     Property for accessing element 0 of this int_4 as an int.
            /// </summary>
            __declspec( property( get=get_x, put=set_x) ) int x;
            /// <summary>
            ///     Property for accessing element 0 of this int_4 as an int.
            /// </summary>
            __declspec( property( get=get_x, put=set_x) ) int r;

            /// <summary>
            ///     Returns element 0 of this int_4.
            /// </summary>
            /// <returns>
            ///     Element 0 of this int_4.
            /// </returns>
            int get_x() const __GPU {
                return _M_x;
            }

            /// <summary>
            ///     Returns reference to element 0 of this int_4.
            /// </summary>
            /// <returns>
            ///     Reference to element 0 of this int_4.
            /// </returns>
            int& ref_x() __GPU {
                return _M_x;
            }

            /// <summary>
            ///     Returns reference to element 0 of this int_4.
            /// </summary>
            /// <returns>
            ///     Reference to element 0 of this int_4.
            /// </returns>
            int& ref_r() __GPU {
                return _M_x;
            }

            /// <summary>
            ///     Set element 0 of this int_4 with an int.
            /// </summary>
            /// <param name="_Value">
            ///     an int value.
            /// </param>
            void set_x(int _Value) __GPU
            {
                _M_x = _Value;
            }

            /// <summary>
            ///     Property for accessing element 1 of this int_4 as an int.
            /// </summary>
            __declspec( property( get=get_y, put=set_y) ) int y;
            /// <summary>
            ///     Property for accessing element 1 of this int_4 as an int.
            /// </summary>
            __declspec( property( get=get_y, put=set_y) ) int g;

            /// <summary>
            ///     Returns element 1 of this int_4.
            /// </summary>
            /// <returns>
            ///     Element 1 of this int_4.
            /// </returns>
            int get_y() const __GPU {
                return _M_y;
            }

            /// <summary>
            ///     Returns reference to element 1 of this int_4.
            /// </summary>
            /// <returns>
            ///     Reference to element 1 of this int_4.
            /// </returns>
            int& ref_y() __GPU {
                return _M_y;
            }

            /// <summary>
            ///     Returns reference to element 1 of this int_4.
            /// </summary>
            /// <returns>
            ///     Reference to element 1 of this int_4.
            /// </returns>
            int& ref_g() __GPU {
                return _M_y;
            }

            /// <summary>
            ///     Set element 1 of this int_4 with an int.
            /// </summary>
            /// <param name="_Value">
            ///     an int value.
            /// </param>
            void set_y(int _Value) __GPU
            {
                _M_y = _Value;
            }

            /// <summary>
            ///     Property for accessing element 2 of this int_4 as an int.
            /// </summary>
            __declspec( property( get=get_z, put=set_z) ) int z;
            /// <summary>
            ///     Property for accessing element 2 of this int_4 as an int.
            /// </summary>
            __declspec( property( get=get_z, put=set_z) ) int b;

            /// <summary>
            ///     Returns element 2 of this int_4.
            /// </summary>
            /// <returns>
            ///     Element 2 of this int_4.
            /// </returns>
            int get_z() const __GPU {
                return _M_z;
            }

            /// <summary>
            ///     Returns reference to element 2 of this int_4.
            /// </summary>
            /// <returns>
            ///     Reference to element 2 of this int_4.
            /// </returns>
            int& ref_z() __GPU {
                return _M_z;
            }

            /// <summary>
            ///     Returns reference to element 2 of this int_4.
            /// </summary>
            /// <returns>
            ///     Reference to element 2 of this int_4.
            /// </returns>
            int& ref_b() __GPU {
                return _M_z;
            }

            /// <summary>
            ///     Set element 2 of this int_4 with an int.
            /// </summary>
            /// <param name="_Value">
            ///     an int value.
            /// </param>
            void set_z(int _Value) __GPU
            {
                _M_z = _Value;
            }

            /// <summary>
            ///     Property for accessing element 3 of this int_4 as an int.
            /// </summary>
            __declspec( property( get=get_w, put=set_w) ) int w;
            /// <summary>
            ///     Property for accessing element 3 of this int_4 as an int.
            /// </summary>
            __declspec( property( get=get_w, put=set_w) ) int a;

            /// <summary>
            ///     Returns element 3 of this int_4.
            /// </summary>
            /// <returns>
            ///     Element 3 of this int_4.
            /// </returns>
            int get_w() const __GPU {
                return _M_w;
            }

            /// <summary>
            ///     Returns reference to element 3 of this int_4.
            /// </summary>
            /// <returns>
            ///     Reference to element 3 of this int_4.
            /// </returns>
            int& ref_w() __GPU {
                return _M_w;
            }

            /// <summary>
            ///     Returns reference to element 3 of this int_4.
            /// </summary>
            /// <returns>
            ///     Reference to element 3 of this int_4.
            /// </returns>
            int& ref_a() __GPU {
                return _M_w;
            }

            /// <summary>
            ///     Set element 3 of this int_4 with an int.
            /// </summary>
            /// <param name="_Value">
            ///     an int value.
            /// </param>
            void set_w(int _Value) __GPU
            {
                _M_w = _Value;
            }

        public:
            /// <summary>
            ///     Default constructor, initializes all elements with 0.
            /// </summary>
            int_4() __GPU
            {
                _M_x = 0;
                _M_y = 0;
                _M_z = 0;
                _M_w = 0;
            }

            /// <summary>
            ///     Constructor.
            /// </summary>
            /// <param name="_V0">
            ///     The value to initialize element 0.
            /// </param>
            /// <param name="_V1">
            ///     The value to initialize element 1.
            /// </param>
            /// <param name="_V2">
            ///     The value to initialize element 2.
            /// </param>
            /// <param name="_V3">
            ///     The value to initialize element 3.
            /// </param>
            int_4(int _V0, int _V1, int _V2, int _V3) __GPU
            {
                _M_x = _V0;
                _M_y = _V1;
                _M_z = _V2;
                _M_w = _V3;
            }

            /// <summary>
            ///     Constructor.
            /// </summary>
            /// <param name="_V">
            ///     The value for initialization.
            /// </param>
            int_4(int _V) __GPU
            {
                _M_x = _V;
                _M_y = _V;
                _M_z = _V;
                _M_w = _V;
            }

            /// <summary>
            ///     Constructor.
            ///     Each element is initialized by casting from the corresponding element in _Other.
            /// </summary>
            /// <param name="_Other">
            ///     The object used to initialize.
            /// </param>
            explicit inline int_4(const uint_4& _Other) __GPU;

            /// <summary>
            ///     Constructor.
            ///     Each element is initialized by casting from the corresponding element in _Other.
            /// </summary>
            /// <param name="_Other">
            ///     The object used to initialize.
            /// </param>
            explicit inline int_4(const float_4& _Other) __GPU;

            /// <summary>
            ///     Constructor.
            ///     Each element is initialized by casting from the corresponding element in _Other.
            /// </summary>
            /// <param name="_Other">
            ///     The object used to initialize.
            /// </param>
            explicit inline int_4(const unorm_4& _Other) __GPU;

            /// <summary>
            ///     Constructor.
            ///     Each element is initialized by casting from the corresponding element in _Other.
            /// </summary>
            /// <param name="_Other">
            ///     The object used to initialize.
            /// </param>
            explicit inline int_4(const norm_4& _Other) __GPU;

            /// <summary>
            ///     Constructor.
            ///     Each element is initialized by casting from the corresponding element in _Other.
            /// </summary>
            /// <param name="_Other">
            ///     The object used to initialize.
            /// </param>
            explicit inline int_4(const double_4& _Other) __GPU;

            int_4 operator~() const __GPU
            {
                int_4 _Value = *this;
                return int_4(~_Value.x, ~_Value.y, ~_Value.z, ~_Value.w);
            }

            int_4 operator-() const __GPU
            {
                int_4 _Value = *this;
                return int_4(-_Value.x, -_Value.y, -_Value.z, -_Value.w);
            }

            int_4& operator++() __GPU
            {
                int_4 _Value = *this;
                ++_Value._M_x;
                ++_Value._M_y;
                ++_Value._M_z;
                ++_Value._M_w;
                *this = _Value;
                return *this;
            }

            int_4 operator++(int) __GPU
            {
                int_4 _Result = *this;
                ++(*this);
                return _Result;
            }

            int_4& operator--() __GPU
            {
                int_4 _Value = *this;
                --_Value._M_x;
                --_Value._M_y;
                --_Value._M_z;
                --_Value._M_w;
                *this = _Value;
                return *this;
            }

            int_4 operator--(int) __GPU
            {
                int_4 _Result = *this;
                --(*this);
                return _Result;
            }

            int_4& operator+=(const int_4& _Other) __GPU
            {
                int_4 _Value1 = *this;
                int_4 _Value2 = _Other;
                _Value1.x += _Value2.x;
                _Value1.y += _Value2.y;
                _Value1.z += _Value2.z;
                _Value1.w += _Value2.w;
                *this = _Value1;
                return *this;
            }

            int_4& operator-=(const int_4& _Other) __GPU
            {
                int_4 _Value1 = *this;
                int_4 _Value2 = _Other;
                _Value1.x -= _Value2.x;
                _Value1.y -= _Value2.y;
                _Value1.z -= _Value2.z;
                _Value1.w -= _Value2.w;
                *this = _Value1;
                return *this;
            }

            int_4& operator*=(const int_4& _Other) __GPU
            {
                int_4 _Value1 = *this;
                int_4 _Value2 = _Other;
                _Value1.x *= _Value2.x;
                _Value1.y *= _Value2.y;
                _Value1.z *= _Value2.z;
                _Value1.w *= _Value2.w;
                *this = _Value1;
                return *this;
            }

            int_4& operator/=(const int_4& _Other) __GPU
            {
                int_4 _Value1 = *this;
                int_4 _Value2 = _Other;
                _Value1.x /= _Value2.x;
                _Value1.y /= _Value2.y;
                _Value1.z /= _Value2.z;
                _Value1.w /= _Value2.w;
                *this = _Value1;
                return *this;
            }

            int_4& operator%=(const int_4& _Other) __GPU
            {
                int_4 _Value1 = *this;
                int_4 _Value2 = _Other;
                _Value1.x %= _Value2.x;
                _Value1.y %= _Value2.y;
                _Value1.z %= _Value2.z;
                _Value1.w %= _Value2.w;
                *this = _Value1;
                return *this;
            }

            int_4& operator^=(const int_4& _Other) __GPU
            {
                int_4 _Value1 = *this;
                int_4 _Value2 = _Other;
                _Value1.x ^= _Value2.x;
                _Value1.y ^= _Value2.y;
                _Value1.z ^= _Value2.z;
                _Value1.w ^= _Value2.w;
                *this = _Value1;
                return *this;
            }

            int_4& operator|=(const int_4& _Other) __GPU
            {
                int_4 _Value1 = *this;
                int_4 _Value2 = _Other;
                _Value1.x |= _Value2.x;
                _Value1.y |= _Value2.y;
                _Value1.z |= _Value2.z;
                _Value1.w |= _Value2.w;
                *this = _Value1;
                return *this;
            }

            int_4& operator&=(const int_4& _Other) __GPU
            {
                int_4 _Value1 = *this;
                int_4 _Value2 = _Other;
                _Value1.x &= _Value2.x;
                _Value1.y &= _Value2.y;
                _Value1.z &= _Value2.z;
                _Value1.w &= _Value2.w;
                *this = _Value1;
                return *this;
            }

            int_4& operator>>=(const int_4& _Other) __GPU
            {
                int_4 _Value1 = *this;
                int_4 _Value2 = _Other;
                _Value1.x >>= _Value2.x;
                _Value1.y >>= _Value2.y;
                _Value1.z >>= _Value2.z;
                _Value1.w >>= _Value2.w;
                *this = _Value1;
                return *this;
            }

            int_4& operator<<=(const int_4& _Other) __GPU
            {
                int_4 _Value1 = *this;
                int_4 _Value2 = _Other;
                _Value1.x <<= _Value2.x;
                _Value1.y <<= _Value2.y;
                _Value1.z <<= _Value2.z;
                _Value1.w <<= _Value2.w;
                *this = _Value1;
                return *this;
            }

        public:
            /// <summary>
            ///     Property for accessing element 0, and 1 of this int_4 as an int_2.
            /// </summary>
            __declspec( property( get=get_xy, put=set_xy) ) int_2 xy;
            /// <summary>
            ///     Property for accessing element 0, and 1 of this int_4 as an int_2.
            /// </summary>
            __declspec( property( get=get_xy, put=set_xy) ) int_2 rg;

            /// <summary>
            ///     Returns an int_2 that is composed of element 0, and element 1 of this int_4.
            /// </summary>
            /// <returns>
            ///     an int_2.
            /// </returns>
            int_2 get_xy() const __GPU {
                return int_2(_M_x,_M_y);
            }

            /// <summary>
            ///     Set element 0, and 1 of this int_4 with an int_2.
            /// </summary>
            /// <param name="_Value">
            ///     an int_2 value.
            /// </param>
            void set_xy(const int_2& _Value) __GPU
            {
                int_2 _Val = _Value;
                _M_x = _Val.x;
                _M_y = _Val.y;
            }

            /// <summary>
            ///     Property for accessing element 0, and 2 of this int_4 as an int_2.
            /// </summary>
            __declspec( property( get=get_xz, put=set_xz) ) int_2 xz;
            /// <summary>
            ///     Property for accessing element 0, and 2 of this int_4 as an int_2.
            /// </summary>
            __declspec( property( get=get_xz, put=set_xz) ) int_2 rb;

            /// <summary>
            ///     Returns an int_2 that is composed of element 0, and element 2 of this int_4.
            /// </summary>
            /// <returns>
            ///     an int_2.
            /// </returns>
            int_2 get_xz() const __GPU {
                return int_2(_M_x,_M_z);
            }

            /// <summary>
            ///     Set element 0, and 2 of this int_4 with an int_2.
            /// </summary>
            /// <param name="_Value">
            ///     an int_2 value.
            /// </param>
            void set_xz(const int_2& _Value) __GPU
            {
                int_2 _Val = _Value;
                _M_x = _Val.x;
                _M_z = _Val.y;
            }

            /// <summary>
            ///     Property for accessing element 0, and 3 of this int_4 as an int_2.
            /// </summary>
            __declspec( property( get=get_xw, put=set_xw) ) int_2 xw;
            /// <summary>
            ///     Property for accessing element 0, and 3 of this int_4 as an int_2.
            /// </summary>
            __declspec( property( get=get_xw, put=set_xw) ) int_2 ra;

            /// <summary>
            ///     Returns an int_2 that is composed of element 0, and element 3 of this int_4.
            /// </summary>
            /// <returns>
            ///     an int_2.
            /// </returns>
            int_2 get_xw() const __GPU {
                return int_2(_M_x,_M_w);
            }

            /// <summary>
            ///     Set element 0, and 3 of this int_4 with an int_2.
            /// </summary>
            /// <param name="_Value">
            ///     an int_2 value.
            /// </param>
            void set_xw(const int_2& _Value) __GPU
            {
                int_2 _Val = _Value;
                _M_x = _Val.x;
                _M_w = _Val.y;
            }

            /// <summary>
            ///     Property for accessing element 1, and 0 of this int_4 as an int_2.
            /// </summary>
            __declspec( property( get=get_yx, put=set_yx) ) int_2 yx;
            /// <summary>
            ///     Property for accessing element 1, and 0 of this int_4 as an int_2.
            /// </summary>
            __declspec( property( get=get_yx, put=set_yx) ) int_2 gr;

            /// <summary>
            ///     Returns an int_2 that is composed of element 1, and element 0 of this int_4.
            /// </summary>
            /// <returns>
            ///     an int_2.
            /// </returns>
            int_2 get_yx() const __GPU {
                return int_2(_M_y,_M_x);
            }

            /// <summary>
            ///     Set element 1, and 0 of this int_4 with an int_2.
            /// </summary>
            /// <param name="_Value">
            ///     an int_2 value.
            /// </param>
            void set_yx(const int_2& _Value) __GPU
            {
                int_2 _Val = _Value;
                _M_y = _Val.x;
                _M_x = _Val.y;
            }

            /// <summary>
            ///     Property for accessing element 1, and 2 of this int_4 as an int_2.
            /// </summary>
            __declspec( property( get=get_yz, put=set_yz) ) int_2 yz;
            /// <summary>
            ///     Property for accessing element 1, and 2 of this int_4 as an int_2.
            /// </summary>
            __declspec( property( get=get_yz, put=set_yz) ) int_2 gb;

            /// <summary>
            ///     Returns an int_2 that is composed of element 1, and element 2 of this int_4.
            /// </summary>
            /// <returns>
            ///     an int_2.
            /// </returns>
            int_2 get_yz() const __GPU {
                return int_2(_M_y,_M_z);
            }

            /// <summary>
            ///     Set element 1, and 2 of this int_4 with an int_2.
            /// </summary>
            /// <param name="_Value">
            ///     an int_2 value.
            /// </param>
            void set_yz(const int_2& _Value) __GPU
            {
                int_2 _Val = _Value;
                _M_y = _Val.x;
                _M_z = _Val.y;
            }

            /// <summary>
            ///     Property for accessing element 1, and 3 of this int_4 as an int_2.
            /// </summary>
            __declspec( property( get=get_yw, put=set_yw) ) int_2 yw;
            /// <summary>
            ///     Property for accessing element 1, and 3 of this int_4 as an int_2.
            /// </summary>
            __declspec( property( get=get_yw, put=set_yw) ) int_2 ga;

            /// <summary>
            ///     Returns an int_2 that is composed of element 1, and element 3 of this int_4.
            /// </summary>
            /// <returns>
            ///     an int_2.
            /// </returns>
            int_2 get_yw() const __GPU {
                return int_2(_M_y,_M_w);
            }

            /// <summary>
            ///     Set element 1, and 3 of this int_4 with an int_2.
            /// </summary>
            /// <param name="_Value">
            ///     an int_2 value.
            /// </param>
            void set_yw(const int_2& _Value) __GPU
            {
                int_2 _Val = _Value;
                _M_y = _Val.x;
                _M_w = _Val.y;
            }

            /// <summary>
            ///     Property for accessing element 2, and 0 of this int_4 as an int_2.
            /// </summary>
            __declspec( property( get=get_zx, put=set_zx) ) int_2 zx;
            /// <summary>
            ///     Property for accessing element 2, and 0 of this int_4 as an int_2.
            /// </summary>
            __declspec( property( get=get_zx, put=set_zx) ) int_2 br;

            /// <summary>
            ///     Returns an int_2 that is composed of element 2, and element 0 of this int_4.
            /// </summary>
            /// <returns>
            ///     an int_2.
            /// </returns>
            int_2 get_zx() const __GPU {
                return int_2(_M_z,_M_x);
            }

            /// <summary>
            ///     Set element 2, and 0 of this int_4 with an int_2.
            /// </summary>
            /// <param name="_Value">
            ///     an int_2 value.
            /// </param>
            void set_zx(const int_2& _Value) __GPU
            {
                int_2 _Val = _Value;
                _M_z = _Val.x;
                _M_x = _Val.y;
            }

            /// <summary>
            ///     Property for accessing element 2, and 1 of this int_4 as an int_2.
            /// </summary>
            __declspec( property( get=get_zy, put=set_zy) ) int_2 zy;
            /// <summary>
            ///     Property for accessing element 2, and 1 of this int_4 as an int_2.
            /// </summary>
            __declspec( property( get=get_zy, put=set_zy) ) int_2 bg;

            /// <summary>
            ///     Returns an int_2 that is composed of element 2, and element 1 of this int_4.
            /// </summary>
            /// <returns>
            ///     an int_2.
            /// </returns>
            int_2 get_zy() const __GPU {
                return int_2(_M_z,_M_y);
            }

            /// <summary>
            ///     Set element 2, and 1 of this int_4 with an int_2.
            /// </summary>
            /// <param name="_Value">
            ///     an int_2 value.
            /// </param>
            void set_zy(const int_2& _Value) __GPU
            {
                int_2 _Val = _Value;
                _M_z = _Val.x;
                _M_y = _Val.y;
            }

            /// <summary>
            ///     Property for accessing element 2, and 3 of this int_4 as an int_2.
            /// </summary>
            __declspec( property( get=get_zw, put=set_zw) ) int_2 zw;
            /// <summary>
            ///     Property for accessing element 2, and 3 of this int_4 as an int_2.
            /// </summary>
            __declspec( property( get=get_zw, put=set_zw) ) int_2 ba;

            /// <summary>
            ///     Returns an int_2 that is composed of element 2, and element 3 of this int_4.
            /// </summary>
            /// <returns>
            ///     an int_2.
            /// </returns>
            int_2 get_zw() const __GPU {
                return int_2(_M_z,_M_w);
            }

            /// <summary>
            ///     Set element 2, and 3 of this int_4 with an int_2.
            /// </summary>
            /// <param name="_Value">
            ///     an int_2 value.
            /// </param>
            void set_zw(const int_2& _Value) __GPU
            {
                int_2 _Val = _Value;
                _M_z = _Val.x;
                _M_w = _Val.y;
            }

            /// <summary>
            ///     Property for accessing element 3, and 0 of this int_4 as an int_2.
            /// </summary>
            __declspec( property( get=get_wx, put=set_wx) ) int_2 wx;
            /// <summary>
            ///     Property for accessing element 3, and 0 of this int_4 as an int_2.
            /// </summary>
            __declspec( property( get=get_wx, put=set_wx) ) int_2 ar;

            /// <summary>
            ///     Returns an int_2 that is composed of element 3, and element 0 of this int_4.
            /// </summary>
            /// <returns>
            ///     an int_2.
            /// </returns>
            int_2 get_wx() const __GPU {
                return int_2(_M_w,_M_x);
            }

            /// <summary>
            ///     Set element 3, and 0 of this int_4 with an int_2.
            /// </summary>
            /// <param name="_Value">
            ///     an int_2 value.
            /// </param>
            void set_wx(const int_2& _Value) __GPU
            {
                int_2 _Val = _Value;
                _M_w = _Val.x;
                _M_x = _Val.y;
            }

            /// <summary>
            ///     Property for accessing element 3, and 1 of this int_4 as an int_2.
            /// </summary>
            __declspec( property( get=get_wy, put=set_wy) ) int_2 wy;
            /// <summary>
            ///     Property for accessing element 3, and 1 of this int_4 as an int_2.
            /// </summary>
            __declspec( property( get=get_wy, put=set_wy) ) int_2 ag;

            /// <summary>
            ///     Returns an int_2 that is composed of element 3, and element 1 of this int_4.
            /// </summary>
            /// <returns>
            ///     an int_2.
            /// </returns>
            int_2 get_wy() const __GPU {
                return int_2(_M_w,_M_y);
            }

            /// <summary>
            ///     Set element 3, and 1 of this int_4 with an int_2.
            /// </summary>
            /// <param name="_Value">
            ///     an int_2 value.
            /// </param>
            void set_wy(const int_2& _Value) __GPU