Add files using upload-large-folder tool

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.psdimporter@4.0.2/Editor/PSDImportPostProcessor.cs

@@ -0,0 +1,85 @@
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor.U2D;
+using UnityEditor.U2D.Sprites;
+using UnityEngine;
+
+namespace UnityEditor.U2D.PSD
+{
+    internal class PSDImportPostProcessor : AssetPostprocessor
+    {
+        private static string s_CurrentApplyAssetPath = null;
+        
+        void OnPostprocessSprites(Texture2D texture, Sprite[] sprites)
+        {
+            var dataProviderFactories = new SpriteDataProviderFactories();
+            dataProviderFactories.Init();
+            PSDImporter psd = AssetImporter.GetAtPath(assetPath) as PSDImporter;
+            if (psd == null)
+                return;
+            ISpriteEditorDataProvider importer = dataProviderFactories.GetSpriteEditorDataProviderFromObject(psd);
+            if (importer != null)
+            {
+                importer.InitSpriteEditorDataProvider();
+                var physicsOutlineDataProvider = importer.GetDataProvider<ISpritePhysicsOutlineDataProvider>();
+                var textureDataProvider = importer.GetDataProvider<ITextureDataProvider>();
+                int actualWidth = 0, actualHeight = 0;
+                textureDataProvider.GetTextureActualWidthAndHeight(out actualWidth, out actualHeight);
+                float definitionScaleW = (float)texture.width / actualWidth;
+                float definitionScaleH = (float)texture.height / actualHeight;
+                float definitionScale = Mathf.Min(definitionScaleW, definitionScaleH);
+                foreach (var sprite in sprites)
+                {
+                    var guid = sprite.GetSpriteID();
+                    var outline = physicsOutlineDataProvider.GetOutlines(guid);
+                    var outlineOffset = sprite.rect.size / 2;
+                    if (outline != null && outline.Count > 0)
+                    {
+                        // Ensure that outlines are all valid.
+                        int validOutlineCount = 0;
+                        for (int i = 0; i < outline.Count; ++i)
+                            validOutlineCount = validOutlineCount + ( (outline[i].Length > 2) ? 1 : 0 );
+
+                        int index = 0;
+                        var convertedOutline = new Vector2[validOutlineCount][];
+                        for (int i = 0; i < outline.Count; ++i)
+                        {
+                            if (outline[i].Length > 2)
+                            {
+                                convertedOutline[index] = new Vector2[outline[i].Length];
+                                for (int j = 0; j < outline[i].Length; ++j)
+                                {
+                                    convertedOutline[index][j] = outline[i][j] * definitionScale + outlineOffset;
+                                }
+                                index++;
+                            }
+                        }
+                        sprite.OverridePhysicsShape(convertedOutline);
+                    }
+                }
+            }
+        }
+        
+        public static string currentApplyAssetPath
+        {
+            set { s_CurrentApplyAssetPath = value; }
+        }
+        static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromPath)
+        {
+            if (!string.IsNullOrEmpty(s_CurrentApplyAssetPath))
+            {
+                foreach (var asset in importedAssets)
+                {
+                    if (asset == s_CurrentApplyAssetPath)
+                    {
+                        var obj = AssetDatabase.LoadMainAssetAtPath(asset);
+                        Selection.activeObject = obj;
+                        Unsupported.SceneTrackerFlushDirty();
+                        s_CurrentApplyAssetPath = null;
+                        break;
+                    }
+                }
+            }
+        }
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.psdimporter@4.0.2/Editor/PSDImporterEditor.cs

@@ -0,0 +1,1126 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using PhotoshopFile;
+using UnityEditor.AssetImporters;
+using UnityEditor.U2D.Animation;
+using UnityEditor.U2D.Common;
+using UnityEditor.U2D.Sprites;
+using UnityEngine;
+using UnityEngine.Scripting.APIUpdating;
+
+namespace UnityEditor.U2D.PSD
+{
+    /// <summary>
+    /// Inspector for PSDImporter
+    /// </summary>
+    [CustomEditor(typeof(PSDImporter))]
+    [MovedFrom("UnityEditor.Experimental.AssetImporters")]
+    public class PSDImporterEditor : ScriptedImporterEditor, ITexturePlatformSettingsDataProvider
+    {
+        SerializedProperty m_TextureType;
+        SerializedProperty m_TextureShape;
+        SerializedProperty m_SpriteMode;
+        SerializedProperty m_SpritePixelsToUnits;
+        SerializedProperty m_SpriteMeshType;
+        SerializedProperty m_SpriteExtrude;
+        SerializedProperty m_Alignment;
+        SerializedProperty m_SpritePivot;
+        SerializedProperty m_NPOTScale;
+        SerializedProperty m_IsReadable;
+        SerializedProperty m_sRGBTexture;
+        SerializedProperty m_AlphaSource;
+        SerializedProperty m_MipMapMode;
+        SerializedProperty m_EnableMipMap;
+        SerializedProperty m_FadeOut;
+        SerializedProperty m_BorderMipMap;
+        SerializedProperty m_MipMapsPreserveCoverage;
+        SerializedProperty m_AlphaTestReferenceValue;
+        SerializedProperty m_MipMapFadeDistanceStart;
+        SerializedProperty m_MipMapFadeDistanceEnd;
+        SerializedProperty m_AlphaIsTransparency;
+        SerializedProperty m_FilterMode;
+        SerializedProperty m_Aniso;
+
+        SerializedProperty m_WrapU;
+        SerializedProperty m_WrapV;
+        SerializedProperty m_WrapW;
+        SerializedProperty m_ConvertToNormalMap;
+        SerializedProperty m_MosaicLayers;
+        SerializedProperty m_ImportHiddenLayers;
+        SerializedProperty m_ResliceFromLayer;
+        SerializedProperty m_CharacterMode;
+        SerializedProperty m_DocumentPivot;
+        SerializedProperty m_DocumentAlignment;
+        SerializedProperty m_GenerateGOHierarchy;
+        SerializedProperty m_PaperDollMode;
+        SerializedProperty m_KeepDupilcateSpriteName;
+
+        readonly int[] m_FilterModeOptions = (int[])(Enum.GetValues(typeof(FilterMode)));
+
+        bool    m_IsPOT = false;
+        bool m_ShowAdvanced = false;
+        bool m_ShowExperimental = false;
+        Dictionary<TextureImporterType, Action[]> m_AdvanceInspectorGUI = new Dictionary<TextureImporterType, Action[]>();
+        int m_PlatformSettingsIndex;
+        bool m_ShowPerAxisWrapModes = false;
+
+        TexturePlatformSettingsHelper m_TexturePlatformSettingsHelper;
+
+        TexturePlatformSettingsView m_TexturePlatformSettingsView = new TexturePlatformSettingsView();
+        TexturePlatformSettingsController m_TexturePlatformSettingsController = new TexturePlatformSettingsController();
+
+        /// <summary>
+        /// Implementation of AssetImporterEditor.OnEnable
+        /// </summary>
+        public override void OnEnable()
+        {
+            base.OnEnable();
+            m_MosaicLayers = serializedObject.FindProperty("m_MosaicLayers");
+            m_ImportHiddenLayers = serializedObject.FindProperty("m_ImportHiddenLayers");
+            m_ResliceFromLayer = serializedObject.FindProperty("m_ResliceFromLayer");
+            m_CharacterMode = serializedObject.FindProperty("m_CharacterMode");
+            m_DocumentPivot = serializedObject.FindProperty("m_DocumentPivot");
+            m_DocumentAlignment = serializedObject.FindProperty("m_DocumentAlignment");
+            m_GenerateGOHierarchy = serializedObject.FindProperty("m_GenerateGOHierarchy");
+            m_PaperDollMode = serializedObject.FindProperty("m_PaperDollMode");
+            m_KeepDupilcateSpriteName = serializedObject.FindProperty("m_KeepDupilcateSpriteName");
+
+            var textureImporterSettingsSP = serializedObject.FindProperty("m_TextureImporterSettings");
+            m_TextureType = textureImporterSettingsSP.FindPropertyRelative("m_TextureType");
+            m_TextureShape = textureImporterSettingsSP.FindPropertyRelative("m_TextureShape");
+            m_ConvertToNormalMap = textureImporterSettingsSP.FindPropertyRelative("m_ConvertToNormalMap");
+            m_SpriteMode = textureImporterSettingsSP.FindPropertyRelative("m_SpriteMode");
+            m_SpritePixelsToUnits = textureImporterSettingsSP.FindPropertyRelative("m_SpritePixelsToUnits");
+            m_SpriteMeshType = textureImporterSettingsSP.FindPropertyRelative("m_SpriteMeshType");
+            m_SpriteExtrude = textureImporterSettingsSP.FindPropertyRelative("m_SpriteExtrude");
+            m_Alignment = textureImporterSettingsSP.FindPropertyRelative("m_Alignment");
+            m_SpritePivot = textureImporterSettingsSP.FindPropertyRelative("m_SpritePivot");
+            m_NPOTScale = textureImporterSettingsSP.FindPropertyRelative("m_NPOTScale");
+            m_IsReadable = textureImporterSettingsSP.FindPropertyRelative("m_IsReadable");
+            m_sRGBTexture = textureImporterSettingsSP.FindPropertyRelative("m_sRGBTexture");
+            m_AlphaSource = textureImporterSettingsSP.FindPropertyRelative("m_AlphaSource");
+            m_MipMapMode = textureImporterSettingsSP.FindPropertyRelative("m_MipMapMode");
+            m_EnableMipMap = textureImporterSettingsSP.FindPropertyRelative("m_EnableMipMap");
+            m_FadeOut = textureImporterSettingsSP.FindPropertyRelative("m_FadeOut");
+            m_BorderMipMap = textureImporterSettingsSP.FindPropertyRelative("m_BorderMipMap");
+            m_MipMapsPreserveCoverage = textureImporterSettingsSP.FindPropertyRelative("m_MipMapsPreserveCoverage");
+            m_AlphaTestReferenceValue = textureImporterSettingsSP.FindPropertyRelative("m_AlphaTestReferenceValue");
+            m_MipMapFadeDistanceStart = textureImporterSettingsSP.FindPropertyRelative("m_MipMapFadeDistanceStart");
+            m_MipMapFadeDistanceEnd = textureImporterSettingsSP.FindPropertyRelative("m_MipMapFadeDistanceEnd");
+            m_AlphaIsTransparency = textureImporterSettingsSP.FindPropertyRelative("m_AlphaIsTransparency");
+            m_FilterMode = textureImporterSettingsSP.FindPropertyRelative("m_FilterMode");
+            m_Aniso = textureImporterSettingsSP.FindPropertyRelative("m_Aniso");
+            m_WrapU = textureImporterSettingsSP.FindPropertyRelative("m_WrapU");
+            m_WrapV = textureImporterSettingsSP.FindPropertyRelative("m_WrapV");
+            m_WrapW = textureImporterSettingsSP.FindPropertyRelative("m_WrapW");
+
+            var textureWidth = serializedObject.FindProperty("m_TextureActualWidth");
+            var textureHeight = serializedObject.FindProperty("m_TextureActualHeight");
+            m_IsPOT = Mathf.IsPowerOfTwo(textureWidth.intValue) && Mathf.IsPowerOfTwo(textureHeight.intValue);
+
+
+            var advanceGUIAction = new Action[]
+            {
+                ColorSpaceGUI,
+                AlphaHandlingGUI,
+                POTScaleGUI,
+                ReadableGUI,
+                MipMapGUI
+            };
+            m_AdvanceInspectorGUI.Add(TextureImporterType.Sprite, advanceGUIAction);
+
+            advanceGUIAction = new Action[]
+            {
+                POTScaleGUI,
+                ReadableGUI,
+                MipMapGUI
+            };
+            m_AdvanceInspectorGUI.Add(TextureImporterType.Default, advanceGUIAction);
+            LoadPlatformSettings();
+            m_TexturePlatformSettingsHelper = new TexturePlatformSettingsHelper(this);
+        }
+
+        /// <summary>
+        /// Implementation of AssetImporterEditor.OnInspectorGUI
+        /// </summary>
+        public override void OnInspectorGUI()
+        {
+            serializedObject.Update();
+            if (s_Styles == null)
+                s_Styles = new Styles();
+
+            EditorGUI.showMixedValue = m_TextureType.hasMultipleDifferentValues;
+            m_TextureType.intValue = EditorGUILayout.IntPopup(s_Styles.textureTypeTitle, m_TextureType.intValue, s_Styles.textureTypeOptions, s_Styles.textureTypeValues);
+            EditorGUI.showMixedValue = false;
+
+            switch ((TextureImporterType)m_TextureType.intValue)
+            {
+                case TextureImporterType.Sprite:
+                    DoSpriteInspector();
+                    break;
+                case TextureImporterType.Default:
+                    DoTextureDefaultInspector();
+                    break;
+                default:
+                    Debug.LogWarning("We only support Default or Sprite texture type for now. Texture type is set to default.");
+                    m_TextureType.intValue = (int)TextureImporterType.Default;
+                    break;
+            }
+
+            DoAdvanceInspector();
+            CommonTextureSettingsGUI();
+            GUILayout.Space(10);
+            DoPlatformSettings();
+            serializedObject.ApplyModifiedProperties();
+            ApplyRevertGUI();
+        }
+
+        /// <summary>
+        /// Implementation of AssetImporterEditor.Apply
+        /// </summary>
+        protected override void Apply()
+        {
+            FileStream fileStream = new FileStream(((AssetImporter)target).assetPath, FileMode.Open, FileAccess.Read);
+            var doc = PaintDotNet.Data.PhotoshopFileType.PsdLoad.Load(fileStream, ELoadFlag.Header | ELoadFlag.ColorMode);
+
+            PSDApplyEvent evt = new PSDApplyEvent()
+            {
+                instance_id = target.GetInstanceID(),
+                texture_type = m_TextureType.intValue,
+                sprite_mode = m_SpriteMode.intValue,
+                mosaic_layer = m_MosaicLayers.boolValue,
+                import_hidden_layer = m_ImportHiddenLayers.boolValue,
+                character_mode = m_CharacterMode.boolValue,
+                generate_go_hierarchy = m_GenerateGOHierarchy.boolValue,
+                reslice_from_layer = m_ResliceFromLayer.boolValue,
+                is_character_rigged = IsCharacterRigged(),
+                is_psd = IsPSD(doc),
+                color_mode = FileColorMode(doc)
+            };
+            doc.Cleanup();
+            AnalyticFactory.analytics.SendApplyEvent(evt);
+            m_TexturePlatformSettingsHelper.Apply();
+            base.Apply();
+            Selection.activeObject = null;
+            Unsupported.SceneTrackerFlushDirty();
+            PSDImportPostProcessor.currentApplyAssetPath = ((PSDImporter) target).assetPath;
+        }
+
+        static bool IsPSD(PsdFile doc)
+        {
+            return !doc.IsLargeDocument;
+        }
+
+        static PsdColorMode FileColorMode(PsdFile doc)
+        {
+            return doc.ColorMode;
+        }
+
+        bool IsCharacterRigged()
+        {
+            var importer = target as PSDImporter;
+            if (importer != null)
+            {
+                var characterProvider = importer.GetDataProvider<ICharacterDataProvider>();
+                var meshDataProvider = importer.GetDataProvider<ISpriteMeshDataProvider>();
+                if (characterProvider != null && meshDataProvider != null)
+                {
+                    var character = characterProvider.GetCharacterData();
+                    foreach (var parts in character.parts)
+                    {
+                        var vert = meshDataProvider.GetVertices(new GUID(parts.spriteId));
+                        var indices = meshDataProvider.GetIndices(new GUID(parts.spriteId));
+                        if (parts.bones != null && parts.bones.Length > 0 &&
+                            vert != null && vert.Length > 0 &&
+                            indices != null && indices.Length > 0)
+                            return true;
+                    }
+                }
+            }
+            return false;
+        }
+
+        Dictionary<string, List<TextureImporterPlatformSettings>> m_PlatfromSettings = new Dictionary<string, List<TextureImporterPlatformSettings>>();
+        void LoadPlatformSettings()
+        {
+            foreach (var t in targets)
+            {
+                var importer = ((PSDImporter)t);
+                var importerPlatformSettings = importer.GetAllPlatformSettings();
+                for (int i = 0; i < importerPlatformSettings.Length; ++i)
+                {
+                    var tip = importerPlatformSettings[i];
+                    List<TextureImporterPlatformSettings> platformSettings = null;
+                    m_PlatfromSettings.TryGetValue(tip.name, out platformSettings);
+                    if (platformSettings == null)
+                    {
+                        platformSettings = new List<TextureImporterPlatformSettings>();
+                        m_PlatfromSettings.Add(tip.name, platformSettings);
+                    }
+                    platformSettings.Add(tip);
+                }
+            }
+        }
+
+        void StorePlatformSettings()
+        {
+            var platformSettingsSP = serializedObject.FindProperty("m_PlatformSettings");
+            platformSettingsSP.ClearArray();
+            foreach (var keyValue in m_PlatfromSettings)
+            {
+                if (!keyValue.Value[0].overridden)
+                    continue;
+
+                SerializedProperty platformSettingSP = null;
+                for (int i = 0; i < platformSettingsSP.arraySize; ++i)
+                {
+                    var sp = platformSettingsSP.GetArrayElementAtIndex(i);
+                    if (sp.FindPropertyRelative("m_Name").stringValue == keyValue.Key)
+                        platformSettingSP = sp;
+                }
+                if (platformSettingSP == null)
+                {
+                    platformSettingsSP.InsertArrayElementAtIndex(platformSettingsSP.arraySize);
+                    platformSettingSP = platformSettingsSP.GetArrayElementAtIndex(platformSettingsSP.arraySize - 1);
+                }
+
+                var tip = keyValue.Value[0];
+                platformSettingSP.FindPropertyRelative("m_Name").stringValue = tip.name;
+                platformSettingSP.FindPropertyRelative("m_Overridden").intValue = tip.overridden ? 1 : 0;
+                platformSettingSP.FindPropertyRelative("m_MaxTextureSize").intValue = tip.maxTextureSize;
+                platformSettingSP.FindPropertyRelative("m_ResizeAlgorithm").intValue = (int)tip.resizeAlgorithm;
+                platformSettingSP.FindPropertyRelative("m_TextureFormat").intValue = (int)tip.format;
+                platformSettingSP.FindPropertyRelative("m_TextureCompression").intValue = (int)tip.textureCompression;
+                platformSettingSP.FindPropertyRelative("m_CompressionQuality").intValue = tip.compressionQuality;
+                platformSettingSP.FindPropertyRelative("m_CrunchedCompression").intValue = tip.crunchedCompression ? 1 : 0;
+                platformSettingSP.FindPropertyRelative("m_AllowsAlphaSplitting").intValue = tip.allowsAlphaSplitting ? 1 : 0;
+            }
+        }
+
+        void DoPlatformSettings()
+        {
+            m_TexturePlatformSettingsHelper.ShowPlatformSpecificSettings();
+        }
+
+        void DoAdvanceInspector()
+        {
+            if (!m_TextureType.hasMultipleDifferentValues)
+            {
+                if (m_AdvanceInspectorGUI.ContainsKey((TextureImporterType)m_TextureType.intValue))
+                {
+                    EditorGUILayout.Space();
+
+                    m_ShowAdvanced = EditorGUILayout.Foldout(m_ShowAdvanced, s_Styles.showAdvanced, true);
+                    if (m_ShowAdvanced)
+                    {
+                        foreach (var action in m_AdvanceInspectorGUI[(TextureImporterType)m_TextureType.intValue])
+                        {
+                            action();
+                        }
+                    }
+                }
+            }
+            EditorGUILayout.Space();
+        }
+
+        void CommonTextureSettingsGUI()
+        {
+            EditorGUI.BeginChangeCheck();
+
+            // Wrap mode
+            bool isVolume = false;
+            WrapModePopup(m_WrapU, m_WrapV, m_WrapW, isVolume, ref m_ShowPerAxisWrapModes);
+
+
+            // Display warning about repeat wrap mode on restricted npot emulation
+            if (m_NPOTScale.intValue == (int)TextureImporterNPOTScale.None &&
+                (m_WrapU.intValue == (int)TextureWrapMode.Repeat || m_WrapV.intValue == (int)TextureWrapMode.Repeat) &&
+                !InternalEditorBridge.DoesHardwareSupportsFullNPOT())
+            {
+                bool displayWarning = false;
+                foreach (var target in targets)
+                {
+                    var imp = (PSDImporter)target;
+                    int w = imp.textureActualWidth;
+                    int h = imp.textureActualHeight;
+                    if (!Mathf.IsPowerOfTwo(w) || !Mathf.IsPowerOfTwo(h))
+                    {
+                        displayWarning = true;
+                        break;
+                    }
+                }
+
+                if (displayWarning)
+                {
+                    EditorGUILayout.HelpBox(s_Styles.warpNotSupportWarning.text, MessageType.Warning, true);
+                }
+            }
+
+            // Filter mode
+            EditorGUI.showMixedValue = m_FilterMode.hasMultipleDifferentValues;
+            FilterMode filter = (FilterMode)m_FilterMode.intValue;
+            if ((int)filter == -1)
+            {
+                if (m_FadeOut.intValue > 0 || m_ConvertToNormalMap.intValue > 0)
+                    filter = FilterMode.Trilinear;
+                else
+                    filter = FilterMode.Bilinear;
+            }
+            filter = (FilterMode)EditorGUILayout.IntPopup(s_Styles.filterMode, (int)filter, s_Styles.filterModeOptions, m_FilterModeOptions);
+            EditorGUI.showMixedValue = false;
+            if (EditorGUI.EndChangeCheck())
+                m_FilterMode.intValue = (int)filter;
+
+            // Aniso
+            bool showAniso = (FilterMode)m_FilterMode.intValue != FilterMode.Point
+                && m_EnableMipMap.intValue > 0
+                && (TextureImporterShape)m_TextureShape.intValue != TextureImporterShape.TextureCube;
+            using (new EditorGUI.DisabledScope(!showAniso))
+            {
+                EditorGUI.BeginChangeCheck();
+                EditorGUI.showMixedValue = m_Aniso.hasMultipleDifferentValues;
+                int aniso = m_Aniso.intValue;
+                if (aniso == -1)
+                    aniso = 1;
+                aniso = EditorGUILayout.IntSlider(s_Styles.anisoLevelLabel, aniso, 0, 16);
+                EditorGUI.showMixedValue = false;
+                if (EditorGUI.EndChangeCheck())
+                    m_Aniso.intValue = aniso;
+
+                if (aniso > 1)
+                {
+                    if (QualitySettings.anisotropicFiltering == AnisotropicFiltering.Disable)
+                        EditorGUILayout.HelpBox(s_Styles.anisotropicDisableInfo.text, MessageType.Info);
+                    else if (QualitySettings.anisotropicFiltering == AnisotropicFiltering.ForceEnable)
+                        EditorGUILayout.HelpBox(s_Styles.anisotropicForceEnableInfo.text, MessageType.Info);
+                }
+            }
+        }
+
+        private static bool IsAnyTextureObjectUsingPerAxisWrapMode(UnityEngine.Object[] objects, bool isVolumeTexture)
+        {
+            foreach (var o in objects)
+            {
+                int u = 0, v = 0, w = 0;
+                // the objects can be Textures themselves, or texture-related importers
+                if (o is Texture)
+                {
+                    var ti = (Texture)o;
+                    u = (int)ti.wrapModeU;
+                    v = (int)ti.wrapModeV;
+                    w = (int)ti.wrapModeW;
+                }
+                if (o is TextureImporter)
+                {
+                    var ti = (TextureImporter)o;
+                    u = (int)ti.wrapModeU;
+                    v = (int)ti.wrapModeV;
+                    w = (int)ti.wrapModeW;
+                }
+                if (o is IHVImageFormatImporter)
+                {
+                    var ti = (IHVImageFormatImporter)o;
+                    u = (int)ti.wrapModeU;
+                    v = (int)ti.wrapModeV;
+                    w = (int)ti.wrapModeW;
+                }
+                u = Mathf.Max(0, u);
+                v = Mathf.Max(0, v);
+                w = Mathf.Max(0, w);
+                if (u != v)
+                {
+                    return true;
+                }
+                if (isVolumeTexture)
+                {
+                    if (u != w || v != w)
+                    {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
+
+        // showPerAxisWrapModes is state of whether "Per-Axis" mode should be active in the main dropdown.
+        // It is set automatically if wrap modes in UVW are different, or if user explicitly picks "Per-Axis" option -- when that one is picked,
+        // then it should stay true even if UVW wrap modes will initially be the same.
+        //
+        // Note: W wrapping mode is only shown when isVolumeTexture is true.
+        internal static void WrapModePopup(SerializedProperty wrapU, SerializedProperty wrapV, SerializedProperty wrapW, bool isVolumeTexture, ref bool showPerAxisWrapModes)
+        {
+            if (s_Styles == null)
+                s_Styles = new Styles();
+
+            // In texture importer settings, serialized properties for things like wrap modes can contain -1;
+            // that seems to indicate "use defaults, user has not changed them to anything" but not totally sure.
+            // Show them as Repeat wrap modes in the popups.
+            var wu = (TextureWrapMode)Mathf.Max(wrapU.intValue, 0);
+            var wv = (TextureWrapMode)Mathf.Max(wrapV.intValue, 0);
+            var ww = (TextureWrapMode)Mathf.Max(wrapW.intValue, 0);
+
+            // automatically go into per-axis mode if values are already different
+            if (wu != wv)
+                showPerAxisWrapModes = true;
+            if (isVolumeTexture)
+            {
+                if (wu != ww || wv != ww)
+                    showPerAxisWrapModes = true;
+            }
+
+            // It's not possible to determine whether any single texture in the whole selection is using per-axis wrap modes
+            // just from SerializedProperty values. They can only tell if "some values in whole selection are different" (e.g.
+            // wrap value on U axis is not the same among all textures), and can return value of "some" object in the selection
+            // (typically based on object loading order). So in order for more intuitive behavior with multi-selection,
+            // we go over the actual objects when there's >1 object selected and some wrap modes are different.
+            if (!showPerAxisWrapModes)
+            {
+                if (wrapU.hasMultipleDifferentValues || wrapV.hasMultipleDifferentValues || (isVolumeTexture && wrapW.hasMultipleDifferentValues))
+                {
+                    if (IsAnyTextureObjectUsingPerAxisWrapMode(wrapU.serializedObject.targetObjects, isVolumeTexture))
+                    {
+                        showPerAxisWrapModes = true;
+                    }
+                }
+            }
+
+            int value = showPerAxisWrapModes ? -1 : (int)wu;
+
+            // main wrap mode popup
+            EditorGUI.BeginChangeCheck();
+            EditorGUI.showMixedValue = !showPerAxisWrapModes && (wrapU.hasMultipleDifferentValues || wrapV.hasMultipleDifferentValues || (isVolumeTexture && wrapW.hasMultipleDifferentValues));
+            value = EditorGUILayout.IntPopup(s_Styles.wrapModeLabel, value, s_Styles.wrapModeContents, s_Styles.wrapModeValues);
+            if (EditorGUI.EndChangeCheck() && value != -1)
+            {
+                // assign the same wrap mode to all axes, and hide per-axis popups
+                wrapU.intValue = value;
+                wrapV.intValue = value;
+                wrapW.intValue = value;
+                showPerAxisWrapModes = false;
+            }
+
+            // show per-axis popups if needed
+            if (value == -1)
+            {
+                showPerAxisWrapModes = true;
+                EditorGUI.indentLevel++;
+                WrapModeAxisPopup(s_Styles.wrapU, wrapU);
+                WrapModeAxisPopup(s_Styles.wrapV, wrapV);
+                if (isVolumeTexture)
+                {
+                    WrapModeAxisPopup(s_Styles.wrapW, wrapW);
+                }
+                EditorGUI.indentLevel--;
+            }
+            EditorGUI.showMixedValue = false;
+        }
+
+        static void WrapModeAxisPopup(GUIContent label, SerializedProperty wrapProperty)
+        {
+            // In texture importer settings, serialized properties for wrap modes can contain -1, which means "use default".
+            var wrap = (TextureWrapMode)Mathf.Max(wrapProperty.intValue, 0);
+            Rect rect = EditorGUILayout.GetControlRect();
+            EditorGUI.BeginChangeCheck();
+            EditorGUI.BeginProperty(rect, label, wrapProperty);
+            wrap = (TextureWrapMode)EditorGUI.EnumPopup(rect, label, wrap);
+            EditorGUI.EndProperty();
+            if (EditorGUI.EndChangeCheck())
+            {
+                wrapProperty.intValue = (int)wrap;
+            }
+        }
+
+        void DoWrapModePopup()
+        {
+            WrapModePopup(m_WrapU, m_WrapV, m_WrapW, IsVolume(), ref m_ShowPerAxisWrapModes);
+        }
+
+        bool IsVolume()
+        {
+            var t = target as Texture;
+            return t != null && t.dimension == UnityEngine.Rendering.TextureDimension.Tex3D;
+        }
+
+        void DoSpriteInspector()
+        {
+            EditorGUI.BeginChangeCheck();
+            EditorGUILayout.IntPopup(m_SpriteMode, s_Styles.spriteModeOptions, new[] { 1, 2, 3 }, s_Styles.spriteMode);
+
+            // Ensure that PropertyField focus will be cleared when we change spriteMode.
+            if (EditorGUI.EndChangeCheck())
+            {
+                GUIUtility.keyboardControl = 0;
+            }
+
+            EditorGUI.indentLevel++;
+
+            // Show generic attributes
+            if (m_SpriteMode.intValue != 0)
+            {
+                EditorGUILayout.PropertyField(m_SpritePixelsToUnits, s_Styles.spritePixelsPerUnit);
+
+                if (m_SpriteMode.intValue != (int)SpriteImportMode.Polygon && !m_SpriteMode.hasMultipleDifferentValues)
+                {
+                    EditorGUILayout.IntPopup(m_SpriteMeshType, s_Styles.spriteMeshTypeOptions, new[] { 0, 1 }, s_Styles.spriteMeshType);
+                }
+
+                EditorGUILayout.IntSlider(m_SpriteExtrude, 0, 32, s_Styles.spriteExtrude);
+
+                if (m_SpriteMode.intValue == 1)
+                {
+                    EditorGUILayout.IntPopup(m_Alignment, s_Styles.spriteAlignmentOptions, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }, s_Styles.spriteAlignment);
+
+                    if (m_Alignment.intValue == (int)SpriteAlignment.Custom)
+                    {
+                        GUILayout.BeginHorizontal();
+                        EditorGUILayout.PropertyField(m_SpritePivot, new GUIContent());
+                        GUILayout.EndHorizontal();
+                    }
+                }
+            }
+
+            EditorGUILayout.PropertyField(m_ImportHiddenLayers, s_Styles.importHiddenLayer);
+            if (m_SpriteMode.intValue == (int)SpriteImportMode.Multiple && !m_SpriteMode.hasMultipleDifferentValues)
+            {
+                EditorGUILayout.PropertyField(m_MosaicLayers, s_Styles.mosaicLayers);
+                using (new EditorGUI.DisabledScope(!m_MosaicLayers.boolValue))
+                {
+                    EditorGUILayout.PropertyField(m_CharacterMode, s_Styles.characterMode);
+                    using (new EditorGUI.DisabledScope(!m_CharacterMode.boolValue))
+                    {
+                        EditorGUILayout.PropertyField(m_GenerateGOHierarchy, s_Styles.generateGOHierarchy);
+                        EditorGUILayout.IntPopup(m_DocumentAlignment, s_Styles.spriteAlignmentOptions, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }, s_Styles.characterAlignment);
+                        if (m_DocumentAlignment.intValue == (int)SpriteAlignment.Custom)
+                        {
+                            GUILayout.BeginHorizontal();
+                            GUILayout.Space(EditorGUIUtility.labelWidth);
+                            EditorGUILayout.PropertyField(m_DocumentPivot, new GUIContent());
+                            GUILayout.EndHorizontal();
+                        }
+                        //EditorGUILayout.PropertyField(m_PaperDollMode, s_Styles.paperDollMode);
+                    }
+
+
+                    EditorGUILayout.PropertyField(m_ResliceFromLayer, s_Styles.resliceFromLayer);
+                    if (m_ResliceFromLayer.boolValue)
+                    {
+                        EditorGUILayout.HelpBox(s_Styles.resliceFromLayerWarning.text, MessageType.Info, true);
+                    }
+                }
+                m_ShowExperimental = EditorGUILayout.Foldout(m_ShowExperimental, s_Styles.experimental, true);
+                if (m_ShowExperimental)
+                {
+                    EditorGUI.indentLevel++;
+                    EditorGUILayout.PropertyField(m_KeepDupilcateSpriteName, s_Styles.keepDuplicateSpriteName);
+                    EditorGUI.indentLevel--;
+                }
+            }
+
+            using (new EditorGUI.DisabledScope(targets.Length != 1))
+            {
+                GUILayout.BeginHorizontal();
+
+                GUILayout.FlexibleSpace();
+                if (GUILayout.Button(s_Styles.spriteEditorButtonLabel))
+                {
+                    if (HasModified())
+                    {
+                        // To ensure Sprite Editor Window to have the latest texture import setting,
+                        // We must applied those modified values first.
+                        string dialogText = string.Format(s_Styles.unappliedSettingsDialogContent.text, ((AssetImporter)target).assetPath);
+                        if (EditorUtility.DisplayDialog(s_Styles.unappliedSettingsDialogTitle.text,
+                            dialogText, s_Styles.applyButtonLabel.text, s_Styles.revertButtonLabel.text))
+                        {
+                            ApplyAndImport();
+                            InternalEditorBridge.ShowSpriteEditorWindow(this.assetTarget);
+
+                            // We reimported the asset which destroyed the editor, so we can't keep running the UI here.
+                            GUIUtility.ExitGUI();
+                        }
+                    }
+                    else
+                    {
+                        InternalEditorBridge.ShowSpriteEditorWindow(this.assetTarget);
+                    }
+                }
+                GUILayout.EndHorizontal();
+            }
+            EditorGUI.indentLevel--;
+        }
+
+        void DoTextureDefaultInspector()
+        {
+            ColorSpaceGUI();
+            AlphaHandlingGUI();
+        }
+
+        void ColorSpaceGUI()
+        {
+            ToggleFromInt(m_sRGBTexture, s_Styles.sRGBTexture);
+        }
+
+        void POTScaleGUI()
+        {
+            using (new EditorGUI.DisabledScope(m_IsPOT || m_TextureType.intValue == (int)TextureImporterType.Sprite))
+            {
+                EnumPopup(m_NPOTScale, typeof(TextureImporterNPOTScale), s_Styles.npot);
+            }
+        }
+
+        void ReadableGUI()
+        {
+            ToggleFromInt(m_IsReadable, s_Styles.readWrite);
+        }
+
+        void AlphaHandlingGUI()
+        {
+            EditorGUI.showMixedValue = m_AlphaSource.hasMultipleDifferentValues;
+            EditorGUI.BeginChangeCheck();
+            int newAlphaUsage = EditorGUILayout.IntPopup(s_Styles.alphaSource, m_AlphaSource.intValue, s_Styles.alphaSourceOptions, s_Styles.alphaSourceValues);
+
+            EditorGUI.showMixedValue = false;
+            if (EditorGUI.EndChangeCheck())
+            {
+                m_AlphaSource.intValue = newAlphaUsage;
+            }
+
+            bool showAlphaIsTransparency = (TextureImporterAlphaSource)m_AlphaSource.intValue != TextureImporterAlphaSource.None;
+            using (new EditorGUI.DisabledScope(!showAlphaIsTransparency))
+            {
+                ToggleFromInt(m_AlphaIsTransparency, s_Styles.alphaIsTransparency);
+            }
+        }
+
+        void MipMapGUI()
+        {
+            ToggleFromInt(m_EnableMipMap, s_Styles.generateMipMaps);
+
+            if (m_EnableMipMap.boolValue && !m_EnableMipMap.hasMultipleDifferentValues)
+            {
+                EditorGUI.indentLevel++;
+                ToggleFromInt(m_BorderMipMap, s_Styles.borderMipMaps);
+                EditorGUILayout.Popup(s_Styles.mipMapFilter, m_MipMapMode.intValue, s_Styles.mipMapFilterOptions);
+
+                ToggleFromInt(m_MipMapsPreserveCoverage, s_Styles.mipMapsPreserveCoverage);
+                if (m_MipMapsPreserveCoverage.intValue != 0 && !m_MipMapsPreserveCoverage.hasMultipleDifferentValues)
+                {
+                    EditorGUI.indentLevel++;
+                    EditorGUILayout.PropertyField(m_AlphaTestReferenceValue, s_Styles.alphaTestReferenceValue);
+                    EditorGUI.indentLevel--;
+                }
+
+                // Mipmap fadeout
+                ToggleFromInt(m_FadeOut, s_Styles.mipmapFadeOutToggle);
+                if (m_FadeOut.intValue > 0)
+                {
+                    EditorGUI.indentLevel++;
+                    EditorGUI.BeginChangeCheck();
+                    float min = m_MipMapFadeDistanceStart.intValue;
+                    float max = m_MipMapFadeDistanceEnd.intValue;
+                    EditorGUILayout.MinMaxSlider(s_Styles.mipmapFadeOut, ref min, ref max, 0, 10);
+                    if (EditorGUI.EndChangeCheck())
+                    {
+                        m_MipMapFadeDistanceStart.intValue = Mathf.RoundToInt(min);
+                        m_MipMapFadeDistanceEnd.intValue = Mathf.RoundToInt(max);
+                    }
+                    EditorGUI.indentLevel--;
+                }
+                EditorGUI.indentLevel--;
+            }
+        }
+
+        void ToggleFromInt(SerializedProperty property, GUIContent label)
+        {
+            EditorGUI.BeginChangeCheck();
+            EditorGUI.showMixedValue = property.hasMultipleDifferentValues;
+            int value = EditorGUILayout.Toggle(label, property.intValue > 0) ? 1 : 0;
+            EditorGUI.showMixedValue = false;
+            if (EditorGUI.EndChangeCheck())
+                property.intValue = value;
+        }
+
+        void EnumPopup(SerializedProperty property, System.Type type, GUIContent label)
+        {
+            EditorGUILayout.IntPopup(label.text, property.intValue,
+                System.Enum.GetNames(type),
+                System.Enum.GetValues(type) as int[]);
+        }
+
+        void ExportMosaicTexture()
+        {
+            var assetPath = ((AssetImporter)target).assetPath;
+            var texture2D = AssetDatabase.LoadAssetAtPath<Texture2D>(assetPath);
+            if (texture2D == null)
+                return;
+            if (!texture2D.isReadable)
+                texture2D = InternalEditorBridge.CreateTemporaryDuplicate(texture2D, texture2D.width, texture2D.height);
+            var pixelData = texture2D.GetPixels();
+            texture2D = new Texture2D(texture2D.width, texture2D.height);
+            texture2D.SetPixels(pixelData);
+            texture2D.Apply();
+            byte[] bytes = texture2D.EncodeToPNG();
+            var fileName = Path.GetFileNameWithoutExtension(assetPath);
+            var filePath = Path.GetDirectoryName(assetPath);
+            var savePath = Path.Combine(filePath, fileName + ".png");
+            File.WriteAllBytes(savePath, bytes);
+            AssetDatabase.Refresh();
+        }
+
+        protected override void ResetValues()
+        {
+            base.ResetValues();
+            LoadPlatformSettings();
+            m_TexturePlatformSettingsHelper = new TexturePlatformSettingsHelper(this);
+        }
+
+        public int GetTargetCount()
+        {
+            return targets.Length;
+        }
+
+        public TextureImporterPlatformSettings GetPlatformTextureSettings(int i, string name)
+        {
+            if(m_PlatfromSettings.ContainsKey(name))
+                if(m_PlatfromSettings[name].Count > i)
+                    return m_PlatfromSettings[name][i];
+            return new TextureImporterPlatformSettings()
+            {
+                name = name,
+                overridden = false
+            };
+        }
+
+        public bool ShowPresetSettings()
+        {
+            return assetTarget == null;
+        }
+
+        public bool DoesSourceTextureHaveAlpha(int v)
+        {
+            return true;
+        }
+
+        public bool IsSourceTextureHDR(int v)
+        {
+            return false;
+        }
+
+        public void SetPlatformTextureSettings(int i, TextureImporterPlatformSettings platformSettings)
+        {
+            var psdImporter = ((PSDImporter)targets[i]);
+            psdImporter.SetPlatformTextureSettings(platformSettings);
+            psdImporter.Apply();
+        }
+
+        public void GetImporterSettings(int i, TextureImporterSettings settings)
+        {
+            ((PSDImporter)targets[i]).ReadTextureSettings(settings);
+            // Get settings that have been changed in the inspector
+            GetSerializedPropertySettings(settings);
+        }
+
+        internal TextureImporterSettings GetSerializedPropertySettings(TextureImporterSettings settings)
+        {
+            if (!m_AlphaSource.hasMultipleDifferentValues)
+                settings.alphaSource = (TextureImporterAlphaSource)m_AlphaSource.intValue;
+
+            if (!m_ConvertToNormalMap.hasMultipleDifferentValues)
+                settings.convertToNormalMap = m_ConvertToNormalMap.intValue > 0;
+
+            if (!m_BorderMipMap.hasMultipleDifferentValues)
+                settings.borderMipmap = m_BorderMipMap.intValue > 0;
+
+            if (!m_MipMapsPreserveCoverage.hasMultipleDifferentValues)
+                settings.mipMapsPreserveCoverage = m_MipMapsPreserveCoverage.intValue > 0;
+
+            if (!m_AlphaTestReferenceValue.hasMultipleDifferentValues)
+                settings.alphaTestReferenceValue = m_AlphaTestReferenceValue.floatValue;
+
+            if (!m_NPOTScale.hasMultipleDifferentValues)
+                settings.npotScale = (TextureImporterNPOTScale)m_NPOTScale.intValue;
+
+            if (!m_IsReadable.hasMultipleDifferentValues)
+                settings.readable = m_IsReadable.intValue > 0;
+
+            if (!m_sRGBTexture.hasMultipleDifferentValues)
+                settings.sRGBTexture = m_sRGBTexture.intValue > 0;
+
+            if (!m_EnableMipMap.hasMultipleDifferentValues)
+                settings.mipmapEnabled = m_EnableMipMap.intValue > 0;
+
+            if (!m_MipMapMode.hasMultipleDifferentValues)
+                settings.mipmapFilter = (TextureImporterMipFilter)m_MipMapMode.intValue;
+
+            if (!m_FadeOut.hasMultipleDifferentValues)
+                settings.fadeOut = m_FadeOut.intValue > 0;
+
+            if (!m_MipMapFadeDistanceStart.hasMultipleDifferentValues)
+                settings.mipmapFadeDistanceStart = m_MipMapFadeDistanceStart.intValue;
+
+            if (!m_MipMapFadeDistanceEnd.hasMultipleDifferentValues)
+                settings.mipmapFadeDistanceEnd = m_MipMapFadeDistanceEnd.intValue;
+
+            if (!m_SpriteMode.hasMultipleDifferentValues)
+                settings.spriteMode = m_SpriteMode.intValue;
+
+            if (!m_SpritePixelsToUnits.hasMultipleDifferentValues)
+                settings.spritePixelsPerUnit = m_SpritePixelsToUnits.floatValue;
+
+            if (!m_SpriteExtrude.hasMultipleDifferentValues)
+                settings.spriteExtrude = (uint)m_SpriteExtrude.intValue;
+
+            if (!m_SpriteMeshType.hasMultipleDifferentValues)
+                settings.spriteMeshType = (SpriteMeshType)m_SpriteMeshType.intValue;
+
+            if (!m_Alignment.hasMultipleDifferentValues)
+                settings.spriteAlignment = m_Alignment.intValue;
+
+            if (!m_SpritePivot.hasMultipleDifferentValues)
+                settings.spritePivot = m_SpritePivot.vector2Value;
+
+            if (!m_WrapU.hasMultipleDifferentValues)
+                settings.wrapModeU = (TextureWrapMode)m_WrapU.intValue;
+            if (!m_WrapV.hasMultipleDifferentValues)
+                settings.wrapModeU = (TextureWrapMode)m_WrapV.intValue;
+            if (!m_WrapW.hasMultipleDifferentValues)
+                settings.wrapModeU = (TextureWrapMode)m_WrapW.intValue;
+
+            if (!m_FilterMode.hasMultipleDifferentValues)
+                settings.filterMode = (FilterMode)m_FilterMode.intValue;
+
+            if (!m_Aniso.hasMultipleDifferentValues)
+                settings.aniso = m_Aniso.intValue;
+
+
+            if (!m_AlphaIsTransparency.hasMultipleDifferentValues)
+                settings.alphaIsTransparency = m_AlphaIsTransparency.intValue > 0;
+
+            if (!m_TextureType.hasMultipleDifferentValues)
+                settings.textureType = (TextureImporterType)m_TextureType.intValue;
+
+            if (!m_TextureShape.hasMultipleDifferentValues)
+                settings.textureShape = (TextureImporterShape)m_TextureShape.intValue;
+
+            return settings;
+        }
+        /// <summary>
+        /// Override of AssetImporterEditor.showImportedObject
+        /// The property always returns false so that imported objects does not show up in the Inspector.
+        /// </summary>
+        /// <returns>false</returns>
+        public override bool showImportedObject
+        {
+            get { return false; }
+        }
+        
+        public bool textureTypeHasMultipleDifferentValues
+        {
+           get { return m_TextureType.hasMultipleDifferentValues; }
+        }
+
+        public TextureImporterType textureType
+        {
+           get { return (TextureImporterType)m_TextureType.intValue; }
+        }
+
+        public SpriteImportMode spriteImportMode
+        {
+            get { return (SpriteImportMode)m_SpriteMode.intValue; }
+        }
+
+        public override bool HasModified()
+        {
+            if (base.HasModified())
+                return true;
+
+            return m_TexturePlatformSettingsHelper.HasModified();
+        }
+
+        internal class Styles
+        {
+            public readonly GUIContent textureTypeTitle = new GUIContent("Texture Type", "What will this texture be used for?");
+            public readonly GUIContent[] textureTypeOptions =
+            {
+                new GUIContent("Default", "Texture is a normal image such as a diffuse texture or other."),
+                new GUIContent("Sprite (2D and UI)", "Texture is used for a sprite."),
+            };
+            public readonly int[] textureTypeValues =
+            {
+                (int)TextureImporterType.Default,
+                (int)TextureImporterType.Sprite,
+            };
+
+            public readonly GUIContent textureShape = new GUIContent("Texture Shape", "What shape is this texture?");
+            private readonly GUIContent textureShape2D = new GUIContent("2D, Texture is 2D.");
+            private readonly  GUIContent textureShapeCube = new GUIContent("Cube", "Texture is a Cubemap.");
+            public readonly Dictionary<TextureImporterShape, GUIContent[]> textureShapeOptionsDictionnary = new Dictionary<TextureImporterShape, GUIContent[]>();
+            public readonly Dictionary<TextureImporterShape, int[]> textureShapeValuesDictionnary = new Dictionary<TextureImporterShape, int[]>();
+
+
+            public readonly GUIContent filterMode = new GUIContent("Filter Mode");
+            public readonly GUIContent[] filterModeOptions =
+            {
+                new GUIContent("Point (no filter)"),
+                new GUIContent("Bilinear"),
+                new GUIContent("Trilinear")
+            };
+
+            public readonly GUIContent textureFormat = new GUIContent("Format");
+
+            public readonly GUIContent defaultPlatform = new GUIContent("Default");
+            public readonly GUIContent mipmapFadeOutToggle = new GUIContent("Fadeout Mip Maps");
+            public readonly GUIContent mipmapFadeOut = new GUIContent("Fade Range");
+            public readonly GUIContent readWrite = new GUIContent("Read/Write Enabled", "Enable to be able to access the raw pixel data from code.");
+
+            public readonly GUIContent alphaSource = new GUIContent("Alpha Source", "How is the alpha generated for the imported texture.");
+            public readonly GUIContent[] alphaSourceOptions =
+            {
+                new GUIContent("None", "No Alpha will be used."),
+                new GUIContent("Input Texture Alpha", "Use Alpha from the input texture if one is provided."),
+                new GUIContent("From Gray Scale", "Generate Alpha from image gray scale."),
+            };
+            public readonly int[] alphaSourceValues =
+            {
+                (int)TextureImporterAlphaSource.None,
+                (int)TextureImporterAlphaSource.FromInput,
+                (int)TextureImporterAlphaSource.FromGrayScale,
+            };
+
+            public readonly GUIContent generateMipMaps = new GUIContent("Generate Mip Maps");
+            public readonly GUIContent sRGBTexture = new GUIContent("sRGB (Color Texture)", "Texture content is stored in gamma space. Non-HDR color textures should enable this flag (except if used for IMGUI).");
+            public readonly GUIContent borderMipMaps = new GUIContent("Border Mip Maps");
+            public readonly GUIContent mipMapsPreserveCoverage = new GUIContent("Mip Maps Preserve Coverage", "The alpha channel of generated Mip Maps will preserve coverage during the alpha test.");
+            public readonly GUIContent alphaTestReferenceValue = new GUIContent("Alpha Cutoff Value", "The reference value used during the alpha test. Controls Mip Map coverage.");
+            public readonly GUIContent mipMapFilter = new GUIContent("Mip Map Filtering");
+            public readonly GUIContent[] mipMapFilterOptions =
+            {
+                new GUIContent("Box"),
+                new GUIContent("Kaiser"),
+            };
+            public readonly GUIContent npot = new GUIContent("Non Power of 2", "How non-power-of-two textures are scaled on import.");
+
+            public readonly GUIContent compressionQuality = new GUIContent("Compressor Quality");
+            public readonly GUIContent compressionQualitySlider = new GUIContent("Compressor Quality", "Use the slider to adjust compression quality from 0 (Fastest) to 100 (Best)");
+            public readonly GUIContent[] mobileCompressionQualityOptions =
+            {
+                new GUIContent("Fast"),
+                new GUIContent("Normal"),
+                new GUIContent("Best")
+            };
+
+            public readonly GUIContent spriteMode = new GUIContent("Sprite Mode");
+            public readonly GUIContent[] spriteModeOptions =
+            {
+                new GUIContent("Single"),
+                new GUIContent("Multiple"),
+                new GUIContent("Polygon"),
+            };
+            public readonly GUIContent[] spriteMeshTypeOptions =
+            {
+                new GUIContent("Full Rect"),
+                new GUIContent("Tight"),
+            };
+
+            public readonly GUIContent spritePackingTag = new GUIContent("Packing Tag", "Tag for the Sprite Packing system.");
+            public readonly GUIContent spritePixelsPerUnit = new GUIContent("Pixels Per Unit", "How many pixels in the sprite correspond to one unit in the world.");
+            public readonly GUIContent spriteExtrude = new GUIContent("Extrude Edges", "How much empty area to leave around the sprite in the generated mesh.");
+            public readonly GUIContent spriteMeshType = new GUIContent("Mesh Type", "Type of sprite mesh to generate.");
+            public readonly GUIContent spriteAlignment = new GUIContent("Pivot", "Sprite pivot point in its local space. May be used for syncing animation frames of different sizes.");
+            public readonly GUIContent characterAlignment = new GUIContent("Pivot", "Character pivot point in its local space using normalized value i.e. 0 - 1");
+
+            public readonly GUIContent[] spriteAlignmentOptions =
+            {
+                new GUIContent("Center"),
+                new GUIContent("Top Left"),
+                new GUIContent("Top"),
+                new GUIContent("Top Right"),
+                new GUIContent("Left"),
+                new GUIContent("Right"),
+                new GUIContent("Bottom Left"),
+                new GUIContent("Bottom"),
+                new GUIContent("Bottom Right"),
+                new GUIContent("Custom"),
+            };
+
+            public readonly GUIContent warpNotSupportWarning = new GUIContent("Graphics device doesn't support Repeat wrap mode on NPOT textures. Falling back to Clamp.");
+            public readonly GUIContent anisoLevelLabel = new GUIContent("Aniso Level");
+            public readonly GUIContent anisotropicDisableInfo = new GUIContent("Anisotropic filtering is disabled for all textures in Quality Settings.");
+            public readonly GUIContent anisotropicForceEnableInfo = new GUIContent("Anisotropic filtering is enabled for all textures in Quality Settings.");
+            public readonly GUIContent unappliedSettingsDialogTitle = new GUIContent("Unapplied import settings");
+            public readonly GUIContent unappliedSettingsDialogContent = new GUIContent("Unapplied import settings for \'{0}\'.\nApply and continue to sprite editor or cancel.");
+            public readonly GUIContent applyButtonLabel = new GUIContent("Apply");
+            public readonly GUIContent revertButtonLabel = new GUIContent("Revert");
+            public readonly GUIContent spriteEditorButtonLabel = new GUIContent("Sprite Editor");
+            public readonly GUIContent resliceFromLayerWarning = new GUIContent("This will reinitialize and recreate all Sprites based on the file’s layer data. Existing Sprite metadata from previously generated Sprites are copied over.");
+            public readonly GUIContent alphaIsTransparency = new GUIContent("Alpha Is Transparency", "If the provided alpha channel is transparency, enable this to pre-filter the color to avoid texture filtering artifacts. This is not supported for HDR textures.");
+            public readonly GUIContent etc1Compression = new GUIContent("Compress using ETC1 (split alpha channel)|Alpha for this texture will be preserved by splitting the alpha channel to another texture, and both resulting textures will be compressed using ETC1.");
+            public readonly GUIContent crunchedCompression = new GUIContent("Use Crunch Compression", "Texture is crunch-compressed to save space on disk when applicable.");
+
+            public readonly GUIContent showAdvanced = new GUIContent("Advanced", "Show advanced settings.");
+
+            public readonly GUIContent platformSettingsLabel  = new GUIContent("Platform Setttings");
+
+            public readonly GUIContent[] platformSettingsSelection;
+
+            public readonly GUIContent wrapModeLabel = new GUIContent("Wrap Mode");
+            public readonly GUIContent wrapU = new GUIContent("U axis");
+            public readonly GUIContent wrapV = new GUIContent("V axis");
+            public readonly GUIContent wrapW = new GUIContent("W axis");
+
+
+            public readonly GUIContent[] wrapModeContents =
+            {
+                new GUIContent("Repeat"),
+                new GUIContent("Clamp"),
+                new GUIContent("Mirror"),
+                new GUIContent("Mirror Once"),
+                new GUIContent("Per-axis")
+            };
+            public readonly int[] wrapModeValues =
+            {
+                (int)TextureWrapMode.Repeat,
+                (int)TextureWrapMode.Clamp,
+                (int)TextureWrapMode.Mirror,
+                (int)TextureWrapMode.MirrorOnce,
+                -1
+            };
+
+            public readonly GUIContent importHiddenLayer = new GUIContent(L10n.Tr("Import Hidden"), L10n.Tr("Import hidden layers"));
+            public readonly GUIContent mosaicLayers = new GUIContent(L10n.Tr("Mosaic"), L10n.Tr("Layers will be imported as individual Sprites"));
+            public readonly GUIContent characterMode = new GUIContent(L10n.Tr("Character Rig"), L10n.Tr("Enable to support 2D Animation character rigging"));
+            public readonly GUIContent generateGOHierarchy = new GUIContent(L10n.Tr("Use Layer Grouping"), L10n.Tr("GameObjects are grouped according to source file layer grouping"));
+            public readonly GUIContent resliceFromLayer = new GUIContent(L10n.Tr("Reslice"), L10n.Tr("Recreate Sprite rects from file"));
+            public readonly GUIContent paperDollMode = new GUIContent(L10n.Tr("Paper Doll Mode"), L10n.Tr("Special mode to generate a Prefab for Paper Doll use case"));
+            public readonly GUIContent experimental =  new GUIContent(L10n.Tr("Experimental"));
+            public readonly GUIContent keepDuplicateSpriteName = new GUIContent(L10n.Tr("Keep Duplicate Name"), L10n.Tr("Keep Sprite name same as Layer Name even if there are duplicated Layer Name"));
+
+            public Styles()
+            {
+                // This is far from ideal, but it's better than having tons of logic in the GUI code itself.
+                // The combination should not grow too much anyway since only Texture3D will be added later.
+                GUIContent[] s2D_Options = { textureShape2D };
+                GUIContent[] sCube_Options = { textureShapeCube };
+                GUIContent[] s2D_Cube_Options = { textureShape2D, textureShapeCube };
+                textureShapeOptionsDictionnary.Add(TextureImporterShape.Texture2D, s2D_Options);
+                textureShapeOptionsDictionnary.Add(TextureImporterShape.TextureCube, sCube_Options);
+                textureShapeOptionsDictionnary.Add(TextureImporterShape.Texture2D | TextureImporterShape.TextureCube, s2D_Cube_Options);
+
+                int[] s2D_Values = { (int)TextureImporterShape.Texture2D };
+                int[] sCube_Values = { (int)TextureImporterShape.TextureCube };
+                int[] s2D_Cube_Values = { (int)TextureImporterShape.Texture2D, (int)TextureImporterShape.TextureCube };
+                textureShapeValuesDictionnary.Add(TextureImporterShape.Texture2D, s2D_Values);
+                textureShapeValuesDictionnary.Add(TextureImporterShape.TextureCube, sCube_Values);
+                textureShapeValuesDictionnary.Add(TextureImporterShape.Texture2D | TextureImporterShape.TextureCube, s2D_Cube_Values);
+
+                platformSettingsSelection = new GUIContent[TexturePlatformSettingsModal.kValidBuildPlatform.Length];
+                for (int i = 0; i < TexturePlatformSettingsModal.kValidBuildPlatform.Length; ++i)
+                {
+                    platformSettingsSelection[i] = new GUIContent(TexturePlatformSettingsModal.kValidBuildPlatform[i].buildTargetName);
+                }
+            }
+        }
+
+        internal static Styles s_Styles;
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.psdimporter@4.0.2/Editor/PSDImporterEditor.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 18bf2b24e4cf52b4db1d73f71d4bd76b
+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.2d.spriteshape@5.1.1/Editor/Handles/Shaders/Sprites-Inspector.shader

@@ -0,0 +1,83 @@
+// Texture is forced to be in Gamma space regardless of the active ColorSpace.
+Shader "Hidden/InternalSpritesInspector"
+{
+    Properties
+    {
+        [PerRendererData] _MainTex("Sprite Texture", 2D) = "white" {}
+        _Color("Tint", Color) = (1, 1, 1, 1)
+        [MaterialToggle] PixelSnap("Pixel snap", Float) = 0
+    }
+
+    SubShader
+    {
+        Tags
+        {
+            "Queue" = "Transparent"
+            "IgnoreProjector" = "True"
+            "RenderType" = "Transparent"
+            "PreviewType" = "Plane"
+            "CanUseSpriteAtlas" = "True"
+        }
+
+        Cull Off
+        Lighting Off
+        ZWrite Off
+        Fog{ Mode Off }
+        Blend SrcAlpha OneMinusSrcAlpha
+
+        Pass
+        {
+
+            CGPROGRAM
+            #pragma vertex vert
+            #pragma fragment frag
+            #pragma multi_compile DUMMY PIXELSNAP_ON
+            #include "UnityCG.cginc"
+
+            uniform bool _AdjustLinearForGamma;
+
+            struct appdata_t
+            {
+                float4 vertex   : POSITION;
+                float4 color    : COLOR;
+                float2 texcoord : TEXCOORD0;
+            };
+
+            struct v2f
+            {
+                float4 vertex   : SV_POSITION;
+                fixed4 color : COLOR;
+                half2 texcoord  : TEXCOORD0;
+                float2 clipUV : TEXCOORD1;
+            };
+
+            fixed4 _Color;
+            uniform float4x4 unity_GUIClipTextureMatrix;
+
+            v2f vert(appdata_t IN)
+            {
+                float3 screenUV = UnityObjectToViewPos(IN.vertex);
+                v2f OUT;
+                OUT.vertex = UnityObjectToClipPos(IN.vertex);
+                OUT.texcoord = IN.texcoord;
+                OUT.color = IN.color * _Color;
+                OUT.clipUV = mul(unity_GUIClipTextureMatrix, float4(screenUV.xy, 0, 1.0));
+                return OUT;
+            }
+
+            sampler2D _MainTex;
+            sampler2D _GUIClipTexture;
+
+            fixed4 frag(v2f IN) : COLOR
+            {
+                fixed4 col = tex2D(_MainTex, IN.texcoord);
+                fixed alpha = col.a;
+                if (_AdjustLinearForGamma)
+                    col.rgb = LinearToGammaSpace(col.rgb);
+                col.a = alpha * tex2D(_GUIClipTexture, IN.clipUV).a;
+                return col * IN.color;
+            }
+            ENDCG
+        }
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.spriteshape@5.1.1/Editor/ObjectMenuCreation/DefaultAssets/Textures/Sprite Shape Corner.png.meta

@@ -0,0 +1,130 @@
+fileFormatVersion: 2
+guid: 608e61deb05c54660bebf5a4dd2ee02d
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 11
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: -1
+    mipBias: -100
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 0
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 256
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: iPhone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.spriteshape@5.1.1/Editor/ObjectMenuCreation/DefaultAssets/Textures/Sprite Shape Fill.png.meta

@@ -0,0 +1,130 @@
+fileFormatVersion: 2
+guid: b281b91a70a624a0da1c43adc1c30c7b
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 11
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: -1
+    mipBias: -100
+    wrapU: 0
+    wrapV: 0
+    wrapW: 0
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 0
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 256
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: iPhone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.spriteshape@5.1.1/Runtime/External/LibTessDotNet.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 9214d94ab547c5447a11c7a7c6a59482
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.spriteshape@5.1.1/Runtime/External/LibTessDotNet/Dict.cs

@@ -0,0 +1,107 @@
+/*
+** SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008) 
+** Copyright (C) 2011 Silicon Graphics, Inc.
+** All Rights Reserved.
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+** of the Software, and to permit persons to whom the Software is furnished to do so,
+** subject to the following conditions:
+** 
+** The above copyright notice including the dates of first publication and either this
+** permission notice or a reference to http://oss.sgi.com/projects/FreeB/ shall be
+** included in all copies or substantial portions of the Software. 
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+** INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+** PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL SILICON GRAPHICS, INC.
+** BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
+** OR OTHER DEALINGS IN THE SOFTWARE.
+** 
+** Except as contained in this notice, the name of Silicon Graphics, Inc. shall not
+** be used in advertising or otherwise to promote the sale, use or other dealings in
+** this Software without prior written authorization from Silicon Graphics, Inc.
+*/
+/*
+** Original Author: Eric Veach, July 1994.
+** libtess2: Mikko Mononen, http://code.google.com/p/libtess2/.
+** LibTessDotNet: Remi Gillig, https://github.com/speps/LibTessDotNet
+*/
+
+namespace Unity.SpriteShape.External
+{
+
+namespace LibTessDotNet
+{
+    internal class Dict<TValue> where TValue : class
+    {
+        public class Node
+        {
+            internal TValue _key;
+            internal Node _prev, _next;
+
+            public TValue Key { get { return _key; } }
+            public Node Prev { get { return _prev; } }
+            public Node Next { get { return _next; } }
+        }
+
+        public delegate bool LessOrEqual(TValue lhs, TValue rhs);
+
+        private LessOrEqual _leq;
+        Node _head;
+
+        public Dict(LessOrEqual leq)
+        {
+            _leq = leq;
+
+            _head = new Node { _key = null };
+            _head._prev = _head;
+            _head._next = _head;
+        }
+
+        public Node Insert(TValue key)
+        {
+            return InsertBefore(_head, key);
+        }
+
+        public Node InsertBefore(Node node, TValue key)
+        {
+            do {
+                node = node._prev;
+            } while (node._key != null && !_leq(node._key, key));
+
+            var newNode = new Node { _key = key };
+            newNode._next = node._next;
+            node._next._prev = newNode;
+            newNode._prev = node;
+            node._next = newNode;
+
+            return newNode;
+        }
+
+        public Node Find(TValue key)
+        {
+            var node = _head;
+            do {
+                node = node._next;
+            } while (node._key != null && !_leq(key, node._key));
+            return node;
+        }
+
+        public Node Min()
+        {
+            return _head._next;
+        }
+
+        public void Remove(Node node)
+        {
+            node._next._prev = node._prev;
+            node._prev._next = node._next;
+        }
+    }
+}
+
+} // namespace Unity.VectorGraphics.External

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.spriteshape@5.1.1/Runtime/External/LibTessDotNet/Dict.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d1f51a5b71c3ce943b689d3664e4d5fd
+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.2d.spriteshape@5.1.1/Runtime/External/LibTessDotNet/Geom.cs

@@ -0,0 +1,301 @@
+/*
+** SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008) 
+** Copyright (C) 2011 Silicon Graphics, Inc.
+** All Rights Reserved.
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+** of the Software, and to permit persons to whom the Software is furnished to do so,
+** subject to the following conditions:
+** 
+** The above copyright notice including the dates of first publication and either this
+** permission notice or a reference to http://oss.sgi.com/projects/FreeB/ shall be
+** included in all copies or substantial portions of the Software. 
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+** INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+** PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL SILICON GRAPHICS, INC.
+** BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
+** OR OTHER DEALINGS IN THE SOFTWARE.
+** 
+** Except as contained in this notice, the name of Silicon Graphics, Inc. shall not
+** be used in advertising or otherwise to promote the sale, use or other dealings in
+** this Software without prior written authorization from Silicon Graphics, Inc.
+*/
+/*
+** Original Author: Eric Veach, July 1994.
+** libtess2: Mikko Mononen, http://code.google.com/p/libtess2/.
+** LibTessDotNet: Remi Gillig, https://github.com/speps/LibTessDotNet
+*/
+
+using System;
+using System.Diagnostics;
+
+namespace Unity.SpriteShape.External
+{
+
+using Real = System.Single;
+namespace LibTessDotNet
+{
+    internal static class Geom
+    {
+        public static bool IsWindingInside(WindingRule rule, int n)
+        {
+            switch (rule)
+            {
+                case WindingRule.EvenOdd:
+                    return (n & 1) == 1;
+                case WindingRule.NonZero:
+                    return n != 0;
+                case WindingRule.Positive:
+                    return n > 0;
+                case WindingRule.Negative:
+                    return n < 0;
+                case WindingRule.AbsGeqTwo:
+                    return n >= 2 || n <= -2;
+            }
+            throw new Exception("Wrong winding rule");
+        }
+
+        public static bool VertCCW(MeshUtils.Vertex u, MeshUtils.Vertex v, MeshUtils.Vertex w)
+        {
+            return (u._s * (v._t - w._t) + v._s * (w._t - u._t) + w._s * (u._t - v._t)) >= 0.0f;
+        }
+        public static bool VertEq(MeshUtils.Vertex lhs, MeshUtils.Vertex rhs)
+        {
+            return lhs._s == rhs._s && lhs._t == rhs._t;
+        }
+        public static bool VertLeq(MeshUtils.Vertex lhs, MeshUtils.Vertex rhs)
+        {
+            return (lhs._s < rhs._s) || (lhs._s == rhs._s && lhs._t <= rhs._t);
+        }
+
+        /// <summary>
+        /// Given three vertices u,v,w such that VertLeq(u,v) && VertLeq(v,w),
+        /// evaluates the t-coord of the edge uw at the s-coord of the vertex v.
+        /// Returns v->t - (uw)(v->s), ie. the signed distance from uw to v.
+        /// If uw is vertical (and thus passes thru v), the result is zero.
+        /// 
+        /// The calculation is extremely accurate and stable, even when v
+        /// is very close to u or w.  In particular if we set v->t = 0 and
+        /// let r be the negated result (this evaluates (uw)(v->s)), then
+        /// r is guaranteed to satisfy MIN(u->t,w->t) <= r <= MAX(u->t,w->t).
+        /// </summary>
+        public static Real EdgeEval(MeshUtils.Vertex u, MeshUtils.Vertex v, MeshUtils.Vertex w)
+        {
+            Debug.Assert(VertLeq(u, v) && VertLeq(v, w));
+
+            var gapL = v._s - u._s;
+            var gapR = w._s - v._s;
+
+            if (gapL + gapR > 0.0f)
+            {
+                if (gapL < gapR)
+                {
+                    return (v._t - u._t) + (u._t - w._t) * (gapL / (gapL + gapR));
+                }
+                else
+                {
+                    return (v._t - w._t) + (w._t - u._t) * (gapR / (gapL + gapR));
+                }
+            }
+            /* vertical line */
+            return 0;
+        }
+
+        /// <summary>
+        /// Returns a number whose sign matches EdgeEval(u,v,w) but which
+        /// is cheaper to evaluate. Returns > 0, == 0 , or < 0
+        /// as v is above, on, or below the edge uw.
+        /// </summary>
+        public static Real EdgeSign(MeshUtils.Vertex u, MeshUtils.Vertex v, MeshUtils.Vertex w)
+        {
+            Debug.Assert(VertLeq(u, v) && VertLeq(v, w));
+
+            var gapL = v._s - u._s;
+            var gapR = w._s - v._s;
+
+            if (gapL + gapR > 0.0f)
+            {
+                return (v._t - w._t) * gapL + (v._t - u._t) * gapR;
+            }
+            /* vertical line */
+            return 0;
+        }
+
+        public static bool TransLeq(MeshUtils.Vertex lhs, MeshUtils.Vertex rhs)
+        {
+            return (lhs._t < rhs._t) || (lhs._t == rhs._t && lhs._s <= rhs._s);
+        }
+
+        public static Real TransEval(MeshUtils.Vertex u, MeshUtils.Vertex v, MeshUtils.Vertex w)
+        {
+            Debug.Assert(TransLeq(u, v) && TransLeq(v, w));
+
+            var gapL = v._t - u._t;
+            var gapR = w._t - v._t;
+
+            if (gapL + gapR > 0.0f)
+            {
+                if (gapL < gapR)
+                {
+                    return (v._s - u._s) + (u._s - w._s) * (gapL / (gapL + gapR));
+                }
+                else
+                {
+                    return (v._s - w._s) + (w._s - u._s) * (gapR / (gapL + gapR));
+                }
+            }
+            /* vertical line */
+            return 0;
+        }
+
+        public static Real TransSign(MeshUtils.Vertex u, MeshUtils.Vertex v, MeshUtils.Vertex w)
+        {
+            Debug.Assert(TransLeq(u, v) && TransLeq(v, w));
+
+            var gapL = v._t - u._t;
+            var gapR = w._t - v._t;
+
+            if (gapL + gapR > 0.0f)
+            {
+                return (v._s - w._s) * gapL + (v._s - u._s) * gapR;
+            }
+            /* vertical line */
+            return 0;
+        }
+
+        public static bool EdgeGoesLeft(MeshUtils.Edge e)
+        {
+            return VertLeq(e._Dst, e._Org);
+        }
+
+        public static bool EdgeGoesRight(MeshUtils.Edge e)
+        {
+            return VertLeq(e._Org, e._Dst);
+        }
+
+        public static Real VertL1dist(MeshUtils.Vertex u, MeshUtils.Vertex v)
+        {
+            return Math.Abs(u._s - v._s) + Math.Abs(u._t - v._t);
+        }
+
+        public static void AddWinding(MeshUtils.Edge eDst, MeshUtils.Edge eSrc)
+        {
+            eDst._winding += eSrc._winding;
+            eDst._Sym._winding += eSrc._Sym._winding;
+        }
+
+        public static Real Interpolate(Real a, Real x, Real b, Real y)
+        {
+            if (a < 0.0f)
+            {
+                a = 0.0f;
+            }
+            if (b < 0.0f)
+            {
+                b = 0.0f;
+            }
+            return ((a <= b) ? ((b == 0.0f) ? ((x+y) / 2.0f)
+                    : (x + (y-x) * (a/(a+b))))
+                    : (y + (x-y) * (b/(a+b))));
+        }
+
+        static void Swap(ref MeshUtils.Vertex a, ref MeshUtils.Vertex b)
+        {
+            var tmp = a;
+            a = b;
+            b = tmp;
+        }
+
+        /// <summary>
+        /// Given edges (o1,d1) and (o2,d2), compute their point of intersection.
+        /// The computed point is guaranteed to lie in the intersection of the
+        /// bounding rectangles defined by each edge.
+        /// </summary>
+        public static void EdgeIntersect(MeshUtils.Vertex o1, MeshUtils.Vertex d1, MeshUtils.Vertex o2, MeshUtils.Vertex d2, MeshUtils.Vertex v)
+        {
+            // This is certainly not the most efficient way to find the intersection
+            // of two line segments, but it is very numerically stable.
+            // 
+            // Strategy: find the two middle vertices in the VertLeq ordering,
+            // and interpolate the intersection s-value from these.  Then repeat
+            // using the TransLeq ordering to find the intersection t-value.
+
+            if (!VertLeq(o1, d1)) { Swap(ref o1, ref d1); }
+            if (!VertLeq(o2, d2)) { Swap(ref o2, ref d2); }
+            if (!VertLeq(o1, o2)) { Swap(ref o1, ref o2); Swap(ref d1, ref d2); }
+
+            if (!VertLeq(o2, d1))
+            {
+                // Technically, no intersection -- do our best
+                v._s = (o2._s + d1._s) / 2.0f;
+            }
+            else if (VertLeq(d1, d2))
+            {
+                // Interpolate between o2 and d1
+                var z1 = EdgeEval(o1, o2, d1);
+                var z2 = EdgeEval(o2, d1, d2);
+                if (z1 + z2 < 0.0f)
+                {
+                    z1 = -z1;
+                    z2 = -z2;
+                }
+                v._s = Interpolate(z1, o2._s, z2, d1._s);
+            }
+            else
+            {
+                // Interpolate between o2 and d2
+                var z1 = EdgeSign(o1, o2, d1);
+                var z2 = -EdgeSign(o1, d2, d1);
+                if (z1 + z2 < 0.0f)
+                {
+                    z1 = -z1;
+                    z2 = -z2;
+                }
+                v._s = Interpolate(z1, o2._s, z2, d2._s);
+            }
+
+            // Now repeat the process for t
+
+            if (!TransLeq(o1, d1)) { Swap(ref o1, ref d1); }
+            if (!TransLeq(o2, d2)) { Swap(ref o2, ref d2); }
+            if (!TransLeq(o1, o2)) { Swap(ref o1, ref o2); Swap(ref d1, ref d2); }
+
+            if (!TransLeq(o2, d1))
+            {
+                // Technically, no intersection -- do our best
+                v._t = (o2._t + d1._t) / 2.0f;
+            }
+            else if (TransLeq(d1, d2))
+            {
+                // Interpolate between o2 and d1
+                var z1 = TransEval(o1, o2, d1);
+                var z2 = TransEval(o2, d1, d2);
+                if (z1 + z2 < 0.0f)
+                {
+                    z1 = -z1;
+                    z2 = -z2;
+                }
+                v._t = Interpolate(z1, o2._t, z2, d1._t);
+            }
+            else
+            {
+                // Interpolate between o2 and d2
+                var z1 = TransSign(o1, o2, d1);
+                var z2 = -TransSign(o1, d2, d1);
+                if (z1 + z2 < 0.0f)
+                {
+                    z1 = -z1;
+                    z2 = -z2;
+                }
+                v._t = Interpolate(z1, o2._t, z2, d2._t);
+            }
+        }
+    }
+}
+
+} // namespace Unity.VectorGraphics.External

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.spriteshape@5.1.1/Runtime/External/LibTessDotNet/Geom.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8eb4e2609b653584b88dc0ee64a2ba24
+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.2d.spriteshape@5.1.1/Runtime/External/LibTessDotNet/LICENSE.txt

@@ -0,0 +1,25 @@
+** SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008) 
+** Copyright (C) 2011 Silicon Graphics, Inc.
+** All Rights Reserved.
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+** of the Software, and to permit persons to whom the Software is furnished to do so,
+** subject to the following conditions:
+** 
+** The above copyright notice including the dates of first publication and either this
+** permission notice or a reference to http://oss.sgi.com/projects/FreeB/ shall be
+** included in all copies or substantial portions of the Software. 
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+** INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+** PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL SILICON GRAPHICS, INC.
+** BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
+** OR OTHER DEALINGS IN THE SOFTWARE.
+** 
+** Except as contained in this notice, the name of Silicon Graphics, Inc. shall not
+** be used in advertising or otherwise to promote the sale, use or other dealings in
+** this Software without prior written authorization from Silicon Graphics, Inc.

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.spriteshape@5.1.1/Runtime/UTess2D/ArraySlice.cs

@@ -0,0 +1,165 @@
+using System;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+using Unity.Collections;
+using Unity.Collections.LowLevel.Unsafe;
+
+namespace UnityEngine.U2D
+{
+
+    namespace UTess
+    {
+
+        [StructLayout(LayoutKind.Sequential)]
+        [DebuggerDisplay("Length = {Length}")]
+        internal unsafe struct ArraySlice<T> : System.IEquatable<ArraySlice<T>> where T : struct
+        {
+            [NativeDisableUnsafePtrRestriction] internal byte* m_Buffer;
+            internal int m_Stride;
+            internal int m_Length;
+            
+#if ENABLE_UNITY_COLLECTIONS_CHECKS
+            internal int m_MinIndex;
+            internal int m_MaxIndex;
+            internal AtomicSafetyHandle m_Safety;
+#endif
+
+            public ArraySlice(NativeArray<T> array, int start, int length)
+            {
+#if ENABLE_UNITY_COLLECTIONS_CHECKS
+                if (start < 0)
+                    throw new ArgumentOutOfRangeException(nameof(start), $"Slice start {start} < 0.");
+                if (length < 0)
+                    throw new ArgumentOutOfRangeException(nameof(length), $"Slice length {length} < 0.");
+                if (start + length > array.Length)
+                    throw new ArgumentException(
+                        $"Slice start + length ({start + length}) range must be <= array.Length ({array.Length})");
+                m_MinIndex = 0;
+                m_MaxIndex = length - 1;
+                m_Safety = Unity.Collections.LowLevel.Unsafe.NativeArrayUnsafeUtility.GetAtomicSafetyHandle(array);
+#endif
+
+                m_Stride = UnsafeUtility.SizeOf<T>();
+                var ptr = (byte*) array.GetUnsafePtr() + m_Stride * start;
+                m_Buffer = ptr;
+                m_Length = length;
+            }
+
+            public bool Equals(ArraySlice<T> other)
+            {
+                return m_Buffer == other.m_Buffer && m_Stride == other.m_Stride && m_Length == other.m_Length;
+            }
+
+            public override bool Equals(object obj)
+            {
+                if (ReferenceEquals(null, obj)) return false;
+                return obj is ArraySlice<T> && Equals((ArraySlice<T>) obj);
+            }
+
+            public override int GetHashCode()
+            {
+                unchecked
+                {
+                    var hashCode = (int) m_Buffer;
+                    hashCode = (hashCode * 397) ^ m_Stride;
+                    hashCode = (hashCode * 397) ^ m_Length;
+                    return hashCode;
+                }
+            }
+
+            public static bool operator ==(ArraySlice<T> left, ArraySlice<T> right)
+            {
+                return left.Equals(right);
+            }
+
+            public static bool operator !=(ArraySlice<T> left, ArraySlice<T> right)
+            {
+                return !left.Equals(right);
+            }
+
+#if ENABLE_UNITY_COLLECTIONS_CHECKS
+            // These are double-whammy excluded to we can elide bounds checks in the Burst disassembly view
+            [Conditional("ENABLE_UNITY_COLLECTIONS_CHECKS")]
+            void CheckReadIndex(int index)
+            {
+#if ENABLE_UNITY_COLLECTIONS_CHECKS
+                if (index < m_MinIndex || index > m_MaxIndex)
+                    FailOutOfRangeError(index);
+#endif
+            }
+
+            [Conditional("ENABLE_UNITY_COLLECTIONS_CHECKS")]
+            void CheckWriteIndex(int index)
+            {
+#if ENABLE_UNITY_COLLECTIONS_CHECKS
+                if (index < m_MinIndex || index > m_MaxIndex)
+                    FailOutOfRangeError(index);
+#endif
+            }
+
+            [Conditional("ENABLE_UNITY_COLLECTIONS_CHECKS")]
+            private void FailOutOfRangeError(int index)
+            {
+                if (index < Length && (m_MinIndex != 0 || m_MaxIndex != Length - 1))
+                    throw new System.IndexOutOfRangeException(
+                        $"Index {index} is out of restricted IJobParallelFor range [{m_MinIndex}...{m_MaxIndex}] in ReadWriteBuffer.\n" +
+                        "ReadWriteBuffers are restricted to only read & write the element at the job index. " +
+                        "You can use double buffering strategies to avoid race conditions due to " +
+                        "reading & writing in parallel to the same elements from a job.");
+
+                throw new System.IndexOutOfRangeException($"Index {index} is out of range of '{Length}' Length.");
+            }
+
+#endif
+
+            public static unsafe ArraySlice<T> ConvertExistingDataToArraySlice(void* dataPointer, int stride, int length)
+            {
+                if (length < 0)
+                    throw new System.ArgumentException($"Invalid length of '{length}'. It must be greater than 0.",
+                        nameof(length));
+                if (stride < 0)
+                    throw new System.ArgumentException($"Invalid stride '{stride}'. It must be greater than 0.",
+                        nameof(stride));
+
+                var newSlice = new ArraySlice<T>
+                {
+                    m_Stride = stride,
+                    m_Buffer = (byte*) dataPointer,
+                    m_Length = length,
+#if ENABLE_UNITY_COLLECTIONS_CHECKS
+                    m_MinIndex = 0,
+                    m_MaxIndex = length - 1,
+#endif
+                };
+
+                return newSlice;
+            }
+
+            public T this[int index]
+            {
+                get
+                {
+#if ENABLE_UNITY_COLLECTIONS_CHECKS
+                    CheckReadIndex(index);
+#endif
+                    return UnsafeUtility.ReadArrayElementWithStride<T>(m_Buffer, index, m_Stride);
+                }
+
+                [WriteAccessRequired]
+                set
+                {
+#if ENABLE_UNITY_COLLECTIONS_CHECKS
+                    CheckWriteIndex(index);
+#endif
+                    UnsafeUtility.WriteArrayElementWithStride(m_Buffer, index, m_Stride, value);
+                }
+            }
+
+            public int Stride => m_Stride;
+            public int Length => m_Length;
+
+        }
+        
+    }
+
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.spriteshape@5.1.1/Runtime/UTess2D/ArraySlice.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 39b2d71389cf61842bdac5523826301a
+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.2d.spriteshape@5.1.1/Runtime/UTess2D/Tessellator.cs

@@ -0,0 +1,1117 @@
+using System;
+using System.Collections.Generic;
+using Unity.Collections;
+using Unity.Mathematics;
+using Unity.Collections.LowLevel.Unsafe;
+
+namespace UnityEngine.U2D
+{
+
+    namespace UTess
+    {
+
+        enum TessEventType
+        {
+            EVENT_POINT = 0,
+            EVENT_END = 1,
+            EVENT_START = 2,
+        };
+
+        struct TessEdge
+        {
+            public int a;
+            public int b;
+        };
+
+        struct TessEvent
+        {
+            public float2 a;
+            public float2 b;
+            public int idx;
+            public int type;
+        };
+
+        struct TessHull
+        {
+            public float2 a;
+            public float2 b;
+            public int idx;
+
+            public ArraySlice<int> ilarray;
+            public int ilcount;
+            public ArraySlice<int> iuarray;
+            public int iucount;
+        };
+
+        struct TessCell
+        {
+            public int a;
+            public int b;
+            public int c;
+        };
+
+        struct TessStar
+        {
+            public ArraySlice<int> points;
+            public int pointCount;
+        };
+
+        internal struct TessUtils
+        {
+
+            // From https://www.cs.cmu.edu/afs/cs/project/quake/public/code/predicates.c and is public domain. Can't find one within Unity.
+            public static float OrientFast(float2 a, float2 b, float2 c)
+            {
+                float epsilon = 1.1102230246251565e-16f;
+                float errbound3 = (3.0f + 16.0f * epsilon) * epsilon;
+                float l = (a.y - c.y) * (b.x - c.x);
+                float r = (a.x - c.x) * (b.y - c.y);
+                float det = l - r;
+                float s = 0;
+                if (l > 0)
+                {
+                    if (r <= 0)
+                    {
+                        return det;
+                    }
+                    else
+                    {
+                        s = l + r;
+                    }
+                }
+                else if (l < 0)
+                {
+                    if (r >= 0)
+                    {
+                        return det;
+                    }
+                    else
+                    {
+                        s = -(l + r);
+                    }
+                }
+                else
+                {
+                    return det;
+                }
+
+                float tol = errbound3 * s;
+                if (det >= tol || det <= -tol)
+                {
+                    return det;
+                }
+
+                return epsilon;
+            }
+
+            public static float Norm(float2 cV)
+            {
+                return cV.x * cV.x + cV.y * cV.y;
+            }
+
+            public static float Dist(float2 cV1, float2 cV2)
+            {
+                return (cV1.x - cV2.x) * (cV1.x - cV2.x) + (cV1.y - cV2.y) * (cV1.y - cV2.y);
+            }            
+            public static bool IsInsideCircle(float2 a, float2 b, float2 c, float2 p)
+            {
+                float ab = Norm(a);
+                float cd = Norm(b);
+                float ef = Norm(c);
+
+                float ax = a.x;
+                float ay = a.y;
+                float bx = b.x;
+                float by = b.y;
+                float cx = c.x;
+                float cy = c.y;
+
+                float circum_x = (ab * (cy - by) + cd * (ay - cy) + ef * (by - ay)) /
+                                 (ax * (cy - by) + bx * (ay - cy) + cx * (by - ay));
+                float circum_y = (ab * (cx - bx) + cd * (ax - cx) + ef * (bx - ax)) /
+                                 (ay * (cx - bx) + by * (ax - cx) + cy * (bx - ax));
+
+                float2 circum = new float2();
+                circum.x = circum_x / 2;
+                circum.y = circum_y / 2;
+                float circum_radius = Dist(a, circum);
+                float dist = Dist(p, circum);
+                return circum_radius - dist > 0.00001f;
+            }
+
+            public unsafe static void InsertionSort<T, U>(void* array, int lo, int hi, U comp)
+                where T : struct where U : IComparer<T>
+            {
+                int i, j;
+                T t;
+                for (i = lo; i < hi; i++)
+                {
+                    j = i;
+                    t = UnsafeUtility.ReadArrayElement<T>(array, i + 1);
+                    while (j >= lo && comp.Compare(t, UnsafeUtility.ReadArrayElement<T>(array, j)) < 0)
+                    {
+                        UnsafeUtility.WriteArrayElement<T>(array, j + 1, UnsafeUtility.ReadArrayElement<T>(array, j));
+                        j--;
+                    }
+
+                    UnsafeUtility.WriteArrayElement<T>(array, j + 1, t);
+                }
+            }
+
+        }
+
+        struct TessEventCompare : IComparer<TessEvent>
+        {
+            public int Compare(TessEvent a, TessEvent b)
+            {
+                float f = (a.a.x - b.a.x);
+                if (0 != f)
+                    return (f > 0) ? 1 : -1;
+
+                f = (a.a.y - b.a.y);
+                if (0 != f)
+                    return (f > 0) ? 1 : -1;
+
+                int i = a.type - b.type;
+                if (0 != i)
+                    return i;
+
+                if (a.type != (int) TessEventType.EVENT_POINT)
+                {
+                    float o = TessUtils.OrientFast(a.a, a.b, b.b);
+                    if (0 != o)
+                    {
+                        return (o > 0) ? 1 : -1;
+                    }
+                }
+
+                return a.idx - b.idx;
+            }
+        }
+
+        struct TessEdgeCompare : IComparer<TessEdge>
+        {
+            public int Compare(TessEdge a, TessEdge b)
+            {
+                int i = a.a - b.a;
+                if (0 != i)
+                    return i;
+                i = a.b - b.b;
+                return i;
+            }
+        }
+
+        struct TessCellCompare : IComparer<TessCell>
+        {
+            public int Compare(TessCell a, TessCell b)
+            {
+                int i = a.a - b.a;
+                if (0 != i)
+                    return i;
+                i = a.b - b.b;
+                if (0 != i)
+                    return i;
+                i = a.c - b.c;
+                return i;
+            }
+        }
+
+        internal struct Tessellator
+        {
+            // For Processing.
+            NativeArray<TessEdge> m_Edges;
+            NativeArray<TessStar> m_Stars;
+            NativeArray<TessCell> m_Cells;
+            int m_CellCount;
+
+            // For Storage.
+            NativeArray<int> m_ILArray;
+            NativeArray<int> m_IUArray;
+            NativeArray<int> m_SPArray;
+            int m_NumPoints;
+            int m_StarCount;            
+
+            // Intermediates.
+            NativeArray<int> m_Flags;
+            NativeArray<int> m_Neighbors;
+            NativeArray<int> m_Constraints;
+
+            static float TestPoint(TessHull hull, float2 point)
+            {
+                return TessUtils.OrientFast(hull.a, hull.b, point);
+            }
+
+            static int GetLowerHullForVector(NativeArray<TessHull> hulls, int hullCount, float2 p)
+            {
+                int i;
+                int l = 0;
+                int h = hullCount - 1;
+                i = l - 1;
+                while (l <= h)
+                {
+                    int m;
+                    m = ((int) (l + h)) >> 1;
+                    if (TestPoint(hulls[m], p) < 0)
+                    {
+                        i = m;
+                        l = m + 1;
+                    }
+                    else
+                        h = m - 1;
+                }
+
+                return i;
+            }
+
+            static int GetUpperHullForVector(NativeArray<TessHull> hulls, int hullCount, float2 p)
+            {
+                int i;
+                int l = 0;
+                int h = hullCount - 1;
+                i = h + 1;
+                while (l <= h)
+                {
+                    int m;
+                    m = ((int) (l + h)) >> 1;
+                    if (TestPoint(hulls[m], p) > 0)
+                    {
+                        i = m;
+                        h = m - 1;
+                    }
+                    else
+                        l = m + 1;
+                }
+
+                return i;
+            }
+
+            static float FindSplit(TessHull hull, TessEvent edge)
+            {
+                float d = 0;
+                if (hull.a.x < edge.a.x)
+                {
+                    d = TessUtils.OrientFast(hull.a, hull.b, edge.a);
+                }
+                else
+                {
+                    d = TessUtils.OrientFast(edge.b, edge.a, hull.a);
+                }
+
+                if (0 != d)
+                {
+                    return d;
+                }
+
+                if (edge.b.x < hull.b.x)
+                {
+                    d = TessUtils.OrientFast(hull.a, hull.b, edge.b);
+                }
+                else
+                {
+                    d = TessUtils.OrientFast(edge.b, edge.a, hull.b);
+                }
+
+                if (0 != d)
+                {
+                    return d;
+                }
+
+                return hull.idx - edge.idx;
+            }
+
+            static int GetLowerEqualHullForEvent(NativeArray<TessHull> hulls, int hullCount, TessEvent p)
+            {
+                int i;
+                int l = 0;
+                int h = hullCount - 1;
+                i = l - 1;
+                while (l <= h)
+                {
+                    int m;
+                    m = ((int) (l + h)) >> 1;
+                    if (FindSplit(hulls[m], p) <= 0)
+                    {
+                        i = m;
+                        l = m + 1;
+                    }
+                    else
+                        h = m - 1;
+                }
+
+                return i;
+            }
+
+            static int GetEqualHullForEvent(NativeArray<TessHull> hulls, int hullCount, TessEvent p)
+            {
+                int l = 0;
+                int h = hullCount - 1;
+                while (l <= h)
+                {
+                    int m;
+                    m = ((int) (l + h)) >> 1;
+                    float f = FindSplit(hulls[m], p);
+                    if (f == 0)
+                    {
+                        return m;
+                    }
+                    else if (f <= 0)
+                    {
+                        l = m + 1;
+                    }
+                    else
+                        h = m - 1;
+                }
+
+                return -1;
+            }
+
+            void AddPoint(NativeArray<TessHull> hulls, int hullCount, NativeArray<float2> points, float2 p,
+                int idx)
+            {
+                int l = GetLowerHullForVector(hulls, hullCount, p);
+                int u = GetUpperHullForVector(hulls, hullCount, p);
+                for (int i = l; i < u; ++i)
+                {
+                    TessHull hull = hulls[i];
+
+                    int m = hull.ilcount;
+                    while (m > 1 && TessUtils.OrientFast(points[hull.ilarray[m - 2]], points[hull.ilarray[m - 1]], p) >
+                        0)
+                    {
+                        TessCell c = new TessCell();
+                        c.a = hull.ilarray[m - 1];
+                        c.b = hull.ilarray[m - 2];
+                        c.c = idx;
+                        m_Cells[m_CellCount++] = c;
+                        m -= 1;
+                    }
+
+                    hull.ilcount = m + 1;
+                    hull.ilarray[m] = idx;
+
+                    m = hull.iucount;
+                    while (m > 1 && TessUtils.OrientFast(points[hull.iuarray[m - 2]], points[hull.iuarray[m - 1]], p) <
+                        0)
+                    {
+                        TessCell c = new TessCell();
+                        c.a = hull.iuarray[m - 2];
+                        c.b = hull.iuarray[m - 1];
+                        c.c = idx;
+                        m_Cells[m_CellCount++] = c;
+                        m -= 1;
+                    }
+
+                    hull.iucount = m + 1;
+                    hull.iuarray[m] = idx;
+
+                    hulls[i] = hull;
+                }
+            }
+
+            static void InsertHull(NativeArray<TessHull> Hulls, int Pos, ref int Count, TessHull Value)
+            {
+                if (Count < Hulls.Length - 1)
+                {
+                    for (int i = Count; i > Pos; --i)
+                        Hulls[i] = Hulls[i - 1];
+                    Hulls[Pos] = Value;
+                    Count++;
+                }
+            }
+
+            static void EraseHull(NativeArray<TessHull> Hulls, int Pos, ref int Count)
+            {
+                if (Count < Hulls.Length)
+                {
+                    for (int i = Pos; i < Count - 1; ++i)
+                        Hulls[i] = Hulls[i + 1];
+                    Count--;
+                }
+            }
+
+            void SplitHulls(NativeArray<TessHull> hulls, ref int hullCount, NativeArray<float2> points,
+                TessEvent evt)
+            {
+                int index = GetLowerEqualHullForEvent(hulls, hullCount, evt);
+                TessHull hull = hulls[index];
+
+                TessHull newHull;
+                newHull.a = evt.a;
+                newHull.b = evt.b;
+                newHull.idx = evt.idx;
+
+                int y = hull.iuarray[hull.iucount - 1];
+                newHull.iuarray = new ArraySlice<int>(m_IUArray, newHull.idx * m_NumPoints, m_NumPoints);
+                newHull.iucount = hull.iucount;
+                for (int i = 0; i < newHull.iucount; ++i)
+                    newHull.iuarray[i] = hull.iuarray[i];
+                hull.iuarray[0] = y;
+                hull.iucount = 1;
+                hulls[index] = hull;
+
+                newHull.ilarray = new ArraySlice<int>(m_ILArray, newHull.idx * m_NumPoints, m_NumPoints);
+                newHull.ilarray[0] = y;
+                newHull.ilcount = 1;
+
+                InsertHull(hulls, index + 1, ref hullCount, newHull);
+            }
+
+            void MergeHulls(NativeArray<TessHull> hulls, ref int hullCount, NativeArray<float2> points,
+                TessEvent evt)
+            {
+                float2 temp = evt.a;
+                evt.a = evt.b;
+                evt.b = temp;
+                int index = GetEqualHullForEvent(hulls, hullCount, evt);
+
+                TessHull upper = hulls[index];
+                TessHull lower = hulls[index - 1];
+
+                lower.iucount = upper.iucount;
+                for (int i = 0; i < lower.iucount; ++i)
+                    lower.iuarray[i] = upper.iuarray[i];
+
+                hulls[index - 1] = lower;
+                EraseHull(hulls, index, ref hullCount);
+            }
+
+            internal void Triangulate(NativeArray<float2> points, NativeArray<TessEdge> edgesIn)
+            {
+                int numEdges = edgesIn.Length;
+                const int kStarEdges = 16;
+
+                m_NumPoints = points.Length;
+                m_StarCount = m_NumPoints > kStarEdges ? m_NumPoints : kStarEdges;
+                m_StarCount = m_StarCount * 2;
+                m_CellCount = 0;
+                m_Cells = new NativeArray<TessCell>(m_NumPoints * (m_NumPoints + 1), Allocator.Temp);
+                m_ILArray = new NativeArray<int>(m_NumPoints * (m_NumPoints + 1), Allocator.Temp); // Make room for -1 node.
+                m_IUArray = new NativeArray<int>(m_NumPoints * (m_NumPoints + 1), Allocator.Temp); // Make room for -1 node.
+                m_SPArray = new NativeArray<int>(m_NumPoints * (m_StarCount), Allocator.Temp); // Make room for -1 node.
+
+                NativeArray<TessHull> hulls = new NativeArray<TessHull>(m_NumPoints * 8, Allocator.Temp);
+                int hullCount = 0;
+
+                NativeArray<TessEvent> events = new NativeArray<TessEvent>(m_NumPoints + (numEdges * 2), Allocator.Temp);
+                int eventCount = 0;
+
+                for (int i = 0; i < m_NumPoints; ++i)
+                {
+                    TessEvent evt = new TessEvent();
+                    evt.a = points[i];
+                    evt.b = new float2();
+                    evt.idx = i;
+                    evt.type = (int) TessEventType.EVENT_POINT;
+                    events[eventCount++] = evt;
+                }
+
+                for (int i = 0; i < numEdges; ++i)
+                {
+                    TessEdge e = edgesIn[i];
+                    float2 a = points[e.a];
+                    float2 b = points[e.b];
+                    if (a.x < b.x)
+                    {
+                        TessEvent _s = new TessEvent();
+                        _s.a = a;
+                        _s.b = b;
+                        _s.idx = i;
+                        _s.type = (int) TessEventType.EVENT_START;
+
+                        TessEvent _e = new TessEvent();
+                        _e.a = b;
+                        _e.b = a;
+                        _e.idx = i;
+                        _e.type = (int) TessEventType.EVENT_END;
+
+                        events[eventCount++] = _s;
+                        events[eventCount++] = _e;
+                    }
+                    else if (a.x > b.x)
+                    {
+                        TessEvent _s = new TessEvent();
+                        _s.a = b;
+                        _s.b = a;
+                        _s.idx = i;
+                        _s.type = (int) TessEventType.EVENT_START;
+
+                        TessEvent _e = new TessEvent();
+                        _e.a = a;
+                        _e.b = b;
+                        _e.idx = i;
+                        _e.type = (int) TessEventType.EVENT_END;
+
+                        events[eventCount++] = _s;
+                        events[eventCount++] = _e;
+                    }
+                }
+
+                unsafe
+                {
+                    TessUtils.InsertionSort<TessEvent, TessEventCompare>(
+                        NativeArrayUnsafeUtility.GetUnsafeBufferPointerWithoutChecks(events), 0, eventCount - 1,
+                        new TessEventCompare());
+                    ;
+                }
+
+                float minX = events[0].a.x - (1 + math.abs(events[0].a.x)) * math.pow(2.0f, -16.0f);
+                TessHull hull;
+                hull.a.x = minX;
+                hull.a.y = 1;
+                hull.b.x = minX;
+                hull.b.y = 0;
+                hull.idx = -1;
+                hull.ilarray = new ArraySlice<int>(m_ILArray, m_NumPoints * m_NumPoints, m_NumPoints); // Last element
+                hull.iuarray = new ArraySlice<int>(m_IUArray, m_NumPoints * m_NumPoints, m_NumPoints);
+                hull.ilcount = 0;
+                hull.iucount = 0;
+                hulls[hullCount++] = hull;
+
+                for (int i = 0, numEvents = eventCount; i < numEvents; ++i)
+                {
+                    switch (events[i].type)
+                    {
+                        case (int) TessEventType.EVENT_POINT:
+                        {
+                            AddPoint(hulls, hullCount, points, events[i].a, events[i].idx);
+                        }
+                            break;
+
+                        case (int) TessEventType.EVENT_START:
+                        {
+                            SplitHulls(hulls, ref hullCount, points, events[i]);
+                        }
+                            break;
+
+                        default:
+                        {
+                            MergeHulls(hulls, ref hullCount, points, events[i]);
+                        }
+                            break;
+                    }
+                }
+
+                hulls.Dispose();
+                events.Dispose();
+            }
+
+
+            void Prepare(NativeArray<TessEdge> edgesIn)
+            {
+                m_Stars = new NativeArray<TessStar>(edgesIn.Length, Allocator.Temp);
+
+                for (int i = 0; i < edgesIn.Length; ++i)
+                {
+                    TessEdge e = edgesIn[i];
+                    e.a = (edgesIn[i].a < edgesIn[i].b) ? edgesIn[i].a : edgesIn[i].b;
+                    e.b = (edgesIn[i].a > edgesIn[i].b) ? edgesIn[i].a : edgesIn[i].b;
+                    edgesIn[i] = e;
+                    TessStar s = m_Stars[i];
+                    s.points = new ArraySlice<int>(m_SPArray, i * m_StarCount, m_StarCount);
+                    s.pointCount = 0;
+                    m_Stars[i] = s;
+                }
+
+                unsafe
+                {
+                    TessUtils.InsertionSort<TessEdge, TessEdgeCompare>(
+                        NativeArrayUnsafeUtility.GetUnsafeBufferPointerWithoutChecks(edgesIn), 0, edgesIn.Length - 1,
+                        new TessEdgeCompare());
+                }
+
+                m_Edges = new NativeArray<TessEdge>(edgesIn.Length, Allocator.Temp);
+                m_Edges.CopyFrom(edgesIn);
+
+                // Fill stars.
+                for (int i = 0; i < m_CellCount; ++i)
+                {
+                    int a = m_Cells[i].a;
+                    int b = m_Cells[i].b;
+                    int c = m_Cells[i].c;
+                    TessStar sa = m_Stars[a];
+                    TessStar sb = m_Stars[b];
+                    TessStar sc = m_Stars[c];
+                    sa.points[sa.pointCount++] = b;
+                    sa.points[sa.pointCount++] = c;
+                    sb.points[sb.pointCount++] = c;
+                    sb.points[sb.pointCount++] = a;
+                    sc.points[sc.pointCount++] = a;
+                    sc.points[sc.pointCount++] = b;
+                    m_Stars[a] = sa;
+                    m_Stars[b] = sb;
+                    m_Stars[c] = sc;
+                }
+            }
+
+            int OppositeOf(int a, int b)
+            {
+                ArraySlice<int> points = m_Stars[b].points;
+                for (int k = 1, n = m_Stars[b].pointCount; k < n; k += 2)
+                {
+                    if (points[k] == a)
+                    {
+                        return points[k - 1];
+                    }
+                }
+
+                return -1;
+            }
+
+            static int GetEqualHullForEdges(NativeArray<TessEdge> edges, TessEdge p)
+            {
+                int l = 0;
+                int h = edges.Length - 1;
+                TessEdgeCompare tec = new TessEdgeCompare();
+                while (l <= h)
+                {
+                    int m;
+                    m = ((int) (l + h)) >> 1;
+                    int f = tec.Compare(edges[m], p);
+                    if (f == 0)
+                    {
+                        return m;
+                    }
+                    else if (f <= 0)
+                    {
+                        l = m + 1;
+                    }
+                    else
+                        h = m - 1;
+                }
+
+                return -1;
+            }
+
+            int FindConstraint(int a, int b)
+            {
+                TessEdge e;
+                e.a = a < b ? a : b;
+                e.b = a > b ? a : b;
+                return GetEqualHullForEdges(m_Edges, e);
+            }
+
+            void AddTriangle(int i, int j, int k)
+            {
+                TessStar si = m_Stars[i];
+                TessStar sj = m_Stars[j];
+                TessStar sk = m_Stars[k];
+                si.points[si.pointCount++] = j;
+                si.points[si.pointCount++] = k;
+                sj.points[sj.pointCount++] = k;
+                sj.points[sj.pointCount++] = i;
+                sk.points[sk.pointCount++] = i;
+                sk.points[sk.pointCount++] = j;
+                m_Stars[i] = si;
+                m_Stars[j] = sj;
+                m_Stars[k] = sk;
+            }
+
+            void RemovePair(int r, int j, int k)
+            {
+                TessStar s = m_Stars[r];
+                ArraySlice<int> points = s.points;
+                for (int i = 1, n = s.pointCount; i < n; i += 2)
+                {
+                    if (points[i - 1] == j && points[i] == k)
+                    {
+                        points[i - 1] = points[n - 2];
+                        points[i] = points[n - 1];
+                        s.points = points;
+                        s.pointCount = s.pointCount - 2;
+                        m_Stars[r] = s;
+                        return;
+                    }
+                }
+            }
+
+            void RemoveTriangle(int i, int j, int k)
+            {
+                RemovePair(i, j, k);
+                RemovePair(j, k, i);
+                RemovePair(k, i, j);
+            }
+
+            void EdgeFlip(int i, int j)
+            {
+                int a = OppositeOf(i, j);
+                int b = OppositeOf(j, i);
+                RemoveTriangle(i, j, a);
+                RemoveTriangle(j, i, b);
+                AddTriangle(i, b, a);
+                AddTriangle(j, a, b);
+            }
+
+            void Flip(NativeArray<float2> points, ref NativeArray<int> stack, ref int stackCount,
+                int a, int b, int x)
+            {
+                int y = OppositeOf(a, b);
+
+                if (y < 0)
+                {
+                    return;
+                }
+
+                if (b < a)
+                {
+                    int tmp = a;
+                    a = b;
+                    b = tmp;
+                    tmp = x;
+                    x = y;
+                    y = tmp;
+                }
+
+                if (FindConstraint(a, b) != -1)
+                {
+                    return;
+                }
+
+                if (TessUtils.IsInsideCircle(points[a], points[b], points[x], points[y]))
+                {
+                    stack[stackCount++] = a;
+                    stack[stackCount++] = b;
+                }
+            }
+
+            NativeArray<TessCell> GetCells(ref int count)
+            {
+                NativeArray<TessCell> cellsOut = new NativeArray<TessCell>(m_NumPoints * (m_NumPoints + 1), Allocator.Temp);
+                count = 0;
+                for (int i = 0, n = m_Stars.Length; i < n; ++i)
+                {
+                    ArraySlice<int> points = m_Stars[i].points;
+                    for (int j = 0, m = m_Stars[i].pointCount; j < m; j += 2)
+                    {
+                        int s = points[j];
+                        int t = points[j + 1];
+                        if (i < math.min(s, t))
+                        {
+                            TessCell c = new TessCell();
+                            c.a = i;
+                            c.b = s;
+                            c.c = t;
+                            cellsOut[count++] = c;
+                        }
+                    }
+                }
+
+                return cellsOut;
+            }
+
+            internal void ApplyDelaunay(NativeArray<float2> points, NativeArray<TessEdge> edgesIn)
+            {
+
+                NativeArray<int> stack = new NativeArray<int>(m_NumPoints * (m_NumPoints + 1), Allocator.Temp);
+                int stackCount = 0;
+
+                Prepare(edgesIn);
+                for (int a = 0; a < m_NumPoints; ++a)
+                {
+                    TessStar star = m_Stars[a];
+                    for (int j = 1; j < star.pointCount; j += 2)
+                    {
+                        int b = star.points[j];
+
+                        if (b < a)
+                        {
+                            continue;
+                        }
+
+                        if (FindConstraint(a, b) >= 0)
+                        {
+                            continue;
+                        }
+
+                        int x = star.points[j - 1], y = -1;
+                        for (int k = 1; k < star.pointCount; k += 2)
+                        {
+                            if (star.points[k - 1] == b)
+                            {
+                                y = star.points[k];
+                                break;
+                            }
+                        }
+
+                        if (y < 0)
+                        {
+                            continue;
+                        }
+
+                        if (TessUtils.IsInsideCircle(points[a], points[b], points[x], points[y]))
+                        {
+                            stack[stackCount++] = a;
+                            stack[stackCount++] = b;
+                        }
+                    }
+                }
+
+                while (stackCount > 0)
+                {
+                    int b = stack[stackCount - 1];
+                    stackCount--;
+                    int a = stack[stackCount - 1];
+                    stackCount--;
+
+                    int x = -1, y = -1;
+                    TessStar star = m_Stars[a];
+                    for (int i = 1; i < star.pointCount; i += 2)
+                    {
+                        int s = star.points[i - 1];
+                        int t = star.points[i];
+                        if (s == b)
+                        {
+                            y = t;
+                        }
+                        else if (t == b)
+                        {
+                            x = s;
+                        }
+                    }
+
+                    if (x < 0 || y < 0)
+                    {
+                        continue;
+                    }
+
+                    if (!TessUtils.IsInsideCircle(points[a], points[b], points[x], points[y]))
+                    {
+                        continue;
+                    }
+
+                    EdgeFlip(a, b);
+
+                    Flip(points, ref stack, ref stackCount, x, a, y);
+                    Flip(points, ref stack, ref stackCount, a, y, x);
+                    Flip(points, ref stack, ref stackCount, y, b, x);
+                    Flip(points, ref stack, ref stackCount, b, x, y);
+                }
+
+                stack.Dispose();
+            }
+
+            int GetEqualCellForCells(NativeArray<TessCell> cells, int count, TessCell p)
+            {
+                int l = 0;
+                int h = count - 1;
+                TessCellCompare tcc = new TessCellCompare();
+                while (l <= h)
+                {
+                    int m;
+                    m = ((int) (l + h)) >> 1;
+                    int f = tcc.Compare(cells[m], p);
+                    if (f == 0)
+                    {
+                        return m;
+                    }
+                    else if (f <= 0)
+                    {
+                        l = m + 1;
+                    }
+                    else
+                        h = m - 1;
+                }
+
+                return -1;
+            }
+
+            int FindNeighbor(NativeArray<TessCell> cells, int count, int a, int b, int c)
+            {
+                int x = a, y = b, z = c;
+                if (b < c)
+                {
+                    if (b < a)
+                    {
+                        x = b;
+                        y = c;
+                        z = a;
+                    }
+                }
+                else if (c < a)
+                {
+                    x = c;
+                    y = a;
+                    z = b;
+                }
+
+                if (x < 0)
+                {
+                    return -1;
+                }
+
+                TessCell key;
+                key.a = x;
+                key.b = y;
+                key.c = z;
+                return GetEqualCellForCells(cells, count, key);
+            }
+
+            NativeArray<TessCell> Constrain(ref int count)
+            {
+                var cells = GetCells(ref count);
+                int nc = count;
+                for (int i = 0; i < nc; ++i)
+                {
+                    TessCell c = cells[i];
+                    int x = c.a, y = c.b, z = c.c;
+                    if (y < z)
+                    {
+                        if (y < x)
+                        {
+                            c.a = y;
+                            c.b = z;
+                            c.c = x;
+                        }
+                    }
+                    else if (z < x)
+                    {
+                        c.a = z;
+                        c.b = x;
+                        c.c = y;
+                    }
+
+                    cells[i] = c;
+                }
+
+                unsafe
+                {
+                    TessUtils.InsertionSort<TessCell, TessCellCompare>(
+                        NativeArrayUnsafeUtility.GetUnsafeBufferPointerWithoutChecks(cells), 0, m_CellCount - 1,
+                        new TessCellCompare());
+                }
+
+                // Out
+                m_Flags = new NativeArray<int>(nc, Allocator.Temp);
+                m_Neighbors = new NativeArray<int>(nc * 3, Allocator.Temp);
+                m_Constraints = new NativeArray<int>(nc * 3, Allocator.Temp);
+                var next = new NativeArray<int>(nc * 3, Allocator.Temp);
+                var active = new NativeArray<int>(nc * 3, Allocator.Temp);
+
+                int side = 1, nextCount = 0, activeCount = 0;
+
+                for (int i = 0; i < nc; ++i)
+                {
+                    TessCell c = cells[i];
+                    for (int j = 0; j < 3; ++j)
+                    {
+                        int x = j, y = (j + 1) % 3;
+                        x = (x == 0) ? c.a : (j == 1) ? c.b : c.c;
+                        y = (y == 0) ? c.a : (y == 1) ? c.b : c.c;
+
+                        int o = OppositeOf(y, x);
+                        int a = m_Neighbors[3 * i + j] = FindNeighbor(cells, count, y, x, o);
+                        int b = m_Constraints[3 * i + j] = (-1 != FindConstraint(x, y)) ? 1 : 0;
+                        if (a < 0)
+                        {
+                            if (0 != b)
+                            {
+                                next[nextCount++] = i;
+                            }
+                            else
+                            {
+                                active[activeCount++] = i;
+                                m_Flags[i] = 1;
+                            }
+                        }
+                    }
+                }
+
+                while (activeCount > 0 || nextCount > 0)
+                {
+                    while (activeCount > 0)
+                    {
+                        int t = active[activeCount - 1];
+                        activeCount--;
+                        if (m_Flags[t] == -side)
+                        {
+                            continue;
+                        }
+
+                        m_Flags[t] = side;
+                        TessCell c = cells[t];
+                        for (int j = 0; j < 3; ++j)
+                        {
+                            int f = m_Neighbors[3 * t + j];
+                            if (f >= 0 && m_Flags[f] == 0)
+                            {
+                                if (0 != m_Constraints[3 * t + j])
+                                {
+                                    next[nextCount++] = f;
+                                }
+                                else
+                                {
+                                    active[activeCount++] = f;
+                                    m_Flags[f] = side;
+                                }
+                            }
+                        }
+                    }
+
+                    for (int e = 0; e < nextCount; e++)
+                        active[e] = next[e];
+                    activeCount = nextCount;
+                    nextCount = 0;
+                    side = -side;
+                }
+
+                active.Dispose();
+                next.Dispose();
+                return cells;
+            }
+
+            internal NativeArray<TessCell> RemoveExterior(ref int cellCount)
+            {
+                int constrainedCount = 0;
+                NativeArray<TessCell> constrained = Constrain(ref constrainedCount);
+
+                NativeArray<TessCell> cellsOut = new NativeArray<TessCell>(constrainedCount, Allocator.Temp);
+                cellCount = 0;
+                for (int i = 0; i < constrainedCount; ++i)
+                {
+                    if (m_Flags[i] == -1)
+                    {
+                        cellsOut[cellCount++] = constrained[i];
+                    }
+                }
+
+                constrained.Dispose();
+                return cellsOut;
+            }
+
+            internal NativeArray<TessCell> RemoveInterior(int cellCount)
+            {
+                int constrainedCount = 0;
+                NativeArray<TessCell> constrained = Constrain(ref constrainedCount);
+
+                NativeArray<TessCell> cellsOut = new NativeArray<TessCell>(constrainedCount, Allocator.Temp);
+                cellCount = 0;
+                for (int i = 0; i < constrainedCount; ++i)
+                {
+                    if (m_Flags[i] == 1)
+                    {
+                        cellsOut[cellCount++] = constrained[i];
+                    }
+                }
+
+                constrained.Dispose();
+                return cellsOut;
+            }
+
+            internal void Cleanup()
+            {
+                m_Edges.Dispose();
+                m_Stars.Dispose();
+                m_ILArray.Dispose();
+                m_IUArray.Dispose();
+                m_SPArray.Dispose();
+                m_Cells.Dispose();
+
+                m_Flags.Dispose();
+                m_Neighbors.Dispose();
+                m_Constraints.Dispose();
+            }
+
+        }
+
+    }
+    
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.spriteshape@5.1.1/Runtime/UTess2D/Tessellator.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d8287b2baa933c3439b7138b01b09648
+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.2d.spriteshape@5.1.1/Samples~/Extras/Scenes/Colliders.unity.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 299e0b891b406a8409a068bd55ee5a1f
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.spriteshape@5.1.1/Samples~/Extras/Scenes/ConformingSplineScene.unity

@@ -0,0 +1,528 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!29 &1
+OcclusionCullingSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 2
+  m_OcclusionBakeSettings:
+    smallestOccluder: 5
+    smallestHole: 0.25
+    backfaceThreshold: 100
+  m_SceneGUID: 00000000000000000000000000000000
+  m_OcclusionCullingData: {fileID: 0}
+--- !u!104 &2
+RenderSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 9
+  m_Fog: 0
+  m_FogColor: {r: 0.5, g: 0.5, b: 0.5, a: 1}
+  m_FogMode: 3
+  m_FogDensity: 0.01
+  m_LinearFogStart: 0
+  m_LinearFogEnd: 300
+  m_AmbientSkyColor: {r: 0.212, g: 0.227, b: 0.259, a: 1}
+  m_AmbientEquatorColor: {r: 0.114, g: 0.125, b: 0.133, a: 1}
+  m_AmbientGroundColor: {r: 0.047, g: 0.043, b: 0.035, a: 1}
+  m_AmbientIntensity: 1
+  m_AmbientMode: 0
+  m_SubtractiveShadowColor: {r: 0.42, g: 0.478, b: 0.627, a: 1}
+  m_SkyboxMaterial: {fileID: 0}
+  m_HaloStrength: 0.5
+  m_FlareStrength: 1
+  m_FlareFadeSpeed: 3
+  m_HaloTexture: {fileID: 0}
+  m_SpotCookie: {fileID: 10001, guid: 0000000000000000e000000000000000, type: 0}
+  m_DefaultReflectionMode: 0
+  m_DefaultReflectionResolution: 128
+  m_ReflectionBounces: 1
+  m_ReflectionIntensity: 1
+  m_CustomReflection: {fileID: 0}
+  m_Sun: {fileID: 0}
+  m_IndirectSpecularColor: {r: 0, g: 0, b: 0, a: 1}
+  m_UseRadianceAmbientProbe: 0
+--- !u!157 &3
+LightmapSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 11
+  m_GIWorkflowMode: 0
+  m_GISettings:
+    serializedVersion: 2
+    m_BounceScale: 1
+    m_IndirectOutputScale: 1
+    m_AlbedoBoost: 1
+    m_EnvironmentLightingMode: 0
+    m_EnableBakedLightmaps: 1
+    m_EnableRealtimeLightmaps: 1
+  m_LightmapEditorSettings:
+    serializedVersion: 12
+    m_Resolution: 2
+    m_BakeResolution: 40
+    m_AtlasSize: 1024
+    m_AO: 0
+    m_AOMaxDistance: 1
+    m_CompAOExponent: 1
+    m_CompAOExponentDirect: 0
+    m_ExtractAmbientOcclusion: 0
+    m_Padding: 2
+    m_LightmapParameters: {fileID: 0}
+    m_LightmapsBakeMode: 1
+    m_TextureCompression: 1
+    m_FinalGather: 0
+    m_FinalGatherFiltering: 1
+    m_FinalGatherRayCount: 256
+    m_ReflectionCompression: 2
+    m_MixedBakeMode: 2
+    m_BakeBackend: 0
+    m_PVRSampling: 1
+    m_PVRDirectSampleCount: 32
+    m_PVRSampleCount: 500
+    m_PVRBounces: 2
+    m_PVREnvironmentSampleCount: 500
+    m_PVREnvironmentReferencePointCount: 2048
+    m_PVRFilteringMode: 2
+    m_PVRDenoiserTypeDirect: 0
+    m_PVRDenoiserTypeIndirect: 0
+    m_PVRDenoiserTypeAO: 0
+    m_PVRFilterTypeDirect: 0
+    m_PVRFilterTypeIndirect: 0
+    m_PVRFilterTypeAO: 0
+    m_PVREnvironmentMIS: 0
+    m_PVRCulling: 1
+    m_PVRFilteringGaussRadiusDirect: 1
+    m_PVRFilteringGaussRadiusIndirect: 5
+    m_PVRFilteringGaussRadiusAO: 2
+    m_PVRFilteringAtrousPositionSigmaDirect: 0.5
+    m_PVRFilteringAtrousPositionSigmaIndirect: 2
+    m_PVRFilteringAtrousPositionSigmaAO: 1
+    m_ShowResolutionOverlay: 1
+    m_ExportTrainingData: 0
+  m_LightingDataAsset: {fileID: 0}
+  m_UseShadowmask: 1
+--- !u!196 &4
+NavMeshSettings:
+  serializedVersion: 2
+  m_ObjectHideFlags: 0
+  m_BuildSettings:
+    serializedVersion: 2
+    agentTypeID: 0
+    agentRadius: 0.5
+    agentHeight: 2
+    agentSlope: 45
+    agentClimb: 0.4
+    ledgeDropHeight: 0
+    maxJumpAcrossDistance: 0
+    minRegionArea: 2
+    manualCellSize: 0
+    cellSize: 0.16666667
+    manualTileSize: 0
+    tileSize: 256
+    accuratePlacement: 0
+    debug:
+      m_Flags: 0
+  m_NavMeshData: {fileID: 0}
+--- !u!1 &400039572
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 400039576}
+  - component: {fileID: 400039575}
+  - component: {fileID: 400039574}
+  m_Layer: 0
+  m_Name: Top
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!114 &400039574
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 400039572}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 90539df1cd5704abcb25fec9f3f5f84b, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_LegacyGenerator: 0
+  m_Spline:
+    m_IsOpenEnded: 1
+    m_ControlPoints:
+    - position: {x: 0.37061024, y: 7.517852, z: 0}
+      leftTangent: {x: 0, y: 0, z: 0}
+      rightTangent: {x: 0, y: 0, z: 0}
+      mode: 0
+      height: 1
+      bevelCutoff: 0
+      bevelSize: 0
+      spriteIndex: 0
+      corner: 0
+    - position: {x: 0.41290092, y: -1.8726089, z: 0}
+      leftTangent: {x: -3.4678102, y: 1.8794639, z: 0}
+      rightTangent: {x: 3.4678102, y: -1.8794639, z: 0}
+      mode: 1
+      height: 1
+      bevelCutoff: 0
+      bevelSize: 0
+      spriteIndex: 0
+      corner: 0
+    - position: {x: 7.9664383, y: -6.63839, z: 0}
+      leftTangent: {x: -4.8397465, y: -0.030138493, z: 0}
+      rightTangent: {x: 4.8397465, y: 0.030138493, z: 0}
+      mode: 1
+      height: 1
+      bevelCutoff: 0
+      bevelSize: 0
+      spriteIndex: 0
+      corner: 0
+    - position: {x: 15, y: -1, z: 0}
+      leftTangent: {x: -3.2519875, y: -2.4569178, z: 0}
+      rightTangent: {x: 3.2519875, y: 2.4569178, z: 0}
+      mode: 1
+      height: 1
+      bevelCutoff: 0
+      bevelSize: 0
+      spriteIndex: 0
+      corner: 0
+    - position: {x: 14.186232, y: 7.786347, z: 0}
+      leftTangent: {x: 0, y: 0, z: 0}
+      rightTangent: {x: 0, y: 0, z: 0}
+      mode: 0
+      height: 1
+      bevelCutoff: 0
+      bevelSize: 0
+      spriteIndex: 0
+      corner: 0
+  m_SpriteShape: {fileID: 11400000, guid: 541c57e7ddb8adc46b7ca9573818a619, type: 2}
+  m_FillPixelPerUnit: 100
+  m_StretchTiling: 1
+  m_SplineDetail: 16
+  m_AdaptiveUV: 1
+  m_StretchUV: 0
+  m_WorldSpaceUV: 0
+  m_ColliderDetail: 4
+  m_ColliderOffset: 0
+  m_UpdateCollider: 0
+  m_OptimizeCollider: 1
+--- !u!1971053207 &400039575
+SpriteShapeRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 400039572}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_DynamicOccludee: 0
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_RenderingLayerMask: 4294967295
+  m_RendererPriority: 0
+  m_Materials:
+  - {fileID: 10754, guid: 0000000000000000f000000000000000, type: 0}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_PreserveUVs: 0
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
+  m_SelectedEditorRenderState: 0
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_MaskInteraction: 0
+  m_ShapeTexture: {fileID: 0}
+  m_Sprites:
+  - {fileID: 21300000, guid: e74b518a65bc45f4cace9a2fef6af29d, type: 3}
+  m_LocalAABB:
+    m_Center: {x: 7.558513, y: 0.5739784, z: -0.005}
+    m_Extent: {x: 8.697825, y: 7.2123685, z: 0.005}
+--- !u!4 &400039576
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 400039572}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: -7.61, y: -0.47, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children:
+  - {fileID: 1865283555}
+  m_Father: {fileID: 0}
+  m_RootOrder: 1
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &1865283552
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1865283555}
+  - component: {fileID: 1865283554}
+  - component: {fileID: 1865283553}
+  - component: {fileID: 1865283556}
+  m_Layer: 0
+  m_Name: Bottom
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!114 &1865283553
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1865283552}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 90539df1cd5704abcb25fec9f3f5f84b, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_LegacyGenerator: 0
+  m_Spline:
+    m_IsOpenEnded: 1
+    m_ControlPoints:
+    - position: {x: 0.37061024, y: 7.517852, z: 0}
+      leftTangent: {x: 0, y: 0, z: 0}
+      rightTangent: {x: 0, y: 0, z: 0}
+      mode: 0
+      height: 1
+      bevelCutoff: 0
+      bevelSize: 0
+      spriteIndex: 0
+      corner: 0
+    - position: {x: 0.41290092, y: -1.8726089, z: 0}
+      leftTangent: {x: -3.4678102, y: 1.8794639, z: 0}
+      rightTangent: {x: 3.4678102, y: -1.8794639, z: 0}
+      mode: 1
+      height: 1
+      bevelCutoff: 0
+      bevelSize: 0
+      spriteIndex: 0
+      corner: 0
+    - position: {x: 7.9664383, y: -6.63839, z: 0}
+      leftTangent: {x: -4.8397465, y: -0.030138493, z: 0}
+      rightTangent: {x: 4.8397465, y: 0.030138493, z: 0}
+      mode: 1
+      height: 1
+      bevelCutoff: 0
+      bevelSize: 0
+      spriteIndex: 0
+      corner: 0
+    - position: {x: 15, y: -1, z: 0}
+      leftTangent: {x: -3.2519875, y: -2.4569178, z: 0}
+      rightTangent: {x: 3.2519875, y: 2.4569178, z: 0}
+      mode: 1
+      height: 1
+      bevelCutoff: 0
+      bevelSize: 0
+      spriteIndex: 0
+      corner: 0
+    - position: {x: 14.186232, y: 7.786347, z: 0}
+      leftTangent: {x: 0, y: 0, z: 0}
+      rightTangent: {x: 0, y: 0, z: 0}
+      mode: 0
+      height: 1
+      bevelCutoff: 0
+      bevelSize: 0
+      spriteIndex: 0
+      corner: 0
+  m_SpriteShape: {fileID: 11400000, guid: e03579ec9d1b6c54ea364bd8ee0bcfd8, type: 2}
+  m_FillPixelPerUnit: 100
+  m_StretchTiling: 1
+  m_SplineDetail: 16
+  m_AdaptiveUV: 1
+  m_StretchUV: 0
+  m_WorldSpaceUV: 0
+  m_ColliderDetail: 4
+  m_ColliderOffset: 0
+  m_UpdateCollider: 0
+  m_OptimizeCollider: 1
+--- !u!1971053207 &1865283554
+SpriteShapeRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1865283552}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_DynamicOccludee: 0
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_RenderingLayerMask: 4294967295
+  m_RendererPriority: 0
+  m_Materials:
+  - {fileID: 10754, guid: 0000000000000000f000000000000000, type: 0}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_PreserveUVs: 0
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
+  m_SelectedEditorRenderState: 0
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_MaskInteraction: 0
+  m_ShapeTexture: {fileID: 0}
+  m_Sprites:
+  - {fileID: 21300000, guid: 418ab5c27d3054eb89959d9c715e00c9, type: 3}
+  - {fileID: 21300000, guid: e74b518a65bc45f4cace9a2fef6af29d, type: 3}
+  m_LocalAABB:
+    m_Center: {x: 7.5582957, y: 0.47995615, z: -0.005}
+    m_Extent: {x: 9.09759, y: 7.5183325, z: 0.005}
+--- !u!4 &1865283555
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1865283552}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 400039576}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!114 &1865283556
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1865283552}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: db6f6067a1e6dd34ca4e2c4b7145e79b, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_ParentObject: {fileID: 400039572}
+--- !u!1 &1990748034
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1990748038}
+  - component: {fileID: 1990748037}
+  - component: {fileID: 1990748036}
+  - component: {fileID: 1990748035}
+  m_Layer: 0
+  m_Name: Main Camera
+  m_TagString: MainCamera
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!81 &1990748035
+AudioListener:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1990748034}
+  m_Enabled: 1
+--- !u!124 &1990748036
+Behaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1990748034}
+  m_Enabled: 1
+--- !u!20 &1990748037
+Camera:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1990748034}
+  m_Enabled: 1
+  serializedVersion: 2
+  m_ClearFlags: 2
+  m_BackGroundColor: {r: 0.19215687, g: 0.3019608, b: 0.4745098, a: 0}
+  m_projectionMatrixMode: 1
+  m_GateFitMode: 2
+  m_FOVAxisMode: 0
+  m_SensorSize: {x: 36, y: 24}
+  m_LensShift: {x: 0, y: 0}
+  m_FocalLength: 50
+  m_NormalizedViewPortRect:
+    serializedVersion: 2
+    x: 0
+    y: 0
+    width: 1
+    height: 1
+  near clip plane: 0.3
+  far clip plane: 1000
+  field of view: 60
+  orthographic: 1
+  orthographic size: 15
+  m_Depth: -1
+  m_CullingMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  m_RenderingPath: -1
+  m_TargetTexture: {fileID: 0}
+  m_TargetDisplay: 0
+  m_TargetEye: 3
+  m_HDR: 1
+  m_AllowMSAA: 1
+  m_AllowDynamicResolution: 0
+  m_ForceIntoRT: 0
+  m_OcclusionCulling: 1
+  m_StereoConvergence: 10
+  m_StereoSeparation: 0.022
+--- !u!4 &1990748038
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1990748034}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 1, z: -10}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.spriteshape@5.1.1/Samples~/Extras/Scenes/ConformingSplineScene.unity.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: b8529774cb716f645b682951a7aae689
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.spriteshape@5.1.1/Samples~/Extras/Scenes/SimpleDrawScene.unity

