Add files using upload-large-folder tool

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Runtime/Triangle/Log.cs

@@ -0,0 +1,84 @@
+// -----------------------------------------------------------------------
+// <copyright file="Log.cs" company="">
+// Triangle.NET code by Christian Woltering, http://triangle.codeplex.com/
+// </copyright>
+// -----------------------------------------------------------------------
+
+namespace UnityEngine.U2D.Animation.TriangleNet
+{
+    using System.Collections.Generic;
+    using Animation.TriangleNet.Logging;
+
+    /// <summary>
+    /// A simple logger, which logs messages to a List.
+    /// </summary>
+    /// <remarks>Using singleton pattern as proposed by Jon Skeet.
+    /// http://csharpindepth.com/Articles/General/Singleton.aspx
+    /// </remarks>
+    internal sealed class Log : ILog<LogItem>
+    {
+        /// <summary>
+        /// Log detailed information.
+        /// </summary>
+        internal static bool Verbose { get; set; }
+
+        private List<LogItem> log = new List<LogItem>();
+
+        private LogLevel level = LogLevel.Info;
+
+        #region Singleton pattern
+
+        private static readonly Log instance = new Log();
+
+        // Explicit static constructor to tell C# compiler
+        // not to mark type as beforefieldinit
+        static Log() {}
+
+        private Log() {}
+
+        internal static ILog<LogItem> Instance
+        {
+            get
+            {
+                return instance;
+            }
+        }
+
+        #endregion
+
+        public void Add(LogItem item)
+        {
+            log.Add(item);
+        }
+
+        public void Clear()
+        {
+            log.Clear();
+        }
+
+        public void Info(string message)
+        {
+            log.Add(new LogItem(LogLevel.Info, message));
+        }
+
+        public void Warning(string message, string location)
+        {
+            log.Add(new LogItem(LogLevel.Warning, message, location));
+        }
+
+        public void Error(string message, string location)
+        {
+            log.Add(new LogItem(LogLevel.Error, message, location));
+        }
+
+        public IList<LogItem> Data
+        {
+            get { return log; }
+        }
+
+        public LogLevel Level
+        {
+            get { return level; }
+        }
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Runtime/Triangle/Log.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 196e2f3da40aa4a94a0a42a5e8fe60b9
+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.animation@5.0.4/Runtime/Triangle/Logging.meta

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

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Runtime/Triangle/Mesh.cs

@@ -0,0 +1,1768 @@
+// -----------------------------------------------------------------------
+// <copyright file="Mesh.cs">
+// Original Triangle code by Jonathan Richard Shewchuk, http://www.cs.cmu.edu/~quake/triangle.html
+// Triangle.NET code by Christian Woltering, http://triangle.codeplex.com/
+// </copyright>
+// -----------------------------------------------------------------------
+
+namespace UnityEngine.U2D.Animation.TriangleNet
+{
+    using System;
+    using System.Collections.Generic;
+    using Animation.TriangleNet.Geometry;
+    using Animation.TriangleNet.Logging;
+    using Animation.TriangleNet.Meshing;
+    using Animation.TriangleNet.Meshing.Data;
+    using Animation.TriangleNet.Meshing.Iterators;
+    using Animation.TriangleNet.Tools;
+    using Animation.TriangleNet.Topology;
+
+    /// <summary>
+    /// Mesh data structure.
+    /// </summary>
+    internal class Mesh : IMesh
+    {
+        #region Variables
+
+        IPredicates predicates;
+
+        ILog<LogItem> logger;
+
+        QualityMesher qualityMesher;
+
+        // Stack that maintains a list of recently flipped triangles.
+        Stack<Otri> flipstack;
+
+        // TODO: Check if custom hashmap implementation could be faster.
+
+        // Using hashsets for memory management should quite fast.
+        internal TrianglePool triangles;
+        internal Dictionary<int, SubSegment> subsegs;
+        internal Dictionary<int, Vertex> vertices;
+
+        // Hash seeds (should belong to mesh instance)
+        internal int hash_vtx = 0;
+        internal int hash_seg = 0;
+        internal int hash_tri = 0;
+
+        internal List<Point> holes;
+        internal List<RegionPointer> regions;
+
+        // TODO: remove mesh_dim, invertices and insegments
+
+        // Other variables.
+        internal Rectangle bounds; // x and y bounds.
+        internal int invertices;     // Number of input vertices.
+        internal int insegments;     // Number of input segments.
+        internal int undeads;        // Number of input vertices that don't appear in the mesh.
+        internal int mesh_dim;       // Dimension (ought to be 2).
+        internal int nextras = 0;        // Number of attributes per vertex.
+        //internal int eextras;        // Number of attributes per triangle.
+        internal int hullsize;       // Number of edges in convex hull.
+        internal int steinerleft;    // Number of Steiner points not yet used.
+        internal bool checksegments; // Are there segments in the triangulation yet?
+        internal bool checkquality;  // Has quality triangulation begun yet?
+
+        // Triangular bounding box vertices.
+        internal Vertex infvertex1, infvertex2, infvertex3;
+
+        internal TriangleLocator locator;
+
+        // Controls the behavior of the mesh instance.
+        internal Behavior behavior;
+
+        // The current node numbering
+        internal NodeNumbering numbering;
+
+        #endregion
+
+        #region Public properties
+
+        /// <summary>
+        /// Gets the mesh bounding box.
+        /// </summary>
+        public Rectangle Bounds
+        {
+            get { return this.bounds; }
+        }
+
+        /// <summary>
+        /// Gets the mesh vertices.
+        /// </summary>
+        public ICollection<Vertex> Vertices
+        {
+            get { return this.vertices.Values; }
+        }
+
+        /// <summary>
+        /// Gets the mesh holes.
+        /// </summary>
+        public IList<Point> Holes
+        {
+            get { return this.holes; }
+        }
+
+        /// <summary>
+        /// Gets the mesh triangles.
+        /// </summary>
+        public ICollection<Triangle> Triangles
+        {
+            get { return this.triangles; }
+        }
+
+        /// <summary>
+        /// Gets the mesh segments.
+        /// </summary>
+        public ICollection<SubSegment> Segments
+        {
+            get { return this.subsegs.Values; }
+        }
+
+        /// <summary>
+        /// Gets the mesh edges.
+        /// </summary>
+        public IEnumerable<Edge> Edges
+        {
+            get
+            {
+                var e = new EdgeIterator(this);
+                while (e.MoveNext())
+                {
+                    yield return e.Current;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets the number of input vertices.
+        /// </summary>
+        public int NumberOfInputPoints
+        {
+            get { return invertices; }
+        }
+
+        /// <summary>
+        /// Gets the number of mesh edges.
+        /// </summary>
+        public int NumberOfEdges
+        {
+            get { return (3 * triangles.Count + hullsize) / 2; }
+        }
+
+        /// <summary>
+        /// Indicates whether the input is a PSLG or a point set.
+        /// </summary>
+        public bool IsPolygon
+        {
+            get { return this.insegments > 0; }
+        }
+
+        /// <summary>
+        /// Gets the current node numbering.
+        /// </summary>
+        public NodeNumbering CurrentNumbering
+        {
+            get { return numbering; }
+        }
+
+        #endregion
+
+        #region "Outer space" variables
+
+        internal const int DUMMY = -1;
+
+        // The triangle that fills "outer space," called 'dummytri', is pointed to
+        // by every triangle and subsegment on a boundary (be it outer or inner) of
+        // the triangulation. Also, 'dummytri' points to one of the triangles on
+        // the convex hull (until the holes and concavities are carved), making it
+        // possible to find a starting triangle for point location.
+
+        // 'dummytri' and 'dummysub' are generally required to fulfill only a few
+        // invariants: their vertices must remain NULL and 'dummytri' must always
+        // be bonded (at offset zero) to some triangle on the convex hull of the
+        // mesh, via a boundary edge. Otherwise, the connections of 'dummytri' and
+        // 'dummysub' may change willy-nilly. This makes it possible to avoid
+        // writing a good deal of special-case code (in the edge flip, for example)
+        // for dealing with the boundary of the mesh, places where no subsegment is
+        // present, and so forth.  Other entities are frequently bonded to
+        // 'dummytri' and 'dummysub' as if they were real mesh entities, with no
+        // harm done.
+
+        internal Triangle dummytri;
+
+        // Set up 'dummysub', the omnipresent subsegment pointed to by any
+        // triangle side or subsegment end that isn't attached to a real
+        // subsegment.
+
+        internal SubSegment dummysub;
+
+        private void Initialize()
+        {
+            dummysub = new SubSegment();
+            dummysub.hash = DUMMY;
+
+            // Initialize the two adjoining subsegments to be the omnipresent
+            // subsegment. These will eventually be changed by various bonding
+            // operations, but their values don't really matter, as long as they
+            // can legally be dereferenced.
+            dummysub.subsegs[0].seg = dummysub;
+            dummysub.subsegs[1].seg = dummysub;
+
+            // Set up 'dummytri', the 'triangle' that occupies "outer space."
+            dummytri = new Triangle();
+            dummytri.hash = dummytri.id = DUMMY;
+
+            // Initialize the three adjoining triangles to be "outer space." These
+            // will eventually be changed by various bonding operations, but their
+            // values don't really matter, as long as they can legally be
+            // dereferenced.
+            dummytri.neighbors[0].tri = dummytri;
+            dummytri.neighbors[1].tri = dummytri;
+            dummytri.neighbors[2].tri = dummytri;
+
+            // Initialize the three adjoining subsegments of 'dummytri' to be
+            // the omnipresent subsegment.
+            dummytri.subsegs[0].seg = dummysub;
+            dummytri.subsegs[1].seg = dummysub;
+            dummytri.subsegs[2].seg = dummysub;
+        }
+
+        #endregion
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Mesh" /> class.
+        /// </summary>
+        public Mesh(Configuration config)
+        {
+            Initialize();
+
+            logger = Log.Instance;
+
+            behavior = new Behavior();
+
+            vertices = new Dictionary<int, Vertex>();
+            subsegs = new Dictionary<int, SubSegment>();
+
+            triangles = config.TrianglePool();
+
+            flipstack = new Stack<Otri>();
+
+            holes = new List<Point>();
+            regions = new List<RegionPointer>();
+
+            steinerleft = -1;
+
+            this.predicates = config.Predicates();
+
+            this.locator = new TriangleLocator(this, predicates);
+        }
+
+        public void Refine(QualityOptions quality, bool delaunay = false)
+        {
+            invertices = vertices.Count;
+
+            if (behavior.Poly)
+            {
+                insegments = behavior.useSegments ? subsegs.Count : hullsize;
+            }
+
+            Reset();
+
+            if (qualityMesher == null)
+            {
+                qualityMesher = new QualityMesher(this, new Configuration());
+            }
+
+            // Enforce angle and area constraints.
+            qualityMesher.Apply(quality, delaunay);
+        }
+
+        /// <summary>
+        /// Renumber vertex and triangle id's.
+        /// </summary>
+        public void Renumber()
+        {
+            this.Renumber(NodeNumbering.Linear);
+        }
+
+        /// <summary>
+        /// Renumber vertex and triangle id's.
+        /// </summary>
+        public void Renumber(NodeNumbering num)
+        {
+            // Don't need to do anything if the nodes are already numbered.
+            if (num == this.numbering)
+            {
+                return;
+            }
+
+            int id;
+
+            if (num == NodeNumbering.Linear)
+            {
+                id = 0;
+                foreach (var node in this.vertices.Values)
+                {
+                    node.id = id++;
+                }
+            }
+            else if (num == NodeNumbering.CuthillMcKee)
+            {
+                var rcm = new CuthillMcKee();
+                var iperm = rcm.Renumber(this);
+
+                // Permute the node indices.
+                foreach (var node in this.vertices.Values)
+                {
+                    node.id = iperm[node.id];
+                }
+            }
+
+            // Remember the current numbering.
+            numbering = num;
+
+            // Triangles will always be numbered from 0 to n-1
+            id = 0;
+            foreach (var item in this.triangles)
+            {
+                item.id = id++;
+            }
+        }
+
+        #region Misc
+
+        /// <summary>
+        /// Set QualityMesher for mesh refinement.
+        /// </summary>
+        /// <param name="qmesher"></param>
+        internal void SetQualityMesher(QualityMesher qmesher)
+        {
+            qualityMesher = qmesher;
+        }
+
+        internal void CopyTo(Mesh target)
+        {
+            target.vertices = this.vertices;
+            target.triangles = this.triangles;
+            target.subsegs = this.subsegs;
+
+            target.holes = this.holes;
+            target.regions = this.regions;
+
+            target.hash_vtx = this.hash_vtx;
+            target.hash_seg = this.hash_seg;
+            target.hash_tri = this.hash_tri;
+
+            target.numbering = this.numbering;
+            target.hullsize = this.hullsize;
+        }
+
+        /// <summary>
+        /// Reset all the mesh data. This method will also wipe
+        /// out all mesh data.
+        /// </summary>
+        private void ResetData()
+        {
+            vertices.Clear();
+            triangles.Restart();
+            subsegs.Clear();
+
+            holes.Clear();
+            regions.Clear();
+
+            this.hash_vtx = 0;
+            this.hash_seg = 0;
+            this.hash_tri = 0;
+
+            flipstack.Clear();
+
+            hullsize = 0;
+
+            Reset();
+
+            locator.Reset();
+        }
+
+        /// <summary>
+        /// Reset the mesh triangulation state.
+        /// </summary>
+        private void Reset()
+        {
+            numbering = NodeNumbering.None;
+
+            undeads = 0;               // No eliminated input vertices yet.
+            checksegments = false;     // There are no segments in the triangulation yet.
+            checkquality = false;      // The quality triangulation stage has not begun.
+
+            Statistic.InCircleCount = 0;
+            Statistic.CounterClockwiseCount = 0;
+            Statistic.InCircleAdaptCount = 0;
+            Statistic.CounterClockwiseAdaptCount = 0;
+            Statistic.Orient3dCount = 0;
+            Statistic.HyperbolaCount = 0;
+            Statistic.CircleTopCount = 0;
+            Statistic.CircumcenterCount = 0;
+        }
+
+        /// <summary>
+        /// Read the vertices from memory.
+        /// </summary>
+        /// <param name="data">The input data.</param>
+        internal void TransferNodes(IList<Vertex> points)
+        {
+            this.invertices = points.Count;
+            this.mesh_dim = 2;
+            this.bounds = new Rectangle();
+
+            if (this.invertices < 3)
+            {
+                logger.Error("Input must have at least three input vertices.", "Mesh.TransferNodes()");
+                throw new Exception("Input must have at least three input vertices.");
+            }
+
+            var v = points[0];
+
+#if USE_ATTRIBS
+            // Check attributes.
+            this.nextras = v.attributes == null ? 0 : v.attributes.Length;
+#endif
+
+            // Simple heuristic to check if ids are already set.  We assume that if the
+            // first two vertex ids are distinct, then all input vertices have pairwise
+            // distinct ids.
+            bool userId = (v.id != points[1].id);
+
+            foreach (var p in points)
+            {
+                if (userId)
+                {
+                    p.hash = p.id;
+
+                    // Make sure the hash counter gets updated.
+                    hash_vtx = Math.Max(p.hash + 1, hash_vtx);
+                }
+                else
+                {
+                    p.hash = p.id = hash_vtx++;
+                }
+
+                this.vertices.Add(p.hash, p);
+                this.bounds.Expand(p);
+            }
+        }
+
+        /// <summary>
+        /// Construct a mapping from vertices to triangles to improve the speed of
+        /// point location for segment insertion.
+        /// </summary>
+        /// <remarks>
+        /// Traverses all the triangles, and provides each corner of each triangle
+        /// with a pointer to that triangle. Of course, pointers will be overwritten
+        /// by other pointers because (almost) each vertex is a corner of several
+        /// triangles, but in the end every vertex will point to some triangle
+        /// that contains it.
+        /// </remarks>
+        internal void MakeVertexMap()
+        {
+            Otri tri = default(Otri);
+            Vertex triorg;
+
+            foreach (var t in this.triangles)
+            {
+                tri.tri = t;
+                // Check all three vertices of the triangle.
+                for (tri.orient = 0; tri.orient < 3; tri.orient++)
+                {
+                    triorg = tri.Org();
+                    triorg.tri = tri;
+                }
+            }
+        }
+
+        #endregion
+
+        #region Factory
+
+        /// <summary>
+        /// Create a new triangle with orientation zero.
+        /// </summary>
+        /// <param name="newotri">Reference to the new triangle.</param>
+        internal void MakeTriangle(ref Otri newotri)
+        {
+            Triangle tri = triangles.Get();
+
+            //tri.id = tri.hash;
+
+            tri.subsegs[0].seg = dummysub;
+            tri.subsegs[1].seg = dummysub;
+            tri.subsegs[2].seg = dummysub;
+
+            tri.neighbors[0].tri = dummytri;
+            tri.neighbors[1].tri = dummytri;
+            tri.neighbors[2].tri = dummytri;
+
+            newotri.tri = tri;
+            newotri.orient = 0;
+        }
+
+        /// <summary>
+        /// Create a new subsegment with orientation zero.
+        /// </summary>
+        /// <param name="newsubseg">Reference to the new subseg.</param>
+        internal void MakeSegment(ref Osub newsubseg)
+        {
+            var seg = new SubSegment();
+
+            seg.hash = this.hash_seg++;
+
+            seg.subsegs[0].seg = dummysub;
+            seg.subsegs[1].seg = dummysub;
+
+            seg.triangles[0].tri = dummytri;
+            seg.triangles[1].tri = dummytri;
+
+            newsubseg.seg = seg;
+            newsubseg.orient = 0;
+
+            subsegs.Add(seg.hash, seg);
+        }
+
+        #endregion
+
+        #region Manipulation
+
+        /// <summary>
+        /// Insert a vertex into a Delaunay triangulation, performing flips as necessary
+        /// to maintain the Delaunay property.
+        /// </summary>
+        /// <param name="newvertex">The point to be inserted.</param>
+        /// <param name="searchtri">The triangle to start the search.</param>
+        /// <param name="splitseg">Segment to split.</param>
+        /// <param name="segmentflaws">Check for creation of encroached subsegments.</param>
+        /// <param name="triflaws">Check for creation of bad quality triangles.</param>
+        /// <returns>If a duplicate vertex or violated segment does not prevent the
+        /// vertex from being inserted, the return value will be ENCROACHINGVERTEX if
+        /// the vertex encroaches upon a subsegment (and checking is enabled), or
+        /// SUCCESSFULVERTEX otherwise. In either case, 'searchtri' is set to a handle
+        /// whose origin is the newly inserted vertex.</returns>
+        /// <remarks>
+        /// The point 'newvertex' is located. If 'searchtri.triangle' is not NULL,
+        /// the search for the containing triangle begins from 'searchtri'.  If
+        /// 'searchtri.triangle' is NULL, a full point location procedure is called.
+        /// If 'insertvertex' is found inside a triangle, the triangle is split into
+        /// three; if 'insertvertex' lies on an edge, the edge is split in two,
+        /// thereby splitting the two adjacent triangles into four. Edge flips are
+        /// used to restore the Delaunay property. If 'insertvertex' lies on an
+        /// existing vertex, no action is taken, and the value DUPLICATEVERTEX is
+        /// returned. On return, 'searchtri' is set to a handle whose origin is the
+        /// existing vertex.
+        ///
+        /// InsertVertex() does not use flip() for reasons of speed; some
+        /// information can be reused from edge flip to edge flip, like the
+        /// locations of subsegments.
+        ///
+        /// Param 'splitseg': Normally, the parameter 'splitseg' is set to NULL,
+        /// implying that no subsegment should be split. In this case, if 'insertvertex'
+        /// is found to lie on a segment, no action is taken, and the value VIOLATINGVERTEX
+        /// is returned. On return, 'searchtri' is set to a handle whose primary edge is the
+        /// violated subsegment.
+        /// If the calling routine wishes to split a subsegment by inserting a vertex in it,
+        /// the parameter 'splitseg' should be that subsegment. In this case, 'searchtri'
+        /// MUST be the triangle handle reached by pivoting from that subsegment; no point
+        /// location is done.
+        ///
+        /// Param 'segmentflaws': Flags that indicate whether or not there should
+        /// be checks for the creation of encroached subsegments. If a newly inserted
+        /// vertex encroaches upon subsegments, these subsegments are added to the list
+        /// of subsegments to be split if 'segmentflaws' is set.
+        ///
+        /// Param 'triflaws': Flags that indicate whether or not there should be
+        /// checks for the creation of bad quality triangles. If bad triangles are
+        /// created, these are added to the queue if 'triflaws' is set.
+        /// </remarks>
+        internal InsertVertexResult InsertVertex(Vertex newvertex, ref Otri searchtri,
+            ref Osub splitseg, bool segmentflaws, bool triflaws)
+        {
+            Otri horiz = default(Otri);
+            Otri top = default(Otri);
+            Otri botleft = default(Otri), botright = default(Otri);
+            Otri topleft = default(Otri), topright = default(Otri);
+            Otri newbotleft = default(Otri), newbotright = default(Otri);
+            Otri newtopright = default(Otri);
+            Otri botlcasing = default(Otri), botrcasing = default(Otri);
+            Otri toplcasing = default(Otri), toprcasing = default(Otri);
+            Otri testtri = default(Otri);
+            Osub botlsubseg = default(Osub), botrsubseg = default(Osub);
+            Osub toplsubseg = default(Osub), toprsubseg = default(Osub);
+            Osub brokensubseg = default(Osub);
+            Osub checksubseg = default(Osub);
+            Osub rightsubseg = default(Osub);
+            Osub newsubseg = default(Osub);
+            BadSubseg encroached;
+            //FlipStacker newflip;
+            Vertex first;
+            Vertex leftvertex, rightvertex, botvertex, topvertex, farvertex;
+            Vertex segmentorg, segmentdest;
+            int region;
+            double area;
+            InsertVertexResult success;
+            LocateResult intersect;
+            bool doflip;
+            bool mirrorflag;
+            bool enq;
+
+            if (splitseg.seg == null)
+            {
+                // Find the location of the vertex to be inserted.  Check if a good
+                // starting triangle has already been provided by the caller.
+                if (searchtri.tri.id == DUMMY)
+                {
+                    // Find a boundary triangle.
+                    horiz.tri = dummytri;
+                    horiz.orient = 0;
+                    horiz.Sym();
+
+                    // Search for a triangle containing 'newvertex'.
+                    intersect = locator.Locate(newvertex, ref horiz);
+                }
+                else
+                {
+                    // Start searching from the triangle provided by the caller.
+                    searchtri.Copy(ref horiz);
+                    intersect = locator.PreciseLocate(newvertex, ref horiz, true);
+                }
+            }
+            else
+            {
+                // The calling routine provides the subsegment in which
+                // the vertex is inserted.
+                searchtri.Copy(ref horiz);
+                intersect = LocateResult.OnEdge;
+            }
+
+            if (intersect == LocateResult.OnVertex)
+            {
+                // There's already a vertex there.  Return in 'searchtri' a triangle
+                // whose origin is the existing vertex.
+                horiz.Copy(ref searchtri);
+                locator.Update(ref horiz);
+                return InsertVertexResult.Duplicate;
+            }
+            if ((intersect == LocateResult.OnEdge) || (intersect == LocateResult.Outside))
+            {
+                // The vertex falls on an edge or boundary.
+                if (checksegments && (splitseg.seg == null))
+                {
+                    // Check whether the vertex falls on a subsegment.
+                    horiz.Pivot(ref brokensubseg);
+                    if (brokensubseg.seg.hash != DUMMY)
+                    {
+                        // The vertex falls on a subsegment, and hence will not be inserted.
+                        if (segmentflaws)
+                        {
+                            enq = behavior.NoBisect != 2;
+                            if (enq && (behavior.NoBisect == 1))
+                            {
+                                // This subsegment may be split only if it is an
+                                // internal boundary.
+                                horiz.Sym(ref testtri);
+                                enq = testtri.tri.id != DUMMY;
+                            }
+                            if (enq)
+                            {
+                                // Add the subsegment to the list of encroached subsegments.
+                                encroached = new BadSubseg();
+                                encroached.subseg = brokensubseg;
+                                encroached.org = brokensubseg.Org();
+                                encroached.dest = brokensubseg.Dest();
+
+                                qualityMesher.AddBadSubseg(encroached);
+                            }
+                        }
+                        // Return a handle whose primary edge contains the vertex,
+                        //   which has not been inserted.
+                        horiz.Copy(ref searchtri);
+                        locator.Update(ref horiz);
+                        return InsertVertexResult.Violating;
+                    }
+                }
+
+                // Insert the vertex on an edge, dividing one triangle into two (if
+                // the edge lies on a boundary) or two triangles into four.
+                horiz.Lprev(ref botright);
+                botright.Sym(ref botrcasing);
+                horiz.Sym(ref topright);
+                // Is there a second triangle?  (Or does this edge lie on a boundary?)
+                mirrorflag = topright.tri.id != DUMMY;
+                if (mirrorflag)
+                {
+                    topright.Lnext();
+                    topright.Sym(ref toprcasing);
+                    MakeTriangle(ref newtopright);
+                }
+                else
+                {
+                    // Splitting a boundary edge increases the number of boundary edges.
+                    hullsize++;
+                }
+                MakeTriangle(ref newbotright);
+
+                // Set the vertices of changed and new triangles.
+                rightvertex = horiz.Org();
+                leftvertex = horiz.Dest();
+                botvertex = horiz.Apex();
+                newbotright.SetOrg(botvertex);
+                newbotright.SetDest(rightvertex);
+                newbotright.SetApex(newvertex);
+                horiz.SetOrg(newvertex);
+
+                // Set the region of a new triangle.
+                newbotright.tri.label = botright.tri.label;
+
+                if (behavior.VarArea)
+                {
+                    // Set the area constraint of a new triangle.
+                    newbotright.tri.area = botright.tri.area;
+                }
+
+                if (mirrorflag)
+                {
+                    topvertex = topright.Dest();
+                    newtopright.SetOrg(rightvertex);
+                    newtopright.SetDest(topvertex);
+                    newtopright.SetApex(newvertex);
+                    topright.SetOrg(newvertex);
+
+                    // Set the region of another new triangle.
+                    newtopright.tri.label = topright.tri.label;
+
+                    if (behavior.VarArea)
+                    {
+                        // Set the area constraint of another new triangle.
+                        newtopright.tri.area = topright.tri.area;
+                    }
+                }
+
+                // There may be subsegments that need to be bonded
+                // to the new triangle(s).
+                if (checksegments)
+                {
+                    botright.Pivot(ref botrsubseg);
+
+                    if (botrsubseg.seg.hash != DUMMY)
+                    {
+                        botright.SegDissolve(dummysub);
+                        newbotright.SegBond(ref botrsubseg);
+                    }
+
+                    if (mirrorflag)
+                    {
+                        topright.Pivot(ref toprsubseg);
+                        if (toprsubseg.seg.hash != DUMMY)
+                        {
+                            topright.SegDissolve(dummysub);
+                            newtopright.SegBond(ref toprsubseg);
+                        }
+                    }
+                }
+
+                // Bond the new triangle(s) to the surrounding triangles.
+                newbotright.Bond(ref botrcasing);
+                newbotright.Lprev();
+                newbotright.Bond(ref botright);
+                newbotright.Lprev();
+
+                if (mirrorflag)
+                {
+                    newtopright.Bond(ref toprcasing);
+                    newtopright.Lnext();
+                    newtopright.Bond(ref topright);
+                    newtopright.Lnext();
+                    newtopright.Bond(ref newbotright);
+                }
+
+                if (splitseg.seg != null)
+                {
+                    // Split the subsegment into two.
+                    splitseg.SetDest(newvertex);
+                    segmentorg = splitseg.SegOrg();
+                    segmentdest = splitseg.SegDest();
+                    splitseg.Sym();
+                    splitseg.Pivot(ref rightsubseg);
+                    InsertSubseg(ref newbotright, splitseg.seg.boundary);
+                    newbotright.Pivot(ref newsubseg);
+                    newsubseg.SetSegOrg(segmentorg);
+                    newsubseg.SetSegDest(segmentdest);
+                    splitseg.Bond(ref newsubseg);
+                    newsubseg.Sym();
+                    newsubseg.Bond(ref rightsubseg);
+                    splitseg.Sym();
+
+                    // Transfer the subsegment's boundary marker to the vertex if required.
+                    if (newvertex.label == 0)
+                    {
+                        newvertex.label = splitseg.seg.boundary;
+                    }
+                }
+
+                if (checkquality)
+                {
+                    flipstack.Clear();
+
+                    flipstack.Push(default(Otri)); // Dummy flip (see UndoVertex)
+                    flipstack.Push(horiz);
+                }
+
+                // Position 'horiz' on the first edge to check for
+                // the Delaunay property.
+                horiz.Lnext();
+            }
+            else
+            {
+                // Insert the vertex in a triangle, splitting it into three.
+                horiz.Lnext(ref botleft);
+                horiz.Lprev(ref botright);
+                botleft.Sym(ref botlcasing);
+                botright.Sym(ref botrcasing);
+                MakeTriangle(ref newbotleft);
+                MakeTriangle(ref newbotright);
+
+                // Set the vertices of changed and new triangles.
+                rightvertex = horiz.Org();
+                leftvertex = horiz.Dest();
+                botvertex = horiz.Apex();
+                newbotleft.SetOrg(leftvertex);
+                newbotleft.SetDest(botvertex);
+                newbotleft.SetApex(newvertex);
+                newbotright.SetOrg(botvertex);
+                newbotright.SetDest(rightvertex);
+                newbotright.SetApex(newvertex);
+                horiz.SetApex(newvertex);
+
+                // Set the region of the new triangles.
+                newbotleft.tri.label = horiz.tri.label;
+                newbotright.tri.label = horiz.tri.label;
+
+                if (behavior.VarArea)
+                {
+                    // Set the area constraint of the new triangles.
+                    area = horiz.tri.area;
+                    newbotleft.tri.area = area;
+                    newbotright.tri.area = area;
+                }
+
+                // There may be subsegments that need to be bonded
+                // to the new triangles.
+                if (checksegments)
+                {
+                    botleft.Pivot(ref botlsubseg);
+                    if (botlsubseg.seg.hash != DUMMY)
+                    {
+                        botleft.SegDissolve(dummysub);
+                        newbotleft.SegBond(ref botlsubseg);
+                    }
+                    botright.Pivot(ref botrsubseg);
+                    if (botrsubseg.seg.hash != DUMMY)
+                    {
+                        botright.SegDissolve(dummysub);
+                        newbotright.SegBond(ref botrsubseg);
+                    }
+                }
+
+                // Bond the new triangles to the surrounding triangles.
+                newbotleft.Bond(ref botlcasing);
+                newbotright.Bond(ref botrcasing);
+                newbotleft.Lnext();
+                newbotright.Lprev();
+                newbotleft.Bond(ref newbotright);
+                newbotleft.Lnext();
+                botleft.Bond(ref newbotleft);
+                newbotright.Lprev();
+                botright.Bond(ref newbotright);
+
+                if (checkquality)
+                {
+                    flipstack.Clear();
+                    flipstack.Push(horiz);
+                }
+            }
+
+            // The insertion is successful by default, unless an encroached
+            // subsegment is found.
+            success = InsertVertexResult.Successful;
+
+            if (newvertex.tri.tri != null)
+            {
+                // Store the coordinates of the triangle that contains newvertex.
+                newvertex.tri.SetOrg(rightvertex);
+                newvertex.tri.SetDest(leftvertex);
+                newvertex.tri.SetApex(botvertex);
+            }
+
+            // Circle around the newly inserted vertex, checking each edge opposite it
+            // for the Delaunay property. Non-Delaunay edges are flipped. 'horiz' is
+            // always the edge being checked. 'first' marks where to stop circling.
+            first = horiz.Org();
+            rightvertex = first;
+            leftvertex = horiz.Dest();
+            // Circle until finished.
+            while (true)
+            {
+                // By default, the edge will be flipped.
+                doflip = true;
+
+                if (checksegments)
+                {
+                    // Check for a subsegment, which cannot be flipped.
+                    horiz.Pivot(ref checksubseg);
+                    if (checksubseg.seg.hash != DUMMY)
+                    {
+                        // The edge is a subsegment and cannot be flipped.
+                        doflip = false;
+
+                        if (segmentflaws)
+                        {
+                            // Does the new vertex encroach upon this subsegment?
+                            if (qualityMesher.CheckSeg4Encroach(ref checksubseg) > 0)
+                            {
+                                success = InsertVertexResult.Encroaching;
+                            }
+                        }
+                    }
+                }
+
+                if (doflip)
+                {
+                    // Check if the edge is a boundary edge.
+                    horiz.Sym(ref top);
+                    if (top.tri.id == DUMMY)
+                    {
+                        // The edge is a boundary edge and cannot be flipped.
+                        doflip = false;
+                    }
+                    else
+                    {
+                        // Find the vertex on the other side of the edge.
+                        farvertex = top.Apex();
+                        // In the incremental Delaunay triangulation algorithm, any of
+                        // 'leftvertex', 'rightvertex', and 'farvertex' could be vertices
+                        // of the triangular bounding box. These vertices must be
+                        // treated as if they are infinitely distant, even though their
+                        // "coordinates" are not.
+                        if ((leftvertex == infvertex1) || (leftvertex == infvertex2) ||
+                            (leftvertex == infvertex3))
+                        {
+                            // 'leftvertex' is infinitely distant. Check the convexity of
+                            // the boundary of the triangulation. 'farvertex' might be
+                            // infinite as well, but trust me, this same condition should
+                            // be applied.
+                            doflip = predicates.CounterClockwise(newvertex, rightvertex, farvertex) > 0.0;
+                        }
+                        else if ((rightvertex == infvertex1) ||
+                                 (rightvertex == infvertex2) ||
+                                 (rightvertex == infvertex3))
+                        {
+                            // 'rightvertex' is infinitely distant. Check the convexity of
+                            // the boundary of the triangulation. 'farvertex' might be
+                            // infinite as well, but trust me, this same condition should
+                            // be applied.
+                            doflip = predicates.CounterClockwise(farvertex, leftvertex, newvertex) > 0.0;
+                        }
+                        else if ((farvertex == infvertex1) ||
+                                 (farvertex == infvertex2) ||
+                                 (farvertex == infvertex3))
+                        {
+                            // 'farvertex' is infinitely distant and cannot be inside
+                            // the circumcircle of the triangle 'horiz'.
+                            doflip = false;
+                        }
+                        else
+                        {
+                            // Test whether the edge is locally Delaunay.
+                            doflip = predicates.InCircle(leftvertex, newvertex, rightvertex, farvertex) > 0.0;
+                        }
+                        if (doflip)
+                        {
+                            // We made it! Flip the edge 'horiz' by rotating its containing
+                            // quadrilateral (the two triangles adjacent to 'horiz').
+                            // Identify the casing of the quadrilateral.
+                            top.Lprev(ref topleft);
+                            topleft.Sym(ref toplcasing);
+                            top.Lnext(ref topright);
+                            topright.Sym(ref toprcasing);
+                            horiz.Lnext(ref botleft);
+                            botleft.Sym(ref botlcasing);
+                            horiz.Lprev(ref botright);
+                            botright.Sym(ref botrcasing);
+                            // Rotate the quadrilateral one-quarter turn counterclockwise.
+                            topleft.Bond(ref botlcasing);
+                            botleft.Bond(ref botrcasing);
+                            botright.Bond(ref toprcasing);
+                            topright.Bond(ref toplcasing);
+                            if (checksegments)
+                            {
+                                // Check for subsegments and rebond them to the quadrilateral.
+                                topleft.Pivot(ref toplsubseg);
+                                botleft.Pivot(ref botlsubseg);
+                                botright.Pivot(ref botrsubseg);
+                                topright.Pivot(ref toprsubseg);
+                                if (toplsubseg.seg.hash == DUMMY)
+                                {
+                                    topright.SegDissolve(dummysub);
+                                }
+                                else
+                                {
+                                    topright.SegBond(ref toplsubseg);
+                                }
+                                if (botlsubseg.seg.hash == DUMMY)
+                                {
+                                    topleft.SegDissolve(dummysub);
+                                }
+                                else
+                                {
+                                    topleft.SegBond(ref botlsubseg);
+                                }
+                                if (botrsubseg.seg.hash == DUMMY)
+                                {
+                                    botleft.SegDissolve(dummysub);
+                                }
+                                else
+                                {
+                                    botleft.SegBond(ref botrsubseg);
+                                }
+                                if (toprsubseg.seg.hash == DUMMY)
+                                {
+                                    botright.SegDissolve(dummysub);
+                                }
+                                else
+                                {
+                                    botright.SegBond(ref toprsubseg);
+                                }
+                            }
+                            // New vertex assignments for the rotated quadrilateral.
+                            horiz.SetOrg(farvertex);
+                            horiz.SetDest(newvertex);
+                            horiz.SetApex(rightvertex);
+                            top.SetOrg(newvertex);
+                            top.SetDest(farvertex);
+                            top.SetApex(leftvertex);
+
+                            // Assign region.
+                            // TODO: check region ok (no Math.Min necessary)
+                            region = Math.Min(top.tri.label, horiz.tri.label);
+                            top.tri.label = region;
+                            horiz.tri.label = region;
+
+                            if (behavior.VarArea)
+                            {
+                                if ((top.tri.area <= 0.0) || (horiz.tri.area <= 0.0))
+                                {
+                                    area = -1.0;
+                                }
+                                else
+                                {
+                                    // Take the average of the two triangles' area constraints.
+                                    // This prevents small area constraints from migrating a
+                                    // long, long way from their original location due to flips.
+                                    area = 0.5 * (top.tri.area + horiz.tri.area);
+                                }
+
+                                top.tri.area = area;
+                                horiz.tri.area = area;
+                            }
+
+                            if (checkquality)
+                            {
+                                flipstack.Push(horiz);
+                            }
+
+                            // On the next iterations, consider the two edges that were exposed (this
+                            // is, are now visible to the newly inserted vertex) by the edge flip.
+                            horiz.Lprev();
+                            leftvertex = farvertex;
+                        }
+                    }
+                }
+                if (!doflip)
+                {
+                    // The handle 'horiz' is accepted as locally Delaunay.
+                    if (triflaws)
+                    {
+                        // Check the triangle 'horiz' for quality.
+                        qualityMesher.TestTriangle(ref horiz);
+                    }
+
+                    // Look for the next edge around the newly inserted vertex.
+                    horiz.Lnext();
+                    horiz.Sym(ref testtri);
+                    // Check for finishing a complete revolution about the new vertex, or
+                    // falling outside of the triangulation. The latter will happen when
+                    // a vertex is inserted at a boundary.
+                    if ((leftvertex == first) || (testtri.tri.id == DUMMY))
+                    {
+                        // We're done. Return a triangle whose origin is the new vertex.
+                        horiz.Lnext(ref searchtri);
+
+                        Otri recenttri = default(Otri);
+                        horiz.Lnext(ref recenttri);
+                        locator.Update(ref recenttri);
+
+                        return success;
+                    }
+                    // Finish finding the next edge around the newly inserted vertex.
+                    testtri.Lnext(ref horiz);
+                    rightvertex = leftvertex;
+                    leftvertex = horiz.Dest();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Create a new subsegment and inserts it between two triangles. Its
+        /// vertices are properly initialized.
+        /// </summary>
+        /// <param name="tri">The new subsegment is inserted at the edge
+        /// described by this handle.</param>
+        /// <param name="subsegmark">The marker 'subsegmark' is applied to the
+        /// subsegment and, if appropriate, its vertices.</param>
+        internal void InsertSubseg(ref Otri tri, int subsegmark)
+        {
+            Otri oppotri = default(Otri);
+            Osub newsubseg = default(Osub);
+            Vertex triorg, tridest;
+
+            triorg = tri.Org();
+            tridest = tri.Dest();
+            // Mark vertices if possible.
+            if (triorg.label == 0)
+            {
+                triorg.label = subsegmark;
+            }
+            if (tridest.label == 0)
+            {
+                tridest.label = subsegmark;
+            }
+            // Check if there's already a subsegment here.
+            tri.Pivot(ref newsubseg);
+            if (newsubseg.seg.hash == DUMMY)
+            {
+                // Make new subsegment and initialize its vertices.
+                MakeSegment(ref newsubseg);
+                newsubseg.SetOrg(tridest);
+                newsubseg.SetDest(triorg);
+                newsubseg.SetSegOrg(tridest);
+                newsubseg.SetSegDest(triorg);
+                // Bond new subsegment to the two triangles it is sandwiched between.
+                // Note that the facing triangle 'oppotri' might be equal to 'dummytri'
+                // (outer space), but the new subsegment is bonded to it all the same.
+                tri.SegBond(ref newsubseg);
+                tri.Sym(ref oppotri);
+                newsubseg.Sym();
+                oppotri.SegBond(ref newsubseg);
+                newsubseg.seg.boundary = subsegmark;
+            }
+            else if (newsubseg.seg.boundary == 0)
+            {
+                newsubseg.seg.boundary = subsegmark;
+            }
+        }
+
+        /// <summary>
+        /// Transform two triangles to two different triangles by flipping an edge
+        /// counterclockwise within a quadrilateral.
+        /// </summary>
+        /// <param name="flipedge">Handle to the edge that will be flipped.</param>
+        /// <remarks>Imagine the original triangles, abc and bad, oriented so that the
+        /// shared edge ab lies in a horizontal plane, with the vertex b on the left
+        /// and the vertex a on the right. The vertex c lies below the edge, and
+        /// the vertex d lies above the edge. The 'flipedge' handle holds the edge
+        /// ab of triangle abc, and is directed left, from vertex a to vertex b.
+        ///
+        /// The triangles abc and bad are deleted and replaced by the triangles cdb
+        /// and dca.  The triangles that represent abc and bad are NOT deallocated;
+        /// they are reused for dca and cdb, respectively.  Hence, any handles that
+        /// may have held the original triangles are still valid, although not
+        /// directed as they were before.
+        ///
+        /// Upon completion of this routine, the 'flipedge' handle holds the edge
+        /// dc of triangle dca, and is directed down, from vertex d to vertex c.
+        /// (Hence, the two triangles have rotated counterclockwise.)
+        ///
+        /// WARNING:  This transformation is geometrically valid only if the
+        /// quadrilateral adbc is convex.  Furthermore, this transformation is
+        /// valid only if there is not a subsegment between the triangles abc and
+        /// bad.  This routine does not check either of these preconditions, and
+        /// it is the responsibility of the calling routine to ensure that they are
+        /// met.  If they are not, the streets shall be filled with wailing and
+        /// gnashing of teeth.
+        ///
+        /// Terminology
+        ///
+        /// A "local transformation" replaces a small set of triangles with another
+        /// set of triangles.  This may or may not involve inserting or deleting a
+        /// vertex.
+        ///
+        /// The term "casing" is used to describe the set of triangles that are
+        /// attached to the triangles being transformed, but are not transformed
+        /// themselves.  Think of the casing as a fixed hollow structure inside
+        /// which all the action happens.  A "casing" is only defined relative to
+        /// a single transformation; each occurrence of a transformation will
+        /// involve a different casing.
+        /// </remarks>
+        internal void Flip(ref Otri flipedge)
+        {
+            Otri botleft = default(Otri), botright = default(Otri);
+            Otri topleft = default(Otri), topright = default(Otri);
+            Otri top = default(Otri);
+            Otri botlcasing = default(Otri), botrcasing = default(Otri);
+            Otri toplcasing = default(Otri), toprcasing = default(Otri);
+            Osub botlsubseg = default(Osub), botrsubseg = default(Osub);
+            Osub toplsubseg = default(Osub), toprsubseg = default(Osub);
+            Vertex leftvertex, rightvertex, botvertex;
+            Vertex farvertex;
+
+            // Identify the vertices of the quadrilateral.
+            rightvertex = flipedge.Org();
+            leftvertex = flipedge.Dest();
+            botvertex = flipedge.Apex();
+            flipedge.Sym(ref top);
+
+            // SELF CHECK
+
+            //if (top.triangle.id == DUMMY)
+            //{
+            //    logger.Error("Attempt to flip on boundary.", "Mesh.Flip()");
+            //    flipedge.LnextSelf();
+            //    return;
+            //}
+
+            //if (checksegments)
+            //{
+            //    flipedge.SegPivot(ref toplsubseg);
+            //    if (toplsubseg.ss != Segment.Empty)
+            //    {
+            //        logger.Error("Attempt to flip a segment.", "Mesh.Flip()");
+            //        flipedge.LnextSelf();
+            //        return;
+            //    }
+            //}
+
+            farvertex = top.Apex();
+
+            // Identify the casing of the quadrilateral.
+            top.Lprev(ref topleft);
+            topleft.Sym(ref toplcasing);
+            top.Lnext(ref topright);
+            topright.Sym(ref toprcasing);
+            flipedge.Lnext(ref botleft);
+            botleft.Sym(ref botlcasing);
+            flipedge.Lprev(ref botright);
+            botright.Sym(ref botrcasing);
+            // Rotate the quadrilateral one-quarter turn counterclockwise.
+            topleft.Bond(ref botlcasing);
+            botleft.Bond(ref botrcasing);
+            botright.Bond(ref toprcasing);
+            topright.Bond(ref toplcasing);
+
+            if (checksegments)
+            {
+                // Check for subsegments and rebond them to the quadrilateral.
+                topleft.Pivot(ref toplsubseg);
+                botleft.Pivot(ref botlsubseg);
+                botright.Pivot(ref botrsubseg);
+                topright.Pivot(ref toprsubseg);
+
+                if (toplsubseg.seg.hash == DUMMY)
+                {
+                    topright.SegDissolve(dummysub);
+                }
+                else
+                {
+                    topright.SegBond(ref toplsubseg);
+                }
+
+                if (botlsubseg.seg.hash == DUMMY)
+                {
+                    topleft.SegDissolve(dummysub);
+                }
+                else
+                {
+                    topleft.SegBond(ref botlsubseg);
+                }
+
+                if (botrsubseg.seg.hash == DUMMY)
+                {
+                    botleft.SegDissolve(dummysub);
+                }
+                else
+                {
+                    botleft.SegBond(ref botrsubseg);
+                }
+
+                if (toprsubseg.seg.hash == DUMMY)
+                {
+                    botright.SegDissolve(dummysub);
+                }
+                else
+                {
+                    botright.SegBond(ref toprsubseg);
+                }
+            }
+
+            // New vertex assignments for the rotated quadrilateral.
+            flipedge.SetOrg(farvertex);
+            flipedge.SetDest(botvertex);
+            flipedge.SetApex(rightvertex);
+            top.SetOrg(botvertex);
+            top.SetDest(farvertex);
+            top.SetApex(leftvertex);
+        }
+
+        /// <summary>
+        /// Transform two triangles to two different triangles by flipping an edge
+        /// clockwise within a quadrilateral. Reverses the flip() operation so that
+        /// the data structures representing the triangles are back where they were
+        /// before the flip().
+        /// </summary>
+        /// <param name="flipedge"></param>
+        /// <remarks>
+        /// See above Flip() remarks for more information.
+        ///
+        /// Upon completion of this routine, the 'flipedge' handle holds the edge
+        /// cd of triangle cdb, and is directed up, from vertex c to vertex d.
+        /// (Hence, the two triangles have rotated clockwise.)
+        /// </remarks>
+        internal void Unflip(ref Otri flipedge)
+        {
+            Otri botleft = default(Otri), botright = default(Otri);
+            Otri topleft = default(Otri), topright = default(Otri);
+            Otri top = default(Otri);
+            Otri botlcasing = default(Otri), botrcasing = default(Otri);
+            Otri toplcasing = default(Otri), toprcasing = default(Otri);
+            Osub botlsubseg = default(Osub), botrsubseg = default(Osub);
+            Osub toplsubseg = default(Osub), toprsubseg = default(Osub);
+            Vertex leftvertex, rightvertex, botvertex;
+            Vertex farvertex;
+
+            // Identify the vertices of the quadrilateral.
+            rightvertex = flipedge.Org();
+            leftvertex = flipedge.Dest();
+            botvertex = flipedge.Apex();
+            flipedge.Sym(ref top);
+
+            farvertex = top.Apex();
+
+            // Identify the casing of the quadrilateral.
+            top.Lprev(ref topleft);
+            topleft.Sym(ref toplcasing);
+            top.Lnext(ref topright);
+            topright.Sym(ref toprcasing);
+            flipedge.Lnext(ref botleft);
+            botleft.Sym(ref botlcasing);
+            flipedge.Lprev(ref botright);
+            botright.Sym(ref botrcasing);
+            // Rotate the quadrilateral one-quarter turn clockwise.
+            topleft.Bond(ref toprcasing);
+            botleft.Bond(ref toplcasing);
+            botright.Bond(ref botlcasing);
+            topright.Bond(ref botrcasing);
+
+            if (checksegments)
+            {
+                // Check for subsegments and rebond them to the quadrilateral.
+                topleft.Pivot(ref toplsubseg);
+                botleft.Pivot(ref botlsubseg);
+                botright.Pivot(ref botrsubseg);
+                topright.Pivot(ref toprsubseg);
+                if (toplsubseg.seg.hash == DUMMY)
+                {
+                    botleft.SegDissolve(dummysub);
+                }
+                else
+                {
+                    botleft.SegBond(ref toplsubseg);
+                }
+                if (botlsubseg.seg.hash == DUMMY)
+                {
+                    botright.SegDissolve(dummysub);
+                }
+                else
+                {
+                    botright.SegBond(ref botlsubseg);
+                }
+                if (botrsubseg.seg.hash == DUMMY)
+                {
+                    topright.SegDissolve(dummysub);
+                }
+                else
+                {
+                    topright.SegBond(ref botrsubseg);
+                }
+                if (toprsubseg.seg.hash == DUMMY)
+                {
+                    topleft.SegDissolve(dummysub);
+                }
+                else
+                {
+                    topleft.SegBond(ref toprsubseg);
+                }
+            }
+
+            // New vertex assignments for the rotated quadrilateral.
+            flipedge.SetOrg(botvertex);
+            flipedge.SetDest(farvertex);
+            flipedge.SetApex(leftvertex);
+            top.SetOrg(farvertex);
+            top.SetDest(botvertex);
+            top.SetApex(rightvertex);
+        }
+
+        /// <summary>
+        /// Find the Delaunay triangulation of a polygon that has a certain "nice" shape.
+        /// This includes the polygons that result from deletion of a vertex or insertion
+        /// of a segment.
+        /// </summary>
+        /// <param name="firstedge">The primary edge of the first triangle.</param>
+        /// <param name="lastedge">The primary edge of the last triangle.</param>
+        /// <param name="edgecount">The number of sides of the polygon, including its
+        /// base.</param>
+        /// <param name="doflip">A flag, wether to perform the last flip.</param>
+        /// <param name="triflaws">A flag that determines whether the new triangles should
+        /// be tested for quality, and enqueued if they are bad.</param>
+        /// <remarks>
+        //  This is a conceptually difficult routine. The starting assumption is
+        //  that we have a polygon with n sides. n - 1 of these sides are currently
+        //  represented as edges in the mesh. One side, called the "base", need not
+        //  be.
+        //
+        //  Inside the polygon is a structure I call a "fan", consisting of n - 1
+        //  triangles that share a common origin. For each of these triangles, the
+        //  edge opposite the origin is one of the sides of the polygon. The
+        //  primary edge of each triangle is the edge directed from the origin to
+        //  the destination; note that this is not the same edge that is a side of
+        //  the polygon. 'firstedge' is the primary edge of the first triangle.
+        //  From there, the triangles follow in counterclockwise order about the
+        //  polygon, until 'lastedge', the primary edge of the last triangle.
+        //  'firstedge' and 'lastedge' are probably connected to other triangles
+        //  beyond the extremes of the fan, but their identity is not important, as
+        //  long as the fan remains connected to them.
+        //
+        //  Imagine the polygon oriented so that its base is at the bottom.  This
+        //  puts 'firstedge' on the far right, and 'lastedge' on the far left.
+        //  The right vertex of the base is the destination of 'firstedge', and the
+        //  left vertex of the base is the apex of 'lastedge'.
+        //
+        //  The challenge now is to find the right sequence of edge flips to
+        //  transform the fan into a Delaunay triangulation of the polygon.  Each
+        //  edge flip effectively removes one triangle from the fan, committing it
+        //  to the polygon.  The resulting polygon has one fewer edge. If 'doflip'
+        //  is set, the final flip will be performed, resulting in a fan of one
+        //  (useless?) triangle. If 'doflip' is not set, the final flip is not
+        //  performed, resulting in a fan of two triangles, and an unfinished
+        //  triangular polygon that is not yet filled out with a single triangle.
+        //  On completion of the routine, 'lastedge' is the last remaining triangle,
+        //  or the leftmost of the last two.
+        //
+        //  Although the flips are performed in the order described above, the
+        //  decisions about what flips to perform are made in precisely the reverse
+        //  order. The recursive triangulatepolygon() procedure makes a decision,
+        //  uses up to two recursive calls to triangulate the "subproblems"
+        //  (polygons with fewer edges), and then performs an edge flip.
+        //
+        //  The "decision" it makes is which vertex of the polygon should be
+        //  connected to the base. This decision is made by testing every possible
+        //  vertex.  Once the best vertex is found, the two edges that connect this
+        //  vertex to the base become the bases for two smaller polygons. These
+        //  are triangulated recursively. Unfortunately, this approach can take
+        //  O(n^2) time not only in the worst case, but in many common cases. It's
+        //  rarely a big deal for vertex deletion, where n is rarely larger than
+        //  ten, but it could be a big deal for segment insertion, especially if
+        //  there's a lot of long segments that each cut many triangles. I ought to
+        //  code a faster algorithm some day.
+        /// </remarks>
+        private void TriangulatePolygon(Otri firstedge, Otri lastedge,
+            int edgecount, bool doflip, bool triflaws)
+        {
+            Otri testtri = default(Otri);
+            Otri besttri = default(Otri);
+            Otri tempedge = default(Otri);
+            Vertex leftbasevertex, rightbasevertex;
+            Vertex testvertex;
+            Vertex bestvertex;
+
+            int bestnumber = 1;
+
+            // Identify the base vertices.
+            leftbasevertex = lastedge.Apex();
+            rightbasevertex = firstedge.Dest();
+
+            // Find the best vertex to connect the base to.
+            firstedge.Onext(ref besttri);
+            bestvertex = besttri.Dest();
+            besttri.Copy(ref testtri);
+
+            for (int i = 2; i <= edgecount - 2; i++)
+            {
+                testtri.Onext();
+                testvertex = testtri.Dest();
+                // Is this a better vertex?
+                if (predicates.InCircle(leftbasevertex, rightbasevertex, bestvertex, testvertex) > 0.0)
+                {
+                    testtri.Copy(ref besttri);
+                    bestvertex = testvertex;
+                    bestnumber = i;
+                }
+            }
+
+            if (bestnumber > 1)
+            {
+                // Recursively triangulate the smaller polygon on the right.
+                besttri.Oprev(ref tempedge);
+                TriangulatePolygon(firstedge, tempedge, bestnumber + 1, true, triflaws);
+            }
+
+            if (bestnumber < edgecount - 2)
+            {
+                // Recursively triangulate the smaller polygon on the left.
+                besttri.Sym(ref tempedge);
+                TriangulatePolygon(besttri, lastedge, edgecount - bestnumber, true, triflaws);
+                // Find 'besttri' again; it may have been lost to edge flips.
+                tempedge.Sym(ref besttri);
+            }
+
+            if (doflip)
+            {
+                // Do one final edge flip.
+                Flip(ref besttri);
+                if (triflaws)
+                {
+                    // Check the quality of the newly committed triangle.
+                    besttri.Sym(ref testtri);
+                    qualityMesher.TestTriangle(ref testtri);
+                }
+            }
+            // Return the base triangle.
+            besttri.Copy(ref lastedge);
+        }
+
+        /// <summary>
+        /// Delete a vertex from a Delaunay triangulation, ensuring that the
+        /// triangulation remains Delaunay.
+        /// </summary>
+        /// <param name="deltri"></param>
+        /// <remarks>The origin of 'deltri' is deleted. The union of the triangles
+        /// adjacent to this vertex is a polygon, for which the Delaunay triangulation
+        /// is found. Two triangles are removed from the mesh.
+        ///
+        /// Only interior vertices that do not lie on segments or boundaries
+        /// may be deleted.
+        /// </remarks>
+        internal void DeleteVertex(ref Otri deltri)
+        {
+            Otri countingtri = default(Otri);
+            Otri firstedge = default(Otri), lastedge = default(Otri);
+            Otri deltriright = default(Otri);
+            Otri lefttri = default(Otri), righttri = default(Otri);
+            Otri leftcasing = default(Otri), rightcasing = default(Otri);
+            Osub leftsubseg = default(Osub), rightsubseg = default(Osub);
+            Vertex delvertex;
+            Vertex neworg;
+            int edgecount;
+
+            delvertex = deltri.Org();
+
+            VertexDealloc(delvertex);
+
+            // Count the degree of the vertex being deleted.
+            deltri.Onext(ref countingtri);
+            edgecount = 1;
+            while (!deltri.Equals(countingtri))
+            {
+                edgecount++;
+                countingtri.Onext();
+            }
+
+            if (edgecount > 3)
+            {
+                // Triangulate the polygon defined by the union of all triangles
+                // adjacent to the vertex being deleted.  Check the quality of
+                // the resulting triangles.
+                deltri.Onext(ref firstedge);
+                deltri.Oprev(ref lastedge);
+                TriangulatePolygon(firstedge, lastedge, edgecount, false, behavior.NoBisect == 0);
+            }
+            // Splice out two triangles.
+            deltri.Lprev(ref deltriright);
+            deltri.Dnext(ref lefttri);
+            lefttri.Sym(ref leftcasing);
+            deltriright.Oprev(ref righttri);
+            righttri.Sym(ref rightcasing);
+            deltri.Bond(ref leftcasing);
+            deltriright.Bond(ref rightcasing);
+            lefttri.Pivot(ref leftsubseg);
+            if (leftsubseg.seg.hash != DUMMY)
+            {
+                deltri.SegBond(ref leftsubseg);
+            }
+            righttri.Pivot(ref rightsubseg);
+            if (rightsubseg.seg.hash != DUMMY)
+            {
+                deltriright.SegBond(ref rightsubseg);
+            }
+
+            // Set the new origin of 'deltri' and check its quality.
+            neworg = lefttri.Org();
+            deltri.SetOrg(neworg);
+            if (behavior.NoBisect == 0)
+            {
+                qualityMesher.TestTriangle(ref deltri);
+            }
+
+            // Delete the two spliced-out triangles.
+            TriangleDealloc(lefttri.tri);
+            TriangleDealloc(righttri.tri);
+        }
+
+        /// <summary>
+        /// Undo the most recent vertex insertion.
+        /// </summary>
+        /// <remarks>
+        /// Walks through the list of transformations (flips and a vertex insertion)
+        /// in the reverse of the order in which they were done, and undoes them.
+        /// The inserted vertex is removed from the triangulation and deallocated.
+        /// Two triangles (possibly just one) are also deallocated.
+        /// </remarks>
+        internal void UndoVertex()
+        {
+            Otri fliptri;
+
+            Otri botleft = default(Otri), botright = default(Otri), topright = default(Otri);
+            Otri botlcasing = default(Otri), botrcasing = default(Otri), toprcasing = default(Otri);
+            Otri gluetri = default(Otri);
+            Osub botlsubseg = default(Osub), botrsubseg = default(Osub), toprsubseg = default(Osub);
+            Vertex botvertex, rightvertex;
+
+            // Walk through the list of transformations (flips and a vertex insertion)
+            // in the reverse of the order in which they were done, and undo them.
+            while (flipstack.Count > 0)
+            {
+                // Find a triangle involved in the last unreversed transformation.
+                fliptri = flipstack.Pop();
+
+                // We are reversing one of three transformations:  a trisection of one
+                // triangle into three (by inserting a vertex in the triangle), a
+                // bisection of two triangles into four (by inserting a vertex in an
+                // edge), or an edge flip.
+                if (flipstack.Count == 0)
+                {
+                    // Restore a triangle that was split into three triangles,
+                    // so it is again one triangle.
+                    fliptri.Dprev(ref botleft);
+                    botleft.Lnext();
+                    fliptri.Onext(ref botright);
+                    botright.Lprev();
+                    botleft.Sym(ref botlcasing);
+                    botright.Sym(ref botrcasing);
+                    botvertex = botleft.Dest();
+
+                    fliptri.SetApex(botvertex);
+                    fliptri.Lnext();
+                    fliptri.Bond(ref botlcasing);
+                    botleft.Pivot(ref botlsubseg);
+                    fliptri.SegBond(ref botlsubseg);
+                    fliptri.Lnext();
+                    fliptri.Bond(ref botrcasing);
+                    botright.Pivot(ref botrsubseg);
+                    fliptri.SegBond(ref botrsubseg);
+
+                    // Delete the two spliced-out triangles.
+                    TriangleDealloc(botleft.tri);
+                    TriangleDealloc(botright.tri);
+                }
+                else if (flipstack.Peek().tri == null) // Dummy flip
+                {
+                    // Restore two triangles that were split into four triangles,
+                    // so they are again two triangles.
+                    fliptri.Lprev(ref gluetri);
+                    gluetri.Sym(ref botright);
+                    botright.Lnext();
+                    botright.Sym(ref botrcasing);
+                    rightvertex = botright.Dest();
+
+                    fliptri.SetOrg(rightvertex);
+                    gluetri.Bond(ref botrcasing);
+                    botright.Pivot(ref botrsubseg);
+                    gluetri.SegBond(ref botrsubseg);
+
+                    // Delete the spliced-out triangle.
+                    TriangleDealloc(botright.tri);
+
+                    fliptri.Sym(ref gluetri);
+                    if (gluetri.tri.id != DUMMY)
+                    {
+                        gluetri.Lnext();
+                        gluetri.Dnext(ref topright);
+                        topright.Sym(ref toprcasing);
+
+                        gluetri.SetOrg(rightvertex);
+                        gluetri.Bond(ref toprcasing);
+                        topright.Pivot(ref toprsubseg);
+                        gluetri.SegBond(ref toprsubseg);
+
+                        // Delete the spliced-out triangle.
+                        TriangleDealloc(topright.tri);
+                    }
+
+                    flipstack.Clear();
+                }
+                else
+                {
+                    // Undo an edge flip.
+                    Unflip(ref fliptri);
+                }
+            }
+        }
+
+        #endregion
+
+        #region Dealloc
+
+        /// <summary>
+        /// Deallocate space for a triangle, marking it dead.
+        /// </summary>
+        /// <param name="dyingtriangle"></param>
+        internal void TriangleDealloc(Triangle dyingtriangle)
+        {
+            // Mark the triangle as dead. This makes it possible to detect dead
+            // triangles when traversing the list of all triangles.
+            Otri.Kill(dyingtriangle);
+            triangles.Release(dyingtriangle);
+        }
+
+        /// <summary>
+        /// Deallocate space for a vertex, marking it dead.
+        /// </summary>
+        /// <param name="dyingvertex"></param>
+        internal void VertexDealloc(Vertex dyingvertex)
+        {
+            // Mark the vertex as dead. This makes it possible to detect dead
+            // vertices when traversing the list of all vertices.
+            dyingvertex.type = VertexType.DeadVertex;
+            vertices.Remove(dyingvertex.hash);
+        }
+
+        /// <summary>
+        /// Deallocate space for a subsegment, marking it dead.
+        /// </summary>
+        /// <param name="dyingsubseg"></param>
+        internal void SubsegDealloc(SubSegment dyingsubseg)
+        {
+            // Mark the subsegment as dead. This makes it possible to detect dead
+            // subsegments when traversing the list of all subsegments.
+            Osub.Kill(dyingsubseg);
+            subsegs.Remove(dyingsubseg.hash);
+        }
+
+        #endregion
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Runtime/Triangle/Mesh.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: cf5fb0e34d9b14ac88f67bf18b0bc902
+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.animation@5.0.4/Runtime/Triangle/MeshValidator.cs

@@ -0,0 +1,214 @@
+// -----------------------------------------------------------------------
+// <copyright file="MeshValidator.cs">
+// Original Triangle code by Jonathan Richard Shewchuk, http://www.cs.cmu.edu/~quake/triangle.html
+// Triangle.NET code by Christian Woltering, http://triangle.codeplex.com/
+// </copyright>
+// -----------------------------------------------------------------------
+
+namespace UnityEngine.U2D.Animation.TriangleNet
+{
+    using System;
+    using Animation.TriangleNet.Topology;
+    using Animation.TriangleNet.Geometry;
+
+    internal static class MeshValidator
+    {
+        private static RobustPredicates predicates = RobustPredicates.Default;
+
+        /// <summary>
+        /// Test the mesh for topological consistency.
+        /// </summary>
+        internal static bool IsConsistent(Mesh mesh)
+        {
+            Otri tri = default(Otri);
+            Otri oppotri = default(Otri), oppooppotri = default(Otri);
+            Vertex org, dest, apex;
+            Vertex oppoorg, oppodest;
+
+            var logger = Log.Instance;
+
+            // Temporarily turn on exact arithmetic if it's off.
+            bool saveexact = Behavior.NoExact;
+            Behavior.NoExact = false;
+
+            int horrors = 0;
+
+            // Run through the list of triangles, checking each one.
+            foreach (var t in mesh.triangles)
+            {
+                tri.tri = t;
+
+                // Check all three edges of the triangle.
+                for (tri.orient = 0; tri.orient < 3; tri.orient++)
+                {
+                    org = tri.Org();
+                    dest = tri.Dest();
+                    if (tri.orient == 0)
+                    {
+                        // Only test for inversion once.
+                        // Test if the triangle is flat or inverted.
+                        apex = tri.Apex();
+                        if (predicates.CounterClockwise(org, dest, apex) <= 0.0)
+                        {
+                            if (Log.Verbose)
+                            {
+                                logger.Warning(String.Format("Triangle is flat or inverted (ID {0}).", t.id),
+                                    "MeshValidator.IsConsistent()");
+                            }
+
+                            horrors++;
+                        }
+                    }
+
+                    // Find the neighboring triangle on this edge.
+                    tri.Sym(ref oppotri);
+                    if (oppotri.tri.id != Mesh.DUMMY)
+                    {
+                        // Check that the triangle's neighbor knows it's a neighbor.
+                        oppotri.Sym(ref oppooppotri);
+                        if ((tri.tri != oppooppotri.tri) || (tri.orient != oppooppotri.orient))
+                        {
+                            if (tri.tri == oppooppotri.tri && Log.Verbose)
+                            {
+                                logger.Warning("Asymmetric triangle-triangle bond: (Right triangle, wrong orientation)",
+                                    "MeshValidator.IsConsistent()");
+                            }
+
+                            horrors++;
+                        }
+                        // Check that both triangles agree on the identities
+                        // of their shared vertices.
+                        oppoorg = oppotri.Org();
+                        oppodest = oppotri.Dest();
+                        if ((org != oppodest) || (dest != oppoorg))
+                        {
+                            if (Log.Verbose)
+                            {
+                                logger.Warning("Mismatched edge coordinates between two triangles.",
+                                    "MeshValidator.IsConsistent()");
+                            }
+
+                            horrors++;
+                        }
+                    }
+                }
+            }
+
+            // Check for unconnected vertices
+            mesh.MakeVertexMap();
+            foreach (var v in mesh.vertices.Values)
+            {
+                if (v.tri.tri == null && Log.Verbose)
+                {
+                    logger.Warning("Vertex (ID " + v.id + ") not connected to mesh (duplicate input vertex?)",
+                        "MeshValidator.IsConsistent()");
+                }
+            }
+
+            // Restore the status of exact arithmetic.
+            Behavior.NoExact = saveexact;
+
+            return (horrors == 0);
+        }
+
+        /// <summary>
+        /// Check if the mesh is (conforming) Delaunay.
+        /// </summary>
+        internal static bool IsDelaunay(Mesh mesh)
+        {
+            return IsDelaunay(mesh, false);
+        }
+
+        /// <summary>
+        /// Check if that the mesh is (constrained) Delaunay.
+        /// </summary>
+        internal static bool IsConstrainedDelaunay(Mesh mesh)
+        {
+            return IsDelaunay(mesh, true);
+        }
+
+        /// <summary>
+        /// Ensure that the mesh is (constrained) Delaunay.
+        /// </summary>
+        private static bool IsDelaunay(Mesh mesh, bool constrained)
+        {
+            Otri loop = default(Otri);
+            Otri oppotri = default(Otri);
+            Osub opposubseg = default(Osub);
+            Vertex org, dest, apex;
+            Vertex oppoapex;
+
+            bool shouldbedelaunay;
+
+            var logger = Log.Instance;
+
+            // Temporarily turn on exact arithmetic if it's off.
+            bool saveexact = Behavior.NoExact;
+            Behavior.NoExact = false;
+
+            int horrors = 0;
+
+            var inf1 = mesh.infvertex1;
+            var inf2 = mesh.infvertex2;
+            var inf3 = mesh.infvertex3;
+
+            // Run through the list of triangles, checking each one.
+            foreach (var tri in mesh.triangles)
+            {
+                loop.tri = tri;
+
+                // Check all three edges of the triangle.
+                for (loop.orient = 0; loop.orient < 3; loop.orient++)
+                {
+                    org = loop.Org();
+                    dest = loop.Dest();
+                    apex = loop.Apex();
+
+                    loop.Sym(ref oppotri);
+                    oppoapex = oppotri.Apex();
+
+                    // Only test that the edge is locally Delaunay if there is an
+                    // adjoining triangle whose pointer is larger (to ensure that
+                    // each pair isn't tested twice).
+                    shouldbedelaunay = (loop.tri.id < oppotri.tri.id) &&
+                        !Otri.IsDead(oppotri.tri) && (oppotri.tri.id != Mesh.DUMMY) &&
+                        (org != inf1) && (org != inf2) && (org != inf3) &&
+                        (dest != inf1) && (dest != inf2) && (dest != inf3) &&
+                        (apex != inf1) && (apex != inf2) && (apex != inf3) &&
+                        (oppoapex != inf1) && (oppoapex != inf2) && (oppoapex != inf3);
+
+                    if (constrained && mesh.checksegments && shouldbedelaunay)
+                    {
+                        // If a subsegment separates the triangles, then the edge is
+                        // constrained, so no local Delaunay test should be done.
+                        loop.Pivot(ref opposubseg);
+
+                        if (opposubseg.seg.hash != Mesh.DUMMY)
+                        {
+                            shouldbedelaunay = false;
+                        }
+                    }
+
+                    if (shouldbedelaunay)
+                    {
+                        if (predicates.NonRegular(org, dest, apex, oppoapex) > 0.0)
+                        {
+                            if (Log.Verbose)
+                            {
+                                logger.Warning(String.Format("Non-regular pair of triangles found (IDs {0}/{1}).",
+                                    loop.tri.id, oppotri.tri.id), "MeshValidator.IsDelaunay()");
+                            }
+
+                            horrors++;
+                        }
+                    }
+                }
+            }
+
+            // Restore the status of exact arithmetic.
+            Behavior.NoExact = saveexact;
+
+            return (horrors == 0);
+        }
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Runtime/Triangle/MeshValidator.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8688318786c2246dbae9df88b4e94a46
+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.animation@5.0.4/Runtime/Triangle/Meshing.meta

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

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Runtime/Triangle/NewLocation.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 19387af761aa944a6bda921093ae6d70
+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.animation@5.0.4/Runtime/Triangle/Properties.meta

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

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Runtime/Triangle/RobustPredicates.cs

@@ -0,0 +1,1347 @@
+// -----------------------------------------------------------------------
+// <copyright file="RobustPredicates.cs">
+// Original Triangle code by Jonathan Richard Shewchuk, http://www.cs.cmu.edu/~quake/triangle.html
+// Triangle.NET code by Christian Woltering, http://triangle.codeplex.com/
+// </copyright>
+// -----------------------------------------------------------------------
+
+namespace UnityEngine.U2D.Animation.TriangleNet
+{
+    using System;
+    using Animation.TriangleNet.Geometry;
+    using Animation.TriangleNet.Tools;
+
+    /// <summary>
+    /// Adaptive exact arithmetic geometric predicates.
+    /// </summary>
+    /// <remarks>
+    /// The adaptive exact arithmetic geometric predicates implemented herein are described in
+    /// detail in the paper "Adaptive Precision Floating-Point Arithmetic and Fast Robust
+    /// Geometric Predicates." by Jonathan Richard Shewchuk, see
+    /// http://www.cs.cmu.edu/~quake/robust.html
+    ///
+    /// The macros of the original C code were automatically expanded using the Visual Studio
+    /// command prompt with the command "CL /P /C EXACT.C", see
+    /// http://msdn.microsoft.com/en-us/library/8z9z0bx6.aspx
+    /// </remarks>
+    internal class RobustPredicates : IPredicates
+    {
+        #region Default predicates instance (Singleton)
+
+        private static readonly object creationLock = new object();
+        private static RobustPredicates _default;
+
+        /// <summary>
+        /// Gets the default configuration instance.
+        /// </summary>
+        internal static RobustPredicates Default
+        {
+            get
+            {
+                if (_default == null)
+                {
+                    lock (creationLock)
+                    {
+                        if (_default == null)
+                        {
+                            _default = new RobustPredicates();
+                        }
+                    }
+                }
+
+                return _default;
+            }
+        }
+
+        #endregion
+
+        #region Static initialization
+
+        private static double epsilon, splitter, resulterrbound;
+        private static double ccwerrboundA, ccwerrboundB, ccwerrboundC;
+        private static double iccerrboundA, iccerrboundB, iccerrboundC;
+        //private static double o3derrboundA, o3derrboundB, o3derrboundC;
+
+        /// <summary>
+        /// Initialize the variables used for exact arithmetic.
+        /// </summary>
+        /// <remarks>
+        /// 'epsilon' is the largest power of two such that 1.0 + epsilon = 1.0 in
+        /// floating-point arithmetic. 'epsilon' bounds the relative roundoff
+        /// error. It is used for floating-point error analysis.
+        ///
+        /// 'splitter' is used to split floating-point numbers into two half-
+        /// length significands for exact multiplication.
+        ///
+        /// I imagine that a highly optimizing compiler might be too smart for its
+        /// own good, and somehow cause this routine to fail, if it pretends that
+        /// floating-point arithmetic is too much like double arithmetic.
+        ///
+        /// Don't change this routine unless you fully understand it.
+        /// </remarks>
+        static RobustPredicates()
+        {
+            double half;
+            double check, lastcheck;
+            bool every_other;
+
+            every_other = true;
+            half = 0.5;
+            epsilon = 1.0;
+            splitter = 1.0;
+            check = 1.0;
+            // Repeatedly divide 'epsilon' by two until it is too small to add to
+            // one without causing roundoff.  (Also check if the sum is equal to
+            // the previous sum, for machines that round up instead of using exact
+            // rounding.  Not that these routines will work on such machines.)
+            do
+            {
+                lastcheck = check;
+                epsilon *= half;
+                if (every_other)
+                {
+                    splitter *= 2.0;
+                }
+                every_other = !every_other;
+                check = 1.0 + epsilon;
+            }
+            while ((check != 1.0) && (check != lastcheck));
+            splitter += 1.0;
+            // Error bounds for orientation and incircle tests.
+            resulterrbound = (3.0 + 8.0 * epsilon) * epsilon;
+            ccwerrboundA = (3.0 + 16.0 * epsilon) * epsilon;
+            ccwerrboundB = (2.0 + 12.0 * epsilon) * epsilon;
+            ccwerrboundC = (9.0 + 64.0 * epsilon) * epsilon * epsilon;
+            iccerrboundA = (10.0 + 96.0 * epsilon) * epsilon;
+            iccerrboundB = (4.0 + 48.0 * epsilon) * epsilon;
+            iccerrboundC = (44.0 + 576.0 * epsilon) * epsilon * epsilon;
+            //o3derrboundA = (7.0 + 56.0 * epsilon) * epsilon;
+            //o3derrboundB = (3.0 + 28.0 * epsilon) * epsilon;
+            //o3derrboundC = (26.0 + 288.0 * epsilon) * epsilon * epsilon;
+        }
+
+        #endregion
+
+        public RobustPredicates()
+        {
+            AllocateWorkspace();
+        }
+
+        /// <summary>
+        /// Check, if the three points appear in counterclockwise order. The result is
+        /// also a rough approximation of twice the signed area of the triangle defined
+        /// by the three points.
+        /// </summary>
+        /// <param name="pa">Point a.</param>
+        /// <param name="pb">Point b.</param>
+        /// <param name="pc">Point c.</param>
+        /// <returns>Return a positive value if the points pa, pb, and pc occur in
+        /// counterclockwise order; a negative value if they occur in clockwise order;
+        /// and zero if they are collinear.</returns>
+        public double CounterClockwise(Point pa, Point pb, Point pc)
+        {
+            double detleft, detright, det;
+            double detsum, errbound;
+
+            Statistic.CounterClockwiseCount++;
+
+            detleft = (pa.x - pc.x) * (pb.y - pc.y);
+            detright = (pa.y - pc.y) * (pb.x - pc.x);
+            det = detleft - detright;
+
+            if (Behavior.NoExact)
+            {
+                return det;
+            }
+
+            if (detleft > 0.0)
+            {
+                if (detright <= 0.0)
+                {
+                    return det;
+                }
+                else
+                {
+                    detsum = detleft + detright;
+                }
+            }
+            else if (detleft < 0.0)
+            {
+                if (detright >= 0.0)
+                {
+                    return det;
+                }
+                else
+                {
+                    detsum = -detleft - detright;
+                }
+            }
+            else
+            {
+                return det;
+            }
+
+            errbound = ccwerrboundA * detsum;
+            if ((det >= errbound) || (-det >= errbound))
+            {
+                return det;
+            }
+
+            Statistic.CounterClockwiseAdaptCount++;
+            return CounterClockwiseAdapt(pa, pb, pc, detsum);
+        }
+
+        /// <summary>
+        /// Check if the point pd lies inside the circle passing through pa, pb, and pc. The
+        /// points pa, pb, and pc must be in counterclockwise order, or the sign of the result
+        /// will be reversed.
+        /// </summary>
+        /// <param name="pa">Point a.</param>
+        /// <param name="pb">Point b.</param>
+        /// <param name="pc">Point c.</param>
+        /// <param name="pd">Point d.</param>
+        /// <returns>Return a positive value if the point pd lies inside the circle passing through
+        /// pa, pb, and pc; a negative value if it lies outside; and zero if the four points
+        /// are cocircular.</returns>
+        public double InCircle(Point pa, Point pb, Point pc, Point pd)
+        {
+            double adx, bdx, cdx, ady, bdy, cdy;
+            double bdxcdy, cdxbdy, cdxady, adxcdy, adxbdy, bdxady;
+            double alift, blift, clift;
+            double det;
+            double permanent, errbound;
+
+            Statistic.InCircleCount++;
+
+            adx = pa.x - pd.x;
+            bdx = pb.x - pd.x;
+            cdx = pc.x - pd.x;
+            ady = pa.y - pd.y;
+            bdy = pb.y - pd.y;
+            cdy = pc.y - pd.y;
+
+            bdxcdy = bdx * cdy;
+            cdxbdy = cdx * bdy;
+            alift = adx * adx + ady * ady;
+
+            cdxady = cdx * ady;
+            adxcdy = adx * cdy;
+            blift = bdx * bdx + bdy * bdy;
+
+            adxbdy = adx * bdy;
+            bdxady = bdx * ady;
+            clift = cdx * cdx + cdy * cdy;
+
+            det = alift * (bdxcdy - cdxbdy)
+                + blift * (cdxady - adxcdy)
+                + clift * (adxbdy - bdxady);
+
+            if (Behavior.NoExact)
+            {
+                return det;
+            }
+
+            permanent = (Math.Abs(bdxcdy) + Math.Abs(cdxbdy)) * alift
+                + (Math.Abs(cdxady) + Math.Abs(adxcdy)) * blift
+                + (Math.Abs(adxbdy) + Math.Abs(bdxady)) * clift;
+            errbound = iccerrboundA * permanent;
+            if ((det > errbound) || (-det > errbound))
+            {
+                return det;
+            }
+
+            Statistic.InCircleAdaptCount++;
+            return InCircleAdapt(pa, pb, pc, pd, permanent);
+        }
+
+        /// <summary>
+        /// Return a positive value if the point pd is incompatible with the circle
+        /// or plane passing through pa, pb, and pc (meaning that pd is inside the
+        /// circle or below the plane); a negative value if it is compatible; and
+        /// zero if the four points are cocircular/coplanar. The points pa, pb, and
+        /// pc must be in counterclockwise order, or the sign of the result will be
+        /// reversed.
+        /// </summary>
+        /// <param name="pa">Point a.</param>
+        /// <param name="pb">Point b.</param>
+        /// <param name="pc">Point c.</param>
+        /// <param name="pd">Point d.</param>
+        /// <returns>Return a positive value if the point pd lies inside the circle passing through
+        /// pa, pb, and pc; a negative value if it lies outside; and zero if the four points
+        /// are cocircular.</returns>
+        public double NonRegular(Point pa, Point pb, Point pc, Point pd)
+        {
+            return InCircle(pa, pb, pc, pd);
+        }
+
+        /// <summary>
+        /// Find the circumcenter of a triangle.
+        /// </summary>
+        /// <param name="org">Triangle point.</param>
+        /// <param name="dest">Triangle point.</param>
+        /// <param name="apex">Triangle point.</param>
+        /// <param name="xi">Relative coordinate of new location.</param>
+        /// <param name="eta">Relative coordinate of new location.</param>
+        /// <param name="offconstant">Off-center constant.</param>
+        /// <returns>Coordinates of the circumcenter (or off-center)</returns>
+        public Point FindCircumcenter(Point org, Point dest, Point apex,
+            ref double xi, ref double eta, double offconstant)
+        {
+            double xdo, ydo, xao, yao;
+            double dodist, aodist, dadist;
+            double denominator;
+            double dx, dy, dxoff, dyoff;
+
+            Statistic.CircumcenterCount++;
+
+            // Compute the circumcenter of the triangle.
+            xdo = dest.x - org.x;
+            ydo = dest.y - org.y;
+            xao = apex.x - org.x;
+            yao = apex.y - org.y;
+            dodist = xdo * xdo + ydo * ydo;
+            aodist = xao * xao + yao * yao;
+            dadist = (dest.x - apex.x) * (dest.x - apex.x) +
+                (dest.y - apex.y) * (dest.y - apex.y);
+
+            if (Behavior.NoExact)
+            {
+                denominator = 0.5 / (xdo * yao - xao * ydo);
+            }
+            else
+            {
+                // Use the counterclockwise() routine to ensure a positive (and
+                // reasonably accurate) result, avoiding any possibility of
+                // division by zero.
+                denominator = 0.5 / CounterClockwise(dest, apex, org);
+                // Don't count the above as an orientation test.
+                Statistic.CounterClockwiseCount--;
+            }
+
+            dx = (yao * dodist - ydo * aodist) * denominator;
+            dy = (xdo * aodist - xao * dodist) * denominator;
+
+            // Find the (squared) length of the triangle's shortest edge.  This
+            // serves as a conservative estimate of the insertion radius of the
+            // circumcenter's parent. The estimate is used to ensure that
+            // the algorithm terminates even if very small angles appear in
+            // the input PSLG.
+            if ((dodist < aodist) && (dodist < dadist))
+            {
+                if (offconstant > 0.0)
+                {
+                    // Find the position of the off-center, as described by Alper Ungor.
+                    dxoff = 0.5 * xdo - offconstant * ydo;
+                    dyoff = 0.5 * ydo + offconstant * xdo;
+                    // If the off-center is closer to the origin than the
+                    // circumcenter, use the off-center instead.
+                    if (dxoff * dxoff + dyoff * dyoff < dx * dx + dy * dy)
+                    {
+                        dx = dxoff;
+                        dy = dyoff;
+                    }
+                }
+            }
+            else if (aodist < dadist)
+            {
+                if (offconstant > 0.0)
+                {
+                    dxoff = 0.5 * xao + offconstant * yao;
+                    dyoff = 0.5 * yao - offconstant * xao;
+                    // If the off-center is closer to the origin than the
+                    // circumcenter, use the off-center instead.
+                    if (dxoff * dxoff + dyoff * dyoff < dx * dx + dy * dy)
+                    {
+                        dx = dxoff;
+                        dy = dyoff;
+                    }
+                }
+            }
+            else
+            {
+                if (offconstant > 0.0)
+                {
+                    dxoff = 0.5 * (apex.x - dest.x) - offconstant * (apex.y - dest.y);
+                    dyoff = 0.5 * (apex.y - dest.y) + offconstant * (apex.x - dest.x);
+                    // If the off-center is closer to the destination than the
+                    // circumcenter, use the off-center instead.
+                    if (dxoff * dxoff + dyoff * dyoff <
+                        (dx - xdo) * (dx - xdo) + (dy - ydo) * (dy - ydo))
+                    {
+                        dx = xdo + dxoff;
+                        dy = ydo + dyoff;
+                    }
+                }
+            }
+
+            // To interpolate vertex attributes for the new vertex inserted at
+            // the circumcenter, define a coordinate system with a xi-axis,
+            // directed from the triangle's origin to its destination, and
+            // an eta-axis, directed from its origin to its apex.
+            // Calculate the xi and eta coordinates of the circumcenter.
+            xi = (yao * dx - xao * dy) * (2.0 * denominator);
+            eta = (xdo * dy - ydo * dx) * (2.0 * denominator);
+
+            return new Point(org.x + dx, org.y + dy);
+        }
+
+        /// <summary>
+        /// Find the circumcenter of a triangle.
+        /// </summary>
+        /// <param name="org">Triangle point.</param>
+        /// <param name="dest">Triangle point.</param>
+        /// <param name="apex">Triangle point.</param>
+        /// <param name="xi">Relative coordinate of new location.</param>
+        /// <param name="eta">Relative coordinate of new location.</param>
+        /// <returns>Coordinates of the circumcenter</returns>
+        /// <remarks>
+        /// The result is returned both in terms of x-y coordinates and xi-eta
+        /// (barycentric) coordinates. The xi-eta coordinate system is defined in
+        /// terms of the triangle: the origin of the triangle is the origin of the
+        /// coordinate system; the destination of the triangle is one unit along the
+        /// xi axis; and the apex of the triangle is one unit along the eta axis.
+        /// This procedure also returns the square of the length of the triangle's
+        /// shortest edge.
+        /// </remarks>
+        public Point FindCircumcenter(Point org, Point dest, Point apex,
+            ref double xi, ref double eta)
+        {
+            double xdo, ydo, xao, yao;
+            double dodist, aodist;
+            double denominator;
+            double dx, dy;
+
+            Statistic.CircumcenterCount++;
+
+            // Compute the circumcenter of the triangle.
+            xdo = dest.x - org.x;
+            ydo = dest.y - org.y;
+            xao = apex.x - org.x;
+            yao = apex.y - org.y;
+            dodist = xdo * xdo + ydo * ydo;
+            aodist = xao * xao + yao * yao;
+
+            if (Behavior.NoExact)
+            {
+                denominator = 0.5 / (xdo * yao - xao * ydo);
+            }
+            else
+            {
+                // Use the counterclockwise() routine to ensure a positive (and
+                // reasonably accurate) result, avoiding any possibility of
+                // division by zero.
+                denominator = 0.5 / CounterClockwise(dest, apex, org);
+                // Don't count the above as an orientation test.
+                Statistic.CounterClockwiseCount--;
+            }
+
+            dx = (yao * dodist - ydo * aodist) * denominator;
+            dy = (xdo * aodist - xao * dodist) * denominator;
+
+            // To interpolate vertex attributes for the new vertex inserted at
+            // the circumcenter, define a coordinate system with a xi-axis,
+            // directed from the triangle's origin to its destination, and
+            // an eta-axis, directed from its origin to its apex.
+            // Calculate the xi and eta coordinates of the circumcenter.
+            xi = (yao * dx - xao * dy) * (2.0 * denominator);
+            eta = (xdo * dy - ydo * dx) * (2.0 * denominator);
+
+            return new Point(org.x + dx, org.y + dy);
+        }
+
+        #region Exact arithmetics
+
+        /// <summary>
+        /// Sum two expansions, eliminating zero components from the output expansion.
+        /// </summary>
+        /// <param name="elen"></param>
+        /// <param name="e"></param>
+        /// <param name="flen"></param>
+        /// <param name="f"></param>
+        /// <param name="h"></param>
+        /// <returns></returns>
+        /// <remarks>
+        /// Sets h = e + f.  See the Robust Predicates paper for details.
+        ///
+        /// If round-to-even is used (as with IEEE 754), maintains the strongly nonoverlapping
+        /// property.  (That is, if e is strongly nonoverlapping, h will be also.) Does NOT
+        /// maintain the nonoverlapping or nonadjacent properties.
+        /// </remarks>
+        private int FastExpansionSumZeroElim(int elen, double[] e, int flen, double[] f, double[] h)
+        {
+            double Q;
+            double Qnew;
+            double hh;
+            double bvirt;
+            double avirt, bround, around;
+            int eindex, findex, hindex;
+            double enow, fnow;
+
+            enow = e[0];
+            fnow = f[0];
+            eindex = findex = 0;
+            if ((fnow > enow) == (fnow > -enow))
+            {
+                Q = enow;
+                enow = e[++eindex];
+            }
+            else
+            {
+                Q = fnow;
+                fnow = f[++findex];
+            }
+            hindex = 0;
+            if ((eindex < elen) && (findex < flen))
+            {
+                if ((fnow > enow) == (fnow > -enow))
+                {
+                    Qnew = (double)(enow + Q); bvirt = Qnew - enow; hh = Q - bvirt;
+                    enow = e[++eindex];
+                }
+                else
+                {
+                    Qnew = (double)(fnow + Q); bvirt = Qnew - fnow; hh = Q - bvirt;
+                    fnow = f[++findex];
+                }
+                Q = Qnew;
+                if (hh != 0.0)
+                {
+                    h[hindex++] = hh;
+                }
+                while ((eindex < elen) && (findex < flen))
+                {
+                    if ((fnow > enow) == (fnow > -enow))
+                    {
+                        Qnew = (double)(Q + enow);
+                        bvirt = (double)(Qnew - Q);
+                        avirt = Qnew - bvirt;
+                        bround = enow - bvirt;
+                        around = Q - avirt;
+                        hh = around + bround;
+
+                        enow = e[++eindex];
+                    }
+                    else
+                    {
+                        Qnew = (double)(Q + fnow);
+                        bvirt = (double)(Qnew - Q);
+                        avirt = Qnew - bvirt;
+                        bround = fnow - bvirt;
+                        around = Q - avirt;
+                        hh = around + bround;
+
+                        fnow = f[++findex];
+                    }
+                    Q = Qnew;
+                    if (hh != 0.0)
+                    {
+                        h[hindex++] = hh;
+                    }
+                }
+            }
+            while (eindex < elen)
+            {
+                Qnew = (double)(Q + enow);
+                bvirt = (double)(Qnew - Q);
+                avirt = Qnew - bvirt;
+                bround = enow - bvirt;
+                around = Q - avirt;
+                hh = around + bround;
+
+                enow = e[++eindex];
+                Q = Qnew;
+                if (hh != 0.0)
+                {
+                    h[hindex++] = hh;
+                }
+            }
+            while (findex < flen)
+            {
+                Qnew = (double)(Q + fnow);
+                bvirt = (double)(Qnew - Q);
+                avirt = Qnew - bvirt;
+                bround = fnow - bvirt;
+                around = Q - avirt;
+                hh = around + bround;
+
+                fnow = f[++findex];
+                Q = Qnew;
+                if (hh != 0.0)
+                {
+                    h[hindex++] = hh;
+                }
+            }
+            if ((Q != 0.0) || (hindex == 0))
+            {
+                h[hindex++] = Q;
+            }
+            return hindex;
+        }
+
+        /// <summary>
+        /// Multiply an expansion by a scalar, eliminating zero components from the output expansion.
+        /// </summary>
+        /// <param name="elen"></param>
+        /// <param name="e"></param>
+        /// <param name="b"></param>
+        /// <param name="h"></param>
+        /// <returns></returns>
+        /// <remarks>
+        /// Sets h = be.  See my Robust Predicates paper for details.
+        ///
+        /// Maintains the nonoverlapping property.  If round-to-even is used (as with IEEE 754),
+        /// maintains the strongly nonoverlapping and nonadjacent properties as well. (That is,
+        /// if e has one of these properties, so will h.)
+        /// </remarks>
+        private int ScaleExpansionZeroElim(int elen, double[] e, double b, double[] h)
+        {
+            double Q, sum;
+            double hh;
+            double product1;
+            double product0;
+            int eindex, hindex;
+            double enow;
+            double bvirt;
+            double avirt, bround, around;
+            double c;
+            double abig;
+            double ahi, alo, bhi, blo;
+            double err1, err2, err3;
+
+            c = (double)(splitter * b); abig = (double)(c - b); bhi = c - abig; blo = b - bhi;
+            Q = (double)(e[0] * b); c = (double)(splitter * e[0]); abig = (double)(c - e[0]); ahi = c - abig; alo = e[0] - ahi; err1 = Q - (ahi * bhi); err2 = err1 - (alo * bhi); err3 = err2 - (ahi * blo); hh = (alo * blo) - err3;
+            hindex = 0;
+            if (hh != 0)
+            {
+                h[hindex++] = hh;
+            }
+            for (eindex = 1; eindex < elen; eindex++)
+            {
+                enow = e[eindex];
+                product1 = (double)(enow * b); c = (double)(splitter * enow); abig = (double)(c - enow); ahi = c - abig; alo = enow - ahi; err1 = product1 - (ahi * bhi); err2 = err1 - (alo * bhi); err3 = err2 - (ahi * blo); product0 = (alo * blo) - err3;
+                sum = (double)(Q + product0); bvirt = (double)(sum - Q); avirt = sum - bvirt; bround = product0 - bvirt; around = Q - avirt; hh = around + bround;
+                if (hh != 0)
+                {
+                    h[hindex++] = hh;
+                }
+                Q = (double)(product1 + sum); bvirt = Q - product1; hh = sum - bvirt;
+                if (hh != 0)
+                {
+                    h[hindex++] = hh;
+                }
+            }
+            if ((Q != 0.0) || (hindex == 0))
+            {
+                h[hindex++] = Q;
+            }
+            return hindex;
+        }
+
+        /// <summary>
+        /// Produce a one-word estimate of an expansion's value.
+        /// </summary>
+        /// <param name="elen"></param>
+        /// <param name="e"></param>
+        /// <returns></returns>
+        private double Estimate(int elen, double[] e)
+        {
+            double Q;
+            int eindex;
+
+            Q = e[0];
+            for (eindex = 1; eindex < elen; eindex++)
+            {
+                Q += e[eindex];
+            }
+            return Q;
+        }
+
+        /// <summary>
+        /// Return a positive value if the points pa, pb, and pc occur in counterclockwise
+        /// order; a negative value if they occur in clockwise order; and zero if they are
+        /// collinear. The result is also a rough approximation of twice the signed area of
+        /// the triangle defined by the three points.
+        /// </summary>
+        /// <param name="pa"></param>
+        /// <param name="pb"></param>
+        /// <param name="pc"></param>
+        /// <param name="detsum"></param>
+        /// <returns></returns>
+        /// <remarks>
+        /// Uses exact arithmetic if necessary to ensure a correct answer. The result returned
+        /// is the determinant of a matrix. This determinant is computed adaptively, in the
+        /// sense that exact arithmetic is used only to the degree it is needed to ensure that
+        /// the returned value has the correct sign.  Hence, this function is usually quite fast,
+        /// but will run more slowly when the input points are collinear or nearly so.
+        /// </remarks>
+        private double CounterClockwiseAdapt(Point pa, Point pb, Point pc, double detsum)
+        {
+            double acx, acy, bcx, bcy;
+            double acxtail, acytail, bcxtail, bcytail;
+            double detleft, detright;
+            double detlefttail, detrighttail;
+            double det, errbound;
+            // Edited to work around index out of range exceptions (changed array length from 4 to 5).
+            // See unsafe indexing in FastExpansionSumZeroElim.
+            double[] B = new double[5], u = new double[5];
+            double[] C1 = new double[8], C2 = new double[12], D = new double[16];
+            double B3;
+            int C1length, C2length, Dlength;
+
+            double u3;
+            double s1, t1;
+            double s0, t0;
+
+            double bvirt;
+            double avirt, bround, around;
+            double c;
+            double abig;
+            double ahi, alo, bhi, blo;
+            double err1, err2, err3;
+            double _i, _j;
+            double _0;
+
+            acx = (double)(pa.x - pc.x);
+            bcx = (double)(pb.x - pc.x);
+            acy = (double)(pa.y - pc.y);
+            bcy = (double)(pb.y - pc.y);
+
+            detleft = (double)(acx * bcy); c = (double)(splitter * acx); abig = (double)(c - acx); ahi = c - abig; alo = acx - ahi; c = (double)(splitter * bcy); abig = (double)(c - bcy); bhi = c - abig; blo = bcy - bhi; err1 = detleft - (ahi * bhi); err2 = err1 - (alo * bhi); err3 = err2 - (ahi * blo); detlefttail = (alo * blo) - err3;
+            detright = (double)(acy * bcx); c = (double)(splitter * acy); abig = (double)(c - acy); ahi = c - abig; alo = acy - ahi; c = (double)(splitter * bcx); abig = (double)(c - bcx); bhi = c - abig; blo = bcx - bhi; err1 = detright - (ahi * bhi); err2 = err1 - (alo * bhi); err3 = err2 - (ahi * blo); detrighttail = (alo * blo) - err3;
+
+            _i = (double)(detlefttail - detrighttail); bvirt = (double)(detlefttail - _i); avirt = _i + bvirt; bround = bvirt - detrighttail; around = detlefttail - avirt; B[0] = around + bround; _j = (double)(detleft + _i); bvirt = (double)(_j - detleft); avirt = _j - bvirt; bround = _i - bvirt; around = detleft - avirt; _0 = around + bround; _i = (double)(_0 - detright); bvirt = (double)(_0 - _i); avirt = _i + bvirt; bround = bvirt - detright; around = _0 - avirt; B[1] = around + bround; B3 = (double)(_j + _i); bvirt = (double)(B3 - _j); avirt = B3 - bvirt; bround = _i - bvirt; around = _j - avirt; B[2] = around + bround;
+
+            B[3] = B3;
+
+            det = Estimate(4, B);
+            errbound = ccwerrboundB * detsum;
+            if ((det >= errbound) || (-det >= errbound))
+            {
+                return det;
+            }
+
+            bvirt = (double)(pa.x - acx); avirt = acx + bvirt; bround = bvirt - pc.x; around = pa.x - avirt; acxtail = around + bround;
+            bvirt = (double)(pb.x - bcx); avirt = bcx + bvirt; bround = bvirt - pc.x; around = pb.x - avirt; bcxtail = around + bround;
+            bvirt = (double)(pa.y - acy); avirt = acy + bvirt; bround = bvirt - pc.y; around = pa.y - avirt; acytail = around + bround;
+            bvirt = (double)(pb.y - bcy); avirt = bcy + bvirt; bround = bvirt - pc.y; around = pb.y - avirt; bcytail = around + bround;
+
+            if ((acxtail == 0.0) && (acytail == 0.0)
+                && (bcxtail == 0.0) && (bcytail == 0.0))
+            {
+                return det;
+            }
+
+            errbound = ccwerrboundC * detsum + resulterrbound * ((det) >= 0.0 ? (det) : -(det));
+            det += (acx * bcytail + bcy * acxtail)
+                - (acy * bcxtail + bcx * acytail);
+            if ((det >= errbound) || (-det >= errbound))
+            {
+                return det;
+            }
+
+            s1 = (double)(acxtail * bcy); c = (double)(splitter * acxtail); abig = (double)(c - acxtail); ahi = c - abig; alo = acxtail - ahi; c = (double)(splitter * bcy); abig = (double)(c - bcy); bhi = c - abig; blo = bcy - bhi; err1 = s1 - (ahi * bhi); err2 = err1 - (alo * bhi); err3 = err2 - (ahi * blo); s0 = (alo * blo) - err3;
+            t1 = (double)(acytail * bcx); c = (double)(splitter * acytail); abig = (double)(c - acytail); ahi = c - abig; alo = acytail - ahi; c = (double)(splitter * bcx); abig = (double)(c - bcx); bhi = c - abig; blo = bcx - bhi; err1 = t1 - (ahi * bhi); err2 = err1 - (alo * bhi); err3 = err2 - (ahi * blo); t0 = (alo * blo) - err3;
+            _i = (double)(s0 - t0); bvirt = (double)(s0 - _i); avirt = _i + bvirt; bround = bvirt - t0; around = s0 - avirt; u[0] = around + bround; _j = (double)(s1 + _i); bvirt = (double)(_j - s1); avirt = _j - bvirt; bround = _i - bvirt; around = s1 - avirt; _0 = around + bround; _i = (double)(_0 - t1); bvirt = (double)(_0 - _i); avirt = _i + bvirt; bround = bvirt - t1; around = _0 - avirt; u[1] = around + bround; u3 = (double)(_j + _i); bvirt = (double)(u3 - _j); avirt = u3 - bvirt; bround = _i - bvirt; around = _j - avirt; u[2] = around + bround;
+            u[3] = u3;
+            C1length = FastExpansionSumZeroElim(4, B, 4, u, C1);
+
+            s1 = (double)(acx * bcytail); c = (double)(splitter * acx); abig = (double)(c - acx); ahi = c - abig; alo = acx - ahi; c = (double)(splitter * bcytail); abig = (double)(c - bcytail); bhi = c - abig; blo = bcytail - bhi; err1 = s1 - (ahi * bhi); err2 = err1 - (alo * bhi); err3 = err2 - (ahi * blo); s0 = (alo * blo) - err3;
+            t1 = (double)(acy * bcxtail); c = (double)(splitter * acy); abig = (double)(c - acy); ahi = c - abig; alo = acy - ahi; c = (double)(splitter * bcxtail); abig = (double)(c - bcxtail); bhi = c - abig; blo = bcxtail - bhi; err1 = t1 - (ahi * bhi); err2 = err1 - (alo * bhi); err3 = err2 - (ahi * blo); t0 = (alo * blo) - err3;
+            _i = (double)(s0 - t0); bvirt = (double)(s0 - _i); avirt = _i + bvirt; bround = bvirt - t0; around = s0 - avirt; u[0] = around + bround; _j = (double)(s1 + _i); bvirt = (double)(_j - s1); avirt = _j - bvirt; bround = _i - bvirt; around = s1 - avirt; _0 = around + bround; _i = (double)(_0 - t1); bvirt = (double)(_0 - _i); avirt = _i + bvirt; bround = bvirt - t1; around = _0 - avirt; u[1] = around + bround; u3 = (double)(_j + _i); bvirt = (double)(u3 - _j); avirt = u3 - bvirt; bround = _i - bvirt; around = _j - avirt; u[2] = around + bround;
+            u[3] = u3;
+            C2length = FastExpansionSumZeroElim(C1length, C1, 4, u, C2);
+
+            s1 = (double)(acxtail * bcytail); c = (double)(splitter * acxtail); abig = (double)(c - acxtail); ahi = c - abig; alo = acxtail - ahi; c = (double)(splitter * bcytail); abig = (double)(c - bcytail); bhi = c - abig; blo = bcytail - bhi; err1 = s1 - (ahi * bhi); err2 = err1 - (alo * bhi); err3 = err2 - (ahi * blo); s0 = (alo * blo) - err3;
+            t1 = (double)(acytail * bcxtail); c = (double)(splitter * acytail); abig = (double)(c - acytail); ahi = c - abig; alo = acytail - ahi; c = (double)(splitter * bcxtail); abig = (double)(c - bcxtail); bhi = c - abig; blo = bcxtail - bhi; err1 = t1 - (ahi * bhi); err2 = err1 - (alo * bhi); err3 = err2 - (ahi * blo); t0 = (alo * blo) - err3;
+            _i = (double)(s0 - t0); bvirt = (double)(s0 - _i); avirt = _i + bvirt; bround = bvirt - t0; around = s0 - avirt; u[0] = around + bround; _j = (double)(s1 + _i); bvirt = (double)(_j - s1); avirt = _j - bvirt; bround = _i - bvirt; around = s1 - avirt; _0 = around + bround; _i = (double)(_0 - t1); bvirt = (double)(_0 - _i); avirt = _i + bvirt; bround = bvirt - t1; around = _0 - avirt; u[1] = around + bround; u3 = (double)(_j + _i); bvirt = (double)(u3 - _j); avirt = u3 - bvirt; bround = _i - bvirt; around = _j - avirt; u[2] = around + bround;
+            u[3] = u3;
+            Dlength = FastExpansionSumZeroElim(C2length, C2, 4, u, D);
+
+            return (D[Dlength - 1]);
+        }
+
+        /// <summary>
+        /// Return a positive value if the point pd lies inside the circle passing through
+        /// pa, pb, and pc; a negative value if it lies outside; and zero if the four points
+        /// are cocircular. The points pa, pb, and pc must be in counterclockwise order, or
+        /// the sign of the result will be reversed.
+        /// </summary>
+        /// <param name="pa"></param>
+        /// <param name="pb"></param>
+        /// <param name="pc"></param>
+        /// <param name="pd"></param>
+        /// <param name="permanent"></param>
+        /// <returns></returns>
+        /// <remarks>
+        /// Uses exact arithmetic if necessary to ensure a correct answer. The result returned
+        /// is the determinant of a matrix. This determinant is computed adaptively, in the
+        /// sense that exact arithmetic is used only to the degree it is needed to ensure that
+        /// the returned value has the correct sign. Hence, this function is usually quite fast,
+        /// but will run more slowly when the input points are cocircular or nearly so.
+        /// </remarks>
+        private double InCircleAdapt(Point pa, Point pb, Point pc, Point pd, double permanent)
+        {
+            double adx, bdx, cdx, ady, bdy, cdy;
+            double det, errbound;
+
+            double bdxcdy1, cdxbdy1, cdxady1, adxcdy1, adxbdy1, bdxady1;
+            double bdxcdy0, cdxbdy0, cdxady0, adxcdy0, adxbdy0, bdxady0;
+            double[] bc = new double[4], ca = new double[4], ab = new double[4];
+            double bc3, ca3, ab3;
+            int axbclen, axxbclen, aybclen, ayybclen, alen;
+            int bxcalen, bxxcalen, bycalen, byycalen, blen;
+            int cxablen, cxxablen, cyablen, cyyablen, clen;
+            int ablen;
+            double[] finnow, finother, finswap;
+            int finlength;
+
+            double adxtail, bdxtail, cdxtail, adytail, bdytail, cdytail;
+            double adxadx1, adyady1, bdxbdx1, bdybdy1, cdxcdx1, cdycdy1;
+            double adxadx0, adyady0, bdxbdx0, bdybdy0, cdxcdx0, cdycdy0;
+            double[] aa = new double[4], bb = new double[4], cc = new double[4];
+            double aa3, bb3, cc3;
+            double ti1, tj1;
+            double ti0, tj0;
+            // Edited to work around index out of range exceptions (changed array length from 4 to 5).
+            // See unsafe indexing in FastExpansionSumZeroElim.
+            double[] u = new double[5], v = new double[5];
+            double u3, v3;
+            int temp8len, temp16alen, temp16blen, temp16clen;
+            int temp32alen, temp32blen, temp48len, temp64len;
+            double[] axtbb = new double[8], axtcc = new double[8], aytbb = new double[8], aytcc = new double[8];
+            int axtbblen, axtcclen, aytbblen, aytcclen;
+            double[] bxtaa = new double[8], bxtcc = new double[8], bytaa = new double[8], bytcc = new double[8];
+            int bxtaalen, bxtcclen, bytaalen, bytcclen;
+            double[] cxtaa = new double[8], cxtbb = new double[8], cytaa = new double[8], cytbb = new double[8];
+            int cxtaalen, cxtbblen, cytaalen, cytbblen;
+            double[] axtbc = new double[8], aytbc = new double[8], bxtca = new double[8], bytca = new double[8], cxtab = new double[8], cytab = new double[8];
+            int axtbclen = 0, aytbclen = 0, bxtcalen = 0, bytcalen = 0, cxtablen = 0, cytablen = 0;
+            double[] axtbct = new double[16], aytbct = new double[16], bxtcat = new double[16], bytcat = new double[16], cxtabt = new double[16], cytabt = new double[16];
+            int axtbctlen, aytbctlen, bxtcatlen, bytcatlen, cxtabtlen, cytabtlen;
+            double[] axtbctt = new double[8], aytbctt = new double[8], bxtcatt = new double[8];
+            double[] bytcatt = new double[8], cxtabtt = new double[8], cytabtt = new double[8];
+            int axtbcttlen, aytbcttlen, bxtcattlen, bytcattlen, cxtabttlen, cytabttlen;
+            double[] abt = new double[8], bct = new double[8], cat = new double[8];
+            int abtlen, bctlen, catlen;
+            double[] abtt = new double[4], bctt = new double[4], catt = new double[4];
+            int abttlen, bcttlen, cattlen;
+            double abtt3, bctt3, catt3;
+            double negate;
+
+            double bvirt;
+            double avirt, bround, around;
+            double c;
+            double abig;
+            double ahi, alo, bhi, blo;
+            double err1, err2, err3;
+            double _i, _j;
+            double _0;
+
+            adx = (double)(pa.x - pd.x);
+            bdx = (double)(pb.x - pd.x);
+            cdx = (double)(pc.x - pd.x);
+            ady = (double)(pa.y - pd.y);
+            bdy = (double)(pb.y - pd.y);
+            cdy = (double)(pc.y - pd.y);
+
+            adx = (double)(pa.x - pd.x);
+            bdx = (double)(pb.x - pd.x);
+            cdx = (double)(pc.x - pd.x);
+            ady = (double)(pa.y - pd.y);
+            bdy = (double)(pb.y - pd.y);
+            cdy = (double)(pc.y - pd.y);
+
+            bdxcdy1 = (double)(bdx * cdy); c = (double)(splitter * bdx); abig = (double)(c - bdx); ahi = c - abig; alo = bdx - ahi; c = (double)(splitter * cdy); abig = (double)(c - cdy); bhi = c - abig; blo = cdy - bhi; err1 = bdxcdy1 - (ahi * bhi); err2 = err1 - (alo * bhi); err3 = err2 - (ahi * blo); bdxcdy0 = (alo * blo) - err3;
+            cdxbdy1 = (double)(cdx * bdy); c = (double)(splitter * cdx); abig = (double)(c - cdx); ahi = c - abig; alo = cdx - ahi; c = (double)(splitter * bdy); abig = (double)(c - bdy); bhi = c - abig; blo = bdy - bhi; err1 = cdxbdy1 - (ahi * bhi); err2 = err1 - (alo * bhi); err3 = err2 - (ahi * blo); cdxbdy0 = (alo * blo) - err3;
+            _i = (double)(bdxcdy0 - cdxbdy0); bvirt = (double)(bdxcdy0 - _i); avirt = _i + bvirt; bround = bvirt - cdxbdy0; around = bdxcdy0 - avirt; bc[0] = around + bround; _j = (double)(bdxcdy1 + _i); bvirt = (double)(_j - bdxcdy1); avirt = _j - bvirt; bround = _i - bvirt; around = bdxcdy1 - avirt; _0 = around + bround; _i = (double)(_0 - cdxbdy1); bvirt = (double)(_0 - _i); avirt = _i + bvirt; bround = bvirt - cdxbdy1; around = _0 - avirt; bc[1] = around + bround; bc3 = (double)(_j + _i); bvirt = (double)(bc3 - _j); avirt = bc3 - bvirt; bround = _i - bvirt; around = _j - avirt; bc[2] = around + bround;
+            bc[3] = bc3;
+            axbclen = ScaleExpansionZeroElim(4, bc, adx, axbc);
+            axxbclen = ScaleExpansionZeroElim(axbclen, axbc, adx, axxbc);
+            aybclen = ScaleExpansionZeroElim(4, bc, ady, aybc);
+            ayybclen = ScaleExpansionZeroElim(aybclen, aybc, ady, ayybc);
+            alen = FastExpansionSumZeroElim(axxbclen, axxbc, ayybclen, ayybc, adet);
+
+            cdxady1 = (double)(cdx * ady); c = (double)(splitter * cdx); abig = (double)(c - cdx); ahi = c - abig; alo = cdx - ahi; c = (double)(splitter * ady); abig = (double)(c - ady); bhi = c - abig; blo = ady - bhi; err1 = cdxady1 - (ahi * bhi); err2 = err1 - (alo * bhi); err3 = err2 - (ahi * blo); cdxady0 = (alo * blo) - err3;
+            adxcdy1 = (double)(adx * cdy); c = (double)(splitter * adx); abig = (double)(c - adx); ahi = c - abig; alo = adx - ahi; c = (double)(splitter * cdy); abig = (double)(c - cdy); bhi = c - abig; blo = cdy - bhi; err1 = adxcdy1 - (ahi * bhi); err2 = err1 - (alo * bhi); err3 = err2 - (ahi * blo); adxcdy0 = (alo * blo) - err3;
+            _i = (double)(cdxady0 - adxcdy0); bvirt = (double)(cdxady0 - _i); avirt = _i + bvirt; bround = bvirt - adxcdy0; around = cdxady0 - avirt; ca[0] = around + bround; _j = (double)(cdxady1 + _i); bvirt = (double)(_j - cdxady1); avirt = _j - bvirt; bround = _i - bvirt; around = cdxady1 - avirt; _0 = around + bround; _i = (double)(_0 - adxcdy1); bvirt = (double)(_0 - _i); avirt = _i + bvirt; bround = bvirt - adxcdy1; around = _0 - avirt; ca[1] = around + bround; ca3 = (double)(_j + _i); bvirt = (double)(ca3 - _j); avirt = ca3 - bvirt; bround = _i - bvirt; around = _j - avirt; ca[2] = around + bround;
+            ca[3] = ca3;
+            bxcalen = ScaleExpansionZeroElim(4, ca, bdx, bxca);
+            bxxcalen = ScaleExpansionZeroElim(bxcalen, bxca, bdx, bxxca);
+            bycalen = ScaleExpansionZeroElim(4, ca, bdy, byca);
+            byycalen = ScaleExpansionZeroElim(bycalen, byca, bdy, byyca);
+            blen = FastExpansionSumZeroElim(bxxcalen, bxxca, byycalen, byyca, bdet);
+
+            adxbdy1 = (double)(adx * bdy); c = (double)(splitter * adx); abig = (double)(c - adx); ahi = c - abig; alo = adx - ahi; c = (double)(splitter * bdy); abig = (double)(c - bdy); bhi = c - abig; blo = bdy - bhi; err1 = adxbdy1 - (ahi * bhi); err2 = err1 - (alo * bhi); err3 = err2 - (ahi * blo); adxbdy0 = (alo * blo) - err3;
+            bdxady1 = (double)(bdx * ady); c = (double)(splitter * bdx); abig = (double)(c - bdx); ahi = c - abig; alo = bdx - ahi; c = (double)(splitter * ady); abig = (double)(c - ady); bhi = c - abig; blo = ady - bhi; err1 = bdxady1 - (ahi * bhi); err2 = err1 - (alo * bhi); err3 = err2 - (ahi * blo); bdxady0 = (alo * blo) - err3;
+            _i = (double)(adxbdy0 - bdxady0); bvirt = (double)(adxbdy0 - _i); avirt = _i + bvirt; bround = bvirt - bdxady0; around = adxbdy0 - avirt; ab[0] = around + bround; _j = (double)(adxbdy1 + _i); bvirt = (double)(_j - adxbdy1); avirt = _j - bvirt; bround = _i - bvirt; around = adxbdy1 - avirt; _0 = around + bround; _i = (double)(_0 - bdxady1); bvirt = (double)(_0 - _i); avirt = _i + bvirt; bround = bvirt - bdxady1; around = _0 - avirt; ab[1] = around + bround; ab3 = (double)(_j + _i); bvirt = (double)(ab3 - _j); avirt = ab3 - bvirt; bround = _i - bvirt; around = _j - avirt; ab[2] = around + bround;
+            ab[3] = ab3;
+            cxablen = ScaleExpansionZeroElim(4, ab, cdx, cxab);
+            cxxablen = ScaleExpansionZeroElim(cxablen, cxab, cdx, cxxab);
+            cyablen = ScaleExpansionZeroElim(4, ab, cdy, cyab);
+            cyyablen = ScaleExpansionZeroElim(cyablen, cyab, cdy, cyyab);
+            clen = FastExpansionSumZeroElim(cxxablen, cxxab, cyyablen, cyyab, cdet);
+
+            ablen = FastExpansionSumZeroElim(alen, adet, blen, bdet, abdet);
+            finlength = FastExpansionSumZeroElim(ablen, abdet, clen, cdet, fin1);
+
+            det = Estimate(finlength, fin1);
+            errbound = iccerrboundB * permanent;
+            if ((det >= errbound) || (-det >= errbound))
+            {
+                return det;
+            }
+
+            bvirt = (double)(pa.x - adx); avirt = adx + bvirt; bround = bvirt - pd.x; around = pa.x - avirt; adxtail = around + bround;
+            bvirt = (double)(pa.y - ady); avirt = ady + bvirt; bround = bvirt - pd.y; around = pa.y - avirt; adytail = around + bround;
+            bvirt = (double)(pb.x - bdx); avirt = bdx + bvirt; bround = bvirt - pd.x; around = pb.x - avirt; bdxtail = around + bround;
+            bvirt = (double)(pb.y - bdy); avirt = bdy + bvirt; bround = bvirt - pd.y; around = pb.y - avirt; bdytail = around + bround;
+            bvirt = (double)(pc.x - cdx); avirt = cdx + bvirt; bround = bvirt - pd.x; around = pc.x - avirt; cdxtail = around + bround;
+            bvirt = (double)(pc.y - cdy); avirt = cdy + bvirt; bround = bvirt - pd.y; around = pc.y - avirt; cdytail = around + bround;
+            if ((adxtail == 0.0) && (bdxtail == 0.0) && (cdxtail == 0.0)
+                && (adytail == 0.0) && (bdytail == 0.0) && (cdytail == 0.0))
+            {
+                return det;
+            }
+
+            errbound = iccerrboundC * permanent + resulterrbound * ((det) >= 0.0 ? (det) : -(det));
+            det += ((adx * adx + ady * ady) * ((bdx * cdytail + cdy * bdxtail) - (bdy * cdxtail + cdx * bdytail))
+                + 2.0 * (adx * adxtail + ady * adytail) * (bdx * cdy - bdy * cdx))
+                + ((bdx * bdx + bdy * bdy) * ((cdx * adytail + ady * cdxtail) - (cdy * adxtail + adx * cdytail))
+                    + 2.0 * (bdx * bdxtail + bdy * bdytail) * (cdx * ady - cdy * adx))
+                + ((cdx * cdx + cdy * cdy) * ((adx * bdytail + bdy * adxtail) - (ady * bdxtail + bdx * adytail))
+                    + 2.0 * (cdx * cdxtail + cdy * cdytail) * (adx * bdy - ady * bdx));
+            if ((det >= errbound) || (-det >= errbound))
+            {
+                return det;
+            }
+
+            finnow = fin1;
+            finother = fin2;
+
+            if ((bdxtail != 0.0) || (bdytail != 0.0) || (cdxtail != 0.0) || (cdytail != 0.0))
+            {
+                adxadx1 = (double)(adx * adx); c = (double)(splitter * adx); abig = (double)(c - adx); ahi = c - abig; alo = adx - ahi; err1 = adxadx1 - (ahi * ahi); err3 = err1 - ((ahi + ahi) * alo); adxadx0 = (alo * alo) - err3;
+                adyady1 = (double)(ady * ady); c = (double)(splitter * ady); abig = (double)(c - ady); ahi = c - abig; alo = ady - ahi; err1 = adyady1 - (ahi * ahi); err3 = err1 - ((ahi + ahi) * alo); adyady0 = (alo * alo) - err3;
+                _i = (double)(adxadx0 + adyady0); bvirt = (double)(_i - adxadx0); avirt = _i - bvirt; bround = adyady0 - bvirt; around = adxadx0 - avirt; aa[0] = around + bround; _j = (double)(adxadx1 + _i); bvirt = (double)(_j - adxadx1); avirt = _j - bvirt; bround = _i - bvirt; around = adxadx1 - avirt; _0 = around + bround; _i = (double)(_0 + adyady1); bvirt = (double)(_i - _0); avirt = _i - bvirt; bround = adyady1 - bvirt; around = _0 - avirt; aa[1] = around + bround; aa3 = (double)(_j + _i); bvirt = (double)(aa3 - _j); avirt = aa3 - bvirt; bround = _i - bvirt; around = _j - avirt; aa[2] = around + bround;
+                aa[3] = aa3;
+            }
+            if ((cdxtail != 0.0) || (cdytail != 0.0) || (adxtail != 0.0) || (adytail != 0.0))
+            {
+                bdxbdx1 = (double)(bdx * bdx); c = (double)(splitter * bdx); abig = (double)(c - bdx); ahi = c - abig; alo = bdx - ahi; err1 = bdxbdx1 - (ahi * ahi); err3 = err1 - ((ahi + ahi) * alo); bdxbdx0 = (alo * alo) - err3;
+                bdybdy1 = (double)(bdy * bdy); c = (double)(splitter * bdy); abig = (double)(c - bdy); ahi = c - abig; alo = bdy - ahi; err1 = bdybdy1 - (ahi * ahi); err3 = err1 - ((ahi + ahi) * alo); bdybdy0 = (alo * alo) - err3;
+                _i = (double)(bdxbdx0 + bdybdy0); bvirt = (double)(_i - bdxbdx0); avirt = _i - bvirt; bround = bdybdy0 - bvirt; around = bdxbdx0 - avirt; bb[0] = around + bround; _j = (double)(bdxbdx1 + _i); bvirt = (double)(_j - bdxbdx1); avirt = _j - bvirt; bround = _i - bvirt; around = bdxbdx1 - avirt; _0 = around + bround; _i = (double)(_0 + bdybdy1); bvirt = (double)(_i - _0); avirt = _i - bvirt; bround = bdybdy1 - bvirt; around = _0 - avirt; bb[1] = around + bround; bb3 = (double)(_j + _i); bvirt = (double)(bb3 - _j); avirt = bb3 - bvirt; bround = _i - bvirt; around = _j - avirt; bb[2] = around + bround;
+                bb[3] = bb3;
+            }
+            if ((adxtail != 0.0) || (adytail != 0.0) || (bdxtail != 0.0) || (bdytail != 0.0))
+            {
+                cdxcdx1 = (double)(cdx * cdx); c = (double)(splitter * cdx); abig = (double)(c - cdx); ahi = c - abig; alo = cdx - ahi; err1 = cdxcdx1 - (ahi * ahi); err3 = err1 - ((ahi + ahi) * alo); cdxcdx0 = (alo * alo) - err3;
+                cdycdy1 = (double)(cdy * cdy); c = (double)(splitter * cdy); abig = (double)(c - cdy); ahi = c - abig; alo = cdy - ahi; err1 = cdycdy1 - (ahi * ahi); err3 = err1 - ((ahi + ahi) * alo); cdycdy0 = (alo * alo) - err3;
+                _i = (double)(cdxcdx0 + cdycdy0); bvirt = (double)(_i - cdxcdx0); avirt = _i - bvirt; bround = cdycdy0 - bvirt; around = cdxcdx0 - avirt; cc[0] = around + bround; _j = (double)(cdxcdx1 + _i); bvirt = (double)(_j - cdxcdx1); avirt = _j - bvirt; bround = _i - bvirt; around = cdxcdx1 - avirt; _0 = around + bround; _i = (double)(_0 + cdycdy1); bvirt = (double)(_i - _0); avirt = _i - bvirt; bround = cdycdy1 - bvirt; around = _0 - avirt; cc[1] = around + bround; cc3 = (double)(_j + _i); bvirt = (double)(cc3 - _j); avirt = cc3 - bvirt; bround = _i - bvirt; around = _j - avirt; cc[2] = around + bround;
+                cc[3] = cc3;
+            }
+
+            if (adxtail != 0.0)
+            {
+                axtbclen = ScaleExpansionZeroElim(4, bc, adxtail, axtbc);
+                temp16alen = ScaleExpansionZeroElim(axtbclen, axtbc, 2.0 * adx, temp16a);
+
+                axtcclen = ScaleExpansionZeroElim(4, cc, adxtail, axtcc);
+                temp16blen = ScaleExpansionZeroElim(axtcclen, axtcc, bdy, temp16b);
+
+                axtbblen = ScaleExpansionZeroElim(4, bb, adxtail, axtbb);
+                temp16clen = ScaleExpansionZeroElim(axtbblen, axtbb, -cdy, temp16c);
+
+                temp32alen = FastExpansionSumZeroElim(temp16alen, temp16a, temp16blen, temp16b, temp32a);
+                temp48len = FastExpansionSumZeroElim(temp16clen, temp16c, temp32alen, temp32a, temp48);
+                finlength = FastExpansionSumZeroElim(finlength, finnow, temp48len, temp48, finother);
+                finswap = finnow; finnow = finother; finother = finswap;
+            }
+            if (adytail != 0.0)
+            {
+                aytbclen = ScaleExpansionZeroElim(4, bc, adytail, aytbc);
+                temp16alen = ScaleExpansionZeroElim(aytbclen, aytbc, 2.0 * ady, temp16a);
+
+                aytbblen = ScaleExpansionZeroElim(4, bb, adytail, aytbb);
+                temp16blen = ScaleExpansionZeroElim(aytbblen, aytbb, cdx, temp16b);
+
+                aytcclen = ScaleExpansionZeroElim(4, cc, adytail, aytcc);
+                temp16clen = ScaleExpansionZeroElim(aytcclen, aytcc, -bdx, temp16c);
+
+                temp32alen = FastExpansionSumZeroElim(temp16alen, temp16a, temp16blen, temp16b, temp32a);
+                temp48len = FastExpansionSumZeroElim(temp16clen, temp16c, temp32alen, temp32a, temp48);
+                finlength = FastExpansionSumZeroElim(finlength, finnow, temp48len, temp48, finother);
+                finswap = finnow; finnow = finother; finother = finswap;
+            }
+            if (bdxtail != 0.0)
+            {
+                bxtcalen = ScaleExpansionZeroElim(4, ca, bdxtail, bxtca);
+                temp16alen = ScaleExpansionZeroElim(bxtcalen, bxtca, 2.0 * bdx, temp16a);
+
+                bxtaalen = ScaleExpansionZeroElim(4, aa, bdxtail, bxtaa);
+                temp16blen = ScaleExpansionZeroElim(bxtaalen, bxtaa, cdy, temp16b);
+
+                bxtcclen = ScaleExpansionZeroElim(4, cc, bdxtail, bxtcc);
+                temp16clen = ScaleExpansionZeroElim(bxtcclen, bxtcc, -ady, temp16c);
+
+                temp32alen = FastExpansionSumZeroElim(temp16alen, temp16a, temp16blen, temp16b, temp32a);
+                temp48len = FastExpansionSumZeroElim(temp16clen, temp16c, temp32alen, temp32a, temp48);
+                finlength = FastExpansionSumZeroElim(finlength, finnow, temp48len, temp48, finother);
+                finswap = finnow; finnow = finother; finother = finswap;
+            }
+            if (bdytail != 0.0)
+            {
+                bytcalen = ScaleExpansionZeroElim(4, ca, bdytail, bytca);
+                temp16alen = ScaleExpansionZeroElim(bytcalen, bytca, 2.0 * bdy, temp16a);
+
+                bytcclen = ScaleExpansionZeroElim(4, cc, bdytail, bytcc);
+                temp16blen = ScaleExpansionZeroElim(bytcclen, bytcc, adx, temp16b);
+
+                bytaalen = ScaleExpansionZeroElim(4, aa, bdytail, bytaa);
+                temp16clen = ScaleExpansionZeroElim(bytaalen, bytaa, -cdx, temp16c);
+
+                temp32alen = FastExpansionSumZeroElim(temp16alen, temp16a, temp16blen, temp16b, temp32a);
+                temp48len = FastExpansionSumZeroElim(temp16clen, temp16c, temp32alen, temp32a, temp48);
+                finlength = FastExpansionSumZeroElim(finlength, finnow, temp48len, temp48, finother);
+                finswap = finnow; finnow = finother; finother = finswap;
+            }
+            if (cdxtail != 0.0)
+            {
+                cxtablen = ScaleExpansionZeroElim(4, ab, cdxtail, cxtab);
+                temp16alen = ScaleExpansionZeroElim(cxtablen, cxtab, 2.0 * cdx, temp16a);
+
+                cxtbblen = ScaleExpansionZeroElim(4, bb, cdxtail, cxtbb);
+                temp16blen = ScaleExpansionZeroElim(cxtbblen, cxtbb, ady, temp16b);
+
+                cxtaalen = ScaleExpansionZeroElim(4, aa, cdxtail, cxtaa);
+                temp16clen = ScaleExpansionZeroElim(cxtaalen, cxtaa, -bdy, temp16c);
+
+                temp32alen = FastExpansionSumZeroElim(temp16alen, temp16a, temp16blen, temp16b, temp32a);
+                temp48len = FastExpansionSumZeroElim(temp16clen, temp16c, temp32alen, temp32a, temp48);
+                finlength = FastExpansionSumZeroElim(finlength, finnow, temp48len, temp48, finother);
+                finswap = finnow; finnow = finother; finother = finswap;
+            }
+            if (cdytail != 0.0)
+            {
+                cytablen = ScaleExpansionZeroElim(4, ab, cdytail, cytab);
+                temp16alen = ScaleExpansionZeroElim(cytablen, cytab, 2.0 * cdy, temp16a);
+
+                cytaalen = ScaleExpansionZeroElim(4, aa, cdytail, cytaa);
+                temp16blen = ScaleExpansionZeroElim(cytaalen, cytaa, bdx, temp16b);
+
+                cytbblen = ScaleExpansionZeroElim(4, bb, cdytail, cytbb);
+                temp16clen = ScaleExpansionZeroElim(cytbblen, cytbb, -adx, temp16c);
+
+                temp32alen = FastExpansionSumZeroElim(temp16alen, temp16a, temp16blen, temp16b, temp32a);
+                temp48len = FastExpansionSumZeroElim(temp16clen, temp16c, temp32alen, temp32a, temp48);
+                finlength = FastExpansionSumZeroElim(finlength, finnow, temp48len, temp48, finother);
+                finswap = finnow; finnow = finother; finother = finswap;
+            }
+
+            if ((adxtail != 0.0) || (adytail != 0.0))
+            {
+                if ((bdxtail != 0.0) || (bdytail != 0.0)
+                    || (cdxtail != 0.0) || (cdytail != 0.0))
+                {
+                    ti1 = (double)(bdxtail * cdy); c = (double)(splitter * bdxtail); abig = (double)(c - bdxtail); ahi = c - abig; alo = bdxtail - ahi; c = (double)(splitter * cdy); abig = (double)(c - cdy); bhi = c - abig; blo = cdy - bhi; err1 = ti1 - (ahi * bhi); err2 = err1 - (alo * bhi); err3 = err2 - (ahi * blo); ti0 = (alo * blo) - err3;
+                    tj1 = (double)(bdx * cdytail); c = (double)(splitter * bdx); abig = (double)(c - bdx); ahi = c - abig; alo = bdx - ahi; c = (double)(splitter * cdytail); abig = (double)(c - cdytail); bhi = c - abig; blo = cdytail - bhi; err1 = tj1 - (ahi * bhi); err2 = err1 - (alo * bhi); err3 = err2 - (ahi * blo); tj0 = (alo * blo) - err3;
+                    _i = (double)(ti0 + tj0); bvirt = (double)(_i - ti0); avirt = _i - bvirt; bround = tj0 - bvirt; around = ti0 - avirt; u[0] = around + bround; _j = (double)(ti1 + _i); bvirt = (double)(_j - ti1); avirt = _j - bvirt; bround = _i - bvirt; around = ti1 - avirt; _0 = around + bround; _i = (double)(_0 + tj1); bvirt = (double)(_i - _0); avirt = _i - bvirt; bround = tj1 - bvirt; around = _0 - avirt; u[1] = around + bround; u3 = (double)(_j + _i); bvirt = (double)(u3 - _j); avirt = u3 - bvirt; bround = _i - bvirt; around = _j - avirt; u[2] = around + bround;
+                    u[3] = u3;
+                    negate = -bdy;
+                    ti1 = (double)(cdxtail * negate); c = (double)(splitter * cdxtail); abig = (double)(c - cdxtail); ahi = c - abig; alo = cdxtail - ahi; c = (double)(splitter * negate); abig = (double)(c - negate); bhi = c - abig; blo = negate - bhi; err1 = ti1 - (ahi * bhi); err2 = err1 - (alo * bhi); err3 = err2 - (ahi * blo); ti0 = (alo * blo) - err3;
+                    negate = -bdytail;
+                    tj1 = (double)(cdx * negate); c = (double)(splitter * cdx); abig = (double)(c - cdx); ahi = c - abig; alo = cdx - ahi; c = (double)(splitter * negate); abig = (double)(c - negate); bhi = c - abig; blo = negate - bhi; err1 = tj1 - (ahi * bhi); err2 = err1 - (alo * bhi); err3 = err2 - (ahi * blo); tj0 = (alo * blo) - err3;
+                    _i = (double)(ti0 + tj0); bvirt = (double)(_i - ti0); avirt = _i - bvirt; bround = tj0 - bvirt; around = ti0 - avirt; v[0] = around + bround; _j = (double)(ti1 + _i); bvirt = (double)(_j - ti1); avirt = _j - bvirt; bround = _i - bvirt; around = ti1 - avirt; _0 = around + bround; _i = (double)(_0 + tj1); bvirt = (double)(_i - _0); avirt = _i - bvirt; bround = tj1 - bvirt; around = _0 - avirt; v[1] = around + bround; v3 = (double)(_j + _i); bvirt = (double)(v3 - _j); avirt = v3 - bvirt; bround = _i - bvirt; around = _j - avirt; v[2] = around + bround;
+                    v[3] = v3;
+                    bctlen = FastExpansionSumZeroElim(4, u, 4, v, bct);
+
+                    ti1 = (double)(bdxtail * cdytail); c = (double)(splitter * bdxtail); abig = (double)(c - bdxtail); ahi = c - abig; alo = bdxtail - ahi; c = (double)(splitter * cdytail); abig = (double)(c - cdytail); bhi = c - abig; blo = cdytail - bhi; err1 = ti1 - (ahi * bhi); err2 = err1 - (alo * bhi); err3 = err2 - (ahi * blo); ti0 = (alo * blo) - err3;
+                    tj1 = (double)(cdxtail * bdytail); c = (double)(splitter * cdxtail); abig = (double)(c - cdxtail); ahi = c - abig; alo = cdxtail - ahi; c = (double)(splitter * bdytail); abig = (double)(c - bdytail); bhi = c - abig; blo = bdytail - bhi; err1 = tj1 - (ahi * bhi); err2 = err1 - (alo * bhi); err3 = err2 - (ahi * blo); tj0 = (alo * blo) - err3;
+                    _i = (double)(ti0 - tj0); bvirt = (double)(ti0 - _i); avirt = _i + bvirt; bround = bvirt - tj0; around = ti0 - avirt; bctt[0] = around + bround; _j = (double)(ti1 + _i); bvirt = (double)(_j - ti1); avirt = _j - bvirt; bround = _i - bvirt; around = ti1 - avirt; _0 = around + bround; _i = (double)(_0 - tj1); bvirt = (double)(_0 - _i); avirt = _i + bvirt; bround = bvirt - tj1; around = _0 - avirt; bctt[1] = around + bround; bctt3 = (double)(_j + _i); bvirt = (double)(bctt3 - _j); avirt = bctt3 - bvirt; bround = _i - bvirt; around = _j - avirt; bctt[2] = around + bround;
+                    bctt[3] = bctt3;
+                    bcttlen = 4;
+                }
+                else
+                {
+                    bct[0] = 0.0;
+                    bctlen = 1;
+                    bctt[0] = 0.0;
+                    bcttlen = 1;
+                }
+
+                if (adxtail != 0.0)
+                {
+                    temp16alen = ScaleExpansionZeroElim(axtbclen, axtbc, adxtail, temp16a);
+                    axtbctlen = ScaleExpansionZeroElim(bctlen, bct, adxtail, axtbct);
+                    temp32alen = ScaleExpansionZeroElim(axtbctlen, axtbct, 2.0 * adx, temp32a);
+                    temp48len = FastExpansionSumZeroElim(temp16alen, temp16a, temp32alen, temp32a, temp48);
+                    finlength = FastExpansionSumZeroElim(finlength, finnow, temp48len, temp48, finother);
+                    finswap = finnow; finnow = finother; finother = finswap;
+                    if (bdytail != 0.0)
+                    {
+                        temp8len = ScaleExpansionZeroElim(4, cc, adxtail, temp8);
+                        temp16alen = ScaleExpansionZeroElim(temp8len, temp8, bdytail, temp16a);
+                        finlength = FastExpansionSumZeroElim(finlength, finnow, temp16alen, temp16a, finother);
+                        finswap = finnow; finnow = finother; finother = finswap;
+                    }
+                    if (cdytail != 0.0)
+                    {
+                        temp8len = ScaleExpansionZeroElim(4, bb, -adxtail, temp8);
+                        temp16alen = ScaleExpansionZeroElim(temp8len, temp8, cdytail, temp16a);
+                        finlength = FastExpansionSumZeroElim(finlength, finnow, temp16alen, temp16a, finother);
+                        finswap = finnow; finnow = finother; finother = finswap;
+                    }
+
+                    temp32alen = ScaleExpansionZeroElim(axtbctlen, axtbct, adxtail, temp32a);
+                    axtbcttlen = ScaleExpansionZeroElim(bcttlen, bctt, adxtail, axtbctt);
+                    temp16alen = ScaleExpansionZeroElim(axtbcttlen, axtbctt, 2.0 * adx, temp16a);
+                    temp16blen = ScaleExpansionZeroElim(axtbcttlen, axtbctt, adxtail, temp16b);
+                    temp32blen = FastExpansionSumZeroElim(temp16alen, temp16a, temp16blen, temp16b, temp32b);
+                    temp64len = FastExpansionSumZeroElim(temp32alen, temp32a, temp32blen, temp32b, temp64);
+                    finlength = FastExpansionSumZeroElim(finlength, finnow, temp64len, temp64, finother);
+                    finswap = finnow; finnow = finother; finother = finswap;
+                }
+                if (adytail != 0.0)
+                {
+                    temp16alen = ScaleExpansionZeroElim(aytbclen, aytbc, adytail, temp16a);
+                    aytbctlen = ScaleExpansionZeroElim(bctlen, bct, adytail, aytbct);
+                    temp32alen = ScaleExpansionZeroElim(aytbctlen, aytbct, 2.0 * ady, temp32a);
+                    temp48len = FastExpansionSumZeroElim(temp16alen, temp16a, temp32alen, temp32a, temp48);
+                    finlength = FastExpansionSumZeroElim(finlength, finnow, temp48len, temp48, finother);
+                    finswap = finnow; finnow = finother; finother = finswap;
+
+
+                    temp32alen = ScaleExpansionZeroElim(aytbctlen, aytbct, adytail, temp32a);
+                    aytbcttlen = ScaleExpansionZeroElim(bcttlen, bctt, adytail, aytbctt);
+                    temp16alen = ScaleExpansionZeroElim(aytbcttlen, aytbctt, 2.0 * ady, temp16a);
+                    temp16blen = ScaleExpansionZeroElim(aytbcttlen, aytbctt, adytail, temp16b);
+                    temp32blen = FastExpansionSumZeroElim(temp16alen, temp16a, temp16blen, temp16b, temp32b);
+                    temp64len = FastExpansionSumZeroElim(temp32alen, temp32a, temp32blen, temp32b, temp64);
+                    finlength = FastExpansionSumZeroElim(finlength, finnow, temp64len, temp64, finother);
+                    finswap = finnow; finnow = finother; finother = finswap;
+                }
+            }
+            if ((bdxtail != 0.0) || (bdytail != 0.0))
+            {
+                if ((cdxtail != 0.0) || (cdytail != 0.0)
+                    || (adxtail != 0.0) || (adytail != 0.0))
+                {
+                    ti1 = (double)(cdxtail * ady); c = (double)(splitter * cdxtail); abig = (double)(c - cdxtail); ahi = c - abig; alo = cdxtail - ahi; c = (double)(splitter * ady); abig = (double)(c - ady); bhi = c - abig; blo = ady - bhi; err1 = ti1 - (ahi * bhi); err2 = err1 - (alo * bhi); err3 = err2 - (ahi * blo); ti0 = (alo * blo) - err3;
+                    tj1 = (double)(cdx * adytail); c = (double)(splitter * cdx); abig = (double)(c - cdx); ahi = c - abig; alo = cdx - ahi; c = (double)(splitter * adytail); abig = (double)(c - adytail); bhi = c - abig; blo = adytail - bhi; err1 = tj1 - (ahi * bhi); err2 = err1 - (alo * bhi); err3 = err2 - (ahi * blo); tj0 = (alo * blo) - err3;
+                    _i = (double)(ti0 + tj0); bvirt = (double)(_i - ti0); avirt = _i - bvirt; bround = tj0 - bvirt; around = ti0 - avirt; u[0] = around + bround; _j = (double)(ti1 + _i); bvirt = (double)(_j - ti1); avirt = _j - bvirt; bround = _i - bvirt; around = ti1 - avirt; _0 = around + bround; _i = (double)(_0 + tj1); bvirt = (double)(_i - _0); avirt = _i - bvirt; bround = tj1 - bvirt; around = _0 - avirt; u[1] = around + bround; u3 = (double)(_j + _i); bvirt = (double)(u3 - _j); avirt = u3 - bvirt; bround = _i - bvirt; around = _j - avirt; u[2] = around + bround;
+                    u[3] = u3;
+                    negate = -cdy;
+                    ti1 = (double)(adxtail * negate); c = (double)(splitter * adxtail); abig = (double)(c - adxtail); ahi = c - abig; alo = adxtail - ahi; c = (double)(splitter * negate); abig = (double)(c - negate); bhi = c - abig; blo = negate - bhi; err1 = ti1 - (ahi * bhi); err2 = err1 - (alo * bhi); err3 = err2 - (ahi * blo); ti0 = (alo * blo) - err3;
+                    negate = -cdytail;
+                    tj1 = (double)(adx * negate); c = (double)(splitter * adx); abig = (double)(c - adx); ahi = c - abig; alo = adx - ahi; c = (double)(splitter * negate); abig = (double)(c - negate); bhi = c - abig; blo = negate - bhi; err1 = tj1 - (ahi * bhi); err2 = err1 - (alo * bhi); err3 = err2 - (ahi * blo); tj0 = (alo * blo) - err3;
+                    _i = (double)(ti0 + tj0); bvirt = (double)(_i - ti0); avirt = _i - bvirt; bround = tj0 - bvirt; around = ti0 - avirt; v[0] = around + bround; _j = (double)(ti1 + _i); bvirt = (double)(_j - ti1); avirt = _j - bvirt; bround = _i - bvirt; around = ti1 - avirt; _0 = around + bround; _i = (double)(_0 + tj1); bvirt = (double)(_i - _0); avirt = _i - bvirt; bround = tj1 - bvirt; around = _0 - avirt; v[1] = around + bround; v3 = (double)(_j + _i); bvirt = (double)(v3 - _j); avirt = v3 - bvirt; bround = _i - bvirt; around = _j - avirt; v[2] = around + bround;
+                    v[3] = v3;
+                    catlen = FastExpansionSumZeroElim(4, u, 4, v, cat);
+
+                    ti1 = (double)(cdxtail * adytail); c = (double)(splitter * cdxtail); abig = (double)(c - cdxtail); ahi = c - abig; alo = cdxtail - ahi; c = (double)(splitter * adytail); abig = (double)(c - adytail); bhi = c - abig; blo = adytail - bhi; err1 = ti1 - (ahi * bhi); err2 = err1 - (alo * bhi); err3 = err2 - (ahi * blo); ti0 = (alo * blo) - err3;
+                    tj1 = (double)(adxtail * cdytail); c = (double)(splitter * adxtail); abig = (double)(c - adxtail); ahi = c - abig; alo = adxtail - ahi; c = (double)(splitter * cdytail); abig = (double)(c - cdytail); bhi = c - abig; blo = cdytail - bhi; err1 = tj1 - (ahi * bhi); err2 = err1 - (alo * bhi); err3 = err2 - (ahi * blo); tj0 = (alo * blo) - err3;
+                    _i = (double)(ti0 - tj0); bvirt = (double)(ti0 - _i); avirt = _i + bvirt; bround = bvirt - tj0; around = ti0 - avirt; catt[0] = around + bround; _j = (double)(ti1 + _i); bvirt = (double)(_j - ti1); avirt = _j - bvirt; bround = _i - bvirt; around = ti1 - avirt; _0 = around + bround; _i = (double)(_0 - tj1); bvirt = (double)(_0 - _i); avirt = _i + bvirt; bround = bvirt - tj1; around = _0 - avirt; catt[1] = around + bround; catt3 = (double)(_j + _i); bvirt = (double)(catt3 - _j); avirt = catt3 - bvirt; bround = _i - bvirt; around = _j - avirt; catt[2] = around + bround;
+                    catt[3] = catt3;
+                    cattlen = 4;
+                }
+                else
+                {
+                    cat[0] = 0.0;
+                    catlen = 1;
+                    catt[0] = 0.0;
+                    cattlen = 1;
+                }
+
+                if (bdxtail != 0.0)
+                {
+                    temp16alen = ScaleExpansionZeroElim(bxtcalen, bxtca, bdxtail, temp16a);
+                    bxtcatlen = ScaleExpansionZeroElim(catlen, cat, bdxtail, bxtcat);
+                    temp32alen = ScaleExpansionZeroElim(bxtcatlen, bxtcat, 2.0 * bdx, temp32a);
+                    temp48len = FastExpansionSumZeroElim(temp16alen, temp16a, temp32alen, temp32a, temp48);
+                    finlength = FastExpansionSumZeroElim(finlength, finnow, temp48len, temp48, finother);
+                    finswap = finnow; finnow = finother; finother = finswap;
+                    if (cdytail != 0.0)
+                    {
+                        temp8len = ScaleExpansionZeroElim(4, aa, bdxtail, temp8);
+                        temp16alen = ScaleExpansionZeroElim(temp8len, temp8, cdytail, temp16a);
+                        finlength = FastExpansionSumZeroElim(finlength, finnow, temp16alen, temp16a, finother);
+                        finswap = finnow; finnow = finother; finother = finswap;
+                    }
+                    if (adytail != 0.0)
+                    {
+                        temp8len = ScaleExpansionZeroElim(4, cc, -bdxtail, temp8);
+                        temp16alen = ScaleExpansionZeroElim(temp8len, temp8, adytail, temp16a);
+                        finlength = FastExpansionSumZeroElim(finlength, finnow, temp16alen, temp16a, finother);
+                        finswap = finnow; finnow = finother; finother = finswap;
+                    }
+
+                    temp32alen = ScaleExpansionZeroElim(bxtcatlen, bxtcat, bdxtail, temp32a);
+                    bxtcattlen = ScaleExpansionZeroElim(cattlen, catt, bdxtail, bxtcatt);
+                    temp16alen = ScaleExpansionZeroElim(bxtcattlen, bxtcatt, 2.0 * bdx, temp16a);
+                    temp16blen = ScaleExpansionZeroElim(bxtcattlen, bxtcatt, bdxtail, temp16b);
+                    temp32blen = FastExpansionSumZeroElim(temp16alen, temp16a, temp16blen, temp16b, temp32b);
+                    temp64len = FastExpansionSumZeroElim(temp32alen, temp32a, temp32blen, temp32b, temp64);
+                    finlength = FastExpansionSumZeroElim(finlength, finnow, temp64len, temp64, finother);
+                    finswap = finnow; finnow = finother; finother = finswap;
+                }
+                if (bdytail != 0.0)
+                {
+                    temp16alen = ScaleExpansionZeroElim(bytcalen, bytca, bdytail, temp16a);
+                    bytcatlen = ScaleExpansionZeroElim(catlen, cat, bdytail, bytcat);
+                    temp32alen = ScaleExpansionZeroElim(bytcatlen, bytcat, 2.0 * bdy, temp32a);
+                    temp48len = FastExpansionSumZeroElim(temp16alen, temp16a, temp32alen, temp32a, temp48);
+                    finlength = FastExpansionSumZeroElim(finlength, finnow, temp48len, temp48, finother);
+                    finswap = finnow; finnow = finother; finother = finswap;
+
+                    temp32alen = ScaleExpansionZeroElim(bytcatlen, bytcat, bdytail, temp32a);
+                    bytcattlen = ScaleExpansionZeroElim(cattlen, catt, bdytail, bytcatt);
+                    temp16alen = ScaleExpansionZeroElim(bytcattlen, bytcatt, 2.0 * bdy, temp16a);
+                    temp16blen = ScaleExpansionZeroElim(bytcattlen, bytcatt, bdytail, temp16b);
+                    temp32blen = FastExpansionSumZeroElim(temp16alen, temp16a, temp16blen, temp16b, temp32b);
+                    temp64len = FastExpansionSumZeroElim(temp32alen, temp32a, temp32blen, temp32b, temp64);
+                    finlength = FastExpansionSumZeroElim(finlength, finnow, temp64len, temp64, finother);
+                    finswap = finnow; finnow = finother; finother = finswap;
+                }
+            }
+            if ((cdxtail != 0.0) || (cdytail != 0.0))
+            {
+                if ((adxtail != 0.0) || (adytail != 0.0)
+                    || (bdxtail != 0.0) || (bdytail != 0.0))
+                {
+                    ti1 = (double)(adxtail * bdy); c = (double)(splitter * adxtail); abig = (double)(c - adxtail); ahi = c - abig; alo = adxtail - ahi; c = (double)(splitter * bdy); abig = (double)(c - bdy); bhi = c - abig; blo = bdy - bhi; err1 = ti1 - (ahi * bhi); err2 = err1 - (alo * bhi); err3 = err2 - (ahi * blo); ti0 = (alo * blo) - err3;
+                    tj1 = (double)(adx * bdytail); c = (double)(splitter * adx); abig = (double)(c - adx); ahi = c - abig; alo = adx - ahi; c = (double)(splitter * bdytail); abig = (double)(c - bdytail); bhi = c - abig; blo = bdytail - bhi; err1 = tj1 - (ahi * bhi); err2 = err1 - (alo * bhi); err3 = err2 - (ahi * blo); tj0 = (alo * blo) - err3;
+                    _i = (double)(ti0 + tj0); bvirt = (double)(_i - ti0); avirt = _i - bvirt; bround = tj0 - bvirt; around = ti0 - avirt; u[0] = around + bround; _j = (double)(ti1 + _i); bvirt = (double)(_j - ti1); avirt = _j - bvirt; bround = _i - bvirt; around = ti1 - avirt; _0 = around + bround; _i = (double)(_0 + tj1); bvirt = (double)(_i - _0); avirt = _i - bvirt; bround = tj1 - bvirt; around = _0 - avirt; u[1] = around + bround; u3 = (double)(_j + _i); bvirt = (double)(u3 - _j); avirt = u3 - bvirt; bround = _i - bvirt; around = _j - avirt; u[2] = around + bround;
+                    u[3] = u3;
+                    negate = -ady;
+                    ti1 = (double)(bdxtail * negate); c = (double)(splitter * bdxtail); abig = (double)(c - bdxtail); ahi = c - abig; alo = bdxtail - ahi; c = (double)(splitter * negate); abig = (double)(c - negate); bhi = c - abig; blo = negate - bhi; err1 = ti1 - (ahi * bhi); err2 = err1 - (alo * bhi); err3 = err2 - (ahi * blo); ti0 = (alo * blo) - err3;
+                    negate = -adytail;
+                    tj1 = (double)(bdx * negate); c = (double)(splitter * bdx); abig = (double)(c - bdx); ahi = c - abig; alo = bdx - ahi; c = (double)(splitter * negate); abig = (double)(c - negate); bhi = c - abig; blo = negate - bhi; err1 = tj1 - (ahi * bhi); err2 = err1 - (alo * bhi); err3 = err2 - (ahi * blo); tj0 = (alo * blo) - err3;
+                    _i = (double)(ti0 + tj0); bvirt = (double)(_i - ti0); avirt = _i - bvirt; bround = tj0 - bvirt; around = ti0 - avirt; v[0] = around + bround; _j = (double)(ti1 + _i); bvirt = (double)(_j - ti1); avirt = _j - bvirt; bround = _i - bvirt; around = ti1 - avirt; _0 = around + bround; _i = (double)(_0 + tj1); bvirt = (double)(_i - _0); avirt = _i - bvirt; bround = tj1 - bvirt; around = _0 - avirt; v[1] = around + bround; v3 = (double)(_j + _i); bvirt = (double)(v3 - _j); avirt = v3 - bvirt; bround = _i - bvirt; around = _j - avirt; v[2] = around + bround;
+                    v[3] = v3;
+                    abtlen = FastExpansionSumZeroElim(4, u, 4, v, abt);
+
+                    ti1 = (double)(adxtail * bdytail); c = (double)(splitter * adxtail); abig = (double)(c - adxtail); ahi = c - abig; alo = adxtail - ahi; c = (double)(splitter * bdytail); abig = (double)(c - bdytail); bhi = c - abig; blo = bdytail - bhi; err1 = ti1 - (ahi * bhi); err2 = err1 - (alo * bhi); err3 = err2 - (ahi * blo); ti0 = (alo * blo) - err3;
+                    tj1 = (double)(bdxtail * adytail); c = (double)(splitter * bdxtail); abig = (double)(c - bdxtail); ahi = c - abig; alo = bdxtail - ahi; c = (double)(splitter * adytail); abig = (double)(c - adytail); bhi = c - abig; blo = adytail - bhi; err1 = tj1 - (ahi * bhi); err2 = err1 - (alo * bhi); err3 = err2 - (ahi * blo); tj0 = (alo * blo) - err3;
+                    _i = (double)(ti0 - tj0); bvirt = (double)(ti0 - _i); avirt = _i + bvirt; bround = bvirt - tj0; around = ti0 - avirt; abtt[0] = around + bround; _j = (double)(ti1 + _i); bvirt = (double)(_j - ti1); avirt = _j - bvirt; bround = _i - bvirt; around = ti1 - avirt; _0 = around + bround; _i = (double)(_0 - tj1); bvirt = (double)(_0 - _i); avirt = _i + bvirt; bround = bvirt - tj1; around = _0 - avirt; abtt[1] = around + bround; abtt3 = (double)(_j + _i); bvirt = (double)(abtt3 - _j); avirt = abtt3 - bvirt; bround = _i - bvirt; around = _j - avirt; abtt[2] = around + bround;
+                    abtt[3] = abtt3;
+                    abttlen = 4;
+                }
+                else
+                {
+                    abt[0] = 0.0;
+                    abtlen = 1;
+                    abtt[0] = 0.0;
+                    abttlen = 1;
+                }
+
+                if (cdxtail != 0.0)
+                {
+                    temp16alen = ScaleExpansionZeroElim(cxtablen, cxtab, cdxtail, temp16a);
+                    cxtabtlen = ScaleExpansionZeroElim(abtlen, abt, cdxtail, cxtabt);
+                    temp32alen = ScaleExpansionZeroElim(cxtabtlen, cxtabt, 2.0 * cdx, temp32a);
+                    temp48len = FastExpansionSumZeroElim(temp16alen, temp16a, temp32alen, temp32a, temp48);
+                    finlength = FastExpansionSumZeroElim(finlength, finnow, temp48len, temp48, finother);
+                    finswap = finnow; finnow = finother; finother = finswap;
+                    if (adytail != 0.0)
+                    {
+                        temp8len = ScaleExpansionZeroElim(4, bb, cdxtail, temp8);
+                        temp16alen = ScaleExpansionZeroElim(temp8len, temp8, adytail, temp16a);
+                        finlength = FastExpansionSumZeroElim(finlength, finnow, temp16alen, temp16a, finother);
+                        finswap = finnow; finnow = finother; finother = finswap;
+                    }
+                    if (bdytail != 0.0)
+                    {
+                        temp8len = ScaleExpansionZeroElim(4, aa, -cdxtail, temp8);
+                        temp16alen = ScaleExpansionZeroElim(temp8len, temp8, bdytail, temp16a);
+                        finlength = FastExpansionSumZeroElim(finlength, finnow, temp16alen, temp16a, finother);
+                        finswap = finnow; finnow = finother; finother = finswap;
+                    }
+
+                    temp32alen = ScaleExpansionZeroElim(cxtabtlen, cxtabt, cdxtail, temp32a);
+                    cxtabttlen = ScaleExpansionZeroElim(abttlen, abtt, cdxtail, cxtabtt);
+                    temp16alen = ScaleExpansionZeroElim(cxtabttlen, cxtabtt, 2.0 * cdx, temp16a);
+                    temp16blen = ScaleExpansionZeroElim(cxtabttlen, cxtabtt, cdxtail, temp16b);
+                    temp32blen = FastExpansionSumZeroElim(temp16alen, temp16a, temp16blen, temp16b, temp32b);
+                    temp64len = FastExpansionSumZeroElim(temp32alen, temp32a, temp32blen, temp32b, temp64);
+                    finlength = FastExpansionSumZeroElim(finlength, finnow, temp64len, temp64, finother);
+                    finswap = finnow; finnow = finother; finother = finswap;
+                }
+                if (cdytail != 0.0)
+                {
+                    temp16alen = ScaleExpansionZeroElim(cytablen, cytab, cdytail, temp16a);
+                    cytabtlen = ScaleExpansionZeroElim(abtlen, abt, cdytail, cytabt);
+                    temp32alen = ScaleExpansionZeroElim(cytabtlen, cytabt, 2.0 * cdy, temp32a);
+                    temp48len = FastExpansionSumZeroElim(temp16alen, temp16a, temp32alen, temp32a, temp48);
+                    finlength = FastExpansionSumZeroElim(finlength, finnow, temp48len, temp48, finother);
+                    finswap = finnow; finnow = finother; finother = finswap;
+
+
+                    temp32alen = ScaleExpansionZeroElim(cytabtlen, cytabt, cdytail, temp32a);
+                    cytabttlen = ScaleExpansionZeroElim(abttlen, abtt, cdytail, cytabtt);
+                    temp16alen = ScaleExpansionZeroElim(cytabttlen, cytabtt, 2.0 * cdy, temp16a);
+                    temp16blen = ScaleExpansionZeroElim(cytabttlen, cytabtt, cdytail, temp16b);
+                    temp32blen = FastExpansionSumZeroElim(temp16alen, temp16a, temp16blen, temp16b, temp32b);
+                    temp64len = FastExpansionSumZeroElim(temp32alen, temp32a, temp32blen, temp32b, temp64);
+                    finlength = FastExpansionSumZeroElim(finlength, finnow, temp64len, temp64, finother);
+                    finswap = finnow; finnow = finother; finother = finswap;
+                }
+            }
+
+            return finnow[finlength - 1];
+        }
+
+        #region Workspace
+
+        // InCircleAdapt workspace:
+        double[] fin1, fin2, abdet;
+
+        double[] axbc, axxbc, aybc, ayybc, adet;
+        double[] bxca, bxxca, byca, byyca, bdet;
+        double[] cxab, cxxab, cyab, cyyab, cdet;
+
+        double[] temp8, temp16a, temp16b, temp16c;
+        double[] temp32a, temp32b, temp48, temp64;
+
+        private void AllocateWorkspace()
+        {
+            fin1 = new double[1152];
+            fin2 = new double[1152];
+            abdet = new double[64];
+
+            axbc = new double[8];
+            axxbc = new double[16];
+            aybc = new double[8];
+            ayybc = new double[16];
+            adet = new double[32];
+
+            bxca = new double[8];
+            bxxca = new double[16];
+            byca = new double[8];
+            byyca = new double[16];
+            bdet = new double[32];
+
+            cxab = new double[8];
+            cxxab = new double[16];
+            cyab = new double[8];
+            cyyab = new double[16];
+            cdet = new double[32];
+
+            temp8 = new double[8];
+            temp16a = new double[16];
+            temp16b = new double[16];
+            temp16c = new double[16];
+
+            temp32a = new double[32];
+            temp32b = new double[32];
+            temp48 = new double[48];
+            temp64 = new double[64];
+        }
+
+        private void ClearWorkspace()
+        {
+        }
+
+        #endregion
+
+        #endregion
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Runtime/Triangle/RobustPredicates.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a913e1ffc26254097a25b9656988d897
+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.animation@5.0.4/Runtime/Triangle/Smoothing.meta

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

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Runtime/Triangle/Tools.meta

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

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Runtime/Triangle/Topology.meta

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

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Runtime/Triangle/TriangleLocator.cs

@@ -0,0 +1,363 @@
+// -----------------------------------------------------------------------
+// <copyright file="TriangleLocator.cs" company="">
+// Original Triangle code by Jonathan Richard Shewchuk, http://www.cs.cmu.edu/~quake/triangle.html
+// Triangle.NET code by Christian Woltering, http://triangle.codeplex.com/
+// </copyright>
+// -----------------------------------------------------------------------
+
+namespace UnityEngine.U2D.Animation.TriangleNet
+{
+    using Animation.TriangleNet.Geometry;
+    using Animation.TriangleNet.Topology;
+
+    /// <summary>
+    /// Locate triangles in a mesh.
+    /// </summary>
+    /// <remarks>
+    /// WARNING: This routine is designed for convex triangulations, and will
+    /// not generally work after the holes and concavities have been carved.
+    ///
+    /// Based on a paper by Ernst P. Mucke, Isaac Saias, and Binhai Zhu, "Fast
+    /// Randomized Point Location Without Preprocessing in Two- and Three-Dimensional
+    /// Delaunay Triangulations," Proceedings of the Twelfth Annual Symposium on
+    /// Computational Geometry, ACM, May 1996.
+    /// </remarks>
+    internal class TriangleLocator
+    {
+        TriangleSampler sampler;
+        Mesh mesh;
+
+        IPredicates predicates;
+
+        // Pointer to a recently visited triangle. Improves point location if
+        // proximate vertices are inserted sequentially.
+        internal Otri recenttri;
+
+        public TriangleLocator(Mesh mesh)
+            : this(mesh, RobustPredicates.Default)
+        {
+        }
+
+        public TriangleLocator(Mesh mesh, IPredicates predicates)
+        {
+            this.mesh = mesh;
+            this.predicates = predicates;
+
+            sampler = new TriangleSampler(mesh);
+        }
+
+        /// <summary>
+        /// Suggest the given triangle as a starting triangle for point location.
+        /// </summary>
+        /// <param name="otri"></param>
+        public void Update(ref Otri otri)
+        {
+            otri.Copy(ref recenttri);
+        }
+
+        public void Reset()
+        {
+            sampler.Reset();
+            recenttri.tri = null; // No triangle has been visited yet.
+        }
+
+        /// <summary>
+        /// Find a triangle or edge containing a given point.
+        /// </summary>
+        /// <param name="searchpoint">The point to locate.</param>
+        /// <param name="searchtri">The triangle to start the search at.</param>
+        /// <param name="stopatsubsegment"> If 'stopatsubsegment' is set, the search
+        /// will stop if it tries to walk through a subsegment, and will return OUTSIDE.</param>
+        /// <returns>Location information.</returns>
+        /// <remarks>
+        /// Begins its search from 'searchtri'. It is important that 'searchtri'
+        /// be a handle with the property that 'searchpoint' is strictly to the left
+        /// of the edge denoted by 'searchtri', or is collinear with that edge and
+        /// does not intersect that edge. (In particular, 'searchpoint' should not
+        /// be the origin or destination of that edge.)
+        ///
+        /// These conditions are imposed because preciselocate() is normally used in
+        /// one of two situations:
+        ///
+        /// (1)  To try to find the location to insert a new point.  Normally, we
+        ///      know an edge that the point is strictly to the left of. In the
+        ///      incremental Delaunay algorithm, that edge is a bounding box edge.
+        ///      In Ruppert's Delaunay refinement algorithm for quality meshing,
+        ///      that edge is the shortest edge of the triangle whose circumcenter
+        ///      is being inserted.
+        ///
+        /// (2)  To try to find an existing point.  In this case, any edge on the
+        ///      convex hull is a good starting edge. You must screen out the
+        ///      possibility that the vertex sought is an endpoint of the starting
+        ///      edge before you call preciselocate().
+        ///
+        /// On completion, 'searchtri' is a triangle that contains 'searchpoint'.
+        ///
+        /// This implementation differs from that given by Guibas and Stolfi.  It
+        /// walks from triangle to triangle, crossing an edge only if 'searchpoint'
+        /// is on the other side of the line containing that edge. After entering
+        /// a triangle, there are two edges by which one can leave that triangle.
+        /// If both edges are valid ('searchpoint' is on the other side of both
+        /// edges), one of the two is chosen by drawing a line perpendicular to
+        /// the label edge (whose endpoints are 'forg' and 'fdest') passing through
+        /// 'fapex'. Depending on which side of this perpendicular 'searchpoint'
+        /// falls on, an exit edge is chosen.
+        ///
+        /// This implementation is empirically faster than the Guibas and Stolfi
+        /// point location routine (which I originally used), which tends to spiral
+        /// in toward its target.
+        ///
+        /// Returns ONVERTEX if the point lies on an existing vertex. 'searchtri'
+        /// is a handle whose origin is the existing vertex.
+        ///
+        /// Returns ONEDGE if the point lies on a mesh edge. 'searchtri' is a
+        /// handle whose primary edge is the edge on which the point lies.
+        ///
+        /// Returns INTRIANGLE if the point lies strictly within a triangle.
+        /// 'searchtri' is a handle on the triangle that contains the point.
+        ///
+        /// Returns OUTSIDE if the point lies outside the mesh. 'searchtri' is a
+        /// handle whose primary edge the point is to the right of.  This might
+        /// occur when the circumcenter of a triangle falls just slightly outside
+        /// the mesh due to floating-point roundoff error. It also occurs when
+        /// seeking a hole or region point that a foolish user has placed outside
+        /// the mesh.
+        ///
+        /// WARNING:  This routine is designed for convex triangulations, and will
+        /// not generally work after the holes and concavities have been carved.
+        /// However, it can still be used to find the circumcenter of a triangle, as
+        /// long as the search is begun from the triangle in question.</remarks>
+        public LocateResult PreciseLocate(Point searchpoint, ref Otri searchtri,
+            bool stopatsubsegment)
+        {
+            Otri backtracktri = default(Otri);
+            Osub checkedge = default(Osub);
+            Vertex forg, fdest, fapex;
+            double orgorient, destorient;
+            bool moveleft;
+
+            // Where are we?
+            forg = searchtri.Org();
+            fdest = searchtri.Dest();
+            fapex = searchtri.Apex();
+            while (true)
+            {
+                // Check whether the apex is the point we seek.
+                if ((fapex.x == searchpoint.x) && (fapex.y == searchpoint.y))
+                {
+                    searchtri.Lprev();
+                    return LocateResult.OnVertex;
+                }
+                // Does the point lie on the other side of the line defined by the
+                // triangle edge opposite the triangle's destination?
+                destorient = predicates.CounterClockwise(forg, fapex, searchpoint);
+                // Does the point lie on the other side of the line defined by the
+                // triangle edge opposite the triangle's origin?
+                orgorient = predicates.CounterClockwise(fapex, fdest, searchpoint);
+                if (destorient > 0.0)
+                {
+                    if (orgorient > 0.0)
+                    {
+                        // Move left if the inner product of (fapex - searchpoint) and
+                        // (fdest - forg) is positive.  This is equivalent to drawing
+                        // a line perpendicular to the line (forg, fdest) and passing
+                        // through 'fapex', and determining which side of this line
+                        // 'searchpoint' falls on.
+                        moveleft = (fapex.x - searchpoint.x) * (fdest.x - forg.x) +
+                            (fapex.y - searchpoint.y) * (fdest.y - forg.y) > 0.0;
+                    }
+                    else
+                    {
+                        moveleft = true;
+                    }
+                }
+                else
+                {
+                    if (orgorient > 0.0)
+                    {
+                        moveleft = false;
+                    }
+                    else
+                    {
+                        // The point we seek must be on the boundary of or inside this
+                        // triangle.
+                        if (destorient == 0.0)
+                        {
+                            searchtri.Lprev();
+                            return LocateResult.OnEdge;
+                        }
+                        if (orgorient == 0.0)
+                        {
+                            searchtri.Lnext();
+                            return LocateResult.OnEdge;
+                        }
+                        return LocateResult.InTriangle;
+                    }
+                }
+
+                // Move to another triangle. Leave a trace 'backtracktri' in case
+                // floating-point roundoff or some such bogey causes us to walk
+                // off a boundary of the triangulation.
+                if (moveleft)
+                {
+                    searchtri.Lprev(ref backtracktri);
+                    fdest = fapex;
+                }
+                else
+                {
+                    searchtri.Lnext(ref backtracktri);
+                    forg = fapex;
+                }
+                backtracktri.Sym(ref searchtri);
+
+                if (mesh.checksegments && stopatsubsegment)
+                {
+                    // Check for walking through a subsegment.
+                    backtracktri.Pivot(ref checkedge);
+                    if (checkedge.seg.hash != Mesh.DUMMY)
+                    {
+                        // Go back to the last triangle.
+                        backtracktri.Copy(ref searchtri);
+                        return LocateResult.Outside;
+                    }
+                }
+                // Check for walking right out of the triangulation.
+                if (searchtri.tri.id == Mesh.DUMMY)
+                {
+                    // Go back to the last triangle.
+                    backtracktri.Copy(ref searchtri);
+                    return LocateResult.Outside;
+                }
+
+                fapex = searchtri.Apex();
+            }
+        }
+
+        /// <summary>
+        /// Find a triangle or edge containing a given point.
+        /// </summary>
+        /// <param name="searchpoint">The point to locate.</param>
+        /// <param name="searchtri">The triangle to start the search at.</param>
+        /// <returns>Location information.</returns>
+        /// <remarks>
+        /// Searching begins from one of:  the input 'searchtri', a recently
+        /// encountered triangle 'recenttri', or from a triangle chosen from a
+        /// random sample. The choice is made by determining which triangle's
+        /// origin is closest to the point we are searching for. Normally,
+        /// 'searchtri' should be a handle on the convex hull of the triangulation.
+        ///
+        /// Details on the random sampling method can be found in the Mucke, Saias,
+        /// and Zhu paper cited in the header of this code.
+        ///
+        /// On completion, 'searchtri' is a triangle that contains 'searchpoint'.
+        ///
+        /// Returns ONVERTEX if the point lies on an existing vertex. 'searchtri'
+        /// is a handle whose origin is the existing vertex.
+        ///
+        /// Returns ONEDGE if the point lies on a mesh edge. 'searchtri' is a
+        /// handle whose primary edge is the edge on which the point lies.
+        ///
+        /// Returns INTRIANGLE if the point lies strictly within a triangle.
+        /// 'searchtri' is a handle on the triangle that contains the point.
+        ///
+        /// Returns OUTSIDE if the point lies outside the mesh. 'searchtri' is a
+        /// handle whose primary edge the point is to the right of.  This might
+        /// occur when the circumcenter of a triangle falls just slightly outside
+        /// the mesh due to floating-point roundoff error. It also occurs when
+        /// seeking a hole or region point that a foolish user has placed outside
+        /// the mesh.
+        ///
+        /// WARNING:  This routine is designed for convex triangulations, and will
+        /// not generally work after the holes and concavities have been carved.
+        /// </remarks>
+        public LocateResult Locate(Point searchpoint, ref Otri searchtri)
+        {
+            Otri sampletri = default(Otri);
+            Vertex torg, tdest;
+            double searchdist, dist;
+            double ahead;
+
+            // Record the distance from the suggested starting triangle to the
+            // point we seek.
+            torg = searchtri.Org();
+            searchdist = (searchpoint.x - torg.x) * (searchpoint.x - torg.x) +
+                (searchpoint.y - torg.y) * (searchpoint.y - torg.y);
+
+            // If a recently encountered triangle has been recorded and has not been
+            // deallocated, test it as a good starting point.
+            if (recenttri.tri != null)
+            {
+                if (!Otri.IsDead(recenttri.tri))
+                {
+                    torg = recenttri.Org();
+                    if ((torg.x == searchpoint.x) && (torg.y == searchpoint.y))
+                    {
+                        recenttri.Copy(ref searchtri);
+                        return LocateResult.OnVertex;
+                    }
+                    dist = (searchpoint.x - torg.x) * (searchpoint.x - torg.x) +
+                        (searchpoint.y - torg.y) * (searchpoint.y - torg.y);
+                    if (dist < searchdist)
+                    {
+                        recenttri.Copy(ref searchtri);
+                        searchdist = dist;
+                    }
+                }
+            }
+
+            // TODO: Improve sampling.
+            sampler.Update();
+
+            foreach (var t in sampler)
+            {
+                sampletri.tri = t;
+                if (!Otri.IsDead(sampletri.tri))
+                {
+                    torg = sampletri.Org();
+                    dist = (searchpoint.x - torg.x) * (searchpoint.x - torg.x) +
+                        (searchpoint.y - torg.y) * (searchpoint.y - torg.y);
+                    if (dist < searchdist)
+                    {
+                        sampletri.Copy(ref searchtri);
+                        searchdist = dist;
+                    }
+                }
+            }
+
+            // Where are we?
+            torg = searchtri.Org();
+            tdest = searchtri.Dest();
+
+            // Check the starting triangle's vertices.
+            if ((torg.x == searchpoint.x) && (torg.y == searchpoint.y))
+            {
+                return LocateResult.OnVertex;
+            }
+            if ((tdest.x == searchpoint.x) && (tdest.y == searchpoint.y))
+            {
+                searchtri.Lnext();
+                return LocateResult.OnVertex;
+            }
+
+            // Orient 'searchtri' to fit the preconditions of calling preciselocate().
+            ahead = predicates.CounterClockwise(torg, tdest, searchpoint);
+            if (ahead < 0.0)
+            {
+                // Turn around so that 'searchpoint' is to the left of the
+                // edge specified by 'searchtri'.
+                searchtri.Sym();
+            }
+            else if (ahead == 0.0)
+            {
+                // Check if 'searchpoint' is between 'torg' and 'tdest'.
+                if (((torg.x < searchpoint.x) == (searchpoint.x < tdest.x)) &&
+                    ((torg.y < searchpoint.y) == (searchpoint.y < tdest.y)))
+                {
+                    return LocateResult.OnEdge;
+                }
+            }
+
+            return PreciseLocate(searchpoint, ref searchtri, false);
+        }
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Runtime/Triangle/TriangleLocator.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a6f597013f4dd4897a204c7116d61766
+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.animation@5.0.4/Samples~/AnimationSamples/5 SpriteSwap/Animation/Animators/Rikr.controller

@@ -0,0 +1,72 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!91 &9100000
+AnimatorController:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Rikr
+  serializedVersion: 5
+  m_AnimatorParameters: []
+  m_AnimatorLayers:
+  - serializedVersion: 5
+    m_Name: Base Layer
+    m_StateMachine: {fileID: 1107221854909101526}
+    m_Mask: {fileID: 0}
+    m_Motions: []
+    m_Behaviours: []
+    m_BlendingMode: 0
+    m_SyncedLayerIndex: -1
+    m_DefaultWeight: 0
+    m_IKPass: 0
+    m_SyncedLayerAffectsTiming: 0
+    m_Controller: {fileID: 9100000}
+--- !u!1102 &1102824689331069682
+AnimatorState:
+  serializedVersion: 5
+  m_ObjectHideFlags: 1
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: New Animation
+  m_Speed: 1
+  m_CycleOffset: 0
+  m_Transitions: []
+  m_StateMachineBehaviours: []
+  m_Position: {x: 50, y: 50, z: 0}
+  m_IKOnFeet: 0
+  m_WriteDefaultValues: 1
+  m_Mirror: 0
+  m_SpeedParameterActive: 0
+  m_MirrorParameterActive: 0
+  m_CycleOffsetParameterActive: 0
+  m_TimeParameterActive: 0
+  m_Motion: {fileID: 7400000, guid: 9b2cd1aa90c02a7428b34dc5060cbecb, type: 2}
+  m_Tag: 
+  m_SpeedParameter: 
+  m_MirrorParameter: 
+  m_CycleOffsetParameter: 
+  m_TimeParameter: 
+--- !u!1107 &1107221854909101526
+AnimatorStateMachine:
+  serializedVersion: 5
+  m_ObjectHideFlags: 1
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Base Layer
+  m_ChildStates:
+  - serializedVersion: 1
+    m_State: {fileID: 1102824689331069682}
+    m_Position: {x: 200, y: 0, z: 0}
+  m_ChildStateMachines: []
+  m_AnyStateTransitions: []
+  m_EntryTransitions: []
+  m_StateMachineTransitions: {}
+  m_StateMachineBehaviours: []
+  m_AnyStatePosition: {x: 50, y: 20, z: 0}
+  m_EntryPosition: {x: 50, y: 120, z: 0}
+  m_ExitPosition: {x: 800, y: 120, z: 0}
+  m_ParentStateMachinePosition: {x: 800, y: 20, z: 0}
+  m_DefaultState: {fileID: 1102824689331069682}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Samples~/AnimationSamples/5 SpriteSwap/Animation/Animators/Rikr.controller.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 698995a1f48c8a34d873540aa75279f8
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 9100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: