jbrowse-plugin-graphgenomeviewer 7.4.1 → 7.4.2

package/dist/chunks/{chunk-UW7INEQF.js.map → chunk-2XZYJLCE.js.map}

@@ -1,6 +1,6 @@
 {
   "version": 3,
-  "sources": ["../../node_modules/.pnpm/@jbrowse+graph-fmmm-layout@1.0.2/node_modules/@jbrowse/graph-fmmm-layout/esm/loadFmmm.js", "../../node_modules/.pnpm/@jbrowse+graph-fmmm-layout@1.0.2/node_modules/@jbrowse/graph-fmmm-layout/esm/fmmmLayout.js", "../../node_modules/.pnpm/@jbrowse+graph-stress-layout@1.0.0/node_modules/@jbrowse/graph-stress-layout/esm/stressPlacement.js", "../../node_modules/.pnpm/@jbrowse+graph-stress-layout@1.0.0/node_modules/@jbrowse/graph-stress-layout/esm/stressEngine.js", "../../node_modules/.pnpm/@jbrowse+bandage-core@11.7.0/node_modules/@jbrowse/bandage-core/dist/chunks/chunk-CO6RGQAD.js", "../../node_modules/.pnpm/@jbrowse+bandage-core@11.7.0/node_modules/@jbrowse/bandage-core/dist/chunks/chunk-34BOZKIE.js", "../../node_modules/.pnpm/@jbrowse+bandage-core@11.7.0/node_modules/@jbrowse/bandage-core/dist/chunks/chunk-HKYXWZQS.js"],
+  "sources": ["../../node_modules/.pnpm/@jbrowse+graph-fmmm-layout@1.0.2/node_modules/@jbrowse/graph-fmmm-layout/esm/loadFmmm.js", "../../node_modules/.pnpm/@jbrowse+graph-fmmm-layout@1.0.2/node_modules/@jbrowse/graph-fmmm-layout/esm/fmmmLayout.js", "../../node_modules/.pnpm/@jbrowse+graph-stress-layout@1.0.0/node_modules/@jbrowse/graph-stress-layout/esm/stressPlacement.js", "../../node_modules/.pnpm/@jbrowse+graph-stress-layout@1.0.0/node_modules/@jbrowse/graph-stress-layout/esm/stressEngine.js", "../../node_modules/.pnpm/@jbrowse+bandage-core@11.7.1/node_modules/@jbrowse/bandage-core/dist/chunks/chunk-CO6RGQAD.js", "../../node_modules/.pnpm/@jbrowse+bandage-core@11.7.1/node_modules/@jbrowse/bandage-core/dist/chunks/chunk-34BOZKIE.js", "../../node_modules/.pnpm/@jbrowse+bandage-core@11.7.1/node_modules/@jbrowse/bandage-core/dist/chunks/chunk-HKYXWZQS.js"],
   "sourcesContent": ["let cached;\nexport function loadFmmm() {\n    cached !== null && cached !== void 0 ? cached : (cached = import('./bandage-layout.js')\n        .then(mod => mod.default())\n        .catch((e) => {\n        cached = undefined;\n        throw e;\n    }));\n    return cached;\n}\n", "import { loadFmmm } from \"./loadFmmm.js\";\nexport async function fmmmLayout(request) {\n    const engine = await loadFmmm();\n    return engine.computeLayout(request.graph, request.options);\n}\n", "// A node whose id starts with this is a deletion's route rather than sequence,\n// placed as an arch over the backbone.\nexport const ROUTE_ID = '\\u0000deletion:';\n// Where the stress engine starts an anchored graph. The backbone lies straight\n// along x at drawn length (its seeds). Every other node belongs to a piece: a\n// connected set of unplaced nodes, anchored where its links meet chains already\n// placed. A piece whose anchors sit on one placed curve is drawn in that\n// curve's frame (arc length along it, depth out of it): two anchors give a\n// spine along a circular arc of the piece's drawn length, a lens when it fits\n// its gap and a teardrop when longer, pushed out (legs, then a dropped chord,\n// then a tilt) until it clears what is drawn; a spine shorter than its gap is\n// a straight bar under it, hung deeper the wider the gap so its links leave\n// the lane; one anchor gives a straight tip. Anchors on\n// different curves use the chord between them. What a spine leaves unplaced\n// becomes pieces anchored on it, so nesting recurses. Deletion routes arch\n// above the backbone. Components with no backbone stay NaN for the engine's\n// random start.\nconst MIN_DEPTH = 12;\nconst LANE_GAP = 15;\nconst CLEAR = LANE_GAP * 0.7;\nconst TIP_ANGLE = (25 * Math.PI) / 180;\n// how deep a deletion arch rises, or a short bar hangs, per unit of its gap\nconst BOW = 0.25;\nconst BOW_CAP = 150;\n// a teardrop beside another leans away from it rather than dropping\nconst TEARDROP_TILTS = [0, -0.35, 0.35, -0.7, 0.7, -1.05, 1.05, -1.4, 1.4];\nconst SIDES = [0, 1];\nfunction other(side) {\n    return side ? 0 : 1;\n}\nfunction unit(a, b) {\n    const dx = b.x - a.x;\n    const dy = b.y - a.y;\n    const m = Math.hypot(dx, dy) || 1;\n    return { x: dx / m, y: dy / m };\n}\nfunction lerp(a, b, f) {\n    return { x: a.x + (b.x - a.x) * f, y: a.y + (b.y - a.y) * f };\n}\nfunction centroidOf(pts) {\n    let x = 0;\n    let y = 0;\n    for (const p of pts) {\n        x += p.x;\n        y += p.y;\n    }\n    return { x: x / pts.length, y: y / pts.length };\n}\nfunction arcLengths(pts) {\n    const arc = new Float64Array(pts.length);\n    for (let i = 1; i < pts.length; i++) {\n        arc[i] =\n            arc[i - 1] +\n                Math.hypot(pts[i].x - pts[i - 1].x, pts[i].y - pts[i - 1].y);\n    }\n    return arc;\n}\nfunction polylineLength(pts) {\n    var _a;\n    return (_a = arcLengths(pts)[pts.length - 1]) !== null && _a !== void 0 ? _a : 0;\n}\n// arc angle theta in (0, 2pi) with L/c = theta / (2 sin(theta/2)); a piece's\n// candidates ask for a handful of ratios hundreds of times\nconst arcAngles = new Map();\nfunction arcAngle(ratio) {\n    const known = arcAngles.get(ratio);\n    if (known !== undefined) {\n        return known;\n    }\n    const angle = solveArcAngle(ratio);\n    if (arcAngles.size > 10000) {\n        arcAngles.clear();\n    }\n    arcAngles.set(ratio, angle);\n    return angle;\n}\nfunction solveArcAngle(ratio) {\n    let lo = 1e-6;\n    let hi = 2 * Math.PI - 1e-6;\n    for (let i = 0; i < 60; i++) {\n        const mid = (lo + hi) / 2;\n        if (mid / (2 * Math.sin(mid / 2)) < ratio) {\n            lo = mid;\n        }\n        else {\n            hi = mid;\n        }\n    }\n    return (lo + hi) / 2;\n}\n// arc length of the circular arc with chord c and sagitta s\nfunction archLength(c, s) {\n    if (c < 1e-9) {\n        return Math.PI * s;\n    }\n    const R = ((c * c) / 4 + s * s) / (2 * s);\n    const theta = 2 * Math.asin(Math.min(1, c / (2 * R)));\n    return R * (s > R ? 2 * Math.PI - theta : theta);\n}\n// from (0, drop) to (c, drop) in `length`: legs of h along v joined by a\n// circular arc\nfunction arcFlat(c, length, h, drop) {\n    const arc = length - 2 * h;\n    const theta = c < 1e-9 ? 2 * Math.PI : arcAngle(arc / c);\n    const R = arc / theta;\n    const cos = Math.cos(theta / 2);\n    const cu = c / 2;\n    const cv = drop + h - R * cos;\n    return {\n        at: t => {\n            if (t <= h) {\n                return { u: 0, v: drop + t };\n            }\n            if (t >= length - h) {\n                return { u: c, v: drop + length - t };\n            }\n            const a = (t - h) / R - theta / 2;\n            return { u: cu + R * Math.sin(a), v: cv + R * Math.cos(a) };\n        },\n        apex: drop + h + R * (1 - cos),\n        length,\n    };\n}\n// The flat curve rotated about its chord's midpoint, which moves its feet\n// off the anchors by (c/2) sin(angle): one up, one down. A shear that kept\n// the feet swung a deep loop across its neighbours and raised link crossings\n// by half on the KIV-2 eight-haplotype cut.\nfunction tilted(flat, c, angle) {\n    if (!angle) {\n        return flat;\n    }\n    const cos = Math.cos(angle);\n    const sin = Math.sin(angle);\n    return {\n        ...flat,\n        at: t => {\n            const { u, v } = flat.at(t);\n            const du = u - c / 2;\n            return { u: c / 2 + du * cos - v * sin, v: du * sin + v * cos };\n        },\n    };\n}\n// whether any of the flat curve lies behind its frame: a loop's top poking\n// up through the reference line, which read as a glitch on every walk panel\nfunction behindFrame(flat) {\n    for (let i = 0; i <= 32; i++) {\n        if (flat.at((flat.length * i) / 32).v < -1e-6) {\n            return true;\n        }\n    }\n    return false;\n}\nfunction lineFlat(u0, v0, du, dv, length) {\n    return {\n        at: t => ({ u: u0 + du * t, v: v0 + dv * t }),\n        apex: v0 + Math.max(0, dv) * length,\n        length,\n    };\n}\n// A placed curve: dense samples with cumulative arc length and outward normals.\nclass Curve {\n    constructor(pts, normals, straight = false) {\n        var _a;\n        this.pts = pts;\n        this.normals = normals;\n        this.straight = straight;\n        this.arc = arcLengths(pts);\n        this.total = (_a = this.arc[pts.length - 1]) !== null && _a !== void 0 ? _a : 0;\n    }\n    segment(t) {\n        const { arc } = this;\n        let lo = 1;\n        let hi = arc.length - 1;\n        while (lo < hi) {\n            const mid = (lo + hi) >> 1;\n            if (arc[mid] < t) {\n                lo = mid + 1;\n            }\n            else {\n                hi = mid;\n            }\n        }\n        return lo;\n    }\n    fraction(i, t) {\n        const span = this.arc[i] - this.arc[i - 1];\n        return span > 0 ? (t - this.arc[i - 1]) / span : 0;\n    }\n    pointAt(t) {\n        const { pts } = this;\n        const last = pts.length - 1;\n        if (last === 0) {\n            return { ...pts[0] };\n        }\n        if (t <= 0) {\n            const d = unit(pts[0], pts[1]);\n            return { x: pts[0].x + d.x * t, y: pts[0].y + d.y * t };\n        }\n        if (t >= this.total) {\n            const d = unit(pts[last - 1], pts[last]);\n            const r = t - this.total;\n            return { x: pts[last].x + d.x * r, y: pts[last].y + d.y * r };\n        }\n        const i = this.segment(t);\n        return lerp(pts[i - 1], pts[i], this.fraction(i, t));\n    }\n    normalAt(t) {\n        const { normals } = this;\n        if (normals.length === 1 || t <= 0) {\n            return normals[0];\n        }\n        if (t >= this.total) {\n            return normals[normals.length - 1];\n        }\n        const i = this.segment(t);\n        const { x, y } = lerp(normals[i - 1], normals[i], this.fraction(i, t));\n        const m = Math.hypot(x, y) || 1;\n        return { x: x / m, y: y / m };\n    }\n}\n// A polyline's outward normals: the perpendicular pointing away from its\n// centroid where the shape is fat enough to say, else the frame's own outward.\nfunction outwardNormals(pts, outRef) {\n    const centroid = centroidOf(pts);\n    return pts.map((p, i) => {\n        const t = unit(pts[Math.max(0, i - 1)], pts[Math.min(pts.length - 1, i + 1)]);\n        const n = { x: -t.y, y: t.x };\n        const rx = p.x - centroid.x;\n        const ry = p.y - centroid.y;\n        const rm = Math.hypot(rx, ry);\n        const dot = n.x * rx + n.y * ry;\n        const ref = outRef[i];\n        const sign = rm > 1e-9 && Math.abs(dot) > 0.3 * rm\n            ? Math.sign(dot)\n            : Math.sign(n.x * ref.x + n.y * ref.y) || 1;\n        return { x: n.x * sign, y: n.y * sign };\n    });\n}\n// the flat curve carried into the frame from arc length tA, outward by sign,\n// sampled every `step` at most\nfunction mapFlat(frame, tA, sign, flat, step) {\n    const ds = Math.min(step, Math.max(flat.length / 24, 0.5));\n    const pts = [];\n    const refs = [];\n    for (let t = 0; t <= flat.length + 1e-9; t += ds) {\n        const { u, v } = flat.at(Math.min(t, flat.length));\n        const q = frame.pointAt(tA + u);\n        const nr = frame.normalAt(tA + u);\n        const ox = nr.x * sign;\n        const oy = nr.y * sign;\n        pts.push({ x: q.x + ox * v, y: q.y + oy * v });\n        refs.push({ x: ox, y: oy });\n    }\n    return { pts, refs };\n}\nconst FINE_STEP = 5;\nconst COARSE_STEP = CLEAR / 2;\n// the flat curve whose image in a curved frame has the asked length, within\n// a tenth of a percent or six tries\nfunction fitted(frame, tA, sign, make, length, step) {\n    let flatLength = length;\n    let mapped = mapFlat(frame, tA, sign, make(flatLength), step);\n    if (frame.straight) {\n        return mapped;\n    }\n    for (let i = 0; i < 6; i++) {\n        const got = polylineLength(mapped.pts);\n        if (!(got > 0) || Math.abs(got / length - 1) < 1e-3) {\n            break;\n        }\n        flatLength *= length / got;\n        mapped = mapFlat(frame, tA, sign, make(flatLength), step);\n    }\n    return mapped;\n}\nfunction depths(from, n) {\n    return Array.from({ length: n }, (_, i) => from + (i * LANE_GAP) / 2);\n}\nfunction spanOf(anchors) {\n    if (anchors.length === 0) {\n        return Infinity;\n    }\n    let lo = Infinity;\n    let hi = -Infinity;\n    for (const a of anchors) {\n        lo = Math.min(lo, a.point.x);\n        hi = Math.max(hi, a.point.x);\n    }\n    return hi - lo;\n}\nfunction cellKey(gx, gy) {\n    return (gx * 73856093) ^ (gy * 19349663);\n}\nclass Placer {\n    constructor(c) {\n        this.c = c;\n        this.grid = new Map();\n        const { ids, first, count, per, seedX, seedY, backbone } = c;\n        const N = ids.length;\n        this.points = Array.from({ length: N }, () => undefined);\n        this.params = Array.from({ length: N }, () => undefined);\n        this.curves = Array.from({ length: N }, () => undefined);\n        this.links = c.links.map((sides, k) => sides.map(out => out.filter(([v]) => v !== k)));\n        this.route = ids.map(id => id.startsWith(ROUTE_ID));\n        let min = Infinity;\n        let max = -Infinity;\n        for (let k = 0; k < N; k++) {\n            const start = first[k];\n            if (!backbone[start] || Number.isNaN(seedX[start])) {\n                continue;\n            }\n            min = Math.min(min, seedX[start]);\n            max = Math.max(max, seedX[start] + per[k] * (count[k] - 1));\n        }\n        this.backbone = new Curve([\n            { x: min, y: 0 },\n            { x: max, y: 0 },\n        ], [\n            { x: 0, y: 1 },\n            { x: 0, y: 1 },\n        ], true);\n        this.backboneCentroid = { x: (min + max) / 2, y: 0 };\n        for (let k = 0; k < N; k++) {\n            const start = first[k];\n            if (!backbone[start] || Number.isNaN(seedX[start])) {\n                continue;\n            }\n            const pts = [];\n            const ts = [];\n            for (let i = 0; i < count[k]; i++) {\n                const x = seedX[start] + i * per[k];\n                pts.push({ x, y: seedY[start] });\n                ts.push(x - min);\n            }\n            this.points[k] = pts;\n            this.params[k] = ts;\n            this.curves[k] = this.backbone;\n            this.occupy(pts, this.backbone);\n        }\n    }\n    static hasBackbone(c) {\n        for (let k = 0; k < c.ids.length; k++) {\n            const start = c.first[k];\n            if (c.backbone[start] && !Number.isNaN(c.seedX[start])) {\n                return true;\n            }\n        }\n        return false;\n    }\n    run() {\n        const free = [];\n        for (let k = 0; k < this.points.length; k++) {\n            if (!this.points[k]) {\n                free.push(k);\n            }\n        }\n        // Narrow pieces first, short before long, except that pieces on the same\n        // feet go longest first so an inner loop nests inside the outer one rather\n        // than crossing it. A wide loop whose foot lies inside a narrower loop's\n        // disc still drives its leg through it; making the narrow loop yield and\n        // re-place after the wide one freed it but re-placed it as a hairpin on\n        // long legs, 243/411/13 to 229/459/21 link-node/link-link/node-node\n        // crossings on the KIV-2 eight-haplotype cut at twice the time, and\n        // leaning the re-placed loop by shear at 0.1-0.4 rad gave 310/480/25.\n        const pieces = this.componentsOf(free)\n            .map(members => ({ members, anchors: this.anchorsOf(members) }))\n            .filter(p => p.anchors.length)\n            .map(p => ({\n            members: p.members,\n            span: spanOf(p.anchors),\n            drawn: p.members.reduce((s, k) => s + this.drawn(k), 0),\n            feet: p.anchors\n                .map(a => `${a.point.x},${a.point.y}`)\n                .sort()\n                .join(' '),\n        }))\n            .sort((a, b) => a.span - b.span ||\n            (a.feet === b.feet ? b.drawn - a.drawn : a.drawn - b.drawn));\n        for (const p of pieces) {\n            this.placePiece(p.members, this.backboneCentroid);\n        }\n    }\n    write(X, Y) {\n        const { first } = this.c;\n        this.points.forEach((pts, k) => {\n            pts === null || pts === void 0 ? void 0 : pts.forEach((p, i) => {\n                X[first[k] + i] = p.x;\n                Y[first[k] + i] = p.y;\n            });\n        });\n    }\n    drawn(k) {\n        return this.c.per[k] * (this.c.count[k] - 1);\n    }\n    endIndex(k, side) {\n        return side ? this.c.count[k] - 1 : 0;\n    }\n    occupy(pts, curve) {\n        for (const p of pts) {\n            const key = cellKey(Math.floor(p.x / CLEAR), Math.floor(p.y / CLEAR));\n            const list = this.grid.get(key);\n            const occupant = { x: p.x, y: p.y, curve };\n            if (list) {\n                list.push(occupant);\n            }\n            else {\n                this.grid.set(key, [occupant]);\n            }\n        }\n    }\n    // placed points within CLEAR of the candidate, off the exempt curve and\n    // beyond a lane of the anchors, up to `limit`. Exempting two lanes let\n    // teardrops off adjacent anchors cross at the neck: 3 node crossings on the\n    // HPRC KIV-2 cut against 1, and 2 on MHC class II against 0.\n    violations(pts, exempt, anchorPts, limit) {\n        var _a;\n        let n = 0;\n        for (const p of pts) {\n            if (anchorPts.some(a => Math.hypot(p.x - a.x, p.y - a.y) < LANE_GAP)) {\n                continue;\n            }\n            const cx = Math.floor(p.x / CLEAR);\n            const cy = Math.floor(p.y / CLEAR);\n            for (let gx = cx - 1; gx <= cx + 1; gx++) {\n                for (let gy = cy - 1; gy <= cy + 1; gy++) {\n                    for (const q of (_a = this.grid.get(cellKey(gx, gy))) !== null && _a !== void 0 ? _a : []) {\n                        if (q.curve !== exempt &&\n                            Math.hypot(p.x - q.x, p.y - q.y) < CLEAR) {\n                            n++;\n                            if (n >= limit) {\n                                return n;\n                            }\n                        }\n                    }\n                }\n            }\n        }\n        return n;\n    }\n    // The first candidate that clears what is drawn, else the least crowded.\n    // Exempting only the feet of pieces at the same anchor, or adding\n    // candidates with legs splayed a lane or more out from the anchors, moved\n    // no count that mattered on the HPRC cuts.\n    choose(candidates, exempt, anchorPts) {\n        let best;\n        let bestV = Infinity;\n        for (const candidate of candidates) {\n            const v = this.violations(candidate(COARSE_STEP).pts, exempt, anchorPts, bestV);\n            if (v === 0) {\n                return candidate(FINE_STEP);\n            }\n            if (v < bestV) {\n                bestV = v;\n                best = candidate;\n            }\n        }\n        return best(FINE_STEP);\n    }\n    anchorsOf(members) {\n        const set = new Set(members);\n        const out = [];\n        for (const u of members) {\n            for (const uSide of SIDES) {\n                for (const [v, vSide] of this.links[u][uSide]) {\n                    const pts = this.points[v];\n                    if (set.has(v) || !pts) {\n                        continue;\n                    }\n                    const i = this.endIndex(v, vSide);\n                    out.push({\n                        u,\n                        uSide,\n                        v,\n                        vSide,\n                        point: pts[i],\n                        curve: this.curves[v],\n                        t: this.params[v][i],\n                    });\n                }\n            }\n        }\n        return out;\n    }\n    componentsOf(members) {\n        const set = new Set(members);\n        const seen = new Set();\n        const comps = [];\n        for (const s of members) {\n            if (seen.has(s)) {\n                continue;\n            }\n            const queue = [s];\n            seen.add(s);\n            for (const u of queue) {\n                for (const side of SIDES) {\n                    for (const [v] of this.links[u][side]) {\n                        if (set.has(v) && !seen.has(v)) {\n                            seen.add(v);\n                            queue.push(v);\n                        }\n                    }\n                }\n            }\n            comps.push(queue);\n        }\n        return comps;\n    }\n    // side-consistent BFS over (node, entered side) within the piece; without a\n    // target, the path to the farthest state\n    spinePath(members, from, fromSide, to, toExitSide) {\n        const set = new Set(members);\n        const key = (k, s) => k * 2 + s;\n        const reached = (k, s) => k === to && other(s) === toExitSide;\n        const prev = new Map([[key(from, fromSide), -1]]);\n        const queue = [[from, fromSide]];\n        let far = [from, fromSide];\n        for (const [k, s] of queue) {\n            far = [k, s];\n            if (to !== undefined && reached(k, s)) {\n                break;\n            }\n            for (const [v, t] of this.links[k][other(s)]) {\n                if (!set.has(v) || prev.has(key(v, t))) {\n                    continue;\n                }\n                prev.set(key(v, t), key(k, s));\n                queue.push([v, t]);\n            }\n        }\n        if (to !== undefined && !reached(far[0], far[1])) {\n            return undefined;\n        }\n        const path = [];\n        for (let cur = key(far[0], far[1]); cur !== -1; cur = prev.get(cur)) {\n            path.push({ k: cur >> 1, enter: (cur & 1) });\n        }\n        return path.reverse();\n    }\n    loosePath(members, from, to) {\n        const set = new Set(members);\n        const prev = new Map([[from, -1]]);\n        const side = new Map([[from, 0]]);\n        const queue = [from];\n        for (const k of queue) {\n            if (k === to) {\n                break;\n            }\n            for (const s of SIDES) {\n                for (const [v, t] of this.links[k][s]) {\n                    if (!set.has(v) || prev.has(v)) {\n                        continue;\n                    }\n                    prev.set(v, k);\n                    side.set(v, t);\n                    queue.push(v);\n                }\n            }\n        }\n        const path = [];\n        for (let cur = to; cur !== -1; cur = prev.get(cur)) {\n            path.push({ k: cur, enter: side.get(cur) });\n        }\n        return path.reverse();\n    }\n    spineLength(spine) {\n        const { link } = this.c;\n        return spine.reduce((s, { k }) => s + this.drawn(k) + link, link);\n    }\n    // the spine's chains along the curve from arc length t0, at their own\n    // spacing unless one is given\n    layAlong(spine, curve, t0, spacing) {\n        const { count, per, link } = this.c;\n        let t = t0;\n        const all = [];\n        for (const { k, enter } of spine) {\n            const step = spacing !== null && spacing !== void 0 ? spacing : per[k];\n            const pts = [];\n            const ts = [];\n            for (let i = 0; i < count[k]; i++) {\n                pts.push(curve.pointAt(t + i * step));\n                ts.push(t + i * step);\n            }\n            if (enter === 1) {\n                pts.reverse();\n                ts.reverse();\n            }\n            this.points[k] = pts;\n            this.params[k] = ts;\n            this.curves[k] = curve;\n            all.push(...pts);\n            t += step * (count[k] - 1) + link;\n        }\n        return all;\n    }\n    arcCandidates(frame, tA, sign, c, L) {\n        const hMax = (L - c) / 2 - 1e-6;\n        const tilts = L > 2 * c ? TEARDROP_TILTS : [0];\n        const candidates = [];\n        for (const drop of depths(0, 8)) {\n            for (const tilt of tilts) {\n                for (let i = 0; i <= 16; i++) {\n                    const h = (hMax * i) / 16;\n                    const flat = tilted(arcFlat(c, L, h, drop), c, tilt);\n                    if ((i < 16 && flat.apex < MIN_DEPTH) || behindFrame(flat)) {\n                        continue;\n                    }\n                    candidates.push(step => fitted(frame, tA, sign, length => tilted(arcFlat(c, length, Math.min(h, (length - c) / 2 - 1e-6), drop), c, tilt), L, step));\n                }\n            }\n        }\n        return candidates;\n    }\n    placePiece(members, parent) {\n        var _a;\n        const { count, link } = this.c;\n        const anchors = this.anchorsOf(members);\n        if (anchors.length === 0) {\n            return;\n        }\n        const route = members.every(k => this.route[k]);\n        const shared = anchors.every(a => a.curve === anchors[0].curve)\n            ? anchors[0].curve\n            : undefined;\n        let frame;\n        let tA;\n        let tB;\n        let sign;\n        if (shared) {\n            anchors.sort((a, b) => a.t - b.t);\n            frame = shared;\n            tA = anchors[0].t;\n            tB = anchors[anchors.length - 1].t;\n            sign = frame === this.backbone && route ? -1 : 1;\n        }\n        else {\n            // A piece between curves hangs on the chord, and its links stay long.\n            // Relaxing just these pieces over their links with the rest held\n            // stretched the junction nodes across the gap instead: on the KIV-2\n            // eight-haplotype cut, chain length error 0.3% to 57% and node\n            // crossings 22 to 48. Hanging the piece on the curve with most anchors\n            // more than doubled that cut's link crossings.\n            anchors.sort((a, b) => a.point.x - b.point.x || a.point.y - b.point.y);\n            const a = anchors[0].point;\n            const b = anchors[anchors.length - 1].point;\n            const chord = Math.hypot(b.x - a.x, b.y - a.y);\n            const u = chord > 1e-9 ? unit(a, b) : { x: 1, y: 0 };\n            const n = { x: -u.y, y: u.x };\n            const mid = lerp(a, b, 0.5);\n            sign = anchors.some(x => x.curve === this.backbone)\n                ? (route ? -1 : 1) * (Math.sign(n.y) || 1)\n                : (mid.x - parent.x) * n.x + (mid.y - parent.y) * n.y >= 0\n                    ? 1\n                    : -1;\n            frame = new Curve([a, b], [n, n], true);\n            tA = 0;\n            tB = chord;\n        }\n        const A = anchors[0];\n        const B = anchors[anchors.length - 1];\n        const c = tB - tA;\n        const single = anchors.length === 1 || (A.u === B.u && A.uSide === B.uSide && c < 1e-9);\n        const anchorPts = [A.point, B.point];\n        const pick = (candidates) => this.choose(candidates, shared, anchorPts);\n        let spine;\n        let mapped;\n        let start = link;\n        let spacing;\n        if (single) {\n            spine = this.spinePath(members, A.u, A.uSide);\n            const L = this.spineLength(spine);\n            const next = A.vSide\n                ? Math.max(0, count[A.v] - 2)\n                : Math.min(1, count[A.v] - 1);\n            const dirU = A.t >= this.params[A.v][next] ? 1 : -1;\n            const du = dirU * Math.cos(TIP_ANGLE);\n            const dv = Math.sin(TIP_ANGLE);\n            mapped = pick(depths(0, 12).map(drop => (step) => fitted(frame, tA, sign, length => lineFlat(0, drop, du, dv, length), L, step)));\n        }\n        else {\n            spine =\n                (_a = this.spinePath(members, A.u, A.uSide, B.u, B.uSide)) !== null && _a !== void 0 ? _a : this.loosePath(members, A.u, B.u);\n            const L = this.spineLength(spine);\n            if (route) {\n                const d0 = Math.max(MIN_DEPTH, Math.min(BOW * c, BOW_CAP));\n                mapped = pick(depths(d0, 12).map(d => (step) => mapFlat(frame, tA, sign, arcFlat(c, archLength(c, d), 0, 0), step)));\n                const total = polylineLength(mapped.pts);\n                spacing = Math.max(1e-3, (total - 2 * link) / (count[spine[0].k] - 1));\n            }\n            else if (L > c + 1e-6) {\n                mapped = pick(this.arcCandidates(frame, tA, sign, c, L));\n            }\n            else {\n                const bar = L - 2 * link;\n                const d0 = Math.max(MIN_DEPTH, Math.min(BOW * (c - bar), BOW_CAP));\n                mapped = pick(depths(d0, 12).map(d => (step) => fitted(frame, tA, sign, length => lineFlat(c / 2 - length / 2, d, 1, 0, length), bar, step)));\n                start = 0;\n            }\n        }\n        const curve = new Curve(mapped.pts, outwardNormals(mapped.pts, mapped.refs));\n        const placed = this.layAlong(spine, curve, start, spacing);\n        this.occupy(placed, curve);\n        const centroid = centroidOf(placed);\n        const rest = members.filter(k => !this.points[k]);\n        const subs = this.componentsOf(rest)\n            .map(m => ({ members: m, span: spanOf(this.anchorsOf(m)) }))\n            .sort((a, b) => a.span - b.span);\n        for (const sub of subs) {\n            this.placePiece(sub.members, centroid);\n        }\n    }\n}\n// Initial positions per point, NaN where the placement reached nothing.\nexport function stressPlacement(c) {\n    const X = new Float64Array(c.n).fill(NaN);\n    const Y = new Float64Array(c.n).fill(NaN);\n    if (Placer.hasBackbone(c)) {\n        const placer = new Placer(c);\n        placer.run();\n        placer.write(X, Y);\n    }\n    return { X, Y };\n}\n", "import { stressPlacement } from \"./stressPlacement.js\";\n// A layout taking the Bandage engine's request: each node is the chain of\n// points FMMM would build, and the result is a polyline per node.\n//\n// A component with a seeded backbone is drawn by stressPlacement: the\n// backbone straight along x, every other node hung off it. The rest is a\n// stress layout by stochastic gradient descent (Zheng, Pawar & Goodman 2019)\n// with target distances from random walks, after odgi's path-guided SGD:\n// every point starts a few walks of log-uniform length each iteration, and\n// how far a walk got is how far apart its ends should sit, so a repeat's loop\n// draws as a ring of its own circumference. Stress has no repulsion, so a\n// final pass pushes apart points that are close but not joined.\n//\n// Running the schedule on a placed component twists its loops, since a walk\n// from a loop's leg runs on along the backbone and pulls the leg to lie along\n// it: 32 node crossings on HPRC MHC class II against the placement's 4.\n// walks per point and iterations by the quality the request names\nconst QUALITY = [\n    { walks: 2, iterations: 15 },\n    { walks: 4, iterations: 30 },\n    { walks: 8, iterations: 60 },\n    { walks: 12, iterations: 90 },\n    { walks: 16, iterations: 120 },\n];\nconst UNTANGLE_PASSES = 20;\n// the untangle radius, in link lengths\nconst UNTANGLE_LINKS = 3;\nconst UNTANGLE_PUSH = 0.3;\nconst SMOOTH_PASSES = 2;\n// a 20-link cap balls a 3k-node graph up\nconst MAX_HOPS = 200;\n// the step size the schedule ends on, as a share of the smallest pair's\nconst EPS = 0.1;\n// the share of the schedule a seeded component skips\nconst WARM = 0.5;\nconst isBackbone = (node) => { var _a; return ((_a = node.stable) === null || _a === void 0 ? void 0 : _a.rank) === 0; };\nfunction flipped(strand, name) {\n    const own = name.at(-1);\n    return ((strand === '+' || strand === '-') &&\n        (own === '+' || own === '-') &&\n        strand !== own);\n}\nfunction xorshift(seed) {\n    let s = Math.imul(seed, 2654435761) >>> 0 || 1;\n    return () => {\n        s ^= s << 13;\n        s >>>= 0;\n        s ^= s >>> 17;\n        s ^= s << 5;\n        s >>>= 0;\n        return s / 4294967296;\n    };\n}\nexport function num(value, fallback) {\n    return typeof value === 'number' && Number.isFinite(value) ? value : fallback;\n}\n// A node's drawn length, in layout units, from its bp\nexport function drawnLength(options, bp) {\n    return Math.max((num(options.nodeLengthPerMegabase, 1000) * bp) / 1000000, num(options.minimumNodeLength, 1));\n}\nexport function chains(request) {\n    const { nodes, edges } = request.graph;\n    const o = request.options;\n    const segment = num(o.nodeSegmentLength, 1);\n    const link = num(o.edgeLength, 1);\n    const ids = nodes.map(n => n.id);\n    const first = new Int32Array(nodes.length);\n    const count = new Int32Array(nodes.length);\n    const per = new Float64Array(nodes.length);\n    let n = 0;\n    nodes.forEach((node, k) => {\n        const drawn = drawnLength(o, node.length);\n        const steps = Math.max(1, Math.ceil(drawn / segment));\n        first[k] = n;\n        count[k] = steps + 1;\n        per[k] = drawn / steps;\n        n += steps + 1;\n    });\n    const chainOf = new Int32Array(n);\n    const indexOf = new Int32Array(n);\n    const seedX = new Float64Array(n).fill(NaN);\n    const seedY = new Float64Array(n).fill(NaN);\n    const backbone = new Uint8Array(n);\n    const adjacent = Array.from({ length: n }, () => []);\n    nodes.forEach((node, k) => {\n        const seeded = typeof node.x === 'number' && typeof node.y === 'number';\n        const reference = isBackbone(node) ? 1 : 0;\n        for (let i = 0; i < count[k]; i++) {\n            const v = first[k] + i;\n            chainOf[v] = k;\n            indexOf[v] = i;\n            backbone[v] = reference;\n            if (seeded) {\n                seedX[v] = node.x + i * per[k];\n                seedY[v] = node.y;\n            }\n            if (i > 0) {\n                adjacent[v - 1].push([v, per[k]]);\n                adjacent[v].push([v - 1, per[k]]);\n            }\n        }\n    });\n    const index = new Map(ids.map((id, k) => [id, k]));\n    const links = nodes.map(() => [[], []]);\n    for (const edge of edges) {\n        const a = index.get(edge.from);\n        const b = index.get(edge.to);\n        if (a === undefined || b === undefined) {\n            continue;\n        }\n        // a self link on a chain of one step has nowhere to go, as in FMMM\n        if (a === b && count[a] <= 2) {\n            continue;\n        }\n        const fromSide = flipped(edge.fromStrand, edge.from) ? 0 : 1;\n        const toSide = flipped(edge.toStrand, edge.to) ? 1 : 0;\n        const u = first[a] + (fromSide ? count[a] - 1 : 0);\n        const v = first[b] + (toSide ? count[b] - 1 : 0);\n        adjacent[u].push([v, link]);\n        adjacent[v].push([u, link]);\n        links[a][fromSide].push([b, toSide]);\n        links[b][toSide].push([a, fromSide]);\n    }\n    const off = new Int32Array(n + 1);\n    for (let i = 0; i < n; i++) {\n        off[i + 1] = off[i] + adjacent[i].length;\n    }\n    const nb = new Int32Array(off[n]);\n    const wt = new Float64Array(off[n]);\n    for (let i = 0; i < n; i++) {\n        adjacent[i].forEach(([v, w], k) => {\n            nb[off[i] + k] = v;\n            wt[off[i] + k] = w;\n        });\n    }\n    return {\n        ids,\n        first,\n        count,\n        per,\n        links,\n        chainOf,\n        indexOf,\n        seedX,\n        seedY,\n        backbone,\n        off,\n        nb,\n        wt,\n        n,\n        link,\n    };\n}\n// each point's connected component, and the points of each component\nfunction components(c) {\n    const { n, off, nb } = c;\n    const comp = new Int32Array(n).fill(-1);\n    const members = [];\n    for (let s = 0; s < n; s++) {\n        if (comp[s] >= 0) {\n            continue;\n        }\n        const queue = [s];\n        comp[s] = members.length;\n        for (const u of queue) {\n            for (let e = off[u]; e < off[u + 1]; e++) {\n                const v = nb[e];\n                if (comp[v] < 0) {\n                    comp[v] = members.length;\n                    queue.push(v);\n                }\n            }\n        }\n        members.push(queue);\n    }\n    return { comp, members };\n}\nexport function stressLayout(request, opts = {}) {\n    var _a, _b, _c;\n    const c = chains(request);\n    const { n, off, nb, wt, seedX, seedY, first, count, per, link } = c;\n    const o = request.options;\n    const quality = QUALITY[Math.max(0, Math.min(4, num((_a = opts.quality) !== null && _a !== void 0 ? _a : o.quality, 2)))];\n    const gap = num((_b = opts.componentSeparation) !== null && _b !== void 0 ? _b : o.componentSeparation, 15);\n    const rand = xorshift(num((_c = opts.seed) !== null && _c !== void 0 ? _c : o.seed, 1));\n    const X = new Float64Array(n);\n    const Y = new Float64Array(n);\n    const nodePositions = {};\n    if (n === 0) {\n        return { nodePositions };\n    }\n    const { comp, members } = components(c);\n    let dmin = Infinity;\n    let total = 0;\n    for (let e = 0; e < nb.length; e++) {\n        dmin = Math.min(dmin, wt[e]);\n        total += wt[e];\n    }\n    total /= 2;\n    let anySeed = false;\n    for (let i = 0; i < n; i++) {\n        if (!Number.isNaN(seedX[i])) {\n            anySeed = true;\n            break;\n        }\n    }\n    const placed = anySeed ? stressPlacement(c) : undefined;\n    const side = Math.sqrt(n) * 20;\n    for (let i = 0; i < n; i++) {\n        if (placed && !Number.isNaN(placed.X[i])) {\n            X[i] = placed.X[i];\n            Y[i] = placed.Y[i];\n        }\n        else if (anySeed && !Number.isNaN(seedX[i])) {\n            X[i] = seedX[i] + rand() - 0.5;\n            Y[i] = seedY[i] + rand() - 0.5;\n        }\n        else {\n            X[i] = rand() * side;\n            Y[i] = rand() * side;\n        }\n    }\n    // the points the schedule moves: those of components the placement did not\n    // draw whole, in index order so the schedule runs as it would alone\n    const drawn = members.map(points => placed !== undefined && points.every(i => !Number.isNaN(placed.X[i])));\n    const loose = [];\n    let looseSeeded = true;\n    for (let i = 0; i < n; i++) {\n        if (!drawn[comp[i]]) {\n            loose.push(i);\n            looseSeeded && (looseSeeded = !Number.isNaN(seedX[i]));\n        }\n    }\n    const dmax = Math.max(total / 4, dmin * 10);\n    const etaMax = dmax * dmax;\n    const etaMin = EPS * dmin * dmin;\n    const { walks, iterations } = quality;\n    const lambda = Math.log(etaMax / etaMin) / Math.max(1, iterations - 1);\n    const logMin = Math.log(dmin);\n    const logMax = Math.log(dmax);\n    const move = (i, j, d, eta) => {\n        let mu = eta / (d * d);\n        if (mu > 1) {\n            mu = 1;\n        }\n        const dx = X[i] - X[j];\n        const dy = Y[i] - Y[j];\n        const mag = Math.sqrt(dx * dx + dy * dy) || 1e-9;\n        const r = (mu * (mag - d)) / (2 * mag);\n        const rx = r * dx;\n        const ry = r * dy;\n        X[i] = X[i] - rx;\n        Y[i] = Y[i] - ry;\n        X[j] = X[j] + rx;\n        Y[j] = Y[j] + ry;\n    };\n    // The end of a walk of up to `length` from point i, with how far it got in\n    // `walked`: a walk stops short at a free chain end.\n    let walked = 0;\n    const walk = (i, length) => {\n        let chain = c.chainOf[i];\n        let idx = c.indexOf[i];\n        let dir = rand() < 0.5 ? -1 : 1;\n        let remaining = length;\n        for (let hops = 0; hops < MAX_HOPS; hops++) {\n            const points = count[chain];\n            const step = per[chain];\n            const toEnd = (dir > 0 ? points - 1 - idx : idx) * step;\n            if (remaining <= toEnd) {\n                const steps = Math.round(remaining / step);\n                walked = length - remaining + steps * step;\n                return first[chain] + idx + dir * steps;\n            }\n            remaining -= toEnd;\n            const out = c.links[chain][dir > 0 ? 1 : 0];\n            if (out.length === 0) {\n                walked = length - remaining;\n                return first[chain] + (dir > 0 ? points - 1 : 0);\n            }\n            const [next, enterSide] = out[Math.floor(rand() * out.length)];\n            remaining -= link;\n            chain = next;\n            dir = enterSide === 0 ? 1 : -1;\n            idx = enterSide === 0 ? 0 : count[next] - 1;\n            if (remaining <= 0) {\n                walked = length - remaining;\n                return first[chain] + idx;\n            }\n        }\n        return -1;\n    };\n    const adjacentTerms = (i, eta) => {\n        for (let e = off[i]; e < off[i + 1]; e++) {\n            const j = nb[e];\n            if (j > i) {\n                move(i, j, wt[e], eta);\n            }\n        }\n    };\n    const order = Int32Array.from(loose);\n    const warm = looseSeeded ? Math.floor(WARM * iterations) : 0;\n    for (let t = loose.length ? warm : iterations; t < iterations; t++) {\n        const eta = etaMax * Math.exp(-lambda * t);\n        for (let k = order.length - 1; k > 0; k--) {\n            const r = Math.floor(rand() * (k + 1));\n            const tmp = order[k];\n            order[k] = order[r];\n            order[r] = tmp;\n        }\n        for (const i of order) {\n            adjacentTerms(i, eta);\n            for (let w = 0; w < walks; w++) {\n                const length = Math.exp(logMin + rand() * (logMax - logMin));\n                const j = walk(i, length);\n                if (j >= 0 && j !== i && walked > 0) {\n                    move(i, j, walked, eta);\n                }\n            }\n        }\n    }\n    // untangle: points closer than the radius and not joined push apart, then\n    // a sweep over the links pulls each back towards its length\n    const radius = UNTANGLE_LINKS * link;\n    const key = (x, y) => (Math.floor(x / radius) * 73856093) ^ (Math.floor(y / radius) * 19349663);\n    for (let u = 0; u < (loose.length ? UNTANGLE_PASSES : 0); u++) {\n        const grid = new Map();\n        for (const i of loose) {\n            const k = key(X[i], Y[i]);\n            const list = grid.get(k);\n            if (list) {\n                list.push(i);\n            }\n            else {\n                grid.set(k, [i]);\n            }\n        }\n        for (const i of loose) {\n            const cx = Math.floor(X[i] / radius);\n            const cy = Math.floor(Y[i] / radius);\n            for (let gx = cx - 1; gx <= cx + 1; gx++) {\n                for (let gy = cy - 1; gy <= cy + 1; gy++) {\n                    const list = grid.get((gx * 73856093) ^ (gy * 19349663));\n                    if (!list) {\n                        continue;\n                    }\n                    for (const j of list) {\n                        if (j <= i) {\n                            continue;\n                        }\n                        let joined = false;\n                        for (let e = off[i]; e < off[i + 1]; e++) {\n                            if (nb[e] === j) {\n                                joined = true;\n                                break;\n                            }\n                        }\n                        if (joined) {\n                            continue;\n                        }\n                        const dx = X[i] - X[j];\n                        const dy = Y[i] - Y[j];\n                        const mag = Math.sqrt(dx * dx + dy * dy);\n                        if (mag >= radius) {\n                            continue;\n                        }\n                        let rx;\n                        let ry;\n                        if (mag > 1e-6) {\n                            const r = (UNTANGLE_PUSH * (radius - mag)) / (2 * mag);\n                            rx = r * dx;\n                            ry = r * dy;\n                        }\n                        else {\n                            rx = UNTANGLE_PUSH * radius * (rand() - 0.5);\n                            ry = UNTANGLE_PUSH * radius * (rand() - 0.5);\n                        }\n                        X[i] = X[i] + rx;\n                        Y[i] = Y[i] + ry;\n                        X[j] = X[j] - rx;\n                        Y[j] = Y[j] - ry;\n                    }\n                }\n            }\n        }\n        for (const i of loose) {\n            adjacentTerms(i, Infinity);\n        }\n    }\n    // each chain's interior points smoothed, so a node reads as one curve, then\n    // spaced evenly along it at its drawn length\n    for (let k = 0; k < count.length; k++) {\n        const a = first[k];\n        const m = count[k];\n        if (m < 3) {\n            continue;\n        }\n        for (let s = 0; s < SMOOTH_PASSES; s++) {\n            const xs = X.slice(a, a + m);\n            const ys = Y.slice(a, a + m);\n            for (let i = 1; i + 1 < m; i++) {\n                X[a + i] = 0.5 * xs[i] + 0.25 * (xs[i - 1] + xs[i + 1]);\n                Y[a + i] = 0.5 * ys[i] + 0.25 * (ys[i - 1] + ys[i + 1]);\n            }\n        }\n        respace(X, Y, a, m, per[k]);\n    }\n    packComponents(comp, members, X, Y, anySeed, gap);\n    for (let k = 0; k < c.ids.length; k++) {\n        const points = [];\n        for (let i = 0; i < count[k]; i++) {\n            points.push({ x: X[first[k] + i], y: Y[first[k] + i] });\n        }\n        nodePositions[c.ids[k]] = points;\n    }\n    return { nodePositions };\n}\n// Points a to a+m-1 moved to equal spacing along their polyline. Smoothing\n// shortens a curve, so the interior first bulges out from the chord between\n// the ends until the length is back, and the points then take their full\n// spacing. The ends stay, since extending them along their tangents ran a\n// node past its anchors and through the links there.\nfunction respace(X, Y, a, m, per) {\n    bulge(X, Y, a, m, per * (m - 1));\n    const lengths = new Float64Array(m);\n    for (let i = 1; i < m; i++) {\n        lengths[i] =\n            lengths[i - 1] +\n                Math.hypot(X[a + i] - X[a + i - 1], Y[a + i] - Y[a + i - 1]);\n    }\n    if (!lengths[m - 1]) {\n        return;\n    }\n    const total = lengths[m - 1];\n    const xs = X.slice(a, a + m);\n    const ys = Y.slice(a, a + m);\n    let seg = 1;\n    for (let i = 1; i + 1 < m; i++) {\n        const s = (total * i) / (m - 1);\n        while (seg < m - 1 && lengths[seg] < s) {\n            seg++;\n        }\n        const span = lengths[seg] - lengths[seg - 1];\n        const t = span > 0 ? (s - lengths[seg - 1]) / span : 0;\n        X[a + i] = xs[seg - 1] + (xs[seg] - xs[seg - 1]) * t;\n        Y[a + i] = ys[seg - 1] + (ys[seg] - ys[seg - 1]) * t;\n    }\n}\n// Interior points a+1 to a+m-2 pushed out from the chord between the ends,\n// their offsets from it scaled by one factor, until the polyline is `target`\n// long. A chain lying along its chord has nothing to push and keeps its\n// length.\nfunction bulge(X, Y, a, m, target) {\n    const b = a + m - 1;\n    const cx = X[a];\n    const cy = Y[a];\n    const chord = Math.hypot(X[b] - cx, Y[b] - cy);\n    const ux = chord > 1e-9 ? (X[b] - cx) / chord : 1;\n    const uy = chord > 1e-9 ? (Y[b] - cy) / chord : 0;\n    const along = new Float64Array(m);\n    const off = new Float64Array(m);\n    let flat = true;\n    for (let i = 0; i < m; i++) {\n        const dx = X[a + i] - cx;\n        const dy = Y[a + i] - cy;\n        along[i] = dx * ux + dy * uy;\n        off[i] = dy * ux - dx * uy;\n        flat && (flat = Math.abs(off[i]) < 1e-6);\n    }\n    const lengthAt = (f) => {\n        let total = 0;\n        for (let i = 1; i < m; i++) {\n            total += Math.hypot(along[i] - along[i - 1], f * (off[i] - off[i - 1]));\n        }\n        return total;\n    };\n    if (flat || lengthAt(1) >= target) {\n        return;\n    }\n    let lo = 1;\n    let hi = 2;\n    while (lengthAt(hi) < target && hi < 1e6) {\n        lo = hi;\n        hi *= 2;\n    }\n    for (let it = 0; it < 40; it++) {\n        const mid = (lo + hi) / 2;\n        if (lengthAt(mid) < target) {\n            lo = mid;\n        }\n        else {\n            hi = mid;\n        }\n    }\n    const f = (lo + hi) / 2;\n    for (let i = 1; i + 1 < m; i++) {\n        X[a + i] = cx + along[i] * ux - f * off[i] * uy;\n        Y[a + i] = cy + along[i] * uy + f * off[i] * ux;\n    }\n}\n// Components stacked top to bottom, left aligned, `gap` apart. A component\n// with no seeds is turned so its long axis runs along x; a seeded one keeps\n// the frame its seeds stated.\nfunction packComponents(comp, members, X, Y, anySeed, gap) {\n    if (!anySeed) {\n        for (const points of members) {\n            rotateToPrincipalAxis(X, Y, points);\n        }\n    }\n    if (members.length < 2) {\n        return;\n    }\n    const minX = new Float64Array(members.length).fill(Infinity);\n    const minY = new Float64Array(members.length).fill(Infinity);\n    const maxY = new Float64Array(members.length).fill(-Infinity);\n    for (let i = 0; i < X.length; i++) {\n        const k = comp[i];\n        minX[k] = Math.min(minX[k], X[i]);\n        minY[k] = Math.min(minY[k], Y[i]);\n        maxY[k] = Math.max(maxY[k], Y[i]);\n    }\n    const shift = new Float64Array(members.length);\n    let y = 0;\n    for (let k = 0; k < members.length; k++) {\n        shift[k] = y - minY[k];\n        y += maxY[k] - minY[k] + gap;\n    }\n    for (let i = 0; i < X.length; i++) {\n        const k = comp[i];\n        X[i] = X[i] - minX[k];\n        Y[i] = Y[i] + shift[k];\n    }\n}\nfunction rotateToPrincipalAxis(X, Y, points) {\n    if (points.length < 3) {\n        return;\n    }\n    let cx = 0;\n    let cy = 0;\n    for (const i of points) {\n        cx += X[i];\n        cy += Y[i];\n    }\n    cx /= points.length;\n    cy /= points.length;\n    let sxx = 0;\n    let syy = 0;\n    let sxy = 0;\n    for (const i of points) {\n        const dx = X[i] - cx;\n        const dy = Y[i] - cy;\n        sxx += dx * dx;\n        syy += dy * dy;\n        sxy += dx * dy;\n    }\n    const angle = -0.5 * Math.atan2(2 * sxy, sxx - syy);\n    const cos = Math.cos(angle);\n    const sin = Math.sin(angle);\n    for (const i of points) {\n        const dx = X[i] - cx;\n        const dy = Y[i] - cy;\n        X[i] = cx + cos * dx - sin * dy;\n        Y[i] = cy + sin * dx + cos * dy;\n    }\n}\n", "// src/layoutEngines.ts\nimport { fmmmLayout } from \"@jbrowse/graph-fmmm-layout\";\nimport { stressLayout } from \"@jbrowse/graph-stress-layout\";\nvar LAYOUT_ENGINES = [\n  {\n    value: \"fmmm\",\n    label: \"Bandage (FMMM)\",\n    description: \"Bandage's force-directed layout: OGDF's fast multipole multilevel method, compiled to wasm.\"\n  },\n  {\n    value: \"stress\",\n    label: \"Stress\",\n    description: \"Plain JS: the reference drawn straight and each variant placed against it, an allele as a lens, a repeat loop as a ring, a deletion as an arch; stress by stochastic gradient descent for components with no reference.\"\n  }\n];\nvar LAYOUT_ENGINE_VALUES = LAYOUT_ENGINES.map((e) => e.value);\nfunction isLayoutEngineKind(value) {\n  return LAYOUT_ENGINE_VALUES.includes(value);\n}\nvar layoutEngine = async (request) => {\n  const start = performance.now();\n  const result = request.options.engine === \"stress\" ? stressLayout(request) : await fmmmLayout(request);\n  return { result, duration: performance.now() - start };\n};\n\nexport {\n  LAYOUT_ENGINES,\n  LAYOUT_ENGINE_VALUES,\n  isLayoutEngineKind,\n  layoutEngine\n};\n", "// src/layout/drawnScale.ts\nvar MEAN_NODE_LENGTH = 40;\nvar MIN_TOTAL_GRAPH_LENGTH = 500;\nvar BANDAGE_MINIMUM_NODE_LENGTH = 5;\nfunction drawnNodeLength(opts, length) {\n  return Math.max(\n    opts.nodeLengthPerMegabase * length / 1e6,\n    opts.minimumNodeLength\n  );\n}\nfunction bandageAutoScale(graph, minNodeLength = BANDAGE_MINIMUM_NODE_LENGTH) {\n  const totalLength = graph.nodes.reduce((sum, n) => sum + n.length, 0);\n  const megabases = totalLength / 1e6;\n  const target = Math.max(\n    graph.nodes.length * MEAN_NODE_LENGTH,\n    MIN_TOTAL_GRAPH_LENGTH\n  );\n  return {\n    nodeLengthPerMegabase: megabases > 0 ? target / megabases : 1e4,\n    minimumNodeLength: Math.max(BANDAGE_MINIMUM_NODE_LENGTH, minNodeLength),\n    edgeLength: 5,\n    nodeSegmentLength: 20\n  };\n}\nvar PROPORTIONAL_LENGTH = { power: 1, effect: 1 };\nfunction isProportional(law) {\n  return law.power === 1 && law.effect === 1;\n}\nfunction drawnLengthFor(graph, law) {\n  const count = graph.nodes.length;\n  const totalLength = graph.nodes.reduce((sum, n) => sum + n.length, 0);\n  const meanBp = count > 0 ? totalLength / count : 0;\n  const meanDrawn = count > 0 ? Math.max(count * MEAN_NODE_LENGTH, MIN_TOTAL_GRAPH_LENGTH) / count : MEAN_NODE_LENGTH;\n  return (bp) => {\n    if (meanBp <= 0) {\n      return meanDrawn;\n    }\n    const relative = (bp / meanBp) ** law.power;\n    return Math.max(\n      meanDrawn * ((relative - 1) * law.effect + 1),\n      BANDAGE_MINIMUM_NODE_LENGTH\n    );\n  };\n}\nvar LAYOUT_LENGTH_PRECISION = 1e3;\nvar PROPORTIONAL_SPREAD = {\n  law: PROPORTIONAL_LENGTH,\n  minNodeLength: 0\n};\nfunction layoutScaling(graph, spread = PROPORTIONAL_SPREAD) {\n  const { law, minNodeLength } = spread;\n  const opts = bandageAutoScale(graph, minNodeLength);\n  if (isProportional(law)) {\n    return { nodes: graph.nodes, opts };\n  }\n  const drawn = drawnLengthFor(graph, law);\n  return {\n    nodes: graph.nodes.map((node) => ({\n      ...node,\n      length: Math.round(drawn(node.length) * LAYOUT_LENGTH_PRECISION)\n    })),\n    opts: {\n      ...opts,\n      nodeLengthPerMegabase: 1e6 / LAYOUT_LENGTH_PRECISION,\n      // Bandage's own floor only. A law and a raised floor are alternatives\n      // rather than a stack: the law has already lifted the small end, and a\n      // floor on top of it would flatten exactly what it just spread.\n      minimumNodeLength: BANDAGE_MINIMUM_NODE_LENGTH\n    }\n  };\n}\nfunction drawnLengthOf(graph, spread = PROPORTIONAL_SPREAD) {\n  if (isProportional(spread.law)) {\n    const opts = bandageAutoScale(graph, spread.minNodeLength);\n    return (bp) => drawnNodeLength(opts, bp);\n  }\n  return drawnLengthFor(graph, spread.law);\n}\n\nexport {\n  MEAN_NODE_LENGTH,\n  drawnNodeLength,\n  bandageAutoScale,\n  PROPORTIONAL_LENGTH,\n  drawnLengthFor,\n  layoutScaling,\n  drawnLengthOf\n};\n", "import {\n  MEAN_NODE_LENGTH,\n  PROPORTIONAL_LENGTH\n} from \"./chunk-34BOZKIE.js\";\n\n// src/bubbleSpreads.ts\nvar BUBBLE_SPREADS = [\n  {\n    value: \"auto\",\n    label: \"Proportional\",\n    description: \"Bandage's own scale: a node draws proportional to its length, so a 1 bp allele is a speck.\",\n    law: PROPORTIONAL_LENGTH,\n    minNodeFactor: 0\n  },\n  {\n    value: \"open\",\n    label: \"Open bubbles\",\n    description: \"Give every allele a drawn length, so a bubble reads as two arms rather than a knot.\",\n    law: PROPORTIONAL_LENGTH,\n    minNodeFactor: 2.5\n  },\n  {\n    value: \"wide\",\n    label: \"Wide bubbles\",\n    description: \"As open, spread further. Best on a window of a dozen bubbles.\",\n    law: PROPORTIONAL_LENGTH,\n    minNodeFactor: 10\n  },\n  {\n    value: \"compress\",\n    label: \"Compress lengths\",\n    description: \"Pull the longest and shortest nodes towards the graph\\u2019s mean, so a cut spanning kb and bp fits one pane.\",\n    law: { power: 0.5, effect: 0.5 },\n    minNodeFactor: 0\n  }\n];\nvar BUBBLE_SPREAD_VALUES = BUBBLE_SPREADS.map((s) => s.value);\nfunction spreadFor(spread) {\n  const entry = BUBBLE_SPREADS.find((s) => s.value === spread);\n  return {\n    law: entry?.law ?? PROPORTIONAL_LENGTH,\n    minNodeLength: (entry?.minNodeFactor ?? 0) * MEAN_NODE_LENGTH\n  };\n}\n\nexport {\n  BUBBLE_SPREADS,\n  BUBBLE_SPREAD_VALUES,\n  spreadFor\n};\n"],
   "mappings": "AAAA,IAAIA,GACG,SAASC,IAAW,CACvB,OAAAD,KAAiDA,GAAS,OAAO,8BAAqB,EACjF,KAAKE,GAAOA,EAAI,QAAQ,CAAC,EACzB,MAAOC,GAAM,CACd,MAAAH,GAAS,OACHG,CACV,CAAC,GACMH,EACX,CCRA,eAAsBI,GAAWC,EAAS,CAEtC,OADe,MAAMC,GAAS,GAChB,cAAcD,EAAQ,MAAOA,EAAQ,OAAO,CAC9D,CCFO,IAAME,GAAW,cAkBxB,IAAMC,GAAa,GAAK,KAAK,GAAM,IAE7BC,GAAM,IACNC,GAAU,IAEVC,GAAiB,CAAC,EAAG,KAAO,IAAM,IAAM,GAAK,MAAO,KAAM,KAAM,GAAG,EACnEC,GAAQ,CAAC,EAAG,CAAC,EACnB,SAASC,GAAMC,EAAM,CACjB,OAAOA,EAAO,EAAI,CACtB,CACA,SAASC,GAAKC,EAAGC,EAAG,CAChB,IAAMC,EAAKD,EAAE,EAAID,EAAE,EACbG,EAAKF,EAAE,EAAID,EAAE,EACbI,EAAI,KAAK,MAAMF,EAAIC,CAAE,GAAK,EAChC,MAAO,CAAE,EAAGD,EAAKE,EAAG,EAAGD,EAAKC,CAAE,CAClC,CACA,SAASC,GAAKL,EAAGC,EAAGK,EAAG,CACnB,MAAO,CAAE,EAAGN,EAAE,GAAKC,EAAE,EAAID,EAAE,GAAKM,EAAG,EAAGN,EAAE,GAAKC,EAAE,EAAID,EAAE,GAAKM,CAAE,CAChE,CACA,SAASC,GAAWC,EAAK,CACrB,IAAIC,EAAI,EACJC,EAAI,EACR,QAAWC,KAAKH,EACZC,GAAKE,EAAE,EACPD,GAAKC,EAAE,EAEX,MAAO,CAAE,EAAGF,EAAID,EAAI,OAAQ,EAAGE,EAAIF,EAAI,MAAO,CAClD,CACA,SAASI,GAAWJ,EAAK,CACrB,IAAMK,EAAM,IAAI,aAAaL,EAAI,MAAM,EACvC,QAASM,EAAI,EAAGA,EAAIN,EAAI,OAAQM,IAC5BD,EAAIC,CAAC,EACDD,EAAIC,EAAI,CAAC,EACL,KAAK,MAAMN,EAAIM,CAAC,EAAE,EAAIN,EAAIM,EAAI,CAAC,EAAE,EAAGN,EAAIM,CAAC,EAAE,EAAIN,EAAIM,EAAI,CAAC,EAAE,CAAC,EAEvE,OAAOD,CACX,CACA,SAASE,GAAeP,EAAK,CACzB,IAAIQ,EACJ,OAAQA,EAAKJ,GAAWJ,CAAG,EAAEA,EAAI,OAAS,CAAC,KAAO,MAAQQ,IAAO,OAASA,EAAK,CACnF,CAGA,IAAMC,GAAY,IAAI,IACtB,SAASC,GAASC,EAAO,CACrB,IAAMC,EAAQH,GAAU,IAAIE,CAAK,EACjC,GAAIC,IAAU,OACV,OAAOA,EAEX,IAAMC,EAAQC,GAAcH,CAAK,EACjC,OAAIF,GAAU,KAAO,KACjBA,GAAU,MAAM,EAEpBA,GAAU,IAAIE,EAAOE,CAAK,EACnBA,CACX,CACA,SAASC,GAAcH,EAAO,CAC1B,IAAII,EAAK,KACLC,EAAK,EAAI,KAAK,GAAK,KACvB,QAASV,EAAI,EAAGA,EAAI,GAAIA,IAAK,CACzB,IAAMW,GAAOF,EAAKC,GAAM,EACpBC,GAAO,EAAI,KAAK,IAAIA,EAAM,CAAC,GAAKN,EAChCI,EAAKE,EAGLD,EAAKC,CAEb,CACA,OAAQF,EAAKC,GAAM,CACvB,CAEA,SAASE,GAAWC,EAAGC,EAAG,CACtB,GAAID,EAAI,KACJ,OAAO,KAAK,GAAKC,EAErB,IAAMC,GAAMF,EAAIA,EAAK,EAAIC,EAAIA,IAAM,EAAIA,GACjCE,EAAQ,EAAI,KAAK,KAAK,KAAK,IAAI,EAAGH,GAAK,EAAIE,EAAE,CAAC,EACpD,OAAOA,GAAKD,EAAIC,EAAI,EAAI,KAAK,GAAKC,EAAQA,EAC9C,CAGA,SAASC,GAAQJ,EAAGK,EAAQC,EAAGC,EAAM,CACjC,IAAMrB,EAAMmB,EAAS,EAAIC,EACnBH,EAAQH,EAAI,KAAO,EAAI,KAAK,GAAKT,GAASL,EAAMc,CAAC,EACjDE,EAAIhB,EAAMiB,EACVK,EAAM,KAAK,IAAIL,EAAQ,CAAC,EACxBM,EAAKT,EAAI,EACTU,EAAKH,EAAOD,EAAIJ,EAAIM,EAC1B,MAAO,CACH,GAAIG,GAAK,CACL,GAAIA,GAAKL,EACL,MAAO,CAAE,EAAG,EAAG,EAAGC,EAAOI,CAAE,EAE/B,GAAIA,GAAKN,EAASC,EACd,MAAO,CAAE,EAAGN,EAAG,EAAGO,EAAOF,EAASM,CAAE,EAExC,IAAMtC,GAAKsC,EAAIL,GAAKJ,EAAIC,EAAQ,EAChC,MAAO,CAAE,EAAGM,EAAKP,EAAI,KAAK,IAAI7B,CAAC,EAAG,EAAGqC,EAAKR,EAAI,KAAK,IAAI7B,CAAC,CAAE,CAC9D,EACA,KAAMkC,EAAOD,EAAIJ,GAAK,EAAIM,GAC1B,OAAAH,CACJ,CACJ,CAKA,SAASO,GAAOC,EAAMb,EAAGN,EAAO,CAC5B,GAAI,CAACA,EACD,OAAOmB,EAEX,IAAML,EAAM,KAAK,IAAId,CAAK,EACpBoB,EAAM,KAAK,IAAIpB,CAAK,EAC1B,MAAO,CACH,GAAGmB,EACH,GAAIF,GAAK,CACL,GAAM,CAAE,EAAAI,EAAG,EAAAC,CAAE,EAAIH,EAAK,GAAGF,CAAC,EACpBM,EAAKF,EAAIf,EAAI,EACnB,MAAO,CAAE,EAAGA,EAAI,EAAIiB,EAAKT,EAAMQ,EAAIF,EAAK,EAAGG,EAAKH,EAAME,EAAIR,CAAI,CAClE,CACJ,CACJ,CAGA,SAASU,GAAYL,EAAM,CACvB,QAAS1B,EAAI,EAAGA,GAAK,GAAIA,IACrB,GAAI0B,EAAK,GAAIA,EAAK,OAAS1B,EAAK,EAAE,EAAE,EAAI,MACpC,MAAO,GAGf,MAAO,EACX,CACA,SAASgC,GAASC,EAAIC,EAAIJ,EAAIK,EAAIjB,EAAQ,CACtC,MAAO,CACH,GAAIM,IAAM,CAAE,EAAGS,EAAKH,EAAKN,EAAG,EAAGU,EAAKC,EAAKX,CAAE,GAC3C,KAAMU,EAAK,KAAK,IAAI,EAAGC,CAAE,EAAIjB,EAC7B,OAAAA,CACJ,CACJ,CAEA,IAAMkB,GAAN,KAAY,CACR,YAAY1C,EAAK2C,EAASC,EAAW,GAAO,CACxC,IAAIpC,EACJ,KAAK,IAAMR,EACX,KAAK,QAAU2C,EACf,KAAK,SAAWC,EAChB,KAAK,IAAMxC,GAAWJ,CAAG,EACzB,KAAK,OAASQ,EAAK,KAAK,IAAIR,EAAI,OAAS,CAAC,KAAO,MAAQQ,IAAO,OAASA,EAAK,CAClF,CACA,QAAQ,EAAG,CACP,GAAM,CAAE,IAAAH,CAAI,EAAI,KACZU,EAAK,EACLC,EAAKX,EAAI,OAAS,EACtB,KAAOU,EAAKC,GAAI,CACZ,IAAMC,EAAOF,EAAKC,GAAO,EACrBX,EAAIY,CAAG,EAAI,EACXF,EAAKE,EAAM,EAGXD,EAAKC,CAEb,CACA,OAAOF,CACX,CACA,SAAST,EAAGwB,EAAG,CACX,IAAMe,EAAO,KAAK,IAAIvC,CAAC,EAAI,KAAK,IAAIA,EAAI,CAAC,EACzC,OAAOuC,EAAO,GAAKf,EAAI,KAAK,IAAIxB,EAAI,CAAC,GAAKuC,EAAO,CACrD,CACA,QAAQ,EAAG,CACP,GAAM,CAAE,IAAA7C,CAAI,EAAI,KACV8C,EAAO9C,EAAI,OAAS,EAC1B,GAAI8C,IAAS,EACT,MAAO,CAAE,GAAG9C,EAAI,CAAC,CAAE,EAEvB,GAAI,GAAK,EAAG,CACR,IAAM+C,EAAIxD,GAAKS,EAAI,CAAC,EAAGA,EAAI,CAAC,CAAC,EAC7B,MAAO,CAAE,EAAGA,EAAI,CAAC,EAAE,EAAI+C,EAAE,EAAI,EAAG,EAAG/C,EAAI,CAAC,EAAE,EAAI+C,EAAE,EAAI,CAAE,CAC1D,CACA,GAAI,GAAK,KAAK,MAAO,CACjB,IAAMA,EAAIxD,GAAKS,EAAI8C,EAAO,CAAC,EAAG9C,EAAI8C,CAAI,CAAC,EACjC,EAAI,EAAI,KAAK,MACnB,MAAO,CAAE,EAAG9C,EAAI8C,CAAI,EAAE,EAAIC,EAAE,EAAI,EAAG,EAAG/C,EAAI8C,CAAI,EAAE,EAAIC,EAAE,EAAI,CAAE,CAChE,CACA,IAAMzC,EAAI,KAAK,QAAQ,CAAC,EACxB,OAAOT,GAAKG,EAAIM,EAAI,CAAC,EAAGN,EAAIM,CAAC,EAAG,KAAK,SAASA,EAAG,CAAC,CAAC,CACvD,CACA,SAAS,EAAG,CACR,GAAM,CAAE,QAAAqC,CAAQ,EAAI,KACpB,GAAIA,EAAQ,SAAW,GAAK,GAAK,EAC7B,OAAOA,EAAQ,CAAC,EAEpB,GAAI,GAAK,KAAK,MACV,OAAOA,EAAQA,EAAQ,OAAS,CAAC,EAErC,IAAMrC,EAAI,KAAK,QAAQ,CAAC,EAClB,CAAE,EAAAL,EAAG,EAAAC,CAAE,EAAIL,GAAK8C,EAAQrC,EAAI,CAAC,EAAGqC,EAAQrC,CAAC,EAAG,KAAK,SAASA,EAAG,CAAC,CAAC,EAC/DV,EAAI,KAAK,MAAMK,EAAGC,CAAC,GAAK,EAC9B,MAAO,CAAE,EAAGD,EAAIL,EAAG,EAAGM,EAAIN,CAAE,CAChC,CACJ,EAGA,SAASoD,GAAehD,EAAKiD,EAAQ,CACjC,IAAMC,EAAWnD,GAAWC,CAAG,EAC/B,OAAOA,EAAI,IAAI,CAACG,EAAGG,IAAM,CACrB,IAAMwB,EAAIvC,GAAKS,EAAI,KAAK,IAAI,EAAGM,EAAI,CAAC,CAAC,EAAGN,EAAI,KAAK,IAAIA,EAAI,OAAS,EAAGM,EAAI,CAAC,CAAC,CAAC,EACtE6C,EAAI,CAAE,EAAG,CAACrB,EAAE,EAAG,EAAGA,EAAE,CAAE,EACtBsB,EAAKjD,EAAE,EAAI+C,EAAS,EACpBG,EAAKlD,EAAE,EAAI+C,EAAS,EACpBI,EAAK,KAAK,MAAMF,EAAIC,CAAE,EACtBE,EAAMJ,EAAE,EAAIC,EAAKD,EAAE,EAAIE,EACvBG,EAAMP,EAAO3C,CAAC,EACdmD,EAAOH,EAAK,MAAQ,KAAK,IAAIC,CAAG,EAAI,GAAMD,EAC1C,KAAK,KAAKC,CAAG,EACb,KAAK,KAAKJ,EAAE,EAAIK,EAAI,EAAIL,EAAE,EAAIK,EAAI,CAAC,GAAK,EAC9C,MAAO,CAAE,EAAGL,EAAE,EAAIM,EAAM,EAAGN,EAAE,EAAIM,CAAK,CAC1C,CAAC,CACL,CAGA,SAASC,GAAQC,EAAOC,EAAIH,EAAMzB,EAAM6B,EAAM,CAC1C,IAAMC,EAAK,KAAK,IAAID,EAAM,KAAK,IAAI7B,EAAK,OAAS,GAAI,EAAG,CAAC,EACnDhC,EAAM,CAAC,EACP+D,EAAO,CAAC,EACd,QAASjC,EAAI,EAAGA,GAAKE,EAAK,OAAS,KAAMF,GAAKgC,EAAI,CAC9C,GAAM,CAAE,EAAA5B,EAAG,EAAAC,CAAE,EAAIH,EAAK,GAAG,KAAK,IAAIF,EAAGE,EAAK,MAAM,CAAC,EAC3CgC,EAAIL,EAAM,QAAQC,EAAK1B,CAAC,EACxB+B,EAAKN,EAAM,SAASC,EAAK1B,CAAC,EAC1BgC,EAAKD,EAAG,EAAIR,EACZU,EAAKF,EAAG,EAAIR,EAClBzD,EAAI,KAAK,CAAE,EAAGgE,EAAE,EAAIE,EAAK/B,EAAG,EAAG6B,EAAE,EAAIG,EAAKhC,CAAE,CAAC,EAC7C4B,EAAK,KAAK,CAAE,EAAGG,EAAI,EAAGC,CAAG,CAAC,CAC9B,CACA,MAAO,CAAE,IAAAnE,EAAK,KAAA+D,CAAK,CACvB,CACA,IAAMK,GAAY,EACZC,GAAc,KAAQ,EAG5B,SAASC,GAAOX,EAAOC,EAAIH,EAAMc,EAAM/C,EAAQqC,EAAM,CACjD,IAAIW,EAAahD,EACbiD,EAASf,GAAQC,EAAOC,EAAIH,EAAMc,EAAKC,CAAU,EAAGX,CAAI,EAC5D,GAAIF,EAAM,SACN,OAAOc,EAEX,QAASnE,EAAI,EAAGA,EAAI,EAAGA,IAAK,CACxB,IAAMoE,EAAMnE,GAAekE,EAAO,GAAG,EACrC,GAAI,EAAEC,EAAM,IAAM,KAAK,IAAIA,EAAMlD,EAAS,CAAC,EAAI,KAC3C,MAEJgD,GAAchD,EAASkD,EACvBD,EAASf,GAAQC,EAAOC,EAAIH,EAAMc,EAAKC,CAAU,EAAGX,CAAI,CAC5D,CACA,OAAOY,CACX,CACA,SAASE,GAAOC,EAAMzB,EAAG,CACrB,OAAO,MAAM,KAAK,CAAE,OAAQA,CAAE,EAAG,CAAC0B,EAAGvE,IAAMsE,EAAQtE,EAAI,GAAY,CAAC,CACxE,CACA,SAASwE,GAAOC,EAAS,CACrB,GAAIA,EAAQ,SAAW,EACnB,MAAO,KAEX,IAAIhE,EAAK,IACLC,EAAK,KACT,QAAWxB,KAAKuF,EACZhE,EAAK,KAAK,IAAIA,EAAIvB,EAAE,MAAM,CAAC,EAC3BwB,EAAK,KAAK,IAAIA,EAAIxB,EAAE,MAAM,CAAC,EAE/B,OAAOwB,EAAKD,CAChB,CACA,SAASiE,GAAQC,EAAIC,EAAI,CACrB,OAAQD,EAAK,SAAaC,EAAK,QACnC,CACA,IAAMC,GAAN,KAAa,CACT,YAAYhE,EAAG,CACX,KAAK,EAAIA,EACT,KAAK,KAAO,IAAI,IAChB,GAAM,CAAE,IAAAiE,EAAK,MAAAC,EAAO,MAAAC,EAAO,IAAAC,EAAK,MAAAC,EAAO,MAAAC,EAAO,SAAAC,CAAS,EAAIvE,EACrDwE,EAAIP,EAAI,OACd,KAAK,OAAS,MAAM,KAAK,CAAE,OAAQO,CAAE,EAAG,IAAG,EAAY,EACvD,KAAK,OAAS,MAAM,KAAK,CAAE,OAAQA,CAAE,EAAG,IAAG,EAAY,EACvD,KAAK,OAAS,MAAM,KAAK,CAAE,OAAQA,CAAE,EAAG,IAAG,EAAY,EACvD,KAAK,MAAQxE,EAAE,MAAM,IAAI,CAACyE,EAAOC,IAAMD,EAAM,IAAIE,GAAOA,EAAI,OAAO,CAAC,CAAC3D,CAAC,IAAMA,IAAM0D,CAAC,CAAC,CAAC,EACrF,KAAK,MAAQT,EAAI,IAAIW,GAAMA,EAAG,WAAWC,EAAQ,CAAC,EAClD,IAAIC,EAAM,IACNC,EAAM,KACV,QAASL,EAAI,EAAGA,EAAIF,EAAGE,IAAK,CACxB,IAAMM,EAAQd,EAAMQ,CAAC,EACjB,CAACH,EAASS,CAAK,GAAK,OAAO,MAAMX,EAAMW,CAAK,CAAC,IAGjDF,EAAM,KAAK,IAAIA,EAAKT,EAAMW,CAAK,CAAC,EAChCD,EAAM,KAAK,IAAIA,EAAKV,EAAMW,CAAK,EAAIZ,EAAIM,CAAC,GAAKP,EAAMO,CAAC,EAAI,EAAE,EAC9D,CACA,KAAK,SAAW,IAAInD,GAAM,CACtB,CAAE,EAAGuD,EAAK,EAAG,CAAE,EACf,CAAE,EAAGC,EAAK,EAAG,CAAE,CACnB,EAAG,CACC,CAAE,EAAG,EAAG,EAAG,CAAE,EACb,CAAE,EAAG,EAAG,EAAG,CAAE,CACjB,EAAG,EAAI,EACP,KAAK,iBAAmB,CAAE,GAAID,EAAMC,GAAO,EAAG,EAAG,CAAE,EACnD,QAASL,EAAI,EAAGA,EAAIF,EAAGE,IAAK,CACxB,IAAMM,EAAQd,EAAMQ,CAAC,EACrB,GAAI,CAACH,EAASS,CAAK,GAAK,OAAO,MAAMX,EAAMW,CAAK,CAAC,EAC7C,SAEJ,IAAMnG,EAAM,CAAC,EACPoG,EAAK,CAAC,EACZ,QAAS9F,EAAI,EAAGA,EAAIgF,EAAMO,CAAC,EAAGvF,IAAK,CAC/B,IAAML,EAAIuF,EAAMW,CAAK,EAAI7F,EAAIiF,EAAIM,CAAC,EAClC7F,EAAI,KAAK,CAAE,EAAAC,EAAG,EAAGwF,EAAMU,CAAK,CAAE,CAAC,EAC/BC,EAAG,KAAKnG,EAAIgG,CAAG,CACnB,CACA,KAAK,OAAOJ,CAAC,EAAI7F,EACjB,KAAK,OAAO6F,CAAC,EAAIO,EACjB,KAAK,OAAOP,CAAC,EAAI,KAAK,SACtB,KAAK,OAAO7F,EAAK,KAAK,QAAQ,CAClC,CACJ,CACA,OAAO,YAAYmB,EAAG,CAClB,QAAS0E,EAAI,EAAGA,EAAI1E,EAAE,IAAI,OAAQ0E,IAAK,CACnC,IAAMM,EAAQhF,EAAE,MAAM0E,CAAC,EACvB,GAAI1E,EAAE,SAASgF,CAAK,GAAK,CAAC,OAAO,MAAMhF,EAAE,MAAMgF,CAAK,CAAC,EACjD,MAAO,EAEf,CACA,MAAO,EACX,CACA,KAAM,CACF,IAAME,EAAO,CAAC,EACd,QAASR,EAAI,EAAGA,EAAI,KAAK,OAAO,OAAQA,IAC/B,KAAK,OAAOA,CAAC,GACdQ,EAAK,KAAKR,CAAC,EAWnB,IAAMS,EAAS,KAAK,aAAaD,CAAI,EAChC,IAAIE,IAAY,CAAE,QAAAA,EAAS,QAAS,KAAK,UAAUA,CAAO,CAAE,EAAE,EAC9D,OAAOpG,GAAKA,EAAE,QAAQ,MAAM,EAC5B,IAAIA,IAAM,CACX,QAASA,EAAE,QACX,KAAM2E,GAAO3E,EAAE,OAAO,EACtB,MAAOA,EAAE,QAAQ,OAAO,CAAC,EAAG0F,IAAM,EAAI,KAAK,MAAMA,CAAC,EAAG,CAAC,EACtD,KAAM1F,EAAE,QACH,IAAIX,GAAK,GAAGA,EAAE,MAAM,CAAC,IAAIA,EAAE,MAAM,CAAC,EAAE,EACpC,KAAK,EACL,KAAK,GAAG,CACjB,EAAE,EACG,KAAK,CAACA,EAAGC,IAAMD,EAAE,KAAOC,EAAE,OAC1BD,EAAE,OAASC,EAAE,KAAOA,EAAE,MAAQD,EAAE,MAAQA,EAAE,MAAQC,EAAE,MAAM,EAC/D,QAAWU,KAAKmG,EACZ,KAAK,WAAWnG,EAAE,QAAS,KAAK,gBAAgB,CAExD,CACA,MAAMqG,EAAGC,EAAG,CACR,GAAM,CAAE,MAAApB,CAAM,EAAI,KAAK,EACvB,KAAK,OAAO,QAAQ,CAACrF,EAAK6F,IAAM,CACc7F,GAAI,QAAQ,CAACG,EAAGG,IAAM,CAC5DkG,EAAEnB,EAAMQ,CAAC,EAAIvF,CAAC,EAAIH,EAAE,EACpBsG,EAAEpB,EAAMQ,CAAC,EAAIvF,CAAC,EAAIH,EAAE,CACxB,CAAC,CACL,CAAC,CACL,CACA,MAAM0F,EAAG,CACL,OAAO,KAAK,EAAE,IAAIA,CAAC,GAAK,KAAK,EAAE,MAAMA,CAAC,EAAI,EAC9C,CACA,SAASA,EAAGvG,EAAM,CACd,OAAOA,EAAO,KAAK,EAAE,MAAMuG,CAAC,EAAI,EAAI,CACxC,CACA,OAAO7F,EAAK0G,EAAO,CACf,QAAWvG,KAAKH,EAAK,CACjB,IAAM2G,EAAM3B,GAAQ,KAAK,MAAM7E,EAAE,EAAI,IAAK,EAAG,KAAK,MAAMA,EAAE,EAAI,IAAK,CAAC,EAC9DyG,EAAO,KAAK,KAAK,IAAID,CAAG,EACxBE,EAAW,CAAE,EAAG1G,EAAE,EAAG,EAAGA,EAAE,EAAG,MAAAuG,CAAM,EACrCE,EACAA,EAAK,KAAKC,CAAQ,EAGlB,KAAK,KAAK,IAAIF,EAAK,CAACE,CAAQ,CAAC,CAErC,CACJ,CAKA,WAAW7G,EAAK8G,EAAQC,EAAWC,EAAO,CACtC,IAAIxG,EACJ,IAAI2C,EAAI,EACR,QAAWhD,KAAKH,EAAK,CACjB,GAAI+G,EAAU,KAAKvH,GAAK,KAAK,MAAMW,EAAE,EAAIX,EAAE,EAAGW,EAAE,EAAIX,EAAE,CAAC,EAAI,EAAQ,EAC/D,SAEJ,IAAMyH,EAAK,KAAK,MAAM9G,EAAE,EAAI,IAAK,EAC3B+G,EAAK,KAAK,MAAM/G,EAAE,EAAI,IAAK,EACjC,QAAS8E,EAAKgC,EAAK,EAAGhC,GAAMgC,EAAK,EAAGhC,IAChC,QAASC,EAAKgC,EAAK,EAAGhC,GAAMgC,EAAK,EAAGhC,IAChC,QAAWlB,KAAMxD,EAAK,KAAK,KAAK,IAAIwE,GAAQC,EAAIC,CAAE,CAAC,KAAO,MAAQ1E,IAAO,OAASA,EAAK,CAAC,EACpF,GAAIwD,EAAE,QAAU8C,GACZ,KAAK,MAAM3G,EAAE,EAAI6D,EAAE,EAAG7D,EAAE,EAAI6D,EAAE,CAAC,EAAI,OACnCb,IACIA,GAAK6D,GACL,OAAO7D,CAM/B,CACA,OAAOA,CACX,CAKA,OAAOgE,EAAYL,EAAQC,EAAW,CAClC,IAAIK,EACAC,EAAQ,IACZ,QAAWC,KAAaH,EAAY,CAChC,IAAMhF,EAAI,KAAK,WAAWmF,EAAUjD,EAAW,EAAE,IAAKyC,EAAQC,EAAWM,CAAK,EAC9E,GAAIlF,IAAM,EACN,OAAOmF,EAAUlD,EAAS,EAE1BjC,EAAIkF,IACJA,EAAQlF,EACRiF,EAAOE,EAEf,CACA,OAAOF,EAAKhD,EAAS,CACzB,CACA,UAAUmC,EAAS,CACf,IAAMgB,EAAM,IAAI,IAAIhB,CAAO,EACrBT,EAAM,CAAC,EACb,QAAW5D,KAAKqE,EACZ,QAAWiB,KAASpI,GAChB,OAAW,CAAC+C,EAAGsF,CAAK,IAAK,KAAK,MAAMvF,CAAC,EAAEsF,CAAK,EAAG,CAC3C,IAAMxH,EAAM,KAAK,OAAOmC,CAAC,EACzB,GAAIoF,EAAI,IAAIpF,CAAC,GAAK,CAACnC,EACf,SAEJ,IAAMM,EAAI,KAAK,SAAS6B,EAAGsF,CAAK,EAChC3B,EAAI,KAAK,CACL,EAAA5D,EACA,MAAAsF,EACA,EAAArF,EACA,MAAAsF,EACA,MAAOzH,EAAIM,CAAC,EACZ,MAAO,KAAK,OAAO6B,CAAC,EACpB,EAAG,KAAK,OAAOA,CAAC,EAAE7B,CAAC,CACvB,CAAC,CACL,CAGR,OAAOwF,CACX,CACA,aAAaS,EAAS,CAClB,IAAMgB,EAAM,IAAI,IAAIhB,CAAO,EACrBmB,EAAO,IAAI,IACXC,EAAQ,CAAC,EACf,QAAWvG,KAAKmF,EAAS,CACrB,GAAImB,EAAK,IAAItG,CAAC,EACV,SAEJ,IAAMwG,EAAQ,CAACxG,CAAC,EAChBsG,EAAK,IAAItG,CAAC,EACV,QAAWc,KAAK0F,EACZ,QAAWtI,KAAQF,GACf,OAAW,CAAC+C,CAAC,IAAK,KAAK,MAAMD,CAAC,EAAE5C,CAAI,EAC5BiI,EAAI,IAAIpF,CAAC,GAAK,CAACuF,EAAK,IAAIvF,CAAC,IACzBuF,EAAK,IAAIvF,CAAC,EACVyF,EAAM,KAAKzF,CAAC,GAK5BwF,EAAM,KAAKC,CAAK,CACpB,CACA,OAAOD,CACX,CAGA,UAAUpB,EAAS3B,EAAMiD,EAAUC,EAAIC,EAAY,CAC/C,IAAMR,EAAM,IAAI,IAAIhB,CAAO,EACrBI,EAAM,CAACd,EAAGzE,IAAMyE,EAAI,EAAIzE,EACxB4G,EAAU,CAACnC,EAAGzE,IAAMyE,IAAMiC,GAAMzI,GAAM+B,CAAC,IAAM2G,EAC7CE,EAAO,IAAI,IAAI,CAAC,CAACtB,EAAI/B,EAAMiD,CAAQ,EAAG,EAAE,CAAC,CAAC,EAC1CD,EAAQ,CAAC,CAAChD,EAAMiD,CAAQ,CAAC,EAC3BK,EAAM,CAACtD,EAAMiD,CAAQ,EACzB,OAAW,CAAChC,EAAGzE,CAAC,IAAKwG,EAAO,CAExB,GADAM,EAAM,CAACrC,EAAGzE,CAAC,EACP0G,IAAO,QAAaE,EAAQnC,EAAGzE,CAAC,EAChC,MAEJ,OAAW,CAACe,EAAGL,CAAC,IAAK,KAAK,MAAM+D,CAAC,EAAExG,GAAM+B,CAAC,CAAC,EACnC,CAACmG,EAAI,IAAIpF,CAAC,GAAK8F,EAAK,IAAItB,EAAIxE,EAAGL,CAAC,CAAC,IAGrCmG,EAAK,IAAItB,EAAIxE,EAAGL,CAAC,EAAG6E,EAAId,EAAGzE,CAAC,CAAC,EAC7BwG,EAAM,KAAK,CAACzF,EAAGL,CAAC,CAAC,EAEzB,CACA,GAAIgG,IAAO,QAAa,CAACE,EAAQE,EAAI,CAAC,EAAGA,EAAI,CAAC,CAAC,EAC3C,OAEJ,IAAMC,EAAO,CAAC,EACd,QAASC,EAAMzB,EAAIuB,EAAI,CAAC,EAAGA,EAAI,CAAC,CAAC,EAAGE,IAAQ,GAAIA,EAAMH,EAAK,IAAIG,CAAG,EAC9DD,EAAK,KAAK,CAAE,EAAGC,GAAO,EAAG,MAAQA,EAAM,CAAG,CAAC,EAE/C,OAAOD,EAAK,QAAQ,CACxB,CACA,UAAU5B,EAAS3B,EAAMkD,EAAI,CACzB,IAAMP,EAAM,IAAI,IAAIhB,CAAO,EACrB0B,EAAO,IAAI,IAAI,CAAC,CAACrD,EAAM,EAAE,CAAC,CAAC,EAC3BtF,EAAO,IAAI,IAAI,CAAC,CAACsF,EAAM,CAAC,CAAC,CAAC,EAC1BgD,EAAQ,CAAChD,CAAI,EACnB,QAAWiB,KAAK+B,EAAO,CACnB,GAAI/B,IAAMiC,EACN,MAEJ,QAAW1G,KAAKhC,GACZ,OAAW,CAAC+C,EAAGL,CAAC,IAAK,KAAK,MAAM+D,CAAC,EAAEzE,CAAC,EAC5B,CAACmG,EAAI,IAAIpF,CAAC,GAAK8F,EAAK,IAAI9F,CAAC,IAG7B8F,EAAK,IAAI9F,EAAG0D,CAAC,EACbvG,EAAK,IAAI6C,EAAGL,CAAC,EACb8F,EAAM,KAAKzF,CAAC,EAGxB,CACA,IAAMgG,EAAO,CAAC,EACd,QAASC,EAAMN,EAAIM,IAAQ,GAAIA,EAAMH,EAAK,IAAIG,CAAG,EAC7CD,EAAK,KAAK,CAAE,EAAGC,EAAK,MAAO9I,EAAK,IAAI8I,CAAG,CAAE,CAAC,EAE9C,OAAOD,EAAK,QAAQ,CACxB,CACA,YAAYE,EAAO,CACf,GAAM,CAAE,KAAAC,CAAK,EAAI,KAAK,EACtB,OAAOD,EAAM,OAAO,CAACjH,EAAG,CAAE,EAAAyE,CAAE,IAAMzE,EAAI,KAAK,MAAMyE,CAAC,EAAIyC,EAAMA,CAAI,CACpE,CAGA,SAASD,EAAO3B,EAAO6B,EAAIC,EAAS,CAChC,GAAM,CAAE,MAAAlD,EAAO,IAAAC,EAAK,KAAA+C,CAAK,EAAI,KAAK,EAC9BxG,EAAIyG,EACFE,EAAM,CAAC,EACb,OAAW,CAAE,EAAA5C,EAAG,MAAA6C,CAAM,IAAKL,EAAO,CAC9B,IAAMxE,EAAO2E,GAAmDjD,EAAIM,CAAC,EAC/D7F,EAAM,CAAC,EACPoG,EAAK,CAAC,EACZ,QAAS9F,EAAI,EAAGA,EAAIgF,EAAMO,CAAC,EAAGvF,IAC1BN,EAAI,KAAK0G,EAAM,QAAQ5E,EAAIxB,EAAIuD,CAAI,CAAC,EACpCuC,EAAG,KAAKtE,EAAIxB,EAAIuD,CAAI,EAEpB6E,IAAU,IACV1I,EAAI,QAAQ,EACZoG,EAAG,QAAQ,GAEf,KAAK,OAAOP,CAAC,EAAI7F,EACjB,KAAK,OAAO6F,CAAC,EAAIO,EACjB,KAAK,OAAOP,CAAC,EAAIa,EACjB+B,EAAI,KAAK,GAAGzI,CAAG,EACf8B,GAAK+B,GAAQyB,EAAMO,CAAC,EAAI,GAAKyC,CACjC,CACA,OAAOG,CACX,CACA,cAAc9E,EAAOC,EAAIH,EAAMtC,EAAGwH,EAAG,CACjC,IAAMC,GAAQD,EAAIxH,GAAK,EAAI,KACrB0H,EAAQF,EAAI,EAAIxH,EAAIhC,GAAiB,CAAC,CAAC,EACvCgI,EAAa,CAAC,EACpB,QAAWzF,KAAQiD,GAAO,EAAG,CAAC,EAC1B,QAAWmE,KAAQD,EACf,QAASvI,EAAI,EAAGA,GAAK,GAAIA,IAAK,CAC1B,IAAMmB,EAAKmH,EAAOtI,EAAK,GACjB0B,EAAOD,GAAOR,GAAQJ,EAAGwH,EAAGlH,EAAGC,CAAI,EAAGP,EAAG2H,CAAI,EAC9CxI,EAAI,IAAM0B,EAAK,KAAO,IAAcK,GAAYL,CAAI,GAGzDmF,EAAW,KAAKtD,GAAQS,GAAOX,EAAOC,EAAIH,EAAMjC,GAAUO,GAAOR,GAAQJ,EAAGK,EAAQ,KAAK,IAAIC,GAAID,EAASL,GAAK,EAAI,IAAI,EAAGO,CAAI,EAAGP,EAAG2H,CAAI,EAAGH,EAAG9E,CAAI,CAAC,CACvJ,CAGR,OAAOsD,CACX,CACA,WAAWZ,EAASwC,EAAQ,CACxB,IAAIvI,EACJ,GAAM,CAAE,MAAA8E,EAAO,KAAAgD,CAAK,EAAI,KAAK,EACvBvD,EAAU,KAAK,UAAUwB,CAAO,EACtC,GAAIxB,EAAQ,SAAW,EACnB,OAEJ,IAAMiE,EAAQzC,EAAQ,MAAMV,GAAK,KAAK,MAAMA,CAAC,CAAC,EACxCoD,EAASlE,EAAQ,MAAMvF,GAAKA,EAAE,QAAUuF,EAAQ,CAAC,EAAE,KAAK,EACxDA,EAAQ,CAAC,EAAE,MACX,OACFpB,EACAC,EACAsF,EACAzF,EACJ,GAAIwF,EACAlE,EAAQ,KAAK,CAACvF,EAAGC,IAAMD,EAAE,EAAIC,EAAE,CAAC,EAChCkE,EAAQsF,EACRrF,EAAKmB,EAAQ,CAAC,EAAE,EAChBmE,EAAKnE,EAAQA,EAAQ,OAAS,CAAC,EAAE,EACjCtB,EAAOE,IAAU,KAAK,UAAYqF,EAAQ,GAAK,MAE9C,CAODjE,EAAQ,KAAK,CAACvF,EAAGC,IAAMD,EAAE,MAAM,EAAIC,EAAE,MAAM,GAAKD,EAAE,MAAM,EAAIC,EAAE,MAAM,CAAC,EACrE,IAAMD,EAAIuF,EAAQ,CAAC,EAAE,MACftF,EAAIsF,EAAQA,EAAQ,OAAS,CAAC,EAAE,MAChCoE,EAAQ,KAAK,MAAM1J,EAAE,EAAID,EAAE,EAAGC,EAAE,EAAID,EAAE,CAAC,EACvC0C,EAAIiH,EAAQ,KAAO5J,GAAKC,EAAGC,CAAC,EAAI,CAAE,EAAG,EAAG,EAAG,CAAE,EAC7C0D,EAAI,CAAE,EAAG,CAACjB,EAAE,EAAG,EAAGA,EAAE,CAAE,EACtBjB,EAAMpB,GAAKL,EAAGC,EAAG,EAAG,EAC1BgE,EAAOsB,EAAQ,KAAK9E,GAAKA,EAAE,QAAU,KAAK,QAAQ,GAC3C+I,EAAQ,GAAK,IAAM,KAAK,KAAK7F,EAAE,CAAC,GAAK,IACrClC,EAAI,EAAI8H,EAAO,GAAK5F,EAAE,GAAKlC,EAAI,EAAI8H,EAAO,GAAK5F,EAAE,GAAK,EACnD,EACA,GACVQ,EAAQ,IAAIjB,GAAM,CAAClD,EAAGC,CAAC,EAAG,CAAC0D,EAAGA,CAAC,EAAG,EAAI,EACtCS,EAAK,EACLsF,EAAKC,CACT,CACA,IAAMC,EAAIrE,EAAQ,CAAC,EACbsE,EAAItE,EAAQA,EAAQ,OAAS,CAAC,EAC9B5D,EAAI+H,EAAKtF,EACT0F,EAASvE,EAAQ,SAAW,GAAMqE,EAAE,IAAMC,EAAE,GAAKD,EAAE,QAAUC,EAAE,OAASlI,EAAI,KAC5E4F,EAAY,CAACqC,EAAE,MAAOC,EAAE,KAAK,EAC7BE,EAAQpC,GAAe,KAAK,OAAOA,EAAY8B,EAAQlC,CAAS,EAClEsB,EACA5D,EACA0B,EAAQmC,EACRE,EACJ,GAAIc,EAAQ,CACRjB,EAAQ,KAAK,UAAU9B,EAAS6C,EAAE,EAAGA,EAAE,KAAK,EAC5C,IAAMT,EAAI,KAAK,YAAYN,CAAK,EAC1BmB,EAAOJ,EAAE,MACT,KAAK,IAAI,EAAG9D,EAAM8D,EAAE,CAAC,EAAI,CAAC,EAC1B,KAAK,IAAI,EAAG9D,EAAM8D,EAAE,CAAC,EAAI,CAAC,EAE1BhH,GADOgH,EAAE,GAAK,KAAK,OAAOA,EAAE,CAAC,EAAEI,CAAI,EAAI,EAAI,IAC/B,KAAK,IAAIxK,EAAS,EAC9ByD,EAAK,KAAK,IAAIzD,EAAS,EAC7ByF,EAAS8E,EAAK5E,GAAO,EAAG,EAAE,EAAE,IAAIjD,GAASmC,GAASS,GAAOX,EAAOC,EAAIH,EAAMjC,GAAUc,GAAS,EAAGZ,EAAMU,EAAIK,EAAIjB,CAAM,EAAGmH,EAAG9E,CAAI,CAAC,CAAC,CACpI,KACK,CACDwE,GACK7H,EAAK,KAAK,UAAU+F,EAAS6C,EAAE,EAAGA,EAAE,MAAOC,EAAE,EAAGA,EAAE,KAAK,KAAO,MAAQ7I,IAAO,OAASA,EAAK,KAAK,UAAU+F,EAAS6C,EAAE,EAAGC,EAAE,CAAC,EAChI,IAAMV,EAAI,KAAK,YAAYN,CAAK,EAChC,GAAIW,EAAO,CACP,IAAMS,EAAK,KAAK,IAAI,GAAW,KAAK,IAAIxK,GAAMkC,EAAGjC,EAAO,CAAC,EACzDuF,EAAS8E,EAAK5E,GAAO8E,EAAI,EAAE,EAAE,IAAI1G,GAAMc,GAASH,GAAQC,EAAOC,EAAIH,EAAMlC,GAAQJ,EAAGD,GAAWC,EAAG4B,CAAC,EAAG,EAAG,CAAC,EAAGc,CAAI,CAAC,CAAC,EACnH,IAAM6F,EAAQnJ,GAAekE,EAAO,GAAG,EACvC+D,EAAU,KAAK,IAAI,MAAOkB,EAAQ,EAAIpB,IAAShD,EAAM+C,EAAM,CAAC,EAAE,CAAC,EAAI,EAAE,CACzE,SACSM,EAAIxH,EAAI,KACbsD,EAAS8E,EAAK,KAAK,cAAc5F,EAAOC,EAAIH,EAAMtC,EAAGwH,CAAC,CAAC,MAEtD,CACD,IAAMgB,EAAMhB,EAAI,EAAIL,EACdmB,EAAK,KAAK,IAAI,GAAW,KAAK,IAAIxK,IAAOkC,EAAIwI,GAAMzK,EAAO,CAAC,EACjEuF,EAAS8E,EAAK5E,GAAO8E,EAAI,EAAE,EAAE,IAAI1G,GAAMc,GAASS,GAAOX,EAAOC,EAAIH,EAAMjC,GAAUc,GAASnB,EAAI,EAAIK,EAAS,EAAGuB,EAAG,EAAG,EAAGvB,CAAM,EAAGmI,EAAK9F,CAAI,CAAC,CAAC,EAC5IsC,EAAQ,CACZ,CACJ,CACA,IAAMO,EAAQ,IAAIhE,GAAM+B,EAAO,IAAKzB,GAAeyB,EAAO,IAAKA,EAAO,IAAI,CAAC,EACrEmF,EAAS,KAAK,SAASvB,EAAO3B,EAAOP,EAAOqC,CAAO,EACzD,KAAK,OAAOoB,EAAQlD,CAAK,EACzB,IAAMxD,EAAWnD,GAAW6J,CAAM,EAC5BC,EAAOtD,EAAQ,OAAOV,GAAK,CAAC,KAAK,OAAOA,CAAC,CAAC,EAC1CiE,EAAO,KAAK,aAAaD,CAAI,EAC9B,IAAIjK,IAAM,CAAE,QAASA,EAAG,KAAMkF,GAAO,KAAK,UAAUlF,CAAC,CAAC,CAAE,EAAE,EAC1D,KAAK,CAACJ,EAAGC,IAAMD,EAAE,KAAOC,EAAE,IAAI,EACnC,QAAWsK,KAAOD,EACd,KAAK,WAAWC,EAAI,QAAS7G,CAAQ,CAE7C,CACJ,EAEO,SAAS8G,GAAgB7I,EAAG,CAC/B,IAAMqF,EAAI,IAAI,aAAarF,EAAE,CAAC,EAAE,KAAK,GAAG,EAClCsF,EAAI,IAAI,aAAatF,EAAE,CAAC,EAAE,KAAK,GAAG,EACxC,GAAIgE,GAAO,YAAYhE,CAAC,EAAG,CACvB,IAAM8I,EAAS,IAAI9E,GAAOhE,CAAC,EAC3B8I,EAAO,IAAI,EACXA,EAAO,MAAMzD,EAAGC,CAAC,CACrB,CACA,MAAO,CAAE,EAAAD,EAAG,EAAAC,CAAE,CAClB,CChsBA,IAAMyD,GAAU,CACZ,CAAE,MAAO,EAAG,WAAY,EAAG,EAC3B,CAAE,MAAO,EAAG,WAAY,EAAG,EAC3B,CAAE,MAAO,EAAG,WAAY,EAAG,EAC3B,CAAE,MAAO,GAAI,WAAY,EAAG,EAC5B,CAAE,MAAO,GAAI,WAAY,GAAI,CACjC,EACMC,GAAkB,GAElBC,GAAiB,EACjBC,GAAgB,GAChBC,GAAgB,EAEhBC,GAAW,IAEXC,GAAM,GAENC,GAAO,GACPC,GAAcC,GAAS,CAAE,IAAIC,EAAI,QAASA,EAAKD,EAAK,UAAY,MAAQC,IAAO,OAAS,OAASA,EAAG,QAAU,CAAG,EACvH,SAASC,GAAQC,EAAQC,EAAM,CAC3B,IAAMC,EAAMD,EAAK,GAAG,EAAE,EACtB,OAASD,IAAW,KAAOA,IAAW,OACjCE,IAAQ,KAAOA,IAAQ,MACxBF,IAAWE,CACnB,CACA,SAASC,GAASC,EAAM,CACpB,IAAIC,EAAI,KAAK,KAAKD,EAAM,UAAU,IAAM,GAAK,EAC7C,MAAO,KACHC,GAAKA,GAAK,GACVA,KAAO,EACPA,GAAKA,IAAM,GACXA,GAAKA,GAAK,EACVA,KAAO,EACAA,EAAI,WAEnB,CACO,SAASC,EAAIC,EAAOC,EAAU,CACjC,OAAO,OAAOD,GAAU,UAAY,OAAO,SAASA,CAAK,EAAIA,EAAQC,CACzE,CAEO,SAASC,GAAYC,EAASC,EAAI,CACrC,OAAO,KAAK,IAAKL,EAAII,EAAQ,sBAAuB,GAAI,EAAIC,EAAM,IAASL,EAAII,EAAQ,kBAAmB,CAAC,CAAC,CAChH,CACO,SAASE,GAAOC,EAAS,CAC5B,GAAM,CAAE,MAAAC,EAAO,MAAAC,CAAM,EAAIF,EAAQ,MAC3BG,EAAIH,EAAQ,QACZI,EAAUX,EAAIU,EAAE,kBAAmB,CAAC,EACpCE,EAAOZ,EAAIU,EAAE,WAAY,CAAC,EAC1BG,EAAML,EAAM,IAAIM,GAAKA,EAAE,EAAE,EACzBC,EAAQ,IAAI,WAAWP,EAAM,MAAM,EACnCQ,EAAQ,IAAI,WAAWR,EAAM,MAAM,EACnCS,EAAM,IAAI,aAAaT,EAAM,MAAM,EACrCM,EAAI,EACRN,EAAM,QAAQ,CAACjB,EAAM2B,IAAM,CACvB,IAAMC,EAAQhB,GAAYO,EAAGnB,EAAK,MAAM,EAClC6B,EAAQ,KAAK,IAAI,EAAG,KAAK,KAAKD,EAAQR,CAAO,CAAC,EACpDI,EAAMG,CAAC,EAAIJ,EACXE,EAAME,CAAC,EAAIE,EAAQ,EACnBH,EAAIC,CAAC,EAAIC,EAAQC,EACjBN,GAAKM,EAAQ,CACjB,CAAC,EACD,IAAMC,EAAU,IAAI,WAAWP,CAAC,EAC1BQ,EAAU,IAAI,WAAWR,CAAC,EAC1BS,EAAQ,IAAI,aAAaT,CAAC,EAAE,KAAK,GAAG,EACpCU,EAAQ,IAAI,aAAaV,CAAC,EAAE,KAAK,GAAG,EACpCW,EAAW,IAAI,WAAWX,CAAC,EAC3BY,EAAW,MAAM,KAAK,CAAE,OAAQZ,CAAE,EAAG,IAAM,CAAC,CAAC,EACnDN,EAAM,QAAQ,CAACjB,EAAM2B,IAAM,CACvB,IAAMS,EAAS,OAAOpC,EAAK,GAAM,UAAY,OAAOA,EAAK,GAAM,SACzDqC,EAAYtC,GAAWC,CAAI,EAAI,EAAI,EACzC,QAASsC,EAAI,EAAGA,EAAIb,EAAME,CAAC,EAAGW,IAAK,CAC/B,IAAMC,EAAIf,EAAMG,CAAC,EAAIW,EACrBR,EAAQS,CAAC,EAAIZ,EACbI,EAAQQ,CAAC,EAAID,EACbJ,EAASK,CAAC,EAAIF,EACVD,IACAJ,EAAMO,CAAC,EAAIvC,EAAK,EAAIsC,EAAIZ,EAAIC,CAAC,EAC7BM,EAAMM,CAAC,EAAIvC,EAAK,GAEhBsC,EAAI,IACJH,EAASI,EAAI,CAAC,EAAE,KAAK,CAACA,EAAGb,EAAIC,CAAC,CAAC,CAAC,EAChCQ,EAASI,CAAC,EAAE,KAAK,CAACA,EAAI,EAAGb,EAAIC,CAAC,CAAC,CAAC,EAExC,CACJ,CAAC,EACD,IAAMa,EAAQ,IAAI,IAAIlB,EAAI,IAAI,CAACmB,EAAId,IAAM,CAACc,EAAId,CAAC,CAAC,CAAC,EAC3Ce,EAAQzB,EAAM,IAAI,IAAM,CAAC,CAAC,EAAG,CAAC,CAAC,CAAC,EACtC,QAAW0B,KAAQzB,EAAO,CACtB,IAAM0B,EAAIJ,EAAM,IAAIG,EAAK,IAAI,EACvBE,EAAIL,EAAM,IAAIG,EAAK,EAAE,EAK3B,GAJIC,IAAM,QAAaC,IAAM,QAIzBD,IAAMC,GAAKpB,EAAMmB,CAAC,GAAK,EACvB,SAEJ,IAAME,EAAW5C,GAAQyC,EAAK,WAAYA,EAAK,IAAI,EAAI,EAAI,EACrDI,EAAS7C,GAAQyC,EAAK,SAAUA,EAAK,EAAE,EAAI,EAAI,EAC/CK,EAAIxB,EAAMoB,CAAC,GAAKE,EAAWrB,EAAMmB,CAAC,EAAI,EAAI,GAC1CL,EAAIf,EAAMqB,CAAC,GAAKE,EAAStB,EAAMoB,CAAC,EAAI,EAAI,GAC9CV,EAASa,CAAC,EAAE,KAAK,CAACT,EAAGlB,CAAI,CAAC,EAC1Bc,EAASI,CAAC,EAAE,KAAK,CAACS,EAAG3B,CAAI,CAAC,EAC1BqB,EAAME,CAAC,EAAEE,CAAQ,EAAE,KAAK,CAACD,EAAGE,CAAM,CAAC,EACnCL,EAAMG,CAAC,EAAEE,CAAM,EAAE,KAAK,CAACH,EAAGE,CAAQ,CAAC,CACvC,CACA,IAAMG,EAAM,IAAI,WAAW1B,EAAI,CAAC,EAChC,QAASe,EAAI,EAAGA,EAAIf,EAAGe,IACnBW,EAAIX,EAAI,CAAC,EAAIW,EAAIX,CAAC,EAAIH,EAASG,CAAC,EAAE,OAEtC,IAAMY,EAAK,IAAI,WAAWD,EAAI1B,CAAC,CAAC,EAC1B4B,EAAK,IAAI,aAAaF,EAAI1B,CAAC,CAAC,EAClC,QAASe,EAAI,EAAGA,EAAIf,EAAGe,IACnBH,EAASG,CAAC,EAAE,QAAQ,CAAC,CAACC,EAAGa,CAAC,EAAGzB,IAAM,CAC/BuB,EAAGD,EAAIX,CAAC,EAAIX,CAAC,EAAIY,EACjBY,EAAGF,EAAIX,CAAC,EAAIX,CAAC,EAAIyB,CACrB,CAAC,EAEL,MAAO,CACH,IAAA9B,EACA,MAAAE,EACA,MAAAC,EACA,IAAAC,EACA,MAAAgB,EACA,QAAAZ,EACA,QAAAC,EACA,MAAAC,EACA,MAAAC,EACA,SAAAC,EACA,IAAAe,EACA,GAAAC,EACA,GAAAC,EACA,EAAA5B,EACA,KAAAF,CACJ,CACJ,CAEA,SAASgC,GAAWC,EAAG,CACnB,GAAM,CAAE,EAAA/B,EAAG,IAAA0B,EAAK,GAAAC,CAAG,EAAII,EACjBC,EAAO,IAAI,WAAWhC,CAAC,EAAE,KAAK,EAAE,EAChCiC,EAAU,CAAC,EACjB,QAAShD,EAAI,EAAGA,EAAIe,EAAGf,IAAK,CACxB,GAAI+C,EAAK/C,CAAC,GAAK,EACX,SAEJ,IAAMiD,EAAQ,CAACjD,CAAC,EAChB+C,EAAK/C,CAAC,EAAIgD,EAAQ,OAClB,QAAWR,KAAKS,EACZ,QAASC,EAAIT,EAAID,CAAC,EAAGU,EAAIT,EAAID,EAAI,CAAC,EAAGU,IAAK,CACtC,IAAMnB,EAAIW,EAAGQ,CAAC,EACVH,EAAKhB,CAAC,EAAI,IACVgB,EAAKhB,CAAC,EAAIiB,EAAQ,OAClBC,EAAM,KAAKlB,CAAC,EAEpB,CAEJiB,EAAQ,KAAKC,CAAK,CACtB,CACA,MAAO,CAAE,KAAAF,EAAM,QAAAC,CAAQ,CAC3B,CACO,SAASG,GAAa3C,EAAS4C,EAAO,CAAC,EAAG,CAC7C,IAAI3D,EAAI4D,EAAIC,EACZ,IAAMR,EAAIvC,GAAOC,CAAO,EAClB,CAAE,EAAAO,EAAG,IAAA0B,EAAK,GAAAC,EAAI,GAAAC,EAAI,MAAAnB,EAAO,MAAAC,EAAO,MAAAT,EAAO,MAAAC,EAAO,IAAAC,EAAK,KAAAL,CAAK,EAAIiC,EAC5DnC,EAAIH,EAAQ,QACZ+C,EAAUxE,GAAQ,KAAK,IAAI,EAAG,KAAK,IAAI,EAAGkB,GAAKR,EAAK2D,EAAK,WAAa,MAAQ3D,IAAO,OAASA,EAAKkB,EAAE,QAAS,CAAC,CAAC,CAAC,CAAC,EAClH6C,EAAMvD,GAAKoD,EAAKD,EAAK,uBAAyB,MAAQC,IAAO,OAASA,EAAK1C,EAAE,oBAAqB,EAAE,EACpG8C,EAAO3D,GAASG,GAAKqD,EAAKF,EAAK,QAAU,MAAQE,IAAO,OAASA,EAAK3C,EAAE,KAAM,CAAC,CAAC,EAChF+C,EAAI,IAAI,aAAa3C,CAAC,EACtB4C,EAAI,IAAI,aAAa5C,CAAC,EACtB6C,EAAgB,CAAC,EACvB,GAAI7C,IAAM,EACN,MAAO,CAAE,cAAA6C,CAAc,EAE3B,GAAM,CAAE,KAAAb,EAAM,QAAAC,CAAQ,EAAIH,GAAWC,CAAC,EAClCe,EAAO,IACPC,EAAQ,EACZ,QAASZ,EAAI,EAAGA,EAAIR,EAAG,OAAQQ,IAC3BW,EAAO,KAAK,IAAIA,EAAMlB,EAAGO,CAAC,CAAC,EAC3BY,GAASnB,EAAGO,CAAC,EAEjBY,GAAS,EACT,IAAIC,EAAU,GACd,QAASjC,EAAI,EAAGA,EAAIf,EAAGe,IACnB,GAAI,CAAC,OAAO,MAAMN,EAAMM,CAAC,CAAC,EAAG,CACzBiC,EAAU,GACV,KACJ,CAEJ,IAAMC,EAASD,EAAUE,GAAgBnB,CAAC,EAAI,OACxCoB,EAAO,KAAK,KAAKnD,CAAC,EAAI,GAC5B,QAASe,EAAI,EAAGA,EAAIf,EAAGe,IACfkC,GAAU,CAAC,OAAO,MAAMA,EAAO,EAAElC,CAAC,CAAC,GACnC4B,EAAE5B,CAAC,EAAIkC,EAAO,EAAElC,CAAC,EACjB6B,EAAE7B,CAAC,EAAIkC,EAAO,EAAElC,CAAC,GAEZiC,GAAW,CAAC,OAAO,MAAMvC,EAAMM,CAAC,CAAC,GACtC4B,EAAE5B,CAAC,EAAIN,EAAMM,CAAC,EAAI2B,EAAK,EAAI,GAC3BE,EAAE7B,CAAC,EAAIL,EAAMK,CAAC,EAAI2B,EAAK,EAAI,KAG3BC,EAAE5B,CAAC,EAAI2B,EAAK,EAAIS,EAChBP,EAAE7B,CAAC,EAAI2B,EAAK,EAAIS,GAKxB,IAAM9C,EAAQ4B,EAAQ,IAAImB,GAAUH,IAAW,QAAaG,EAAO,MAAMrC,GAAK,CAAC,OAAO,MAAMkC,EAAO,EAAElC,CAAC,CAAC,CAAC,CAAC,EACnGsC,EAAQ,CAAC,EACXC,EAAc,GAClB,QAASvC,EAAI,EAAGA,EAAIf,EAAGe,IACdV,EAAM2B,EAAKjB,CAAC,CAAC,IACdsC,EAAM,KAAKtC,CAAC,EACZuC,IAAgBA,EAAc,CAAC,OAAO,MAAM7C,EAAMM,CAAC,CAAC,IAG5D,IAAMwC,EAAO,KAAK,IAAIR,EAAQ,EAAGD,EAAO,EAAE,EACpCU,EAASD,EAAOA,EAChBE,EAASnF,GAAMwE,EAAOA,EACtB,CAAE,MAAAY,GAAO,WAAAC,EAAW,EAAInB,EACxBoB,GAAS,KAAK,IAAIJ,EAASC,CAAM,EAAI,KAAK,IAAI,EAAGE,GAAa,CAAC,EAC/DE,GAAS,KAAK,IAAIf,CAAI,EACtBgB,GAAS,KAAK,IAAIP,CAAI,EACtBQ,GAAO,CAAChD,EAAGiD,EAAGC,EAAGC,IAAQ,CAC3B,IAAIC,EAAKD,GAAOD,EAAIA,GAChBE,EAAK,IACLA,EAAK,GAET,IAAMC,EAAKzB,EAAE5B,CAAC,EAAI4B,EAAEqB,CAAC,EACfK,EAAKzB,EAAE7B,CAAC,EAAI6B,EAAEoB,CAAC,EACfM,EAAM,KAAK,KAAKF,EAAKA,EAAKC,EAAKA,CAAE,GAAK,KACtCE,EAAKJ,GAAMG,EAAML,IAAO,EAAIK,GAC5BE,EAAKD,EAAIH,EACTK,EAAKF,EAAIF,EACf1B,EAAE5B,CAAC,EAAI4B,EAAE5B,CAAC,EAAIyD,EACd5B,EAAE7B,CAAC,EAAI6B,EAAE7B,CAAC,EAAI0D,EACd9B,EAAEqB,CAAC,EAAIrB,EAAEqB,CAAC,EAAIQ,EACd5B,EAAEoB,CAAC,EAAIpB,EAAEoB,CAAC,EAAIS,CAClB,EAGIC,GAAS,EACPC,GAAO,CAAC5D,EAAG6D,IAAW,CACxB,IAAIC,EAAQ9C,EAAE,QAAQhB,CAAC,EACnB+D,EAAM/C,EAAE,QAAQhB,CAAC,EACjBgE,EAAMrC,EAAK,EAAI,GAAM,GAAK,EAC1BsC,EAAYJ,EAChB,QAASK,EAAO,EAAGA,EAAO5G,GAAU4G,IAAQ,CACxC,IAAM7B,EAASlD,EAAM2E,CAAK,EACpBK,EAAO/E,EAAI0E,CAAK,EAChBM,GAASJ,EAAM,EAAI3B,EAAS,EAAI0B,EAAMA,GAAOI,EACnD,GAAIF,GAAaG,EAAO,CACpB,IAAM7E,EAAQ,KAAK,MAAM0E,EAAYE,CAAI,EACzC,OAAAR,GAASE,EAASI,EAAY1E,EAAQ4E,EAC/BjF,EAAM4E,CAAK,EAAIC,EAAMC,EAAMzE,CACtC,CACA0E,GAAaG,EACb,IAAMC,EAAMrD,EAAE,MAAM8C,CAAK,EAAEE,EAAM,EAAI,EAAI,CAAC,EAC1C,GAAIK,EAAI,SAAW,EACf,OAAAV,GAASE,EAASI,EACX/E,EAAM4E,CAAK,GAAKE,EAAM,EAAI3B,EAAS,EAAI,GAElD,GAAM,CAACiC,EAAMC,CAAS,EAAIF,EAAI,KAAK,MAAM1C,EAAK,EAAI0C,EAAI,MAAM,CAAC,EAK7D,GAJAJ,GAAalF,EACb+E,EAAQQ,EACRN,EAAMO,IAAc,EAAI,EAAI,GAC5BR,EAAMQ,IAAc,EAAI,EAAIpF,EAAMmF,CAAI,EAAI,EACtCL,GAAa,EACb,OAAAN,GAASE,EAASI,EACX/E,EAAM4E,CAAK,EAAIC,CAE9B,CACA,MAAO,EACX,EACMS,GAAgB,CAACxE,EAAGmD,IAAQ,CAC9B,QAAS/B,EAAIT,EAAIX,CAAC,EAAGoB,EAAIT,EAAIX,EAAI,CAAC,EAAGoB,IAAK,CACtC,IAAM6B,EAAIrC,EAAGQ,CAAC,EACV6B,EAAIjD,GACJgD,GAAKhD,EAAGiD,EAAGpC,EAAGO,CAAC,EAAG+B,CAAG,CAE7B,CACJ,EACMsB,EAAQ,WAAW,KAAKnC,CAAK,EAC7BoC,GAAOnC,EAAc,KAAK,MAAM/E,GAAOoF,EAAU,EAAI,EAC3D,QAAS+B,EAAIrC,EAAM,OAASoC,GAAO9B,GAAY+B,EAAI/B,GAAY+B,IAAK,CAChE,IAAMxB,EAAMV,EAAS,KAAK,IAAI,CAACI,GAAS8B,CAAC,EACzC,QAAStF,EAAIoF,EAAM,OAAS,EAAGpF,EAAI,EAAGA,IAAK,CACvC,IAAMmE,EAAI,KAAK,MAAM7B,EAAK,GAAKtC,EAAI,EAAE,EAC/BuF,EAAMH,EAAMpF,CAAC,EACnBoF,EAAMpF,CAAC,EAAIoF,EAAMjB,CAAC,EAClBiB,EAAMjB,CAAC,EAAIoB,CACf,CACA,QAAW5E,KAAKyE,EAAO,CACnBD,GAAcxE,EAAGmD,CAAG,EACpB,QAASrC,EAAI,EAAGA,EAAI6B,GAAO7B,IAAK,CAC5B,IAAM+C,EAAS,KAAK,IAAIf,GAASnB,EAAK,GAAKoB,GAASD,GAAO,EACrDG,EAAIW,GAAK5D,EAAG6D,CAAM,EACpBZ,GAAK,GAAKA,IAAMjD,GAAK2D,GAAS,GAC9BX,GAAKhD,EAAGiD,EAAGU,GAAQR,CAAG,CAE9B,CACJ,CACJ,CAGA,IAAM0B,EAAS1H,GAAiB4B,EAC1B+F,GAAM,CAACC,EAAGC,IAAO,KAAK,MAAMD,EAAIF,CAAM,EAAI,SAAa,KAAK,MAAMG,EAAIH,CAAM,EAAI,SACtF,QAASnE,EAAI,EAAGA,GAAK4B,EAAM,OAASpF,GAAkB,GAAIwD,IAAK,CAC3D,IAAMuE,EAAO,IAAI,IACjB,QAAWjF,KAAKsC,EAAO,CACnB,IAAM,EAAIwC,GAAIlD,EAAE5B,CAAC,EAAG6B,EAAE7B,CAAC,CAAC,EAClBkF,EAAOD,EAAK,IAAI,CAAC,EACnBC,EACAA,EAAK,KAAKlF,CAAC,EAGXiF,EAAK,IAAI,EAAG,CAACjF,CAAC,CAAC,CAEvB,CACA,QAAWA,KAAKsC,EAAO,CACnB,IAAM6C,EAAK,KAAK,MAAMvD,EAAE5B,CAAC,EAAI6E,CAAM,EAC7BO,EAAK,KAAK,MAAMvD,EAAE7B,CAAC,EAAI6E,CAAM,EACnC,QAASQ,EAAKF,EAAK,EAAGE,GAAMF,EAAK,EAAGE,IAChC,QAASC,EAAKF,EAAK,EAAGE,GAAMF,EAAK,EAAGE,IAAM,CACtC,IAAMJ,EAAOD,EAAK,IAAKI,EAAK,SAAaC,EAAK,QAAS,EACvD,GAAKJ,EAGL,QAAWjC,KAAKiC,EAAM,CAClB,GAAIjC,GAAKjD,EACL,SAEJ,IAAIuF,EAAS,GACb,QAASnE,EAAIT,EAAIX,CAAC,EAAGoB,EAAIT,EAAIX,EAAI,CAAC,EAAGoB,IACjC,GAAIR,EAAGQ,CAAC,IAAM6B,EAAG,CACbsC,EAAS,GACT,KACJ,CAEJ,GAAIA,EACA,SAEJ,IAAMlC,EAAKzB,EAAE5B,CAAC,EAAI4B,EAAEqB,CAAC,EACfK,EAAKzB,EAAE7B,CAAC,EAAI6B,EAAEoB,CAAC,EACfM,EAAM,KAAK,KAAKF,EAAKA,EAAKC,EAAKA,CAAE,EACvC,GAAIC,GAAOsB,EACP,SAEJ,IAAIpB,EACAC,GACJ,GAAIH,EAAM,KAAM,CACZ,IAAMC,EAAKpG,IAAiByH,EAAStB,IAAS,EAAIA,GAClDE,EAAKD,EAAIH,EACTK,GAAKF,EAAIF,CACb,MAEIG,EAAKrG,GAAgByH,GAAUlD,EAAK,EAAI,IACxC+B,GAAKtG,GAAgByH,GAAUlD,EAAK,EAAI,IAE5CC,EAAE5B,CAAC,EAAI4B,EAAE5B,CAAC,EAAIyD,EACd5B,EAAE7B,CAAC,EAAI6B,EAAE7B,CAAC,EAAI0D,GACd9B,EAAEqB,CAAC,EAAIrB,EAAEqB,CAAC,EAAIQ,EACd5B,EAAEoB,CAAC,EAAIpB,EAAEoB,CAAC,EAAIS,EAClB,CACJ,CAER,CACA,QAAW1D,KAAKsC,EACZkC,GAAcxE,EAAG,GAAQ,CAEjC,CAGA,QAASX,EAAI,EAAGA,EAAIF,EAAM,OAAQE,IAAK,CACnC,IAAMiB,EAAIpB,EAAMG,CAAC,EACX,EAAIF,EAAME,CAAC,EACjB,GAAI,IAAI,GAGR,SAASnB,EAAI,EAAGA,EAAIb,GAAea,IAAK,CACpC,IAAMsH,EAAK5D,EAAE,MAAMtB,EAAGA,EAAI,CAAC,EACrBmF,EAAK5D,EAAE,MAAMvB,EAAGA,EAAI,CAAC,EAC3B,QAASN,EAAI,EAAGA,EAAI,EAAI,EAAGA,IACvB4B,EAAEtB,EAAIN,CAAC,EAAI,GAAMwF,EAAGxF,CAAC,EAAI,KAAQwF,EAAGxF,EAAI,CAAC,EAAIwF,EAAGxF,EAAI,CAAC,GACrD6B,EAAEvB,EAAIN,CAAC,EAAI,GAAMyF,EAAGzF,CAAC,EAAI,KAAQyF,EAAGzF,EAAI,CAAC,EAAIyF,EAAGzF,EAAI,CAAC,EAE7D,CACA0F,GAAQ9D,EAAGC,EAAGvB,EAAG,EAAGlB,EAAIC,CAAC,CAAC,EAC9B,CACAsG,GAAe1E,EAAMC,EAASU,EAAGC,EAAGI,EAASP,CAAG,EAChD,QAASrC,EAAI,EAAGA,EAAI2B,EAAE,IAAI,OAAQ3B,IAAK,CACnC,IAAMgD,EAAS,CAAC,EAChB,QAASrC,EAAI,EAAGA,EAAIb,EAAME,CAAC,EAAGW,IAC1BqC,EAAO,KAAK,CAAE,EAAGT,EAAE1C,EAAMG,CAAC,EAAIW,CAAC,EAAG,EAAG6B,EAAE3C,EAAMG,CAAC,EAAIW,CAAC,CAAE,CAAC,EAE1D8B,EAAcd,EAAE,IAAI3B,CAAC,CAAC,EAAIgD,CAC9B,CACA,MAAO,CAAE,cAAAP,CAAc,CAC3B,CAMA,SAAS4D,GAAQ9D,EAAGC,EAAGvB,EAAGsF,EAAGxG,EAAK,CAC9ByG,GAAMjE,EAAGC,EAAGvB,EAAGsF,EAAGxG,GAAOwG,EAAI,EAAE,EAC/B,IAAME,EAAU,IAAI,aAAaF,CAAC,EAClC,QAAS5F,EAAI,EAAGA,EAAI4F,EAAG5F,IACnB8F,EAAQ9F,CAAC,EACL8F,EAAQ9F,EAAI,CAAC,EACT,KAAK,MAAM4B,EAAEtB,EAAIN,CAAC,EAAI4B,EAAEtB,EAAIN,EAAI,CAAC,EAAG6B,EAAEvB,EAAIN,CAAC,EAAI6B,EAAEvB,EAAIN,EAAI,CAAC,CAAC,EAEvE,GAAI,CAAC8F,EAAQF,EAAI,CAAC,EACd,OAEJ,IAAM5D,EAAQ8D,EAAQF,EAAI,CAAC,EACrBJ,EAAK5D,EAAE,MAAMtB,EAAGA,EAAIsF,CAAC,EACrBH,EAAK5D,EAAE,MAAMvB,EAAGA,EAAIsF,CAAC,EACvBG,EAAM,EACV,QAAS/F,EAAI,EAAGA,EAAI,EAAI4F,EAAG5F,IAAK,CAC5B,IAAM9B,EAAK8D,EAAQhC,GAAM4F,EAAI,GAC7B,KAAOG,EAAMH,EAAI,GAAKE,EAAQC,CAAG,EAAI7H,GACjC6H,IAEJ,IAAMC,EAAOF,EAAQC,CAAG,EAAID,EAAQC,EAAM,CAAC,EACrCpB,EAAIqB,EAAO,GAAK9H,EAAI4H,EAAQC,EAAM,CAAC,GAAKC,EAAO,EACrDpE,EAAEtB,EAAIN,CAAC,EAAIwF,EAAGO,EAAM,CAAC,GAAKP,EAAGO,CAAG,EAAIP,EAAGO,EAAM,CAAC,GAAKpB,EACnD9C,EAAEvB,EAAIN,CAAC,EAAIyF,EAAGM,EAAM,CAAC,GAAKN,EAAGM,CAAG,EAAIN,EAAGM,EAAM,CAAC,GAAKpB,CACvD,CACJ,CAKA,SAASkB,GAAMjE,EAAGC,EAAGvB,EAAGsF,EAAGK,EAAQ,CAC/B,IAAM1F,EAAID,EAAIsF,EAAI,EACZT,EAAKvD,EAAEtB,CAAC,EACR8E,EAAKvD,EAAEvB,CAAC,EACR4F,EAAQ,KAAK,MAAMtE,EAAErB,CAAC,EAAI4E,EAAItD,EAAEtB,CAAC,EAAI6E,CAAE,EACvCe,EAAKD,EAAQ,MAAQtE,EAAErB,CAAC,EAAI4E,GAAMe,EAAQ,EAC1CE,EAAKF,EAAQ,MAAQrE,EAAEtB,CAAC,EAAI6E,GAAMc,EAAQ,EAC1CG,EAAQ,IAAI,aAAaT,CAAC,EAC1BjF,EAAM,IAAI,aAAaiF,CAAC,EAC1BU,EAAO,GACX,QAAStG,EAAI,EAAGA,EAAI4F,EAAG5F,IAAK,CACxB,IAAMqD,EAAKzB,EAAEtB,EAAIN,CAAC,EAAImF,EAChB7B,EAAKzB,EAAEvB,EAAIN,CAAC,EAAIoF,EACtBiB,EAAMrG,CAAC,EAAIqD,EAAK8C,EAAK7C,EAAK8C,EAC1BzF,EAAIX,CAAC,EAAIsD,EAAK6C,EAAK9C,EAAK+C,EACxBE,IAASA,EAAO,KAAK,IAAI3F,EAAIX,CAAC,CAAC,EAAI,KACvC,CACA,IAAMuG,EAAYC,GAAM,CACpB,IAAIxE,EAAQ,EACZ,QAAShC,EAAI,EAAGA,EAAI4F,EAAG5F,IACnBgC,GAAS,KAAK,MAAMqE,EAAMrG,CAAC,EAAIqG,EAAMrG,EAAI,CAAC,EAAGwG,GAAK7F,EAAIX,CAAC,EAAIW,EAAIX,EAAI,CAAC,EAAE,EAE1E,OAAOgC,CACX,EACA,GAAIsE,GAAQC,EAAS,CAAC,GAAKN,EACvB,OAEJ,IAAIQ,EAAK,EACLC,EAAK,EACT,KAAOH,EAASG,CAAE,EAAIT,GAAUS,EAAK,KACjCD,EAAKC,EACLA,GAAM,EAEV,QAASC,EAAK,EAAGA,EAAK,GAAIA,IAAM,CAC5B,IAAMC,GAAOH,EAAKC,GAAM,EACpBH,EAASK,CAAG,EAAIX,EAChBQ,EAAKG,EAGLF,EAAKE,CAEb,CACA,IAAMJ,GAAKC,EAAKC,GAAM,EACtB,QAAS1G,EAAI,EAAGA,EAAI,EAAI4F,EAAG5F,IACvB4B,EAAEtB,EAAIN,CAAC,EAAImF,EAAKkB,EAAMrG,CAAC,EAAImG,EAAKK,EAAI7F,EAAIX,CAAC,EAAIoG,EAC7CvE,EAAEvB,EAAIN,CAAC,EAAIoF,EAAKiB,EAAMrG,CAAC,EAAIoG,EAAKI,EAAI7F,EAAIX,CAAC,EAAImG,CAErD,CAIA,SAASR,GAAe1E,EAAMC,EAASU,EAAGC,EAAGI,EAASP,EAAK,CACvD,GAAI,CAACO,EACD,QAAWI,KAAUnB,EACjB2F,GAAsBjF,EAAGC,EAAGQ,CAAM,EAG1C,GAAInB,EAAQ,OAAS,EACjB,OAEJ,IAAM4F,EAAO,IAAI,aAAa5F,EAAQ,MAAM,EAAE,KAAK,GAAQ,EACrD6F,EAAO,IAAI,aAAa7F,EAAQ,MAAM,EAAE,KAAK,GAAQ,EACrD8F,EAAO,IAAI,aAAa9F,EAAQ,MAAM,EAAE,KAAK,IAAS,EAC5D,QAASlB,EAAI,EAAGA,EAAI4B,EAAE,OAAQ5B,IAAK,CAC/B,IAAMX,EAAI4B,EAAKjB,CAAC,EAChB8G,EAAKzH,CAAC,EAAI,KAAK,IAAIyH,EAAKzH,CAAC,EAAGuC,EAAE5B,CAAC,CAAC,EAChC+G,EAAK1H,CAAC,EAAI,KAAK,IAAI0H,EAAK1H,CAAC,EAAGwC,EAAE7B,CAAC,CAAC,EAChCgH,EAAK3H,CAAC,EAAI,KAAK,IAAI2H,EAAK3H,CAAC,EAAGwC,EAAE7B,CAAC,CAAC,CACpC,CACA,IAAMiH,EAAQ,IAAI,aAAa/F,EAAQ,MAAM,EACzC8D,EAAI,EACR,QAAS3F,EAAI,EAAGA,EAAI6B,EAAQ,OAAQ7B,IAChC4H,EAAM5H,CAAC,EAAI2F,EAAI+B,EAAK1H,CAAC,EACrB2F,GAAKgC,EAAK3H,CAAC,EAAI0H,EAAK1H,CAAC,EAAIqC,EAE7B,QAAS1B,EAAI,EAAGA,EAAI4B,EAAE,OAAQ5B,IAAK,CAC/B,IAAMX,EAAI4B,EAAKjB,CAAC,EAChB4B,EAAE5B,CAAC,EAAI4B,EAAE5B,CAAC,EAAI8G,EAAKzH,CAAC,EACpBwC,EAAE7B,CAAC,EAAI6B,EAAE7B,CAAC,EAAIiH,EAAM5H,CAAC,CACzB,CACJ,CACA,SAASwH,GAAsBjF,EAAGC,EAAGQ,EAAQ,CACzC,GAAIA,EAAO,OAAS,EAChB,OAEJ,IAAI8C,EAAK,EACLC,EAAK,EACT,QAAWpF,KAAKqC,EACZ8C,GAAMvD,EAAE5B,CAAC,EACToF,GAAMvD,EAAE7B,CAAC,EAEbmF,GAAM9C,EAAO,OACb+C,GAAM/C,EAAO,OACb,IAAI6E,EAAM,EACNC,EAAM,EACNC,EAAM,EACV,QAAWpH,KAAKqC,EAAQ,CACpB,IAAMgB,EAAKzB,EAAE5B,CAAC,EAAImF,EACZ7B,EAAKzB,EAAE7B,CAAC,EAAIoF,EAClB8B,GAAO7D,EAAKA,EACZ8D,GAAO7D,EAAKA,EACZ8D,GAAO/D,EAAKC,CAChB,CACA,IAAM+D,EAAQ,IAAO,KAAK,MAAM,EAAID,EAAKF,EAAMC,CAAG,EAC5CG,EAAM,KAAK,IAAID,CAAK,EACpBE,EAAM,KAAK,IAAIF,CAAK,EAC1B,QAAWrH,KAAKqC,EAAQ,CACpB,IAAMgB,EAAKzB,EAAE5B,CAAC,EAAImF,EACZ7B,EAAKzB,EAAE7B,CAAC,EAAIoF,EAClBxD,EAAE5B,CAAC,EAAImF,EAAKmC,EAAMjE,EAAKkE,EAAMjE,EAC7BzB,EAAE7B,CAAC,EAAIoF,EAAKmC,EAAMlE,EAAKiE,EAAMhE,CACjC,CACJ,CChjBA,IAAIkE,GAAiB,CACnB,CACE,MAAO,OACP,MAAO,iBACP,YAAa,6FACf,EACA,CACE,MAAO,SACP,MAAO,SACP,YAAa,yNACf,CACF,EACIC,GAAuBD,GAAe,IAAKE,GAAMA,EAAE,KAAK,EAI5D,IAAIC,GAAe,MAAOC,GAAY,CACpC,IAAMC,EAAQ,YAAY,IAAI,EAE9B,MAAO,CAAE,OADMD,EAAQ,QAAQ,SAAW,SAAWE,GAAaF,CAAO,EAAI,MAAMG,GAAWH,CAAO,EACpF,SAAU,YAAY,IAAI,EAAIC,CAAM,CACvD,ECtBA,IAAIG,GAAmB,GACnBC,GAAyB,IACzBC,GAA8B,EAClC,SAASC,GAAgBC,EAAMC,EAAQ,CACrC,OAAO,KAAK,IACVD,EAAK,sBAAwBC,EAAS,IACtCD,EAAK,iBACP,CACF,CACA,SAASE,GAAiBC,EAAOC,EAAgBN,GAA6B,CAE5E,IAAMO,EADcF,EAAM,MAAM,OAAO,CAACG,EAAKC,IAAMD,EAAMC,EAAE,OAAQ,CAAC,EACpC,IAC1BC,EAAS,KAAK,IAClBL,EAAM,MAAM,OAASP,GACrBC,EACF,EACA,MAAO,CACL,sBAAuBQ,EAAY,EAAIG,EAASH,EAAY,IAC5D,kBAAmB,KAAK,IAAIP,GAA6BM,CAAa,EACtE,WAAY,EACZ,kBAAmB,EACrB,CACF,CACA,IAAIK,GAAsB,CAAE,MAAO,EAAG,OAAQ,CAAE,EAChD,SAASC,GAAeC,EAAK,CAC3B,OAAOA,EAAI,QAAU,GAAKA,EAAI,SAAW,CAC3C,CACA,SAASC,GAAeT,EAAOQ,EAAK,CAClC,IAAME,EAAQV,EAAM,MAAM,OACpBW,EAAcX,EAAM,MAAM,OAAO,CAACG,EAAKC,IAAMD,EAAMC,EAAE,OAAQ,CAAC,EAC9DQ,EAASF,EAAQ,EAAIC,EAAcD,EAAQ,EAC3CG,EAAYH,EAAQ,EAAI,KAAK,IAAIA,EAAQjB,GAAkBC,EAAsB,EAAIgB,EAAQjB,GACnG,OAAQqB,GAAO,CACb,GAAIF,GAAU,EACZ,OAAOC,EAET,IAAME,GAAYD,EAAKF,IAAWJ,EAAI,MACtC,OAAO,KAAK,IACVK,IAAcE,EAAW,GAAKP,EAAI,OAAS,GAC3Cb,EACF,CACF,CACF,CACA,IAAIqB,GAA0B,IAC1BC,GAAsB,CACxB,IAAKX,GACL,cAAe,CACjB,EACA,SAASY,GAAclB,EAAOmB,EAASF,GAAqB,CAC1D,GAAM,CAAE,IAAAT,EAAK,cAAAP,CAAc,EAAIkB,EACzBtB,EAAOE,GAAiBC,EAAOC,CAAa,EAClD,GAAIM,GAAeC,CAAG,EACpB,MAAO,CAAE,MAAOR,EAAM,MAAO,KAAAH,CAAK,EAEpC,IAAMuB,EAAQX,GAAeT,EAAOQ,CAAG,EACvC,MAAO,CACL,MAAOR,EAAM,MAAM,IAAKqB,IAAU,CAChC,GAAGA,EACH,OAAQ,KAAK,MAAMD,EAAMC,EAAK,MAAM,EAAIL,EAAuB,CACjE,EAAE,EACF,KAAM,CACJ,GAAGnB,EACH,sBAAuB,IAAMmB,GAI7B,kBAAmBrB,EACrB,CACF,CACF,CACA,SAAS2B,GAActB,EAAOmB,EAASF,GAAqB,CAC1D,GAAIV,GAAeY,EAAO,GAAG,EAAG,CAC9B,IAAMtB,EAAOE,GAAiBC,EAAOmB,EAAO,aAAa,EACzD,OAAQL,GAAOlB,GAAgBC,EAAMiB,CAAE,CACzC,CACA,OAAOL,GAAeT,EAAOmB,EAAO,GAAG,CACzC,CCvEA,IAAII,GAAiB,CACnB,CACE,MAAO,OACP,MAAO,eACP,YAAa,6FACb,IAAKC,GACL,cAAe,CACjB,EACA,CACE,MAAO,OACP,MAAO,eACP,YAAa,sFACb,IAAKA,GACL,cAAe,GACjB,EACA,CACE,MAAO,OACP,MAAO,eACP,YAAa,gEACb,IAAKA,GACL,cAAe,EACjB,EACA,CACE,MAAO,WACP,MAAO,mBACP,YAAa,gHACb,IAAK,CAAE,MAAO,GAAK,OAAQ,EAAI,EAC/B,cAAe,CACjB,CACF,EACIC,GAAuBF,GAAe,IAAKG,GAAMA,EAAE,KAAK,EAC5D,SAASC,GAAUC,EAAQ,CACzB,IAAMC,EAAQN,GAAe,KAAMG,GAAMA,EAAE,QAAUE,CAAM,EAC3D,MAAO,CACL,IAAKC,GAAO,KAAOL,GACnB,eAAgBK,GAAO,eAAiB,GAAKC,EAC/C,CACF",
   "names": ["cached", "loadFmmm", "mod", "e", "fmmmLayout", "request", "loadFmmm", "ROUTE_ID", "TIP_ANGLE", "BOW", "BOW_CAP", "TEARDROP_TILTS", "SIDES", "other", "side", "unit", "a", "b", "dx", "dy", "m", "lerp", "f", "centroidOf", "pts", "x", "y", "p", "arcLengths", "arc", "i", "polylineLength", "_a", "arcAngles", "arcAngle", "ratio", "known", "angle", "solveArcAngle", "lo", "hi", "mid", "archLength", "c", "s", "R", "theta", "arcFlat", "length", "h", "drop", "cos", "cu", "cv", "t", "tilted", "flat", "sin", "u", "v", "du", "behindFrame", "lineFlat", "u0", "v0", "dv", "Curve", "normals", "straight", "span", "last", "d", "outwardNormals", "outRef", "centroid", "n", "rx", "ry", "rm", "dot", "ref", "sign", "mapFlat", "frame", "tA", "step", "ds", "refs", "q", "nr", "ox", "oy", "FINE_STEP", "COARSE_STEP", "fitted", "make", "flatLength", "mapped", "got", "depths", "from", "_", "spanOf", "anchors", "cellKey", "gx", "gy", "Placer", "ids", "first", "count", "per", "seedX", "seedY", "backbone", "N", "sides", "k", "out", "id", "ROUTE_ID", "min", "max", "start", "ts", "free", "pieces", "members", "X", "Y", "curve", "key", "list", "occupant", "exempt", "anchorPts", "limit", "cx", "cy", "candidates", "best", "bestV", "candidate", "set", "uSide", "vSide", "seen", "comps", "queue", "fromSide", "to", "toExitSide", "reached", "prev", "far", "path", "cur", "spine", "link", "t0", "spacing", "all", "enter", "L", "hMax", "tilts", "tilt", "parent", "route", "shared", "tB", "chord", "A", "B", "single", "pick", "next", "d0", "total", "bar", "placed", "rest", "subs", "sub", "stressPlacement", "placer", "QUALITY", "UNTANGLE_PASSES", "UNTANGLE_LINKS", "UNTANGLE_PUSH", "SMOOTH_PASSES", "MAX_HOPS", "EPS", "WARM", "isBackbone", "node", "_a", "flipped", "strand", "name", "own", "xorshift", "seed", "s", "num", "value", "fallback", "drawnLength", "options", "bp", "chains", "request", "nodes", "edges", "o", "segment", "link", "ids", "n", "first", "count", "per", "k", "drawn", "steps", "chainOf", "indexOf", "seedX", "seedY", "backbone", "adjacent", "seeded", "reference", "i", "v", "index", "id", "links", "edge", "a", "b", "fromSide", "toSide", "u", "off", "nb", "wt", "w", "components", "c", "comp", "members", "queue", "e", "stressLayout", "opts", "_b", "_c", "quality", "gap", "rand", "X", "Y", "nodePositions", "dmin", "total", "anySeed", "placed", "stressPlacement", "side", "points", "loose", "looseSeeded", "dmax", "etaMax", "etaMin", "walks", "iterations", "lambda", "logMin", "logMax", "move", "j", "d", "eta", "mu", "dx", "dy", "mag", "r", "rx", "ry", "walked", "walk", "length", "chain", "idx", "dir", "remaining", "hops", "step", "toEnd", "out", "next", "enterSide", "adjacentTerms", "order", "warm", "t", "tmp", "radius", "key", "x", "y", "grid", "list", "cx", "cy", "gx", "gy", "joined", "xs", "ys", "respace", "packComponents", "m", "bulge", "lengths", "seg", "span", "target", "chord", "ux", "uy", "along", "flat", "lengthAt", "f", "lo", "hi", "it", "mid", "rotateToPrincipalAxis", "minX", "minY", "maxY", "shift", "sxx", "syy", "sxy", "angle", "cos", "sin", "LAYOUT_ENGINES", "LAYOUT_ENGINE_VALUES", "e", "layoutEngine", "request", "start", "stressLayout", "fmmmLayout", "MEAN_NODE_LENGTH", "MIN_TOTAL_GRAPH_LENGTH", "BANDAGE_MINIMUM_NODE_LENGTH", "drawnNodeLength", "opts", "length", "bandageAutoScale", "graph", "minNodeLength", "megabases", "sum", "n", "target", "PROPORTIONAL_LENGTH", "isProportional", "law", "drawnLengthFor", "count", "totalLength", "meanBp", "meanDrawn", "bp", "relative", "LAYOUT_LENGTH_PRECISION", "PROPORTIONAL_SPREAD", "layoutScaling", "spread", "drawn", "node", "drawnLengthOf", "BUBBLE_SPREADS", "PROPORTIONAL_LENGTH", "BUBBLE_SPREAD_VALUES", "s", "spreadFor", "spread", "entry", "MEAN_NODE_LENGTH"]