@@ -0,0 +1,326 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!29 &1
+OcclusionCullingSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 2
+  m_OcclusionBakeSettings:
+    smallestOccluder: 5
+    smallestHole: 0.25
+    backfaceThreshold: 100
+  m_SceneGUID: 00000000000000000000000000000000
+  m_OcclusionCullingData: {fileID: 0}
+--- !u!104 &2
+RenderSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 9
+  m_Fog: 0
+  m_FogColor: {r: 0.5, g: 0.5, b: 0.5, a: 1}
+  m_FogMode: 3
+  m_FogDensity: 0.01
+  m_LinearFogStart: 0
+  m_LinearFogEnd: 300
+  m_AmbientSkyColor: {r: 0.212, g: 0.227, b: 0.259, a: 1}
+  m_AmbientEquatorColor: {r: 0.114, g: 0.125, b: 0.133, a: 1}
+  m_AmbientGroundColor: {r: 0.047, g: 0.043, b: 0.035, a: 1}
+  m_AmbientIntensity: 1
+  m_AmbientMode: 0
+  m_SubtractiveShadowColor: {r: 0.42, g: 0.478, b: 0.627, a: 1}
+  m_SkyboxMaterial: {fileID: 0}
+  m_HaloStrength: 0.5
+  m_FlareStrength: 1
+  m_FlareFadeSpeed: 3
+  m_HaloTexture: {fileID: 0}
+  m_SpotCookie: {fileID: 10001, guid: 0000000000000000e000000000000000, type: 0}
+  m_DefaultReflectionMode: 0
+  m_DefaultReflectionResolution: 128
+  m_ReflectionBounces: 1
+  m_ReflectionIntensity: 1
+  m_CustomReflection: {fileID: 0}
+  m_Sun: {fileID: 0}
+  m_IndirectSpecularColor: {r: 0, g: 0, b: 0, a: 1}
+  m_UseRadianceAmbientProbe: 0
+--- !u!157 &3
+LightmapSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 11
+  m_GIWorkflowMode: 0
+  m_GISettings:
+    serializedVersion: 2
+    m_BounceScale: 1
+    m_IndirectOutputScale: 1
+    m_AlbedoBoost: 1
+    m_TemporalCoherenceThreshold: 1
+    m_EnvironmentLightingMode: 0
+    m_EnableBakedLightmaps: 1
+    m_EnableRealtimeLightmaps: 1
+  m_LightmapEditorSettings:
+    serializedVersion: 10
+    m_Resolution: 2
+    m_BakeResolution: 40
+    m_AtlasSize: 1024
+    m_AO: 0
+    m_AOMaxDistance: 1
+    m_CompAOExponent: 1
+    m_CompAOExponentDirect: 0
+    m_Padding: 2
+    m_LightmapParameters: {fileID: 0}
+    m_LightmapsBakeMode: 1
+    m_TextureCompression: 1
+    m_FinalGather: 0
+    m_FinalGatherFiltering: 1
+    m_FinalGatherRayCount: 256
+    m_ReflectionCompression: 2
+    m_MixedBakeMode: 2
+    m_BakeBackend: 1
+    m_PVRSampling: 1
+    m_PVRDirectSampleCount: 32
+    m_PVRSampleCount: 500
+    m_PVRBounces: 2
+    m_PVRFilterTypeDirect: 0
+    m_PVRFilterTypeIndirect: 0
+    m_PVRFilterTypeAO: 0
+    m_PVRFilteringMode: 1
+    m_PVRCulling: 1
+    m_PVRFilteringGaussRadiusDirect: 1
+    m_PVRFilteringGaussRadiusIndirect: 5
+    m_PVRFilteringGaussRadiusAO: 2
+    m_PVRFilteringAtrousPositionSigmaDirect: 0.5
+    m_PVRFilteringAtrousPositionSigmaIndirect: 2
+    m_PVRFilteringAtrousPositionSigmaAO: 1
+    m_ShowResolutionOverlay: 1
+  m_LightingDataAsset: {fileID: 0}
+  m_UseShadowmask: 1
+--- !u!196 &4
+NavMeshSettings:
+  serializedVersion: 2
+  m_ObjectHideFlags: 0
+  m_BuildSettings:
+    serializedVersion: 2
+    agentTypeID: 0
+    agentRadius: 0.5
+    agentHeight: 2
+    agentSlope: 45
+    agentClimb: 0.4
+    ledgeDropHeight: 0
+    maxJumpAcrossDistance: 0
+    minRegionArea: 2
+    manualCellSize: 0
+    cellSize: 0.16666667
+    manualTileSize: 0
+    tileSize: 256
+    accuratePlacement: 0
+    debug:
+      m_Flags: 0
+  m_NavMeshData: {fileID: 0}
+--- !u!1 &1048079211
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1048079214}
+  - component: {fileID: 1048079213}
+  - component: {fileID: 1048079212}
+  m_Layer: 0
+  m_Name: Main Camera
+  m_TagString: MainCamera
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!81 &1048079212
+AudioListener:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1048079211}
+  m_Enabled: 1
+--- !u!20 &1048079213
+Camera:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1048079211}
+  m_Enabled: 1
+  serializedVersion: 2
+  m_ClearFlags: 2
+  m_BackGroundColor: {r: 0.19215687, g: 0.3019608, b: 0.4745098, a: 0}
+  m_projectionMatrixMode: 1
+  m_SensorSize: {x: 36, y: 24}
+  m_LensShift: {x: 0, y: 0}
+  m_FocalLength: 50
+  m_NormalizedViewPortRect:
+    serializedVersion: 2
+    x: 0
+    y: 0
+    width: 1
+    height: 1
+  near clip plane: 0.3
+  far clip plane: 1000
+  field of view: 60
+  orthographic: 1
+  orthographic size: 5
+  m_Depth: -1
+  m_CullingMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  m_RenderingPath: -1
+  m_TargetTexture: {fileID: 0}
+  m_TargetDisplay: 0
+  m_TargetEye: 3
+  m_HDR: 1
+  m_AllowMSAA: 1
+  m_AllowDynamicResolution: 0
+  m_ForceIntoRT: 0
+  m_OcclusionCulling: 1
+  m_StereoConvergence: 10
+  m_StereoSeparation: 0.022
+--- !u!4 &1048079214
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1048079211}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 1, z: -10}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &1480543089
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1480543093}
+  - component: {fileID: 1480543092}
+  - component: {fileID: 1480543091}
+  - component: {fileID: 1480543090}
+  m_Layer: 0
+  m_Name: SpriteShape
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!114 &1480543090
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1480543089}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 922bb1bbfeaeb9a4c9204b7d0bc3d8c8, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  minimumDistance: 1
+--- !u!114 &1480543091
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1480543089}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 90539df1cd5704abcb25fec9f3f5f84b, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Spline:
+    m_IsOpenEnded: 1
+    m_ControlPoints:
+    - position: {x: -1, y: 0, z: 0}
+      leftTangent: {x: 0, y: 0, z: 0}
+      rightTangent: {x: 0, y: 0, z: 0}
+      mode: 0
+      height: 1
+      bevelCutoff: 0
+      bevelSize: 0
+      spriteIndex: 1
+      corner: 0
+    - position: {x: 1, y: 0, z: 0}
+      leftTangent: {x: 0, y: 0, z: 0}
+      rightTangent: {x: 0, y: 0, z: 0}
+      mode: 0
+      height: 1
+      bevelCutoff: 0
+      bevelSize: 0.216
+      spriteIndex: 0
+      corner: 0
+  m_SpriteShape: {fileID: 11400000, guid: e03579ec9d1b6c54ea364bd8ee0bcfd8, type: 2}
+  m_SplineDetail: 16
+  m_AdaptiveUV: 1
+  m_UpdateCollider: 0
+  m_ColliderDetail: 4
+  m_ColliderOffset: 0
+  m_ColliderCornerType: 0
+--- !u!1971053207 &1480543092
+SpriteShapeRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1480543089}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_DynamicOccludee: 0
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_RenderingLayerMask: 4294967295
+  m_Materials:
+  - {fileID: 10754, guid: 0000000000000000f000000000000000, type: 0}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_PreserveUVs: 0
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
+  m_SelectedEditorRenderState: 0
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_MaskInteraction: 0
+  m_ShapeTexture: {fileID: 0}
+  m_Sprites:
+  - {fileID: 21300000, guid: 418ab5c27d3054eb89959d9c715e00c9, type: 3}
+  - {fileID: 21300000, guid: e74b518a65bc45f4cace9a2fef6af29d, type: 3}
+  - {fileID: 0}
+  - {fileID: 0}
+  - {fileID: 0}
+  - {fileID: 0}
+  - {fileID: 0}
+  - {fileID: 0}
+  - {fileID: 0}
+  - {fileID: 0}
+  m_LocalAABB:
+    m_Center: {x: 0, y: 0.20000002, z: 0}
+    m_Extent: {x: 1, y: 0.20000002, z: 0}
+--- !u!4 &1480543093
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1480543089}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 1
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.spriteshape@5.1.1/Samples~/Extras/Scenes/SimpleDrawScene.unity.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: e182160e1c8c64844872387ebf59c6e9
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.spriteshape@5.1.1/Samples~/Extras/Scenes/SimplifiedSpriteShape.unity

@@ -0,0 +1,382 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!29 &1
+OcclusionCullingSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 2
+  m_OcclusionBakeSettings:
+    smallestOccluder: 5
+    smallestHole: 0.25
+    backfaceThreshold: 100
+  m_SceneGUID: 00000000000000000000000000000000
+  m_OcclusionCullingData: {fileID: 0}
+--- !u!104 &2
+RenderSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 9
+  m_Fog: 0
+  m_FogColor: {r: 0.5, g: 0.5, b: 0.5, a: 1}
+  m_FogMode: 3
+  m_FogDensity: 0.01
+  m_LinearFogStart: 0
+  m_LinearFogEnd: 300
+  m_AmbientSkyColor: {r: 0.212, g: 0.227, b: 0.259, a: 1}
+  m_AmbientEquatorColor: {r: 0.114, g: 0.125, b: 0.133, a: 1}
+  m_AmbientGroundColor: {r: 0.047, g: 0.043, b: 0.035, a: 1}
+  m_AmbientIntensity: 1
+  m_AmbientMode: 0
+  m_SubtractiveShadowColor: {r: 0.42, g: 0.478, b: 0.627, a: 1}
+  m_SkyboxMaterial: {fileID: 0}
+  m_HaloStrength: 0.5
+  m_FlareStrength: 1
+  m_FlareFadeSpeed: 3
+  m_HaloTexture: {fileID: 0}
+  m_SpotCookie: {fileID: 10001, guid: 0000000000000000e000000000000000, type: 0}
+  m_DefaultReflectionMode: 0
+  m_DefaultReflectionResolution: 128
+  m_ReflectionBounces: 1
+  m_ReflectionIntensity: 1
+  m_CustomReflection: {fileID: 0}
+  m_Sun: {fileID: 0}
+  m_IndirectSpecularColor: {r: 0, g: 0, b: 0, a: 1}
+  m_UseRadianceAmbientProbe: 0
+--- !u!157 &3
+LightmapSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 11
+  m_GIWorkflowMode: 0
+  m_GISettings:
+    serializedVersion: 2
+    m_BounceScale: 1
+    m_IndirectOutputScale: 1
+    m_AlbedoBoost: 1
+    m_EnvironmentLightingMode: 0
+    m_EnableBakedLightmaps: 1
+    m_EnableRealtimeLightmaps: 1
+  m_LightmapEditorSettings:
+    serializedVersion: 12
+    m_Resolution: 2
+    m_BakeResolution: 40
+    m_AtlasSize: 1024
+    m_AO: 0
+    m_AOMaxDistance: 1
+    m_CompAOExponent: 1
+    m_CompAOExponentDirect: 0
+    m_ExtractAmbientOcclusion: 0
+    m_Padding: 2
+    m_LightmapParameters: {fileID: 0}
+    m_LightmapsBakeMode: 1
+    m_TextureCompression: 1
+    m_FinalGather: 0
+    m_FinalGatherFiltering: 1
+    m_FinalGatherRayCount: 256
+    m_ReflectionCompression: 2
+    m_MixedBakeMode: 2
+    m_BakeBackend: 1
+    m_PVRSampling: 1
+    m_PVRDirectSampleCount: 32
+    m_PVRSampleCount: 500
+    m_PVRBounces: 2
+    m_PVREnvironmentSampleCount: 500
+    m_PVREnvironmentReferencePointCount: 2048
+    m_PVRFilteringMode: 2
+    m_PVRDenoiserTypeDirect: 0
+    m_PVRDenoiserTypeIndirect: 0
+    m_PVRDenoiserTypeAO: 0
+    m_PVRFilterTypeDirect: 0
+    m_PVRFilterTypeIndirect: 0
+    m_PVRFilterTypeAO: 0
+    m_PVREnvironmentMIS: 0
+    m_PVRCulling: 1
+    m_PVRFilteringGaussRadiusDirect: 1
+    m_PVRFilteringGaussRadiusIndirect: 5
+    m_PVRFilteringGaussRadiusAO: 2
+    m_PVRFilteringAtrousPositionSigmaDirect: 0.5
+    m_PVRFilteringAtrousPositionSigmaIndirect: 2
+    m_PVRFilteringAtrousPositionSigmaAO: 1
+    m_ExportTrainingData: 0
+    m_TrainingDataDestination: TrainingData
+  m_LightingDataAsset: {fileID: 0}
+  m_UseShadowmask: 1
+--- !u!196 &4
+NavMeshSettings:
+  serializedVersion: 2
+  m_ObjectHideFlags: 0
+  m_BuildSettings:
+    serializedVersion: 2
+    agentTypeID: 0
+    agentRadius: 0.5
+    agentHeight: 2
+    agentSlope: 45
+    agentClimb: 0.4
+    ledgeDropHeight: 0
+    maxJumpAcrossDistance: 0
+    minRegionArea: 2
+    manualCellSize: 0
+    cellSize: 0.16666667
+    manualTileSize: 0
+    tileSize: 256
+    accuratePlacement: 0
+    debug:
+      m_Flags: 0
+  m_NavMeshData: {fileID: 0}
+--- !u!1 &53845803
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 53845806}
+  - component: {fileID: 53845805}
+  - component: {fileID: 53845804}
+  m_Layer: 0
+  m_Name: SpriteShape
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!114 &53845804
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 53845803}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 90539df1cd5704abcb25fec9f3f5f84b, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_LegacyGenerator: 0
+  m_Spline:
+    m_IsOpenEnded: 0
+    m_ControlPoints:
+    - position: {x: 0.12956464, y: 1.8859321, z: 0}
+      leftTangent: {x: 0.87607896, y: -0.028361678, z: 0}
+      rightTangent: {x: -0.876079, y: 0.028361678, z: 0}
+      mode: 1
+      height: 1
+      bevelCutoff: 180
+      bevelSize: 0.5
+      spriteIndex: 0
+      corner: 0
+    - position: {x: -2, y: 0, z: 0}
+      leftTangent: {x: 0.7276257, y: 0.5038886, z: 0}
+      rightTangent: {x: -0.72762585, y: -0.5038886, z: 0}
+      mode: 1
+      height: 1
+      bevelCutoff: 0
+      bevelSize: 0
+      spriteIndex: 0
+      corner: 0
+    - position: {x: -4.370756, y: -1.2540917, z: 0}
+      leftTangent: {x: 0.27876043, y: 0.84002125, z: 0}
+      rightTangent: {x: -0.27876043, y: -0.84002113, z: 0}
+      mode: 1
+      height: 1
+      bevelCutoff: 180
+      bevelSize: 0.424
+      spriteIndex: 0
+      corner: 0
+    - position: {x: -2.9905427, y: -4.1601443, z: 0}
+      leftTangent: {x: -1.0090494, y: 0.19818997, z: 0}
+      rightTangent: {x: 1.0090494, y: -0.19819021, z: 0}
+      mode: 1
+      height: 1
+      bevelCutoff: 175
+      bevelSize: 0.473
+      spriteIndex: 0
+      corner: 0
+    - position: {x: -0.68832755, y: -2.0601013, z: 0}
+      leftTangent: {x: -1.020073, y: -0.13004279, z: 0}
+      rightTangent: {x: 1.020073, y: 0.13004267, z: 0}
+      mode: 1
+      height: 1
+      bevelCutoff: 0
+      bevelSize: 0
+      spriteIndex: 0
+      corner: 0
+    - position: {x: 2.4391866, y: -3.7118704, z: 0}
+      leftTangent: {x: -1.0588536, y: -0.24282193, z: 0}
+      rightTangent: {x: 1.0588536, y: 0.24282193, z: 0}
+      mode: 1
+      height: 1
+      bevelCutoff: 0
+      bevelSize: 0
+      spriteIndex: 0
+      corner: 0
+    - position: {x: 4.389332, y: -1.0597417, z: 0}
+      leftTangent: {x: 0.22145462, y: -0.83364165, z: 0}
+      rightTangent: {x: -0.22145462, y: 0.83364165, z: 0}
+      mode: 1
+      height: 1
+      bevelCutoff: 180
+      bevelSize: 0.407
+      spriteIndex: 0
+      corner: 0
+    - position: {x: 2, y: 0, z: 0}
+      leftTangent: {x: 0.71019197, y: -0.4895181, z: 0}
+      rightTangent: {x: -0.71019197, y: 0.4895181, z: 0}
+      mode: 1
+      height: 1
+      bevelCutoff: 0
+      bevelSize: 0
+      spriteIndex: 0
+      corner: 0
+  m_SpriteShape: {fileID: 11400000, guid: 19b9cf308de41834c9968d12bec673b1, type: 2}
+  m_FillPixelPerUnit: 100
+  m_StretchTiling: 1
+  m_SplineDetail: 16
+  m_AdaptiveUV: 1
+  m_StretchUV: 0
+  m_WorldSpaceUV: 0
+  m_ColliderDetail: 4
+  m_ColliderOffset: 0
+  m_UpdateCollider: 0
+  m_OptimizeCollider: 1
+--- !u!1971053207 &53845805
+SpriteShapeRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 53845803}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_RenderingLayerMask: 4294967295
+  m_RendererPriority: 0
+  m_Materials:
+  - {fileID: 10754, guid: 0000000000000000f000000000000000, type: 0}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_ReceiveGI: 1
+  m_PreserveUVs: 0
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
+  m_SelectedEditorRenderState: 0
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_MaskInteraction: 0
+  m_ShapeTexture: {fileID: 0}
+  m_Sprites:
+  - {fileID: 21300000, guid: c6dabd295b8ab514fa47b5d4e2b0266e, type: 3}
+  m_LocalAABB:
+    m_Center: {x: -0.009027481, y: -1.1412225, z: -0.005}
+    m_Extent: {x: 4.6648436, y: 3.2670288, z: 0.005}
+--- !u!4 &53845806
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 53845803}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 1
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &408902805
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 408902808}
+  - component: {fileID: 408902807}
+  - component: {fileID: 408902806}
+  m_Layer: 0
+  m_Name: Main Camera
+  m_TagString: MainCamera
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!81 &408902806
+AudioListener:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 408902805}
+  m_Enabled: 1
+--- !u!20 &408902807
+Camera:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 408902805}
+  m_Enabled: 1
+  serializedVersion: 2
+  m_ClearFlags: 2
+  m_BackGroundColor: {r: 0.19215687, g: 0.3019608, b: 0.4745098, a: 0}
+  m_projectionMatrixMode: 1
+  m_GateFitMode: 2
+  m_FOVAxisMode: 0
+  m_SensorSize: {x: 36, y: 24}
+  m_LensShift: {x: 0, y: 0}
+  m_FocalLength: 50
+  m_NormalizedViewPortRect:
+    serializedVersion: 2
+    x: 0
+    y: 0
+    width: 1
+    height: 1
+  near clip plane: 0.3
+  far clip plane: 1000
+  field of view: 60
+  orthographic: 1
+  orthographic size: 5
+  m_Depth: -1
+  m_CullingMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  m_RenderingPath: -1
+  m_TargetTexture: {fileID: 0}
+  m_TargetDisplay: 0
+  m_TargetEye: 3
+  m_HDR: 1
+  m_AllowMSAA: 1
+  m_AllowDynamicResolution: 0
+  m_ForceIntoRT: 0
+  m_OcclusionCulling: 1
+  m_StereoConvergence: 10
+  m_StereoSeparation: 0.022
+--- !u!4 &408902808
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 408902805}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: -10}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.spriteshape@5.1.1/Samples~/Extras/Scenes/SimplifiedSpriteShape.unity.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 254bf62203b7710419a1e6283f7e049b
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.spriteshape@5.1.1/Samples~/Extras/Scenes/SprinklePrefabs.unity

@@ -0,0 +1,373 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!29 &1
+OcclusionCullingSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 2
+  m_OcclusionBakeSettings:
+    smallestOccluder: 5
+    smallestHole: 0.25
+    backfaceThreshold: 100
+  m_SceneGUID: 00000000000000000000000000000000
+  m_OcclusionCullingData: {fileID: 0}
+--- !u!104 &2
+RenderSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 9
+  m_Fog: 0
+  m_FogColor: {r: 0.5, g: 0.5, b: 0.5, a: 1}
+  m_FogMode: 3
+  m_FogDensity: 0.01
+  m_LinearFogStart: 0
+  m_LinearFogEnd: 300
+  m_AmbientSkyColor: {r: 0.212, g: 0.227, b: 0.259, a: 1}
+  m_AmbientEquatorColor: {r: 0.114, g: 0.125, b: 0.133, a: 1}
+  m_AmbientGroundColor: {r: 0.047, g: 0.043, b: 0.035, a: 1}
+  m_AmbientIntensity: 1
+  m_AmbientMode: 0
+  m_SubtractiveShadowColor: {r: 0.42, g: 0.478, b: 0.627, a: 1}
+  m_SkyboxMaterial: {fileID: 0}
+  m_HaloStrength: 0.5
+  m_FlareStrength: 1
+  m_FlareFadeSpeed: 3
+  m_HaloTexture: {fileID: 0}
+  m_SpotCookie: {fileID: 10001, guid: 0000000000000000e000000000000000, type: 0}
+  m_DefaultReflectionMode: 0
+  m_DefaultReflectionResolution: 128
+  m_ReflectionBounces: 1
+  m_ReflectionIntensity: 1
+  m_CustomReflection: {fileID: 0}
+  m_Sun: {fileID: 0}
+  m_IndirectSpecularColor: {r: 0, g: 0, b: 0, a: 1}
+  m_UseRadianceAmbientProbe: 0
+--- !u!157 &3
+LightmapSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 11
+  m_GIWorkflowMode: 0
+  m_GISettings:
+    serializedVersion: 2
+    m_BounceScale: 1
+    m_IndirectOutputScale: 1
+    m_AlbedoBoost: 1
+    m_TemporalCoherenceThreshold: 1
+    m_EnvironmentLightingMode: 0
+    m_EnableBakedLightmaps: 1
+    m_EnableRealtimeLightmaps: 1
+  m_LightmapEditorSettings:
+    serializedVersion: 10
+    m_Resolution: 2
+    m_BakeResolution: 40
+    m_AtlasSize: 1024
+    m_AO: 0
+    m_AOMaxDistance: 1
+    m_CompAOExponent: 1
+    m_CompAOExponentDirect: 0
+    m_Padding: 2
+    m_LightmapParameters: {fileID: 0}
+    m_LightmapsBakeMode: 1
+    m_TextureCompression: 1
+    m_FinalGather: 0
+    m_FinalGatherFiltering: 1
+    m_FinalGatherRayCount: 256
+    m_ReflectionCompression: 2
+    m_MixedBakeMode: 2
+    m_BakeBackend: 1
+    m_PVRSampling: 1
+    m_PVRDirectSampleCount: 32
+    m_PVRSampleCount: 500
+    m_PVRBounces: 2
+    m_PVRFilterTypeDirect: 0
+    m_PVRFilterTypeIndirect: 0
+    m_PVRFilterTypeAO: 0
+    m_PVRFilteringMode: 1
+    m_PVRCulling: 1
+    m_PVRFilteringGaussRadiusDirect: 1
+    m_PVRFilteringGaussRadiusIndirect: 5
+    m_PVRFilteringGaussRadiusAO: 2
+    m_PVRFilteringAtrousPositionSigmaDirect: 0.5
+    m_PVRFilteringAtrousPositionSigmaIndirect: 2
+    m_PVRFilteringAtrousPositionSigmaAO: 1
+    m_ShowResolutionOverlay: 1
+  m_LightingDataAsset: {fileID: 0}
+  m_UseShadowmask: 1
+--- !u!196 &4
+NavMeshSettings:
+  serializedVersion: 2
+  m_ObjectHideFlags: 0
+  m_BuildSettings:
+    serializedVersion: 2
+    agentTypeID: 0
+    agentRadius: 0.5
+    agentHeight: 2
+    agentSlope: 45
+    agentClimb: 0.4
+    ledgeDropHeight: 0
+    maxJumpAcrossDistance: 0
+    minRegionArea: 2
+    manualCellSize: 0
+    cellSize: 0.16666667
+    manualTileSize: 0
+    tileSize: 256
+    accuratePlacement: 0
+    debug:
+      m_Flags: 0
+  m_NavMeshData: {fileID: 0}
+--- !u!1 &408902805
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 408902808}
+  - component: {fileID: 408902807}
+  - component: {fileID: 408902806}
+  m_Layer: 0
+  m_Name: Main Camera
+  m_TagString: MainCamera
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!81 &408902806
+AudioListener:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 408902805}
+  m_Enabled: 1
+--- !u!20 &408902807
+Camera:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 408902805}
+  m_Enabled: 1
+  serializedVersion: 2
+  m_ClearFlags: 2
+  m_BackGroundColor: {r: 0.19215687, g: 0.3019608, b: 0.4745098, a: 0}
+  m_projectionMatrixMode: 1
+  m_SensorSize: {x: 36, y: 24}
+  m_LensShift: {x: 0, y: 0}
+  m_FocalLength: 50
+  m_NormalizedViewPortRect:
+    serializedVersion: 2
+    x: 0
+    y: 0
+    width: 1
+    height: 1
+  near clip plane: 0.3
+  far clip plane: 1000
+  field of view: 60
+  orthographic: 1
+  orthographic size: 15
+  m_Depth: -1
+  m_CullingMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  m_RenderingPath: -1
+  m_TargetTexture: {fileID: 0}
+  m_TargetDisplay: 0
+  m_TargetEye: 3
+  m_HDR: 1
+  m_AllowMSAA: 1
+  m_AllowDynamicResolution: 0
+  m_ForceIntoRT: 0
+  m_OcclusionCulling: 1
+  m_StereoConvergence: 10
+  m_StereoSeparation: 0.022
+--- !u!4 &408902808
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 408902805}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: -10}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &2103414715
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 2103414719}
+  - component: {fileID: 2103414718}
+  - component: {fileID: 2103414717}
+  - component: {fileID: 2103414716}
+  m_Layer: 0
+  m_Name: New SpriteShapeController
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!114 &2103414716
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 2103414715}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 1c3eb1d33a6f9114bb5b51099948d2ce, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Prefab: {fileID: 1791732276458280, guid: 91b2663493e1ab642b1b60fc7955f947, type: 2}
+  m_RandomFactor: 90
+  m_UseNormals: 1
+--- !u!114 &2103414717
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 2103414715}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 90539df1cd5704abcb25fec9f3f5f84b, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Spline:
+    m_IsOpenEnded: 1
+    m_ControlPoints:
+    - position: {x: 26.488874, y: -2.6975656, z: 0}
+      leftTangent: {x: 0, y: 0, z: 0}
+      rightTangent: {x: 0, y: 0, z: 0}
+      mode: 0
+      height: 1
+      bevelCutoff: 0
+      bevelSize: 0
+      spriteIndex: 0
+      corner: 0
+    - position: {x: 10.016745, y: -9.5673275, z: 0}
+      leftTangent: {x: 5.787901, y: 1.0897436, z: -0}
+      rightTangent: {x: -5.787901, y: -1.0897436, z: 0}
+      mode: 1
+      height: 1
+      bevelCutoff: 0
+      bevelSize: 0
+      spriteIndex: 0
+      corner: 0
+    - position: {x: -9.3538, y: -9.1233, z: 0}
+      leftTangent: {x: 0, y: 0, z: 0}
+      rightTangent: {x: 0, y: 0, z: 0}
+      mode: 0
+      height: 1
+      bevelCutoff: 0
+      bevelSize: 0
+      spriteIndex: 0
+      corner: 0
+    - position: {x: -15.8531, y: 1.9792956, z: 0}
+      leftTangent: {x: -0.88264585, y: -3.0461369, z: -0}
+      rightTangent: {x: 0.88264585, y: 3.0461369, z: 0}
+      mode: 1
+      height: 1
+      bevelCutoff: 0
+      bevelSize: 0
+      spriteIndex: 0
+      corner: 0
+    - position: {x: -4.864938, y: 10.117959, z: 0}
+      leftTangent: {x: 0, y: 0, z: 0}
+      rightTangent: {x: 0, y: 0, z: 0}
+      mode: 0
+      height: 1
+      bevelCutoff: 0
+      bevelSize: 0
+      spriteIndex: 0
+      corner: 0
+    - position: {x: 10.084305, y: -0.2951008, z: 0}
+      leftTangent: {x: -1.3592644, y: -0.46925667, z: -0}
+      rightTangent: {x: 1.3592644, y: 0.46925667, z: 0}
+      mode: 1
+      height: 1
+      bevelCutoff: 0
+      bevelSize: 0
+      spriteIndex: 0
+      corner: 0
+    - position: {x: 25.481283, y: 4.9277797, z: 0}
+      leftTangent: {x: 0, y: 0, z: 0}
+      rightTangent: {x: 0, y: 0, z: 0}
+      mode: 0
+      height: 1
+      bevelCutoff: 0
+      bevelSize: 0
+      spriteIndex: 0
+      corner: 0
+  m_SpriteShape: {fileID: 11400000, guid: e03579ec9d1b6c54ea364bd8ee0bcfd8, type: 2}
+  m_SplineDetail: 16
+  m_AdaptiveUV: 1
+  m_UpdateCollider: 0
+  m_ColliderDetail: 4
+  m_ColliderOffset: 0
+  m_ColliderCornerType: 0
+--- !u!1971053207 &2103414718
+SpriteShapeRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 2103414715}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_RenderingLayerMask: 4294967295
+  m_Materials:
+  - {fileID: 10754, guid: 0000000000000000f000000000000000, type: 0}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_PreserveUVs: 0
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
+  m_SelectedEditorRenderState: 0
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_MaskInteraction: 0
+  m_ShapeTexture: {fileID: 0}
+  m_Sprites:
+  - {fileID: 21300000, guid: 418ab5c27d3054eb89959d9c715e00c9, type: 3}
+  - {fileID: 21300000, guid: e74b518a65bc45f4cace9a2fef6af29d, type: 3}
+  - {fileID: 0}
+  - {fileID: 0}
+  - {fileID: 0}
+  - {fileID: 0}
+  - {fileID: 0}
+  - {fileID: 0}
+  - {fileID: 0}
+  - {fileID: 0}
+  m_LocalAABB:
+    m_Center: {x: 5.282402, y: 0.079841614, z: 0}
+    m_Extent: {x: 21.206472, y: 10.038117, z: 0}
+--- !u!4 &2103414719
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 2103414715}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: -0.08430457, y: 0.2951008, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 1
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.spriteshape@5.1.1/Samples~/Extras/Scenes/SprinklePrefabs.unity.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 486575d9cb65b134fad35b06df9ae993
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.spriteshape@5.1.1/Samples~/Extras/Scripts/Clipper.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: cc4c383146400014d810176d3a637934
+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.2d.spriteshape@5.1.1/Samples~/Extras/Scripts/ConformingSpline.cs

@@ -0,0 +1,58 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.U2D;
+
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+
+// Demo Script Usage:
+//   When you want multiple SpriteShapes to share a common Spline,
+//   attach this script to the secondary objects you would like to 
+//   copy the Spline and set the ParentObject to the original object
+//   you are copying from.
+
+[ExecuteInEditMode]
+public class ConformingSpline : MonoBehaviour
+{
+
+    public GameObject m_ParentObject;
+    private int hashCode;
+
+    // Use this for initialization
+    void Start()
+    {
+
+    }
+
+    // Update is called once per frame
+    void Update()
+    {
+        if (m_ParentObject != null)
+        {
+            hashCode = CopySpline(m_ParentObject, gameObject, hashCode);
+        }
+    }
+
+    private static int CopySpline(GameObject src, GameObject dst, int hashCode)
+    {
+#if UNITY_EDITOR
+        var parentSpriteShapeController = src.GetComponent<SpriteShapeController>();
+        var mirrorSpriteShapeController = dst.GetComponent<SpriteShapeController>();
+
+        if (parentSpriteShapeController != null && mirrorSpriteShapeController != null && parentSpriteShapeController.spline.GetHashCode() != hashCode)
+        {
+            SerializedObject srcController = new SerializedObject(parentSpriteShapeController);
+            SerializedObject dstController = new SerializedObject(mirrorSpriteShapeController);
+            SerializedProperty srcSpline = srcController.FindProperty("m_Spline");
+            dstController.CopyFromSerializedProperty(srcSpline);
+            dstController.ApplyModifiedProperties();
+            EditorUtility.SetDirty(mirrorSpriteShapeController);
+            return parentSpriteShapeController.spline.GetHashCode();
+        }
+#endif
+        return hashCode;
+    }
+
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.spriteshape@5.1.1/Samples~/Extras/Scripts/ConformingSpline.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: db6f6067a1e6dd34ca4e2c4b7145e79b
+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.2d.spriteshape@5.1.1/Samples~/Extras/Scripts/GenerateSpriteShapes.cs

@@ -0,0 +1,43 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Rendering;
+using UnityEngine.U2D;
+
+// Please add this Component to Camera or some top level object on each loadable scene.
+public class GenerateSpriteShapes : MonoBehaviour
+{
+
+    // Once all SpriteShapes are rendered, remove this Component if On or remove it from elsewhere.
+    public bool destroyOnCompletion = true;
+
+    void OnGUI()
+    {
+        
+        // Loop all invisible SpriteShapeRenderers and generate geometry. 
+        SpriteShapeRenderer[] spriteShapeRenderers = (SpriteShapeRenderer[]) GameObject.FindObjectsOfType (typeof(SpriteShapeRenderer));
+        CommandBuffer rc = new CommandBuffer();
+        rc.GetTemporaryRT(0, 256, 256, 0);
+        rc.SetRenderTarget(0);        
+        foreach (var spriteShapeRenderer in spriteShapeRenderers)
+        {
+            var spriteShapeController = spriteShapeRenderer.gameObject.GetComponent<SpriteShapeController>();
+            if (spriteShapeRenderer != null && spriteShapeController != null)
+            {
+                if (!spriteShapeRenderer.isVisible)
+                {
+                    spriteShapeController.BakeMesh();
+                    rc.DrawRenderer(spriteShapeRenderer, spriteShapeRenderer.sharedMaterial);
+                    // Debug.Log("generating shape for " + spriteShapeRenderer.gameObject.name);
+                }
+            }
+        }
+        rc.ReleaseTemporaryRT(0);
+        Graphics.ExecuteCommandBuffer(rc);
+        
+        // SpriteShape Renderers are generated. This component is no longer needed. Delete this [or] remove this Component from elsewhere.
+        if (destroyOnCompletion)
+            Destroy(this);
+        
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.spriteshape@5.1.1/Samples~/Extras/Scripts/GenerateSpriteShapes.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: fccb8cf469e193a4ea6c24362f061c12
+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.2d.spriteshape@5.1.1/Samples~/Extras/Scripts/GeometryCollider.cs

@@ -0,0 +1,171 @@
+using System.Collections;
+using System.Collections.Generic;
+using Unity.Collections;
+using UnityEngine;
+using UnityEngine.Experimental.U2D;
+using UnityEngine.U2D;
+
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+
+[ExecuteAlways]
+public class GeometryCollider : MonoBehaviour
+{
+    [SerializeField]
+    bool m_UpdateCollider = false;
+
+    int m_HashCode = 0;
+
+    void Start()
+    {
+        
+    }
+
+    // Update is called once per frame
+    void Update()
+    {
+        if (m_UpdateCollider)
+            Bake(gameObject, false);
+    }
+
+    static public void Bake(GameObject go, bool forced)
+    {
+        var spriteShapeController = go.GetComponent<SpriteShapeController>();
+        var spriteShapeRenderer = go.GetComponent<SpriteShapeRenderer>();
+        var polyCollider = go.GetComponent<PolygonCollider2D>();
+        var geometryCollider = go.GetComponent<GeometryCollider>();
+
+        if (spriteShapeController != null && polyCollider != null)
+        {
+            var spline = spriteShapeController.spline;
+            if (geometryCollider != null)
+            { 
+                int splineHashCode = spline.GetHashCode();
+                if (splineHashCode == geometryCollider.m_HashCode && !forced)
+                    return;
+                geometryCollider.m_HashCode = splineHashCode;
+            }
+            NativeArray<ushort> indexArray;
+            NativeSlice<Vector3> posArray;
+            NativeSlice<Vector2> uv0Array;
+            NativeArray<SpriteShapeSegment> geomArray;
+            spriteShapeRenderer.GetChannels(65536, out indexArray, out posArray, out uv0Array);
+            geomArray = spriteShapeRenderer.GetSegments(spline.GetPointCount() * 8);
+
+            NativeArray<ushort> indexArrayLocal = new NativeArray<ushort>(indexArray.Length, Allocator.Temp);
+
+            List<Vector2> points = new List<Vector2>();
+            int indexCount = 0, vertexCount = 0, counter = 0;
+            for (int u = 0; u < geomArray.Length; ++u)
+            {
+                if (geomArray[u].indexCount > 0)
+                {
+                    for (int i = 0; i < geomArray[u].indexCount; ++i)
+                    {
+                        indexArrayLocal[counter] = (ushort)(indexArray[counter] + vertexCount);
+                        counter++;
+                    }
+                    vertexCount += geomArray[u].vertexCount;
+                    indexCount += geomArray[u].indexCount;
+                }
+            }
+            Debug.Log(go.name + " : " + counter);
+            OuterEdges(polyCollider, indexArrayLocal, posArray, indexCount);
+        }
+    }
+
+    // Generate the outer edges from the Renderer mesh. Based on code from www.h3xed.com
+    static void OuterEdges(PolygonCollider2D polygonCollider, NativeArray<ushort> triangles, NativeSlice<Vector3> vertices, int triangleCount)
+    {
+        // Get just the outer edges from the mesh's triangles (ignore or remove any shared edges)
+        Dictionary<string, KeyValuePair<int, int>> edges = new Dictionary<string, KeyValuePair<int, int>>();
+        for (int i = 0; i < triangleCount; i += 3)
+        {
+            for (int e = 0; e < 3; e++)
+            {
+                int vert1 = triangles[i + e];
+                int vert2 = triangles[i + e + 1 > i + 2 ? i : i + e + 1];
+                string edge = Mathf.Min(vert1, vert2) + ":" + Mathf.Max(vert1, vert2);
+                if (edges.ContainsKey(edge))
+                {
+                    edges.Remove(edge);
+                }
+                else
+                {
+                    edges.Add(edge, new KeyValuePair<int, int>(vert1, vert2));
+                }
+            }
+        }
+
+        // Create edge lookup (Key is first vertex, Value is second vertex, of each edge)
+        Dictionary<int, int> lookup = new Dictionary<int, int>();
+        foreach (KeyValuePair<int, int> edge in edges.Values)
+        {
+            if (lookup.ContainsKey(edge.Key) == false)
+            {
+                lookup.Add(edge.Key, edge.Value);
+            }
+        }
+
+        // Create empty polygon collider
+        polygonCollider.pathCount = 0;
+
+        // Loop through edge vertices in order
+        int startVert = 0;
+        int nextVert = startVert;
+        int highestVert = startVert;
+        List<Vector2> colliderPath = new List<Vector2>();
+        while (true)
+        {
+
+            // Add vertex to collider path
+            colliderPath.Add(vertices[nextVert]);
+
+            // Get next vertex
+            nextVert = lookup[nextVert];
+
+            // Store highest vertex (to know what shape to move to next)
+            if (nextVert > highestVert)
+            {
+                highestVert = nextVert;
+            }
+
+            // Shape complete
+            if (nextVert == startVert)
+            {
+
+                // Add path to polygon collider
+                polygonCollider.pathCount++;
+                polygonCollider.SetPath(polygonCollider.pathCount - 1, colliderPath.ToArray());
+                colliderPath.Clear();
+
+                // Go to next shape if one exists
+                if (lookup.ContainsKey(highestVert + 1))
+                {
+
+                    // Set starting and next vertices
+                    startVert = highestVert + 1;
+                    nextVert = startVert;
+
+                    // Continue to next loop
+                    continue;
+                }
+
+                // No more verts
+                break;
+            }
+        }
+    }
+
+#if UNITY_EDITOR
+
+    [MenuItem("SpriteShape/Generate Geometry Collider", false, 358)]
+    public static void BakeGeometryCollider()
+    {
+        if (Selection.activeGameObject != null)
+            GeometryCollider.Bake(Selection.activeGameObject, true);
+    }
+
+#endif
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.spriteshape@5.1.1/Samples~/Extras/Scripts/GeometryCollider.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e0ecd6fe4dd55d640bd7ef3235e0e425
+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.2d.spriteshape@5.1.1/Samples~/Extras/Scripts/LegacyCollider.cs

@@ -0,0 +1,159 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.U2D;
+using ExtrasClipperLib;
+
+#if UNITY_EDITOR
+    using UnityEditor;
+#endif
+
+public enum ColliderCornerType
+{
+    Square,
+    Round,
+    Sharp
+}
+
+[ExecuteAlways]
+public class LegacyCollider : MonoBehaviour
+{
+    [SerializeField]
+    ColliderCornerType m_ColliderCornerType = ColliderCornerType.Square;
+    [SerializeField]
+    float m_ColliderOffset = 1.0f;
+    [SerializeField]
+    bool m_UpdateCollider = false;
+
+    const float s_ClipperScale = 100000.0f;
+    int m_HashCode = 0;
+
+    // Start is called before the first frame update
+    void Start()
+    {
+        
+    }
+
+    // Update is called once per frame
+    void Update()
+    {
+        if (m_UpdateCollider)
+            Bake(gameObject, false);
+    }
+
+    static void SampleCurve(float colliderDetail, Vector3 startPoint, Vector3 startTangent, Vector3 endPoint, Vector3 endTangent, ref List<IntPoint> path)
+    {
+        
+        if (startTangent.sqrMagnitude > 0f || endTangent.sqrMagnitude > 0f)
+        {
+            for (int j = 0; j <= colliderDetail; ++j)
+            {
+                float t = j / (float)colliderDetail;
+                Vector3 newPoint = BezierUtility.BezierPoint(startPoint, startTangent + startPoint, endTangent + endPoint, endPoint, t) * s_ClipperScale;
+
+                path.Add(new IntPoint((System.Int64)newPoint.x, (System.Int64)newPoint.y));
+            }
+        }
+        else
+        {
+            Vector3 newPoint = startPoint * s_ClipperScale;
+            path.Add(new IntPoint((System.Int64)newPoint.x, (System.Int64)newPoint.y));
+
+            newPoint = endPoint * s_ClipperScale;
+            path.Add(new IntPoint((System.Int64)newPoint.x, (System.Int64)newPoint.y));
+        }
+    }
+
+    public static void Bake(GameObject go, bool forced)
+    {
+        var sc = go.GetComponent<SpriteShapeController>();
+        var lc = go.GetComponent<LegacyCollider>();
+
+        if (sc != null)
+        {
+            List<IntPoint> path = new List<IntPoint>();
+            int splinePointCount = sc.spline.GetPointCount();
+            int pathPointCount = splinePointCount;
+
+            ColliderCornerType cct = ColliderCornerType.Square;
+            float co = 1.0f;
+
+            if (lc != null)
+            { 
+                int hashCode = sc.spline.GetHashCode() + lc.m_ColliderCornerType.GetHashCode() + lc.m_ColliderOffset.GetHashCode();
+                if (lc.m_HashCode == hashCode && !forced)
+                    return;
+
+                lc.m_HashCode = hashCode;
+                cct = lc.m_ColliderCornerType;
+                co = lc.m_ColliderOffset;
+            }
+
+            if (sc.spline.isOpenEnded)
+                pathPointCount--;
+
+            for (int i = 0; i < pathPointCount; ++i)
+            {
+                int nextIndex = SplineUtility.NextIndex(i, splinePointCount);
+                SampleCurve(sc.colliderDetail, sc.spline.GetPosition(i), sc.spline.GetRightTangent(i), sc.spline.GetPosition(nextIndex), sc.spline.GetLeftTangent(nextIndex), ref path);
+            }
+
+            if (co != 0f)
+            {
+                List<List<IntPoint>> solution = new List<List<IntPoint>>();
+                ClipperOffset clipOffset = new ClipperOffset();
+
+                EndType endType = EndType.etClosedPolygon;
+
+                if (sc.spline.isOpenEnded)
+                {
+                    endType = EndType.etOpenSquare;
+
+                    if (cct == ColliderCornerType.Round)
+                        endType = EndType.etOpenRound;
+                }
+
+                clipOffset.ArcTolerance = 200f / sc.colliderDetail;
+                clipOffset.AddPath(path, (ExtrasClipperLib.JoinType)cct, endType);
+                clipOffset.Execute(ref solution, s_ClipperScale * co);
+
+                if (solution.Count > 0)
+                    path = solution[0];
+            }
+
+            List<Vector2> pathPoints = new List<Vector2>(path.Count);
+            for (int i = 0; i < path.Count; ++i)
+            {
+                IntPoint ip = path[i];
+                pathPoints.Add(new Vector2(ip.X / s_ClipperScale, ip.Y / s_ClipperScale));
+            }
+
+            var pc = go.GetComponent<PolygonCollider2D>();
+            if (pc)
+            {
+                pc.pathCount = 0;
+                pc.SetPath(0, pathPoints.ToArray());
+            }
+
+            var ec = go.GetComponent<EdgeCollider2D>();
+            if (ec)
+            {
+                if (co > 0f || co < 0f && !sc.spline.isOpenEnded)
+                    pathPoints.Add(pathPoints[0]);
+                ec.points = pathPoints.ToArray();
+            }
+        }
+    }
+
+#if UNITY_EDITOR
+
+    [MenuItem("SpriteShape/Generate Legacy Collider", false, 358)]
+    public static void BakeLegacyCollider()
+    {
+        if (Selection.activeGameObject != null)
+            LegacyCollider.Bake(Selection.activeGameObject, true);
+    }
+
+#endif
+}
+

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.spriteshape@5.1.1/Samples~/Extras/Scripts/LegacyCollider.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6a8e65bafadf93f41a17da25163f2f51
+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.2d.spriteshape@5.1.1/Samples~/Extras/Scripts/SimpleDraw.cs

@@ -0,0 +1,59 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.U2D;
+
+// Dynamic modification of spline to follow the path of mouse movement.
+// This script is just a simplified demo to demonstrate the idea.
+
+public class SimpleDraw : MonoBehaviour
+{
+    public float minimumDistance = 1.0f;
+    private Vector3 lastPosition;
+
+    // Use this for initialization
+    void Start()
+    {
+
+    }
+
+    private void Smoothen(SpriteShapeController sc, int pointIndex)
+    {
+        Vector3 position = sc.spline.GetPosition(pointIndex);
+        Vector3 positionNext = sc.spline.GetPosition(SplineUtility.NextIndex(pointIndex, sc.spline.GetPointCount()));
+        Vector3 positionPrev = sc.spline.GetPosition(SplineUtility.PreviousIndex(pointIndex, sc.spline.GetPointCount()));
+        Vector3 forward = gameObject.transform.forward;
+
+        float scale = Mathf.Min((positionNext - position).magnitude, (positionPrev - position).magnitude) * 0.33f;
+
+        Vector3 leftTangent = (positionPrev - position).normalized * scale;
+        Vector3 rightTangent = (positionNext - position).normalized * scale;
+
+        sc.spline.SetTangentMode(pointIndex, ShapeTangentMode.Continuous);
+        SplineUtility.CalculateTangents(position, positionPrev, positionNext, forward, scale, out rightTangent, out leftTangent);
+
+        sc.spline.SetLeftTangent(pointIndex, leftTangent);
+        sc.spline.SetRightTangent(pointIndex, rightTangent);
+    }
+
+    // Update is called once per frame
+    void Update()
+    {
+        var mp = Input.mousePosition;
+        mp.z = 10.0f;
+        mp = Camera.main.ScreenToWorldPoint(mp);
+        var dt = Mathf.Abs((mp - lastPosition).magnitude);
+        var md = (minimumDistance > 1.0f) ? minimumDistance : 1.0f;
+        if (Input.GetMouseButton(0) && dt > md)
+        {
+            var spriteShapeController = gameObject.GetComponent<SpriteShapeController>();
+            var spline = spriteShapeController.spline;
+            spline.InsertPointAt(spline.GetPointCount(), mp);
+            var newPointIndex = spline.GetPointCount() - 1;
+            Smoothen(spriteShapeController, newPointIndex - 1);
+
+            spline.SetHeight(newPointIndex, UnityEngine.Random.Range(0.1f, 2.0f));
+            lastPosition = mp;
+        }
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.spriteshape@5.1.1/Samples~/Extras/Scripts/SimpleDraw.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 922bb1bbfeaeb9a4c9204b7d0bc3d8c8
+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.2d.spriteshape@5.1.1/Samples~/Extras/Scripts/Sprinkler.cs

@@ -0,0 +1,53 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.U2D;
+
+public class Sprinkler : MonoBehaviour
+{
+
+    public GameObject m_Prefab;
+    public float m_RandomFactor = 10.0f;
+    public bool m_UseNormals = false;
+
+    float Angle(Vector3 a, Vector3 b)
+    {
+        float dot = Vector3.Dot(a, b);
+        float det = (a.x * b.y) - (b.x * a.y);
+        return Mathf.Atan2(det, dot) * Mathf.Rad2Deg;
+    }
+
+    // Use this for initialization. Plant the Prefabs on Startup
+    void Start ()
+    {
+        SpriteShapeController ssc = GetComponent<SpriteShapeController>();
+        Spline spl = ssc.spline;
+
+        for (int i = 1; i < spl.GetPointCount() - 1; ++i)
+        {
+            if (Random.Range(0, 100) > (100 - m_RandomFactor) )
+            {
+                var go = GameObject.Instantiate(m_Prefab);
+                go.transform.position = spl.GetPosition(i);
+
+                if (m_UseNormals)
+                {
+                    Vector3 lt = Vector3.Normalize(spl.GetPosition(i - 1) - spl.GetPosition(i));
+                    Vector3 rt = Vector3.Normalize(spl.GetPosition(i + 1) - spl.GetPosition(i));
+                    float a = Angle(Vector3.up, lt);
+                    float b = Angle(lt, rt);
+                    float c = a + (b * 0.5f);
+                    if (b > 0)
+                        c = (180 + c);
+                    go.transform.rotation = Quaternion.Euler(0, 0, c);
+                }
+            }
+        }
+	}
+	
+	// Update is called once per frame
+	void Update ()
+    {
+
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.spriteshape@5.1.1/Samples~/Extras/Scripts/Sprinkler.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1c3eb1d33a6f9114bb5b51099948d2ce
+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.2d.spriteshape@5.1.1/Samples~/Extras/Sprite Shape Profiles/Branch.asset

@@ -0,0 +1,48 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: af7181f404f1447c0a7a17b3070b952b, type: 3}
+  m_Name: Branch
+  m_EditorClassIdentifier: 
+  m_Angles:
+  - m_Start: -180
+    m_End: 180
+    m_Order: 0
+    m_Sprites:
+    - {fileID: 21300000, guid: e205c552afc6743cb9c52e5ff6504efc, type: 3}
+  m_FillTexture: {fileID: 0}
+  m_CornerSprites:
+  - m_CornerType: 0
+    m_Sprites:
+    - {fileID: 0}
+  - m_CornerType: 1
+    m_Sprites:
+    - {fileID: 0}
+  - m_CornerType: 2
+    m_Sprites:
+    - {fileID: 0}
+  - m_CornerType: 3
+    m_Sprites:
+    - {fileID: 0}
+  - m_CornerType: 4
+    m_Sprites:
+    - {fileID: 0}
+  - m_CornerType: 5
+    m_Sprites:
+    - {fileID: 0}
+  - m_CornerType: 6
+    m_Sprites:
+    - {fileID: 0}
+  - m_CornerType: 7
+    m_Sprites:
+    - {fileID: 0}
+  m_FillOffset: 0
+  m_UseSpriteBorders: 1

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.spriteshape@5.1.1/Samples~/Extras/Sprite Shape Profiles/Branch.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 67e0d7ab8806749199e5b764729aa46a
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.spriteshape@5.1.1/Samples~/Extras/Sprite Shape Profiles/Castle Wall.asset

@@ -0,0 +1,64 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: af7181f404f1447c0a7a17b3070b952b, type: 3}
+  m_Name: Castle Wall
+  m_EditorClassIdentifier: 
+  m_Angles:
+  - m_Start: -64
+    m_End: 61
+    m_Order: 7
+    m_Sprites:
+    - {fileID: 21300002, guid: 3bc0f8978d0114d568eb440fca26e64b, type: 3}
+    - {fileID: 21300012, guid: a8321f6fae34f034787010a903e29648, type: 3}
+  - m_Start: 61
+    m_End: 127
+    m_Order: 4
+    m_Sprites:
+    - {fileID: 21300014, guid: 3bc0f8978d0114d568eb440fca26e64b, type: 3}
+  - m_Start: 127
+    m_End: 233
+    m_Order: 8
+    m_Sprites:
+    - {fileID: 21300010, guid: 3bc0f8978d0114d568eb440fca26e64b, type: 3}
+  - m_Start: -127
+    m_End: -64
+    m_Order: 3
+    m_Sprites:
+    - {fileID: 21300006, guid: 3bc0f8978d0114d568eb440fca26e64b, type: 3}
+  m_FillTexture: {fileID: 2800000, guid: 7d8cda48c729c46329cd9d3c69a3a4e6, type: 3}
+  m_CornerSprites:
+  - m_CornerType: 0
+    m_Sprites:
+    - {fileID: 21300000, guid: 3bc0f8978d0114d568eb440fca26e64b, type: 3}
+  - m_CornerType: 1
+    m_Sprites:
+    - {fileID: 21300004, guid: 3bc0f8978d0114d568eb440fca26e64b, type: 3}
+  - m_CornerType: 2
+    m_Sprites:
+    - {fileID: 21300012, guid: 3bc0f8978d0114d568eb440fca26e64b, type: 3}
+  - m_CornerType: 3
+    m_Sprites:
+    - {fileID: 21300008, guid: 3bc0f8978d0114d568eb440fca26e64b, type: 3}
+  - m_CornerType: 4
+    m_Sprites:
+    - {fileID: 0}
+  - m_CornerType: 5
+    m_Sprites:
+    - {fileID: 0}
+  - m_CornerType: 6
+    m_Sprites:
+    - {fileID: 21300012, guid: 3bc0f8978d0114d568eb440fca26e64b, type: 3}
+  - m_CornerType: 7
+    m_Sprites:
+    - {fileID: 21300008, guid: 3bc0f8978d0114d568eb440fca26e64b, type: 3}
+  m_FillOffset: 0
+  m_UseSpriteBorders: 1

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.spriteshape@5.1.1/Samples~/Extras/Sprite Shape Profiles/Castle Wall.asset.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: a710fe91ca336478e999261a86254e9f
+timeCreated: 1507533165
+licenseType: Pro
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.spriteshape@5.1.1/Samples~/Extras/Sprite Shape Profiles/Simple1.asset

@@ -0,0 +1,48 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: af7181f404f1447c0a7a17b3070b952b, type: 3}
+  m_Name: Simple1
+  m_EditorClassIdentifier: 
+  m_Angles:
+  - m_Start: -180
+    m_End: 180
+    m_Order: 0
+    m_Sprites:
+    - {fileID: 21300000, guid: e74b518a65bc45f4cace9a2fef6af29d, type: 3}
+  m_FillTexture: {fileID: 0}
+  m_CornerSprites:
+  - m_CornerType: 0
+    m_Sprites:
+    - {fileID: 0}
+  - m_CornerType: 1
+    m_Sprites:
+    - {fileID: 0}
+  - m_CornerType: 2
+    m_Sprites:
+    - {fileID: 0}
+  - m_CornerType: 3
+    m_Sprites:
+    - {fileID: 0}
+  - m_CornerType: 4
+    m_Sprites:
+    - {fileID: 0}
+  - m_CornerType: 5
+    m_Sprites:
+    - {fileID: 0}
+  - m_CornerType: 6
+    m_Sprites:
+    - {fileID: 0}
+  - m_CornerType: 7
+    m_Sprites:
+    - {fileID: 0}
+  m_FillOffset: 0
+  m_UseSpriteBorders: 1

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.spriteshape@5.1.1/Samples~/Extras/Sprite Shape Profiles/Simple1.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 541c57e7ddb8adc46b7ca9573818a619
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.spriteshape@5.1.1/Samples~/Extras/Sprite Shape Profiles/Simple2.asset

@@ -0,0 +1,49 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: af7181f404f1447c0a7a17b3070b952b, type: 3}
+  m_Name: Simple2
+  m_EditorClassIdentifier: 
+  m_Angles:
+  - m_Start: -180
+    m_End: 180
+    m_Order: 0
+    m_Sprites:
+    - {fileID: 21300000, guid: 418ab5c27d3054eb89959d9c715e00c9, type: 3}
+    - {fileID: 21300000, guid: e74b518a65bc45f4cace9a2fef6af29d, type: 3}
+  m_FillTexture: {fileID: 0}
+  m_CornerSprites:
+  - m_CornerType: 0
+    m_Sprites:
+    - {fileID: 0}
+  - m_CornerType: 1
+    m_Sprites:
+    - {fileID: 0}
+  - m_CornerType: 2
+    m_Sprites:
+    - {fileID: 0}
+  - m_CornerType: 3
+    m_Sprites:
+    - {fileID: 0}
+  - m_CornerType: 4
+    m_Sprites:
+    - {fileID: 0}
+  - m_CornerType: 5
+    m_Sprites:
+    - {fileID: 0}
+  - m_CornerType: 6
+    m_Sprites:
+    - {fileID: 0}
+  - m_CornerType: 7
+    m_Sprites:
+    - {fileID: 0}
+  m_FillOffset: 0
+  m_UseSpriteBorders: 1

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.spriteshape@5.1.1/Samples~/Extras/Sprite Shape Profiles/Simple2.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: e03579ec9d1b6c54ea364bd8ee0bcfd8
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.spriteshape@5.1.1/Samples~/Extras/Sprite Shape Profiles/Simple3.asset

@@ -0,0 +1,48 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: af7181f404f1447c0a7a17b3070b952b, type: 3}
+  m_Name: Simple3
+  m_EditorClassIdentifier: 
+  m_Angles:
+  - m_Start: -180
+    m_End: 180
+    m_Order: 0
+    m_Sprites:
+    - {fileID: 21300000, guid: c6dabd295b8ab514fa47b5d4e2b0266e, type: 3}
+  m_FillTexture: {fileID: 0}
+  m_CornerSprites:
+  - m_CornerType: 0
+    m_Sprites:
+    - {fileID: 0}
+  - m_CornerType: 1
+    m_Sprites:
+    - {fileID: 0}
+  - m_CornerType: 2
+    m_Sprites:
+    - {fileID: 0}
+  - m_CornerType: 3
+    m_Sprites:
+    - {fileID: 0}
+  - m_CornerType: 4
+    m_Sprites:
+    - {fileID: 0}
+  - m_CornerType: 5
+    m_Sprites:
+    - {fileID: 0}
+  - m_CornerType: 6
+    m_Sprites:
+    - {fileID: 0}
+  - m_CornerType: 7
+    m_Sprites:
+    - {fileID: 0}
+  m_FillOffset: 0
+  m_UseSpriteBorders: 1

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.spriteshape@5.1.1/Samples~/Extras/Sprite Shape Profiles/Simple3.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 19b9cf308de41834c9968d12bec673b1
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.spriteshape@5.1.1/Samples~/Extras/Sprite Shape Profiles/Tree A.asset

@@ -0,0 +1,43 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: af7181f404f1447c0a7a17b3070b952b, type: 3}
+  m_Name: Tree A
+  m_EditorClassIdentifier: 
+  m_Angles: []
+  m_FillTexture: {fileID: 2800000, guid: a94adaf94669646788de8f639270804a, type: 3}
+  m_CornerSprites:
+  - m_CornerType: 0
+    m_Sprites:
+    - {fileID: 0}
+  - m_CornerType: 1
+    m_Sprites:
+    - {fileID: 0}
+  - m_CornerType: 2
+    m_Sprites:
+    - {fileID: 0}
+  - m_CornerType: 3
+    m_Sprites:
+    - {fileID: 0}
+  - m_CornerType: 4
+    m_Sprites:
+    - {fileID: 0}
+  - m_CornerType: 5
+    m_Sprites:
+    - {fileID: 0}
+  - m_CornerType: 6
+    m_Sprites:
+    - {fileID: 0}
+  - m_CornerType: 7
+    m_Sprites:
+    - {fileID: 0}
+  m_FillOffset: 0
+  m_UseSpriteBorders: 1