Add files using upload-large-folder tool

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<string> k_ColPropertyPaths =
+            new ReadOnlyCollection<string>(new[] { "c0", "c1", "c2", "c3" });
+        static ReadOnlyCollection<string> k_RowPropertyPaths =
+            new ReadOnlyCollection<string>(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<SerializedPropertyType, Action<SerializedProperty, bool>> k_UtilityValueSetters =
+            new Dictionary<SerializedPropertyType, Action<SerializedProperty, bool>>
+            {
+                { 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();
+        }
+    }
+}

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: 

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<string> 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<SerializedProperty, double4> m_PostNormalizedValues = new Dictionary<SerializedProperty, double4>();
+
+            public VectorPropertyGUIData(SerializedProperty property)
+            {
+                m_VectorProperty = property;
+                var parentPath = m_VectorProperty.propertyPath;
+                var i = 0;
+                var elementPaths = new List<string>(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<double4, double4> 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<string, VectorPropertyGUIData> m_GUIDataPerPropertyPath = new Dictionary<string, VectorPropertyGUIData>();
+
+        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();
+            }
+        }
+    }
+}

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
+}

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: 

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: 

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 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using System;
+using System.Runtime.CompilerServices;
+
+#pragma warning disable 0660, 0661
+
+namespace Unity.Mathematics
+{
+    [System.Serializable]
+    public partial struct uint3x2 : System.IEquatable<uint3x2>, IFormattable
+    {
+        public uint3 c0;
+        public uint3 c1;
+
+        /// <summary>uint3x2 zero value.</summary>
+        public static readonly uint3x2 zero;
+
+        /// <summary>Constructs a uint3x2 matrix from two uint3 vectors.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint3x2(uint3 c0, uint3 c1)
+        { 
+            this.c0 = c0;
+            this.c1 = c1;
+        }
+
+        /// <summary>Constructs a uint3x2 matrix from 6 uint values given in row-major order.</summary>
+        [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);
+        }
+
+        /// <summary>Constructs a uint3x2 matrix from a single uint value by assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint3x2(uint v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+        }
+
+        /// <summary>Constructs a uint3x2 matrix from a single bool value by converting it to uint and assigning it to every component.</summary>
+        [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);
+        }
+
+        /// <summary>Constructs a uint3x2 matrix from a bool3x2 matrix by componentwise conversion.</summary>
+        [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);
+        }
+
+        /// <summary>Constructs a uint3x2 matrix from a single int value by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint3x2(int v)
+        {
+            this.c0 = (uint3)v;
+            this.c1 = (uint3)v;
+        }
+
+        /// <summary>Constructs a uint3x2 matrix from a int3x2 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint3x2(int3x2 v)
+        {
+            this.c0 = (uint3)v.c0;
+            this.c1 = (uint3)v.c1;
+        }
+
+        /// <summary>Constructs a uint3x2 matrix from a single float value by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint3x2(float v)
+        {
+            this.c0 = (uint3)v;
+            this.c1 = (uint3)v;
+        }
+
+        /// <summary>Constructs a uint3x2 matrix from a float3x2 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint3x2(float3x2 v)
+        {
+            this.c0 = (uint3)v.c0;
+            this.c1 = (uint3)v.c1;
+        }
+
+        /// <summary>Constructs a uint3x2 matrix from a single double value by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint3x2(double v)
+        {
+            this.c0 = (uint3)v;
+            this.c1 = (uint3)v;
+        }
+
+        /// <summary>Constructs a uint3x2 matrix from a double3x2 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint3x2(double3x2 v)
+        {
+            this.c0 = (uint3)v.c0;
+            this.c1 = (uint3)v.c1;
+        }
+
+
+        /// <summary>Implicitly converts a single uint value to a uint3x2 matrix by assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator uint3x2(uint v) { return new uint3x2(v); }
+
+        /// <summary>Explicitly converts a single bool value to a uint3x2 matrix by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator uint3x2(bool v) { return new uint3x2(v); }
+
+        /// <summary>Explicitly converts a bool3x2 matrix to a uint3x2 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator uint3x2(bool3x2 v) { return new uint3x2(v); }
+
+        /// <summary>Explicitly converts a single int value to a uint3x2 matrix by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator uint3x2(int v) { return new uint3x2(v); }
+
+        /// <summary>Explicitly converts a int3x2 matrix to a uint3x2 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator uint3x2(int3x2 v) { return new uint3x2(v); }
+
+        /// <summary>Explicitly converts a single float value to a uint3x2 matrix by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator uint3x2(float v) { return new uint3x2(v); }
+
+        /// <summary>Explicitly converts a float3x2 matrix to a uint3x2 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator uint3x2(float3x2 v) { return new uint3x2(v); }
+
+        /// <summary>Explicitly converts a single double value to a uint3x2 matrix by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator uint3x2(double v) { return new uint3x2(v); }
+
+        /// <summary>Explicitly converts a double3x2 matrix to a uint3x2 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator uint3x2(double3x2 v) { return new uint3x2(v); }
+
+
+        /// <summary>Returns the result of a componentwise multiplication operation on two uint3x2 matrices.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x2 operator * (uint3x2 lhs, uint3x2 rhs) { return new uint3x2 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise multiplication operation on a uint3x2 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x2 operator * (uint3x2 lhs, uint rhs) { return new uint3x2 (lhs.c0 * rhs, lhs.c1 * rhs); }
+
+        /// <summary>Returns the result of a componentwise multiplication operation on a uint value and a uint3x2 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x2 operator * (uint lhs, uint3x2 rhs) { return new uint3x2 (lhs * rhs.c0, lhs * rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise addition operation on two uint3x2 matrices.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x2 operator + (uint3x2 lhs, uint3x2 rhs) { return new uint3x2 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise addition operation on a uint3x2 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x2 operator + (uint3x2 lhs, uint rhs) { return new uint3x2 (lhs.c0 + rhs, lhs.c1 + rhs); }
+
+        /// <summary>Returns the result of a componentwise addition operation on a uint value and a uint3x2 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x2 operator + (uint lhs, uint3x2 rhs) { return new uint3x2 (lhs + rhs.c0, lhs + rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise subtraction operation on two uint3x2 matrices.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x2 operator - (uint3x2 lhs, uint3x2 rhs) { return new uint3x2 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise subtraction operation on a uint3x2 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x2 operator - (uint3x2 lhs, uint rhs) { return new uint3x2 (lhs.c0 - rhs, lhs.c1 - rhs); }
+
+        /// <summary>Returns the result of a componentwise subtraction operation on a uint value and a uint3x2 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x2 operator - (uint lhs, uint3x2 rhs) { return new uint3x2 (lhs - rhs.c0, lhs - rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise division operation on two uint3x2 matrices.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x2 operator / (uint3x2 lhs, uint3x2 rhs) { return new uint3x2 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise division operation on a uint3x2 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x2 operator / (uint3x2 lhs, uint rhs) { return new uint3x2 (lhs.c0 / rhs, lhs.c1 / rhs); }
+
+        /// <summary>Returns the result of a componentwise division operation on a uint value and a uint3x2 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x2 operator / (uint lhs, uint3x2 rhs) { return new uint3x2 (lhs / rhs.c0, lhs / rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise modulus operation on two uint3x2 matrices.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x2 operator % (uint3x2 lhs, uint3x2 rhs) { return new uint3x2 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise modulus operation on a uint3x2 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x2 operator % (uint3x2 lhs, uint rhs) { return new uint3x2 (lhs.c0 % rhs, lhs.c1 % rhs); }
+
+        /// <summary>Returns the result of a componentwise modulus operation on a uint value and a uint3x2 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x2 operator % (uint lhs, uint3x2 rhs) { return new uint3x2 (lhs % rhs.c0, lhs % rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise increment operation on a uint3x2 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x2 operator ++ (uint3x2 val) { return new uint3x2 (++val.c0, ++val.c1); }
+
+
+        /// <summary>Returns the result of a componentwise decrement operation on a uint3x2 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x2 operator -- (uint3x2 val) { return new uint3x2 (--val.c0, --val.c1); }
+
+
+        /// <summary>Returns the result of a componentwise less than operation on two uint3x2 matrices.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator < (uint3x2 lhs, uint3x2 rhs) { return new bool3x2 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise less than operation on a uint3x2 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator < (uint3x2 lhs, uint rhs) { return new bool3x2 (lhs.c0 < rhs, lhs.c1 < rhs); }
+
+        /// <summary>Returns the result of a componentwise less than operation on a uint value and a uint3x2 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator < (uint lhs, uint3x2 rhs) { return new bool3x2 (lhs < rhs.c0, lhs < rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise less or equal operation on two uint3x2 matrices.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator <= (uint3x2 lhs, uint3x2 rhs) { return new bool3x2 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise less or equal operation on a uint3x2 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator <= (uint3x2 lhs, uint rhs) { return new bool3x2 (lhs.c0 <= rhs, lhs.c1 <= rhs); }
+
+        /// <summary>Returns the result of a componentwise less or equal operation on a uint value and a uint3x2 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator <= (uint lhs, uint3x2 rhs) { return new bool3x2 (lhs <= rhs.c0, lhs <= rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise greater than operation on two uint3x2 matrices.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator > (uint3x2 lhs, uint3x2 rhs) { return new bool3x2 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise greater than operation on a uint3x2 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator > (uint3x2 lhs, uint rhs) { return new bool3x2 (lhs.c0 > rhs, lhs.c1 > rhs); }
+
+        /// <summary>Returns the result of a componentwise greater than operation on a uint value and a uint3x2 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator > (uint lhs, uint3x2 rhs) { return new bool3x2 (lhs > rhs.c0, lhs > rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on two uint3x2 matrices.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator >= (uint3x2 lhs, uint3x2 rhs) { return new bool3x2 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on a uint3x2 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator >= (uint3x2 lhs, uint rhs) { return new bool3x2 (lhs.c0 >= rhs, lhs.c1 >= rhs); }
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on a uint value and a uint3x2 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator >= (uint lhs, uint3x2 rhs) { return new bool3x2 (lhs >= rhs.c0, lhs >= rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise unary minus operation on a uint3x2 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x2 operator - (uint3x2 val) { return new uint3x2 (-val.c0, -val.c1); }
+
+
+        /// <summary>Returns the result of a componentwise unary plus operation on a uint3x2 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x2 operator + (uint3x2 val) { return new uint3x2 (+val.c0, +val.c1); }
+
+
+        /// <summary>Returns the result of a componentwise left shift operation on a uint3x2 matrix by a number of bits specified by a single int.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x2 operator << (uint3x2 x, int n) { return new uint3x2 (x.c0 << n, x.c1 << n); }
+
+        /// <summary>Returns the result of a componentwise right shift operation on a uint3x2 matrix by a number of bits specified by a single int.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x2 operator >> (uint3x2 x, int n) { return new uint3x2 (x.c0 >> n, x.c1 >> n); }
+
+        /// <summary>Returns the result of a componentwise equality operation on two uint3x2 matrices.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator == (uint3x2 lhs, uint3x2 rhs) { return new bool3x2 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a uint3x2 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator == (uint3x2 lhs, uint rhs) { return new bool3x2 (lhs.c0 == rhs, lhs.c1 == rhs); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a uint value and a uint3x2 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator == (uint lhs, uint3x2 rhs) { return new bool3x2 (lhs == rhs.c0, lhs == rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise not equal operation on two uint3x2 matrices.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator != (uint3x2 lhs, uint3x2 rhs) { return new bool3x2 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a uint3x2 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator != (uint3x2 lhs, uint rhs) { return new bool3x2 (lhs.c0 != rhs, lhs.c1 != rhs); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a uint value and a uint3x2 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator != (uint lhs, uint3x2 rhs) { return new bool3x2 (lhs != rhs.c0, lhs != rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise not operation on a uint3x2 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x2 operator ~ (uint3x2 val) { return new uint3x2 (~val.c0, ~val.c1); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise and operation on two uint3x2 matrices.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x2 operator & (uint3x2 lhs, uint3x2 rhs) { return new uint3x2 (lhs.c0 & rhs.c0, lhs.c1 & rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise bitwise and operation on a uint3x2 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x2 operator & (uint3x2 lhs, uint rhs) { return new uint3x2 (lhs.c0 & rhs, lhs.c1 & rhs); }
+
+        /// <summary>Returns the result of a componentwise bitwise and operation on a uint value and a uint3x2 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x2 operator & (uint lhs, uint3x2 rhs) { return new uint3x2 (lhs & rhs.c0, lhs & rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise or operation on two uint3x2 matrices.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x2 operator | (uint3x2 lhs, uint3x2 rhs) { return new uint3x2 (lhs.c0 | rhs.c0, lhs.c1 | rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise bitwise or operation on a uint3x2 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x2 operator | (uint3x2 lhs, uint rhs) { return new uint3x2 (lhs.c0 | rhs, lhs.c1 | rhs); }
+
+        /// <summary>Returns the result of a componentwise bitwise or operation on a uint value and a uint3x2 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x2 operator | (uint lhs, uint3x2 rhs) { return new uint3x2 (lhs | rhs.c0, lhs | rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise exclusive or operation on two uint3x2 matrices.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x2 operator ^ (uint3x2 lhs, uint3x2 rhs) { return new uint3x2 (lhs.c0 ^ rhs.c0, lhs.c1 ^ rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise bitwise exclusive or operation on a uint3x2 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x2 operator ^ (uint3x2 lhs, uint rhs) { return new uint3x2 (lhs.c0 ^ rhs, lhs.c1 ^ rhs); }
+
+        /// <summary>Returns the result of a componentwise bitwise exclusive or operation on a uint value and a uint3x2 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x2 operator ^ (uint lhs, uint3x2 rhs) { return new uint3x2 (lhs ^ rhs.c0, lhs ^ rhs.c1); }
+
+
+
+        /// <summary>Returns the uint3 element at a specified index.</summary>
+        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]; }
+            }
+        }
+
+        /// <summary>Returns true if the uint3x2 is equal to a given uint3x2, false otherwise.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool Equals(uint3x2 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1); }
+
+        /// <summary>Returns true if the uint3x2 is equal to a given uint3x2, false otherwise.</summary>
+        public override bool Equals(object o) { return Equals((uint3x2)o); }
+
+
+        /// <summary>Returns a hash code for the uint3x2.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override int GetHashCode() { return (int)math.hash(this); }
+
+
+        /// <summary>Returns a string representation of the uint3x2.</summary>
+        [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);
+        }
+
+        /// <summary>Returns a string representation of the uint3x2 using a specified format and culture-specific format information.</summary>
+        [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
+    {
+        /// <summary>Returns a uint3x2 matrix constructed from two uint3 vectors.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x2 uint3x2(uint3 c0, uint3 c1) { return new uint3x2(c0, c1); }
+
+        /// <summary>Returns a uint3x2 matrix constructed from from 6 uint values given in row-major order.</summary>
+        [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);
+        }
+
+        /// <summary>Returns a uint3x2 matrix constructed from a single uint value by assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x2 uint3x2(uint v) { return new uint3x2(v); }
+
+        /// <summary>Returns a uint3x2 matrix constructed from a single bool value by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x2 uint3x2(bool v) { return new uint3x2(v); }
+
+        /// <summary>Return a uint3x2 matrix constructed from a bool3x2 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x2 uint3x2(bool3x2 v) { return new uint3x2(v); }
+
+        /// <summary>Returns a uint3x2 matrix constructed from a single int value by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x2 uint3x2(int v) { return new uint3x2(v); }
+
+        /// <summary>Return a uint3x2 matrix constructed from a int3x2 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x2 uint3x2(int3x2 v) { return new uint3x2(v); }
+
+        /// <summary>Returns a uint3x2 matrix constructed from a single float value by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x2 uint3x2(float v) { return new uint3x2(v); }
+
+        /// <summary>Return a uint3x2 matrix constructed from a float3x2 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x2 uint3x2(float3x2 v) { return new uint3x2(v); }
+
+        /// <summary>Returns a uint3x2 matrix constructed from a single double value by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x2 uint3x2(double v) { return new uint3x2(v); }
+
+        /// <summary>Return a uint3x2 matrix constructed from a double3x2 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x2 uint3x2(double3x2 v) { return new uint3x2(v); }
+
+        /// <summary>Return the uint2x3 transpose of a uint3x2 matrix.</summary>
+        [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);
+        }
+
+        /// <summary>Returns a uint hash code of a uint3x2 vector.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint hash(uint3x2 v)
+        {
+            return csum(v.c0 * uint3(0x515D90F5u, 0xEC9F68F3u, 0xF9EA92D5u) + 
+                        v.c1 * uint3(0xC2FAFCB9u, 0x616E9CA1u, 0xC5C5394Bu)) + 0xCAE78587u;
+        }
+
+        /// <summary>
+        /// 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.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3 hashwide(uint3x2 v)
+        {
+            return (v.c0 * uint3(0x7A1541C9u, 0xF83BD927u, 0x6A243BCBu) + 
+                    v.c1 * uint3(0x509B84C9u, 0x91D13847u, 0x52F7230Fu)) + 0xCF286E83u;
+        }
+
+    }
+}

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: 

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 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using System;
+using System.Runtime.CompilerServices;
+
+#pragma warning disable 0660, 0661
+
+namespace Unity.Mathematics
+{
+    [System.Serializable]
+    public partial struct uint3x3 : System.IEquatable<uint3x3>, IFormattable
+    {
+        public uint3 c0;
+        public uint3 c1;
+        public uint3 c2;
+
+        /// <summary>uint3x3 identity transform.</summary>
+        public static readonly uint3x3 identity = new uint3x3(1u, 0u, 0u,   0u, 1u, 0u,   0u, 0u, 1u);
+
+        /// <summary>uint3x3 zero value.</summary>
+        public static readonly uint3x3 zero;
+
+        /// <summary>Constructs a uint3x3 matrix from three uint3 vectors.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint3x3(uint3 c0, uint3 c1, uint3 c2)
+        { 
+            this.c0 = c0;
+            this.c1 = c1;
+            this.c2 = c2;
+        }
+
+        /// <summary>Constructs a uint3x3 matrix from 9 uint values given in row-major order.</summary>
+        [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);
+        }
+
+        /// <summary>Constructs a uint3x3 matrix from a single uint value by assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint3x3(uint v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+            this.c2 = v;
+        }
+
+        /// <summary>Constructs a uint3x3 matrix from a single bool value by converting it to uint and assigning it to every component.</summary>
+        [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);
+        }
+
+        /// <summary>Constructs a uint3x3 matrix from a bool3x3 matrix by componentwise conversion.</summary>
+        [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);
+        }
+
+        /// <summary>Constructs a uint3x3 matrix from a single int value by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint3x3(int v)
+        {
+            this.c0 = (uint3)v;
+            this.c1 = (uint3)v;
+            this.c2 = (uint3)v;
+        }
+
+        /// <summary>Constructs a uint3x3 matrix from a int3x3 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint3x3(int3x3 v)
+        {
+            this.c0 = (uint3)v.c0;
+            this.c1 = (uint3)v.c1;
+            this.c2 = (uint3)v.c2;
+        }
+
+        /// <summary>Constructs a uint3x3 matrix from a single float value by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint3x3(float v)
+        {
+            this.c0 = (uint3)v;
+            this.c1 = (uint3)v;
+            this.c2 = (uint3)v;
+        }
+
+        /// <summary>Constructs a uint3x3 matrix from a float3x3 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint3x3(float3x3 v)
+        {
+            this.c0 = (uint3)v.c0;
+            this.c1 = (uint3)v.c1;
+            this.c2 = (uint3)v.c2;
+        }
+
+        /// <summary>Constructs a uint3x3 matrix from a single double value by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint3x3(double v)
+        {
+            this.c0 = (uint3)v;
+            this.c1 = (uint3)v;
+            this.c2 = (uint3)v;
+        }
+
+        /// <summary>Constructs a uint3x3 matrix from a double3x3 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint3x3(double3x3 v)
+        {
+            this.c0 = (uint3)v.c0;
+            this.c1 = (uint3)v.c1;
+            this.c2 = (uint3)v.c2;
+        }
+
+
+        /// <summary>Implicitly converts a single uint value to a uint3x3 matrix by assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator uint3x3(uint v) { return new uint3x3(v); }
+
+        /// <summary>Explicitly converts a single bool value to a uint3x3 matrix by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator uint3x3(bool v) { return new uint3x3(v); }
+
+        /// <summary>Explicitly converts a bool3x3 matrix to a uint3x3 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator uint3x3(bool3x3 v) { return new uint3x3(v); }
+
+        /// <summary>Explicitly converts a single int value to a uint3x3 matrix by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator uint3x3(int v) { return new uint3x3(v); }
+
+        /// <summary>Explicitly converts a int3x3 matrix to a uint3x3 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator uint3x3(int3x3 v) { return new uint3x3(v); }
+
+        /// <summary>Explicitly converts a single float value to a uint3x3 matrix by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator uint3x3(float v) { return new uint3x3(v); }
+
+        /// <summary>Explicitly converts a float3x3 matrix to a uint3x3 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator uint3x3(float3x3 v) { return new uint3x3(v); }
+
+        /// <summary>Explicitly converts a single double value to a uint3x3 matrix by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator uint3x3(double v) { return new uint3x3(v); }
+
+        /// <summary>Explicitly converts a double3x3 matrix to a uint3x3 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator uint3x3(double3x3 v) { return new uint3x3(v); }
+
+
+        /// <summary>Returns the result of a componentwise multiplication operation on two uint3x3 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise multiplication operation on a uint3x3 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x3 operator * (uint3x3 lhs, uint rhs) { return new uint3x3 (lhs.c0 * rhs, lhs.c1 * rhs, lhs.c2 * rhs); }
+
+        /// <summary>Returns the result of a componentwise multiplication operation on a uint value and a uint3x3 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x3 operator * (uint lhs, uint3x3 rhs) { return new uint3x3 (lhs * rhs.c0, lhs * rhs.c1, lhs * rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise addition operation on two uint3x3 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise addition operation on a uint3x3 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x3 operator + (uint3x3 lhs, uint rhs) { return new uint3x3 (lhs.c0 + rhs, lhs.c1 + rhs, lhs.c2 + rhs); }
+
+        /// <summary>Returns the result of a componentwise addition operation on a uint value and a uint3x3 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x3 operator + (uint lhs, uint3x3 rhs) { return new uint3x3 (lhs + rhs.c0, lhs + rhs.c1, lhs + rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise subtraction operation on two uint3x3 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise subtraction operation on a uint3x3 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x3 operator - (uint3x3 lhs, uint rhs) { return new uint3x3 (lhs.c0 - rhs, lhs.c1 - rhs, lhs.c2 - rhs); }
+
+        /// <summary>Returns the result of a componentwise subtraction operation on a uint value and a uint3x3 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x3 operator - (uint lhs, uint3x3 rhs) { return new uint3x3 (lhs - rhs.c0, lhs - rhs.c1, lhs - rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise division operation on two uint3x3 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise division operation on a uint3x3 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x3 operator / (uint3x3 lhs, uint rhs) { return new uint3x3 (lhs.c0 / rhs, lhs.c1 / rhs, lhs.c2 / rhs); }
+
+        /// <summary>Returns the result of a componentwise division operation on a uint value and a uint3x3 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x3 operator / (uint lhs, uint3x3 rhs) { return new uint3x3 (lhs / rhs.c0, lhs / rhs.c1, lhs / rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise modulus operation on two uint3x3 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise modulus operation on a uint3x3 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x3 operator % (uint3x3 lhs, uint rhs) { return new uint3x3 (lhs.c0 % rhs, lhs.c1 % rhs, lhs.c2 % rhs); }
+
+        /// <summary>Returns the result of a componentwise modulus operation on a uint value and a uint3x3 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x3 operator % (uint lhs, uint3x3 rhs) { return new uint3x3 (lhs % rhs.c0, lhs % rhs.c1, lhs % rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise increment operation on a uint3x3 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x3 operator ++ (uint3x3 val) { return new uint3x3 (++val.c0, ++val.c1, ++val.c2); }
+
+
+        /// <summary>Returns the result of a componentwise decrement operation on a uint3x3 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x3 operator -- (uint3x3 val) { return new uint3x3 (--val.c0, --val.c1, --val.c2); }
+
+
+        /// <summary>Returns the result of a componentwise less than operation on two uint3x3 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise less than operation on a uint3x3 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 operator < (uint3x3 lhs, uint rhs) { return new bool3x3 (lhs.c0 < rhs, lhs.c1 < rhs, lhs.c2 < rhs); }
+
+        /// <summary>Returns the result of a componentwise less than operation on a uint value and a uint3x3 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 operator < (uint lhs, uint3x3 rhs) { return new bool3x3 (lhs < rhs.c0, lhs < rhs.c1, lhs < rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise less or equal operation on two uint3x3 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise less or equal operation on a uint3x3 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 operator <= (uint3x3 lhs, uint rhs) { return new bool3x3 (lhs.c0 <= rhs, lhs.c1 <= rhs, lhs.c2 <= rhs); }
+
+        /// <summary>Returns the result of a componentwise less or equal operation on a uint value and a uint3x3 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 operator <= (uint lhs, uint3x3 rhs) { return new bool3x3 (lhs <= rhs.c0, lhs <= rhs.c1, lhs <= rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise greater than operation on two uint3x3 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise greater than operation on a uint3x3 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 operator > (uint3x3 lhs, uint rhs) { return new bool3x3 (lhs.c0 > rhs, lhs.c1 > rhs, lhs.c2 > rhs); }
+
+        /// <summary>Returns the result of a componentwise greater than operation on a uint value and a uint3x3 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 operator > (uint lhs, uint3x3 rhs) { return new bool3x3 (lhs > rhs.c0, lhs > rhs.c1, lhs > rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on two uint3x3 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on a uint3x3 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 operator >= (uint3x3 lhs, uint rhs) { return new bool3x3 (lhs.c0 >= rhs, lhs.c1 >= rhs, lhs.c2 >= rhs); }
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on a uint value and a uint3x3 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 operator >= (uint lhs, uint3x3 rhs) { return new bool3x3 (lhs >= rhs.c0, lhs >= rhs.c1, lhs >= rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise unary minus operation on a uint3x3 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x3 operator - (uint3x3 val) { return new uint3x3 (-val.c0, -val.c1, -val.c2); }
+
+
+        /// <summary>Returns the result of a componentwise unary plus operation on a uint3x3 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x3 operator + (uint3x3 val) { return new uint3x3 (+val.c0, +val.c1, +val.c2); }
+
+
+        /// <summary>Returns the result of a componentwise left shift operation on a uint3x3 matrix by a number of bits specified by a single int.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x3 operator << (uint3x3 x, int n) { return new uint3x3 (x.c0 << n, x.c1 << n, x.c2 << n); }
+
+        /// <summary>Returns the result of a componentwise right shift operation on a uint3x3 matrix by a number of bits specified by a single int.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x3 operator >> (uint3x3 x, int n) { return new uint3x3 (x.c0 >> n, x.c1 >> n, x.c2 >> n); }
+
+        /// <summary>Returns the result of a componentwise equality operation on two uint3x3 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a uint3x3 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 operator == (uint3x3 lhs, uint rhs) { return new bool3x3 (lhs.c0 == rhs, lhs.c1 == rhs, lhs.c2 == rhs); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a uint value and a uint3x3 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 operator == (uint lhs, uint3x3 rhs) { return new bool3x3 (lhs == rhs.c0, lhs == rhs.c1, lhs == rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise not equal operation on two uint3x3 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a uint3x3 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 operator != (uint3x3 lhs, uint rhs) { return new bool3x3 (lhs.c0 != rhs, lhs.c1 != rhs, lhs.c2 != rhs); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a uint value and a uint3x3 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 operator != (uint lhs, uint3x3 rhs) { return new bool3x3 (lhs != rhs.c0, lhs != rhs.c1, lhs != rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise not operation on a uint3x3 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x3 operator ~ (uint3x3 val) { return new uint3x3 (~val.c0, ~val.c1, ~val.c2); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise and operation on two uint3x3 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise bitwise and operation on a uint3x3 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x3 operator & (uint3x3 lhs, uint rhs) { return new uint3x3 (lhs.c0 & rhs, lhs.c1 & rhs, lhs.c2 & rhs); }
+
+        /// <summary>Returns the result of a componentwise bitwise and operation on a uint value and a uint3x3 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x3 operator & (uint lhs, uint3x3 rhs) { return new uint3x3 (lhs & rhs.c0, lhs & rhs.c1, lhs & rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise or operation on two uint3x3 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise bitwise or operation on a uint3x3 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x3 operator | (uint3x3 lhs, uint rhs) { return new uint3x3 (lhs.c0 | rhs, lhs.c1 | rhs, lhs.c2 | rhs); }
+
+        /// <summary>Returns the result of a componentwise bitwise or operation on a uint value and a uint3x3 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x3 operator | (uint lhs, uint3x3 rhs) { return new uint3x3 (lhs | rhs.c0, lhs | rhs.c1, lhs | rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise exclusive or operation on two uint3x3 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise bitwise exclusive or operation on a uint3x3 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x3 operator ^ (uint3x3 lhs, uint rhs) { return new uint3x3 (lhs.c0 ^ rhs, lhs.c1 ^ rhs, lhs.c2 ^ rhs); }
+
+        /// <summary>Returns the result of a componentwise bitwise exclusive or operation on a uint value and a uint3x3 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x3 operator ^ (uint lhs, uint3x3 rhs) { return new uint3x3 (lhs ^ rhs.c0, lhs ^ rhs.c1, lhs ^ rhs.c2); }
+
+
+
+        /// <summary>Returns the uint3 element at a specified index.</summary>
+        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]; }
+            }
+        }
+
+        /// <summary>Returns true if the uint3x3 is equal to a given uint3x3, false otherwise.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool Equals(uint3x3 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1) && c2.Equals(rhs.c2); }
+
+        /// <summary>Returns true if the uint3x3 is equal to a given uint3x3, false otherwise.</summary>
+        public override bool Equals(object o) { return Equals((uint3x3)o); }
+
+
+        /// <summary>Returns a hash code for the uint3x3.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override int GetHashCode() { return (int)math.hash(this); }
+
+
+        /// <summary>Returns a string representation of the uint3x3.</summary>
+        [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);
+        }
+
+        /// <summary>Returns a string representation of the uint3x3 using a specified format and culture-specific format information.</summary>
+        [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
+    {
+        /// <summary>Returns a uint3x3 matrix constructed from three uint3 vectors.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x3 uint3x3(uint3 c0, uint3 c1, uint3 c2) { return new uint3x3(c0, c1, c2); }
+
+        /// <summary>Returns a uint3x3 matrix constructed from from 9 uint values given in row-major order.</summary>
+        [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);
+        }
+
+        /// <summary>Returns a uint3x3 matrix constructed from a single uint value by assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x3 uint3x3(uint v) { return new uint3x3(v); }
+
+        /// <summary>Returns a uint3x3 matrix constructed from a single bool value by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x3 uint3x3(bool v) { return new uint3x3(v); }
+
+        /// <summary>Return a uint3x3 matrix constructed from a bool3x3 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x3 uint3x3(bool3x3 v) { return new uint3x3(v); }
+
+        /// <summary>Returns a uint3x3 matrix constructed from a single int value by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x3 uint3x3(int v) { return new uint3x3(v); }
+
+        /// <summary>Return a uint3x3 matrix constructed from a int3x3 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x3 uint3x3(int3x3 v) { return new uint3x3(v); }
+
+        /// <summary>Returns a uint3x3 matrix constructed from a single float value by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x3 uint3x3(float v) { return new uint3x3(v); }
+
+        /// <summary>Return a uint3x3 matrix constructed from a float3x3 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x3 uint3x3(float3x3 v) { return new uint3x3(v); }
+
+        /// <summary>Returns a uint3x3 matrix constructed from a single double value by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x3 uint3x3(double v) { return new uint3x3(v); }
+
+        /// <summary>Return a uint3x3 matrix constructed from a double3x3 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x3 uint3x3(double3x3 v) { return new uint3x3(v); }
+
+        /// <summary>Return the uint3x3 transpose of a uint3x3 matrix.</summary>
+        [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);
+        }
+
+        /// <summary>Returns a uint hash code of a uint3x3 vector.</summary>
+        [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;
+        }
+
+        /// <summary>
+        /// 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.
+        /// </summary>
+        [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;
+        }
+
+    }
+}

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: 

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 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using System;
+using System.Runtime.CompilerServices;
+
+#pragma warning disable 0660, 0661
+
+namespace Unity.Mathematics
+{
+    [System.Serializable]
+    public partial struct uint3x4 : System.IEquatable<uint3x4>, IFormattable
+    {
+        public uint3 c0;
+        public uint3 c1;
+        public uint3 c2;
+        public uint3 c3;
+
+        /// <summary>uint3x4 zero value.</summary>
+        public static readonly uint3x4 zero;
+
+        /// <summary>Constructs a uint3x4 matrix from four uint3 vectors.</summary>
+        [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;
+        }
+
+        /// <summary>Constructs a uint3x4 matrix from 12 uint values given in row-major order.</summary>
+        [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);
+        }
+
+        /// <summary>Constructs a uint3x4 matrix from a single uint value by assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint3x4(uint v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+            this.c2 = v;
+            this.c3 = v;
+        }
+
+        /// <summary>Constructs a uint3x4 matrix from a single bool value by converting it to uint and assigning it to every component.</summary>
+        [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);
+        }
+
+        /// <summary>Constructs a uint3x4 matrix from a bool3x4 matrix by componentwise conversion.</summary>
+        [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);
+        }
+
+        /// <summary>Constructs a uint3x4 matrix from a single int value by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint3x4(int v)
+        {
+            this.c0 = (uint3)v;
+            this.c1 = (uint3)v;
+            this.c2 = (uint3)v;
+            this.c3 = (uint3)v;
+        }
+
+        /// <summary>Constructs a uint3x4 matrix from a int3x4 matrix by componentwise conversion.</summary>
+        [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;
+        }
+
+        /// <summary>Constructs a uint3x4 matrix from a single float value by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint3x4(float v)
+        {
+            this.c0 = (uint3)v;
+            this.c1 = (uint3)v;
+            this.c2 = (uint3)v;
+            this.c3 = (uint3)v;
+        }
+
+        /// <summary>Constructs a uint3x4 matrix from a float3x4 matrix by componentwise conversion.</summary>
+        [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;
+        }
+
+        /// <summary>Constructs a uint3x4 matrix from a single double value by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint3x4(double v)
+        {
+            this.c0 = (uint3)v;
+            this.c1 = (uint3)v;
+            this.c2 = (uint3)v;
+            this.c3 = (uint3)v;
+        }
+
+        /// <summary>Constructs a uint3x4 matrix from a double3x4 matrix by componentwise conversion.</summary>
+        [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;
+        }
+
+
+        /// <summary>Implicitly converts a single uint value to a uint3x4 matrix by assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator uint3x4(uint v) { return new uint3x4(v); }
+
+        /// <summary>Explicitly converts a single bool value to a uint3x4 matrix by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator uint3x4(bool v) { return new uint3x4(v); }
+
+        /// <summary>Explicitly converts a bool3x4 matrix to a uint3x4 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator uint3x4(bool3x4 v) { return new uint3x4(v); }
+
+        /// <summary>Explicitly converts a single int value to a uint3x4 matrix by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator uint3x4(int v) { return new uint3x4(v); }
+
+        /// <summary>Explicitly converts a int3x4 matrix to a uint3x4 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator uint3x4(int3x4 v) { return new uint3x4(v); }
+
+        /// <summary>Explicitly converts a single float value to a uint3x4 matrix by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator uint3x4(float v) { return new uint3x4(v); }
+
+        /// <summary>Explicitly converts a float3x4 matrix to a uint3x4 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator uint3x4(float3x4 v) { return new uint3x4(v); }
+
+        /// <summary>Explicitly converts a single double value to a uint3x4 matrix by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator uint3x4(double v) { return new uint3x4(v); }
+
+        /// <summary>Explicitly converts a double3x4 matrix to a uint3x4 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator uint3x4(double3x4 v) { return new uint3x4(v); }
+
+
+        /// <summary>Returns the result of a componentwise multiplication operation on two uint3x4 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise multiplication operation on a uint3x4 matrix and a uint value.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise multiplication operation on a uint value and a uint3x4 matrix.</summary>
+        [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); }
+
+
+        /// <summary>Returns the result of a componentwise addition operation on two uint3x4 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise addition operation on a uint3x4 matrix and a uint value.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise addition operation on a uint value and a uint3x4 matrix.</summary>
+        [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); }
+
+
+        /// <summary>Returns the result of a componentwise subtraction operation on two uint3x4 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise subtraction operation on a uint3x4 matrix and a uint value.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise subtraction operation on a uint value and a uint3x4 matrix.</summary>
+        [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); }
+
+
+        /// <summary>Returns the result of a componentwise division operation on two uint3x4 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise division operation on a uint3x4 matrix and a uint value.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise division operation on a uint value and a uint3x4 matrix.</summary>
+        [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); }
+
+
+        /// <summary>Returns the result of a componentwise modulus operation on two uint3x4 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise modulus operation on a uint3x4 matrix and a uint value.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise modulus operation on a uint value and a uint3x4 matrix.</summary>
+        [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); }
+
+
+        /// <summary>Returns the result of a componentwise increment operation on a uint3x4 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x4 operator ++ (uint3x4 val) { return new uint3x4 (++val.c0, ++val.c1, ++val.c2, ++val.c3); }
+
+
+        /// <summary>Returns the result of a componentwise decrement operation on a uint3x4 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x4 operator -- (uint3x4 val) { return new uint3x4 (--val.c0, --val.c1, --val.c2, --val.c3); }
+
+
+        /// <summary>Returns the result of a componentwise less than operation on two uint3x4 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise less than operation on a uint3x4 matrix and a uint value.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise less than operation on a uint value and a uint3x4 matrix.</summary>
+        [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); }
+
+
+        /// <summary>Returns the result of a componentwise less or equal operation on two uint3x4 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise less or equal operation on a uint3x4 matrix and a uint value.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise less or equal operation on a uint value and a uint3x4 matrix.</summary>
+        [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); }
+
+
+        /// <summary>Returns the result of a componentwise greater than operation on two uint3x4 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise greater than operation on a uint3x4 matrix and a uint value.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise greater than operation on a uint value and a uint3x4 matrix.</summary>
+        [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); }
+
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on two uint3x4 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on a uint3x4 matrix and a uint value.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on a uint value and a uint3x4 matrix.</summary>
+        [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); }
+
+
+        /// <summary>Returns the result of a componentwise unary minus operation on a uint3x4 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x4 operator - (uint3x4 val) { return new uint3x4 (-val.c0, -val.c1, -val.c2, -val.c3); }
+
+
+        /// <summary>Returns the result of a componentwise unary plus operation on a uint3x4 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x4 operator + (uint3x4 val) { return new uint3x4 (+val.c0, +val.c1, +val.c2, +val.c3); }
+
+
+        /// <summary>Returns the result of a componentwise left shift operation on a uint3x4 matrix by a number of bits specified by a single int.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise right shift operation on a uint3x4 matrix by a number of bits specified by a single int.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise equality operation on two uint3x4 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a uint3x4 matrix and a uint value.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a uint value and a uint3x4 matrix.</summary>
+        [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); }
+
+
+        /// <summary>Returns the result of a componentwise not equal operation on two uint3x4 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a uint3x4 matrix and a uint value.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a uint value and a uint3x4 matrix.</summary>
+        [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); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise not operation on a uint3x4 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x4 operator ~ (uint3x4 val) { return new uint3x4 (~val.c0, ~val.c1, ~val.c2, ~val.c3); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise and operation on two uint3x4 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise bitwise and operation on a uint3x4 matrix and a uint value.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise bitwise and operation on a uint value and a uint3x4 matrix.</summary>
+        [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); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise or operation on two uint3x4 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise bitwise or operation on a uint3x4 matrix and a uint value.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise bitwise or operation on a uint value and a uint3x4 matrix.</summary>
+        [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); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise exclusive or operation on two uint3x4 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise bitwise exclusive or operation on a uint3x4 matrix and a uint value.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise bitwise exclusive or operation on a uint value and a uint3x4 matrix.</summary>
+        [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); }
+
+
+
+        /// <summary>Returns the uint3 element at a specified index.</summary>
+        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]; }
+            }
+        }
+
+        /// <summary>Returns true if the uint3x4 is equal to a given uint3x4, false otherwise.</summary>
+        [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); }
+
+        /// <summary>Returns true if the uint3x4 is equal to a given uint3x4, false otherwise.</summary>
+        public override bool Equals(object o) { return Equals((uint3x4)o); }
+
+
+        /// <summary>Returns a hash code for the uint3x4.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override int GetHashCode() { return (int)math.hash(this); }
+
+
+        /// <summary>Returns a string representation of the uint3x4.</summary>
+        [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);
+        }
+
+        /// <summary>Returns a string representation of the uint3x4 using a specified format and culture-specific format information.</summary>
+        [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
+    {
+        /// <summary>Returns a uint3x4 matrix constructed from four uint3 vectors.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x4 uint3x4(uint3 c0, uint3 c1, uint3 c2, uint3 c3) { return new uint3x4(c0, c1, c2, c3); }
+
+        /// <summary>Returns a uint3x4 matrix constructed from from 12 uint values given in row-major order.</summary>
+        [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);
+        }
+
+        /// <summary>Returns a uint3x4 matrix constructed from a single uint value by assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x4 uint3x4(uint v) { return new uint3x4(v); }
+
+        /// <summary>Returns a uint3x4 matrix constructed from a single bool value by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x4 uint3x4(bool v) { return new uint3x4(v); }
+
+        /// <summary>Return a uint3x4 matrix constructed from a bool3x4 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x4 uint3x4(bool3x4 v) { return new uint3x4(v); }
+
+        /// <summary>Returns a uint3x4 matrix constructed from a single int value by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x4 uint3x4(int v) { return new uint3x4(v); }
+
+        /// <summary>Return a uint3x4 matrix constructed from a int3x4 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x4 uint3x4(int3x4 v) { return new uint3x4(v); }
+
+        /// <summary>Returns a uint3x4 matrix constructed from a single float value by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x4 uint3x4(float v) { return new uint3x4(v); }
+
+        /// <summary>Return a uint3x4 matrix constructed from a float3x4 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x4 uint3x4(float3x4 v) { return new uint3x4(v); }
+
+        /// <summary>Returns a uint3x4 matrix constructed from a single double value by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x4 uint3x4(double v) { return new uint3x4(v); }
+
+        /// <summary>Return a uint3x4 matrix constructed from a double3x4 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3x4 uint3x4(double3x4 v) { return new uint3x4(v); }
+
+        /// <summary>Return the uint4x3 transpose of a uint3x4 matrix.</summary>
+        [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);
+        }
+
+        /// <summary>Returns a uint hash code of a uint3x4 vector.</summary>
+        [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;
+        }
+
+        /// <summary>
+        /// 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.
+        /// </summary>
+        [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;
+        }
+
+    }
+}

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: 

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: 

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 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using System;
+using System.Runtime.CompilerServices;
+
+#pragma warning disable 0660, 0661
+
+namespace Unity.Mathematics
+{
+    [System.Serializable]
+    public partial struct uint4x2 : System.IEquatable<uint4x2>, IFormattable
+    {
+        public uint4 c0;
+        public uint4 c1;
+
+        /// <summary>uint4x2 zero value.</summary>
+        public static readonly uint4x2 zero;
+
+        /// <summary>Constructs a uint4x2 matrix from two uint4 vectors.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint4x2(uint4 c0, uint4 c1)
+        { 
+            this.c0 = c0;
+            this.c1 = c1;
+        }
+
+        /// <summary>Constructs a uint4x2 matrix from 8 uint values given in row-major order.</summary>
+        [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);
+        }
+
+        /// <summary>Constructs a uint4x2 matrix from a single uint value by assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint4x2(uint v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+        }
+
+        /// <summary>Constructs a uint4x2 matrix from a single bool value by converting it to uint and assigning it to every component.</summary>
+        [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);
+        }
+
+        /// <summary>Constructs a uint4x2 matrix from a bool4x2 matrix by componentwise conversion.</summary>
+        [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);
+        }
+
+        /// <summary>Constructs a uint4x2 matrix from a single int value by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint4x2(int v)
+        {
+            this.c0 = (uint4)v;
+            this.c1 = (uint4)v;
+        }
+
+        /// <summary>Constructs a uint4x2 matrix from a int4x2 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint4x2(int4x2 v)
+        {
+            this.c0 = (uint4)v.c0;
+            this.c1 = (uint4)v.c1;
+        }
+
+        /// <summary>Constructs a uint4x2 matrix from a single float value by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint4x2(float v)
+        {
+            this.c0 = (uint4)v;
+            this.c1 = (uint4)v;
+        }
+
+        /// <summary>Constructs a uint4x2 matrix from a float4x2 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint4x2(float4x2 v)
+        {
+            this.c0 = (uint4)v.c0;
+            this.c1 = (uint4)v.c1;
+        }
+
+        /// <summary>Constructs a uint4x2 matrix from a single double value by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint4x2(double v)
+        {
+            this.c0 = (uint4)v;
+            this.c1 = (uint4)v;
+        }
+
+        /// <summary>Constructs a uint4x2 matrix from a double4x2 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint4x2(double4x2 v)
+        {
+            this.c0 = (uint4)v.c0;
+            this.c1 = (uint4)v.c1;
+        }
+
+
+        /// <summary>Implicitly converts a single uint value to a uint4x2 matrix by assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator uint4x2(uint v) { return new uint4x2(v); }
+
+        /// <summary>Explicitly converts a single bool value to a uint4x2 matrix by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator uint4x2(bool v) { return new uint4x2(v); }
+
+        /// <summary>Explicitly converts a bool4x2 matrix to a uint4x2 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator uint4x2(bool4x2 v) { return new uint4x2(v); }
+
+        /// <summary>Explicitly converts a single int value to a uint4x2 matrix by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator uint4x2(int v) { return new uint4x2(v); }
+
+        /// <summary>Explicitly converts a int4x2 matrix to a uint4x2 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator uint4x2(int4x2 v) { return new uint4x2(v); }
+
+        /// <summary>Explicitly converts a single float value to a uint4x2 matrix by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator uint4x2(float v) { return new uint4x2(v); }
+
+        /// <summary>Explicitly converts a float4x2 matrix to a uint4x2 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator uint4x2(float4x2 v) { return new uint4x2(v); }
+
+        /// <summary>Explicitly converts a single double value to a uint4x2 matrix by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator uint4x2(double v) { return new uint4x2(v); }
+
+        /// <summary>Explicitly converts a double4x2 matrix to a uint4x2 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator uint4x2(double4x2 v) { return new uint4x2(v); }
+
+
+        /// <summary>Returns the result of a componentwise multiplication operation on two uint4x2 matrices.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x2 operator * (uint4x2 lhs, uint4x2 rhs) { return new uint4x2 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise multiplication operation on a uint4x2 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x2 operator * (uint4x2 lhs, uint rhs) { return new uint4x2 (lhs.c0 * rhs, lhs.c1 * rhs); }
+
+        /// <summary>Returns the result of a componentwise multiplication operation on a uint value and a uint4x2 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x2 operator * (uint lhs, uint4x2 rhs) { return new uint4x2 (lhs * rhs.c0, lhs * rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise addition operation on two uint4x2 matrices.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x2 operator + (uint4x2 lhs, uint4x2 rhs) { return new uint4x2 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise addition operation on a uint4x2 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x2 operator + (uint4x2 lhs, uint rhs) { return new uint4x2 (lhs.c0 + rhs, lhs.c1 + rhs); }
+
+        /// <summary>Returns the result of a componentwise addition operation on a uint value and a uint4x2 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x2 operator + (uint lhs, uint4x2 rhs) { return new uint4x2 (lhs + rhs.c0, lhs + rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise subtraction operation on two uint4x2 matrices.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x2 operator - (uint4x2 lhs, uint4x2 rhs) { return new uint4x2 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise subtraction operation on a uint4x2 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x2 operator - (uint4x2 lhs, uint rhs) { return new uint4x2 (lhs.c0 - rhs, lhs.c1 - rhs); }
+
+        /// <summary>Returns the result of a componentwise subtraction operation on a uint value and a uint4x2 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x2 operator - (uint lhs, uint4x2 rhs) { return new uint4x2 (lhs - rhs.c0, lhs - rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise division operation on two uint4x2 matrices.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x2 operator / (uint4x2 lhs, uint4x2 rhs) { return new uint4x2 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise division operation on a uint4x2 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x2 operator / (uint4x2 lhs, uint rhs) { return new uint4x2 (lhs.c0 / rhs, lhs.c1 / rhs); }
+
+        /// <summary>Returns the result of a componentwise division operation on a uint value and a uint4x2 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x2 operator / (uint lhs, uint4x2 rhs) { return new uint4x2 (lhs / rhs.c0, lhs / rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise modulus operation on two uint4x2 matrices.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x2 operator % (uint4x2 lhs, uint4x2 rhs) { return new uint4x2 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise modulus operation on a uint4x2 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x2 operator % (uint4x2 lhs, uint rhs) { return new uint4x2 (lhs.c0 % rhs, lhs.c1 % rhs); }
+
+        /// <summary>Returns the result of a componentwise modulus operation on a uint value and a uint4x2 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x2 operator % (uint lhs, uint4x2 rhs) { return new uint4x2 (lhs % rhs.c0, lhs % rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise increment operation on a uint4x2 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x2 operator ++ (uint4x2 val) { return new uint4x2 (++val.c0, ++val.c1); }
+
+
+        /// <summary>Returns the result of a componentwise decrement operation on a uint4x2 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x2 operator -- (uint4x2 val) { return new uint4x2 (--val.c0, --val.c1); }
+
+
+        /// <summary>Returns the result of a componentwise less than operation on two uint4x2 matrices.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator < (uint4x2 lhs, uint4x2 rhs) { return new bool4x2 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise less than operation on a uint4x2 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator < (uint4x2 lhs, uint rhs) { return new bool4x2 (lhs.c0 < rhs, lhs.c1 < rhs); }
+
+        /// <summary>Returns the result of a componentwise less than operation on a uint value and a uint4x2 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator < (uint lhs, uint4x2 rhs) { return new bool4x2 (lhs < rhs.c0, lhs < rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise less or equal operation on two uint4x2 matrices.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator <= (uint4x2 lhs, uint4x2 rhs) { return new bool4x2 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise less or equal operation on a uint4x2 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator <= (uint4x2 lhs, uint rhs) { return new bool4x2 (lhs.c0 <= rhs, lhs.c1 <= rhs); }
+
+        /// <summary>Returns the result of a componentwise less or equal operation on a uint value and a uint4x2 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator <= (uint lhs, uint4x2 rhs) { return new bool4x2 (lhs <= rhs.c0, lhs <= rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise greater than operation on two uint4x2 matrices.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator > (uint4x2 lhs, uint4x2 rhs) { return new bool4x2 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise greater than operation on a uint4x2 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator > (uint4x2 lhs, uint rhs) { return new bool4x2 (lhs.c0 > rhs, lhs.c1 > rhs); }
+
+        /// <summary>Returns the result of a componentwise greater than operation on a uint value and a uint4x2 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator > (uint lhs, uint4x2 rhs) { return new bool4x2 (lhs > rhs.c0, lhs > rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on two uint4x2 matrices.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator >= (uint4x2 lhs, uint4x2 rhs) { return new bool4x2 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on a uint4x2 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator >= (uint4x2 lhs, uint rhs) { return new bool4x2 (lhs.c0 >= rhs, lhs.c1 >= rhs); }
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on a uint value and a uint4x2 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator >= (uint lhs, uint4x2 rhs) { return new bool4x2 (lhs >= rhs.c0, lhs >= rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise unary minus operation on a uint4x2 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x2 operator - (uint4x2 val) { return new uint4x2 (-val.c0, -val.c1); }
+
+
+        /// <summary>Returns the result of a componentwise unary plus operation on a uint4x2 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x2 operator + (uint4x2 val) { return new uint4x2 (+val.c0, +val.c1); }
+
+
+        /// <summary>Returns the result of a componentwise left shift operation on a uint4x2 matrix by a number of bits specified by a single int.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x2 operator << (uint4x2 x, int n) { return new uint4x2 (x.c0 << n, x.c1 << n); }
+
+        /// <summary>Returns the result of a componentwise right shift operation on a uint4x2 matrix by a number of bits specified by a single int.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x2 operator >> (uint4x2 x, int n) { return new uint4x2 (x.c0 >> n, x.c1 >> n); }
+
+        /// <summary>Returns the result of a componentwise equality operation on two uint4x2 matrices.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator == (uint4x2 lhs, uint4x2 rhs) { return new bool4x2 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a uint4x2 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator == (uint4x2 lhs, uint rhs) { return new bool4x2 (lhs.c0 == rhs, lhs.c1 == rhs); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a uint value and a uint4x2 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator == (uint lhs, uint4x2 rhs) { return new bool4x2 (lhs == rhs.c0, lhs == rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise not equal operation on two uint4x2 matrices.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator != (uint4x2 lhs, uint4x2 rhs) { return new bool4x2 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a uint4x2 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator != (uint4x2 lhs, uint rhs) { return new bool4x2 (lhs.c0 != rhs, lhs.c1 != rhs); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a uint value and a uint4x2 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator != (uint lhs, uint4x2 rhs) { return new bool4x2 (lhs != rhs.c0, lhs != rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise not operation on a uint4x2 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x2 operator ~ (uint4x2 val) { return new uint4x2 (~val.c0, ~val.c1); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise and operation on two uint4x2 matrices.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x2 operator & (uint4x2 lhs, uint4x2 rhs) { return new uint4x2 (lhs.c0 & rhs.c0, lhs.c1 & rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise bitwise and operation on a uint4x2 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x2 operator & (uint4x2 lhs, uint rhs) { return new uint4x2 (lhs.c0 & rhs, lhs.c1 & rhs); }
+
+        /// <summary>Returns the result of a componentwise bitwise and operation on a uint value and a uint4x2 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x2 operator & (uint lhs, uint4x2 rhs) { return new uint4x2 (lhs & rhs.c0, lhs & rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise or operation on two uint4x2 matrices.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x2 operator | (uint4x2 lhs, uint4x2 rhs) { return new uint4x2 (lhs.c0 | rhs.c0, lhs.c1 | rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise bitwise or operation on a uint4x2 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x2 operator | (uint4x2 lhs, uint rhs) { return new uint4x2 (lhs.c0 | rhs, lhs.c1 | rhs); }
+
+        /// <summary>Returns the result of a componentwise bitwise or operation on a uint value and a uint4x2 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x2 operator | (uint lhs, uint4x2 rhs) { return new uint4x2 (lhs | rhs.c0, lhs | rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise exclusive or operation on two uint4x2 matrices.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x2 operator ^ (uint4x2 lhs, uint4x2 rhs) { return new uint4x2 (lhs.c0 ^ rhs.c0, lhs.c1 ^ rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise bitwise exclusive or operation on a uint4x2 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x2 operator ^ (uint4x2 lhs, uint rhs) { return new uint4x2 (lhs.c0 ^ rhs, lhs.c1 ^ rhs); }
+
+        /// <summary>Returns the result of a componentwise bitwise exclusive or operation on a uint value and a uint4x2 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x2 operator ^ (uint lhs, uint4x2 rhs) { return new uint4x2 (lhs ^ rhs.c0, lhs ^ rhs.c1); }
+
+
+
+        /// <summary>Returns the uint4 element at a specified index.</summary>
+        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]; }
+            }
+        }
+
+        /// <summary>Returns true if the uint4x2 is equal to a given uint4x2, false otherwise.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool Equals(uint4x2 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1); }
+
+        /// <summary>Returns true if the uint4x2 is equal to a given uint4x2, false otherwise.</summary>
+        public override bool Equals(object o) { return Equals((uint4x2)o); }
+
+
+        /// <summary>Returns a hash code for the uint4x2.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override int GetHashCode() { return (int)math.hash(this); }
+
+
+        /// <summary>Returns a string representation of the uint4x2.</summary>
+        [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);
+        }
+
+        /// <summary>Returns a string representation of the uint4x2 using a specified format and culture-specific format information.</summary>
+        [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
+    {
+        /// <summary>Returns a uint4x2 matrix constructed from two uint4 vectors.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x2 uint4x2(uint4 c0, uint4 c1) { return new uint4x2(c0, c1); }
+
+        /// <summary>Returns a uint4x2 matrix constructed from from 8 uint values given in row-major order.</summary>
+        [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);
+        }
+
+        /// <summary>Returns a uint4x2 matrix constructed from a single uint value by assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x2 uint4x2(uint v) { return new uint4x2(v); }
+
+        /// <summary>Returns a uint4x2 matrix constructed from a single bool value by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x2 uint4x2(bool v) { return new uint4x2(v); }
+
+        /// <summary>Return a uint4x2 matrix constructed from a bool4x2 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x2 uint4x2(bool4x2 v) { return new uint4x2(v); }
+
+        /// <summary>Returns a uint4x2 matrix constructed from a single int value by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x2 uint4x2(int v) { return new uint4x2(v); }
+
+        /// <summary>Return a uint4x2 matrix constructed from a int4x2 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x2 uint4x2(int4x2 v) { return new uint4x2(v); }
+
+        /// <summary>Returns a uint4x2 matrix constructed from a single float value by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x2 uint4x2(float v) { return new uint4x2(v); }
+
+        /// <summary>Return a uint4x2 matrix constructed from a float4x2 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x2 uint4x2(float4x2 v) { return new uint4x2(v); }
+
+        /// <summary>Returns a uint4x2 matrix constructed from a single double value by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x2 uint4x2(double v) { return new uint4x2(v); }
+
+        /// <summary>Return a uint4x2 matrix constructed from a double4x2 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x2 uint4x2(double4x2 v) { return new uint4x2(v); }
+
+        /// <summary>Return the uint2x4 transpose of a uint4x2 matrix.</summary>
+        [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);
+        }
+
+        /// <summary>Returns a uint hash code of a uint4x2 vector.</summary>
+        [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;
+        }
+
+        /// <summary>
+        /// 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.
+        /// </summary>
+        [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;
+        }
+
+    }
+}

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: 

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 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using System;
+using System.Runtime.CompilerServices;
+
+#pragma warning disable 0660, 0661
+
+namespace Unity.Mathematics
+{
+    [System.Serializable]
+    public partial struct uint4x3 : System.IEquatable<uint4x3>, IFormattable
+    {
+        public uint4 c0;
+        public uint4 c1;
+        public uint4 c2;
+
+        /// <summary>uint4x3 zero value.</summary>
+        public static readonly uint4x3 zero;
+
+        /// <summary>Constructs a uint4x3 matrix from three uint4 vectors.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint4x3(uint4 c0, uint4 c1, uint4 c2)
+        { 
+            this.c0 = c0;
+            this.c1 = c1;
+            this.c2 = c2;
+        }
+
+        /// <summary>Constructs a uint4x3 matrix from 12 uint values given in row-major order.</summary>
+        [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);
+        }
+
+        /// <summary>Constructs a uint4x3 matrix from a single uint value by assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint4x3(uint v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+            this.c2 = v;
+        }
+
+        /// <summary>Constructs a uint4x3 matrix from a single bool value by converting it to uint and assigning it to every component.</summary>
+        [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);
+        }
+
+        /// <summary>Constructs a uint4x3 matrix from a bool4x3 matrix by componentwise conversion.</summary>
+        [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);
+        }
+
+        /// <summary>Constructs a uint4x3 matrix from a single int value by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint4x3(int v)
+        {
+            this.c0 = (uint4)v;
+            this.c1 = (uint4)v;
+            this.c2 = (uint4)v;
+        }
+
+        /// <summary>Constructs a uint4x3 matrix from a int4x3 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint4x3(int4x3 v)
+        {
+            this.c0 = (uint4)v.c0;
+            this.c1 = (uint4)v.c1;
+            this.c2 = (uint4)v.c2;
+        }
+
+        /// <summary>Constructs a uint4x3 matrix from a single float value by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint4x3(float v)
+        {
+            this.c0 = (uint4)v;
+            this.c1 = (uint4)v;
+            this.c2 = (uint4)v;
+        }
+
+        /// <summary>Constructs a uint4x3 matrix from a float4x3 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint4x3(float4x3 v)
+        {
+            this.c0 = (uint4)v.c0;
+            this.c1 = (uint4)v.c1;
+            this.c2 = (uint4)v.c2;
+        }
+
+        /// <summary>Constructs a uint4x3 matrix from a single double value by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint4x3(double v)
+        {
+            this.c0 = (uint4)v;
+            this.c1 = (uint4)v;
+            this.c2 = (uint4)v;
+        }
+
+        /// <summary>Constructs a uint4x3 matrix from a double4x3 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint4x3(double4x3 v)
+        {
+            this.c0 = (uint4)v.c0;
+            this.c1 = (uint4)v.c1;
+            this.c2 = (uint4)v.c2;
+        }
+
+
+        /// <summary>Implicitly converts a single uint value to a uint4x3 matrix by assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator uint4x3(uint v) { return new uint4x3(v); }
+
+        /// <summary>Explicitly converts a single bool value to a uint4x3 matrix by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator uint4x3(bool v) { return new uint4x3(v); }
+
+        /// <summary>Explicitly converts a bool4x3 matrix to a uint4x3 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator uint4x3(bool4x3 v) { return new uint4x3(v); }
+
+        /// <summary>Explicitly converts a single int value to a uint4x3 matrix by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator uint4x3(int v) { return new uint4x3(v); }
+
+        /// <summary>Explicitly converts a int4x3 matrix to a uint4x3 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator uint4x3(int4x3 v) { return new uint4x3(v); }
+
+        /// <summary>Explicitly converts a single float value to a uint4x3 matrix by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator uint4x3(float v) { return new uint4x3(v); }
+
+        /// <summary>Explicitly converts a float4x3 matrix to a uint4x3 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator uint4x3(float4x3 v) { return new uint4x3(v); }
+
+        /// <summary>Explicitly converts a single double value to a uint4x3 matrix by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator uint4x3(double v) { return new uint4x3(v); }
+
+        /// <summary>Explicitly converts a double4x3 matrix to a uint4x3 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator uint4x3(double4x3 v) { return new uint4x3(v); }
+
+
+        /// <summary>Returns the result of a componentwise multiplication operation on two uint4x3 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise multiplication operation on a uint4x3 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x3 operator * (uint4x3 lhs, uint rhs) { return new uint4x3 (lhs.c0 * rhs, lhs.c1 * rhs, lhs.c2 * rhs); }
+
+        /// <summary>Returns the result of a componentwise multiplication operation on a uint value and a uint4x3 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x3 operator * (uint lhs, uint4x3 rhs) { return new uint4x3 (lhs * rhs.c0, lhs * rhs.c1, lhs * rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise addition operation on two uint4x3 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise addition operation on a uint4x3 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x3 operator + (uint4x3 lhs, uint rhs) { return new uint4x3 (lhs.c0 + rhs, lhs.c1 + rhs, lhs.c2 + rhs); }
+
+        /// <summary>Returns the result of a componentwise addition operation on a uint value and a uint4x3 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x3 operator + (uint lhs, uint4x3 rhs) { return new uint4x3 (lhs + rhs.c0, lhs + rhs.c1, lhs + rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise subtraction operation on two uint4x3 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise subtraction operation on a uint4x3 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x3 operator - (uint4x3 lhs, uint rhs) { return new uint4x3 (lhs.c0 - rhs, lhs.c1 - rhs, lhs.c2 - rhs); }
+
+        /// <summary>Returns the result of a componentwise subtraction operation on a uint value and a uint4x3 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x3 operator - (uint lhs, uint4x3 rhs) { return new uint4x3 (lhs - rhs.c0, lhs - rhs.c1, lhs - rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise division operation on two uint4x3 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise division operation on a uint4x3 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x3 operator / (uint4x3 lhs, uint rhs) { return new uint4x3 (lhs.c0 / rhs, lhs.c1 / rhs, lhs.c2 / rhs); }
+
+        /// <summary>Returns the result of a componentwise division operation on a uint value and a uint4x3 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x3 operator / (uint lhs, uint4x3 rhs) { return new uint4x3 (lhs / rhs.c0, lhs / rhs.c1, lhs / rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise modulus operation on two uint4x3 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise modulus operation on a uint4x3 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x3 operator % (uint4x3 lhs, uint rhs) { return new uint4x3 (lhs.c0 % rhs, lhs.c1 % rhs, lhs.c2 % rhs); }
+
+        /// <summary>Returns the result of a componentwise modulus operation on a uint value and a uint4x3 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x3 operator % (uint lhs, uint4x3 rhs) { return new uint4x3 (lhs % rhs.c0, lhs % rhs.c1, lhs % rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise increment operation on a uint4x3 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x3 operator ++ (uint4x3 val) { return new uint4x3 (++val.c0, ++val.c1, ++val.c2); }
+
+
+        /// <summary>Returns the result of a componentwise decrement operation on a uint4x3 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x3 operator -- (uint4x3 val) { return new uint4x3 (--val.c0, --val.c1, --val.c2); }
+
+
+        /// <summary>Returns the result of a componentwise less than operation on two uint4x3 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise less than operation on a uint4x3 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 operator < (uint4x3 lhs, uint rhs) { return new bool4x3 (lhs.c0 < rhs, lhs.c1 < rhs, lhs.c2 < rhs); }
+
+        /// <summary>Returns the result of a componentwise less than operation on a uint value and a uint4x3 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 operator < (uint lhs, uint4x3 rhs) { return new bool4x3 (lhs < rhs.c0, lhs < rhs.c1, lhs < rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise less or equal operation on two uint4x3 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise less or equal operation on a uint4x3 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 operator <= (uint4x3 lhs, uint rhs) { return new bool4x3 (lhs.c0 <= rhs, lhs.c1 <= rhs, lhs.c2 <= rhs); }
+
+        /// <summary>Returns the result of a componentwise less or equal operation on a uint value and a uint4x3 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 operator <= (uint lhs, uint4x3 rhs) { return new bool4x3 (lhs <= rhs.c0, lhs <= rhs.c1, lhs <= rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise greater than operation on two uint4x3 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise greater than operation on a uint4x3 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 operator > (uint4x3 lhs, uint rhs) { return new bool4x3 (lhs.c0 > rhs, lhs.c1 > rhs, lhs.c2 > rhs); }
+
+        /// <summary>Returns the result of a componentwise greater than operation on a uint value and a uint4x3 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 operator > (uint lhs, uint4x3 rhs) { return new bool4x3 (lhs > rhs.c0, lhs > rhs.c1, lhs > rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on two uint4x3 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on a uint4x3 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 operator >= (uint4x3 lhs, uint rhs) { return new bool4x3 (lhs.c0 >= rhs, lhs.c1 >= rhs, lhs.c2 >= rhs); }
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on a uint value and a uint4x3 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 operator >= (uint lhs, uint4x3 rhs) { return new bool4x3 (lhs >= rhs.c0, lhs >= rhs.c1, lhs >= rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise unary minus operation on a uint4x3 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x3 operator - (uint4x3 val) { return new uint4x3 (-val.c0, -val.c1, -val.c2); }
+
+
+        /// <summary>Returns the result of a componentwise unary plus operation on a uint4x3 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x3 operator + (uint4x3 val) { return new uint4x3 (+val.c0, +val.c1, +val.c2); }
+
+
+        /// <summary>Returns the result of a componentwise left shift operation on a uint4x3 matrix by a number of bits specified by a single int.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x3 operator << (uint4x3 x, int n) { return new uint4x3 (x.c0 << n, x.c1 << n, x.c2 << n); }
+
+        /// <summary>Returns the result of a componentwise right shift operation on a uint4x3 matrix by a number of bits specified by a single int.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x3 operator >> (uint4x3 x, int n) { return new uint4x3 (x.c0 >> n, x.c1 >> n, x.c2 >> n); }
+
+        /// <summary>Returns the result of a componentwise equality operation on two uint4x3 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a uint4x3 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 operator == (uint4x3 lhs, uint rhs) { return new bool4x3 (lhs.c0 == rhs, lhs.c1 == rhs, lhs.c2 == rhs); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a uint value and a uint4x3 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 operator == (uint lhs, uint4x3 rhs) { return new bool4x3 (lhs == rhs.c0, lhs == rhs.c1, lhs == rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise not equal operation on two uint4x3 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a uint4x3 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 operator != (uint4x3 lhs, uint rhs) { return new bool4x3 (lhs.c0 != rhs, lhs.c1 != rhs, lhs.c2 != rhs); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a uint value and a uint4x3 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 operator != (uint lhs, uint4x3 rhs) { return new bool4x3 (lhs != rhs.c0, lhs != rhs.c1, lhs != rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise not operation on a uint4x3 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x3 operator ~ (uint4x3 val) { return new uint4x3 (~val.c0, ~val.c1, ~val.c2); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise and operation on two uint4x3 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise bitwise and operation on a uint4x3 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x3 operator & (uint4x3 lhs, uint rhs) { return new uint4x3 (lhs.c0 & rhs, lhs.c1 & rhs, lhs.c2 & rhs); }
+
+        /// <summary>Returns the result of a componentwise bitwise and operation on a uint value and a uint4x3 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x3 operator & (uint lhs, uint4x3 rhs) { return new uint4x3 (lhs & rhs.c0, lhs & rhs.c1, lhs & rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise or operation on two uint4x3 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise bitwise or operation on a uint4x3 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x3 operator | (uint4x3 lhs, uint rhs) { return new uint4x3 (lhs.c0 | rhs, lhs.c1 | rhs, lhs.c2 | rhs); }
+
+        /// <summary>Returns the result of a componentwise bitwise or operation on a uint value and a uint4x3 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x3 operator | (uint lhs, uint4x3 rhs) { return new uint4x3 (lhs | rhs.c0, lhs | rhs.c1, lhs | rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise exclusive or operation on two uint4x3 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise bitwise exclusive or operation on a uint4x3 matrix and a uint value.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x3 operator ^ (uint4x3 lhs, uint rhs) { return new uint4x3 (lhs.c0 ^ rhs, lhs.c1 ^ rhs, lhs.c2 ^ rhs); }
+
+        /// <summary>Returns the result of a componentwise bitwise exclusive or operation on a uint value and a uint4x3 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x3 operator ^ (uint lhs, uint4x3 rhs) { return new uint4x3 (lhs ^ rhs.c0, lhs ^ rhs.c1, lhs ^ rhs.c2); }
+
+
+
+        /// <summary>Returns the uint4 element at a specified index.</summary>
+        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]; }
+            }
+        }
+
+        /// <summary>Returns true if the uint4x3 is equal to a given uint4x3, false otherwise.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool Equals(uint4x3 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1) && c2.Equals(rhs.c2); }
+
+        /// <summary>Returns true if the uint4x3 is equal to a given uint4x3, false otherwise.</summary>
+        public override bool Equals(object o) { return Equals((uint4x3)o); }
+
+
+        /// <summary>Returns a hash code for the uint4x3.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override int GetHashCode() { return (int)math.hash(this); }
+
+
+        /// <summary>Returns a string representation of the uint4x3.</summary>
+        [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);
+        }
+
+        /// <summary>Returns a string representation of the uint4x3 using a specified format and culture-specific format information.</summary>
+        [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
+    {
+        /// <summary>Returns a uint4x3 matrix constructed from three uint4 vectors.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x3 uint4x3(uint4 c0, uint4 c1, uint4 c2) { return new uint4x3(c0, c1, c2); }
+
+        /// <summary>Returns a uint4x3 matrix constructed from from 12 uint values given in row-major order.</summary>
+        [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);
+        }
+
+        /// <summary>Returns a uint4x3 matrix constructed from a single uint value by assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x3 uint4x3(uint v) { return new uint4x3(v); }
+
+        /// <summary>Returns a uint4x3 matrix constructed from a single bool value by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x3 uint4x3(bool v) { return new uint4x3(v); }
+
+        /// <summary>Return a uint4x3 matrix constructed from a bool4x3 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x3 uint4x3(bool4x3 v) { return new uint4x3(v); }
+
+        /// <summary>Returns a uint4x3 matrix constructed from a single int value by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x3 uint4x3(int v) { return new uint4x3(v); }
+
+        /// <summary>Return a uint4x3 matrix constructed from a int4x3 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x3 uint4x3(int4x3 v) { return new uint4x3(v); }
+
+        /// <summary>Returns a uint4x3 matrix constructed from a single float value by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x3 uint4x3(float v) { return new uint4x3(v); }
+
+        /// <summary>Return a uint4x3 matrix constructed from a float4x3 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x3 uint4x3(float4x3 v) { return new uint4x3(v); }
+
+        /// <summary>Returns a uint4x3 matrix constructed from a single double value by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x3 uint4x3(double v) { return new uint4x3(v); }
+
+        /// <summary>Return a uint4x3 matrix constructed from a double4x3 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x3 uint4x3(double4x3 v) { return new uint4x3(v); }
+
+        /// <summary>Return the uint3x4 transpose of a uint4x3 matrix.</summary>
+        [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);
+        }
+
+        /// <summary>Returns a uint hash code of a uint4x3 vector.</summary>
+        [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;
+        }
+
+        /// <summary>
+        /// 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.
+        /// </summary>
+        [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;
+        }
+
+    }
+}

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: 

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 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using System;
+using System.Runtime.CompilerServices;
+
+#pragma warning disable 0660, 0661
+
+namespace Unity.Mathematics
+{
+    [System.Serializable]
+    public partial struct uint4x4 : System.IEquatable<uint4x4>, IFormattable
+    {
+        public uint4 c0;
+        public uint4 c1;
+        public uint4 c2;
+        public uint4 c3;
+
+        /// <summary>uint4x4 identity transform.</summary>
+        public static readonly uint4x4 identity = new uint4x4(1u, 0u, 0u, 0u,   0u, 1u, 0u, 0u,   0u, 0u, 1u, 0u,   0u, 0u, 0u, 1u);
+
+        /// <summary>uint4x4 zero value.</summary>
+        public static readonly uint4x4 zero;
+
+        /// <summary>Constructs a uint4x4 matrix from four uint4 vectors.</summary>
+        [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;
+        }
+
+        /// <summary>Constructs a uint4x4 matrix from 16 uint values given in row-major order.</summary>
+        [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);
+        }
+
+        /// <summary>Constructs a uint4x4 matrix from a single uint value by assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint4x4(uint v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+            this.c2 = v;
+            this.c3 = v;
+        }
+
+        /// <summary>Constructs a uint4x4 matrix from a single bool value by converting it to uint and assigning it to every component.</summary>
+        [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);
+        }
+
+        /// <summary>Constructs a uint4x4 matrix from a bool4x4 matrix by componentwise conversion.</summary>
+        [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);
+        }
+
+        /// <summary>Constructs a uint4x4 matrix from a single int value by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint4x4(int v)
+        {
+            this.c0 = (uint4)v;
+            this.c1 = (uint4)v;
+            this.c2 = (uint4)v;
+            this.c3 = (uint4)v;
+        }
+
+        /// <summary>Constructs a uint4x4 matrix from a int4x4 matrix by componentwise conversion.</summary>
+        [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;
+        }
+
+        /// <summary>Constructs a uint4x4 matrix from a single float value by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint4x4(float v)
+        {
+            this.c0 = (uint4)v;
+            this.c1 = (uint4)v;
+            this.c2 = (uint4)v;
+            this.c3 = (uint4)v;
+        }
+
+        /// <summary>Constructs a uint4x4 matrix from a float4x4 matrix by componentwise conversion.</summary>
+        [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;
+        }
+
+        /// <summary>Constructs a uint4x4 matrix from a single double value by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint4x4(double v)
+        {
+            this.c0 = (uint4)v;
+            this.c1 = (uint4)v;
+            this.c2 = (uint4)v;
+            this.c3 = (uint4)v;
+        }
+
+        /// <summary>Constructs a uint4x4 matrix from a double4x4 matrix by componentwise conversion.</summary>
+        [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;
+        }
+
+
+        /// <summary>Implicitly converts a single uint value to a uint4x4 matrix by assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator uint4x4(uint v) { return new uint4x4(v); }
+
+        /// <summary>Explicitly converts a single bool value to a uint4x4 matrix by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator uint4x4(bool v) { return new uint4x4(v); }
+
+        /// <summary>Explicitly converts a bool4x4 matrix to a uint4x4 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator uint4x4(bool4x4 v) { return new uint4x4(v); }
+
+        /// <summary>Explicitly converts a single int value to a uint4x4 matrix by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator uint4x4(int v) { return new uint4x4(v); }
+
+        /// <summary>Explicitly converts a int4x4 matrix to a uint4x4 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator uint4x4(int4x4 v) { return new uint4x4(v); }
+
+        /// <summary>Explicitly converts a single float value to a uint4x4 matrix by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator uint4x4(float v) { return new uint4x4(v); }
+
+        /// <summary>Explicitly converts a float4x4 matrix to a uint4x4 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator uint4x4(float4x4 v) { return new uint4x4(v); }
+
+        /// <summary>Explicitly converts a single double value to a uint4x4 matrix by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator uint4x4(double v) { return new uint4x4(v); }
+
+        /// <summary>Explicitly converts a double4x4 matrix to a uint4x4 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator uint4x4(double4x4 v) { return new uint4x4(v); }
+
+
+        /// <summary>Returns the result of a componentwise multiplication operation on two uint4x4 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise multiplication operation on a uint4x4 matrix and a uint value.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise multiplication operation on a uint value and a uint4x4 matrix.</summary>
+        [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); }
+
+
+        /// <summary>Returns the result of a componentwise addition operation on two uint4x4 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise addition operation on a uint4x4 matrix and a uint value.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise addition operation on a uint value and a uint4x4 matrix.</summary>
+        [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); }
+
+
+        /// <summary>Returns the result of a componentwise subtraction operation on two uint4x4 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise subtraction operation on a uint4x4 matrix and a uint value.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise subtraction operation on a uint value and a uint4x4 matrix.</summary>
+        [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); }
+
+
+        /// <summary>Returns the result of a componentwise division operation on two uint4x4 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise division operation on a uint4x4 matrix and a uint value.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise division operation on a uint value and a uint4x4 matrix.</summary>
+        [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); }
+
+
+        /// <summary>Returns the result of a componentwise modulus operation on two uint4x4 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise modulus operation on a uint4x4 matrix and a uint value.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise modulus operation on a uint value and a uint4x4 matrix.</summary>
+        [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); }
+
+
+        /// <summary>Returns the result of a componentwise increment operation on a uint4x4 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x4 operator ++ (uint4x4 val) { return new uint4x4 (++val.c0, ++val.c1, ++val.c2, ++val.c3); }
+
+
+        /// <summary>Returns the result of a componentwise decrement operation on a uint4x4 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x4 operator -- (uint4x4 val) { return new uint4x4 (--val.c0, --val.c1, --val.c2, --val.c3); }
+
+
+        /// <summary>Returns the result of a componentwise less than operation on two uint4x4 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise less than operation on a uint4x4 matrix and a uint value.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise less than operation on a uint value and a uint4x4 matrix.</summary>
+        [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); }
+
+
+        /// <summary>Returns the result of a componentwise less or equal operation on two uint4x4 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise less or equal operation on a uint4x4 matrix and a uint value.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise less or equal operation on a uint value and a uint4x4 matrix.</summary>
+        [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); }
+
+
+        /// <summary>Returns the result of a componentwise greater than operation on two uint4x4 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise greater than operation on a uint4x4 matrix and a uint value.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise greater than operation on a uint value and a uint4x4 matrix.</summary>
+        [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); }
+
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on two uint4x4 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on a uint4x4 matrix and a uint value.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on a uint value and a uint4x4 matrix.</summary>
+        [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); }
+
+
+        /// <summary>Returns the result of a componentwise unary minus operation on a uint4x4 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x4 operator - (uint4x4 val) { return new uint4x4 (-val.c0, -val.c1, -val.c2, -val.c3); }
+
+
+        /// <summary>Returns the result of a componentwise unary plus operation on a uint4x4 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x4 operator + (uint4x4 val) { return new uint4x4 (+val.c0, +val.c1, +val.c2, +val.c3); }
+
+
+        /// <summary>Returns the result of a componentwise left shift operation on a uint4x4 matrix by a number of bits specified by a single int.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise right shift operation on a uint4x4 matrix by a number of bits specified by a single int.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise equality operation on two uint4x4 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a uint4x4 matrix and a uint value.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a uint value and a uint4x4 matrix.</summary>
+        [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); }
+
+
+        /// <summary>Returns the result of a componentwise not equal operation on two uint4x4 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a uint4x4 matrix and a uint value.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a uint value and a uint4x4 matrix.</summary>
+        [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); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise not operation on a uint4x4 matrix.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x4 operator ~ (uint4x4 val) { return new uint4x4 (~val.c0, ~val.c1, ~val.c2, ~val.c3); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise and operation on two uint4x4 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise bitwise and operation on a uint4x4 matrix and a uint value.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise bitwise and operation on a uint value and a uint4x4 matrix.</summary>
+        [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); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise or operation on two uint4x4 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise bitwise or operation on a uint4x4 matrix and a uint value.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise bitwise or operation on a uint value and a uint4x4 matrix.</summary>
+        [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); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise exclusive or operation on two uint4x4 matrices.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise bitwise exclusive or operation on a uint4x4 matrix and a uint value.</summary>
+        [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); }
+
+        /// <summary>Returns the result of a componentwise bitwise exclusive or operation on a uint value and a uint4x4 matrix.</summary>
+        [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); }
+
+
+
+        /// <summary>Returns the uint4 element at a specified index.</summary>
+        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]; }
+            }
+        }
+
+        /// <summary>Returns true if the uint4x4 is equal to a given uint4x4, false otherwise.</summary>
+        [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); }
+
+        /// <summary>Returns true if the uint4x4 is equal to a given uint4x4, false otherwise.</summary>
+        public override bool Equals(object o) { return Equals((uint4x4)o); }
+
+
+        /// <summary>Returns a hash code for the uint4x4.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override int GetHashCode() { return (int)math.hash(this); }
+
+
+        /// <summary>Returns a string representation of the uint4x4.</summary>
+        [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);
+        }
+
+        /// <summary>Returns a string representation of the uint4x4 using a specified format and culture-specific format information.</summary>
+        [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
+    {
+        /// <summary>Returns a uint4x4 matrix constructed from four uint4 vectors.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x4 uint4x4(uint4 c0, uint4 c1, uint4 c2, uint4 c3) { return new uint4x4(c0, c1, c2, c3); }
+
+        /// <summary>Returns a uint4x4 matrix constructed from from 16 uint values given in row-major order.</summary>
+        [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);
+        }
+
+        /// <summary>Returns a uint4x4 matrix constructed from a single uint value by assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x4 uint4x4(uint v) { return new uint4x4(v); }
+
+        /// <summary>Returns a uint4x4 matrix constructed from a single bool value by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x4 uint4x4(bool v) { return new uint4x4(v); }
+
+        /// <summary>Return a uint4x4 matrix constructed from a bool4x4 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x4 uint4x4(bool4x4 v) { return new uint4x4(v); }
+
+        /// <summary>Returns a uint4x4 matrix constructed from a single int value by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x4 uint4x4(int v) { return new uint4x4(v); }
+
+        /// <summary>Return a uint4x4 matrix constructed from a int4x4 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x4 uint4x4(int4x4 v) { return new uint4x4(v); }
+
+        /// <summary>Returns a uint4x4 matrix constructed from a single float value by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x4 uint4x4(float v) { return new uint4x4(v); }
+
+        /// <summary>Return a uint4x4 matrix constructed from a float4x4 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x4 uint4x4(float4x4 v) { return new uint4x4(v); }
+
+        /// <summary>Returns a uint4x4 matrix constructed from a single double value by converting it to uint and assigning it to every component.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x4 uint4x4(double v) { return new uint4x4(v); }
+
+        /// <summary>Return a uint4x4 matrix constructed from a double4x4 matrix by componentwise conversion.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4x4 uint4x4(double4x4 v) { return new uint4x4(v); }
+
+        /// <summary>Return the uint4x4 transpose of a uint4x4 matrix.</summary>
+        [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);
+        }
+
+        /// <summary>Returns a uint hash code of a uint4x4 vector.</summary>
+        [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;
+        }
+
+        /// <summary>
+        /// 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.
+        /// </summary>
+        [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;
+        }
+
+    }
+}

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: