@esotericsoftware/spine-core 4.0.14 → 4.0.15

package/dist/PathConstraint.js

@@ -1,469 +1,469 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-import { PathAttachment } from "./attachments/PathAttachment";
-import { RotateMode, SpacingMode, PositionMode } from "./PathConstraintData";
-import { Utils, MathUtils } from "./Utils";
-/** Stores the current pose for a path constraint. A path constraint adjusts the rotation, translation, and scale of the
- * constrained bones so they follow a {@link PathAttachment}.
- *
- * See [Path constraints](http://esotericsoftware.com/spine-path-constraints) in the Spine User Guide. */
-export class PathConstraint {
-    constructor(data, skeleton) {
-        /** The position along the path. */
-        this.position = 0;
-        /** The spacing between bones. */
-        this.spacing = 0;
-        this.mixRotate = 0;
-        this.mixX = 0;
-        this.mixY = 0;
-        this.spaces = new Array();
-        this.positions = new Array();
-        this.world = new Array();
-        this.curves = new Array();
-        this.lengths = new Array();
-        this.segments = new Array();
-        this.active = false;
-        if (!data)
-            throw new Error("data cannot be null.");
-        if (!skeleton)
-            throw new Error("skeleton cannot be null.");
-        this.data = data;
-        this.bones = new Array();
-        for (let i = 0, n = data.bones.length; i < n; i++)
-            this.bones.push(skeleton.findBone(data.bones[i].name));
-        this.target = skeleton.findSlot(data.target.name);
-        this.position = data.position;
-        this.spacing = data.spacing;
-        this.mixRotate = data.mixRotate;
-        this.mixX = data.mixX;
-        this.mixY = data.mixY;
-    }
-    isActive() {
-        return this.active;
-    }
-    update() {
-        let attachment = this.target.getAttachment();
-        if (!(attachment instanceof PathAttachment))
-            return;
-        let mixRotate = this.mixRotate, mixX = this.mixX, mixY = this.mixY;
-        if (mixRotate == 0 && mixX == 0 && mixY == 0)
-            return;
-        let data = this.data;
-        let tangents = data.rotateMode == RotateMode.Tangent, scale = data.rotateMode == RotateMode.ChainScale;
-        let bones = this.bones;
-        let boneCount = bones.length, spacesCount = tangents ? boneCount : boneCount + 1;
-        let spaces = Utils.setArraySize(this.spaces, spacesCount), lengths = scale ? this.lengths = Utils.setArraySize(this.lengths, boneCount) : null;
-        let spacing = this.spacing;
-        switch (data.spacingMode) {
-            case SpacingMode.Percent:
-                if (scale) {
-                    for (let i = 0, n = spacesCount - 1; i < n; i++) {
-                        let bone = bones[i];
-                        let setupLength = bone.data.length;
-                        if (setupLength < PathConstraint.epsilon)
-                            lengths[i] = 0;
-                        else {
-                            let x = setupLength * bone.a, y = setupLength * bone.c;
-                            lengths[i] = Math.sqrt(x * x + y * y);
-                        }
-                    }
-                }
-                Utils.arrayFill(spaces, 1, spacesCount, spacing);
-                break;
-            case SpacingMode.Proportional:
-                let sum = 0;
-                for (let i = 0, n = spacesCount - 1; i < n;) {
-                    let bone = bones[i];
-                    let setupLength = bone.data.length;
-                    if (setupLength < PathConstraint.epsilon) {
-                        if (scale)
-                            lengths[i] = 0;
-                        spaces[++i] = spacing;
-                    }
-                    else {
-                        let x = setupLength * bone.a, y = setupLength * bone.c;
-                        let length = Math.sqrt(x * x + y * y);
-                        if (scale)
-                            lengths[i] = length;
-                        spaces[++i] = length;
-                        sum += length;
-                    }
-                }
-                if (sum > 0) {
-                    sum = spacesCount / sum * spacing;
-                    for (let i = 1; i < spacesCount; i++)
-                        spaces[i] *= sum;
-                }
-                break;
-            default:
-                let lengthSpacing = data.spacingMode == SpacingMode.Length;
-                for (let i = 0, n = spacesCount - 1; i < n;) {
-                    let bone = bones[i];
-                    let setupLength = bone.data.length;
-                    if (setupLength < PathConstraint.epsilon) {
-                        if (scale)
-                            lengths[i] = 0;
-                        spaces[++i] = spacing;
-                    }
-                    else {
-                        let x = setupLength * bone.a, y = setupLength * bone.c;
-                        let length = Math.sqrt(x * x + y * y);
-                        if (scale)
-                            lengths[i] = length;
-                        spaces[++i] = (lengthSpacing ? setupLength + spacing : spacing) * length / setupLength;
-                    }
-                }
-        }
-        let positions = this.computeWorldPositions(attachment, spacesCount, tangents);
-        let boneX = positions[0], boneY = positions[1], offsetRotation = data.offsetRotation;
-        let tip = false;
-        if (offsetRotation == 0)
-            tip = data.rotateMode == RotateMode.Chain;
-        else {
-            tip = false;
-            let p = this.target.bone;
-            offsetRotation *= p.a * p.d - p.b * p.c > 0 ? MathUtils.degRad : -MathUtils.degRad;
-        }
-        for (let i = 0, p = 3; i < boneCount; i++, p += 3) {
-            let bone = bones[i];
-            bone.worldX += (boneX - bone.worldX) * mixX;
-            bone.worldY += (boneY - bone.worldY) * mixY;
-            let x = positions[p], y = positions[p + 1], dx = x - boneX, dy = y - boneY;
-            if (scale) {
-                let length = lengths[i];
-                if (length != 0) {
-                    let s = (Math.sqrt(dx * dx + dy * dy) / length - 1) * mixRotate + 1;
-                    bone.a *= s;
-                    bone.c *= s;
-                }
-            }
-            boneX = x;
-            boneY = y;
-            if (mixRotate > 0) {
-                let a = bone.a, b = bone.b, c = bone.c, d = bone.d, r = 0, cos = 0, sin = 0;
-                if (tangents)
-                    r = positions[p - 1];
-                else if (spaces[i + 1] == 0)
-                    r = positions[p + 2];
-                else
-                    r = Math.atan2(dy, dx);
-                r -= Math.atan2(c, a);
-                if (tip) {
-                    cos = Math.cos(r);
-                    sin = Math.sin(r);
-                    let length = bone.data.length;
-                    boneX += (length * (cos * a - sin * c) - dx) * mixRotate;
-                    boneY += (length * (sin * a + cos * c) - dy) * mixRotate;
-                }
-                else {
-                    r += offsetRotation;
-                }
-                if (r > MathUtils.PI)
-                    r -= MathUtils.PI2;
-                else if (r < -MathUtils.PI) //
-                    r += MathUtils.PI2;
-                r *= mixRotate;
-                cos = Math.cos(r);
-                sin = Math.sin(r);
-                bone.a = cos * a - sin * c;
-                bone.b = cos * b - sin * d;
-                bone.c = sin * a + cos * c;
-                bone.d = sin * b + cos * d;
-            }
-            bone.updateAppliedTransform();
-        }
-    }
-    computeWorldPositions(path, spacesCount, tangents) {
-        let target = this.target;
-        let position = this.position;
-        let spaces = this.spaces, out = Utils.setArraySize(this.positions, spacesCount * 3 + 2), world = null;
-        let closed = path.closed;
-        let verticesLength = path.worldVerticesLength, curveCount = verticesLength / 6, prevCurve = PathConstraint.NONE;
-        if (!path.constantSpeed) {
-            let lengths = path.lengths;
-            curveCount -= closed ? 1 : 2;
-            let pathLength = lengths[curveCount];
-            if (this.data.positionMode == PositionMode.Percent)
-                position *= pathLength;
-            let multiplier;
-            switch (this.data.spacingMode) {
-                case SpacingMode.Percent:
-                    multiplier = pathLength;
-                    break;
-                case SpacingMode.Proportional:
-                    multiplier = pathLength / spacesCount;
-                    break;
-                default:
-                    multiplier = 1;
-            }
-            world = Utils.setArraySize(this.world, 8);
-            for (let i = 0, o = 0, curve = 0; i < spacesCount; i++, o += 3) {
-                let space = spaces[i] * multiplier;
-                position += space;
-                let p = position;
-                if (closed) {
-                    p %= pathLength;
-                    if (p < 0)
-                        p += pathLength;
-                    curve = 0;
-                }
-                else if (p < 0) {
-                    if (prevCurve != PathConstraint.BEFORE) {
-                        prevCurve = PathConstraint.BEFORE;
-                        path.computeWorldVertices(target, 2, 4, world, 0, 2);
-                    }
-                    this.addBeforePosition(p, world, 0, out, o);
-                    continue;
-                }
-                else if (p > pathLength) {
-                    if (prevCurve != PathConstraint.AFTER) {
-                        prevCurve = PathConstraint.AFTER;
-                        path.computeWorldVertices(target, verticesLength - 6, 4, world, 0, 2);
-                    }
-                    this.addAfterPosition(p - pathLength, world, 0, out, o);
-                    continue;
-                }
-                // Determine curve containing position.
-                for (;; curve++) {
-                    let length = lengths[curve];
-                    if (p > length)
-                        continue;
-                    if (curve == 0)
-                        p /= length;
-                    else {
-                        let prev = lengths[curve - 1];
-                        p = (p - prev) / (length - prev);
-                    }
-                    break;
-                }
-                if (curve != prevCurve) {
-                    prevCurve = curve;
-                    if (closed && curve == curveCount) {
-                        path.computeWorldVertices(target, verticesLength - 4, 4, world, 0, 2);
-                        path.computeWorldVertices(target, 0, 4, world, 4, 2);
-                    }
-                    else
-                        path.computeWorldVertices(target, curve * 6 + 2, 8, world, 0, 2);
-                }
-                this.addCurvePosition(p, world[0], world[1], world[2], world[3], world[4], world[5], world[6], world[7], out, o, tangents || (i > 0 && space == 0));
-            }
-            return out;
-        }
-        // World vertices.
-        if (closed) {
-            verticesLength += 2;
-            world = Utils.setArraySize(this.world, verticesLength);
-            path.computeWorldVertices(target, 2, verticesLength - 4, world, 0, 2);
-            path.computeWorldVertices(target, 0, 2, world, verticesLength - 4, 2);
-            world[verticesLength - 2] = world[0];
-            world[verticesLength - 1] = world[1];
-        }
-        else {
-            curveCount--;
-            verticesLength -= 4;
-            world = Utils.setArraySize(this.world, verticesLength);
-            path.computeWorldVertices(target, 2, verticesLength, world, 0, 2);
-        }
-        // Curve lengths.
-        let curves = Utils.setArraySize(this.curves, curveCount);
-        let pathLength = 0;
-        let x1 = world[0], y1 = world[1], cx1 = 0, cy1 = 0, cx2 = 0, cy2 = 0, x2 = 0, y2 = 0;
-        let tmpx = 0, tmpy = 0, dddfx = 0, dddfy = 0, ddfx = 0, ddfy = 0, dfx = 0, dfy = 0;
-        for (let i = 0, w = 2; i < curveCount; i++, w += 6) {
-            cx1 = world[w];
-            cy1 = world[w + 1];
-            cx2 = world[w + 2];
-            cy2 = world[w + 3];
-            x2 = world[w + 4];
-            y2 = world[w + 5];
-            tmpx = (x1 - cx1 * 2 + cx2) * 0.1875;
-            tmpy = (y1 - cy1 * 2 + cy2) * 0.1875;
-            dddfx = ((cx1 - cx2) * 3 - x1 + x2) * 0.09375;
-            dddfy = ((cy1 - cy2) * 3 - y1 + y2) * 0.09375;
-            ddfx = tmpx * 2 + dddfx;
-            ddfy = tmpy * 2 + dddfy;
-            dfx = (cx1 - x1) * 0.75 + tmpx + dddfx * 0.16666667;
-            dfy = (cy1 - y1) * 0.75 + tmpy + dddfy * 0.16666667;
-            pathLength += Math.sqrt(dfx * dfx + dfy * dfy);
-            dfx += ddfx;
-            dfy += ddfy;
-            ddfx += dddfx;
-            ddfy += dddfy;
-            pathLength += Math.sqrt(dfx * dfx + dfy * dfy);
-            dfx += ddfx;
-            dfy += ddfy;
-            pathLength += Math.sqrt(dfx * dfx + dfy * dfy);
-            dfx += ddfx + dddfx;
-            dfy += ddfy + dddfy;
-            pathLength += Math.sqrt(dfx * dfx + dfy * dfy);
-            curves[i] = pathLength;
-            x1 = x2;
-            y1 = y2;
-        }
-        if (this.data.positionMode == PositionMode.Percent)
-            position *= pathLength;
-        let multiplier;
-        switch (this.data.spacingMode) {
-            case SpacingMode.Percent:
-                multiplier = pathLength;
-                break;
-            case SpacingMode.Proportional:
-                multiplier = pathLength / spacesCount;
-                break;
-            default:
-                multiplier = 1;
-        }
-        let segments = this.segments;
-        let curveLength = 0;
-        for (let i = 0, o = 0, curve = 0, segment = 0; i < spacesCount; i++, o += 3) {
-            let space = spaces[i] * multiplier;
-            position += space;
-            let p = position;
-            if (closed) {
-                p %= pathLength;
-                if (p < 0)
-                    p += pathLength;
-                curve = 0;
-            }
-            else if (p < 0) {
-                this.addBeforePosition(p, world, 0, out, o);
-                continue;
-            }
-            else if (p > pathLength) {
-                this.addAfterPosition(p - pathLength, world, verticesLength - 4, out, o);
-                continue;
-            }
-            // Determine curve containing position.
-            for (;; curve++) {
-                let length = curves[curve];
-                if (p > length)
-                    continue;
-                if (curve == 0)
-                    p /= length;
-                else {
-                    let prev = curves[curve - 1];
-                    p = (p - prev) / (length - prev);
-                }
-                break;
-            }
-            // Curve segment lengths.
-            if (curve != prevCurve) {
-                prevCurve = curve;
-                let ii = curve * 6;
-                x1 = world[ii];
-                y1 = world[ii + 1];
-                cx1 = world[ii + 2];
-                cy1 = world[ii + 3];
-                cx2 = world[ii + 4];
-                cy2 = world[ii + 5];
-                x2 = world[ii + 6];
-                y2 = world[ii + 7];
-                tmpx = (x1 - cx1 * 2 + cx2) * 0.03;
-                tmpy = (y1 - cy1 * 2 + cy2) * 0.03;
-                dddfx = ((cx1 - cx2) * 3 - x1 + x2) * 0.006;
-                dddfy = ((cy1 - cy2) * 3 - y1 + y2) * 0.006;
-                ddfx = tmpx * 2 + dddfx;
-                ddfy = tmpy * 2 + dddfy;
-                dfx = (cx1 - x1) * 0.3 + tmpx + dddfx * 0.16666667;
-                dfy = (cy1 - y1) * 0.3 + tmpy + dddfy * 0.16666667;
-                curveLength = Math.sqrt(dfx * dfx + dfy * dfy);
-                segments[0] = curveLength;
-                for (ii = 1; ii < 8; ii++) {
-                    dfx += ddfx;
-                    dfy += ddfy;
-                    ddfx += dddfx;
-                    ddfy += dddfy;
-                    curveLength += Math.sqrt(dfx * dfx + dfy * dfy);
-                    segments[ii] = curveLength;
-                }
-                dfx += ddfx;
-                dfy += ddfy;
-                curveLength += Math.sqrt(dfx * dfx + dfy * dfy);
-                segments[8] = curveLength;
-                dfx += ddfx + dddfx;
-                dfy += ddfy + dddfy;
-                curveLength += Math.sqrt(dfx * dfx + dfy * dfy);
-                segments[9] = curveLength;
-                segment = 0;
-            }
-            // Weight by segment length.
-            p *= curveLength;
-            for (;; segment++) {
-                let length = segments[segment];
-                if (p > length)
-                    continue;
-                if (segment == 0)
-                    p /= length;
-                else {
-                    let prev = segments[segment - 1];
-                    p = segment + (p - prev) / (length - prev);
-                }
-                break;
-            }
-            this.addCurvePosition(p * 0.1, x1, y1, cx1, cy1, cx2, cy2, x2, y2, out, o, tangents || (i > 0 && space == 0));
-        }
-        return out;
-    }
-    addBeforePosition(p, temp, i, out, o) {
-        let x1 = temp[i], y1 = temp[i + 1], dx = temp[i + 2] - x1, dy = temp[i + 3] - y1, r = Math.atan2(dy, dx);
-        out[o] = x1 + p * Math.cos(r);
-        out[o + 1] = y1 + p * Math.sin(r);
-        out[o + 2] = r;
-    }
-    addAfterPosition(p, temp, i, out, o) {
-        let x1 = temp[i + 2], y1 = temp[i + 3], dx = x1 - temp[i], dy = y1 - temp[i + 1], r = Math.atan2(dy, dx);
-        out[o] = x1 + p * Math.cos(r);
-        out[o + 1] = y1 + p * Math.sin(r);
-        out[o + 2] = r;
-    }
-    addCurvePosition(p, x1, y1, cx1, cy1, cx2, cy2, x2, y2, out, o, tangents) {
-        if (p == 0 || isNaN(p)) {
-            out[o] = x1;
-            out[o + 1] = y1;
-            out[o + 2] = Math.atan2(cy1 - y1, cx1 - x1);
-            return;
-        }
-        let tt = p * p, ttt = tt * p, u = 1 - p, uu = u * u, uuu = uu * u;
-        let ut = u * p, ut3 = ut * 3, uut3 = u * ut3, utt3 = ut3 * p;
-        let x = x1 * uuu + cx1 * uut3 + cx2 * utt3 + x2 * ttt, y = y1 * uuu + cy1 * uut3 + cy2 * utt3 + y2 * ttt;
-        out[o] = x;
-        out[o + 1] = y;
-        if (tangents) {
-            if (p < 0.001)
-                out[o + 2] = Math.atan2(cy1 - y1, cx1 - x1);
-            else
-                out[o + 2] = Math.atan2(y - (y1 * uu + cy1 * ut * 2 + cy2 * tt), x - (x1 * uu + cx1 * ut * 2 + cx2 * tt));
-        }
-    }
-}
-PathConstraint.NONE = -1;
-PathConstraint.BEFORE = -2;
-PathConstraint.AFTER = -3;
-PathConstraint.epsilon = 0.00001;
+/******************************************************************************
+ * Spine Runtimes License Agreement
+ * Last updated January 1, 2020. Replaces all prior versions.
+ *
+ * Copyright (c) 2013-2020, Esoteric Software LLC
+ *
+ * Integration of the Spine Runtimes into software or otherwise creating
+ * derivative works of the Spine Runtimes is permitted under the terms and
+ * conditions of Section 2 of the Spine Editor License Agreement:
+ * http://esotericsoftware.com/spine-editor-license
+ *
+ * Otherwise, it is permitted to integrate the Spine Runtimes into software
+ * or otherwise create derivative works of the Spine Runtimes (collectively,
+ * "Products"), provided that each user of the Products must obtain their own
+ * Spine Editor license and redistribution of the Products in any form must
+ * include this license and copyright notice.
+ *
+ * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
+ * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *****************************************************************************/
+import { PathAttachment } from "./attachments/PathAttachment";
+import { RotateMode, SpacingMode, PositionMode } from "./PathConstraintData";
+import { Utils, MathUtils } from "./Utils";
+/** Stores the current pose for a path constraint. A path constraint adjusts the rotation, translation, and scale of the
+ * constrained bones so they follow a {@link PathAttachment}.
+ *
+ * See [Path constraints](http://esotericsoftware.com/spine-path-constraints) in the Spine User Guide. */
+export class PathConstraint {
+    constructor(data, skeleton) {
+        /** The position along the path. */
+        this.position = 0;
+        /** The spacing between bones. */
+        this.spacing = 0;
+        this.mixRotate = 0;
+        this.mixX = 0;
+        this.mixY = 0;
+        this.spaces = new Array();
+        this.positions = new Array();
+        this.world = new Array();
+        this.curves = new Array();
+        this.lengths = new Array();
+        this.segments = new Array();
+        this.active = false;
+        if (!data)
+            throw new Error("data cannot be null.");
+        if (!skeleton)
+            throw new Error("skeleton cannot be null.");
+        this.data = data;
+        this.bones = new Array();
+        for (let i = 0, n = data.bones.length; i < n; i++)
+            this.bones.push(skeleton.findBone(data.bones[i].name));
+        this.target = skeleton.findSlot(data.target.name);
+        this.position = data.position;
+        this.spacing = data.spacing;
+        this.mixRotate = data.mixRotate;
+        this.mixX = data.mixX;
+        this.mixY = data.mixY;
+    }
+    isActive() {
+        return this.active;
+    }
+    update() {
+        let attachment = this.target.getAttachment();
+        if (!(attachment instanceof PathAttachment))
+            return;
+        let mixRotate = this.mixRotate, mixX = this.mixX, mixY = this.mixY;
+        if (mixRotate == 0 && mixX == 0 && mixY == 0)
+            return;
+        let data = this.data;
+        let tangents = data.rotateMode == RotateMode.Tangent, scale = data.rotateMode == RotateMode.ChainScale;
+        let bones = this.bones;
+        let boneCount = bones.length, spacesCount = tangents ? boneCount : boneCount + 1;
+        let spaces = Utils.setArraySize(this.spaces, spacesCount), lengths = scale ? this.lengths = Utils.setArraySize(this.lengths, boneCount) : null;
+        let spacing = this.spacing;
+        switch (data.spacingMode) {
+            case SpacingMode.Percent:
+                if (scale) {
+                    for (let i = 0, n = spacesCount - 1; i < n; i++) {
+                        let bone = bones[i];
+                        let setupLength = bone.data.length;
+                        if (setupLength < PathConstraint.epsilon)
+                            lengths[i] = 0;
+                        else {
+                            let x = setupLength * bone.a, y = setupLength * bone.c;
+                            lengths[i] = Math.sqrt(x * x + y * y);
+                        }
+                    }
+                }
+                Utils.arrayFill(spaces, 1, spacesCount, spacing);
+                break;
+            case SpacingMode.Proportional:
+                let sum = 0;
+                for (let i = 0, n = spacesCount - 1; i < n;) {
+                    let bone = bones[i];
+                    let setupLength = bone.data.length;
+                    if (setupLength < PathConstraint.epsilon) {
+                        if (scale)
+                            lengths[i] = 0;
+                        spaces[++i] = spacing;
+                    }
+                    else {
+                        let x = setupLength * bone.a, y = setupLength * bone.c;
+                        let length = Math.sqrt(x * x + y * y);
+                        if (scale)
+                            lengths[i] = length;
+                        spaces[++i] = length;
+                        sum += length;
+                    }
+                }
+                if (sum > 0) {
+                    sum = spacesCount / sum * spacing;
+                    for (let i = 1; i < spacesCount; i++)
+                        spaces[i] *= sum;
+                }
+                break;
+            default:
+                let lengthSpacing = data.spacingMode == SpacingMode.Length;
+                for (let i = 0, n = spacesCount - 1; i < n;) {
+                    let bone = bones[i];
+                    let setupLength = bone.data.length;
+                    if (setupLength < PathConstraint.epsilon) {
+                        if (scale)
+                            lengths[i] = 0;
+                        spaces[++i] = spacing;
+                    }
+                    else {
+                        let x = setupLength * bone.a, y = setupLength * bone.c;
+                        let length = Math.sqrt(x * x + y * y);
+                        if (scale)
+                            lengths[i] = length;
+                        spaces[++i] = (lengthSpacing ? setupLength + spacing : spacing) * length / setupLength;
+                    }
+                }
+        }
+        let positions = this.computeWorldPositions(attachment, spacesCount, tangents);
+        let boneX = positions[0], boneY = positions[1], offsetRotation = data.offsetRotation;
+        let tip = false;
+        if (offsetRotation == 0)
+            tip = data.rotateMode == RotateMode.Chain;
+        else {
+            tip = false;
+            let p = this.target.bone;
+            offsetRotation *= p.a * p.d - p.b * p.c > 0 ? MathUtils.degRad : -MathUtils.degRad;
+        }
+        for (let i = 0, p = 3; i < boneCount; i++, p += 3) {
+            let bone = bones[i];
+            bone.worldX += (boneX - bone.worldX) * mixX;
+            bone.worldY += (boneY - bone.worldY) * mixY;
+            let x = positions[p], y = positions[p + 1], dx = x - boneX, dy = y - boneY;
+            if (scale) {
+                let length = lengths[i];
+                if (length != 0) {
+                    let s = (Math.sqrt(dx * dx + dy * dy) / length - 1) * mixRotate + 1;
+                    bone.a *= s;
+                    bone.c *= s;
+                }
+            }
+            boneX = x;
+            boneY = y;
+            if (mixRotate > 0) {
+                let a = bone.a, b = bone.b, c = bone.c, d = bone.d, r = 0, cos = 0, sin = 0;
+                if (tangents)
+                    r = positions[p - 1];
+                else if (spaces[i + 1] == 0)
+                    r = positions[p + 2];
+                else
+                    r = Math.atan2(dy, dx);
+                r -= Math.atan2(c, a);
+                if (tip) {
+                    cos = Math.cos(r);
+                    sin = Math.sin(r);
+                    let length = bone.data.length;
+                    boneX += (length * (cos * a - sin * c) - dx) * mixRotate;
+                    boneY += (length * (sin * a + cos * c) - dy) * mixRotate;
+                }
+                else {
+                    r += offsetRotation;
+                }
+                if (r > MathUtils.PI)
+                    r -= MathUtils.PI2;
+                else if (r < -MathUtils.PI) //
+                    r += MathUtils.PI2;
+                r *= mixRotate;
+                cos = Math.cos(r);
+                sin = Math.sin(r);
+                bone.a = cos * a - sin * c;
+                bone.b = cos * b - sin * d;
+                bone.c = sin * a + cos * c;
+                bone.d = sin * b + cos * d;
+            }
+            bone.updateAppliedTransform();
+        }
+    }
+    computeWorldPositions(path, spacesCount, tangents) {
+        let target = this.target;
+        let position = this.position;
+        let spaces = this.spaces, out = Utils.setArraySize(this.positions, spacesCount * 3 + 2), world = null;
+        let closed = path.closed;
+        let verticesLength = path.worldVerticesLength, curveCount = verticesLength / 6, prevCurve = PathConstraint.NONE;
+        if (!path.constantSpeed) {
+            let lengths = path.lengths;
+            curveCount -= closed ? 1 : 2;
+            let pathLength = lengths[curveCount];
+            if (this.data.positionMode == PositionMode.Percent)
+                position *= pathLength;
+            let multiplier;
+            switch (this.data.spacingMode) {
+                case SpacingMode.Percent:
+                    multiplier = pathLength;
+                    break;
+                case SpacingMode.Proportional:
+                    multiplier = pathLength / spacesCount;
+                    break;
+                default:
+                    multiplier = 1;
+            }
+            world = Utils.setArraySize(this.world, 8);
+            for (let i = 0, o = 0, curve = 0; i < spacesCount; i++, o += 3) {
+                let space = spaces[i] * multiplier;
+                position += space;
+                let p = position;
+                if (closed) {
+                    p %= pathLength;
+                    if (p < 0)
+                        p += pathLength;
+                    curve = 0;
+                }
+                else if (p < 0) {
+                    if (prevCurve != PathConstraint.BEFORE) {
+                        prevCurve = PathConstraint.BEFORE;
+                        path.computeWorldVertices(target, 2, 4, world, 0, 2);
+                    }
+                    this.addBeforePosition(p, world, 0, out, o);
+                    continue;
+                }
+                else if (p > pathLength) {
+                    if (prevCurve != PathConstraint.AFTER) {
+                        prevCurve = PathConstraint.AFTER;
+                        path.computeWorldVertices(target, verticesLength - 6, 4, world, 0, 2);
+                    }
+                    this.addAfterPosition(p - pathLength, world, 0, out, o);
+                    continue;
+                }
+                // Determine curve containing position.
+                for (;; curve++) {
+                    let length = lengths[curve];
+                    if (p > length)
+                        continue;
+                    if (curve == 0)
+                        p /= length;
+                    else {
+                        let prev = lengths[curve - 1];
+                        p = (p - prev) / (length - prev);
+                    }
+                    break;
+                }
+                if (curve != prevCurve) {
+                    prevCurve = curve;
+                    if (closed && curve == curveCount) {
+                        path.computeWorldVertices(target, verticesLength - 4, 4, world, 0, 2);
+                        path.computeWorldVertices(target, 0, 4, world, 4, 2);
+                    }
+                    else
+                        path.computeWorldVertices(target, curve * 6 + 2, 8, world, 0, 2);
+                }
+                this.addCurvePosition(p, world[0], world[1], world[2], world[3], world[4], world[5], world[6], world[7], out, o, tangents || (i > 0 && space == 0));
+            }
+            return out;
+        }
+        // World vertices.
+        if (closed) {
+            verticesLength += 2;
+            world = Utils.setArraySize(this.world, verticesLength);
+            path.computeWorldVertices(target, 2, verticesLength - 4, world, 0, 2);
+            path.computeWorldVertices(target, 0, 2, world, verticesLength - 4, 2);
+            world[verticesLength - 2] = world[0];
+            world[verticesLength - 1] = world[1];
+        }
+        else {
+            curveCount--;
+            verticesLength -= 4;
+            world = Utils.setArraySize(this.world, verticesLength);
+            path.computeWorldVertices(target, 2, verticesLength, world, 0, 2);
+        }
+        // Curve lengths.
+        let curves = Utils.setArraySize(this.curves, curveCount);
+        let pathLength = 0;
+        let x1 = world[0], y1 = world[1], cx1 = 0, cy1 = 0, cx2 = 0, cy2 = 0, x2 = 0, y2 = 0;
+        let tmpx = 0, tmpy = 0, dddfx = 0, dddfy = 0, ddfx = 0, ddfy = 0, dfx = 0, dfy = 0;
+        for (let i = 0, w = 2; i < curveCount; i++, w += 6) {
+            cx1 = world[w];
+            cy1 = world[w + 1];
+            cx2 = world[w + 2];
+            cy2 = world[w + 3];
+            x2 = world[w + 4];
+            y2 = world[w + 5];
+            tmpx = (x1 - cx1 * 2 + cx2) * 0.1875;
+            tmpy = (y1 - cy1 * 2 + cy2) * 0.1875;
+            dddfx = ((cx1 - cx2) * 3 - x1 + x2) * 0.09375;
+            dddfy = ((cy1 - cy2) * 3 - y1 + y2) * 0.09375;
+            ddfx = tmpx * 2 + dddfx;
+            ddfy = tmpy * 2 + dddfy;
+            dfx = (cx1 - x1) * 0.75 + tmpx + dddfx * 0.16666667;
+            dfy = (cy1 - y1) * 0.75 + tmpy + dddfy * 0.16666667;
+            pathLength += Math.sqrt(dfx * dfx + dfy * dfy);
+            dfx += ddfx;
+            dfy += ddfy;
+            ddfx += dddfx;
+            ddfy += dddfy;
+            pathLength += Math.sqrt(dfx * dfx + dfy * dfy);
+            dfx += ddfx;
+            dfy += ddfy;
+            pathLength += Math.sqrt(dfx * dfx + dfy * dfy);
+            dfx += ddfx + dddfx;
+            dfy += ddfy + dddfy;
+            pathLength += Math.sqrt(dfx * dfx + dfy * dfy);
+            curves[i] = pathLength;
+            x1 = x2;
+            y1 = y2;
+        }
+        if (this.data.positionMode == PositionMode.Percent)
+            position *= pathLength;
+        let multiplier;
+        switch (this.data.spacingMode) {
+            case SpacingMode.Percent:
+                multiplier = pathLength;
+                break;
+            case SpacingMode.Proportional:
+                multiplier = pathLength / spacesCount;
+                break;
+            default:
+                multiplier = 1;
+        }
+        let segments = this.segments;
+        let curveLength = 0;
+        for (let i = 0, o = 0, curve = 0, segment = 0; i < spacesCount; i++, o += 3) {
+            let space = spaces[i] * multiplier;
+            position += space;
+            let p = position;
+            if (closed) {
+                p %= pathLength;
+                if (p < 0)
+                    p += pathLength;
+                curve = 0;
+            }
+            else if (p < 0) {
+                this.addBeforePosition(p, world, 0, out, o);
+                continue;
+            }
+            else if (p > pathLength) {
+                this.addAfterPosition(p - pathLength, world, verticesLength - 4, out, o);
+                continue;
+            }
+            // Determine curve containing position.
+            for (;; curve++) {
+                let length = curves[curve];
+                if (p > length)
+                    continue;
+                if (curve == 0)
+                    p /= length;
+                else {
+                    let prev = curves[curve - 1];
+                    p = (p - prev) / (length - prev);
+                }
+                break;
+            }
+            // Curve segment lengths.
+            if (curve != prevCurve) {
+                prevCurve = curve;
+                let ii = curve * 6;
+                x1 = world[ii];
+                y1 = world[ii + 1];
+                cx1 = world[ii + 2];
+                cy1 = world[ii + 3];
+                cx2 = world[ii + 4];
+                cy2 = world[ii + 5];
+                x2 = world[ii + 6];
+                y2 = world[ii + 7];
+                tmpx = (x1 - cx1 * 2 + cx2) * 0.03;
+                tmpy = (y1 - cy1 * 2 + cy2) * 0.03;
+                dddfx = ((cx1 - cx2) * 3 - x1 + x2) * 0.006;
+                dddfy = ((cy1 - cy2) * 3 - y1 + y2) * 0.006;
+                ddfx = tmpx * 2 + dddfx;
+                ddfy = tmpy * 2 + dddfy;
+                dfx = (cx1 - x1) * 0.3 + tmpx + dddfx * 0.16666667;
+                dfy = (cy1 - y1) * 0.3 + tmpy + dddfy * 0.16666667;
+                curveLength = Math.sqrt(dfx * dfx + dfy * dfy);
+                segments[0] = curveLength;
+                for (ii = 1; ii < 8; ii++) {
+                    dfx += ddfx;
+                    dfy += ddfy;
+                    ddfx += dddfx;
+                    ddfy += dddfy;
+                    curveLength += Math.sqrt(dfx * dfx + dfy * dfy);
+                    segments[ii] = curveLength;
+                }
+                dfx += ddfx;
+                dfy += ddfy;
+                curveLength += Math.sqrt(dfx * dfx + dfy * dfy);
+                segments[8] = curveLength;
+                dfx += ddfx + dddfx;
+                dfy += ddfy + dddfy;
+                curveLength += Math.sqrt(dfx * dfx + dfy * dfy);
+                segments[9] = curveLength;
+                segment = 0;
+            }
+            // Weight by segment length.
+            p *= curveLength;
+            for (;; segment++) {
+                let length = segments[segment];
+                if (p > length)
+                    continue;
+                if (segment == 0)
+                    p /= length;
+                else {
+                    let prev = segments[segment - 1];
+                    p = segment + (p - prev) / (length - prev);
+                }
+                break;
+            }
+            this.addCurvePosition(p * 0.1, x1, y1, cx1, cy1, cx2, cy2, x2, y2, out, o, tangents || (i > 0 && space == 0));
+        }
+        return out;
+    }
+    addBeforePosition(p, temp, i, out, o) {
+        let x1 = temp[i], y1 = temp[i + 1], dx = temp[i + 2] - x1, dy = temp[i + 3] - y1, r = Math.atan2(dy, dx);
+        out[o] = x1 + p * Math.cos(r);
+        out[o + 1] = y1 + p * Math.sin(r);
+        out[o + 2] = r;
+    }
+    addAfterPosition(p, temp, i, out, o) {
+        let x1 = temp[i + 2], y1 = temp[i + 3], dx = x1 - temp[i], dy = y1 - temp[i + 1], r = Math.atan2(dy, dx);
+        out[o] = x1 + p * Math.cos(r);
+        out[o + 1] = y1 + p * Math.sin(r);
+        out[o + 2] = r;
+    }
+    addCurvePosition(p, x1, y1, cx1, cy1, cx2, cy2, x2, y2, out, o, tangents) {
+        if (p == 0 || isNaN(p)) {
+            out[o] = x1;
+            out[o + 1] = y1;
+            out[o + 2] = Math.atan2(cy1 - y1, cx1 - x1);
+            return;
+        }
+        let tt = p * p, ttt = tt * p, u = 1 - p, uu = u * u, uuu = uu * u;
+        let ut = u * p, ut3 = ut * 3, uut3 = u * ut3, utt3 = ut3 * p;
+        let x = x1 * uuu + cx1 * uut3 + cx2 * utt3 + x2 * ttt, y = y1 * uuu + cy1 * uut3 + cy2 * utt3 + y2 * ttt;
+        out[o] = x;
+        out[o + 1] = y;
+        if (tangents) {
+            if (p < 0.001)
+                out[o + 2] = Math.atan2(cy1 - y1, cx1 - x1);
+            else
+                out[o + 2] = Math.atan2(y - (y1 * uu + cy1 * ut * 2 + cy2 * tt), x - (x1 * uu + cx1 * ut * 2 + cx2 * tt));
+        }
+    }
+}
+PathConstraint.NONE = -1;
+PathConstraint.BEFORE = -2;
+PathConstraint.AFTER = -3;
+PathConstraint.epsilon = 0.00001;
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PathConstraint.js","sourceRoot":"","sources":["../src/PathConstraint.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;+EA2B+E;AAE/E,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAE9D,OAAO,EAAsB,UAAU,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAIjG,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAG3C;;;yGAGyG;AACzG,MAAM,OAAO,cAAc;IA+B1B,YAAa,IAAwB,EAAE,QAAkB;QAlBzD,mCAAmC;QACnC,aAAQ,GAAG,CAAC,CAAC;QAEb,iCAAiC;QACjC,YAAO,GAAG,CAAC,CAAC;QAEZ,cAAS,GAAG,CAAC,CAAC;QAEd,SAAI,GAAG,CAAC,CAAC;QAET,SAAI,GAAG,CAAC,CAAC;QAET,WAAM,GAAG,IAAI,KAAK,EAAU,CAAC;QAAC,cAAS,GAAG,IAAI,KAAK,EAAU,CAAC;QAC9D,UAAK,GAAG,IAAI,KAAK,EAAU,CAAC;QAAC,WAAM,GAAG,IAAI,KAAK,EAAU,CAAC;QAAC,YAAO,GAAG,IAAI,KAAK,EAAU,CAAC;QACzF,aAAQ,GAAG,IAAI,KAAK,EAAU,CAAC;QAE/B,WAAM,GAAG,KAAK,CAAC;QAGd,IAAI,CAAC,IAAI;YAAE,MAAM,IAAI,KAAK,CAAC,sBAAsB,CAAC,CAAC;QACnD,IAAI,CAAC,QAAQ;YAAE,MAAM,IAAI,KAAK,CAAC,0BAA0B,CAAC,CAAC;QAC3D,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,KAAK,GAAG,IAAI,KAAK,EAAQ,CAAC;QAC/B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE;YAChD,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;QACxD,IAAI,CAAC,MAAM,GAAG,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QAClD,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC;QAC9B,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;QAC5B,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;QAChC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QACtB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;IACvB,CAAC;IAED,QAAQ;QACP,OAAO,IAAI,CAAC,MAAM,CAAC;IACpB,CAAC;IAED,MAAM;QACL,IAAI,UAAU,GAAG,IAAI,CAAC,MAAM,CAAC,aAAa,EAAE,CAAC;QAC7C,IAAI,CAAC,CAAC,UAAU,YAAY,cAAc,CAAC;YAAE,OAAO;QAEpD,IAAI,SAAS,GAAG,IAAI,CAAC,SAAS,EAAE,IAAI,GAAG,IAAI,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QACnE,IAAI,SAAS,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC;YAAE,OAAO;QAErD,IAAI,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QACrB,IAAI,QAAQ,GAAG,IAAI,CAAC,UAAU,IAAI,UAAU,CAAC,OAAO,EAAE,KAAK,GAAG,IAAI,CAAC,UAAU,IAAI,UAAU,CAAC,UAAU,CAAC;QAEvG,IAAI,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;QACvB,IAAI,SAAS,GAAG,KAAK,CAAC,MAAM,EAAE,WAAW,GAAG,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,GAAG,CAAC,CAAC;QACjF,IAAI,MAAM,GAAG,KAAK,CAAC,YAAY,CAAC,IAAI,CAAC,MAAM,EAAE,WAAW,CAAC,EAAE,OAAO,GAAkB,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC,YAAY,CAAC,IAAI,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;QAC9J,IAAI,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;QAE3B,QAAQ,IAAI,CAAC,WAAW,EAAE;YACzB,KAAK,WAAW,CAAC,OAAO;gBACvB,IAAI,KAAK,EAAE;oBACV,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,WAAW,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE;wBAChD,IAAI,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;wBACpB,IAAI,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC;wBACnC,IAAI,WAAW,GAAG,cAAc,CAAC,OAAO;4BACvC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;6BACX;4BACJ,IAAI,CAAC,GAAG,WAAW,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC,GAAG,WAAW,GAAG,IAAI,CAAC,CAAC,CAAC;4BACvD,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;yBACtC;qBACD;iBACD;gBACD,KAAK,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC,EAAE,WAAW,EAAE,OAAO,CAAC,CAAC;gBACjD,MAAM;YACP,KAAK,WAAW,CAAC,YAAY;gBAC5B,IAAI,GAAG,GAAG,CAAC,CAAC;gBACZ,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,WAAW,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG;oBAC5C,IAAI,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;oBACpB,IAAI,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC;oBACnC,IAAI,WAAW,GAAG,cAAc,CAAC,OAAO,EAAE;wBACzC,IAAI,KAAK;4BAAE,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;wBAC1B,MAAM,CAAC,EAAE,CAAC,CAAC,GAAG,OAAO,CAAC;qBACtB;yBAAM;wBACN,IAAI,CAAC,GAAG,WAAW,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC,GAAG,WAAW,GAAG,IAAI,CAAC,CAAC,CAAC;wBACvD,IAAI,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;wBACtC,IAAI,KAAK;4BAAE,OAAO,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC;wBAC/B,MAAM,CAAC,EAAE,CAAC,CAAC,GAAG,MAAM,CAAC;wBACrB,GAAG,IAAI,MAAM,CAAC;qBACd;iBACD;gBACD,IAAI,GAAG,GAAG,CAAC,EAAE;oBACZ,GAAG,GAAG,WAAW,GAAG,GAAG,GAAG,OAAO,CAAC;oBAClC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,WAAW,EAAE,CAAC,EAAE;wBACnC,MAAM,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC;iBAClB;gBACD,MAAM;YACP;gBACC,IAAI,aAAa,GAAG,IAAI,CAAC,WAAW,IAAI,WAAW,CAAC,MAAM,CAAC;gBAC3D,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,WAAW,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG;oBAC5C,IAAI,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;oBACpB,IAAI,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC;oBACnC,IAAI,WAAW,GAAG,cAAc,CAAC,OAAO,EAAE;wBACzC,IAAI,KAAK;4BAAE,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;wBAC1B,MAAM,CAAC,EAAE,CAAC,CAAC,GAAG,OAAO,CAAC;qBACtB;yBAAM;wBACN,IAAI,CAAC,GAAG,WAAW,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC,GAAG,WAAW,GAAG,IAAI,CAAC,CAAC,CAAC;wBACvD,IAAI,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;wBACtC,IAAI,KAAK;4BAAE,OAAO,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC;wBAC/B,MAAM,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC,CAAC,WAAW,GAAG,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,MAAM,GAAG,WAAW,CAAC;qBACvF;iBACD;SACF;QAED,IAAI,SAAS,GAAG,IAAI,CAAC,qBAAqB,CAAiB,UAAU,EAAE,WAAW,EAAE,QAAQ,CAAC,CAAC;QAC9F,IAAI,KAAK,GAAG,SAAS,CAAC,CAAC,CAAC,EAAE,KAAK,GAAG,SAAS,CAAC,CAAC,CAAC,EAAE,cAAc,GAAG,IAAI,CAAC,cAAc,CAAC;QACrF,IAAI,GAAG,GAAG,KAAK,CAAC;QAChB,IAAI,cAAc,IAAI,CAAC;YACtB,GAAG,GAAG,IAAI,CAAC,UAAU,IAAI,UAAU,CAAC,KAAK,CAAC;aACtC;YACJ,GAAG,GAAG,KAAK,CAAC;YACZ,IAAI,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;YACzB,cAAc,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC;SACnF;QACD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,SAAS,EAAE,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE;YAClD,IAAI,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;YACpB,IAAI,CAAC,MAAM,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC;YAC5C,IAAI,CAAC,MAAM,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC;YAC5C,IAAI,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,GAAG,CAAC,GAAG,KAAK,EAAE,EAAE,GAAG,CAAC,GAAG,KAAK,CAAC;YAC3E,IAAI,KAAK,EAAE;gBACV,IAAI,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;gBACxB,IAAI,MAAM,IAAI,CAAC,EAAE;oBAChB,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,GAAG,MAAM,GAAG,CAAC,CAAC,GAAG,SAAS,GAAG,CAAC,CAAC;oBACpE,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC;oBACZ,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC;iBACZ;aACD;YACD,KAAK,GAAG,CAAC,CAAC;YACV,KAAK,GAAG,CAAC,CAAC;YACV,IAAI,SAAS,GAAG,CAAC,EAAE;gBAClB,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,CAAC,EAAE,GAAG,GAAG,CAAC,CAAC;gBAC5E,IAAI,QAAQ;oBACX,CAAC,GAAG,SAAS,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;qBACjB,IAAI,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC;oBAC1B,CAAC,GAAG,SAAS,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;;oBAErB,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;gBACxB,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;gBACtB,IAAI,GAAG,EAAE;oBACR,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;oBAClB,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;oBAClB,IAAI,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC;oBAC9B,KAAK,IAAI,CAAC,MAAM,GAAG,CAAC,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,CAAC,CAAC,GAAG,EAAE,CAAC,GAAG,SAAS,CAAC;oBACzD,KAAK,IAAI,CAAC,MAAM,GAAG,CAAC,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,CAAC,CAAC,GAAG,EAAE,CAAC,GAAG,SAAS,CAAC;iBACzD;qBAAM;oBACN,CAAC,IAAI,cAAc,CAAC;iBACpB;gBACD,IAAI,CAAC,GAAG,SAAS,CAAC,EAAE;oBACnB,CAAC,IAAI,SAAS,CAAC,GAAG,CAAC;qBACf,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,EAAE,EAAE;oBAC7B,CAAC,IAAI,SAAS,CAAC,GAAG,CAAC;gBACpB,CAAC,IAAI,SAAS,CAAC;gBACf,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;gBAClB,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;gBAClB,IAAI,CAAC,CAAC,GAAG,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,CAAC,CAAC;gBAC3B,IAAI,CAAC,CAAC,GAAG,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,CAAC,CAAC;gBAC3B,IAAI,CAAC,CAAC,GAAG,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,CAAC,CAAC;gBAC3B,IAAI,CAAC,CAAC,GAAG,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,CAAC,CAAC;aAC3B;YACD,IAAI,CAAC,sBAAsB,EAAE,CAAC;SAC9B;IACF,CAAC;IAED,qBAAqB,CAAE,IAAoB,EAAE,WAAmB,EAAE,QAAiB;QAClF,IAAI,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;QACzB,IAAI,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC;QAC7B,IAAI,MAAM,GAAG,IAAI,CAAC,MAAM,EAAE,GAAG,GAAG,KAAK,CAAC,YAAY,CAAC,IAAI,CAAC,SAAS,EAAE,WAAW,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,GAAkB,IAAI,CAAC;QACrH,IAAI,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;QACzB,IAAI,cAAc,GAAG,IAAI,CAAC,mBAAmB,EAAE,UAAU,GAAG,cAAc,GAAG,CAAC,EAAE,SAAS,GAAG,cAAc,CAAC,IAAI,CAAC;QAEhH,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE;YACxB,IAAI,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;YAC3B,UAAU,IAAI,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAC7B,IAAI,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;YACrC,IAAI,IAAI,CAAC,IAAI,CAAC,YAAY,IAAI,YAAY,CAAC,OAAO;gBAAE,QAAQ,IAAI,UAAU,CAAC;YAE3E,IAAI,UAAU,CAAC;YACf,QAAQ,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE;gBAC9B,KAAK,WAAW,CAAC,OAAO;oBACvB,UAAU,GAAG,UAAU,CAAC;oBACxB,MAAM;gBACP,KAAK,WAAW,CAAC,YAAY;oBAC5B,UAAU,GAAG,UAAU,GAAG,WAAW,CAAC;oBACtC,MAAM;gBACP;oBACC,UAAU,GAAG,CAAC,CAAC;aAChB;YACD,KAAK,GAAG,KAAK,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;YAC1C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,KAAK,GAAG,CAAC,EAAE,CAAC,GAAG,WAAW,EAAE,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE;gBAC/D,IAAI,KAAK,GAAG,MAAM,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC;gBACnC,QAAQ,IAAI,KAAK,CAAC;gBAClB,IAAI,CAAC,GAAG,QAAQ,CAAC;gBAEjB,IAAI,MAAM,EAAE;oBACX,CAAC,IAAI,UAAU,CAAC;oBAChB,IAAI,CAAC,GAAG,CAAC;wBAAE,CAAC,IAAI,UAAU,CAAC;oBAC3B,KAAK,GAAG,CAAC,CAAC;iBACV;qBAAM,IAAI,CAAC,GAAG,CAAC,EAAE;oBACjB,IAAI,SAAS,IAAI,cAAc,CAAC,MAAM,EAAE;wBACvC,SAAS,GAAG,cAAc,CAAC,MAAM,CAAC;wBAClC,IAAI,CAAC,oBAAoB,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;qBACrD;oBACD,IAAI,CAAC,iBAAiB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;oBAC5C,SAAS;iBACT;qBAAM,IAAI,CAAC,GAAG,UAAU,EAAE;oBAC1B,IAAI,SAAS,IAAI,cAAc,CAAC,KAAK,EAAE;wBACtC,SAAS,GAAG,cAAc,CAAC,KAAK,CAAC;wBACjC,IAAI,CAAC,oBAAoB,CAAC,MAAM,EAAE,cAAc,GAAG,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;qBACtE;oBACD,IAAI,CAAC,gBAAgB,CAAC,CAAC,GAAG,UAAU,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;oBACxD,SAAS;iBACT;gBAED,uCAAuC;gBACvC,QAAS,KAAK,EAAE,EAAE;oBACjB,IAAI,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;oBAC5B,IAAI,CAAC,GAAG,MAAM;wBAAE,SAAS;oBACzB,IAAI,KAAK,IAAI,CAAC;wBACb,CAAC,IAAI,MAAM,CAAC;yBACR;wBACJ,IAAI,IAAI,GAAG,OAAO,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC;wBAC9B,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;qBACjC;oBACD,MAAM;iBACN;gBACD,IAAI,KAAK,IAAI,SAAS,EAAE;oBACvB,SAAS,GAAG,KAAK,CAAC;oBAClB,IAAI,MAAM,IAAI,KAAK,IAAI,UAAU,EAAE;wBAClC,IAAI,CAAC,oBAAoB,CAAC,MAAM,EAAE,cAAc,GAAG,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;wBACtE,IAAI,CAAC,oBAAoB,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;qBACrD;;wBACA,IAAI,CAAC,oBAAoB,CAAC,MAAM,EAAE,KAAK,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;iBAClE;gBACD,IAAI,CAAC,gBAAgB,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAC9G,QAAQ,IAAI,CAAC,CAAC,GAAG,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC;aACpC;YACD,OAAO,GAAG,CAAC;SACX;QAED,kBAAkB;QAClB,IAAI,MAAM,EAAE;YACX,cAAc,IAAI,CAAC,CAAC;YACpB,KAAK,GAAG,KAAK,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,EAAE,cAAc,CAAC,CAAC;YACvD,IAAI,CAAC,oBAAoB,CAAC,MAAM,EAAE,CAAC,EAAE,cAAc,GAAG,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;YACtE,IAAI,CAAC,oBAAoB,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,cAAc,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;YACtE,KAAK,CAAC,cAAc,GAAG,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;YACrC,KAAK,CAAC,cAAc,GAAG,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;SACrC;aAAM;YACN,UAAU,EAAE,CAAC;YACb,cAAc,IAAI,CAAC,CAAC;YACpB,KAAK,GAAG,KAAK,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,EAAE,cAAc,CAAC,CAAC;YACvD,IAAI,CAAC,oBAAoB,CAAC,MAAM,EAAE,CAAC,EAAE,cAAc,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;SAClE;QAED,iBAAiB;QACjB,IAAI,MAAM,GAAG,KAAK,CAAC,YAAY,CAAC,IAAI,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;QACzD,IAAI,UAAU,GAAG,CAAC,CAAC;QACnB,IAAI,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC,EAAE,GAAG,GAAG,CAAC,EAAE,GAAG,GAAG,CAAC,EAAE,GAAG,GAAG,CAAC,EAAE,GAAG,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC;QACrF,IAAI,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,GAAG,GAAG,CAAC,EAAE,GAAG,GAAG,CAAC,CAAC;QACnF,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,UAAU,EAAE,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE;YACnD,GAAG,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;YACf,GAAG,GAAG,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;YACnB,GAAG,GAAG,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;YACnB,GAAG,GAAG,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;YACnB,EAAE,GAAG,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;YAClB,EAAE,GAAG,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;YAClB,IAAI,GAAG,CAAC,EAAE,GAAG,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,GAAG,MAAM,CAAC;YACrC,IAAI,GAAG,CAAC,EAAE,GAAG,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,GAAG,MAAM,CAAC;YACrC,KAAK,GAAG,CAAC,CAAC,GAAG,GAAG,GAAG,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC;YAC9C,KAAK,GAAG,CAAC,CAAC,GAAG,GAAG,GAAG,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC;YAC9C,IAAI,GAAG,IAAI,GAAG,CAAC,GAAG,KAAK,CAAC;YACxB,IAAI,GAAG,IAAI,GAAG,CAAC,GAAG,KAAK,CAAC;YACxB,GAAG,GAAG,CAAC,GAAG,GAAG,EAAE,CAAC,GAAG,IAAI,GAAG,IAAI,GAAG,KAAK,GAAG,UAAU,CAAC;YACpD,GAAG,GAAG,CAAC,GAAG,GAAG,EAAE,CAAC,GAAG,IAAI,GAAG,IAAI,GAAG,KAAK,GAAG,UAAU,CAAC;YACpD,UAAU,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC,CAAC;YAC/C,GAAG,IAAI,IAAI,CAAC;YACZ,GAAG,IAAI,IAAI,CAAC;YACZ,IAAI,IAAI,KAAK,CAAC;YACd,IAAI,IAAI,KAAK,CAAC;YACd,UAAU,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC,CAAC;YAC/C,GAAG,IAAI,IAAI,CAAC;YACZ,GAAG,IAAI,IAAI,CAAC;YACZ,UAAU,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC,CAAC;YAC/C,GAAG,IAAI,IAAI,GAAG,KAAK,CAAC;YACpB,GAAG,IAAI,IAAI,GAAG,KAAK,CAAC;YACpB,UAAU,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC,CAAC;YAC/C,MAAM,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC;YACvB,EAAE,GAAG,EAAE,CAAC;YACR,EAAE,GAAG,EAAE,CAAC;SACR;QAED,IAAI,IAAI,CAAC,IAAI,CAAC,YAAY,IAAI,YAAY,CAAC,OAAO;YAAE,QAAQ,IAAI,UAAU,CAAC;QAE3E,IAAI,UAAU,CAAC;QACf,QAAQ,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE;YAC9B,KAAK,WAAW,CAAC,OAAO;gBACvB,UAAU,GAAG,UAAU,CAAC;gBACxB,MAAM;YACP,KAAK,WAAW,CAAC,YAAY;gBAC5B,UAAU,GAAG,UAAU,GAAG,WAAW,CAAC;gBACtC,MAAM;YACP;gBACC,UAAU,GAAG,CAAC,CAAC;SAChB;QAED,IAAI,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC;QAC7B,IAAI,WAAW,GAAG,CAAC,CAAC;QACpB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,KAAK,GAAG,CAAC,EAAE,OAAO,GAAG,CAAC,EAAE,CAAC,GAAG,WAAW,EAAE,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE;YAC5E,IAAI,KAAK,GAAG,MAAM,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC;YACnC,QAAQ,IAAI,KAAK,CAAC;YAClB,IAAI,CAAC,GAAG,QAAQ,CAAC;YAEjB,IAAI,MAAM,EAAE;gBACX,CAAC,IAAI,UAAU,CAAC;gBAChB,IAAI,CAAC,GAAG,CAAC;oBAAE,CAAC,IAAI,UAAU,CAAC;gBAC3B,KAAK,GAAG,CAAC,CAAC;aACV;iBAAM,IAAI,CAAC,GAAG,CAAC,EAAE;gBACjB,IAAI,CAAC,iBAAiB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;gBAC5C,SAAS;aACT;iBAAM,IAAI,CAAC,GAAG,UAAU,EAAE;gBAC1B,IAAI,CAAC,gBAAgB,CAAC,CAAC,GAAG,UAAU,EAAE,KAAK,EAAE,cAAc,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;gBACzE,SAAS;aACT;YAED,uCAAuC;YACvC,QAAS,KAAK,EAAE,EAAE;gBACjB,IAAI,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;gBAC3B,IAAI,CAAC,GAAG,MAAM;oBAAE,SAAS;gBACzB,IAAI,KAAK,IAAI,CAAC;oBACb,CAAC,IAAI,MAAM,CAAC;qBACR;oBACJ,IAAI,IAAI,GAAG,MAAM,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC;oBAC7B,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;iBACjC;gBACD,MAAM;aACN;YAED,yBAAyB;YACzB,IAAI,KAAK,IAAI,SAAS,EAAE;gBACvB,SAAS,GAAG,KAAK,CAAC;gBAClB,IAAI,EAAE,GAAG,KAAK,GAAG,CAAC,CAAC;gBACnB,EAAE,GAAG,KAAK,CAAC,EAAE,CAAC,CAAC;gBACf,EAAE,GAAG,KAAK,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;gBACnB,GAAG,GAAG,KAAK,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;gBACpB,GAAG,GAAG,KAAK,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;gBACpB,GAAG,GAAG,KAAK,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;gBACpB,GAAG,GAAG,KAAK,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;gBACpB,EAAE,GAAG,KAAK,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;gBACnB,EAAE,GAAG,KAAK,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;gBACnB,IAAI,GAAG,CAAC,EAAE,GAAG,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,GAAG,IAAI,CAAC;gBACnC,IAAI,GAAG,CAAC,EAAE,GAAG,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,GAAG,IAAI,CAAC;gBACnC,KAAK,GAAG,CAAC,CAAC,GAAG,GAAG,GAAG,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,GAAG,KAAK,CAAC;gBAC5C,KAAK,GAAG,CAAC,CAAC,GAAG,GAAG,GAAG,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,GAAG,KAAK,CAAC;gBAC5C,IAAI,GAAG,IAAI,GAAG,CAAC,GAAG,KAAK,CAAC;gBACxB,IAAI,GAAG,IAAI,GAAG,CAAC,GAAG,KAAK,CAAC;gBACxB,GAAG,GAAG,CAAC,GAAG,GAAG,EAAE,CAAC,GAAG,GAAG,GAAG,IAAI,GAAG,KAAK,GAAG,UAAU,CAAC;gBACnD,GAAG,GAAG,CAAC,GAAG,GAAG,EAAE,CAAC,GAAG,GAAG,GAAG,IAAI,GAAG,KAAK,GAAG,UAAU,CAAC;gBACnD,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC,CAAC;gBAC/C,QAAQ,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC;gBAC1B,KAAK,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC,EAAE,EAAE,EAAE,EAAE;oBAC1B,GAAG,IAAI,IAAI,CAAC;oBACZ,GAAG,IAAI,IAAI,CAAC;oBACZ,IAAI,IAAI,KAAK,CAAC;oBACd,IAAI,IAAI,KAAK,CAAC;oBACd,WAAW,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC,CAAC;oBAChD,QAAQ,CAAC,EAAE,CAAC,GAAG,WAAW,CAAC;iBAC3B;gBACD,GAAG,IAAI,IAAI,CAAC;gBACZ,GAAG,IAAI,IAAI,CAAC;gBACZ,WAAW,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC,CAAC;gBAChD,QAAQ,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC;gBAC1B,GAAG,IAAI,IAAI,GAAG,KAAK,CAAC;gBACpB,GAAG,IAAI,IAAI,GAAG,KAAK,CAAC;gBACpB,WAAW,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC,CAAC;gBAChD,QAAQ,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC;gBAC1B,OAAO,GAAG,CAAC,CAAC;aACZ;YAED,4BAA4B;YAC5B,CAAC,IAAI,WAAW,CAAC;YACjB,QAAS,OAAO,EAAE,EAAE;gBACnB,IAAI,MAAM,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAC;gBAC/B,IAAI,CAAC,GAAG,MAAM;oBAAE,SAAS;gBACzB,IAAI,OAAO,IAAI,CAAC;oBACf,CAAC,IAAI,MAAM,CAAC;qBACR;oBACJ,IAAI,IAAI,GAAG,QAAQ,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC;oBACjC,CAAC,GAAG,OAAO,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;iBAC3C;gBACD,MAAM;aACN;YACD,IAAI,CAAC,gBAAgB,CAAC,CAAC,GAAG,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,QAAQ,IAAI,CAAC,CAAC,GAAG,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC;SAC9G;QACD,OAAO,GAAG,CAAC;IACZ,CAAC;IAED,iBAAiB,CAAE,CAAS,EAAE,IAAmB,EAAE,CAAS,EAAE,GAAkB,EAAE,CAAS;QAC1F,IAAI,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,GAAG,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,GAAG,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,EAAE,GAAG,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;QACzG,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QAC9B,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QAClC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;IAChB,CAAC;IAED,gBAAgB,CAAE,CAAS,EAAE,IAAmB,EAAE,CAAS,EAAE,GAAkB,EAAE,CAAS;QACzF,IAAI,EAAE,GAAG,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,GAAG,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;QACzG,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QAC9B,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QAClC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;IAChB,CAAC;IAED,gBAAgB,CAAE,CAAS,EAAE,EAAU,EAAE,EAAU,EAAE,GAAW,EAAE,GAAW,EAAE,GAAW,EAAE,GAAW,EAAE,EAAU,EAAE,EAAU,EAC9H,GAAkB,EAAE,CAAS,EAAE,QAAiB;QAChD,IAAI,CAAC,IAAI,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,EAAE;YACvB,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;YACZ,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,CAAC;YAChB,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,GAAG,EAAE,EAAE,GAAG,GAAG,EAAE,CAAC,CAAC;YAC5C,OAAO;SACP;QACD,IAAI,EAAE,GAAG,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,EAAE,GAAG,CAAC,CAAC;QAClE,IAAI,EAAE,GAAG,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,EAAE,GAAG,CAAC,EAAE,IAAI,GAAG,CAAC,GAAG,GAAG,EAAE,IAAI,GAAG,GAAG,GAAG,CAAC,CAAC;QAC7D,IAAI,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,GAAG,GAAG,GAAG,IAAI,GAAG,EAAE,GAAG,GAAG,EAAE,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,GAAG,GAAG,GAAG,IAAI,GAAG,EAAE,GAAG,GAAG,CAAC;QACzG,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QACX,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;QACf,IAAI,QAAQ,EAAE;YACb,IAAI,CAAC,GAAG,KAAK;gBACZ,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,GAAG,EAAE,EAAE,GAAG,GAAG,EAAE,CAAC,CAAC;;gBAE5C,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,GAAG,GAAG,GAAG,EAAE,GAAG,CAAC,GAAG,GAAG,GAAG,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,GAAG,GAAG,GAAG,EAAE,GAAG,CAAC,GAAG,GAAG,GAAG,EAAE,CAAC,CAAC,CAAC;SAC3G;IACF,CAAC;;AA5bM,mBAAI,GAAG,CAAC,CAAC,CAAC;AAAQ,qBAAM,GAAG,CAAC,CAAC,CAAC;AAAQ,oBAAK,GAAG,CAAC,CAAC,CAAC;AACjD,sBAAO,GAAG,OAAO,CAAC"}