diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics.Editor/MatrixDrawer.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics.Editor/MatrixDrawer.cs new file mode 100644 index 0000000000000000000000000000000000000000..3f31a0c7bb8af587e9f4ac08f5f3bc76520b5726 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics.Editor/MatrixDrawer.cs @@ -0,0 +1,139 @@ +using System; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using UnityEditor; +using UnityEngine; + +namespace Unity.Mathematics.Editor +{ + [CustomPropertyDrawer(typeof(bool2x2)), CustomPropertyDrawer(typeof(bool2x3)), CustomPropertyDrawer(typeof(bool2x4))] + [CustomPropertyDrawer(typeof(bool3x2)), CustomPropertyDrawer(typeof(bool3x3)), CustomPropertyDrawer(typeof(bool3x4))] + [CustomPropertyDrawer(typeof(bool4x2)), CustomPropertyDrawer(typeof(bool4x3)), CustomPropertyDrawer(typeof(bool4x4))] + [CustomPropertyDrawer(typeof(double2x2)), CustomPropertyDrawer(typeof(double2x3)), CustomPropertyDrawer(typeof(double2x4))] + [CustomPropertyDrawer(typeof(double3x2)), CustomPropertyDrawer(typeof(double3x3)), CustomPropertyDrawer(typeof(double3x4))] + [CustomPropertyDrawer(typeof(double4x2)), CustomPropertyDrawer(typeof(double4x3)), CustomPropertyDrawer(typeof(double4x4))] + [CustomPropertyDrawer(typeof(float2x2)), CustomPropertyDrawer(typeof(float2x3)), CustomPropertyDrawer(typeof(float2x4))] + [CustomPropertyDrawer(typeof(float3x2)), CustomPropertyDrawer(typeof(float3x3)), CustomPropertyDrawer(typeof(float3x4))] + [CustomPropertyDrawer(typeof(float4x2)), CustomPropertyDrawer(typeof(float4x3)), CustomPropertyDrawer(typeof(float4x4))] + [CustomPropertyDrawer(typeof(int2x2)), CustomPropertyDrawer(typeof(int2x3)), CustomPropertyDrawer(typeof(int2x4))] + [CustomPropertyDrawer(typeof(int3x2)), CustomPropertyDrawer(typeof(int3x3)), CustomPropertyDrawer(typeof(int3x4))] + [CustomPropertyDrawer(typeof(int4x2)), CustomPropertyDrawer(typeof(int4x3)), CustomPropertyDrawer(typeof(int4x4))] + [CustomPropertyDrawer(typeof(uint2x2)), CustomPropertyDrawer(typeof(uint2x3)), CustomPropertyDrawer(typeof(uint2x4))] + [CustomPropertyDrawer(typeof(uint3x2)), CustomPropertyDrawer(typeof(uint3x3)), CustomPropertyDrawer(typeof(uint3x4))] + [CustomPropertyDrawer(typeof(uint4x2)), CustomPropertyDrawer(typeof(uint4x3)), CustomPropertyDrawer(typeof(uint4x4))] + class MatrixDrawer : PropertyDrawer + { + public override bool CanCacheInspectorGUI(SerializedProperty property) + { + return false; + } + + public override float GetPropertyHeight(SerializedProperty property, GUIContent label) + { + if (!property.isExpanded) + return EditorGUIUtility.singleLineHeight; + var rows = 1 + property.type[property.type.Length - 3] - '0'; + return rows * EditorGUIUtility.singleLineHeight + (rows - 1) * EditorGUIUtility.standardVerticalSpacing; + } + + static ReadOnlyCollection k_ColPropertyPaths = + new ReadOnlyCollection(new[] { "c0", "c1", "c2", "c3" }); + static ReadOnlyCollection k_RowPropertyPaths = + new ReadOnlyCollection(new[] { "x", "y", "z", "w" }); + + public override void OnGUI(Rect position, SerializedProperty property, GUIContent label) + { + position.height = EditorGUIUtility.singleLineHeight; + EditorGUI.PropertyField(position, property, label, false); + + if (Event.current.type == EventType.ContextClick && position.Contains(Event.current.mousePosition)) + { + DoUtilityMenu(property); + Event.current.Use(); + } + + if (!property.isExpanded) + return; + + var rows = property.type[property.type.Length - 3] - '0'; + var cols = property.type[property.type.Length - 1] - '0'; + + ++EditorGUI.indentLevel; + position = EditorGUI.IndentedRect(position); + --EditorGUI.indentLevel; + + var elementType = property.FindPropertyRelative("c0.x").propertyType; + for (var row = 0; row < rows; ++row) + { + position.y += position.height + EditorGUIUtility.standardVerticalSpacing; + var elementRect = new Rect(position) + { + width = elementType == SerializedPropertyType.Boolean + ? EditorGUIUtility.singleLineHeight + : (position.width - (cols - 1) * EditorGUIUtility.standardVerticalSpacing) / cols + }; + for (var col = 0; col < cols; ++col) + { + EditorGUI.PropertyField( + elementRect, + property.FindPropertyRelative($"{k_ColPropertyPaths[col]}.{k_RowPropertyPaths[row]}"), + GUIContent.none + ); + elementRect.x += elementRect.width + EditorGUIUtility.standardVerticalSpacing; + } + } + } + + Dictionary> k_UtilityValueSetters = + new Dictionary> + { + { SerializedPropertyType.Boolean, (property, b) => property.boolValue = b }, + { SerializedPropertyType.Float, (property, b) => property.floatValue = b ? 1f : 0f }, + { SerializedPropertyType.Integer, (property, b) => property.intValue = b ? 1 : 0 } + }; + + void DoUtilityMenu(SerializedProperty property) + { + var rows = property.type[property.type.Length - 3] - '0'; + var cols = property.type[property.type.Length - 1] - '0'; + var elementType = property.FindPropertyRelative("c0.x").propertyType; + var setValue = k_UtilityValueSetters[elementType]; + var menu = new GenericMenu(); + property = property.Copy(); + menu.AddItem( + EditorGUIUtility.TrTextContent("Set to Zero"), + false, + () => + { + property.serializedObject.Update();; + for (var row = 0; row < rows; ++row) + for (var col = 0; col < cols; ++col) + setValue( + property.FindPropertyRelative($"{k_ColPropertyPaths[col]}.{k_RowPropertyPaths[row]}"), + false + ); + property.serializedObject.ApplyModifiedProperties(); + } + ); + if (rows == cols) + { + menu.AddItem( + EditorGUIUtility.TrTextContent("Reset to Identity"), + false, + () => + { + property.serializedObject.Update(); + for (var row = 0; row < rows; ++row) + for (var col = 0; col < cols; ++col) + setValue( + property.FindPropertyRelative($"{k_ColPropertyPaths[col]}.{k_RowPropertyPaths[row]}"), + row == col + ); + property.serializedObject.ApplyModifiedProperties(); + } + ); + } + menu.ShowAsContext(); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics.Editor/MatrixDrawer.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics.Editor/MatrixDrawer.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..7daf3acd1795906ceddd93f3683225f4d4e2ee12 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics.Editor/MatrixDrawer.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 407410bec194a4cfe929933685bb80a7 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics.Editor/PostNormalizedVectorDrawer.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics.Editor/PostNormalizedVectorDrawer.cs new file mode 100644 index 0000000000000000000000000000000000000000..d4189eda71cb90e0704ed3d1544cd8522c45c66e --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics.Editor/PostNormalizedVectorDrawer.cs @@ -0,0 +1,202 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using UnityEditor; +using UnityEngine; +using UnityObject = UnityEngine.Object; + +namespace Unity.Mathematics.Editor +{ + [CustomPropertyDrawer(typeof(PostNormalizeAttribute))] + class PostNormalizedVectorDrawer : PrimitiveVectorDrawer + { + static class Content + { + public static readonly string tooltip = + L10n.Tr("Values you enter will be post-normalized. You will see the normalized result if you change selection and view the values again."); + } + + class VectorPropertyGUIData + { + const int k_MaxElements = 4; + + public readonly bool Valid; + + // parent property + readonly SerializedProperty m_VectorProperty; + // relative paths of element child properties + readonly IReadOnlyList m_ElementPaths; + // the number of element child properties + readonly int m_NumElements; + // per child property; value is null if there are multiple different values + readonly double?[] m_PreNormalizedValues; + // per target; used to revert actual values for each object after displaying pre-normalized values + readonly Dictionary m_PostNormalizedValues = new Dictionary(); + + public VectorPropertyGUIData(SerializedProperty property) + { + m_VectorProperty = property; + var parentPath = m_VectorProperty.propertyPath; + var i = 0; + var elementPaths = new List(k_MaxElements); + var iterator = m_VectorProperty.Copy(); + while (iterator.Next(true) && iterator.propertyPath.StartsWith(parentPath)) + { + if (i >= k_MaxElements || iterator.propertyType != SerializedPropertyType.Float) + return; + elementPaths.Add(iterator.propertyPath.Substring(parentPath.Length + 1)); + i++; + } + + Valid = true; + m_NumElements = elementPaths.Count; + m_ElementPaths = elementPaths; + m_PreNormalizedValues = elementPaths.Select(p => (double?)null).ToArray(); + + UpdatePreNormalizedValues(); + UpdatePostNormalizedValues(); + } + + void UpdatePostNormalizedValues() + { + m_PostNormalizedValues.Clear(); + foreach (var target in m_VectorProperty.serializedObject.targetObjects) + { + var postNormalizedValue = new double4(); + var parentProperty = new SerializedObject(target).FindProperty(m_VectorProperty.propertyPath); + for (var i = 0; i < m_NumElements; ++i) + postNormalizedValue[i] = parentProperty.FindPropertyRelative(m_ElementPaths[i]).doubleValue; + m_PostNormalizedValues[parentProperty] = postNormalizedValue; + } + } + + public void UpdatePreNormalizedValues() + { + for (var i = 0; i < m_NumElements; ++i) + { + var p = m_VectorProperty.FindPropertyRelative(m_ElementPaths[i]); + m_PreNormalizedValues[i] = p.hasMultipleDifferentValues ? (double?)null : p.doubleValue; + } + } + + public void ApplyPreNormalizedValues() + { + m_VectorProperty.serializedObject.ApplyModifiedProperties(); + for (var i = 0; i < m_NumElements; ++i) + { + if (m_PreNormalizedValues[i] != null) + m_VectorProperty.FindPropertyRelative(m_ElementPaths[i]).doubleValue = m_PreNormalizedValues[i].Value; + } + } + + public void UnapplyPreNormalizedValues() + { + foreach (var target in m_PostNormalizedValues) + { + target.Key.serializedObject.Update(); + for (var i = 0; i < m_NumElements; ++i) + { + target.Key.FindPropertyRelative(m_ElementPaths[i]).doubleValue = target.Value[i]; + target.Key.serializedObject.ApplyModifiedProperties(); + } + } + m_VectorProperty.serializedObject.Update(); + } + + public void PostNormalize(Func normalize) + { + m_VectorProperty.serializedObject.ApplyModifiedProperties(); + foreach (var target in m_PostNormalizedValues) + { + target.Key.serializedObject.Update(); + var postNormalizedValue = new double4(); + for (var i = 0; i < m_NumElements; ++i) + postNormalizedValue[i] = target.Key.FindPropertyRelative(m_ElementPaths[i]).doubleValue; + postNormalizedValue = normalize(normalize(postNormalizedValue)); + for (var i = 0; i < m_NumElements; ++i) + target.Key.FindPropertyRelative(m_ElementPaths[i]).doubleValue = postNormalizedValue[i]; + target.Key.serializedObject.ApplyModifiedProperties(); + } + UpdatePostNormalizedValues(); + m_VectorProperty.serializedObject.Update(); + } + + public void RebuildIfDirty() + { + foreach (var target in m_PostNormalizedValues) + { + target.Key.serializedObject.Update(); + for (var i = 0; i < m_NumElements; ++i) + { + var serialized = target.Key.FindPropertyRelative(m_ElementPaths[i]).doubleValue; + if (target.Value[i] != serialized) + { + UpdatePreNormalizedValues(); + UpdatePostNormalizedValues(); + return; + } + } + } + } + } + + Dictionary m_GUIDataPerPropertyPath = new Dictionary(); + + protected virtual SerializedProperty GetVectorProperty(SerializedProperty property) + { + return property; + } + + protected virtual double4 Normalize(double4 value) + { + return math.normalizesafe(value); + } + + VectorPropertyGUIData GetGUIData(SerializedProperty property) + { + VectorPropertyGUIData guiData; + if (!m_GUIDataPerPropertyPath.TryGetValue(property.propertyPath, out guiData)) + { + guiData = new VectorPropertyGUIData(GetVectorProperty(property)); + m_GUIDataPerPropertyPath[property.propertyPath] = guiData; + } + return guiData; + } + + public override float GetPropertyHeight(SerializedProperty property, GUIContent label) + { + return GetGUIData(property).Valid ? base.GetPropertyHeight(property, label) : EditorGUIUtility.singleLineHeight; + } + + public override void OnGUI(Rect position, SerializedProperty property, GUIContent label) + { + var guiData = GetGUIData(property); + if (!guiData.Valid) + { + EditorGUI.HelpBox( + EditorGUI.PrefixLabel(position, label), + L10n.Tr($"{typeof(PostNormalizeAttribute).Name} only works with decimal vector types."), + MessageType.None + ); + return; + } + + if (string.IsNullOrEmpty(label.tooltip)) + label.tooltip = Content.tooltip; + + guiData.RebuildIfDirty(); + guiData.ApplyPreNormalizedValues(); + EditorGUI.BeginChangeCheck(); + base.OnGUI(position, property, label); + if (EditorGUI.EndChangeCheck()) + { + guiData.UpdatePreNormalizedValues(); + guiData.PostNormalize(Normalize); + } + else + { + guiData.UnapplyPreNormalizedValues(); + } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/Unity.Mathematics.asmdef b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/Unity.Mathematics.asmdef new file mode 100644 index 0000000000000000000000000000000000000000..bb5810592267e1974f9a2a29a2eeecc4f8f01e95 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/Unity.Mathematics.asmdef @@ -0,0 +1,4 @@ +{ + "name": "Unity.Mathematics", + "allowUnsafeCode": true +} \ No newline at end of file diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/Unity.Mathematics.asmdef.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/Unity.Mathematics.asmdef.meta new file mode 100644 index 0000000000000000000000000000000000000000..6193fbb53e034dd83d3865189096c55230688c36 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/Unity.Mathematics.asmdef.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: d8b63aba1907145bea998dd612889d6b +AssemblyDefinitionImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/uint3.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/uint3.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..b79320be386c7eefcb988fe8425c20d30bece085 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/uint3.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 3f9d441c51e38d9488cbdd2f013adcd3 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/uint3x2.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/uint3x2.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..fa231da42eb98bfb85b1ae42f6158eadd2dfee3f --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/uint3x2.gen.cs @@ -0,0 +1,494 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using System; +using System.Runtime.CompilerServices; + +#pragma warning disable 0660, 0661 + +namespace Unity.Mathematics +{ + [System.Serializable] + public partial struct uint3x2 : System.IEquatable, IFormattable + { + public uint3 c0; + public uint3 c1; + + /// uint3x2 zero value. + public static readonly uint3x2 zero; + + /// Constructs a uint3x2 matrix from two uint3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint3x2(uint3 c0, uint3 c1) + { + this.c0 = c0; + this.c1 = c1; + } + + /// Constructs a uint3x2 matrix from 6 uint values given in row-major order. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint3x2(uint m00, uint m01, + uint m10, uint m11, + uint m20, uint m21) + { + this.c0 = new uint3(m00, m10, m20); + this.c1 = new uint3(m01, m11, m21); + } + + /// Constructs a uint3x2 matrix from a single uint value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint3x2(uint v) + { + this.c0 = v; + this.c1 = v; + } + + /// Constructs a uint3x2 matrix from a single bool value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint3x2(bool v) + { + this.c0 = math.select(new uint3(0u), new uint3(1u), v); + this.c1 = math.select(new uint3(0u), new uint3(1u), v); + } + + /// Constructs a uint3x2 matrix from a bool3x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint3x2(bool3x2 v) + { + this.c0 = math.select(new uint3(0u), new uint3(1u), v.c0); + this.c1 = math.select(new uint3(0u), new uint3(1u), v.c1); + } + + /// Constructs a uint3x2 matrix from a single int value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint3x2(int v) + { + this.c0 = (uint3)v; + this.c1 = (uint3)v; + } + + /// Constructs a uint3x2 matrix from a int3x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint3x2(int3x2 v) + { + this.c0 = (uint3)v.c0; + this.c1 = (uint3)v.c1; + } + + /// Constructs a uint3x2 matrix from a single float value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint3x2(float v) + { + this.c0 = (uint3)v; + this.c1 = (uint3)v; + } + + /// Constructs a uint3x2 matrix from a float3x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint3x2(float3x2 v) + { + this.c0 = (uint3)v.c0; + this.c1 = (uint3)v.c1; + } + + /// Constructs a uint3x2 matrix from a single double value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint3x2(double v) + { + this.c0 = (uint3)v; + this.c1 = (uint3)v; + } + + /// Constructs a uint3x2 matrix from a double3x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint3x2(double3x2 v) + { + this.c0 = (uint3)v.c0; + this.c1 = (uint3)v.c1; + } + + + /// Implicitly converts a single uint value to a uint3x2 matrix by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator uint3x2(uint v) { return new uint3x2(v); } + + /// Explicitly converts a single bool value to a uint3x2 matrix by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint3x2(bool v) { return new uint3x2(v); } + + /// Explicitly converts a bool3x2 matrix to a uint3x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint3x2(bool3x2 v) { return new uint3x2(v); } + + /// Explicitly converts a single int value to a uint3x2 matrix by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint3x2(int v) { return new uint3x2(v); } + + /// Explicitly converts a int3x2 matrix to a uint3x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint3x2(int3x2 v) { return new uint3x2(v); } + + /// Explicitly converts a single float value to a uint3x2 matrix by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint3x2(float v) { return new uint3x2(v); } + + /// Explicitly converts a float3x2 matrix to a uint3x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint3x2(float3x2 v) { return new uint3x2(v); } + + /// Explicitly converts a single double value to a uint3x2 matrix by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint3x2(double v) { return new uint3x2(v); } + + /// Explicitly converts a double3x2 matrix to a uint3x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint3x2(double3x2 v) { return new uint3x2(v); } + + + /// Returns the result of a componentwise multiplication operation on two uint3x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x2 operator * (uint3x2 lhs, uint3x2 rhs) { return new uint3x2 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1); } + + /// Returns the result of a componentwise multiplication operation on a uint3x2 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x2 operator * (uint3x2 lhs, uint rhs) { return new uint3x2 (lhs.c0 * rhs, lhs.c1 * rhs); } + + /// Returns the result of a componentwise multiplication operation on a uint value and a uint3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x2 operator * (uint lhs, uint3x2 rhs) { return new uint3x2 (lhs * rhs.c0, lhs * rhs.c1); } + + + /// Returns the result of a componentwise addition operation on two uint3x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x2 operator + (uint3x2 lhs, uint3x2 rhs) { return new uint3x2 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1); } + + /// Returns the result of a componentwise addition operation on a uint3x2 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x2 operator + (uint3x2 lhs, uint rhs) { return new uint3x2 (lhs.c0 + rhs, lhs.c1 + rhs); } + + /// Returns the result of a componentwise addition operation on a uint value and a uint3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x2 operator + (uint lhs, uint3x2 rhs) { return new uint3x2 (lhs + rhs.c0, lhs + rhs.c1); } + + + /// Returns the result of a componentwise subtraction operation on two uint3x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x2 operator - (uint3x2 lhs, uint3x2 rhs) { return new uint3x2 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1); } + + /// Returns the result of a componentwise subtraction operation on a uint3x2 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x2 operator - (uint3x2 lhs, uint rhs) { return new uint3x2 (lhs.c0 - rhs, lhs.c1 - rhs); } + + /// Returns the result of a componentwise subtraction operation on a uint value and a uint3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x2 operator - (uint lhs, uint3x2 rhs) { return new uint3x2 (lhs - rhs.c0, lhs - rhs.c1); } + + + /// Returns the result of a componentwise division operation on two uint3x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x2 operator / (uint3x2 lhs, uint3x2 rhs) { return new uint3x2 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1); } + + /// Returns the result of a componentwise division operation on a uint3x2 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x2 operator / (uint3x2 lhs, uint rhs) { return new uint3x2 (lhs.c0 / rhs, lhs.c1 / rhs); } + + /// Returns the result of a componentwise division operation on a uint value and a uint3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x2 operator / (uint lhs, uint3x2 rhs) { return new uint3x2 (lhs / rhs.c0, lhs / rhs.c1); } + + + /// Returns the result of a componentwise modulus operation on two uint3x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x2 operator % (uint3x2 lhs, uint3x2 rhs) { return new uint3x2 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1); } + + /// Returns the result of a componentwise modulus operation on a uint3x2 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x2 operator % (uint3x2 lhs, uint rhs) { return new uint3x2 (lhs.c0 % rhs, lhs.c1 % rhs); } + + /// Returns the result of a componentwise modulus operation on a uint value and a uint3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x2 operator % (uint lhs, uint3x2 rhs) { return new uint3x2 (lhs % rhs.c0, lhs % rhs.c1); } + + + /// Returns the result of a componentwise increment operation on a uint3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x2 operator ++ (uint3x2 val) { return new uint3x2 (++val.c0, ++val.c1); } + + + /// Returns the result of a componentwise decrement operation on a uint3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x2 operator -- (uint3x2 val) { return new uint3x2 (--val.c0, --val.c1); } + + + /// Returns the result of a componentwise less than operation on two uint3x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator < (uint3x2 lhs, uint3x2 rhs) { return new bool3x2 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1); } + + /// Returns the result of a componentwise less than operation on a uint3x2 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator < (uint3x2 lhs, uint rhs) { return new bool3x2 (lhs.c0 < rhs, lhs.c1 < rhs); } + + /// Returns the result of a componentwise less than operation on a uint value and a uint3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator < (uint lhs, uint3x2 rhs) { return new bool3x2 (lhs < rhs.c0, lhs < rhs.c1); } + + + /// Returns the result of a componentwise less or equal operation on two uint3x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator <= (uint3x2 lhs, uint3x2 rhs) { return new bool3x2 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1); } + + /// Returns the result of a componentwise less or equal operation on a uint3x2 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator <= (uint3x2 lhs, uint rhs) { return new bool3x2 (lhs.c0 <= rhs, lhs.c1 <= rhs); } + + /// Returns the result of a componentwise less or equal operation on a uint value and a uint3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator <= (uint lhs, uint3x2 rhs) { return new bool3x2 (lhs <= rhs.c0, lhs <= rhs.c1); } + + + /// Returns the result of a componentwise greater than operation on two uint3x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator > (uint3x2 lhs, uint3x2 rhs) { return new bool3x2 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1); } + + /// Returns the result of a componentwise greater than operation on a uint3x2 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator > (uint3x2 lhs, uint rhs) { return new bool3x2 (lhs.c0 > rhs, lhs.c1 > rhs); } + + /// Returns the result of a componentwise greater than operation on a uint value and a uint3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator > (uint lhs, uint3x2 rhs) { return new bool3x2 (lhs > rhs.c0, lhs > rhs.c1); } + + + /// Returns the result of a componentwise greater or equal operation on two uint3x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator >= (uint3x2 lhs, uint3x2 rhs) { return new bool3x2 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1); } + + /// Returns the result of a componentwise greater or equal operation on a uint3x2 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator >= (uint3x2 lhs, uint rhs) { return new bool3x2 (lhs.c0 >= rhs, lhs.c1 >= rhs); } + + /// Returns the result of a componentwise greater or equal operation on a uint value and a uint3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator >= (uint lhs, uint3x2 rhs) { return new bool3x2 (lhs >= rhs.c0, lhs >= rhs.c1); } + + + /// Returns the result of a componentwise unary minus operation on a uint3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x2 operator - (uint3x2 val) { return new uint3x2 (-val.c0, -val.c1); } + + + /// Returns the result of a componentwise unary plus operation on a uint3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x2 operator + (uint3x2 val) { return new uint3x2 (+val.c0, +val.c1); } + + + /// Returns the result of a componentwise left shift operation on a uint3x2 matrix by a number of bits specified by a single int. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x2 operator << (uint3x2 x, int n) { return new uint3x2 (x.c0 << n, x.c1 << n); } + + /// Returns the result of a componentwise right shift operation on a uint3x2 matrix by a number of bits specified by a single int. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x2 operator >> (uint3x2 x, int n) { return new uint3x2 (x.c0 >> n, x.c1 >> n); } + + /// Returns the result of a componentwise equality operation on two uint3x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator == (uint3x2 lhs, uint3x2 rhs) { return new bool3x2 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1); } + + /// Returns the result of a componentwise equality operation on a uint3x2 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator == (uint3x2 lhs, uint rhs) { return new bool3x2 (lhs.c0 == rhs, lhs.c1 == rhs); } + + /// Returns the result of a componentwise equality operation on a uint value and a uint3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator == (uint lhs, uint3x2 rhs) { return new bool3x2 (lhs == rhs.c0, lhs == rhs.c1); } + + + /// Returns the result of a componentwise not equal operation on two uint3x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator != (uint3x2 lhs, uint3x2 rhs) { return new bool3x2 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1); } + + /// Returns the result of a componentwise not equal operation on a uint3x2 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator != (uint3x2 lhs, uint rhs) { return new bool3x2 (lhs.c0 != rhs, lhs.c1 != rhs); } + + /// Returns the result of a componentwise not equal operation on a uint value and a uint3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator != (uint lhs, uint3x2 rhs) { return new bool3x2 (lhs != rhs.c0, lhs != rhs.c1); } + + + /// Returns the result of a componentwise bitwise not operation on a uint3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x2 operator ~ (uint3x2 val) { return new uint3x2 (~val.c0, ~val.c1); } + + + /// Returns the result of a componentwise bitwise and operation on two uint3x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x2 operator & (uint3x2 lhs, uint3x2 rhs) { return new uint3x2 (lhs.c0 & rhs.c0, lhs.c1 & rhs.c1); } + + /// Returns the result of a componentwise bitwise and operation on a uint3x2 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x2 operator & (uint3x2 lhs, uint rhs) { return new uint3x2 (lhs.c0 & rhs, lhs.c1 & rhs); } + + /// Returns the result of a componentwise bitwise and operation on a uint value and a uint3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x2 operator & (uint lhs, uint3x2 rhs) { return new uint3x2 (lhs & rhs.c0, lhs & rhs.c1); } + + + /// Returns the result of a componentwise bitwise or operation on two uint3x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x2 operator | (uint3x2 lhs, uint3x2 rhs) { return new uint3x2 (lhs.c0 | rhs.c0, lhs.c1 | rhs.c1); } + + /// Returns the result of a componentwise bitwise or operation on a uint3x2 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x2 operator | (uint3x2 lhs, uint rhs) { return new uint3x2 (lhs.c0 | rhs, lhs.c1 | rhs); } + + /// Returns the result of a componentwise bitwise or operation on a uint value and a uint3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x2 operator | (uint lhs, uint3x2 rhs) { return new uint3x2 (lhs | rhs.c0, lhs | rhs.c1); } + + + /// Returns the result of a componentwise bitwise exclusive or operation on two uint3x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x2 operator ^ (uint3x2 lhs, uint3x2 rhs) { return new uint3x2 (lhs.c0 ^ rhs.c0, lhs.c1 ^ rhs.c1); } + + /// Returns the result of a componentwise bitwise exclusive or operation on a uint3x2 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x2 operator ^ (uint3x2 lhs, uint rhs) { return new uint3x2 (lhs.c0 ^ rhs, lhs.c1 ^ rhs); } + + /// Returns the result of a componentwise bitwise exclusive or operation on a uint value and a uint3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x2 operator ^ (uint lhs, uint3x2 rhs) { return new uint3x2 (lhs ^ rhs.c0, lhs ^ rhs.c1); } + + + + /// Returns the uint3 element at a specified index. + unsafe public ref uint3 this[int index] + { + get + { +#if ENABLE_UNITY_COLLECTIONS_CHECKS + if ((uint)index >= 2) + throw new System.ArgumentException("index must be between[0...1]"); +#endif + fixed (uint3x2* array = &this) { return ref ((uint3*)array)[index]; } + } + } + + /// Returns true if the uint3x2 is equal to a given uint3x2, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool Equals(uint3x2 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1); } + + /// Returns true if the uint3x2 is equal to a given uint3x2, false otherwise. + public override bool Equals(object o) { return Equals((uint3x2)o); } + + + /// Returns a hash code for the uint3x2. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override int GetHashCode() { return (int)math.hash(this); } + + + /// Returns a string representation of the uint3x2. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override string ToString() + { + return string.Format("uint3x2({0}, {1}, {2}, {3}, {4}, {5})", c0.x, c1.x, c0.y, c1.y, c0.z, c1.z); + } + + /// Returns a string representation of the uint3x2 using a specified format and culture-specific format information. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public string ToString(string format, IFormatProvider formatProvider) + { + return string.Format("uint3x2({0}, {1}, {2}, {3}, {4}, {5})", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider), c0.z.ToString(format, formatProvider), c1.z.ToString(format, formatProvider)); + } + + } + + public static partial class math + { + /// Returns a uint3x2 matrix constructed from two uint3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x2 uint3x2(uint3 c0, uint3 c1) { return new uint3x2(c0, c1); } + + /// Returns a uint3x2 matrix constructed from from 6 uint values given in row-major order. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x2 uint3x2(uint m00, uint m01, + uint m10, uint m11, + uint m20, uint m21) + { + return new uint3x2(m00, m01, + m10, m11, + m20, m21); + } + + /// Returns a uint3x2 matrix constructed from a single uint value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x2 uint3x2(uint v) { return new uint3x2(v); } + + /// Returns a uint3x2 matrix constructed from a single bool value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x2 uint3x2(bool v) { return new uint3x2(v); } + + /// Return a uint3x2 matrix constructed from a bool3x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x2 uint3x2(bool3x2 v) { return new uint3x2(v); } + + /// Returns a uint3x2 matrix constructed from a single int value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x2 uint3x2(int v) { return new uint3x2(v); } + + /// Return a uint3x2 matrix constructed from a int3x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x2 uint3x2(int3x2 v) { return new uint3x2(v); } + + /// Returns a uint3x2 matrix constructed from a single float value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x2 uint3x2(float v) { return new uint3x2(v); } + + /// Return a uint3x2 matrix constructed from a float3x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x2 uint3x2(float3x2 v) { return new uint3x2(v); } + + /// Returns a uint3x2 matrix constructed from a single double value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x2 uint3x2(double v) { return new uint3x2(v); } + + /// Return a uint3x2 matrix constructed from a double3x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x2 uint3x2(double3x2 v) { return new uint3x2(v); } + + /// Return the uint2x3 transpose of a uint3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint2x3 transpose(uint3x2 v) + { + return uint2x3( + v.c0.x, v.c0.y, v.c0.z, + v.c1.x, v.c1.y, v.c1.z); + } + + /// Returns a uint hash code of a uint3x2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint hash(uint3x2 v) + { + return csum(v.c0 * uint3(0x515D90F5u, 0xEC9F68F3u, 0xF9EA92D5u) + + v.c1 * uint3(0xC2FAFCB9u, 0x616E9CA1u, 0xC5C5394Bu)) + 0xCAE78587u; + } + + /// + /// Returns a uint3 vector hash code of a uint3x2 vector. + /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash + /// that are only reduced to a narrow uint hash at the very end instead of at every step. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3 hashwide(uint3x2 v) + { + return (v.c0 * uint3(0x7A1541C9u, 0xF83BD927u, 0x6A243BCBu) + + v.c1 * uint3(0x509B84C9u, 0x91D13847u, 0x52F7230Fu)) + 0xCF286E83u; + } + + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/uint3x2.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/uint3x2.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..5edd82cff4a6416bb8ea7e8f97dbe14fc2a417f9 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/uint3x2.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 7b284ac5d8ece4e8cbadac0249c18c4c +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/uint3x3.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/uint3x3.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..f774aabc3d91ab8427c3f6fa08c3bd1ea6b7b058 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/uint3x3.gen.cs @@ -0,0 +1,512 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using System; +using System.Runtime.CompilerServices; + +#pragma warning disable 0660, 0661 + +namespace Unity.Mathematics +{ + [System.Serializable] + public partial struct uint3x3 : System.IEquatable, IFormattable + { + public uint3 c0; + public uint3 c1; + public uint3 c2; + + /// uint3x3 identity transform. + public static readonly uint3x3 identity = new uint3x3(1u, 0u, 0u, 0u, 1u, 0u, 0u, 0u, 1u); + + /// uint3x3 zero value. + public static readonly uint3x3 zero; + + /// Constructs a uint3x3 matrix from three uint3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint3x3(uint3 c0, uint3 c1, uint3 c2) + { + this.c0 = c0; + this.c1 = c1; + this.c2 = c2; + } + + /// Constructs a uint3x3 matrix from 9 uint values given in row-major order. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint3x3(uint m00, uint m01, uint m02, + uint m10, uint m11, uint m12, + uint m20, uint m21, uint m22) + { + this.c0 = new uint3(m00, m10, m20); + this.c1 = new uint3(m01, m11, m21); + this.c2 = new uint3(m02, m12, m22); + } + + /// Constructs a uint3x3 matrix from a single uint value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint3x3(uint v) + { + this.c0 = v; + this.c1 = v; + this.c2 = v; + } + + /// Constructs a uint3x3 matrix from a single bool value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint3x3(bool v) + { + this.c0 = math.select(new uint3(0u), new uint3(1u), v); + this.c1 = math.select(new uint3(0u), new uint3(1u), v); + this.c2 = math.select(new uint3(0u), new uint3(1u), v); + } + + /// Constructs a uint3x3 matrix from a bool3x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint3x3(bool3x3 v) + { + this.c0 = math.select(new uint3(0u), new uint3(1u), v.c0); + this.c1 = math.select(new uint3(0u), new uint3(1u), v.c1); + this.c2 = math.select(new uint3(0u), new uint3(1u), v.c2); + } + + /// Constructs a uint3x3 matrix from a single int value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint3x3(int v) + { + this.c0 = (uint3)v; + this.c1 = (uint3)v; + this.c2 = (uint3)v; + } + + /// Constructs a uint3x3 matrix from a int3x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint3x3(int3x3 v) + { + this.c0 = (uint3)v.c0; + this.c1 = (uint3)v.c1; + this.c2 = (uint3)v.c2; + } + + /// Constructs a uint3x3 matrix from a single float value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint3x3(float v) + { + this.c0 = (uint3)v; + this.c1 = (uint3)v; + this.c2 = (uint3)v; + } + + /// Constructs a uint3x3 matrix from a float3x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint3x3(float3x3 v) + { + this.c0 = (uint3)v.c0; + this.c1 = (uint3)v.c1; + this.c2 = (uint3)v.c2; + } + + /// Constructs a uint3x3 matrix from a single double value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint3x3(double v) + { + this.c0 = (uint3)v; + this.c1 = (uint3)v; + this.c2 = (uint3)v; + } + + /// Constructs a uint3x3 matrix from a double3x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint3x3(double3x3 v) + { + this.c0 = (uint3)v.c0; + this.c1 = (uint3)v.c1; + this.c2 = (uint3)v.c2; + } + + + /// Implicitly converts a single uint value to a uint3x3 matrix by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator uint3x3(uint v) { return new uint3x3(v); } + + /// Explicitly converts a single bool value to a uint3x3 matrix by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint3x3(bool v) { return new uint3x3(v); } + + /// Explicitly converts a bool3x3 matrix to a uint3x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint3x3(bool3x3 v) { return new uint3x3(v); } + + /// Explicitly converts a single int value to a uint3x3 matrix by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint3x3(int v) { return new uint3x3(v); } + + /// Explicitly converts a int3x3 matrix to a uint3x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint3x3(int3x3 v) { return new uint3x3(v); } + + /// Explicitly converts a single float value to a uint3x3 matrix by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint3x3(float v) { return new uint3x3(v); } + + /// Explicitly converts a float3x3 matrix to a uint3x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint3x3(float3x3 v) { return new uint3x3(v); } + + /// Explicitly converts a single double value to a uint3x3 matrix by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint3x3(double v) { return new uint3x3(v); } + + /// Explicitly converts a double3x3 matrix to a uint3x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint3x3(double3x3 v) { return new uint3x3(v); } + + + /// Returns the result of a componentwise multiplication operation on two uint3x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x3 operator * (uint3x3 lhs, uint3x3 rhs) { return new uint3x3 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1, lhs.c2 * rhs.c2); } + + /// Returns the result of a componentwise multiplication operation on a uint3x3 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x3 operator * (uint3x3 lhs, uint rhs) { return new uint3x3 (lhs.c0 * rhs, lhs.c1 * rhs, lhs.c2 * rhs); } + + /// Returns the result of a componentwise multiplication operation on a uint value and a uint3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x3 operator * (uint lhs, uint3x3 rhs) { return new uint3x3 (lhs * rhs.c0, lhs * rhs.c1, lhs * rhs.c2); } + + + /// Returns the result of a componentwise addition operation on two uint3x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x3 operator + (uint3x3 lhs, uint3x3 rhs) { return new uint3x3 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1, lhs.c2 + rhs.c2); } + + /// Returns the result of a componentwise addition operation on a uint3x3 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x3 operator + (uint3x3 lhs, uint rhs) { return new uint3x3 (lhs.c0 + rhs, lhs.c1 + rhs, lhs.c2 + rhs); } + + /// Returns the result of a componentwise addition operation on a uint value and a uint3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x3 operator + (uint lhs, uint3x3 rhs) { return new uint3x3 (lhs + rhs.c0, lhs + rhs.c1, lhs + rhs.c2); } + + + /// Returns the result of a componentwise subtraction operation on two uint3x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x3 operator - (uint3x3 lhs, uint3x3 rhs) { return new uint3x3 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1, lhs.c2 - rhs.c2); } + + /// Returns the result of a componentwise subtraction operation on a uint3x3 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x3 operator - (uint3x3 lhs, uint rhs) { return new uint3x3 (lhs.c0 - rhs, lhs.c1 - rhs, lhs.c2 - rhs); } + + /// Returns the result of a componentwise subtraction operation on a uint value and a uint3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x3 operator - (uint lhs, uint3x3 rhs) { return new uint3x3 (lhs - rhs.c0, lhs - rhs.c1, lhs - rhs.c2); } + + + /// Returns the result of a componentwise division operation on two uint3x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x3 operator / (uint3x3 lhs, uint3x3 rhs) { return new uint3x3 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1, lhs.c2 / rhs.c2); } + + /// Returns the result of a componentwise division operation on a uint3x3 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x3 operator / (uint3x3 lhs, uint rhs) { return new uint3x3 (lhs.c0 / rhs, lhs.c1 / rhs, lhs.c2 / rhs); } + + /// Returns the result of a componentwise division operation on a uint value and a uint3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x3 operator / (uint lhs, uint3x3 rhs) { return new uint3x3 (lhs / rhs.c0, lhs / rhs.c1, lhs / rhs.c2); } + + + /// Returns the result of a componentwise modulus operation on two uint3x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x3 operator % (uint3x3 lhs, uint3x3 rhs) { return new uint3x3 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1, lhs.c2 % rhs.c2); } + + /// Returns the result of a componentwise modulus operation on a uint3x3 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x3 operator % (uint3x3 lhs, uint rhs) { return new uint3x3 (lhs.c0 % rhs, lhs.c1 % rhs, lhs.c2 % rhs); } + + /// Returns the result of a componentwise modulus operation on a uint value and a uint3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x3 operator % (uint lhs, uint3x3 rhs) { return new uint3x3 (lhs % rhs.c0, lhs % rhs.c1, lhs % rhs.c2); } + + + /// Returns the result of a componentwise increment operation on a uint3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x3 operator ++ (uint3x3 val) { return new uint3x3 (++val.c0, ++val.c1, ++val.c2); } + + + /// Returns the result of a componentwise decrement operation on a uint3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x3 operator -- (uint3x3 val) { return new uint3x3 (--val.c0, --val.c1, --val.c2); } + + + /// Returns the result of a componentwise less than operation on two uint3x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator < (uint3x3 lhs, uint3x3 rhs) { return new bool3x3 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1, lhs.c2 < rhs.c2); } + + /// Returns the result of a componentwise less than operation on a uint3x3 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator < (uint3x3 lhs, uint rhs) { return new bool3x3 (lhs.c0 < rhs, lhs.c1 < rhs, lhs.c2 < rhs); } + + /// Returns the result of a componentwise less than operation on a uint value and a uint3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator < (uint lhs, uint3x3 rhs) { return new bool3x3 (lhs < rhs.c0, lhs < rhs.c1, lhs < rhs.c2); } + + + /// Returns the result of a componentwise less or equal operation on two uint3x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator <= (uint3x3 lhs, uint3x3 rhs) { return new bool3x3 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1, lhs.c2 <= rhs.c2); } + + /// Returns the result of a componentwise less or equal operation on a uint3x3 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator <= (uint3x3 lhs, uint rhs) { return new bool3x3 (lhs.c0 <= rhs, lhs.c1 <= rhs, lhs.c2 <= rhs); } + + /// Returns the result of a componentwise less or equal operation on a uint value and a uint3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator <= (uint lhs, uint3x3 rhs) { return new bool3x3 (lhs <= rhs.c0, lhs <= rhs.c1, lhs <= rhs.c2); } + + + /// Returns the result of a componentwise greater than operation on two uint3x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator > (uint3x3 lhs, uint3x3 rhs) { return new bool3x3 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1, lhs.c2 > rhs.c2); } + + /// Returns the result of a componentwise greater than operation on a uint3x3 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator > (uint3x3 lhs, uint rhs) { return new bool3x3 (lhs.c0 > rhs, lhs.c1 > rhs, lhs.c2 > rhs); } + + /// Returns the result of a componentwise greater than operation on a uint value and a uint3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator > (uint lhs, uint3x3 rhs) { return new bool3x3 (lhs > rhs.c0, lhs > rhs.c1, lhs > rhs.c2); } + + + /// Returns the result of a componentwise greater or equal operation on two uint3x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator >= (uint3x3 lhs, uint3x3 rhs) { return new bool3x3 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1, lhs.c2 >= rhs.c2); } + + /// Returns the result of a componentwise greater or equal operation on a uint3x3 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator >= (uint3x3 lhs, uint rhs) { return new bool3x3 (lhs.c0 >= rhs, lhs.c1 >= rhs, lhs.c2 >= rhs); } + + /// Returns the result of a componentwise greater or equal operation on a uint value and a uint3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator >= (uint lhs, uint3x3 rhs) { return new bool3x3 (lhs >= rhs.c0, lhs >= rhs.c1, lhs >= rhs.c2); } + + + /// Returns the result of a componentwise unary minus operation on a uint3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x3 operator - (uint3x3 val) { return new uint3x3 (-val.c0, -val.c1, -val.c2); } + + + /// Returns the result of a componentwise unary plus operation on a uint3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x3 operator + (uint3x3 val) { return new uint3x3 (+val.c0, +val.c1, +val.c2); } + + + /// Returns the result of a componentwise left shift operation on a uint3x3 matrix by a number of bits specified by a single int. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x3 operator << (uint3x3 x, int n) { return new uint3x3 (x.c0 << n, x.c1 << n, x.c2 << n); } + + /// Returns the result of a componentwise right shift operation on a uint3x3 matrix by a number of bits specified by a single int. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x3 operator >> (uint3x3 x, int n) { return new uint3x3 (x.c0 >> n, x.c1 >> n, x.c2 >> n); } + + /// Returns the result of a componentwise equality operation on two uint3x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator == (uint3x3 lhs, uint3x3 rhs) { return new bool3x3 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1, lhs.c2 == rhs.c2); } + + /// Returns the result of a componentwise equality operation on a uint3x3 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator == (uint3x3 lhs, uint rhs) { return new bool3x3 (lhs.c0 == rhs, lhs.c1 == rhs, lhs.c2 == rhs); } + + /// Returns the result of a componentwise equality operation on a uint value and a uint3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator == (uint lhs, uint3x3 rhs) { return new bool3x3 (lhs == rhs.c0, lhs == rhs.c1, lhs == rhs.c2); } + + + /// Returns the result of a componentwise not equal operation on two uint3x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator != (uint3x3 lhs, uint3x3 rhs) { return new bool3x3 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1, lhs.c2 != rhs.c2); } + + /// Returns the result of a componentwise not equal operation on a uint3x3 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator != (uint3x3 lhs, uint rhs) { return new bool3x3 (lhs.c0 != rhs, lhs.c1 != rhs, lhs.c2 != rhs); } + + /// Returns the result of a componentwise not equal operation on a uint value and a uint3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator != (uint lhs, uint3x3 rhs) { return new bool3x3 (lhs != rhs.c0, lhs != rhs.c1, lhs != rhs.c2); } + + + /// Returns the result of a componentwise bitwise not operation on a uint3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x3 operator ~ (uint3x3 val) { return new uint3x3 (~val.c0, ~val.c1, ~val.c2); } + + + /// Returns the result of a componentwise bitwise and operation on two uint3x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x3 operator & (uint3x3 lhs, uint3x3 rhs) { return new uint3x3 (lhs.c0 & rhs.c0, lhs.c1 & rhs.c1, lhs.c2 & rhs.c2); } + + /// Returns the result of a componentwise bitwise and operation on a uint3x3 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x3 operator & (uint3x3 lhs, uint rhs) { return new uint3x3 (lhs.c0 & rhs, lhs.c1 & rhs, lhs.c2 & rhs); } + + /// Returns the result of a componentwise bitwise and operation on a uint value and a uint3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x3 operator & (uint lhs, uint3x3 rhs) { return new uint3x3 (lhs & rhs.c0, lhs & rhs.c1, lhs & rhs.c2); } + + + /// Returns the result of a componentwise bitwise or operation on two uint3x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x3 operator | (uint3x3 lhs, uint3x3 rhs) { return new uint3x3 (lhs.c0 | rhs.c0, lhs.c1 | rhs.c1, lhs.c2 | rhs.c2); } + + /// Returns the result of a componentwise bitwise or operation on a uint3x3 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x3 operator | (uint3x3 lhs, uint rhs) { return new uint3x3 (lhs.c0 | rhs, lhs.c1 | rhs, lhs.c2 | rhs); } + + /// Returns the result of a componentwise bitwise or operation on a uint value and a uint3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x3 operator | (uint lhs, uint3x3 rhs) { return new uint3x3 (lhs | rhs.c0, lhs | rhs.c1, lhs | rhs.c2); } + + + /// Returns the result of a componentwise bitwise exclusive or operation on two uint3x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x3 operator ^ (uint3x3 lhs, uint3x3 rhs) { return new uint3x3 (lhs.c0 ^ rhs.c0, lhs.c1 ^ rhs.c1, lhs.c2 ^ rhs.c2); } + + /// Returns the result of a componentwise bitwise exclusive or operation on a uint3x3 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x3 operator ^ (uint3x3 lhs, uint rhs) { return new uint3x3 (lhs.c0 ^ rhs, lhs.c1 ^ rhs, lhs.c2 ^ rhs); } + + /// Returns the result of a componentwise bitwise exclusive or operation on a uint value and a uint3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x3 operator ^ (uint lhs, uint3x3 rhs) { return new uint3x3 (lhs ^ rhs.c0, lhs ^ rhs.c1, lhs ^ rhs.c2); } + + + + /// Returns the uint3 element at a specified index. + unsafe public ref uint3 this[int index] + { + get + { +#if ENABLE_UNITY_COLLECTIONS_CHECKS + if ((uint)index >= 3) + throw new System.ArgumentException("index must be between[0...2]"); +#endif + fixed (uint3x3* array = &this) { return ref ((uint3*)array)[index]; } + } + } + + /// Returns true if the uint3x3 is equal to a given uint3x3, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool Equals(uint3x3 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1) && c2.Equals(rhs.c2); } + + /// Returns true if the uint3x3 is equal to a given uint3x3, false otherwise. + public override bool Equals(object o) { return Equals((uint3x3)o); } + + + /// Returns a hash code for the uint3x3. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override int GetHashCode() { return (int)math.hash(this); } + + + /// Returns a string representation of the uint3x3. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override string ToString() + { + return string.Format("uint3x3({0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8})", c0.x, c1.x, c2.x, c0.y, c1.y, c2.y, c0.z, c1.z, c2.z); + } + + /// Returns a string representation of the uint3x3 using a specified format and culture-specific format information. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public string ToString(string format, IFormatProvider formatProvider) + { + return string.Format("uint3x3({0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8})", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c2.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider), c2.y.ToString(format, formatProvider), c0.z.ToString(format, formatProvider), c1.z.ToString(format, formatProvider), c2.z.ToString(format, formatProvider)); + } + + } + + public static partial class math + { + /// Returns a uint3x3 matrix constructed from three uint3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x3 uint3x3(uint3 c0, uint3 c1, uint3 c2) { return new uint3x3(c0, c1, c2); } + + /// Returns a uint3x3 matrix constructed from from 9 uint values given in row-major order. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x3 uint3x3(uint m00, uint m01, uint m02, + uint m10, uint m11, uint m12, + uint m20, uint m21, uint m22) + { + return new uint3x3(m00, m01, m02, + m10, m11, m12, + m20, m21, m22); + } + + /// Returns a uint3x3 matrix constructed from a single uint value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x3 uint3x3(uint v) { return new uint3x3(v); } + + /// Returns a uint3x3 matrix constructed from a single bool value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x3 uint3x3(bool v) { return new uint3x3(v); } + + /// Return a uint3x3 matrix constructed from a bool3x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x3 uint3x3(bool3x3 v) { return new uint3x3(v); } + + /// Returns a uint3x3 matrix constructed from a single int value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x3 uint3x3(int v) { return new uint3x3(v); } + + /// Return a uint3x3 matrix constructed from a int3x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x3 uint3x3(int3x3 v) { return new uint3x3(v); } + + /// Returns a uint3x3 matrix constructed from a single float value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x3 uint3x3(float v) { return new uint3x3(v); } + + /// Return a uint3x3 matrix constructed from a float3x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x3 uint3x3(float3x3 v) { return new uint3x3(v); } + + /// Returns a uint3x3 matrix constructed from a single double value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x3 uint3x3(double v) { return new uint3x3(v); } + + /// Return a uint3x3 matrix constructed from a double3x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x3 uint3x3(double3x3 v) { return new uint3x3(v); } + + /// Return the uint3x3 transpose of a uint3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x3 transpose(uint3x3 v) + { + return uint3x3( + v.c0.x, v.c0.y, v.c0.z, + v.c1.x, v.c1.y, v.c1.z, + v.c2.x, v.c2.y, v.c2.z); + } + + /// Returns a uint hash code of a uint3x3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint hash(uint3x3 v) + { + return csum(v.c0 * uint3(0xAC60D0C3u, 0x9263662Fu, 0xE69626FFu) + + v.c1 * uint3(0xBD010EEBu, 0x9CEDE1D1u, 0x43BE0B51u) + + v.c2 * uint3(0xAF836EE1u, 0xB130C137u, 0x54834775u)) + 0x7C022221u; + } + + /// + /// Returns a uint3 vector hash code of a uint3x3 vector. + /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash + /// that are only reduced to a narrow uint hash at the very end instead of at every step. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3 hashwide(uint3x3 v) + { + return (v.c0 * uint3(0xA2D00EDFu, 0xA8977779u, 0x9F1C739Bu) + + v.c1 * uint3(0x4B1BD187u, 0x9DF50593u, 0xF18EEB85u) + + v.c2 * uint3(0x9E19BFC3u, 0x8196B06Fu, 0xD24EFA19u)) + 0x7D8048BBu; + } + + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/uint3x3.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/uint3x3.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..a6e8de23225dc7ebdbd0f4eef6f25f53d03dd930 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/uint3x3.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: c1262616ca00349c28426545d8525266 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/uint3x4.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/uint3x4.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..222079654841165ba0fd885385936749f014f36d --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/uint3x4.gen.cs @@ -0,0 +1,524 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using System; +using System.Runtime.CompilerServices; + +#pragma warning disable 0660, 0661 + +namespace Unity.Mathematics +{ + [System.Serializable] + public partial struct uint3x4 : System.IEquatable, IFormattable + { + public uint3 c0; + public uint3 c1; + public uint3 c2; + public uint3 c3; + + /// uint3x4 zero value. + public static readonly uint3x4 zero; + + /// Constructs a uint3x4 matrix from four uint3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint3x4(uint3 c0, uint3 c1, uint3 c2, uint3 c3) + { + this.c0 = c0; + this.c1 = c1; + this.c2 = c2; + this.c3 = c3; + } + + /// Constructs a uint3x4 matrix from 12 uint values given in row-major order. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint3x4(uint m00, uint m01, uint m02, uint m03, + uint m10, uint m11, uint m12, uint m13, + uint m20, uint m21, uint m22, uint m23) + { + this.c0 = new uint3(m00, m10, m20); + this.c1 = new uint3(m01, m11, m21); + this.c2 = new uint3(m02, m12, m22); + this.c3 = new uint3(m03, m13, m23); + } + + /// Constructs a uint3x4 matrix from a single uint value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint3x4(uint v) + { + this.c0 = v; + this.c1 = v; + this.c2 = v; + this.c3 = v; + } + + /// Constructs a uint3x4 matrix from a single bool value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint3x4(bool v) + { + this.c0 = math.select(new uint3(0u), new uint3(1u), v); + this.c1 = math.select(new uint3(0u), new uint3(1u), v); + this.c2 = math.select(new uint3(0u), new uint3(1u), v); + this.c3 = math.select(new uint3(0u), new uint3(1u), v); + } + + /// Constructs a uint3x4 matrix from a bool3x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint3x4(bool3x4 v) + { + this.c0 = math.select(new uint3(0u), new uint3(1u), v.c0); + this.c1 = math.select(new uint3(0u), new uint3(1u), v.c1); + this.c2 = math.select(new uint3(0u), new uint3(1u), v.c2); + this.c3 = math.select(new uint3(0u), new uint3(1u), v.c3); + } + + /// Constructs a uint3x4 matrix from a single int value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint3x4(int v) + { + this.c0 = (uint3)v; + this.c1 = (uint3)v; + this.c2 = (uint3)v; + this.c3 = (uint3)v; + } + + /// Constructs a uint3x4 matrix from a int3x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint3x4(int3x4 v) + { + this.c0 = (uint3)v.c0; + this.c1 = (uint3)v.c1; + this.c2 = (uint3)v.c2; + this.c3 = (uint3)v.c3; + } + + /// Constructs a uint3x4 matrix from a single float value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint3x4(float v) + { + this.c0 = (uint3)v; + this.c1 = (uint3)v; + this.c2 = (uint3)v; + this.c3 = (uint3)v; + } + + /// Constructs a uint3x4 matrix from a float3x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint3x4(float3x4 v) + { + this.c0 = (uint3)v.c0; + this.c1 = (uint3)v.c1; + this.c2 = (uint3)v.c2; + this.c3 = (uint3)v.c3; + } + + /// Constructs a uint3x4 matrix from a single double value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint3x4(double v) + { + this.c0 = (uint3)v; + this.c1 = (uint3)v; + this.c2 = (uint3)v; + this.c3 = (uint3)v; + } + + /// Constructs a uint3x4 matrix from a double3x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint3x4(double3x4 v) + { + this.c0 = (uint3)v.c0; + this.c1 = (uint3)v.c1; + this.c2 = (uint3)v.c2; + this.c3 = (uint3)v.c3; + } + + + /// Implicitly converts a single uint value to a uint3x4 matrix by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator uint3x4(uint v) { return new uint3x4(v); } + + /// Explicitly converts a single bool value to a uint3x4 matrix by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint3x4(bool v) { return new uint3x4(v); } + + /// Explicitly converts a bool3x4 matrix to a uint3x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint3x4(bool3x4 v) { return new uint3x4(v); } + + /// Explicitly converts a single int value to a uint3x4 matrix by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint3x4(int v) { return new uint3x4(v); } + + /// Explicitly converts a int3x4 matrix to a uint3x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint3x4(int3x4 v) { return new uint3x4(v); } + + /// Explicitly converts a single float value to a uint3x4 matrix by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint3x4(float v) { return new uint3x4(v); } + + /// Explicitly converts a float3x4 matrix to a uint3x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint3x4(float3x4 v) { return new uint3x4(v); } + + /// Explicitly converts a single double value to a uint3x4 matrix by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint3x4(double v) { return new uint3x4(v); } + + /// Explicitly converts a double3x4 matrix to a uint3x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint3x4(double3x4 v) { return new uint3x4(v); } + + + /// Returns the result of a componentwise multiplication operation on two uint3x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x4 operator * (uint3x4 lhs, uint3x4 rhs) { return new uint3x4 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1, lhs.c2 * rhs.c2, lhs.c3 * rhs.c3); } + + /// Returns the result of a componentwise multiplication operation on a uint3x4 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x4 operator * (uint3x4 lhs, uint rhs) { return new uint3x4 (lhs.c0 * rhs, lhs.c1 * rhs, lhs.c2 * rhs, lhs.c3 * rhs); } + + /// Returns the result of a componentwise multiplication operation on a uint value and a uint3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x4 operator * (uint lhs, uint3x4 rhs) { return new uint3x4 (lhs * rhs.c0, lhs * rhs.c1, lhs * rhs.c2, lhs * rhs.c3); } + + + /// Returns the result of a componentwise addition operation on two uint3x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x4 operator + (uint3x4 lhs, uint3x4 rhs) { return new uint3x4 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1, lhs.c2 + rhs.c2, lhs.c3 + rhs.c3); } + + /// Returns the result of a componentwise addition operation on a uint3x4 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x4 operator + (uint3x4 lhs, uint rhs) { return new uint3x4 (lhs.c0 + rhs, lhs.c1 + rhs, lhs.c2 + rhs, lhs.c3 + rhs); } + + /// Returns the result of a componentwise addition operation on a uint value and a uint3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x4 operator + (uint lhs, uint3x4 rhs) { return new uint3x4 (lhs + rhs.c0, lhs + rhs.c1, lhs + rhs.c2, lhs + rhs.c3); } + + + /// Returns the result of a componentwise subtraction operation on two uint3x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x4 operator - (uint3x4 lhs, uint3x4 rhs) { return new uint3x4 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1, lhs.c2 - rhs.c2, lhs.c3 - rhs.c3); } + + /// Returns the result of a componentwise subtraction operation on a uint3x4 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x4 operator - (uint3x4 lhs, uint rhs) { return new uint3x4 (lhs.c0 - rhs, lhs.c1 - rhs, lhs.c2 - rhs, lhs.c3 - rhs); } + + /// Returns the result of a componentwise subtraction operation on a uint value and a uint3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x4 operator - (uint lhs, uint3x4 rhs) { return new uint3x4 (lhs - rhs.c0, lhs - rhs.c1, lhs - rhs.c2, lhs - rhs.c3); } + + + /// Returns the result of a componentwise division operation on two uint3x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x4 operator / (uint3x4 lhs, uint3x4 rhs) { return new uint3x4 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1, lhs.c2 / rhs.c2, lhs.c3 / rhs.c3); } + + /// Returns the result of a componentwise division operation on a uint3x4 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x4 operator / (uint3x4 lhs, uint rhs) { return new uint3x4 (lhs.c0 / rhs, lhs.c1 / rhs, lhs.c2 / rhs, lhs.c3 / rhs); } + + /// Returns the result of a componentwise division operation on a uint value and a uint3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x4 operator / (uint lhs, uint3x4 rhs) { return new uint3x4 (lhs / rhs.c0, lhs / rhs.c1, lhs / rhs.c2, lhs / rhs.c3); } + + + /// Returns the result of a componentwise modulus operation on two uint3x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x4 operator % (uint3x4 lhs, uint3x4 rhs) { return new uint3x4 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1, lhs.c2 % rhs.c2, lhs.c3 % rhs.c3); } + + /// Returns the result of a componentwise modulus operation on a uint3x4 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x4 operator % (uint3x4 lhs, uint rhs) { return new uint3x4 (lhs.c0 % rhs, lhs.c1 % rhs, lhs.c2 % rhs, lhs.c3 % rhs); } + + /// Returns the result of a componentwise modulus operation on a uint value and a uint3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x4 operator % (uint lhs, uint3x4 rhs) { return new uint3x4 (lhs % rhs.c0, lhs % rhs.c1, lhs % rhs.c2, lhs % rhs.c3); } + + + /// Returns the result of a componentwise increment operation on a uint3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x4 operator ++ (uint3x4 val) { return new uint3x4 (++val.c0, ++val.c1, ++val.c2, ++val.c3); } + + + /// Returns the result of a componentwise decrement operation on a uint3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x4 operator -- (uint3x4 val) { return new uint3x4 (--val.c0, --val.c1, --val.c2, --val.c3); } + + + /// Returns the result of a componentwise less than operation on two uint3x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator < (uint3x4 lhs, uint3x4 rhs) { return new bool3x4 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1, lhs.c2 < rhs.c2, lhs.c3 < rhs.c3); } + + /// Returns the result of a componentwise less than operation on a uint3x4 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator < (uint3x4 lhs, uint rhs) { return new bool3x4 (lhs.c0 < rhs, lhs.c1 < rhs, lhs.c2 < rhs, lhs.c3 < rhs); } + + /// Returns the result of a componentwise less than operation on a uint value and a uint3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator < (uint lhs, uint3x4 rhs) { return new bool3x4 (lhs < rhs.c0, lhs < rhs.c1, lhs < rhs.c2, lhs < rhs.c3); } + + + /// Returns the result of a componentwise less or equal operation on two uint3x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator <= (uint3x4 lhs, uint3x4 rhs) { return new bool3x4 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1, lhs.c2 <= rhs.c2, lhs.c3 <= rhs.c3); } + + /// Returns the result of a componentwise less or equal operation on a uint3x4 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator <= (uint3x4 lhs, uint rhs) { return new bool3x4 (lhs.c0 <= rhs, lhs.c1 <= rhs, lhs.c2 <= rhs, lhs.c3 <= rhs); } + + /// Returns the result of a componentwise less or equal operation on a uint value and a uint3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator <= (uint lhs, uint3x4 rhs) { return new bool3x4 (lhs <= rhs.c0, lhs <= rhs.c1, lhs <= rhs.c2, lhs <= rhs.c3); } + + + /// Returns the result of a componentwise greater than operation on two uint3x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator > (uint3x4 lhs, uint3x4 rhs) { return new bool3x4 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1, lhs.c2 > rhs.c2, lhs.c3 > rhs.c3); } + + /// Returns the result of a componentwise greater than operation on a uint3x4 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator > (uint3x4 lhs, uint rhs) { return new bool3x4 (lhs.c0 > rhs, lhs.c1 > rhs, lhs.c2 > rhs, lhs.c3 > rhs); } + + /// Returns the result of a componentwise greater than operation on a uint value and a uint3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator > (uint lhs, uint3x4 rhs) { return new bool3x4 (lhs > rhs.c0, lhs > rhs.c1, lhs > rhs.c2, lhs > rhs.c3); } + + + /// Returns the result of a componentwise greater or equal operation on two uint3x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator >= (uint3x4 lhs, uint3x4 rhs) { return new bool3x4 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1, lhs.c2 >= rhs.c2, lhs.c3 >= rhs.c3); } + + /// Returns the result of a componentwise greater or equal operation on a uint3x4 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator >= (uint3x4 lhs, uint rhs) { return new bool3x4 (lhs.c0 >= rhs, lhs.c1 >= rhs, lhs.c2 >= rhs, lhs.c3 >= rhs); } + + /// Returns the result of a componentwise greater or equal operation on a uint value and a uint3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator >= (uint lhs, uint3x4 rhs) { return new bool3x4 (lhs >= rhs.c0, lhs >= rhs.c1, lhs >= rhs.c2, lhs >= rhs.c3); } + + + /// Returns the result of a componentwise unary minus operation on a uint3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x4 operator - (uint3x4 val) { return new uint3x4 (-val.c0, -val.c1, -val.c2, -val.c3); } + + + /// Returns the result of a componentwise unary plus operation on a uint3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x4 operator + (uint3x4 val) { return new uint3x4 (+val.c0, +val.c1, +val.c2, +val.c3); } + + + /// Returns the result of a componentwise left shift operation on a uint3x4 matrix by a number of bits specified by a single int. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x4 operator << (uint3x4 x, int n) { return new uint3x4 (x.c0 << n, x.c1 << n, x.c2 << n, x.c3 << n); } + + /// Returns the result of a componentwise right shift operation on a uint3x4 matrix by a number of bits specified by a single int. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x4 operator >> (uint3x4 x, int n) { return new uint3x4 (x.c0 >> n, x.c1 >> n, x.c2 >> n, x.c3 >> n); } + + /// Returns the result of a componentwise equality operation on two uint3x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator == (uint3x4 lhs, uint3x4 rhs) { return new bool3x4 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1, lhs.c2 == rhs.c2, lhs.c3 == rhs.c3); } + + /// Returns the result of a componentwise equality operation on a uint3x4 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator == (uint3x4 lhs, uint rhs) { return new bool3x4 (lhs.c0 == rhs, lhs.c1 == rhs, lhs.c2 == rhs, lhs.c3 == rhs); } + + /// Returns the result of a componentwise equality operation on a uint value and a uint3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator == (uint lhs, uint3x4 rhs) { return new bool3x4 (lhs == rhs.c0, lhs == rhs.c1, lhs == rhs.c2, lhs == rhs.c3); } + + + /// Returns the result of a componentwise not equal operation on two uint3x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator != (uint3x4 lhs, uint3x4 rhs) { return new bool3x4 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1, lhs.c2 != rhs.c2, lhs.c3 != rhs.c3); } + + /// Returns the result of a componentwise not equal operation on a uint3x4 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator != (uint3x4 lhs, uint rhs) { return new bool3x4 (lhs.c0 != rhs, lhs.c1 != rhs, lhs.c2 != rhs, lhs.c3 != rhs); } + + /// Returns the result of a componentwise not equal operation on a uint value and a uint3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator != (uint lhs, uint3x4 rhs) { return new bool3x4 (lhs != rhs.c0, lhs != rhs.c1, lhs != rhs.c2, lhs != rhs.c3); } + + + /// Returns the result of a componentwise bitwise not operation on a uint3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x4 operator ~ (uint3x4 val) { return new uint3x4 (~val.c0, ~val.c1, ~val.c2, ~val.c3); } + + + /// Returns the result of a componentwise bitwise and operation on two uint3x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x4 operator & (uint3x4 lhs, uint3x4 rhs) { return new uint3x4 (lhs.c0 & rhs.c0, lhs.c1 & rhs.c1, lhs.c2 & rhs.c2, lhs.c3 & rhs.c3); } + + /// Returns the result of a componentwise bitwise and operation on a uint3x4 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x4 operator & (uint3x4 lhs, uint rhs) { return new uint3x4 (lhs.c0 & rhs, lhs.c1 & rhs, lhs.c2 & rhs, lhs.c3 & rhs); } + + /// Returns the result of a componentwise bitwise and operation on a uint value and a uint3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x4 operator & (uint lhs, uint3x4 rhs) { return new uint3x4 (lhs & rhs.c0, lhs & rhs.c1, lhs & rhs.c2, lhs & rhs.c3); } + + + /// Returns the result of a componentwise bitwise or operation on two uint3x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x4 operator | (uint3x4 lhs, uint3x4 rhs) { return new uint3x4 (lhs.c0 | rhs.c0, lhs.c1 | rhs.c1, lhs.c2 | rhs.c2, lhs.c3 | rhs.c3); } + + /// Returns the result of a componentwise bitwise or operation on a uint3x4 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x4 operator | (uint3x4 lhs, uint rhs) { return new uint3x4 (lhs.c0 | rhs, lhs.c1 | rhs, lhs.c2 | rhs, lhs.c3 | rhs); } + + /// Returns the result of a componentwise bitwise or operation on a uint value and a uint3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x4 operator | (uint lhs, uint3x4 rhs) { return new uint3x4 (lhs | rhs.c0, lhs | rhs.c1, lhs | rhs.c2, lhs | rhs.c3); } + + + /// Returns the result of a componentwise bitwise exclusive or operation on two uint3x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x4 operator ^ (uint3x4 lhs, uint3x4 rhs) { return new uint3x4 (lhs.c0 ^ rhs.c0, lhs.c1 ^ rhs.c1, lhs.c2 ^ rhs.c2, lhs.c3 ^ rhs.c3); } + + /// Returns the result of a componentwise bitwise exclusive or operation on a uint3x4 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x4 operator ^ (uint3x4 lhs, uint rhs) { return new uint3x4 (lhs.c0 ^ rhs, lhs.c1 ^ rhs, lhs.c2 ^ rhs, lhs.c3 ^ rhs); } + + /// Returns the result of a componentwise bitwise exclusive or operation on a uint value and a uint3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x4 operator ^ (uint lhs, uint3x4 rhs) { return new uint3x4 (lhs ^ rhs.c0, lhs ^ rhs.c1, lhs ^ rhs.c2, lhs ^ rhs.c3); } + + + + /// Returns the uint3 element at a specified index. + unsafe public ref uint3 this[int index] + { + get + { +#if ENABLE_UNITY_COLLECTIONS_CHECKS + if ((uint)index >= 4) + throw new System.ArgumentException("index must be between[0...3]"); +#endif + fixed (uint3x4* array = &this) { return ref ((uint3*)array)[index]; } + } + } + + /// Returns true if the uint3x4 is equal to a given uint3x4, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool Equals(uint3x4 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1) && c2.Equals(rhs.c2) && c3.Equals(rhs.c3); } + + /// Returns true if the uint3x4 is equal to a given uint3x4, false otherwise. + public override bool Equals(object o) { return Equals((uint3x4)o); } + + + /// Returns a hash code for the uint3x4. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override int GetHashCode() { return (int)math.hash(this); } + + + /// Returns a string representation of the uint3x4. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override string ToString() + { + return string.Format("uint3x4({0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}, {10}, {11})", c0.x, c1.x, c2.x, c3.x, c0.y, c1.y, c2.y, c3.y, c0.z, c1.z, c2.z, c3.z); + } + + /// Returns a string representation of the uint3x4 using a specified format and culture-specific format information. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public string ToString(string format, IFormatProvider formatProvider) + { + return string.Format("uint3x4({0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}, {10}, {11})", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c2.x.ToString(format, formatProvider), c3.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider), c2.y.ToString(format, formatProvider), c3.y.ToString(format, formatProvider), c0.z.ToString(format, formatProvider), c1.z.ToString(format, formatProvider), c2.z.ToString(format, formatProvider), c3.z.ToString(format, formatProvider)); + } + + } + + public static partial class math + { + /// Returns a uint3x4 matrix constructed from four uint3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x4 uint3x4(uint3 c0, uint3 c1, uint3 c2, uint3 c3) { return new uint3x4(c0, c1, c2, c3); } + + /// Returns a uint3x4 matrix constructed from from 12 uint values given in row-major order. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x4 uint3x4(uint m00, uint m01, uint m02, uint m03, + uint m10, uint m11, uint m12, uint m13, + uint m20, uint m21, uint m22, uint m23) + { + return new uint3x4(m00, m01, m02, m03, + m10, m11, m12, m13, + m20, m21, m22, m23); + } + + /// Returns a uint3x4 matrix constructed from a single uint value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x4 uint3x4(uint v) { return new uint3x4(v); } + + /// Returns a uint3x4 matrix constructed from a single bool value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x4 uint3x4(bool v) { return new uint3x4(v); } + + /// Return a uint3x4 matrix constructed from a bool3x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x4 uint3x4(bool3x4 v) { return new uint3x4(v); } + + /// Returns a uint3x4 matrix constructed from a single int value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x4 uint3x4(int v) { return new uint3x4(v); } + + /// Return a uint3x4 matrix constructed from a int3x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x4 uint3x4(int3x4 v) { return new uint3x4(v); } + + /// Returns a uint3x4 matrix constructed from a single float value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x4 uint3x4(float v) { return new uint3x4(v); } + + /// Return a uint3x4 matrix constructed from a float3x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x4 uint3x4(float3x4 v) { return new uint3x4(v); } + + /// Returns a uint3x4 matrix constructed from a single double value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x4 uint3x4(double v) { return new uint3x4(v); } + + /// Return a uint3x4 matrix constructed from a double3x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x4 uint3x4(double3x4 v) { return new uint3x4(v); } + + /// Return the uint4x3 transpose of a uint3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x3 transpose(uint3x4 v) + { + return uint4x3( + v.c0.x, v.c0.y, v.c0.z, + v.c1.x, v.c1.y, v.c1.z, + v.c2.x, v.c2.y, v.c2.z, + v.c3.x, v.c3.y, v.c3.z); + } + + /// Returns a uint hash code of a uint3x4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint hash(uint3x4 v) + { + return csum(v.c0 * uint3(0xD1224537u, 0xE99ED6F3u, 0x48125549u) + + v.c1 * uint3(0xEEE2123Bu, 0xE3AD9FE5u, 0xCE1CF8BFu) + + v.c2 * uint3(0x7BE39F3Bu, 0xFAB9913Fu, 0xB4501269u) + + v.c3 * uint3(0xE04B89FDu, 0xDB3DE101u, 0x7B6D1B4Bu)) + 0x58399E77u; + } + + /// + /// Returns a uint3 vector hash code of a uint3x4 vector. + /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash + /// that are only reduced to a narrow uint hash at the very end instead of at every step. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3 hashwide(uint3x4 v) + { + return (v.c0 * uint3(0x5EAC29C9u, 0xFC6014F9u, 0x6BF6693Fu) + + v.c1 * uint3(0x9D1B1D9Bu, 0xF842F5C1u, 0xA47EC335u) + + v.c2 * uint3(0xA477DF57u, 0xC4B1493Fu, 0xBA0966D3u) + + v.c3 * uint3(0xAFBEE253u, 0x5B419C01u, 0x515D90F5u)) + 0xEC9F68F3u; + } + + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/uint3x4.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/uint3x4.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..e331fbd59f579cbdb553019263c14d78c8bed8eb --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/uint3x4.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: b26cb334c782240eb950a56e23e0378c +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/uint4.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/uint4.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..100200ca30a20f01f18983d84c7b9cc5e4043694 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/uint4.gen.cs @@ -0,0 +1,3480 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using System; +using System.Runtime.CompilerServices; +using System.Diagnostics; + +#pragma warning disable 0660, 0661 + +namespace Unity.Mathematics +{ + [DebuggerTypeProxy(typeof(uint4.DebuggerProxy))] + [System.Serializable] + public partial struct uint4 : System.IEquatable, IFormattable + { + public uint x; + public uint y; + public uint z; + public uint w; + + /// uint4 zero value. + public static readonly uint4 zero; + + /// Constructs a uint4 vector from four uint values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4(uint x, uint y, uint z, uint w) + { + this.x = x; + this.y = y; + this.z = z; + this.w = w; + } + + /// Constructs a uint4 vector from two uint values and a uint2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4(uint x, uint y, uint2 zw) + { + this.x = x; + this.y = y; + this.z = zw.x; + this.w = zw.y; + } + + /// Constructs a uint4 vector from a uint value, a uint2 vector and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4(uint x, uint2 yz, uint w) + { + this.x = x; + this.y = yz.x; + this.z = yz.y; + this.w = w; + } + + /// Constructs a uint4 vector from a uint value and a uint3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4(uint x, uint3 yzw) + { + this.x = x; + this.y = yzw.x; + this.z = yzw.y; + this.w = yzw.z; + } + + /// Constructs a uint4 vector from a uint2 vector and two uint values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4(uint2 xy, uint z, uint w) + { + this.x = xy.x; + this.y = xy.y; + this.z = z; + this.w = w; + } + + /// Constructs a uint4 vector from two uint2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4(uint2 xy, uint2 zw) + { + this.x = xy.x; + this.y = xy.y; + this.z = zw.x; + this.w = zw.y; + } + + /// Constructs a uint4 vector from a uint3 vector and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4(uint3 xyz, uint w) + { + this.x = xyz.x; + this.y = xyz.y; + this.z = xyz.z; + this.w = w; + } + + /// Constructs a uint4 vector from a uint4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4(uint4 xyzw) + { + this.x = xyzw.x; + this.y = xyzw.y; + this.z = xyzw.z; + this.w = xyzw.w; + } + + /// Constructs a uint4 vector from a single uint value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4(uint v) + { + this.x = v; + this.y = v; + this.z = v; + this.w = v; + } + + /// Constructs a uint4 vector from a single bool value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4(bool v) + { + this.x = v ? 1u : 0u; + this.y = v ? 1u : 0u; + this.z = v ? 1u : 0u; + this.w = v ? 1u : 0u; + } + + /// Constructs a uint4 vector from a bool4 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4(bool4 v) + { + this.x = v.x ? 1u : 0u; + this.y = v.y ? 1u : 0u; + this.z = v.z ? 1u : 0u; + this.w = v.w ? 1u : 0u; + } + + /// Constructs a uint4 vector from a single int value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4(int v) + { + this.x = (uint)v; + this.y = (uint)v; + this.z = (uint)v; + this.w = (uint)v; + } + + /// Constructs a uint4 vector from a int4 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4(int4 v) + { + this.x = (uint)v.x; + this.y = (uint)v.y; + this.z = (uint)v.z; + this.w = (uint)v.w; + } + + /// Constructs a uint4 vector from a single float value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4(float v) + { + this.x = (uint)v; + this.y = (uint)v; + this.z = (uint)v; + this.w = (uint)v; + } + + /// Constructs a uint4 vector from a float4 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4(float4 v) + { + this.x = (uint)v.x; + this.y = (uint)v.y; + this.z = (uint)v.z; + this.w = (uint)v.w; + } + + /// Constructs a uint4 vector from a single double value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4(double v) + { + this.x = (uint)v; + this.y = (uint)v; + this.z = (uint)v; + this.w = (uint)v; + } + + /// Constructs a uint4 vector from a double4 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4(double4 v) + { + this.x = (uint)v.x; + this.y = (uint)v.y; + this.z = (uint)v.z; + this.w = (uint)v.w; + } + + + /// Implicitly converts a single uint value to a uint4 vector by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator uint4(uint v) { return new uint4(v); } + + /// Explicitly converts a single bool value to a uint4 vector by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint4(bool v) { return new uint4(v); } + + /// Explicitly converts a bool4 vector to a uint4 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint4(bool4 v) { return new uint4(v); } + + /// Explicitly converts a single int value to a uint4 vector by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint4(int v) { return new uint4(v); } + + /// Explicitly converts a int4 vector to a uint4 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint4(int4 v) { return new uint4(v); } + + /// Explicitly converts a single float value to a uint4 vector by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint4(float v) { return new uint4(v); } + + /// Explicitly converts a float4 vector to a uint4 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint4(float4 v) { return new uint4(v); } + + /// Explicitly converts a single double value to a uint4 vector by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint4(double v) { return new uint4(v); } + + /// Explicitly converts a double4 vector to a uint4 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint4(double4 v) { return new uint4(v); } + + + /// Returns the result of a componentwise multiplication operation on two uint4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 operator * (uint4 lhs, uint4 rhs) { return new uint4 (lhs.x * rhs.x, lhs.y * rhs.y, lhs.z * rhs.z, lhs.w * rhs.w); } + + /// Returns the result of a componentwise multiplication operation on a uint4 vector and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 operator * (uint4 lhs, uint rhs) { return new uint4 (lhs.x * rhs, lhs.y * rhs, lhs.z * rhs, lhs.w * rhs); } + + /// Returns the result of a componentwise multiplication operation on a uint value and a uint4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 operator * (uint lhs, uint4 rhs) { return new uint4 (lhs * rhs.x, lhs * rhs.y, lhs * rhs.z, lhs * rhs.w); } + + + /// Returns the result of a componentwise addition operation on two uint4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 operator + (uint4 lhs, uint4 rhs) { return new uint4 (lhs.x + rhs.x, lhs.y + rhs.y, lhs.z + rhs.z, lhs.w + rhs.w); } + + /// Returns the result of a componentwise addition operation on a uint4 vector and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 operator + (uint4 lhs, uint rhs) { return new uint4 (lhs.x + rhs, lhs.y + rhs, lhs.z + rhs, lhs.w + rhs); } + + /// Returns the result of a componentwise addition operation on a uint value and a uint4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 operator + (uint lhs, uint4 rhs) { return new uint4 (lhs + rhs.x, lhs + rhs.y, lhs + rhs.z, lhs + rhs.w); } + + + /// Returns the result of a componentwise subtraction operation on two uint4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 operator - (uint4 lhs, uint4 rhs) { return new uint4 (lhs.x - rhs.x, lhs.y - rhs.y, lhs.z - rhs.z, lhs.w - rhs.w); } + + /// Returns the result of a componentwise subtraction operation on a uint4 vector and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 operator - (uint4 lhs, uint rhs) { return new uint4 (lhs.x - rhs, lhs.y - rhs, lhs.z - rhs, lhs.w - rhs); } + + /// Returns the result of a componentwise subtraction operation on a uint value and a uint4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 operator - (uint lhs, uint4 rhs) { return new uint4 (lhs - rhs.x, lhs - rhs.y, lhs - rhs.z, lhs - rhs.w); } + + + /// Returns the result of a componentwise division operation on two uint4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 operator / (uint4 lhs, uint4 rhs) { return new uint4 (lhs.x / rhs.x, lhs.y / rhs.y, lhs.z / rhs.z, lhs.w / rhs.w); } + + /// Returns the result of a componentwise division operation on a uint4 vector and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 operator / (uint4 lhs, uint rhs) { return new uint4 (lhs.x / rhs, lhs.y / rhs, lhs.z / rhs, lhs.w / rhs); } + + /// Returns the result of a componentwise division operation on a uint value and a uint4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 operator / (uint lhs, uint4 rhs) { return new uint4 (lhs / rhs.x, lhs / rhs.y, lhs / rhs.z, lhs / rhs.w); } + + + /// Returns the result of a componentwise modulus operation on two uint4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 operator % (uint4 lhs, uint4 rhs) { return new uint4 (lhs.x % rhs.x, lhs.y % rhs.y, lhs.z % rhs.z, lhs.w % rhs.w); } + + /// Returns the result of a componentwise modulus operation on a uint4 vector and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 operator % (uint4 lhs, uint rhs) { return new uint4 (lhs.x % rhs, lhs.y % rhs, lhs.z % rhs, lhs.w % rhs); } + + /// Returns the result of a componentwise modulus operation on a uint value and a uint4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 operator % (uint lhs, uint4 rhs) { return new uint4 (lhs % rhs.x, lhs % rhs.y, lhs % rhs.z, lhs % rhs.w); } + + + /// Returns the result of a componentwise increment operation on a uint4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 operator ++ (uint4 val) { return new uint4 (++val.x, ++val.y, ++val.z, ++val.w); } + + + /// Returns the result of a componentwise decrement operation on a uint4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 operator -- (uint4 val) { return new uint4 (--val.x, --val.y, --val.z, --val.w); } + + + /// Returns the result of a componentwise less than operation on two uint4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator < (uint4 lhs, uint4 rhs) { return new bool4 (lhs.x < rhs.x, lhs.y < rhs.y, lhs.z < rhs.z, lhs.w < rhs.w); } + + /// Returns the result of a componentwise less than operation on a uint4 vector and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator < (uint4 lhs, uint rhs) { return new bool4 (lhs.x < rhs, lhs.y < rhs, lhs.z < rhs, lhs.w < rhs); } + + /// Returns the result of a componentwise less than operation on a uint value and a uint4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator < (uint lhs, uint4 rhs) { return new bool4 (lhs < rhs.x, lhs < rhs.y, lhs < rhs.z, lhs < rhs.w); } + + + /// Returns the result of a componentwise less or equal operation on two uint4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator <= (uint4 lhs, uint4 rhs) { return new bool4 (lhs.x <= rhs.x, lhs.y <= rhs.y, lhs.z <= rhs.z, lhs.w <= rhs.w); } + + /// Returns the result of a componentwise less or equal operation on a uint4 vector and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator <= (uint4 lhs, uint rhs) { return new bool4 (lhs.x <= rhs, lhs.y <= rhs, lhs.z <= rhs, lhs.w <= rhs); } + + /// Returns the result of a componentwise less or equal operation on a uint value and a uint4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator <= (uint lhs, uint4 rhs) { return new bool4 (lhs <= rhs.x, lhs <= rhs.y, lhs <= rhs.z, lhs <= rhs.w); } + + + /// Returns the result of a componentwise greater than operation on two uint4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator > (uint4 lhs, uint4 rhs) { return new bool4 (lhs.x > rhs.x, lhs.y > rhs.y, lhs.z > rhs.z, lhs.w > rhs.w); } + + /// Returns the result of a componentwise greater than operation on a uint4 vector and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator > (uint4 lhs, uint rhs) { return new bool4 (lhs.x > rhs, lhs.y > rhs, lhs.z > rhs, lhs.w > rhs); } + + /// Returns the result of a componentwise greater than operation on a uint value and a uint4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator > (uint lhs, uint4 rhs) { return new bool4 (lhs > rhs.x, lhs > rhs.y, lhs > rhs.z, lhs > rhs.w); } + + + /// Returns the result of a componentwise greater or equal operation on two uint4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator >= (uint4 lhs, uint4 rhs) { return new bool4 (lhs.x >= rhs.x, lhs.y >= rhs.y, lhs.z >= rhs.z, lhs.w >= rhs.w); } + + /// Returns the result of a componentwise greater or equal operation on a uint4 vector and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator >= (uint4 lhs, uint rhs) { return new bool4 (lhs.x >= rhs, lhs.y >= rhs, lhs.z >= rhs, lhs.w >= rhs); } + + /// Returns the result of a componentwise greater or equal operation on a uint value and a uint4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator >= (uint lhs, uint4 rhs) { return new bool4 (lhs >= rhs.x, lhs >= rhs.y, lhs >= rhs.z, lhs >= rhs.w); } + + + /// Returns the result of a componentwise unary minus operation on a uint4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 operator - (uint4 val) { return new uint4 ((uint)-val.x, (uint)-val.y, (uint)-val.z, (uint)-val.w); } + + + /// Returns the result of a componentwise unary plus operation on a uint4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 operator + (uint4 val) { return new uint4 (+val.x, +val.y, +val.z, +val.w); } + + + /// Returns the result of a componentwise left shift operation on a uint4 vector by a number of bits specified by a single int. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 operator << (uint4 x, int n) { return new uint4 (x.x << n, x.y << n, x.z << n, x.w << n); } + + /// Returns the result of a componentwise right shift operation on a uint4 vector by a number of bits specified by a single int. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 operator >> (uint4 x, int n) { return new uint4 (x.x >> n, x.y >> n, x.z >> n, x.w >> n); } + + /// Returns the result of a componentwise equality operation on two uint4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator == (uint4 lhs, uint4 rhs) { return new bool4 (lhs.x == rhs.x, lhs.y == rhs.y, lhs.z == rhs.z, lhs.w == rhs.w); } + + /// Returns the result of a componentwise equality operation on a uint4 vector and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator == (uint4 lhs, uint rhs) { return new bool4 (lhs.x == rhs, lhs.y == rhs, lhs.z == rhs, lhs.w == rhs); } + + /// Returns the result of a componentwise equality operation on a uint value and a uint4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator == (uint lhs, uint4 rhs) { return new bool4 (lhs == rhs.x, lhs == rhs.y, lhs == rhs.z, lhs == rhs.w); } + + + /// Returns the result of a componentwise not equal operation on two uint4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator != (uint4 lhs, uint4 rhs) { return new bool4 (lhs.x != rhs.x, lhs.y != rhs.y, lhs.z != rhs.z, lhs.w != rhs.w); } + + /// Returns the result of a componentwise not equal operation on a uint4 vector and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator != (uint4 lhs, uint rhs) { return new bool4 (lhs.x != rhs, lhs.y != rhs, lhs.z != rhs, lhs.w != rhs); } + + /// Returns the result of a componentwise not equal operation on a uint value and a uint4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator != (uint lhs, uint4 rhs) { return new bool4 (lhs != rhs.x, lhs != rhs.y, lhs != rhs.z, lhs != rhs.w); } + + + /// Returns the result of a componentwise bitwise not operation on a uint4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 operator ~ (uint4 val) { return new uint4 (~val.x, ~val.y, ~val.z, ~val.w); } + + + /// Returns the result of a componentwise bitwise and operation on two uint4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 operator & (uint4 lhs, uint4 rhs) { return new uint4 (lhs.x & rhs.x, lhs.y & rhs.y, lhs.z & rhs.z, lhs.w & rhs.w); } + + /// Returns the result of a componentwise bitwise and operation on a uint4 vector and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 operator & (uint4 lhs, uint rhs) { return new uint4 (lhs.x & rhs, lhs.y & rhs, lhs.z & rhs, lhs.w & rhs); } + + /// Returns the result of a componentwise bitwise and operation on a uint value and a uint4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 operator & (uint lhs, uint4 rhs) { return new uint4 (lhs & rhs.x, lhs & rhs.y, lhs & rhs.z, lhs & rhs.w); } + + + /// Returns the result of a componentwise bitwise or operation on two uint4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 operator | (uint4 lhs, uint4 rhs) { return new uint4 (lhs.x | rhs.x, lhs.y | rhs.y, lhs.z | rhs.z, lhs.w | rhs.w); } + + /// Returns the result of a componentwise bitwise or operation on a uint4 vector and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 operator | (uint4 lhs, uint rhs) { return new uint4 (lhs.x | rhs, lhs.y | rhs, lhs.z | rhs, lhs.w | rhs); } + + /// Returns the result of a componentwise bitwise or operation on a uint value and a uint4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 operator | (uint lhs, uint4 rhs) { return new uint4 (lhs | rhs.x, lhs | rhs.y, lhs | rhs.z, lhs | rhs.w); } + + + /// Returns the result of a componentwise bitwise exclusive or operation on two uint4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 operator ^ (uint4 lhs, uint4 rhs) { return new uint4 (lhs.x ^ rhs.x, lhs.y ^ rhs.y, lhs.z ^ rhs.z, lhs.w ^ rhs.w); } + + /// Returns the result of a componentwise bitwise exclusive or operation on a uint4 vector and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 operator ^ (uint4 lhs, uint rhs) { return new uint4 (lhs.x ^ rhs, lhs.y ^ rhs, lhs.z ^ rhs, lhs.w ^ rhs); } + + /// Returns the result of a componentwise bitwise exclusive or operation on a uint value and a uint4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 operator ^ (uint lhs, uint4 rhs) { return new uint4 (lhs ^ rhs.x, lhs ^ rhs.y, lhs ^ rhs.z, lhs ^ rhs.w); } + + + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xxxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, x, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xxxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, x, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xxxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, x, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xxxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, x, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xxyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, x, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xxyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, x, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xxyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, x, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xxyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, x, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xxzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, x, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xxzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, x, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xxzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, x, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xxzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, x, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xxwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, x, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xxwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, x, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xxwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, x, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xxww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, x, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xyxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, y, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xyxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, y, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xyxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, y, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xyxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, y, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xyyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, y, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xyyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, y, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xyyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, y, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xyyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, y, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xyzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, y, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xyzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, y, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xyzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, y, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xyzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, y, z, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; y = value.y; z = value.z; w = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xywx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, y, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xywy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, y, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xywz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, y, w, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; y = value.y; w = value.z; z = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xyww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, y, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xzxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, z, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xzxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, z, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xzxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, z, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xzxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, z, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xzyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, z, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xzyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, z, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xzyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, z, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xzyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, z, y, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; z = value.y; y = value.z; w = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xzzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, z, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xzzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, z, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xzzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, z, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xzzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, z, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xzwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, z, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xzwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, z, w, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; z = value.y; w = value.z; y = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xzwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, z, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xzww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, z, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xwxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, w, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xwxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, w, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xwxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, w, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xwxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, w, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xwyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, w, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xwyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, w, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xwyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, w, y, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; w = value.y; y = value.z; z = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xwyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, w, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xwzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, w, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xwzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, w, z, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; w = value.y; z = value.z; y = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xwzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, w, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xwzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, w, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xwwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, w, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xwwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, w, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xwwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, w, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 xwww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(x, w, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 yxxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, x, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 yxxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, x, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 yxxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, x, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 yxxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, x, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 yxyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, x, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 yxyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, x, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 yxyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, x, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 yxyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, x, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 yxzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, x, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 yxzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, x, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 yxzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, x, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 yxzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, x, z, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; x = value.y; z = value.z; w = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 yxwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, x, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 yxwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, x, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 yxwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, x, w, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; x = value.y; w = value.z; z = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 yxww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, x, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 yyxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, y, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 yyxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, y, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 yyxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, y, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 yyxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, y, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 yyyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, y, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 yyyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, y, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 yyyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, y, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 yyyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, y, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 yyzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, y, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 yyzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, y, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 yyzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, y, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 yyzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, y, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 yywx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, y, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 yywy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, y, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 yywz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, y, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 yyww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, y, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 yzxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, z, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 yzxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, z, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 yzxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, z, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 yzxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, z, x, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; z = value.y; x = value.z; w = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 yzyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, z, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 yzyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, z, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 yzyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, z, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 yzyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, z, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 yzzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, z, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 yzzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, z, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 yzzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, z, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 yzzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, z, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 yzwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, z, w, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; z = value.y; w = value.z; x = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 yzwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, z, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 yzwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, z, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 yzww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, z, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 ywxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, w, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 ywxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, w, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 ywxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, w, x, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; w = value.y; x = value.z; z = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 ywxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, w, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 ywyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, w, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 ywyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, w, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 ywyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, w, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 ywyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, w, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 ywzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, w, z, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; w = value.y; z = value.z; x = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 ywzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, w, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 ywzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, w, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 ywzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, w, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 ywwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, w, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 ywwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, w, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 ywwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, w, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 ywww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(y, w, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zxxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, x, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zxxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, x, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zxxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, x, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zxxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, x, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zxyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, x, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zxyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, x, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zxyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, x, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zxyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, x, y, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; x = value.y; y = value.z; w = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zxzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, x, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zxzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, x, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zxzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, x, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zxzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, x, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zxwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, x, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zxwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, x, w, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; x = value.y; w = value.z; y = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zxwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, x, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zxww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, x, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zyxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, y, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zyxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, y, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zyxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, y, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zyxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, y, x, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; y = value.y; x = value.z; w = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zyyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, y, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zyyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, y, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zyyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, y, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zyyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, y, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zyzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, y, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zyzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, y, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zyzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, y, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zyzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, y, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zywx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, y, w, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; y = value.y; w = value.z; x = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zywy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, y, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zywz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, y, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zyww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, y, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zzxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, z, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zzxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, z, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zzxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, z, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zzxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, z, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zzyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, z, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zzyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, z, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zzyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, z, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zzyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, z, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zzzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, z, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zzzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, z, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zzzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, z, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zzzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, z, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zzwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, z, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zzwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, z, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zzwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, z, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zzww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, z, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zwxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, w, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zwxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, w, x, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; w = value.y; x = value.z; y = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zwxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, w, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zwxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, w, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zwyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, w, y, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; w = value.y; y = value.z; x = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zwyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, w, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zwyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, w, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zwyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, w, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zwzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, w, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zwzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, w, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zwzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, w, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zwzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, w, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zwwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, w, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zwwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, w, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zwwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, w, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 zwww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(z, w, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wxxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, x, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wxxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, x, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wxxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, x, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wxxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, x, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wxyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, x, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wxyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, x, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wxyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, x, y, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; x = value.y; y = value.z; z = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wxyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, x, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wxzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, x, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wxzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, x, z, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; x = value.y; z = value.z; y = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wxzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, x, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wxzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, x, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wxwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, x, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wxwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, x, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wxwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, x, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wxww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, x, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wyxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, y, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wyxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, y, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wyxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, y, x, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; y = value.y; x = value.z; z = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wyxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, y, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wyyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, y, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wyyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, y, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wyyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, y, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wyyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, y, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wyzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, y, z, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; y = value.y; z = value.z; x = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wyzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, y, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wyzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, y, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wyzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, y, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wywx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, y, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wywy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, y, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wywz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, y, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wyww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, y, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wzxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, z, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wzxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, z, x, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; z = value.y; x = value.z; y = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wzxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, z, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wzxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, z, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wzyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, z, y, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; z = value.y; y = value.z; x = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wzyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, z, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wzyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, z, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wzyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, z, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wzzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, z, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wzzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, z, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wzzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, z, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wzzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, z, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wzwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, z, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wzwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, z, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wzwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, z, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wzww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, z, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wwxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, w, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wwxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, w, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wwxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, w, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wwxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, w, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wwyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, w, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wwyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, w, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wwyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, w, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wwyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, w, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wwzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, w, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wwzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, w, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wwzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, w, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wwzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, w, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wwwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, w, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wwwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, w, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wwwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, w, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint4 wwww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint4(w, w, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 xxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(x, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 xxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(x, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 xxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(x, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 xxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(x, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 xyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(x, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 xyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(x, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 xyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(x, y, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; y = value.y; z = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 xyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(x, y, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; y = value.y; w = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 xzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(x, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 xzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(x, z, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; z = value.y; y = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 xzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(x, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 xzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(x, z, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; z = value.y; w = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 xwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(x, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 xwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(x, w, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; w = value.y; y = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 xwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(x, w, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; w = value.y; z = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 xww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(x, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 yxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(y, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 yxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(y, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 yxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(y, x, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; x = value.y; z = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 yxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(y, x, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; x = value.y; w = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 yyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(y, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 yyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(y, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 yyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(y, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 yyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(y, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 yzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(y, z, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; z = value.y; x = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 yzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(y, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 yzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(y, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 yzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(y, z, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; z = value.y; w = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 ywx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(y, w, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; w = value.y; x = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 ywy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(y, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 ywz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(y, w, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; w = value.y; z = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 yww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(y, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 zxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(z, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 zxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(z, x, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; x = value.y; y = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 zxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(z, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 zxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(z, x, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; x = value.y; w = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 zyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(z, y, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; y = value.y; x = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 zyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(z, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 zyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(z, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 zyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(z, y, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; y = value.y; w = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 zzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(z, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 zzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(z, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 zzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(z, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 zzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(z, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 zwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(z, w, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; w = value.y; x = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 zwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(z, w, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; w = value.y; y = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 zwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(z, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 zww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(z, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 wxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(w, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 wxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(w, x, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; x = value.y; y = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 wxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(w, x, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; x = value.y; z = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 wxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(w, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 wyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(w, y, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; y = value.y; x = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 wyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(w, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 wyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(w, y, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; y = value.y; z = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 wyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(w, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 wzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(w, z, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; z = value.y; x = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 wzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(w, z, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; z = value.y; y = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 wzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(w, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 wzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(w, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 wwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(w, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 wwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(w, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 wwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(w, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint3 www + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint3(w, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint2 xx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint2(x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint2 xy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint2(x, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; y = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint2 xz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint2(x, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; z = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint2 xw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint2(x, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; w = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint2 yx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint2(y, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; x = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint2 yy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint2(y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint2 yz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint2(y, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; z = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint2 yw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint2(y, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; w = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint2 zx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint2(z, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; x = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint2 zy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint2(z, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; y = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint2 zz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint2(z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint2 zw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint2(z, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; w = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint2 wx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint2(w, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; x = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint2 wy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint2(w, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; y = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint2 wz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint2(w, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; z = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public uint2 ww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new uint2(w, w); } + } + + + + /// Returns the uint element at a specified index. + unsafe public uint this[int index] + { + get + { +#if ENABLE_UNITY_COLLECTIONS_CHECKS + if ((uint)index >= 4) + throw new System.ArgumentException("index must be between[0...3]"); +#endif + fixed (uint4* array = &this) { return ((uint*)array)[index]; } + } + set + { +#if ENABLE_UNITY_COLLECTIONS_CHECKS + if ((uint)index >= 4) + throw new System.ArgumentException("index must be between[0...3]"); +#endif + fixed (uint* array = &x) { array[index] = value; } + } + } + + /// Returns true if the uint4 is equal to a given uint4, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool Equals(uint4 rhs) { return x == rhs.x && y == rhs.y && z == rhs.z && w == rhs.w; } + + /// Returns true if the uint4 is equal to a given uint4, false otherwise. + public override bool Equals(object o) { return Equals((uint4)o); } + + + /// Returns a hash code for the uint4. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override int GetHashCode() { return (int)math.hash(this); } + + + /// Returns a string representation of the uint4. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override string ToString() + { + return string.Format("uint4({0}, {1}, {2}, {3})", x, y, z, w); + } + + /// Returns a string representation of the uint4 using a specified format and culture-specific format information. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public string ToString(string format, IFormatProvider formatProvider) + { + return string.Format("uint4({0}, {1}, {2}, {3})", x.ToString(format, formatProvider), y.ToString(format, formatProvider), z.ToString(format, formatProvider), w.ToString(format, formatProvider)); + } + + internal sealed class DebuggerProxy + { + public uint x; + public uint y; + public uint z; + public uint w; + public DebuggerProxy(uint4 v) + { + x = v.x; + y = v.y; + z = v.z; + w = v.w; + } + } + + } + + public static partial class math + { + /// Returns a uint4 vector constructed from four uint values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 uint4(uint x, uint y, uint z, uint w) { return new uint4(x, y, z, w); } + + /// Returns a uint4 vector constructed from two uint values and a uint2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 uint4(uint x, uint y, uint2 zw) { return new uint4(x, y, zw); } + + /// Returns a uint4 vector constructed from a uint value, a uint2 vector and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 uint4(uint x, uint2 yz, uint w) { return new uint4(x, yz, w); } + + /// Returns a uint4 vector constructed from a uint value and a uint3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 uint4(uint x, uint3 yzw) { return new uint4(x, yzw); } + + /// Returns a uint4 vector constructed from a uint2 vector and two uint values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 uint4(uint2 xy, uint z, uint w) { return new uint4(xy, z, w); } + + /// Returns a uint4 vector constructed from two uint2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 uint4(uint2 xy, uint2 zw) { return new uint4(xy, zw); } + + /// Returns a uint4 vector constructed from a uint3 vector and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 uint4(uint3 xyz, uint w) { return new uint4(xyz, w); } + + /// Returns a uint4 vector constructed from a uint4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 uint4(uint4 xyzw) { return new uint4(xyzw); } + + /// Returns a uint4 vector constructed from a single uint value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 uint4(uint v) { return new uint4(v); } + + /// Returns a uint4 vector constructed from a single bool value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 uint4(bool v) { return new uint4(v); } + + /// Return a uint4 vector constructed from a bool4 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 uint4(bool4 v) { return new uint4(v); } + + /// Returns a uint4 vector constructed from a single int value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 uint4(int v) { return new uint4(v); } + + /// Return a uint4 vector constructed from a int4 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 uint4(int4 v) { return new uint4(v); } + + /// Returns a uint4 vector constructed from a single float value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 uint4(float v) { return new uint4(v); } + + /// Return a uint4 vector constructed from a float4 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 uint4(float4 v) { return new uint4(v); } + + /// Returns a uint4 vector constructed from a single double value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 uint4(double v) { return new uint4(v); } + + /// Return a uint4 vector constructed from a double4 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 uint4(double4 v) { return new uint4(v); } + + /// Returns a uint hash code of a uint4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint hash(uint4 v) + { + return csum(v * uint4(0xB492BF15u, 0xD37220E3u, 0x7AA2C2BDu, 0xE16BC89Du)) + 0x7AA07CD3u; + } + + /// + /// Returns a uint4 vector hash code of a uint4 vector. + /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash + /// that are only reduced to a narrow uint hash at the very end instead of at every step. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 hashwide(uint4 v) + { + return (v * uint4(0xAF642BA9u, 0xA8F2213Bu, 0x9F3FDC37u, 0xAC60D0C3u)) + 0x9263662Fu; + } + + /// Returns the result of specified shuffling of the components from two uint4 vectors into a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint shuffle(uint4 a, uint4 b, ShuffleComponent x) + { + return select_shuffle_component(a, b, x); + } + + /// Returns the result of specified shuffling of the components from two uint4 vectors into a uint2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint2 shuffle(uint4 a, uint4 b, ShuffleComponent x, ShuffleComponent y) + { + return uint2( + select_shuffle_component(a, b, x), + select_shuffle_component(a, b, y)); + } + + /// Returns the result of specified shuffling of the components from two uint4 vectors into a uint3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3 shuffle(uint4 a, uint4 b, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z) + { + return uint3( + select_shuffle_component(a, b, x), + select_shuffle_component(a, b, y), + select_shuffle_component(a, b, z)); + } + + /// Returns the result of specified shuffling of the components from two uint4 vectors into a uint4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 shuffle(uint4 a, uint4 b, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z, ShuffleComponent w) + { + return uint4( + select_shuffle_component(a, b, x), + select_shuffle_component(a, b, y), + select_shuffle_component(a, b, z), + select_shuffle_component(a, b, w)); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static uint select_shuffle_component(uint4 a, uint4 b, ShuffleComponent component) + { + switch(component) + { + case ShuffleComponent.LeftX: + return a.x; + case ShuffleComponent.LeftY: + return a.y; + case ShuffleComponent.LeftZ: + return a.z; + case ShuffleComponent.LeftW: + return a.w; + case ShuffleComponent.RightX: + return b.x; + case ShuffleComponent.RightY: + return b.y; + case ShuffleComponent.RightZ: + return b.z; + case ShuffleComponent.RightW: + return b.w; + default: + throw new System.ArgumentException("Invalid shuffle component: " + component); + } + } + + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/uint4.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/uint4.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..e3038e725eeba63ad7f22688ac29d1447a9de4b9 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/uint4.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 9fdee5e687d86ef488fb8ebda7eb849b +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/uint4x2.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/uint4x2.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..62cf28fa03a2344d79d4eb99ead3d7a4edcfd79b --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/uint4x2.gen.cs @@ -0,0 +1,497 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using System; +using System.Runtime.CompilerServices; + +#pragma warning disable 0660, 0661 + +namespace Unity.Mathematics +{ + [System.Serializable] + public partial struct uint4x2 : System.IEquatable, IFormattable + { + public uint4 c0; + public uint4 c1; + + /// uint4x2 zero value. + public static readonly uint4x2 zero; + + /// Constructs a uint4x2 matrix from two uint4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4x2(uint4 c0, uint4 c1) + { + this.c0 = c0; + this.c1 = c1; + } + + /// Constructs a uint4x2 matrix from 8 uint values given in row-major order. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4x2(uint m00, uint m01, + uint m10, uint m11, + uint m20, uint m21, + uint m30, uint m31) + { + this.c0 = new uint4(m00, m10, m20, m30); + this.c1 = new uint4(m01, m11, m21, m31); + } + + /// Constructs a uint4x2 matrix from a single uint value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4x2(uint v) + { + this.c0 = v; + this.c1 = v; + } + + /// Constructs a uint4x2 matrix from a single bool value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4x2(bool v) + { + this.c0 = math.select(new uint4(0u), new uint4(1u), v); + this.c1 = math.select(new uint4(0u), new uint4(1u), v); + } + + /// Constructs a uint4x2 matrix from a bool4x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4x2(bool4x2 v) + { + this.c0 = math.select(new uint4(0u), new uint4(1u), v.c0); + this.c1 = math.select(new uint4(0u), new uint4(1u), v.c1); + } + + /// Constructs a uint4x2 matrix from a single int value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4x2(int v) + { + this.c0 = (uint4)v; + this.c1 = (uint4)v; + } + + /// Constructs a uint4x2 matrix from a int4x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4x2(int4x2 v) + { + this.c0 = (uint4)v.c0; + this.c1 = (uint4)v.c1; + } + + /// Constructs a uint4x2 matrix from a single float value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4x2(float v) + { + this.c0 = (uint4)v; + this.c1 = (uint4)v; + } + + /// Constructs a uint4x2 matrix from a float4x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4x2(float4x2 v) + { + this.c0 = (uint4)v.c0; + this.c1 = (uint4)v.c1; + } + + /// Constructs a uint4x2 matrix from a single double value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4x2(double v) + { + this.c0 = (uint4)v; + this.c1 = (uint4)v; + } + + /// Constructs a uint4x2 matrix from a double4x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4x2(double4x2 v) + { + this.c0 = (uint4)v.c0; + this.c1 = (uint4)v.c1; + } + + + /// Implicitly converts a single uint value to a uint4x2 matrix by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator uint4x2(uint v) { return new uint4x2(v); } + + /// Explicitly converts a single bool value to a uint4x2 matrix by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint4x2(bool v) { return new uint4x2(v); } + + /// Explicitly converts a bool4x2 matrix to a uint4x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint4x2(bool4x2 v) { return new uint4x2(v); } + + /// Explicitly converts a single int value to a uint4x2 matrix by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint4x2(int v) { return new uint4x2(v); } + + /// Explicitly converts a int4x2 matrix to a uint4x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint4x2(int4x2 v) { return new uint4x2(v); } + + /// Explicitly converts a single float value to a uint4x2 matrix by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint4x2(float v) { return new uint4x2(v); } + + /// Explicitly converts a float4x2 matrix to a uint4x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint4x2(float4x2 v) { return new uint4x2(v); } + + /// Explicitly converts a single double value to a uint4x2 matrix by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint4x2(double v) { return new uint4x2(v); } + + /// Explicitly converts a double4x2 matrix to a uint4x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint4x2(double4x2 v) { return new uint4x2(v); } + + + /// Returns the result of a componentwise multiplication operation on two uint4x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x2 operator * (uint4x2 lhs, uint4x2 rhs) { return new uint4x2 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1); } + + /// Returns the result of a componentwise multiplication operation on a uint4x2 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x2 operator * (uint4x2 lhs, uint rhs) { return new uint4x2 (lhs.c0 * rhs, lhs.c1 * rhs); } + + /// Returns the result of a componentwise multiplication operation on a uint value and a uint4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x2 operator * (uint lhs, uint4x2 rhs) { return new uint4x2 (lhs * rhs.c0, lhs * rhs.c1); } + + + /// Returns the result of a componentwise addition operation on two uint4x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x2 operator + (uint4x2 lhs, uint4x2 rhs) { return new uint4x2 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1); } + + /// Returns the result of a componentwise addition operation on a uint4x2 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x2 operator + (uint4x2 lhs, uint rhs) { return new uint4x2 (lhs.c0 + rhs, lhs.c1 + rhs); } + + /// Returns the result of a componentwise addition operation on a uint value and a uint4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x2 operator + (uint lhs, uint4x2 rhs) { return new uint4x2 (lhs + rhs.c0, lhs + rhs.c1); } + + + /// Returns the result of a componentwise subtraction operation on two uint4x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x2 operator - (uint4x2 lhs, uint4x2 rhs) { return new uint4x2 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1); } + + /// Returns the result of a componentwise subtraction operation on a uint4x2 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x2 operator - (uint4x2 lhs, uint rhs) { return new uint4x2 (lhs.c0 - rhs, lhs.c1 - rhs); } + + /// Returns the result of a componentwise subtraction operation on a uint value and a uint4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x2 operator - (uint lhs, uint4x2 rhs) { return new uint4x2 (lhs - rhs.c0, lhs - rhs.c1); } + + + /// Returns the result of a componentwise division operation on two uint4x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x2 operator / (uint4x2 lhs, uint4x2 rhs) { return new uint4x2 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1); } + + /// Returns the result of a componentwise division operation on a uint4x2 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x2 operator / (uint4x2 lhs, uint rhs) { return new uint4x2 (lhs.c0 / rhs, lhs.c1 / rhs); } + + /// Returns the result of a componentwise division operation on a uint value and a uint4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x2 operator / (uint lhs, uint4x2 rhs) { return new uint4x2 (lhs / rhs.c0, lhs / rhs.c1); } + + + /// Returns the result of a componentwise modulus operation on two uint4x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x2 operator % (uint4x2 lhs, uint4x2 rhs) { return new uint4x2 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1); } + + /// Returns the result of a componentwise modulus operation on a uint4x2 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x2 operator % (uint4x2 lhs, uint rhs) { return new uint4x2 (lhs.c0 % rhs, lhs.c1 % rhs); } + + /// Returns the result of a componentwise modulus operation on a uint value and a uint4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x2 operator % (uint lhs, uint4x2 rhs) { return new uint4x2 (lhs % rhs.c0, lhs % rhs.c1); } + + + /// Returns the result of a componentwise increment operation on a uint4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x2 operator ++ (uint4x2 val) { return new uint4x2 (++val.c0, ++val.c1); } + + + /// Returns the result of a componentwise decrement operation on a uint4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x2 operator -- (uint4x2 val) { return new uint4x2 (--val.c0, --val.c1); } + + + /// Returns the result of a componentwise less than operation on two uint4x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator < (uint4x2 lhs, uint4x2 rhs) { return new bool4x2 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1); } + + /// Returns the result of a componentwise less than operation on a uint4x2 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator < (uint4x2 lhs, uint rhs) { return new bool4x2 (lhs.c0 < rhs, lhs.c1 < rhs); } + + /// Returns the result of a componentwise less than operation on a uint value and a uint4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator < (uint lhs, uint4x2 rhs) { return new bool4x2 (lhs < rhs.c0, lhs < rhs.c1); } + + + /// Returns the result of a componentwise less or equal operation on two uint4x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator <= (uint4x2 lhs, uint4x2 rhs) { return new bool4x2 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1); } + + /// Returns the result of a componentwise less or equal operation on a uint4x2 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator <= (uint4x2 lhs, uint rhs) { return new bool4x2 (lhs.c0 <= rhs, lhs.c1 <= rhs); } + + /// Returns the result of a componentwise less or equal operation on a uint value and a uint4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator <= (uint lhs, uint4x2 rhs) { return new bool4x2 (lhs <= rhs.c0, lhs <= rhs.c1); } + + + /// Returns the result of a componentwise greater than operation on two uint4x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator > (uint4x2 lhs, uint4x2 rhs) { return new bool4x2 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1); } + + /// Returns the result of a componentwise greater than operation on a uint4x2 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator > (uint4x2 lhs, uint rhs) { return new bool4x2 (lhs.c0 > rhs, lhs.c1 > rhs); } + + /// Returns the result of a componentwise greater than operation on a uint value and a uint4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator > (uint lhs, uint4x2 rhs) { return new bool4x2 (lhs > rhs.c0, lhs > rhs.c1); } + + + /// Returns the result of a componentwise greater or equal operation on two uint4x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator >= (uint4x2 lhs, uint4x2 rhs) { return new bool4x2 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1); } + + /// Returns the result of a componentwise greater or equal operation on a uint4x2 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator >= (uint4x2 lhs, uint rhs) { return new bool4x2 (lhs.c0 >= rhs, lhs.c1 >= rhs); } + + /// Returns the result of a componentwise greater or equal operation on a uint value and a uint4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator >= (uint lhs, uint4x2 rhs) { return new bool4x2 (lhs >= rhs.c0, lhs >= rhs.c1); } + + + /// Returns the result of a componentwise unary minus operation on a uint4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x2 operator - (uint4x2 val) { return new uint4x2 (-val.c0, -val.c1); } + + + /// Returns the result of a componentwise unary plus operation on a uint4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x2 operator + (uint4x2 val) { return new uint4x2 (+val.c0, +val.c1); } + + + /// Returns the result of a componentwise left shift operation on a uint4x2 matrix by a number of bits specified by a single int. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x2 operator << (uint4x2 x, int n) { return new uint4x2 (x.c0 << n, x.c1 << n); } + + /// Returns the result of a componentwise right shift operation on a uint4x2 matrix by a number of bits specified by a single int. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x2 operator >> (uint4x2 x, int n) { return new uint4x2 (x.c0 >> n, x.c1 >> n); } + + /// Returns the result of a componentwise equality operation on two uint4x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator == (uint4x2 lhs, uint4x2 rhs) { return new bool4x2 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1); } + + /// Returns the result of a componentwise equality operation on a uint4x2 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator == (uint4x2 lhs, uint rhs) { return new bool4x2 (lhs.c0 == rhs, lhs.c1 == rhs); } + + /// Returns the result of a componentwise equality operation on a uint value and a uint4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator == (uint lhs, uint4x2 rhs) { return new bool4x2 (lhs == rhs.c0, lhs == rhs.c1); } + + + /// Returns the result of a componentwise not equal operation on two uint4x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator != (uint4x2 lhs, uint4x2 rhs) { return new bool4x2 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1); } + + /// Returns the result of a componentwise not equal operation on a uint4x2 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator != (uint4x2 lhs, uint rhs) { return new bool4x2 (lhs.c0 != rhs, lhs.c1 != rhs); } + + /// Returns the result of a componentwise not equal operation on a uint value and a uint4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator != (uint lhs, uint4x2 rhs) { return new bool4x2 (lhs != rhs.c0, lhs != rhs.c1); } + + + /// Returns the result of a componentwise bitwise not operation on a uint4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x2 operator ~ (uint4x2 val) { return new uint4x2 (~val.c0, ~val.c1); } + + + /// Returns the result of a componentwise bitwise and operation on two uint4x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x2 operator & (uint4x2 lhs, uint4x2 rhs) { return new uint4x2 (lhs.c0 & rhs.c0, lhs.c1 & rhs.c1); } + + /// Returns the result of a componentwise bitwise and operation on a uint4x2 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x2 operator & (uint4x2 lhs, uint rhs) { return new uint4x2 (lhs.c0 & rhs, lhs.c1 & rhs); } + + /// Returns the result of a componentwise bitwise and operation on a uint value and a uint4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x2 operator & (uint lhs, uint4x2 rhs) { return new uint4x2 (lhs & rhs.c0, lhs & rhs.c1); } + + + /// Returns the result of a componentwise bitwise or operation on two uint4x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x2 operator | (uint4x2 lhs, uint4x2 rhs) { return new uint4x2 (lhs.c0 | rhs.c0, lhs.c1 | rhs.c1); } + + /// Returns the result of a componentwise bitwise or operation on a uint4x2 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x2 operator | (uint4x2 lhs, uint rhs) { return new uint4x2 (lhs.c0 | rhs, lhs.c1 | rhs); } + + /// Returns the result of a componentwise bitwise or operation on a uint value and a uint4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x2 operator | (uint lhs, uint4x2 rhs) { return new uint4x2 (lhs | rhs.c0, lhs | rhs.c1); } + + + /// Returns the result of a componentwise bitwise exclusive or operation on two uint4x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x2 operator ^ (uint4x2 lhs, uint4x2 rhs) { return new uint4x2 (lhs.c0 ^ rhs.c0, lhs.c1 ^ rhs.c1); } + + /// Returns the result of a componentwise bitwise exclusive or operation on a uint4x2 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x2 operator ^ (uint4x2 lhs, uint rhs) { return new uint4x2 (lhs.c0 ^ rhs, lhs.c1 ^ rhs); } + + /// Returns the result of a componentwise bitwise exclusive or operation on a uint value and a uint4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x2 operator ^ (uint lhs, uint4x2 rhs) { return new uint4x2 (lhs ^ rhs.c0, lhs ^ rhs.c1); } + + + + /// Returns the uint4 element at a specified index. + unsafe public ref uint4 this[int index] + { + get + { +#if ENABLE_UNITY_COLLECTIONS_CHECKS + if ((uint)index >= 2) + throw new System.ArgumentException("index must be between[0...1]"); +#endif + fixed (uint4x2* array = &this) { return ref ((uint4*)array)[index]; } + } + } + + /// Returns true if the uint4x2 is equal to a given uint4x2, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool Equals(uint4x2 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1); } + + /// Returns true if the uint4x2 is equal to a given uint4x2, false otherwise. + public override bool Equals(object o) { return Equals((uint4x2)o); } + + + /// Returns a hash code for the uint4x2. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override int GetHashCode() { return (int)math.hash(this); } + + + /// Returns a string representation of the uint4x2. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override string ToString() + { + return string.Format("uint4x2({0}, {1}, {2}, {3}, {4}, {5}, {6}, {7})", c0.x, c1.x, c0.y, c1.y, c0.z, c1.z, c0.w, c1.w); + } + + /// Returns a string representation of the uint4x2 using a specified format and culture-specific format information. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public string ToString(string format, IFormatProvider formatProvider) + { + return string.Format("uint4x2({0}, {1}, {2}, {3}, {4}, {5}, {6}, {7})", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider), c0.z.ToString(format, formatProvider), c1.z.ToString(format, formatProvider), c0.w.ToString(format, formatProvider), c1.w.ToString(format, formatProvider)); + } + + } + + public static partial class math + { + /// Returns a uint4x2 matrix constructed from two uint4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x2 uint4x2(uint4 c0, uint4 c1) { return new uint4x2(c0, c1); } + + /// Returns a uint4x2 matrix constructed from from 8 uint values given in row-major order. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x2 uint4x2(uint m00, uint m01, + uint m10, uint m11, + uint m20, uint m21, + uint m30, uint m31) + { + return new uint4x2(m00, m01, + m10, m11, + m20, m21, + m30, m31); + } + + /// Returns a uint4x2 matrix constructed from a single uint value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x2 uint4x2(uint v) { return new uint4x2(v); } + + /// Returns a uint4x2 matrix constructed from a single bool value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x2 uint4x2(bool v) { return new uint4x2(v); } + + /// Return a uint4x2 matrix constructed from a bool4x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x2 uint4x2(bool4x2 v) { return new uint4x2(v); } + + /// Returns a uint4x2 matrix constructed from a single int value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x2 uint4x2(int v) { return new uint4x2(v); } + + /// Return a uint4x2 matrix constructed from a int4x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x2 uint4x2(int4x2 v) { return new uint4x2(v); } + + /// Returns a uint4x2 matrix constructed from a single float value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x2 uint4x2(float v) { return new uint4x2(v); } + + /// Return a uint4x2 matrix constructed from a float4x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x2 uint4x2(float4x2 v) { return new uint4x2(v); } + + /// Returns a uint4x2 matrix constructed from a single double value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x2 uint4x2(double v) { return new uint4x2(v); } + + /// Return a uint4x2 matrix constructed from a double4x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x2 uint4x2(double4x2 v) { return new uint4x2(v); } + + /// Return the uint2x4 transpose of a uint4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint2x4 transpose(uint4x2 v) + { + return uint2x4( + v.c0.x, v.c0.y, v.c0.z, v.c0.w, + v.c1.x, v.c1.y, v.c1.z, v.c1.w); + } + + /// Returns a uint hash code of a uint4x2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint hash(uint4x2 v) + { + return csum(v.c0 * uint4(0xFA3A3285u, 0xAD55999Du, 0xDCDD5341u, 0x94DDD769u) + + v.c1 * uint4(0xA1E92D39u, 0x4583C801u, 0x9536A0F5u, 0xAF816615u)) + 0x9AF8D62Du; + } + + /// + /// Returns a uint4 vector hash code of a uint4x2 vector. + /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash + /// that are only reduced to a narrow uint hash at the very end instead of at every step. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 hashwide(uint4x2 v) + { + return (v.c0 * uint4(0xE3600729u, 0x5F17300Du, 0x670D6809u, 0x7AF32C49u) + + v.c1 * uint4(0xAE131389u, 0x5D1B165Bu, 0x87096CD7u, 0x4C7F6DD1u)) + 0x4822A3E9u; + } + + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/uint4x2.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/uint4x2.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..ede207723e0b3d9d745af7581b67f30b6bff0de5 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/uint4x2.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 793eda612f42a4089bcfd0be1ece0a6d +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/uint4x3.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/uint4x3.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..fec012448ef86f120a30b28e407ee329d2c2dcd1 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/uint4x3.gen.cs @@ -0,0 +1,512 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using System; +using System.Runtime.CompilerServices; + +#pragma warning disable 0660, 0661 + +namespace Unity.Mathematics +{ + [System.Serializable] + public partial struct uint4x3 : System.IEquatable, IFormattable + { + public uint4 c0; + public uint4 c1; + public uint4 c2; + + /// uint4x3 zero value. + public static readonly uint4x3 zero; + + /// Constructs a uint4x3 matrix from three uint4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4x3(uint4 c0, uint4 c1, uint4 c2) + { + this.c0 = c0; + this.c1 = c1; + this.c2 = c2; + } + + /// Constructs a uint4x3 matrix from 12 uint values given in row-major order. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4x3(uint m00, uint m01, uint m02, + uint m10, uint m11, uint m12, + uint m20, uint m21, uint m22, + uint m30, uint m31, uint m32) + { + this.c0 = new uint4(m00, m10, m20, m30); + this.c1 = new uint4(m01, m11, m21, m31); + this.c2 = new uint4(m02, m12, m22, m32); + } + + /// Constructs a uint4x3 matrix from a single uint value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4x3(uint v) + { + this.c0 = v; + this.c1 = v; + this.c2 = v; + } + + /// Constructs a uint4x3 matrix from a single bool value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4x3(bool v) + { + this.c0 = math.select(new uint4(0u), new uint4(1u), v); + this.c1 = math.select(new uint4(0u), new uint4(1u), v); + this.c2 = math.select(new uint4(0u), new uint4(1u), v); + } + + /// Constructs a uint4x3 matrix from a bool4x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4x3(bool4x3 v) + { + this.c0 = math.select(new uint4(0u), new uint4(1u), v.c0); + this.c1 = math.select(new uint4(0u), new uint4(1u), v.c1); + this.c2 = math.select(new uint4(0u), new uint4(1u), v.c2); + } + + /// Constructs a uint4x3 matrix from a single int value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4x3(int v) + { + this.c0 = (uint4)v; + this.c1 = (uint4)v; + this.c2 = (uint4)v; + } + + /// Constructs a uint4x3 matrix from a int4x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4x3(int4x3 v) + { + this.c0 = (uint4)v.c0; + this.c1 = (uint4)v.c1; + this.c2 = (uint4)v.c2; + } + + /// Constructs a uint4x3 matrix from a single float value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4x3(float v) + { + this.c0 = (uint4)v; + this.c1 = (uint4)v; + this.c2 = (uint4)v; + } + + /// Constructs a uint4x3 matrix from a float4x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4x3(float4x3 v) + { + this.c0 = (uint4)v.c0; + this.c1 = (uint4)v.c1; + this.c2 = (uint4)v.c2; + } + + /// Constructs a uint4x3 matrix from a single double value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4x3(double v) + { + this.c0 = (uint4)v; + this.c1 = (uint4)v; + this.c2 = (uint4)v; + } + + /// Constructs a uint4x3 matrix from a double4x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4x3(double4x3 v) + { + this.c0 = (uint4)v.c0; + this.c1 = (uint4)v.c1; + this.c2 = (uint4)v.c2; + } + + + /// Implicitly converts a single uint value to a uint4x3 matrix by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator uint4x3(uint v) { return new uint4x3(v); } + + /// Explicitly converts a single bool value to a uint4x3 matrix by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint4x3(bool v) { return new uint4x3(v); } + + /// Explicitly converts a bool4x3 matrix to a uint4x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint4x3(bool4x3 v) { return new uint4x3(v); } + + /// Explicitly converts a single int value to a uint4x3 matrix by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint4x3(int v) { return new uint4x3(v); } + + /// Explicitly converts a int4x3 matrix to a uint4x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint4x3(int4x3 v) { return new uint4x3(v); } + + /// Explicitly converts a single float value to a uint4x3 matrix by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint4x3(float v) { return new uint4x3(v); } + + /// Explicitly converts a float4x3 matrix to a uint4x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint4x3(float4x3 v) { return new uint4x3(v); } + + /// Explicitly converts a single double value to a uint4x3 matrix by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint4x3(double v) { return new uint4x3(v); } + + /// Explicitly converts a double4x3 matrix to a uint4x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint4x3(double4x3 v) { return new uint4x3(v); } + + + /// Returns the result of a componentwise multiplication operation on two uint4x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x3 operator * (uint4x3 lhs, uint4x3 rhs) { return new uint4x3 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1, lhs.c2 * rhs.c2); } + + /// Returns the result of a componentwise multiplication operation on a uint4x3 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x3 operator * (uint4x3 lhs, uint rhs) { return new uint4x3 (lhs.c0 * rhs, lhs.c1 * rhs, lhs.c2 * rhs); } + + /// Returns the result of a componentwise multiplication operation on a uint value and a uint4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x3 operator * (uint lhs, uint4x3 rhs) { return new uint4x3 (lhs * rhs.c0, lhs * rhs.c1, lhs * rhs.c2); } + + + /// Returns the result of a componentwise addition operation on two uint4x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x3 operator + (uint4x3 lhs, uint4x3 rhs) { return new uint4x3 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1, lhs.c2 + rhs.c2); } + + /// Returns the result of a componentwise addition operation on a uint4x3 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x3 operator + (uint4x3 lhs, uint rhs) { return new uint4x3 (lhs.c0 + rhs, lhs.c1 + rhs, lhs.c2 + rhs); } + + /// Returns the result of a componentwise addition operation on a uint value and a uint4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x3 operator + (uint lhs, uint4x3 rhs) { return new uint4x3 (lhs + rhs.c0, lhs + rhs.c1, lhs + rhs.c2); } + + + /// Returns the result of a componentwise subtraction operation on two uint4x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x3 operator - (uint4x3 lhs, uint4x3 rhs) { return new uint4x3 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1, lhs.c2 - rhs.c2); } + + /// Returns the result of a componentwise subtraction operation on a uint4x3 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x3 operator - (uint4x3 lhs, uint rhs) { return new uint4x3 (lhs.c0 - rhs, lhs.c1 - rhs, lhs.c2 - rhs); } + + /// Returns the result of a componentwise subtraction operation on a uint value and a uint4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x3 operator - (uint lhs, uint4x3 rhs) { return new uint4x3 (lhs - rhs.c0, lhs - rhs.c1, lhs - rhs.c2); } + + + /// Returns the result of a componentwise division operation on two uint4x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x3 operator / (uint4x3 lhs, uint4x3 rhs) { return new uint4x3 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1, lhs.c2 / rhs.c2); } + + /// Returns the result of a componentwise division operation on a uint4x3 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x3 operator / (uint4x3 lhs, uint rhs) { return new uint4x3 (lhs.c0 / rhs, lhs.c1 / rhs, lhs.c2 / rhs); } + + /// Returns the result of a componentwise division operation on a uint value and a uint4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x3 operator / (uint lhs, uint4x3 rhs) { return new uint4x3 (lhs / rhs.c0, lhs / rhs.c1, lhs / rhs.c2); } + + + /// Returns the result of a componentwise modulus operation on two uint4x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x3 operator % (uint4x3 lhs, uint4x3 rhs) { return new uint4x3 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1, lhs.c2 % rhs.c2); } + + /// Returns the result of a componentwise modulus operation on a uint4x3 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x3 operator % (uint4x3 lhs, uint rhs) { return new uint4x3 (lhs.c0 % rhs, lhs.c1 % rhs, lhs.c2 % rhs); } + + /// Returns the result of a componentwise modulus operation on a uint value and a uint4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x3 operator % (uint lhs, uint4x3 rhs) { return new uint4x3 (lhs % rhs.c0, lhs % rhs.c1, lhs % rhs.c2); } + + + /// Returns the result of a componentwise increment operation on a uint4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x3 operator ++ (uint4x3 val) { return new uint4x3 (++val.c0, ++val.c1, ++val.c2); } + + + /// Returns the result of a componentwise decrement operation on a uint4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x3 operator -- (uint4x3 val) { return new uint4x3 (--val.c0, --val.c1, --val.c2); } + + + /// Returns the result of a componentwise less than operation on two uint4x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator < (uint4x3 lhs, uint4x3 rhs) { return new bool4x3 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1, lhs.c2 < rhs.c2); } + + /// Returns the result of a componentwise less than operation on a uint4x3 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator < (uint4x3 lhs, uint rhs) { return new bool4x3 (lhs.c0 < rhs, lhs.c1 < rhs, lhs.c2 < rhs); } + + /// Returns the result of a componentwise less than operation on a uint value and a uint4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator < (uint lhs, uint4x3 rhs) { return new bool4x3 (lhs < rhs.c0, lhs < rhs.c1, lhs < rhs.c2); } + + + /// Returns the result of a componentwise less or equal operation on two uint4x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator <= (uint4x3 lhs, uint4x3 rhs) { return new bool4x3 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1, lhs.c2 <= rhs.c2); } + + /// Returns the result of a componentwise less or equal operation on a uint4x3 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator <= (uint4x3 lhs, uint rhs) { return new bool4x3 (lhs.c0 <= rhs, lhs.c1 <= rhs, lhs.c2 <= rhs); } + + /// Returns the result of a componentwise less or equal operation on a uint value and a uint4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator <= (uint lhs, uint4x3 rhs) { return new bool4x3 (lhs <= rhs.c0, lhs <= rhs.c1, lhs <= rhs.c2); } + + + /// Returns the result of a componentwise greater than operation on two uint4x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator > (uint4x3 lhs, uint4x3 rhs) { return new bool4x3 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1, lhs.c2 > rhs.c2); } + + /// Returns the result of a componentwise greater than operation on a uint4x3 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator > (uint4x3 lhs, uint rhs) { return new bool4x3 (lhs.c0 > rhs, lhs.c1 > rhs, lhs.c2 > rhs); } + + /// Returns the result of a componentwise greater than operation on a uint value and a uint4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator > (uint lhs, uint4x3 rhs) { return new bool4x3 (lhs > rhs.c0, lhs > rhs.c1, lhs > rhs.c2); } + + + /// Returns the result of a componentwise greater or equal operation on two uint4x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator >= (uint4x3 lhs, uint4x3 rhs) { return new bool4x3 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1, lhs.c2 >= rhs.c2); } + + /// Returns the result of a componentwise greater or equal operation on a uint4x3 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator >= (uint4x3 lhs, uint rhs) { return new bool4x3 (lhs.c0 >= rhs, lhs.c1 >= rhs, lhs.c2 >= rhs); } + + /// Returns the result of a componentwise greater or equal operation on a uint value and a uint4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator >= (uint lhs, uint4x3 rhs) { return new bool4x3 (lhs >= rhs.c0, lhs >= rhs.c1, lhs >= rhs.c2); } + + + /// Returns the result of a componentwise unary minus operation on a uint4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x3 operator - (uint4x3 val) { return new uint4x3 (-val.c0, -val.c1, -val.c2); } + + + /// Returns the result of a componentwise unary plus operation on a uint4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x3 operator + (uint4x3 val) { return new uint4x3 (+val.c0, +val.c1, +val.c2); } + + + /// Returns the result of a componentwise left shift operation on a uint4x3 matrix by a number of bits specified by a single int. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x3 operator << (uint4x3 x, int n) { return new uint4x3 (x.c0 << n, x.c1 << n, x.c2 << n); } + + /// Returns the result of a componentwise right shift operation on a uint4x3 matrix by a number of bits specified by a single int. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x3 operator >> (uint4x3 x, int n) { return new uint4x3 (x.c0 >> n, x.c1 >> n, x.c2 >> n); } + + /// Returns the result of a componentwise equality operation on two uint4x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator == (uint4x3 lhs, uint4x3 rhs) { return new bool4x3 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1, lhs.c2 == rhs.c2); } + + /// Returns the result of a componentwise equality operation on a uint4x3 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator == (uint4x3 lhs, uint rhs) { return new bool4x3 (lhs.c0 == rhs, lhs.c1 == rhs, lhs.c2 == rhs); } + + /// Returns the result of a componentwise equality operation on a uint value and a uint4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator == (uint lhs, uint4x3 rhs) { return new bool4x3 (lhs == rhs.c0, lhs == rhs.c1, lhs == rhs.c2); } + + + /// Returns the result of a componentwise not equal operation on two uint4x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator != (uint4x3 lhs, uint4x3 rhs) { return new bool4x3 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1, lhs.c2 != rhs.c2); } + + /// Returns the result of a componentwise not equal operation on a uint4x3 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator != (uint4x3 lhs, uint rhs) { return new bool4x3 (lhs.c0 != rhs, lhs.c1 != rhs, lhs.c2 != rhs); } + + /// Returns the result of a componentwise not equal operation on a uint value and a uint4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator != (uint lhs, uint4x3 rhs) { return new bool4x3 (lhs != rhs.c0, lhs != rhs.c1, lhs != rhs.c2); } + + + /// Returns the result of a componentwise bitwise not operation on a uint4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x3 operator ~ (uint4x3 val) { return new uint4x3 (~val.c0, ~val.c1, ~val.c2); } + + + /// Returns the result of a componentwise bitwise and operation on two uint4x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x3 operator & (uint4x3 lhs, uint4x3 rhs) { return new uint4x3 (lhs.c0 & rhs.c0, lhs.c1 & rhs.c1, lhs.c2 & rhs.c2); } + + /// Returns the result of a componentwise bitwise and operation on a uint4x3 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x3 operator & (uint4x3 lhs, uint rhs) { return new uint4x3 (lhs.c0 & rhs, lhs.c1 & rhs, lhs.c2 & rhs); } + + /// Returns the result of a componentwise bitwise and operation on a uint value and a uint4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x3 operator & (uint lhs, uint4x3 rhs) { return new uint4x3 (lhs & rhs.c0, lhs & rhs.c1, lhs & rhs.c2); } + + + /// Returns the result of a componentwise bitwise or operation on two uint4x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x3 operator | (uint4x3 lhs, uint4x3 rhs) { return new uint4x3 (lhs.c0 | rhs.c0, lhs.c1 | rhs.c1, lhs.c2 | rhs.c2); } + + /// Returns the result of a componentwise bitwise or operation on a uint4x3 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x3 operator | (uint4x3 lhs, uint rhs) { return new uint4x3 (lhs.c0 | rhs, lhs.c1 | rhs, lhs.c2 | rhs); } + + /// Returns the result of a componentwise bitwise or operation on a uint value and a uint4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x3 operator | (uint lhs, uint4x3 rhs) { return new uint4x3 (lhs | rhs.c0, lhs | rhs.c1, lhs | rhs.c2); } + + + /// Returns the result of a componentwise bitwise exclusive or operation on two uint4x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x3 operator ^ (uint4x3 lhs, uint4x3 rhs) { return new uint4x3 (lhs.c0 ^ rhs.c0, lhs.c1 ^ rhs.c1, lhs.c2 ^ rhs.c2); } + + /// Returns the result of a componentwise bitwise exclusive or operation on a uint4x3 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x3 operator ^ (uint4x3 lhs, uint rhs) { return new uint4x3 (lhs.c0 ^ rhs, lhs.c1 ^ rhs, lhs.c2 ^ rhs); } + + /// Returns the result of a componentwise bitwise exclusive or operation on a uint value and a uint4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x3 operator ^ (uint lhs, uint4x3 rhs) { return new uint4x3 (lhs ^ rhs.c0, lhs ^ rhs.c1, lhs ^ rhs.c2); } + + + + /// Returns the uint4 element at a specified index. + unsafe public ref uint4 this[int index] + { + get + { +#if ENABLE_UNITY_COLLECTIONS_CHECKS + if ((uint)index >= 3) + throw new System.ArgumentException("index must be between[0...2]"); +#endif + fixed (uint4x3* array = &this) { return ref ((uint4*)array)[index]; } + } + } + + /// Returns true if the uint4x3 is equal to a given uint4x3, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool Equals(uint4x3 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1) && c2.Equals(rhs.c2); } + + /// Returns true if the uint4x3 is equal to a given uint4x3, false otherwise. + public override bool Equals(object o) { return Equals((uint4x3)o); } + + + /// Returns a hash code for the uint4x3. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override int GetHashCode() { return (int)math.hash(this); } + + + /// Returns a string representation of the uint4x3. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override string ToString() + { + return string.Format("uint4x3({0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}, {10}, {11})", c0.x, c1.x, c2.x, c0.y, c1.y, c2.y, c0.z, c1.z, c2.z, c0.w, c1.w, c2.w); + } + + /// Returns a string representation of the uint4x3 using a specified format and culture-specific format information. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public string ToString(string format, IFormatProvider formatProvider) + { + return string.Format("uint4x3({0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}, {10}, {11})", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c2.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider), c2.y.ToString(format, formatProvider), c0.z.ToString(format, formatProvider), c1.z.ToString(format, formatProvider), c2.z.ToString(format, formatProvider), c0.w.ToString(format, formatProvider), c1.w.ToString(format, formatProvider), c2.w.ToString(format, formatProvider)); + } + + } + + public static partial class math + { + /// Returns a uint4x3 matrix constructed from three uint4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x3 uint4x3(uint4 c0, uint4 c1, uint4 c2) { return new uint4x3(c0, c1, c2); } + + /// Returns a uint4x3 matrix constructed from from 12 uint values given in row-major order. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x3 uint4x3(uint m00, uint m01, uint m02, + uint m10, uint m11, uint m12, + uint m20, uint m21, uint m22, + uint m30, uint m31, uint m32) + { + return new uint4x3(m00, m01, m02, + m10, m11, m12, + m20, m21, m22, + m30, m31, m32); + } + + /// Returns a uint4x3 matrix constructed from a single uint value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x3 uint4x3(uint v) { return new uint4x3(v); } + + /// Returns a uint4x3 matrix constructed from a single bool value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x3 uint4x3(bool v) { return new uint4x3(v); } + + /// Return a uint4x3 matrix constructed from a bool4x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x3 uint4x3(bool4x3 v) { return new uint4x3(v); } + + /// Returns a uint4x3 matrix constructed from a single int value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x3 uint4x3(int v) { return new uint4x3(v); } + + /// Return a uint4x3 matrix constructed from a int4x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x3 uint4x3(int4x3 v) { return new uint4x3(v); } + + /// Returns a uint4x3 matrix constructed from a single float value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x3 uint4x3(float v) { return new uint4x3(v); } + + /// Return a uint4x3 matrix constructed from a float4x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x3 uint4x3(float4x3 v) { return new uint4x3(v); } + + /// Returns a uint4x3 matrix constructed from a single double value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x3 uint4x3(double v) { return new uint4x3(v); } + + /// Return a uint4x3 matrix constructed from a double4x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x3 uint4x3(double4x3 v) { return new uint4x3(v); } + + /// Return the uint3x4 transpose of a uint4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x4 transpose(uint4x3 v) + { + return uint3x4( + v.c0.x, v.c0.y, v.c0.z, v.c0.w, + v.c1.x, v.c1.y, v.c1.z, v.c1.w, + v.c2.x, v.c2.y, v.c2.z, v.c2.w); + } + + /// Returns a uint hash code of a uint4x3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint hash(uint4x3 v) + { + return csum(v.c0 * uint4(0xE7579997u, 0xEF7D56C7u, 0x66F38F0Bu, 0x624256A3u) + + v.c1 * uint4(0x5292ADE1u, 0xD2E590E5u, 0xF25BE857u, 0x9BC17CE7u) + + v.c2 * uint4(0xC8B86851u, 0x64095221u, 0xADF428FFu, 0xA3977109u)) + 0x745ED837u; + } + + /// + /// Returns a uint4 vector hash code of a uint4x3 vector. + /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash + /// that are only reduced to a narrow uint hash at the very end instead of at every step. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 hashwide(uint4x3 v) + { + return (v.c0 * uint4(0x9CDC88F5u, 0xFA62D721u, 0x7E4DB1CFu, 0x68EEE0F5u) + + v.c1 * uint4(0xBC3B0A59u, 0x816EFB5Du, 0xA24E82B7u, 0x45A22087u) + + v.c2 * uint4(0xFC104C3Bu, 0x5FFF6B19u, 0x5E6CBF3Bu, 0xB546F2A5u)) + 0xBBCF63E7u; + } + + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/uint4x3.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/uint4x3.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..2f3698df4a71c44deb6c0bb08bdc520f939a625b --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/uint4x3.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 8178bb4bab5354260979dd1f191c22ca +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/uint4x4.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/uint4x4.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..6a17f62b91d6a1ccb8ddd43cd05d6e1b244d35fe --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/uint4x4.gen.cs @@ -0,0 +1,530 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using System; +using System.Runtime.CompilerServices; + +#pragma warning disable 0660, 0661 + +namespace Unity.Mathematics +{ + [System.Serializable] + public partial struct uint4x4 : System.IEquatable, IFormattable + { + public uint4 c0; + public uint4 c1; + public uint4 c2; + public uint4 c3; + + /// uint4x4 identity transform. + public static readonly uint4x4 identity = new uint4x4(1u, 0u, 0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u, 1u); + + /// uint4x4 zero value. + public static readonly uint4x4 zero; + + /// Constructs a uint4x4 matrix from four uint4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4x4(uint4 c0, uint4 c1, uint4 c2, uint4 c3) + { + this.c0 = c0; + this.c1 = c1; + this.c2 = c2; + this.c3 = c3; + } + + /// Constructs a uint4x4 matrix from 16 uint values given in row-major order. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4x4(uint m00, uint m01, uint m02, uint m03, + uint m10, uint m11, uint m12, uint m13, + uint m20, uint m21, uint m22, uint m23, + uint m30, uint m31, uint m32, uint m33) + { + this.c0 = new uint4(m00, m10, m20, m30); + this.c1 = new uint4(m01, m11, m21, m31); + this.c2 = new uint4(m02, m12, m22, m32); + this.c3 = new uint4(m03, m13, m23, m33); + } + + /// Constructs a uint4x4 matrix from a single uint value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4x4(uint v) + { + this.c0 = v; + this.c1 = v; + this.c2 = v; + this.c3 = v; + } + + /// Constructs a uint4x4 matrix from a single bool value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4x4(bool v) + { + this.c0 = math.select(new uint4(0u), new uint4(1u), v); + this.c1 = math.select(new uint4(0u), new uint4(1u), v); + this.c2 = math.select(new uint4(0u), new uint4(1u), v); + this.c3 = math.select(new uint4(0u), new uint4(1u), v); + } + + /// Constructs a uint4x4 matrix from a bool4x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4x4(bool4x4 v) + { + this.c0 = math.select(new uint4(0u), new uint4(1u), v.c0); + this.c1 = math.select(new uint4(0u), new uint4(1u), v.c1); + this.c2 = math.select(new uint4(0u), new uint4(1u), v.c2); + this.c3 = math.select(new uint4(0u), new uint4(1u), v.c3); + } + + /// Constructs a uint4x4 matrix from a single int value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4x4(int v) + { + this.c0 = (uint4)v; + this.c1 = (uint4)v; + this.c2 = (uint4)v; + this.c3 = (uint4)v; + } + + /// Constructs a uint4x4 matrix from a int4x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4x4(int4x4 v) + { + this.c0 = (uint4)v.c0; + this.c1 = (uint4)v.c1; + this.c2 = (uint4)v.c2; + this.c3 = (uint4)v.c3; + } + + /// Constructs a uint4x4 matrix from a single float value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4x4(float v) + { + this.c0 = (uint4)v; + this.c1 = (uint4)v; + this.c2 = (uint4)v; + this.c3 = (uint4)v; + } + + /// Constructs a uint4x4 matrix from a float4x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4x4(float4x4 v) + { + this.c0 = (uint4)v.c0; + this.c1 = (uint4)v.c1; + this.c2 = (uint4)v.c2; + this.c3 = (uint4)v.c3; + } + + /// Constructs a uint4x4 matrix from a single double value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4x4(double v) + { + this.c0 = (uint4)v; + this.c1 = (uint4)v; + this.c2 = (uint4)v; + this.c3 = (uint4)v; + } + + /// Constructs a uint4x4 matrix from a double4x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4x4(double4x4 v) + { + this.c0 = (uint4)v.c0; + this.c1 = (uint4)v.c1; + this.c2 = (uint4)v.c2; + this.c3 = (uint4)v.c3; + } + + + /// Implicitly converts a single uint value to a uint4x4 matrix by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator uint4x4(uint v) { return new uint4x4(v); } + + /// Explicitly converts a single bool value to a uint4x4 matrix by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint4x4(bool v) { return new uint4x4(v); } + + /// Explicitly converts a bool4x4 matrix to a uint4x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint4x4(bool4x4 v) { return new uint4x4(v); } + + /// Explicitly converts a single int value to a uint4x4 matrix by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint4x4(int v) { return new uint4x4(v); } + + /// Explicitly converts a int4x4 matrix to a uint4x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint4x4(int4x4 v) { return new uint4x4(v); } + + /// Explicitly converts a single float value to a uint4x4 matrix by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint4x4(float v) { return new uint4x4(v); } + + /// Explicitly converts a float4x4 matrix to a uint4x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint4x4(float4x4 v) { return new uint4x4(v); } + + /// Explicitly converts a single double value to a uint4x4 matrix by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint4x4(double v) { return new uint4x4(v); } + + /// Explicitly converts a double4x4 matrix to a uint4x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator uint4x4(double4x4 v) { return new uint4x4(v); } + + + /// Returns the result of a componentwise multiplication operation on two uint4x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x4 operator * (uint4x4 lhs, uint4x4 rhs) { return new uint4x4 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1, lhs.c2 * rhs.c2, lhs.c3 * rhs.c3); } + + /// Returns the result of a componentwise multiplication operation on a uint4x4 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x4 operator * (uint4x4 lhs, uint rhs) { return new uint4x4 (lhs.c0 * rhs, lhs.c1 * rhs, lhs.c2 * rhs, lhs.c3 * rhs); } + + /// Returns the result of a componentwise multiplication operation on a uint value and a uint4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x4 operator * (uint lhs, uint4x4 rhs) { return new uint4x4 (lhs * rhs.c0, lhs * rhs.c1, lhs * rhs.c2, lhs * rhs.c3); } + + + /// Returns the result of a componentwise addition operation on two uint4x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x4 operator + (uint4x4 lhs, uint4x4 rhs) { return new uint4x4 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1, lhs.c2 + rhs.c2, lhs.c3 + rhs.c3); } + + /// Returns the result of a componentwise addition operation on a uint4x4 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x4 operator + (uint4x4 lhs, uint rhs) { return new uint4x4 (lhs.c0 + rhs, lhs.c1 + rhs, lhs.c2 + rhs, lhs.c3 + rhs); } + + /// Returns the result of a componentwise addition operation on a uint value and a uint4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x4 operator + (uint lhs, uint4x4 rhs) { return new uint4x4 (lhs + rhs.c0, lhs + rhs.c1, lhs + rhs.c2, lhs + rhs.c3); } + + + /// Returns the result of a componentwise subtraction operation on two uint4x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x4 operator - (uint4x4 lhs, uint4x4 rhs) { return new uint4x4 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1, lhs.c2 - rhs.c2, lhs.c3 - rhs.c3); } + + /// Returns the result of a componentwise subtraction operation on a uint4x4 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x4 operator - (uint4x4 lhs, uint rhs) { return new uint4x4 (lhs.c0 - rhs, lhs.c1 - rhs, lhs.c2 - rhs, lhs.c3 - rhs); } + + /// Returns the result of a componentwise subtraction operation on a uint value and a uint4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x4 operator - (uint lhs, uint4x4 rhs) { return new uint4x4 (lhs - rhs.c0, lhs - rhs.c1, lhs - rhs.c2, lhs - rhs.c3); } + + + /// Returns the result of a componentwise division operation on two uint4x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x4 operator / (uint4x4 lhs, uint4x4 rhs) { return new uint4x4 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1, lhs.c2 / rhs.c2, lhs.c3 / rhs.c3); } + + /// Returns the result of a componentwise division operation on a uint4x4 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x4 operator / (uint4x4 lhs, uint rhs) { return new uint4x4 (lhs.c0 / rhs, lhs.c1 / rhs, lhs.c2 / rhs, lhs.c3 / rhs); } + + /// Returns the result of a componentwise division operation on a uint value and a uint4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x4 operator / (uint lhs, uint4x4 rhs) { return new uint4x4 (lhs / rhs.c0, lhs / rhs.c1, lhs / rhs.c2, lhs / rhs.c3); } + + + /// Returns the result of a componentwise modulus operation on two uint4x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x4 operator % (uint4x4 lhs, uint4x4 rhs) { return new uint4x4 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1, lhs.c2 % rhs.c2, lhs.c3 % rhs.c3); } + + /// Returns the result of a componentwise modulus operation on a uint4x4 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x4 operator % (uint4x4 lhs, uint rhs) { return new uint4x4 (lhs.c0 % rhs, lhs.c1 % rhs, lhs.c2 % rhs, lhs.c3 % rhs); } + + /// Returns the result of a componentwise modulus operation on a uint value and a uint4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x4 operator % (uint lhs, uint4x4 rhs) { return new uint4x4 (lhs % rhs.c0, lhs % rhs.c1, lhs % rhs.c2, lhs % rhs.c3); } + + + /// Returns the result of a componentwise increment operation on a uint4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x4 operator ++ (uint4x4 val) { return new uint4x4 (++val.c0, ++val.c1, ++val.c2, ++val.c3); } + + + /// Returns the result of a componentwise decrement operation on a uint4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x4 operator -- (uint4x4 val) { return new uint4x4 (--val.c0, --val.c1, --val.c2, --val.c3); } + + + /// Returns the result of a componentwise less than operation on two uint4x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator < (uint4x4 lhs, uint4x4 rhs) { return new bool4x4 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1, lhs.c2 < rhs.c2, lhs.c3 < rhs.c3); } + + /// Returns the result of a componentwise less than operation on a uint4x4 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator < (uint4x4 lhs, uint rhs) { return new bool4x4 (lhs.c0 < rhs, lhs.c1 < rhs, lhs.c2 < rhs, lhs.c3 < rhs); } + + /// Returns the result of a componentwise less than operation on a uint value and a uint4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator < (uint lhs, uint4x4 rhs) { return new bool4x4 (lhs < rhs.c0, lhs < rhs.c1, lhs < rhs.c2, lhs < rhs.c3); } + + + /// Returns the result of a componentwise less or equal operation on two uint4x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator <= (uint4x4 lhs, uint4x4 rhs) { return new bool4x4 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1, lhs.c2 <= rhs.c2, lhs.c3 <= rhs.c3); } + + /// Returns the result of a componentwise less or equal operation on a uint4x4 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator <= (uint4x4 lhs, uint rhs) { return new bool4x4 (lhs.c0 <= rhs, lhs.c1 <= rhs, lhs.c2 <= rhs, lhs.c3 <= rhs); } + + /// Returns the result of a componentwise less or equal operation on a uint value and a uint4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator <= (uint lhs, uint4x4 rhs) { return new bool4x4 (lhs <= rhs.c0, lhs <= rhs.c1, lhs <= rhs.c2, lhs <= rhs.c3); } + + + /// Returns the result of a componentwise greater than operation on two uint4x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator > (uint4x4 lhs, uint4x4 rhs) { return new bool4x4 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1, lhs.c2 > rhs.c2, lhs.c3 > rhs.c3); } + + /// Returns the result of a componentwise greater than operation on a uint4x4 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator > (uint4x4 lhs, uint rhs) { return new bool4x4 (lhs.c0 > rhs, lhs.c1 > rhs, lhs.c2 > rhs, lhs.c3 > rhs); } + + /// Returns the result of a componentwise greater than operation on a uint value and a uint4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator > (uint lhs, uint4x4 rhs) { return new bool4x4 (lhs > rhs.c0, lhs > rhs.c1, lhs > rhs.c2, lhs > rhs.c3); } + + + /// Returns the result of a componentwise greater or equal operation on two uint4x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator >= (uint4x4 lhs, uint4x4 rhs) { return new bool4x4 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1, lhs.c2 >= rhs.c2, lhs.c3 >= rhs.c3); } + + /// Returns the result of a componentwise greater or equal operation on a uint4x4 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator >= (uint4x4 lhs, uint rhs) { return new bool4x4 (lhs.c0 >= rhs, lhs.c1 >= rhs, lhs.c2 >= rhs, lhs.c3 >= rhs); } + + /// Returns the result of a componentwise greater or equal operation on a uint value and a uint4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator >= (uint lhs, uint4x4 rhs) { return new bool4x4 (lhs >= rhs.c0, lhs >= rhs.c1, lhs >= rhs.c2, lhs >= rhs.c3); } + + + /// Returns the result of a componentwise unary minus operation on a uint4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x4 operator - (uint4x4 val) { return new uint4x4 (-val.c0, -val.c1, -val.c2, -val.c3); } + + + /// Returns the result of a componentwise unary plus operation on a uint4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x4 operator + (uint4x4 val) { return new uint4x4 (+val.c0, +val.c1, +val.c2, +val.c3); } + + + /// Returns the result of a componentwise left shift operation on a uint4x4 matrix by a number of bits specified by a single int. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x4 operator << (uint4x4 x, int n) { return new uint4x4 (x.c0 << n, x.c1 << n, x.c2 << n, x.c3 << n); } + + /// Returns the result of a componentwise right shift operation on a uint4x4 matrix by a number of bits specified by a single int. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x4 operator >> (uint4x4 x, int n) { return new uint4x4 (x.c0 >> n, x.c1 >> n, x.c2 >> n, x.c3 >> n); } + + /// Returns the result of a componentwise equality operation on two uint4x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator == (uint4x4 lhs, uint4x4 rhs) { return new bool4x4 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1, lhs.c2 == rhs.c2, lhs.c3 == rhs.c3); } + + /// Returns the result of a componentwise equality operation on a uint4x4 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator == (uint4x4 lhs, uint rhs) { return new bool4x4 (lhs.c0 == rhs, lhs.c1 == rhs, lhs.c2 == rhs, lhs.c3 == rhs); } + + /// Returns the result of a componentwise equality operation on a uint value and a uint4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator == (uint lhs, uint4x4 rhs) { return new bool4x4 (lhs == rhs.c0, lhs == rhs.c1, lhs == rhs.c2, lhs == rhs.c3); } + + + /// Returns the result of a componentwise not equal operation on two uint4x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator != (uint4x4 lhs, uint4x4 rhs) { return new bool4x4 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1, lhs.c2 != rhs.c2, lhs.c3 != rhs.c3); } + + /// Returns the result of a componentwise not equal operation on a uint4x4 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator != (uint4x4 lhs, uint rhs) { return new bool4x4 (lhs.c0 != rhs, lhs.c1 != rhs, lhs.c2 != rhs, lhs.c3 != rhs); } + + /// Returns the result of a componentwise not equal operation on a uint value and a uint4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator != (uint lhs, uint4x4 rhs) { return new bool4x4 (lhs != rhs.c0, lhs != rhs.c1, lhs != rhs.c2, lhs != rhs.c3); } + + + /// Returns the result of a componentwise bitwise not operation on a uint4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x4 operator ~ (uint4x4 val) { return new uint4x4 (~val.c0, ~val.c1, ~val.c2, ~val.c3); } + + + /// Returns the result of a componentwise bitwise and operation on two uint4x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x4 operator & (uint4x4 lhs, uint4x4 rhs) { return new uint4x4 (lhs.c0 & rhs.c0, lhs.c1 & rhs.c1, lhs.c2 & rhs.c2, lhs.c3 & rhs.c3); } + + /// Returns the result of a componentwise bitwise and operation on a uint4x4 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x4 operator & (uint4x4 lhs, uint rhs) { return new uint4x4 (lhs.c0 & rhs, lhs.c1 & rhs, lhs.c2 & rhs, lhs.c3 & rhs); } + + /// Returns the result of a componentwise bitwise and operation on a uint value and a uint4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x4 operator & (uint lhs, uint4x4 rhs) { return new uint4x4 (lhs & rhs.c0, lhs & rhs.c1, lhs & rhs.c2, lhs & rhs.c3); } + + + /// Returns the result of a componentwise bitwise or operation on two uint4x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x4 operator | (uint4x4 lhs, uint4x4 rhs) { return new uint4x4 (lhs.c0 | rhs.c0, lhs.c1 | rhs.c1, lhs.c2 | rhs.c2, lhs.c3 | rhs.c3); } + + /// Returns the result of a componentwise bitwise or operation on a uint4x4 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x4 operator | (uint4x4 lhs, uint rhs) { return new uint4x4 (lhs.c0 | rhs, lhs.c1 | rhs, lhs.c2 | rhs, lhs.c3 | rhs); } + + /// Returns the result of a componentwise bitwise or operation on a uint value and a uint4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x4 operator | (uint lhs, uint4x4 rhs) { return new uint4x4 (lhs | rhs.c0, lhs | rhs.c1, lhs | rhs.c2, lhs | rhs.c3); } + + + /// Returns the result of a componentwise bitwise exclusive or operation on two uint4x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x4 operator ^ (uint4x4 lhs, uint4x4 rhs) { return new uint4x4 (lhs.c0 ^ rhs.c0, lhs.c1 ^ rhs.c1, lhs.c2 ^ rhs.c2, lhs.c3 ^ rhs.c3); } + + /// Returns the result of a componentwise bitwise exclusive or operation on a uint4x4 matrix and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x4 operator ^ (uint4x4 lhs, uint rhs) { return new uint4x4 (lhs.c0 ^ rhs, lhs.c1 ^ rhs, lhs.c2 ^ rhs, lhs.c3 ^ rhs); } + + /// Returns the result of a componentwise bitwise exclusive or operation on a uint value and a uint4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x4 operator ^ (uint lhs, uint4x4 rhs) { return new uint4x4 (lhs ^ rhs.c0, lhs ^ rhs.c1, lhs ^ rhs.c2, lhs ^ rhs.c3); } + + + + /// Returns the uint4 element at a specified index. + unsafe public ref uint4 this[int index] + { + get + { +#if ENABLE_UNITY_COLLECTIONS_CHECKS + if ((uint)index >= 4) + throw new System.ArgumentException("index must be between[0...3]"); +#endif + fixed (uint4x4* array = &this) { return ref ((uint4*)array)[index]; } + } + } + + /// Returns true if the uint4x4 is equal to a given uint4x4, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool Equals(uint4x4 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1) && c2.Equals(rhs.c2) && c3.Equals(rhs.c3); } + + /// Returns true if the uint4x4 is equal to a given uint4x4, false otherwise. + public override bool Equals(object o) { return Equals((uint4x4)o); } + + + /// Returns a hash code for the uint4x4. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override int GetHashCode() { return (int)math.hash(this); } + + + /// Returns a string representation of the uint4x4. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override string ToString() + { + return string.Format("uint4x4({0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}, {10}, {11}, {12}, {13}, {14}, {15})", c0.x, c1.x, c2.x, c3.x, c0.y, c1.y, c2.y, c3.y, c0.z, c1.z, c2.z, c3.z, c0.w, c1.w, c2.w, c3.w); + } + + /// Returns a string representation of the uint4x4 using a specified format and culture-specific format information. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public string ToString(string format, IFormatProvider formatProvider) + { + return string.Format("uint4x4({0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}, {10}, {11}, {12}, {13}, {14}, {15})", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c2.x.ToString(format, formatProvider), c3.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider), c2.y.ToString(format, formatProvider), c3.y.ToString(format, formatProvider), c0.z.ToString(format, formatProvider), c1.z.ToString(format, formatProvider), c2.z.ToString(format, formatProvider), c3.z.ToString(format, formatProvider), c0.w.ToString(format, formatProvider), c1.w.ToString(format, formatProvider), c2.w.ToString(format, formatProvider), c3.w.ToString(format, formatProvider)); + } + + } + + public static partial class math + { + /// Returns a uint4x4 matrix constructed from four uint4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x4 uint4x4(uint4 c0, uint4 c1, uint4 c2, uint4 c3) { return new uint4x4(c0, c1, c2, c3); } + + /// Returns a uint4x4 matrix constructed from from 16 uint values given in row-major order. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x4 uint4x4(uint m00, uint m01, uint m02, uint m03, + uint m10, uint m11, uint m12, uint m13, + uint m20, uint m21, uint m22, uint m23, + uint m30, uint m31, uint m32, uint m33) + { + return new uint4x4(m00, m01, m02, m03, + m10, m11, m12, m13, + m20, m21, m22, m23, + m30, m31, m32, m33); + } + + /// Returns a uint4x4 matrix constructed from a single uint value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x4 uint4x4(uint v) { return new uint4x4(v); } + + /// Returns a uint4x4 matrix constructed from a single bool value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x4 uint4x4(bool v) { return new uint4x4(v); } + + /// Return a uint4x4 matrix constructed from a bool4x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x4 uint4x4(bool4x4 v) { return new uint4x4(v); } + + /// Returns a uint4x4 matrix constructed from a single int value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x4 uint4x4(int v) { return new uint4x4(v); } + + /// Return a uint4x4 matrix constructed from a int4x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x4 uint4x4(int4x4 v) { return new uint4x4(v); } + + /// Returns a uint4x4 matrix constructed from a single float value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x4 uint4x4(float v) { return new uint4x4(v); } + + /// Return a uint4x4 matrix constructed from a float4x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x4 uint4x4(float4x4 v) { return new uint4x4(v); } + + /// Returns a uint4x4 matrix constructed from a single double value by converting it to uint and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x4 uint4x4(double v) { return new uint4x4(v); } + + /// Return a uint4x4 matrix constructed from a double4x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x4 uint4x4(double4x4 v) { return new uint4x4(v); } + + /// Return the uint4x4 transpose of a uint4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x4 transpose(uint4x4 v) + { + return uint4x4( + v.c0.x, v.c0.y, v.c0.z, v.c0.w, + v.c1.x, v.c1.y, v.c1.z, v.c1.w, + v.c2.x, v.c2.y, v.c2.z, v.c2.w, + v.c3.x, v.c3.y, v.c3.z, v.c3.w); + } + + /// Returns a uint hash code of a uint4x4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint hash(uint4x4 v) + { + return csum(v.c0 * uint4(0x9C9F0823u, 0x5A9CA13Bu, 0xAFCDD5EFu, 0xA88D187Du) + + v.c1 * uint4(0xCF6EBA1Du, 0x9D88E5A1u, 0xEADF0775u, 0x747A9D7Bu) + + v.c2 * uint4(0x4111F799u, 0xB5F05AF1u, 0xFD80290Bu, 0x8B65ADB7u) + + v.c3 * uint4(0xDFF4F563u, 0x7069770Du, 0xD1224537u, 0xE99ED6F3u)) + 0x48125549u; + } + + /// + /// Returns a uint4 vector hash code of a uint4x4 vector. + /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash + /// that are only reduced to a narrow uint hash at the very end instead of at every step. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 hashwide(uint4x4 v) + { + return (v.c0 * uint4(0xEEE2123Bu, 0xE3AD9FE5u, 0xCE1CF8BFu, 0x7BE39F3Bu) + + v.c1 * uint4(0xFAB9913Fu, 0xB4501269u, 0xE04B89FDu, 0xDB3DE101u) + + v.c2 * uint4(0x7B6D1B4Bu, 0x58399E77u, 0x5EAC29C9u, 0xFC6014F9u) + + v.c3 * uint4(0x6BF6693Fu, 0x9D1B1D9Bu, 0xF842F5C1u, 0xA47EC335u)) + 0xA477DF57u; + } + + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/uint4x4.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/uint4x4.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..87a472336b962fcd5f27c37e861423efd3622aa5 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/uint4x4.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 1878454c2f73547909bfcea105ffd941 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: