Add files using upload-large-folder tool

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/Trim/ITrimItemMode.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b4a5ce78107bc38409a3bb5e8b3289ac
+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.timeline@1.4.6/Editor/Manipulators/Trim/TrimItemModeMix.cs

@@ -0,0 +1,102 @@
+using System;
+using System.Linq;
+using UnityEngine;
+using UnityEngine.Timeline;
+
+namespace UnityEditor.Timeline
+{
+    class TrimItemModeMix : ITrimItemMode, ITrimItemDrawer
+    {
+        ITrimmable m_Item;
+
+        double m_Min;
+        double m_Max;
+
+        public void OnBeforeTrim(ITrimmable item, TrimEdge trimDirection)
+        {
+            m_Item = item;
+
+            var sortedItems = ItemsUtils.GetItemsExcept(item.parentTrack, new[] {item})
+                .OfType<ITrimmable>()
+                .OrderBy(c => c.start);
+
+            var itemStart = (DiscreteTime)item.start;
+            var itemEnd = (DiscreteTime)item.end;
+
+            var overlapped = sortedItems.LastOrDefault(c => (DiscreteTime)c.start == itemStart && (DiscreteTime)c.end == itemEnd);
+
+            ITrimmable nextItem;
+            ITrimmable prevItem;
+
+            m_Min = 0.0;
+            m_Max = double.PositiveInfinity;
+
+            var blendableItem = item as IBlendable;
+            if (blendableItem != null && blendableItem.supportsBlending)
+            {
+                if (trimDirection == TrimEdge.Start)
+                {
+                    nextItem = sortedItems.FirstOrDefault(c => (DiscreteTime)c.start >= itemStart && (DiscreteTime)c.end > itemEnd);
+                    prevItem = sortedItems.LastOrDefault(c => (DiscreteTime)c.start <= itemStart && (DiscreteTime)c.end < itemEnd);
+
+                    if (prevItem != null)
+                        m_Min = prevItem.start + EditModeUtils.BlendDuration(prevItem, TrimEdge.Start);
+
+                    if (nextItem != null)
+                        m_Max = nextItem.start;
+                }
+                else
+                {
+                    nextItem = sortedItems.FirstOrDefault(c => c != overlapped && (DiscreteTime)c.start >= itemStart && (DiscreteTime)c.end >= itemEnd);
+                    prevItem = sortedItems.LastOrDefault(c => c != overlapped && (DiscreteTime)c.start <= itemStart && (DiscreteTime)c.end <= itemEnd);
+
+                    if (prevItem != null)
+                        m_Min = prevItem.end;
+
+                    if (nextItem != null)
+                        m_Max = nextItem.end - EditModeUtils.BlendDuration(nextItem, TrimEdge.End);
+                }
+            }
+            else
+            {
+                nextItem = sortedItems.FirstOrDefault(c => (DiscreteTime)c.start > itemStart);
+                prevItem = sortedItems.LastOrDefault(c => (DiscreteTime)c.start < itemStart);
+
+                if (prevItem != null)
+                    m_Min = prevItem.end;
+
+                if (nextItem != null)
+                    m_Max = nextItem.start;
+            }
+        }
+
+        public void TrimStart(ITrimmable item, double time, bool affectTimeScale)
+        {
+            time = Math.Min(Math.Max(time, m_Min), m_Max);
+            item.SetStart(time, affectTimeScale);
+        }
+
+        public void TrimEnd(ITrimmable item, double time, bool affectTimeScale)
+        {
+            time = Math.Min(Math.Max(time, m_Min), m_Max);
+            item.SetEnd(time, affectTimeScale);
+        }
+
+        public void DrawGUI(WindowState state, Rect bounds, Color color, TrimEdge edge)
+        {
+            if (EditModeUtils.HasBlends(m_Item, edge))
+            {
+                EditModeGUIUtils.DrawBoundsEdge(bounds, color, edge);
+                var cursorType = (edge == TrimEdge.End)
+                    ? TimelineCursors.CursorType.MixRight
+                    : TimelineCursors.CursorType.MixLeft;
+
+                TimelineCursors.SetCursor(cursorType);
+            }
+            else
+            {
+                TimelineCursors.ClearCursor();
+            }
+        }
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/Trim/TrimItemModeMix.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5ddd9f7d3cce6724696a33752ab2f5a4
+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.timeline@1.4.6/Editor/Manipulators/Trim/TrimItemModeReplace.cs

@@ -0,0 +1,139 @@
+using System;
+using System.Linq;
+using UnityEngine;
+using UnityEngine.Timeline;
+
+namespace UnityEditor.Timeline
+{
+    class TrimItemModeReplace : ITrimItemMode, ITrimItemDrawer
+    {
+        ITrimmable m_Item;
+
+        ITrimmable m_ItemToBeReplaced;
+        double m_ClipOriginalEdgeValue;
+        bool m_TrimReplace;
+
+        double m_Min;
+        double m_Max;
+
+        public void OnBeforeTrim(ITrimmable item, TrimEdge trimDirection)
+        {
+            m_Item = item;
+
+            var sortedClips = ItemsUtils.GetItemsExcept(item.parentTrack, new[] { item })
+                .OfType<ITrimmable>()
+                .OrderBy(c => c.start);
+
+            var clipStart = (DiscreteTime)item.start;
+            var clipEnd = (DiscreteTime)item.end;
+
+            var overlapped = sortedClips.LastOrDefault(c => (DiscreteTime)c.start == clipStart && (DiscreteTime)c.end == clipEnd);
+
+            ITrimmable nextItem;
+            ITrimmable prevItem;
+
+            m_Min = 0.0;
+            m_Max = double.PositiveInfinity;
+
+            if (trimDirection == TrimEdge.Start)
+            {
+                nextItem = sortedClips.FirstOrDefault(c => (DiscreteTime)c.start >= clipStart && (DiscreteTime)c.end > clipEnd);
+                prevItem = sortedClips.LastOrDefault(c => (DiscreteTime)c.start <= clipStart && (DiscreteTime)c.end < clipEnd);
+
+                if (prevItem != null)
+                    m_Min = prevItem.start + EditModeUtils.BlendDuration(prevItem, TrimEdge.Start) + TimelineClip.kMinDuration;
+
+                if (nextItem != null)
+                    m_Max = nextItem.start;
+
+                m_ItemToBeReplaced = prevItem;
+
+                if (m_ItemToBeReplaced != null)
+                    m_ClipOriginalEdgeValue = m_ItemToBeReplaced.end;
+            }
+            else
+            {
+                nextItem = sortedClips.FirstOrDefault(c => c != overlapped && (DiscreteTime)c.start >= clipStart && (DiscreteTime)c.end >= clipEnd);
+                prevItem = sortedClips.LastOrDefault(c => c != overlapped && (DiscreteTime)c.start <= clipStart && (DiscreteTime)c.end <= clipEnd);
+
+                if (prevItem != null)
+                    m_Min = prevItem.end;
+
+                if (nextItem != null)
+                    m_Max = nextItem.end - EditModeUtils.BlendDuration(nextItem, TrimEdge.End) - TimelineClip.kMinDuration;
+
+                m_ItemToBeReplaced = nextItem;
+
+                if (m_ItemToBeReplaced != null)
+                    m_ClipOriginalEdgeValue = m_ItemToBeReplaced.start;
+            }
+
+            m_TrimReplace = false;
+        }
+
+        public void TrimStart(ITrimmable item, double time, bool affectTimeScale)
+        {
+            time = Math.Min(Math.Max(time, m_Min), m_Max);
+
+            if (m_ItemToBeReplaced != null)
+            {
+                if (!m_TrimReplace)
+                    m_TrimReplace = item.start >= m_ItemToBeReplaced.end;
+            }
+
+            time = Math.Max(time, 0.0);
+
+            item.SetStart(time, affectTimeScale);
+
+            if (m_ItemToBeReplaced != null && m_TrimReplace)
+            {
+                var prevEnd = Math.Min(item.start, m_ClipOriginalEdgeValue);
+                m_ItemToBeReplaced.SetEnd(prevEnd, false);
+            }
+        }
+
+        public void TrimEnd(ITrimmable item, double time, bool affectTimeScale)
+        {
+            time = Math.Min(Math.Max(time, m_Min), m_Max);
+
+            if (m_ItemToBeReplaced != null)
+            {
+                if (!m_TrimReplace)
+                    m_TrimReplace = item.end <= m_ItemToBeReplaced.start;
+            }
+
+            item.SetEnd(time, affectTimeScale);
+
+            if (m_ItemToBeReplaced != null && m_TrimReplace)
+            {
+                var nextStart = Math.Max(item.end, m_ClipOriginalEdgeValue);
+                m_ItemToBeReplaced.SetStart(nextStart, false);
+            }
+        }
+
+        public void DrawGUI(WindowState state, Rect bounds, Color color, TrimEdge edge)
+        {
+            bool shouldDraw = m_ItemToBeReplaced != null && (edge == TrimEdge.End && m_Item.end > m_ClipOriginalEdgeValue) ||
+                (edge == TrimEdge.Start && m_Item.start < m_ClipOriginalEdgeValue);
+
+            if (shouldDraw)
+            {
+                var cursorType = TimelineCursors.CursorType.Replace;
+                if (EditModeUtils.HasBlends(m_Item, edge))
+                {
+                    color = DirectorStyles.kMixToolColor;
+                    cursorType = (edge == TrimEdge.End)
+                        ? TimelineCursors.CursorType.MixRight
+                        : TimelineCursors.CursorType.MixLeft;
+                }
+
+                EditModeGUIUtils.DrawBoundsEdge(bounds, color, edge);
+                TimelineCursors.SetCursor(cursorType);
+            }
+            else
+            {
+                TimelineCursors.ClearCursor();
+            }
+        }
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/Trim/TrimItemModeReplace.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 769f6f5dd7c8f2d4c9ab1caba0bd2628
+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.timeline@1.4.6/Editor/Manipulators/Trim/TrimItemModeRipple.cs

@@ -0,0 +1,97 @@
+using System;
+using System.Linq;
+using UnityEngine;
+using UnityEngine.Timeline;
+
+namespace UnityEditor.Timeline
+{
+    class TrimItemModeRipple : ITrimItemMode, ITrimItemDrawer
+    {
+        double m_OriginalClipStart;
+        double m_OriginalClipEnd;
+
+        ITrimmable[] m_NextItems;
+
+        double m_BlendDuration;
+
+        double m_TrimStartShift;
+
+        public void OnBeforeTrim(ITrimmable item, TrimEdge trimDirection)
+        {
+            m_OriginalClipStart = item.start;
+            m_OriginalClipEnd = item.end;
+            m_TrimStartShift = 0.0;
+
+            var sortedClips = ItemsUtils.GetItemsExcept(item.parentTrack, new[] { item })
+                .OfType<ITrimmable>()
+                .OrderBy(c => c.start);
+
+            var clipStart = (DiscreteTime)item.start;
+            var clipEnd = (DiscreteTime)item.end;
+
+            m_NextItems = sortedClips.Where(c => (DiscreteTime)c.start >= clipStart && (DiscreteTime)c.end >= clipEnd).ToArray();
+
+            var overlapped = sortedClips.LastOrDefault(c => (DiscreteTime)c.start == clipStart && (DiscreteTime)c.end == clipEnd);
+
+            if (overlapped != null)
+            {
+                m_BlendDuration = overlapped.end - overlapped.start;
+            }
+            else
+            {
+                m_BlendDuration = 0.0;
+
+                var prevClip = sortedClips.LastOrDefault(c => (DiscreteTime)c.start <= clipStart && (DiscreteTime)c.end <= clipEnd);
+                if (prevClip != null)
+                    m_BlendDuration += Math.Max(prevClip.end - item.start, 0.0);
+
+                var nextClip = sortedClips.FirstOrDefault(c => (DiscreteTime)c.start >= clipStart && (DiscreteTime)c.end >= clipEnd);
+                if (nextClip != null)
+                    m_BlendDuration += Math.Max(item.end - nextClip.start, 0.0);
+            }
+        }
+
+        public void TrimStart(ITrimmable item, double time, bool affectTimeScale)
+        {
+            var prevEnd = item.end;
+
+            // HACK If time is negative, make sure we shift the SetStart operation to a positive space.
+            if (time < 0.0)
+                m_TrimStartShift = Math.Max(-time, m_TrimStartShift);
+
+            item.start = m_OriginalClipEnd - item.duration + m_TrimStartShift;
+            time += m_TrimStartShift;
+
+            if (m_BlendDuration > 0.0)
+                time = Math.Min(time, item.end - m_BlendDuration);
+
+            item.SetStart(time, affectTimeScale);
+
+            item.start = m_OriginalClipStart;
+
+            var offset = item.end - prevEnd;
+            foreach (var timelineClip in m_NextItems)
+                timelineClip.start += offset;
+        }
+
+        public void TrimEnd(ITrimmable item, double time, bool affectTimeScale)
+        {
+            var prevEnd = item.end;
+
+            if (m_BlendDuration > 0.0)
+                time = Math.Max(time, item.start + m_BlendDuration);
+
+            item.SetEnd(time, affectTimeScale);
+
+            var offset = item.end - prevEnd;
+            foreach (var timelineClip in m_NextItems)
+                timelineClip.start += offset;
+        }
+
+        public void DrawGUI(WindowState state, Rect bounds, Color color, TrimEdge edge)
+        {
+            EditModeGUIUtils.DrawBoundsEdge(bounds, color, edge);
+            TimelineCursors.SetCursor(TimelineCursors.CursorType.Ripple);
+        }
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/Trim/TrimItemModeRipple.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 20c8bb6b47a526c4c96ca73314fe2856
+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.timeline@1.4.6/Editor/Manipulators/Utils/EditModeGUIUtils.cs

@@ -0,0 +1,27 @@
+using UnityEngine;
+
+namespace UnityEditor.Timeline
+{
+    static class EditModeGUIUtils
+    {
+        public static void DrawBoundsEdge(Rect bounds, Color color, TrimEdge edge, float width = 4.0f)
+        {
+            var r = bounds;
+            r.yMin += 2.0f;
+            r.yMax -= 2.0f;
+            r.width = width;
+
+            r.x = edge == TrimEdge.End ? bounds.xMax : bounds.xMin - width;
+
+            EditorGUI.DrawRect(r, color);
+        }
+
+        public static void DrawOverlayRect(Rect bounds, Color overlayColor)
+        {
+            var c = overlayColor;
+            c.a = 0.2f;
+            EditorGUI.DrawRect(bounds, c);
+            EditorGUI.DrawOutline(bounds, 1.0f, new Color(1.0f, 1.0f, 1.0f, 0.5f));
+        }
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/Utils/EditModeGUIUtils.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8938e753b3f47374889d5cf3265b563c
+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.timeline@1.4.6/Editor/Manipulators/Utils/EditModeMixUtils.cs

@@ -0,0 +1,138 @@
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine.Timeline;
+
+namespace UnityEditor.Timeline
+{
+    static class EditModeMixUtils
+    {
+        static readonly List<PlacementValidity> k_UnrecoverablePlacements = new List<PlacementValidity>
+        {
+            PlacementValidity.InvalidIsWithin,
+            PlacementValidity.InvalidStartsInBlend,
+            PlacementValidity.InvalidContainsBlend,
+            PlacementValidity.InvalidOverlapWithNonBlendableClip
+        };
+
+        public static bool CanInsert(IEnumerable<ItemsPerTrack> itemsGroups)
+        {
+            foreach (var itemsGroup in itemsGroups)
+            {
+                List<ITimelineItem> siblings = ItemsUtils.GetItemsExcept(itemsGroup.targetTrack, itemsGroup.items).ToList();
+                foreach (var item in itemsGroup.items)
+                {
+                    var placementValidity = GetPlacementValidity(item, siblings);
+
+                    if (k_UnrecoverablePlacements.Contains(placementValidity))
+                    {
+                        return false;
+                    }
+                }
+            }
+
+            return true;
+        }
+
+        //Corrects clips durations to fit at insertion point, if needed
+        public static void PrepareItemsForInsertion(IEnumerable<ItemsPerTrack> itemsGroups)
+        {
+            foreach (var itemsGroup in itemsGroups)
+            {
+                var siblings = ItemsUtils.GetItemsExcept(itemsGroup.targetTrack, itemsGroup.items);
+                foreach (var item in itemsGroup.items.OfType<ITrimmable>())
+                {
+                    var eatenItems = siblings.Where(c => EditModeUtils.IsItemWithinRange(c, item.start, item.end)).ToList();
+
+                    var intersectedItem = EditModeUtils.GetFirstIntersectedItem(siblings, item.end);
+                    if (intersectedItem != null)
+                        eatenItems.Add(intersectedItem);
+
+                    var blendableItems = eatenItems.OfType<IBlendable>();
+                    if (blendableItems.Any())
+                    {
+                        var minTime = blendableItems.Min(c => c.end - c.rightBlendDuration);
+
+                        if (item.end > minTime)
+                            item.SetEnd(minTime, false);
+                    }
+                }
+            }
+        }
+
+        public static PlacementValidity GetPlacementValidity(ITimelineItem item, IEnumerable<ITimelineItem> otherItems)
+        {
+            if (item.duration <= 0.0)
+                return PlacementValidity.Valid;  //items without any duration can always be placed
+
+            var sortedItems = otherItems.Where(i => i.duration > 0.0).OrderBy(c => c.start);
+            var candidates = new List<ITimelineItem>();
+            foreach (var sortedItem in sortedItems)
+            {
+                if ((DiscreteTime)sortedItem.start >= (DiscreteTime)item.end)
+                {
+                    // No need to process further
+                    break;
+                }
+
+                if ((DiscreteTime)sortedItem.end <= (DiscreteTime)item.start)
+                {
+                    // Skip
+                    continue;
+                }
+
+                candidates.Add(sortedItem);
+            }
+
+            var discreteStart = (DiscreteTime)item.start;
+            var discreteEnd = (DiscreteTime)item.end;
+
+            // Note: Order of tests matters
+            for (int i = 0, n = candidates.Count; i < n; i++)
+            {
+                var candidate = candidates[i];
+
+                var blendItem = item as IBlendable;
+                if (blendItem != null && blendItem.supportsBlending)
+                {
+                    if (EditModeUtils.Contains(candidate.start, candidate.end, item))
+                        return PlacementValidity.InvalidIsWithin;
+
+                    if (i < n - 1)
+                    {
+                        var nextCandidate = candidates[i + 1];
+
+                        var discreteNextCandidateStart = (DiscreteTime)nextCandidate.start;
+                        var discreteCandidateEnd = (DiscreteTime)candidate.end;
+
+                        if (discreteCandidateEnd > discreteNextCandidateStart)
+                        {
+                            if (discreteStart >= discreteNextCandidateStart)
+                            {
+                                // Note: In case the placement is fully within a blend,
+                                // InvalidStartsInBlend MUST have priority
+                                return PlacementValidity.InvalidStartsInBlend;
+                            }
+
+                            if (discreteEnd > discreteNextCandidateStart && discreteEnd <= discreteCandidateEnd)
+                                return PlacementValidity.InvalidEndsInBlend;
+
+                            if (discreteStart < discreteNextCandidateStart && discreteEnd > discreteCandidateEnd)
+                                return PlacementValidity.InvalidContainsBlend;
+                        }
+                    }
+
+                    if (EditModeUtils.Contains(item.start, item.end, candidate))
+                        return PlacementValidity.InvalidContains;
+                }
+                else
+                {
+                    if (EditModeUtils.Overlaps(item, candidate.start, candidate.end)
+                        || EditModeUtils.Overlaps(candidate, item.start, item.end))
+                        return PlacementValidity.InvalidOverlapWithNonBlendableClip;
+                }
+            }
+
+            return PlacementValidity.Valid;
+        }
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/Utils/EditModeMixUtils.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 505965fb9ab352b4d88882d7c8d822bf
+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.timeline@1.4.6/Editor/Manipulators/Utils/EditModeReplaceUtils.cs

@@ -0,0 +1,57 @@
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine.Timeline;
+
+namespace UnityEditor.Timeline
+{
+    static class EditModeReplaceUtils
+    {
+        public static void Insert(IEnumerable<ItemsPerTrack> itemsGroups)
+        {
+            foreach (var itemsGroup in itemsGroups)
+            {
+                Insert(itemsGroup.targetTrack, itemsGroup.items);
+            }
+        }
+
+        static void Insert(TrackAsset track, IEnumerable<ITimelineItem> items)
+        {
+            if (track == null) return;
+            var orderedItems = ItemsUtils.GetItemsExcept(track, items)
+                .OfType<ITrimmable>()
+                .OrderBy(i => i.start).ToArray();
+
+            foreach (var item in items.OfType<ITrimmable>())
+            {
+                var from = item.start;
+                var to = item.end;
+
+                var overlappedItems = orderedItems.Where(i => EditModeUtils.Overlaps(i, from, to));
+
+                foreach (var overlappedItem in overlappedItems)
+                {
+                    if (EditModeUtils.IsItemWithinRange(overlappedItem, from, to))
+                    {
+                        overlappedItem.Delete();
+                    }
+                    else
+                    {
+                        if (overlappedItem.start >= from)
+                            overlappedItem.TrimStart(to);
+                        else
+                            overlappedItem.TrimEnd(from);
+                    }
+                }
+
+                var includingItems = orderedItems.Where(c => c.start<from && c.end> to);
+                foreach (var includingItem in includingItems)
+                {
+                    var newItem = includingItem.CloneTo(track, includingItem.start) as ITrimmable;
+                    includingItem.TrimStart(to);
+                    if (newItem != null)
+                        newItem.SetEnd(from, false);
+                }
+            }
+        }
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/Utils/EditModeReplaceUtils.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6ca745fb561cbf640b6e603f95662fa0
+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.timeline@1.4.6/Editor/Manipulators/Utils/EditModeRippleUtils.cs

@@ -0,0 +1,108 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine.Timeline;
+
+namespace UnityEditor.Timeline
+{
+    static class EditModeRippleUtils
+    {
+        public static void Insert(IEnumerable<ItemsPerTrack> itemsGroups)
+        {
+            var start = double.MaxValue;
+            var end = double.MinValue;
+
+            foreach (var itemsGroup in itemsGroups)
+            {
+                start = Math.Min(start, itemsGroup.items.Min(c => c.start));
+                end = Math.Max(end, itemsGroup.items.Max(c => c.end));
+            }
+
+            var offset = 0.0;
+            var discreteStart = (DiscreteTime)start;
+            var discreteEnd = (DiscreteTime)end;
+            var itemTypes = ItemsUtils.GetItemTypes(itemsGroups);
+            var siblingsToRipple = new List<ITimelineItem>();
+
+            foreach (var itemsGroup in itemsGroups)
+            {
+                //can only ripple items of the same type as those selected
+                siblingsToRipple.AddRange(ItemsUtils.GetItemsExcept(itemsGroup.targetTrack, itemsGroup.items).Where(i => itemTypes.Contains(i.GetType())));
+                foreach (var item in siblingsToRipple)
+                {
+                    var discreteItemStart = (DiscreteTime)item.start;
+                    var discreteItemEnd = (DiscreteTime)item.end;
+
+                    if ((discreteItemStart < discreteStart && discreteItemEnd > discreteStart) || (discreteItemStart >= discreteStart && discreteItemStart < discreteEnd))
+                        offset = Math.Max(offset, end - item.start);
+                }
+            }
+
+            if (offset > 0.0)
+            {
+                foreach (var sibling in siblingsToRipple)
+                {
+                    if ((DiscreteTime)sibling.end > (DiscreteTime)start)
+                        sibling.start += offset;
+                }
+            }
+        }
+
+        public static void Remove(IEnumerable<ItemsPerTrack> itemsGroups)
+        {
+            foreach (var itemsGroup in itemsGroups)
+                Remove(itemsGroup.targetTrack, itemsGroup.items);
+        }
+
+        static void Remove(TrackAsset track, IEnumerable<ITimelineItem> items)
+        {
+            if (track == null) return;
+
+            //can only ripple items of the same type as those selected
+            var itemTypes = ItemsUtils.GetItemTypes(items);
+            var siblingsToRipple = ItemsUtils.GetItemsExcept(track, items)
+                .Where(i => itemTypes.Contains(i.GetType()))
+                .OrderBy(c => c.start)
+                .ToArray();
+
+            var orderedItems = items
+                .OrderBy(c => c.start)
+                .ToArray();
+
+            var cumulativeOffset = 0.0;
+
+            foreach (var item in orderedItems)
+            {
+                var offset = item.end - item.start;
+                var start = item.start - cumulativeOffset;
+                var end = item.end - cumulativeOffset;
+
+                var nextItem = siblingsToRipple.FirstOrDefault(c => (DiscreteTime)c.start > (DiscreteTime)start && (DiscreteTime)c.start < (DiscreteTime)end);
+                if (nextItem != null)
+                {
+                    offset -= end - nextItem.start;
+                }
+
+                var prevItem = siblingsToRipple.FirstOrDefault(c => (DiscreteTime)c.end > (DiscreteTime)start && (DiscreteTime)c.end < (DiscreteTime)end);
+                if (prevItem != null)
+                {
+                    offset -= prevItem.end - start;
+                }
+
+                if (offset <= 0.0)
+                    continue;
+
+                cumulativeOffset += offset;
+
+                for (int i = siblingsToRipple.Length - 1; i >= 0; --i)
+                {
+                    var c = siblingsToRipple[i];
+                    if ((DiscreteTime)c.start < (DiscreteTime)start)
+                        break;
+
+                    c.start = c.start - offset;
+                }
+            }
+        }
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/Utils/EditModeRippleUtils.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 495e2738ac7d88a41a158cd2e237d70b
+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.timeline@1.4.6/Editor/Manipulators/Utils/EditModeUtils.cs

@@ -0,0 +1,123 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine.Timeline;
+
+namespace UnityEditor.Timeline
+{
+    static class EditModeUtils
+    {
+        public static void Delete(IEnumerable<ITimelineItem> items)
+        {
+            if (items == null)
+                return;
+
+            foreach (var item in items)
+                item.Delete();
+        }
+
+        public static void SetStart(IEnumerable<ITimelineItem> items, double time)
+        {
+            var offset = time - items.Min(c => c.start);
+
+            foreach (var item in items)
+                item.start += offset;
+        }
+
+        public static void SetParentTrack(IEnumerable<ITimelineItem> items, TrackAsset parentTrack)
+        {
+            foreach (var item in items)
+            {
+                if (item.parentTrack == parentTrack)
+                    continue;
+
+                item.parentTrack = parentTrack;
+
+                var clipGUI = item.gui as TimelineClipGUI;
+                if (clipGUI != null)
+                {
+                    clipGUI.clipCurveEditor = null;
+                }
+            }
+        }
+
+        public static ITimelineItem GetFirstIntersectedItem(IEnumerable<ITimelineItem> items, double time)
+        {
+            return items.FirstOrDefault(c => Intersects(time, c.start, c.end));
+        }
+
+        static bool Intersects(double time, double start, double end)
+        {
+            var discreteTime = (DiscreteTime)time;
+            return discreteTime > (DiscreteTime)start && discreteTime < (DiscreteTime)end;
+        }
+
+        public static bool Overlaps(ITimelineItem item, double from, double to)
+        {
+            var discreteFrom = (DiscreteTime)from;
+            var discreteTo = (DiscreteTime)to;
+            var discreteStart = (DiscreteTime)item.start;
+
+            if (discreteStart >= discreteFrom && discreteStart < discreteTo)
+                return true;
+
+            var discreteEnd = (DiscreteTime)item.end;
+
+            if (discreteEnd > discreteFrom && discreteEnd <= discreteTo)
+                return true;
+
+            return false;
+        }
+
+        public static bool IsItemWithinRange(ITimelineItem item, double from, double to)
+        {
+            return (DiscreteTime)item.start >= (DiscreteTime)from && (DiscreteTime)item.end <= (DiscreteTime)to;
+        }
+
+        public static bool IsRangeWithinItem(double from, double to, ITimelineItem item)
+        {
+            return (DiscreteTime)from >= (DiscreteTime)item.start && (DiscreteTime)to <= (DiscreteTime)item.end;
+        }
+
+        public static bool Contains(double from, double to, ITimelineItem item)
+        {
+            return (DiscreteTime)from < (DiscreteTime)item.start && (DiscreteTime)to > (DiscreteTime)item.end;
+        }
+
+        public static bool HasBlends(ITimelineItem item, TrimEdge edge)
+        {
+            var blendable = item as IBlendable;
+            if (blendable == null) return false;
+
+            return edge == TrimEdge.Start && blendable.hasLeftBlend || edge == TrimEdge.End && blendable.hasRightBlend;
+        }
+
+        public static double BlendDuration(ITimelineItem item, TrimEdge edge)
+        {
+            var blendable = item as IBlendable;
+            if (blendable == null) return 0.0;
+
+            return edge == TrimEdge.Start ? blendable.leftBlendDuration : blendable.rightBlendDuration;
+        }
+
+        public static bool IsInfiniteTrack(TrackAsset track)
+        {
+            var aTrack = track as AnimationTrack;
+            return aTrack != null && aTrack.CanConvertToClipMode();
+        }
+
+        public static void GetInfiniteClipBoundaries(TrackAsset track, out double start, out double end)
+        {
+            var info = AnimationClipCurveCache.Instance.GetCurveInfo(((AnimationTrack)track).infiniteClip);
+            if (info.keyTimes.Length > 0)
+            {
+                start = info.keyTimes.Min();
+                end = info.keyTimes.Max();
+            }
+            else
+            {
+                start = end = 0.0f;
+            }
+        }
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/Utils/EditModeUtils.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 70eae1897c9d308448eb3bb0b5be9f58
+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.timeline@1.4.6/Editor/Manipulators/Utils/ManipulatorsUtils.cs

@@ -0,0 +1,19 @@
+using UnityEngine;
+
+namespace UnityEditor.Timeline
+{
+    static class ManipulatorsUtils
+    {
+        public static EventModifiers actionModifier
+        {
+            get
+            {
+                if (Application.platform == RuntimePlatform.OSXEditor ||
+                    Application.platform == RuntimePlatform.OSXPlayer)
+                    return EventModifiers.Command;
+
+                return EventModifiers.Control;
+            }
+        }
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.timeline@1.4.6/Editor/Manipulators/Utils/ManipulatorsUtils.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e177382a693dea644acd34e3e7a3feb3
+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.timeline@1.4.6/Editor/Manipulators/Utils/PlacementValidity.cs

@@ -0,0 +1,13 @@
+namespace UnityEditor.Timeline
+{
+    enum PlacementValidity
+    {
+        Valid,
+        InvalidContains,
+        InvalidIsWithin,
+        InvalidStartsInBlend,
+        InvalidEndsInBlend,
+        InvalidContainsBlend,
+        InvalidOverlapWithNonBlendableClip
+    }
+}